Documentation improved, some reindenting (again), variable types checked, unnecessary defines removed

1 files changed, 62 insertions, 63 deletions

diff --git a/trackerlogic.c b/trackerlogic.c
index 85e8156..2b8ffaf 100644
--- a/trackerlogic.c
+++ b/trackerlogic.c
@@ -22,8 +22,7 @@
 #include <sys/stat.h>
 #endif
 
-// GLOBAL VARIABLES
-//
+/* GLOBAL VARIABLES */
 static ot_vector all_torrents[256];
 
 #ifdef WANT_CLOSED_TRACKER
@@ -36,36 +35,37 @@ int g_check_blacklist = 1;
 static ot_torrent* const OT_TORRENT_ON_BLACKLIST = (ot_torrent*)2;
 #endif
 
-// 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
-// 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,
-                            int compare_size, int *exactmatch ) {
+/* 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
+   calling functions the chance to insert data
+*/
+static void *binary_search( const void * const key, const void * base, const size_t member_count, const size_t member_size,
+                            size_t compare_size, int *exactmatch ) {
+  size_t mc = member_count;
   ot_byte *lookat = ((ot_byte*)base) + member_size * (member_count >> 1);
   *exactmatch = 1;
 
-  while( member_count ) {
+  while( mc ) {
     int cmp = memcmp( lookat, key, compare_size);
     if (cmp == 0) return (void *)lookat;
     if (cmp < 0) {
       base = (void*)(lookat + member_size);
-      --member_count;
+      --mc;
     }
-    member_count >>= 1;
-    lookat = ((ot_byte*)base) + member_size * (member_count >> 1);
+    mc >>= 1;
+    lookat = ((ot_byte*)base) + member_size * (mc >> 1);
   }
   *exactmatch = 0;
   return (void*)lookat;
 }
 
-// Converter function from memory to human readable hex strings
-// * definitely not thread safe!!!
-//
+/* Converter function from memory to human readable hex strings
+   - 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;}
 
 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;
 
@@ -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 );
     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);
 
     vector->data = new_data;
     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++;
   return match;
 }
@@ -91,11 +91,11 @@ static int vector_remove_peer( ot_vector *vector, ot_peer *peer ) {
   ot_peer *match;
 
   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;
   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 ) ) {
     vector->space /= OT_VECTOR_SHRINK_RATIO;
     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;
 
   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 this is being called after a unsuccessful malloc() for peer_list
-  // in add_peer_to_torrent, match->peer_list actually might be NULL
+  /* If this is being called after a unsuccessful malloc() for peer_list
+     in add_peer_to_torrent, match->peer_list actually might be NULL */
   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 ) ) {
     vector->space /= OT_VECTOR_SHRINK_RATIO;
     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;
 }
 
-// Returns 1, if torrent is gone, 0 otherwise
+/* Returns 1, if torrent is gone, 0 otherwise */
 static int clean_peerlist( ot_peerlist *peer_list ) {
-  long timedout = NOW-peer_list->base;
-  int i;
+  int i, timedout = (int)( NOW - peer_list->base );
 
   if( !timedout ) return 0;
   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);
 
-  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 );
 
-  MEMMOVE( peer_list->seed_count + timedout, peer_list->seed_count, sizeof( unsigned long ) * (OT_POOLS_COUNT-timedout) );
-  byte_zero( peer_list->seed_count, sizeof( unsigned long ) * 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( size_t ) * timedout );
 
   peer_list->base = NOW;
   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( !exactmatch ) {
-    // Create a new torrent entry, then
-    MEMMOVE( &torrent->hash, hash, sizeof( ot_hash ) );
+    /* Create a new torrent entry, then */
+    memmove( &torrent->hash, hash, sizeof( ot_hash ) );
 
     torrent->peer_list = malloc( sizeof (ot_peerlist) );
     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_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
-  // remove it from all older pools
+  /* If we hadn't had a match in current pool, create peer there and
+     remove it from all older pools */
   if( !exactmatch ) {
     int i;
-    MEMMOVE( peer_dest, peer, sizeof( ot_peer ) );
+    memmove( peer_dest, peer, sizeof( ot_peer ) );
     if( OT_FLAG(peer) & PEER_FLAG_SEEDING )
       torrent->peer_list->seed_count[0]++;
     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;
 }
 
-// Compiles a list of random peers for a torrent
-// * reply must have enough space to hold 24+6*amount bytes
-// * Selector function can be anything, maybe test for seeds, etc.
-// * RANDOM may return huge values
-// * does not yet check not to return self
-//
-size_t return_peers_for_torrent( ot_torrent *torrent, unsigned long amount, char *reply ) {
-  char           *r = reply;
-  unsigned long  peer_count, seed_count, index;
-  signed   long  pool_offset = -1, pool_index = 0;
-  signed   long  wert = -1;
+/* Compiles a list of random peers for a torrent
+   * reply must have enough space to hold 24+6*amount bytes
+   * Selector function can be anything, maybe test for seeds, etc.
+   * RANDOM may return huge values
+   * does not yet check not to return self
+*/
+size_t return_peers_for_torrent( ot_torrent *torrent, unsigned int amount, char *reply ) {
+  char        *r = reply;
+  unsigned int peer_count, seed_count, index;
+  int          pool_offset = -1, pool_index = 0, wert = -1;
 
 #ifdef WANT_CLOSED_TRACKER
   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
 
 #ifdef WANT_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
 
@@ -251,23 +253,19 @@ size_t return_peers_for_torrent( ot_torrent *torrent, unsigned long amount, char
   }
   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 ) {
     double step = 1.8*((double)( peer_count - wert - 1 ))/((double)( amount - index ));
     int off = random() % (int)floor( step );
     off = 1 + ( off % ( peer_count - wert - 1 ));
     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 ) {
       pool_offset -= torrent->peer_list->peers[pool_index].size;
       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++ = 'e';
@@ -275,12 +273,12 @@ size_t return_peers_for_torrent( ot_torrent *torrent, unsigned long amount, char
   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 ) {
   char        *r = reply;
   int          exactmatch, peers = 0, seeds = 0, i;
   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;
   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];
   }
 
-  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;
+  memmove( r, "d5:filesd20:", 12 ); memmove( r+12, hash, 20 );
+  r += sprintf( r+32, "d8:completei%de10:downloadedi%de10:incompletei%deeee", seeds, torrent->peer_list->downloaded, peers-seeds ) + 32;
 
   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 ) {
   int          exactmatch, i;
   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;
   
-  // Maybe this does the job
+  /* Maybe this does the job */
   if( clean_peerlist( torrent->peer_list ) ) {
 #ifdef WANT_CLOSED_TRACKER
     if( !g_closedtracker ) 
@@ -332,7 +330,7 @@ int init_logic( char *serverdir ) {
 
   srandom( time(NULL));
 
-  // Initialize control structures
+  /* Initialize control structures */
   byte_zero( all_torrents, sizeof (all_torrents));
 
   return 0;
@@ -340,7 +338,8 @@ int init_logic( char *serverdir ) {
 
 void deinit_logic( ) {
   int i, j;
-  // Free all torrents...
+
+  /* Free all torrents... */
   for(i=0; i<256; ++i ) {
     if( all_torrents[i].size ) {
       ot_torrent *torrents_list = (ot_torrent*)all_torrents[i].data;