Ticket #1559: session_init2.patch

daemon/daemon.c

@@ -166 +166 @@
               const char * password,
               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;
+    int64_t numval;
+
+    // 1. get benclist with only default values
+
+    tr_benc * sessionConfig = tr_getDefaultSettings();
 
-    if( !tr_bencLoadJSONFile( myConfigFilename, &state ) )
+    // 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 );
-    getConfigInt( dict, KEY_WHITELIST_ENABLED, &whitelistEnabled,
-                  TR_DEFAULT_RPC_WHITELIST_ENABLED );
-    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 );
-
-    /***
-    ****
-    ***/
+    if(configDir && *configDir) {
+        replaceStr( sessionConfig, TR_PREFS_KEY_CONFIG_DIR, configDir );
+    }
 
     /* 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 );
-
+    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 */
@@ -254 +220 @@
     tr_free( torrents );
     tr_ctorFree( ctor );
 
+    tr_bencFree( sessionConfig );
+
     if( dict )
         tr_bencFree( &state );
 }

libtransmission/bencode.c

@@ -1316 +1316 @@
 ****
 ***/
 
+struct mergeWalk
+{
+    const char* key;
+    tr_bool key_set;
+    struct tr_benc * b;
+};
+
+
+static void
+replaceInt( tr_benc *    dict, const char * key, int64_t value ) {
+    tr_bencDictRemove( dict, key );
+    tr_bencDictAddInt( dict, key, value );
+}
+
+static void
+replaceStr( tr_benc *    dict,  const char * key, const char*  value ) {
+    tr_bencDictRemove( dict, key );
+    tr_bencDictAddStr( dict, key, value );
+}
+
+static void
+mergeIntFunc( const tr_benc * val, void * vdata) {
+    struct mergeWalk * data = vdata;
+    assert(data->key_set == 1);
+    replaceInt(data->b, data->key, (int64_t)val->val.i);
+    data->key = NULL;
+    data->key_set = 0;
+}
+
+static void
+mergeStrFunc( const tr_benc * key, void * vdata ) {
+    struct mergeWalk * data = vdata;
+    assert(key != NULL);
+    if(data->key_set && key) {
+        replaceStr(data->b, data->key, key->val.s.s);
+        data->key = NULL;
+        data->key_set = 0;
+    } else {
+        data->key = key->val.s.s;
+        data->key_set = 1;
+    }
+}
+
+static void
+mergeDummyFunc( const tr_benc * val UNUSED, void * vdata UNUSED ) {
+}
+
+void
+tr_bencMergeDicts( tr_benc * b1, const tr_benc * b2) {
+    struct WalkFuncs walkFuncs;
+    struct mergeWalk data;
+
+    assert(b1 && b2);
+    walkFuncs.intFunc = mergeIntFunc;
+    walkFuncs.stringFunc = mergeStrFunc;
+    walkFuncs.dictBeginFunc = mergeDummyFunc;
+    walkFuncs.listBeginFunc = mergeDummyFunc;
+    walkFuncs.containerEndFunc = mergeDummyFunc;
+
+    data.key_set = 0;
+    data.key = NULL;
+    data.b = b1;
+
+    bencWalk( b2, &walkFuncs, &data );
+}
+
+/***
+****
+***/
+
 static int
 saveFile( const char * filename,
           const char * content,

libtransmission/bencode.h

@@ -13 +13 @@
 #ifndef TR_BENCODE_H
 #define TR_BENCODE_H 1
 
+#include <stdlib.h>
 #include <inttypes.h> /* for int64_t */
 
 enum
@@ -225 +226 @@
                      const uint8_t ** setme_str,
                      size_t *         setme_strlen );
 
+/***
+****
+***/
+
+void  tr_bencMergeDicts( tr_benc * b1, const tr_benc * b2);
+
+
 #endif

libtransmission/bencode-test.c

@@ -362 +362 @@
 }
 
 static int
