#define KEY_BLOCKLIST "blocklist-enabled"
#define KEY_DOWNLOAD_DIR "download-dir"
#define KEY_ENCRYPTION "encryption"
-#define KEY_PEER_LIMIT "peer-limit"
+#define KEY_PEER_LIMIT "max-peers-global"
#define KEY_PEER_PORT "peer-port"
#define KEY_PORT_FORWARDING "port-forwarding-enabled"
#define KEY_PEX_ENABLED "pex-enabled"
-#define KEY_AUTH_REQUIRED "rpc-auth-required"
+#define KEY_AUTH_REQUIRED "rpc-authentication-required"
#define KEY_USERNAME "rpc-username"
#define KEY_PASSWORD "rpc-password"
-#define KEY_ACL "rpc-acl"
+#define KEY_ACL "rpc-access-control-list"
#define KEY_RPC_PORT "rpc-port"
-#define KEY_DSPEED "speed-limit-down"
-#define KEY_DSPEED_ENABLED "speed-limit-down-enabled"
-#define KEY_USPEED "speed-limit-up"
-#define KEY_USPEED_ENABLED "speed-limit-up-enabled"
+#define KEY_DSPEED "download-limit"
+#define KEY_DSPEED_ENABLED "download-limit-enabled"
+#define KEY_USPEED "upload-limit"
+#define KEY_USPEED_ENABLED "upload-limit-enabled"
-#define CONFIG_FILE "session.json"
+#define CONFIG_FILE "settings.json"
-const char * encryption_str[3] = { "tolerated", "preferred", "required" };
+/***
+**** Config File
+***/
+static void
+replaceInt( tr_benc * dict, const char * key, int64_t value )
+{
+ tr_bencDictRemove( dict, key );
+ tr_bencDictAddInt( dict, key, value );
+}
+static void
+replaceStr( tr_benc * dict, const char * key, const char* value )
+{
+ tr_bencDictRemove( dict, key );
+ tr_bencDictAddStr( dict, key, value );
+}
static void
saveState( tr_session * s )
{
tr_benc d;
- tr_bencInitDict( &d, 16 );
- tr_bencDictAddInt( &d, KEY_BLOCKLIST, tr_blocklistIsEnabled( s ) );
- tr_bencDictAddStr( &d, KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
- tr_bencDictAddInt( &d, KEY_PEER_LIMIT, tr_sessionGetPeerLimit( s ) );
- tr_bencDictAddInt( &d, KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
- tr_bencDictAddInt( &d, KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
- tr_bencDictAddInt( &d, KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
- tr_bencDictAddStr( &d, KEY_USERNAME, tr_sessionGetRPCUsername( s ) );
- tr_bencDictAddStr( &d, KEY_PASSWORD, tr_sessionGetRPCPassword( s ) );
- tr_bencDictAddStr( &d, KEY_ACL, tr_sessionGetRPCACL( s ) );
- tr_bencDictAddInt( &d, KEY_RPC_PORT, tr_sessionGetRPCPort( s ) );
- tr_bencDictAddInt( &d, KEY_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled( s ) );
- tr_bencDictAddInt( &d, KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
- tr_bencDictAddInt( &d, KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
- tr_bencDictAddInt( &d, KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
- tr_bencDictAddInt( &d, KEY_USPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
- tr_bencDictAddStr( &d, KEY_ENCRYPTION, encryption_str[tr_sessionGetEncryption( s )] );
+ if( tr_bencLoadJSONFile( myConfigFilename, &d ) )
+ tr_bencInitDict( &d, 16 );
+
+ replaceInt( &d, KEY_BLOCKLIST, tr_blocklistIsEnabled( s ) );
+ replaceStr( &d, KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
+ replaceInt( &d, KEY_PEER_LIMIT, tr_sessionGetPeerLimit( s ) );
+ replaceInt( &d, KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
+ replaceInt( &d, KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
+ replaceInt( &d, KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
+ replaceStr( &d, KEY_USERNAME, tr_sessionGetRPCUsername( s ) );
+ replaceStr( &d, KEY_PASSWORD, tr_sessionGetRPCPassword( s ) );
+ replaceStr( &d, KEY_ACL, tr_sessionGetRPCACL( s ) );
+ replaceInt( &d, KEY_RPC_PORT, tr_sessionGetRPCPort( s ) );
+ replaceInt( &d, KEY_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled( s ) );
+ replaceInt( &d, KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
+ replaceInt( &d, KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
+ replaceInt( &d, KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
+fprintf( stderr, "session says its speed upload speed limit is %d\n", tr_sessionGetSpeedLimit( s, TR_UP ) );
+ replaceInt( &d, KEY_USPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
+ replaceInt( &d, KEY_ENCRYPTION, tr_sessionGetEncryption( s ) );
+
tr_bencSaveJSONFile( myConfigFilename, &d );
tr_bencFree( &d );
tr_ninf( MY_NAME, "saved \"%s\"", myConfigFilename );
}
+static void
+getConfigInt( tr_benc * dict,
+ const char * key,
+ int * setme,
+ int defaultVal )
+{
+ if( *setme < 0 ) {
+ int64_t i;
+ if( tr_bencDictFindInt( dict, key, &i ) )
+ *setme = i;
+ else
+ *setme = defaultVal;
+ }
+}
+
+static void
+getConfigStr( tr_benc * dict,
+ const char * key,
+ const char ** setme,
+ const char * defaultVal )
+{
+ if( !*setme ) {
+ const char * s;
+ if( tr_bencDictFindStr( dict, key, &s ) )
+ *setme = s;
+ else
+ *setme = defaultVal;
+ }
+}
+
/**
* @param port port number, or -1 if not set in the command line
* @param auth TRUE, FALSE, or -1 if not set on the command line
int blocklistEnabled )
{
char mycwd[MAX_PATH_LENGTH];
- tr_benc state;
- int have_state;
- int64_t i;
- int64_t peer_port = TR_DEFAULT_PORT;
- int64_t peers = TR_DEFAULT_GLOBAL_PEER_LIMIT;
- int64_t pex_enabled = TR_DEFAULT_PEX_ENABLED;
- int64_t fwd_enabled = TR_DEFAULT_PORT_FORWARDING_ENABLED;
- int64_t up_limit = 100;
- int64_t up_limited = FALSE;
- int64_t down_limit = 100;
- int64_t down_limited = FALSE;
- int encryption = TR_ENCRYPTION_PREFERRED;
+ tr_benc state, *dict = NULL;
+ int peerPort=-1, peers=-1;
+ int pexEnabled = -1;
+ int fwdEnabled = -1;
+ int upLimit=-1, upLimited=-1, downLimit=-1, downLimited=-1;
+ int encryption = -1;
tr_ctor * ctor;
tr_torrent ** torrents;
- if(( have_state = !tr_bencLoadJSONFile( myConfigFilename, &state )))
- {
- const char * str;
- tr_ninf( MY_NAME, "loading settings from \"%s\"", myConfigFilename );
-
- tr_bencDictFindInt( &state, KEY_PEER_LIMIT, &peers );
- tr_bencDictFindInt( &state, KEY_PEX_ENABLED, &pex_enabled );
- tr_bencDictFindInt( &state, KEY_PEER_PORT, &peer_port );
- tr_bencDictFindInt( &state, KEY_PORT_FORWARDING, &fwd_enabled );
- tr_bencDictFindInt( &state, KEY_DSPEED, &down_limit );
- tr_bencDictFindInt( &state, KEY_DSPEED_ENABLED, &down_limited );
- tr_bencDictFindInt( &state, KEY_USPEED, &up_limit );
- tr_bencDictFindInt( &state, KEY_USPEED_ENABLED, &up_limited );
- if( tr_bencDictFindStr( &state, KEY_ENCRYPTION, &str ) ) {
- if( !strcmp( str, "required" ) )
- encryption = TR_ENCRYPTION_REQUIRED;
- else if( !strcmp( str, "tolerated" ) )
- encryption = TR_PLAINTEXT_PREFERRED;
- }
- }
+ if( !tr_bencLoadJSONFile( myConfigFilename, &state ) )
+ dict = &state;
/***
**** Decide on which values to pass into tr_sessionInitFull().
**** If neither of those can be found, the TR_DEFAULT fields are used .
***/
- /* authorization */
- if( authRequired < 0 ) {
- if( have_state && tr_bencDictFindInt( &state, KEY_AUTH_REQUIRED, &i ) )
- authRequired = i;
- if( authRequired < 0 )
- authRequired = FALSE;
- }
-
- /* username */
- if( !username )
- tr_bencDictFindStr( &state, KEY_USERNAME, &username );
-
- /* password */
- if( !password )
- tr_bencDictFindStr( &state, KEY_PASSWORD, &password );
-
- /* acl */
- if( !acl ) {
- if( have_state )
- tr_bencDictFindStr( &state, KEY_ACL, &acl );
- if( !acl )
- acl = TR_DEFAULT_RPC_ACL;
- }
-
- /* rpc port */
- if( rpcPort < 0 ) {
- if( have_state && tr_bencDictFindInt( &state, KEY_RPC_PORT, &i ) )
- rpcPort = i;
- if( rpcPort < 0 )
- rpcPort = TR_DEFAULT_RPC_PORT;
- }
-
-
- /* blocklist */
- if( blocklistEnabled < 0 ) {
- if( have_state && tr_bencDictFindInt( &state, KEY_BLOCKLIST, &i ) )
- blocklistEnabled = i;
- if( blocklistEnabled < 0 )
- blocklistEnabled = TR_DEFAULT_BLOCKLIST_ENABLED;
- }
-
- /* download dir */
- if( !downloadDir ) {
- if( have_state )
- tr_bencDictFindStr( &state, KEY_DOWNLOAD_DIR, &downloadDir );
- if( !downloadDir ) {
- getcwd( mycwd, sizeof( mycwd ) );
- downloadDir = mycwd;
- }
- }
+ getcwd( mycwd, sizeof( mycwd ) );
+ getConfigStr( dict, KEY_DOWNLOAD_DIR, &downloadDir, mycwd );
+ getConfigInt( dict, KEY_PEX_ENABLED, &pexEnabled, TR_DEFAULT_PEX_ENABLED );
+ getConfigInt( dict, KEY_PORT_FORWARDING, &fwdEnabled, TR_DEFAULT_PORT_FORWARDING_ENABLED );
+ getConfigInt( dict, KEY_PEER_PORT, &peerPort, TR_DEFAULT_PORT );
+ getConfigInt( dict, KEY_DSPEED, &downLimit, 100 );
+ getConfigInt( dict, KEY_DSPEED_ENABLED, &downLimited, FALSE );
+ getConfigInt( dict, KEY_USPEED, &upLimit, 100 );
+ getConfigInt( dict, KEY_USPEED_ENABLED, &upLimited, FALSE );
+ getConfigInt( dict, KEY_PEER_LIMIT, &peers, TR_DEFAULT_GLOBAL_PEER_LIMIT );
+ getConfigInt( dict, KEY_BLOCKLIST, &blocklistEnabled, TR_DEFAULT_BLOCKLIST_ENABLED );
+ getConfigInt( dict, KEY_RPC_PORT, &rpcPort, TR_DEFAULT_RPC_PORT );
+ getConfigStr( dict, KEY_ACL, &acl, TR_DEFAULT_RPC_ACL );
+ getConfigInt( dict, KEY_AUTH_REQUIRED, &authRequired, FALSE );
+ getConfigStr( dict, KEY_USERNAME, &username, NULL );
+ getConfigStr( dict, KEY_PASSWORD, &password, NULL );
+ getConfigInt( dict, KEY_ENCRYPTION, &encryption, TR_ENCRYPTION_PREFERRED );
/***
****
/* start the session */
mySession = tr_sessionInitFull( configDir, "daemon", downloadDir,
- pex_enabled, fwd_enabled, peer_port,
+ pexEnabled, fwdEnabled, peerPort,
encryption,
- up_limit, up_limited,
- down_limit, down_limited,
+ upLimited, upLimit,
+ downLimited, downLimit,
peers,
TR_MSG_INF, 0,
blocklistEnabled,
tr_free( torrents );
tr_ctorFree( ctor );
- if( have_state )
+ if( dict )
tr_bencFree( &state );
}
{
int i, n;
int active;
- char * match;
+ const char * match;
const int n_entries = G_N_ELEMENTS( entries );
GtkActionGroup * action_group;
gtk_ui_manager_insert_action_group( ui_manager, action_group, 0 );
g_object_unref (G_OBJECT(action_group));
- g_free( match );
}
/****
{
GtkWidget * w;
GtkWidget * c;
- char * folder;
+ const char * folder;
w = gtk_file_chooser_dialog_new( _( "Add a Torrent" ), parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
addTorrentFilters( GTK_FILE_CHOOSER( w ) );
g_signal_connect( w, "response", G_CALLBACK(onAddDialogResponse), core );
- if(( folder = pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ))) {
+ if(( folder = pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER )))
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), folder );
- g_free( folder );
- }
c = gtk_check_button_new_with_mnemonic( _( "Display _options dialog" ) );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( c ), pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) );
if( errstr != NULL )
*errstr = NULL;
- gl_confdir = g_build_filename( dir, "gtk", NULL );
+ gl_confdir = g_strdup( dir );
- if( mkdir_p(gl_confdir, 0755 ) )
+ if( mkdir_p( gl_confdir, 0755 ) )
return TRUE;
if( errstr != NULL )
return didLock;
}
-char*
-cf_sockname( void )
-{
- assert( gl_confdir != NULL );
- return g_build_filename( gl_confdir, "socket", NULL );
-}
-
/***
****
**** Preferences
****
***/
-#define GROUP "general"
-
static char*
getPrefsFilename( void )
{
assert( gl_confdir != NULL );
- return g_build_filename( gl_confdir, "prefs.ini", NULL );
+ return g_build_filename( gl_confdir, "settings.json", NULL );
}
-static GKeyFile*
-getPrefsKeyFile( void )
+static tr_benc*
+getPrefs( void )
{
- static GKeyFile * myKeyFile = NULL;
+ static tr_benc dict;
+ static gboolean loaded = FALSE;
- if( myKeyFile == NULL )
+ if( !loaded )
{
char * filename = getPrefsFilename( );
- myKeyFile = g_key_file_new( );
- g_key_file_load_from_file( myKeyFile, filename, 0, NULL );
+ if( tr_bencLoadJSONFile( filename, &dict ) )
+ tr_bencInitDict( &dict, 100 );
g_free( filename );
+ loaded = TRUE;
}
- return myKeyFile;
+ return &dict;
}
+/***
+****
+***/
+
int
-pref_int_get( const char * key ) {
- return g_key_file_get_integer( getPrefsKeyFile( ), GROUP, key, NULL );
+pref_int_get( const char * key )
+{
+ int64_t i;
+ tr_bencDictFindInt( getPrefs( ), key, &i );
+ return i;
}
void
-pref_int_set( const char * key, int value ) {
- g_key_file_set_integer( getPrefsKeyFile( ), GROUP, key, value );
+pref_int_set( const char * key, int value )
+{
+ tr_benc * d = getPrefs( );
+ tr_bencDictRemove( d, key );
+ tr_bencDictAddInt( d, key, value );
}
void
-pref_int_set_default( const char * key, int value ) {
- if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
+pref_int_set_default( const char * key, int value )
+{
+ if( !tr_bencDictFind( getPrefs( ), key ) )
pref_int_set( key, value );
}
+/***
+****
+***/
+
gboolean
-pref_flag_get ( const char * key ) {
- return g_key_file_get_boolean( getPrefsKeyFile( ), GROUP, key, NULL );
+pref_flag_get ( const char * key )
+{
+ int64_t i;
+ tr_bencDictFindInt( getPrefs( ), key, &i );
+ return i != 0;
}
gboolean
-pref_flag_eval( pref_flag_t val, const char * key ) {
+pref_flag_eval( pref_flag_t val, const char * key )
+{
switch( val ) {
case PREF_FLAG_TRUE: return TRUE;
case PREF_FLAG_FALSE: return FALSE;
}
}
void
-pref_flag_set( const char * key, gboolean value ) {
- g_key_file_set_boolean( getPrefsKeyFile( ), GROUP, key, value );
+pref_flag_set( const char * key, gboolean value )
+{
+ pref_int_set( key, value!=0 );
}
void
-pref_flag_set_default( const char * key, gboolean value ) {
- if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
- pref_flag_set( key, value );
+pref_flag_set_default( const char * key, gboolean value )
+{
+ pref_int_set_default( key, value!=0 );
}
-char*
-pref_string_get( const char * key ) {
- return g_key_file_get_string( getPrefsKeyFile( ), GROUP, key, NULL );
+/***
+****
+***/
+
+const char*
+pref_string_get( const char * key )
+{
+ const char * str = NULL;
+ tr_bencDictFindStr( getPrefs( ), key, &str );
+ return str;
}
+
void
-pref_string_set( const char * key, const char * value ) {
- g_key_file_set_string( getPrefsKeyFile( ), GROUP, key, value );
+pref_string_set( const char * key, const char * value )
+{
+ tr_benc * d = getPrefs( );
+ tr_bencDictRemove( d, key );
+ tr_bencDictAddStr( d, key, value );
}
+
void
-pref_string_set_default( const char * key, const char * value ) {
- if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
+pref_string_set_default( const char * key, const char * value )
+{
+ if( !tr_bencDictFind( getPrefs( ), key ) )
pref_string_set( key, value );
}
+/***
+****
+***/
+
void
-pref_save(char **errstr)
+pref_save( void )
{
- gsize datalen;
- GError * err = NULL;
- char * data;
- char * filename;
- char * path;
-
- filename = getPrefsFilename( );
- path = g_path_get_dirname( filename );
- mkdir_p( path, 0755 );
-
- data = g_key_file_to_data( getPrefsKeyFile(), &datalen, &err );
- if( !err ) {
- GIOChannel * out = g_io_channel_new_file( filename, "w+", &err );
- g_io_channel_write_chars( out, data, datalen, NULL, &err );
- g_io_channel_unref( out );
- }
+ char * filename = getPrefsFilename( );
+ char * path = g_path_get_dirname( filename );
- if( errstr != NULL )
- *errstr = err ? g_strdup( err->message ) : NULL;
+ mkdir_p( path, 0755 );
+ tr_bencSaveJSONFile( filename, getPrefs( ) );
- g_clear_error( &err );
- g_free( data );
g_free( path );
g_free( filename );
}
#endif
static char*
-getCompat08PrefsFilename( void )
+getCompat080PrefsFilename( void )
{
assert( gl_confdir != NULL );
return g_build_filename( g_get_home_dir(), ".transmission", "gtk", "prefs", NULL );
}
static char*
-getCompat09PrefsFilename( void )
+getCompat090PrefsFilename( void )
{
assert( gl_confdir != NULL );
return g_build_filename( g_get_home_dir(), ".transmission", "gtk", "prefs.ini", NULL );
}
+static char*
+getCompat121PrefsFilename( void )
+{
+ assert( gl_confdir != NULL );
+ return g_build_filename( gl_confdir, "prefs.ini", NULL );
+}
+
static void
translate_08_to_09( const char* oldfile, const char* newfile )
{
g_free( contents );
}
+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" },
+ { "listening-port", "peer-port" },
+ { "nat-traversal-enabled", "port-forwarding-enabled" },
+ { "encrypted-connections-only", "encryption" }
+ };
+
+ 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_bencSaveJSONFile( new_file, &dict );
+ tr_bencFree( &dict );
+}
+
void
cf_check_older_configs( void )
{
- char * cfn = getPrefsFilename( );
- char * cfn08 = getCompat08PrefsFilename( );
- char * cfn09 = getCompat09PrefsFilename( );
+ char * filename = getPrefsFilename( );
+
+ if( !g_file_test( filename, G_FILE_TEST_IS_REGULAR ) )
+ {
+ char * key1 = getCompat121PrefsFilename( );
+ char * key2 = getCompat090PrefsFilename( );
+ char * benc = getCompat080PrefsFilename( );
- if( !g_file_test( cfn, G_FILE_TEST_IS_REGULAR )
- && g_file_test( cfn09, G_FILE_TEST_IS_REGULAR ) )
- g_rename( cfn09, cfn );
+ if( g_file_test( key1, G_FILE_TEST_IS_REGULAR ) )
+ {
+ translate_keyfile_to_json( key1, filename );
+ }
+ else if( g_file_test( key2, G_FILE_TEST_IS_REGULAR ) )
+ {
+ translate_keyfile_to_json( key2, filename );
+ }
+ else if( g_file_test( benc, G_FILE_TEST_IS_REGULAR ) )
+ {
+ char * tmpfile;
+ int fd = g_file_open_tmp( "transmission-prefs-XXXXXX", &tmpfile, NULL );
+ if( fd != -1 ) close( fd );
+ translate_08_to_09( benc, tmpfile );
+ translate_keyfile_to_json( tmpfile, filename );
+ unlink( tmpfile );
+ }
- if( !g_file_test( cfn, G_FILE_TEST_IS_REGULAR )
- && g_file_test( cfn08, G_FILE_TEST_IS_REGULAR ) )
- translate_08_to_09( cfn08, cfn );
+ g_free( benc );
+ g_free( key2 );
+ g_free( key1 );
+ }
- g_free( cfn09 );
- g_free( cfn08 );
- g_free( cfn );
+ g_free( filename );
}
#ifndef TG_CONF_H
#define TG_CONF_H
-int pref_int_get ( const char * key );
-void pref_int_set ( const char * key, int value );
-void pref_int_set_default ( const char * key, int value );
+int pref_int_get ( const char * key );
+void pref_int_set ( const char * key, int value );
+void pref_int_set_default ( const char * key, int value );
-gboolean pref_flag_get ( const char * key );
-void pref_flag_set ( const char * key, gboolean value );
-void pref_flag_set_default ( const char * key, gboolean value );
+gboolean pref_flag_get ( const char * key );
+void pref_flag_set ( const char * key, gboolean value );
+void pref_flag_set_default ( const char * key, gboolean value );
-char* pref_string_get ( const char * key );
-void pref_string_set ( const char * key, const char * value );
-void pref_string_set_default ( const char * key, const char * value );
+const char* pref_string_get ( const char * key );
+void pref_string_set ( const char * key, const char * value );
+void pref_string_set_default ( const char * key, const char * value );
-void pref_save ( char **errstr );
+void pref_save ( void );
/**
***
cf_init(const char *confdir, char **errstr);
gboolean
cf_lock(char **errstr);
-char *
-cf_sockname(void);
void
cf_check_older_configs(void);
"gtk",
pref_string_get( PREF_KEY_DOWNLOAD_DIR ),
pref_flag_get( PREF_KEY_PEX ),
- pref_flag_get( PREF_KEY_NAT ),
+ pref_flag_get( PREF_KEY_PORT_FORWARDING ),
pref_int_get( PREF_KEY_PORT ),
- pref_flag_get( PREF_KEY_ENCRYPTED_ONLY )
- ? TR_ENCRYPTION_REQUIRED
- : TR_ENCRYPTION_PREFERRED,
+ pref_int_get( PREF_KEY_ENCRYPTION ),
pref_flag_get( PREF_KEY_UL_LIMIT_ENABLED ),
pref_int_get( PREF_KEY_UL_LIMIT ),
pref_flag_get( PREF_KEY_DL_LIMIT_ENABLED ),
struct cbdata * cbdata = data;
tr_handle * tr = tr_core_handle( cbdata->core );
- if( !strcmp( key, PREF_KEY_ENCRYPTED_ONLY ) )
+ if( !strcmp( key, PREF_KEY_ENCRYPTION ) )
{
- const gboolean crypto_only = pref_flag_get( key );
- tr_sessionSetEncryption( tr, crypto_only ? TR_ENCRYPTION_REQUIRED
- : TR_ENCRYPTION_PREFERRED );
+ const int encryption = pref_int_get( key );
+g_message( "setting encryption to %d", encryption );
+ tr_sessionSetEncryption( tr, encryption );
}
else if( !strcmp( key, PREF_KEY_PORT ) )
{
const int limit = pref_int_get( key );
tr_sessionSetSpeedLimit( tr, TR_UP, limit );
}
- else if( !strcmp( key, PREF_KEY_NAT ) )
+ else if( !strcmp( key, PREF_KEY_PORT_FORWARDING ) )
{
const gboolean enabled = pref_flag_get( key );
tr_sessionSetPortForwardingEnabled( tr, enabled );
else if( !strcmp( key, PREF_KEY_RPC_ACL ) )
{
char * err = NULL;
- char * s = pref_string_get( key );
+ const char * s = pref_string_get( key );
tr_sessionSetRPCACL( tr, s, &err );
- g_free( s );
}
else if( !strcmp( key, PREF_KEY_RPC_USERNAME ) )
{
- char * s = pref_string_get( key );
+ const char * s = pref_string_get( key );
tr_sessionSetRPCUsername( tr, s );
- g_free( s );
}
else if( !strcmp( key, PREF_KEY_RPC_PASSWORD ) )
{
- char * s = pref_string_get( key );
+ const char * s = pref_string_get( key );
tr_sessionSetRPCPassword( tr, s );
- g_free( s );
}
else if( !strcmp( key, PREF_KEY_RPC_AUTH_ENABLED ) )
{
}
else if( !strcmp( key, PREF_KEY_PROXY_SERVER ) )
{
- char * s = pref_string_get( key );
+ const char * s = pref_string_get( key );
tr_sessionSetProxy( tr, s );
- g_free( s );
}
else if( !strcmp( key, PREF_KEY_PROXY_TYPE ) )
{
}
else if( !strcmp( key, PREF_KEY_PROXY_USERNAME ) )
{
- char * s = pref_string_get( key );
+ const char * s = pref_string_get( key );
tr_sessionSetProxyUsername( tr, s );
- g_free( s );
}
else if( !strcmp( key, PREF_KEY_PROXY_PASSWORD ) )
{
- char * s = pref_string_get( key );
+ const char * s = pref_string_get( key );
tr_sessionSetProxyPassword( tr, s );
- g_free( s );
}
}
{
GObjectClass * parent;
- pref_save( NULL );
+ pref_save( );
core->priv = NULL;
parent = g_type_class_peek( g_type_parent( TR_CORE_TYPE ) );
pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
if( tr_ctorGetDownloadDir( ctor, TR_FORCE, NULL ) ) {
- char * path = pref_string_get( PREF_KEY_DOWNLOAD_DIR );
+ const char * path = pref_string_get( PREF_KEY_DOWNLOAD_DIR );
tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
- g_free( path );
}
}
if( !strcmp( key, PREF_KEY_SORT_MODE ) ||
!strcmp( key, PREF_KEY_SORT_REVERSED ) )
{
- char * mode = pref_string_get( PREF_KEY_SORT_MODE );
+ const char * mode = pref_string_get( PREF_KEY_SORT_MODE );
gboolean isReversed = pref_flag_get( PREF_KEY_SORT_REVERSED );
setSort( core, mode, isReversed );
- g_free( mode );
}
else if( !strcmp( key, PREF_KEY_MAX_PEERS_GLOBAL ) )
{
static void
commitPrefsChange( TrCore * core, const char * key )
{
- pref_save( NULL );
+ pref_save( );
g_signal_emit( core, TR_CORE_GET_CLASS(core)->prefsig, 0, key );
}
void
tr_core_set_pref( TrCore * self, const char * key, const char * newval )
{
- char * oldval = pref_string_get( key );
+ const char * oldval = pref_string_get( key );
if( tr_strcmp( oldval, newval ) )
{
pref_string_set( key, newval );
commitPrefsChange( self, key );
}
- g_free( oldval );
}
void
pref_int_set_default ( PREF_KEY_PORT, TR_DEFAULT_PORT );
- pref_flag_set_default ( PREF_KEY_NAT, TRUE );
+ pref_flag_set_default ( PREF_KEY_PORT_FORWARDING, TRUE );
pref_flag_set_default ( PREF_KEY_PEX, TR_DEFAULT_PEX_ENABLED );
pref_flag_set_default ( PREF_KEY_ASKQUIT, TRUE );
- pref_flag_set_default ( PREF_KEY_ENCRYPTED_ONLY, FALSE );
+ pref_flag_set_default ( PREF_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED );
pref_int_set_default ( PREF_KEY_MSGLEVEL, TR_MSG_INF );
pref_string_set_default( PREF_KEY_RPC_PASSWORD, pw );
pref_flag_set_default ( PREF_KEY_RPC_AUTH_ENABLED, FALSE );
- pref_save( NULL );
+ pref_save( );
}
/**
new_entry( const char * key, gpointer core )
{
GtkWidget * w = gtk_entry_new( );
- char * value = pref_string_get( key );
+ const char * value = pref_string_get( key );
if( value )
gtk_entry_set_text( GTK_ENTRY( w ), value );
g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
g_signal_connect( w, "changed", G_CALLBACK(entry_changed_cb), core );
- g_free( value );
return w;
}
{
GtkWidget * w = gtk_file_chooser_button_new( NULL,
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
- char * path = pref_string_get( key );
+ const char * path = pref_string_get( key );
g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
g_signal_connect( w, "selection-changed", G_CALLBACK(chosen_cb), core );
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(w), path );
- g_free( path );
return w;
}
tr_webRun( handle, url, NULL, got_blocklist, data );
}
+static void
+onEncryptionToggled( GtkToggleButton * w, gpointer core )
+{
+ const int val = gtk_toggle_button_get_active( w )
+ ? TR_ENCRYPTION_REQUIRED
+ : TR_ENCRYPTION_PREFERRED;
+ tr_core_set_pref_int( TR_CORE( core ), PREF_KEY_ENCRYPTION, val );
+}
+
static GtkWidget*
peerPage( GObject * core, gboolean * alive )
{
hig_workarea_add_wide_control( t, &row, h );
s = _("_Ignore unencrypted peers");
- w = new_check_button( s, PREF_KEY_ENCRYPTED_ONLY, core );
+ w = gtk_check_button_new_with_mnemonic( s );
+ gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(w),
+ pref_int_get(PREF_KEY_ENCRYPTION)==TR_ENCRYPTION_REQUIRED );
+ g_signal_connect( w, "toggled", G_CALLBACK(onEncryptionToggled), core );
hig_workarea_add_wide_control( t, &row, w );
s = _("Use peer e_xchange");
/* access control list */
{
- char * val = pref_string_get( PREF_KEY_RPC_ACL );
+ const char * val = pref_string_get( PREF_KEY_RPC_ACL );
GtkTreeModel * m = acl_tree_model_new( val );
GtkTreeViewColumn * c;
GtkCellRenderer * r;
w = hig_workarea_add_row( t, &row, s, w, NULL );
gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.1f );
page->widgets = g_slist_append( page->widgets, w );
- g_free( val );
/* permission column */
m = allow_deny_model_new( );
hig_workarea_add_section_title (t, &row, _( "Router" ) );
s = _("Use port _forwarding from my router" );
- w = new_check_button( s, PREF_KEY_NAT, core );
+ w = new_check_button( s, PREF_KEY_PORT_FORWARDING, core );
hig_workarea_add_wide_control( t, &row, w );
hig_workarea_add_section_divider( t, &row );
#define PREF_KEY_UL_LIMIT_ENABLED "upload-limit-enabled"
#define PREF_KEY_UL_LIMIT "upload-limit"
#define PREF_KEY_OPTIONS_PROMPT "show-options-window"
-#define PREF_KEY_DOWNLOAD_DIR "default-download-directory"
+#define PREF_KEY_DOWNLOAD_DIR "download-dir"
#define PREF_KEY_OPEN_DIALOG_FOLDER "open-dialog-folder"
#define PREF_KEY_ALLOW_HIBERNATION "allow-hibernation"
#define PREF_KEY_DIR_WATCH "watch-folder"
#define PREF_KEY_START "start-added-torrents"
#define PREF_KEY_TRASH_ORIGINAL "trash-original-torrent-files"
#define PREF_KEY_PEER_SOCKET_TOS "peer-socket-tos"
-#define PREF_KEY_PORT "listening-port"
-#define PREF_KEY_NAT "nat-traversal-enabled"
+#define PREF_KEY_PORT "peer-port"
+#define PREF_KEY_PORT_FORWARDING "port-forwarding-enabled"
#define PREF_KEY_PEX "pex-enabled"
#define PREF_KEY_ASKQUIT "prompt-before-exit"
-#define PREF_KEY_ENCRYPTED_ONLY "encrypted-connections-only"
+#define PREF_KEY_ENCRYPTION "encryption"
#define PREF_KEY_MSGLEVEL "debug-message-level"
#define PREF_KEY_SORT_MODE "sort-mode"
#define PREF_KEY_SORT_REVERSED "sort-reversed"
{
int i, n;
int status_stats_mode;
- char * pch;
+ const char * pch;
PrivateData * p;
GtkWidget *vbox, *w, *self, *h, *c, *s, *image, *menu;
GtkWindow *win;
gtk_menu_shell_append( GTK_MENU_SHELL(menu), w );
gtk_widget_show( w );
}
- g_free( pch );
/* status */
h = p->status = gtk_hbox_new( FALSE, GUI_PAD );
static void
updateStats( PrivateData * p )
{
- char * pch;
+ const char * pch;
char up[32], down[32], ratio[32], buf[128];
struct tr_session_stats stats;
tr_handle * handle = tr_core_handle( p->core );
tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
g_snprintf( buf, sizeof(buf), _("Ratio: %s"), ratio );
}
- g_free( pch );
gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
}
} val;
} tr_benc;
-const tr_benc BENC_INIT;
-
/* backwards compatability */
typedef tr_benc benc_val_t;
};
static char*
-getFilename( const tr_handle * handle, char * buf, size_t buflen )
+getOldFilename( const tr_handle * handle, char * buf, size_t buflen )
{
tr_buildPath( buf, buflen, tr_sessionGetConfigDir(handle),
"stats.benc",
return buf;
}
+static char*
+getFilename( const tr_handle * handle, char * buf, size_t buflen )
+{
+ tr_buildPath( buf, buflen, tr_sessionGetConfigDir(handle),
+ "stats.json",
+ NULL );
+ return buf;
+}
+
static void
loadCumulativeStats( const tr_handle * handle, tr_session_stats * setme )
{
+ int loaded = FALSE;
char filename[MAX_PATH_LENGTH];
tr_benc top;
getFilename( handle, filename, sizeof(filename) );
- if( !tr_bencLoadFile( filename, &top ) )
+ loaded = !tr_bencLoadJSONFile( filename, &top );
+ if( !loaded ) {
+ getOldFilename( handle, filename, sizeof(filename) );
+ loaded = !tr_bencLoadFile( filename, &top );
+ }
+ if( loaded )
{
int64_t i;
getFilename( handle, filename, sizeof(filename) );
tr_deepLog( __FILE__, __LINE__, NULL, "Saving stats to \"%s\"", filename );
- tr_bencSaveFile( filename, &top );
+ tr_bencSaveJSONFile( filename, &top );
tr_bencFree( &top );
}
const tr_tracker_info * trackers,
int trackerCount )
{
- tr_benc metainfo = BENC_INIT;
+ tr_benc metainfo;
/* save to the .torrent file */
if( !tr_bencLoadFile( tor->info.torrent, &metainfo ) )
projects / transmission / commitdiff