Ticket #1559: session_init3.patch

daemon/daemon.c

@@ -159 +159 @@
               int          blocklistEnabled )
 {
     tr_benc       state, *dict = NULL;
-    int           peerPort = -1, peers = -1;
-    int           whitelistEnabled = -1;
-    int           pexEnabled = -1;
-    int           fwdEnabled = -1;
-    int           upLimit = -1, upLimited = -1, downLimit = -1,
-                  downLimited = -1;
-    int           encryption = -1;
-    int           useLazyBitfield = -1;
     tr_ctor *     ctor;
     tr_torrent ** torrents;
 
-    if( !tr_bencLoadJSONFile( myConfigFilename, &state ) )
+    int64_t numval;
+
+    // 1. get benclist with only default values
+
+    tr_benc * sessionConfig = tr_getDefaultSettings();
+
+    // 2. overwrite defaults with preferences from settings file
+    if( !tr_bencLoadJSONFile( myConfigFilename, &state ) ) {
         dict = &state;
+        tr_bencMergeDicts( sessionConfig, dict);
+    }
     
+    // 3. overwrite settings with preferences from the command line
+    if(rpcPort != -1 ) {
+        replaceInt( sessionConfig, TR_PREFS_KEY_RPC_PORT, rpcPort );
+    }
+    if(whitelist && *whitelist) {
+        replaceStr( sessionConfig, TR_PREFS_KEY_WHITELIST, whitelist );
+        replaceInt( sessionConfig, TR_PREFS_KEY_WHITELIST_ENABLED, TRUE );
+    }
+    if(authRequired != -1 && username && password) {
+        replaceInt( sessionConfig, TR_PREFS_KEY_RPC_AUTH_REQUIRED, authRequired );
+        replaceStr( sessionConfig, TR_PREFS_KEY_RPC_USERNAME, username );
+        replaceStr( sessionConfig, TR_PREFS_KEY_RPC_PASSWORD, password );
+    }
+    if(blocklistEnabled != -1) {
+        replaceInt( sessionConfig, TR_PREFS_KEY_BLOCKLIST, blocklistEnabled );
+    }
+    if(downloadDir != NULL) {
+        replaceStr( sessionConfig, TR_PREFS_KEY_DOWNLOAD_DIR, downloadDir );
+    }
 
-    /***
-    ****  Decide on which values to pass into tr_sessionInitFull().
-    ****  The command-line arguments are given precedence and
-    ****  the state file from the previous session is used as a fallback.
-    ****  If neither of those can be found, the TR_DEFAULT fields are used .
-    ***/
-
-    getConfigStr( dict, KEY_DOWNLOAD_DIR,      &downloadDir,       TR_DEFAULT_DOWNLOAD_DIR );
-    getConfigInt( dict, KEY_PEX_ENABLED,       &pexEnabled,        TR_DEFAULT_PEX_ENABLED );
-    getConfigInt( dict, KEY_PORT_FORWARDING,   &fwdEnabled,        TR_DEFAULT_PORT_FORWARDING_ENABLED );
-    getConfigInt( dict, KEY_PEER_PORT,         &peerPort,          TR_DEFAULT_PORT );
-    getConfigInt( dict, KEY_DSPEED,            &downLimit,         100 );
-    getConfigInt( dict, KEY_DSPEED_ENABLED,    &downLimited,       FALSE );
-    getConfigInt( dict, KEY_USPEED,            &upLimit,           100 );
-    getConfigInt( dict, KEY_USPEED_ENABLED,    &upLimited,         FALSE );
-    getConfigInt( dict, KEY_LAZY_BITFIELD,     &useLazyBitfield,   TR_DEFAULT_LAZY_BITFIELD_ENABLED );
-    getConfigInt( dict, KEY_PEER_LIMIT,        &peers,             TR_DEFAULT_GLOBAL_PEER_LIMIT );
-    getConfigInt( dict, KEY_BLOCKLIST,         &blocklistEnabled,  TR_DEFAULT_BLOCKLIST_ENABLED );
-    getConfigInt( dict, KEY_RPC_PORT,          &rpcPort,           TR_DEFAULT_RPC_PORT );
-    getConfigStr( dict, KEY_WHITELIST,         &whitelist,         TR_DEFAULT_RPC_WHITELIST );
-    getConfigInt( dict, KEY_AUTH_REQUIRED,     &authRequired,      FALSE );
-    getConfigStr( dict, KEY_USERNAME,          &username,          NULL );
-    getConfigStr( dict, KEY_PASSWORD,          &password,          NULL );
-    getConfigInt( dict, KEY_ENCRYPTION,        &encryption,        TR_DEFAULT_ENCRYPTION );
-
-    whitelistEnabled = whitelist && *whitelist;
-
-    /***
-    ****
-    ***/
 
-    /* start the session */
-    mySession = tr_sessionInitFull( configDir, "daemon", downloadDir,
-                                    pexEnabled, fwdEnabled, peerPort,
-                                    encryption,
-                                    useLazyBitfield,
-                                    upLimited, upLimit,
-                                    downLimited, downLimit,
-                                    peers,
-                                    TR_MSG_INF, 0,
-                                    blocklistEnabled,
-                                    TR_DEFAULT_PEER_SOCKET_TOS,
-                                    TRUE, rpcPort,
-                                    whitelistEnabled, whitelist,
-                                    authRequired, username, password,
-                                    TR_DEFAULT_PROXY_ENABLED,
-                                    TR_DEFAULT_PROXY,
-                                    TR_DEFAULT_PROXY_PORT,
-                                    TR_DEFAULT_PROXY_TYPE,
-                                    TR_DEFAULT_PROXY_AUTH_ENABLED,
-                                    TR_DEFAULT_PROXY_USERNAME,
-                                    TR_DEFAULT_PROXY_PASSWORD );
+    if(configDir && *configDir) {
+        replaceStr( sessionConfig, TR_PREFS_KEY_CONFIG_DIR, configDir );
+    }
 
+    /* start the session */
+    mySession = tr_sessionInitFull( sessionConfig );
 
-    if( authRequired )
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &numval ) );
+    if( numval != 0)
         tr_ninf( MY_NAME, "requiring authentication" );
 
     /* load the torrents */
