summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--Makefile6
-rw-r--r--opentracker.c2
-rw-r--r--ot_clean.c119
-rw-r--r--ot_clean.h15
-rw-r--r--ot_mutex.c31
-rw-r--r--ot_mutex.h9
-rw-r--r--ot_stats.c201
-rw-r--r--ot_stats.h13
-rw-r--r--ot_sync.c107
-rw-r--r--ot_sync.h14
-rw-r--r--ot_vector.c110
-rw-r--r--ot_vector.h26
-rw-r--r--trackerlogic.c600
-rw-r--r--trackerlogic.h48
14 files changed, 723 insertions, 578 deletions
diff --git a/Makefile b/Makefile
index 4dd8957..2360025 100644
--- a/Makefile
+++ b/Makefile
@@ -1,13 +1,13 @@
CC?=gcc
-FEATURES=#-DWANT_CLOSED_TRACKER -DWANT_UTORRENT1600_WORKAROUND #-DWANT_IP_FROM_QUERY_STRING -D_DEBUG_HTTPERROR -DWANT_TRACKER_SYNC
+FEATURES=-DWANT_TRACKER_SYNC #-DWANT_CLOSED_TRACKER -DWANT_UTORRENT1600_WORKAROUND #-DWANT_IP_FROM_QUERY_STRING -D_DEBUG_HTTPERROR -DWANT_TRACKER_SYNC
OPTS_debug=-g -ggdb #-pg # -fprofile-arcs -ftest-coverage
OPTS_production=-s -Os
CFLAGS+=-I../libowfat -Wall -pipe -Wextra #-pedantic #-ansi
LDFLAGS+=-L../libowfat/ -lowfat
BINARY = opentracker
-HEADERS=trackerlogic.h scan_urlencoded_query.h mutex.h
-SOURCES=opentracker.c trackerlogic.c scan_urlencoded_query.c mutex.c
+HEADERS=trackerlogic.h scan_urlencoded_query.h ot_mutex.h ot_stats.h ot_sync.h ot_vector.h ot_clean.h
+SOURCES=opentracker.c trackerlogic.c scan_urlencoded_query.c ot_mutex.c ot_stats.c ot_sync.c ot_vector.c ot_clean.c
all: $(BINARY) $(BINARY).debug
diff --git a/opentracker.c b/opentracker.c
index 00fe65f..0345177 100644
--- a/opentracker.c
+++ b/opentracker.c
@@ -29,6 +29,8 @@
#include "trackerlogic.h"
#include "scan_urlencoded_query.h"
+#include "ot_stats.h"
+#include "ot_sync.h"
/* Globals */
static unsigned long long ot_overall_tcp_connections = 0;
diff --git a/ot_clean.c b/ot_clean.c
new file mode 100644
index 0000000..46b3e0c
--- /dev/null
+++ b/ot_clean.c
@@ -0,0 +1,119 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+ It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+/* System */
+#include <stdlib.h>
+#include <string.h>
+
+/* Libowfat */
+#include "byte.h"
+
+/* Opentracker */
+#include "trackerlogic.h"
+#include "ot_mutex.h"
+
+/* To remember, when we last cleaned up */
+static ot_time all_torrents_clean[OT_BUCKET_COUNT];
+
+/* Clean a single torrent
+ return 1 if torrent timed out
+*/
+int clean_single_torrent( ot_torrent *torrent ) {
+ ot_peerlist *peer_list = torrent->peer_list;
+ size_t peers_count = 0, seeds_count;
+ time_t timedout = (int)( NOW - peer_list->base );
+ int i;
+#ifdef WANT_TRACKER_SYNC
+ char *new_peers;
+#endif
+
+ /* Torrent has idled out */
+ if( timedout > OT_TORRENT_TIMEOUT )
+ return 1;
+
+ /* Nothing to be cleaned here? Test if torrent is worth keeping */
+ if( timedout > OT_POOLS_COUNT ) {
+ if( !peer_list->peer_count )
+ return peer_list->down_count ? 0 : 1;
+ timedout = OT_POOLS_COUNT;
+ }
+
+ /* Release vectors that have timed out */
+ for( i = OT_POOLS_COUNT - timedout; i < OT_POOLS_COUNT; ++i )
+ free( peer_list->peers[i].data);
+
+ /* Shift vectors back by the amount of pools that were shifted out */
+ memmove( peer_list->peers + timedout, peer_list->peers, sizeof( ot_vector ) * ( OT_POOLS_COUNT - timedout ) );
+ byte_zero( peer_list->peers, sizeof( ot_vector ) * timedout );
+
+ /* Shift back seed counts as well */
+ memmove( peer_list->seed_counts + timedout, peer_list->seed_counts, sizeof( size_t ) * ( OT_POOLS_COUNT - timedout ) );
+ byte_zero( peer_list->seed_counts, sizeof( size_t ) * timedout );
+
+#ifdef WANT_TRACKER_SYNC
+ /* Save the block modified within last OT_POOLS_TIMEOUT */
+ if( peer_list->peers[1].size &&
+ ( new_peers = realloc( peer_list->changeset.data, sizeof( ot_peer ) * peer_list->peers[1].size ) ) )
+ {
+ memmove( new_peers, peer_list->peers[1].data, peer_list->peers[1].size );
+ peer_list->changeset.data = new_peers;
+ peer_list->changeset.size = sizeof( ot_peer ) * peer_list->peers[1].size;
+ } else {
+ free( peer_list->changeset.data );
+
+ memset( &peer_list->changeset, 0, sizeof( ot_vector ) );
+ }
+#endif
+
+ peers_count = seeds_count = 0;
+ for( i = 0; i < OT_POOLS_COUNT; ++i ) {
+ peers_count += peer_list->peers[i].size;
+ seeds_count += peer_list->seed_counts[i];
+ }
+ peer_list->seed_count = seeds_count;
+ peer_list->peer_count = peers_count;
+
+ if( peers_count )
+ peer_list->base = NOW;
+ else {
+ /* When we got here, the last time that torrent
+ has been touched is OT_POOLS_COUNT units before */
+ peer_list->base = NOW - OT_POOLS_COUNT;
+ }
+ return 0;
+}
+
+/* Clean up all peers in current bucket, remove timedout pools and
+ torrents */
+void clean_all_torrents( void ) {
+ ot_vector *torrents_list;
+ size_t i;
+ static int bucket;
+ ot_time time_now = NOW;
+
+ /* Search for an uncleaned bucked */
+ while( ( all_torrents_clean[bucket] == time_now ) && ( ++bucket < OT_BUCKET_COUNT ) );
+ if( bucket >= OT_BUCKET_COUNT ) {
+ bucket = 0; return;
+ }
+
+ all_torrents_clean[bucket] = time_now;
+
+ torrents_list = mutex_bucket_lock( bucket );
+ for( i=0; i<torrents_list->size; ++i ) {
+ ot_torrent *torrent = ((ot_torrent*)(torrents_list->data)) + i;
+ if( clean_single_torrent( torrent ) ) {
+ vector_remove_torrent( torrents_list, torrent );
+ --i; continue;
+ }
+ }
+ mutex_bucket_unlock( bucket );
+}
+
+void clean_init( void ) {
+ byte_zero( all_torrents_clean, sizeof( all_torrents_clean ) );
+}
+
+void clean_deinit( void ) {
+ byte_zero( all_torrents_clean, sizeof( all_torrents_clean ) );
+} \ No newline at end of file
diff --git a/ot_clean.h b/ot_clean.h
new file mode 100644
index 0000000..9c2fe11
--- /dev/null
+++ b/ot_clean.h
@@ -0,0 +1,15 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+ It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+#ifndef __OT_CLEAN_H__
+#define __OT_CLEAN_H__
+
+#include "trackerlogic.h"
+
+void clean_init( void );
+void clean_deinit( void );
+
+void clean_all_torrents( void );
+int clean_single_torrent( ot_torrent *torrent );
+
+#endif \ No newline at end of file
diff --git a/ot_mutex.c b/ot_mutex.c
index 5c14e45..bb82f46 100644
--- a/ot_mutex.c
+++ b/ot_mutex.c
@@ -1,11 +1,19 @@
/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
It is considered beerware. Prost. Skol. Cheers or whatever. */
+/* System */
#include <pthread.h>
#include <stdio.h>
+/* Libowfat */
+#include "byte.h"
+
+/* Opentracker */
#include "trackerlogic.h"
-#include "mutex.h"
+#include "ot_mutex.h"
+
+/* Our global all torrents list */
+static ot_vector all_torrents[OT_BUCKET_COUNT];
static int bucket_locklist[ OT_MAX_THREADS ];
static int bucket_locklist_count = 0;
@@ -51,12 +59,23 @@ static void bucket_remove( int bucket ) {
--bucket_locklist_count;
}
-void mutex_bucket_lock( int bucket ) {
+ot_vector *mutex_bucket_lock( int bucket ) {
pthread_mutex_lock( &bucket_mutex );
while( bucket_check( bucket ) )
pthread_cond_wait( &bucket_being_unlocked, &bucket_mutex );
bucket_push( bucket );
pthread_mutex_unlock( &bucket_mutex );
+ return all_torrents + bucket;
+}
+
+ot_vector *mutex_bucket_lock_by_hash( ot_hash *hash ) {
+ unsigned char *local_hash = hash[0];
+ int bucket = ( local_hash[0] << 2 ) | ( local_hash[1] >> 6 );
+
+ /* Can block */
+ mutex_bucket_lock( bucket );
+
+ return all_torrents + bucket;
}
void mutex_bucket_unlock( int bucket ) {
@@ -66,12 +85,20 @@ void mutex_bucket_unlock( int bucket ) {
pthread_mutex_unlock( &bucket_mutex );
}
+void mutex_bucket_unlock_by_hash( ot_hash *hash ) {
+ unsigned char *local_hash = hash[0];
+ int bucket = ( local_hash[0] << 2 ) | ( local_hash[1] >> 6 );
+ mutex_bucket_unlock( bucket );
+}
+
void mutex_init( ) {
pthread_mutex_init(&bucket_mutex, NULL);
pthread_cond_init (&bucket_being_unlocked, NULL);
+ byte_zero( all_torrents, sizeof( all_torrents ) );
}
void mutex_deinit( ) {
pthread_mutex_destroy(&bucket_mutex);
pthread_cond_destroy(&bucket_being_unlocked);
+ byte_zero( all_torrents, sizeof( all_torrents ) );
}
diff --git a/ot_mutex.h b/ot_mutex.h
index 8d91ab3..2d30c69 100644
--- a/ot_mutex.h
+++ b/ot_mutex.h
@@ -1,13 +1,16 @@
/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
It is considered beerware. Prost. Skol. Cheers or whatever. */
-#ifndef __MUTEX_H__
-#define __MUTEX_H__
+#ifndef __OT_MUTEX_H__
+#define __OT_MUTEX_H__
void mutex_init( );
void mutex_deinit( );
-void mutex_bucket_lock( int bucket );
+ot_vector *mutex_bucket_lock( int bucket );
+ot_vector *mutex_bucket_lock_by_hash( ot_hash *hash );
+
void mutex_bucket_unlock( int bucket );
+void mutex_bucket_unlock_by_hash( ot_hash *hash );
#endif
diff --git a/ot_stats.c b/ot_stats.c
new file mode 100644
index 0000000..215d557
--- /dev/null
+++ b/ot_stats.c
@@ -0,0 +1,201 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+ It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+/* System */
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <string.h>
+
+/* Libowfat */
+#include "byte.h"
+
+/* Opentracker */
+#include "trackerlogic.h"
+#include "ot_mutex.h"
+#include "ot_stats.h"
+
+/* Converter function from memory to human readable hex strings */
+static char*to_hex(char*d,ot_byte*s){const char*m="0123456789ABCDEF";char*e=d+40;while(d<e){*d++=m[*s>>4];*d++=m[*s++&15];}*d=0;return d;}
+
+typedef struct { size_t val; ot_torrent * torrent; } ot_record;
+
+/* Fetches stats from tracker */
+size_t return_stats_for_tracker( char *reply, int mode ) {
+ size_t torrent_count = 0, peer_count = 0, seed_count = 0, j;
+ ot_record top5s[5], top5c[5];
+ char *r = reply;
+ int bucket;
+
+ byte_zero( top5s, sizeof( top5s ) );
+ byte_zero( top5c, sizeof( top5c ) );
+
+ for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
+ ot_vector *torrents_list = mutex_bucket_lock( bucket );
+ torrent_count += torrents_list->size;
+ for( j=0; j<torrents_list->size; ++j ) {
+ ot_peerlist *peer_list = ( ((ot_torrent*)(torrents_list->data))[j] ).peer_list;
+ if( mode == STATS_TOP5 ) {
+ int idx = 4; while( (idx >= 0) && ( peer_list->peer_count > top5c[idx].val ) ) --idx;
+ if ( idx++ != 4 ) {
+ memmove( top5c + idx + 1, top5c + idx, ( 4 - idx ) * sizeof( ot_record ) );
+ top5c[idx].val = peer_list->peer_count;
+ top5c[idx].torrent = (ot_torrent*)(torrents_list->data) + j;
+ }
+ idx = 4; while( (idx >= 0) && ( peer_list->seed_count > top5s[idx].val ) ) --idx;
+ if ( idx++ != 4 ) {
+ memmove( top5s + idx + 1, top5s + idx, ( 4 - idx ) * sizeof( ot_record ) );
+ top5s[idx].val = peer_list->seed_count;
+ top5s[idx].torrent = (ot_torrent*)(torrents_list->data) + j;
+ }
+ }
+ peer_count += peer_list->peer_count; seed_count += peer_list->seed_count;
+ }
+ mutex_bucket_unlock( bucket );
+ }
+ if( mode == STATS_TOP5 ) {
+ char hex_out[42];
+ int idx;
+ r += sprintf( r, "Top5 torrents by peers:\n" );
+ for( idx=0; idx<5; ++idx )
+ if( top5c[idx].torrent )
+ r += sprintf( r, "\t%zd\t%s\n", top5c[idx].val, to_hex( hex_out, top5c[idx].torrent->hash) );
+ r += sprintf( r, "Top5 torrents by seeds:\n" );
+ for( idx=0; idx<5; ++idx )
+ if( top5s[idx].torrent )
+ r += sprintf( r, "\t%zd\t%s\n", top5s[idx].val, to_hex( hex_out, top5s[idx].torrent->hash) );
+ } else
+ r += sprintf( r, "%zd\n%zd\nopentracker serving %zd torrents\nopentracker", peer_count, seed_count, torrent_count );
+
+ return r - reply;
+}
+
+/* This function collects 4096 /24s in 4096 possible
+ malloc blocks
+*/
+size_t return_stats_for_slash24s( char *reply, size_t amount, ot_dword thresh ) {
+
+#define NUM_TOPBITS 12
+#define NUM_LOWBITS (24-NUM_TOPBITS)
+#define NUM_BUFS (1<<NUM_TOPBITS)
+#define NUM_S24S (1<<NUM_LOWBITS)
+#define MSK_S24S (NUM_S24S-1)
+
+ ot_dword *counts[ NUM_BUFS ];
+ ot_dword slash24s[amount*2]; /* first dword amount, second dword subnet */
+ int bucket;
+ size_t i, j, k, l;
+ char *r = reply;
+
+ byte_zero( counts, sizeof( counts ) );
+ byte_zero( slash24s, amount * 2 * sizeof(ot_dword) );
+
+ r += sprintf( r, "Stats for all /24s with more than %u announced torrents:\n\n", thresh );
+
+ for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
+ ot_vector *torrents_list = mutex_bucket_lock( bucket );
+ for( j=0; j<torrents_list->size; ++j ) {
+ ot_peerlist *peer_list = ( ((ot_torrent*)(torrents_list->data))[j] ).peer_list;
+ for( k=0; k<OT_POOLS_COUNT; ++k ) {
+ ot_peer *peers = peer_list->peers[k].data;
+ size_t numpeers = peer_list->peers[k].size;
+ for( l=0; l<numpeers; ++l ) {
+ ot_dword s24 = ntohl(*(ot_dword*)(peers+l)) >> 8;
+ ot_dword *count = counts[ s24 >> NUM_LOWBITS ];
+ if( !count ) {
+ count = malloc( sizeof(ot_dword) * NUM_S24S );
+ if( !count )
+ goto bailout_cleanup;
+ byte_zero( count, sizeof( ot_dword ) * NUM_S24S );
+ counts[ s24 >> NUM_LOWBITS ] = count;
+ }
+ count[ s24 & MSK_S24S ]++;
+ }
+ }
+ }
+ mutex_bucket_unlock( bucket );
+ }
+
+ k = l = 0; /* Debug: count allocated bufs */
+ for( i=0; i < NUM_BUFS; ++i ) {
+ ot_dword *count = counts[i];
+ if( !counts[i] )
+ continue;
+ ++k; /* Debug: count allocated bufs */
+ for( j=0; j < NUM_S24S; ++j ) {
+ if( count[j] > thresh ) {
+ /* This subnet seems to announce more torrents than the last in our list */
+ int insert_pos = amount - 1;
+ while( ( insert_pos >= 0 ) && ( count[j] > slash24s[ 2 * insert_pos ] ) )
+ --insert_pos;
+ ++insert_pos;
+ memmove( slash24s + 2 * ( insert_pos + 1 ), slash24s + 2 * ( insert_pos ), 2 * sizeof( ot_dword ) * ( amount - insert_pos - 1 ) );
+ slash24s[ 2 * insert_pos ] = count[j];
+ slash24s[ 2 * insert_pos + 1 ] = ( i << NUM_TOPBITS ) + j;
+ if( slash24s[ 2 * amount - 2 ] > thresh )
+ thresh = slash24s[ 2 * amount - 2 ];
+ }
+ if( count[j] ) ++l;
+ }
+ free( count );
+ }
+
+ r += sprintf( r, "Allocated bufs: %zd, used s24s: %zd\n", k, l );
+
+ for( i=0; i < amount; ++i )
+ if( slash24s[ 2*i ] >= thresh ) {
+ ot_dword ip = slash24s[ 2*i +1 ];
+ r += sprintf( r, "% 10ld %d.%d.%d.0/24\n", (long)slash24s[ 2*i ], (int)(ip >> 16), (int)(255 & ( ip >> 8 )), (int)(ip & 255) );
+ }
+
+ return r - reply;
+
+bailout_cleanup:
+
+ for( i=0; i < NUM_BUFS; ++i )
+ free( counts[i] );
+
+ return 0;
+}
+
+size_t return_memstat_for_tracker( char **reply ) {
+ size_t torrent_count = 0, j;
+ size_t allocated, replysize;
+ ot_vector *torrents_list;
+ int bucket, k;
+ char *r;
+
+ for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
+ torrents_list = mutex_bucket_lock(bucket);
+ torrent_count += torrents_list->size;
+ mutex_bucket_unlock(bucket);
+ }
+
+ allocated = OT_BUCKET_COUNT*32 + (43+OT_POOLS_COUNT*32)*torrent_count;
+ if( !( r = *reply = mmap( NULL, allocated, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0 ) ) ) return 0;
+
+ for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
+ torrents_list = mutex_bucket_lock(bucket);
+ r += sprintf( r, "%02X: %08X %08X\n", bucket, (unsigned int)torrents_list->size, (unsigned int)torrents_list->space );
+ mutex_bucket_unlock(bucket);
+ }
+
+ for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
+ ot_vector *torrents_list = mutex_bucket_lock(bucket);
+ char hex_out[42];
+ for( j=0; j<torrents_list->size; ++j ) {
+ ot_peerlist *peer_list = ( ((ot_torrent*)(torrents_list->data))[j] ).peer_list;
+ ot_hash *hash =&( ((ot_torrent*)(torrents_list->data))[j] ).hash;
+ r += sprintf( r, "\n%s:\n", to_hex( hex_out, (ot_byte*)hash) );
+ for( k=0; k<OT_POOLS_COUNT; ++k )
+ r += sprintf( r, "\t%05X %05X\n", ((unsigned int)peer_list->peers[k].size), (unsigned int)peer_list->peers[k].space );
+ }
+ mutex_bucket_unlock(bucket);
+ }
+
+ replysize = ( r - *reply );
+ fix_mmapallocation( *reply, allocated, replysize );
+
+ return replysize;
+} \ No newline at end of file
diff --git a/ot_stats.h b/ot_stats.h
new file mode 100644
index 0000000..e4d7c06
--- /dev/null
+++ b/ot_stats.h
@@ -0,0 +1,13 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+ It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+#ifndef __OT_STATS_H__
+#define __OT_STATS_H__
+
+enum { STATS_CONNS, STATS_PEERS, STATS_TOP5, STATS_DMEM, STATS_TCP, STATS_UDP, STATS_SLASH24S, SYNC_IN, SYNC_OUT, STATS_FULLSCRAPE };
+
+size_t return_stats_for_tracker( char *reply, int mode );
+size_t return_stats_for_slash24s( char *reply, size_t amount, ot_dword thresh );
+size_t return_memstat_for_tracker( char **reply );
+
+#endif
diff --git a/ot_sync.c b/ot_sync.c
new file mode 100644
index 0000000..6e95a98
--- /dev/null
+++ b/ot_sync.c
@@ -0,0 +1,107 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+ It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+/* System */
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <stdio.h>
+#include <string.h>
+
+/* Libowfat */
+#include "scan.h"
+#include "byte.h"
+
+/* Opentracker */
+#include "trackerlogic.h"
+#include "ot_mutex.h"
+#include "ot_sync.h"
+
+#ifdef WANT_TRACKER_SYNC
+/* Import Changeset from an external authority
+ format: d4:syncd[..]ee
+ [..]: ( 20:01234567890abcdefghij16:XXXXYYYY )+
+*/
+int add_changeset_to_tracker( ot_byte *data, size_t len ) {
+ ot_hash *hash;
+ ot_byte *end = data + len;
+ unsigned long peer_count;
+
+ /* We do know, that the string is \n terminated, so it cant
+ overflow */
+ if( byte_diff( data, 8, "d4:syncd" ) ) return -1;
+ data += 8;
+
+ while( 1 ) {
+ if( byte_diff( data, 3, "20:" ) ) {
+ if( byte_diff( data, 2, "ee" ) )
+ return -1;
+ return 0;
+ }
+ data += 3;
+ hash = (ot_hash*)data;
+ data += sizeof( ot_hash );
+
+ /* Scan string length indicator */
+ data += ( len = scan_ulong( (char*)data, &peer_count ) );
+
+ /* If no long was scanned, it is not divisible by 8, it is not
+ followed by a colon or claims to need to much memory, we fail */
+ if( !len || !peer_count || ( peer_count & 7 ) || ( *data++ != ':' ) || ( data + peer_count > end ) )
+ return -1;
+
+ while( peer_count > 0 ) {
+ add_peer_to_torrent( hash, (ot_peer*)data, 1 );
+ data += 8; peer_count -= 8;
+ }
+ }
+ return 0;
+}
+
+/* Proposed output format
+ d4:syncd20:<info_hash>8*N:(xxxxyyyy)*Nee
+*/
+size_t return_changeset_for_tracker( char **reply ) {
+ size_t allocated = 0, i, replysize;
+ ot_vector *torrents_list;
+ int bucket;
+ char *r;
+
+ /* Maybe there is time to clean_all_torrents(); */
+
+ /* Determine space needed for whole changeset */
+ for( bucket = 0; bucket < OT_BUCKET_COUNT; ++bucket ) {
+ torrents_list = mutex_bucket_lock(bucket);
+ for( i=0; i<torrents_list->size; ++i ) {
+ ot_torrent *torrent = ((ot_torrent*)(torrents_list->data)) + i;
+ allocated += sizeof( ot_hash ) + sizeof(ot_peer) * torrent->peer_list->changeset.size + 13;
+ }
+ mutex_bucket_unlock(bucket);
+ }
+
+ /* add "d4:syncd" and "ee" */
+ allocated += 8 + 2;
+
+ if( !( r = *reply = mmap( NULL, allocated, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0 ) ) )
+ return 0;
+
+ memmove( r, "d4:syncd", 8 ); r += 8;
+ for( bucket = 0; bucket < OT_BUCKET_COUNT; ++bucket ) {
+ torrents_list = mutex_bucket_lock(bucket);
+ for( i=0; i<torrents_list->size; ++i ) {
+ ot_torrent *torrent = ((ot_torrent*)(torrents_list->data)) + i;
+ const size_t byte_count = sizeof(ot_peer) * torrent->peer_list->changeset.size;
+ *r++ = '2'; *r++ = '0'; *r++ = ':';
+ memmove( r, torrent->hash, sizeof( ot_hash ) ); r += sizeof( ot_hash );
+ r += sprintf( r, "%zd:", byte_count );
+ memmove( r, torrent->peer_list->changeset.data, byte_count ); r += byte_count;
+ }
+ mutex_bucket_unlock(bucket);
+ }
+ *r++ = 'e'; *r++ = 'e';
+
+ replysize = ( r - *reply );
+ fix_mmapallocation( *reply, allocated, replysize );
+
+ return replysize;
+}
+#endif
diff --git a/ot_sync.h b/ot_sync.h
new file mode 100644
index 0000000..cf0fb3d
--- /dev/null
+++ b/ot_sync.h
@@ -0,0 +1,14 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+ It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+#ifndef __OT_SYNC_H__
+#define __OT_SYNC_H__
+
+#include "trackerlogic.h"
+
+#ifdef WANT_TRACKER_SYNC
+size_t return_changeset_for_tracker( char **reply );
+int add_changeset_to_tracker( ot_byte *data, size_t len );
+#endif
+
+#endif \ No newline at end of file
diff --git a/ot_vector.c b/ot_vector.c
new file mode 100644
index 0000000..aa71279
--- /dev/null
+++ b/ot_vector.c
@@ -0,0 +1,110 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+ It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+/* System */
+#include <stdlib.h>
+#include <string.h>
+
+/* Opentracker */
+#include "trackerlogic.h"
+#include "ot_vector.h"
+
+/* 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
+*/
+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( mc ) {
+ int cmp = memcmp( lookat, key, compare_size);
+ if (cmp == 0) return (void *)lookat;
+ if (cmp < 0) {
+ base = (void*)(lookat + member_size);
+ --mc;
+ }
+ mc >>= 1;
+ lookat = ((ot_byte*)base) + member_size * (mc >> 1);
+ }
+ *exactmatch = 0;
+ return (void*)lookat;
+}
+
+/* This is the generic insert operation for our vector type.
+ It tries to locate the object at "key" with size "member_size" by comparing its first "compare_size" bytes with
+ those of objects in vector. Our special "binary_search" function does that and either returns the match or a
+ pointer to where the object is to be inserted. vector_find_or_insert makes space for the object and copies it,
+ if it wasn't found in vector. Caller needs to check the passed "exactmatch" variable to see, whether an insert
+ took place. If resizing the vector failed, NULL is returned, else the pointer to the object in vector.
+*/
+void *vector_find_or_insert( ot_vector *vector, void *key, size_t member_size, size_t compare_size, int *exactmatch ) {
+ ot_byte *match = binary_search( key, vector->data, vector->size, member_size, compare_size, exactmatch );
+
+ if( *exactmatch ) return match;
+
+ if( vector->size + 1 >= vector->space ) {
+ size_t new_space = vector->space ? OT_VECTOR_GROW_RATIO * vector->space : OT_VECTOR_MIN_MEMBERS;
+ ot_byte *new_data = realloc( vector->data, new_space * member_size );
+ if( !new_data ) return NULL;
+
+ /* 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 );
+ vector->size++;
+ return match;
+}
+
+/* This is the non-generic delete from vector-operation specialized for peers in pools.
+ Set hysteresis == 0 if you expect the vector not to ever grow again.
+ It returns 0 if no peer was found (and thus not removed)
+ 1 if a non-seeding peer was removed
+ 2 if a seeding peer was removed
+*/
+int vector_remove_peer( ot_vector *vector, ot_peer *peer, int hysteresis ) {
+ int exactmatch;
+ size_t shrink_thresh = hysteresis ? OT_VECTOR_SHRINK_THRESH : OT_VECTOR_SHRINK_RATIO;
+ ot_peer *end = ((ot_peer*)vector->data) + vector->size;
+ ot_peer *match;
+
+ if( !vector->size ) return 0;
+ 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 ) );
+ if( ( --vector->size * 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 ) );
+ }
+ if( !vector->size ) {
+ /* for peer pools its safe to let them go,
+ in 999 of 1000 this happens in older pools, that won't ever grow again */
+ free( vector->data );
+ vector->data = NULL;
+ vector->space = 0;
+ }
+ return exactmatch;
+}
+
+void vector_remove_torrent( ot_vector *vector, ot_torrent *match ) {
+ ot_torrent *end = ((ot_torrent*)vector->data) + vector->size;
+
+ if( !vector->size ) return;
+
+ /* 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 ) );
+ 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 ) );
+ }
+}
diff --git a/ot_vector.h b/ot_vector.h
new file mode 100644
index 0000000..8863855
--- /dev/null
+++ b/ot_vector.h
@@ -0,0 +1,26 @@
+/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
+ It is considered beerware. Prost. Skol. Cheers or whatever. */
+
+#ifndef __OT_VECTOR_H__
+#define __OT_VECTOR_H__
+
+#include "trackerlogic.h"
+
+#define OT_VECTOR_MIN_MEMBERS 4
+#define OT_VECTOR_GROW_RATIO 8
+#define OT_VECTOR_SHRINK_THRESH 6
+#define OT_VECTOR_SHRINK_RATIO 4
+typedef struct {
+ void *data;
+ size_t size;
+ size_t space;
+} ot_vector;
+
+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 );
+void *vector_find_or_insert( ot_vector *vector, void *key, size_t member_size, size_t compare_size, int *exactmatch );
+
+int vector_remove_peer( ot_vector *vector, ot_peer *peer, int hysteresis );
+void vector_remove_torrent( ot_vector *vector, ot_torrent *match );
+
+#endif \ No newline at end of file
diff --git a/trackerlogic.c b/trackerlogic.c
index 2725399..c09f1b9 100644
--- a/trackerlogic.c
+++ b/trackerlogic.c
@@ -1,149 +1,33 @@
/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
It is considered beerware. Prost. Skol. Cheers or whatever. */
-#include "trackerlogic.h"
-
+/* System */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
-#include <fcntl.h>
#include <sys/types.h>
#include <sys/mman.h>
-#include <arpa/inet.h>
#include <unistd.h>
#include <time.h>
#include <math.h>
-#include <glob.h>
-#include <errno.h>
+/* Libowfat */
#include "scan.h"
#include "byte.h"
-#include "mutex.h"
-/* GLOBAL VARIABLES */
+/* Opentracker */
+#include "trackerlogic.h"
+#include "ot_mutex.h"
+#include "ot_stats.h"
+#include "ot_clean.h"
-/* We maintain a list of 1024 pointers to sorted list of ot_torrent structs
- Sort key is, of course, its hash */
-#define OT_BUCKET_COUNT 1024
-static ot_vector all_torrents[OT_BUCKET_COUNT];
-static ot_time all_torrents_clean[OT_BUCKET_COUNT];
+/* GLOBAL VARIABLES */
#if defined ( WANT_BLACKLISTING ) || defined( WANT_CLOSED_TRACKER )
static ot_vector accesslist;
#define WANT_ACCESS_CONTROL
#endif
-static int clean_single_torrent( ot_torrent *torrent );
-
-/* these functions protect our buckets from other threads that
- try to commit announces or clean up */
-static ot_vector *lock_bucket_by_hash( ot_hash *hash ) {
- unsigned char *local_hash = hash[0];
- int bucket = ( local_hash[0] << 2 ) | ( local_hash[1] >> 6 );
-
- /* Can block */
- mutex_bucket_lock( bucket );
-
- return all_torrents + bucket;
-}
-
-static void *unlock_bucket_by_hash( ot_hash *hash ) {
- unsigned char *local_hash = hash[0];
- int bucket = ( local_hash[0] << 2 ) | ( local_hash[1] >> 6 );
- mutex_bucket_unlock( bucket );
-
- /* To make caller's code look better, allow
- return unlock_bucket_by_hash() */
- return NULL;
-}
-
-/* Converter function from memory to human readable hex strings */
-static char*to_hex(char*d,ot_byte*s){const char*m="0123456789ABCDEF";char*e=d+40;while(d<e){*d++=m[*s>>4];*d++=m[*s++&15];}*d=0;return d;}
-
-/* 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( mc ) {
- int cmp = memcmp( lookat, key, compare_size);
- if (cmp == 0) return (void *)lookat;
- if (cmp < 0) {
- base = (void*)(lookat + member_size);
- --mc;
- }
- mc >>= 1;
- lookat = ((ot_byte*)base) + member_size * (mc >> 1);
- }
- *exactmatch = 0;
- return (void*)lookat;
-}
-
-/* This is the generic insert operation for our vector type.
- It tries to locate the object at "key" with size "member_size" by comparing its first "compare_size" bytes with
- those of objects in vector. Our special "binary_search" function does that and either returns the match or a
- pointer to where the object is to be inserted. vector_find_or_insert makes space for the object and copies it,
- if it wasn't found in vector. Caller needs to check the passed "exactmatch" variable to see, whether an insert
- took place. If resizing the vector failed, NULL is returned, else the pointer to the object in vector.
-*/
-static void *vector_find_or_insert( ot_vector *vector, void *key, size_t member_size, size_t compare_size, int *exactmatch ) {
- ot_byte *match = binary_search( key, vector->data, vector->size, member_size, compare_size, exactmatch );
-
- if( *exactmatch ) return match;
-
- if( vector->size + 1 >= vector->space ) {
- size_t new_space = vector->space ? OT_VECTOR_GROW_RATIO * vector->space : OT_VECTOR_MIN_MEMBERS;
- ot_byte *new_data = realloc( vector->data, new_space * member_size );
- if( !new_data ) return NULL;
-
- /* 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 );
- vector->size++;
- return match;
-}
-
-/* This is the non-generic delete from vector-operation specialized for peers in pools.
- Set hysteresis == 0 if you expect the vector not to ever grow again.
- It returns 0 if no peer was found (and thus not removed)
- 1 if a non-seeding peer was removed
- 2 if a seeding peer was removed
-*/
-static int vector_remove_peer( ot_vector *vector, ot_peer *peer, int hysteresis ) {
- int exactmatch;
- size_t shrink_thresh = hysteresis ? OT_VECTOR_SHRINK_THRESH : OT_VECTOR_SHRINK_RATIO;
- ot_peer *end = ((ot_peer*)vector->data) + vector->size;
- ot_peer *match;
-
- if( !vector->size ) return 0;
- 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 ) );
- if( ( --vector->size * 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 ) );
- }
- if( !vector->size ) {
- /* for peer pools its safe to let them go,
- in 999 of 1000 this happens in older pools, that won't ever grow again */
- free( vector->data );
- vector->data = NULL;
- vector->space = 0;
- }
- return exactmatch;
-}
-
-static void free_peerlist( ot_peerlist *peer_list ) {
+void free_peerlist( ot_peerlist *peer_list ) {
size_t i;
for( i=0; i<OT_POOLS_COUNT; ++i )
if( peer_list->peers[i].data )
@@ -154,27 +38,11 @@ static void free_peerlist( ot_peerlist *peer_list ) {
free( peer_list );
}
-static void vector_remove_torrent( ot_vector *vector, ot_torrent *match ) {
- ot_torrent *end = ((ot_torrent*)vector->data) + vector->size;
-
- if( !vector->size ) return;
-
- /* 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 ) );
- 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 ) );
- }
-}
-
ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer WANT_TRACKER_SYNC_PARAM( int from_changeset ) ) {
int exactmatch;
ot_torrent *torrent;
ot_peer *peer_dest;
- ot_vector *torrents_list = lock_bucket_by_hash( hash ), *peer_pool;
+ ot_vector *torrents_list = mutex_bucket_lock_by_hash( hash ), *peer_pool;
int base_pool = 0;
#ifdef WANT_ACCESS_CONTROL
@@ -184,13 +52,17 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer WANT_TRACKER_SYNC
exactmatch = !exactmatch;
#endif
- if( exactmatch )
- return unlock_bucket_by_hash( hash );
+ if( exactmatch ) {
+ mutex_bucket_unlock_by_hash( hash );
+ return NULL;
+ }
#endif
torrent = vector_find_or_insert( torrents_list, (void*)hash, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
- if( !torrent )
- return unlock_bucket_by_hash( hash );
+ if( !torrent ) {
+ mutex_bucket_unlock_by_hash( hash );
+ return NULL;
+ }
if( !exactmatch ) {
/* Create a new torrent entry, then */
@@ -198,7 +70,8 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer WANT_TRACKER_SYNC
if( !( torrent->peer_list = malloc( sizeof (ot_peerlist) ) ) ) {
vector_remove_torrent( torrents_list, torrent );
- return unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
+ return NULL;
}
byte_zero( torrent->peer_list, sizeof( ot_peerlist ) );
@@ -216,7 +89,7 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer WANT_TRACKER_SYNC
peer_pool = &torrent->peer_list->peers[0];
binary_search( peer, peer_pool->data, peer_pool->size, sizeof(ot_peer), OT_PEER_COMPARE_SIZE, &exactmatch );
if( exactmatch ) {
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
return torrent;
}
base_pool = 1;
@@ -248,7 +121,7 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer WANT_TRACKER_SYNC
torrent->peer_list->seed_count--;
case 1: default:
torrent->peer_list->peer_count--;
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
return torrent;
}
}
@@ -269,7 +142,7 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer WANT_TRACKER_SYNC
memmove( peer_dest, peer, sizeof( ot_peer ) );
}
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
return torrent;
}
@@ -282,13 +155,13 @@ ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer WANT_TRACKER_SYNC
size_t return_peers_for_torrent( ot_hash *hash, size_t amount, char *reply, int is_tcp ) {
char *r = reply;
int exactmatch;
- ot_vector *torrents_list = lock_bucket_by_hash( hash );
+ ot_vector *torrents_list = mutex_bucket_lock_by_hash( hash );
ot_torrent *torrent = binary_search( hash, torrents_list->data, torrents_list->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
ot_peerlist *peer_list = torrent->peer_list;
size_t index;
if( !torrent ) {
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
return 0;
}
@@ -338,12 +211,12 @@ size_t return_peers_for_torrent( ot_hash *hash, size_t amount, char *reply, int
if( is_tcp )
*r++ = 'e';
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
return r - reply;
}
/* Release memory we allocated too much */
-static void fix_mmapallocation( void *buf, size_t old_alloc, size_t new_alloc ) {
+void fix_mmapallocation( void *buf, size_t old_alloc, size_t new_alloc ) {
int page_size = getpagesize();
size_t old_pages = 1 + old_alloc / page_size;
size_t new_pages = 1 + new_alloc / page_size;
@@ -356,19 +229,23 @@ static void fix_mmapallocation( void *buf, size_t old_alloc, size_t new_alloc )
size_t return_fullscrape_for_tracker( char **reply ) {
size_t torrent_count = 0, j;
size_t allocated, replysize;
- int i;
+ ot_vector *torrents_list;
+ int bucket;
char *r;
- for( i=0; i<OT_BUCKET_COUNT; ++i )
- torrent_count += all_torrents[i].size;
+ for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
+ ot_vector *torrents_list = mutex_bucket_lock( bucket );
+ torrent_count += torrents_list->size;
+ mutex_bucket_unlock( bucket );
+ }
/* one extra for pro- and epilogue */
allocated = 100*(1+torrent_count);
if( !( r = *reply = mmap( NULL, allocated, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0 ) ) ) return 0;
memmove( r, "d5:filesd", 9 ); r += 9;
- for( i=0; i<OT_BUCKET_COUNT; ++i ) {
- ot_vector *torrents_list = all_torrents + i;
+ for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
+ torrents_list = mutex_bucket_lock( bucket );
for( j=0; j<torrents_list->size; ++j ) {
ot_peerlist *peer_list = ( ((ot_torrent*)(torrents_list->data))[j] ).peer_list;
ot_hash *hash =&( ((ot_torrent*)(torrents_list->data))[j] ).hash;
@@ -378,6 +255,7 @@ size_t return_fullscrape_for_tracker( char **reply ) {
r += sprintf( r, "d8:completei%zde10:downloadedi%zde10:incompletei%zdee", peer_list->seed_count, peer_list->down_count, peer_list->peer_count-peer_list->seed_count );
}
}
+ mutex_bucket_unlock( bucket );
}
*r++='e'; *r++='e';
@@ -388,45 +266,10 @@ size_t return_fullscrape_for_tracker( char **reply ) {
return replysize;
}
-size_t return_memstat_for_tracker( char **reply ) {
- size_t torrent_count = 0, j;
- size_t allocated, replysize;
- int i, k;
- char *r;
-
- for( i=0; i<OT_BUCKET_COUNT; ++i ) {
- ot_vector *torrents_list = all_torrents + i;
- torrent_count += torrents_list->size;
- }
-
- allocated = OT_BUCKET_COUNT*32 + (43+OT_POOLS_COUNT*32)*torrent_count;
- if( !( r = *reply = mmap( NULL, allocated, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0 ) ) ) return 0;
-
- for( i=0; i<OT_BUCKET_COUNT; ++i )
- r += sprintf( r, "%02X: %08X %08X\n", i, (unsigned int)all_torrents[i].size, (unsigned int)all_torrents[i].space );
-
- for( i=0; i<OT_BUCKET_COUNT; ++i ) {
- ot_vector *torrents_list = all_torrents + i;
- char hex_out[42];
- for( j=0; j<torrents_list->size; ++j ) {
- ot_peerlist *peer_list = ( ((ot_torrent*)(torrents_list->data))[j] ).peer_list;
- ot_hash *hash =&( ((ot_torrent*)(torrents_list->data))[j] ).hash;
- r += sprintf( r, "\n%s:\n", to_hex( hex_out, (ot_byte*)hash) );
- for( k=0; k<OT_POOLS_COUNT; ++k )
- r += sprintf( r, "\t%05X %05X\n", ((unsigned int)peer_list->peers[k].size), (unsigned int)peer_list->peers[k].space );
- }
- }
-
- replysize = ( r - *reply );
- fix_mmapallocation( *reply, allocated, replysize );
-
- return replysize;
-}
-
/* Fetches scrape info for a specific torrent */
size_t return_udp_scrape_for_torrent( ot_hash *hash, char *reply ) {
int exactmatch;
- ot_vector *torrents_list = lock_bucket_by_hash( hash );
+ ot_vector *torrents_list = mutex_bucket_lock_by_hash( hash );
ot_torrent *torrent = binary_search( hash, torrents_list->data, torrents_list->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
if( !exactmatch ) {
@@ -443,7 +286,7 @@ size_t return_udp_scrape_for_torrent( ot_hash *hash, char *reply ) {
r[2] = htonl( torrent->peer_list->peer_count-torrent->peer_list->seed_count );
}
}
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
return 12;
}
@@ -456,7 +299,7 @@ size_t return_tcp_scrape_for_torrent( ot_hash *hash_list, int amount, char *repl
for( i=0; i<amount; ++i ) {
ot_hash *hash = hash_list + i;
- ot_vector *torrents_list = lock_bucket_by_hash( hash );
+ ot_vector *torrents_list = mutex_bucket_lock_by_hash( hash );
ot_torrent *torrent = binary_search( hash, torrents_list->data, torrents_list->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
if( exactmatch ) {
@@ -468,347 +311,22 @@ size_t return_tcp_scrape_for_torrent( ot_hash *hash_list, int amount, char *repl
torrent->peer_list->seed_count, torrent->peer_list->down_count, torrent->peer_list->peer_count-torrent->peer_list->seed_count ) + 23;
}
}
- unlock_bucket_by_hash( hash );
- }
-
- *r++ = 'e'; *r++ = 'e';
- return r - reply;
-}
-
-#ifdef WANT_TRACKER_SYNC
-/* Import Changeset from an external authority
- format: d4:syncd[..]ee
- [..]: ( 20:01234567890abcdefghij16:XXXXYYYY )+
-*/
-int add_changeset_to_tracker( ot_byte *data, size_t len ) {
- ot_hash *hash;
- ot_byte *end = data + len;
- unsigned long peer_count;
-
- /* We do know, that the string is \n terminated, so it cant
- overflow */
- if( byte_diff( data, 8, "d4:syncd" ) ) return -1;
- data += 8;
-
- while( 1 ) {
- if( byte_diff( data, 3, "20:" ) ) {
- if( byte_diff( data, 2, "ee" ) )
- return -1;
- return 0;
- }
- data += 3;
- hash = (ot_hash*)data;
- data += sizeof( ot_hash );
-
- /* Scan string length indicator */
- data += ( len = scan_ulong( (char*)data, &peer_count ) );
-
- /* If no long was scanned, it is not divisible by 8, it is not
- followed by a colon or claims to need to much memory, we fail */
- if( !len || !peer_count || ( peer_count & 7 ) || ( *data++ != ':' ) || ( data + peer_count > end ) )
- return -1;
-
- while( peer_count > 0 ) {
- add_peer_to_torrent( hash, (ot_peer*)data, 1 );
- data += 8; peer_count -= 8;
- }
- }
- return 0;
-}
-
-/* Proposed output format
- d4:syncd20:<info_hash>8*N:(xxxxyyyy)*Nee
-*/
-size_t return_changeset_for_tracker( char **reply ) {
- size_t allocated = 0, i, replysize;
- int bucket;
- char *r;
-
- /* Maybe there is time to clean_all_torrents(); */
-
- /* Determine space needed for whole changeset */
- for( bucket = 0; bucket < OT_BUCKET_COUNT; ++bucket ) {
- ot_vector *torrents_list = all_torrents + bucket;
- for( i=0; i<torrents_list->size; ++i ) {
- ot_torrent *torrent = ((ot_torrent*)(torrents_list->data)) + i;
- allocated += sizeof( ot_hash ) + sizeof(ot_peer) * torrent->peer_list->changeset.size + 13;
- }
+ mutex_bucket_unlock_by_hash( hash );
}
- /* add "d4:syncd" and "ee" */
- allocated += 8 + 2;
-
- if( !( r = *reply = mmap( NULL, allocated, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0 ) ) )
- return 0;
-
- memmove( r, "d4:syncd", 8 ); r += 8;
- for( bucket = 0; bucket < OT_BUCKET_COUNT; ++bucket ) {
- ot_vector *torrents_list = all_torrents + bucket;
- for( i=0; i<torrents_list->size; ++i ) {
- ot_torrent *torrent = ((ot_torrent*)(torrents_list->data)) + i;
- const size_t byte_count = sizeof(ot_peer) * torrent->peer_list->changeset.size;
- *r++ = '2'; *r++ = '0'; *r++ = ':';
- memmove( r, torrent->hash, sizeof( ot_hash ) ); r += sizeof( ot_hash );
- r += sprintf( r, "%zd:", byte_count );
- memmove( r, torrent->peer_list->changeset.data, byte_count ); r += byte_count;
- }
- }
*r++ = 'e'; *r++ = 'e';
-
- replysize = ( r - *reply );
- fix_mmapallocation( *reply, allocated, replysize );
-
- return replysize;
-}
-#endif
-
-/* Clean a single torrent
- return 1 if torrent timed out
-*/
-static int clean_single_torrent( ot_torrent *torrent ) {
- ot_peerlist *peer_list = torrent->peer_list;
- size_t peers_count = 0, seeds_count;
- time_t timedout = (int)( NOW - peer_list->base );
- int i;
-#ifdef WANT_TRACKER_SYNC
- char *new_peers;
-#endif
-
- /* Torrent has idled out */
- if( timedout > OT_TORRENT_TIMEOUT )
- return 1;
-
- /* Nothing to be cleaned here? Test if torrent is worth keeping */
- if( timedout > OT_POOLS_COUNT ) {
- if( !peer_list->peer_count )
- return peer_list->down_count ? 0 : 1;
- timedout = OT_POOLS_COUNT;
- }
-
- /* Release vectors that have timed out */
- for( i = OT_POOLS_COUNT - timedout; i < OT_POOLS_COUNT; ++i )
- free( peer_list->peers[i].data);
-
- /* Shift vectors back by the amount of pools that were shifted out */
- memmove( peer_list->peers + timedout, peer_list->peers, sizeof( ot_vector ) * ( OT_POOLS_COUNT - timedout ) );
- byte_zero( peer_list->peers, sizeof( ot_vector ) * timedout );
-
- /* Shift back seed counts as well */
- memmove( peer_list->seed_counts + timedout, peer_list->seed_counts, sizeof( size_t ) * ( OT_POOLS_COUNT - timedout ) );
- byte_zero( peer_list->seed_counts, sizeof( size_t ) * timedout );
-
-#ifdef WANT_TRACKER_SYNC
- /* Save the block modified within last OT_POOLS_TIMEOUT */
- if( peer_list->peers[1].size &&
- ( new_peers = realloc( peer_list->changeset.data, sizeof( ot_peer ) * peer_list->peers[1].size ) ) )
- {
- memmove( new_peers, peer_list->peers[1].data, peer_list->peers[1].size );
- peer_list->changeset.data = new_peers;
- peer_list->changeset.size = sizeof( ot_peer ) * peer_list->peers[1].size;
- } else {
- free( peer_list->changeset.data );
-
- memset( &peer_list->changeset, 0, sizeof( ot_vector ) );
- }
-#endif
-
- peers_count = seeds_count = 0;
- for( i = 0; i < OT_POOLS_COUNT; ++i ) {
- peers_count += peer_list->peers[i].size;
- seeds_count += peer_list->seed_counts[i];
- }
- peer_list->seed_count = seeds_count;
- peer_list->peer_count = peers_count;
-
- if( peers_count )
- peer_list->base = NOW;
- else {
- /* When we got here, the last time that torrent
- has been touched is OT_POOLS_COUNT units before */
- peer_list->base = NOW - OT_POOLS_COUNT;
- }
- return 0;
-}
-
-/* Clean up all peers in current bucket, remove timedout pools and
- torrents */
-void clean_all_torrents( void ) {
- ot_vector *torrents_list;
- size_t i;
- static int bucket;
- ot_time time_now = NOW;
-
- /* Search for an uncleaned bucked */
- while( ( all_torrents_clean[bucket] == time_now ) && ( ++bucket < OT_BUCKET_COUNT ) );
- if( bucket >= OT_BUCKET_COUNT ) {
- bucket = 0; return;
- }
-
- all_torrents_clean[bucket] = time_now;
-
- mutex_bucket_lock( bucket );
- torrents_list = all_torrents + bucket;
- for( i=0; i<torrents_list->size; ++i ) {
- ot_torrent *torrent = ((ot_torrent*)(torrents_list->data)) + i;
- if( clean_single_torrent( torrent ) ) {
- vector_remove_torrent( torrents_list, torrent );
- --i; continue;
- }
- }
- mutex_bucket_unlock( bucket );
-}
-
-typedef struct { size_t val; ot_torrent * torrent; } ot_record;
-
-/* Fetches stats from tracker */
-size_t return_stats_for_tracker( char *reply, int mode ) {
- size_t torrent_count = 0, peer_count = 0, seed_count = 0, j;
- ot_record top5s[5], top5c[5];
- char *r = reply;
- int bucket;
-
- byte_zero( top5s, sizeof( top5s ) );
- byte_zero( top5c, sizeof( top5c ) );
-
- for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
- ot_vector *torrents_list = all_torrents + bucket;
- mutex_bucket_lock( bucket );
- torrent_count += torrents_list->size;
- for( j=0; j<torrents_list->size; ++j ) {
- ot_peerlist *peer_list = ( ((ot_torrent*)(torrents_list->data))[j] ).peer_list;
- if( mode == STATS_TOP5 ) {
- int idx = 4; while( (idx >= 0) && ( peer_list->peer_count > top5c[idx].val ) ) --idx;
- if ( idx++ != 4 ) {
- memmove( top5c + idx + 1, top5c + idx, ( 4 - idx ) * sizeof( ot_record ) );
- top5c[idx].val = peer_list->peer_count;
- top5c[idx].torrent = (ot_torrent*)(torrents_list->data) + j;
- }
- idx = 4; while( (idx >= 0) && ( peer_list->seed_count > top5s[idx].val ) ) --idx;
- if ( idx++ != 4 ) {
- memmove( top5s + idx + 1, top5s + idx, ( 4 - idx ) * sizeof( ot_record ) );
- top5s[idx].val = peer_list->seed_count;
- top5s[idx].torrent = (ot_torrent*)(torrents_list->data) + j;
- }
- }
- peer_count += peer_list->peer_count; seed_count += peer_list->seed_count;
- }
- mutex_bucket_unlock( bucket );
- }
- if( mode == STATS_TOP5 ) {
- char hex_out[42];
- int idx;
- r += sprintf( r, "Top5 torrents by peers:\n" );
- for( idx=0; idx<5; ++idx )
- if( top5c[idx].torrent )
- r += sprintf( r, "\t%zd\t%s\n", top5c[idx].val, to_hex( hex_out, top5c[idx].torrent->hash) );
- r += sprintf( r, "Top5 torrents by seeds:\n" );
- for( idx=0; idx<5; ++idx )
- if( top5s[idx].torrent )
- r += sprintf( r, "\t%zd\t%s\n", top5s[idx].val, to_hex( hex_out, top5s[idx].torrent->hash) );
- } else
- r += sprintf( r, "%zd\n%zd\nopentracker serving %zd torrents\nopentracker", peer_count, seed_count, torrent_count );
-
- return r - reply;
-}
-
-/* This function collects 4096 /24s in 4096 possible
- malloc blocks
-*/
-size_t return_stats_for_slash24s( char *reply, size_t amount, ot_dword thresh ) {
-
-#define NUM_TOPBITS 12
-#define NUM_LOWBITS (24-NUM_TOPBITS)
-#define NUM_BUFS (1<<NUM_TOPBITS)
-#define NUM_S24S (1<<NUM_LOWBITS)
-#define MSK_S24S (NUM_S24S-1)
-
- ot_dword *counts[ NUM_BUFS ];
- ot_dword slash24s[amount*2]; /* first dword amount, second dword subnet */
- int bucket;
- size_t i, j, k, l;
- char *r = reply;
-
- byte_zero( counts, sizeof( counts ) );
- byte_zero( slash24s, amount * 2 * sizeof(ot_dword) );
-
- r += sprintf( r, "Stats for all /24s with more than %u announced torrents:\n\n", thresh );
-
- for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
- ot_vector *torrents_list = all_torrents + bucket;
- mutex_bucket_lock( bucket );
- for( j=0; j<torrents_list->size; ++j ) {
- ot_peerlist *peer_list = ( ((ot_torrent*)(torrents_list->data))[j] ).peer_list;
- for( k=0; k<OT_POOLS_COUNT; ++k ) {
- ot_peer *peers = peer_list->peers[k].data;
- size_t numpeers = peer_list->peers[k].size;
- for( l=0; l<numpeers; ++l ) {
- ot_dword s24 = ntohl(*(ot_dword*)(peers+l)) >> 8;
- ot_dword *count = counts[ s24 >> NUM_LOWBITS ];
- if( !count ) {
- count = malloc( sizeof(ot_dword) * NUM_S24S );
- if( !count )
- goto bailout_cleanup;
- byte_zero( count, sizeof( ot_dword ) * NUM_S24S );
- counts[ s24 >> NUM_LOWBITS ] = count;
- }
- count[ s24 & MSK_S24S ]++;
- }
- }
- }
- mutex_bucket_unlock( bucket );
- }
-
- k = l = 0; /* Debug: count allocated bufs */
- for( i=0; i < NUM_BUFS; ++i ) {
- ot_dword *count = counts[i];
- if( !counts[i] )
- continue;
- ++k; /* Debug: count allocated bufs */
- for( j=0; j < NUM_S24S; ++j ) {
- if( count[j] > thresh ) {
- /* This subnet seems to announce more torrents than the last in our list */
- int insert_pos = amount - 1;
- while( ( insert_pos >= 0 ) && ( count[j] > slash24s[ 2 * insert_pos ] ) )
- --insert_pos;
- ++insert_pos;
- memmove( slash24s + 2 * ( insert_pos + 1 ), slash24s + 2 * ( insert_pos ), 2 * sizeof( ot_dword ) * ( amount - insert_pos - 1 ) );
- slash24s[ 2 * insert_pos ] = count[j];
- slash24s[ 2 * insert_pos + 1 ] = ( i << NUM_TOPBITS ) + j;
- if( slash24s[ 2 * amount - 2 ] > thresh )
- thresh = slash24s[ 2 * amount - 2 ];
- }
- if( count[j] ) ++l;
- }
- free( count );
- }
-
- r += sprintf( r, "Allocated bufs: %zd, used s24s: %zd\n", k, l );
-
- for( i=0; i < amount; ++i )
- if( slash24s[ 2*i ] >= thresh ) {
- ot_dword ip = slash24s[ 2*i +1 ];
- r += sprintf( r, "% 10ld %d.%d.%d.0/24\n", (long)slash24s[ 2*i ], (int)(ip >> 16), (int)(255 & ( ip >> 8 )), (int)(ip & 255) );
- }
-
return r - reply;
-
-bailout_cleanup:
-
- for( i=0; i < NUM_BUFS; ++i )
- free( counts[i] );
-
- return 0;
}
size_t remove_peer_from_torrent( ot_hash *hash, ot_peer *peer, char *reply, int is_tcp ) {
int exactmatch;
size_t index;
- ot_vector *torrents_list = lock_bucket_by_hash( hash );
+ ot_vector *torrents_list = mutex_bucket_lock_by_hash( hash );
ot_torrent *torrent = binary_search( hash, torrents_list->data, torrents_list->size, sizeof( ot_torrent ), OT_HASH_COMPARE_SIZE, &exactmatch );
ot_peerlist *peer_list;
if( !exactmatch ) {
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
if( is_tcp )
return sprintf( reply, "d8:completei0e10:incompletei0e8:intervali%ie5:peers0:e", OT_CLIENT_REQUEST_INTERVAL_RANDOM );
@@ -835,7 +353,7 @@ exit_loop:
if( is_tcp ) {
size_t reply_size = sprintf( reply, "d8:completei%zde10:incompletei%zde8:intervali%ie5:peers0:e", peer_list->seed_count, peer_list->peer_count - peer_list->seed_count, OT_CLIENT_REQUEST_INTERVAL_RANDOM );
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
return reply_size;
}
@@ -844,7 +362,7 @@ exit_loop:
((ot_dword*)reply)[3] = peer_list->peer_count - peer_list->seed_count;
((ot_dword*)reply)[4] = peer_list->seed_count;
- unlock_bucket_by_hash( hash );
+ mutex_bucket_unlock_by_hash( hash );
return (size_t)20;
}
@@ -874,30 +392,28 @@ int trackerlogic_init( const char * const serverdir ) {
}
srandom( time(NULL) );
-
- /* Initialize control structures */
- byte_zero( all_torrents, sizeof( all_torrents ) );
-
+
+ clean_init( );
mutex_init( );
return 0;
}
void trackerlogic_deinit( void ) {
- int i;
+ int bucket;
size_t j;
/* Free all torrents... */
- for(i=0; i<OT_BUCKET_COUNT; ++i ) {
- if( all_torrents[i].size ) {
- ot_torrent *torrents_list = (ot_torrent*)all_torrents[i].data;
- for( j=0; j<all_torrents[i].size; ++j )
- free_peerlist( torrents_list[j].peer_list );
- free( all_torrents[i].data );
+ for(bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
+ ot_vector *torrents_list = mutex_bucket_lock( bucket );
+ if( torrents_list->size ) {
+ for( j=0; j<torrents_list->size; ++j ) {
+ ot_torrent *torrent = ((ot_torrent*)(torrents_list->data)) + j;
+ free_peerlist( torrent->peer_list );
+ }
+ free( torrents_list->data );
}
}
- byte_zero( all_torrents, sizeof (all_torrents));
- byte_zero( all_torrents_clean, sizeof (all_torrents_clean));
-
mutex_deinit( );
-}
+ clean_deinit( );
+} \ No newline at end of file
diff --git a/trackerlogic.h b/trackerlogic.h
index 5b03012..fd80f92 100644
--- a/trackerlogic.h
+++ b/trackerlogic.h
@@ -1,8 +1,8 @@
/* This software was written by Dirk Engling <erdgeist@erdgeist.org>
It is considered beerware. Prost. Skol. Cheers or whatever. */
-#ifndef __TRACKERLOGIC_H__
-#define __TRACKERLOGIC_H__
+#ifndef __OT_TRACKERLOGIC_H__
+#define __OT_TRACKERLOGIC_H__
#include <sys/types.h>
#include <sys/time.h>
@@ -20,16 +20,6 @@ typedef ot_byte ot_hash[20];
typedef ot_dword ot_ip;
typedef time_t ot_time;
-#define OT_VECTOR_MIN_MEMBERS 4
-#define OT_VECTOR_GROW_RATIO 8
-#define OT_VECTOR_SHRINK_THRESH 6
-#define OT_VECTOR_SHRINK_RATIO 4
-typedef struct {
- void *data;
- size_t size;
- size_t space;
-} ot_vector;
-
/* Some tracker behaviour tunable */
#define OT_CLIENT_TIMEOUT 30
#define OT_CLIENT_TIMEOUT_CHECKINTERVAL 10
@@ -42,6 +32,10 @@ typedef struct {
#define OT_CLIENT_REQUEST_INTERVAL_RANDOM ( OT_CLIENT_REQUEST_INTERVAL - OT_CLIENT_REQUEST_VARIATION/2 + (int)( random( ) % OT_CLIENT_REQUEST_VARIATION ) )
+/* We maintain a list of 1024 pointers to sorted list of ot_torrent structs
+ Sort key is, of course, its hash */
+#define OT_BUCKET_COUNT 1024
+
/* Number of tracker admin ip addresses allowed */
#define OT_ADMINIP_MAX 64
#define OT_MAX_THREADS 16
@@ -70,7 +64,16 @@ static const ot_byte PEER_FLAG_STOPPED = 0x20;
#define OT_PEER_COMPARE_SIZE ((size_t)6)
#define OT_HASH_COMPARE_SIZE (sizeof(ot_hash))
+struct ot_peerlist;
+typedef struct ot_peerlist ot_peerlist;
typedef struct {
+ ot_hash hash;
+ ot_peerlist *peer_list;
+} ot_torrent;
+
+#include "ot_vector.h"
+
+struct ot_peerlist {
ot_time base;
size_t seed_count;
size_t peer_count;
@@ -80,12 +83,7 @@ typedef struct {
#ifdef WANT_TRACKER_SYNC
ot_vector changeset;
#endif
-} ot_peerlist;
-
-typedef struct {
- ot_hash hash;
- ot_peerlist *peer_list;
-} ot_torrent;
+};
/*
Exported functions
@@ -100,27 +98,21 @@ typedef struct {
int trackerlogic_init( const char * const serverdir );
void trackerlogic_deinit( void );
-enum { STATS_CONNS, STATS_PEERS, STATS_TOP5, STATS_DMEM, STATS_TCP, STATS_UDP, STATS_SLASH24S, SYNC_IN, SYNC_OUT, STATS_FULLSCRAPE };
-
ot_torrent *add_peer_to_torrent( ot_hash *hash, ot_peer *peer WANT_TRACKER_SYNC_PARAM( int from_changeset ) );
size_t remove_peer_from_torrent( ot_hash *hash, ot_peer *peer, char *reply, int is_tcp );
size_t return_peers_for_torrent( ot_hash *hash, size_t amount, char *reply, int is_tcp );
size_t return_fullscrape_for_tracker( char **reply );
size_t return_tcp_scrape_for_torrent( ot_hash *hash, int amount, char *reply );
size_t return_udp_scrape_for_torrent( ot_hash *hash, char *reply );
-size_t return_stats_for_tracker( char *reply, int mode );
-size_t return_stats_for_slash24s( char *reply, size_t amount, ot_dword thresh );
-size_t return_memstat_for_tracker( char **reply );
void clean_all_torrents( void );
-#ifdef WANT_TRACKER_SYNC
-size_t return_changeset_for_tracker( char **reply );
-int add_changeset_to_tracker( ot_byte *data, size_t len );
-#endif
-
#if defined ( WANT_BLACKLISTING ) || defined ( WANT_CLOSED_TRACKER )
int accesslist_addentry( ot_hash *hash );
void accesslist_reset( void );
#endif
+/* Helper, before it moves to its own object */
+void fix_mmapallocation( void *buf, size_t old_alloc, size_t new_alloc );
+void free_peerlist( ot_peerlist *peer_list );
+
#endif