Changeset 6162


Ignore:
Timestamp:
Jun 12, 2008, 4:25:36 PM (13 years ago)
Author:
charles
Message:

unify the daemon and gtk client's config files so that you can easily swap back and forth between clients and keep the same torrents and preferences.

Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/daemon.c

    r6148 r6162  
    3737#define KEY_DOWNLOAD_DIR     "download-dir"
    3838#define KEY_ENCRYPTION       "encryption"
    39 #define KEY_PEER_LIMIT       "peer-limit"
     39#define KEY_PEER_LIMIT       "max-peers-global"
    4040#define KEY_PEER_PORT        "peer-port"
    4141#define KEY_PORT_FORWARDING  "port-forwarding-enabled"
    4242#define KEY_PEX_ENABLED      "pex-enabled"
    43 #define KEY_AUTH_REQUIRED    "rpc-auth-required"
     43#define KEY_AUTH_REQUIRED    "rpc-authentication-required"
    4444#define KEY_USERNAME         "rpc-username"
    4545#define KEY_PASSWORD         "rpc-password"
    46 #define KEY_ACL              "rpc-acl"
     46#define KEY_ACL              "rpc-access-control-list"
    4747#define KEY_RPC_PORT         "rpc-port"
    48 #define KEY_DSPEED           "speed-limit-down"
    49 #define KEY_DSPEED_ENABLED   "speed-limit-down-enabled"
    50 #define KEY_USPEED           "speed-limit-up"
    51 #define KEY_USPEED_ENABLED   "speed-limit-up-enabled"
    52 
    53 #define CONFIG_FILE          "session.json"
    54 
    55 const char * encryption_str[3] = { "tolerated", "preferred", "required" };
    56 
     48#define KEY_DSPEED           "download-limit"
     49#define KEY_DSPEED_ENABLED   "download-limit-enabled"
     50#define KEY_USPEED           "upload-limit"
     51#define KEY_USPEED_ENABLED   "upload-limit-enabled"
     52
     53#define CONFIG_FILE          "settings.json"
     54
     55/***
     56****  Config File
     57***/
     58
     59static void
     60replaceInt( tr_benc * dict, const char * key, int64_t value )
     61{
     62    tr_bencDictRemove( dict, key );
     63    tr_bencDictAddInt( dict, key, value );
     64}
     65static void
     66replaceStr( tr_benc * dict, const char * key, const char* value )
     67{
     68    tr_bencDictRemove( dict, key );
     69    tr_bencDictAddStr( dict, key, value );
     70}
    5771static void
    5872saveState( tr_session * s )
    5973{
    6074    tr_benc d;
    61     tr_bencInitDict( &d, 16 );
    62     tr_bencDictAddInt( &d, KEY_BLOCKLIST,        tr_blocklistIsEnabled( s ) );
    63     tr_bencDictAddStr( &d, KEY_DOWNLOAD_DIR,     tr_sessionGetDownloadDir( s ) );
    64     tr_bencDictAddInt( &d, KEY_PEER_LIMIT,       tr_sessionGetPeerLimit( s ) );
    65     tr_bencDictAddInt( &d, KEY_PEER_PORT,        tr_sessionGetPeerPort( s ) );
    66     tr_bencDictAddInt( &d, KEY_PORT_FORWARDING,  tr_sessionIsPortForwardingEnabled( s ) );
    67     tr_bencDictAddInt( &d, KEY_PEX_ENABLED,      tr_sessionIsPexEnabled( s ) );
    68     tr_bencDictAddStr( &d, KEY_USERNAME,         tr_sessionGetRPCUsername( s ) );
    69     tr_bencDictAddStr( &d, KEY_PASSWORD,         tr_sessionGetRPCPassword( s ) );
    70     tr_bencDictAddStr( &d, KEY_ACL,              tr_sessionGetRPCACL( s ) );
    71     tr_bencDictAddInt( &d, KEY_RPC_PORT,         tr_sessionGetRPCPort( s ) );
    72     tr_bencDictAddInt( &d, KEY_AUTH_REQUIRED,    tr_sessionIsRPCPasswordEnabled( s ) );
    73     tr_bencDictAddInt( &d, KEY_DSPEED,           tr_sessionGetSpeedLimit( s, TR_DOWN ) );
    74     tr_bencDictAddInt( &d, KEY_DSPEED_ENABLED,   tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
    75     tr_bencDictAddInt( &d, KEY_USPEED,           tr_sessionGetSpeedLimit( s, TR_UP ) );
    76     tr_bencDictAddInt( &d, KEY_USPEED_ENABLED,   tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
    77     tr_bencDictAddStr( &d, KEY_ENCRYPTION,       encryption_str[tr_sessionGetEncryption( s )] );
     75    if( tr_bencLoadJSONFile( myConfigFilename, &d ) )
     76        tr_bencInitDict( &d, 16 );
     77   
     78    replaceInt( &d, KEY_BLOCKLIST,       tr_blocklistIsEnabled( s ) );
     79    replaceStr( &d, KEY_DOWNLOAD_DIR,    tr_sessionGetDownloadDir( s ) );
     80    replaceInt( &d, KEY_PEER_LIMIT,      tr_sessionGetPeerLimit( s ) );
     81    replaceInt( &d, KEY_PEER_PORT,       tr_sessionGetPeerPort( s ) );
     82    replaceInt( &d, KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
     83    replaceInt( &d, KEY_PEX_ENABLED,     tr_sessionIsPexEnabled( s ) );
     84    replaceStr( &d, KEY_USERNAME,        tr_sessionGetRPCUsername( s ) );
     85    replaceStr( &d, KEY_PASSWORD,        tr_sessionGetRPCPassword( s ) );
     86    replaceStr( &d, KEY_ACL,             tr_sessionGetRPCACL( s ) );
     87    replaceInt( &d, KEY_RPC_PORT,        tr_sessionGetRPCPort( s ) );
     88    replaceInt( &d, KEY_AUTH_REQUIRED,   tr_sessionIsRPCPasswordEnabled( s ) );
     89    replaceInt( &d, KEY_DSPEED,          tr_sessionGetSpeedLimit( s, TR_DOWN ) );
     90    replaceInt( &d, KEY_DSPEED_ENABLED,  tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
     91    replaceInt( &d, KEY_USPEED,          tr_sessionGetSpeedLimit( s, TR_UP ) );
     92fprintf( stderr, "session says its speed upload speed limit is %d\n", tr_sessionGetSpeedLimit( s, TR_UP ) );
     93    replaceInt( &d, KEY_USPEED_ENABLED,  tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
     94    replaceInt( &d, KEY_ENCRYPTION,      tr_sessionGetEncryption( s ) );
     95
    7896    tr_bencSaveJSONFile( myConfigFilename, &d );
    7997    tr_bencFree( &d );
    8098    tr_ninf( MY_NAME, "saved \"%s\"", myConfigFilename );
     99}
     100
     101static void
     102getConfigInt( tr_benc     * dict,
     103              const char  * key,
     104              int         * setme,
     105              int           defaultVal )
     106{
     107    if( *setme < 0 ) {
     108        int64_t i;
     109        if( tr_bencDictFindInt( dict, key, &i ) )
     110            *setme = i;
     111        else
     112            *setme = defaultVal;
     113    }
     114}
     115
     116static void
     117getConfigStr( tr_benc      * dict,
     118              const char   * key,
     119              const char  ** setme,
     120              const char   * defaultVal )
     121{
     122    if( !*setme ) {
     123        const char * s;
     124        if( tr_bencDictFindStr( dict, key, &s ) )
     125            *setme = s;
     126        else
     127            *setme = defaultVal;
     128    }
    81129}
    82130
     
    93141{
    94142    char mycwd[MAX_PATH_LENGTH];
    95     tr_benc state;
    96     int have_state;
    97     int64_t i;
    98     int64_t peer_port = TR_DEFAULT_PORT;
    99     int64_t peers = TR_DEFAULT_GLOBAL_PEER_LIMIT;
    100     int64_t pex_enabled = TR_DEFAULT_PEX_ENABLED;
    101     int64_t fwd_enabled = TR_DEFAULT_PORT_FORWARDING_ENABLED;
    102     int64_t up_limit = 100;
    103     int64_t up_limited = FALSE;
    104     int64_t down_limit = 100;
    105     int64_t down_limited = FALSE;
    106     int encryption = TR_ENCRYPTION_PREFERRED;
     143    tr_benc state, *dict = NULL;
     144    int peerPort=-1, peers=-1;
     145    int pexEnabled = -1;
     146    int fwdEnabled = -1;
     147    int upLimit=-1, upLimited=-1, downLimit=-1, downLimited=-1;
     148    int encryption = -1;
    107149    tr_ctor * ctor;
    108150    tr_torrent ** torrents;
    109151
    110     if(( have_state = !tr_bencLoadJSONFile( myConfigFilename, &state )))
    111     {
    112         const char * str;
    113         tr_ninf( MY_NAME, "loading settings from \"%s\"", myConfigFilename );
    114 
    115         tr_bencDictFindInt( &state, KEY_PEER_LIMIT, &peers );
    116         tr_bencDictFindInt( &state, KEY_PEX_ENABLED, &pex_enabled );
    117         tr_bencDictFindInt( &state, KEY_PEER_PORT, &peer_port );
    118         tr_bencDictFindInt( &state, KEY_PORT_FORWARDING, &fwd_enabled );
    119         tr_bencDictFindInt( &state, KEY_DSPEED, &down_limit );
    120         tr_bencDictFindInt( &state, KEY_DSPEED_ENABLED, &down_limited );
    121         tr_bencDictFindInt( &state, KEY_USPEED, &up_limit );
    122         tr_bencDictFindInt( &state, KEY_USPEED_ENABLED, &up_limited );
    123         if( tr_bencDictFindStr( &state, KEY_ENCRYPTION, &str ) ) {
    124             if( !strcmp( str, "required" ) )
    125                 encryption = TR_ENCRYPTION_REQUIRED;
    126             else if( !strcmp( str, "tolerated" ) )
    127                 encryption = TR_PLAINTEXT_PREFERRED;
    128         }
    129     }
     152    if( !tr_bencLoadJSONFile( myConfigFilename, &state ) )
     153        dict = &state;
    130154
    131155    /***
     
    136160    ***/
    137161
    138     /* authorization */
    139     if( authRequired < 0 ) {
    140         if( have_state && tr_bencDictFindInt( &state, KEY_AUTH_REQUIRED, &i ) )
    141             authRequired = i;
    142         if( authRequired < 0 )
    143             authRequired = FALSE;
    144     }
    145 
    146     /* username */
    147     if( !username )
    148         tr_bencDictFindStr( &state, KEY_USERNAME, &username );
    149 
    150     /* password */
    151     if( !password )
    152         tr_bencDictFindStr( &state, KEY_PASSWORD, &password );
    153 
    154     /* acl */
    155     if( !acl ) {
    156         if( have_state )
    157             tr_bencDictFindStr( &state, KEY_ACL, &acl );
    158         if( !acl )
    159             acl = TR_DEFAULT_RPC_ACL;
    160     }
    161 
    162     /* rpc port */
    163     if( rpcPort < 0 ) {
    164         if( have_state && tr_bencDictFindInt( &state, KEY_RPC_PORT, &i ) )
    165             rpcPort = i;
    166         if( rpcPort < 0 )
    167             rpcPort = TR_DEFAULT_RPC_PORT;
    168     }
    169 
    170 
    171     /* blocklist */
    172     if( blocklistEnabled < 0 ) {
    173         if( have_state && tr_bencDictFindInt( &state, KEY_BLOCKLIST, &i ) )
    174             blocklistEnabled = i;
    175         if( blocklistEnabled < 0 )
    176             blocklistEnabled = TR_DEFAULT_BLOCKLIST_ENABLED;
    177     }
    178 
    179     /* download dir */
    180     if( !downloadDir ) {
    181         if( have_state )
    182             tr_bencDictFindStr( &state, KEY_DOWNLOAD_DIR, &downloadDir );
    183         if( !downloadDir ) {
    184             getcwd( mycwd, sizeof( mycwd ) );
    185             downloadDir = mycwd;
    186         }
    187     }
     162    getcwd( mycwd, sizeof( mycwd ) );
     163    getConfigStr( dict, KEY_DOWNLOAD_DIR,    &downloadDir,       mycwd );
     164    getConfigInt( dict, KEY_PEX_ENABLED,     &pexEnabled,        TR_DEFAULT_PEX_ENABLED );
     165    getConfigInt( dict, KEY_PORT_FORWARDING, &fwdEnabled,        TR_DEFAULT_PORT_FORWARDING_ENABLED );
     166    getConfigInt( dict, KEY_PEER_PORT,       &peerPort,          TR_DEFAULT_PORT );
     167    getConfigInt( dict, KEY_DSPEED,          &downLimit,         100 );
     168    getConfigInt( dict, KEY_DSPEED_ENABLED,  &downLimited,       FALSE );
     169    getConfigInt( dict, KEY_USPEED,          &upLimit,           100 );
     170    getConfigInt( dict, KEY_USPEED_ENABLED,  &upLimited,         FALSE );
     171    getConfigInt( dict, KEY_PEER_LIMIT,      &peers,             TR_DEFAULT_GLOBAL_PEER_LIMIT );
     172    getConfigInt( dict, KEY_BLOCKLIST,       &blocklistEnabled,  TR_DEFAULT_BLOCKLIST_ENABLED );
     173    getConfigInt( dict, KEY_RPC_PORT,        &rpcPort,           TR_DEFAULT_RPC_PORT );
     174    getConfigStr( dict, KEY_ACL,             &acl,               TR_DEFAULT_RPC_ACL );
     175    getConfigInt( dict, KEY_AUTH_REQUIRED,   &authRequired,      FALSE );
     176    getConfigStr( dict, KEY_USERNAME,        &username,          NULL );
     177    getConfigStr( dict, KEY_PASSWORD,        &password,          NULL );
     178    getConfigInt( dict, KEY_ENCRYPTION,      &encryption,        TR_ENCRYPTION_PREFERRED );
    188179
    189180    /***
     
    193184    /* start the session */
    194185    mySession = tr_sessionInitFull( configDir, "daemon", downloadDir,
    195                                     pex_enabled, fwd_enabled, peer_port,
     186                                    pexEnabled, fwdEnabled, peerPort,
    196187                                    encryption,
    197                                     up_limit, up_limited,
    198                                     down_limit, down_limited,
     188                                    upLimited, upLimit,
     189                                    downLimited, downLimit,
    199190                                    peers,
    200191                                    TR_MSG_INF, 0,
     
    219210    tr_ctorFree( ctor );
    220211
    221     if( have_state )
     212    if( dict )
    222213        tr_bencFree( &state );
    223214}
  • trunk/gtk/actions.c

    r6118 r6162  
    208208  int i, n;
    209209  int active;
    210   char * match;
     210  const char * match;
    211211  const int n_entries = G_N_ELEMENTS( entries );
    212212  GtkActionGroup * action_group;
     
    255255  gtk_ui_manager_insert_action_group( ui_manager, action_group, 0 );
    256256  g_object_unref (G_OBJECT(action_group));
    257   g_free( match );
    258257}
    259258
  • trunk/gtk/add-dialog.c

    r5868 r6162  
    291291    GtkWidget * w;
    292292    GtkWidget * c;
    293     char * folder;
     293    const char * folder;
    294294
    295295    w = gtk_file_chooser_dialog_new( _( "Add a Torrent" ), parent,
     
    306306    g_signal_connect( w, "response", G_CALLBACK(onAddDialogResponse), core );
    307307
    308     if(( folder = pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ))) {
     308    if(( folder = pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER )))
    309309        gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), folder );
    310         g_free( folder );
    311     }
    312310
    313311    c = gtk_check_button_new_with_mnemonic( _( "Display _options dialog" ) );
  • trunk/gtk/conf.c

    r5753 r6162  
    5252        *errstr = NULL;
    5353
    54     gl_confdir = g_build_filename( dir, "gtk", NULL );
    55 
    56     if( mkdir_p(gl_confdir, 0755 ) )
     54    gl_confdir = g_strdup( dir );
     55
     56    if( mkdir_p( gl_confdir, 0755 ) )
    5757        return TRUE;
    5858
     
    123123}
    124124
    125 char*
    126 cf_sockname( void )
    127 {
    128     assert( gl_confdir != NULL );
    129     return g_build_filename( gl_confdir, "socket", NULL );
    130 }
    131 
    132125/***
    133126****
     
    135128****
    136129***/
    137 
    138 #define GROUP "general"
    139130
    140131static char*
     
    142133{
    143134    assert( gl_confdir != NULL );
    144     return g_build_filename( gl_confdir, "prefs.ini", NULL );
    145 }
    146 
    147 static GKeyFile*
    148 getPrefsKeyFile( void )
    149 {
    150     static GKeyFile * myKeyFile = NULL;
    151 
    152     if( myKeyFile == NULL )
     135    return g_build_filename( gl_confdir, "settings.json", NULL );
     136}
     137
     138static tr_benc*
     139getPrefs( void )
     140{
     141    static tr_benc dict;
     142    static gboolean loaded = FALSE;
     143
     144    if( !loaded )
    153145    {
    154146        char * filename = getPrefsFilename( );
    155         myKeyFile = g_key_file_new( );
    156         g_key_file_load_from_file( myKeyFile, filename, 0, NULL );
     147        if( tr_bencLoadJSONFile( filename, &dict ) )
     148            tr_bencInitDict( &dict, 100 );
    157149        g_free( filename );
    158     }
    159 
    160     return myKeyFile;
    161 }
     150        loaded = TRUE;
     151    }
     152
     153    return &dict;
     154}
     155
     156/***
     157****
     158***/
    162159
    163160int
    164 pref_int_get( const char * key ) {
    165     return g_key_file_get_integer( getPrefsKeyFile( ), GROUP, key, NULL );
    166 }
    167 void
    168 pref_int_set( const char * key, int value ) {
    169     g_key_file_set_integer( getPrefsKeyFile( ), GROUP, key, value );
    170 }
    171 void
    172 pref_int_set_default( const char * key, int value ) {
    173     if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
     161pref_int_get( const char * key )
     162{
     163    int64_t i;
     164    tr_bencDictFindInt( getPrefs( ), key, &i );
     165    return i;
     166}
     167void
     168pref_int_set( const char * key, int value )
     169{
     170    tr_benc * d = getPrefs( );
     171    tr_bencDictRemove( d, key );
     172    tr_bencDictAddInt( d, key, value );
     173}
     174void
     175pref_int_set_default( const char * key, int value )
     176{
     177    if( !tr_bencDictFind( getPrefs( ), key ) )
    174178        pref_int_set( key, value );
    175179}
    176180
     181/***
     182****
     183***/
     184
    177185gboolean
    178 pref_flag_get ( const char * key ) {
    179     return g_key_file_get_boolean( getPrefsKeyFile( ), GROUP, key, NULL );
     186pref_flag_get ( const char * key )
     187{
     188    int64_t i;
     189    tr_bencDictFindInt( getPrefs( ), key, &i );
     190    return i != 0;
    180191}
    181192gboolean
    182 pref_flag_eval( pref_flag_t val, const char * key ) {
     193pref_flag_eval( pref_flag_t val, const char * key )
     194{
    183195    switch( val ) {
    184196        case PREF_FLAG_TRUE: return TRUE;
     
    188200}
    189201void
    190 pref_flag_set( const char * key, gboolean value ) {
    191     g_key_file_set_boolean( getPrefsKeyFile( ), GROUP, key, value );
    192 }
    193 void
    194 pref_flag_set_default( const char * key, gboolean value ) {
    195     if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
    196         pref_flag_set( key, value );
    197 }
    198 
    199 char*
    200 pref_string_get( const char * key ) {
    201     return g_key_file_get_string( getPrefsKeyFile( ), GROUP, key, NULL );
    202 }
    203 void
    204 pref_string_set( const char * key, const char * value ) {
    205     g_key_file_set_string( getPrefsKeyFile( ), GROUP, key, value );
    206 }
    207 void
    208 pref_string_set_default( const char * key, const char * value ) {
    209     if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
     202pref_flag_set( const char * key, gboolean value )
     203{
     204    pref_int_set( key, value!=0 );
     205}
     206void
     207pref_flag_set_default( const char * key, gboolean value )
     208{
     209    pref_int_set_default( key, value!=0 );
     210}
     211
     212/***
     213****
     214***/
     215
     216const char*
     217pref_string_get( const char * key )
     218{
     219    const char * str = NULL;
     220    tr_bencDictFindStr( getPrefs( ), key, &str );
     221    return str;
     222}
     223
     224void
     225pref_string_set( const char * key, const char * value )
     226{
     227    tr_benc * d = getPrefs( );
     228    tr_bencDictRemove( d, key );
     229    tr_bencDictAddStr( d, key, value );
     230}
     231
     232void
     233pref_string_set_default( const char * key, const char * value )
     234{
     235    if( !tr_bencDictFind( getPrefs( ), key ) )
    210236        pref_string_set( key, value );
    211237}
    212238
    213 void
    214 pref_save(char **errstr)
    215 {
    216     gsize datalen;
    217     GError * err = NULL;
    218     char * data;
    219     char * filename;
    220     char * path;
    221 
    222     filename = getPrefsFilename( );
    223     path = g_path_get_dirname( filename );
     239/***
     240****
     241***/
     242
     243void
     244pref_save( void )
     245{
     246    char * filename = getPrefsFilename( );
     247    char * path = g_path_get_dirname( filename );
     248
    224249    mkdir_p( path, 0755 );
    225 
    226     data = g_key_file_to_data( getPrefsKeyFile(), &datalen, &err );
    227     if( !err ) {
    228         GIOChannel * out = g_io_channel_new_file( filename, "w+", &err );
    229         g_io_channel_write_chars( out, data, datalen, NULL, &err );
    230         g_io_channel_unref( out );
    231     }
    232 
    233     if( errstr != NULL )
    234         *errstr = err ? g_strdup( err->message ) : NULL;
    235 
    236     g_clear_error( &err );
    237     g_free( data );
     250    tr_bencSaveJSONFile( filename, getPrefs( ) );
     251
    238252    g_free( path );
    239253    g_free( filename );
     
    258272
    259273static char*
    260 getCompat08PrefsFilename( void )
     274getCompat080PrefsFilename( void )
    261275{
    262276    assert( gl_confdir != NULL );
     
    265279
    266280static char*
    267 getCompat09PrefsFilename( void )
     281getCompat090PrefsFilename( void )
    268282{
    269283    assert( gl_confdir != NULL );
    270284    return g_build_filename( g_get_home_dir(), ".transmission", "gtk", "prefs.ini", NULL );
     285}
     286
     287static char*
     288getCompat121PrefsFilename( void )
     289{
     290    assert( gl_confdir != NULL );
     291    return g_build_filename( gl_confdir, "prefs.ini", NULL );
    271292}
    272293
     
    322343}
    323344
     345static void
     346translate_keyfile_to_json( const char * old_file, const char * new_file )
     347{
     348    tr_benc dict;
     349    GKeyFile * keyfile;
     350    gchar ** keys;
     351    gsize i;
     352    gsize length;
     353
     354    static struct pref_entry {
     355        const char* oldkey;
     356        const char* newkey;
     357    } renamed[] = {
     358        { "default-download-directory", "download-dir" },
     359        { "listening-port", "peer-port" },
     360        { "nat-traversal-enabled", "port-forwarding-enabled" },
     361        { "encrypted-connections-only", "encryption" }
     362    };
     363
     364    keyfile = g_key_file_new( );
     365    g_key_file_load_from_file( keyfile, old_file, 0, NULL );
     366    length = 0;
     367    keys = g_key_file_get_keys( keyfile, "general", &length, NULL );
     368
     369    tr_bencInitDict( &dict, length );
     370    for( i=0; i<length; ++i )
     371    {
     372        guint j;
     373        const char * key = keys[i];
     374        gchar * val = g_key_file_get_value( keyfile, "general", key, NULL );
     375
     376        for( j=0; j<G_N_ELEMENTS(renamed); ++j )
     377            if( !strcmp( renamed[j].oldkey, key ) )
     378                key = renamed[j].newkey;
     379
     380        if( !strcmp(val,"true") || !strcmp(val,"false") )
     381            tr_bencDictAddInt( &dict, key, !strcmp(val,"true") );
     382        else {
     383            char * end;
     384            long l;
     385            errno = 0;
     386            l = strtol( val, &end, 10 );
     387            if( !errno && end && !*end )
     388                tr_bencDictAddInt( &dict, key, l );
     389            else
     390                tr_bencDictAddStr( &dict, key, val );
     391        }
     392
     393        g_free( val );
     394    }
     395
     396    g_key_file_free( keyfile );
     397    tr_bencSaveJSONFile( new_file, &dict );
     398    tr_bencFree( &dict );
     399}
     400
    324401void
    325402cf_check_older_configs( void )
    326403{
    327     char * cfn = getPrefsFilename( );
    328     char * cfn08 = getCompat08PrefsFilename( );
    329     char * cfn09 = getCompat09PrefsFilename( );
    330 
    331     if( !g_file_test( cfn,   G_FILE_TEST_IS_REGULAR )
    332       && g_file_test( cfn09, G_FILE_TEST_IS_REGULAR ) )
    333       g_rename( cfn09, cfn );
    334 
    335     if( !g_file_test( cfn,   G_FILE_TEST_IS_REGULAR )
    336       && g_file_test( cfn08, G_FILE_TEST_IS_REGULAR ) )
    337         translate_08_to_09( cfn08, cfn );
    338 
    339     g_free( cfn09 );
    340     g_free( cfn08 );
    341     g_free( cfn );
    342 }
     404    char * filename = getPrefsFilename( );
     405
     406    if( !g_file_test( filename, G_FILE_TEST_IS_REGULAR ) )
     407    {
     408        char * key1 = getCompat121PrefsFilename( );
     409        char * key2 = getCompat090PrefsFilename( );
     410        char * benc = getCompat080PrefsFilename( );
     411
     412        if( g_file_test( key1, G_FILE_TEST_IS_REGULAR ) )
     413        {
     414            translate_keyfile_to_json( key1, filename );
     415        }
     416        else if( g_file_test( key2, G_FILE_TEST_IS_REGULAR ) )
     417        {
     418            translate_keyfile_to_json( key2, filename );
     419        }
     420        else if( g_file_test( benc, G_FILE_TEST_IS_REGULAR ) )
     421        {
     422            char * tmpfile;
     423            int fd = g_file_open_tmp( "transmission-prefs-XXXXXX", &tmpfile, NULL );
     424            if( fd != -1 ) close( fd );
     425            translate_08_to_09( benc, tmpfile );
     426            translate_keyfile_to_json( tmpfile, filename );
     427            unlink( tmpfile );
     428        }
     429
     430        g_free( benc );
     431        g_free( key2 );
     432        g_free( key1 );
     433    }
     434
     435    g_free( filename );
     436}
  • trunk/gtk/conf.h

    r5302 r6162  
    3030#define TG_CONF_H
    3131
    32 int       pref_int_get            ( const char * key );
    33 void      pref_int_set            ( const char * key, int value );
    34 void      pref_int_set_default    ( const char * key, int value );
     32int          pref_int_get            ( const char * key );
     33void         pref_int_set            ( const char * key, int value );
     34void         pref_int_set_default    ( const char * key, int value );
    3535
    36 gboolean  pref_flag_get           ( const char * key );
    37 void      pref_flag_set           ( const char * key, gboolean value );
    38 void      pref_flag_set_default   ( const char * key, gboolean value );
     36gboolean     pref_flag_get           ( const char * key );
     37void         pref_flag_set           ( const char * key, gboolean value );
     38void         pref_flag_set_default   ( const char * key, gboolean value );
    3939
    40 char*     pref_string_get         ( const char * key );
    41 void      pref_string_set         ( const char * key, const char * value );
    42 void      pref_string_set_default ( const char * key, const char * value );
     40const char*  pref_string_get         ( const char * key );
     41void         pref_string_set         ( const char * key, const char * value );
     42void         pref_string_set_default ( const char * key, const char * value );
    4343
    44 void      pref_save               ( char **errstr );
     44void         pref_save               ( void );
    4545
    4646/**
     
    6868gboolean
    6969cf_lock(char **errstr);
    70 char *
    71 cf_sockname(void);
    7270void
    7371cf_check_older_configs(void);
  • trunk/gtk/main.c

    r6153 r6162  
    413413                            pref_string_get( PREF_KEY_DOWNLOAD_DIR ),
    414414                            pref_flag_get( PREF_KEY_PEX ),
    415                             pref_flag_get( PREF_KEY_NAT ),
     415                            pref_flag_get( PREF_KEY_PORT_FORWARDING ),
    416416                            pref_int_get( PREF_KEY_PORT ),
    417                             pref_flag_get( PREF_KEY_ENCRYPTED_ONLY )
    418                                 ? TR_ENCRYPTION_REQUIRED
    419                                 : TR_ENCRYPTION_PREFERRED,
     417                            pref_int_get( PREF_KEY_ENCRYPTION ),
    420418                            pref_flag_get( PREF_KEY_UL_LIMIT_ENABLED ),
    421419                            pref_int_get( PREF_KEY_UL_LIMIT ),
     
    888886    tr_handle     * tr     = tr_core_handle( cbdata->core );
    889887
    890     if( !strcmp( key, PREF_KEY_ENCRYPTED_ONLY ) )
    891     {
    892         const gboolean crypto_only = pref_flag_get( key );
    893         tr_sessionSetEncryption( tr, crypto_only ? TR_ENCRYPTION_REQUIRED
    894                                                  : TR_ENCRYPTION_PREFERRED );
     888    if( !strcmp( key, PREF_KEY_ENCRYPTION ) )
     889    {
     890        const int encryption = pref_int_get( key );
     891g_message( "setting encryption to %d", encryption );
     892        tr_sessionSetEncryption( tr, encryption );
    895893    }
    896894    else if( !strcmp( key, PREF_KEY_PORT ) )
     
    929927        tr_sessionSetSpeedLimit( tr, TR_UP, limit );
    930928    }
    931     else if( !strcmp( key, PREF_KEY_NAT ) )
     929    else if( !strcmp( key, PREF_KEY_PORT_FORWARDING ) )
    932930    {
    933931        const gboolean enabled = pref_flag_get( key );
     
    954952    {
    955953        char * err = NULL;
    956         char * s = pref_string_get( key );
     954        const char * s = pref_string_get( key );
    957955        tr_sessionSetRPCACL( tr, s, &err );
    958         g_free( s );
    959956    }
    960957    else if( !strcmp( key, PREF_KEY_RPC_USERNAME ) )
    961958    {
    962         char * s = pref_string_get( key );
     959        const char * s = pref_string_get( key );
    963960        tr_sessionSetRPCUsername( tr, s );
    964         g_free( s );
    965961    }
    966962    else if( !strcmp( key, PREF_KEY_RPC_PASSWORD ) )
    967963    {
    968         char * s = pref_string_get( key );
     964        const char * s = pref_string_get( key );
    969965        tr_sessionSetRPCPassword( tr, s );
    970         g_free( s );
    971966    }
    972967    else if( !strcmp( key, PREF_KEY_RPC_AUTH_ENABLED ) )
     
    977972    else if( !strcmp( key, PREF_KEY_PROXY_SERVER ) )
    978973    {
    979         char * s = pref_string_get( key );
     974        const char * s = pref_string_get( key );
    980975        tr_sessionSetProxy( tr, s );
    981         g_free( s );
    982976    }
    983977    else if( !strcmp( key, PREF_KEY_PROXY_TYPE ) )
     
    998992    else if( !strcmp( key, PREF_KEY_PROXY_USERNAME ) )
    999993    {
    1000         char * s = pref_string_get( key );
     994        const char * s = pref_string_get( key );
    1001995        tr_sessionSetProxyUsername( tr, s );
    1002         g_free( s );
    1003996    }
    1004997    else if( !strcmp( key, PREF_KEY_PROXY_PASSWORD ) )
    1005998    {
    1006         char * s = pref_string_get( key );
     999        const char * s = pref_string_get( key );
    10071000        tr_sessionSetProxyPassword( tr, s );
    1008         g_free( s );
    10091001    }
    10101002}
  • trunk/gtk/tr-core.c

    r6097 r6162  
    126126        GObjectClass * parent;
    127127
    128         pref_save( NULL );
     128        pref_save( );
    129129        core->priv = NULL;
    130130
     
    387387
    388388    if( tr_ctorGetDownloadDir( ctor, TR_FORCE, NULL ) ) {
    389         char * path = pref_string_get( PREF_KEY_DOWNLOAD_DIR );
     389        const char * path = pref_string_get( PREF_KEY_DOWNLOAD_DIR );
    390390        tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
    391         g_free( path );
    392391    }
    393392}
     
    494493        !strcmp( key, PREF_KEY_SORT_REVERSED ) )
    495494    {
    496         char * mode = pref_string_get( PREF_KEY_SORT_MODE );
     495        const char * mode = pref_string_get( PREF_KEY_SORT_MODE );
    497496        gboolean isReversed = pref_flag_get( PREF_KEY_SORT_REVERSED );
    498497        setSort( core, mode, isReversed );
    499         g_free( mode );
    500498    }
    501499    else if( !strcmp( key, PREF_KEY_MAX_PEERS_GLOBAL ) )
     
    10281026commitPrefsChange( TrCore * core, const char * key )
    10291027{
    1030     pref_save( NULL );
     1028    pref_save( );
    10311029    g_signal_emit( core, TR_CORE_GET_CLASS(core)->prefsig, 0, key );
    10321030}
     
    10351033tr_core_set_pref( TrCore * self, const char * key, const char * newval )
    10361034{
    1037     char * oldval = pref_string_get( key );
     1035    const char * oldval = pref_string_get( key );
    10381036    if( tr_strcmp( oldval, newval ) )
    10391037    {
     
    10411039        commitPrefsChange( self, key );
    10421040    }
    1043     g_free( oldval );
    10441041}
    10451042
  • trunk/gtk/tr-prefs.c

    r6153 r6162  
    9494    pref_int_set_default    ( PREF_KEY_PORT, TR_DEFAULT_PORT );
    9595
    96     pref_flag_set_default   ( PREF_KEY_NAT, TRUE );
     96    pref_flag_set_default   ( PREF_KEY_PORT_FORWARDING, TRUE );
    9797    pref_flag_set_default   ( PREF_KEY_PEX, TR_DEFAULT_PEX_ENABLED );
    9898    pref_flag_set_default   ( PREF_KEY_ASKQUIT, TRUE );
    99     pref_flag_set_default   ( PREF_KEY_ENCRYPTED_ONLY, FALSE );
     99    pref_flag_set_default   ( PREF_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED );
    100100
    101101    pref_int_set_default    ( PREF_KEY_MSGLEVEL, TR_MSG_INF );
     
    119119    pref_flag_set_default  ( PREF_KEY_RPC_AUTH_ENABLED, FALSE );
    120120
    121     pref_save( NULL );
     121    pref_save( );
    122122}
    123123
     
    192192{
    193193    GtkWidget * w = gtk_entry_new( );
    194     char * value = pref_string_get( key );
     194    const char * value = pref_string_get( key );
    195195    if( value )
    196196        gtk_entry_set_text( GTK_ENTRY( w ), value );
    197197    g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
    198198    g_signal_connect( w, "changed", G_CALLBACK(entry_changed_cb), core );
    199     g_free( value );
    200199    return w;
    201200}
     
    215214    GtkWidget * w = gtk_file_chooser_button_new( NULL,
    216215                                    GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
    217     char * path = pref_string_get( key );
     216    const char * path = pref_string_get( key );
    218217    g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
    219218    g_signal_connect( w, "selection-changed", G_CALLBACK(chosen_cb), core );
    220219    gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(w), path );
    221     g_free( path );
    222220    return w;
    223221}
     
    497495}
    498496
     497static void
     498onEncryptionToggled( GtkToggleButton * w, gpointer core )
     499{
     500    const int val = gtk_toggle_button_get_active( w )
     501                  ? TR_ENCRYPTION_REQUIRED
     502                  : TR_ENCRYPTION_PREFERRED;
     503    tr_core_set_pref_int( TR_CORE( core ), PREF_KEY_ENCRYPTION, val );
     504}
     505
    499506static GtkWidget*
    500507peerPage( GObject * core, gboolean * alive )
     
    531538       
    532539        s = _("_Ignore unencrypted peers");
    533         w = new_check_button( s, PREF_KEY_ENCRYPTED_ONLY, core );
     540        w = gtk_check_button_new_with_mnemonic( s );
     541        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(w),
     542                                      pref_int_get(PREF_KEY_ENCRYPTION)==TR_ENCRYPTION_REQUIRED );
     543        g_signal_connect( w, "toggled", G_CALLBACK(onEncryptionToggled), core );
    534544        hig_workarea_add_wide_control( t, &row, w );
    535545
     
    811821        /* access control list */
    812822        {
    813         char * val = pref_string_get( PREF_KEY_RPC_ACL );
     823        const char * val = pref_string_get( PREF_KEY_RPC_ACL );
    814824        GtkTreeModel * m = acl_tree_model_new( val );
    815825        GtkTreeViewColumn * c;
     
    853863        gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.1f );
    854864        page->widgets = g_slist_append( page->widgets, w );
    855         g_free( val );
    856865
    857866        /* permission column */
     
    972981
    973982        s = _("Use port _forwarding from my router" );
    974         w = new_check_button( s, PREF_KEY_NAT, core );
     983        w = new_check_button( s, PREF_KEY_PORT_FORWARDING, core );
    975984        hig_workarea_add_wide_control( t, &row, w );
    976985
  • trunk/gtk/tr-prefs.h

    r6148 r6162  
    2626#define PREF_KEY_UL_LIMIT               "upload-limit"
    2727#define PREF_KEY_OPTIONS_PROMPT         "show-options-window"
    28 #define PREF_KEY_DOWNLOAD_DIR           "default-download-directory"
     28#define PREF_KEY_DOWNLOAD_DIR           "download-dir"
    2929#define PREF_KEY_OPEN_DIALOG_FOLDER     "open-dialog-folder"
    3030#define PREF_KEY_ALLOW_HIBERNATION      "allow-hibernation"
     
    3535#define PREF_KEY_TRASH_ORIGINAL         "trash-original-torrent-files"
    3636#define PREF_KEY_PEER_SOCKET_TOS        "peer-socket-tos"
    37 #define PREF_KEY_PORT                   "listening-port"
    38 #define PREF_KEY_NAT                    "nat-traversal-enabled"
     37#define PREF_KEY_PORT                   "peer-port"
     38#define PREF_KEY_PORT_FORWARDING        "port-forwarding-enabled"
    3939#define PREF_KEY_PEX                    "pex-enabled"
    4040#define PREF_KEY_ASKQUIT                "prompt-before-exit"
    41 #define PREF_KEY_ENCRYPTED_ONLY         "encrypted-connections-only"
     41#define PREF_KEY_ENCRYPTION             "encryption"
    4242#define PREF_KEY_MSGLEVEL               "debug-message-level"
    4343#define PREF_KEY_SORT_MODE              "sort-mode"
  • trunk/gtk/tr-window.c

    r5975 r6162  
    414414    int i, n;
    415415    int status_stats_mode;
    416     char * pch;
     416    const char * pch;
    417417    PrivateData * p;
    418418    GtkWidget *vbox, *w, *self, *h, *c, *s, *image, *menu;
     
    511511        gtk_widget_show( w );
    512512    }
    513     g_free( pch );
    514513
    515514    /* status */
     
    607606updateStats( PrivateData * p )
    608607{
    609     char * pch;
     608    const char * pch;
    610609    char up[32], down[32], ratio[32], buf[128];
    611610    struct tr_session_stats stats;
     
    639638        g_snprintf( buf, sizeof(buf), _("Ratio: %s"), ratio );
    640639    }
    641     g_free( pch );
    642640    gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
    643641}
  • trunk/libtransmission/bencode.h

    r6146 r6162  
    5353    } val;
    5454} tr_benc;
    55 
    56 const tr_benc BENC_INIT;
    5755
    5856/* backwards compatability */
  • trunk/libtransmission/stats.c

    r5916 r6162  
    3030
    3131static char*
    32 getFilename( const tr_handle * handle, char * buf, size_t buflen )
     32getOldFilename( const tr_handle * handle, char * buf, size_t buflen )
    3333{
    3434    tr_buildPath( buf, buflen, tr_sessionGetConfigDir(handle),
     
    3838}
    3939
     40static char*
     41getFilename( const tr_handle * handle, char * buf, size_t buflen )
     42{
     43    tr_buildPath( buf, buflen, tr_sessionGetConfigDir(handle),
     44                               "stats.json",
     45                               NULL );
     46    return buf;
     47}
     48
    4049static void
    4150loadCumulativeStats( const tr_handle * handle, tr_session_stats * setme )
    4251{
     52    int loaded = FALSE;
    4353    char filename[MAX_PATH_LENGTH];
    4454    tr_benc top;
    4555
    4656    getFilename( handle, filename, sizeof(filename) );
    47     if( !tr_bencLoadFile( filename, &top ) )
     57    loaded = !tr_bencLoadJSONFile( filename, &top );
     58    if( !loaded ) {
     59        getOldFilename( handle, filename, sizeof(filename) );
     60        loaded = !tr_bencLoadFile( filename, &top );
     61    }
     62    if( loaded )
    4863    {
    4964        int64_t i;
     
    7994    getFilename( handle, filename, sizeof(filename) );
    8095    tr_deepLog( __FILE__, __LINE__, NULL, "Saving stats to \"%s\"", filename );
    81     tr_bencSaveFile( filename, &top );
     96    tr_bencSaveJSONFile( filename, &top );
    8297
    8398    tr_bencFree( &top );
  • trunk/libtransmission/torrent.c

    r6124 r6162  
    15551555                           int                      trackerCount )
    15561556{
    1557     tr_benc metainfo = BENC_INIT;
     1557    tr_benc metainfo;
    15581558
    15591559    /* save to the .torrent file */
Note: See TracChangeset for help on using the changeset viewer.