premiere-libtorrent/include/libtorrent/peer_info.hpp

/*

Copyright (c) 2003-2012, Arvid Norberg
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the distribution.
    * Neither the name of the author nor the names of its
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

*/

#ifndef TORRENT_PEER_INFO_HPP_INCLUDED
#define TORRENT_PEER_INFO_HPP_INCLUDED

#include "libtorrent/socket.hpp"
#include "libtorrent/deadline_timer.hpp"
#include "libtorrent/peer_id.hpp"
#include "libtorrent/size_type.hpp"
#include "libtorrent/config.hpp"
#include "libtorrent/bitfield.hpp"

namespace libtorrent
{
	struct TORRENT_EXPORT peer_info
	{
		enum peer_flags_t
		{
			// **we** are interested in pieces from this peer.
			interesting = 0x1,

			// **we** have choked this peer.
			choked = 0x2,

			// the peer is interested in **us**
			remote_interested = 0x4,

			// the peer has choked **us**.
			remote_choked = 0x8,

			// means that this peer supports the
			// `extension protocol`__.          
			// 
			// __ extension_protocol.html
			supports_extensions = 0x10,

			// The connection was initiated by us, the peer has a   
			// listen port open, and that port is the same as in the
			// address of this peer. If this flag is not set, this  
			// peer connection was opened by this peer connecting to
			// us.                                                  
			local_connection = 0x20,

			// The connection is opened, and waiting for the        
			// handshake. Until the handshake is done, the peer     
			// cannot be identified.                                
			handshake = 0x40,

			// The connection is in a half-open state (i.e. it is   
			// being connected).                                    
			connecting = 0x80,

			// The connection is currently queued for a connection  
			// attempt. This may happen if there is a limit set on  
			// the number of half-open TCP connections.             
			queued = 0x100,

			// The peer has participated in a piece that failed the 
			// hash check, and is now "on parole", which means we're
			// only requesting whole pieces from this peer until    
			// it either fails that piece or proves that it doesn't 
			// send bad data.                                       
			on_parole = 0x200,

			// This peer is a seed (it has all the pieces).         
			seed = 0x400,

			// This peer is subject to an optimistic unchoke. It has
			// been unchoked for a while to see if it might unchoke 
			// us in return an earn an upload/unchoke slot. If it   
			// doesn't within some period of time, it will be choked
			// and another peer will be optimistically unchoked.    
			optimistic_unchoke = 0x800,

			// This peer has recently failed to send a block within 
			// the request timeout from when the request was sent.  
			// We're currently picking one block at a time from this
			// peer.                                                
			snubbed = 0x1000,

			// This peer has either explicitly (with an extension)  
			// or implicitly (by becoming a seed) told us that it   
			// will not downloading anything more, regardless of    
			// which pieces we have.                                
			upload_only = 0x2000,

			// This means the last time this peer picket a piece,   
			// it could not pick as many as it wanted because there 
			// were not enough free ones. i.e. all pieces this peer 
			// has were already requested from other peers.         
			endgame_mode = 0x4000,

			// This flag is set if the peer was in holepunch mode   
			// when the connection succeeded. This typically only   
			// happens if both peers are behind a NAT and the peers 
			// connect via the NAT holepunch mechanism.             
			holepunched = 0x8000,

			i2p_socket = 0x10000,
			utp_socket = 0x20000,
			rc4_encrypted = 0x100000,
			plaintext_encrypted = 0x200000
		};

		// tells you in which state the peer is in. It is set to
		// any combination of the peer_flags_t enum.
		unsigned int flags;

		enum peer_source_flags
		{
			// The peer was received from the tracker.
			tracker = 0x1,

			// The peer was received from the kademlia DHT.
			dht = 0x2,

			// The peer was received from the peer exchange
			// extension.
			pex = 0x4,

			// The peer was received from the local service
			// discovery (The peer is on the local network).
			lsd = 0x8,

			// The peer was added from the fast resume data.
			resume_data = 0x10,
			
			// we received an incoming connection from this peer
			incoming = 0x20
		};