@@ -237 +212 @@
     tr_free( torrents );
     tr_ctorFree( ctor );
 
+    tr_bencFree( sessionConfig );
+
     if( dict )
         tr_bencFree( &state );
 }

libtransmission/session.c

@@ -197 +197 @@
 ****
 ***/
 
+tr_benc * tr_getDefaultSettings( void ) {
+
+    tr_benc * d = tr_new0( tr_benc, 1 );
+
+    tr_bencInitDict( d, 28 );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL,           TR_DEFAULT_MSG_LEVEL );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_MSGQUEUE_ENABLED,   TR_DEFAULT_MSGQUEUE_ENABLED );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST,          TR_DEFAULT_BLOCKLIST_ENABLED );
+    tr_bencDictAddStr( d, TR_PREFS_KEY_CONFIG_DIR,         TR_DEFAULT_CONFIG_DIR );
+    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,       TR_DEFAULT_DOWNLOAD_DIR );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT,         TR_DEFAULT_GLOBAL_PEER_LIMIT );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT,          TR_DEFAULT_PORT );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,    TR_DEFAULT_PORT_FORWARDING_ENABLED );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS,    TR_DEFAULT_PEER_SOCKET_TOS );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,        TR_DEFAULT_PEX_ENABLED );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED,        TR_DEFAULT_RPC_ENABLED );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,           TR_DEFAULT_RPC_PORT );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,  TR_DEFAULT_RPC_AUTH_ENABLED );
+    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME,       NULL );
+    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD,       NULL );
+    tr_bencDictAddStr( d, TR_PREFS_KEY_WHITELIST,          TR_DEFAULT_RPC_WHITELIST );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED,             100 );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED,     0 );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,             100 );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,     0 );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED,      TR_DEFAULT_PROXY_ENABLED );
+    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,              TR_DEFAULT_PROXY );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT,         TR_DEFAULT_PROXY_PORT );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE,         TR_DEFAULT_PROXY_TYPE );
+    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED, TR_DEFAULT_ENCRYPTION );
+    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME,     TR_DEFAULT_PROXY_USERNAME );
+    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD,     TR_DEFAULT_PROXY_PASSWORD );
+
+    return d;
+}
+
 static void metainfoLookupRescan( tr_handle * h );
 
 tr_handle *
