premiere-libtorrent/include/libtorrent/policy.hpp

428 lines
12 KiB
C++

/*
Copyright (c) 2003, 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_POLICY_HPP_INCLUDED
#define TORRENT_POLICY_HPP_INCLUDED
#include <algorithm>
#include <deque>
#include "libtorrent/peer.hpp"
#include "libtorrent/piece_picker.hpp"
#include "libtorrent/socket.hpp"
#include "libtorrent/size_type.hpp"
#include "libtorrent/invariant_check.hpp"
#include "libtorrent/config.hpp"
#include "libtorrent/time.hpp"
namespace libtorrent
{
class torrent;
class peer_connection;
enum
{
// the limits of the download queue size
min_request_queue = 2,
// the amount of free upload allowed before
// the peer is choked
free_upload_amount = 4 * 16 * 1024
};
void request_a_block(torrent& t, peer_connection& c);
class TORRENT_EXPORT policy
{
public:
policy(torrent* t);
// this is called every 10 seconds to allow
// for peer choking management
void pulse();
struct peer;
// this is called once for every peer we get from
// the tracker, pex, lsd or dht.
policy::peer* add_peer(const tcp::endpoint& remote, const peer_id& pid
, int source, char flags);
// false means duplicate connection
bool update_peer_port(int port, policy::peer* p, int src);
// called when an incoming connection is accepted
// false means the connection was refused or failed
bool new_connection(peer_connection& c, int session_time);
// the given connection was just closed
void connection_closed(const peer_connection& c, int session_time);
void ban_peer(policy::peer* p);
// the peer has got at least one interesting piece
void peer_is_interesting(peer_connection& c);
// the peer unchoked us
void unchoked(peer_connection& c);
// the peer is interested in our pieces
void interested(peer_connection& c);
// the peer is not interested in our pieces
void not_interested(peer_connection& c);
void ip_filter_updated();
void set_seed(policy::peer* p, bool s);
#ifdef TORRENT_DEBUG
bool has_connection(const peer_connection* p);
void check_invariant() const;
#endif
// intended struct layout (on 32 bit architectures)
// offset size alignment field
// 0 12 1 prev_amount_upload, prev_amount_download
// 12 4 4 connection
// 16 2 2 last_optimistically_unchoked
// 18 2 2 last_connected
// 20 16 1 addr
// 36 2 2 port
// 38 1 1 hashfails
// 39 1 1 failcount, connectable, optimistically_unchoked, seed
// 40 1 1 fast_reconnects, trust_points
// 41 1 1 source, pe_support, is_v6_addr
// 42 1 1 on_parole, banned, added_to_dht
// 43 1 1 <padding>
// 44
struct peer
{
peer();
peer(boost::uint16_t port, bool connectable, int src);
size_type total_download() const;
size_type total_upload() const;
libtorrent::address address() const;
tcp::endpoint ip() const { return tcp::endpoint(address(), port); }
// this is the accumulated amount of
// uploaded and downloaded data to this
// peer. It only accounts for what was
// shared during the last connection to
// this peer. i.e. These are only updated
// when the connection is closed. For the
// total amount of upload and download
// we'll have to add thes figures with the
// statistics from the peer_connection.
// 48 bits can fit 256 Terabytes
boost::uint64_t prev_amount_upload:48;
boost::uint64_t prev_amount_download:48;
// if the peer is connected now, this
// will refer to a valid peer_connection
peer_connection* connection;
#ifndef TORRENT_DISABLE_GEO_IP
#ifdef TORRENT_DEBUG
// only used in debug mode to assert that
// the first entry in the AS pair keeps the same
boost::uint16_t inet_as_num;
#endif
// The AS this peer belongs to
std::pair<const int, int>* inet_as;
#endif
// the time when this peer was optimistically unchoked
// the last time. in seconds since session was created
// 16 bits is enough to last for 18.2 hours
// when the session time reaches 18 hours, it jumps back by
// 9 hours, and all peers' times are updated to be
// relative to that new time offset
boost::uint16_t last_optimistically_unchoked;
// the time when the peer connected to us
// or disconnected if it isn't connected right now
// in number of seconds since session was created
boost::uint16_t last_connected;
// the port this peer is or was connected on
boost::uint16_t port;
// the number of times this peer has been
// part of a piece that failed the hash check
boost::uint8_t hashfails;
// the number of failed connection attempts
// this peer has
unsigned failcount:5; // [0, 31]
// incoming peers (that don't advertize their listen port)
// will not be considered connectable. Peers that
// we have a listen port for will be assumed to be.
bool connectable:1;
// true if this peer currently is unchoked
// because of an optimistic unchoke.
// when the optimistic unchoke is moved to
// another peer, this peer will be choked
// if this is true
bool optimistically_unchoked:1;
// this is true if the peer is a seed
bool seed:1;
// the number of times we have allowed a fast
// reconnect for this peer.
unsigned fast_reconnects:4;
// for every valid piece we receive where this
// peer was one of the participants, we increase
// this value. For every invalid piece we receive
// where this peer was a participant, we decrease
// this value. If it sinks below a threshold, its
// considered a bad peer and will be banned.
signed trust_points:4; // [-7, 8]
// a bitmap combining the peer_source flags
// from peer_info.
unsigned source:6;
#ifndef TORRENT_DISABLE_ENCRYPTION
// Hints encryption support of peer. Only effective
// for and when the outgoing encryption policy
// allows both encrypted and non encrypted
// connections (pe_settings::out_enc_policy
// == enabled). The initial state of this flag
// determines the initial connection attempt
// type (true = encrypted, false = standard).
// This will be toggled everytime either an
// encrypted or non-encrypted handshake fails.
bool pe_support:1;
#endif
#if TORRENT_USE_IPV6
// this is true if the v6 union member in addr is
// the one to use, false if it's the v4 one
bool is_v6_addr:1;
#endif
// if this is true, the peer has previously
// participated in a piece that failed the piece
// hash check. This will put the peer on parole
// and only request entire pieces. If a piece pass
// that was partially requested from this peer it
// will leave parole mode and continue download
// pieces as normal peers.
bool on_parole:1;
// is set to true if this peer has been banned
bool banned:1;
#ifndef TORRENT_DISABLE_DHT
// this is set to true when this peer as been
// pinged by the DHT
bool added_to_dht:1;
#endif
};
struct ipv4_peer : peer
{
ipv4_peer(tcp::endpoint const& ip, bool connectable, int src);
ipv4_peer(libtorrent::address const& a);
address_v4 addr;
};
#if TORRENT_USE_IPV6
struct ipv6_peer : peer
{
ipv6_peer(tcp::endpoint const& ip, bool connectable, int src);
ipv6_peer(libtorrent::address const& a);
address_v6::bytes_type addr;
};
#endif
int num_peers() const { return m_peers.size(); }
struct peer_address_compare
{
bool operator()(
peer const* lhs, libtorrent::address const& rhs) const
{
return lhs->address() < rhs;
}
bool operator()(
libtorrent::address const& lhs, peer const* rhs) const
{
return lhs < rhs->address();
}
bool operator()(
peer const* lhs, peer const* rhs) const
{
return lhs->address() < rhs->address();
}
};
typedef std::deque<peer*> peers_t;
typedef peers_t::iterator iterator;
typedef peers_t::const_iterator const_iterator;
iterator begin_peer() { return m_peers.begin(); }
iterator end_peer() { return m_peers.end(); }
const_iterator begin_peer() const { return m_peers.begin(); }
const_iterator end_peer() const { return m_peers.end(); }
std::pair<iterator, iterator> find_peers(address const& a)
{
return std::equal_range(
m_peers.begin(), m_peers.end(), a, peer_address_compare());
}
std::pair<const_iterator, const_iterator> find_peers(address const& a) const
{
return std::equal_range(
m_peers.begin(), m_peers.end(), a, peer_address_compare());
}
bool connect_one_peer(int session_time);
bool has_peer(policy::peer const* p) const;
int num_seeds() const { return m_num_seeds; }
int num_connect_candidates() const { return m_num_connect_candidates; }
void recalculate_connect_candidates();
void erase_peer(policy::peer* p);
void erase_peer(iterator i);
private:
bool compare_peer_erase(policy::peer const& lhs, policy::peer const& rhs) const;
bool compare_peer(policy::peer const& lhs, policy::peer const& rhs
, address const& external_ip) const;
iterator find_connect_candidate(int session_time);
bool is_connect_candidate(peer const& p, bool finished) const;
bool is_erase_candidate(peer const& p, bool finished) const;
bool should_erase_immediately(peer const& p) const;
void erase_peers();
peers_t m_peers;
// since the peer list can grow too large
// to scan all of it, start at this iterator
int m_round_robin;
torrent* m_torrent;
// free download we have got that hasn't
// been distributed yet.
size_type m_available_free_upload;
// The number of peers in our peer list
// that are connect candidates. i.e. they're
// not already connected and they have not
// yet reached their max try count and they
// have the connectable state (we have a listen
// port for them).
int m_num_connect_candidates;
// the number of seeds in the peer list
int m_num_seeds;
// this was the state of the torrent the
// last time we recalculated the number of
// connect candidates. Since seeds (or upload
// only) peers are not connect candidates
// when we're finished, the set depends on
// this state. Every time m_torrent->is_finished()
// is different from this state, we need to
// recalculate the connect candidates.
bool m_finished;
};
inline policy::ipv4_peer::ipv4_peer(
tcp::endpoint const& ip, bool connectable, int src
)
: peer(ip.port(), connectable, src)
, addr(ip.address().to_v4())
{
is_v6_addr = false;
}
inline policy::ipv4_peer::ipv4_peer(libtorrent::address const& a)
: addr(a.to_v4())
{
is_v6_addr = false;
}
inline policy::ipv6_peer::ipv6_peer(
tcp::endpoint const& ip, bool connectable, int src
)
: peer(ip.port(), connectable, src)
, addr(ip.address().to_v6().to_bytes())
{
is_v6_addr = true;
}
inline policy::ipv6_peer::ipv6_peer(libtorrent::address const& a)
: addr(a.to_v6().to_bytes())
{
is_v6_addr = true;
}
inline libtorrent::address policy::peer::address() const
{
#if TORRENT_USE_IPV6
if (is_v6_addr)
return libtorrent::address_v6(
static_cast<policy::ipv6_peer const*>(this)->addr);
#endif
return static_cast<policy::ipv4_peer const*>(this)->addr;
}
}
#endif // TORRENT_POLICY_HPP_INCLUDED