		// a combination of flags describing from which sources this peer
		// was received.
		int source;

		// bits for the read_state and write_state
		enum bw_state
		{
			// The peer is not waiting for any external events to   
			// send or receive data.
			bw_idle = 0,

			// The peer is waiting for the rate limiter.
			bw_limit = 1,

			// The peer has quota and is currently waiting for a
			// network read or write operation to complete. This is
			// the state all peers are in if there are no bandwidth
			// limits.
			bw_network = 2,

			// The peer is waiting for the disk I/O thread to catch
			// up writing buffers to disk before downloading more.
			bw_disk = 4
		};
#ifndef TORRENT_NO_DEPRECATE
		enum bw_state_deprecated { bw_torrent = bw_limit, bw_global = bw_limit };
#endif

		// bitmasks indicating what state this peer
		// is in with regards to sending and receiving data. The states are declared in the
		// bw_state enum.
		char read_state;
		char write_state;
		
		// the IP-address to this peer. The type is an asio endpoint. For
		// more info, see the asio_ documentation.
		//
		// .. _asio: http://asio.sourceforge.net/asio-0.3.8/doc/asio/reference.html
		tcp::endpoint ip;

		// the current upload and download speed
		// we have to and from this peer (including any protocol messages).
		// updated about once per second
		int up_speed;
		int down_speed;

		// The transfer rates
		// of payload data only 
		// updated about once per second
		int payload_up_speed;
		int payload_down_speed;

		// the total number of bytes downloaded
		// from and uploaded to this peer. These numbers do not include the protocol chatter, but only
		// the payload data.
		size_type total_download;
		size_type total_upload;

		// the peer's id as used in the bit torrent protocol. This id can be used to
		// extract 'fingerprints' from the peer. Sometimes it can tell you which client the peer
		// is using. See identify_client()_
		peer_id pid;

		// a bitfield, with one bit per piece in the torrent.
		// Each bit tells you if the peer has that piece (if it's set to 1)
		// or if the peer miss that piece (set to 0).
		bitfield pieces;

		// the number of bytes per second we are allowed to send to or receive from this
		// peer. It may be -1 if there's no local limit on the peer. The global
		// limit and the torrent limit may also be enforced.
		int upload_limit;
		int download_limit;

		// the time since we last sent a request
		// to this peer and since any transfer occurred with this peer
		time_duration last_request;
		time_duration last_active;

		// the time until all blocks in the request
		// queue will be d
		time_duration download_queue_time;
		int queue_bytes;

		// the number of seconds until the current front piece request
		// will time out. This timeout can be adjusted through ``session_settings::request_timeout``.
		// -1 means that there is not outstanding request.
		int request_timeout;

		// the number of bytes allocated
		// and used for the peer's send buffer, respectively.
		int send_buffer_size;
		int used_send_buffer;

		// the number of bytes
		// allocated and used as receive buffer, respectively.
		int receive_buffer_size;
		int used_receive_buffer;

		// the number of pieces this peer has participated in
		// sending us that turned out to fail the hash check.
		int num_hashfails;

		// the two letter `ISO 3166 country code`__ for the country the peer
		// is connected from. If the country hasn't been resolved yet, both chars are set
		// to 0. If the resolution failed for some reason, the field is set to "--". If the
		// resolution service returns an invalid country code, it is set to "!!".
		// The ``countries.nerd.dk`` service is used to look up countries. This field will
		// remain set to 0 unless the torrent is set to resolve countries, see `resolve_countries()`_.
		// 
		// __ http://www.iso.org/iso/en/prods-services/iso3166ma/02iso-3166-code-lists/list-en1.html
		char country[2];

		// the name of the AS this peer is located in. This might be
		// an empty string if there is no name in the geo ip database.
		std::string inet_as_name;

		// the AS number the peer is located in.
		int inet_as;

		// a measurement of the balancing of free download (that we get)
		// and free upload that we give. Every peer gets a certain amount of free upload, but
		// this member says how much *extra* free upload this peer has got. If it is a negative
		// number it means that this was a peer from which we have got this amount of free
		// download.
		size_type load_balancing;

