4094 lines
116 KiB
C
4094 lines
116 KiB
C
/*
|
|
* This file Copyright (C) Mnemosyne LLC
|
|
*
|
|
* This file is licensed by the GPL version 2. Works owned by the
|
|
* Transmission project are granted a special exemption to clause 2 (b)
|
|
* so that the bulk of its code can remain under the MIT license.
|
|
* This exemption does not extend to derived works not owned by
|
|
* the Transmission project.
|
|
*
|
|
* $Id$
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <errno.h> /* error codes ERANGE, ... */
|
|
#include <limits.h> /* INT_MAX */
|
|
#include <string.h> /* memcpy, memcmp, strstr */
|
|
#include <stdlib.h> /* qsort */
|
|
|
|
#include <event2/event.h>
|
|
|
|
#include <libutp/utp.h>
|
|
|
|
#include "transmission.h"
|
|
#include "announcer.h"
|
|
#include "bandwidth.h"
|
|
#include "blocklist.h"
|
|
#include "cache.h"
|
|
#include "clients.h"
|
|
#include "completion.h"
|
|
#include "crypto.h"
|
|
#include "handshake.h"
|
|
#include "net.h"
|
|
#include "peer-io.h"
|
|
#include "peer-mgr.h"
|
|
#include "peer-msgs.h"
|
|
#include "ptrarray.h"
|
|
#include "session.h"
|
|
#include "stats.h" /* tr_statsAddUploaded, tr_statsAddDownloaded */
|
|
#include "torrent.h"
|
|
#include "tr-utp.h"
|
|
#include "utils.h"
|
|
#include "webseed.h"
|
|
|
|
enum
|
|
{
|
|
/* how frequently to cull old atoms */
|
|
ATOM_PERIOD_MSEC = (60 * 1000),
|
|
|
|
/* how frequently to change which peers are choked */
|
|
RECHOKE_PERIOD_MSEC = (10 * 1000),
|
|
|
|
/* an optimistically unchoked peer is immune from rechoking
|
|
for this many calls to rechokeUploads (). */
|
|
OPTIMISTIC_UNCHOKE_MULTIPLIER = 4,
|
|
|
|
/* how frequently to reallocate bandwidth */
|
|
BANDWIDTH_PERIOD_MSEC = 500,
|
|
|
|
/* how frequently to age out old piece request lists */
|
|
REFILL_UPKEEP_PERIOD_MSEC = (10 * 1000),
|
|
|
|
/* how frequently to decide which peers live and die */
|
|
RECONNECT_PERIOD_MSEC = 500,
|
|
|
|
/* when many peers are available, keep idle ones this long */
|
|
MIN_UPLOAD_IDLE_SECS = (60),
|
|
|
|
/* when few peers are available, keep idle ones this long */
|
|
MAX_UPLOAD_IDLE_SECS = (60 * 5),
|
|
|
|
/* max number of peers to ask for per second overall.
|
|
* this throttle is to avoid overloading the router */
|
|
MAX_CONNECTIONS_PER_SECOND = 12,
|
|
|
|
MAX_CONNECTIONS_PER_PULSE = (int)(MAX_CONNECTIONS_PER_SECOND * (RECONNECT_PERIOD_MSEC/1000.0)),
|
|
|
|
/* number of bad pieces a peer is allowed to send before we ban them */
|
|
MAX_BAD_PIECES_PER_PEER = 5,
|
|
|
|
/* amount of time to keep a list of request pieces lying around
|
|
before it's considered too old and needs to be rebuilt */
|
|
PIECE_LIST_SHELF_LIFE_SECS = 60,
|
|
|
|
/* use for bitwise operations w/peer_atom.flags2 */
|
|
MYFLAG_BANNED = 1,
|
|
|
|
/* use for bitwise operations w/peer_atom.flags2 */
|
|
/* unreachable for now... but not banned.
|
|
* if they try to connect to us it's okay */
|
|
MYFLAG_UNREACHABLE = 2,
|
|
|
|
/* the minimum we'll wait before attempting to reconnect to a peer */
|
|
MINIMUM_RECONNECT_INTERVAL_SECS = 5,
|
|
|
|
/** how long we'll let requests we've made linger before we cancel them */
|
|
REQUEST_TTL_SECS = 120,
|
|
|
|
NO_BLOCKS_CANCEL_HISTORY = 120,
|
|
|
|
CANCEL_HISTORY_SEC = 60
|
|
};
|
|
|
|
const tr_peer_event TR_PEER_EVENT_INIT = { 0, 0, NULL, 0, 0, 0, false, 0 };
|
|
|
|
/**
|
|
***
|
|
**/
|
|
|
|
/**
|
|
* Peer information that should be kept even before we've connected and
|
|
* after we've disconnected. These are kept in a pool of peer_atoms to decide
|
|
* which ones would make good candidates for connecting to, and to watch out
|
|
* for banned peers.
|
|
*
|
|
* @see tr_peer
|
|
* @see tr_peermsgs
|
|
*/
|
|
struct peer_atom
|
|
{
|
|
uint8_t fromFirst; /* where the peer was first found */
|
|
uint8_t fromBest; /* the "best" value of where the peer has been found */
|
|
uint8_t flags; /* these match the added_f flags */
|
|
uint8_t flags2; /* flags that aren't defined in added_f */
|
|
int8_t seedProbability; /* how likely is this to be a seed... [0..100] or -1 for unknown */
|
|
int8_t blocklisted; /* -1 for unknown, true for blocklisted, false for not blocklisted */
|
|
|
|
tr_port port;
|
|
bool utp_failed; /* We recently failed to connect over uTP */
|
|
uint16_t numFails;
|
|
time_t time; /* when the peer's connection status last changed */
|
|
time_t piece_data_time;
|
|
|
|
time_t lastConnectionAttemptAt;
|
|
time_t lastConnectionAt;
|
|
|
|
/* similar to a TTL field, but less rigid --
|
|
* if the swarm is small, the atom will be kept past this date. */
|
|
time_t shelf_date;
|
|
tr_peer * peer; /* will be NULL if not connected */
|
|
tr_address addr;
|
|
};
|
|
|
|
#ifdef NDEBUG
|
|
#define tr_isAtom(a) (TRUE)
|
|
#else
|
|
static bool
|
|
tr_isAtom (const struct peer_atom * atom)
|
|
{
|
|
return (atom != NULL)
|
|
&& (atom->fromFirst < TR_PEER_FROM__MAX)
|
|
&& (atom->fromBest < TR_PEER_FROM__MAX)
|
|
&& (tr_address_is_valid (&atom->addr));
|
|
}
|
|
#endif
|
|
|
|
static const char*
|
|
tr_atomAddrStr (const struct peer_atom * atom)
|
|
{
|
|
return atom ? tr_peerIoAddrStr (&atom->addr, atom->port) : "[no atom]";
|
|
}
|
|
|
|
struct block_request
|
|
{
|
|
tr_block_index_t block;
|
|
tr_peer * peer;
|
|
time_t sentAt;
|
|
};
|
|
|
|
struct weighted_piece
|
|
{
|
|
tr_piece_index_t index;
|
|
int16_t salt;
|
|
int16_t requestCount;
|
|
};
|
|
|
|
enum piece_sort_state
|
|
{
|
|
PIECES_UNSORTED,
|
|
PIECES_SORTED_BY_INDEX,
|
|
PIECES_SORTED_BY_WEIGHT
|
|
};
|
|
|
|
/** @brief Opaque, per-torrent data structure for peer connection information */
|
|
typedef struct tr_torrent_peers
|
|
{
|
|
tr_ptrArray outgoingHandshakes; /* tr_handshake */
|
|
tr_ptrArray pool; /* struct peer_atom */
|
|
tr_ptrArray peers; /* tr_peer */
|
|
tr_ptrArray webseeds; /* tr_webseed */
|
|
|
|
tr_torrent * tor;
|
|
struct tr_peerMgr * manager;
|
|
|
|
tr_peer * optimistic; /* the optimistic peer, or NULL if none */
|
|
int optimisticUnchokeTimeScaler;
|
|
|
|
bool isRunning;
|
|
bool needsCompletenessCheck;
|
|
|
|
struct block_request * requests;
|
|
int requestCount;
|
|
int requestAlloc;
|
|
|
|
struct weighted_piece * pieces;
|
|
int pieceCount;
|
|
enum piece_sort_state pieceSortState;
|
|
|
|
/* An array of pieceCount items stating how many peers have each piece.
|
|
This is used to help us for downloading pieces "rarest first."
|
|
This may be NULL if we don't have metainfo yet, or if we're not
|
|
downloading and don't care about rarity */
|
|
uint16_t * pieceReplication;
|
|
size_t pieceReplicationSize;
|
|
|
|
int interestedCount;
|
|
int maxPeers;
|
|
time_t lastCancel;
|
|
|
|
/* Before the endgame this should be 0. In endgame, is contains the average
|
|
* number of pending requests per peer. Only peers which have more pending
|
|
* requests are considered 'fast' are allowed to request a block that's
|
|
* already been requested from another (slower?) peer. */
|
|
int endgame;
|
|
}
|
|
Torrent;
|
|
|
|
struct tr_peerMgr
|
|
{
|
|
tr_session * session;
|
|
tr_ptrArray incomingHandshakes; /* tr_handshake */
|
|
struct event * bandwidthTimer;
|
|
struct event * rechokeTimer;
|
|
struct event * refillUpkeepTimer;
|
|
struct event * atomTimer;
|
|
};
|
|
|
|
#define tordbg(t, ...) \
|
|
do \
|
|
{ \
|
|
if (tr_deepLoggingIsActive ()) \
|
|
tr_deepLog (__FILE__, __LINE__, tr_torrentName (t->tor), __VA_ARGS__); \
|
|
} \
|
|
while (0)
|
|
|
|
#define dbgmsg(...) \
|
|
do \
|
|
{ \
|
|
if (tr_deepLoggingIsActive ()) \
|
|
tr_deepLog (__FILE__, __LINE__, NULL, __VA_ARGS__); \
|
|
} \
|
|
while (0)
|
|
|
|
/**
|
|
***
|
|
**/
|
|
|
|
static inline void
|
|
managerLock (const struct tr_peerMgr * manager)
|
|
{
|
|
tr_sessionLock (manager->session);
|
|
}
|
|
|
|
static inline void
|
|
managerUnlock (const struct tr_peerMgr * manager)
|
|
{
|
|
tr_sessionUnlock (manager->session);
|
|
}
|
|
|
|
static inline void
|
|
torrentLock (Torrent * torrent)
|
|
{
|
|
managerLock (torrent->manager);
|
|
}
|
|
|
|
static inline void
|
|
torrentUnlock (Torrent * torrent)
|
|
{
|
|
managerUnlock (torrent->manager);
|
|
}
|
|
|
|
static inline int
|
|
torrentIsLocked (const Torrent * t)
|
|
{
|
|
return tr_sessionIsLocked (t->manager->session);
|
|
}
|
|
|
|
/**
|
|
***
|
|
**/
|
|
|
|
static int
|
|
handshakeCompareToAddr (const void * va, const void * vb)
|
|
{
|
|
const tr_handshake * a = va;
|
|
|
|
return tr_address_compare (tr_handshakeGetAddr (a, NULL), vb);
|
|
}
|
|
|
|
static int
|
|
handshakeCompare (const void * a, const void * b)
|
|
{
|
|
return handshakeCompareToAddr (a, tr_handshakeGetAddr (b, NULL));
|
|
}
|
|
|
|
static inline tr_handshake*
|
|
getExistingHandshake (tr_ptrArray * handshakes, const tr_address * addr)
|
|
{
|
|
if (tr_ptrArrayEmpty (handshakes))
|
|
return NULL;
|
|
|
|
return tr_ptrArrayFindSorted (handshakes, addr, handshakeCompareToAddr);
|
|
}
|
|
|
|
static int
|
|
comparePeerAtomToAddress (const void * va, const void * vb)
|
|
{
|
|
const struct peer_atom * a = va;
|
|
|
|
return tr_address_compare (&a->addr, vb);
|
|
}
|
|
|
|
static int
|
|
compareAtomsByAddress (const void * va, const void * vb)
|
|
{
|
|
const struct peer_atom * b = vb;
|
|
|
|
assert (tr_isAtom (b));
|
|
|
|
return comparePeerAtomToAddress (va, &b->addr);
|
|
}
|
|
|
|
/**
|
|
***
|
|
**/
|
|
|
|
const tr_address *
|
|
tr_peerAddress (const tr_peer * peer)
|
|
{
|
|
return &peer->atom->addr;
|
|
}
|
|
|
|
static Torrent*
|
|
getExistingTorrent (tr_peerMgr * manager,
|
|
const uint8_t * hash)
|
|
{
|
|
tr_torrent * tor = tr_torrentFindFromHash (manager->session, hash);
|
|
|
|
return tor == NULL ? NULL : tor->torrentPeers;
|
|
}
|
|
|
|
static int
|
|
peerCompare (const void * a, const void * b)
|
|
{
|
|
return tr_address_compare (tr_peerAddress (a), tr_peerAddress (b));
|
|
}
|
|
|
|
static struct peer_atom*
|
|
getExistingAtom (const Torrent * t,
|
|
const tr_address * addr)
|
|
{
|
|
Torrent * tt = (Torrent*)t;
|
|
return tr_ptrArrayFindSorted (&tt->pool, addr, comparePeerAtomToAddress);
|
|
}
|
|
|
|
static bool
|
|
peerIsInUse (const Torrent * ct, const struct peer_atom * atom)
|
|
{
|
|
Torrent * t = (Torrent*) ct;
|
|
|
|
assert (torrentIsLocked (t));
|
|
|
|
return (atom->peer != NULL)
|
|
|| getExistingHandshake (&t->outgoingHandshakes, &atom->addr)
|
|
|| getExistingHandshake (&t->manager->incomingHandshakes, &atom->addr);
|
|
}
|
|
|
|
void
|
|
tr_peerConstruct (tr_peer * peer)
|
|
{
|
|
memset (peer, 0, sizeof (tr_peer));
|
|
|
|
peer->have = TR_BITFIELD_INIT;
|
|
}
|
|
|
|
static tr_peer*
|
|
peerNew (struct peer_atom * atom)
|
|
{
|
|
tr_peer * peer = tr_new (tr_peer, 1);
|
|
tr_peerConstruct (peer);
|
|
|
|
peer->atom = atom;
|
|
atom->peer = peer;
|
|
|
|
return peer;
|
|
}
|
|
|
|
static tr_peer*
|
|
getPeer (Torrent * torrent, struct peer_atom * atom)
|
|
{
|
|
tr_peer * peer;
|
|
|
|
assert (torrentIsLocked (torrent));
|
|
|
|
peer = atom->peer;
|
|
|
|
if (peer == NULL)
|
|
{
|
|
peer = peerNew (atom);
|
|
tr_bitfieldConstruct (&peer->have, torrent->tor->info.pieceCount);
|
|
tr_bitfieldConstruct (&peer->blame, torrent->tor->blockCount);
|
|
tr_ptrArrayInsertSorted (&torrent->peers, peer, peerCompare);
|
|
}
|
|
|
|
return peer;
|
|
}
|
|
|
|
static void peerDeclinedAllRequests (Torrent *, const tr_peer *);
|
|
|
|
void
|
|
tr_peerDestruct (tr_torrent * tor, tr_peer * peer)
|
|
{
|
|
assert (peer != NULL);
|
|
|
|
peerDeclinedAllRequests (tor->torrentPeers, peer);
|
|
|
|
if (peer->msgs != NULL)
|
|
tr_peerMsgsFree (peer->msgs);
|
|
|
|
if (peer->io) {
|
|
tr_peerIoClear (peer->io);
|
|
tr_peerIoUnref (peer->io); /* balanced by the ref in handshakeDoneCB () */
|
|
}
|
|
|
|
tr_bitfieldDestruct (&peer->have);
|
|
tr_bitfieldDestruct (&peer->blame);
|
|
|
|
if (peer->atom)
|
|
peer->atom->peer = NULL;
|
|
}
|
|
|
|
static void
|
|
peerDelete (Torrent * t, tr_peer * peer)
|
|
{
|
|
tr_peerDestruct (t->tor, peer);
|
|
tr_free (peer);
|
|
}
|
|
|
|
static bool
|
|
replicationExists (const Torrent * t)
|
|
{
|
|
return t->pieceReplication != NULL;
|
|
}
|
|
|
|
static void
|
|
replicationFree (Torrent * t)
|
|
{
|
|
tr_free (t->pieceReplication);
|
|
t->pieceReplication = NULL;
|
|
t->pieceReplicationSize = 0;
|
|
}
|
|
|
|
static void
|
|
replicationNew (Torrent * t)
|
|
{
|
|
tr_piece_index_t piece_i;
|
|
const tr_piece_index_t piece_count = t->tor->info.pieceCount;
|
|
tr_peer ** peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
|
|
const int peer_count = tr_ptrArraySize (&t->peers);
|
|
|
|
assert (!replicationExists (t));
|
|
|
|
t->pieceReplicationSize = piece_count;
|
|
t->pieceReplication = tr_new0 (uint16_t, piece_count);
|
|
|
|
for (piece_i=0; piece_i<piece_count; ++piece_i)
|
|
{
|
|
int peer_i;
|
|
uint16_t r = 0;
|
|
|
|
for (peer_i=0; peer_i<peer_count; ++peer_i)
|
|
if (tr_bitfieldHas (&peers[peer_i]->have, piece_i))
|
|
++r;
|
|
|
|
t->pieceReplication[piece_i] = r;
|
|
}
|
|
}
|
|
|
|
static void
|
|
torrentFree (void * vt)
|
|
{
|
|
Torrent * t = vt;
|
|
|
|
assert (t);
|
|
assert (!t->isRunning);
|
|
assert (torrentIsLocked (t));
|
|
assert (tr_ptrArrayEmpty (&t->outgoingHandshakes));
|
|
assert (tr_ptrArrayEmpty (&t->peers));
|
|
|
|
tr_ptrArrayDestruct (&t->webseeds, (PtrArrayForeachFunc)tr_webseedFree);
|
|
tr_ptrArrayDestruct (&t->pool, (PtrArrayForeachFunc)tr_free);
|
|
tr_ptrArrayDestruct (&t->outgoingHandshakes, NULL);
|
|
tr_ptrArrayDestruct (&t->peers, NULL);
|
|
|
|
replicationFree (t);
|
|
|
|
tr_free (t->requests);
|
|
tr_free (t->pieces);
|
|
tr_free (t);
|
|
}
|
|
|
|
static void peerCallbackFunc (tr_peer *, const tr_peer_event *, void *);
|
|
|
|
static void
|
|
rebuildWebseedArray (Torrent * t, tr_torrent * tor)
|
|
{
|
|
unsigned int i;
|
|
const tr_info * inf = &tor->info;
|
|
|
|
/* clear the array */
|
|
tr_ptrArrayDestruct (&t->webseeds, (PtrArrayForeachFunc)tr_webseedFree);
|
|
t->webseeds = TR_PTR_ARRAY_INIT;
|
|
|
|
/* repopulate it */
|
|
for (i = 0; i < inf->webseedCount; ++i)
|
|
{
|
|
tr_webseed * w = tr_webseedNew (tor, inf->webseeds[i], peerCallbackFunc, t);
|
|
tr_ptrArrayAppend (&t->webseeds, w);
|
|
}
|
|
}
|
|
|
|
static Torrent*
|
|
torrentNew (tr_peerMgr * manager, tr_torrent * tor)
|
|
{
|
|
Torrent * t;
|
|
|
|
t = tr_new0 (Torrent, 1);
|
|
t->manager = manager;
|
|
t->tor = tor;
|
|
t->pool = TR_PTR_ARRAY_INIT;
|
|
t->peers = TR_PTR_ARRAY_INIT;
|
|
t->webseeds = TR_PTR_ARRAY_INIT;
|
|
t->outgoingHandshakes = TR_PTR_ARRAY_INIT;
|
|
|
|
rebuildWebseedArray (t, tor);
|
|
|
|
return t;
|
|
}
|
|
|
|
static void ensureMgrTimersExist (struct tr_peerMgr * m);
|
|
|
|
tr_peerMgr*
|
|
tr_peerMgrNew (tr_session * session)
|
|
{
|
|
tr_peerMgr * m = tr_new0 (tr_peerMgr, 1);
|
|
m->session = session;
|
|
m->incomingHandshakes = TR_PTR_ARRAY_INIT;
|
|
ensureMgrTimersExist (m);
|
|
return m;
|
|
}
|
|
|
|
static void
|
|
deleteTimer (struct event ** t)
|
|
{
|
|
if (*t != NULL)
|
|
{
|
|
event_free (*t);
|
|
*t = NULL;
|
|
}
|
|
}
|
|
|
|
static void
|
|
deleteTimers (struct tr_peerMgr * m)
|
|
{
|
|
deleteTimer (&m->atomTimer);
|
|
deleteTimer (&m->bandwidthTimer);
|
|
deleteTimer (&m->rechokeTimer);
|
|
deleteTimer (&m->refillUpkeepTimer);
|
|
}
|
|
|
|
void
|
|
tr_peerMgrFree (tr_peerMgr * manager)
|
|
{
|
|
managerLock (manager);
|
|
|
|
deleteTimers (manager);
|
|
|
|
/* free the handshakes. Abort invokes handshakeDoneCB (), which removes
|
|
* the item from manager->handshakes, so this is a little roundabout... */
|
|
while (!tr_ptrArrayEmpty (&manager->incomingHandshakes))
|
|
tr_handshakeAbort (tr_ptrArrayNth (&manager->incomingHandshakes, 0));
|
|
|
|
tr_ptrArrayDestruct (&manager->incomingHandshakes, NULL);
|
|
|
|
managerUnlock (manager);
|
|
tr_free (manager);
|
|
}
|
|
|
|
static int
|
|
clientIsDownloadingFrom (const tr_torrent * tor, const tr_peer * peer)
|
|
{
|
|
if (!tr_torrentHasMetadata (tor))
|
|
return true;
|
|
|
|
return peer->clientIsInterested && !peer->clientIsChoked;
|
|
}
|
|
|
|
static int
|
|
clientIsUploadingTo (const tr_peer * peer)
|
|
{
|
|
return peer->peerIsInterested && !peer->peerIsChoked;
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
void
|
|
tr_peerMgrOnBlocklistChanged (tr_peerMgr * mgr)
|
|
{
|
|
tr_torrent * tor = NULL;
|
|
tr_session * session = mgr->session;
|
|
|
|
/* we cache whether or not a peer is blocklisted...
|
|
since the blocklist has changed, erase that cached value */
|
|
while ((tor = tr_torrentNext (session, tor)))
|
|
{
|
|
int i;
|
|
Torrent * t = tor->torrentPeers;
|
|
const int n = tr_ptrArraySize (&t->pool);
|
|
for (i=0; i<n; ++i) {
|
|
struct peer_atom * atom = tr_ptrArrayNth (&t->pool, i);
|
|
atom->blocklisted = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool
|
|
isAtomBlocklisted (tr_session * session, struct peer_atom * atom)
|
|
{
|
|
if (atom->blocklisted < 0)
|
|
atom->blocklisted = tr_sessionIsAddressBlocked (session, &atom->addr);
|
|
|
|
assert (tr_isBool (atom->blocklisted));
|
|
return atom->blocklisted;
|
|
}
|
|
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
static void
|
|
atomSetSeedProbability (struct peer_atom * atom, int seedProbability)
|
|
{
|
|
assert (atom != NULL);
|
|
assert (-1<=seedProbability && seedProbability<=100);
|
|
|
|
atom->seedProbability = seedProbability;
|
|
|
|
if (seedProbability == 100)
|
|
atom->flags |= ADDED_F_SEED_FLAG;
|
|
else if (seedProbability != -1)
|
|
atom->flags &= ~ADDED_F_SEED_FLAG;
|
|
}
|
|
|
|
static inline bool
|
|
atomIsSeed (const struct peer_atom * atom)
|
|
{
|
|
return atom->seedProbability == 100;
|
|
}
|
|
|
|
static void
|
|
atomSetSeed (const Torrent * t, struct peer_atom * atom)
|
|
{
|
|
if (!atomIsSeed (atom))
|
|
{
|
|
tordbg (t, "marking peer %s as a seed", tr_atomAddrStr (atom));
|
|
|
|
atomSetSeedProbability (atom, 100);
|
|
}
|
|
}
|
|
|
|
|
|
bool
|
|
tr_peerMgrPeerIsSeed (const tr_torrent * tor,
|
|
const tr_address * addr)
|
|
{
|
|
bool isSeed = false;
|
|
const Torrent * t = tor->torrentPeers;
|
|
const struct peer_atom * atom = getExistingAtom (t, addr);
|
|
|
|
if (atom)
|
|
isSeed = atomIsSeed (atom);
|
|
|
|
return isSeed;
|
|
}
|
|
|
|
void
|
|
tr_peerMgrSetUtpSupported (tr_torrent * tor, const tr_address * addr)
|
|
{
|
|
struct peer_atom * atom = getExistingAtom (tor->torrentPeers, addr);
|
|
|
|
if (atom)
|
|
atom->flags |= ADDED_F_UTP_FLAGS;
|
|
}
|
|
|
|
void
|
|
tr_peerMgrSetUtpFailed (tr_torrent *tor, const tr_address *addr, bool failed)
|
|
{
|
|
struct peer_atom * atom = getExistingAtom (tor->torrentPeers, addr);
|
|
|
|
if (atom)
|
|
atom->utp_failed = failed;
|
|
}
|
|
|
|
|
|
/**
|
|
*** REQUESTS
|
|
***
|
|
*** There are two data structures associated with managing block requests:
|
|
***
|
|
*** 1. Torrent::requests, an array of "struct block_request" which keeps
|
|
*** track of which blocks have been requested, and when, and by which peers.
|
|
*** This is list is used for (a) cancelling requests that have been pending
|
|
*** for too long and (b) avoiding duplicate requests before endgame.
|
|
***
|
|
*** 2. Torrent::pieces, an array of "struct weighted_piece" which lists the
|
|
*** pieces that we want to request. It's used to decide which blocks to
|
|
*** return next when tr_peerMgrGetBlockRequests () is called.
|
|
**/
|
|
|
|
/**
|
|
*** struct block_request
|
|
**/
|
|
|
|
static int
|
|
compareReqByBlock (const void * va, const void * vb)
|
|
{
|
|
const struct block_request * a = va;
|
|
const struct block_request * b = vb;
|
|
|
|
/* primary key: block */
|
|
if (a->block < b->block) return -1;
|
|
if (a->block > b->block) return 1;
|
|
|
|
/* secondary key: peer */
|
|
if (a->peer < b->peer) return -1;
|
|
if (a->peer > b->peer) return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
requestListAdd (Torrent * t, tr_block_index_t block, tr_peer * peer)
|
|
{
|
|
struct block_request key;
|
|
|
|
/* ensure enough room is available... */
|
|
if (t->requestCount + 1 >= t->requestAlloc)
|
|
{
|
|
const int CHUNK_SIZE = 128;
|
|
t->requestAlloc += CHUNK_SIZE;
|
|
t->requests = tr_renew (struct block_request,
|
|
t->requests, t->requestAlloc);
|
|
}
|
|
|
|
/* populate the record we're inserting */
|
|
key.block = block;
|
|
key.peer = peer;
|
|
key.sentAt = tr_time ();
|
|
|
|
/* insert the request to our array... */
|
|
{
|
|
bool exact;
|
|
const int pos = tr_lowerBound (&key, t->requests, t->requestCount,
|
|
sizeof (struct block_request),
|
|
compareReqByBlock, &exact);
|
|
assert (!exact);
|
|
memmove (t->requests + pos + 1,
|
|
t->requests + pos,
|
|
sizeof (struct block_request) * (t->requestCount++ - pos));
|
|
t->requests[pos] = key;
|
|
}
|
|
|
|
if (peer != NULL)
|
|
{
|
|
++peer->pendingReqsToPeer;
|
|
assert (peer->pendingReqsToPeer >= 0);
|
|
}
|
|
|
|
/*fprintf (stderr, "added request of block %lu from peer %s... "
|
|
"there are now %d block\n",
|
|
(unsigned long)block, tr_atomAddrStr (peer->atom), t->requestCount);*/
|
|
}
|
|
|
|
static struct block_request *
|
|
requestListLookup (Torrent * t, tr_block_index_t block, const tr_peer * peer)
|
|
{
|
|
struct block_request key;
|
|
key.block = block;
|
|
key.peer = (tr_peer*) peer;
|
|
|
|
return bsearch (&key, t->requests, t->requestCount,
|
|
sizeof (struct block_request),
|
|
compareReqByBlock);
|
|
}
|
|
|
|
/**
|
|
* Find the peers are we currently requesting the block
|
|
* with index @a block from and append them to @a peerArr.
|
|
*/
|
|
static void
|
|
getBlockRequestPeers (Torrent * t, tr_block_index_t block,
|
|
tr_ptrArray * peerArr)
|
|
{
|
|
bool exact;
|
|
int i, pos;
|
|
struct block_request key;
|
|
|
|
key.block = block;
|
|
key.peer = NULL;
|
|
pos = tr_lowerBound (&key, t->requests, t->requestCount,
|
|
sizeof (struct block_request),
|
|
compareReqByBlock, &exact);
|
|
|
|
assert (!exact); /* shouldn't have a request with .peer == NULL */
|
|
|
|
for (i = pos; i < t->requestCount; ++i)
|
|
{
|
|
if (t->requests[i].block != block)
|
|
break;
|
|
tr_ptrArrayAppend (peerArr, t->requests[i].peer);
|
|
}
|
|
}
|
|
|
|
static void
|
|
decrementPendingReqCount (const struct block_request * b)
|
|
{
|
|
if (b->peer != NULL)
|
|
if (b->peer->pendingReqsToPeer > 0)
|
|
--b->peer->pendingReqsToPeer;
|
|
}
|
|
|
|
static void
|
|
requestListRemove (Torrent * t, tr_block_index_t block, const tr_peer * peer)
|
|
{
|
|
const struct block_request * b = requestListLookup (t, block, peer);
|
|
if (b != NULL)
|
|
{
|
|
const int pos = b - t->requests;
|
|
assert (pos < t->requestCount);
|
|
|
|
decrementPendingReqCount (b);
|
|
|
|
tr_removeElementFromArray (t->requests,
|
|
pos,
|
|
sizeof (struct block_request),
|
|
t->requestCount--);
|
|
|
|
/*fprintf (stderr, "removing request of block %lu from peer %s... "
|
|
"there are now %d block requests left\n",
|
|
(unsigned long)block, tr_atomAddrStr (peer->atom), t->requestCount);*/
|
|
}
|
|
}
|
|
|
|
static int
|
|
countActiveWebseeds (const Torrent * t)
|
|
{
|
|
int activeCount = 0;
|
|
const tr_webseed ** w = (const tr_webseed **) tr_ptrArrayBase (&t->webseeds);
|
|
const tr_webseed ** const wend = w + tr_ptrArraySize (&t->webseeds);
|
|
|
|
for (; w!=wend; ++w)
|
|
if (tr_webseedIsActive (*w))
|
|
++activeCount;
|
|
|
|
return activeCount;
|
|
}
|
|
|
|
static bool
|
|
testForEndgame (const Torrent * t)
|
|
{
|
|
/* we consider ourselves to be in endgame if the number of bytes
|
|
we've got requested is >= the number of bytes left to download */
|
|
return (t->requestCount * t->tor->blockSize)
|
|
>= tr_cpLeftUntilDone (&t->tor->completion);
|
|
}
|
|
|
|
static void
|
|
updateEndgame (Torrent * t)
|
|
{
|
|
assert (t->requestCount >= 0);
|
|
|
|
if (!testForEndgame (t))
|
|
{
|
|
/* not in endgame */
|
|
t->endgame = 0;
|
|
}
|
|
else if (!t->endgame) /* only recalculate when endgame first begins */
|
|
{
|
|
int numDownloading = 0;
|
|
const tr_peer ** p = (const tr_peer **) tr_ptrArrayBase (&t->peers);
|
|
const tr_peer ** const pend = p + tr_ptrArraySize (&t->peers);
|
|
|
|
/* add the active bittorrent peers... */
|
|
for (; p!=pend; ++p)
|
|
if ((*p)->pendingReqsToPeer > 0)
|
|
++numDownloading;
|
|
|
|
/* add the active webseeds... */
|
|
numDownloading += countActiveWebseeds (t);
|
|
|
|
/* average number of pending requests per downloading peer */
|
|
t->endgame = t->requestCount / MAX (numDownloading, 1);
|
|
}
|
|
}
|
|
|
|
|
|
/****
|
|
*****
|
|
***** Piece List Manipulation / Accessors
|
|
*****
|
|
****/
|
|
|
|
static inline void
|
|
invalidatePieceSorting (Torrent * t)
|
|
{
|
|
t->pieceSortState = PIECES_UNSORTED;
|
|
}
|
|
|
|
static const tr_torrent * weightTorrent;
|
|
|
|
static const uint16_t * weightReplication;
|
|
|
|
static void
|
|
setComparePieceByWeightTorrent (Torrent * t)
|
|
{
|
|
if (!replicationExists (t))
|
|
replicationNew (t);
|
|
|
|
weightTorrent = t->tor;
|
|
weightReplication = t->pieceReplication;
|
|
}
|
|
|
|
/* we try to create a "weight" s.t. high-priority pieces come before others,
|
|
* and that partially-complete pieces come before empty ones. */
|
|
static int
|
|
comparePieceByWeight (const void * va, const void * vb)
|
|
{
|
|
const struct weighted_piece * a = va;
|
|
const struct weighted_piece * b = vb;
|
|
int ia, ib, missing, pending;
|
|
const tr_torrent * tor = weightTorrent;
|
|
const uint16_t * rep = weightReplication;
|
|
|
|
/* primary key: weight */
|
|
missing = tr_cpMissingBlocksInPiece (&tor->completion, a->index);
|
|
pending = a->requestCount;
|
|
ia = missing > pending ? missing - pending : (tor->blockCountInPiece + pending);
|
|
missing = tr_cpMissingBlocksInPiece (&tor->completion, b->index);
|
|
pending = b->requestCount;
|
|
ib = missing > pending ? missing - pending : (tor->blockCountInPiece + pending);
|
|
if (ia < ib) return -1;
|
|
if (ia > ib) return 1;
|
|
|
|
/* secondary key: higher priorities go first */
|
|
ia = tor->info.pieces[a->index].priority;
|
|
ib = tor->info.pieces[b->index].priority;
|
|
if (ia > ib) return -1;
|
|
if (ia < ib) return 1;
|
|
|
|
/* tertiary key: rarest first. */
|
|
ia = rep[a->index];
|
|
ib = rep[b->index];
|
|
if (ia < ib) return -1;
|
|
if (ia > ib) return 1;
|
|
|
|
/* quaternary key: random */
|
|
if (a->salt < b->salt) return -1;
|
|
if (a->salt > b->salt) return 1;
|
|
|
|
/* okay, they're equal */
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
comparePieceByIndex (const void * va, const void * vb)
|
|
{
|
|
const struct weighted_piece * a = va;
|
|
const struct weighted_piece * b = vb;
|
|
if (a->index < b->index) return -1;
|
|
if (a->index > b->index) return 1;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
pieceListSort (Torrent * t, enum piece_sort_state state)
|
|
{
|
|
assert (state==PIECES_SORTED_BY_INDEX
|
|
|| state==PIECES_SORTED_BY_WEIGHT);
|
|
|
|
|
|
if (state == PIECES_SORTED_BY_WEIGHT)
|
|
{
|
|
setComparePieceByWeightTorrent (t);
|
|
qsort (t->pieces, t->pieceCount, sizeof (struct weighted_piece), comparePieceByWeight);
|
|
}
|
|
else
|
|
qsort (t->pieces, t->pieceCount, sizeof (struct weighted_piece), comparePieceByIndex);
|
|
|
|
t->pieceSortState = state;
|
|
}
|
|
|
|
/**
|
|
* These functions are useful for testing, but too expensive for nightly builds.
|
|
* let's leave it disabled but add an easy hook to compile it back in
|
|
*/
|
|
#if 1
|
|
#define assertWeightedPiecesAreSorted(t)
|
|
#define assertReplicationCountIsExact(t)
|
|
#else
|
|
static void
|
|
assertWeightedPiecesAreSorted (Torrent * t)
|
|
{
|
|
if (!t->endgame)
|
|
{
|
|
int i;
|
|
setComparePieceByWeightTorrent (t);
|
|
for (i=0; i<t->pieceCount-1; ++i)
|
|
assert (comparePieceByWeight (&t->pieces[i], &t->pieces[i+1]) <= 0);
|
|
}
|
|
}
|
|
static void
|
|
assertReplicationCountIsExact (Torrent * t)
|
|
{
|
|
/* This assert might fail due to errors of implementations in other
|
|
* clients. It happens when receiving duplicate bitfields/HaveAll/HaveNone
|
|
* from a client. If a such a behavior is noticed,
|
|
* a bug report should be filled to the faulty client. */
|
|
|
|
size_t piece_i;
|
|
const uint16_t * rep = t->pieceReplication;
|
|
const size_t piece_count = t->pieceReplicationSize;
|
|
const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
|
|
const int peer_count = tr_ptrArraySize (&t->peers);
|
|
|
|
assert (piece_count == t->tor->info.pieceCount);
|
|
|
|
for (piece_i=0; piece_i<piece_count; ++piece_i)
|
|
{
|
|
int peer_i;
|
|
uint16_t r = 0;
|
|
|
|
for (peer_i=0; peer_i<peer_count; ++peer_i)
|
|
if (tr_bitsetHas (&peers[peer_i]->have, piece_i))
|
|
++r;
|
|
|
|
assert (rep[piece_i] == r);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static struct weighted_piece *
|
|
pieceListLookup (Torrent * t, tr_piece_index_t index)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<t->pieceCount; ++i)
|
|
if (t->pieces[i].index == index)
|
|
return &t->pieces[i];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
pieceListRebuild (Torrent * t)
|
|
{
|
|
|
|
if (!tr_torrentIsSeed (t->tor))
|
|
{
|
|
tr_piece_index_t i;
|
|
tr_piece_index_t * pool;
|
|
tr_piece_index_t poolCount = 0;
|
|
const tr_torrent * tor = t->tor;
|
|
const tr_info * inf = tr_torrentInfo (tor);
|
|
struct weighted_piece * pieces;
|
|
int pieceCount;
|
|
|
|
/* build the new list */
|
|
pool = tr_new (tr_piece_index_t, inf->pieceCount);
|
|
for (i=0; i<inf->pieceCount; ++i)
|
|
if (!inf->pieces[i].dnd)
|
|
if (!tr_cpPieceIsComplete (&tor->completion, i))
|
|
pool[poolCount++] = i;
|
|
pieceCount = poolCount;
|
|
pieces = tr_new0 (struct weighted_piece, pieceCount);
|
|
for (i=0; i<poolCount; ++i) {
|
|
struct weighted_piece * piece = pieces + i;
|
|
piece->index = pool[i];
|
|
piece->requestCount = 0;
|
|
piece->salt = tr_cryptoWeakRandInt (4096);
|
|
}
|
|
|
|
/* if we already had a list of pieces, merge it into
|
|
* the new list so we don't lose its requestCounts */
|
|
if (t->pieces != NULL)
|
|
{
|
|
struct weighted_piece * o = t->pieces;
|
|
struct weighted_piece * oend = o + t->pieceCount;
|
|
struct weighted_piece * n = pieces;
|
|
struct weighted_piece * nend = n + pieceCount;
|
|
|
|
pieceListSort (t, PIECES_SORTED_BY_INDEX);
|
|
|
|
while (o!=oend && n!=nend) {
|
|
if (o->index < n->index)
|
|
++o;
|
|
else if (o->index > n->index)
|
|
++n;
|
|
else
|
|
*n++ = *o++;
|
|
}
|
|
|
|
tr_free (t->pieces);
|
|
}
|
|
|
|
t->pieces = pieces;
|
|
t->pieceCount = pieceCount;
|
|
|
|
pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
|
|
|
|
/* cleanup */
|
|
tr_free (pool);
|
|
}
|
|
}
|
|
|
|
static void
|
|
pieceListRemovePiece (Torrent * t, tr_piece_index_t piece)
|
|
{
|
|
struct weighted_piece * p;
|
|
|
|
if ((p = pieceListLookup (t, piece)))
|
|
{
|
|
const int pos = p - t->pieces;
|
|
|
|
tr_removeElementFromArray (t->pieces,
|
|
pos,
|
|
sizeof (struct weighted_piece),
|
|
t->pieceCount--);
|
|
|
|
if (t->pieceCount == 0)
|
|
{
|
|
tr_free (t->pieces);
|
|
t->pieces = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
pieceListResortPiece (Torrent * t, struct weighted_piece * p)
|
|
{
|
|
int pos;
|
|
bool isSorted = true;
|
|
|
|
if (p == NULL)
|
|
return;
|
|
|
|
/* is the torrent already sorted? */
|
|
pos = p - t->pieces;
|
|
setComparePieceByWeightTorrent (t);
|
|
if (isSorted && (pos > 0) && (comparePieceByWeight (p-1, p) > 0))
|
|
isSorted = false;
|
|
if (isSorted && (pos < t->pieceCount - 1) && (comparePieceByWeight (p, p+1) > 0))
|
|
isSorted = false;
|
|
|
|
if (t->pieceSortState != PIECES_SORTED_BY_WEIGHT)
|
|
{
|
|
pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
|
|
isSorted = true;
|
|
}
|
|
|
|
/* if it's not sorted, move it around */
|
|
if (!isSorted)
|
|
{
|
|
bool exact;
|
|
const struct weighted_piece tmp = *p;
|
|
|
|
tr_removeElementFromArray (t->pieces,
|
|
pos,
|
|
sizeof (struct weighted_piece),
|
|
t->pieceCount--);
|
|
|
|
pos = tr_lowerBound (&tmp, t->pieces, t->pieceCount,
|
|
sizeof (struct weighted_piece),
|
|
comparePieceByWeight, &exact);
|
|
|
|
memmove (&t->pieces[pos + 1],
|
|
&t->pieces[pos],
|
|
sizeof (struct weighted_piece) * (t->pieceCount++ - pos));
|
|
|
|
t->pieces[pos] = tmp;
|
|
}
|
|
|
|
assertWeightedPiecesAreSorted (t);
|
|
}
|
|
|
|
static void
|
|
pieceListRemoveRequest (Torrent * t, tr_block_index_t block)
|
|
{
|
|
struct weighted_piece * p;
|
|
const tr_piece_index_t index = tr_torBlockPiece (t->tor, block);
|
|
|
|
if (((p = pieceListLookup (t, index))) && (p->requestCount > 0))
|
|
{
|
|
--p->requestCount;
|
|
pieceListResortPiece (t, p);
|
|
}
|
|
}
|
|
|
|
|
|
/****
|
|
*****
|
|
***** Replication count (for rarest first policy)
|
|
*****
|
|
****/
|
|
|
|
/**
|
|
* Increase the replication count of this piece and sort it if the
|
|
* piece list is already sorted
|
|
*/
|
|
static void
|
|
tr_incrReplicationOfPiece (Torrent * t, const size_t index)
|
|
{
|
|
assert (replicationExists (t));
|
|
assert (t->pieceReplicationSize == t->tor->info.pieceCount);
|
|
|
|
/* One more replication of this piece is present in the swarm */
|
|
++t->pieceReplication[index];
|
|
|
|
/* we only resort the piece if the list is already sorted */
|
|
if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
|
|
pieceListResortPiece (t, pieceListLookup (t, index));
|
|
}
|
|
|
|
/**
|
|
* Increases the replication count of pieces present in the bitfield
|
|
*/
|
|
static void
|
|
tr_incrReplicationFromBitfield (Torrent * t, const tr_bitfield * b)
|
|
{
|
|
size_t i;
|
|
uint16_t * rep = t->pieceReplication;
|
|
const size_t n = t->tor->info.pieceCount;
|
|
|
|
assert (replicationExists (t));
|
|
|
|
for (i=0; i<n; ++i)
|
|
if (tr_bitfieldHas (b, i))
|
|
++rep[i];
|
|
|
|
if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
|
|
invalidatePieceSorting (t);
|
|
}
|
|
|
|
/**
|
|
* Increase the replication count of every piece
|
|
*/
|
|
static void
|
|
tr_incrReplication (Torrent * t)
|
|
{
|
|
int i;
|
|
const int n = t->pieceReplicationSize;
|
|
|
|
assert (replicationExists (t));
|
|
assert (t->pieceReplicationSize == t->tor->info.pieceCount);
|
|
|
|
for (i=0; i<n; ++i)
|
|
++t->pieceReplication[i];
|
|
}
|
|
|
|
/**
|
|
* Decrease the replication count of pieces present in the bitset.
|
|
*/
|
|
static void
|
|
tr_decrReplicationFromBitfield (Torrent * t, const tr_bitfield * b)
|
|
{
|
|
int i;
|
|
const int n = t->pieceReplicationSize;
|
|
|
|
assert (replicationExists (t));
|
|
assert (t->pieceReplicationSize == t->tor->info.pieceCount);
|
|
|
|
if (tr_bitfieldHasAll (b))
|
|
{
|
|
for (i=0; i<n; ++i)
|
|
--t->pieceReplication[i];
|
|
}
|
|
else if (!tr_bitfieldHasNone (b))
|
|
{
|
|
for (i=0; i<n; ++i)
|
|
if (tr_bitfieldHas (b, i))
|
|
--t->pieceReplication[i];
|
|
|
|
if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
|
|
invalidatePieceSorting (t);
|
|
}
|
|
}
|
|
|
|
/**
|
|
***
|
|
**/
|
|
|
|
void
|
|
tr_peerMgrRebuildRequests (tr_torrent * tor)
|
|
{
|
|
assert (tr_isTorrent (tor));
|
|
|
|
pieceListRebuild (tor->torrentPeers);
|
|
}
|
|
|
|
void
|
|
tr_peerMgrGetNextRequests (tr_torrent * tor,
|
|
tr_peer * peer,
|
|
int numwant,
|
|
tr_block_index_t * setme,
|
|
int * numgot,
|
|
bool get_intervals)
|
|
{
|
|
int i;
|
|
int got;
|
|
Torrent * t;
|
|
struct weighted_piece * pieces;
|
|
const tr_bitfield * const have = &peer->have;
|
|
|
|
/* sanity clause */
|
|
assert (tr_isTorrent (tor));
|
|
assert (peer->clientIsInterested);
|
|
assert (!peer->clientIsChoked);
|
|
assert (numwant > 0);
|
|
|
|
/* walk through the pieces and find blocks that should be requested */
|
|
got = 0;
|
|
t = tor->torrentPeers;
|
|
|
|
/* prep the pieces list */
|
|
if (t->pieces == NULL)
|
|
pieceListRebuild (t);
|
|
|
|
if (t->pieceSortState != PIECES_SORTED_BY_WEIGHT)
|
|
pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
|
|
|
|
assertReplicationCountIsExact (t);
|
|
assertWeightedPiecesAreSorted (t);
|
|
|
|
updateEndgame (t);
|
|
pieces = t->pieces;
|
|
for (i=0; i<t->pieceCount && got<numwant; ++i)
|
|
{
|
|
struct weighted_piece * p = pieces + i;
|
|
|
|
/* if the peer has this piece that we want... */
|
|
if (tr_bitfieldHas (have, p->index))
|
|
{
|
|
tr_block_index_t b;
|
|
tr_block_index_t first;
|
|
tr_block_index_t last;
|
|
tr_ptrArray peerArr = TR_PTR_ARRAY_INIT;
|
|
|
|
tr_torGetPieceBlockRange (tor, p->index, &first, &last);
|
|
|
|
for (b=first; b<=last && (got<numwant || (get_intervals && setme[2*got-1] == b-1)); ++b)
|
|
{
|
|
int peerCount;
|
|
tr_peer ** peers;
|
|
|
|
/* don't request blocks we've already got */
|
|
if (tr_cpBlockIsComplete (&tor->completion, b))
|
|
continue;
|
|
|
|
/* always add peer if this block has no peers yet */
|
|
tr_ptrArrayClear (&peerArr);
|
|
getBlockRequestPeers (t, b, &peerArr);
|
|
peers = (tr_peer **) tr_ptrArrayPeek (&peerArr, &peerCount);
|
|
if (peerCount != 0)
|
|
{
|
|
/* don't make a second block request until the endgame */
|
|
if (!t->endgame)
|
|
continue;
|
|
|
|
/* don't have more than two peers requesting this block */
|
|
if (peerCount > 1)
|
|
continue;
|
|
|
|
/* don't send the same request to the same peer twice */
|
|
if (peer == peers[0])
|
|
continue;
|
|
|
|
/* in the endgame allow an additional peer to download a
|
|
block but only if the peer seems to be handling requests
|
|
relatively fast */
|
|
if (peer->pendingReqsToPeer + numwant - got < t->endgame)
|
|
continue;
|
|
}
|
|
|
|
/* update the caller's table */
|
|
if (!get_intervals) {
|
|
setme[got++] = b;
|
|
}
|
|
/* if intervals are requested two array entries are necessarry:
|
|
one for the interval's starting block and one for its end block */
|
|
else if (got && setme[2 * got - 1] == b - 1 && b != first) {
|
|
/* expand the last interval */
|
|
++setme[2 * got - 1];
|
|
}
|
|
else {
|
|
/* begin a new interval */
|
|
setme[2 * got] = setme[2 * got + 1] = b;
|
|
++got;
|
|
}
|
|
|
|
/* update our own tables */
|
|
requestListAdd (t, b, peer);
|
|
++p->requestCount;
|
|
}
|
|
|
|
tr_ptrArrayDestruct (&peerArr, NULL);
|
|
}
|
|
}
|
|
|
|
/* In most cases we've just changed the weights of a small number of pieces.
|
|
* So rather than qsort ()ing the entire array, it's faster to apply an
|
|
* adaptive insertion sort algorithm. */
|
|
if (got > 0)
|
|
{
|
|
/* not enough requests || last piece modified */
|
|
if (i == t->pieceCount) --i;
|
|
|
|
setComparePieceByWeightTorrent (t);
|
|
while (--i >= 0)
|
|
{
|
|
bool exact;
|
|
|
|
/* relative position! */
|
|
const int newpos = tr_lowerBound (&t->pieces[i], &t->pieces[i + 1],
|
|
t->pieceCount - (i + 1),
|
|
sizeof (struct weighted_piece),
|
|
comparePieceByWeight, &exact);
|
|
if (newpos > 0)
|
|
{
|
|
const struct weighted_piece piece = t->pieces[i];
|
|
memmove (&t->pieces[i],
|
|
&t->pieces[i + 1],
|
|
sizeof (struct weighted_piece) * (newpos));
|
|
t->pieces[i + newpos] = piece;
|
|
}
|
|
}
|
|
}
|
|
|
|
assertWeightedPiecesAreSorted (t);
|
|
*numgot = got;
|
|
}
|
|
|
|
bool
|
|
tr_peerMgrDidPeerRequest (const tr_torrent * tor,
|
|
const tr_peer * peer,
|
|
tr_block_index_t block)
|
|
{
|
|
const Torrent * t = tor->torrentPeers;
|
|
return requestListLookup ((Torrent*)t, block, peer) != NULL;
|
|
}
|
|
|
|
/* cancel requests that are too old */
|
|
static void
|
|
refillUpkeep (int foo UNUSED, short bar UNUSED, void * vmgr)
|
|
{
|
|
time_t now;
|
|
time_t too_old;
|
|
tr_torrent * tor;
|
|
int cancel_buflen = 0;
|
|
struct block_request * cancel = NULL;
|
|
tr_peerMgr * mgr = vmgr;
|
|
managerLock (mgr);
|
|
|
|
now = tr_time ();
|
|
too_old = now - REQUEST_TTL_SECS;
|
|
|
|
/* alloc the temporary "cancel" buffer */
|
|
tor = NULL;
|
|
while ((tor = tr_torrentNext (mgr->session, tor)))
|
|
cancel_buflen = MAX (cancel_buflen, tor->torrentPeers->requestCount);
|
|
if (cancel_buflen > 0)
|
|
cancel = tr_new (struct block_request, cancel_buflen);
|
|
|
|
/* prune requests that are too old */
|
|
tor = NULL;
|
|
while ((tor = tr_torrentNext (mgr->session, tor)))
|
|
{
|
|
Torrent * t = tor->torrentPeers;
|
|
const int n = t->requestCount;
|
|
if (n > 0)
|
|
{
|
|
int keepCount = 0;
|
|
int cancelCount = 0;
|
|
const struct block_request * it;
|
|
const struct block_request * end;
|
|
|
|
for (it=t->requests, end=it+n; it!=end; ++it)
|
|
{
|
|
if ((it->sentAt <= too_old) && it->peer->msgs && !tr_peerMsgsIsReadingBlock (it->peer->msgs, it->block))
|
|
cancel[cancelCount++] = *it;
|
|
else
|
|
{
|
|
if (it != &t->requests[keepCount])
|
|
t->requests[keepCount] = *it;
|
|
keepCount++;
|
|
}
|
|
}
|
|
|
|
/* prune out the ones we aren't keeping */
|
|
t->requestCount = keepCount;
|
|
|
|
/* send cancel messages for all the "cancel" ones */
|
|
for (it=cancel, end=it+cancelCount; it!=end; ++it) {
|
|
if ((it->peer != NULL) && (it->peer->msgs != NULL)) {
|
|
tr_historyAdd (&it->peer->cancelsSentToPeer, now, 1);
|
|
tr_peerMsgsCancel (it->peer->msgs, it->block);
|
|
decrementPendingReqCount (it);
|
|
}
|
|
}
|
|
|
|
/* decrement the pending request counts for the timed-out blocks */
|
|
for (it=cancel, end=it+cancelCount; it!=end; ++it)
|
|
pieceListRemoveRequest (t, it->block);
|
|
}
|
|
}
|
|
|
|
tr_free (cancel);
|
|
tr_timerAddMsec (mgr->refillUpkeepTimer, REFILL_UPKEEP_PERIOD_MSEC);
|
|
managerUnlock (mgr);
|
|
}
|
|
|
|
static void
|
|
addStrike (Torrent * t, tr_peer * peer)
|
|
{
|
|
tordbg (t, "increasing peer %s strike count to %d",
|
|
tr_atomAddrStr (peer->atom), peer->strikes + 1);
|
|
|
|
if (++peer->strikes >= MAX_BAD_PIECES_PER_PEER)
|
|
{
|
|
struct peer_atom * atom = peer->atom;
|
|
atom->flags2 |= MYFLAG_BANNED;
|
|
peer->doPurge = 1;
|
|
tordbg (t, "banning peer %s", tr_atomAddrStr (atom));
|
|
}
|
|
}
|
|
|
|
static void
|
|
gotBadPiece (Torrent * t, tr_piece_index_t pieceIndex)
|
|
{
|
|
tr_torrent * tor = t->tor;
|
|
const uint32_t byteCount = tr_torPieceCountBytes (tor, pieceIndex);
|
|
|
|
tor->corruptCur += byteCount;
|
|
tor->downloadedCur -= MIN (tor->downloadedCur, byteCount);
|
|
|
|
tr_announcerAddBytes (tor, TR_ANN_CORRUPT, byteCount);
|
|
}
|
|
|
|
static void
|
|
peerSuggestedPiece (Torrent * t UNUSED,
|
|
tr_peer * peer UNUSED,
|
|
tr_piece_index_t pieceIndex UNUSED,
|
|
int isFastAllowed UNUSED)
|
|
{
|
|
#if 0
|
|
assert (t);
|
|
assert (peer);
|
|
assert (peer->msgs);
|
|
|
|
/* is this a valid piece? */
|
|
if (pieceIndex >= t->tor->info.pieceCount)
|
|
return;
|
|
|
|
/* don't ask for it if we've already got it */
|
|
if (tr_cpPieceIsComplete (t->tor->completion, pieceIndex))
|
|
return;
|
|
|
|
/* don't ask for it if they don't have it */
|
|
if (!tr_bitfieldHas (peer->have, pieceIndex))
|
|
return;
|
|
|
|
/* don't ask for it if we're choked and it's not fast */
|
|
if (!isFastAllowed && peer->clientIsChoked)
|
|
return;
|
|
|
|
/* request the blocks that we don't have in this piece */
|
|
{
|
|
tr_block_index_t b;
|
|
tr_block_index_t first;
|
|
tr_block_index_t last;
|
|
const tr_torrent * tor = t->tor;
|
|
|
|
tr_torGetPieceBlockRange (t->tor, pieceIndex, &first, &last);
|
|
|
|
for (b=first; b<=last; ++b)
|
|
{
|
|
if (!tr_cpBlockIsComplete (tor->completion, b))
|
|
{
|
|
const uint32_t offset = getBlockOffsetInPiece (tor, b);
|
|
const uint32_t length = tr_torBlockCountBytes (tor, b);
|
|
tr_peerMsgsAddRequest (peer->msgs, pieceIndex, offset, length);
|
|
incrementPieceRequests (t, pieceIndex);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
removeRequestFromTables (Torrent * t, tr_block_index_t block, const tr_peer * peer)
|
|
{
|
|
requestListRemove (t, block, peer);
|
|
pieceListRemoveRequest (t, block);
|
|
}
|
|
|
|
/* peer choked us, or maybe it disconnected.
|
|
either way we need to remove all its requests */
|
|
static void
|
|
peerDeclinedAllRequests (Torrent * t, const tr_peer * peer)
|
|
{
|
|
int i, n;
|
|
tr_block_index_t * blocks = tr_new (tr_block_index_t, t->requestCount);
|
|
|
|
for (i=n=0; i<t->requestCount; ++i)
|
|
if (peer == t->requests[i].peer)
|
|
blocks[n++] = t->requests[i].block;
|
|
|
|
for (i=0; i<n; ++i)
|
|
removeRequestFromTables (t, blocks[i], peer);
|
|
|
|
tr_free (blocks);
|
|
}
|
|
|
|
static void tr_peerMgrSetBlame (tr_torrent *, tr_piece_index_t, int);
|
|
|
|
static void
|
|
peerCallbackFunc (tr_peer * peer, const tr_peer_event * e, void * vt)
|
|
{
|
|
Torrent * t = vt;
|
|
|
|
torrentLock (t);
|
|
|
|
assert (peer != NULL);
|
|
|
|
switch (e->eventType)
|
|
{
|
|
case TR_PEER_PEER_GOT_DATA:
|
|
{
|
|
const time_t now = tr_time ();
|
|
tr_torrent * tor = t->tor;
|
|
|
|
if (e->wasPieceData)
|
|
{
|
|
tor->uploadedCur += e->length;
|
|
tr_announcerAddBytes (tor, TR_ANN_UP, e->length);
|
|
tr_torrentSetActivityDate (tor, now);
|
|
tr_torrentSetDirty (tor);
|
|
}
|
|
|
|
/* update the stats */
|
|
if (e->wasPieceData)
|
|
tr_statsAddUploaded (tor->session, e->length);
|
|
|
|
/* update our atom */
|
|
if (peer->atom && e->wasPieceData)
|
|
peer->atom->piece_data_time = now;
|
|
|
|
break;
|
|
}
|
|
|
|
case TR_PEER_CLIENT_GOT_HAVE:
|
|
if (replicationExists (t)) {
|
|
tr_incrReplicationOfPiece (t, e->pieceIndex);
|
|
assertReplicationCountIsExact (t);
|
|
}
|
|
break;
|
|
|
|
case TR_PEER_CLIENT_GOT_HAVE_ALL:
|
|
if (replicationExists (t)) {
|
|
tr_incrReplication (t);
|
|
assertReplicationCountIsExact (t);
|
|
}
|
|
break;
|
|
|
|
case TR_PEER_CLIENT_GOT_HAVE_NONE:
|
|
/* noop */
|
|
break;
|
|
|
|
case TR_PEER_CLIENT_GOT_BITFIELD:
|
|
assert (e->bitfield != NULL);
|
|
if (replicationExists (t)) {
|
|
tr_incrReplicationFromBitfield (t, e->bitfield);
|
|
assertReplicationCountIsExact (t);
|
|
}
|
|
break;
|
|
|
|
case TR_PEER_CLIENT_GOT_REJ: {
|
|
tr_block_index_t b = _tr_block (t->tor, e->pieceIndex, e->offset);
|
|
if (b < t->tor->blockCount)
|
|
removeRequestFromTables (t, b, peer);
|
|
else
|
|
tordbg (t, "Peer %s sent an out-of-range reject message",
|
|
tr_atomAddrStr (peer->atom));
|
|
break;
|
|
}
|
|
|
|
case TR_PEER_CLIENT_GOT_CHOKE:
|
|
peerDeclinedAllRequests (t, peer);
|
|
break;
|
|
|
|
case TR_PEER_CLIENT_GOT_PORT:
|
|
if (peer->atom)
|
|
peer->atom->port = e->port;
|
|
break;
|
|
|
|
case TR_PEER_CLIENT_GOT_SUGGEST:
|
|
peerSuggestedPiece (t, peer, e->pieceIndex, false);
|
|
break;
|
|
|
|
case TR_PEER_CLIENT_GOT_ALLOWED_FAST:
|
|
peerSuggestedPiece (t, peer, e->pieceIndex, true);
|
|
break;
|
|
|
|
case TR_PEER_CLIENT_GOT_DATA:
|
|
{
|
|
const time_t now = tr_time ();
|
|
tr_torrent * tor = t->tor;
|
|
|
|
if (e->wasPieceData)
|
|
{
|
|
tor->downloadedCur += e->length;
|
|
tr_torrentSetActivityDate (tor, now);
|
|
tr_torrentSetDirty (tor);
|
|
}
|
|
|
|
/* update the stats */
|
|
if (e->wasPieceData)
|
|
tr_statsAddDownloaded (tor->session, e->length);
|
|
|
|
/* update our atom */
|
|
if (peer->atom && e->wasPieceData)
|
|
peer->atom->piece_data_time = now;
|
|
|
|
break;
|
|
}
|
|
|
|
case TR_PEER_CLIENT_GOT_BLOCK:
|
|
{
|
|
tr_torrent * tor = t->tor;
|
|
tr_block_index_t block = _tr_block (tor, e->pieceIndex, e->offset);
|
|
int i, peerCount;
|
|
tr_peer ** peers;
|
|
tr_ptrArray peerArr = TR_PTR_ARRAY_INIT;
|
|
|
|
removeRequestFromTables (t, block, peer);
|
|
getBlockRequestPeers (t, block, &peerArr);
|
|
peers = (tr_peer **) tr_ptrArrayPeek (&peerArr, &peerCount);
|
|
|
|
/* remove additional block requests and send cancel to peers */
|
|
for (i=0; i<peerCount; i++) {
|
|
tr_peer * p = peers[i];
|
|
assert (p != peer);
|
|
if (p->msgs) {
|
|
tr_historyAdd (&p->cancelsSentToPeer, tr_time (), 1);
|
|
tr_peerMsgsCancel (p->msgs, block);
|
|
}
|
|
removeRequestFromTables (t, block, p);
|
|
}
|
|
|
|
tr_ptrArrayDestruct (&peerArr, false);
|
|
|
|
tr_historyAdd (&peer->blocksSentToClient, tr_time (), 1);
|
|
|
|
if (tr_cpBlockIsComplete (&tor->completion, block))
|
|
{
|
|
/* we already have this block... */
|
|
const uint32_t n = tr_torBlockCountBytes (tor, block);
|
|
tor->downloadedCur -= MIN (tor->downloadedCur, n);
|
|
tordbg (t, "we have this block already...");
|
|
}
|
|
else
|
|
{
|
|
tr_cpBlockAdd (&tor->completion, block);
|
|
pieceListResortPiece (t, pieceListLookup (t, e->pieceIndex));
|
|
tr_torrentSetDirty (tor);
|
|
|
|
if (tr_cpPieceIsComplete (&tor->completion, e->pieceIndex))
|
|
{
|
|
const tr_piece_index_t p = e->pieceIndex;
|
|
const bool ok = tr_torrentCheckPiece (tor, p);
|
|
|
|
tordbg (t, "[LAZY] checked just-completed piece %zu", (size_t)p);
|
|
|
|
if (!ok)
|
|
{
|
|
tr_torerr (tor, _("Piece %lu, which was just downloaded, failed its checksum test"),
|
|
(unsigned long)p);
|
|
}
|
|
|
|
tr_peerMgrSetBlame (tor, p, ok);
|
|
|
|
if (!ok)
|
|
{
|
|
gotBadPiece (t, p);
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
int peerCount;
|
|
tr_peer ** peers;
|
|
tr_file_index_t fileIndex;
|
|
|
|
/* only add this to downloadedCur if we got it from a peer --
|
|
* webseeds shouldn't count against our ratio. As one tracker
|
|
* admin put it, "Those pieces are downloaded directly from the
|
|
* content distributor, not the peers, it is the tracker's job
|
|
* to manage the swarms, not the web server and does not fit
|
|
* into the jurisdiction of the tracker." */
|
|
if (peer->msgs != NULL) {
|
|
const uint32_t n = tr_torPieceCountBytes (tor, p);
|
|
tr_announcerAddBytes (tor, TR_ANN_DOWN, n);
|
|
}
|
|
|
|
peerCount = tr_ptrArraySize (&t->peers);
|
|
peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
|
|
for (i=0; i<peerCount; ++i)
|
|
tr_peerMsgsHave (peers[i]->msgs, p);
|
|
|
|
for (fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex) {
|
|
const tr_file * file = &tor->info.files[fileIndex];
|
|
if ((file->firstPiece <= p) && (p <= file->lastPiece)) {
|
|
if (tr_cpFileIsComplete (&tor->completion, fileIndex)) {
|
|
tr_cacheFlushFile (tor->session->cache, tor, fileIndex);
|
|
tr_torrentFileCompleted (tor, fileIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
pieceListRemovePiece (t, p);
|
|
}
|
|
}
|
|
|
|
t->needsCompletenessCheck = true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TR_PEER_ERROR:
|
|
if ((e->err == ERANGE) || (e->err == EMSGSIZE) || (e->err == ENOTCONN))
|
|
{
|
|
/* some protocol error from the peer */
|
|
peer->doPurge = 1;
|
|
tordbg (t, "setting %s doPurge flag because we got an ERANGE, EMSGSIZE, or ENOTCONN error",
|
|
tr_atomAddrStr (peer->atom));
|
|
}
|
|
else
|
|
{
|
|
tordbg (t, "unhandled error: %s", tr_strerror (e->err));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert (0);
|
|
}
|
|
|
|
torrentUnlock (t);
|
|
}
|
|
|
|
static int
|
|
getDefaultShelfLife (uint8_t from)
|
|
{
|
|
/* in general, peers obtained from firsthand contact
|
|
* are better than those from secondhand, etc etc */
|
|
switch (from)
|
|
{
|
|
case TR_PEER_FROM_INCOMING : return 60 * 60 * 6;
|
|
case TR_PEER_FROM_LTEP : return 60 * 60 * 6;
|
|
case TR_PEER_FROM_TRACKER : return 60 * 60 * 3;
|
|
case TR_PEER_FROM_DHT : return 60 * 60 * 3;
|
|
case TR_PEER_FROM_PEX : return 60 * 60 * 2;
|
|
case TR_PEER_FROM_RESUME : return 60 * 60;
|
|
case TR_PEER_FROM_LPD : return 10 * 60;
|
|
default : return 60 * 60;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ensureAtomExists (Torrent * t,
|
|
const tr_address * addr,
|
|
const tr_port port,
|
|
const uint8_t flags,
|
|
const int8_t seedProbability,
|
|
const uint8_t from)
|
|
{
|
|
struct peer_atom * a;
|
|
|
|
assert (tr_address_is_valid (addr));
|
|
assert (from < TR_PEER_FROM__MAX);
|
|
|
|
a = getExistingAtom (t, addr);
|
|
|
|
if (a == NULL)
|
|
{
|
|
const int jitter = tr_cryptoWeakRandInt (60*10);
|
|
a = tr_new0 (struct peer_atom, 1);
|
|
a->addr = *addr;
|
|
a->port = port;
|
|
a->flags = flags;
|
|
a->fromFirst = from;
|
|
a->fromBest = from;
|
|
a->shelf_date = tr_time () + getDefaultShelfLife (from) + jitter;
|
|
a->blocklisted = -1;
|
|
atomSetSeedProbability (a, seedProbability);
|
|
tr_ptrArrayInsertSorted (&t->pool, a, compareAtomsByAddress);
|
|
|
|
tordbg (t, "got a new atom: %s", tr_atomAddrStr (a));
|
|
}
|
|
else
|
|
{
|
|
if (from < a->fromBest)
|
|
a->fromBest = from;
|
|
|
|
if (a->seedProbability == -1)
|
|
atomSetSeedProbability (a, seedProbability);
|
|
|
|
a->flags |= flags;
|
|
}
|
|
}
|
|
|
|
static int
|
|
getMaxPeerCount (const tr_torrent * tor)
|
|
{
|
|
return tor->maxConnectedPeers;
|
|
}
|
|
|
|
static int
|
|
getPeerCount (const Torrent * t)
|
|
{
|
|
return tr_ptrArraySize (&t->peers);/* + tr_ptrArraySize (&t->outgoingHandshakes); */
|
|
}
|
|
|
|
/* FIXME: this is kind of a mess. */
|
|
static bool
|
|
myHandshakeDoneCB (tr_handshake * handshake,
|
|
tr_peerIo * io,
|
|
bool readAnythingFromPeer,
|
|
bool isConnected,
|
|
const uint8_t * peer_id,
|
|
void * vmanager)
|
|
{
|
|
bool ok = isConnected;
|
|
bool success = false;
|
|
tr_port port;
|
|
const tr_address * addr;
|
|
tr_peerMgr * manager = vmanager;
|
|
Torrent * t;
|
|
tr_handshake * ours;
|
|
|
|
assert (io);
|
|
assert (tr_isBool (ok));
|
|
|
|
t = tr_peerIoHasTorrentHash (io)
|
|
? getExistingTorrent (manager, tr_peerIoGetTorrentHash (io))
|
|
: NULL;
|
|
|
|
if (tr_peerIoIsIncoming (io))
|
|
ours = tr_ptrArrayRemoveSorted (&manager->incomingHandshakes,
|
|
handshake, handshakeCompare);
|
|
else if (t)
|
|
ours = tr_ptrArrayRemoveSorted (&t->outgoingHandshakes,
|
|
handshake, handshakeCompare);
|
|
else
|
|
ours = handshake;
|
|
|
|
assert (ours);
|
|
assert (ours == handshake);
|
|
|
|
if (t)
|
|
torrentLock (t);
|
|
|
|
addr = tr_peerIoGetAddress (io, &port);
|
|
|
|
if (!ok || !t || !t->isRunning)
|
|
{
|
|
if (t)
|
|
{
|
|
struct peer_atom * atom = getExistingAtom (t, addr);
|
|
if (atom)
|
|
{
|
|
++atom->numFails;
|
|
|
|
if (!readAnythingFromPeer)
|
|
{
|
|
tordbg (t, "marking peer %s as unreachable... numFails is %d", tr_atomAddrStr (atom), (int)atom->numFails);
|
|
atom->flags2 |= MYFLAG_UNREACHABLE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else /* looking good */
|
|
{
|
|
struct peer_atom * atom;
|
|
|
|
ensureAtomExists (t, addr, port, 0, -1, TR_PEER_FROM_INCOMING);
|
|
atom = getExistingAtom (t, addr);
|
|
atom->time = tr_time ();
|
|
atom->piece_data_time = 0;
|
|
atom->lastConnectionAt = tr_time ();
|
|
|
|
if (!tr_peerIoIsIncoming (io))
|
|
{
|
|
atom->flags |= ADDED_F_CONNECTABLE;
|
|
atom->flags2 &= ~MYFLAG_UNREACHABLE;
|
|
}
|
|
|
|
/* In principle, this flag specifies whether the peer groks uTP,
|
|
not whether it's currently connected over uTP. */
|
|
if (io->utp_socket)
|
|
atom->flags |= ADDED_F_UTP_FLAGS;
|
|
|
|
if (atom->flags2 & MYFLAG_BANNED)
|
|
{
|
|
tordbg (t, "banned peer %s tried to reconnect",
|
|
tr_atomAddrStr (atom));
|
|
}
|
|
else if (tr_peerIoIsIncoming (io)
|
|
&& (getPeerCount (t) >= getMaxPeerCount (t->tor)))
|
|
|
|
{
|
|
}
|
|
else
|
|
{
|
|
tr_peer * peer = atom->peer;
|
|
|
|
if (peer) /* we already have this peer */
|
|
{
|
|
}
|
|
else
|
|
{
|
|
peer = getPeer (t, atom);
|
|
|
|
if (!peer_id)
|
|
peer->client = TR_KEY_NONE;
|
|
else {
|
|
char client[128];
|
|
tr_clientForId (client, sizeof (client), peer_id);
|
|
peer->client = tr_quark_new (client, -1);
|
|
}
|
|
|
|
peer->io = tr_handshakeStealIO (handshake); /* this steals its refcount too, which is
|
|
balanced by our unref in peerDelete () */
|
|
tr_peerIoSetParent (peer->io, &t->tor->bandwidth);
|
|
tr_peerMsgsNew (t->tor, peer, peerCallbackFunc, t);
|
|
|
|
success = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (t)
|
|
torrentUnlock (t);
|
|
|
|
return success;
|
|
}
|
|
|
|
void
|
|
tr_peerMgrAddIncoming (tr_peerMgr * manager,
|
|
tr_address * addr,
|
|
tr_port port,
|
|
int socket,
|
|
struct UTPSocket * utp_socket)
|
|
{
|
|
tr_session * session;
|
|
|
|
managerLock (manager);
|
|
|
|
assert (tr_isSession (manager->session));
|
|
session = manager->session;
|
|
|
|
if (tr_sessionIsAddressBlocked (session, addr))
|
|
{
|
|
tr_dbg ("Banned IP address \"%s\" tried to connect to us", tr_address_to_string (addr));
|
|
if (socket >= 0)
|
|
tr_netClose (session, socket);
|
|
else
|
|
UTP_Close (utp_socket);
|
|
}
|
|
else if (getExistingHandshake (&manager->incomingHandshakes, addr))
|
|
{
|
|
if (socket >= 0)
|
|
tr_netClose (session, socket);
|
|
else
|
|
UTP_Close (utp_socket);
|
|
}
|
|
else /* we don't have a connection to them yet... */
|
|
{
|
|
tr_peerIo * io;
|
|
tr_handshake * handshake;
|
|
|
|
io = tr_peerIoNewIncoming (session, &session->bandwidth, addr, port, socket, utp_socket);
|
|
|
|
handshake = tr_handshakeNew (io,
|
|
session->encryptionMode,
|
|
myHandshakeDoneCB,
|
|
manager);
|
|
|
|
tr_peerIoUnref (io); /* balanced by the implicit ref in tr_peerIoNewIncoming () */
|
|
|
|
tr_ptrArrayInsertSorted (&manager->incomingHandshakes, handshake,
|
|
handshakeCompare);
|
|
}
|
|
|
|
managerUnlock (manager);
|
|
}
|
|
|
|
void
|
|
tr_peerMgrAddPex (tr_torrent * tor, uint8_t from,
|
|
const tr_pex * pex, int8_t seedProbability)
|
|
{
|
|
if (tr_isPex (pex)) /* safeguard against corrupt data */
|
|
{
|
|
Torrent * t = tor->torrentPeers;
|
|
managerLock (t->manager);
|
|
|
|
if (!tr_sessionIsAddressBlocked (t->manager->session, &pex->addr))
|
|
if (tr_address_is_valid_for_peers (&pex->addr, pex->port))
|
|
ensureAtomExists (t, &pex->addr, pex->port, pex->flags, seedProbability, from);
|
|
|
|
managerUnlock (t->manager);
|
|
}
|
|
}
|
|
|
|
void
|
|
tr_peerMgrMarkAllAsSeeds (tr_torrent * tor)
|
|
{
|
|
Torrent * t = tor->torrentPeers;
|
|
const int n = tr_ptrArraySize (&t->pool);
|
|
struct peer_atom ** it = (struct peer_atom**) tr_ptrArrayBase (&t->pool);
|
|
struct peer_atom ** end = it + n;
|
|
|
|
while (it != end)
|
|
atomSetSeed (t, *it++);
|
|
}
|
|
|
|
tr_pex *
|
|
tr_peerMgrCompactToPex (const void * compact,
|
|
size_t compactLen,
|
|
const uint8_t * added_f,
|
|
size_t added_f_len,
|
|
size_t * pexCount)
|
|
{
|
|
size_t i;
|
|
size_t n = compactLen / 6;
|
|
const uint8_t * walk = compact;
|
|
tr_pex * pex = tr_new0 (tr_pex, n);
|
|
|
|
for (i = 0; i < n; ++i)
|
|
{
|
|
pex[i].addr.type = TR_AF_INET;
|
|
memcpy (&pex[i].addr.addr, walk, 4); walk += 4;
|
|
memcpy (&pex[i].port, walk, 2); walk += 2;
|
|
if (added_f && (n == added_f_len))
|
|
pex[i].flags = added_f[i];
|
|
}
|
|
|
|
*pexCount = n;
|
|
return pex;
|
|
}
|
|
|
|
tr_pex *
|
|
tr_peerMgrCompact6ToPex (const void * compact,
|
|
size_t compactLen,
|
|
const uint8_t * added_f,
|
|
size_t added_f_len,
|
|
size_t * pexCount)
|
|
{
|
|
size_t i;
|
|
size_t n = compactLen / 18;
|
|
const uint8_t * walk = compact;
|
|
tr_pex * pex = tr_new0 (tr_pex, n);
|
|
|
|
for (i = 0; i < n; ++i)
|
|
{
|
|
pex[i].addr.type = TR_AF_INET6;
|
|
memcpy (&pex[i].addr.addr.addr6.s6_addr, walk, 16); walk += 16;
|
|
memcpy (&pex[i].port, walk, 2); walk += 2;
|
|
if (added_f && (n == added_f_len))
|
|
pex[i].flags = added_f[i];
|
|
}
|
|
|
|
*pexCount = n;
|
|
return pex;
|
|
}
|
|
|
|
tr_pex *
|
|
tr_peerMgrArrayToPex (const void * array,
|
|
size_t arrayLen,
|
|
size_t * pexCount)
|
|
{
|
|
size_t i;
|
|
size_t n = arrayLen / (sizeof (tr_address) + 2);
|
|
/*size_t n = arrayLen / sizeof (tr_peerArrayElement);*/
|
|
const uint8_t * walk = array;
|
|
tr_pex * pex = tr_new0 (tr_pex, n);
|
|
|
|
for (i = 0 ; i < n ; i++) {
|
|
memcpy (&pex[i].addr, walk, sizeof (tr_address));
|
|
memcpy (&pex[i].port, walk + sizeof (tr_address), 2);
|
|
pex[i].flags = 0x00;
|
|
walk += sizeof (tr_address) + 2;
|
|
}
|
|
|
|
*pexCount = n;
|
|
return pex;
|
|
}
|
|
|
|
/**
|
|
***
|
|
**/
|
|
|
|
static void
|
|
tr_peerMgrSetBlame (tr_torrent * tor,
|
|
tr_piece_index_t pieceIndex,
|
|
int success)
|
|
{
|
|
if (!success)
|
|
{
|
|
int peerCount, i;
|
|
Torrent * t = tor->torrentPeers;
|
|
tr_peer ** peers;
|
|
|
|
assert (torrentIsLocked (t));
|
|
|
|
peers = (tr_peer **) tr_ptrArrayPeek (&t->peers, &peerCount);
|
|
for (i = 0; i < peerCount; ++i)
|
|
{
|
|
tr_peer * peer = peers[i];
|
|
if (tr_bitfieldHas (&peer->blame, pieceIndex))
|
|
{
|
|
tordbg (t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
|
|
tr_atomAddrStr (peer->atom),
|
|
pieceIndex, (int)peer->strikes + 1);
|
|
addStrike (t, peer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
tr_pexCompare (const void * va, const void * vb)
|
|
{
|
|
const tr_pex * a = va;
|
|
const tr_pex * b = vb;
|
|
int i;
|
|
|
|
assert (tr_isPex (a));
|
|
assert (tr_isPex (b));
|
|
|
|
if ((i = tr_address_compare (&a->addr, &b->addr)))
|
|
return i;
|
|
|
|
if (a->port != b->port)
|
|
return a->port < b->port ? -1 : 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* better goes first */
|
|
static int
|
|
compareAtomsByUsefulness (const void * va, const void *vb)
|
|
{
|
|
const struct peer_atom * a = * (const struct peer_atom**) va;
|
|
const struct peer_atom * b = * (const struct peer_atom**) vb;
|
|
|
|
assert (tr_isAtom (a));
|
|
assert (tr_isAtom (b));
|
|
|
|
if (a->piece_data_time != b->piece_data_time)
|
|
return a->piece_data_time > b->piece_data_time ? -1 : 1;
|
|
if (a->fromBest != b->fromBest)
|
|
return a->fromBest < b->fromBest ? -1 : 1;
|
|
if (a->numFails != b->numFails)
|
|
return a->numFails < b->numFails ? -1 : 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static bool
|
|
isAtomInteresting (const tr_torrent * tor, struct peer_atom * atom)
|
|
{
|
|
if (tr_torrentIsSeed (tor) && atomIsSeed (atom))
|
|
return false;
|
|
|
|
if (peerIsInUse (tor->torrentPeers, atom))
|
|
return true;
|
|
|
|
if (isAtomBlocklisted (tor->session, atom))
|
|
return false;
|
|
|
|
if (atom->flags2 & MYFLAG_BANNED)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
int
|
|
tr_peerMgrGetPeers (tr_torrent * tor,
|
|
tr_pex ** setme_pex,
|
|
uint8_t af,
|
|
uint8_t list_mode,
|
|
int maxCount)
|
|
{
|
|
int i;
|
|
int n;
|
|
int count = 0;
|
|
int atomCount = 0;
|
|
const Torrent * t = tor->torrentPeers;
|
|
struct peer_atom ** atoms = NULL;
|
|
tr_pex * pex;
|
|
tr_pex * walk;
|
|
|
|
assert (tr_isTorrent (tor));
|
|
assert (setme_pex != NULL);
|
|
assert (af==TR_AF_INET || af==TR_AF_INET6);
|
|
assert (list_mode==TR_PEERS_CONNECTED || list_mode==TR_PEERS_INTERESTING);
|
|
|
|
managerLock (t->manager);
|
|
|
|
/**
|
|
*** build a list of atoms
|
|
**/
|
|
|
|
if (list_mode == TR_PEERS_CONNECTED) /* connected peers only */
|
|
{
|
|
int i;
|
|
const tr_peer ** peers = (const tr_peer **) tr_ptrArrayBase (&t->peers);
|
|
atomCount = tr_ptrArraySize (&t->peers);
|
|
atoms = tr_new (struct peer_atom *, atomCount);
|
|
for (i=0; i<atomCount; ++i)
|
|
atoms[i] = peers[i]->atom;
|
|
}
|
|
else /* TR_PEERS_INTERESTING */
|
|
{
|
|
int i;
|
|
struct peer_atom ** atomBase = (struct peer_atom**) tr_ptrArrayBase (&t->pool);
|
|
n = tr_ptrArraySize (&t->pool);
|
|
atoms = tr_new (struct peer_atom *, n);
|
|
for (i=0; i<n; ++i)
|
|
if (isAtomInteresting (tor, atomBase[i]))
|
|
atoms[atomCount++] = atomBase[i];
|
|
}
|
|
|
|
qsort (atoms, atomCount, sizeof (struct peer_atom *), compareAtomsByUsefulness);
|
|
|
|
/**
|
|
*** add the first N of them into our return list
|
|
**/
|
|
|
|
n = MIN (atomCount, maxCount);
|
|
pex = walk = tr_new0 (tr_pex, n);
|
|
|
|
for (i=0; i<atomCount && count<n; ++i)
|
|
{
|
|
const struct peer_atom * atom = atoms[i];
|
|
if (atom->addr.type == af)
|
|
{
|
|
assert (tr_address_is_valid (&atom->addr));
|
|
walk->addr = atom->addr;
|
|
walk->port = atom->port;
|
|
walk->flags = atom->flags;
|
|
++count;
|
|
++walk;
|
|
}
|
|
}
|
|
|
|
qsort (pex, count, sizeof (tr_pex), tr_pexCompare);
|
|
|
|
assert ((walk - pex) == count);
|
|
*setme_pex = pex;
|
|
|
|
/* cleanup */
|
|
tr_free (atoms);
|
|
managerUnlock (t->manager);
|
|
return count;
|
|
}
|
|
|
|
static void atomPulse (int, short, void *);
|
|
static void bandwidthPulse (int, short, void *);
|
|
static void rechokePulse (int, short, void *);
|
|
static void reconnectPulse (int, short, void *);
|
|
|
|
static struct event *
|
|
createTimer (tr_session * session, int msec, void (*callback)(int, short, void *), void * cbdata)
|
|
{
|
|
struct event * timer = evtimer_new (session->event_base, callback, cbdata);
|
|
tr_timerAddMsec (timer, msec);
|
|
return timer;
|
|
}
|
|
|
|
static void
|
|
ensureMgrTimersExist (struct tr_peerMgr * m)
|
|
{
|
|
if (m->atomTimer == NULL)
|
|
m->atomTimer = createTimer (m->session, ATOM_PERIOD_MSEC, atomPulse, m);
|
|
|
|
if (m->bandwidthTimer == NULL)
|
|
m->bandwidthTimer = createTimer (m->session, BANDWIDTH_PERIOD_MSEC, bandwidthPulse, m);
|
|
|
|
if (m->rechokeTimer == NULL)
|
|
m->rechokeTimer = createTimer (m->session, RECHOKE_PERIOD_MSEC, rechokePulse, m);
|
|
|
|
if (m->refillUpkeepTimer == NULL)
|
|
m->refillUpkeepTimer = createTimer (m->session, REFILL_UPKEEP_PERIOD_MSEC, refillUpkeep, m);
|
|
}
|
|
|
|
void
|
|
tr_peerMgrStartTorrent (tr_torrent * tor)
|
|
{
|
|
Torrent * t = tor->torrentPeers;
|
|
|
|
assert (tr_isTorrent (tor));
|
|
assert (tr_torrentIsLocked (tor));
|
|
|
|
ensureMgrTimersExist (t->manager);
|
|
|
|
t->isRunning = true;
|
|
t->maxPeers = t->tor->maxConnectedPeers;
|
|
t->pieceSortState = PIECES_UNSORTED;
|
|
|
|
rechokePulse (0, 0, t->manager);
|
|
}
|
|
|
|
static void
|
|
stopTorrent (Torrent * t)
|
|
{
|
|
tr_peer * peer;
|
|
|
|
t->isRunning = false;
|
|
|
|
replicationFree (t);
|
|
invalidatePieceSorting (t);
|
|
|
|
/* disconnect the peers. */
|
|
while ((peer = tr_ptrArrayPop (&t->peers)))
|
|
peerDelete (t, peer);
|
|
|
|
/* disconnect the handshakes. handshakeAbort calls handshakeDoneCB (),
|
|
* which removes the handshake from t->outgoingHandshakes... */
|
|
while (!tr_ptrArrayEmpty (&t->outgoingHandshakes))
|
|
tr_handshakeAbort (tr_ptrArrayNth (&t->outgoingHandshakes, 0));
|
|
}
|
|
|
|
void
|
|
tr_peerMgrStopTorrent (tr_torrent * tor)
|
|
{
|
|
assert (tr_isTorrent (tor));
|
|
assert (tr_torrentIsLocked (tor));
|
|
|
|
stopTorrent (tor->torrentPeers);
|
|
}
|
|
|
|
void
|
|
tr_peerMgrAddTorrent (tr_peerMgr * manager, tr_torrent * tor)
|
|
{
|
|
assert (tr_isTorrent (tor));
|
|
assert (tr_torrentIsLocked (tor));
|
|
assert (tor->torrentPeers == NULL);
|
|
|
|
tor->torrentPeers = torrentNew (manager, tor);
|
|
}
|
|
|
|
void
|
|
tr_peerMgrRemoveTorrent (tr_torrent * tor)
|
|
{
|
|
assert (tr_isTorrent (tor));
|
|
assert (tr_torrentIsLocked (tor));
|
|
|
|
stopTorrent (tor->torrentPeers);
|
|
torrentFree (tor->torrentPeers);
|
|
}
|
|
|
|
void
|
|
tr_peerUpdateProgress (tr_torrent * tor, tr_peer * peer)
|
|
{
|
|
const tr_bitfield * have = &peer->have;
|
|
|
|
if (tr_bitfieldHasAll (have))
|
|
{
|
|
peer->progress = 1.0;
|
|
}
|
|
else if (tr_bitfieldHasNone (have))
|
|
{
|
|
peer->progress = 0.0;
|
|
}
|
|
else
|
|
{
|
|
const float true_count = tr_bitfieldCountTrueBits (have);
|
|
|
|
if (tr_torrentHasMetadata (tor))
|
|
{
|
|
peer->progress = true_count / tor->info.pieceCount;
|
|
}
|
|
else /* without pieceCount, this result is only a best guess... */
|
|
{
|
|
peer->progress = true_count / (have->bit_count + 1);
|
|
}
|
|
}
|
|
|
|
/* clamp the progress range */
|
|
if (peer->progress < 0.0)
|
|
peer->progress = 0.0;
|
|
if (peer->progress > 1.0)
|
|
peer->progress = 1.0;
|
|
|
|
if (peer->atom && (peer->progress >= 1.0))
|
|
atomSetSeed (tor->torrentPeers, peer->atom);
|
|
}
|
|
|
|
void
|
|
tr_peerMgrOnTorrentGotMetainfo (tr_torrent * tor)
|
|
{
|
|
int i;
|
|
int peerCount;
|
|
tr_peer ** peers;
|
|
|
|
/* the webseed list may have changed... */
|
|
rebuildWebseedArray (tor->torrentPeers, tor);
|
|
|
|
/* some peer_msgs' progress fields may not be accurate if we
|
|
didn't have the metadata before now... so refresh them all... */
|
|
peerCount = tr_ptrArraySize (&tor->torrentPeers->peers);
|
|
peers = (tr_peer**) tr_ptrArrayBase (&tor->torrentPeers->peers);
|
|
for (i=0; i<peerCount; ++i)
|
|
tr_peerUpdateProgress (tor, peers[i]);
|
|
|
|
}
|
|
|
|
void
|
|
tr_peerMgrTorrentAvailability (const tr_torrent * tor,
|
|
int8_t * tab,
|
|
unsigned int tabCount)
|
|
{
|
|
assert (tr_isTorrent (tor));
|
|
assert (tab != NULL);
|
|
assert (tabCount > 0);
|
|
|
|
memset (tab, 0, tabCount);
|
|
|
|
if (tr_torrentHasMetadata (tor))
|
|
{
|
|
tr_piece_index_t i;
|
|
const int peerCount = tr_ptrArraySize (&tor->torrentPeers->peers);
|
|
const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&tor->torrentPeers->peers);
|
|
const float interval = tor->info.pieceCount / (float)tabCount;
|
|
const bool isSeed = tr_cpGetStatus (&tor->completion) == TR_SEED;
|
|
|
|
for (i=0; i<tabCount; ++i)
|
|
{
|
|
const int piece = i * interval;
|
|
|
|
if (isSeed || tr_cpPieceIsComplete (&tor->completion, piece))
|
|
{
|
|
tab[i] = -1;
|
|
}
|
|
else if (peerCount)
|
|
{
|
|
int j;
|
|
for (j=0; j<peerCount; ++j)
|
|
if (tr_bitfieldHas (&peers[j]->have, piece))
|
|
++tab[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool
|
|
peerIsSeed (const tr_peer * peer)
|
|
{
|
|
if (peer->progress >= 1.0)
|
|
return true;
|
|
|
|
if (peer->atom && atomIsSeed (peer->atom))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/* count how many bytes we want that connected peers have */
|
|
uint64_t
|
|
tr_peerMgrGetDesiredAvailable (const tr_torrent * tor)
|
|
{
|
|
size_t i;
|
|
size_t n;
|
|
uint64_t desiredAvailable;
|
|
const Torrent * t = tor->torrentPeers;
|
|
|
|
/* common shortcuts... */
|
|
|
|
if (tr_torrentIsSeed (t->tor))
|
|
return 0;
|
|
|
|
if (!tr_torrentHasMetadata (tor))
|
|
return 0;
|
|
|
|
n = tr_ptrArraySize (&t->peers);
|
|
if (n == 0)
|
|
return 0;
|
|
else {
|
|
const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
|
|
for (i=0; i<n; ++i)
|
|
if (peers[i]->atom && atomIsSeed (peers[i]->atom))
|
|
return tr_cpLeftUntilDone (&tor->completion);
|
|
}
|
|
|
|
if (!t->pieceReplication || !t->pieceReplicationSize)
|
|
return 0;
|
|
|
|
/* do it the hard way */
|
|
|
|
desiredAvailable = 0;
|
|
for (i=0, n=MIN (tor->info.pieceCount, t->pieceReplicationSize); i<n; ++i)
|
|
if (!tor->info.pieces[i].dnd && (t->pieceReplication[i] > 0))
|
|
desiredAvailable += tr_cpMissingBytesInPiece (&t->tor->completion, i);
|
|
|
|
assert (desiredAvailable <= tor->info.totalSize);
|
|
return desiredAvailable;
|
|
}
|
|
|
|
void
|
|
tr_peerMgrTorrentStats (tr_torrent * tor,
|
|
int * setmePeersConnected,
|
|
int * setmeWebseedsSendingToUs,
|
|
int * setmePeersSendingToUs,
|
|
int * setmePeersGettingFromUs,
|
|
int * setmePeersFrom)
|
|
{
|
|
int i;
|
|
int size;
|
|
Torrent * t;
|
|
const tr_peer ** peers;
|
|
|
|
assert (tr_isTorrent (tor));
|
|
|
|
*setmePeersConnected = 0;
|
|
*setmePeersGettingFromUs = 0;
|
|
*setmePeersSendingToUs = 0;
|
|
*setmeWebseedsSendingToUs = 0;
|
|
|
|
t = tor->torrentPeers;
|
|
size = tr_ptrArraySize (&t->peers);
|
|
peers = (const tr_peer **) tr_ptrArrayBase (&t->peers);
|
|
|
|
for (i=0; i<TR_PEER_FROM__MAX; ++i)
|
|
setmePeersFrom[i] = 0;
|
|
|
|
for (i=0; i<size; ++i)
|
|
{
|
|
const tr_peer * peer = peers[i];
|
|
const struct peer_atom * atom = peer->atom;
|
|
|
|
if (peer->io == NULL) /* not connected */
|
|
continue;
|
|
|
|
++*setmePeersConnected;
|
|
|
|
++setmePeersFrom[atom->fromFirst];
|
|
|
|
if (clientIsDownloadingFrom (tor, peer))
|
|
++*setmePeersSendingToUs;
|
|
|
|
if (clientIsUploadingTo (peer))
|
|
++*setmePeersGettingFromUs;
|
|
}
|
|
|
|
*setmeWebseedsSendingToUs = countActiveWebseeds (t);
|
|
}
|
|
|
|
double*
|
|
tr_peerMgrWebSpeeds_KBps (const tr_torrent * tor)
|
|
{
|
|
unsigned int i;
|
|
unsigned int webseedCount;
|
|
const Torrent * t;
|
|
const tr_webseed ** webseeds;
|
|
double * ret = NULL;
|
|
const uint64_t now = tr_time_msec ();
|
|
|
|
assert (tr_isTorrent (tor));
|
|
|
|
t = tor->torrentPeers;
|
|
webseedCount = tr_ptrArraySize (&t->webseeds);
|
|
webseeds = (const tr_webseed**) tr_ptrArrayBase (&t->webseeds);
|
|
ret = tr_new0 (double, webseedCount);
|
|
|
|
assert (t->manager != NULL);
|
|
assert (webseedCount == tor->info.webseedCount);
|
|
|
|
for (i=0; i<webseedCount; ++i)
|
|
{
|
|
unsigned int Bps;
|
|
if (tr_webseedGetSpeed_Bps (webseeds[i], now, &Bps))
|
|
ret[i] = Bps / (double)tr_speed_K;
|
|
else
|
|
ret[i] = -1.0;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
unsigned int
|
|
tr_peerGetPieceSpeed_Bps (const tr_peer * peer, uint64_t now, tr_direction direction)
|
|
{
|
|
return peer->io ? tr_peerIoGetPieceSpeed_Bps (peer->io, now, direction) : 0.0;
|
|
}
|
|
|
|
struct tr_peer_stat *
|
|
tr_peerMgrPeerStats (const tr_torrent * tor, int * setmeCount)
|
|
{
|
|
int i;
|
|
int size = 0;
|
|
tr_peer_stat * ret;
|
|
const Torrent * t;
|
|
const tr_peer ** peers;
|
|
const time_t now = tr_time ();
|
|
const uint64_t now_msec = tr_time_msec ();
|
|
|
|
assert (tr_isTorrent (tor));
|
|
assert (tor->torrentPeers->manager != NULL);
|
|
|
|
t = tor->torrentPeers;
|
|
peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
|
|
size = tr_ptrArraySize (&t->peers);
|
|
ret = tr_new0 (tr_peer_stat, size);
|
|
|
|
for (i=0; i<size; ++i)
|
|
{
|
|
char * pch;
|
|
const tr_peer * peer = peers[i];
|
|
const struct peer_atom * atom = peer->atom;
|
|
tr_peer_stat * stat = ret + i;
|
|
|
|
tr_address_to_string_with_buf (&atom->addr, stat->addr, sizeof (stat->addr));
|
|
tr_strlcpy (stat->client, tr_quark_get_string(peer->client,NULL), sizeof (stat->client));
|
|
stat->port = ntohs (peer->atom->port);
|
|
stat->from = atom->fromFirst;
|
|
stat->progress = peer->progress;
|
|
stat->isUTP = peer->io->utp_socket != NULL;
|
|
stat->isEncrypted = tr_peerIoIsEncrypted (peer->io) ? 1 : 0;
|
|
stat->rateToPeer_KBps = toSpeedKBps (tr_peerGetPieceSpeed_Bps (peer, now_msec, TR_CLIENT_TO_PEER));
|
|
stat->rateToClient_KBps = toSpeedKBps (tr_peerGetPieceSpeed_Bps (peer, now_msec, TR_PEER_TO_CLIENT));
|
|
stat->peerIsChoked = peer->peerIsChoked;
|
|
stat->peerIsInterested = peer->peerIsInterested;
|
|
stat->clientIsChoked = peer->clientIsChoked;
|
|
stat->clientIsInterested = peer->clientIsInterested;
|
|
stat->isIncoming = tr_peerIoIsIncoming (peer->io);
|
|
stat->isDownloadingFrom = clientIsDownloadingFrom (tor, peer);
|
|
stat->isUploadingTo = clientIsUploadingTo (peer);
|
|
stat->isSeed = peerIsSeed (peer);
|
|
|
|
stat->blocksToPeer = tr_historyGet (&peer->blocksSentToPeer, now, CANCEL_HISTORY_SEC);
|
|
stat->blocksToClient = tr_historyGet (&peer->blocksSentToClient, now, CANCEL_HISTORY_SEC);
|
|
stat->cancelsToPeer = tr_historyGet (&peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC);
|
|
stat->cancelsToClient = tr_historyGet (&peer->cancelsSentToClient, now, CANCEL_HISTORY_SEC);
|
|
|
|
stat->pendingReqsToPeer = peer->pendingReqsToPeer;
|
|
stat->pendingReqsToClient = peer->pendingReqsToClient;
|
|
|
|
pch = stat->flagStr;
|
|
if (stat->isUTP) *pch++ = 'T';
|
|
if (t->optimistic == peer) *pch++ = 'O';
|
|
if (stat->isDownloadingFrom) *pch++ = 'D';
|
|
else if (stat->clientIsInterested) *pch++ = 'd';
|
|
if (stat->isUploadingTo) *pch++ = 'U';
|
|
else if (stat->peerIsInterested) *pch++ = 'u';
|
|
if (!stat->clientIsChoked && !stat->clientIsInterested) *pch++ = 'K';
|
|
if (!stat->peerIsChoked && !stat->peerIsInterested) *pch++ = '?';
|
|
if (stat->isEncrypted) *pch++ = 'E';
|
|
if (stat->from == TR_PEER_FROM_DHT) *pch++ = 'H';
|
|
else if (stat->from == TR_PEER_FROM_PEX) *pch++ = 'X';
|
|
if (stat->isIncoming) *pch++ = 'I';
|
|
*pch = '\0';
|
|
}
|
|
|
|
*setmeCount = size;
|
|
return ret;
|
|
}
|
|
|
|
/***
|
|
****
|
|
****
|
|
***/
|
|
|
|
void
|
|
tr_peerMgrClearInterest (tr_torrent * tor)
|
|
{
|
|
int i;
|
|
Torrent * t = tor->torrentPeers;
|
|
const int peerCount = tr_ptrArraySize (&t->peers);
|
|
|
|
assert (tr_isTorrent (tor));
|
|
assert (tr_torrentIsLocked (tor));
|
|
|
|
for (i=0; i<peerCount; ++i)
|
|
{
|
|
const tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
|
|
tr_peerMsgsSetInterested (peer->msgs, false);
|
|
}
|
|
}
|
|
|
|
/* does this peer have any pieces that we want? */
|
|
static bool
|
|
isPeerInteresting (tr_torrent * const tor,
|
|
const bool * const piece_is_interesting,
|
|
const tr_peer * const peer)
|
|
{
|
|
tr_piece_index_t i, n;
|
|
|
|
/* these cases should have already been handled by the calling code... */
|
|
assert (!tr_torrentIsSeed (tor));
|
|
assert (tr_torrentIsPieceTransferAllowed (tor, TR_PEER_TO_CLIENT));
|
|
|
|
if (peerIsSeed (peer))
|
|
return true;
|
|
|
|
for (i=0, n=tor->info.pieceCount; i<n; ++i)
|
|
if (piece_is_interesting[i] && tr_bitfieldHas (&peer->have, i))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
typedef enum
|
|
{
|
|
RECHOKE_STATE_GOOD,
|
|
RECHOKE_STATE_UNTESTED,
|
|
RECHOKE_STATE_BAD
|
|
}
|
|
tr_rechoke_state;
|
|
|
|
struct tr_rechoke_info
|
|
{
|
|
tr_peer * peer;
|
|
int salt;
|
|
int rechoke_state;
|
|
};
|
|
|
|
static int
|
|
compare_rechoke_info (const void * va, const void * vb)
|
|
{
|
|
const struct tr_rechoke_info * a = va;
|
|
const struct tr_rechoke_info * b = vb;
|
|
|
|
if (a->rechoke_state != b->rechoke_state)
|
|
return a->rechoke_state - b->rechoke_state;
|
|
|
|
return a->salt - b->salt;
|
|
}
|
|
|
|
/* determines who we send "interested" messages to */
|
|
static void
|
|
rechokeDownloads (Torrent * t)
|
|
{
|
|
int i;
|
|
int maxPeers = 0;
|
|
int rechoke_count = 0;
|
|
struct tr_rechoke_info * rechoke = NULL;
|
|
const int MIN_INTERESTING_PEERS = 5;
|
|
const int peerCount = tr_ptrArraySize (&t->peers);
|
|
const time_t now = tr_time ();
|
|
|
|
/* some cases where this function isn't necessary */
|
|
if (tr_torrentIsSeed (t->tor))
|
|
return;
|
|
if (!tr_torrentIsPieceTransferAllowed (t->tor, TR_PEER_TO_CLIENT))
|
|
return;
|
|
|
|
/* decide HOW MANY peers to be interested in */
|
|
{
|
|
int blocks = 0;
|
|
int cancels = 0;
|
|
time_t timeSinceCancel;
|
|
|
|
/* Count up how many blocks & cancels each peer has.
|
|
*
|
|
* There are two situations where we send out cancels --
|
|
*
|
|
* 1. We've got unresponsive peers, which is handled by deciding
|
|
* -which- peers to be interested in.
|
|
*
|
|
* 2. We've hit our bandwidth cap, which is handled by deciding
|
|
* -how many- peers to be interested in.
|
|
*
|
|
* We're working on 2. here, so we need to ignore unresponsive
|
|
* peers in our calculations lest they confuse Transmission into
|
|
* thinking it's hit its bandwidth cap.
|
|
*/
|
|
for (i=0; i<peerCount; ++i)
|
|
{
|
|
const tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
|
|
const int b = tr_historyGet (&peer->blocksSentToClient, now, CANCEL_HISTORY_SEC);
|
|
const int c = tr_historyGet (&peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC);
|
|
|
|
if (b == 0) /* ignore unresponsive peers, as described above */
|
|
continue;
|
|
|
|
blocks += b;
|
|
cancels += c;
|
|
}
|
|
|
|
if (cancels > 0)
|
|
{
|
|
/* cancelRate: of the block requests we've recently made, the percentage we cancelled.
|
|
* higher values indicate more congestion. */
|
|
const double cancelRate = cancels / (double)(cancels + blocks);
|
|
const double mult = 1 - MIN (cancelRate, 0.5);
|
|
maxPeers = t->interestedCount * mult;
|
|
tordbg (t, "cancel rate is %.3f -- reducing the "
|
|
"number of peers we're interested in by %.0f percent",
|
|
cancelRate, mult * 100);
|
|
t->lastCancel = now;
|
|
}
|
|
|
|
timeSinceCancel = now - t->lastCancel;
|
|
if (timeSinceCancel)
|
|
{
|
|
const int maxIncrease = 15;
|
|
const time_t maxHistory = 2 * CANCEL_HISTORY_SEC;
|
|
const double mult = MIN (timeSinceCancel, maxHistory) / (double) maxHistory;
|
|
const int inc = maxIncrease * mult;
|
|
maxPeers = t->maxPeers + inc;
|
|
tordbg (t, "time since last cancel is %li -- increasing the "
|
|
"number of peers we're interested in by %d",
|
|
timeSinceCancel, inc);
|
|
}
|
|
}
|
|
|
|
/* don't let the previous section's number tweaking go too far... */
|
|
if (maxPeers < MIN_INTERESTING_PEERS)
|
|
maxPeers = MIN_INTERESTING_PEERS;
|
|
if (maxPeers > t->tor->maxConnectedPeers)
|
|
maxPeers = t->tor->maxConnectedPeers;
|
|
|
|
t->maxPeers = maxPeers;
|
|
|
|
if (peerCount > 0)
|
|
{
|
|
bool * piece_is_interesting;
|
|
const tr_torrent * const tor = t->tor;
|
|
const int n = tor->info.pieceCount;
|
|
|
|
/* build a bitfield of interesting pieces... */
|
|
piece_is_interesting = tr_new (bool, n);
|
|
for (i=0; i<n; i++)
|
|
piece_is_interesting[i] = !tor->info.pieces[i].dnd && !tr_cpPieceIsComplete (&tor->completion, i);
|
|
|
|
/* decide WHICH peers to be interested in (based on their cancel-to-block ratio) */
|
|
for (i=0; i<peerCount; ++i)
|
|
{
|
|
tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
|
|
|
|
if (!isPeerInteresting (t->tor, piece_is_interesting, peer))
|
|
{
|
|
tr_peerMsgsSetInterested (peer->msgs, false);
|
|
}
|
|
else
|
|
{
|
|
tr_rechoke_state rechoke_state;
|
|
const int blocks = tr_historyGet (&peer->blocksSentToClient, now, CANCEL_HISTORY_SEC);
|
|
const int cancels = tr_historyGet (&peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC);
|
|
|
|
if (!blocks && !cancels)
|
|
rechoke_state = RECHOKE_STATE_UNTESTED;
|
|
else if (!cancels)
|
|
rechoke_state = RECHOKE_STATE_GOOD;
|
|
else if (!blocks)
|
|
rechoke_state = RECHOKE_STATE_BAD;
|
|
else if ((cancels * 10) < blocks)
|
|
rechoke_state = RECHOKE_STATE_GOOD;
|
|
else
|
|
rechoke_state = RECHOKE_STATE_BAD;
|
|
|
|
if (rechoke == NULL)
|
|
rechoke = tr_new (struct tr_rechoke_info, peerCount);
|
|
|
|
rechoke[rechoke_count].peer = peer;
|
|
rechoke[rechoke_count].rechoke_state = rechoke_state;
|
|
rechoke[rechoke_count].salt = tr_cryptoWeakRandInt (INT_MAX);
|
|
rechoke_count++;
|
|
}
|
|
|
|
}
|
|
|
|
tr_free (piece_is_interesting);
|
|
}
|
|
|
|
/* now that we know which & how many peers to be interested in... update the peer interest */
|
|
qsort (rechoke, rechoke_count, sizeof (struct tr_rechoke_info), compare_rechoke_info);
|
|
t->interestedCount = MIN (maxPeers, rechoke_count);
|
|
for (i=0; i<rechoke_count; ++i)
|
|
tr_peerMsgsSetInterested (rechoke[i].peer->msgs, i<t->interestedCount);
|
|
|
|
/* cleanup */
|
|
tr_free (rechoke);
|
|
}
|
|
|
|
/**
|
|
***
|
|
**/
|
|
|
|
struct ChokeData
|
|
{
|
|
bool isInterested;
|
|
bool wasChoked;
|
|
bool isChoked;
|
|
int rate;
|
|
int salt;
|
|
tr_peer * peer;
|
|
};
|
|
|
|
static int
|
|
compareChoke (const void * va, const void * vb)
|
|
{
|
|
const struct ChokeData * a = va;
|
|
const struct ChokeData * b = vb;
|
|
|
|
if (a->rate != b->rate) /* prefer higher overall speeds */
|
|
return a->rate > b->rate ? -1 : 1;
|
|
|
|
if (a->wasChoked != b->wasChoked) /* prefer unchoked */
|
|
return a->wasChoked ? 1 : -1;
|
|
|
|
if (a->salt != b->salt) /* random order */
|
|
return a->salt - b->salt;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* is this a new connection? */
|
|
static int
|
|
isNew (const tr_peer * peer)
|
|
{
|
|
return peer && peer->io && tr_peerIoGetAge (peer->io) < 45;
|
|
}
|
|
|
|
/* get a rate for deciding which peers to choke and unchoke. */
|
|
static int
|
|
getRate (const tr_torrent * tor, struct peer_atom * atom, uint64_t now)
|
|
{
|
|
unsigned int Bps;
|
|
|
|
if (tr_torrentIsSeed (tor))
|
|
Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_CLIENT_TO_PEER);
|
|
|
|
/* downloading a private torrent... take upload speed into account
|
|
* because there may only be a small window of opportunity to share */
|
|
else if (tr_torrentIsPrivate (tor))
|
|
Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_PEER_TO_CLIENT)
|
|
+ tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_CLIENT_TO_PEER);
|
|
|
|
/* downloading a public torrent */
|
|
else
|
|
Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_PEER_TO_CLIENT);
|
|
|
|
/* convert it to bytes per second */
|
|
return Bps;
|
|
}
|
|
|
|
static inline bool
|
|
isBandwidthMaxedOut (const tr_bandwidth * b,
|
|
const uint64_t now_msec, tr_direction dir)
|
|
{
|
|
if (!tr_bandwidthIsLimited (b, dir))
|
|
return false;
|
|
else {
|
|
const unsigned int got = tr_bandwidthGetPieceSpeed_Bps (b, now_msec, dir);
|
|
const unsigned int want = tr_bandwidthGetDesiredSpeed_Bps (b, dir);
|
|
return got >= want;
|
|
}
|
|
}
|
|
|
|
static void
|
|
rechokeUploads (Torrent * t, const uint64_t now)
|
|
{
|
|
int i, size, unchokedInterested;
|
|
const int peerCount = tr_ptrArraySize (&t->peers);
|
|
tr_peer ** peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
|
|
struct ChokeData * choke = tr_new0 (struct ChokeData, peerCount);
|
|
const tr_session * session = t->manager->session;
|
|
const int chokeAll = !tr_torrentIsPieceTransferAllowed (t->tor, TR_CLIENT_TO_PEER);
|
|
const bool isMaxedOut = isBandwidthMaxedOut (&t->tor->bandwidth, now, TR_UP);
|
|
|
|
assert (torrentIsLocked (t));
|
|
|
|
/* an optimistic unchoke peer's "optimistic"
|
|
* state lasts for N calls to rechokeUploads (). */
|
|
if (t->optimisticUnchokeTimeScaler > 0)
|
|
t->optimisticUnchokeTimeScaler--;
|
|
else
|
|
t->optimistic = NULL;
|
|
|
|
/* sort the peers by preference and rate */
|
|
for (i = 0, size = 0; i < peerCount; ++i)
|
|
{
|
|
tr_peer * peer = peers[i];
|
|
struct peer_atom * atom = peer->atom;
|
|
|
|
if (peerIsSeed (peer)) /* choke seeds and partial seeds */
|
|
{
|
|
tr_peerMsgsSetChoke (peer->msgs, true);
|
|
}
|
|
else if (chokeAll) /* choke everyone if we're not uploading */
|
|
{
|
|
tr_peerMsgsSetChoke (peer->msgs, true);
|
|
}
|
|
else if (peer != t->optimistic)
|
|
{
|
|
struct ChokeData * n = &choke[size++];
|
|
n->peer = peer;
|
|
n->isInterested = peer->peerIsInterested;
|
|
n->wasChoked = peer->peerIsChoked;
|
|
n->rate = getRate (t->tor, atom, now);
|
|
n->salt = tr_cryptoWeakRandInt (INT_MAX);
|
|
n->isChoked = true;
|
|
}
|
|
}
|
|
|
|
qsort (choke, size, sizeof (struct ChokeData), compareChoke);
|
|
|
|
/**
|
|
* Reciprocation and number of uploads capping is managed by unchoking
|
|
* the N peers which have the best upload rate and are interested.
|
|
* This maximizes the client's download rate. These N peers are
|
|
* referred to as downloaders, because they are interested in downloading
|
|
* from the client.
|
|
*
|
|
* Peers which have a better upload rate (as compared to the downloaders)
|
|
* but aren't interested get unchoked. If they become interested, the
|
|
* downloader with the worst upload rate gets choked. If a client has
|
|
* a complete file, it uses its upload rate rather than its download
|
|
* rate to decide which peers to unchoke.
|
|
*
|
|
* If our bandwidth is maxed out, don't unchoke any more peers.
|
|
*/
|
|
unchokedInterested = 0;
|
|
for (i=0; i<size && unchokedInterested<session->uploadSlotsPerTorrent; ++i) {
|
|
choke[i].isChoked = isMaxedOut ? choke[i].wasChoked : false;
|
|
if (choke[i].isInterested)
|
|
++unchokedInterested;
|
|
}
|
|
|
|
/* optimistic unchoke */
|
|
if (!t->optimistic && !isMaxedOut && (i<size))
|
|
{
|
|
int n;
|
|
struct ChokeData * c;
|
|
tr_ptrArray randPool = TR_PTR_ARRAY_INIT;
|
|
|
|
for (; i<size; ++i)
|
|
{
|
|
if (choke[i].isInterested)
|
|
{
|
|
const tr_peer * peer = choke[i].peer;
|
|
int x = 1, y;
|
|
if (isNew (peer)) x *= 3;
|
|
for (y=0; y<x; ++y)
|
|
tr_ptrArrayAppend (&randPool, &choke[i]);
|
|
}
|
|
}
|
|
|
|
if ((n = tr_ptrArraySize (&randPool)))
|
|
{
|
|
c = tr_ptrArrayNth (&randPool, tr_cryptoWeakRandInt (n));
|
|
c->isChoked = false;
|
|
t->optimistic = c->peer;
|
|
t->optimisticUnchokeTimeScaler = OPTIMISTIC_UNCHOKE_MULTIPLIER;
|
|
}
|
|
|
|
tr_ptrArrayDestruct (&randPool, NULL);
|
|
}
|
|
|
|
for (i=0; i<size; ++i)
|
|
tr_peerMsgsSetChoke (choke[i].peer->msgs, choke[i].isChoked);
|
|
|
|
/* cleanup */
|
|
tr_free (choke);
|
|
}
|
|
|
|
static void
|
|
rechokePulse (int foo UNUSED, short bar UNUSED, void * vmgr)
|
|
{
|
|
tr_torrent * tor = NULL;
|
|
tr_peerMgr * mgr = vmgr;
|
|
const uint64_t now = tr_time_msec ();
|
|
|
|
managerLock (mgr);
|
|
|
|
while ((tor = tr_torrentNext (mgr->session, tor))) {
|
|
if (tor->isRunning) {
|
|
Torrent * t = tor->torrentPeers;
|
|
if (!tr_ptrArrayEmpty (&t->peers)) {
|
|
rechokeUploads (t, now);
|
|
rechokeDownloads (t);
|
|
}
|
|
}
|
|
}
|
|
|
|
tr_timerAddMsec (mgr->rechokeTimer, RECHOKE_PERIOD_MSEC);
|
|
managerUnlock (mgr);
|
|
}
|
|
|
|
/***
|
|
****
|
|
**** Life and Death
|
|
****
|
|
***/
|
|
|
|
static bool
|
|
shouldPeerBeClosed (const Torrent * t,
|
|
const tr_peer * peer,
|
|
int peerCount,
|
|
const time_t now)
|
|
{
|
|
const tr_torrent * tor = t->tor;
|
|
const struct peer_atom * atom = peer->atom;
|
|
|
|
/* if it's marked for purging, close it */
|
|
if (peer->doPurge)
|
|
{
|
|
tordbg (t, "purging peer %s because its doPurge flag is set",
|
|
tr_atomAddrStr (atom));
|
|
return true;
|
|
}
|
|
|
|
/* disconnect if we're both seeds and enough time has passed for PEX */
|
|
if (tr_torrentIsSeed (tor) && peerIsSeed (peer))
|
|
return !tr_torrentAllowsPex (tor) || (now-atom->time>=30);
|
|
|
|
/* disconnect if it's been too long since piece data has been transferred.
|
|
* this is on a sliding scale based on number of available peers... */
|
|
{
|
|
const int relaxStrictnessIfFewerThanN = (int)((getMaxPeerCount (tor) * 0.9) + 0.5);
|
|
/* if we have >= relaxIfFewerThan, strictness is 100%.
|
|
* if we have zero connections, strictness is 0% */
|
|
const float strictness = peerCount >= relaxStrictnessIfFewerThanN
|
|
? 1.0
|
|
: peerCount / (float)relaxStrictnessIfFewerThanN;
|
|
const int lo = MIN_UPLOAD_IDLE_SECS;
|
|
const int hi = MAX_UPLOAD_IDLE_SECS;
|
|
const int limit = hi - ((hi - lo) * strictness);
|
|
const int idleTime = now - MAX (atom->time, atom->piece_data_time);
|
|
/*fprintf (stderr, "strictness is %.3f, limit is %d seconds... time since connect is %d, time since piece is %d ... idleTime is %d, doPurge is %d\n", (double)strictness, limit, (int)(now - atom->time), (int)(now - atom->piece_data_time), idleTime, idleTime > limit);*/
|
|
if (idleTime > limit) {
|
|
tordbg (t, "purging peer %s because it's been %d secs since we shared anything",
|
|
tr_atomAddrStr (atom), idleTime);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static tr_peer **
|
|
getPeersToClose (Torrent * t, const time_t now_sec, int * setmeSize)
|
|
{
|
|
int i, peerCount, outsize;
|
|
struct tr_peer ** ret = NULL;
|
|
tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek (&t->peers, &peerCount);
|
|
|
|
assert (torrentIsLocked (t));
|
|
|
|
for (i = outsize = 0; i < peerCount; ++i) {
|
|
if (shouldPeerBeClosed (t, peers[i], peerCount, now_sec)) {
|
|
if (ret == NULL)
|
|
ret = tr_new (tr_peer *, peerCount);
|
|
ret[outsize++] = peers[i];
|
|
}
|
|
}
|
|
|
|
*setmeSize = outsize;
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
getReconnectIntervalSecs (const struct peer_atom * atom, const time_t now)
|
|
{
|
|
int sec;
|
|
|
|
/* if we were recently connected to this peer and transferring piece
|
|
* data, try to reconnect to them sooner rather that later -- we don't
|
|
* want network troubles to get in the way of a good peer. */
|
|
if ((now - atom->piece_data_time) <= (MINIMUM_RECONNECT_INTERVAL_SECS * 2))
|
|
sec = MINIMUM_RECONNECT_INTERVAL_SECS;
|
|
|
|
/* don't allow reconnects more often than our minimum */
|
|
else if ((now - atom->time) < MINIMUM_RECONNECT_INTERVAL_SECS)
|
|
sec = MINIMUM_RECONNECT_INTERVAL_SECS;
|
|
|
|
/* otherwise, the interval depends on how many times we've tried
|
|
* and failed to connect to the peer */
|
|
else switch (atom->numFails) {
|
|
case 0: sec = 0; break;
|
|
case 1: sec = 5; break;
|
|
case 2: sec = 2 * 60; break;
|
|
case 3: sec = 15 * 60; break;
|
|
case 4: sec = 30 * 60; break;
|
|
case 5: sec = 60 * 60; break;
|
|
default: sec = 120 * 60; break;
|
|
}
|
|
|
|
/* penalize peers that were unreachable the last time we tried */
|
|
if (atom->flags2 & MYFLAG_UNREACHABLE)
|
|
sec += sec;
|
|
|
|
dbgmsg ("reconnect interval for %s is %d seconds", tr_atomAddrStr (atom), sec);
|
|
return sec;
|
|
}
|
|
|
|
static void
|
|
removePeer (Torrent * t, tr_peer * peer)
|
|
{
|
|
tr_peer * removed;
|
|
struct peer_atom * atom = peer->atom;
|
|
|
|
assert (torrentIsLocked (t));
|
|
assert (atom);
|
|
|
|
atom->time = tr_time ();
|
|
|
|
removed = tr_ptrArrayRemoveSorted (&t->peers, peer, peerCompare);
|
|
|
|
if (replicationExists (t))
|
|
tr_decrReplicationFromBitfield (t, &peer->have);
|
|
|
|
assert (removed == peer);
|
|
peerDelete (t, removed);
|
|
}
|
|
|
|
static void
|
|
closePeer (Torrent * t, tr_peer * peer)
|
|
{
|
|
struct peer_atom * atom;
|
|
|
|
assert (t != NULL);
|
|
assert (peer != NULL);
|
|
|
|
atom = peer->atom;
|
|
|
|
/* if we transferred piece data, then they might be good peers,
|
|
so reset their `numFails' weight to zero. otherwise we connected
|
|
to them fruitlessly, so mark it as another fail */
|
|
if (atom->piece_data_time) {
|
|
tordbg (t, "resetting atom %s numFails to 0", tr_atomAddrStr (atom));
|
|
atom->numFails = 0;
|
|
} else {
|
|
++atom->numFails;
|
|
tordbg (t, "incremented atom %s numFails to %d", tr_atomAddrStr (atom), (int)atom->numFails);
|
|
}
|
|
|
|
tordbg (t, "removing bad peer %s", tr_peerIoGetAddrStr (peer->io));
|
|
removePeer (t, peer);
|
|
}
|
|
|
|
static void
|
|
removeAllPeers (Torrent * t)
|
|
{
|
|
while (!tr_ptrArrayEmpty (&t->peers))
|
|
removePeer (t, tr_ptrArrayNth (&t->peers, 0));
|
|
}
|
|
|
|
static void
|
|
closeBadPeers (Torrent * t, const time_t now_sec)
|
|
{
|
|
if (!tr_ptrArrayEmpty (&t->peers))
|
|
{
|
|
int i;
|
|
int peerCount;
|
|
struct tr_peer ** peers = getPeersToClose (t, now_sec, &peerCount);
|
|
for (i=0; i<peerCount; ++i)
|
|
closePeer (t, peers[i]);
|
|
tr_free (peers);
|
|
}
|
|
}
|
|
|
|
struct peer_liveliness
|
|
{
|
|
tr_peer * peer;
|
|
void * clientData;
|
|
time_t pieceDataTime;
|
|
time_t time;
|
|
int speed;
|
|
bool doPurge;
|
|
};
|
|
|
|
static int
|
|
comparePeerLiveliness (const void * va, const void * vb)
|
|
{
|
|
const struct peer_liveliness * a = va;
|
|
const struct peer_liveliness * b = vb;
|
|
|
|
if (a->doPurge != b->doPurge)
|
|
return a->doPurge ? 1 : -1;
|
|
|
|
if (a->speed != b->speed) /* faster goes first */
|
|
return a->speed > b->speed ? -1 : 1;
|
|
|
|
/* the one to give us data more recently goes first */
|
|
if (a->pieceDataTime != b->pieceDataTime)
|
|
return a->pieceDataTime > b->pieceDataTime ? -1 : 1;
|
|
|
|
/* the one we connected to most recently goes first */
|
|
if (a->time != b->time)
|
|
return a->time > b->time ? -1 : 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
sortPeersByLivelinessImpl (tr_peer ** peers,
|
|
void ** clientData,
|
|
int n,
|
|
uint64_t now,
|
|
int (*compare)(const void *va, const void *vb))
|
|
{
|
|
int i;
|
|
struct peer_liveliness *lives, *l;
|
|
|
|
/* build a sortable array of peer + extra info */
|
|
lives = l = tr_new0 (struct peer_liveliness, n);
|
|
for (i=0; i<n; ++i, ++l)
|
|
{
|
|
tr_peer * p = peers[i];
|
|
l->peer = p;
|
|
l->doPurge = p->doPurge;
|
|
l->pieceDataTime = p->atom->piece_data_time;
|
|
l->time = p->atom->time;
|
|
l->speed = tr_peerGetPieceSpeed_Bps (p, now, TR_UP)
|
|
+ tr_peerGetPieceSpeed_Bps (p, now, TR_DOWN);
|
|
if (clientData)
|
|
l->clientData = clientData[i];
|
|
}
|
|
|
|
/* sort 'em */
|
|
assert (n == (l - lives));
|
|
qsort (lives, n, sizeof (struct peer_liveliness), compare);
|
|
|
|
/* build the peer array */
|
|
for (i=0, l=lives; i<n; ++i, ++l) {
|
|
peers[i] = l->peer;
|
|
if (clientData)
|
|
clientData[i] = l->clientData;
|
|
}
|
|
assert (n == (l - lives));
|
|
|
|
/* cleanup */
|
|
tr_free (lives);
|
|
}
|
|
|
|
static void
|
|
sortPeersByLiveliness (tr_peer ** peers, void ** clientData, int n, uint64_t now)
|
|
{
|
|
sortPeersByLivelinessImpl (peers, clientData, n, now, comparePeerLiveliness);
|
|
}
|
|
|
|
|
|
static void
|
|
enforceTorrentPeerLimit (Torrent * t, uint64_t now)
|
|
{
|
|
int n = tr_ptrArraySize (&t->peers);
|
|
const int max = tr_torrentGetPeerLimit (t->tor);
|
|
if (n > max)
|
|
{
|
|
void * base = tr_ptrArrayBase (&t->peers);
|
|
tr_peer ** peers = tr_memdup (base, n*sizeof (tr_peer*));
|
|
sortPeersByLiveliness (peers, NULL, n, now);
|
|
while (n > max)
|
|
closePeer (t, peers[--n]);
|
|
tr_free (peers);
|
|
}
|
|
}
|
|
|
|
static void
|
|
enforceSessionPeerLimit (tr_session * session, uint64_t now)
|
|
{
|
|
int n = 0;
|
|
tr_torrent * tor = NULL;
|
|
const int max = tr_sessionGetPeerLimit (session);
|
|
|
|
/* count the total number of peers */
|
|
while ((tor = tr_torrentNext (session, tor)))
|
|
n += tr_ptrArraySize (&tor->torrentPeers->peers);
|
|
|
|
/* if there are too many, prune out the worst */
|
|
if (n > max)
|
|
{
|
|
tr_peer ** peers = tr_new (tr_peer*, n);
|
|
Torrent ** torrents = tr_new (Torrent*, n);
|
|
|
|
/* populate the peer array */
|
|
n = 0;
|
|
tor = NULL;
|
|
while ((tor = tr_torrentNext (session, tor))) {
|
|
int i;
|
|
Torrent * t = tor->torrentPeers;
|
|
const int tn = tr_ptrArraySize (&t->peers);
|
|
for (i=0; i<tn; ++i, ++n) {
|
|
peers[n] = tr_ptrArrayNth (&t->peers, i);
|
|
torrents[n] = t;
|
|
}
|
|
}
|
|
|
|
/* sort 'em */
|
|
sortPeersByLiveliness (peers, (void**)torrents, n, now);
|
|
|
|
/* cull out the crappiest */
|
|
while (n-- > max)
|
|
closePeer (torrents[n], peers[n]);
|
|
|
|
/* cleanup */
|
|
tr_free (torrents);
|
|
tr_free (peers);
|
|
}
|
|
}
|
|
|
|
static void makeNewPeerConnections (tr_peerMgr * mgr, const int max);
|
|
|
|
static void
|
|
reconnectPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
|
|
{
|
|
tr_torrent * tor;
|
|
tr_peerMgr * mgr = vmgr;
|
|
const time_t now_sec = tr_time ();
|
|
const uint64_t now_msec = tr_time_msec ();
|
|
|
|
/**
|
|
*** enforce the per-session and per-torrent peer limits
|
|
**/
|
|
|
|
/* if we're over the per-torrent peer limits, cull some peers */
|
|
tor = NULL;
|
|
while ((tor = tr_torrentNext (mgr->session, tor)))
|
|
if (tor->isRunning)
|
|
enforceTorrentPeerLimit (tor->torrentPeers, now_msec);
|
|
|
|
/* if we're over the per-session peer limits, cull some peers */
|
|
enforceSessionPeerLimit (mgr->session, now_msec);
|
|
|
|
/* remove crappy peers */
|
|
tor = NULL;
|
|
while ((tor = tr_torrentNext (mgr->session, tor)))
|
|
if (!tor->torrentPeers->isRunning)
|
|
removeAllPeers (tor->torrentPeers);
|
|
else
|
|
closeBadPeers (tor->torrentPeers, now_sec);
|
|
|
|
/* try to make new peer connections */
|
|
makeNewPeerConnections (mgr, MAX_CONNECTIONS_PER_PULSE);
|
|
}
|
|
|
|
/****
|
|
*****
|
|
***** BANDWIDTH ALLOCATION
|
|
*****
|
|
****/
|
|
|
|
static void
|
|
pumpAllPeers (tr_peerMgr * mgr)
|
|
{
|
|
tr_torrent * tor = NULL;
|
|
|
|
while ((tor = tr_torrentNext (mgr->session, tor)))
|
|
{
|
|
int j;
|
|
Torrent * t = tor->torrentPeers;
|
|
|
|
for (j=0; j<tr_ptrArraySize (&t->peers); ++j)
|
|
{
|
|
tr_peer * peer = tr_ptrArrayNth (&t->peers, j);
|
|
tr_peerMsgsPulse (peer->msgs);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
queuePulseForeach (void * vtor)
|
|
{
|
|
tr_torrent * tor = vtor;
|
|
|
|
tr_torrentStartNow (tor);
|
|
|
|
if (tor->queue_started_callback != NULL)
|
|
(*tor->queue_started_callback)(tor, tor->queue_started_user_data);
|
|
}
|
|
|
|
static void
|
|
queuePulse (tr_session * session, tr_direction dir)
|
|
{
|
|
assert (tr_isSession (session));
|
|
assert (tr_isDirection (dir));
|
|
|
|
if (tr_sessionGetQueueEnabled (session, dir))
|
|
{
|
|
tr_ptrArray torrents = TR_PTR_ARRAY_INIT;
|
|
|
|
tr_sessionGetNextQueuedTorrents (session,
|
|
dir,
|
|
tr_sessionCountQueueFreeSlots (session, dir),
|
|
&torrents);
|
|
|
|
tr_ptrArrayForeach (&torrents, queuePulseForeach);
|
|
|
|
tr_ptrArrayDestruct (&torrents, NULL);
|
|
}
|
|
}
|
|
|
|
static void
|
|
bandwidthPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
|
|
{
|
|
tr_torrent * tor;
|
|
tr_peerMgr * mgr = vmgr;
|
|
tr_session * session = mgr->session;
|
|
managerLock (mgr);
|
|
|
|
/* FIXME: this next line probably isn't necessary... */
|
|
pumpAllPeers (mgr);
|
|
|
|
/* allocate bandwidth to the peers */
|
|
tr_bandwidthAllocate (&session->bandwidth, TR_UP, BANDWIDTH_PERIOD_MSEC);
|
|
tr_bandwidthAllocate (&session->bandwidth, TR_DOWN, BANDWIDTH_PERIOD_MSEC);
|
|
|
|
/* torrent upkeep */
|
|
tor = NULL;
|
|
while ((tor = tr_torrentNext (session, tor)))
|
|
{
|
|
/* possibly stop torrents that have seeded enough */
|
|
tr_torrentCheckSeedLimit (tor);
|
|
|
|
/* run the completeness check for any torrents that need it */
|
|
if (tor->torrentPeers->needsCompletenessCheck) {
|
|
tor->torrentPeers->needsCompletenessCheck = false;
|
|
tr_torrentRecheckCompleteness (tor);
|
|
}
|
|
|
|
/* stop torrents that are ready to stop, but couldn't be stopped
|
|
earlier during the peer-io callback call chain */
|
|
if (tor->isStopping)
|
|
tr_torrentStop (tor);
|
|
}
|
|
|
|
/* pump the queues */
|
|
queuePulse (session, TR_UP);
|
|
queuePulse (session, TR_DOWN);
|
|
|
|
reconnectPulse (0, 0, mgr);
|
|
|
|
tr_timerAddMsec (mgr->bandwidthTimer, BANDWIDTH_PERIOD_MSEC);
|
|
managerUnlock (mgr);
|
|
}
|
|
|
|
/***
|
|
****
|
|
***/
|
|
|
|
static int
|
|
compareAtomPtrsByAddress (const void * va, const void *vb)
|
|
{
|
|
const struct peer_atom * a = * (const struct peer_atom**) va;
|
|
const struct peer_atom * b = * (const struct peer_atom**) vb;
|
|
|
|
assert (tr_isAtom (a));
|
|
assert (tr_isAtom (b));
|
|
|
|
return tr_address_compare (&a->addr, &b->addr);
|
|
}
|
|
|
|
/* best come first, worst go last */
|
|
static int
|
|
compareAtomPtrsByShelfDate (const void * va, const void *vb)
|
|
{
|
|
time_t atime;
|
|
time_t btime;
|
|
const struct peer_atom * a = * (const struct peer_atom**) va;
|
|
const struct peer_atom * b = * (const struct peer_atom**) vb;
|
|
const int data_time_cutoff_secs = 60 * 60;
|
|
const time_t tr_now = tr_time ();
|
|
|
|
assert (tr_isAtom (a));
|
|
assert (tr_isAtom (b));
|
|
|
|
/* primary key: the last piece data time *if* it was within the last hour */
|
|
atime = a->piece_data_time; if (atime + data_time_cutoff_secs < tr_now) atime = 0;
|
|
btime = b->piece_data_time; if (btime + data_time_cutoff_secs < tr_now) btime = 0;
|
|
if (atime != btime)
|
|
return atime > btime ? -1 : 1;
|
|
|
|
/* secondary key: shelf date. */
|
|
if (a->shelf_date != b->shelf_date)
|
|
return a->shelf_date > b->shelf_date ? -1 : 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
getMaxAtomCount (const tr_torrent * tor)
|
|
{
|
|
return MIN (50, tor->maxConnectedPeers * 3);
|
|
}
|
|
|
|
static void
|
|
atomPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
|
|
{
|
|
tr_torrent * tor = NULL;
|
|
tr_peerMgr * mgr = vmgr;
|
|
managerLock (mgr);
|
|
|
|
while ((tor = tr_torrentNext (mgr->session, tor)))
|
|
{
|
|
int atomCount;
|
|
Torrent * t = tor->torrentPeers;
|
|
const int maxAtomCount = getMaxAtomCount (tor);
|
|
struct peer_atom ** atoms = (struct peer_atom**) tr_ptrArrayPeek (&t->pool, &atomCount);
|
|
|
|
if (atomCount > maxAtomCount) /* we've got too many atoms... time to prune */
|
|
{
|
|
int i;
|
|
int keepCount = 0;
|
|
int testCount = 0;
|
|
struct peer_atom ** keep = tr_new (struct peer_atom*, atomCount);
|
|
struct peer_atom ** test = tr_new (struct peer_atom*, atomCount);
|
|
|
|
/* keep the ones that are in use */
|
|
for (i=0; i<atomCount; ++i) {
|
|
struct peer_atom * atom = atoms[i];
|
|
if (peerIsInUse (t, atom))
|
|
keep[keepCount++] = atom;
|
|
else
|
|
test[testCount++] = atom;
|
|
}
|
|
|
|
/* if there's room, keep the best of what's left */
|
|
i = 0;
|
|
if (keepCount < maxAtomCount) {
|
|
qsort (test, testCount, sizeof (struct peer_atom *), compareAtomPtrsByShelfDate);
|
|
while (i<testCount && keepCount<maxAtomCount)
|
|
keep[keepCount++] = test[i++];
|
|
}
|
|
|
|
/* free the culled atoms */
|
|
while (i<testCount)
|
|
tr_free (test[i++]);
|
|
|
|
/* rebuild Torrent.pool with what's left */
|
|
tr_ptrArrayDestruct (&t->pool, NULL);
|
|
t->pool = TR_PTR_ARRAY_INIT;
|
|
qsort (keep, keepCount, sizeof (struct peer_atom *), compareAtomPtrsByAddress);
|
|
for (i=0; i<keepCount; ++i)
|
|
tr_ptrArrayAppend (&t->pool, keep[i]);
|
|
|
|
tordbg (t, "max atom count is %d... pruned from %d to %d\n", maxAtomCount, atomCount, keepCount);
|
|
|
|
/* cleanup */
|
|
tr_free (test);
|
|
tr_free (keep);
|
|
}
|
|
}
|
|
|
|
tr_timerAddMsec (mgr->atomTimer, ATOM_PERIOD_MSEC);
|
|
managerUnlock (mgr);
|
|
}
|
|
|
|
/***
|
|
****
|
|
****
|
|
****
|
|
***/
|
|
|
|
/* is this atom someone that we'd want to initiate a connection to? */
|
|
static bool
|
|
isPeerCandidate (const tr_torrent * tor, struct peer_atom * atom, const time_t now)
|
|
{
|
|
/* not if we're both seeds */
|
|
if (tr_torrentIsSeed (tor) && atomIsSeed (atom))
|
|
return false;
|
|
|
|
/* not if we've already got a connection to them... */
|
|
if (peerIsInUse (tor->torrentPeers, atom))
|
|
return false;
|
|
|
|
/* not if we just tried them already */
|
|
if ((now - atom->time) < getReconnectIntervalSecs (atom, now))
|
|
return false;
|
|
|
|
/* not if they're blocklisted */
|
|
if (isAtomBlocklisted (tor->session, atom))
|
|
return false;
|
|
|
|
/* not if they're banned... */
|
|
if (atom->flags2 & MYFLAG_BANNED)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
struct peer_candidate
|
|
{
|
|
uint64_t score;
|
|
tr_torrent * tor;
|
|
struct peer_atom * atom;
|
|
};
|
|
|
|
static bool
|
|
torrentWasRecentlyStarted (const tr_torrent * tor)
|
|
{
|
|
return difftime (tr_time (), tor->startDate) < 120;
|
|
}
|
|
|
|
static inline uint64_t
|
|
addValToKey (uint64_t value, int width, uint64_t addme)
|
|
{
|
|
value = (value << (uint64_t)width);
|
|
value |= addme;
|
|
return value;
|
|
}
|
|
|
|
/* smaller value is better */
|
|
static uint64_t
|
|
getPeerCandidateScore (const tr_torrent * tor, const struct peer_atom * atom, uint8_t salt)
|
|
{
|
|
uint64_t i;
|
|
uint64_t score = 0;
|
|
const bool failed = atom->lastConnectionAt < atom->lastConnectionAttemptAt;
|
|
|
|
/* prefer peers we've connected to, or never tried, over peers we failed to connect to. */
|
|
i = failed ? 1 : 0;
|
|
score = addValToKey (score, 1, i);
|
|
|
|
/* prefer the one we attempted least recently (to cycle through all peers) */
|
|
i = atom->lastConnectionAttemptAt;
|
|
score = addValToKey (score, 32, i);
|
|
|
|
/* prefer peers belonging to a torrent of a higher priority */
|
|
switch (tr_torrentGetPriority (tor)) {
|
|
case TR_PRI_HIGH: i = 0; break;
|
|
case TR_PRI_NORMAL: i = 1; break;
|
|
case TR_PRI_LOW: i = 2; break;
|
|
}
|
|
score = addValToKey (score, 4, i);
|
|
|
|
/* prefer recently-started torrents */
|
|
i = torrentWasRecentlyStarted (tor) ? 0 : 1;
|
|
score = addValToKey (score, 1, i);
|
|
|
|
/* prefer torrents we're downloading with */
|
|
i = tr_torrentIsSeed (tor) ? 1 : 0;
|
|
score = addValToKey (score, 1, i);
|
|
|
|
/* prefer peers that are known to be connectible */
|
|
i = (atom->flags & ADDED_F_CONNECTABLE) ? 0 : 1;
|
|
score = addValToKey (score, 1, i);
|
|
|
|
/* prefer peers that we might have a chance of uploading to...
|
|
so lower seed probability is better */
|
|
if (atom->seedProbability == 100) i = 101;
|
|
else if (atom->seedProbability == -1) i = 100;
|
|
else i = atom->seedProbability;
|
|
score = addValToKey (score, 8, i);
|
|
|
|
/* Prefer peers that we got from more trusted sources.
|
|
* lower `fromBest' values indicate more trusted sources */
|
|
score = addValToKey (score, 4, atom->fromBest);
|
|
|
|
/* salt */
|
|
score = addValToKey (score, 8, salt);
|
|
|
|
return score;
|
|
}
|
|
|
|
static int
|
|
comparePeerCandidates (const void * va, const void * vb)
|
|
{
|
|
int ret;
|
|
const struct peer_candidate * a = va;
|
|
const struct peer_candidate * b = vb;
|
|
|
|
if (a->score < b->score)
|
|
ret = -1;
|
|
else if (a->score > b->score)
|
|
ret = 1;
|
|
else
|
|
ret = 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Partial sorting -- selecting the k best candidates
|
|
Adapted from http://en.wikipedia.org/wiki/Selection_algorithm */
|
|
static void
|
|
selectPeerCandidates (struct peer_candidate * candidates, int candidate_count, int select_count)
|
|
{
|
|
tr_quickfindFirstK (candidates,
|
|
candidate_count,
|
|
sizeof(struct peer_candidate),
|
|
comparePeerCandidates,
|
|
select_count);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
static bool
|
|
checkBestScoresComeFirst (const struct peer_candidate * candidates, int n, int k)
|
|
{
|
|
int i;
|
|
uint64_t worstFirstScore = 0;
|
|
const int x = MIN (n, k) - 1;
|
|
|
|
for (i=0; i<x; i++)
|
|
if (worstFirstScore < candidates[i].score)
|
|
worstFirstScore = candidates[i].score;
|
|
|
|
for (i=0; i<x; i++)
|
|
assert (candidates[i].score <= worstFirstScore);
|
|
|
|
for (i=x+1; i<n; i++)
|
|
assert (candidates[i].score >= worstFirstScore);
|
|
|
|
return true;
|
|
}
|
|
#endif /* NDEBUG */
|
|
|
|
/** @return an array of all the atoms we might want to connect to */
|
|
static struct peer_candidate*
|
|
getPeerCandidates (tr_session * session, int * candidateCount, int max)
|
|
{
|
|
int atomCount;
|
|
int peerCount;
|
|
tr_torrent * tor;
|
|
struct peer_candidate * candidates;
|
|
struct peer_candidate * walk;
|
|
const time_t now = tr_time ();
|
|
const uint64_t now_msec = tr_time_msec ();
|
|
/* leave 5% of connection slots for incoming connections -- ticket #2609 */
|
|
const int maxCandidates = tr_sessionGetPeerLimit (session) * 0.95;
|
|
|
|
/* count how many peers and atoms we've got */
|
|
tor= NULL;
|
|
atomCount = 0;
|
|
peerCount = 0;
|
|
while ((tor = tr_torrentNext (session, tor))) {
|
|
atomCount += tr_ptrArraySize (&tor->torrentPeers->pool);
|
|
peerCount += tr_ptrArraySize (&tor->torrentPeers->peers);
|
|
}
|
|
|
|
/* don't start any new handshakes if we're full up */
|
|
if (maxCandidates <= peerCount) {
|
|
*candidateCount = 0;
|
|
return NULL;
|
|
}
|
|
|
|
/* allocate an array of candidates */
|
|
walk = candidates = tr_new (struct peer_candidate, atomCount);
|
|
|
|
/* populate the candidate array */
|
|
tor = NULL;
|
|
while ((tor = tr_torrentNext (session, tor)))
|
|
{
|
|
int i, nAtoms;
|
|
struct peer_atom ** atoms;
|
|
|
|
if (!tor->torrentPeers->isRunning)
|
|
continue;
|
|
|
|
/* if we've already got enough peers in this torrent... */
|
|
if (tr_torrentGetPeerLimit (tor) <= tr_ptrArraySize (&tor->torrentPeers->peers))
|
|
continue;
|
|
|
|
/* if we've already got enough speed in this torrent... */
|
|
if (tr_torrentIsSeed (tor) && isBandwidthMaxedOut (&tor->bandwidth, now_msec, TR_UP))
|
|
continue;
|
|
|
|
atoms = (struct peer_atom**) tr_ptrArrayPeek (&tor->torrentPeers->pool, &nAtoms);
|
|
for (i=0; i<nAtoms; ++i)
|
|
{
|
|
struct peer_atom * atom = atoms[i];
|
|
|
|
if (isPeerCandidate (tor, atom, now))
|
|
{
|
|
const uint8_t salt = tr_cryptoWeakRandInt (1024);
|
|
walk->tor = tor;
|
|
walk->atom = atom;
|
|
walk->score = getPeerCandidateScore (tor, atom, salt);
|
|
++walk;
|
|
}
|
|
}
|
|
}
|
|
|
|
*candidateCount = walk - candidates;
|
|
if (walk != candidates)
|
|
selectPeerCandidates (candidates, walk-candidates, max);
|
|
|
|
assert (checkBestScoresComeFirst (candidates, *candidateCount, max));
|
|
|
|
return candidates;
|
|
}
|
|
|
|
static void
|
|
initiateConnection (tr_peerMgr * mgr, Torrent * t, struct peer_atom * atom)
|
|
{
|
|
tr_peerIo * io;
|
|
const time_t now = tr_time ();
|
|
bool utp = tr_sessionIsUTPEnabled (mgr->session) && !atom->utp_failed;
|
|
|
|
if (atom->fromFirst == TR_PEER_FROM_PEX)
|
|
/* PEX has explicit signalling for uTP support. If an atom
|
|
originally came from PEX and doesn't have the uTP flag, skip the
|
|
uTP connection attempt. Are we being optimistic here? */
|
|
utp = utp && (atom->flags & ADDED_F_UTP_FLAGS);
|
|
|
|
tordbg (t, "Starting an OUTGOING%s connection with %s",
|
|
utp ? " µTP" : "",
|
|
tr_atomAddrStr (atom));
|
|
|
|
io = tr_peerIoNewOutgoing (mgr->session,
|
|
&mgr->session->bandwidth,
|
|
&atom->addr,
|
|
atom->port,
|
|
t->tor->info.hash,
|
|
t->tor->completeness == TR_SEED,
|
|
utp);
|
|
|
|
if (io == NULL)
|
|
{
|
|
tordbg (t, "peerIo not created; marking peer %s as unreachable",
|
|
tr_atomAddrStr (atom));
|
|
atom->flags2 |= MYFLAG_UNREACHABLE;
|
|
atom->numFails++;
|
|
}
|
|
else
|
|
{
|
|
tr_handshake * handshake = tr_handshakeNew (io,
|
|
mgr->session->encryptionMode,
|
|
myHandshakeDoneCB,
|
|
mgr);
|
|
|
|
assert (tr_peerIoGetTorrentHash (io));
|
|
|
|
tr_peerIoUnref (io); /* balanced by the initial ref
|
|
in tr_peerIoNewOutgoing () */
|
|
|
|
tr_ptrArrayInsertSorted (&t->outgoingHandshakes, handshake,
|
|
handshakeCompare);
|
|
}
|
|
|
|
atom->lastConnectionAttemptAt = now;
|
|
atom->time = now;
|
|
}
|
|
|
|
static void
|
|
initiateCandidateConnection (tr_peerMgr * mgr, struct peer_candidate * c)
|
|
{
|
|
#if 0
|
|
fprintf (stderr, "Starting an OUTGOING connection with %s - [%s] seedProbability==%d; %s, %s\n",
|
|
tr_atomAddrStr (c->atom),
|
|
tr_torrentName (c->tor),
|
|
(int)c->atom->seedProbability,
|
|
tr_torrentIsPrivate (c->tor) ? "private" : "public",
|
|
tr_torrentIsSeed (c->tor) ? "seed" : "downloader");
|
|
#endif
|
|
|
|
initiateConnection (mgr, c->tor->torrentPeers, c->atom);
|
|
}
|
|
|
|
static void
|
|
makeNewPeerConnections (struct tr_peerMgr * mgr, const int max)
|
|
{
|
|
int i, n;
|
|
struct peer_candidate * candidates;
|
|
|
|
candidates = getPeerCandidates (mgr->session, &n, max);
|
|
|
|
for (i=0; i<n && i<max; ++i)
|
|
initiateCandidateConnection (mgr, &candidates[i]);
|
|
|
|
tr_free (candidates);
|
|
}
|