Ticket #1559: session_init.patch

File session_init.patch, 20.7 KB (added by KyleK, 12 years ago)
  • daemon/daemon.c

    diff -aBbur -x'*.m4' -x'*.Dpo' -x'autom4te*' -x'*.in*' -x'config.*' -x'*.a' -x'*.o' -x.svn -xconfigure Transmission-svn/daemon/daemon.c Transmission/daemon/daemon.c
    old new  
    166166              const char * password,
    167167              int          blocklistEnabled )
    168168{
     169
     170
    169171    tr_benc       state, *dict = NULL;
    170     int           peerPort = -1, peers = -1;
    171     int           whitelistEnabled = -1;
    172     int           pexEnabled = -1;
    173     int           fwdEnabled = -1;
    174     int           upLimit = -1, upLimited = -1, downLimit = -1,
    175                   downLimited = -1;
    176     int           encryption = -1;
    177     int           useLazyBitfield = -1;
    178172    tr_ctor *     ctor;
    179173    tr_torrent ** torrents;
    180174
     175    tr_sessionConfig_t * sessionConfig = tr_configNew();
     176
     177    sessionConfig->configDir = configDir;
     178    sessionConfig->downloadDir = downloadDir;
     179    sessionConfig->publicPort = rpcPort;
     180    sessionConfig->rpcWhitelist = whitelist;
     181    sessionConfig->rpcPasswordIsEnabled = authRequired;
     182    sessionConfig->rpcUsername = username;
     183    sessionConfig->rpcPassword = password;
     184    sessionConfig->isBlocklistEnabled = blocklistEnabled;
     185    sessionConfig->tag = "daemon";
     186
    181187    if( !tr_bencLoadJSONFile( myConfigFilename, &state ) )
    182188        dict = &state;
    183189
     
    188194    ****  If neither of those can be found, the TR_DEFAULT fields are used .
    189195    ***/
    190196
    191     getConfigStr( dict, KEY_DOWNLOAD_DIR,    &downloadDir,
    192                   TR_DEFAULT_DOWNLOAD_DIR );
    193     getConfigInt( dict, KEY_PEX_ENABLED,     &pexEnabled,
    194                   TR_DEFAULT_PEX_ENABLED );
    195     getConfigInt( dict, KEY_PORT_FORWARDING, &fwdEnabled,
     197    getConfigStr( dict, KEY_DOWNLOAD_DIR,    &sessionConfig->downloadDir, TR_DEFAULT_DOWNLOAD_DIR );
     198    getConfigInt( dict, KEY_PEX_ENABLED,     &sessionConfig->isPexEnabled, TR_DEFAULT_PEX_ENABLED );
     199    getConfigInt( dict, KEY_PORT_FORWARDING, &sessionConfig->isPortForwardingEnabled,
    196200                  TR_DEFAULT_PORT_FORWARDING_ENABLED );
    197     getConfigInt( dict, KEY_PEER_PORT,       &peerPort,
    198                   TR_DEFAULT_PORT );
    199     getConfigInt( dict, KEY_DSPEED,          &downLimit,         100 );
    200     getConfigInt( dict, KEY_DSPEED_ENABLED,  &downLimited,       FALSE );
    201     getConfigInt( dict, KEY_USPEED,          &upLimit,           100 );
    202     getConfigInt( dict, KEY_USPEED_ENABLED,  &upLimited,         FALSE );
    203     getConfigInt( dict, KEY_LAZY_BITFIELD,   &useLazyBitfield,
     201    getConfigInt( dict, KEY_PEER_PORT,       &sessionConfig->publicPort, TR_DEFAULT_PORT );
     202    getConfigInt( dict, KEY_DSPEED,          &sessionConfig->downloadLimit,         100 );
     203    getConfigInt( dict, KEY_DSPEED_ENABLED,  &sessionConfig->isDownloadLimitEnabled,       FALSE );
     204    getConfigInt( dict, KEY_USPEED,          &sessionConfig->uploadLimit,           100 );
     205    getConfigInt( dict, KEY_USPEED_ENABLED,  &sessionConfig->isUploadLimitEnabled,         FALSE );
     206    getConfigInt( dict, KEY_LAZY_BITFIELD,   &sessionConfig->useLazyBitfield,
    204207                  TR_DEFAULT_LAZY_BITFIELD_ENABLED );
    205     getConfigInt( dict, KEY_PEER_LIMIT,      &peers,
    206                   TR_DEFAULT_GLOBAL_PEER_LIMIT );
    207     getConfigInt( dict, KEY_BLOCKLIST,       &blocklistEnabled,
     208    getConfigInt( dict, KEY_PEER_LIMIT,      &sessionConfig->peerLimit, TR_DEFAULT_GLOBAL_PEER_LIMIT );
     209    getConfigInt( dict, KEY_BLOCKLIST,       &sessionConfig->isBlocklistEnabled,
    208210                  TR_DEFAULT_BLOCKLIST_ENABLED );
    209     getConfigInt( dict, KEY_RPC_PORT,        &rpcPort,
    210                   TR_DEFAULT_RPC_PORT );
    211     getConfigInt( dict, KEY_WHITELIST_ENABLED, &whitelistEnabled,
     211    getConfigInt( dict, KEY_RPC_PORT,        &sessionConfig->rpcPort, TR_DEFAULT_RPC_PORT );
     212    getConfigInt( dict, KEY_WHITELIST_ENABLED, &sessionConfig->rpcWhitelistIsEnabled,
    212213                  TR_DEFAULT_RPC_WHITELIST_ENABLED );
    213     getConfigStr( dict, KEY_WHITELIST,       &whitelist,
    214                   TR_DEFAULT_RPC_WHITELIST );
    215     getConfigInt( dict, KEY_AUTH_REQUIRED,   &authRequired,      FALSE );
    216     getConfigStr( dict, KEY_USERNAME,        &username,          NULL );
    217     getConfigStr( dict, KEY_PASSWORD,        &password,          NULL );
    218     getConfigInt( dict, KEY_ENCRYPTION,      &encryption,
    219                   TR_DEFAULT_ENCRYPTION );
     214    getConfigStr( dict, KEY_WHITELIST,       &sessionConfig->rpcWhitelist, TR_DEFAULT_RPC_WHITELIST );
     215    getConfigInt( dict, KEY_AUTH_REQUIRED,   &sessionConfig->rpcPasswordIsEnabled,      FALSE );
     216    getConfigStr( dict, KEY_USERNAME,        &sessionConfig->rpcUsername,          NULL );
     217    getConfigStr( dict, KEY_PASSWORD,        &sessionConfig->rpcPassword,          NULL );
     218    tr_inf("sessionConfig->encryptionMode: %d (before)", sessionConfig->encryptionMode);
     219    getConfigInt( dict, KEY_ENCRYPTION,      (int*)&sessionConfig->encryptionMode, TR_DEFAULT_ENCRYPTION );
     220    tr_inf("sessionConfig->encryptionMode: %d (after)", sessionConfig->encryptionMode);
     221
     222    sessionConfig->messageLevel       = TR_MSG_INF;
     223    sessionConfig->isMessageQueueingEnabled = FALSE;
     224    sessionConfig->peerSocketTOS      = TR_DEFAULT_PEER_SOCKET_TOS;
     225    sessionConfig->rpcIsEnabled       = TRUE;
     226    sessionConfig->proxyIsEnabled     = TR_DEFAULT_PROXY_ENABLED;
     227    sessionConfig->proxy              = TR_DEFAULT_PROXY;
     228    sessionConfig->proxyPort          = TR_DEFAULT_PROXY_PORT;
     229    sessionConfig->proxyType          = TR_DEFAULT_PROXY_TYPE;
     230    sessionConfig->proxyAuthIsEnabled = TR_DEFAULT_PROXY_AUTH_ENABLED;
     231    sessionConfig->proxyUsername      = TR_DEFAULT_PROXY_USERNAME;
     232    sessionConfig->proxyPassword      = TR_DEFAULT_PROXY_PASSWORD;
    220233
    221234    /***
    222235    ****
    223236    ***/
    224237
    225238    /* start the session */
    226     mySession = tr_sessionInitFull( configDir, "daemon", downloadDir,
    227                                     pexEnabled, fwdEnabled, peerPort,
    228                                     encryption,
    229                                     useLazyBitfield,
    230                                     upLimited, upLimit,
    231                                     downLimited, downLimit,
    232                                     peers,
    233                                     TR_MSG_INF, 0,
    234                                     blocklistEnabled,
    235                                     TR_DEFAULT_PEER_SOCKET_TOS,
    236                                     TRUE, rpcPort,
    237                                     whitelistEnabled, whitelist,
    238                                     authRequired, username, password,
    239                                     TR_DEFAULT_PROXY_ENABLED,
    240                                     TR_DEFAULT_PROXY,
    241                                     TR_DEFAULT_PROXY_PORT,
    242                                     TR_DEFAULT_PROXY_TYPE,
    243                                     TR_DEFAULT_PROXY_AUTH_ENABLED,
    244                                     TR_DEFAULT_PROXY_USERNAME,
    245                                     TR_DEFAULT_PROXY_PASSWORD );
    246 
     239    mySession = tr_sessionInitFull( sessionConfig );
    247240
    248     if( authRequired )
     241    if( sessionConfig->rpcPasswordIsEnabled)
    249242        tr_ninf( MY_NAME, "requiring authentication" );
    250243
    251244    /* load the torrents */
     
    254247    tr_free( torrents );
    255248    tr_ctorFree( ctor );
    256249
     250    tr_free( sessionConfig );
     251
    257252    if( dict )
    258253        tr_bencFree( &state );
    259254}
  • libtransmission/session.c

    diff -aBbur -x'*.m4' -x'*.Dpo' -x'autom4te*' -x'*.in*' -x'config.*' -x'*.a' -x'*.o' -x.svn -xconfigure Transmission-svn/libtransmission/session.c Transmission/libtransmission/session.c
    old new  
    194194****
    195195***/
    196196
     197
     198tr_sessionConfig_t * tr_configNew( void ) {
     199    tr_sessionConfig_t * config = tr_new0( tr_sessionConfig_t, 1 );
     200    config->isPexEnabled = -1;
     201    config->isPortForwardingEnabled = -1;
     202    config->publicPort = -1;
     203    config->encryptionMode = -1;
     204    config->useLazyBitfield = -1;
     205    config->isUploadLimitEnabled = -1;
     206    config->uploadLimit = -1;
     207    config->isDownloadLimitEnabled = -1;
     208    config->downloadLimit = -1;
     209    config->peerLimit = -1;
     210    config->messageLevel = -1;
     211    config->isMessageQueueingEnabled = -1;
     212    config->isBlocklistEnabled = -1;
     213    config->peerSocketTOS = -1;
     214    config->rpcIsEnabled = -1;
     215    config->rpcPort = -1;
     216    config->rpcWhitelistIsEnabled = -1;
     217    config->proxyIsEnabled = -1;
     218    config->proxyPort = -1;
     219    config->proxyType = -1;
     220    config->proxyAuthIsEnabled = -1;
     221
     222    return config;
     223}
     224
    197225static void metainfoLookupRescan( tr_handle * h );
    198226
    199227tr_handle *
    200 tr_sessionInitFull( const char *       configDir,
    201                     const char *       tag,
    202                     const char *       downloadDir,
    203                     int                isPexEnabled,
    204                     int                isPortForwardingEnabled,
    205                     int                publicPort,
    206                     tr_encryption_mode encryptionMode,
    207                     int                useLazyBitfield,
    208                     int                useUploadLimit,
    209                     int                uploadLimit,
    210                     int                useDownloadLimit,
    211                     int                downloadLimit,
    212                     int                globalPeerLimit,
    213                     int                messageLevel,
    214                     int                isMessageQueueingEnabled,
    215                     int                isBlocklistEnabled,
    216                     int                peerSocketTOS,
    217                     int                rpcIsEnabled,
    218                     tr_port            rpcPort,
    219                     int                rpcWhitelistIsEnabled,
    220                     const char *       rpcWhitelist,
    221                     int                rpcAuthIsEnabled,
    222                     const char *       rpcUsername,
    223                     const char *       rpcPassword,
    224                     int                proxyIsEnabled,
    225                     const char *       proxy,
    226                     int                proxyPort,
    227                     tr_proxy_type      proxyType,
    228                     int                proxyAuthIsEnabled,
    229                     const char *       proxyUsername,
    230                     const char *       proxyPassword )
     228tr_sessionInitFull( tr_sessionConfig_t * sessionConfig )
    231229{
    232230    tr_handle * h;
    233231    char      * filename;
     
    238236#endif
    239237
    240238    tr_msgInit( );
    241     tr_setMessageLevel( messageLevel );
    242     tr_setMessageQueuing( isMessageQueueingEnabled );
     239    tr_setMessageLevel( sessionConfig->messageLevel );
     240    tr_setMessageQueuing( sessionConfig->isMessageQueueingEnabled );
    243241
    244242    h = tr_new0( tr_handle, 1 );
    245243    h->lock = tr_lockNew( );
    246     h->isPexEnabled = isPexEnabled ? 1 : 0;
    247     h->encryptionMode = encryptionMode;
    248     h->peerSocketTOS = peerSocketTOS;
    249     h->downloadDir = tr_strdup( downloadDir );
    250     h->isProxyEnabled = proxyIsEnabled ? 1 : 0;
    251     h->proxy = tr_strdup( proxy );
    252     h->proxyPort = proxyPort;
    253     h->proxyType = proxyType;
    254     h->isProxyAuthEnabled = proxyAuthIsEnabled != 0;
    255     h->proxyUsername = tr_strdup( proxyUsername );
    256     h->proxyPassword = tr_strdup( proxyPassword );
     244    h->isPexEnabled = sessionConfig->isPexEnabled ? 1 : 0;
     245    h->encryptionMode = sessionConfig->encryptionMode;
     246    h->peerSocketTOS = sessionConfig->peerSocketTOS;
     247    h->downloadDir = tr_strdup( sessionConfig->downloadDir );
     248    h->isProxyEnabled = sessionConfig->proxyIsEnabled ? 1 : 0;
     249    h->proxy = tr_strdup( sessionConfig->proxy );
     250    h->proxyPort = sessionConfig->proxyPort;
     251    h->proxyType = sessionConfig->proxyType;
     252    h->isProxyAuthEnabled = sessionConfig->proxyAuthIsEnabled != 0;
     253    h->proxyUsername = tr_strdup( sessionConfig->proxyUsername );
     254    h->proxyPassword = tr_strdup( sessionConfig->proxyPassword );
    257255    h->so_sndbuf = 1500 * 3; /* 3x MTU for most ethernet/wireless */
    258256    h->so_rcvbuf = 8192;
    259257
    260     if( configDir == NULL )
    261         configDir = tr_getDefaultConfigDir( );
    262     tr_setConfigDir( h, configDir );
     258    if( sessionConfig->configDir == NULL )
     259        sessionConfig->configDir = tr_getDefaultConfigDir( );
     260    tr_setConfigDir( h, sessionConfig->configDir );
    263261
    264262    tr_netInit( ); /* must go before tr_eventInit */
    265263
     
    267265    while( !h->events )
    268266        tr_wait( 50 );
    269267
    270     h->tag = tr_strdup( tag );
     268    h->tag = tr_strdup( sessionConfig->tag );
    271269    h->peerMgr = tr_peerMgrNew( h );
    272270
    273     h->useLazyBitfield = useLazyBitfield != 0;
     271    h->useLazyBitfield = sessionConfig->useLazyBitfield != 0;
    274272
    275273    /* Initialize rate and file descripts controls */
    276274
    277     tr_fdInit( globalPeerLimit );
    278     h->shared = tr_sharedInit( h, isPortForwardingEnabled, publicPort );
    279     h->isPortSet = publicPort >= 0;
     275    tr_fdInit( sessionConfig->peerLimit );
     276    h->shared = tr_sharedInit( h, sessionConfig->isPortForwardingEnabled, sessionConfig->publicPort );
     277    h->isPortSet = (sessionConfig->publicPort >= 0);
    280278
    281279    h->bandwidth = tr_bandwidthNew( h, NULL );
    282     tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_UP, uploadLimit );
    283     tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_DOWN, downloadLimit );
    284     tr_bandwidthSetLimited( h->bandwidth, TR_UP, useUploadLimit );
    285     tr_bandwidthSetLimited( h->bandwidth, TR_DOWN, useDownloadLimit );
     280    tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_UP, sessionConfig->uploadLimit );
     281    tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_DOWN, sessionConfig->downloadLimit );
     282    tr_bandwidthSetLimited( h->bandwidth, TR_UP, sessionConfig->isUploadLimitEnabled );
     283    tr_bandwidthSetLimited( h->bandwidth, TR_DOWN, sessionConfig->isDownloadLimitEnabled);
    286284
    287285    /* first %s is the application name
    288286       second %s is the version number */
     
    292290    filename = tr_buildPath( h->configDir, "blocklists", NULL );
    293291    tr_mkdirp( filename, 0777 );
    294292    tr_free( filename );
    295     h->isBlocklistEnabled = isBlocklistEnabled;
     293    h->isBlocklistEnabled = sessionConfig->isBlocklistEnabled;
    296294    loadBlocklists( h );
    297295
    298296    tr_statsInit( h );
    299297
    300298    h->web = tr_webInit( h );
    301     h->rpcServer = tr_rpcInit( h, rpcIsEnabled, rpcPort,
    302                                rpcWhitelistIsEnabled, rpcWhitelist,
    303                                rpcAuthIsEnabled, rpcUsername, rpcPassword );
     299    h->rpcServer = tr_rpcInit( h, sessionConfig->rpcIsEnabled, sessionConfig->rpcPort,
     300                               sessionConfig->rpcWhitelistIsEnabled, sessionConfig->rpcWhitelist,
     301                               sessionConfig->rpcPasswordIsEnabled, sessionConfig->rpcUsername,
     302                               sessionConfig->rpcPassword );
    304303
    305304    metainfoLookupRescan( h );
    306305
    307306    return h;
    308307}
    309308
    310 tr_handle *
    311 tr_sessionInit( const char * configDir,
    312                 const char * tag )
    313 {
    314     return tr_sessionInitFull( configDir,
    315                                TR_DEFAULT_DOWNLOAD_DIR,
    316                                tag,
    317                                TR_DEFAULT_PEX_ENABLED,
    318                                TR_DEFAULT_PORT_FORWARDING_ENABLED,
    319                                -1, /* public port */
    320                                TR_DEFAULT_ENCRYPTION, /* encryption mode */
    321                                TR_DEFAULT_LAZY_BITFIELD_ENABLED,
    322                                FALSE, /* use upload speed limit? */
    323                                -1, /* upload speed limit */
    324                                FALSE, /* use download speed limit? */
    325                                -1, /* download speed limit */
    326                                TR_DEFAULT_GLOBAL_PEER_LIMIT,
    327                                TR_MSG_INF, /* message level */
    328                                FALSE, /* is message queueing enabled? */
    329                                FALSE, /* is the blocklist enabled? */
    330                                TR_DEFAULT_PEER_SOCKET_TOS,
    331                                TR_DEFAULT_RPC_ENABLED,
    332                                TR_DEFAULT_RPC_PORT,
    333                                TR_DEFAULT_RPC_WHITELIST_ENABLED,
    334                                TR_DEFAULT_RPC_WHITELIST,
    335                                FALSE,
    336                                "fnord",
    337                                "potzrebie",
    338                                TR_DEFAULT_PROXY_ENABLED,
    339                                TR_DEFAULT_PROXY,
    340                                TR_DEFAULT_PROXY_PORT,
    341                                TR_DEFAULT_PROXY_TYPE,
    342                                TR_DEFAULT_PROXY_AUTH_ENABLED,
    343                                TR_DEFAULT_PROXY_USERNAME,
    344                                TR_DEFAULT_PROXY_PASSWORD );
    345 }
    346 
    347309/***
    348310****
    349311***/
  • libtransmission/transmission.h

    diff -aBbur -x'*.m4' -x'*.Dpo' -x'autom4te*' -x'*.in*' -x'config.*' -x'*.a' -x'*.o' -x.svn -xconfigure Transmission-svn/libtransmission/transmission.h Transmission/libtransmission/transmission.h
    old new  
    168168}
    169169tr_encryption_mode;
    170170
     171
     172typedef struct tr_sessionConfig_t {
     173
     174  const char *       configDir;
     175  const char *       downloadDir;
     176  const char *       tag;
     177  int                isPexEnabled;
     178  int                isPortForwardingEnabled;
     179  int                publicPort;
     180  tr_encryption_mode encryptionMode;
     181  int                useLazyBitfield;
     182  int                isUploadLimitEnabled;
     183  int                uploadLimit;
     184  int                isDownloadLimitEnabled;
     185  int                downloadLimit;
     186  int                peerLimit;
     187  int                messageLevel;
     188  int                isMessageQueueingEnabled;
     189  int                isBlocklistEnabled;
     190  int                peerSocketTOS;
     191  int                rpcIsEnabled;
     192  int                rpcPort;
     193  int                rpcWhitelistIsEnabled;
     194  const char *       rpcWhitelist;
     195  int                rpcPasswordIsEnabled;
     196  const char *       rpcUsername;
     197  const char *       rpcPassword;
     198  int                proxyIsEnabled;
     199  const char *       proxy;
     200  int                proxyPort;
     201  tr_proxy_type      proxyType;
     202  int                proxyAuthIsEnabled;
     203  const char *       proxyUsername;
     204  const char *       proxyPassword;
     205} tr_sessionConfig_t;
     206
     207tr_sessionConfig_t * tr_configNew( void );
     208
    171209/**
    172210 * @brief Start a libtransmission session.
    173211 * @return an opaque handle to the new session
     
    263301 * @see TR_DEFAULT_RPC_WHITELIST_ENABLED
    264302 * @see tr_sessionClose()
    265303 */
    266 tr_session * tr_sessionInitFull( const char *       configDir,
    267                                  const char *       tag,
    268                                  const char *       downloadDir,
    269                                  int                isPexEnabled,
    270                                  int                isPortForwardingEnabled,
    271                                  int                publicPort,
    272                                  tr_encryption_mode encryptionMode,
    273                                  int                useLazyBitfield,
    274                                  int                useUploadLimit,
    275                                  int                uploadLimit,
    276                                  int                useDownloadLimit,
    277                                  int                downloadLimit,
    278                                  int                peerLimit,
    279                                  int                messageLevel,
    280                                  int                isMessageQueueingEnabled,
    281                                  int                isBlocklistEnabled,
    282                                  int                peerSocketTOS,
    283                                  int                rpcIsEnabled,
    284                                  tr_port            rpcPort,
    285                                  int                rpcWhitelistIsEnabled,
    286                                  const char *       rpcWhitelist,
    287                                  int                rpcPasswordIsEnabled,
    288                                  const char *       rpcUsername,
    289                                  const char *       rpcPassword,
    290                                  int                proxyIsEnabled,
    291                                  const char *       proxy,
    292                                  int                proxyPort,
    293                                  tr_proxy_type      proxyType,
    294                                  int                proxyAuthIsEnabled,
    295                                  const char *       proxyUsername,
    296                                  const char *       proxyPassword );
    297 
    298 
    299 /** @brief Shorter form of tr_sessionInitFull()
    300     @deprecated Use tr_sessionInitFull() instead. */
    301 tr_session *  tr_sessionInit( const char * configDir,
    302                               const char * tag );
     304tr_session * tr_sessionInitFull( tr_sessionConfig_t * sessionConfig );
     305
    303306
    304307/** @brief End a libtransmission session
    305308    @see tr_sessionInitFull() */