-tr_sessionInitFull( const char *       configDir,
-                    const char *       tag,
-                    const char *       downloadDir,
-                    int                isPexEnabled,
-                    int                isPortForwardingEnabled,
-                    int                publicPort,
-                    tr_encryption_mode encryptionMode,
-                    int                useLazyBitfield,
-                    int                useUploadLimit,
-                    int                uploadLimit,
-                    int                useDownloadLimit,
-                    int                downloadLimit,
-                    int                globalPeerLimit,
-                    int                messageLevel,
-                    int                isMessageQueueingEnabled,
-                    int                isBlocklistEnabled,
-                    int                peerSocketTOS,
-                    int                rpcIsEnabled,
-                    tr_port            rpcPort,
-                    int                rpcWhitelistIsEnabled,
-                    const char *       rpcWhitelist,
-                    int                rpcAuthIsEnabled,
-                    const char *       rpcUsername,
-                    const char *       rpcPassword,
-                    int                proxyIsEnabled,
-                    const char *       proxy,
-                    int                proxyPort,
-                    tr_proxy_type      proxyType,
-                    int                proxyAuthIsEnabled,
-                    const char *       proxyUsername,
-                    const char *       proxyPassword )
+tr_sessionInitFull( tr_benc * sessionConfig )
 {
     tr_handle * h;
     char      * filename;
+    int64_t numval,  publicPort;
+    int64_t rpc_enabled, whitelist_enabled, rpc_auth_enabled, rpc_port;
+    const char * whitelist = NULL, *rpc_passwd = NULL, *rpc_username = NULL;
+    const char * str = NULL;
 
 #ifndef WIN32
     /* Don't exit when writing on a broken socket */
@@ -241 +251 @@
 #endif
 
     tr_msgInit( );
-    tr_setMessageLevel( messageLevel );
-    tr_setMessageQueuing( isMessageQueueingEnabled );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_MSGLEVEL, &numval ) );
+    tr_setMessageLevel( numval );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_MSGQUEUE_ENABLED, &numval ) );
+    tr_setMessageQueuing( numval );
 
     h = tr_new0( tr_handle, 1 );
     h->lock = tr_lockNew( );
-    h->isPexEnabled = isPexEnabled ? 1 : 0;
-    h->encryptionMode = encryptionMode;
-    h->peerSocketTOS = peerSocketTOS;
-    h->downloadDir = tr_strdup( downloadDir );
-    h->isProxyEnabled = proxyIsEnabled ? 1 : 0;
-    h->proxy = tr_strdup( proxy );
-    h->proxyPort = proxyPort;
-    h->proxyType = proxyType;
-    h->isProxyAuthEnabled = proxyAuthIsEnabled != 0;
-    h->proxyUsername = tr_strdup( proxyUsername );
-    h->proxyPassword = tr_strdup( proxyPassword );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PEX_ENABLED, &numval) );
+    h->isPexEnabled = numval != 0;
+    assert(tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_ENCRYPTION, &numval ) );
+    h->encryptionMode = numval;
+    assert(tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PEER_SOCKET_TOS, &numval ) );
+    h->peerSocketTOS = numval;
+    assert(tr_bencDictFindStr( sessionConfig, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) );
+    h->downloadDir = tr_strdup( str );
+    assert(tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PROXY_ENABLED, &numval ) );
+    h->isProxyEnabled = numval != 0;
+    assert(tr_bencDictFindStr( sessionConfig, TR_PREFS_KEY_PROXY, &str ) );
+    h->proxy = tr_strdup( str );
+    assert(tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PROXY_PORT, &numval ) );
+    h->proxyPort = numval;
+    assert(tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PROXY_TYPE, &numval ) );
+    h->proxyType = numval;
+    assert(tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PROXY_AUTH_ENABLED, &numval ) );
+    h->isProxyAuthEnabled = numval != 0;
+    assert(tr_bencDictFindStr( sessionConfig, TR_PREFS_KEY_PROXY_USERNAME, &str ) );
+    h->proxyUsername = tr_strdup( str );
+    assert(tr_bencDictFindStr( sessionConfig, TR_PREFS_KEY_PROXY_PASSWORD, &str ) );
+    h->proxyPassword = tr_strdup( str );
+
     h->so_sndbuf = 1500 * 3; /* 3x MTU for most ethernet/wireless */
     h->so_rcvbuf = 8192;
 
