|
|
|
@ -22,8 +22,7 @@
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
// GLOBAL VARIABLES
|
|
|
|
/* GLOBAL VARIABLES */
|
|
|
|
//
|
|
|
|
|
|
|
|
static ot_vector all_torrents[256];
|
|
|
|
static ot_vector all_torrents[256];
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef WANT_CLOSED_TRACKER
|
|
|
|
#ifdef WANT_CLOSED_TRACKER
|
|
|
|
@ -36,36 +35,37 @@ int g_check_blacklist = 1;
|
|
|
|
static ot_torrent* const OT_TORRENT_ON_BLACKLIST = (ot_torrent*)2;
|
|
|
|
static ot_torrent* const OT_TORRENT_ON_BLACKLIST = (ot_torrent*)2;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
// This function gives us a binary search that returns a pointer, even if
|
|
|
|
/* This function gives us a binary search that returns a pointer, even if
|
|
|
|
// no exact match is found. In that case it sets exactmatch 0 and gives
|
|
|
|
no exact match is found. In that case it sets exactmatch 0 and gives
|
|
|
|
// calling functions the chance to insert data
|
|
|
|
calling functions the chance to insert data
|
|
|
|
//
|
|
|
|
*/
|
|
|
|
static void *binary_search( const void *key, const void *base, unsigned long member_count, const unsigned long member_size,
|
|
|
|
static void *binary_search( const void * const key, const void * base, const size_t member_count, const size_t member_size,
|
|
|
|
int compare_size, int *exactmatch ) {
|
|
|
|
size_t compare_size, int *exactmatch ) {
|
|
|
|
|
|
|
|
size_t mc = member_count;
|
|
|
|
ot_byte *lookat = ((ot_byte*)base) + member_size * (member_count >> 1);
|
|
|
|
ot_byte *lookat = ((ot_byte*)base) + member_size * (member_count >> 1);
|
|
|
|
*exactmatch = 1;
|
|
|
|
*exactmatch = 1;
|
|
|
|
|
|
|
|
|
|
|
|
while( member_count ) {
|
|
|
|
while( mc ) {
|
|
|
|
int cmp = memcmp( lookat, key, compare_size);
|
|
|
|
int cmp = memcmp( lookat, key, compare_size);
|
|
|
|
if (cmp == 0) return (void *)lookat;
|
|
|
|
if (cmp == 0) return (void *)lookat;
|
|
|
|
if (cmp < 0) {
|
|
|
|
if (cmp < 0) {
|
|
|
|
base = (void*)(lookat + member_size);
|
|
|
|
base = (void*)(lookat + member_size);
|
|
|
|
--member_count;
|
|
|
|
--mc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
member_count >>= 1;
|
|
|
|
mc >>= 1;
|
|
|
|
lookat = ((ot_byte*)base) + member_size * (member_count >> 1);
|
|
|
|
lookat = ((ot_byte*)base) + member_size * (mc >> 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*exactmatch = 0;
|
|
|
|
*exactmatch = 0;
|
|
|
|
return (void*)lookat;
|
|
|
|
return (void*)lookat;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Converter function from memory to human readable hex strings
|
|
|
|
/* Converter function from memory to human readable hex strings
|
|
|
|
// * definitely not thread safe!!!
|
|
|
|
- definitely not thread safe!!!
|
|
|
|
//
|
|
|
|
*/
|
|
|
|
char ths[2+2*20]="-";char*to_hex(ot_byte*s){char*m="0123456789ABCDEF";char*e=ths+41;char*t=ths+1;while(t<e){*t++=m[*s>>4];*t++=m[*s++&15];}*t=0;return ths+1;}
|
|
|
|
char ths[2+2*20]="-";char*to_hex(ot_byte*s){char*m="0123456789ABCDEF";char*e=ths+41;char*t=ths+1;while(t<e){*t++=m[*s>>4];*t++=m[*s++&15];}*t=0;return ths+1;}
|
|
|
|
|
|
|
|
|
|
|
|
static void *vector_find_or_insert( ot_vector *vector, void *key, size_t member_size, int compare_size, int *exactmatch ) {
|
|
|
|
static void *vector_find_or_insert( ot_vector *vector, void *key, size_t member_size, int compare_size, int *exactmatch ) {
|
|
|
|
ot_byte *match = BINARY_FIND( key, vector->data, vector->size, member_size, compare_size, exactmatch );
|
|
|
|
ot_byte *match = binary_search( key, vector->data, vector->size, member_size, compare_size, exactmatch );
|
|
|
|
|
|
|
|
|
|
|
|
if( *exactmatch ) return match;
|
|
|
|
if( *exactmatch ) return match;
|
|
|
|
|
|
|
|
|
|
|
|
@ -74,13 +74,13 @@ static void *vector_find_or_insert( ot_vector *vector, void *key, size_t member_
|
|
|
|
ot_byte *new_data = realloc( vector->data, new_space * member_size );
|
|
|
|
ot_byte *new_data = realloc( vector->data, new_space * member_size );
|
|
|
|
if( !new_data ) return NULL;
|
|
|
|
if( !new_data ) return NULL;
|
|
|
|
|
|
|
|
|
|
|
|
// Adjust pointer if it moved by realloc
|
|
|
|
/* Adjust pointer if it moved by realloc */
|
|
|
|
match = new_data + (match - (ot_byte*)vector->data);
|
|
|
|
match = new_data + (match - (ot_byte*)vector->data);
|
|
|
|
|
|
|
|
|
|
|
|
vector->data = new_data;
|
|
|
|
vector->data = new_data;
|
|
|
|
vector->space = new_space;
|
|
|
|
vector->space = new_space;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
MEMMOVE( match + member_size, match, ((ot_byte*)vector->data) + member_size * vector->size - match );
|
|
|
|
memmove( match + member_size, match, ((ot_byte*)vector->data) + member_size * vector->size - match );
|
|
|
|
vector->size++;
|
|
|
|
vector->size++;
|
|
|
|
return match;
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -91,11 +91,11 @@ static int vector_remove_peer( ot_vector *vector, ot_peer *peer ) {
|
|
|
|
ot_peer *match;
|
|
|
|
ot_peer *match;
|
|
|
|
|
|
|
|
|
|
|
|
if( !vector->size ) return 0;
|
|
|
|
if( !vector->size ) return 0;
|
|
|
|
match = BINARY_FIND( peer, vector->data, vector->size, sizeof( ot_peer ), OT_PEER_COMPARE_SIZE, &exactmatch );
|
|
|
|
match = binary_search( peer, vector->data, vector->size, sizeof( ot_peer ), OT_PEER_COMPARE_SIZE, &exactmatch );
|
|
|
|
|
|
|
|
|
|
|
|
if( !exactmatch ) return 0;
|
|
|
|
if( !exactmatch ) return 0;
|
|
|
|
exactmatch = ( OT_FLAG( match ) & PEER_FLAG_SEEDING ) ? 2 : 1;
|
|
|
|
exactmatch = ( OT_FLAG( match ) & PEER_FLAG_SEEDING ) ? 2 : 1;
|
|
|
|
MEMMOVE( match, match + 1, sizeof(ot_peer) * ( end - match - 1 ) );
|
|
|
|
memmove( match, match + 1, sizeof(ot_peer) * ( end - match - 1 ) );
|
|
|
|
if( ( --vector->size * OT_VECTOR_SHRINK_THRESH < vector->space ) && ( vector->space > OT_VECTOR_MIN_MEMBERS ) ) {
|
|
|
|
if( ( --vector->size * OT_VECTOR_SHRINK_THRESH < vector->space ) && ( vector->space > OT_VECTOR_MIN_MEMBERS ) ) {
|
|
|
|
vector->space /= OT_VECTOR_SHRINK_RATIO;
|
|
|
|
vector->space /= OT_VECTOR_SHRINK_RATIO;
|
|
|
|
vector->data = realloc( vector->data, vector->space * sizeof( ot_peer ) );
|
|
|
|
vector->data = realloc( vector->data, vector->space * sizeof( ot_peer ) );
|
|
|
|
@ -117,15 +117,15 @@ static int vector_remove_torrent( ot_vector *vector, ot_hash *hash ) {
|
|
|
|
ot_torrent *match;
|
|
|
|
ot_torrent *match;
|
|
|
|
|
|
|
|
|
|
|
|
if( !vector->size ) return 0;
|
|
|
|
if( !vector->size ) return 0;
|
|
|
|
match = BINARY_FIND( hash, vector->data, vector->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
|
|
|
|
match = binary_search( hash, vector->data, vector->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
|
|
|
|
|
|
|
|
|
|
|
|
if( !exactmatch ) return 0;
|
|
|
|
if( !exactmatch ) return 0;
|
|
|
|
|
|
|
|
|
|
|
|
// If this is being called after a unsuccessful malloc() for peer_list
|
|
|
|
/* If this is being called after a unsuccessful malloc() for peer_list
|
|
|
|
// in add_peer_to_torrent, match->peer_list actually might be NULL
|
|
|
|
in add_peer_to_torrent, match->peer_list actually might be NULL */
|
|
|
|
if( match->peer_list) free_peerlist( match->peer_list );
|
|
|
|
if( match->peer_list) free_peerlist( match->peer_list );
|
|
|
|
|
|
|
|
|
|
|
|
MEMMOVE( match, match + 1, sizeof(ot_torrent) * ( end - match - 1 ) );
|
|
|
|
memmove( match, match + 1, sizeof(ot_torrent) * ( end - match - 1 ) );
|
|
|
|
if( ( --vector->size * OT_VECTOR_SHRINK_THRESH < vector->space ) && ( vector->space > OT_VECTOR_MIN_MEMBERS ) ) {
|
|
|
|
if( ( --vector->size * OT_VECTOR_SHRINK_THRESH < vector->space ) && ( vector->space > OT_VECTOR_MIN_MEMBERS ) ) {
|
|
|
|
vector->space /= OT_VECTOR_SHRINK_RATIO;
|
|
|
|
vector->space /= OT_VECTOR_SHRINK_RATIO;
|
|
|
|
vector->data = realloc( vector->data, vector->space * sizeof( ot_torrent ) );
|
|
|
|
vector->data = realloc( vector->data, vector->space * sizeof( ot_torrent ) );
|
|
|
|
@ -133,22 +133,21 @@ static int vector_remove_torrent( ot_vector *vector, ot_hash *hash ) {
|
|
|
|
return 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Returns 1, if torrent is gone, 0 otherwise
|
|
|
|
/* Returns 1, if torrent is gone, 0 otherwise */
|
|
|
|
static int clean_peerlist( ot_peerlist *peer_list ) {
|
|
|
|
static int clean_peerlist( ot_peerlist *peer_list ) {
|
|
|
|
long timedout = NOW-peer_list->base;
|
|
|
|
int i, timedout = (int)( NOW - peer_list->base );
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if( !timedout ) return 0;
|
|
|
|
if( !timedout ) return 0;
|
|
|
|
if( timedout > OT_POOLS_COUNT ) timedout = OT_POOLS_COUNT;
|
|
|
|
if( timedout > OT_POOLS_COUNT ) timedout = OT_POOLS_COUNT;
|
|
|
|
|
|
|
|
|
|
|
|
for( i=OT_POOLS_COUNT-timedout; i<OT_POOLS_COUNT; ++i )
|
|
|
|
for( i = OT_POOLS_COUNT - timedout; i < OT_POOLS_COUNT; ++i )
|
|
|
|
free( peer_list->peers[i].data);
|
|
|
|
free( peer_list->peers[i].data);
|
|
|
|
|
|
|
|
|
|
|
|
MEMMOVE( peer_list->peers + timedout, peer_list->peers, sizeof( ot_vector ) * (OT_POOLS_COUNT-timedout) );
|
|
|
|
memmove( peer_list->peers + timedout, peer_list->peers, sizeof( ot_vector ) * (OT_POOLS_COUNT-timedout) );
|
|
|
|
byte_zero( peer_list->peers, sizeof( ot_vector ) * timedout );
|
|
|
|
byte_zero( peer_list->peers, sizeof( ot_vector ) * timedout );
|
|
|
|
|
|
|
|
|
|
|
|
MEMMOVE( peer_list->seed_count + timedout, peer_list->seed_count, sizeof( unsigned long ) * (OT_POOLS_COUNT-timedout) );
|
|
|
|
memmove( peer_list->seed_count + timedout, peer_list->seed_count, sizeof( size_t ) * ( OT_POOLS_COUNT - timedout) );
|
|
|
|
byte_zero( peer_list->seed_count, sizeof( unsigned long ) * timedout );
|
|
|
|
byte_zero( peer_list->seed_count, sizeof( size_t ) * timedout );
|
|
|
|
|
|
|
|
|
|
|
|
peer_list->base = NOW;
|
|
|
|
peer_list->base = NOW;
|
|
|
|
return timedout == OT_POOLS_COUNT;
|
|
|
|
return timedout == OT_POOLS_COUNT;
|
|
|
|
@ -178,8 +177,8 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer ) {
|
|
|
|
if( !torrent ) return NULL;
|
|
|
|
if( !torrent ) return NULL;
|
|
|
|
|
|
|
|
|
|
|
|
if( !exactmatch ) {
|
|
|
|
if( !exactmatch ) {
|
|
|
|
// Create a new torrent entry, then
|
|
|
|
/* Create a new torrent entry, then */
|
|
|
|
MEMMOVE( &torrent->hash, hash, sizeof( ot_hash ) );
|
|
|
|
memmove( &torrent->hash, hash, sizeof( ot_hash ) );
|
|
|
|
|
|
|
|
|
|
|
|
torrent->peer_list = malloc( sizeof (ot_peerlist) );
|
|
|
|
torrent->peer_list = malloc( sizeof (ot_peerlist) );
|
|
|
|
if( !torrent->peer_list ) {
|
|
|
|
if( !torrent->peer_list ) {
|
|
|
|
@ -195,11 +194,11 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer ) {
|
|
|
|
peer_pool = &torrent->peer_list->peers[0];
|
|
|
|
peer_pool = &torrent->peer_list->peers[0];
|
|
|
|
peer_dest = vector_find_or_insert( peer_pool, (void*)peer, sizeof( ot_peer ), OT_PEER_COMPARE_SIZE, &exactmatch );
|
|
|
|
peer_dest = vector_find_or_insert( peer_pool, (void*)peer, sizeof( ot_peer ), OT_PEER_COMPARE_SIZE, &exactmatch );
|
|
|
|
|
|
|
|
|
|
|
|
// If we hadn't had a match in current pool, create peer there and
|
|
|
|
/* If we hadn't had a match in current pool, create peer there and
|
|
|
|
// remove it from all older pools
|
|
|
|
remove it from all older pools */
|
|
|
|
if( !exactmatch ) {
|
|
|
|
if( !exactmatch ) {
|
|
|
|
int i;
|
|
|
|
int i;
|
|
|
|
MEMMOVE( peer_dest, peer, sizeof( ot_peer ) );
|
|
|
|
memmove( peer_dest, peer, sizeof( ot_peer ) );
|
|
|
|
if( OT_FLAG(peer) & PEER_FLAG_SEEDING )
|
|
|
|
if( OT_FLAG(peer) & PEER_FLAG_SEEDING )
|
|
|
|
torrent->peer_list->seed_count[0]++;
|
|
|
|
torrent->peer_list->seed_count[0]++;
|
|
|
|
for( i=1; i<OT_POOLS_COUNT; ++i ) {
|
|
|
|
for( i=1; i<OT_POOLS_COUNT; ++i ) {
|
|
|
|
@ -221,27 +220,30 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer ) {
|
|
|
|
return torrent;
|
|
|
|
return torrent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Compiles a list of random peers for a torrent
|
|
|
|
/* Compiles a list of random peers for a torrent
|
|
|
|
// * reply must have enough space to hold 24+6*amount bytes
|
|
|
|
* reply must have enough space to hold 24+6*amount bytes
|
|
|
|
// * Selector function can be anything, maybe test for seeds, etc.
|
|
|
|
* Selector function can be anything, maybe test for seeds, etc.
|
|
|
|
// * RANDOM may return huge values
|
|
|
|
* RANDOM may return huge values
|
|
|
|
// * does not yet check not to return self
|
|
|
|
* does not yet check not to return self
|
|
|
|
//
|
|
|
|
*/
|
|
|
|
size_t return_peers_for_torrent( ot_torrent *torrent, unsigned long amount, char *reply ) {
|
|
|
|
size_t return_peers_for_torrent( ot_torrent *torrent, unsigned int amount, char *reply ) {
|
|
|
|
char *r = reply;
|
|
|
|
char *r = reply;
|
|
|
|
unsigned long peer_count, seed_count, index;
|
|
|
|
unsigned int peer_count, seed_count, index;
|
|
|
|
signed long pool_offset = -1, pool_index = 0;
|
|
|
|
int pool_offset = -1, pool_index = 0, wert = -1;
|
|
|
|
signed long wert = -1;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef WANT_CLOSED_TRACKER
|
|
|
|
#ifdef WANT_CLOSED_TRACKER
|
|
|
|
if( torrent == OT_TORRENT_NOT_ON_WHITELIST ) {
|
|
|
|
if( torrent == OT_TORRENT_NOT_ON_WHITELIST ) {
|
|
|
|
return( FORMAT_FORMAT_STRING( reply, "d14:failure reason43:This torrent is not served by this tracker.e" ) );
|
|
|
|
const char * const notvalid = "d14:failure reason43:This torrent is not served by this tracker.e";
|
|
|
|
|
|
|
|
memmove( reply, notvalid, sizeof(notvalid));
|
|
|
|
|
|
|
|
return sizeof(notvalid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef WANT_BLACKLIST
|
|
|
|
#ifdef WANT_BLACKLIST
|
|
|
|
if( torrent == OT_TORRENT_ON_BLACKLIST ) {
|
|
|
|
if( torrent == OT_TORRENT_ON_BLACKLIST ) {
|
|
|
|
return( FORMAT_FORMAT_STRING( reply, "d14:failure reason29:This torrent is black listed.e" ) );
|
|
|
|
const char * const blacklisted = "d14:failure reason29:This torrent is black listed.e";
|
|
|
|
|
|
|
|
memmove( reply, blacklisted, sizeof(blacklisted));
|
|
|
|
|
|
|
|
return sizeof(blacklisted);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
@ -251,23 +253,19 @@ size_t return_peers_for_torrent( ot_torrent *torrent, unsigned long amount, char
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( peer_count < amount ) amount = peer_count;
|
|
|
|
if( peer_count < amount ) amount = peer_count;
|
|
|
|
|
|
|
|
|
|
|
|
r += FORMAT_FORMAT_STRING( r, "d8:completei%lie10:incompletei%lie8:intervali600e5:peers%li:", seed_count, peer_count-seed_count, 6*amount );
|
|
|
|
r += sprintf( r, "d8:completei%ie10:incompletei%ie8:intervali600e5:peers%i:", seed_count, peer_count-seed_count, 6*amount );
|
|
|
|
for( index = 0; index < amount; ++index ) {
|
|
|
|
for( index = 0; index < amount; ++index ) {
|
|
|
|
double step = 1.8*((double)( peer_count - wert - 1 ))/((double)( amount - index ));
|
|
|
|
double step = 1.8*((double)( peer_count - wert - 1 ))/((double)( amount - index ));
|
|
|
|
int off = random() % (int)floor( step );
|
|
|
|
int off = random() % (int)floor( step );
|
|
|
|
off = 1 + ( off % ( peer_count - wert - 1 ));
|
|
|
|
off = 1 + ( off % ( peer_count - wert - 1 ));
|
|
|
|
wert += off; pool_offset += off;
|
|
|
|
wert += off; pool_offset += off;
|
|
|
|
|
|
|
|
|
|
|
|
// In some rare occasions random gets the last peer a round to early
|
|
|
|
|
|
|
|
// correct that and return last peer twice
|
|
|
|
|
|
|
|
// if( wert >= peer_count ) { wert--; pool_offset--; }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
while( pool_offset >= torrent->peer_list->peers[pool_index].size ) {
|
|
|
|
while( pool_offset >= torrent->peer_list->peers[pool_index].size ) {
|
|
|
|
pool_offset -= torrent->peer_list->peers[pool_index].size;
|
|
|
|
pool_offset -= torrent->peer_list->peers[pool_index].size;
|
|
|
|
pool_index++;
|
|
|
|
pool_index++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
MEMMOVE( r, ((ot_peer*)torrent->peer_list->peers[pool_index].data) + pool_offset, 6 );
|
|
|
|
memmove( r, ((ot_peer*)torrent->peer_list->peers[pool_index].data) + pool_offset, 6 );
|
|
|
|
r += 6;
|
|
|
|
r += 6;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*r++ = 'e';
|
|
|
|
*r++ = 'e';
|
|
|
|
@ -275,12 +273,12 @@ size_t return_peers_for_torrent( ot_torrent *torrent, unsigned long amount, char
|
|
|
|
return r - reply;
|
|
|
|
return r - reply;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Fetches scrape info for a specific torrent
|
|
|
|
/* Fetches scrape info for a specific torrent */
|
|
|
|
size_t return_scrape_for_torrent( ot_hash *hash, char *reply ) {
|
|
|
|
size_t return_scrape_for_torrent( ot_hash *hash, char *reply ) {
|
|
|
|
char *r = reply;
|
|
|
|
char *r = reply;
|
|
|
|
int exactmatch, peers = 0, seeds = 0, i;
|
|
|
|
int exactmatch, peers = 0, seeds = 0, i;
|
|
|
|
ot_vector *torrents_list = &all_torrents[*hash[0]];
|
|
|
|
ot_vector *torrents_list = &all_torrents[*hash[0]];
|
|
|
|
ot_torrent *torrent = BINARY_FIND( hash, torrents_list->data, torrents_list->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
|
|
|
|
ot_torrent *torrent = binary_search( hash, torrents_list->data, torrents_list->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
|
|
|
|
|
|
|
|
|
|
|
|
if( !exactmatch ) return 0;
|
|
|
|
if( !exactmatch ) return 0;
|
|
|
|
clean_peerlist( torrent->peer_list );
|
|
|
|
clean_peerlist( torrent->peer_list );
|
|
|
|
@ -290,8 +288,8 @@ size_t return_scrape_for_torrent( ot_hash *hash, char *reply ) {
|
|
|
|
seeds += torrent->peer_list->seed_count[i];
|
|
|
|
seeds += torrent->peer_list->seed_count[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
MEMMOVE( r, "d5:filesd20:", 12 ); MEMMOVE( r+12, hash, 20 );
|
|
|
|
memmove( r, "d5:filesd20:", 12 ); memmove( r+12, hash, 20 );
|
|
|
|
r += FORMAT_FORMAT_STRING( r+32, "d8:completei%de10:downloadedi%lde10:incompletei%deeee", seeds, torrent->peer_list->downloaded, peers-seeds ) + 32;
|
|
|
|
r += sprintf( r+32, "d8:completei%de10:downloadedi%de10:incompletei%deeee", seeds, torrent->peer_list->downloaded, peers-seeds ) + 32;
|
|
|
|
|
|
|
|
|
|
|
|
return r - reply;
|
|
|
|
return r - reply;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -299,11 +297,11 @@ size_t return_scrape_for_torrent( ot_hash *hash, char *reply ) {
|
|
|
|
void remove_peer_from_torrent( ot_hash *hash, ot_peer *peer ) {
|
|
|
|
void remove_peer_from_torrent( ot_hash *hash, ot_peer *peer ) {
|
|
|
|
int exactmatch, i;
|
|
|
|
int exactmatch, i;
|
|
|
|
ot_vector *torrents_list = &all_torrents[*hash[0]];
|
|
|
|
ot_vector *torrents_list = &all_torrents[*hash[0]];
|
|
|
|
ot_torrent *torrent = BINARY_FIND( hash, torrents_list->data, torrents_list->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
|
|
|
|
ot_torrent *torrent = binary_search( hash, torrents_list->data, torrents_list->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
|
|
|
|
|
|
|
|
|
|
|
|
if( !exactmatch ) return;
|
|
|
|
if( !exactmatch ) return;
|
|
|
|
|
|
|
|
|
|
|
|
// Maybe this does the job
|
|
|
|
/* Maybe this does the job */
|
|
|
|
if( clean_peerlist( torrent->peer_list ) ) {
|
|
|
|
if( clean_peerlist( torrent->peer_list ) ) {
|
|
|
|
#ifdef WANT_CLOSED_TRACKER
|
|
|
|
#ifdef WANT_CLOSED_TRACKER
|
|
|
|
if( !g_closedtracker )
|
|
|
|
if( !g_closedtracker )
|
|
|
|
@ -332,7 +330,7 @@ int init_logic( char *serverdir ) {
|
|
|
|
|
|
|
|
|
|
|
|
srandom( time(NULL));
|
|
|
|
srandom( time(NULL));
|
|
|
|
|
|
|
|
|
|
|
|
// Initialize control structures
|
|
|
|
/* Initialize control structures */
|
|
|
|
byte_zero( all_torrents, sizeof (all_torrents));
|
|
|
|
byte_zero( all_torrents, sizeof (all_torrents));
|
|
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
return 0;
|
|
|
|
@ -340,7 +338,8 @@ int init_logic( char *serverdir ) {
|
|
|
|
|
|
|
|
|
|
|
|
void deinit_logic( ) {
|
|
|
|
void deinit_logic( ) {
|
|
|
|
int i, j;
|
|
|
|
int i, j;
|
|
|
|
// Free all torrents...
|
|
|
|
|
|
|
|
|
|
|
|
/* Free all torrents... */
|
|
|
|
for(i=0; i<256; ++i ) {
|
|
|
|
for(i=0; i<256; ++i ) {
|
|
|
|
if( all_torrents[i].size ) {
|
|
|
|
if( all_torrents[i].size ) {
|
|
|
|
ot_torrent *torrents_list = (ot_torrent*)all_torrents[i].data;
|
|
|
|
ot_torrent *torrents_list = (ot_torrent*)all_torrents[i].data;
|
|
|
|
|
erdgeist
18 years ago