+testMerge( void ) {
+    tr_benc dest, src;
+    int64_t i;
+    const char * s;
+
+    //initial dictionary (default values)
+
+    tr_bencInitDict(&dest, 10);
+    tr_bencDictAddInt(&dest, "i1", 1);
+    tr_bencDictAddInt(&dest, "i2", 2);
+    tr_bencDictAddInt(&dest, "i4", -35);      // remains untouched
+    tr_bencDictAddStr(&dest, "s5", "abc");
+    tr_bencDictAddStr(&dest, "s6", "def");
+    tr_bencDictAddStr(&dest, "s7", "127.0.0.1");  // remains untouched
+
+    //new dictionary, will overwrite items in dest
+
+    tr_bencInitDict(&src, 10);
+    tr_bencDictAddInt(&src, "i1", 1);   //same value
+    tr_bencDictAddInt(&src, "i2", 4);   //new value
+    tr_bencDictAddInt(&src, "i3", 3);   //new key:value
+    tr_bencDictAddStr(&src, "s5", "abc"); //same value
+    tr_bencDictAddStr(&src, "s6", "xyz"); //new value
+    tr_bencDictAddStr(&src, "s8", "ghi"); //new key:value
+
+    tr_bencMergeDicts( &dest, /*const*/ &src);
+
+    check( tr_bencDictFindInt( &dest, "i1", &i ) );
+    check( i == 1);
+    check( tr_bencDictFindInt( &dest, "i2", &i ) );
+    check( i == 4);
+    check( tr_bencDictFindInt( &dest, "i3", &i ) );
+    check( i == 3);
+    check( tr_bencDictFindInt( &dest, "i4", &i ) );
+    check( i == -35);
+    check( tr_bencDictFindStr( &dest, "s5", &s ) );
+    check(strcmp("abc", s) == 0);
+    check( tr_bencDictFindStr( &dest, "s6", &s ) );
+    check(strcmp("xyz", s) == 0);
+    check( tr_bencDictFindStr( &dest, "s7", &s ) );
+    check(strcmp("127.0.0.1", s) == 0);
+    check( tr_bencDictFindStr( &dest, "s8", &s ) );
+    check(strcmp("ghi", s) == 0);
+
+    tr_bencFree(&dest);
+    tr_bencFree(&src);
+    return 0;
+}
+
+static int
 testStackSmash( int depth )
 {
     int             i;
@@ -408 +458 @@
     if( ( i = testJSON( ) ) )
         return i;
 
+    if( ( i = testMerge( ) ) )
+        return i;
+
 #ifndef WIN32
     i = testStackSmash( 1000000 );
 #else

libtransmission/session.c

@@ -194 +194 @@
 ****
 ***/
 
+tr_benc * tr_getDefaultSettings( void ) {
+
+    tr_benc * d = tr_new0( tr_benc, 1 );
+
+    tr_bencInitDict( d, 16 );
+    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 */
@@ -238 +248 @@
 #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 */
 
@@ -267 +289 @@
     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 );
-    h->shared = tr_sharedInit( h, isPortForwardingEnabled, publicPort );
-    h->isPortSet = publicPort >= 0;
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PEER_LIMIT, &numval ) );
+    tr_fdInit( numval );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PORT_FORWARDING, &numval ) );
+    assert( tr_bencDictFindInt( sessionConfig, TR_PREFS_KEY_PEER_PORT, &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 */
@@ -292 +323 @@
     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

@@ -37 +37 @@
 #endif
 
 #include "version.h"
+#include "bencode.h"
 
 #include <inttypes.h> /* uintN_t */
 #ifndef PRId64
@@ -119 +120 @@
 #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 +139 @@
 /** @see tr_sessionInitFull */
 #define TR_DEFAULT_BLOCKLIST_ENABLED        0
 /** @see tr_sessionInitFull */
-#define TR_DEFAULT_RPC_ENABLED              0
+#define TR_DEFAULT_RPC_ENABLED              1
+/** @see tr_sessionInitFull */
+#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
@@ -263 +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() */