Changeset 6120


Ignore:
Timestamp:
Jun 10, 2008, 4:16:31 PM (14 years ago)
Author:
charles
Message:

wire up the backend proxy support.

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/transmissioncli.c

    r6091 r6120  
    180180            TR_DEFAULT_RPC_PORT,
    181181            TR_DEFAULT_RPC_ACL,
    182             FALSE, "fnord", "potzrebie" );
     182            FALSE, "fnord", "potzrebie",
     183            TR_DEFAULT_PROXY_ENABLED,
     184            TR_DEFAULT_PROXY,
     185            TR_DEFAULT_PROXY_AUTH_ENABLED,
     186            TR_DEFAULT_PROXY_USERNAME,
     187            TR_DEFAULT_PROXY_PASSWORD );
    183188
    184189    if( sourceFile && *sourceFile ) /* creating a torrent */
  • trunk/daemon/daemon.c

    r6055 r6120  
    180180                                    TR_DEFAULT_PEER_SOCKET_TOS,
    181181                                    TRUE, rpc_port, acl,
    182                                     auth_required, user, pass );
     182                                    auth_required, user, pass,
     183                                    TR_DEFAULT_PROXY_ENABLED,
     184                                    TR_DEFAULT_PROXY,
     185                                    TR_DEFAULT_PROXY_AUTH_ENABLED,
     186                                    TR_DEFAULT_PROXY_USERNAME,
     187                                    TR_DEFAULT_PROXY_PASSWORD );
     188
    183189
    184190    if( auth_required )
  • trunk/gtk/main.c

    r6118 r6120  
    432432                            pref_flag_get( PREF_KEY_RPC_AUTH_ENABLED ),
    433433                            pref_string_get( PREF_KEY_RPC_USERNAME ),
    434                             pref_string_get( PREF_KEY_RPC_PASSWORD ) );
     434                            pref_string_get( PREF_KEY_RPC_PASSWORD ),
     435                            pref_flag_get( PREF_KEY_PROXY_SERVER_ENABLED ),
     436                            pref_string_get( PREF_KEY_PROXY_SERVER ),
     437                            pref_flag_get( PREF_KEY_PROXY_AUTH_ENABLED ),
     438                            pref_string_get( PREF_KEY_PROXY_USERNAME ),
     439                            pref_string_get( PREF_KEY_PROXY_PASSWORD ) );
     440
    435441        cbdata->core = tr_core_new( h );
    436442
     
    970976    else if( !strcmp( key, PREF_KEY_PROXY_SERVER ) )
    971977    {
    972         g_message( "FIXME" );
     978        char * s = pref_string_get( key );
     979        tr_sessionSetProxy( tr, s );
     980        g_free( s );
    973981    }
    974982    else if( !strcmp( key, PREF_KEY_PROXY_SERVER_ENABLED ) )
    975983    {
    976         g_message( "FIXME" );
     984        const gboolean enabled = pref_flag_get( key );
     985        tr_sessionSetProxyEnabled( tr, enabled );
    977986    }
    978987    else if( !strcmp( key, PREF_KEY_PROXY_AUTH_ENABLED ) )
    979988    {
    980         g_message( "FIXME" );
     989        const gboolean enabled = pref_flag_get( key );
     990        tr_sessionSetProxyAuthEnabled( tr, enabled );
    981991    }
    982992    else if( !strcmp( key, PREF_KEY_PROXY_USERNAME ) )
    983993    {
    984         g_message( "FIXME" );
     994        char * s = pref_string_get( key );
     995        tr_sessionSetProxyUsername( tr, s );
     996        g_free( s );
    985997    }
    986998    else if( !strcmp( key, PREF_KEY_PROXY_PASSWORD ) )
    987999    {
    988         g_message( "FIXME" );
     1000        char * s = pref_string_get( key );
     1001        tr_sessionSetProxyPassword( tr, s );
     1002        g_free( s );
    9891003    }
    9901004}
  • trunk/libtransmission/session.c

    r6049 r6120  
    120120
    121121tr_handle *
    122 tr_sessionInitFull( const char * configDir,
    123                     const char * downloadDir,
    124                     const char * tag,
    125                     int          isPexEnabled,
    126                     int          isPortForwardingEnabled,
    127                     int          publicPort,
    128                     int          encryptionMode,
    129                     int          isUploadLimitEnabled,
    130                     int          uploadLimit,
    131                     int          isDownloadLimitEnabled,
    132                     int          downloadLimit,
    133                     int          globalPeerLimit,
    134                     int          messageLevel,
    135                     int          isMessageQueueingEnabled,
    136                     int          isBlocklistEnabled,
    137                     int          peerSocketTOS,
    138                     int          rpcIsEnabled,
    139                     int          rpcPort,
    140                     const char * rpcACL,
    141                     int          rpcPasswordIsEnabled,
    142                     const char * rpcUsername,
    143                     const char * rpcPassword )
     122tr_sessionInitFull( const char  * configDir,
     123                    const char  * downloadDir,
     124                    const char  * tag,
     125                    int           isPexEnabled,
     126                    int           isPortForwardingEnabled,
     127                    int           publicPort,
     128                    int           encryptionMode,
     129                    int           isUploadLimitEnabled,
     130                    int           uploadLimit,
     131                    int           isDownloadLimitEnabled,
     132                    int           downloadLimit,
     133                    int           globalPeerLimit,
     134                    int           messageLevel,
     135                    int           isMessageQueueingEnabled,
     136                    int           isBlocklistEnabled,
     137                    int           peerSocketTOS,
     138                    int           rpcIsEnabled,
     139                    int           rpcPort,
     140                    const char  * rpcACL,
     141                    int           rpcAuthIsEnabled,
     142                    const char  * rpcUsername,
     143                    const char  * rpcPassword,
     144                    int           proxyIsEnabled,
     145                    const char  * proxy,
     146                    int           proxyAuthIsEnabled,
     147                    const char  * proxyUsername,
     148                    const char  * proxyPassword )
    144149{
    145150    tr_handle * h;
     
    164169    h->peerSocketTOS = peerSocketTOS;
    165170    h->downloadDir = tr_strdup( downloadDir );
     171    h->isProxyEnabled = proxyIsEnabled ? 1 : 0;
     172    h->proxy = tr_strdup( proxy );
     173    h->isProxyAuthEnabled = proxyAuthIsEnabled ? 1 : 0;
     174    h->proxyUsername = tr_strdup( proxyUsername );
     175    h->proxyPassword = tr_strdup( proxyPassword );
    166176
    167177    tr_setConfigDir( h, configDir );
     
    204214    h->web = tr_webInit( h );
    205215    h->rpcServer = tr_rpcInit( h, rpcIsEnabled, rpcPort, rpcACL,
    206                                   rpcPasswordIsEnabled, rpcUsername, rpcPassword );
     216                                  rpcAuthIsEnabled, rpcUsername, rpcPassword );
    207217
    208218    metainfoLookupRescan( h );
     
    237247                               FALSE,
    238248                               "fnord",
    239                                "potzrebie" );
     249                               "potzrebie",
     250                               TR_DEFAULT_PROXY_ENABLED,
     251                               TR_DEFAULT_PROXY,
     252                               TR_DEFAULT_PROXY_AUTH_ENABLED,
     253                               TR_DEFAULT_PROXY_USERNAME,
     254                               TR_DEFAULT_PROXY_PASSWORD );
     255
    240256}
    241257
     
    488504    tr_free( h->torrentDir );
    489505    tr_free( h->downloadDir );
     506    tr_free( h->proxy );
     507    tr_free( h->proxyUsername );
     508    tr_free( h->proxyPassword );
    490509    free( h );
    491510}
     
    755774
    756775void
    757 tr_sessionSetRPCEnabled( tr_handle * session, int isEnabled )
     776tr_sessionSetRPCEnabled( tr_session * session, int isEnabled )
    758777{
    759778    tr_rpcSetEnabled( session->rpcServer, isEnabled );
    760779}
    761780int
    762 tr_sessionIsRPCEnabled( const tr_handle * session )
     781tr_sessionIsRPCEnabled( const tr_session * session )
    763782{
    764783    return tr_rpcIsEnabled( session->rpcServer );
    765784}
    766785void
    767 tr_sessionSetRPCPort( tr_handle * session, int port )
     786tr_sessionSetRPCPort( tr_session * session, int port )
    768787{
    769788    tr_rpcSetPort( session->rpcServer, port );
    770789}
    771790int
    772 tr_sessionGetRPCPort( const tr_handle * session )
     791tr_sessionGetRPCPort( const tr_session * session )
    773792{
    774793    return tr_rpcGetPort( session->rpcServer );
    775794}
    776795void
    777 tr_sessionSetRPCCallback( tr_handle    * session,
     796tr_sessionSetRPCCallback( tr_session    * session,
    778797                          tr_rpc_func    func,
    779798                          void         * user_data )
     
    782801    session->rpc_func_user_data = user_data;
    783802}
    784 
    785 int
    786 tr_sessionTestRPCACL( const tr_handle  * session,
     803int
     804tr_sessionTestRPCACL( const tr_session  * session,
    787805                      const char       * acl,
    788806                      char            ** allocme_errmsg )
     
    790808    return tr_rpcTestACL( session->rpcServer, acl, allocme_errmsg );
    791809}
    792 
    793 int
    794 tr_sessionSetRPCACL( tr_handle    * session,
     810int
     811tr_sessionSetRPCACL( tr_session    * session,
    795812                     const char   * acl,
    796813                     char        ** allocme_errmsg )
     
    798815    return tr_rpcSetACL( session->rpcServer, acl, allocme_errmsg );
    799816}
    800 
    801817char*
    802818tr_sessionGetRPCACL( const tr_session * session )
     
    804820    return tr_rpcGetACL( session->rpcServer );
    805821}
    806 
    807 void
    808 tr_sessionSetRPCPassword( tr_handle * session, const char * password )
     822void
     823tr_sessionSetRPCPassword( tr_session * session, const char * password )
    809824{
    810825    tr_rpcSetPassword( session->rpcServer, password );
    811826}
    812 
    813827char*
    814 tr_sessionGetRPCPassword( const tr_handle * session )
     828tr_sessionGetRPCPassword( const tr_session * session )
    815829{
    816830    return tr_rpcGetPassword( session->rpcServer );
    817831}
    818 
    819 void
    820 tr_sessionSetRPCUsername( tr_handle * session, const char * username )
     832void
     833tr_sessionSetRPCUsername( tr_session * session, const char * username )
    821834{
    822835    tr_rpcSetUsername( session->rpcServer, username );
    823836}
    824 
    825837char*
    826 tr_sessionGetRPCUsername( const tr_handle * session )
     838tr_sessionGetRPCUsername( const tr_session * session )
    827839{
    828840    return tr_rpcGetUsername( session->rpcServer );
    829841}
    830 
    831 void
    832 tr_sessionSetRPCPasswordEnabled( tr_handle * session, int isEnabled )
     842void
     843tr_sessionSetRPCPasswordEnabled( tr_session * session, int isEnabled )
    833844{
    834845    tr_rpcSetPasswordEnabled( session->rpcServer, isEnabled );
    835846}
    836 
    837 int
    838 tr_sessionIsRPCPasswordEnabled( const tr_handle * session )
     847int
     848tr_sessionIsRPCPasswordEnabled( const tr_session * session )
    839849{
    840850    return tr_rpcIsPasswordEnabled( session->rpcServer );
    841851}
     852
     853/***
     854****
     855***/
     856
     857int
     858tr_sessionIsProxyEnabled( const tr_session * session )
     859{
     860    return session->isProxyEnabled;
     861}
     862void
     863tr_sessionSetProxyEnabled( tr_session * session, int isEnabled )
     864{
     865    session->isProxyEnabled = isEnabled ? 1 : 0;
     866}
     867const char*
     868tr_sessionGetProxy( const tr_session * session )
     869{
     870    return session->proxy;
     871}
     872void
     873tr_sessionSetProxy( tr_session * session, const char * proxy )
     874{
     875    if( proxy != session->proxy )
     876    {
     877        tr_free( session->proxy );
     878        session->proxy = tr_strdup( proxy );
     879    }
     880}
     881int
     882tr_sessionIsProxyAuthEnabled( const tr_session * session )
     883{
     884    return session->isProxyAuthEnabled;
     885}
     886void
     887tr_sessionSetProxyAuthEnabled( tr_session * session, int isEnabled )
     888{
     889    session->isProxyAuthEnabled = isEnabled ? 1 : 0;
     890}
     891const char*
     892tr_sessionGetProxyUsername( const tr_session * session )
     893{
     894    return session->proxyUsername;
     895}
     896void
     897tr_sessionSetProxyUsername( tr_session * session, const char * username )
     898{
     899    if( username != session->proxyUsername )
     900    {
     901        tr_free( session->proxyUsername );
     902        session->proxyUsername = tr_strdup( username );
     903    }
     904}
     905const char*
     906tr_sessionGetProxyPassword( const tr_session * session )
     907{
     908    return session->proxyPassword;
     909}
     910void
     911tr_sessionSetProxyPassword( tr_session * session, const char * password )
     912{
     913    if( password != session->proxyPassword )
     914    {
     915        tr_free( session->proxyPassword );
     916        session->proxyPassword = tr_strdup( password );
     917    }
     918}
  • trunk/libtransmission/session.h

    r5911 r6120  
    5050struct tr_handle
    5151{
    52     unsigned int                 isPortSet        : 1;
    53     unsigned int                 isPexEnabled     : 1;
    54     unsigned int                 isClosed         : 1;
    55     unsigned int                 useUploadLimit   : 1;
    56     unsigned int                 useDownloadLimit : 1;
     52    unsigned int                 isPortSet          : 1;
     53    unsigned int                 isPexEnabled       : 1;
     54    unsigned int                 isProxyEnabled     : 1;
     55    unsigned int                 isProxyAuthEnabled : 1;
     56    unsigned int                 isClosed           : 1;
     57    unsigned int                 useUploadLimit     : 1;
     58    unsigned int                 useDownloadLimit   : 1;
    5759
    5860    tr_encryption_mode           encryptionMode;
     
    7173    char                       * resumeDir;
    7274    char                       * torrentDir;
     75
     76    char                       * proxy;
     77    char                       * proxyUsername;
     78    char                       * proxyPassword;
    7379
    7480    struct tr_ratecontrol      * upload;
     
    94100};
    95101
    96 typedef struct tr_handle tr_session;
    97 
    98102const char * tr_sessionFindTorrentFile( const tr_session * session,
    99103                                        const char       * hashString );
  • trunk/libtransmission/transmission.h

    r6115 r6120  
    8181typedef struct tr_info tr_info;
    8282typedef struct tr_torrent tr_torrent;
     83typedef tr_handle tr_session;
    8384
    8485
     
    116117/** @see tr_sessionInitFull */
    117118#define TR_DEFAULT_RPC_ACL                  "+127.0.0.1"
     119/** @see tr_sessionInitFull */
     120#define TR_DEFAULT_PROXY_ENABLED            0
     121/** @see tr_sessionInitFull */
     122#define TR_DEFAULT_PROXY                    NULL
     123/** @see tr_sessionInitFull */
     124#define TR_DEFAULT_PROXY_AUTH_ENABLED       0
     125/** @see tr_sessionInitFull */
     126#define TR_DEFAULT_PROXY_USERNAME           NULL
     127/** @see tr_sessionInitFull */
     128#define TR_DEFAULT_PROXY_PASSWORD           NULL
     129
    118130
    119131/**
     
    212224 * @see tr_sessionClose()
    213225 */
    214 tr_handle * tr_sessionInitFull( const char * configDir,
    215                                 const char * downloadDir,
    216                                 const char * tag,
    217                                 int          isPexEnabled,
    218                                 int          isPortForwardingEnabled,
    219                                 int          publicPort,
    220                                 int          encryptionMode,
    221                                 int          isUploadLimitEnabled,
    222                                 int          uploadLimit,
    223                                 int          isDownloadLimitEnabled,
    224                                 int          downloadLimit,
    225                                 int          peerLimit,
    226                                 int          messageLevel,
    227                                 int          isMessageQueueingEnabled,
    228                                 int          isBlocklistEnabled,
    229                                 int          peerSocketTOS,
    230                                 int          rpcIsEnabled,
    231                                 int          rpcPort,
    232                                 const char * rpcAccessControlList,
    233                                 int          rpcPasswordIsEnabled,
    234                                 const char * rpcUsername,
    235                                 const char * rpcPassword );
     226tr_handle * tr_sessionInitFull( const char  * configDir,
     227                                const char  * downloadDir,
     228                                const char  * tag,
     229                                int           isPexEnabled,
     230                                int           isPortForwardingEnabled,
     231                                int           publicPort,
     232                                int           encryptionMode,
     233                                int           isUploadLimitEnabled,
     234                                int           uploadLimit,
     235                                int           isDownloadLimitEnabled,
     236                                int           downloadLimit,
     237                                int           peerLimit,
     238                                int           messageLevel,
     239                                int           isMessageQueueingEnabled,
     240                                int           isBlocklistEnabled,
     241                                int           peerSocketTOS,
     242                                int           rpcIsEnabled,
     243                                int           rpcPort,
     244                                const char  * rpcAccessControlList,
     245                                int           rpcPasswordIsEnabled,
     246                                const char  * rpcUsername,
     247                                const char  * rpcPassword,
     248                                int           proxyIsEnabled,
     249                                const char  * proxy,
     250                                int           proxyAuthIsEnabled,
     251                                const char  * proxyUsername,
     252                                const char  * proxyPassword );
     253
    236254
    237255/** @brief Shorter form of tr_sessionInitFull()
     
    338356 * @see tr_sessionGetRPCACL
    339357 */
    340 int tr_sessionSetRPCACL( tr_handle   * session,
     358int tr_sessionSetRPCACL( tr_session  * session,
    341359                         const char  * acl,
    342360                         char       ** allocme_errmsg );
     
    346364    @see tr_sessionInitFull
    347365    @see tr_sessionSetRPCACL */
    348 char* tr_sessionGetRPCACL( const tr_handle * );
    349 
    350 void  tr_sessionSetRPCPassword( tr_handle       * session,
    351                                 const char      * password );
    352 
    353 void  tr_sessionSetRPCUsername( tr_handle       * session,
    354                                 const char      * username );
     366char* tr_sessionGetRPCACL( const tr_session * );
     367
     368void  tr_sessionSetRPCPassword( tr_session   * session,
     369                                const char   * password );
     370
     371void  tr_sessionSetRPCUsername( tr_session   * session,
     372                                const char   * username );
    355373
    356374/** @brief get the password used to restrict RPC requests.
     
    358376    @see tr_sessionInitFull()
    359377    @see tr_sessionSetRPCPassword() */
    360 char* tr_sessionGetRPCPassword( const tr_handle * session );
    361 
    362 char* tr_sessionGetRPCUsername( const tr_handle * session  );
    363 
    364 void  tr_sessionSetRPCPasswordEnabled( tr_handle * session,
     378char* tr_sessionGetRPCPassword( const tr_session * session );
     379
     380char* tr_sessionGetRPCUsername( const tr_session * session  );
     381
     382void  tr_sessionSetRPCPasswordEnabled( tr_session * session,
    365383                                       int         isEnabled );
    366384
    367 int   tr_sessionIsRPCPasswordEnabled( const tr_handle * session );
     385int   tr_sessionIsRPCPasswordEnabled( const tr_session * session );
    368386
    369387
     
    379397tr_rpc_callback_type;
    380398
    381 typedef void ( *tr_rpc_func )( tr_handle            * handle,
     399typedef void ( *tr_rpc_func )( tr_session           * handle,
    382400                               tr_rpc_callback_type   type,
    383401                               struct tr_torrent    * tor_or_null,
    384402                               void                 * user_data );
    385403
    386 void tr_sessionSetRPCCallback( tr_handle    * handle,
     404void tr_sessionSetRPCCallback( tr_session   * handle,
    387405                               tr_rpc_func    func,
    388406                               void         * user_data );
    389407
     408/**
     409***
     410**/
     411
     412int         tr_sessionIsProxyEnabled       ( const tr_session * );
     413int         tr_sessionIsProxyAuthEnabled   ( const tr_session * );
     414const char* tr_sessionGetProxy             ( const tr_session * );
     415const char* tr_sessionGetProxyUsername     ( const tr_session * );
     416const char* tr_sessionGetProxyPassword     ( const tr_session * );
     417void        tr_sessionSetProxyEnabled      ( tr_session *, int isEnabled );
     418void        tr_sessionSetProxyAuthEnabled  ( tr_session *, int isEnabled );
     419void        tr_sessionSetProxy             ( tr_session *, const char * proxy );
     420void        tr_sessionSetProxyUsername     ( tr_session *, const char * username );
     421void        tr_sessionSetProxyPassword     ( tr_session *, const char * password );
    390422
    391423/**
     
    405437
    406438/* stats from the current session. */
    407 void tr_sessionGetStats( const tr_handle   * handle,
     439void tr_sessionGetStats( const tr_session  * session,
    408440                         tr_session_stats  * setme );
    409441
    410442/* stats from the current and past sessions. */
    411 void tr_sessionGetCumulativeStats( const tr_handle   * handle,
     443void tr_sessionGetCumulativeStats( const tr_session  * session,
    412444                                   tr_session_stats  * setme );
    413445
    414 void tr_sessionClearStats( tr_handle * handle );
     446void tr_sessionClearStats( tr_session * session );
    415447
    416448/**
     
    419451 * In public torrents, PEX is enabled by default.
    420452 */
    421 void tr_sessionSetPexEnabled( tr_handle *, int isEnabled );
    422 
    423 int tr_sessionIsPexEnabled( const tr_handle * );
     453void tr_sessionSetPexEnabled( tr_session *, int isEnabled );
     454
     455int tr_sessionIsPexEnabled( const tr_session * );
    424456
    425457typedef enum
     
    431463tr_encryption_mode;
    432464
    433 tr_encryption_mode tr_sessionGetEncryption( tr_handle * handle );
    434 
    435 void tr_sessionSetEncryption( tr_handle * handle, tr_encryption_mode mode );
     465tr_encryption_mode tr_sessionGetEncryption( tr_session * );
     466
     467void tr_sessionSetEncryption( tr_session *, tr_encryption_mode mode );
    436468
    437469
  • trunk/libtransmission/web.c

    r6073 r6120  
    133133{
    134134    struct tr_web_task * task = vtask;
    135 
    136     if( task->session && task->session->web )
     135    const tr_handle * session = task->session;
     136
     137    if( session && session->web )
    137138    {
    138         struct tr_web * web = task->session->web;
     139        struct tr_web * web = session->web;
    139140        CURL * ch;
    140141
     
    145146
    146147        ch = curl_easy_init( );
     148
     149        if( !task->range && session->isProxyEnabled ) {
     150            curl_easy_setopt( ch, CURLOPT_PROXY, session->proxy );
     151            curl_easy_setopt( ch, CURLOPT_PROXYAUTH, CURLAUTH_ANY );
     152        }
     153        if( !task->range && session->isProxyAuthEnabled ) {
     154            char * str = tr_strdup_printf( "%s:%s", session->proxyUsername, session->proxyPassword );
     155            curl_easy_setopt( ch, CURLOPT_PROXYUSERPWD, str );
     156            tr_free( str );
     157        }
     158
    147159        curl_easy_setopt( ch, CURLOPT_PRIVATE, task );
    148160        curl_easy_setopt( ch, CURLOPT_URL, task->url );
Note: See TracChangeset for help on using the changeset viewer.