		// this is the number of requests
		// we have sent to this peer
		// that we haven't got a response
		// for yet
		int download_queue_length;
		
		// the number of block requests that have
		// timed out, and are still in the download
		// queue
		int timed_out_requests;

		// the number of busy requests in the download
		// queue. A budy request is a request for a block
		// we've also requested from a different peer
		int busy_requests;

		// the number of requests messages that are currently in the
		// send buffer waiting to be sent.
		int requests_in_buffer;

		// the number of requests that is
		// tried to be maintained (this is
		// typically a function of download speed)
		int target_dl_queue_length;

		// the number of piece-requests we have received from this peer
		// that we haven't answered with a piece yet.
		int upload_queue_length;

		// the number of times this peer has "failed". i.e. failed to connect
		// or disconnected us. The failcount is decremented when we see this peer in a tracker
		// response or peer exchange message.
		int failcount;

		// You can know which piece, and which part of that piece, that is currently being
		// downloaded from a specific peer by looking at these four members.
		// ``downloading_piece_index`` is the index of the piece that is currently being downloaded.
		// This may be set to -1 if there's currently no piece downloading from this peer. If it is
		// >= 0, the other three members are valid. ``downloading_block_index`` is the index of the
		// block (or sub-piece) that is being downloaded. ``downloading_progress`` is the number
		// of bytes of this block we have received from the peer, and ``downloading_total`` is
		// the total number of bytes in this block.
		int downloading_piece_index;
		int downloading_block_index;
		int downloading_progress;
		int downloading_total;
	
		// a string describing the software at the other end of the connection.
		// In some cases this information is not available, then it will contain a string
		// that may give away something about which software is running in the other end.
		// In the case of a web seed, the server type and version will be a part of this
		// string.
		std::string client;
		
		enum connection_type_t
		{
			// Regular bittorrent connection over TCP
			standard_bittorrent = 0,

			// Bittorrent connection over uTP
			web_seed = 1,

			// HTTP connection using the `BEP 19`_ protocol
			http_seed = 2,

			// HTTP connection using the `BEP 17`_ protocol
			bittorrent_utp = 3
		};

		// the kind of connection this peer uses. See connection_type_t.
		int connection_type;
		
		// an estimate of the rate this peer is downloading at, in
		// bytes per second.
		int remote_dl_rate;

		// the number of bytes this peer has pending in the
		// disk-io thread. Downloaded and waiting to be written to disk. This is what
		// is capped by ``session_settings::max_queued_disk_bytes``.
		int pending_disk_bytes;

		// the number of bytes this peer has been
		// assigned to be allowed to send and receive until it has to request more quota
		// from the bandwidth manager.
		int send_quota;
		int receive_quota;

		// an estimated round trip time to this peer, in milliseconds. It is
		// estimated by timing the the tcp ``connect()``. It may be 0 for incoming connections.
		int rtt;

		// the number of pieces this peer has.
		int num_pieces;

		// the highest download and upload
		// rates seen on this connection. They are given in bytes per second. This number is
		// reset to 0 on reconnect.
		int download_rate_peak;
		int upload_rate_peak;
		
		// the progress of the peer in the range [0, 1]. This is always 0 when
		// floating point operations are diabled, instead use ``progress_ppm``.
		float progress; // [0, 1]

		// indicates the download progress of the peer in the range [0, 1000000]
		// (parts per million).
		int progress_ppm;

		int estimated_reciprocation_rate;

		// the IP and port pair the socket is bound to locally. i.e. the IP
		// address of the interface it's going out over. This may be useful for multi-homed
		// clients with multiple interfaces to the internet.
		tcp::endpoint local_endpoint;
	};

	struct TORRENT_EXPORT peer_list_entry
	{
		enum flags_t
		{
			banned = 1
		};
		
		tcp::endpoint ip;
		int flags;
		boost::uint8_t failcount;
		boost::uint8_t source;
	};

	// defined in policy.cpp
	int source_rank(int source_bitmask);
}

#endif // TORRENT_PEER_INFO_HPP_INCLUDED