Ticket #1559: settings.diff

File settings.diff, 126.6 KB (added by charles, 12 years ago)

development patch that integrates with daemon, cli, gtk

  • libtransmission/utils.c

     
    4949
    5050static tr_lock *      messageLock = NULL;
    5151static int            messageLevel = 0;
    52 static int            messageQueuing = FALSE;
     52static tr_bool        messageQueuing = FALSE;
    5353static tr_msg_list *  messageQueue = NULL;
    5454static tr_msg_list ** messageQueueTail = &messageQueue;
    5555
    … … tr_getMessageLevel( void ) 
    118118}
    119119
    120120void
    121 tr_setMessageQueuing( int enabled )
     121tr_setMessageQueuing( tr_bool enabled )
    122122{
    123123    tr_msgInit( );
    124124    tr_lockLock( messageLock );
    … … tr_setMessageQueuing( int enabled ) 
    126126    tr_lockUnlock( messageLock );
    127127}
    128128
    129 int
     129tr_bool
    130130tr_getMessageQueuing( void )
    131131{
    132132    int ret;

  • libtransmission/bencode.c

    tr_bencGetInt( const tr_benc * val, 
    420420{
    421421    const int success = tr_bencIsInt( val );
    422422
    423     if( success )
     423    if( success && setme )
    424424        *setme = val->val.i;
     425
    425426    return success;
    426427}
    427428
    … … tr_bencDictFindInt( tr_benc * dict, cons 
    444445
    445446    if( child )
    446447        found = tr_bencGetInt( child, setme );
     448
    447449    return found;
    448450}
    449451
    … … tr_bencDictFindDouble( tr_benc * dict, c 
    453455    const char * str;
    454456    const tr_bool success = tr_bencDictFindStr( dict, key, &str );
    455457
    456     if( success )
     458    if( success && setme )
    457459        *setme = strtod( str, NULL );
    458460
    459461    return success;
    … … tr_bencDictFindList( tr_benc * dict, con 
    467469
    468470    if( child )
    469471    {
    470         *setme = child;
     472        if( setme != NULL )
     473            *setme = child;
    471474        found = TRUE;
    472475    }
    473476
    … … tr_bencDictFindDict( tr_benc * dict, con 
    482485
    483486    if( child )
    484487    {
    485         *setme = child;
     488        if( setme != NULL )
     489            *setme = child;
    486490        found = TRUE;
    487491    }
    488492
    … … tr_bencDictFindStr( tr_benc * dict, con 
    497501
    498502    if( child )
    499503    {
    500         *setme = child->val.s.s;
     504        if( setme )
     505            *setme = child->val.s.s;
    501506        found = TRUE;
    502507    }
    503508
    … … tr_bencDictAddInt( tr_benc * dict, 
    678683                   const char * key,
    679684                   int64_t      val )
    680685{
    681     tr_benc * child = tr_bencDictAdd( dict, key );
     686    tr_benc * child;
     687
     688    /* see if it already exists, and if so, try to reuse it */
     689    if(( child = tr_bencDictFind( dict, key ))) {
     690        if( !tr_bencIsInt( child ) ) {
     691            tr_bencDictRemove( dict, key );
     692            child = NULL;
     693        }
     694    }
     695
     696    /* if it doesn't exist, create it */
     697    if( child == NULL )
     698        child = tr_bencDictAdd( dict, key );
    682699
     700    /* set it */
    683701    tr_bencInitInt( child, val );
     702
    684703    return child;
    685704}
    686705
    687706tr_benc*
    688 tr_bencDictAddStr( tr_benc *    dict,
    689                    const char * key,
    690                    const char * val )
     707tr_bencDictAddStr( tr_benc * dict, const char * key, const char * val )
    691708{
    692     tr_benc * child = tr_bencDictAdd( dict, key );
     709    tr_benc * child;
    693710
     711    /* see if it already exists, and if so, try to reuse it */
     712    if(( child = tr_bencDictFind( dict, key ))) {
     713        if( tr_bencIsString( child ) )
     714            tr_free( child->val.s.s );
     715        else {
     716            tr_bencDictRemove( dict, key );
     717            child = NULL;
     718        }
     719    }
     720
     721    /* if it doesn't exist, create it */
     722    if( child == NULL )
     723        child = tr_bencDictAdd( dict, key );
     724
     725    /* set it */
    694726    tr_bencInitStr( child, val, -1 );
     727
    695728    return child;
    696729}
    697730

  • libtransmission/bencode.h

    int tr_bencParseStr( const uint8_t * bu 
    182182***
    183183**/
    184184
    185 void  tr_bencMergeDicts( tr_benc * b1, const tr_benc * b2 );
     185void  tr_bencMergeDicts( tr_benc * target, const tr_benc * source );
    186186
    187187#endif

  • libtransmission/platform.c

    tr_getResumeDir( const tr_handle * handl 
    408408}
    409409
    410410const char*
    411 tr_getDefaultConfigDir( void )
     411tr_getDefaultConfigDir( const char * appname )
    412412{
    413413    static char * s = NULL;
    414414
     415    if( !appname || !*appname )
     416        appname = "Transmission";
     417
    415418    if( !s )
    416419    {
    417420        if( ( s = getenv( "TRANSMISSION_HOME" ) ) )
    … … tr_getDefaultConfigDir( void ) 
    421424        else
    422425        {
    423426#ifdef SYS_DARWIN
    424             s = tr_buildPath( getHomeDir( ), "Library",
    425                               "Application Support", "Transmission", NULL );
     427            s = tr_buildPath( getHomeDir( ), "Library", "Application Support",
     428                              appname, NULL );
    426429#elif defined( WIN32 )
    427430            char appdata[MAX_PATH]; /* SHGetFolderPath() requires MAX_PATH */
    428431            SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, appdata );
    429             s = tr_buildPath( appdata, "Transmission", NULL );
     432            s = tr_buildPath( appdata, appname, NULL );
    430433#else
    431434            if( ( s = getenv( "XDG_CONFIG_HOME" ) ) )
    432                 s = tr_buildPath( s, "transmission", NULL );
     435                s = tr_buildPath( s, appname, NULL );
    433436            else
    434                 s = tr_buildPath( getHomeDir( ), ".config", "transmission", NULL );
     437                s = tr_buildPath( getHomeDir( ), ".config", appname, NULL );
    435438#endif
    436439        }
    437440    }

  • libtransmission/transmission.h

    typedef uint8_t tr_bool; 
    6464 *
    6565 * The default configuration directory is determined this way:
    6666 * 1. If the TRANSMISSION_HOME environmental variable is set, its value is used.
    67  * 2. On Darwin, "${HOME}/Library/Application Support/Transmission" is used.
    68  * 3. On Windows, "${CSIDL_APPDATA}/Transmission" is used.
    69  * 4. If XDG_CONFIG_HOME is set, "${XDG_CONFIG_HOME}/transmission" is used.
    70  * 5. ${HOME}/.config/transmission" is used as a last resort.
     67 * 2. On Darwin, "${HOME}/Library/Application Support/${appname}" is used.
     68 * 3. On Windows, "${CSIDL_APPDATA}/${appname}" is used.
     69 * 4. If XDG_CONFIG_HOME is set, "${XDG_CONFIG_HOME}/${appname}" is used.
     70 * 5. ${HOME}/.config/${appname}" is used as a last resort.
    7171 */
    72 const char* tr_getDefaultConfigDir( void );
     72const char* tr_getDefaultConfigDir( const char * appname );
    7373
    7474/**
    7575 * @brief returns Transmisson's default download directory.
    … … typedef enum 
    107107}
    108108tr_proxy_type;
    109109
    110 /** @see tr_sessionInitFull */
    111 #define TR_DEFAULT_CONFIG_DIR               tr_getDefaultConfigDir( )
    112 /** @see tr_sessionInitFull */
    113 #define TR_DEFAULT_DOWNLOAD_DIR             tr_getDefaultDownloadDir( )
    114 /** @see tr_sessionInitFull */
    115 #ifdef TR_EMBEDDED
    116  #define TR_DEFAULT_ENCRYPTION              TR_CLEAR_PREFERRED
    117 #else
    118  #define TR_DEFAULT_ENCRYPTION              TR_ENCRYPTION_PREFERRED
    119 #endif
    120 /** @see tr_sessionInitFull */
    121 #define TR_DEFAULT_PEX_ENABLED              1
    122 /** @see tr_sessionInitFull */
    123 #define TR_DEFAULT_PORT_FORWARDING_ENABLED  0
    124 /** @see tr_sessionInitFull */
    125 #define TR_DEFAULT_PORT                     51413
    126 /** @see tr_sessionInitFull */
    127 #define TR_DEFAULT_PORT_STR                 "51413"
    128 /** @see tr_sessionInitFull */
    129 #define TR_DEFAULT_LAZY_BITFIELD_ENABLED    1
    130 /** @see tr_sessionInitFull */
    131 #define TR_DEFAULT_GLOBAL_PEER_LIMIT        200
    132 /** @see tr_sessionInitFull */
    133 #define TR_DEFAULT_PEER_SOCKET_TOS          8
    134 /** @see tr_sessionInitFull */
    135 #define TR_DEFAULT_PEER_SOCKET_TOS_STR      "8"
    136 /** @see tr_sessionInitFull */
    137 #define TR_DEFAULT_BLOCKLIST_ENABLED        0
    138 /** @see tr_sessionInitFull */
    139 #define TR_DEFAULT_RPC_ENABLED              0
    140 /** @see tr_sessionInitFull */
    141 #define TR_DEFAULT_RPC_PORT                 9091
    142 /** @see tr_sessionInitFull */
    143 #define TR_DEFAULT_RPC_PORT_STR             "9091"
    144 /** @see tr_sessionInitFull */
    145 #define TR_DEFAULT_RPC_WHITELIST            "127.0.0.1"
    146 /** @see tr_sessionInitFull */
    147 #define TR_DEFAULT_RPC_WHITELIST_ENABLED    0
    148 /** @see tr_sessionInitFull */
    149 #define TR_DEFAULT_PROXY_ENABLED            0
    150 /** @see tr_sessionInitFull */
    151 #define TR_DEFAULT_PROXY                    NULL
    152 /** @see tr_sessionInitFull */
    153 #define TR_DEFAULT_PROXY_PORT               80
    154 /** @see tr_sessionInitFull */
    155 #define TR_DEFAULT_PROXY_TYPE               TR_PROXY_HTTP
    156 /** @see tr_sessionInitFull */
    157 #define TR_DEFAULT_PROXY_AUTH_ENABLED       0
    158 /** @see tr_sessionInitFull */
    159 #define TR_DEFAULT_PROXY_USERNAME           NULL
    160 /** @see tr_sessionInitFull */
    161 #define TR_DEFAULT_PROXY_PASSWORD           NULL
    162 
    163110typedef enum
    164111{
    165112    TR_CLEAR_PREFERRED,
    … … typedef enum 
    168115}
    169116tr_encryption_mode;
    170117
     118#define TR_DEFAULT_RPC_WHITELIST "127.0.0.1"
     119#define TR_DEFAULT_RPC_PORT_STR "9091"
     120#define TR_DEFAULT_PEER_PORT_STR "51413"
     121#define TR_DEFAULT_PEER_SOCKET_TOS_STR "8"
     122
     123#define TR_PREFS_KEY_BLOCKLIST_ENABLED          "blocklist-enabled"
     124#define TR_PREFS_KEY_DOWNLOAD_DIR               "download-dir"
     125#define TR_PREFS_KEY_DSPEED                     "download-limit"
     126#define TR_PREFS_KEY_DSPEED_ENABLED             "download-limit-enabled"
     127#define TR_PREFS_KEY_ENCRYPTION                 "encryption"
     128#define TR_PREFS_KEY_LAZY_BITFIELD              "lazy-bitfield-enabled"
     129#define TR_PREFS_KEY_MSGLEVEL                   "message-level"
     130#define TR_PREFS_KEY_MSGQUEUE_ENABLED           "message-queue-enabled"
     131#define TR_PREFS_KEY_PEER_LIMIT_GLOBAL          "peer-limit-global"
     132#define TR_PREFS_KEY_PEER_LIMIT_TORRENT         "peer-limit-per-torrent"
     133#define TR_PREFS_KEY_PEER_PORT                  "peer-port"
     134#define TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED   "peer-port-random-enabled"
     135#define TR_PREFS_KEY_PEER_PORT_RANDOM_LOW       "peer-port-random-low"
     136#define TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH      "peer-port-random-high"
     137#define TR_PREFS_KEY_PEER_SOCKET_TOS            "peer-socket-tos"
     138#define TR_PREFS_KEY_PEX_ENABLED                "pex-enabled"
     139#define TR_PREFS_KEY_PORT_FORWARDING            "port-forwarding-enabled"
     140#define TR_PREFS_KEY_PROXY_AUTH_ENABLED         "proxy-auth-enabled"
     141#define TR_PREFS_KEY_PROXY_ENABLED              "proxy-enabled"
     142#define TR_PREFS_KEY_PROXY_PASSWORD             "proxy-auth-password"
     143#define TR_PREFS_KEY_PROXY_PORT                 "proxy-port"
     144#define TR_PREFS_KEY_PROXY                      "proxy"
     145#define TR_PREFS_KEY_PROXY_TYPE                 "proxy-type"
     146#define TR_PREFS_KEY_PROXY_USERNAME             "proxy-auth-username"
     147#define TR_PREFS_KEY_RPC_AUTH_REQUIRED          "rpc-authentication-required"
     148#define TR_PREFS_KEY_RPC_ENABLED                "rpc-enabled"
     149#define TR_PREFS_KEY_RPC_PASSWORD               "rpc-password"
     150#define TR_PREFS_KEY_RPC_PORT                   "rpc-port"
     151#define TR_PREFS_KEY_RPC_USERNAME               "rpc-username"
     152#define TR_PREFS_KEY_RPC_WHITELIST_ENABLED      "rpc-whitelist-enabled"
     153#define TR_PREFS_KEY_RPC_WHITELIST              "rpc-whitelist"
     154#define TR_PREFS_KEY_USPEED_ENABLED             "upload-limit-enabled"
     155#define TR_PREFS_KEY_USPEED                     "upload-limit"
     156
     157struct tr_benc;
     158
    171159/**
    172  * @brief Start a libtransmission session.
    173  * @return an opaque handle to the new session
     160 * Add the default libtransmission configuration settings to the
     161 * specified tr_benc dictionary.
     162 *
     163 * Example:
     164 * @code
     165 *     tr_benc settings;
     166 *     int64_t i;
     167 *
     168 *     tr_bencInitDict( &settings, 0 );
     169 *     tr_sessionGetDefaultSettings( &settings );
     170 *     if( tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT, &i ) )
     171 *         fprintf( stderr, "the default peer port is %d\n", (int)i );
     172 *
     173 *     tr_bencFree( &settings );
     174 * @endcode
     175 *
     176 * @param initme pointer to a tr_benc dictionary
     177 * @see tr_sessionLoadSettings()
     178 * @see tr_sessionInit()
     179 * @see tr_getDefaultConfigDir()
     180 */
     181void tr_sessionGetDefaultSettings( struct tr_benc * dictionary );
     182
     183/**
     184 * Add the current libtransmission settings to the specified
     185 * tr_benc dictionary.
     186 *
     187 * @param session
     188 * @param dictionary
     189 * @see tr_sessionGetDefaultSettings()
     190 */
     191void tr_sessionGetSettings( tr_session *, struct tr_benc * dictionary );
     192
     193/**
     194 * Load settings from the configuration directory's settings.json file,
     195 * using the libtransmission defaults as fallbacks for missing keys.
     196 *
     197 * FIXME: this belongs in libtransmissionapp
     198 *
     199 * @param configDir the configuration directory to find settings.json
     200 * @param initme pointer to an uninitialized tr_benc
     201 * @param appName examples: Transmission, transmission-daemon
     202 * @see tr_sessionGetDefaultSettings()
     203 * @see tr_sessionInit()
     204 * @see tr_sessionSaveSettings()
     205 */
     206void tr_sessionLoadSettings( struct tr_benc  * dictionary,
     207                             const char      * configDir,
     208                             const char      * appName );
     209
     210/**
     211 * Add the current libtransmission settings to the specified dictionary
     212 * and save the dictionary to the configuration directory's settings.json file.
     213 *
     214 * FIXME: this belongs in libtransmissionapp
     215 *
     216 * @param session
     217 * @param dictionary
     218 * @see tr_sessionLoadSettings()
     219 */
     220void tr_sessionSaveSettings( tr_session     * session,
     221                             const char     * configDir,
     222                             struct tr_benc * dictonary );
     223
     224/**
     225 * Initialize a libtransmission session.
     226 *
     227 * For example, this will instantiate a session with all the default values:
     228 * @code
     229 *     tr_benc settings;
     230 *     tr_session * session;
     231 *     const char * configDir;
     232 *
     233 *     tr_bencInitDict( &settings, 0 );
     234 *     tr_sessionGetDefaultSettings( &settings );
     235 *     configDir = tr_getDefaultConfigDir( "Transmission" );
     236 *     session = tr_sessionInit( "mac", configDir, TRUE, &settings );
     237 *
     238 *     tr_bencFree( &settings );
     239 * @encode
    174240 *
     241 * @param tag "gtk", "mac", "daemon", etc... this is only for pre-1.30 resume files
    175242 * @param configDir
    176  *  The config directory where libtransmission config subdirectories
    177  *  will be found, such as "torrents", "resume", and "blocklists".
    178  *  #TR_DEFAULT_CONFIG_DIR can be used as a default.
    179  *
    180  * @param downloadDir
    181  *  The default directory to save added torrents.
    182  *  This can be changed per-session with
    183  *  tr_sessionSetDownloadDir() and per-torrent with
    184  *  tr_ctorSetDownloadDir().
    185  *
    186  * @param tag
    187  *  Obsolete.  Only used now for locating legacy fastresume files.
    188  *  This will be removed at some point in the future.
    189  *  Valid tags: beos cli daemon gtk macos wx
    190  *
    191  * @param isPexEnabled
    192  *  whether or not PEX is allowed for non-private torrents.
    193  *  This can be changed per-session with
    194  *  tr_sessionSetPexEnabled().
    195  *  #TR_DEFAULT_PEX_ENABLED is the default.
    196  *
    197  * @param isPortForwardingEnabled
    198  *  If true, libtransmission will attempt
    199  *  to find a local UPnP-enabled or NATPMP-enabled
    200  *  router and forward a port from there to the local
    201  *  machine.  This is so remote peers can initiate
    202  *  connections with us.
    203  *  #TR_DEFAULT_PORT_FORWARDING_ENABLED is the default.
    204  *
    205  * @param publicPort
    206  *  Port number to open for incoming peer connections.
    207  *  -1 for random port.
    208  *  #TR_DEFAULT_PORT is the default.
    209  *
    210  * @param encryptionMode
    211  *  Must be one of #TR_CLEAR_PREFERRED,
    212  *  #TR_ENCRYPTION_PREFERRED, or #TR_ENCRYPTION_REQUIRED.
    213  *
    214  * @param isUploadLimitEnabled
    215  *  If true, libtransmission will limit the entire
    216  *  session's upload speed from "uploadLimit".
    217  *
    218  * @param uploadLimit
    219  *  The speed limit to use for the entire session when
    220  *  "isUploadLimitEnabled" is true.  Units are KiB/s.
    221  *
    222  * @param isDownloadLimitEnabled
    223  *  If true, libtransmission will limit the entire
    224  *  session's download speed from "downloadLimit".
    225  *
    226  * @param downloadLimit
    227  *  The speed limit to use for the entire session when
    228  *  "isDownloadLimitEnabled" is true.  Units are KiB/s.
    229  *
    230  * @param peerLimit
    231  *  The maximum number of peer connections allowed in a session.
    232  *  #TR_DEFAULT_GLOBAL_PEER_LIMIT can be used as a default.
    233  *
    234  * @param messageLevel
    235  *  Verbosity level of libtransmission's logging mechanism.
    236  *  Must be one of #TR_MSG_ERR, #TR_MSG_INF, #TR_MSG_DBG.
    237  *
    238  * @param isMessageQueueingEnabled
    239  *  If true, then messages will build up in a queue until
    240  *  processed by the client application.
    241  *
    242  * @param isBlocklistEnabled
    243  *  If true, then Transmission will not allow peer connections
    244  *  to the IP addressess specified in the blocklist.
    245  *
    246  * @param peerSocketTOS
    247  *
    248  * @param rpcIsEnabled
    249  *  If true, then libtransmission will open an http server port
    250  *  to listen for incoming RPC requests.
    251  *
    252  * @param rpcPort
    253  *  The port on which to listen for incoming RPC requests
    254  *
    255  * @param rpcWhitelist
    256  *  The list of IP addresses allowed to make RPC connections.
    257  *  @see tr_sessionSetRPCWhitelist()
    258  *
    259  * @see TR_DEFAULT_PEER_SOCKET_TOS
    260  * @see TR_DEFAULT_BLOCKLIST_ENABLED
    261  * @see TR_DEFAULT_RPC_ENABLED
    262  * @see TR_DEFAULT_RPC_PORT
    263  * @see TR_DEFAULT_RPC_WHITELIST
    264  * @see TR_DEFAULT_RPC_WHITELIST_ENABLED
    265  * @see tr_sessionClose()
    266  */
    267 tr_session * tr_sessionInitFull( const char *       configDir,
    268                                  const char *       tag,
    269                                  const char *       downloadDir,
    270                                  int                isPexEnabled,
    271                                  int                isPortForwardingEnabled,
    272                                  int                publicPort,
    273                                  tr_encryption_mode encryptionMode,
    274                                  int                useLazyBitfield,
    275                                  int                useUploadLimit,
    276                                  int                uploadLimit,
    277                                  int                useDownloadLimit,
    278                                  int                downloadLimit,
    279                                  int                peerLimit,
    280                                  int                messageLevel,
    281                                  int                isMessageQueueingEnabled,
    282                                  int                isBlocklistEnabled,
    283                                  int                peerSocketTOS,
    284                                  int                rpcIsEnabled,
    285                                  tr_port            rpcPort,
    286                                  int                rpcWhitelistIsEnabled,
    287                                  const char *       rpcWhitelist,
    288                                  int                rpcPasswordIsEnabled,
    289                                  const char *       rpcUsername,
    290                                  const char *       rpcPassword,
    291                                  int                proxyIsEnabled,
    292                                  const char *       proxy,
    293                                  int                proxyPort,
    294                                  tr_proxy_type      proxyType,
    295                                  int                proxyAuthIsEnabled,
    296                                  const char *       proxyUsername,
    297                                  const char *       proxyPassword );
    298 
    299 
    300 /** @brief Shorter form of tr_sessionInitFull()
    301     @deprecated Use tr_sessionInitFull() instead. */
    302 tr_session *  tr_sessionInit( const char * configDir,
    303                               const char * tag );
     243 * @param messageQueueingEnabled if false, messages will be dumped to stderr
     244 * @param settings libtransmission settings
     245 * @see tr_sessionGetDefaultSettings()
     246 * @see tr_sessionLoadSettings()
     247 * @see tr_getDefaultConfigDir()
     248 */
     249tr_session * tr_sessionInit( const char     * tag,
     250                             const char     * configDir,
     251                             tr_bool          messageQueueingEnabled,
     252                             struct tr_benc * settings );
    304253
    305254/** @brief End a libtransmission session
    306255    @see tr_sessionInitFull() */
    307 void         tr_sessionClose( tr_session * );
     256void tr_sessionClose( tr_session * );
    308257
    309258/**
    310259 * @brief Return the session's configuration directory
    … … char* tr_sessionGetRPCWhitelist( const t 
    379328void  tr_sessionSetRPCWhitelistEnabled( tr_session * session,
    380329                                        int          isEnabled );
    381330
    382 int  tr_sessionGetRPCWhitelistEnabled( const tr_session * session );
     331tr_bool tr_sessionGetRPCWhitelistEnabled( const tr_session * session );
    383332
    384333void  tr_sessionSetRPCPassword( tr_session * session,
    385334                                const char * password );
    … … char* tr_sessionGetRPCUsername( const tr 
    398347void  tr_sessionSetRPCPasswordEnabled( tr_session * session,
    399348                                       int          isEnabled );
    400349
    401 int  tr_sessionIsRPCPasswordEnabled( const tr_session * session );
     350tr_bool tr_sessionIsRPCPasswordEnabled( const tr_session * session );
    402351
    403352
    404353typedef enum
    … … void tr_sessionSetRPCCallback( tr_sessio 
    447396***
    448397**/
    449398
    450 int           tr_sessionIsProxyEnabled( const tr_session * );
     399tr_bool       tr_sessionIsProxyEnabled( const tr_session * );
    451400
    452 int           tr_sessionIsProxyAuthEnabled( const tr_session * );
     401tr_bool       tr_sessionIsProxyAuthEnabled( const tr_session * );
    453402
    454403const char*   tr_sessionGetProxy( const tr_session * );
    455404
    456 int           tr_sessionGetProxyPort( const tr_session * );
     405tr_port       tr_sessionGetProxyPort( const tr_session * );
    457406
    458407tr_proxy_type tr_sessionGetProxyType( const tr_session * );
    459408
    … … typedef struct tr_msg_list 
    648597}
    649598tr_msg_list;
    650599
    651 void          tr_setMessageQueuing( int isEnabled );
     600void          tr_setMessageQueuing( tr_bool isEnabled );
    652601
    653 int           tr_getMessageQueuing( void );
     602tr_bool       tr_getMessageQueuing( void );
    654603
    655604tr_msg_list * tr_getQueuedMessages( void );
    656605

  • libtransmission/torrent-ctor.c

     
    1818#include "torrent.h" /* tr_ctorGetSave() */
    1919#include "utils.h"
    2020
    21 #define DEFAULT_MAX_CONNECTED_PEERS 50
    22 
    2321struct optional_args
    2422{
    2523    tr_bool         isSet_paused;
    … … struct optional_args 
    3533 * @ingroup tr_ctor */
    3634struct tr_ctor
    3735{
    38     const tr_handle *       handle;
     36    const tr_session *      session;
    3937    tr_bool                 saveInOurTorrentsDir;
    4038    tr_bool                 doDelete;
    4139
    … … tr_ctorSetMetainfoFromHash( tr_ctor *  
    139137    int          err;
    140138    const char * filename;
    141139
    142     filename = tr_sessionFindTorrentFile( ctor->handle, hashString );
     140    filename = tr_sessionFindTorrentFile( ctor->session, hashString );
    143141    if( !filename )
    144142        err = EINVAL;
    145143    else
    … … tr_ctorGetMetainfo( const tr_ctor * cto 
    298296***/
    299297
    300298tr_ctor*
    301 tr_ctorNew( const tr_handle * handle )
     299tr_ctorNew( const tr_session * session )
    302300{
    303301    tr_ctor * ctor = tr_new0( struct tr_ctor, 1 );
    304302
    305     ctor->handle = handle;
    306     tr_ctorSetPeerLimit( ctor, TR_FALLBACK, DEFAULT_MAX_CONNECTED_PEERS );
     303    ctor->session = session;
     304    tr_ctorSetPeerLimit( ctor, TR_FALLBACK, session->peerLimitPerTorrent );
    307305    tr_ctorSetPaused( ctor, TR_FALLBACK, FALSE );
    308     tr_ctorSetDownloadDir( ctor, TR_FALLBACK, handle->downloadDir );
     306    tr_ctorSetDownloadDir( ctor, TR_FALLBACK, session->downloadDir );
    309307    tr_ctorSetSave( ctor, TRUE );
    310308    return ctor;
    311309}

  • libtransmission/session.c

     
    2222
    2323#include "transmission.h"
    2424#include "bandwidth.h"
     25#include "bencode.h"
    2526#include "blocklist.h"
    2627#include "fdlimit.h"
    2728#include "list.h"
    … …  
    3940#include "web.h"
    4041#include "crypto.h"
    4142
    42 #define PORT_RANDOM_MIN 1024
    43 #define PORT_RANDOM_MAX 65535
     43static tr_port
     44getRandomPort( tr_session * s )
     45{
     46    return tr_cryptoWeakRandInt( s->randomPortHigh - s->randomPortLow + 1) + s->randomPortLow;
     47}
    4448
    4549/* Generate a peer id : "-TRxyzb-" + 12 random alphanumeric
    4650   characters, where x is the major version number, y is the
    … … loadBlocklists( tr_session * session ) 
    197201****
    198202***/
    199203
    200 static void metainfoLookupRescan( tr_handle * h );
     204#ifdef TR_EMBEDDED
     205 #define TR_DEFAULT_ENCRYPTION              TR_CLEAR_PREFERRED
     206#else
     207 #define TR_DEFAULT_ENCRYPTION              TR_ENCRYPTION_PREFERRED
     208#endif
    201209
    202 tr_handle *
    203 tr_sessionInitFull( const char *       configDir,
    204                     const char *       tag,
    205                     const char *       downloadDir,
    206                     int                isPexEnabled,
    207                     int                isPortForwardingEnabled,
    208                     int                publicPort,
    209                     tr_encryption_mode encryptionMode,
    210                     int                useLazyBitfield,
    211                     int                useUploadLimit,
    212                     int                uploadLimit,
    213                     int                useDownloadLimit,
    214                     int                downloadLimit,
    215                     int                globalPeerLimit,
    216                     int                messageLevel,
    217                     int                isMessageQueueingEnabled,
    218                     int                isBlocklistEnabled,
    219                     int                peerSocketTOS,
    220                     int                rpcIsEnabled,
    221                     tr_port            rpcPort,
    222                     int                rpcWhitelistIsEnabled,
    223                     const char *       rpcWhitelist,
    224                     int                rpcAuthIsEnabled,
    225                     const char *       rpcUsername,
    226                     const char *       rpcPassword,
    227                     int                proxyIsEnabled,
    228                     const char *       proxy,
    229                     int                proxyPort,
    230                     tr_proxy_type      proxyType,
    231                     int                proxyAuthIsEnabled,
    232                     const char *       proxyUsername,
    233                     const char *       proxyPassword )
     210void
     211tr_sessionGetDefaultSettings( tr_benc * d )
    234212{
    235     tr_handle * h;
     213    assert( tr_bencIsDict( d ) );
     214
     215    tr_bencDictReserve( d, 30 );
     216    tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        FALSE );
     217    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,             tr_getDefaultDownloadDir( ) );
     218    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED,                   100 );
     219    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED,           0 );
     220    tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION,               TR_DEFAULT_ENCRYPTION );
     221    tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD,            TRUE );
     222    tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL,                 TR_MSG_INF );
     223    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        240 );
     224    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       60 );
     225    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT,                atoi( TR_DEFAULT_PEER_PORT_STR ) );
     226    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, FALSE );
     227    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     1024 );
     228    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    65535 );
     229    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          atoi( TR_DEFAULT_PEER_SOCKET_TOS_STR ) );
     230    tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              TRUE );
     231    tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          TRUE );
     232    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    "" );
     233    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       FALSE );
     234    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED,            FALSE );
     235    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD,           "" );
     236    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT,               80 );
     237    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE,               TR_PROXY_HTTP );
     238    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME,           "" );
     239    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        FALSE );
     240    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED,              TRUE );
     241    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD,             "" );
     242    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME,             "" );
     243    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST,            TR_DEFAULT_RPC_WHITELIST );
     244    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    TRUE );
     245    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,                 atoi( TR_DEFAULT_RPC_PORT_STR ) );
     246    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   100 );
     247    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           0 );
     248}
     249
     250void
     251tr_sessionGetSettings( tr_session * s, struct tr_benc * d )
     252{
     253    int i, n=0;
     254    char * freeme[16];
     255
     256    assert( tr_bencIsDict( d ) );
     257
     258    tr_bencDictReserve( d, 30 );
     259    tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        tr_blocklistIsEnabled( s ) );
     260    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,             s->downloadDir );
     261    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED,                   tr_sessionGetSpeedLimit( s, TR_DOWN ) );
     262    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED,           tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
     263    tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION,               s->encryptionMode );
     264    tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD,            s->useLazyBitfield );
     265    tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL,                 tr_getMessageLevel( ) );
     266    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        tr_sessionGetPeerLimit( s ) );
     267    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       s->peerLimitPerTorrent );
     268    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT,                tr_sessionGetPeerPort( s ) );
     269    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, s->isPortRandom );
     270    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     s->randomPortLow );
     271    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    s->randomPortHigh );
     272    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          s->peerSocketTOS );
     273    tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              s->isPexEnabled );
     274    tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          tr_sessionIsPortForwardingEnabled( s ) );
     275    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    s->proxy );
     276    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       s->isProxyAuthEnabled );
     277    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED,            s->isProxyEnabled );
     278    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD,           s->proxyPassword );
     279    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT,               s->proxyPort );
     280    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE,               s->proxyType );
     281    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME,           s->proxyUsername );
     282    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        tr_sessionIsRPCPasswordEnabled( s ) );
     283    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED,              tr_sessionIsRPCEnabled( s ) );
     284    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD,             freeme[n++] = tr_sessionGetRPCPassword( s ) );
     285    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,                 tr_sessionGetRPCPort( s ) );
     286    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME,             freeme[n++] = tr_sessionGetRPCUsername( s ) );
     287    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST,            freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
     288    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    tr_sessionGetRPCWhitelistEnabled( s ) );
     289    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   tr_sessionGetSpeedLimit( s, TR_UP ) );
     290    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
     291
     292    for( i=0; i<n; ++i )
     293        tr_free( freeme[i] );
     294}
     295
     296void
     297tr_sessionLoadSettings( tr_benc * d, const char * configDir, const char * appName )
     298{
     299    char * filename;
     300    tr_benc fileSettings;
     301
     302    assert( tr_bencIsDict( d ) );
     303
     304    /* get the defaults */
     305    tr_sessionGetDefaultSettings( d );
     306
     307    /* if caller didn't specify a config dir, use the default */
     308    if( !configDir || !*configDir )
     309        configDir = tr_getDefaultConfigDir( appName );
     310
     311    /* file settings override the defaults */
     312    filename = tr_buildPath( configDir, "settings.json", NULL );
     313    if( !tr_bencLoadJSONFile( filename, &fileSettings ) ) {
     314        tr_bencMergeDicts( d, &fileSettings );
     315        tr_bencFree( &fileSettings );
     316    }
     317
     318    /* cleanup */
     319    tr_free( filename );
     320}
     321
     322void
     323tr_sessionSaveSettings( tr_session * session, const char * configDir, tr_benc * settings )
     324{
     325    tr_benc fileSettings;
     326    char * filename;
     327
     328    assert( tr_bencIsDict( settings ) );
     329 
     330    filename = tr_buildPath( configDir, "settings.json", NULL );
     331
     332    tr_sessionGetSettings( session, settings );
     333
     334    if( tr_bencLoadJSONFile( filename, &fileSettings ) ) {
     335        tr_bencSaveJSONFile( filename, settings );
     336    } else {
     337        tr_bencMergeDicts( &fileSettings, settings );
     338        tr_bencSaveJSONFile( filename, &fileSettings );
     339        tr_bencFree( &fileSettings );
     340    }
     341
     342    tr_inf( "saved \"%s\"", filename );
     343    tr_free( filename );
     344}
     345
     346static void metainfoLookupRescan( tr_handle * h );
     347
     348tr_session *
     349tr_sessionInit( const char  * tag,
     350                const char  * configDir,
     351                tr_bool       messageQueuingEnabled,
     352                tr_benc     * clientSettings )
     353{
     354    int64_t i;
     355    int64_t j;
     356    tr_bool found;
     357    const char * str;
     358    tr_benc settings;
     359
     360    tr_session * session;
    236361    char      * filename;
     362    int64_t rpc_enabled, whitelist_enabled, rpc_auth_enabled, rpc_port;
     363    const char * whitelist = NULL, *rpc_passwd = NULL, *rpc_username = NULL;
     364
     365    assert( tr_bencIsDict( clientSettings ) );
     366
     367    session = tr_new0( tr_session, 1 );
     368    session->lock = tr_lockNew( );
     369    session->tag = tr_strdup( tag );
     370
     371    tr_bencInitDict( &settings, 0 );
     372    tr_sessionGetDefaultSettings( &settings );
     373    tr_bencMergeDicts( &settings, clientSettings );
    237374
    238375#ifndef WIN32
    239376    /* Don't exit when writing on a broken socket */
    … … tr_sessionInitFull( const char * c 
    241378#endif
    242379
    243380    tr_msgInit( );
    244     tr_setMessageLevel( messageLevel );
    245     tr_setMessageQueuing( isMessageQueueingEnabled );
    246381
    247     h = tr_new0( tr_handle, 1 );
    248     h->lock = tr_lockNew( );
    249     h->isPexEnabled = isPexEnabled ? 1 : 0;
    250     h->encryptionMode = encryptionMode;
    251     h->peerSocketTOS = peerSocketTOS;
    252     h->downloadDir = tr_strdup( downloadDir );
    253     h->isProxyEnabled = proxyIsEnabled ? 1 : 0;
    254     h->proxy = tr_strdup( proxy );
    255     h->proxyPort = proxyPort;
    256     h->proxyType = proxyType;
    257     h->isProxyAuthEnabled = proxyAuthIsEnabled != 0;
    258     h->proxyUsername = tr_strdup( proxyUsername );
    259     h->proxyPassword = tr_strdup( proxyPassword );
    260     h->so_sndbuf = 1500 * 3; /* 3x MTU for most ethernet/wireless */
    261     h->so_rcvbuf = 8192;
    262 
    263     if( configDir == NULL )
    264         configDir = tr_getDefaultConfigDir( );
    265     tr_setConfigDir( h, configDir );
     382    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i );
     383    assert( found );
     384    session->peerLimitPerTorrent = i;
     385
     386    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_MSGLEVEL, &i );
     387    assert( found );
     388    tr_setMessageLevel( i );
     389    tr_setMessageQueuing( messageQueuingEnabled );
     390
     391
     392    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEX_ENABLED, &i );
     393    assert( found );
     394    session->isPexEnabled = i != 0;
     395
     396    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ENCRYPTION, &i );
     397    assert( found );
     398    session->encryptionMode = i;
     399
     400    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_SOCKET_TOS, &i );
     401    assert( found );
     402    session->peerSocketTOS = i;
     403
     404    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str );
     405    assert( found );
     406    session->downloadDir = tr_strdup( str );
     407
     408    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_ENABLED, &i );
     409    assert( found );
     410    session->isProxyEnabled = i != 0;
     411
     412    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY, &str );
     413    assert( found );
     414    session->proxy = tr_strdup( str );
     415
     416    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_PORT, &i );
     417    assert( found );
     418    session->proxyPort = i;
     419
     420    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_TYPE, &i );
     421    assert( found );
     422    session->proxyType = i;
     423
     424    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_AUTH_ENABLED, &i );
     425    assert( found );
     426    session->isProxyAuthEnabled = i != 0;
     427
     428    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY_USERNAME, &str );
     429    assert( found );
     430    session->proxyUsername = tr_strdup( str );
     431
     432    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY_PASSWORD, &str );
     433    assert( found );
     434    session->proxyPassword = tr_strdup( str );
     435
     436    session->so_sndbuf = 1500 * 3; /* 3x MTU for most ethernet/wireless */
     437    session->so_rcvbuf = 8192;
     438
     439    tr_setConfigDir( session, configDir );
    266440
    267441    tr_netInit( ); /* must go before tr_eventInit */
    268442
    269     tr_eventInit( h );
    270     while( !h->events )
     443    tr_eventInit( session );
     444    while( !session->events )
    271445        tr_wait( 50 );
    272446
    273     h->tag = tr_strdup( tag );
    274     h->peerMgr = tr_peerMgrNew( h );
     447    session->peerMgr = tr_peerMgrNew( session );
    275448
    276     h->useLazyBitfield = useLazyBitfield != 0;
     449    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_LAZY_BITFIELD, &i );
     450    assert( found );
     451    session->useLazyBitfield = i != 0;
    277452
    278453    /* Initialize rate and file descripts controls */
    279454
    280     tr_fdInit( globalPeerLimit );
    281    
    282     /* random port */
    283     if ( publicPort == -1 )
    284         publicPort = tr_cryptoWeakRandInt(PORT_RANDOM_MAX - PORT_RANDOM_MIN + 1) + PORT_RANDOM_MIN;
     455    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i );
     456    assert( found );
     457    tr_fdInit( i );
    285458   
    286     h->shared = tr_sharedInit( h, isPortForwardingEnabled, publicPort );
    287     h->isPortSet = publicPort >= 0;
    288 
    289     h->bandwidth = tr_bandwidthNew( h, NULL );
    290     tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_UP, uploadLimit );
    291     tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_DOWN, downloadLimit );
    292     tr_bandwidthSetLimited( h->bandwidth, TR_UP, useUploadLimit );
    293     tr_bandwidthSetLimited( h->bandwidth, TR_DOWN, useDownloadLimit );
     459    /**
     460    *** random port
     461    **/
     462
     463    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, &i );
     464    assert( found );
     465    session->isPortRandom = i != 0;
     466
     467    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i );
     468    assert( found );
     469    session->randomPortLow = i;
     470
     471    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, &i );
     472    assert( found );
     473    session->randomPortHigh = i;
     474
     475    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, &i )
     476         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT, &j );
     477    assert( found );
     478    session->peerPort = session->isPortRandom ? getRandomPort( session ) : j;
     479    session->shared = tr_sharedInit( session, i, session->peerPort );
     480    session->isPortSet = session->isPortRandom || j>0;
     481    session->bandwidth = tr_bandwidthNew( session, NULL );
     482
     483    /**
     484    **/
     485
     486    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED, &i );
     487    assert( found );
     488    tr_bandwidthSetDesiredSpeed( session->bandwidth, TR_UP, i );
     489
     490    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED, &i );
     491    assert( found );
     492    tr_bandwidthSetDesiredSpeed( session->bandwidth, TR_DOWN, i );
     493
     494    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED_ENABLED, &i );
     495    assert( found );
     496    tr_bandwidthSetLimited( session->bandwidth, TR_UP, i);
     497
     498    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED_ENABLED, &i );
     499    assert( found );
     500    tr_bandwidthSetLimited( session->bandwidth, TR_DOWN, i);
    294501
    295502    /* first %s is the application name
    296503       second %s is the version number */
    297504    tr_inf( _( "%s %s started" ), TR_NAME, LONG_VERSION_STRING );
    298505
    299506    /* initialize the blocklist */
    300     filename = tr_buildPath( h->configDir, "blocklists", NULL );
     507    filename = tr_buildPath( session->configDir, "blocklists", NULL );
    301508    tr_mkdirp( filename, 0777 );
    302509    tr_free( filename );
    303     h->isBlocklistEnabled = isBlocklistEnabled;
    304     loadBlocklists( h );
    305510
    306     tr_statsInit( h );
     511    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i );
     512    assert( found );
     513    session->isBlocklistEnabled = i;
     514    loadBlocklists( session );
     515
     516    tr_statsInit( session );
     517
     518    session->web = tr_webInit( session );
     519    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_ENABLED, &rpc_enabled )
     520         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_PORT, &rpc_port )
     521         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, &whitelist_enabled )
     522         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &rpc_auth_enabled )
     523         && tr_bencDictFindStr( &settings, TR_PREFS_KEY_RPC_WHITELIST, &whitelist )
     524         && tr_bencDictFindStr( &settings, TR_PREFS_KEY_RPC_USERNAME, &rpc_username )
     525         && tr_bencDictFindStr( &settings, TR_PREFS_KEY_RPC_PASSWORD, &rpc_passwd );
     526    assert( found );
     527    session->rpcServer = tr_rpcInit( session, rpc_enabled, rpc_port, whitelist_enabled, whitelist,
     528                                     rpc_auth_enabled, rpc_username, rpc_passwd );
     529
     530    metainfoLookupRescan( session );
    307531
    308     h->web = tr_webInit( h );
    309     h->rpcServer = tr_rpcInit( h, rpcIsEnabled, rpcPort,
    310                                rpcWhitelistIsEnabled, rpcWhitelist,
    311                                rpcAuthIsEnabled, rpcUsername, rpcPassword );
    312 
    313     metainfoLookupRescan( h );
    314 
    315     return h;
    316 }
    317 
    318 tr_handle *
    319 tr_sessionInit( const char * configDir,
    320                 const char * tag )
    321 {
    322     return tr_sessionInitFull( configDir,
    323                                TR_DEFAULT_DOWNLOAD_DIR,
    324                                tag,
    325                                TR_DEFAULT_PEX_ENABLED,
    326                                TR_DEFAULT_PORT_FORWARDING_ENABLED,
    327                                -1, /* public port */
    328                                TR_DEFAULT_ENCRYPTION, /* encryption mode */
    329                                TR_DEFAULT_LAZY_BITFIELD_ENABLED,
    330                                FALSE, /* use upload speed limit? */
    331                                -1, /* upload speed limit */
    332                                FALSE, /* use download speed limit? */
    333                                -1, /* download speed limit */
    334                                TR_DEFAULT_GLOBAL_PEER_LIMIT,
    335                                TR_MSG_INF, /* message level */
    336                                FALSE, /* is message queueing enabled? */
    337                                FALSE, /* is the blocklist enabled? */
    338                                TR_DEFAULT_PEER_SOCKET_TOS,
    339                                TR_DEFAULT_RPC_ENABLED,
    340                                TR_DEFAULT_RPC_PORT,
    341                                TR_DEFAULT_RPC_WHITELIST_ENABLED,
    342                                TR_DEFAULT_RPC_WHITELIST,
    343                                FALSE,
    344                                "fnord",
    345                                "potzrebie",
    346                                TR_DEFAULT_PROXY_ENABLED,
    347                                TR_DEFAULT_PROXY,
    348                                TR_DEFAULT_PROXY_PORT,
    349                                TR_DEFAULT_PROXY_TYPE,
    350                                TR_DEFAULT_PROXY_AUTH_ENABLED,
    351                                TR_DEFAULT_PROXY_USERNAME,
    352                                TR_DEFAULT_PROXY_PASSWORD );
     532    tr_bencFree( &settings );
     533
     534    return session;
    353535}
    354536
    355537/***
    … … tr_setBindPortImpl( void * vdata ) 
    420602    tr_free( data );
    421603}
    422604
    423 void
    424 tr_sessionSetPeerPort( tr_session * session,
    425                        tr_port      port )
     605static void
     606setPortImpl( tr_session * session, tr_port port )
    426607{
    427608    struct bind_port_data * data = tr_new( struct bind_port_data, 1 );
    428 
    429609    data->session = session;
    430610    data->port = port;
    431611    tr_runInEventThread( session, tr_setBindPortImpl, data );
    432612}
    433613
     614void
     615tr_sessionSetPeerPort( tr_session * session,
     616                       tr_port      port )
     617{
     618    session->isPortRandom = FALSE;
     619    session->peerPort = port;
     620    setPortImpl( session, session->peerPort );
     621}
     622
    434623tr_port
    435624tr_sessionSetPeerPortRandom( tr_session * session )
    436625{
    437     const tr_port port = tr_cryptoWeakRandInt(PORT_RANDOM_MAX - PORT_RANDOM_MIN + 1) + PORT_RANDOM_MIN;
    438     tr_sessionSetPeerPort( session, port);
    439     return port;
     626    session->isPortRandom = TRUE;
     627    session->peerPort = getRandomPort( session );
     628    setPortImpl( session, session->peerPort );
     629    return session->peerPort;
    440630}
    441631
    442632tr_port
    443 tr_sessionGetPeerPort( const tr_handle * h )
     633tr_sessionGetPeerPort( const tr_session * session )
    444634{
    445     assert( h );
    446     return tr_sharedGetPeerPort( h->shared );
     635    assert( session );
     636
     637    return session->peerPort;
    447638}
    448639
    449640tr_port_forwarding
    … … tr_sessionSetPeerLimit( tr_handle * hand 
    498689}
    499690
    500691uint16_t
    501 tr_sessionGetPeerLimit( const tr_handle * handle UNUSED )
     692tr_sessionGetPeerLimit( const tr_session * session UNUSED )
    502693{
    503694    return tr_fdGetPeerLimit( );
    504695}
    … … tr_sessionSetRPCWhitelistEnabled( tr_ses 
    10321223    tr_rpcSetWhitelistEnabled( session->rpcServer, isEnabled );
    10331224}
    10341225
    1035 int
     1226tr_bool
    10361227tr_sessionGetRPCWhitelistEnabled( const tr_session * session )
    10371228{
    10381229    return tr_rpcGetWhitelistEnabled( session->rpcServer );
    … … tr_sessionSetRPCPasswordEnabled( tr_sess 
    10721263    tr_rpcSetPasswordEnabled( session->rpcServer, isEnabled );
    10731264}
    10741265
    1075 int
     1266tr_bool
    10761267tr_sessionIsRPCPasswordEnabled( const tr_session * session )
    10771268{
    10781269    return tr_rpcIsPasswordEnabled( session->rpcServer );
    … … tr_sessionIsRPCPasswordEnabled( const tr 
    10821273****
    10831274***/
    10841275
    1085 int
     1276tr_bool
    10861277tr_sessionIsProxyEnabled( const tr_session * session )
    10871278{
    10881279    return session->isProxyEnabled;
    … … tr_sessionGetProxy( const tr_session * s 
    11141305    return session->proxy;
    11151306}
    11161307
    1117 int
     1308tr_port
    11181309tr_sessionGetProxyPort( const tr_session * session )
    11191310{
    11201311    return session->proxyPort;
    … … tr_sessionSetProxyPort( tr_session * ses 
    11381329    session->proxyPort = port;
    11391330}
    11401331
    1141 int
     1332tr_bool
    11421333tr_sessionIsProxyAuthEnabled( const tr_session * session )
    11431334{
    11441335    return session->isProxyAuthEnabled;

  • libtransmission/rpc-server.c

    tr_rpcInit( tr_handle * session, 
    696696    s = tr_new0( tr_rpc_server, 1 );
    697697    s->session = session;
    698698    s->port = port;
    699     s->whitelist = tr_strdup( whitelist && *whitelist
    700                               ? whitelist
    701                               : TR_DEFAULT_RPC_WHITELIST );
     699    s->whitelist = tr_strdup( whitelist && *whitelist ? whitelist : "127.0.0.1" );
    702700    s->username = tr_strdup( username );
    703701    s->password = tr_strdup( password );
    704702    s->isWhitelistEnabled = isWhitelistEnabled != 0;

  • libtransmission/session.h

    struct tr_bandwidth; 
    5858struct tr_handle
    5959{
    6060    tr_bool                      isPortSet;
     61    tr_bool                      isPortRandom;
    6162    tr_bool                      isPexEnabled;
    6263    tr_bool                      isBlocklistEnabled;
    6364    tr_bool                      isProxyEnabled;
    … … struct tr_handle 
    6970
    7071    struct tr_event_handle *     events;
    7172
     73    uint16_t                     peerLimitPerTorrent;
     74
     75    tr_port                      peerPort;
     76    tr_port                      randomPortLow;
     77    tr_port                      randomPortHigh;
     78
    7279    int                          proxyPort;
    7380    int                          peerSocketTOS;
    7481
    … … struct tr_handle 
    7683    tr_torrent *                 torrentList;
    7784
    7885    char *                       tag;
    79 
    8086    char *                       configDir;
    8187    char *                       downloadDir;
    8288    char *                       resumeDir;

  • libtransmission/torrent.c

    tr_torrentIsPieceTransferAllowed( const  
    207207            break;
    208208    }
    209209
     210fprintf( stderr, "tr_torrentIsPieceTransferAllowed( %s, %d ) == %d\n", tor->info.name, direction, isEnabled );
    210211    return isEnabled;
    211212}
    212213
    … … torrentRealInit( tr_handle * h, 
    533534
    534535    tr_peerMgrAddTorrent( h->peerMgr, tor );
    535536
    536     if( !h->isPortSet )
    537         tr_sessionSetPeerPort( h, TR_DEFAULT_PORT );
     537    assert( h->isPortSet );
    538538
    539539    assert( !tor->downloadedCur );
    540540    assert( !tor->uploadedCur );

  • gtk/msgwin.c

    level_combo_changed_cb( GtkWidget * w, 
    6868        gtk_tree_model_get( m, &iter, 1, &level, -1 );
    6969
    7070        tr_setMessageLevel( level );
    71         tr_core_set_pref_int( data->core, PREF_KEY_MSGLEVEL, level );
     71        tr_core_set_pref_int( data->core, TR_PREFS_KEY_MSGLEVEL, level );
    7272        data->maxLevel = level;
    7373        gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( data->filter ) );
    7474    }
    … … debug_level_combo_new( void ) 
    405405
    406406    store = gtk_list_store_new ( 2, G_TYPE_STRING, G_TYPE_INT );
    407407
    408     curlevel = pref_int_get( PREF_KEY_MSGLEVEL );
     408    curlevel = pref_int_get( TR_PREFS_KEY_MSGLEVEL );
    409409    for( i = ii = 0; i < G_N_ELEMENTS( trLevels ); ++i )
    410410    {
    411411        GtkTreeIter iter;
    … … msgwin_new( TrCore * core ) 
    519519    gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE( data->sort ),
    520520                                          COL_SEQUENCE,
    521521                                          GTK_SORT_ASCENDING );
    522     data->maxLevel = pref_int_get( PREF_KEY_MSGLEVEL );
     522    data->maxLevel = pref_int_get( TR_PREFS_KEY_MSGLEVEL );
    523523    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( data->
    524524                                                                   filter ),
    525525                                            isRowVisible, data, NULL );

  • gtk/conf.c

     
    4141#include "conf.h"
    4242#include "util.h"
    4343
     44#define MY_NAME "transmission"
     45
    4446static char * gl_confdir = NULL;
    4547static char * gl_lockpath = NULL;
    4648
    4749/* errstr may be NULL, this might be called before GTK is initialized */
    4850gboolean
    49 cf_init( const char *dir,
    50          char **    errstr )
     51cf_init( const char   * configDir,
     52         char        ** errstr )
    5153{
    5254    if( errstr != NULL )
    5355        *errstr = NULL;
    5456
    55     gl_confdir = g_strdup( dir );
     57    gl_confdir = g_strdup( configDir );
    5658
    5759    if( mkdir_p( gl_confdir, 0755 ) )
    5860        return TRUE;
    … … getPrefsFilename( void ) 
    151153static tr_benc*
    152154getPrefs( void )
    153155{
    154     static tr_benc  dict;
     156    static tr_benc settings;
    155157    static gboolean loaded = FALSE;
    156158
    157159    if( !loaded )
    158160    {
    159         char * filename = getPrefsFilename( );
    160         if( tr_bencLoadJSONFile( filename, &dict ) )
    161             tr_bencInitDict( &dict, 100 );
    162         g_free( filename );
     161        tr_bencInitDict( &settings, 0 );
     162        tr_sessionLoadSettings( &settings, gl_confdir, MY_NAME );
    163163        loaded = TRUE;
    164164    }
    165165
    166     return &dict;
     166    return &settings;
    167167}
    168168
    169169/***
    170170****
    171171***/
    172172
     173tr_benc*
     174pref_get_all( void )
     175{
     176    return getPrefs( );
     177}
     178
    173179int64_t
    174180pref_int_get( const char * key )
    175181{
    … … pref_string_set_default( const char * ke 
    277283***/
    278284
    279285void
    280 pref_save( void )
     286pref_save( tr_session * session )
    281287{
    282     char * filename = getPrefsFilename( );
    283     char * path = g_path_get_dirname( filename );
    284 
    285     mkdir_p( path, 0755 );
    286     tr_bencSaveJSONFile( filename, getPrefs( ) );
    287 
    288     g_free( path );
    289     g_free( filename );
     288    tr_sessionSaveSettings( session, gl_confdir, getPrefs( ) );
    290289}
    291290
    292291/***
    … … static char* 
    316315getCompat080PrefsFilename( void )
    317316{
    318317    assert( gl_confdir != NULL );
    319     return g_build_filename(
    320               g_get_home_dir( ), ".transmission", "gtk", "prefs", NULL );
     318
     319    return g_build_filename( g_get_home_dir( ), ".transmission", "gtk", "prefs", NULL );
    321320}
    322321
    323322static char*
    324323getCompat090PrefsFilename( void )
    325324{
    326325    assert( gl_confdir != NULL );
    327     return g_build_filename(
    328               g_get_home_dir( ), ".transmission", "gtk", "prefs.ini", NULL );
     326
     327    return g_build_filename( g_get_home_dir( ), ".transmission", "gtk", "prefs.ini", NULL );
    329328}
    330329
    331330static char*
    332331getCompat121PrefsFilename( void )
    333332{
    334     return g_build_filename(
    335                g_get_user_config_dir( ), "transmission", "gtk", "prefs.ini",
    336                NULL );
     333    return g_build_filename( g_get_user_config_dir( ), "transmission", "gtk", "prefs.ini", NULL );
    337334}
    338335
    339336static void
    340337translate_08_to_09( const char* oldfile,
    341338                    const char* newfile )
    342339{
    343     static struct pref_entry
    344     {
     340    static struct pref_entry {
    345341        const char*   oldkey;
    346342        const char*   newkey;
    347343    } pref_table[] = {

  • gtk/conf.h

     
    2222 * DEALINGS IN THE SOFTWARE.
    2323 *****************************************************************************/
    2424
     25struct tr_benc;
     26struct tr_handle;
     27
    2528/**
    2629***
    2730**/
    … …  
    2932#ifndef TG_CONF_H
    3033#define TG_CONF_H
    3134
    32 int64_t     pref_int_get( const char * key );
    33 
    34 void        pref_int_set( const char * key,
    35                           int64_t      value );
    36 
    37 void        pref_int_set_default( const char * key,
    38                                   int64_t      value );
    39 
    40 gboolean    pref_flag_get( const char * key );
    41 
    42 void        pref_flag_set( const char * key,
    43                            gboolean     value );
    44 
    45 void        pref_flag_set_default( const char * key,
    46                                    gboolean     value );
    47 
    48 const char* pref_string_get( const char * key );
    49 
    50 void        pref_string_set( const char * key,
    51                              const char * value );
    52 
    53 void        pref_string_set_default( const char * key,
    54                                      const char * value );
     35int64_t          pref_int_get           ( const char * key );
     36void             pref_int_set           ( const char * key, int64_t value );
     37void             pref_int_set_default   ( const char * key, int64_t value );
     38
     39gboolean         pref_flag_get          ( const char * key );
     40void             pref_flag_set          ( const char * key, gboolean value );
     41void             pref_flag_set_default  ( const char * key, gboolean value );
     42
     43const char*      pref_string_get        ( const char * key );
     44void             pref_string_set        ( const char * key, const char * value );
     45void             pref_string_set_default( const char * key, const char * value );
    5546
    56 void        pref_save( void );
     47void             pref_save              ( struct tr_handle * );
     48struct tr_benc*  pref_get_all           ( void );
    5749
    5850/**
    5951***

  • gtk/tr-prefs.c

     
    3535void
    3636tr_prefs_init_global( void )
    3737{
    38     int          i;
    39     char         pw[32];
    4038    const char * str;
    41     const char * pool = "abcdefghijklmnopqrstuvwxyz"
    42                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    43                         "1234567890";
    44     GRand *      rand;
    4539
    4640    cf_check_older_configs( );
    4741
    … … tr_prefs_init_global( void ) 
    5347    pref_flag_set_default   ( PREF_KEY_DIR_WATCH_ENABLED, FALSE );
    5448#endif
    5549
    56     pref_int_set_default    ( PREF_KEY_PEER_SOCKET_TOS,
    57                               TR_DEFAULT_PEER_SOCKET_TOS );
    5850    pref_flag_set_default   ( PREF_KEY_INHIBIT_HIBERNATION, FALSE );
    59     pref_flag_set_default   ( PREF_KEY_BLOCKLIST_ENABLED, TRUE );
    6051    pref_flag_set_default   ( PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
    6152
    6253    pref_string_set_default ( PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
    6354
    64     pref_int_set_default    ( PREF_KEY_MAX_PEERS_GLOBAL,
    65                               TR_DEFAULT_GLOBAL_PEER_LIMIT );
    66     pref_int_set_default    ( PREF_KEY_MAX_PEERS_PER_TORRENT, 50 );
    67 
    6855    pref_flag_set_default   ( PREF_KEY_TOOLBAR, TRUE );
    6956    pref_flag_set_default   ( PREF_KEY_FILTERBAR, TRUE );
    7057    pref_flag_set_default   ( PREF_KEY_STATUSBAR, TRUE );
    7158    pref_flag_set_default   ( PREF_KEY_SHOW_TRAY_ICON, FALSE );
    7259    pref_string_set_default ( PREF_KEY_STATUSBAR_STATS, "total-ratio" );
    7360
    74     pref_flag_set_default   ( PREF_KEY_DL_LIMIT_ENABLED, FALSE );
    75     pref_int_set_default    ( PREF_KEY_DL_LIMIT, 100 );
    76     pref_flag_set_default   ( PREF_KEY_UL_LIMIT_ENABLED, FALSE );
    77     pref_int_set_default    ( PREF_KEY_UL_LIMIT, 50 );
    7861    pref_flag_set_default   ( PREF_KEY_SCHED_LIMIT_ENABLED, FALSE );
    7962    pref_int_set_default    ( PREF_KEY_SCHED_BEGIN,    60 * 23 ); /* 11pm */
    8063    pref_int_set_default    ( PREF_KEY_SCHED_END,      60 * 7 );  /* 7am */
    81     pref_int_set_default    ( PREF_KEY_SCHED_DL_LIMIT, 200 );   /* 2x the other
    82                                                                   limit */
    83     pref_int_set_default    ( PREF_KEY_SCHED_UL_LIMIT, 100 );   /* 2x the other
    84                                                                   limit */
     64    pref_int_set_default    ( PREF_KEY_SCHED_DL_LIMIT, 200 );   /* 2x the other limit */
     65    pref_int_set_default    ( PREF_KEY_SCHED_UL_LIMIT, 100 );   /* 2x the other limit */
    8566
    8667    pref_flag_set_default   ( PREF_KEY_OPTIONS_PROMPT, TRUE );
    8768
    … … tr_prefs_init_global( void ) 
    9071    pref_int_set_default    ( PREF_KEY_MAIN_WINDOW_X, 50 );
    9172    pref_int_set_default    ( PREF_KEY_MAIN_WINDOW_Y, 50 );
    9273
    93     pref_string_set_default ( PREF_KEY_PROXY_SERVER, "" );
    94     pref_int_set_default    ( PREF_KEY_PROXY_PORT, TR_DEFAULT_PROXY_PORT );
    95     pref_int_set_default    ( PREF_KEY_PROXY_TYPE, TR_DEFAULT_PROXY_TYPE );
    96     pref_flag_set_default   ( PREF_KEY_PROXY_SERVER_ENABLED,
    97                               TR_DEFAULT_PROXY_ENABLED );
    98     pref_flag_set_default   ( PREF_KEY_PROXY_AUTH_ENABLED,
    99                               TR_DEFAULT_PROXY_AUTH_ENABLED );
    100     pref_string_set_default ( PREF_KEY_PROXY_USERNAME, "" );
    101     pref_string_set_default ( PREF_KEY_PROXY_PASSWORD, "" );
    102 
    10374    str = NULL;
    10475#if GLIB_CHECK_VERSION( 2, 14, 0 )
    10576    if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
    10677#endif
    10778    if( !str ) str = g_get_home_dir( );
    108     pref_string_set_default ( PREF_KEY_DOWNLOAD_DIR, str );
     79    pref_string_set_default ( TR_PREFS_KEY_DOWNLOAD_DIR, str );
    10980
    110     pref_int_set_default    ( PREF_KEY_PORT, TR_DEFAULT_PORT );
    111 
    112     pref_flag_set_default   ( PREF_KEY_PORT_FORWARDING, TRUE );
    113     pref_flag_set_default   ( PREF_KEY_PEX, TR_DEFAULT_PEX_ENABLED );
    11481    pref_flag_set_default   ( PREF_KEY_ASKQUIT, TRUE );
    115     pref_flag_set_default   ( PREF_KEY_ENCRYPTION, TR_DEFAULT_ENCRYPTION );
    116     pref_flag_set_default   ( PREF_KEY_LAZY_BITFIELD,
    117                               TR_DEFAULT_LAZY_BITFIELD_ENABLED );
    118 
    119     pref_int_set_default    ( PREF_KEY_MSGLEVEL, TR_MSG_INF );
    12082
    12183    pref_string_set_default ( PREF_KEY_SORT_MODE, "sort-by-name" );
    12284    pref_flag_set_default   ( PREF_KEY_SORT_REVERSED, FALSE );
    … … tr_prefs_init_global( void ) 
    12486
    12587    pref_flag_set_default   ( PREF_KEY_START, TRUE );
    12688    pref_flag_set_default   ( PREF_KEY_TRASH_ORIGINAL, FALSE );
    127 
    128     pref_flag_set_default   ( PREF_KEY_RPC_ENABLED, TR_DEFAULT_RPC_ENABLED );
    129     pref_int_set_default    ( PREF_KEY_RPC_PORT, TR_DEFAULT_RPC_PORT );
    130     pref_string_set_default ( PREF_KEY_RPC_WHITELIST, TR_DEFAULT_RPC_WHITELIST );
    131     pref_flag_set_default   ( PREF_KEY_RPC_WHITELIST_ENABLED,
    132                               TR_DEFAULT_RPC_WHITELIST_ENABLED  );
    133 
    134     rand = g_rand_new ( );
    135     for( i = 0; i < 16; ++i )
    136         pw[i] = pool[g_rand_int_range ( rand, 0, strlen( pool ) )];
    137     g_rand_free ( rand );
    138 
    139     pw[16] = '\0';
    140     pref_string_set_default( PREF_KEY_RPC_USERNAME, "transmission" );
    141     pref_string_set_default( PREF_KEY_RPC_PASSWORD, pw );
    142     pref_flag_set_default  ( PREF_KEY_RPC_AUTH_ENABLED, FALSE );
    143 
    144     pref_save( );
    14589}
    14690
    14791/**
    … … torrentPage( GObject * core ) 
    375319    w = new_check_button( s, PREF_KEY_TRASH_ORIGINAL, core );
    376320    hig_workarea_add_wide_control( t, &row, w );
    377321
    378     w = new_path_chooser_button( PREF_KEY_DOWNLOAD_DIR, core );
     322    w = new_path_chooser_button( TR_PREFS_KEY_DOWNLOAD_DIR, core );
    379323    hig_workarea_add_row( t, &row, _( "_Destination folder:" ), w, NULL );
    380324
    381325    hig_workarea_finish( t, &row );
    … … onEncryptionToggled( GtkToggleButton * w 
    510454                    ? TR_ENCRYPTION_REQUIRED
    511455                    : TR_ENCRYPTION_PREFERRED;
    512456
    513     tr_core_set_pref_int( TR_CORE( core ), PREF_KEY_ENCRYPTION, val );
     457    tr_core_set_pref_int( TR_CORE( core ), TR_PREFS_KEY_ENCRYPTION, val );
    514458}
    515459
    516460static GtkWidget*
    … … peerPage( GObject * core ) 
    530474    t = hig_workarea_create( );
    531475    hig_workarea_add_section_title( t, &row, _( "Blocklist" ) );
    532476
    533     w = new_check_button( "", PREF_KEY_BLOCKLIST_ENABLED, core );
     477    w = new_check_button( "", TR_PREFS_KEY_BLOCKLIST_ENABLED, core );
    534478    updateBlocklistText( w, TR_CORE( core ) );
    535479    h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
    536480    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
    … … peerPage( GObject * core ) 
    553497    hig_workarea_add_section_divider( t, &row );
    554498    hig_workarea_add_section_title( t, &row, _( "Limits" ) );
    555499
    556     w = new_spin_button( PREF_KEY_MAX_PEERS_GLOBAL, core, 1, 3000, 5 );
     500    w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_GLOBAL, core, 1, 3000, 5 );
    557501    hig_workarea_add_row( t, &row, _( "Maximum peers _overall:" ), w, NULL );
    558     w = new_spin_button( PREF_KEY_MAX_PEERS_PER_TORRENT, core, 1, 300, 5 );
    559     hig_workarea_add_row( t, &row, _(
    560                               "Maximum peers per _torrent:" ), w, NULL );
     502    w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_TORRENT, core, 1, 300, 5 );
     503    hig_workarea_add_row( t, &row, _( "Maximum peers per _torrent:" ), w, NULL );
    561504
    562505    hig_workarea_add_section_divider( t, &row );
    563506    hig_workarea_add_section_title ( t, &row, _( "Options" ) );
    … … peerPage( GObject * core ) 
    565508    s = _( "_Ignore unencrypted peers" );
    566509    w = gtk_check_button_new_with_mnemonic( s );
    567510    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ),
    568                                   pref_int_get(
    569                                       PREF_KEY_ENCRYPTION ) ==
     511                                  pref_int_get( TR_PREFS_KEY_ENCRYPTION ) ==
    570512                                  TR_ENCRYPTION_REQUIRED );
    571513    g_signal_connect( w, "toggled", G_CALLBACK( onEncryptionToggled ), core );
    572514    hig_workarea_add_wide_control( t, &row, w );
    573515
    574516    s = _( "Use peer e_xchange" );
    575     w = new_check_button( s, PREF_KEY_PEX, core );
     517    w = new_check_button( s, TR_PREFS_KEY_PEX_ENABLED, core );
    576518    hig_workarea_add_wide_control( t, &row, w );
    577519
    578520    hig_workarea_finish( t, &row );
    … … refreshWhitelist( struct remote_page * p 
    648590
    649591    g_string_truncate( gstr, gstr->len - 1 ); /* remove the trailing comma */
    650592
    651     tr_core_set_pref( page->core, PREF_KEY_RPC_WHITELIST, gstr->str );
     593    tr_core_set_pref( page->core, TR_PREFS_KEY_RPC_WHITELIST, gstr->str );
    652594
    653595    g_string_free( gstr, TRUE );
    654596}
    … … static void 
    757699onLaunchClutchCB( GtkButton * w UNUSED,
    758700                  gpointer data UNUSED )
    759701{
    760     int    port = pref_int_get( PREF_KEY_RPC_PORT );
     702    int    port = pref_int_get( TR_PREFS_KEY_RPC_PORT );
    761703    char * url = g_strdup_printf( "http://localhost:%d/transmission/web",
    762704                                  port );
    763705
    … … webPage( GObject * core ) 
    784726
    785727    /* "enabled" checkbutton */
    786728    s = _( "_Enable web interface" );
    787     w = new_check_button( s, PREF_KEY_RPC_ENABLED, core );
     729    w = new_check_button( s, TR_PREFS_KEY_RPC_ENABLED, core );
    788730    page->rpc_tb = GTK_TOGGLE_BUTTON( w );
    789731    g_signal_connect( w, "clicked", G_CALLBACK( onRPCToggled ), page );
    790732    h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
    … … webPage( GObject * core ) 
    796738    hig_workarea_add_wide_control( t, &row, h );
    797739
    798740    /* port */
    799     w = new_spin_button( PREF_KEY_RPC_PORT, core, 0, 65535, 1 );
     741    w = new_spin_button( TR_PREFS_KEY_RPC_PORT, core, 0, 65535, 1 );
    800742    page->widgets = g_slist_append( page->widgets, w );
    801743    w = hig_workarea_add_row( t, &row, _( "Listening _port:" ), w, NULL );
    802744    page->widgets = g_slist_append( page->widgets, w );
    803745
    804746    /* require authentication */
    805747    s = _( "_Require username" );
    806     w = new_check_button( s, PREF_KEY_RPC_AUTH_ENABLED, core );
     748    w = new_check_button( s, TR_PREFS_KEY_RPC_AUTH_REQUIRED, core );
    807749    hig_workarea_add_wide_control( t, &row, w );
    808750    page->auth_tb = GTK_TOGGLE_BUTTON( w );
    809751    page->widgets = g_slist_append( page->widgets, w );
    … … webPage( GObject * core ) 
    811753
    812754    /* username */
    813755    s = _( "_Username:" );
    814     w = new_entry( PREF_KEY_RPC_USERNAME, core );
     756    w = new_entry( TR_PREFS_KEY_RPC_USERNAME, core );
    815757    page->auth_widgets = g_slist_append( page->auth_widgets, w );
    816758    w = hig_workarea_add_row( t, &row, s, w, NULL );
    817759    page->auth_widgets = g_slist_append( page->auth_widgets, w );
    818760
    819761    /* password */
    820762    s = _( "Pass_word:" );
    821     w = new_entry( PREF_KEY_RPC_PASSWORD, core );
     763    w = new_entry( TR_PREFS_KEY_RPC_PASSWORD, core );
    822764    gtk_entry_set_visibility( GTK_ENTRY( w ), FALSE );
    823765    page->auth_widgets = g_slist_append( page->auth_widgets, w );
    824766    w = hig_workarea_add_row( t, &row, s, w, NULL );
    … … webPage( GObject * core ) 
    826768
    827769    /* require authentication */
    828770    s = _( "Only allow the following IP _addresses to connect:" );
    829     w = new_check_button( s, PREF_KEY_RPC_WHITELIST_ENABLED, core );
     771    w = new_check_button( s, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, core );
    830772    hig_workarea_add_wide_control( t, &row, w );
    831773    page->whitelist_tb = GTK_TOGGLE_BUTTON( w );
    832774    page->widgets = g_slist_append( page->widgets, w );
    … … webPage( GObject * core ) 
    834776
    835777    /* access control list */
    836778    {
    837         const char *        val = pref_string_get( PREF_KEY_RPC_WHITELIST );
     779        const char *        val = pref_string_get( TR_PREFS_KEY_RPC_WHITELIST );
    838780        GtkTreeModel *      m = whitelist_tree_model_new( val );
    839781        GtkTreeViewColumn * c;
    840782        GtkCellRenderer *   r;
    … … static void 
    919861refreshProxySensitivity( struct ProxyPage * p )
    920862{
    921863    GSList *       l;
    922     const gboolean proxy_enabled = pref_flag_get(
    923         PREF_KEY_PROXY_SERVER_ENABLED );
    924     const gboolean proxy_auth_enabled = pref_flag_get(
    925         PREF_KEY_PROXY_AUTH_ENABLED );
     864    const gboolean proxy_enabled = pref_flag_get( TR_PREFS_KEY_PROXY_ENABLED );
     865    const gboolean proxy_auth_enabled = pref_flag_get( TR_PREFS_KEY_PROXY_AUTH_ENABLED );
    926866
    927867    for( l = p->proxy_widgets; l != NULL; l = l->next )
    928868        gtk_widget_set_sensitive( GTK_WIDGET( l->data ), proxy_enabled );
    … … onProxyTypeChanged( GtkComboBox * w, 
    973913    if( gtk_combo_box_get_active_iter( w, &iter ) )
    974914    {
    975915        struct ProxyPage * page = gpage;
    976         int                type = TR_PROXY_HTTP;
    977         gtk_tree_model_get( gtk_combo_box_get_model(
    978                                 w ), &iter, 1, &type, -1 );
    979         tr_core_set_pref_int( TR_CORE(
    980                                   page->core ), PREF_KEY_PROXY_TYPE, type );
     916        int type = TR_PROXY_HTTP;
     917        gtk_tree_model_get( gtk_combo_box_get_model( w ), &iter, 1, &type, -1 );
     918        tr_core_set_pref_int( TR_CORE( page->core ), TR_PREFS_KEY_PROXY_TYPE, type );
    981919    }
    982920}
    983921
    … … trackerPage( GObject * core ) 
    998936    hig_workarea_add_section_title ( t, &row, _( "Tracker Proxy" ) );
    999937
    1000938    s = _( "Connect to tracker via a pro_xy" );
    1001     w = new_check_button( s, PREF_KEY_PROXY_SERVER_ENABLED, core );
     939    w = new_check_button( s, TR_PREFS_KEY_PROXY_ENABLED, core );
    1002940    g_signal_connect( w, "toggled", G_CALLBACK( onProxyToggled ), page );
    1003941    hig_workarea_add_wide_control( t, &row, w );
    1004942
    1005943    s = _( "Proxy _server:" );
    1006     w = new_entry( PREF_KEY_PROXY_SERVER, core );
     944    w = new_entry( TR_PREFS_KEY_PROXY, core );
    1007945    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    1008946    w = hig_workarea_add_row( t, &row, s, w, NULL );
    1009947    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    1010948
    1011     w = new_spin_button( PREF_KEY_PROXY_PORT, core, 0, 65535, 1 );
     949    w = new_spin_button( TR_PREFS_KEY_PROXY_PORT, core, 0, 65535, 1 );
    1012950    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    1013951    w = hig_workarea_add_row( t, &row, _( "Proxy _port:" ), w, NULL );
    1014952    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    … … trackerPage( GObject * core ) 
    1018956    w = gtk_combo_box_new_with_model( m );
    1019957    r = gtk_cell_renderer_text_new( );
    1020958    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( w ), r, TRUE );
    1021     gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(
    1022                                         w ), r, "text", 0, NULL );
    1023     gtk_combo_box_set_active( GTK_COMBO_BOX( w ),
    1024                              pref_int_get( PREF_KEY_PROXY_TYPE ) );
     959    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( w ), r, "text", 0, NULL );
     960    gtk_combo_box_set_active( GTK_COMBO_BOX( w ), pref_int_get( TR_PREFS_KEY_PROXY_TYPE ) );
    1025961    g_signal_connect( w, "changed", G_CALLBACK( onProxyTypeChanged ), page );
    1026962    g_object_unref( G_OBJECT( m ) );
    1027963    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    … … trackerPage( GObject * core ) 
    1029965    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    1030966
    1031967    s = _( "_Authentication is required" );
    1032     w = new_check_button( s, PREF_KEY_PROXY_AUTH_ENABLED, core );
     968    w = new_check_button( s, TR_PREFS_KEY_PROXY_AUTH_ENABLED, core );
    1033969    g_signal_connect( w, "toggled", G_CALLBACK( onProxyToggled ), page );
    1034970    hig_workarea_add_wide_control( t, &row, w );
    1035971    page->proxy_widgets = g_slist_append( page->proxy_widgets, w );
    1036972
    1037973    s = _( "_Username:" );
    1038     w = new_entry( PREF_KEY_PROXY_USERNAME, core );
     974    w = new_entry( TR_PREFS_KEY_PROXY_USERNAME, core );
    1039975    page->proxy_auth_widgets = g_slist_append( page->proxy_auth_widgets, w );
    1040976    w = hig_workarea_add_row( t, &row, s, w, NULL );
    1041977    page->proxy_auth_widgets = g_slist_append( page->proxy_auth_widgets, w );
    1042978
    1043979    s = _( "Pass_word:" );
    1044     w = new_entry( PREF_KEY_PROXY_PASSWORD, core );
     980    w = new_entry( TR_PREFS_KEY_RPC_PASSWORD, core );
    1045981    gtk_entry_set_visibility( GTK_ENTRY( w ), FALSE );
    1046982    page->proxy_auth_widgets = g_slist_append( page->proxy_auth_widgets, w );
    1047983    w = hig_workarea_add_row( t, &row, s, w, NULL );
    … … bandwidthPage( GObject * core ) 
    11651101    hig_workarea_add_section_title( t, &row, _( "Limits" ) );
    11661102
    11671103    s = _( "Limit _download speed (KB/s):" );
    1168     w = new_check_button( s, PREF_KEY_DL_LIMIT_ENABLED, core );
    1169     w2 = new_spin_button( PREF_KEY_DL_LIMIT, core, 0, INT_MAX, 5 );
    1170     gtk_widget_set_sensitive( GTK_WIDGET( w2 ),
    1171                              pref_flag_get( PREF_KEY_DL_LIMIT_ENABLED ) );
     1104    w = new_check_button( s, TR_PREFS_KEY_DSPEED_ENABLED, core );
     1105    w2 = new_spin_button( TR_PREFS_KEY_DSPEED, core, 0, INT_MAX, 5 );
     1106    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
    11721107    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    11731108    hig_workarea_add_row_w( t, &row, w, w2, NULL );
    11741109
    11751110    s = _( "Limit _upload speed (KB/s):" );
    1176     w = new_check_button( s, PREF_KEY_UL_LIMIT_ENABLED, core );
    1177     w2 = new_spin_button( PREF_KEY_UL_LIMIT, core, 0, INT_MAX, 5 );
    1178     gtk_widget_set_sensitive( GTK_WIDGET( w2 ),
    1179                              pref_flag_get( PREF_KEY_UL_LIMIT_ENABLED ) );
     1111    w = new_check_button( s, TR_PREFS_KEY_USPEED_ENABLED, core );
     1112    w2 = new_spin_button( TR_PREFS_KEY_USPEED, core, 0, INT_MAX, 5 );
     1113    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
    11801114    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    11811115    hig_workarea_add_row_w( t, &row, w, w2, NULL );
    11821116
    … … bandwidthPage( GObject * core ) 
    12011135
    12021136    w = new_spin_button( PREF_KEY_SCHED_DL_LIMIT, core, 0, INT_MAX, 5 );
    12031137    page->sched_widgets = g_slist_append( page->sched_widgets, w );
    1204     l = hig_workarea_add_row( t, &row, _(
    1205                                   "Limit d_ownload speed (KB/s):" ), w,
    1206                               NULL );
     1138    l = hig_workarea_add_row( t, &row, _( "Limit d_ownload speed (KB/s):" ), w, NULL );
    12071139    page->sched_widgets = g_slist_append( page->sched_widgets, l );
    12081140
    12091141    w = new_spin_button( PREF_KEY_SCHED_UL_LIMIT, core, 0, INT_MAX, 5 );
    12101142    page->sched_widgets = g_slist_append( page->sched_widgets, w );
    1211     l = hig_workarea_add_row( t, &row, _(
    1212                                   "Limit u_pload speed (KB/s):" ), w, NULL );
     1143    l = hig_workarea_add_row( t, &row, _( "Limit u_pload speed (KB/s):" ), w, NULL );
    12131144    page->sched_widgets = g_slist_append( page->sched_widgets, l );
    12141145
    12151146    hig_workarea_finish( t, &row );
    … … onCorePrefsChanged( TrCore * core UNUSED 
    12991230                    const char *  key,
    13001231                    gpointer      gdata )
    13011232{
    1302     if( !strcmp( key, PREF_KEY_PORT ) )
     1233    if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
    13031234    {
    13041235        struct network_page_data * ndata = gdata;
    13051236        struct test_port_data *    data;
    … … networkPage( GObject * core ) 
    13541285    hig_workarea_add_section_title( t, &row, _( "Incoming Peers" ) );
    13551286
    13561287    h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
    1357     w2 = new_spin_button( PREF_KEY_PORT, core, 1, 65535, 1 );
     1288    w2 = new_spin_button( TR_PREFS_KEY_PEER_PORT, core, 1, 65535, 1 );
    13581289    gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
    13591290    data->label = l = gtk_label_new( NULL );
    13601291    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
    … … networkPage( GObject * core ) 
    13641295    g_object_set_data( G_OBJECT( l ), "tr-port-spin", w2 );
    13651296    g_object_set_data( G_OBJECT( l ), "session",
    13661297                      tr_core_session( TR_CORE( core ) ) );
    1367     data->id = g_signal_connect( TR_CORE(
    1368                                      core ), "prefs-changed",
     1298    data->id = g_signal_connect( TR_CORE( core ), "prefs-changed",
    13691299                                 G_CALLBACK( onCorePrefsChanged ), data );
    1370     onCorePrefsChanged( NULL, PREF_KEY_PORT, data );
     1300    onCorePrefsChanged( NULL, TR_PREFS_KEY_PEER_PORT, data );
    13711301
    13721302    s = _( "Use UPnP or NAT-PMP port _forwarding from my router" );
    1373     w = new_check_button( s, PREF_KEY_PORT_FORWARDING, core );
     1303    w = new_check_button( s, TR_PREFS_KEY_PORT_FORWARDING, core );
    13741304    hig_workarea_add_wide_control( t, &row, w );
    13751305
    13761306    hig_workarea_finish( t, &row );

  • gtk/tr-prefs.h

    GtkWidget * tr_prefs_dialog_new( GObject 
    2121/* if you add a key here,  you /must/ add its
    2222 * default in tr_prefs_init_global( void ) */
    2323
    24 #define PREF_KEY_DL_LIMIT_ENABLED       "download-limit-enabled"
    25 #define PREF_KEY_DL_LIMIT               "download-limit"
    26 #define PREF_KEY_UL_LIMIT_ENABLED       "upload-limit-enabled"
    27 #define PREF_KEY_UL_LIMIT               "upload-limit"
    2824#define PREF_KEY_SCHED_LIMIT_ENABLED    "sched-limit-enabled"
    2925#define PREF_KEY_SCHED_BEGIN            "sched-begin"
    3026#define PREF_KEY_SCHED_END              "sched-end"
    3127#define PREF_KEY_SCHED_DL_LIMIT         "sched-download-limit"
    3228#define PREF_KEY_SCHED_UL_LIMIT         "sched-upload-limit"
    3329#define PREF_KEY_OPTIONS_PROMPT         "show-options-window"
    34 #define PREF_KEY_DOWNLOAD_DIR           "download-dir"
    3530#define PREF_KEY_OPEN_DIALOG_FOLDER     "open-dialog-dir"
    3631#define PREF_KEY_INHIBIT_HIBERNATION    "inhibit-desktop-hibernation"
    3732#define PREF_KEY_DIR_WATCH              "watch-dir"
    … … GtkWidget * tr_prefs_dialog_new( GObject 
    3934#define PREF_KEY_SHOW_TRAY_ICON         "show-notification-area-icon"
    4035#define PREF_KEY_START                  "start-added-torrents"
    4136#define PREF_KEY_TRASH_ORIGINAL         "trash-original-torrent-files"
    42 #define PREF_KEY_PEER_SOCKET_TOS        "peer-socket-tos"
    43 #define PREF_KEY_PORT                   "peer-port"
    44 #define PREF_KEY_PORT_FORWARDING        "port-forwarding-enabled"
    45 #define PREF_KEY_PEX                    "pex-enabled"
    4637#define PREF_KEY_ASKQUIT                "prompt-before-exit"
    47 #define PREF_KEY_ENCRYPTION             "encryption"
    48 #define PREF_KEY_MSGLEVEL               "debug-message-level"
    49 #define PREF_KEY_LAZY_BITFIELD          "lazy-bitfield-enabled"
    5038#define PREF_KEY_SORT_MODE              "sort-mode"
    5139#define PREF_KEY_SORT_REVERSED          "sort-reversed"
    5240#define PREF_KEY_MINIMAL_VIEW           "minimal-view"
    … … GtkWidget * tr_prefs_dialog_new( GObject 
    5442#define PREF_KEY_STATUSBAR              "show-statusbar"
    5543#define PREF_KEY_STATUSBAR_STATS        "statusbar-stats"
    5644#define PREF_KEY_TOOLBAR                "show-toolbar"
    57 #define PREF_KEY_MAX_PEERS_GLOBAL       "max-peers-global"
    58 #define PREF_KEY_MAX_PEERS_PER_TORRENT  "max-peers-per-torrent"
    59 #define PREF_KEY_BLOCKLIST_ENABLED      "blocklist-enabled"
    6045#define PREF_KEY_BLOCKLIST_UPDATES_ENABLED  "blocklist-updates-enabled"
    6146#define PREF_KEY_MAIN_WINDOW_HEIGHT     "main-window-height"
    6247#define PREF_KEY_MAIN_WINDOW_WIDTH      "main-window-width"
    6348#define PREF_KEY_MAIN_WINDOW_X          "main-window-x"
    6449#define PREF_KEY_MAIN_WINDOW_Y          "main-window-y"
    65 #define PREF_KEY_RPC_PORT               "rpc-port"
    66 #define PREF_KEY_RPC_ENABLED            "rpc-enabled"
    67 #define PREF_KEY_RPC_WHITELIST          "rpc-whitelist"
    68 #define PREF_KEY_RPC_WHITELIST_ENABLED  "rpc-whitelist-enabled"
    69 #define PREF_KEY_RPC_AUTH_ENABLED       "rpc-authentication-required"
    70 #define PREF_KEY_RPC_PASSWORD           "rpc-password"
    71 #define PREF_KEY_RPC_USERNAME           "rpc-username"
    72 #define PREF_KEY_PROXY_SERVER           "proxy-server"
    73 #define PREF_KEY_PROXY_PORT             "proxy-port"
    74 #define PREF_KEY_PROXY_SERVER_ENABLED   "proxy-server-enabled"
    75 #define PREF_KEY_PROXY_TYPE             "proxy-type"
    76 #define PREF_KEY_PROXY_AUTH_ENABLED     "proxy-authentication-required"
    77 #define PREF_KEY_PROXY_USERNAME         "proxy-username"
    78 #define PREF_KEY_PROXY_PASSWORD         "proxy-authentication"
    7950
    8051
    8152void tr_prefs_init_global( void );

  • gtk/tr-core.c

    tr_core_dispose( GObject * obj ) 
    163163    {
    164164        GObjectClass * parent;
    165165
    166         pref_save( );
    167166        core->priv = NULL;
    168167
    169168        parent = g_type_class_peek( g_type_parent( TR_CORE_TYPE ) );
    … … tr_core_apply_defaults( tr_ctor * ctor ) 
    449448
    450449    if( tr_ctorGetPeerLimit( ctor, TR_FORCE, NULL ) )
    451450        tr_ctorSetPeerLimit( ctor, TR_FORCE,
    452                             pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
     451                             pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
    453452
    454453    if( tr_ctorGetDownloadDir( ctor, TR_FORCE, NULL ) )
    455454    {
    456         const char * path = pref_string_get( PREF_KEY_DOWNLOAD_DIR );
     455        const char * path = pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR );
    457456        tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
    458457    }
    459458}
    … … prefsChanged( TrCore * core, 
    584583        gboolean     isReversed = pref_flag_get( PREF_KEY_SORT_REVERSED );
    585584        setSort( core, mode, isReversed );
    586585    }
    587     else if( !strcmp( key, PREF_KEY_MAX_PEERS_GLOBAL ) )
     586    else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_GLOBAL ) )
    588587    {
    589588        const uint16_t val = pref_int_get( key );
    590589        tr_sessionSetPeerLimit( tr_core_session( core ), val );
    … … tr_core_new( tr_session * session ) 
    684683    prefsChanged( core, PREF_KEY_SORT_MODE, NULL );
    685684    prefsChanged( core, PREF_KEY_SORT_REVERSED, NULL );
    686685    prefsChanged( core, PREF_KEY_DIR_WATCH_ENABLED, NULL );
    687     prefsChanged( core, PREF_KEY_MAX_PEERS_GLOBAL, NULL );
     686    prefsChanged( core, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, NULL );
    688687    prefsChanged( core, PREF_KEY_INHIBIT_HIBERNATION, NULL );
    689     g_signal_connect( core, "prefs-changed", G_CALLBACK(
    690                           prefsChanged ), NULL );
     688    g_signal_connect( core, "prefs-changed", G_CALLBACK( prefsChanged ), NULL );
    691689
    692690    return core;
    693691}
    … … tr_core_close( TrCore * core ) 
    700698    if( session )
    701699    {
    702700        core->priv->session = NULL;
     701        pref_save( session );
    703702        tr_sessionClose( session );
    704703    }
    705704}
    … … tr_core_load( TrCore * self, 
    819818    if( forcePaused )
    820819        tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
    821820    tr_ctorSetPeerLimit( ctor, TR_FALLBACK,
    822                         pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
     821                         pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
    823822
    824823    torrents = tr_sessionLoadTorrents ( tr_core_session( self ), ctor, &count );
    825824    for( i = 0; i < count; ++i )
    … … static void 
    12251224commitPrefsChange( TrCore *     core,
    12261225                   const char * key )
    12271226{
    1228     pref_save( );
     1227    pref_save( tr_core_session( core ) );
    12291228    g_signal_emit( core, TR_CORE_GET_CLASS( core )->prefsig, 0, key );
    12301229}
    12311230

  • gtk/main.c

     
    6868#include <libtransmission/transmission.h>
    6969#include <libtransmission/version.h>
    7070
     71#define MY_NAME "transmission"
     72
    7173/* interval in milliseconds to update the torrent list display */
    7274#define UPDATE_INTERVAL         1666
    7375
    … … main( int argc, 
    352354    gboolean            showversion = FALSE;
    353355    gboolean            startpaused = FALSE;
    354356    gboolean            startminimized = FALSE;
    355     char *              domain = "transmission";
     357    char *              domain = MY_NAME;
    356358    char *              configDir = NULL;
    357359    tr_lockfile_state_t tr_state;
    358360
    … … main( int argc, 
    402404    }
    403405
    404406    if( configDir == NULL )
    405         configDir = (char*) tr_getDefaultConfigDir( );
     407        configDir = (char*) tr_getDefaultConfigDir( MY_NAME );
    406408
    407409    tr_notify_init( );
    408 
    409410    didinit = cf_init( configDir, NULL ); /* must come before actions_init */
    410411    tr_prefs_init_global( );
     412
    411413    myUIManager = gtk_ui_manager_new ( );
    412414    actions_init ( myUIManager, cbdata );
    413     gtk_ui_manager_add_ui_from_string ( myUIManager, fallback_ui_file, -1,
    414                                         NULL );
     415    gtk_ui_manager_add_ui_from_string ( myUIManager, fallback_ui_file, -1, NULL );
    415416    gtk_ui_manager_ensure_update ( myUIManager );
    416     gtk_window_set_default_icon_name ( "transmission" );
     417    gtk_window_set_default_icon_name ( MY_NAME );
    417418
    418419    setupsighandlers( ); /* set up handlers for fatal signals */
    419420
    … … main( int argc, 
    440441    if( didlock && ( didinit || cf_init( configDir, &err ) ) )
    441442    {
    442443        GtkWindow * win;
     444        tr_session * session;
    443445
    444         tr_session * h = tr_sessionInitFull(
    445             configDir,
    446             "gtk",
    447             pref_string_get( PREF_KEY_DOWNLOAD_DIR ),
    448             pref_flag_get( PREF_KEY_PEX ),
    449             pref_flag_get( PREF_KEY_PORT_FORWARDING ),
    450             pref_int_get( PREF_KEY_PORT ),
    451             pref_int_get( PREF_KEY_ENCRYPTION ),
    452             pref_flag_get( PREF_KEY_LAZY_BITFIELD ),
    453             pref_flag_get( PREF_KEY_UL_LIMIT_ENABLED ),
    454             pref_int_get( PREF_KEY_UL_LIMIT ),
    455             pref_flag_get( PREF_KEY_DL_LIMIT_ENABLED ),
    456             pref_int_get( PREF_KEY_DL_LIMIT ),
    457             pref_int_get( PREF_KEY_MAX_PEERS_GLOBAL ),
    458             pref_int_get( PREF_KEY_MSGLEVEL ),
    459             TRUE,                 /* message queueing */
    460             pref_flag_get( PREF_KEY_BLOCKLIST_ENABLED ),
    461             pref_int_get( PREF_KEY_PEER_SOCKET_TOS ),
    462             pref_flag_get( PREF_KEY_RPC_ENABLED ),
    463             pref_int_get( PREF_KEY_RPC_PORT ),
    464             pref_flag_get( PREF_KEY_RPC_WHITELIST_ENABLED ),
    465             pref_string_get( PREF_KEY_RPC_WHITELIST ),
    466             pref_flag_get( PREF_KEY_RPC_AUTH_ENABLED ),
    467             pref_string_get( PREF_KEY_RPC_USERNAME ),
    468             pref_string_get( PREF_KEY_RPC_PASSWORD ),
    469             pref_flag_get( PREF_KEY_PROXY_SERVER_ENABLED ),
    470             pref_string_get( PREF_KEY_PROXY_SERVER ),
    471             pref_int_get( PREF_KEY_PROXY_PORT ),
    472             pref_int_get( PREF_KEY_PROXY_TYPE ),
    473             pref_flag_get( PREF_KEY_PROXY_AUTH_ENABLED ),
    474             pref_string_get( PREF_KEY_PROXY_USERNAME ),
    475             pref_string_get( PREF_KEY_PROXY_PASSWORD ) );
    476 
    477         cbdata->core = tr_core_new( h );
     446        /* initialize the libtransmission session */
     447        session = tr_sessionInit( "gtk", configDir, TRUE, pref_get_all( ) );
     448        cbdata->core = tr_core_new( session );
    478449
    479450        /* create main window now to be a parent to any error dialogs */
    480451        win = GTK_WINDOW( tr_window_new( myUIManager, cbdata->core ) );
    481         g_signal_connect( win, "size-allocate",
    482                           G_CALLBACK( onMainWindowSizeAllocated ), cbdata );
     452        g_signal_connect( win, "size-allocate", G_CALLBACK( onMainWindowSizeAllocated ), cbdata );
    483453
    484454        appsetup( win, argfiles, cbdata, startpaused, startminimized );
    485         tr_sessionSetRPCCallback( h, onRPCChanged, cbdata );
     455        tr_sessionSetRPCCallback( session, onRPCChanged, cbdata );
    486456        gtr_blocklist_maybe_autoupdate( cbdata->core );
    487457
    488458        gtk_main( );
    … … updateScheduledLimits( gpointer data ) 
    555525
    556526            tr_inf ( _( "Ending use of scheduled bandwidth limits" ) );
    557527
    558             b = pref_flag_get( PREF_KEY_DL_LIMIT_ENABLED );
     528            b = pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
    559529            tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, b );
    560             limit = pref_int_get( PREF_KEY_DL_LIMIT );
     530            limit = pref_int_get( TR_PREFS_KEY_DSPEED );
    561531            tr_sessionSetSpeedLimit( tr, TR_DOWN, limit );
    562             b = pref_flag_get( PREF_KEY_UL_LIMIT_ENABLED );
     532            b = pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
    563533            tr_sessionSetSpeedLimitEnabled( tr, TR_UP, b );
    564             limit = pref_int_get( PREF_KEY_UL_LIMIT );
     534            limit = pref_int_get( TR_PREFS_KEY_USPEED );
    565535            tr_sessionSetSpeedLimit( tr, TR_UP, limit );
    566536        }
    567537
    … … prefschanged( TrCore * core UNUSED, 
    10581028    struct cbdata  * cbdata = data;
    10591029    tr_session     * tr     = tr_core_session( cbdata->core );
    10601030
    1061     if( !strcmp( key, PREF_KEY_ENCRYPTION ) )
     1031    if( !strcmp( key, TR_PREFS_KEY_ENCRYPTION ) )
    10621032    {
    10631033        const int encryption = pref_int_get( key );
    10641034        g_message( "setting encryption to %d", encryption );
    10651035        tr_sessionSetEncryption( tr, encryption );
    10661036    }
    1067     else if( !strcmp( key, PREF_KEY_PORT ) )
     1037    else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
    10681038    {
    10691039        const int port = pref_int_get( key );
    10701040        tr_sessionSetPeerPort( tr, port );
    … … prefschanged( TrCore * core UNUSED, 
    10801050            cbdata->icon = NULL;
    10811051        }
    10821052    }
    1083     else if( !strcmp( key, PREF_KEY_DL_LIMIT_ENABLED ) )
     1053    else if( !strcmp( key, TR_PREFS_KEY_DSPEED_ENABLED ) )
    10841054    {
    10851055        const gboolean b = pref_flag_get( key );
    10861056        tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, b );
    10871057    }
    1088     else if( !strcmp( key, PREF_KEY_DL_LIMIT ) )
     1058    else if( !strcmp( key, TR_PREFS_KEY_DSPEED ) )
    10891059    {
    10901060        const int limit = pref_int_get( key );
    10911061        tr_sessionSetSpeedLimit( tr, TR_DOWN, limit );
    10921062    }
    1093     else if( !strcmp( key, PREF_KEY_UL_LIMIT_ENABLED ) )
     1063    else if( !strcmp( key, TR_PREFS_KEY_USPEED_ENABLED ) )
    10941064    {
    10951065        const gboolean b = pref_flag_get( key );
    10961066        tr_sessionSetSpeedLimitEnabled( tr, TR_UP, b );
    10971067    }
    1098     else if( !strcmp( key, PREF_KEY_UL_LIMIT ) )
     1068    else if( !strcmp( key, TR_PREFS_KEY_USPEED ) )
    10991069    {
    11001070        const int limit = pref_int_get( key );
    11011071        tr_sessionSetSpeedLimit( tr, TR_UP, limit );
    … … prefschanged( TrCore * core UNUSED, 
    11041074    {
    11051075        updateScheduledLimits( tr );
    11061076    }
    1107     else if( !strcmp( key, PREF_KEY_PORT_FORWARDING ) )
     1077    else if( !strcmp( key, TR_PREFS_KEY_PORT_FORWARDING ) )
    11081078    {
    11091079        const gboolean enabled = pref_flag_get( key );
    11101080        tr_sessionSetPortForwardingEnabled( tr, enabled );
    11111081    }
    1112     else if( !strcmp( key, PREF_KEY_PEX ) )
     1082    else if( !strcmp( key, TR_PREFS_KEY_PEX_ENABLED ) )
    11131083    {
    11141084        const gboolean b = pref_flag_get( key );
    11151085        tr_sessionSetPortForwardingEnabled( tr, b );
    11161086    }
    1117     else if( !strcmp( key, PREF_KEY_RPC_ENABLED ) )
     1087    else if( !strcmp( key, TR_PREFS_KEY_RPC_ENABLED ) )
    11181088    {
    11191089        tr_sessionSetRPCEnabled( tr, pref_flag_get( key ) );
    11201090    }
    1121     else if( !strcmp( key, PREF_KEY_RPC_PORT ) )
     1091    else if( !strcmp( key, TR_PREFS_KEY_RPC_PORT ) )
    11221092    {
    11231093        tr_sessionSetRPCPort( tr, pref_int_get( key ) );
    11241094    }
    1125     else if( !strcmp( key, PREF_KEY_RPC_ENABLED ) )
     1095    else if( !strcmp( key, TR_PREFS_KEY_RPC_ENABLED ) )
    11261096    {
    11271097        tr_sessionSetRPCEnabled( tr, pref_flag_get( key ) );
    11281098    }
    1129     else if( !strcmp( key, PREF_KEY_RPC_WHITELIST ) )
     1099    else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST ) )
    11301100    {
    11311101        const char * s = pref_string_get( key );
    11321102        tr_sessionSetRPCWhitelist( tr, s );
    11331103    }
    1134     else if( !strcmp( key, PREF_KEY_RPC_WHITELIST_ENABLED ) )
     1104    else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST_ENABLED ) )
    11351105    {
    11361106        tr_sessionSetRPCWhitelistEnabled( tr, pref_flag_get( key ) );
    11371107    }
    1138     else if( !strcmp( key, PREF_KEY_RPC_USERNAME ) )
     1108    else if( !strcmp( key, TR_PREFS_KEY_RPC_USERNAME ) )
    11391109    {
    11401110        const char * s = pref_string_get( key );
    11411111        tr_sessionSetRPCUsername( tr, s );
    11421112    }
    1143     else if( !strcmp( key, PREF_KEY_RPC_PASSWORD ) )
     1113    else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
    11441114    {
    11451115        const char * s = pref_string_get( key );
    11461116        tr_sessionSetRPCPassword( tr, s );
    11471117    }
    1148     else if( !strcmp( key, PREF_KEY_RPC_AUTH_ENABLED ) )
     1118    else if( !strcmp( key, TR_PREFS_KEY_RPC_AUTH_REQUIRED ) )
    11491119    {
    11501120        const gboolean enabled = pref_flag_get( key );
    11511121        tr_sessionSetRPCPasswordEnabled( tr, enabled );
    11521122    }
    1153     else if( !strcmp( key, PREF_KEY_PROXY_SERVER ) )
     1123    else if( !strcmp( key, TR_PREFS_KEY_PROXY ) )
    11541124    {
    11551125        const char * s = pref_string_get( key );
    11561126        tr_sessionSetProxy( tr, s );
    11571127    }
    1158     else if( !strcmp( key, PREF_KEY_PROXY_TYPE ) )
     1128    else if( !strcmp( key, TR_PREFS_KEY_PROXY_TYPE ) )
    11591129    {
    11601130        const int i = pref_int_get( key );
    11611131        tr_sessionSetProxyType( tr, i );
    11621132    }
    1163     else if( !strcmp( key, PREF_KEY_PROXY_SERVER_ENABLED ) )
     1133    else if( !strcmp( key, TR_PREFS_KEY_PROXY_ENABLED ) )
    11641134    {
    11651135        const gboolean enabled = pref_flag_get( key );
    11661136        tr_sessionSetProxyEnabled( tr, enabled );
    11671137    }
    1168     else if( !strcmp( key, PREF_KEY_PROXY_AUTH_ENABLED ) )
     1138    else if( !strcmp( key, TR_PREFS_KEY_PROXY_AUTH_ENABLED ) )
    11691139    {
    11701140        const gboolean enabled = pref_flag_get( key );
    11711141        tr_sessionSetProxyAuthEnabled( tr, enabled );
    11721142    }
    1173     else if( !strcmp( key, PREF_KEY_PROXY_USERNAME ) )
     1143    else if( !strcmp( key, TR_PREFS_KEY_PROXY_USERNAME ) )
    11741144    {
    11751145        const char * s = pref_string_get( key );
    11761146        tr_sessionSetProxyUsername( tr, s );
    11771147    }
    1178     else if( !strcmp( key, PREF_KEY_PROXY_PASSWORD ) )
     1148    else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
    11791149    {
    11801150        const char * s = pref_string_get( key );
    11811151        tr_sessionSetProxyPassword( tr, s );
    … … about( GtkWindow * parent ) 
    12371207                           "website", website_url,
    12381208                           "website-label", website_url,
    12391209                           "copyright",
    1240                            _(
    1241                                "Copyright 2005-2008 The Transmission Project" ),
    1242                            "logo-icon-name", "transmission",
     1210                           _( "Copyright 2005-2008 The Transmission Project" ),
     1211                           "logo-icon-name", MY_NAME,
    12431212#ifdef SHOW_LICENSE
    12441213                           "license", LICENSE,
    12451214                           "wrap-license", TRUE,

  • gtk/add-dialog.c

    get_recent_destinations( void ) 
    4242}
    4343
    4444static void
    45 save_recent_destination( const char * dir  )
     45save_recent_destination( TrCore * core, const char * dir  )
    4646{
    4747    int      i;
    4848    GSList * list = get_recent_destinations( );
    … … save_recent_destination( const char * di 
    7070        g_snprintf( key, sizeof( key ), "recent-download-dir-%d", i + 1 );
    7171        pref_string_set( key, l->data );
    7272    }
    73     pref_save( );
     73    pref_save( tr_core_session( core ) );
    7474
    7575    /* cleanup */
    7676    g_slist_foreach( list, (GFunc)g_free, NULL );
    … … addResponseCB( GtkDialog * dialog, 
    116116    if( data->gtor )
    117117    {
    118118        if( response != GTK_RESPONSE_ACCEPT )
     119        {
    119120            removeOldTorrent( data );
     121        }
    120122        else
    121123        {
    122             if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->
    123                                                                  run_check ) ) )
     124            if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->run_check ) ) )
    124125                tr_torrentStart( tr_torrent_handle( data->gtor ) );
     126
    125127            tr_core_add_torrent( data->core, data->gtor );
    126             if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->
    127                                                                  trash_check ) ) )
     128
     129            if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->trash_check ) ) )
     130
    128131                tr_file_trash_or_unlink( data->filename );
    129             save_recent_destination( data->downloadDir );
     132            save_recent_destination( data->core, data->downloadDir );
    130133        }
    131134    }
    132135

  • daemon/daemon.c

     
    3030
    3131static int           closing = FALSE;
    3232static tr_session  * mySession = NULL;
    33 static char        * myConfigFilename = NULL;
    34 
    35 #define KEY_BLOCKLIST         "blocklist-enabled"
    36 #define KEY_DOWNLOAD_DIR      "download-dir"
    37 #define KEY_ENCRYPTION        "encryption"
    38 #define KEY_LAZY_BITFIELD     "lazy-bitfield-enabled"
    39 #define KEY_PEER_LIMIT        "max-peers-global"
    40 #define KEY_PEER_PORT         "peer-port"
    41 #define KEY_PORT_FORWARDING   "port-forwarding-enabled"
    42 #define KEY_PEX_ENABLED       "pex-enabled"
    43 #define KEY_AUTH_REQUIRED     "rpc-authentication-required"
    44 #define KEY_USERNAME          "rpc-username"
    45 #define KEY_PASSWORD          "rpc-password"
    46 #define KEY_WHITELIST         "rpc-whitelist"
    47 #define KEY_WHITELIST_ENABLED "rpc-whitelist-enabled"
    48 #define KEY_RPC_PORT          "rpc-port"
    49 #define KEY_DSPEED            "download-limit"
    50 #define KEY_DSPEED_ENABLED    "download-limit-enabled"
    51 #define KEY_USPEED            "upload-limit"
    52 #define KEY_USPEED_ENABLED    "upload-limit-enabled"
    53 
    54 #define CONFIG_FILE           "settings.json"
    5533
    5634/***
    5735****  Config File
    5836***/
    5937
    60 static void
    61 replaceInt( tr_benc *    dict,
    62             const char * key,
    63             int64_t      value )
    64 {
    65     tr_bencDictRemove( dict, key );
    66     tr_bencDictAddInt( dict, key, value );
    67 }
    68 
    69 static void
    70 replaceStr( tr_benc *    dict,
    71             const char * key,
    72             const char*  value )
    73 {
    74     tr_bencDictRemove( dict, key );
    75     tr_bencDictAddStr( dict, key, value );
    76 }
    77 
    78 static void
    79 saveState( tr_session * s )
    80 {
    81     int     i, n = 0;
    82     char *  strs[4];
    83 
    84     tr_benc d;
    85 
    86     if( tr_bencLoadJSONFile( myConfigFilename, &d ) )
    87         tr_bencInitDict( &d, 16 );
    88 
    89     replaceInt( &d, KEY_BLOCKLIST,       tr_blocklistIsEnabled( s ) );
    90     replaceStr( &d, KEY_DOWNLOAD_DIR,    tr_sessionGetDownloadDir( s ) );
    91     replaceInt( &d, KEY_PEER_LIMIT,      tr_sessionGetPeerLimit( s ) );
    92     replaceInt( &d, KEY_PEER_PORT,       tr_sessionGetPeerPort( s ) );
    93     replaceInt( &d, KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
    94     replaceInt( &d, KEY_PEX_ENABLED,     tr_sessionIsPexEnabled( s ) );
    95     replaceStr( &d, KEY_USERNAME,        strs[n++] = tr_sessionGetRPCUsername( s ) );
    96     replaceStr( &d, KEY_PASSWORD,        strs[n++] = tr_sessionGetRPCPassword( s ) );
    97     replaceStr( &d, KEY_WHITELIST,       strs[n++] = tr_sessionGetRPCWhitelist( s ) );
    98     replaceInt( &d, KEY_RPC_PORT,        tr_sessionGetRPCPort( s ) );
    99     replaceInt( &d, KEY_AUTH_REQUIRED,   tr_sessionIsRPCPasswordEnabled( s ) );
    100     replaceInt( &d, KEY_DSPEED,          tr_sessionGetSpeedLimit( s, TR_DOWN ) );
    101     replaceInt( &d, KEY_DSPEED_ENABLED,  tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
    102     replaceInt( &d, KEY_USPEED,          tr_sessionGetSpeedLimit( s, TR_UP ) );
    103     replaceInt( &d, KEY_USPEED_ENABLED,  tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
    104     replaceInt( &d, KEY_ENCRYPTION,      tr_sessionGetEncryption( s ) );
    105 
    106     tr_bencSaveJSONFile( myConfigFilename, &d );
    107     tr_bencFree( &d );
    108     tr_ninf( MY_NAME, "saved \"%s\"", myConfigFilename );
    109 
    110     for( i = 0; i < n; ++i )
    111         tr_free( strs[i] );
    112 }
    113 
    114 static void
    115 getConfigInt( tr_benc *    dict,
    116               const char * key,
    117               int *        setme,
    118               int          defaultVal )
    119 {
    120     if( *setme < 0 )
    121     {
    122         int64_t i;
    123         if( tr_bencDictFindInt( dict, key, &i ) )
    124             *setme = i;
    125         else
    126             *setme = defaultVal;
    127     }
    128 }
    129 
    130 static void
    131 getConfigStr( tr_benc *     dict,
    132               const char *  key,
    133               const char ** setme,
    134               const char *  defaultVal )
    135 {
    136     if( !*setme )
    137     {
    138         const char * s;
    139         if( tr_bencDictFindStr( dict, key, &s ) )
    140             *setme = s;
    141         else
    142             *setme = defaultVal;
    143     }
    144 }
    145 
    146 /**
    147  * @param port      port number, or -1 if not set in the command line
    148  * @param auth      TRUE, FALSE, or -1 if not set on the command line
    149  * @param blocklist TRUE, FALSE, or -1 if not set on the command line
    150  */
    151 static void
    152 session_init( const char * configDir,
    153               const char * downloadDir,
    154               int          rpcPort,
    155               const char * whitelist,
    156               int          authRequired,
    157               const char * username,
    158               const char * password,
    159               int          blocklistEnabled )
    160 {
    161     tr_benc       state, *dict = NULL;
    162     int           peerPort = -1, peers = -1;
    163     int           whitelistEnabled = -1;
    164     int           pexEnabled = -1;
    165     int           fwdEnabled = -1;
    166     int           upLimit = -1, upLimited = -1, downLimit = -1,
    167                   downLimited = -1;
    168     int           encryption = -1;
    169     int           useLazyBitfield = -1;
    170     tr_ctor *     ctor;
    171     tr_torrent ** torrents;
    172 
    173     if( !tr_bencLoadJSONFile( myConfigFilename, &state ) )
    174         dict = &state;
    175    
    176 
    177     /***
    178     ****  Decide on which values to pass into tr_sessionInitFull().
    179     ****  The command-line arguments are given precedence and
    180     ****  the state file from the previous session is used as a fallback.
    181     ****  If neither of those can be found, the TR_DEFAULT fields are used .
    182     ***/
    183 
    184     getConfigStr( dict, KEY_DOWNLOAD_DIR,      &downloadDir,       TR_DEFAULT_DOWNLOAD_DIR );
    185     getConfigInt( dict, KEY_PEX_ENABLED,       &pexEnabled,        TR_DEFAULT_PEX_ENABLED );
    186     getConfigInt( dict, KEY_PORT_FORWARDING,   &fwdEnabled,        TR_DEFAULT_PORT_FORWARDING_ENABLED );
    187     getConfigInt( dict, KEY_PEER_PORT,         &peerPort,          TR_DEFAULT_PORT );
    188     getConfigInt( dict, KEY_DSPEED,            &downLimit,         100 );
    189     getConfigInt( dict, KEY_DSPEED_ENABLED,    &downLimited,       FALSE );
    190     getConfigInt( dict, KEY_USPEED,            &upLimit,           100 );
    191     getConfigInt( dict, KEY_USPEED_ENABLED,    &upLimited,         FALSE );
    192     getConfigInt( dict, KEY_LAZY_BITFIELD,     &useLazyBitfield,   TR_DEFAULT_LAZY_BITFIELD_ENABLED );
    193     getConfigInt( dict, KEY_PEER_LIMIT,        &peers,             TR_DEFAULT_GLOBAL_PEER_LIMIT );
    194     getConfigInt( dict, KEY_BLOCKLIST,         &blocklistEnabled,  TR_DEFAULT_BLOCKLIST_ENABLED );
    195     getConfigInt( dict, KEY_RPC_PORT,          &rpcPort,           TR_DEFAULT_RPC_PORT );
    196     getConfigStr( dict, KEY_WHITELIST,         &whitelist,         TR_DEFAULT_RPC_WHITELIST );
    197     getConfigInt( dict, KEY_AUTH_REQUIRED,     &authRequired,      FALSE );
    198     getConfigStr( dict, KEY_USERNAME,          &username,          NULL );
    199     getConfigStr( dict, KEY_PASSWORD,          &password,          NULL );
    200     getConfigInt( dict, KEY_ENCRYPTION,        &encryption,        TR_DEFAULT_ENCRYPTION );
    201 
    202     whitelistEnabled = whitelist && *whitelist;
    203 
    204     /***
    205     ****
    206     ***/
    207 
    208     /* start the session */
    209     mySession = tr_sessionInitFull( configDir, "daemon", downloadDir,
    210                                     pexEnabled, fwdEnabled, peerPort,
    211                                     encryption,
    212                                     useLazyBitfield,
    213                                     upLimited, upLimit,
    214                                     downLimited, downLimit,
    215                                     peers,
    216                                     TR_MSG_INF, 0,
    217                                     blocklistEnabled,
    218                                     TR_DEFAULT_PEER_SOCKET_TOS,
    219                                     TRUE, rpcPort,
    220                                     whitelistEnabled, whitelist,
    221                                     authRequired, username, password,
    222                                     TR_DEFAULT_PROXY_ENABLED,
    223                                     TR_DEFAULT_PROXY,
    224                                     TR_DEFAULT_PROXY_PORT,
    225                                     TR_DEFAULT_PROXY_TYPE,
    226                                     TR_DEFAULT_PROXY_AUTH_ENABLED,
    227                                     TR_DEFAULT_PROXY_USERNAME,
    228                                     TR_DEFAULT_PROXY_PASSWORD );
    229 
    230 
    231     if( authRequired )
    232         tr_ninf( MY_NAME, "requiring authentication" );
    233 
    234     /* load the torrents */
    235     ctor = tr_ctorNew( mySession );
    236     torrents = tr_sessionLoadTorrents( mySession, ctor, NULL );
    237     tr_free( torrents );
    238     tr_ctorFree( ctor );
    239 
    240     if( dict )
    241         tr_bencFree( &state );
    242 }
    243 
    24438static const char *
    24539getUsage( void )
    24640{
    … … getUsage( void ) 
    25650
    25751static const struct tr_option options[] =
    25852{
    259     { 'a', "allowed",
    260       "Allowed IP addresses.  (Default: " TR_DEFAULT_RPC_WHITELIST ")",       "a",
    261       1, "<list>"     },
    262     { 'b', "blocklist",    "Enable peer blocklists",
    263       "b",             0, NULL         },
    264     { 'B', "no-blocklist", "Disable peer blocklists",
    265       "B",             0, NULL         },
    266     { 'f', "foreground",   "Run in the foreground instead of daemonizing",
    267       "f",             0, NULL         },
    268     { 'g', "config-dir",   "Where to look for configuration files",
    269       "g",             1, "<path>"     },
    270     { 'p', "port",
    271       "RPC port (Default: " TR_DEFAULT_RPC_PORT_STR ")",               "p",
    272       1, "<port>"     },
    273     { 't', "auth",         "Require authentication",
    274       "t",             0, NULL         },
    275     { 'T', "no-auth",      "Don't require authentication",
    276       "T",             0, NULL         },
    277     { 'u', "username",     "Set username for authentication",
    278       "u",             1, "<username>" },
    279     { 'v', "password",     "Set password for authentication",
    280       "v",             1, "<password>" },
    281     { 'w', "download-dir", "Where to save downloaded data",
    282       "w",             1, "<path>"     },
    283     {   0, NULL,           NULL,
    284         NULL,            0, NULL         }
     53    { 'a', "allowed", "Allowed IP addresses.  (Default: " TR_DEFAULT_RPC_WHITELIST ")", "a", 1, "<list>" },
     54    { 'b', "blocklist", "Enable peer blocklists", "b", 0, NULL },
     55    { 'B', "no-blocklist", "Disable peer blocklists", "B", 0, NULL },
     56    { 'f', "foreground", "Run in the foreground instead of daemonizing", "f", 0, NULL },
     57    { 'g', "config-dir", "Where to look for configuration files", "g", 1, "<path>" },
     58    { 'p', "port", "RPC port (Default: " TR_DEFAULT_RPC_PORT_STR ")", "p", 1, "<port>" },
     59    { 't', "auth", "Require authentication", "t", 0, NULL },
     60    { 'T', "no-auth", "Don't require authentication", "T", 0, NULL },
     61    { 'u', "username", "Set username for authentication", "u", 1, "<username>" },
     62    { 'v', "password", "Set password for authentication", "v", 1, "<password>" },
     63    { 'w', "download-dir", "Where to save downloaded data", "w", 1, "<path>" },
     64    { 0, NULL, NULL, NULL, 0, NULL }
    28565};
    28666
    28767static void
    … … showUsage( void ) 
    29272}
    29373
    29474static void
    295 readargs( int           argc,
    296           const char ** argv,
    297           int *         nofork,
    298           const char ** configDir,
    299           const char ** downloadDir,
    300           int *         rpcPort,
    301           const char ** whitelist,
    302           int *         authRequired,
    303           const char ** username,
    304           const char ** password,
    305           int *         blocklistEnabled )
    306 {
    307     int          c;
    308     const char * optarg;
    309 
    310     while( ( c = tr_getopt( getUsage( ), argc, argv, options, &optarg ) ) )
    311     {
    312         switch( c )
    313         {
    314             case 'a':
    315                 *whitelist = optarg; break;
    316 
    317             case 'b':
    318                 *blocklistEnabled = 1; break;
    319 
    320             case 'B':
    321                 *blocklistEnabled = 0; break;
    322 
    323             case 'f':
    324                 *nofork = 1; break;
    325 
    326             case 'g':
    327                 *configDir = optarg; break;
    328 
    329             case 'p':
    330                 *rpcPort = atoi( optarg ); break;
    331 
    332             case 't':
    333                 *authRequired = TRUE; break;
    334 
    335             case 'T':
    336                 *authRequired = FALSE; break;
    337 
    338             case 'u':
    339                 *username = optarg; break;
    340 
    341             case 'v':
    342                 *password = optarg; break;
    343 
    344             case 'w':
    345                 *downloadDir = optarg; break;
    346 
    347             default:
    348                 showUsage( ); break;
    349         }
    350     }
    351 }
    352 
    353 static void
    35475gotsig( int sig UNUSED )
    35576{
    35677    closing = TRUE;
    … … daemon( int nochdir, 
    433154#endif
    434155#endif
    435156
     157static const char*
     158getConfigDir( int argc, const char ** argv )
     159{
     160    int c;
     161    const char * configDir = NULL;
     162    const char * optarg;
     163    const int ind = tr_optind;
     164
     165    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
     166        if( c == 'g' )
     167            configDir = optarg;
     168
     169    tr_optind = ind;
     170
     171    if( configDir == NULL )
     172        configDir = tr_getDefaultConfigDir( MY_NAME );
     173
     174    return configDir;
     175}
     176
     177
    436178int
    437179main( int     argc,
    438180      char ** argv )
    439181{
    440     int          nofork = 0;
    441     int          rpcPort = -1;
    442     int          authRequired = -1;
    443     int          blocklistEnabled = -1;
    444     char *       freeme = NULL;
     182    int c;
     183    const char * optarg;
     184    tr_benc settings;
     185    tr_bool foreground = FALSE;
    445186    const char * configDir = NULL;
    446     const char * downloadDir = NULL;
    447     const char * whitelist = NULL;
    448     const char * username = NULL;
    449     const char * password = NULL;
    450187
    451188    signal( SIGINT, gotsig );
    452189    signal( SIGTERM, gotsig );
    … … main( int argc, 
    456193    signal( SIGHUP, SIG_IGN );
    457194#endif
    458195
    459     readargs( argc, (const char**)argv, &nofork, &configDir, &downloadDir,
    460               &rpcPort, &whitelist, &authRequired, &username, &password,
    461               &blocklistEnabled );
    462     if( configDir == NULL )
    463         configDir = getenv( "TRANSMISSION_HOME" );
    464     if( configDir == NULL )
    465         configDir = freeme = tr_strdup_printf( "%s-daemon",
    466                                                tr_getDefaultConfigDir( ) );
    467     myConfigFilename = tr_buildPath( configDir, CONFIG_FILE, NULL );
     196    /* load settings from defaults + config file */
     197    tr_bencInitDict( &settings, 0 );
     198    configDir = getConfigDir( argc, (const char**)argv );
     199    tr_sessionLoadSettings( &settings, configDir, MY_NAME );
     200
     201    /* overwrite settings from the comamndline */
     202    tr_optind = 1;
     203    while(( c = tr_getopt( getUsage(), argc, (const char**)argv, options, &optarg ))) {
     204        switch( c ) {
     205            case 'a': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_WHITELIST, optarg );
     206                      tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, 1 );
     207                      break;
     208            case 'b': tr_bencDictAddInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, 1 );
     209                      break;
     210            case 'B': tr_bencDictAddInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, 0 );
     211                      break;
     212            case 'f': foreground = TRUE;
     213                      break;
     214            case 'g': /* handled above */
     215                      break;
     216            case 'p': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_PORT, atoi( optarg ) );
     217                      break;
     218            case 't': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, 0 );
     219                      break;
     220            case 'T': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, 1 );
     221                      break;
     222            case 'u': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_USERNAME, optarg );
     223                      break;
     224            case 'v': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_PASSWORD, optarg );
     225                      break;
     226            case 'w': tr_bencDictAddStr( &settings, TR_PREFS_KEY_DOWNLOAD_DIR, optarg );
     227                      break;
     228            default:  showUsage( );
     229                      break;
     230        }
     231    }
    468232
    469233#ifndef WIN32
    470     if( !nofork )
     234    if( !foreground )
    471235    {
    472236        if( 0 > daemon( 1, 0 ) )
    473237        {
    … … main( int argc, 
    477241    }
    478242#endif
    479243
    480     session_init( configDir, downloadDir,
    481                   rpcPort, whitelist, authRequired, username, password,
    482                   blocklistEnabled );
     244    /* start the session */
     245    mySession = tr_sessionInit( "daemon", configDir, FALSE, &settings );
     246
     247    if( tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, NULL ) )
     248        tr_ninf( MY_NAME, "requiring authentication" );
     249
     250    /* load the torrents */
     251    {
     252        tr_ctor * ctor = tr_ctorNew( mySession );
     253        tr_torrent ** torrents = tr_sessionLoadTorrents( mySession, ctor, NULL );
     254        tr_free( torrents );
     255        tr_ctorFree( ctor );
     256    }
    483257
    484258    while( !closing )
    485259        tr_wait( 1000 ); /* sleep one second */
    486260
    487     saveState( mySession );
     261    /* shutdown */
    488262    printf( "Closing transmission session..." );
     263    tr_sessionSaveSettings( mySession, configDir, &settings );
    489264    tr_sessionClose( mySession );
    490265    printf( " done.\n" );
    491266
    492     tr_free( freeme );
    493     tr_free( myConfigFilename );
     267    /* cleanup */
     268    tr_bencFree( &settings );
    494269    return 0;
    495270}
    496 

  • daemon/remote.c

     
    3434
    3535#define MY_NAME "transmission-remote"
    3636#define DEFAULT_HOST "localhost"
    37 #define DEFAULT_PORT TR_DEFAULT_RPC_PORT
     37#define DEFAULT_PORT atoi(TR_DEFAULT_RPC_PORT_STR)
    3838
    3939enum { TAG_LIST, TAG_DETAILS, TAG_FILES, TAG_PEERS };
    4040
    … … static tr_option opts[] = 
    8989    { 'n', "auth",                 "Set authentication info",
    9090      "n",  1, "<username:password>" },
    9191    { 'p', "port",
    92       "Port for incoming peers (Default: " TR_DEFAULT_PORT_STR ")",
     92      "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")",
    9393      "p", 1, "<port>" },
    9494    { 900, "priority-high",        "Set the files' priorities as high",
    9595      "ph", 1, "<files>"             },

  • cli/cli.c

     
    3838#define LINEWIDTH 80
    3939#define MY_NAME "transmission-cli"
    4040
    41 static int          showInfo         = 0;
    42 static int          showScrape       = 0;
    43 static int          isPrivate        = 0;
    44 static int          verboseLevel     = 0;
    45 static int          encryptionMode   = TR_DEFAULT_ENCRYPTION;
    46 static int          peerPort         = TR_DEFAULT_PORT;
    47 static int          peerSocketTOS    = TR_DEFAULT_PEER_SOCKET_TOS;
    48 static int          blocklistEnabled = TR_DEFAULT_BLOCKLIST_ENABLED;
    49 static int          uploadLimit      = 20;
    50 static int          downloadLimit    = -1;
    51 static int          natTraversal     = TR_DEFAULT_PORT_FORWARDING_ENABLED;
    52 static int          verify           = 0;
     41static tr_bool showInfo         = 0;
     42static tr_bool showScrape       = 0;
     43static tr_bool isPrivate        = 0;
     44static tr_bool verify           = 0;
    5345static sig_atomic_t gotsig           = 0;
    5446static sig_atomic_t manualUpdate     = 0;
    5547
    5648static const char * torrentPath  = NULL;
    57 static const char * downloadDir  = NULL;
    5849static const char * finishCall   = NULL;
    5950static const char * announce     = NULL;
    6051static const char * configdir    = NULL;
    … … static const char * comment = NULL; 
    6354
    6455static const struct tr_option options[] =
    6556{
    66     { 'a', "announce",             "Set the new torrent's announce URL",
    67       "a",  1, "<url>"     },
    68     { 'b', "blocklist",            "Enable peer blocklists",
    69       "b",  0, NULL        },
    70     { 'B', "no-blocklist",         "Disable peer blocklists",
    71       "B",  0, NULL        },
    72     { 'c', "comment",              "Set the new torrent's comment",
    73       "c",  1, "<comment>" },
    74     { 'd', "downlimit",            "Set max download speed in KB/s",
    75       "d",  1, "<speed>"   },
    76     { 'D', "no-downlimit",         "Don't limit the download speed",
    77       "D",  0, NULL        },
    78     { 910, "encryption-required",  "Encrypt all peer connections",
    79       "er", 0, NULL        },
    80     { 911, "encryption-preferred", "Prefer encrypted peer connections",
    81       "ep", 0, NULL        },
    82     { 912, "encryption-tolerated", "Prefer unencrypted peer connections",
    83       "et", 0, NULL        },
    84     { 'f', "finish",               "Run a script when the torrent finishes",
    85       "f", 1, "<script>" },
    86     { 'g', "config-dir",           "Where to find configuration files",
    87       "g", 1, "<path>" },
    88     { 'i', "info",                 "Show torrent details and exit",
    89       "i",  0, NULL        },
    90     { 'm', "portmap",              "Enable portmapping via NAT-PMP or UPnP",
    91       "m",  0, NULL        },
    92     { 'M', "no-portmap",           "Disable portmapping",
    93       "M",  0, NULL        },
    94     { 'n', "new",                  "Create a new torrent",
    95       "n", 1, "<source>" },
    96     { 'p', "port",
    97       "Port for incoming peers (Default: " TR_DEFAULT_PORT_STR ")",
    98       "p", 1, "<port>" },
    99     { 'r', "private",              "Set the new torrent's 'private' flag",
    100       "r",  0, NULL        },
    101     { 's', "scrape",               "Scrape the torrent and exit",
    102       "s",  0, NULL        },
    103     { 't', "tos",
    104       "Peer socket TOS (0 to 255, default=" TR_DEFAULT_PEER_SOCKET_TOS_STR
    105       ")",
    106       "t", 1, "<tos>" },
    107     { 'u', "uplimit",              "Set max upload speed in KB/s",
    108       "u",  1, "<speed>"   },
    109     { 'U', "no-uplimit",           "Don't limit the upload speed",
    110       "U",  0, NULL        },
    111     { 'v', "verify",               "Verify the specified torrent",
    112       "v",  0, NULL        },
    113     { 'w', "download-dir",         "Where to save downloaded data",
    114       "w",  1, "<path>"    },
    115     {   0, NULL,                   NULL,
    116         NULL, 0, NULL        }
     57    { 'a', "announce",             "Set the new torrent's announce URL", "a",  1, "<url>"     },
     58    { 'b', "blocklist",            "Enable peer blocklists", "b",  0, NULL        },
     59    { 'B', "no-blocklist",         "Disable peer blocklists", "B",  0, NULL        },
     60    { 'c', "comment",              "Set the new torrent's comment", "c",  1, "<comment>" },
     61    { 'd', "downlimit",            "Set max download speed in KB/s", "d",  1, "<speed>"   },
     62    { 'D', "no-downlimit",         "Don't limit the download speed", "D",  0, NULL        },
     63    { 910, "encryption-required",  "Encrypt all peer connections", "er", 0, NULL        },
     64    { 911, "encryption-preferred", "Prefer encrypted peer connections", "ep", 0, NULL        },
     65    { 912, "encryption-tolerated", "Prefer unencrypted peer connections", "et", 0, NULL        },
     66    { 'f', "finish",               "Run a script when the torrent finishes", "f", 1, "<script>" },
     67    { 'g', "config-dir",           "Where to find configuration files", "g", 1, "<path>" },
     68    { 'i', "info",                 "Show torrent details and exit", "i",  0, NULL        },
     69    { 'm', "portmap",              "Enable portmapping via NAT-PMP or UPnP", "m",  0, NULL        },
     70    { 'M', "no-portmap",           "Disable portmapping", "M",  0, NULL        },
     71    { 'n', "new",                  "Create a new torrent", "n", 1, "<source>" },
     72    { 'p', "port", "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")", "p", 1, "<port>" },
     73    { 'r', "private",              "Set the new torrent's 'private' flag", "r",  0, NULL        },
     74    { 's', "scrape",               "Scrape the torrent and exit", "s",  0, NULL        },
     75    { 't', "tos", "Peer socket TOS (0 to 255, default=" TR_DEFAULT_PEER_SOCKET_TOS_STR ")", "t", 1, "<tos>" },
     76    { 'u', "uplimit",              "Set max upload speed in KB/s", "u",  1, "<speed>"   },
     77    { 'U', "no-uplimit",           "Don't limit the upload speed", "U",  0, NULL        },
     78    { 'v', "verify",               "Verify the specified torrent", "v",  0, NULL        },
     79    { 'w', "download-dir",         "Where to save downloaded data", "w",  1, "<path>"    },
     80    { 0, NULL, NULL, NULL, 0, NULL }
    11781};
    11882
    11983static const char *
    … … getUsage( void ) 
    12488           "Usage: " MY_NAME " [options] <torrent-filename>";
    12589}
    12690
    127 static int          parseCommandLine( int           argc,
    128                                       const char ** argv );
     91static int parseCommandLine( tr_benc*, int argc, const char ** argv );
    12992
    13093static void         sigHandler( int signal );
    13194
    … … getStatusStr( const tr_stat * st, 
    301264    else *buf = '\0';
    302265}
    303266
     267static const char*
     268getConfigDir( int argc, const char ** argv )
     269{
     270    int c;
     271    const char * configDir = NULL;
     272    const char * optarg;
     273    const int ind = tr_optind;
     274
     275    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
     276        if( c == 'g' )
     277            configdir = optarg;
     278
     279    tr_optind = ind;
     280
     281    if( configDir == NULL )
     282        configDir = tr_getDefaultConfigDir( MY_NAME );
     283
     284    return configDir;
     285}
     286
    304287int
    305288main( int     argc,
    306289      char ** argv )
    … … main( int argc, 
    309292    tr_session  * h;
    310293    tr_ctor     * ctor;
    311294    tr_torrent  * tor = NULL;
     295    tr_benc settings;
     296    const char * configDir;
    312297
    313298    printf( "Transmission %s - http://www.transmissionbt.com/\n",
    314299            LONG_VERSION_STRING );
    … … main( int argc, 
    319304        return EXIT_FAILURE;
    320305    }
    321306
    322     /* Get options */
    323     if( parseCommandLine( argc, (const char**)argv ) )
     307    /* load the defaults from config file + libtransmission defaults */
     308    tr_bencInitDict( &settings, 0 );
     309    configDir = getConfigDir( argc, (const char**)argv );
     310    tr_sessionLoadSettings( &settings, configDir, MY_NAME );
     311
     312    /* the command line overrides defaults */
     313    if( parseCommandLine( &settings, argc, (const char**)argv ) )
    324314        return EXIT_FAILURE;
    325315
    326316    /* Check the options for validity */
    327     if( !torrentPath )
    328     {
     317    if( !torrentPath ) {
    329318        fprintf( stderr, "No torrent specified!\n" );
    330319        return EXIT_FAILURE;
    331320    }
    332     if( peerPort < 1 || peerPort > 65535 )
    333     {
    334         fprintf( stderr, "Error: Port must between 1 and 65535; got %d\n",
    335                  peerPort );
    336         return EXIT_FAILURE;
    337     }
    338     if( peerSocketTOS < 0 || peerSocketTOS > 255 )
    339     {
    340         fprintf( stderr, "Error: value must between 0 and 255; got %d\n",
    341                  peerSocketTOS );
    342         return EXIT_FAILURE;
    343     }
    344321
    345322    /* don't bind the port if we're just running the CLI
    346      * to get metainfo or to create a torrent */
     323       to get metainfo or to create a torrent */
    347324    if( showInfo || showScrape || ( sourceFile != NULL ) )
    348         peerPort = -1;
     325        tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_PORT, -1 );
    349326
    350     if( configdir == NULL )
    351         configdir = tr_getDefaultConfigDir( );
    352 
    353     if( downloadDir == NULL )
    354         downloadDir = tr_getDefaultDownloadDir( );
    355 
    356     /* Initialize libtransmission */
    357     h = tr_sessionInitFull(
    358         configdir,
    359         "cli",                            /* tag */
    360         downloadDir,                       /* where to download torrents */
    361         TR_DEFAULT_PEX_ENABLED,
    362         natTraversal,                      /* nat enabled */
    363         peerPort,
    364         encryptionMode,
    365         TR_DEFAULT_LAZY_BITFIELD_ENABLED,
    366         uploadLimit >= 0,
    367         uploadLimit,
    368         downloadLimit >= 0,
    369         downloadLimit,
    370         TR_DEFAULT_GLOBAL_PEER_LIMIT,
    371         verboseLevel + 1,                  /* messageLevel */
    372         0,                                 /* is message queueing enabled? */
    373         blocklistEnabled,
    374         peerSocketTOS,
    375         TR_DEFAULT_RPC_ENABLED,
    376         TR_DEFAULT_RPC_PORT,
    377         TR_DEFAULT_RPC_WHITELIST_ENABLED,
    378         TR_DEFAULT_RPC_WHITELIST,
    379         FALSE, "fnord", "potzrebie",
    380         TR_DEFAULT_PROXY_ENABLED,
    381         TR_DEFAULT_PROXY,
    382         TR_DEFAULT_PROXY_PORT,
    383         TR_DEFAULT_PROXY_TYPE,
    384         TR_DEFAULT_PROXY_AUTH_ENABLED,
    385         TR_DEFAULT_PROXY_USERNAME,
    386         TR_DEFAULT_PROXY_PASSWORD );
     327    h = tr_sessionInit( "cli", configDir, FALSE, &settings );
    387328
    388329    if( sourceFile && *sourceFile ) /* creating a torrent */
    389330    {
    … … main( int argc, 
    407348    ctor = tr_ctorNew( h );
    408349    tr_ctorSetMetainfoFromFile( ctor, torrentPath );
    409350    tr_ctorSetPaused( ctor, TR_FORCE, showScrape );
    410     tr_ctorSetDownloadDir( ctor, TR_FORCE, downloadDir );
    411351
    412352    if( showScrape )
    413353    {
    … … main( int argc, 
    521461    }
    522462
    523463cleanup:
     464
     465    tr_sessionSaveSettings( h, configDir, &settings );
     466
    524467    printf( "\n" );
     468    tr_bencFree( &settings );
    525469    tr_sessionClose( h );
    526470    return EXIT_SUCCESS;
    527471}
    … … showUsage( void ) 
    540484}
    541485
    542486static int
    543 numarg( const char * arg )
    544 {
    545     char *     end = NULL;
    546     const long num = strtol( arg, &end, 10 );
    547 
    548     if( *end )
    549     {
    550         fprintf( stderr, "Not a number: \"%s\"\n", arg );
    551         showUsage( );
    552     }
    553     return num;
    554 }
    555 
    556 static int
    557 parseCommandLine( int           argc,
    558                   const char ** argv )
     487parseCommandLine( tr_benc * d, int argc, const char ** argv )
    559488{
    560489    int          c;
    561490    const char * optarg;
    562491
    563     while( ( c = tr_getopt( getUsage( ), argc, argv, options, &optarg ) ) )
     492    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
    564493    {
    565494        switch( c )
    566495        {
    567496            case 'a':
    568497                announce = optarg; break;
    569498
    570             case 'b':
    571                 blocklistEnabled = 1; break;
    572 
    573             case 'B':
    574                 blocklistEnabled = 0; break;
    575 
    576             case 'c':
    577                 comment = optarg; break;
    578 
    579             case 'd':
    580                 downloadLimit = numarg( optarg ); break;
    581 
    582             case 'D':
    583                 downloadLimit = -1; break;
    584 
    585             case 'f':
    586                 finishCall = optarg; break;
    587 
    588             case 'g':
    589                 configdir = optarg; break;
    590 
    591             case 'i':
    592                 showInfo = 1; break;
    593 
    594             case 'm':
    595                 natTraversal = 1; break;
    596 
    597             case 'M':
    598                 natTraversal = 0; break;
    599 
    600             case 'n':
    601                 sourceFile = optarg; break;
    602 
    603             case 'p':
    604                 peerPort = numarg( optarg ); break;
    605 
    606             case 'r':
    607                 isPrivate = 1; break;
    608 
    609             case 's':
    610                 showScrape = 1; break;
    611 
    612             case 't':
    613                 peerSocketTOS = numarg( optarg ); break;
    614 
    615             case 'u':
    616                 uploadLimit = numarg( optarg ); break;
    617 
    618             case 'U':
    619                 uploadLimit = -1; break;
    620 
    621             case 'v':
    622                 verify = 1; break;
    623 
    624             case 'w':
    625                 downloadDir = optarg; break;
    626 
    627             case 910:
    628                 encryptionMode = TR_ENCRYPTION_REQUIRED; break;
    629 
    630             case 911:
    631                 encryptionMode = TR_CLEAR_PREFERRED; break;
    632 
    633             case 912:
    634                 encryptionMode = TR_ENCRYPTION_PREFERRED; break;
    635 
     499            case 'b': tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, 1 );
     500                      break;
     501            case 'B': tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, 0 );
     502                      break;
     503            case 'c': comment = optarg;
     504                      break;
     505            case 'd': tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED, atoi( optarg ) );
     506                      tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, 1 );
     507                      break;
     508            case 'D': tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, 0 );
     509                      break;
     510            case 'f': finishCall = optarg;
     511                      break;
     512            case 'g': /* handled above */
     513                      break;
     514            case 'i': showInfo = 1;
     515                      break;
     516            case 'm': tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, 1 );
     517                      break;
     518            case 'M': tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, 0 );
     519                      break;
     520            case 'n': sourceFile = optarg; break;
     521            case 'p': tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, 1 );
     522                      break;
     523            case 'r': isPrivate = 1;
     524                      break;
     525            case 's': showScrape = 1;
     526                      break;
     527            case 't': tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi( optarg ) );
     528                      break;
     529            case 'u': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, atoi( optarg ) );
     530                      tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 1 );
     531                      break;
     532            case 'U': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 0 );
     533                      break;
     534            case 'v': verify = 1;
     535                      break;
     536            case 'w': tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg );
     537                      break;
     538            case 910: tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED );
     539                      break;
     540            case 911: tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED );
     541                      break;
     542            case 912: tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED );
     543                      break;
    636544            case TR_OPT_UNK:
    637                 torrentPath = optarg; break;
    638 
    639             default:
    640                 return 1;
     545                      torrentPath = optarg;
     546                      break;
     547            default: return 1;
    641548        }
    642549    }
    643550