premiere-libtorrent/src/policy.cpp

1420 lines
39 KiB
C++
Raw Normal View History

/*
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.
*/
#include "libtorrent/pch.hpp"
#include <iostream>
#ifdef _MSC_VER
#pragma warning(push, 1)
#endif
2005-09-28 20:32:05 +02:00
#include <boost/bind.hpp>
#include <boost/utility.hpp>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#include "libtorrent/peer_connection.hpp"
#include "libtorrent/web_peer_connection.hpp"
#include "libtorrent/policy.hpp"
#include "libtorrent/torrent.hpp"
#include "libtorrent/socket.hpp"
2004-01-18 20:12:18 +01:00
#include "libtorrent/alert_types.hpp"
#include "libtorrent/invariant_check.hpp"
#include "libtorrent/time.hpp"
#include "libtorrent/aux_/session_impl.hpp"
#include "libtorrent/piece_picker.hpp"
2004-01-12 04:05:10 +01:00
#ifndef NDEBUG
#include "libtorrent/bt_peer_connection.hpp"
#endif
2004-01-15 17:45:34 +01:00
namespace libtorrent
{
class peer_connection;
}
2005-09-28 20:32:05 +02:00
using boost::bind;
2004-10-14 03:17:04 +02:00
namespace
{
using namespace libtorrent;
2003-11-05 00:27:06 +01:00
size_type collect_free_download(
torrent::peer_iterator start
, torrent::peer_iterator end)
{
size_type accumulator = 0;
for (torrent::peer_iterator i = start; i != end; ++i)
{
// if the peer is interested in us, it means it may
// want to trade it's surplus uploads for downloads itself
// (and we should not consider it free). If the share diff is
// negative, there's no free download to get from this peer.
size_type diff = (*i)->share_diff();
TORRENT_ASSERT(diff < (std::numeric_limits<size_type>::max)());
if ((*i)->is_peer_interested() || diff <= 0)
continue;
TORRENT_ASSERT(diff > 0);
(*i)->add_free_upload(-diff);
accumulator += diff;
TORRENT_ASSERT(accumulator > 0);
}
TORRENT_ASSERT(accumulator >= 0);
return accumulator;
}
// returns the amount of free upload left after
// it has been distributed to the peers
size_type distribute_free_upload(
torrent::peer_iterator start
, torrent::peer_iterator end
, size_type free_upload)
{
if (free_upload <= 0) return free_upload;
int num_peers = 0;
size_type total_diff = 0;
for (torrent::peer_iterator i = start; i != end; ++i)
{
size_type d = (*i)->share_diff();
TORRENT_ASSERT(d < (std::numeric_limits<size_type>::max)());
total_diff += d;
if (!(*i)->is_peer_interested() || (*i)->share_diff() >= 0) continue;
++num_peers;
}
if (num_peers == 0) return free_upload;
size_type upload_share;
if (total_diff >= 0)
{
2007-08-21 09:33:06 +02:00
upload_share = (std::min)(free_upload, total_diff) / num_peers;
}
else
{
upload_share = (free_upload + total_diff) / num_peers;
}
if (upload_share < 0) return free_upload;
for (torrent::peer_iterator i = start; i != end; ++i)
{
peer_connection* p = *i;
if (!p->is_peer_interested() || p->share_diff() >= 0) continue;
p->add_free_upload(upload_share);
free_upload -= upload_share;
}
return free_upload;
}
struct match_peer_endpoint
{
match_peer_endpoint(tcp::endpoint const& ep)
: m_ep(ep)
{}
bool operator()(std::pair<const address, policy::peer> const& p) const
{ return p.second.ip == m_ep; }
tcp::endpoint const& m_ep;
};
struct match_peer_id
{
match_peer_id(peer_id const& id_)
: m_id(id_)
{}
bool operator()(std::pair<const address, policy::peer> const& p) const
{ return p.second.connection && p.second.connection->pid() == m_id; }
peer_id const& m_id;
};
struct match_peer_connection
{
match_peer_connection(peer_connection const& c)
: m_conn(c)
{}
bool operator()(std::pair<const address, policy::peer> const& p) const
{
return p.second.connection == &m_conn
|| (p.second.ip == m_conn.remote()
&& p.second.type == policy::peer::connectable);
}
peer_connection const& m_conn;
};
}
namespace libtorrent
{
2004-02-01 11:45:54 +01:00
// the case where ignore_peer is motivated is if two peers
2004-02-01 10:47:58 +01:00
// have only one piece that we don't have, and it's the
// same piece for both peers. Then they might get into an
// infinite loop, fighting to request the same blocks.
void request_a_block(torrent& t, peer_connection& c)
{
if (t.is_seed()) return;
TORRENT_ASSERT(t.valid_metadata());
TORRENT_ASSERT(c.peer_info_struct() != 0 || !dynamic_cast<bt_peer_connection*>(&c));
int num_requests = c.desired_queue_size()
- (int)c.download_queue().size()
- (int)c.request_queue().size();
2003-11-05 00:27:06 +01:00
#ifdef TORRENT_VERBOSE_LOGGING
(*c.m_logger) << time_now_string() << " PIECE_PICKER [ req: " << num_requests << " ]\n";
#endif
TORRENT_ASSERT(c.desired_queue_size() > 0);
2003-11-05 00:27:06 +01:00
// if our request queue is already full, we
// don't have to make any new requests yet
if (num_requests <= 0) return;
piece_picker& p = t.picker();
std::vector<piece_block> interesting_pieces;
interesting_pieces.reserve(100);
int prefer_whole_pieces = c.prefer_whole_pieces();
bool rarest_first = t.num_pieces() >= t.settings().initial_picker_threshold;
if (prefer_whole_pieces == 0)
{
prefer_whole_pieces = c.statistics().download_payload_rate()
* t.settings().whole_pieces_threshold
> t.torrent_file().piece_length() ? 1 : 0;
}
// if we prefer whole pieces, the piece picker will pick at least
// the number of blocks we want, but it will try to make the picked
// blocks be from whole pieces, possibly by returning more blocks
// than we requested.
2008-02-08 11:22:05 +01:00
#ifndef NDEBUG
asio::error_code ec;
TORRENT_ASSERT(c.remote() == c.get_socket()->remote_endpoint(ec) || ec);
#endif
piece_picker::piece_state_t state;
peer_connection::peer_speed_t speed = c.peer_speed();
if (speed == peer_connection::fast) state = piece_picker::fast;
else if (speed == peer_connection::medium) state = piece_picker::medium;
else state = piece_picker::slow;
2004-01-12 21:31:27 +01:00
// this vector is filled with the interesting pieces
// that some other peer is currently downloading
// we should then compare this peer's download speed
// with the other's, to see if we should abort another
// peer_connection in favour of this one
std::vector<piece_block> busy_pieces;
busy_pieces.reserve(num_requests);
std::vector<int> const& suggested = c.suggested_pieces();
2007-09-06 01:32:05 +02:00
std::vector<bool> const& bitfield = c.get_bitfield();
if (c.has_peer_choked())
{
// if we are choked we can only pick pieces from the
// allowed fast set. The allowed fast set is sorted
// in ascending priority order
std::vector<int> const& allowed_fast = c.allowed_fast();
// build a bitmask with only the allowed pieces in it
std::vector<bool> mask(c.get_bitfield().size(), false);
for (std::vector<int>::const_iterator i = allowed_fast.begin()
, end(allowed_fast.end()); i != end; ++i)
2007-09-06 01:32:05 +02:00
if (bitfield[*i]) mask[*i] = true;
p.pick_pieces(mask, interesting_pieces
, num_requests, prefer_whole_pieces, c.peer_info_struct()
, state, rarest_first, c.on_parole(), suggested);
}
else
{
// picks the interesting pieces from this peer
// the integer is the number of pieces that
// should be guaranteed to be available for download
// (if num_requests is too big, too many pieces are
// picked and cpu-time is wasted)
// the last argument is if we should prefer whole pieces
// for this peer. If we're downloading one piece in 20 seconds
// then use this mode.
2007-09-06 01:32:05 +02:00
p.pick_pieces(bitfield, interesting_pieces
, num_requests, prefer_whole_pieces, c.peer_info_struct()
, state, rarest_first, c.on_parole(), suggested);
}
#ifdef TORRENT_VERBOSE_LOGGING
(*c.m_logger) << time_now_string() << " PIECE_PICKER [ php: " << prefer_whole_pieces
<< " picked: " << interesting_pieces.size() << " ]\n";
#endif
std::deque<piece_block> const& dq = c.download_queue();
std::deque<piece_block> const& rq = c.request_queue();
for (std::vector<piece_block>::iterator i = interesting_pieces.begin();
i != interesting_pieces.end(); ++i)
{
if (prefer_whole_pieces == 0 && num_requests <= 0) break;
2007-06-10 22:46:09 +02:00
if (p.is_requested(*i))
{
if (num_requests <= 0) break;
// don't request pieces we already have in our request queue
if (std::find(dq.begin(), dq.end(), *i) != dq.end()
|| std::find(rq.begin(), rq.end(), *i) != rq.end())
continue;
TORRENT_ASSERT(p.num_peers(*i) > 0);
busy_pieces.push_back(*i);
continue;
}
TORRENT_ASSERT(p.num_peers(*i) == 0);
// ok, we found a piece that's not being downloaded
// by somebody else. request it from this peer
2004-02-01 10:47:58 +01:00
// and return
c.add_request(*i);
TORRENT_ASSERT(p.num_peers(*i) == 1);
TORRENT_ASSERT(p.is_requested(*i));
2003-11-05 00:27:06 +01:00
num_requests--;
}
if (busy_pieces.empty() || num_requests <= 0)
2003-11-05 00:27:06 +01:00
{
// in this case, we could not find any blocks
// that was free. If we couldn't find any busy
// blocks as well, we cannot download anything
// more from this peer.
c.send_block_requests();
return;
}
2004-02-04 12:00:29 +01:00
// if all blocks has the same number of peers on them
// we want to pick a random block
std::random_shuffle(busy_pieces.begin(), busy_pieces.end());
// find the block with the fewest requests to it
std::vector<piece_block>::iterator i = std::min_element(
busy_pieces.begin(), busy_pieces.end()
, bind(&piece_picker::num_peers, boost::cref(p), _1) <
bind(&piece_picker::num_peers, boost::cref(p), _2));
#ifndef NDEBUG
piece_picker::downloading_piece st;
p.piece_info(i->piece_index, st);
TORRENT_ASSERT(st.requested + st.finished + st.writing == p.blocks_in_piece(i->piece_index));
#endif
TORRENT_ASSERT(p.is_requested(*i));
TORRENT_ASSERT(p.num_peers(*i) > 0);
c.add_request(*i);
c.send_block_requests();
}
policy::policy(torrent* t)
: m_torrent(t)
2003-12-14 23:55:32 +01:00
, m_available_free_upload(0)
, m_num_connect_candidates(0)
{ TORRENT_ASSERT(t); }
2007-07-26 09:04:35 +02:00
// disconnects and removes all peers that are now filtered
void policy::ip_filter_updated()
{
aux::session_impl& ses = m_torrent->session();
piece_picker* p = 0;
if (m_torrent->has_picker())
p = &m_torrent->picker();
for (iterator i = m_peers.begin()
2007-07-26 09:04:35 +02:00
, end(m_peers.end()); i != end;)
{
if ((ses.m_ip_filter.access(i->second.ip.address()) & ip_filter::blocked) == 0)
2007-07-26 09:04:35 +02:00
{
++i;
continue;
}
if (i->second.connection)
2007-07-26 09:04:35 +02:00
{
i->second.connection->disconnect("peer banned by IP filter");
2007-07-26 09:04:35 +02:00
if (ses.m_alerts.should_post(alert::info))
{
ses.m_alerts.post_alert(peer_blocked_alert(i->second.ip.address()
2007-07-26 09:04:35 +02:00
, "disconnected blocked peer"));
}
TORRENT_ASSERT(i->second.connection == 0
|| i->second.connection->peer_info_struct() == 0);
2007-07-26 09:04:35 +02:00
}
else
{
if (ses.m_alerts.should_post(alert::info))
{
ses.m_alerts.post_alert(peer_blocked_alert(i->second.ip.address()
2007-07-26 09:04:35 +02:00
, "blocked peer removed from peer list"));
}
}
if (p) p->clear_peer(&i->second);
if (i->second.seed) --m_num_seeds;
2007-07-26 09:04:35 +02:00
m_peers.erase(i++);
}
}
bool policy::is_connect_candidate(peer const& p, bool finished)
2003-12-14 06:56:12 +01:00
{
if (p.connection
|| p.banned
|| p.type == peer::not_connectable
|| (p.seed && finished)
|| p.failcount >= m_torrent->settings().max_failcount)
return false;
2005-04-05 02:54:33 +02:00
aux::session_impl& ses = m_torrent->session();
if (ses.m_port_filter.access(p.ip.port()) & port_filter::blocked)
return false;
return true;
2003-12-14 06:56:12 +01:00
}
policy::iterator policy::find_disconnect_candidate()
2004-01-21 01:59:38 +01:00
{
INVARIANT_CHECK;
iterator disconnect_peer = m_peers.end();
2007-08-21 09:33:06 +02:00
double slowest_transfer_rate = (std::numeric_limits<double>::max)();
2004-01-21 01:59:38 +01:00
ptime now = time_now();
2004-01-21 01:59:38 +01:00
for (iterator i = m_peers.begin();
2005-08-18 22:38:03 +02:00
i != m_peers.end(); ++i)
2004-01-21 01:59:38 +01:00
{
peer_connection* c = i->second.connection;
if (c == 0) continue;
if (c->is_disconnecting()) continue;
// never disconnect an interesting peer if we have a candidate that
// isn't interesting
if (disconnect_peer != m_peers.end()
&& c->is_interesting()
&& !disconnect_peer->second.connection->is_interesting())
2004-01-21 01:59:38 +01:00
continue;
double transferred_amount
= (double)c->statistics().total_payload_download();
2004-01-21 01:59:38 +01:00
time_duration connected_time = now - i->second.connected;
2004-01-21 01:59:38 +01:00
double connected_time_in_seconds = total_seconds(connected_time);
2004-01-21 01:59:38 +01:00
double transfer_rate
= transferred_amount / (connected_time_in_seconds + 1);
2004-01-21 01:59:38 +01:00
// prefer to disconnect uninteresting peers, and secondly slow peers
if (transfer_rate <= slowest_transfer_rate)
2004-01-21 01:59:38 +01:00
{
slowest_transfer_rate = transfer_rate;
disconnect_peer = i;
2004-01-21 01:59:38 +01:00
}
}
return disconnect_peer;
}
policy::iterator policy::find_connect_candidate()
2004-01-14 17:18:53 +01:00
{
2007-08-27 07:32:47 +02:00
// too expensive
// INVARIANT_CHECK;
ptime now = time_now();
2007-05-07 18:24:08 +02:00
ptime min_connect_time(now);
iterator candidate = m_peers.end();
int min_reconnect_time = m_torrent->settings().min_reconnect_time;
2007-09-04 00:57:09 +02:00
bool finished = m_torrent->is_finished();
int min_cidr_distance = (std::numeric_limits<int>::max)();
address external_ip = m_torrent->session().external_address();
// don't bias any particular peers when seeding
if (finished || external_ip == address())
{
// set external_ip to a random value, to
// radomize which peers we prefer
address_v4::bytes_type bytes;
std::generate(bytes.begin(), bytes.end(), &std::rand);
external_ip = address_v4(bytes);
}
2004-01-14 17:18:53 +01:00
#ifndef TORRENT_DISABLE_GEO_IP
int max_inet_as_rate = -1;
bool has_db = m_torrent->session().has_asnum_db();
#endif
int connect_candidates = 0;
int seeds = 0;
2007-05-07 18:24:08 +02:00
for (iterator i = m_peers.begin(); i != m_peers.end(); ++i)
2004-01-14 17:18:53 +01:00
{
if (i->second.seed) ++seeds;
if (!is_connect_candidate(i->second, finished)) continue;
++connect_candidates;
// prefer peers with lower failcount
if (candidate != m_peers.end()
&& candidate->second.failcount < i->second.failcount)
continue;
if (now - i->second.connected < seconds(i->second.failcount * min_reconnect_time))
continue;
2004-01-14 17:22:49 +01:00
TORRENT_ASSERT(i->second.connected <= now);
2004-01-14 17:18:53 +01:00
// don't replace a candidate that is on the local
// network with one that isn't. Local peers should
// always be tried first
if (candidate != m_peers.end()
&& is_local(candidate->second.ip.address())
&& !is_local(i->second.ip.address()))
continue;
if (i->second.connected > min_connect_time) continue;
#ifndef TORRENT_DISABLE_GEO_IP
if (!finished && has_db)
{
// don't bias fast peers when seeding
std::pair<const int, int>* inet_as = i->second.inet_as;
int peak_rate = inet_as ? inet_as->second : 0;
if (peak_rate <= max_inet_as_rate) continue;
max_inet_as_rate = peak_rate;
}
if (max_inet_as_rate <= 0)
#endif
{
int distance = cidr_distance(external_ip, i->second.ip.address());
if (distance > min_cidr_distance) continue;
min_cidr_distance = distance;
}
min_connect_time = i->second.connected;
candidate = i;
2004-01-14 17:18:53 +01:00
}
m_num_connect_candidates = connect_candidates;
m_num_seeds = seeds;
TORRENT_ASSERT(min_connect_time <= now);
2004-01-14 17:18:53 +01:00
#if defined TORRENT_LOGGING || defined TORRENT_VERBOSE_LOGGING
if (candidate != m_peers.end())
{
(*m_torrent->session().m_logger) << time_now_string()
<< " *** FOUND CONNECTION CANDIDATE ["
" ip: " << candidate->second.ip <<
" d: " << min_cidr_distance <<
" external: " << external_ip <<
" t: " << total_seconds(time_now() - min_connect_time) <<
" ]\n";
}
#endif
2004-01-14 17:18:53 +01:00
return candidate;
}
2004-05-14 01:34:42 +02:00
void policy::pulse()
{
INVARIANT_CHECK;
2004-11-30 12:17:32 +01:00
if (m_torrent->is_paused()) return;
piece_picker* p = 0;
if (m_torrent->has_picker())
p = &m_torrent->picker();
bool pinged = false;
ptime now = time_now();
2004-01-21 01:59:38 +01:00
// remove old disconnected peers from the list
for (iterator i = m_peers.begin(); i != m_peers.end();)
{
peer& pe = i->second;
#ifndef TORRENT_DISABLE_DHT
// try to send a DHT ping to this peer
// as well, to figure out if it supports
// DHT (uTorrent and BitComet doesn't
// advertise support)
if (!pinged && !pe.added_to_dht)
{
udp::endpoint node(pe.ip.address(), pe.ip.port());
m_torrent->session().add_dht_node(node);
pe.added_to_dht = true;
pinged = true;
}
#endif
// this timeout has to be customizable!
2007-10-03 19:37:15 +02:00
// don't remove banned peers, they should
// remain banned
if (pe.connection == 0
&& pe.connected != min_time()
&& !pe.banned
&& now - pe.connected > minutes(120))
{
if (p) p->clear_peer(&pe);
if (pe.seed) --m_num_seeds;
m_peers.erase(i++);
}
else
{
++i;
}
}
2004-03-01 22:54:10 +01:00
// -------------------------------------
// maintain the number of connections
// -------------------------------------
/*
2004-03-01 22:54:10 +01:00
// count the number of connected peers except for peers
// that are currently in the process of disconnecting
int num_connected_peers = 0;
for (iterator i = m_peers.begin();
i != m_peers.end(); ++i)
2004-01-21 01:59:38 +01:00
{
2004-03-01 22:54:10 +01:00
if (i->connection && !i->connection->is_disconnecting())
++num_connected_peers;
}
2004-01-21 01:59:38 +01:00
2007-08-21 09:33:06 +02:00
if (m_torrent->max_connections() != (std::numeric_limits<int>::max)())
2004-03-01 22:54:10 +01:00
{
int max_connections = m_torrent->max_connections();
2004-01-21 01:59:38 +01:00
2004-03-01 22:54:10 +01:00
if (num_connected_peers >= max_connections)
2004-01-21 01:59:38 +01:00
{
// every minute, disconnect the worst peer in hope of finding a better peer
ptime local_time = time_now();
if (m_last_optimistic_disconnect + seconds(120) <= local_time
&& find_connect_candidate() != m_peers.end())
2004-01-21 01:59:38 +01:00
{
2004-03-01 22:54:10 +01:00
m_last_optimistic_disconnect = local_time;
2004-01-21 01:59:38 +01:00
--max_connections; // this will have the effect of disconnecting the worst peer
}
}
else
{
// don't do a disconnect earlier than 1 minute after some peer was connected
m_last_optimistic_disconnect = time_now();
2004-01-21 01:59:38 +01:00
}
2004-03-01 22:54:10 +01:00
while (num_connected_peers > max_connections)
2004-01-21 01:59:38 +01:00
{
bool ret = disconnect_one_peer();
2005-05-31 00:50:54 +02:00
(void)ret;
TORRENT_ASSERT(ret);
2004-01-21 01:59:38 +01:00
--num_connected_peers;
}
}
*/
2004-03-01 22:54:10 +01:00
// ------------------------
// upload shift
// ------------------------
// this part will shift downloads
// from peers that are seeds and peers
// that don't want to download from us
// to peers that cannot upload anything
// to us. The shifting will make sure
// that the torrent's share ratio
// will be maintained
2004-01-14 02:19:30 +01:00
// if the share ratio is 0 (infinite)
// m_available_free_upload isn't used
// because it isn't necessary
if (m_torrent->ratio() != 0.f)
{
// accumulate all the free download we get
// and add it to the available free upload
m_available_free_upload
+= collect_free_download(
m_torrent->begin()
, m_torrent->end());
// distribute the free upload among the peers
m_available_free_upload = distribute_free_upload(
2003-12-14 23:55:32 +01:00
m_torrent->begin()
2004-01-14 02:19:30 +01:00
, m_torrent->end()
, m_available_free_upload);
}
}
2007-06-08 00:37:58 +02:00
int policy::count_choked() const
{
int ret = 0;
for (const_iterator i = m_peers.begin();
i != m_peers.end(); ++i)
{
if (!i->second.connection
|| i->second.connection->is_connecting()
|| i->second.connection->is_disconnecting()
|| !i->second.connection->is_peer_interested())
2007-06-08 00:37:58 +02:00
continue;
if (i->second.connection->is_choked()) ++ret;
2007-06-08 00:37:58 +02:00
}
return ret;
}
bool policy::new_connection(peer_connection& c)
{
TORRENT_ASSERT(!c.is_local());
// INVARIANT_CHECK;
2004-03-01 01:50:00 +01:00
// if the connection comes from the tracker,
// it's probably just a NAT-check. Ignore the
// num connections constraint then.
2004-09-16 03:14:16 +02:00
2004-03-28 19:45:37 +02:00
// TODO: only allow _one_ connection to use this
// override at a time
asio::error_code ec;
TORRENT_ASSERT(c.remote() == c.get_socket()->remote_endpoint(ec) || ec);
aux::session_impl& ses = m_torrent->session();
if (m_torrent->num_peers() >= m_torrent->max_connections()
&& ses.num_connections() >= ses.max_connections()
&& c.remote().address() != m_torrent->current_tracker().address())
2004-03-01 01:50:00 +01:00
{
c.disconnect("too many connections, refusing incoming connection");
return false;
2004-03-01 01:50:00 +01:00
}
#if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING
if (c.remote().address() == m_torrent->current_tracker().address())
2004-03-01 01:50:00 +01:00
{
m_torrent->debug_log("overriding connection limit for tracker NAT-check");
}
#endif
2004-01-21 01:59:38 +01:00
iterator i;
2004-01-15 02:29:43 +01:00
if (m_torrent->settings().allow_multiple_connections_per_ip)
{
tcp::endpoint remote = c.remote();
std::pair<iterator, iterator> range = m_peers.equal_range(remote.address());
i = std::find_if(range.first, range.second, match_peer_endpoint(remote));
if (i == range.second) i = m_peers.end();
}
else
{
i = m_peers.find(c.remote().address());
}
if (i != m_peers.end())
{
if (i->second.banned)
{
c.disconnect("ip address banned, closing");
return false;
}
if (i->second.connection != 0)
{
TORRENT_ASSERT(i->second.connection != &c);
// the new connection is a local (outgoing) connection
// or the current one is already connected
if (!i->second.connection->is_connecting() || c.is_local())
{
c.disconnect("duplicate connection, closing");
return false;
}
else
{
#if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING
m_torrent->debug_log("duplicate connection. existing connection"
" is connecting and this connection is incoming. closing existing "
"connection in favour of this one");
#endif
i->second.connection->disconnect("incoming duplicate connection "
"with higher priority, closing");
}
}
}
else
{
2007-07-10 19:25:10 +02:00
// we don't have any info about this peer.
// add a new entry
asio::error_code ec;
TORRENT_ASSERT(c.remote() == c.get_socket()->remote_endpoint(ec) || ec);
peer p(c.remote(), peer::not_connectable, 0);
2007-10-03 02:55:06 +02:00
i = m_peers.insert(std::make_pair(c.remote().address(), p));
#ifndef TORRENT_DISABLE_GEO_IP
int as = ses.as_for_ip(c.remote().address());
#ifndef NDEBUG
i->second.inet_as_num = as;
#endif
i->second.inet_as = ses.lookup_as(as);
#endif
}
2007-07-10 19:25:10 +02:00
c.set_peer_info(&i->second);
TORRENT_ASSERT(i->second.connection == 0);
c.add_stat(i->second.prev_amount_download, i->second.prev_amount_upload);
i->second.prev_amount_download = 0;
i->second.prev_amount_upload = 0;
i->second.connection = &c;
TORRENT_ASSERT(i->second.connection);
2007-10-15 07:03:29 +02:00
if (!c.fast_reconnect())
i->second.connected = time_now();
if (m_num_connect_candidates > 0)
--m_num_connect_candidates;
return true;
}
bool policy::update_peer_port(int port, policy::peer* p, int src)
{
TORRENT_ASSERT(p != 0);
TORRENT_ASSERT(p->connection);
if (p->ip.port() == port) return true;
if (m_torrent->settings().allow_multiple_connections_per_ip)
{
tcp::endpoint remote(p->ip.address(), port);
std::pair<iterator, iterator> range = m_peers.equal_range(remote.address());
iterator i = std::find_if(range.first, range.second
, match_peer_endpoint(remote));
if (i != m_peers.end())
{
policy::peer& pp = i->second;
if (pp.connection)
{
p->connection->disconnect("duplicate connection");
return false;
}
if (m_torrent->has_picker())
m_torrent->picker().clear_peer(&i->second);
if (i->second.seed) --m_num_seeds;
m_peers.erase(i);
}
}
else
{
TORRENT_ASSERT(m_peers.count(p->ip.address()) == 1);
}
p->ip.port(port);
p->source |= src;
return true;
}
bool policy::has_peer(policy::peer const* p) const
{
// find p in m_peers
for (std::multimap<address, peer>::const_iterator i = m_peers.begin()
, end(m_peers.end()); i != end; ++i)
{
if (&i->second == p) return true;
}
return false;
}
policy::peer* policy::peer_from_tracker(tcp::endpoint const& remote, peer_id const& pid
, int src, char flags)
{
2007-08-27 07:32:47 +02:00
// too expensive
// INVARIANT_CHECK;
2005-09-28 18:12:47 +02:00
// just ignore the obviously invalid entries
if (remote.address() == address() || remote.port() == 0)
2007-10-02 22:30:53 +02:00
return 0;
2004-01-16 17:19:27 +01:00
aux::session_impl& ses = m_torrent->session();
port_filter const& pf = ses.m_port_filter;
if (pf.access(remote.port()) & port_filter::blocked)
{
if (ses.m_alerts.should_post(alert::info))
{
ses.m_alerts.post_alert(peer_blocked_alert(remote.address()
, "outgoing port blocked, peer not added to peer list"));
}
2007-10-02 22:30:53 +02:00
return 0;
}
2003-10-27 17:06:00 +01:00
try
{
iterator i;
if (m_torrent->settings().allow_multiple_connections_per_ip)
{
std::pair<iterator, iterator> range = m_peers.equal_range(remote.address());
i = std::find_if(range.first, range.second, match_peer_endpoint(remote));
if (i == range.second) i = m_peers.end();
}
else
{
i = m_peers.find(remote.address());
}
2004-01-15 02:29:43 +01:00
if (i == m_peers.end())
{
// if the IP is blocked, don't add it
if (ses.m_ip_filter.access(remote.address()) & ip_filter::blocked)
{
if (ses.m_alerts.should_post(alert::info))
{
ses.m_alerts.post_alert(peer_blocked_alert(remote.address()
, "blocked peer not added to peer list"));
}
2007-10-02 22:30:53 +02:00
return 0;
}
2004-05-10 08:12:29 +02:00
// we don't have any info about this peer.
// add a new entry
2007-10-12 00:02:00 +02:00
i = m_peers.insert(std::make_pair(remote.address()
, peer(remote, peer::connectable, src)));
2007-06-06 02:41:20 +02:00
#ifndef TORRENT_DISABLE_ENCRYPTION
2007-10-12 00:02:00 +02:00
if (flags & 0x01) i->second.pe_support = true;
2007-06-06 02:41:20 +02:00
#endif
if (flags & 0x02)
{
i->second.seed = true;
++m_num_seeds;
}
#ifndef TORRENT_DISABLE_GEO_IP
int as = ses.as_for_ip(remote.address());
#ifndef NDEBUG
i->second.inet_as_num = as;
#endif
i->second.inet_as = ses.lookup_as(as);
#endif
}
2004-01-15 02:29:43 +01:00
else
{
i->second.type = peer::connectable;
2004-01-15 17:45:34 +01:00
i->second.ip = remote;
i->second.source |= src;
// if this peer has failed before, decrease the
// counter to allow it another try, since somebody
// else is appearantly able to connect to it
// only trust this if it comes from the tracker
if (i->second.failcount > 0 && src == peer_info::tracker)
--i->second.failcount;
// if we're connected to this peer
// we already know if it's a seed or not
// so we don't have to trust this source
if ((flags & 0x02) && !i->second.connection)
{
if (!i->second.seed) ++m_num_seeds;
i->second.seed = true;
}
2004-01-15 02:29:43 +01:00
#if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING
if (i->second.connection)
2004-01-15 02:29:43 +01:00
{
// this means we're already connected
// to this peer. don't connect to
// it again.
m_torrent->debug_log("already connected to peer: " + remote.address().to_string() + ":"
+ boost::lexical_cast<std::string>(remote.port()) + " "
+ boost::lexical_cast<std::string>(i->second.connection->pid()));
TORRENT_ASSERT(i->second.connection->associated_torrent().lock().get() == m_torrent);
2004-01-15 02:29:43 +01:00
}
2007-10-02 22:30:53 +02:00
#endif
}
if (is_connect_candidate(i->second, m_torrent->is_finished()))
++m_num_connect_candidates;
2007-10-02 22:30:53 +02:00
return &i->second;
2003-10-27 17:06:00 +01:00
}
catch(std::exception& e)
2004-01-12 04:05:10 +01:00
{
if (m_torrent->alerts().should_post(alert::debug))
{
m_torrent->alerts().post_alert(
peer_error_alert(remote, pid, e.what()));
2004-01-12 04:05:10 +01:00
}
}
2007-10-02 22:30:53 +02:00
return 0;
}
// this is called when we are choked by a peer
// i.e. a peer lets us know that we will not receive
// anything for a while
2005-04-24 02:50:52 +02:00
void policy::choked(peer_connection&)
{
}
2003-12-14 06:56:12 +01:00
void policy::piece_finished(int index, bool successfully_verified)
{
2005-09-28 18:12:47 +02:00
INVARIANT_CHECK;
TORRENT_ASSERT(index >= 0 && index < m_torrent->torrent_file().num_pieces());
2004-01-25 23:41:55 +01:00
2003-12-17 04:40:13 +01:00
if (successfully_verified)
{
// have all peers update their interested-flag
for (iterator i = m_peers.begin();
2005-08-18 22:38:03 +02:00
i != m_peers.end(); ++i)
2003-12-17 04:40:13 +01:00
{
if (i->second.connection == 0) continue;
2003-12-17 04:40:13 +01:00
// if we're not interested, we will not become interested
if (!i->second.connection->is_interesting()) continue;
if (!i->second.connection->has_piece(index)) continue;
2003-12-17 04:40:13 +01:00
i->second.connection->update_interest();
2003-12-17 04:40:13 +01:00
}
}
}
// this is called when we are unchoked by a peer
// i.e. a peer lets us know that we will receive
// data from now on
void policy::unchoked(peer_connection& c)
{
// INVARIANT_CHECK;
if (c.is_interesting())
{
request_a_block(*m_torrent, c);
}
}
2003-12-14 06:56:12 +01:00
// called when a peer is interested in us
2005-08-05 04:43:44 +02:00
void policy::interested(peer_connection& c)
{
// INVARIANT_CHECK;
2005-09-28 18:12:47 +02:00
TORRENT_ASSERT(std::find_if(m_peers.begin(), m_peers.end()
, boost::bind<bool>(std::equal_to<peer_connection*>(), bind(&peer::connection
, bind(&iterator::value_type::second, _1)), &c)) != m_peers.end());
2005-09-28 20:32:05 +02:00
aux::session_impl& ses = m_torrent->session();
2005-08-05 04:43:44 +02:00
// if the peer is choked and we have upload slots left,
// then unchoke it. Another condition that has to be met
// is that the torrent doesn't keep track of the individual
// up/down ratio for each peer (ratio == 0) or (if it does
// keep track) this particular connection isn't a leecher.
// If the peer was choked because it was leeching, don't
// unchoke it again.
// The exception to this last condition is if we're a seed.
// In that case we don't care if people are leeching, they
// can't pay for their downloads anyway.
if (c.is_choked()
&& ses.num_uploads() < ses.max_uploads()
&& (m_torrent->ratio() == 0
|| c.share_diff() >= -free_upload_amount
2007-09-04 00:57:09 +02:00
|| m_torrent->is_finished()))
2005-08-05 04:43:44 +02:00
{
ses.unchoke_peer(c);
}
#if defined TORRENT_VERBOSE_LOGGING
else if (c.is_choked())
{
std::string reason;
if (ses.num_uploads() >= ses.max_uploads())
{
reason = "the number of uploads ("
+ boost::lexical_cast<std::string>(ses.num_uploads())
+ ") is more than or equal to the limit ("
+ boost::lexical_cast<std::string>(ses.max_uploads())
+ ")";
}
else
{
reason = "the share ratio ("
+ boost::lexical_cast<std::string>(c.share_diff())
+ ") is <= free_upload_amount ("
+ boost::lexical_cast<std::string>(int(free_upload_amount))
+ ") and we are not seeding and the ratio ("
+ boost::lexical_cast<std::string>(m_torrent->ratio())
+ ")is non-zero";
}
(*c.m_logger) << time_now_string() << " DID NOT UNCHOKE [ " << reason << " ]\n";
2005-08-05 04:43:44 +02:00
}
#endif
2003-12-14 23:55:32 +01:00
}
2003-12-14 06:56:12 +01:00
// called when a peer is no longer interested in us
void policy::not_interested(peer_connection& c)
{
2005-09-28 18:12:47 +02:00
INVARIANT_CHECK;
2004-01-17 21:04:19 +01:00
if (m_torrent->ratio() != 0.f)
{
TORRENT_ASSERT(c.share_diff() < (std::numeric_limits<size_type>::max)());
size_type diff = c.share_diff();
2004-01-17 21:04:19 +01:00
if (diff > 0 && c.is_seed())
{
// the peer is a seed and has sent
// us more than we have sent it back.
// consider the download as free download
m_available_free_upload += diff;
c.add_free_upload(-diff);
}
}
/*
2004-03-21 03:03:37 +01:00
if (!c.is_choked())
{
c.send_choke();
--m_num_unchoked;
if (m_torrent->is_seed()) seed_unchoke_one_peer();
else unchoke_one_peer();
2004-03-21 03:03:37 +01:00
}
*/
2003-12-14 06:56:12 +01:00
}
/*
2003-12-14 06:56:12 +01:00
bool policy::unchoke_one_peer()
{
INVARIANT_CHECK;
iterator p = find_unchoke_candidate();
if (p == m_peers.end()) return false;
TORRENT_ASSERT(p->connection);
TORRENT_ASSERT(!p->connection->is_disconnecting());
2003-12-14 06:56:12 +01:00
TORRENT_ASSERT(p->connection->is_choked());
2004-01-12 21:31:27 +01:00
p->connection->send_unchoke();
p->last_optimistically_unchoked = time_now();
2003-12-14 06:56:12 +01:00
++m_num_unchoked;
return true;
}
2005-08-18 22:38:03 +02:00
void policy::choke_one_peer()
{
INVARIANT_CHECK;
iterator p = find_choke_candidate();
if (p == m_peers.end()) return;
TORRENT_ASSERT(p->connection);
TORRENT_ASSERT(!p->connection->is_disconnecting());
TORRENT_ASSERT(!p->connection->is_choked());
2005-08-18 22:38:03 +02:00
p->connection->send_choke();
--m_num_unchoked;
}
*/
2004-01-14 17:18:53 +01:00
bool policy::connect_one_peer()
{
// INVARIANT_CHECK;
TORRENT_ASSERT(m_torrent->want_more_peers());
iterator p = find_connect_candidate();
if (p == m_peers.end()) return false;
TORRENT_ASSERT(!p->second.banned);
TORRENT_ASSERT(!p->second.connection);
TORRENT_ASSERT(p->second.type == peer::connectable);
2004-02-25 14:18:41 +01:00
2004-02-26 19:55:10 +01:00
try
{
if (!m_torrent->connect_to_peer(&p->second))
{
++p->second.failcount;
return false;
}
p->second.connection->add_stat(p->second.prev_amount_download, p->second.prev_amount_upload);
p->second.prev_amount_download = 0;
p->second.prev_amount_upload = 0;
2004-02-26 19:55:10 +01:00
return true;
}
catch (std::exception& e)
{
#if defined TORRENT_LOGGING || defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING
(*m_torrent->session().m_logger) << "*** CONNECTION FAILED '"
<< e.what() << "'\n";
#endif
std::cerr << e.what() << std::endl;
++p->second.failcount;
return false;
}
2004-01-14 17:18:53 +01:00
}
2004-01-21 01:59:38 +01:00
bool policy::disconnect_one_peer()
{
iterator p = find_disconnect_candidate();
if (p == m_peers.end())
2004-01-21 01:59:38 +01:00
return false;
#if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING
(*p->second.connection->m_logger) << "*** CLOSING CONNECTION 'too many connections'\n";
#endif
p->second.connection->disconnect("too many connections, closing");
2004-01-21 01:59:38 +01:00
return true;
}
// this is called whenever a peer connection is closed
2007-08-17 01:53:14 +02:00
void policy::connection_closed(const peer_connection& c) throw()
{
2007-08-27 07:32:47 +02:00
// too expensive
// INVARIANT_CHECK;
2005-09-28 18:12:47 +02:00
2007-08-17 01:53:14 +02:00
peer* p = c.peer_info_struct();
TORRENT_ASSERT((std::find_if(
2004-01-15 17:45:34 +01:00
m_peers.begin()
, m_peers.end()
2007-08-17 01:53:14 +02:00
, match_peer_connection(c))
!= m_peers.end()) == (p != 0));
// if we couldn't find the connection in our list, just ignore it.
if (p == 0) return;
TORRENT_ASSERT(p->connection == &c);
2007-08-17 01:53:14 +02:00
p->connection = 0;
p->optimistically_unchoked = false;
2007-10-04 23:26:50 +02:00
// if fast reconnect is true, we won't
// update the timestamp, and it will remain
// the time when we initiated the connection.
if (!c.fast_reconnect())
p->connected = time_now();
2004-01-14 02:19:30 +01:00
2004-03-21 03:03:37 +01:00
if (c.failed())
{
2007-08-17 01:53:14 +02:00
++p->failcount;
// p->connected = time_now();
2004-03-21 03:03:37 +01:00
}
if (is_connect_candidate(*p, m_torrent->is_finished()))
++m_num_connect_candidates;
2004-01-14 02:19:30 +01:00
// if the share ratio is 0 (infinite), the
// m_available_free_upload isn't used,
// because it isn't necessary.
if (m_torrent->ratio() != 0.f)
{
TORRENT_ASSERT(c.associated_torrent().lock().get() == m_torrent);
TORRENT_ASSERT(c.share_diff() < (std::numeric_limits<size_type>::max)());
m_available_free_upload += c.share_diff();
2004-01-14 02:19:30 +01:00
}
2007-08-17 01:53:14 +02:00
p->prev_amount_download += c.statistics().total_payload_download();
p->prev_amount_upload += c.statistics().total_payload_upload();
}
2003-12-14 06:56:12 +01:00
void policy::peer_is_interesting(peer_connection& c)
{
// INVARIANT_CHECK;
2005-09-28 18:12:47 +02:00
2004-01-12 21:31:27 +01:00
c.send_interested();
if (c.has_peer_choked()
&& c.allowed_fast().empty())
return;
request_a_block(*m_torrent, c);
}
#ifndef NDEBUG
2004-01-15 02:29:43 +01:00
bool policy::has_connection(const peer_connection* c)
{
2007-08-21 21:18:06 +02:00
// too expensive
// INVARIANT_CHECK;
TORRENT_ASSERT(c);
try { TORRENT_ASSERT(c->remote() == c->get_socket()->remote_endpoint()); }
2007-08-21 21:04:27 +02:00
catch (std::exception&) {}
2004-01-15 17:45:34 +01:00
return std::find_if(
m_peers.begin()
, m_peers.end()
, match_peer_connection(*c)) != m_peers.end();
}
2003-12-14 06:56:12 +01:00
2004-05-10 08:12:29 +02:00
void policy::check_invariant() const
2003-12-14 06:56:12 +01:00
{
TORRENT_ASSERT(m_num_connect_candidates >= 0);
2005-05-12 01:14:58 +02:00
if (m_torrent->is_aborted()) return;
int connected_peers = 0;
int total_connections = 0;
int nonempty_connections = 0;
std::set<tcp::endpoint> unique_test;
for (const_iterator i = m_peers.begin();
i != m_peers.end(); ++i)
2003-12-14 06:56:12 +01:00
{
peer const& p = i->second;
#ifndef TORRENT_DISABLE_GEO_IP
TORRENT_ASSERT(p.inet_as == 0 || p.inet_as->first == p.inet_as_num);
#endif
if (!m_torrent->settings().allow_multiple_connections_per_ip)
{
TORRENT_ASSERT(m_peers.count(p.ip.address()) == 1);
}
else
{
TORRENT_ASSERT(unique_test.count(p.ip) == 0);
unique_test.insert(p.ip);
TORRENT_ASSERT(i->first == p.ip.address());
// TORRENT_ASSERT(p.connection == 0 || p.ip == p.connection->remote());
}
++total_connections;
if (!p.connection)
{
continue;
}
if (p.optimistically_unchoked)
{
TORRENT_ASSERT(p.connection);
TORRENT_ASSERT(!p.connection->is_choked());
}
TORRENT_ASSERT(p.connection->peer_info_struct() == 0
|| p.connection->peer_info_struct() == &p);
++nonempty_connections;
if (!p.connection->is_disconnecting())
++connected_peers;
2003-12-14 06:56:12 +01:00
}
int num_torrent_peers = 0;
for (torrent::const_peer_iterator i = m_torrent->begin();
i != m_torrent->end(); ++i)
{
if ((*i)->is_disconnecting()) continue;
// ignore web_peer_connections since they are not managed
// by the policy class
if (dynamic_cast<web_peer_connection*>(*i)) continue;
++num_torrent_peers;
}
if (m_torrent->has_picker())
{
piece_picker& p = m_torrent->picker();
std::vector<piece_picker::downloading_piece> downloaders = p.get_download_queue();
std::set<void*> peer_set;
std::vector<void*> peers;
for (std::vector<piece_picker::downloading_piece>::iterator i = downloaders.begin()
, end(downloaders.end()); i != end; ++i)
{
p.get_downloaders(peers, i->index);
std::copy(peers.begin(), peers.end()
, std::insert_iterator<std::set<void*> >(peer_set, peer_set.begin()));
}
for (std::set<void*>::iterator i = peer_set.begin()
, end(peer_set.end()); i != end; ++i)
{
policy::peer* p = static_cast<policy::peer*>(*i);
if (p == 0) continue;
2007-10-06 23:15:44 +02:00
if (p->connection == 0) continue;
TORRENT_ASSERT(std::find_if(m_peers.begin(), m_peers.end()
, match_peer_connection(*p->connection)) != m_peers.end());
}
}
// this invariant is a bit complicated.
// the usual case should be that connected_peers
// == num_torrent_peers. But when there's an incoming
// connection, it will first be added to the policy
// and then be added to the torrent.
// When there's an outgoing connection, it will first
// be added to the torrent and then to the policy.
// that's why the two second cases are in there.
/*
TORRENT_ASSERT(connected_peers == num_torrent_peers
|| (connected_peers == num_torrent_peers + 1
&& connected_peers > 0)
|| (connected_peers + 1 == num_torrent_peers
&& num_torrent_peers > 0));
*/
2003-12-14 06:56:12 +01:00
}
#endif
2003-12-14 06:56:12 +01:00
policy::peer::peer(const tcp::endpoint& ip_, peer::connection_type t, int src)
: ip(ip_)
#ifndef TORRENT_DISABLE_GEO_IP
, inet_as(0)
#endif
, failcount(0)
, trust_points(0)
, source(src)
2007-05-25 21:42:10 +02:00
, hashfails(0)
, type(t)
, fast_reconnects(0)
#ifndef TORRENT_DISABLE_ENCRYPTION
, pe_support(true)
#endif
, optimistically_unchoked(false)
, seed(false)
2007-05-25 21:42:10 +02:00
, on_parole(false)
2003-12-14 06:56:12 +01:00
, banned(false)
#ifndef TORRENT_DISABLE_DHT
, added_to_dht(false)
#endif
2004-01-14 17:18:53 +01:00
, connection(0)
, prev_amount_upload(0)
, prev_amount_download(0)
, last_optimistically_unchoked(min_time())
, connected(min_time())
2004-01-14 17:18:53 +01:00
{
TORRENT_ASSERT((src & 0xff) == src);
TORRENT_ASSERT(connected < time_now());
2004-01-14 17:18:53 +01:00
}
2003-12-14 06:56:12 +01:00
2004-01-21 01:59:38 +01:00
size_type policy::peer::total_download() const
2003-12-14 06:56:12 +01:00
{
if (connection != 0)
2004-01-15 17:45:34 +01:00
{
TORRENT_ASSERT(prev_amount_download == 0);
2004-02-25 00:55:42 +01:00
return connection->statistics().total_payload_download();
2004-01-15 17:45:34 +01:00
}
2003-12-14 06:56:12 +01:00
else
2004-01-15 17:45:34 +01:00
{
2003-12-14 06:56:12 +01:00
return prev_amount_download;
2004-01-15 17:45:34 +01:00
}
2003-12-14 06:56:12 +01:00
}
2004-01-21 01:59:38 +01:00
size_type policy::peer::total_upload() const
2003-12-14 06:56:12 +01:00
{
if (connection != 0)
2004-01-15 17:45:34 +01:00
{
TORRENT_ASSERT(prev_amount_upload == 0);
2004-02-25 00:55:42 +01:00
return connection->statistics().total_payload_upload();
2004-01-15 17:45:34 +01:00
}
2003-12-14 06:56:12 +01:00
else
2004-01-15 17:45:34 +01:00
{
2003-12-14 06:56:12 +01:00
return prev_amount_upload;
2004-01-15 17:45:34 +01:00
}
2003-12-14 06:56:12 +01:00
}
}
2005-08-18 22:38:03 +02:00