-    if( configDir == NULL )
-        configDir = tr_getDefaultConfigDir( );
-    tr_setConfigDir( h, configDir );
+    assert( tr_bencDictFindStr( sessionConfig, TR_PREFS_KEY_CONFIG_DIR, &str ) );
+    tr_setConfigDir( h, str );
 
     tr_netInit( ); /* must go before tr_eventInit */
 
@@ -270 +293 @@
     while( !h->events )
         tr_wait( 50 );
 
-    h->tag = tr_strdup( tag );
+    assert( tr_bencDictFindStr( sessionConfig, "tag", &str ) );
+    h->tag = tr_strdup( str );
     h->peerMgr = tr_peerMgrNew( h );
 
-    h->useLazyBitfield = useLazyBitfield != 0;
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_LAZY_BITFIELD, &numval ) );
+    h->useLazyBitfield = numval != 0;
 
     /* Initialize rate and file descripts controls */
 
-    tr_fdInit( globalPeerLimit );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PEER_LIMIT, &numval ) );
+    tr_fdInit( numval );
     
     /* random port */
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PORT_FORWARDING, &numval ) );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PEER_PORT, &publicPort ) );
     if ( publicPort == -1 )
         publicPort = tr_cryptoWeakRandInt(PORT_RANDOM_MAX - PORT_RANDOM_MIN + 1) + PORT_RANDOM_MIN;
     
-    h->shared = tr_sharedInit( h, isPortForwardingEnabled, publicPort );
+    h->shared = tr_sharedInit( h, numval, publicPort );
     h->isPortSet = publicPort >= 0;
 
     h->bandwidth = tr_bandwidthNew( h, NULL );
-    tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_UP, uploadLimit );
-    tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_DOWN, downloadLimit );
-    tr_bandwidthSetLimited( h->bandwidth, TR_UP, useUploadLimit );
-    tr_bandwidthSetLimited( h->bandwidth, TR_DOWN, useDownloadLimit );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_USPEED, &numval) );
+    tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_UP, numval );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_DSPEED, &numval) );
+    tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_DOWN, numval );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_USPEED_ENABLED, &numval) );
+    tr_bandwidthSetLimited( h->bandwidth, TR_UP, numval);
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_DSPEED_ENABLED, &numval) );
+    tr_bandwidthSetLimited( h->bandwidth, TR_DOWN, numval);
 
     /* first %s is the application name
        second %s is the version number */
@@ -300 +332 @@
     filename = tr_buildPath( h->configDir, "blocklists", NULL );
     tr_mkdirp( filename, 0777 );
     tr_free( filename );
-    h->isBlocklistEnabled = isBlocklistEnabled;
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_BLOCKLIST, &numval) );
+    h->isBlocklistEnabled = numval;
     loadBlocklists( h );
 
     tr_statsInit( h );
 
     h->web = tr_webInit( h );
-    h->rpcServer = tr_rpcInit( h, rpcIsEnabled, rpcPort,
-                               rpcWhitelistIsEnabled, rpcWhitelist,
-                               rpcAuthIsEnabled, rpcUsername, rpcPassword );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_RPC_ENABLED, &rpc_enabled ) );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_RPC_PORT, &rpc_port ) );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_WHITELIST_ENABLED, &whitelist_enabled ) );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &rpc_auth_enabled ) );
+
+    assert( tr_bencDictFindStr( sessionConfig, TR_PREFS_KEY_WHITELIST, &whitelist ) );
+    assert( tr_bencDictFindStr( sessionConfig, TR_PREFS_KEY_RPC_USERNAME, &rpc_username ) );
+    assert( tr_bencDictFindStr( sessionConfig, TR_PREFS_KEY_RPC_PASSWORD, &rpc_passwd ) );
+
+    h->rpcServer = tr_rpcInit( h, rpc_enabled, rpc_port, whitelist_enabled, whitelist,
+                               rpc_auth_enabled, rpc_username, rpc_passwd );
 
     metainfoLookupRescan( h );
 
     return h;
 }
 
