premiere-libtorrent/include/libtorrent/peer_info.hpp

255 lines
6.4 KiB
C++
Raw Normal View History

/*
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
{
interesting = 0x1,
choked = 0x2,
remote_interested = 0x4,
2004-01-04 05:29:13 +01:00
remote_choked = 0x8,
2004-01-09 11:50:22 +01:00
supports_extensions = 0x10,
local_connection = 0x20,
handshake = 0x40,
connecting = 0x80,
2007-05-25 21:42:10 +02:00
queued = 0x100,
on_parole = 0x200,
seed = 0x400,
optimistic_unchoke = 0x800,
2008-07-19 09:57:43 +02:00
snubbed = 0x1000,
2010-11-29 02:33:05 +01:00
upload_only = 0x2000,
endgame_mode = 0x4000,
holepunched = 0x8000
2007-06-06 02:41:20 +02:00
#ifndef TORRENT_DISABLE_ENCRYPTION
, rc4_encrypted = 0x100000,
plaintext_encrypted = 0x200000
2007-06-06 02:41:20 +02:00
#endif
};
unsigned int flags;
enum peer_source_flags
{
tracker = 0x1,
dht = 0x2,
pex = 0x4,
lsd = 0x8,
2007-09-15 22:17:23 +02:00
resume_data = 0x10,
incoming = 0x20
};
int source;
2008-01-14 00:46:43 +01:00
// bw_idle: the channel is not used
// bw_limit: the channel is waiting for quota
2008-01-14 00:46:43 +01:00
// bw_network: the channel is waiting for an async write
// for read operation to complete
// bw_disk: the peer is waiting for the disk io thread
// this is a bitmask, a peer can wait for network and
// disk at the same time!
enum bw_state { bw_idle = 0, bw_limit = 1, bw_network = 2, bw_disk = 4 };
#ifndef TORRENT_NO_DEPRECATE
enum bw_state_deprecated { bw_torrent = bw_limit, bw_global = bw_limit };
#endif
2008-01-14 00:46:43 +01:00
char read_state;
char write_state;
tcp::endpoint ip;
int up_speed;
int down_speed;
int payload_up_speed;
int payload_down_speed;
size_type total_download;
size_type total_upload;
peer_id pid;
bitfield pieces;
int upload_limit;
int download_limit;
2007-05-25 21:42:10 +02:00
// time since last request
time_duration last_request;
// time since last download or upload
time_duration last_active;
2009-02-17 03:33:45 +01:00
// the time until all blocks in the request
// queue will be d
time_duration download_queue_time;
int queue_bytes;
2009-02-17 03:33:45 +01:00
// the number of seconds until the current
// pending request times out
int request_timeout;
2008-01-10 23:13:23 +01:00
// the size of the send buffer for this peer, in bytes
2007-05-25 21:42:10 +02:00
int send_buffer_size;
2008-01-10 23:13:23 +01:00
// the number bytes that's actually used of the send buffer
int used_send_buffer;
2007-05-25 21:42:10 +02:00
int receive_buffer_size;
int used_receive_buffer;
2007-05-25 21:42:10 +02:00
// the number of failed hashes for this peer
int num_hashfails;
#ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES
// in case the session settings is set
// to resolve countries, this is set to
// the two character country code this
// peer resides in.
char country[2];
#endif
2003-12-09 19:09:34 +01:00
#ifndef TORRENT_DISABLE_GEO_IP
// atonomous system this peer belongs to
std::string inet_as_name;
int inet_as;
#endif
size_type load_balancing;
2004-01-05 00:51:54 +01:00
// 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;
2004-01-05 00:51:54 +01:00
// the number of request messages
// waiting to be sent inside the send buffer
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;
2004-01-14 12:46:26 +01:00
// this is the number of requests
// the peer has sent to us
// that we haven't sent yet
int upload_queue_length;
// the number of times this IP
// has failed to connect
int failcount;
2003-12-09 19:09:34 +01:00
// the currently downloading piece
// if piece index is -1 all associated
// members are just set to 0
int downloading_piece_index;
int downloading_block_index;
int downloading_progress;
int downloading_total;
std::string client;
enum
{
standard_bittorrent = 0,
2008-12-30 04:54:07 +01:00
web_seed = 1,
2010-11-29 02:33:05 +01:00
http_seed = 2,
bittorrent_utp = 3
};
int connection_type;
// approximate peer download rate
int remote_dl_rate;
2007-08-01 08:11:11 +02:00
// number of bytes this peer has in
// the disk write queue
int pending_disk_bytes;
// numbers used for bandwidth limiting
int send_quota;
int receive_quota;
// estimated rtt to peer, in milliseconds
int rtt;
2008-04-03 08:11:21 +02:00
// the number of pieces this peer has
int num_pieces;
2008-04-03 08:11:21 +02:00
// the highest transfer rates seen for this peer
int download_rate_peak;
int upload_rate_peak;
2008-09-25 22:39:06 +02:00
// the peers progress
float progress; // [0, 1]
int progress_ppm; // [0, 1000000]
int estimated_reciprocation_rate;
tcp::endpoint local_endpoint;
};
struct TORRENT_EXPORT peer_list_entry
{
enum flags_t
{
2008-10-26 23:12:12 +01:00
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