void
tr_magnetCreateMetainfo( const tr_magnet_info * info, tr_benc * top )
{
int i;
tr_benc * d;
tr_bencInitDict( top, 4 );
/* announce list */
if( info->trackerCount == 1 )
tr_bencDictAddStr( top, "announce", info->trackers[0] );
else {
tr_benc * trackers = tr_bencDictAddList( top, "announce-list", info->trackerCount );
for( i=0; i<info->trackerCount; ++i )
tr_bencListAddStr( tr_bencListAddList( trackers, 1 ), info->trackers[i] );
}
/* webseeds */
if( info->webseedCount > 0 ) {
tr_benc * urls = tr_bencDictAddList( top, "url-list", info->webseedCount );
for( i=0; i<info->webseedCount; ++i )
tr_bencListAddStr( urls, info->webseeds[i] );
}
/* nonstandard keys */
d = tr_bencDictAddDict( top, "magnet-info", 2 );
tr_bencDictAddRaw( d, "info_hash", info->hash, 20 );
if( info->displayName != NULL )
tr_bencDictAddStr( d, "display-name", info->displayName );
}
/**
* This is where we initialize the preferences file with the default values.
* If you add a new preferences key, you /must/ add a default value here.
*/
static void
tr_prefs_init_defaults( tr_benc * d )
{
const char * str;
cf_check_older_configs( );
#ifdef HAVE_GIO
str = NULL;
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
if( !str ) str = tr_getDefaultDownloadDir( );
tr_bencDictAddStr( d, PREF_KEY_DIR_WATCH, str );
tr_bencDictAddBool( d, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
#endif
tr_bencDictAddBool( d, PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, FALSE );
tr_bencDictAddBool( d, PREF_KEY_INHIBIT_HIBERNATION, FALSE );
tr_bencDictAddBool( d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
tr_bencDictAddStr( d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
tr_bencDictAddBool( d, PREF_KEY_TOOLBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_FILTERBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_STATUSBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_TRAY_ICON, FALSE );
tr_bencDictAddBool( d, PREF_KEY_PLAY_DOWNLOAD_COMPLETE_SOUND, TRUE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_DESKTOP_NOTIFICATION, TRUE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_MORE_TRACKER_INFO, FALSE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_MORE_PEER_INFO, FALSE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_BACKUP_TRACKERS, FALSE );
tr_bencDictAddStr( d, PREF_KEY_STATUSBAR_STATS, "total-ratio" );
tr_bencDictAddBool( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
tr_bencDictAddBool( d, PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, FALSE );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_WIDTH, 300 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_X, 50 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_Y, 50 );
str = NULL;
#if GLIB_CHECK_VERSION( 2, 14, 0 )
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
#endif
if( !str ) str = tr_getDefaultDownloadDir( );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, str );
tr_bencDictAddBool( d, PREF_KEY_ASKQUIT, TRUE );
tr_bencDictAddStr( d, PREF_KEY_SORT_MODE, "sort-by-name" );
tr_bencDictAddBool( d, PREF_KEY_SORT_REVERSED, FALSE );
tr_bencDictAddBool( d, PREF_KEY_COMPACT_VIEW, FALSE );
}
static void
translate_keyfile_to_json( const char * old_file, const char * new_file )
{
tr_benc dict;
GKeyFile * keyfile;
gchar ** keys;
gsize i;
gsize length;
static struct pref_entry {
const char* oldkey;
const char* newkey;
} renamed[] = {
{ "default-download-directory", "download-dir" },
{ "encrypted-connections-only", "encryption" },
{ "listening-port", "peer-port" },
{ "nat-traversal-enabled", "port-forwarding-enabled" },
{ "open-dialog-folder", "open-dialog-dir" },
{ "watch-folder", "watch-dir" },
{ "watch-folder-enabled", "watch-dir-enabled" }
};
keyfile = g_key_file_new( );
g_key_file_load_from_file( keyfile, old_file, 0, NULL );
length = 0;
keys = g_key_file_get_keys( keyfile, "general", &length, NULL );
tr_bencInitDict( &dict, length );
for( i = 0; i < length; ++i )
{
guint j;
const char * key = keys[i];
gchar * val = g_key_file_get_value( keyfile, "general", key,
NULL );
for( j = 0; j < G_N_ELEMENTS( renamed ); ++j )
if( !strcmp( renamed[j].oldkey, key ) )
key = renamed[j].newkey;
if( !strcmp( val, "true" ) || !strcmp( val, "false" ) )
tr_bencDictAddInt( &dict, key, !strcmp( val, "true" ) );
else
{
char * end;
long l;
errno = 0;
l = strtol( val, &end, 10 );
if( !errno && end && !*end )
tr_bencDictAddInt( &dict, key, l );
else
tr_bencDictAddStr( &dict, key, val );
}
g_free( val );
}
g_key_file_free( keyfile );
tr_bencToFile( &dict, TR_FMT_JSON, new_file );
tr_bencFree( &dict );
}
void
tr_torrentSaveResume( tr_torrent * tor )
{
int err;
tr_benc top;
char * filename;
if( !tr_isTorrent( tor ) )
return;
tr_bencInitDict( &top, 50 ); /* arbitrary "big enough" number */
tr_bencDictAddInt( &top, KEY_TIME_SEEDING, tor->secondsSeeding );
tr_bencDictAddInt( &top, KEY_TIME_DOWNLOADING, tor->secondsDownloading );
tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE, tor->activityDate );
tr_bencDictAddInt( &top, KEY_ADDED_DATE, tor->addedDate );
tr_bencDictAddInt( &top, KEY_CORRUPT, tor->corruptPrev + tor->corruptCur );
tr_bencDictAddInt( &top, KEY_DONE_DATE, tor->doneDate );
tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR, tor->downloadDir );
if( tor->incompleteDir != NULL )
tr_bencDictAddStr( &top, KEY_INCOMPLETE_DIR, tor->incompleteDir );
tr_bencDictAddInt( &top, KEY_DOWNLOADED, tor->downloadedPrev + tor->downloadedCur );
tr_bencDictAddInt( &top, KEY_UPLOADED, tor->uploadedPrev + tor->uploadedCur );
tr_bencDictAddInt( &top, KEY_MAX_PEERS, tor->maxConnectedPeers );
tr_bencDictAddInt( &top, KEY_BANDWIDTH_PRIORITY, tr_torrentGetPriority( tor ) );
tr_bencDictAddBool( &top, KEY_PAUSED, !tor->isRunning );
savePeers( &top, tor );
if( tr_torrentHasMetadata( tor ) )
{
saveFilePriorities( &top, tor );
saveDND( &top, tor );
saveProgress( &top, tor );
}
saveSpeedLimits( &top, tor );
saveRatioLimits( &top, tor );
saveIdleLimits( &top, tor );
filename = getResumeFilename( tor );
if(( err = tr_bencToFile( &top, TR_FMT_BENC, filename )))
tr_torrentSetLocalError( tor, "Unable to save resume file: %s", tr_strerror( err ) );
tr_free( filename );
tr_bencFree( &top );
}
/**
* This is where we initialize the preferences file with the default values.
* If you add a new preferences key, you /must/ add a default value here.
*/
static void
tr_prefs_init_defaults( tr_benc * d )
{
const char * str;
cf_check_older_configs( );
str = NULL;
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
if( !str ) str = tr_getDefaultDownloadDir( );
tr_bencDictAddStr ( d, PREF_KEY_DIR_WATCH, str );
tr_bencDictAddBool( d, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
tr_bencDictAddBool( d, PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, FALSE );
tr_bencDictAddBool( d, PREF_KEY_INHIBIT_HIBERNATION, FALSE );
tr_bencDictAddBool( d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
tr_bencDictAddStr ( d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
tr_bencDictAddBool( d, PREF_KEY_TOOLBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_FILTERBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_STATUSBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_TRASH_CAN_ENABLED, TRUE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_TRAY_ICON, FALSE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_MORE_TRACKER_INFO, FALSE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_MORE_PEER_INFO, FALSE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_BACKUP_TRACKERS, FALSE );
tr_bencDictAddStr ( d, PREF_KEY_STATUSBAR_STATS, "total-ratio" );
tr_bencDictAddStr ( d, PREF_KEY_TORRENT_ADDED_NOTIFICATION_COMMAND, "notify-send -c transfer -i transmission '%s' '%s'" );
tr_bencDictAddBool( d, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, true );
tr_bencDictAddStr ( d, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_COMMAND, "notify-send -c transfer.complete -i transmission '%s' '%s'" );
tr_bencDictAddBool( d, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, true );
tr_bencDictAddStr ( d, PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND, "canberra-gtk-play -i complete-download -d 'transmission torrent downloaded'" );
tr_bencDictAddBool( d, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, true );
tr_bencDictAddBool( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
tr_bencDictAddBool( d, PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, FALSE );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_WIDTH, 300 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_X, 50 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_Y, 50 );
str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, str );
tr_bencDictAddStr( d, PREF_KEY_SORT_MODE, "sort-by-name" );
tr_bencDictAddBool( d, PREF_KEY_SORT_REVERSED, FALSE );
tr_bencDictAddBool( d, PREF_KEY_COMPACT_VIEW, FALSE );
}
/**
* This is where we initialize the preferences file with the default values.
* If you add a new preferences key, you /must/ add a default value here.
*/
static void
tr_prefs_init_defaults( tr_benc * d )
{
const char * str;
cf_check_older_configs( );
#ifdef HAVE_GIO
str = NULL;
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
if( !str ) str = tr_getDefaultDownloadDir( );
tr_bencDictAddStr( d, PREF_KEY_DIR_WATCH, str );
tr_bencDictAddInt( d, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
#endif
tr_bencDictAddInt( d, PREF_KEY_INHIBIT_HIBERNATION, FALSE );
tr_bencDictAddInt( d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
tr_bencDictAddStr( d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
tr_bencDictAddInt( d, PREF_KEY_TOOLBAR, TRUE );
tr_bencDictAddInt( d, PREF_KEY_FILTERBAR, TRUE );
tr_bencDictAddInt( d, PREF_KEY_STATUSBAR, TRUE );
tr_bencDictAddInt( d, PREF_KEY_SHOW_TRAY_ICON, FALSE );
tr_bencDictAddInt( d, PREF_KEY_SHOW_DESKTOP_NOTIFICATION, TRUE );
tr_bencDictAddStr( d, PREF_KEY_STATUSBAR_STATS, "total-ratio" );
tr_bencDictAddInt( d, PREF_KEY_SCHED_LIMIT_ENABLED, FALSE );
tr_bencDictAddInt( d, PREF_KEY_SCHED_BEGIN, 60 * 23 ); /* 11pm */
tr_bencDictAddInt( d, PREF_KEY_SCHED_END, 60 * 7 ); /* 7am */
tr_bencDictAddInt( d, PREF_KEY_SCHED_DL_LIMIT, 200 ); /* 2x the other limit */
tr_bencDictAddInt( d, PREF_KEY_SCHED_UL_LIMIT, 100 ); /* 2x the other limit */
tr_bencDictAddInt( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_WIDTH, 300 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_X, 50 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_Y, 50 );
tr_bencDictAddStr( d, PREF_KEY_MAIN_WINDOW_LAYOUT_ORDER, "menu,toolbar,filter,list,statusbar" );
str = NULL;
#if GLIB_CHECK_VERSION( 2, 14, 0 )
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
#endif
if( !str ) str = tr_getDefaultDownloadDir( );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, str );
tr_bencDictAddInt( d, PREF_KEY_ASKQUIT, TRUE );
tr_bencDictAddStr( d, PREF_KEY_SORT_MODE, "sort-by-name" );
tr_bencDictAddInt( d, PREF_KEY_SORT_REVERSED, FALSE );
tr_bencDictAddInt( d, PREF_KEY_MINIMAL_VIEW, FALSE );
tr_bencDictAddInt( d, PREF_KEY_START, TRUE );
tr_bencDictAddInt( d, PREF_KEY_TRASH_ORIGINAL, FALSE );
}
static tr_bool
addURL( tr_benc * metainfo, const char * url )
{
const char * str;
tr_benc * announce_list;
tr_bool changed = FALSE;
tr_bool match = FALSE;
/* maybe add it to "announce" */
if( !tr_bencDictFindStr( metainfo, "announce", &str ) )
{
printf( "\tAdded \"%s\" in \"announce\"\n", url );
tr_bencDictAddStr( metainfo, "announce", url );
changed = TRUE;
}
/* see if it's already in announce-list */
if( tr_bencDictFindList( metainfo, "announce-list", &announce_list ) ) {
tr_benc * tier;
int tierCount = 0;
while(( tier = tr_bencListChild( announce_list, tierCount++ ))) {
tr_benc * node;
int nodeCount = 0;
while(( node = tr_bencListChild( tier, nodeCount++ )))
if( tr_bencGetStr( node, &str ) && !strcmp( str, url ) )
match = TRUE;
}
}
/* if it's not in announce-list, add it now */
if( !match )
{
tr_benc * tier;
if( !tr_bencDictFindList( metainfo, "announce-list", &announce_list ) )
announce_list = tr_bencDictAddList( metainfo, "announce-list", 1 );
tier = tr_bencListAddList( announce_list, 1 );
tr_bencListAddStr( tier, url );
printf( "\tAdded \"%s\" to \"announce-list\" tier %zu\n", url, tr_bencListSize( announce_list ) );
changed = TRUE;
}
return changed;
}
static void
tr_idle_function_done( struct tr_rpc_idle_data * data, const char * result )
{
struct evbuffer * buf = tr_getBuffer( );
if( result == NULL )
result = "success";
tr_bencDictAddStr( data->response, "result", result );
tr_bencSaveAsJSON( data->response, buf );
(*data->callback)( data->session, (const char*)EVBUFFER_DATA(buf),
EVBUFFER_LENGTH(buf), data->callback_user_data );
tr_releaseBuffer( buf );
tr_bencFree( data->response );
tr_free( data->response );
tr_free( data );
}
static bool
addURL (tr_benc * metainfo, const char * url)
{
const char * announce = NULL;
tr_benc * announce_list = NULL;
bool changed = false;
const bool had_announce = tr_bencDictFindStr (metainfo, "announce", &announce);
const bool had_announce_list = tr_bencDictFindList (metainfo, "announce-list", &announce_list);
if (!had_announce && !had_announce_list)
{
/* this new tracker is the only one, so add it to "announce"... */
printf ("\tAdded \"%s\" in \"announce\"\n", url);
tr_bencDictAddStr (metainfo, "announce", url);
changed = true;
}
else
{
if (!had_announce_list)
{
announce_list = tr_bencDictAddList (metainfo, "announce-list", 2);
if (had_announce)
{
/* we're moving from an 'announce' to an 'announce-list',
* so copy the old announce URL to the list */
tr_benc * tier = tr_bencListAddList (announce_list, 1);
tr_bencListAddStr (tier, announce);
changed = true;
}
}
/* If the user-specified URL isn't in the announce list yet, add it */
if (!announce_list_has_url (announce_list, url))
{
tr_benc * tier = tr_bencListAddList (announce_list, 1);
tr_bencListAddStr (tier, url);
printf ("\tAdded \"%s\" to \"announce-list\" tier %zu\n", url, tr_bencListSize (announce_list));
changed = true;
}
}
return changed;
}
void
tr_sessionGetSettings( tr_session * s, struct tr_benc * d )
{
int i, n=0;
char * freeme[16];
assert( tr_bencIsDict( d ) );
tr_bencDictReserve( d, 30 );
tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, s->downloadDir );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, s->encryptionMode );
tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD, s->useLazyBitfield );
tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL, tr_getMessageLevel( ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT, s->openFileLimit );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, s->peerLimitPerTorrent );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, s->isPortRandom );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, s->randomPortLow );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, s->randomPortHigh );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS, s->peerSocketTOS );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED, s->isPexEnabled );
tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION, s->preallocationMode );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY, s->proxy );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED, s->isProxyAuthEnabled );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED, s->isProxyEnabled );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD, s->proxyPassword );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT, s->proxyPort );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE, s->proxyType );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME, s->proxyUsername );
tr_bencDictAddDouble( d, TR_PREFS_KEY_RATIO, s->desiredRatio );
tr_bencDictAddInt( d, TR_PREFS_KEY_RATIO_ENABLED, s->isRatioLimited );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED, tr_sessionIsRPCEnabled( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT, tr_sessionGetRPCPort( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME, freeme[n++] = tr_sessionGetRPCUsername( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST, freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, s->uploadSlotsPerTorrent );
for( i=0; i<n; ++i )
tr_free( freeme[i] );
}
void
tr_sessionGetDefaultSettings( tr_benc * d )
{
assert( tr_bencIsDict( d ) );
tr_bencDictReserve( d, 30 );
tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_getDefaultDownloadDir( ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED, 100 );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, 0 );
tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, TR_DEFAULT_ENCRYPTION );
tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF );
tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT, atoi( TR_DEFAULT_OPEN_FILE_LIMIT_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi( TR_DEFAULT_PEER_LIMIT_GLOBAL_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi( TR_DEFAULT_PEER_LIMIT_TORRENT_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, atoi( TR_DEFAULT_PEER_PORT_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, 1024 );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, 65535 );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi( TR_DEFAULT_PEER_SOCKET_TOS_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION, TR_PREALLOCATE_SPARSE );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY, "" );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED, FALSE );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD, "" );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT, 80 );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE, TR_PROXY_HTTP );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME, "" );
tr_bencDictAddDouble( d, TR_PREFS_KEY_RATIO, 2.0 );
tr_bencDictAddInt( d, TR_PREFS_KEY_RATIO_ENABLED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED, TRUE );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD, "" );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME, "" );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST, TR_DEFAULT_RPC_WHITELIST );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT, atoi( TR_DEFAULT_RPC_PORT_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, 100 );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 0 );
tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, 14 );
}
int
tr_ctorSetMetainfoFromFile( tr_ctor * ctor,
const char * filename )
{
uint8_t * metainfo;
size_t len;
int err;
metainfo = tr_loadFile( filename, &len );
if( metainfo && len )
err = tr_ctorSetMetainfo( ctor, metainfo, len );
else
{
clearMetainfo( ctor );
err = 1;
}
setSourceFile( ctor, filename );
/* if no `name' field was set, then set it from the filename */
if( ctor->isSet_metainfo )
{
tr_benc * info;
if( tr_bencDictFindDict( &ctor->metainfo, "info", &info ) )
{
const char * name;
if( !tr_bencDictFindStr( info, "name.utf-8", &name ) )
if( !tr_bencDictFindStr( info, "name", &name ) )
name = NULL;
if( !name || !*name )
{
char * base = tr_basename( filename );
tr_bencDictAddStr( info, "name", base );
tr_free( base );
}
}
}
tr_free( metainfo );
return err;
}
static bool
replaceURL (tr_benc * metainfo, const char * in, const char * out)
{
const char * str;
tr_benc * announce_list;
bool changed = false;
if (tr_bencDictFindStr (metainfo, "announce", &str) && strstr (str, in))
{
char * newstr = replaceSubstr (str, in, out);
printf ("\tReplaced in \"announce\": \"%s\" --> \"%s\"\n", str, newstr);
tr_bencDictAddStr (metainfo, "announce", newstr);
tr_free (newstr);
changed = true;
}
if (tr_bencDictFindList (metainfo, "announce-list", &announce_list))
{
tr_benc * tier;
int tierCount = 0;
while ((tier = tr_bencListChild (announce_list, tierCount++)))
{
tr_benc * node;
int nodeCount = 0;
while ((node = tr_bencListChild (tier, nodeCount++)))
{
if (tr_bencGetStr (node, &str) && strstr (str, in))
{
char * newstr = replaceSubstr (str, in, out);
printf ("\tReplaced in \"announce-list\" tier %d: \"%s\" --> \"%s\"\n", tierCount, str, newstr);
tr_bencFree (node);
tr_bencInitStr (node, newstr, -1);
tr_free (newstr);
changed = true;
}
}
}
}
return changed;
}
static int
testMerge( void )
{
tr_benc dest, src;
int64_t i;
const char * s;
/* initial dictionary (default values) */
tr_bencInitDict( &dest, 10 );
tr_bencDictAddInt( &dest, "i1", 1 );
tr_bencDictAddInt( &dest, "i2", 2 );
tr_bencDictAddInt( &dest, "i4", -35 ); /* remains untouched */
tr_bencDictAddStr( &dest, "s5", "abc" );
tr_bencDictAddStr( &dest, "s6", "def" );
tr_bencDictAddStr( &dest, "s7", "127.0.0.1" ); /* remains untouched */
/* new dictionary, will overwrite items in dest */
tr_bencInitDict( &src, 10 );
tr_bencDictAddInt( &src, "i1", 1 ); /* same value */
tr_bencDictAddInt( &src, "i2", 4 ); /* new value */
tr_bencDictAddInt( &src, "i3", 3 ); /* new key:value */
tr_bencDictAddStr( &src, "s5", "abc" ); /* same value */
tr_bencDictAddStr( &src, "s6", "xyz" ); /* new value */
tr_bencDictAddStr( &src, "s8", "ghi" ); /* new key:value */
tr_bencMergeDicts( &dest, /*const*/ &src );
check( tr_bencDictFindInt( &dest, "i1", &i ));
check_int_eq (1, i);
check( tr_bencDictFindInt( &dest, "i2", &i ));
check_int_eq (4, i);
check( tr_bencDictFindInt( &dest, "i3", &i ));
check_int_eq (3, i);
check( tr_bencDictFindInt( &dest, "i4", &i ));
check_int_eq (-35, i);
check( tr_bencDictFindStr( &dest, "s5", &s ));
check_streq ("abc", s);
check( tr_bencDictFindStr( &dest, "s6", &s ));
check_streq ("xyz", s);
check( tr_bencDictFindStr( &dest, "s7", &s ));
check_streq ("127.0.0.1", s);
check( tr_bencDictFindStr( &dest, "s8", &s ));
check_streq ("ghi", s);
tr_bencFree( &dest );
tr_bencFree( &src );
return 0;
}
void
tr_torrentSaveResume( const tr_torrent * tor )
{
tr_benc top;
char * filename;
if( !tor )
return;
tr_bencInitDict( &top, 14 );
tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE,
tor->activityDate );
tr_bencDictAddInt( &top, KEY_ADDED_DATE,
tor->addedDate );
tr_bencDictAddInt( &top, KEY_CORRUPT,
tor->corruptPrev + tor->corruptCur );
tr_bencDictAddInt( &top, KEY_DONE_DATE,
tor->doneDate );
tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR,
tor->downloadDir );
tr_bencDictAddInt( &top, KEY_DOWNLOADED,
tor->downloadedPrev + tor->downloadedCur );
tr_bencDictAddInt( &top, KEY_UPLOADED,
tor->uploadedPrev + tor->uploadedCur );
tr_bencDictAddInt( &top, KEY_MAX_PEERS,
tor->maxConnectedPeers );
tr_bencDictAddInt( &top, KEY_PAUSED,
tor->isRunning ? 0 : 1 );
savePeers( &top, tor );
savePriorities( &top, tor );
saveDND( &top, tor );
saveProgress( &top, tor );
saveSpeedLimits( &top, tor );
filename = getResumeFilename( tor );
tr_bencSaveFile( filename, &top );
tr_free( filename );
tr_bencFree( &top );
}
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;
}
static void
handle_upload( struct evhttp_request * req,
struct tr_rpc_server * server )
{
if( req->type != EVHTTP_REQ_POST )
{
send_simple_response( req, 405, NULL );
}
else
{
const char * content_type = evhttp_find_header( req->input_headers,
"Content-Type" );
const char * query = strchr( req->uri, '?' );
const int paused = query && strstr( query + 1, "paused=true" );
const char * in = (const char *) EVBUFFER_DATA( req->input_buffer );
size_t inlen = EVBUFFER_LENGTH( req->input_buffer );
const char * boundary_key = "boundary=";
const char * boundary_key_begin = strstr( content_type,
boundary_key );
const char * boundary_val =
boundary_key_begin ? boundary_key_begin +
strlen( boundary_key ) : "arglebargle";
char * boundary = tr_strdup_printf( "--%s", boundary_val );
const size_t boundary_len = strlen( boundary );
const char * delim = tr_memmem( in, inlen, boundary, boundary_len );
while( delim )
{
size_t part_len;
const char * part = delim + boundary_len;
inlen -= ( part - in );
in = part;
delim = tr_memmem( in, inlen, boundary, boundary_len );
part_len = delim ? (size_t)( delim - part ) : inlen;
if( part_len )
{
char * text = tr_strndup( part, part_len );
if( strstr( text, "filename=\"" ) )
{
const char * body = strstr( text, "\r\n\r\n" );
if( body )
{
char * b64;
size_t body_len;
tr_benc top, *args;
struct evbuffer * json = tr_getBuffer( );
body += 4; /* walk past the \r\n\r\n */
body_len = part_len - ( body - text );
if( body_len >= 2
&& !memcmp( &body[body_len - 2], "\r\n", 2 ) )
body_len -= 2;
tr_bencInitDict( &top, 2 );
args = tr_bencDictAddDict( &top, "arguments", 2 );
tr_bencDictAddStr( &top, "method", "torrent-add" );
b64 = tr_base64_encode( body, body_len, NULL );
tr_bencDictAddStr( args, "metainfo", b64 );
tr_bencDictAddInt( args, "paused", paused );
tr_bencSaveAsJSON( &top, json );
tr_rpc_request_exec_json( server->session,
EVBUFFER_DATA( json ),
EVBUFFER_LENGTH( json ),
NULL, NULL );
tr_releaseBuffer( json );
tr_free( b64 );
tr_bencFree( &top );
}
}
tr_free( text );
}
}
tr_free( boundary );
/* use xml here because json responses to file uploads is trouble.
* see http://www.malsup.com/jquery/form/#sample7 for details */
evhttp_add_header( req->output_headers, "Content-Type",
"text/xml; charset=UTF-8" );
send_simple_response( req, HTTP_OK, NULL );
}
}
static void
saveProgress( tr_benc * dict, tr_torrent * tor )
{
tr_benc * l;
tr_benc * prog;
tr_file_index_t fi;
const tr_info * inf = tr_torrentInfo( tor );
const time_t now = tr_time( );
prog = tr_bencDictAddDict( dict, KEY_PROGRESS, 3 );
/* add the file/piece check timestamps... */
l = tr_bencDictAddList( prog, KEY_PROGRESS_CHECKTIME, inf->fileCount );
for( fi=0; fi<inf->fileCount; ++fi )
{
const tr_piece * p;
const tr_piece * pend;
time_t oldest_nonzero = now;
time_t newest = 0;
tr_bool has_zero = FALSE;
const time_t mtime = tr_torrentGetFileMTime( tor, fi );
const tr_file * f = &inf->files[fi];
/* get the oldest and newest nonzero timestamps for pieces in this file */
for( p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]; p!=pend; ++p )
{
if( !p->timeChecked )
has_zero = TRUE;
else if( oldest_nonzero > p->timeChecked )
oldest_nonzero = p->timeChecked;
if( newest < p->timeChecked )
newest = p->timeChecked;
}
/* If some of a file's pieces have been checked more recently than
the file's mtime, and some lest recently, then that file will
have a list containing timestamps for each piece.
However, the most common use case is that the file doesn't change
after it's downloaded. To reduce overhead in the .resume file,
only a single timestamp is saved for the file if *all* or *none*
of the pieces were tested more recently than the file's mtime. */
if( !has_zero && ( mtime <= oldest_nonzero ) ) /* all checked */
tr_bencListAddInt( l, oldest_nonzero );
else if( newest < mtime ) /* none checked */
tr_bencListAddInt( l, newest );
else { /* some are checked, some aren't... so list piece by piece */
const int offset = oldest_nonzero - 1;
tr_benc * ll = tr_bencListAddList( l, 2 + f->lastPiece - f->firstPiece );
tr_bencListAddInt( ll, offset );
for( p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]+1; p!=pend; ++p )
tr_bencListAddInt( ll, p->timeChecked ? p->timeChecked - offset : 0 );
}
}
/* add the progress */
if( tor->completeness == TR_SEED )
tr_bencDictAddStr( prog, KEY_PROGRESS_HAVE, "all" );
/* add the blocks bitfield */
tr_bitsetToBenc( tr_cpBlockBitset( &tor->completion ),
tr_bencDictAdd( prog, KEY_PROGRESS_BLOCKS ) );
}
static bool
removeURL (tr_benc * metainfo, const char * url)
{
const char * str;
tr_benc * announce_list;
bool changed = false;
if (tr_bencDictFindStr (metainfo, "announce", &str) && !strcmp (str, url))
{
printf ("\tRemoved \"%s\" from \"announce\"\n", str);
tr_bencDictRemove (metainfo, "announce");
changed = true;
}
if (tr_bencDictFindList (metainfo, "announce-list", &announce_list))
{
tr_benc * tier;
int tierIndex = 0;
while ((tier = tr_bencListChild (announce_list, tierIndex)))
{
tr_benc * node;
int nodeIndex = 0;
while ((node = tr_bencListChild (tier, nodeIndex)))
{
if (tr_bencGetStr (node, &str) && !strcmp (str, url))
{
printf ("\tRemoved \"%s\" from \"announce-list\" tier #%d\n", str, (tierIndex+1));
tr_bencListRemove (tier, nodeIndex);
changed = true;
}
else ++nodeIndex;
}
if (tr_bencListSize (tier) == 0)
{
printf ("\tNo URLs left in tier #%d... removing tier\n", (tierIndex+1));
tr_bencListRemove (announce_list, tierIndex);
}
else
{
++tierIndex;
}
}
if (tr_bencListSize (announce_list) == 0)
{
printf ("\tNo tiers left... removing announce-list\n");
tr_bencDictRemove (metainfo, "announce-list");
}
}
/* if we removed the "announce" field and there's still another track left,
* use it as the "announce" field */
if (changed && !tr_bencDictFindStr (metainfo, "announce", &str))
{
tr_benc * tier;
tr_benc * node;
if ((tier = tr_bencListChild (announce_list, 0)))
{
if ((node = tr_bencListChild (tier, 0)))
{
if (tr_bencGetStr (node, &str))
{
tr_bencDictAddStr (metainfo, "announce", str);
printf ("\tAdded \"%s\" to announce\n", str);
}
}
}
}
return changed;
}
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;
}
void
gtr_pref_string_set( const char * key, const char * value )
{
tr_bencDictAddStr( getPrefs( ), key, value );
}