-tr_handle *
-tr_sessionInit( const char * configDir,
-                const char * tag )
-{
-    return tr_sessionInitFull( configDir,
-                               TR_DEFAULT_DOWNLOAD_DIR,
-                               tag,
-                               TR_DEFAULT_PEX_ENABLED,
-                               TR_DEFAULT_PORT_FORWARDING_ENABLED,
-                               -1, /* public port */
-                               TR_DEFAULT_ENCRYPTION, /* encryption mode */
-                               TR_DEFAULT_LAZY_BITFIELD_ENABLED,
-                               FALSE, /* use upload speed limit? */
-                               -1, /* upload speed limit */
-                               FALSE, /* use download speed limit? */
-                               -1, /* download speed limit */
-                               TR_DEFAULT_GLOBAL_PEER_LIMIT,
-                               TR_MSG_INF, /* message level */
-                               FALSE, /* is message queueing enabled? */
-                               FALSE, /* is the blocklist enabled? */
-                               TR_DEFAULT_PEER_SOCKET_TOS,
-                               TR_DEFAULT_RPC_ENABLED,
-                               TR_DEFAULT_RPC_PORT,
-                               TR_DEFAULT_RPC_WHITELIST_ENABLED,
-                               TR_DEFAULT_RPC_WHITELIST,
-                               FALSE,
-                               "fnord",
-                               "potzrebie",
-                               TR_DEFAULT_PROXY_ENABLED,
-                               TR_DEFAULT_PROXY,
-                               TR_DEFAULT_PROXY_PORT,
-                               TR_DEFAULT_PROXY_TYPE,
-                               TR_DEFAULT_PROXY_AUTH_ENABLED,
-                               TR_DEFAULT_PROXY_USERNAME,
-                               TR_DEFAULT_PROXY_PASSWORD );
-}
-
 /***
 ****
 ***/

libtransmission/transmission.h

@@ -59 +59 @@
 typedef uint16_t tr_port;
 typedef uint8_t tr_bool;
 
+#include "bencode.h"
+
 /**
  * @brief returns Transmission's default configuration file directory.
  *
@@ -119 +121 @@
 #endif
 /** @see tr_sessionInitFull */
 #define TR_DEFAULT_PEX_ENABLED              1
+#define TR_DEFAULT_MSG_LEVEL                TR_MSG_INF
+#define TR_DEFAULT_MSGQUEUE_ENABLED         0
 /** @see tr_sessionInitFull */
 #define TR_DEFAULT_PORT_FORWARDING_ENABLED  0
 /** @see tr_sessionInitFull */
@@ -136 +140 @@
 /** @see tr_sessionInitFull */
 #define TR_DEFAULT_BLOCKLIST_ENABLED        0
 /** @see tr_sessionInitFull */
-#define TR_DEFAULT_RPC_ENABLED              0
+#define TR_DEFAULT_RPC_ENABLED              1
+#define TR_DEFAULT_RPC_AUTH_ENABLED         0
 /** @see tr_sessionInitFull */
 #define TR_DEFAULT_RPC_PORT                 9091
 /** @see tr_sessionInitFull */
@@ -168 +173 @@
 }
 tr_encryption_mode;
 
