mirror of git://erdgeist.org/opentracker
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
120 lines
3.6 KiB
C
120 lines
3.6 KiB
C
/* 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 ) );
|
|
}
|