static int
testString( const char * str,
int isGood )
{
tr_benc val;
const uint8_t * end = NULL;
char * saved;
const size_t len = strlen( str );
int savedLen;
int err = tr_bencParse( str, str + len, &val, &end );
if( !isGood )
{
check( err );
}
else
{
check( !err );
#if 0
fprintf( stderr, "in: [%s]\n", str );
fprintf( stderr, "out:\n%s", tr_bencToStr( &val, TR_FMT_JSON, NULL ) );
#endif
check( end == (const uint8_t*)str + len );
saved = tr_bencToStr( &val, TR_FMT_BENC, &savedLen );
check_streq (str, saved);
check_int_eq (savedLen, len);
tr_free( saved );
tr_bencFree( &val );
}
return 0;
}
static int
testStackSmash( void )
{
int i;
int len;
int err;
uint8_t * in;
const uint8_t * end;
tr_benc val;
char * saved;
const int depth = STACK_SMASH_DEPTH;
in = tr_new( uint8_t, depth * 2 + 1 );
for( i = 0; i < depth; ++i )
{
in[i] = 'l';
in[depth + i] = 'e';
}
in[depth * 2] = '\0';
err = tr_bencParse( in, in + ( depth * 2 ), &val, &end );
check( !err );
check( end == in + ( depth * 2 ) );
saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
check_streq ((char*)in, saved);
tr_free( in );
tr_free( saved );
tr_bencFree( &val );
return 0;
}
static int
testParse2( void )
{
tr_benc top;
tr_benc top2;
int64_t intVal;
const char * strVal;
double realVal;
bool boolVal;
int len;
char * benc;
const uint8_t * end;
tr_bencInitDict( &top, 0 );
tr_bencDictAddBool( &top, "this-is-a-bool", true );
tr_bencDictAddInt( &top, "this-is-an-int", 1234 );
tr_bencDictAddReal( &top, "this-is-a-real", 0.5 );
tr_bencDictAddStr( &top, "this-is-a-string", "this-is-a-string" );
benc = tr_bencToStr( &top, TR_FMT_BENC, &len );
check_streq( "d14:this-is-a-booli1e14:this-is-a-real8:0.50000016:this-is-a-string16:this-is-a-string14:this-is-an-inti1234ee", benc );
check( !tr_bencParse( benc, benc+len, &top2, &end ) );
check( (char*)end == benc + len );
check( tr_bencIsDict( &top2 ) );
check( tr_bencDictFindInt( &top, "this-is-an-int", &intVal ) );
check_int_eq (1234, intVal);
check( tr_bencDictFindBool( &top, "this-is-a-bool", &boolVal ) );
check( boolVal == true );
check( tr_bencDictFindStr( &top, "this-is-a-string", &strVal ) );
check_streq ("this-is-a-string", strVal);
check( tr_bencDictFindReal( &top, "this-is-a-real", &realVal ) );
check_int_eq (50, (int)(realVal*100));
tr_bencFree( &top2 );
tr_free( benc );
tr_bencFree( &top );
return 0;
}
int
tr_ctorSetMetainfoFromMagnetLink( tr_ctor * ctor, const char * magnet_link )
{
int err;
tr_magnet_info * magnet_info = tr_magnetParse( magnet_link );
if( magnet_info == NULL )
err = -1;
else {
int len;
tr_benc tmp;
char * str;
tr_magnetCreateMetainfo( magnet_info, &tmp );
str = tr_bencToStr( &tmp, TR_FMT_BENC, &len );
err = tr_ctorSetMetainfo( ctor, (const uint8_t*)str, len );
tr_free( str );
tr_magnetFree( magnet_info );
}
return err;
}
static void
on_scrape_done( tr_session * session,
bool did_connect,
bool did_timeout,
long response_code,
const void * msg,
size_t msglen,
void * vdata,
bool bsync)
{
tr_scrape_response * response;
struct scrape_data * data = vdata;
response = &data->response;
response->did_connect = did_connect;
response->did_timeout = did_timeout;
dbgmsg( data->log_name, "Got scrape response for \"%s\"", response->url );
if( response_code != HTTP_OK )
{
const char * fmt = _( "Tracker gave HTTP response code %ld (%s)" );
const char * response_str = tr_webGetResponseStr( response_code );
response->errmsg = tr_strdup_printf( fmt, response_code, response_str );
}
else
{
tr_benc top;
int64_t intVal;
tr_benc * files;
tr_benc * flags;
const char * str;
const int benc_loaded = !tr_bencLoad( msg, msglen, &top, NULL );
if( getenv( "TR_CURL_VERBOSE" ) != NULL )
{
if( !benc_loaded )
fprintf( stderr, "%s", "Scrape response was not in benc format\n" );
else {
int i, len;
char * str = tr_bencToStr( &top, TR_FMT_JSON, &len );
fprintf( stderr, "%s", "Scrape response:\n< " );
for( i=0; i<len; ++i )
fputc( str[i], stderr );
fputc( '\n', stderr );
tr_free( str );
}
}
if( benc_loaded )
{
if( tr_bencDictFindStr( &top, "failure reason", &str ) )
response->errmsg = tr_strdup( str );
if( tr_bencDictFindDict( &top, "flags", &flags ) )
if( tr_bencDictFindInt( flags, "min_request_interval", &intVal ) )
response->min_request_interval = intVal;
if( tr_bencDictFindDict( &top, "files", &files ) )
{
int i = 0;
for( ;; )
{
int j;
tr_benc * val;
const char * key;
/* get the next "file" */
if( !tr_bencDictChild( files, i++, &key, &val ) )
break;
/* populate the corresponding row in our response array */
for( j=0; j<response->row_count; ++j )
{
struct tr_scrape_response_row * row = &response->rows[j];
if( !memcmp( key, row->info_hash, SHA_DIGEST_LENGTH ) )
{
if( tr_bencDictFindInt( val, "complete", &intVal ) )
row->seeders = intVal;
if( tr_bencDictFindInt( val, "incomplete", &intVal ) )
row->leechers = intVal;
if( tr_bencDictFindInt( val, "downloaded", &intVal ) )
row->downloads = intVal;
if( tr_bencDictFindInt( val, "downloaders", &intVal ) )
row->downloaders = intVal;
break;
}
}
}
}
tr_bencFree( &top );
}
}
if(!bsync)
{
tr_runInEventThread( session, on_scrape_done_eventthread, data );
}
else
{
on_scrape_done_eventthread(data);
}
}
static void
on_announce_done( tr_session * session,
bool did_connect,
bool did_timeout,
long response_code,
const void * msg,
size_t msglen,
void * vdata,
bool bsync)
{
tr_announce_response * response;
struct announce_data * data = vdata;
response = &data->response;
response->did_connect = did_connect;
response->did_timeout = did_timeout;
dbgmsg( data->log_name, "Got announce response" );
if( response_code != HTTP_OK )
{
const char * fmt = _( "Tracker gave HTTP response code %ld (%s)" );
const char * response_str = tr_webGetResponseStr( response_code );
response->errmsg = tr_strdup_printf( fmt, response_code, response_str );
}
else
{
tr_benc benc;
const int benc_loaded = !tr_bencLoad( msg, msglen, &benc, NULL );
if( getenv( "TR_CURL_VERBOSE" ) != NULL )
{
if( !benc_loaded )
fprintf( stderr, "%s", "Announce response was not in benc format\n" );
else {
int i, len;
char * str = tr_bencToStr( &benc, TR_FMT_JSON, &len );
fprintf( stderr, "%s", "Announce response:\n< " );
for( i=0; i<len; ++i )
fputc( str[i], stderr );
fputc( '\n', stderr );
tr_free( str );
}
}
if( benc_loaded && tr_bencIsDict( &benc ) )
{
int64_t i;
size_t rawlen;
tr_benc * tmp;
const char * str;
const uint8_t * raw;
if( tr_bencDictFindStr( &benc, "failure reason", &str ) )
response->errmsg = tr_strdup( str );
if( tr_bencDictFindStr( &benc, "warning message", &str ) )
response->warning = tr_strdup( str );
if( tr_bencDictFindInt( &benc, "interval", &i ) )
response->interval = i;
if( tr_bencDictFindInt( &benc, "min interval", &i ) )
response->min_interval = i;
if( tr_bencDictFindStr( &benc, "tracker id", &str ) )
response->tracker_id_str = tr_strdup( str );
if( tr_bencDictFindInt( &benc, "complete", &i ) )
response->seeders = i;
if( tr_bencDictFindInt( &benc, "incomplete", &i ) )
response->leechers = i;
if( tr_bencDictFindInt( &benc, "downloaded", &i ) )
response->downloads = i;
if( tr_bencDictFindRaw( &benc, "peers6", &raw, &rawlen ) ) {
dbgmsg( data->log_name, "got a peers6 length of %u", rawlen );
response->pex6 = tr_peerMgrCompact6ToPex( raw, rawlen,
NULL, 0, &response->pex6_count );
}
if( tr_bencDictFindRaw( &benc, "peers", &raw, &rawlen ) ) {
dbgmsg( data->log_name, "got a compact peers length of %u", rawlen );
response->pex = tr_peerMgrCompactToPex( raw, rawlen,
NULL, 0, &response->pex_count );
} else if( tr_bencDictFindList( &benc, "peers", &tmp ) ) {
response->pex = listToPex( tmp, &response->pex_count );
dbgmsg( data->log_name, "got a peers list with %u entries",
response->pex_count );
}
}
if( benc_loaded )
tr_bencFree( &benc );
}
if(!bsync)
{
tr_runInEventThread( session, on_announce_done_eventthread, data );
}
else
{
on_announce_done_eventthread(data);
}
}
int
main( int argc, char ** argv )
{
int c;
const char * optarg;
tr_benc settings;
tr_bool boolVal;
tr_bool loaded;
tr_bool foreground = FALSE;
tr_bool dumpSettings = FALSE;
const char * configDir = NULL;
const char * pid_filename;
dtr_watchdir * watchdir = NULL;
FILE * logfile = NULL;
tr_bool pidfile_created = FALSE;
signal( SIGINT, gotsig );
signal( SIGTERM, gotsig );
#ifndef WIN32
signal( SIGHUP, gotsig );
#endif
/* load settings from defaults + config file */
tr_bencInitDict( &settings, 0 );
tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, TRUE );
configDir = getConfigDir( argc, (const char**)argv );
loaded = tr_sessionLoadSettings( &settings, configDir, MY_NAME );
/* overwrite settings from the comamndline */
tr_optind = 1;
while(( c = tr_getopt( getUsage(), argc, (const char**)argv, options, &optarg ))) {
switch( c ) {
case 'a': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_WHITELIST, optarg );
tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, TRUE );
break;
case 'b': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, TRUE );
break;
case 'B': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
break;
case 'c': tr_bencDictAddStr( &settings, PREF_KEY_DIR_WATCH, optarg );
tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, TRUE );
break;
case 'C': tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
break;
case 941: tr_bencDictAddStr( &settings, TR_PREFS_KEY_INCOMPLETE_DIR, optarg );
tr_bencDictAddBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, TRUE );
break;
case 942: tr_bencDictAddBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, FALSE );
break;
case 'd': dumpSettings = TRUE;
break;
case 'e': logfile = fopen( optarg, "a+" );
if( logfile == NULL )
fprintf( stderr, "Couldn't open \"%s\": %s\n", optarg, tr_strerror( errno ) );
break;
case 'f': foreground = TRUE;
break;
case 'g': /* handled above */
break;
case 'V': /* version */
fprintf(stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING);
exit( 0 );
case 'o': tr_bencDictAddBool( &settings, TR_PREFS_KEY_DHT_ENABLED, TRUE );
break;
case 'O': tr_bencDictAddBool( &settings, TR_PREFS_KEY_DHT_ENABLED, FALSE );
break;
case 'p': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_PORT, atoi( optarg ) );
break;
case 't': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, TRUE );
break;
case 'T': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, FALSE );
break;
case 'u': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_USERNAME, optarg );
break;
case 'v': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_PASSWORD, optarg );
break;
case 'w': tr_bencDictAddStr( &settings, TR_PREFS_KEY_DOWNLOAD_DIR, optarg );
break;
case 'P': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_PORT, atoi( optarg ) );
break;
case 'm': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
break;
case 'M': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, FALSE );
break;
case 'L': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi( optarg ) );
break;
case 'l': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi( optarg ) );
break;
case 800: paused = TRUE;
break;
case 910: tr_bencDictAddInt( &settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED );
break;
case 911: tr_bencDictAddInt( &settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED );
break;
case 912: tr_bencDictAddInt( &settings, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED );
break;
case 'i': tr_bencDictAddStr( &settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, optarg );
break;
case 'I': tr_bencDictAddStr( &settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, optarg );
break;
case 'r': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_BIND_ADDRESS, optarg );
break;
case 953: tr_bencDictAddReal( &settings, TR_PREFS_KEY_RATIO, atof(optarg) );
tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, TRUE );
break;
case 954: tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, FALSE );
break;
case 'x': tr_bencDictAddStr( &settings, PREF_KEY_PIDFILE, optarg );
break;
case 'y': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, TRUE );
break;
case 'Y': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, FALSE );
break;
case 810: tr_bencDictAddInt( &settings, TR_PREFS_KEY_MSGLEVEL, TR_MSG_ERR );
break;
case 811: tr_bencDictAddInt( &settings, TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF );
break;
case 812: tr_bencDictAddInt( &settings, TR_PREFS_KEY_MSGLEVEL, TR_MSG_DBG );
break;
default: showUsage( );
break;
}
}
if( foreground && !logfile )
logfile = stderr;
if( !loaded )
{
printMessage( logfile, TR_MSG_ERR, MY_NAME, "Error loading config file -- exiting.", __FILE__, __LINE__ );
return -1;
}
if( dumpSettings )
{
char * str = tr_bencToStr( &settings, TR_FMT_JSON, NULL );
fprintf( stderr, "%s", str );
tr_free( str );
return 0;
}
if( !foreground && tr_daemon( TRUE, FALSE ) < 0 )
{
char buf[256];
tr_snprintf( buf, sizeof( buf ), "Failed to daemonize: %s", tr_strerror( errno ) );
printMessage( logfile, TR_MSG_ERR, MY_NAME, buf, __FILE__, __LINE__ );
exit( 1 );
}
/* start the session */
tr_formatter_mem_init( MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR );
tr_formatter_size_init( DISK_K, DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR );
tr_formatter_speed_init( SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR );
mySession = tr_sessionInit( "daemon", configDir, TRUE, &settings );
tr_ninf( NULL, "Using settings from \"%s\"", configDir );
tr_sessionSaveSettings( mySession, configDir, &settings );
pid_filename = NULL;
tr_bencDictFindStr( &settings, PREF_KEY_PIDFILE, &pid_filename );
if( pid_filename && *pid_filename )
{
FILE * fp = fopen( pid_filename, "w+" );
if( fp != NULL )
{
fprintf( fp, "%d", (int)getpid() );
fclose( fp );
tr_inf( "Saved pidfile \"%s\"", pid_filename );
pidfile_created = TRUE;
}
else
tr_err( "Unable to save pidfile \"%s\": %s", pid_filename, strerror( errno ) );
}
if( tr_bencDictFindBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal ) && boolVal )
tr_ninf( MY_NAME, "requiring authentication" );
/* maybe add a watchdir */
{
const char * dir;
if( tr_bencDictFindBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal )
&& boolVal
&& tr_bencDictFindStr( &settings, PREF_KEY_DIR_WATCH, &dir )
&& dir
&& *dir )
{
tr_inf( "Watching \"%s\" for new .torrent files", dir );
watchdir = dtr_watchdir_new( mySession, dir, onFileAdded );
}
}
/* load the torrents */
{
tr_torrent ** torrents;
tr_ctor * ctor = tr_ctorNew( mySession );
if( paused )
tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
torrents = tr_sessionLoadTorrents( mySession, ctor, NULL );
tr_free( torrents );
tr_ctorFree( ctor );
}
#ifdef HAVE_SYSLOG
if( !foreground )
openlog( MY_NAME, LOG_CONS|LOG_PID, LOG_DAEMON );
#endif
while( !closing ) {
tr_wait_msec( 1000 ); /* sleep one second */
dtr_watchdir_update( watchdir );
pumpLogMessages( logfile );
}
/* shutdown */
#if HAVE_SYSLOG
if( !foreground )
{
syslog( LOG_INFO, "%s", "Closing session" );
closelog( );
}
#endif
printf( "Closing transmission session..." );
tr_sessionSaveSettings( mySession, configDir, &settings );
dtr_watchdir_free( watchdir );
tr_sessionClose( mySession );
printf( " done.\n" );
/* cleanup */
if( pidfile_created )
remove( pid_filename );
tr_bencFree( &settings );
return 0;
}
static int
testParse( void )
{
tr_benc val;
tr_benc * child;
tr_benc * child2;
uint8_t buf[512];
const uint8_t * end;
int err;
int len;
int64_t i;
char * saved;
tr_snprintf( (char*)buf, sizeof( buf ), "i64e" );
err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
check( !err );
check( tr_bencGetInt( &val, &i ) );
check_int_eq (64, i);
check( end == buf + 4 );
tr_bencFree( &val );
tr_snprintf( (char*)buf, sizeof( buf ), "li64ei32ei16ee" );
err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
check( !err );
check( end == buf + strlen( (char*)buf ) );
check( val.val.l.count == 3 );
check( tr_bencGetInt( &val.val.l.vals[0], &i ) );
check_int_eq (64, i);
check( tr_bencGetInt( &val.val.l.vals[1], &i ) );
check_int_eq (32, i);
check( tr_bencGetInt( &val.val.l.vals[2], &i ) );
check_int_eq (16, i);
saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
check_streq ((char*)buf, saved);
tr_free( saved );
tr_bencFree( &val );
end = NULL;
tr_snprintf( (char*)buf, sizeof( buf ), "lllee" );
err = tr_bencParse( buf, buf + strlen( (char*)buf ), &val, &end );
check( err );
check( end == NULL );
end = NULL;
tr_snprintf( (char*)buf, sizeof( buf ), "le" );
err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
check( !err );
check( end == buf + 2 );
saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
check_streq( "le", saved );
tr_free( saved );
tr_bencFree( &val );
if( ( err = testString( "llleee", true ) ) )
return err;
if( ( err = testString( "d3:cow3:moo4:spam4:eggse", true ) ) )
return err;
if( ( err = testString( "d4:spaml1:a1:bee", true ) ) )
return err;
if( ( err =
testString( "d5:greenli1ei2ei3ee4:spamd1:ai123e3:keyi214eee",
true ) ) )
return err;
if( ( err =
testString(
"d9:publisher3:bob17:publisher-webpage15:www.example.com18:publisher.location4:homee",
true ) ) )
return err;
if( ( err =
testString(
"d8:completei1e8:intervali1800e12:min intervali1800e5:peers0:e",
true ) ) )
return err;
if( ( err = testString( "d1:ai0e1:be", false ) ) ) /* odd number of children
*/
return err;
if( ( err = testString( "", false ) ) )
return err;
if( ( err = testString( " ", false ) ) )
return err;
/* nested containers
* parse an unsorted dict
* save as a sorted dict */
end = NULL;
tr_snprintf( (char*)buf, sizeof( buf ), "lld1:bi32e1:ai64eeee" );
err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
check( !err );
check( end == buf + strlen( (const char*)buf ) );
check( ( child = tr_bencListChild( &val, 0 ) ) );
check( ( child2 = tr_bencListChild( child, 0 ) ) );
saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
check_streq( "lld1:ai64e1:bi32eeee", saved );
tr_free( saved );
tr_bencFree( &val );
/* too many endings */
end = NULL;
tr_snprintf( (char*)buf, sizeof( buf ), "leee" );
err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
check( !err );
check( end == buf + 2 );
saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
check_streq( "le", saved );
tr_free( saved );
tr_bencFree( &val );
/* no ending */
end = NULL;
tr_snprintf( (char*)buf, sizeof( buf ), "l1:a1:b1:c" );
err = tr_bencParse( buf, buf + strlen( (char*)buf ), &val, &end );
check( err );
/* incomplete string */
end = NULL;
tr_snprintf( (char*)buf, sizeof( buf ), "1:" );
err = tr_bencParse( buf, buf + strlen( (char*)buf ), &val, &end );
check( err );
return 0;
}