+#define TR_PREFS_KEY_MSGLEVEL           "message-level"
+#define TR_PREFS_KEY_MSGQUEUE_ENABLED   "message-queue-enabled"
+#define TR_PREFS_KEY_BLOCKLIST          "blocklist-enabled"
+#define TR_PREFS_KEY_CONFIG_DIR         "config-dir"
+#define TR_PREFS_KEY_DOWNLOAD_DIR       "download-dir"
+#define TR_PREFS_KEY_ENCRYPTION         "encryption"
+#define TR_PREFS_KEY_LAZY_BITFIELD      "lazy-bitfield-enabled"
+#define TR_PREFS_KEY_PEER_LIMIT         "max-peers-global"
+#define TR_PREFS_KEY_PEER_PORT          "peer-port"
+#define TR_PREFS_KEY_PEER_SOCKET_TOS    "peer-socket-tos"
+#define TR_PREFS_KEY_PORT_FORWARDING    "port-forwarding-enabled"
+#define TR_PREFS_KEY_PEX_ENABLED        "pex-enabled"
+#define TR_PREFS_KEY_WHITELIST          "rpc-whitelist"
+#define TR_PREFS_KEY_WHITELIST_ENABLED  "rpc-whitelist-enabled"
+#define TR_PREFS_KEY_RPC_ENABLED        "rpc-enabled"
+#define TR_PREFS_KEY_RPC_PORT           "rpc-port"
+#define TR_PREFS_KEY_RPC_AUTH_REQUIRED  "rpc-authentication-required"
+#define TR_PREFS_KEY_RPC_USERNAME       "rpc-username"
+#define TR_PREFS_KEY_RPC_PASSWORD       "rpc-password"
+#define TR_PREFS_KEY_DSPEED             "download-limit"
+#define TR_PREFS_KEY_DSPEED_ENABLED     "download-limit-enabled"
+#define TR_PREFS_KEY_USPEED             "upload-limit"
+#define TR_PREFS_KEY_USPEED_ENABLED     "upload-limit-enabled"
+#define TR_PREFS_KEY_PROXY_ENABLED      "proxy-enabled"
+#define TR_PREFS_KEY_PROXY              "proxy"
+#define TR_PREFS_KEY_PROXY_PORT         "proxy-port"
+#define TR_PREFS_KEY_PROXY_TYPE         "proxy-type"
+#define TR_PREFS_KEY_PROXY_AUTH_ENABLED "proxy-auth-enabled"
+#define TR_PREFS_KEY_PROXY_USERNAME     "proxy-auth-username"
+#define TR_PREFS_KEY_PROXY_PASSWORD     "proxy-auth-password"
+
+tr_benc * tr_getDefaultSettings( void );
+
 /**
  * @brief Start a libtransmission session.
  * @return an opaque handle to the new session
@@ -264 +302 @@
  * @see TR_DEFAULT_RPC_WHITELIST_ENABLED
  * @see tr_sessionClose()
  */
-tr_session * tr_sessionInitFull( const char *       configDir,
-                                 const char *       tag,
-                                 const char *       downloadDir,
-                                 int                isPexEnabled,
-                                 int                isPortForwardingEnabled,
-                                 int                publicPort,
-                                 tr_encryption_mode encryptionMode,
-                                 int                useLazyBitfield,
-                                 int                useUploadLimit,
-                                 int                uploadLimit,
-                                 int                useDownloadLimit,
-                                 int                downloadLimit,
-                                 int                peerLimit,
-                                 int                messageLevel,
-                                 int                isMessageQueueingEnabled,
-                                 int                isBlocklistEnabled,
-                                 int                peerSocketTOS,
-                                 int                rpcIsEnabled,
-                                 tr_port            rpcPort,
-                                 int                rpcWhitelistIsEnabled,
-                                 const char *       rpcWhitelist,
-                                 int                rpcPasswordIsEnabled,
-                                 const char *       rpcUsername,
-                                 const char *       rpcPassword,
-                                 int                proxyIsEnabled,
-                                 const char *       proxy,
-                                 int                proxyPort,
-                                 tr_proxy_type      proxyType,
-                                 int                proxyAuthIsEnabled,
-                                 const char *       proxyUsername,
-                                 const char *       proxyPassword );
-
-
-/** @brief Shorter form of tr_sessionInitFull()
-    @deprecated Use tr_sessionInitFull() instead. */
-tr_session *  tr_sessionInit( const char * configDir,
-                              const char * tag );
+
+tr_session * tr_sessionInitFull( tr_benc * sessionConfig );
 
 /** @brief End a libtransmission session
     @see tr_sessionInitFull() */