|
|
|
@ -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