Changeset 7385


Ignore:
Timestamp:
Dec 14, 2008, 11:21:11 AM (13 years ago)
Author:
charles
Message:

(trunk libT) more semantic cleanup: tr_handle->tr_session, int->tr_bool, int->tr_port

Location:
trunk/libtransmission
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/handshake.c

    r7340 r7385  
    9393    tr_peerIo *           io;
    9494    tr_crypto *           crypto;
    95     struct tr_handle *    handle;
     95    tr_session *          session;
    9696    uint8_t               myPublicKey[KEY_LEN];
    9797    uint8_t               mySecret[KEY_LEN];
     
    207207    uint8_t          * walk = buf;
    208208    const uint8_t    * torrentHash = tr_cryptoGetTorrentHash( handshake->crypto );
    209     const tr_torrent * tor = tr_torrentFindFromHash( handshake->handle, torrentHash );
     209    const tr_torrent * tor = tr_torrentFindFromHash( handshake->session, torrentHash );
    210210    const uint8_t    * peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( );
    211211
     
    266266    tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof( hash ) );
    267267    assert( tr_peerIoHasTorrentHash( handshake->io ) );
    268     if( !tr_torrentExists( handshake->handle, hash )
     268    if( !tr_torrentExists( handshake->session, hash )
    269269      || memcmp( hash, tr_peerIoGetTorrentHash( handshake->io ),
    270270                 SHA_DIGEST_LENGTH ) )
     
    284284            handshake->peer_id );
    285285
    286     tor = tr_torrentFindFromHash( handshake->handle, hash );
     286    tor = tr_torrentFindFromHash( handshake->session, hash );
    287287    peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( );
    288288    if( !memcmp( handshake->peer_id, peer_id, PEER_ID_LEN ) )
     
    665665    if( tr_peerIoIsIncoming( handshake->io ) )
    666666    {
    667         if( !tr_torrentExists( handshake->handle, hash ) )
     667        if( !tr_torrentExists( handshake->session, hash ) )
    668668        {
    669669            dbgmsg( handshake, "peer is trying to connect to us for a torrent we don't have." );
     
    725725
    726726    /* if we've somehow connected to ourselves, don't keep the connection */
    727     tor = tr_torrentFindFromHash( handshake->handle, tr_peerIoGetTorrentHash( handshake->io ) );
     727    tor = tr_torrentFindFromHash( handshake->session, tr_peerIoGetTorrentHash( handshake->io ) );
    728728    peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( );
    729729    peerIsGood = memcmp( handshake->peer_id, peer_id, PEER_ID_LEN ) != 0;
     
    845845        obfuscatedTorrentHash[i] = req2[i] ^ req3[i];
    846846    if( ( tor =
    847              tr_torrentFindFromObfuscatedHash( handshake->handle,
     847             tr_torrentFindFromObfuscatedHash( handshake->session,
    848848                                               obfuscatedTorrentHash ) ) )
    849849    {
     
    852852        tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
    853853        if( !tr_torrentAllowsPex( tor )
    854           && tr_peerMgrPeerIsSeed( handshake->handle->peerMgr,
     854          && tr_peerMgrPeerIsSeed( handshake->session->peerMgr,
    855855                                  tor->info.hash,
    856856                                  tr_peerIoGetAddress( handshake->io, NULL ) ) )
     
    11641164    handshake->doneCB = doneCB;
    11651165    handshake->doneUserData = doneUserData;
    1166     handshake->handle = tr_peerIoGetSession( io );
     1166    handshake->session = tr_peerIoGetSession( io );
    11671167    tr_peerIoSetTimeoutSecs( io, 15 );
    11681168
  • trunk/libtransmission/iobuf.c

    r7157 r7385  
    7474    short enabled;     /* events that are currently enabled */
    7575
    76     struct tr_handle * session;
     76    tr_session * session;
    7777    struct tr_bandwidth * bandwidth;
    7878};
     
    246246
    247247struct tr_iobuf *
    248 tr_iobuf_new( struct tr_handle    * session,
     248tr_iobuf_new( tr_session          * session,
    249249              tr_bandwidth        * bandwidth,
    250250              int                   fd,
  • trunk/libtransmission/iobuf.h

    r7154 r7385  
    6969
    7070/** @brief create a new tr_iobuf object. */
    71 struct tr_iobuf* tr_iobuf_new( struct tr_handle     * session,
     71struct tr_iobuf* tr_iobuf_new( tr_session           * session,
    7272                               struct tr_bandwidth  * bandwidth,
    7373                               int                    fd,
  • trunk/libtransmission/makemeta.c

    r6945 r7385  
    114114
    115115tr_metainfo_builder*
    116 tr_metaInfoBuilderCreate( tr_handle *  handle,
     116tr_metaInfoBuilderCreate( tr_session * session,
    117117                          const char * topFile )
    118118{
     
    123123
    124124    ret->top = tr_strdup( topFile );
    125     ret->handle = handle;
     125    ret->handle = session;
    126126    {
    127127        struct stat sb;
     
    445445
    446446static tr_lock*
    447 getQueueLock( tr_handle * h )
     447getQueueLock( tr_session * session )
    448448{
    449449    static tr_lock * lock = NULL;
    450 
    451     tr_globalLock( h );
     450    tr_globalLock( session );
     451
    452452    if( !lock )
    453453        lock = tr_lockNew( );
    454     tr_globalUnlock( h );
    455 
     454
     455    tr_globalUnlock( session );
    456456    return lock;
    457457}
     
    460460makeMetaWorkerFunc( void * user_data )
    461461{
    462     tr_handle * handle = (tr_handle *) user_data;
     462    tr_session * session = user_data;
    463463
    464464    for( ; ; )
     
    467467
    468468        /* find the next builder to process */
    469         tr_lock *             lock = getQueueLock ( handle );
     469        tr_lock * lock = getQueueLock( session );
    470470        tr_lockLock( lock );
    471471        if( queue )
  • trunk/libtransmission/makemeta.h

    r6795 r7385  
    4646    uint32_t                    pieceCount;
    4747    int                         isSingleFile;
    48     tr_handle *                 handle;
     48    tr_session *                handle;
    4949
    5050    /**
     
    8888
    8989
    90 tr_metainfo_builder*tr_metaInfoBuilderCreate( tr_handle *  handle,
     90tr_metainfo_builder*tr_metaInfoBuilderCreate( tr_session * session,
    9191                                              const char * topFile );
    9292
  • trunk/libtransmission/metainfo.c

    r6842 r7385  
    4646
    4747static char*
    48 getTorrentFilename( const tr_handle * handle,
     48getTorrentFilename( const tr_session * session,
    4949                    const tr_info *   inf )
    5050{
    5151    return tr_strdup_printf( "%s%c%s.%16.16s.torrent",
    52                              tr_getTorrentDir( handle ),
     52                             tr_getTorrentDir( session ),
    5353                             TR_PATH_DELIMITER,
    5454                             inf->name,
     
    5757
    5858static char*
    59 getOldTorrentFilename( const tr_handle * handle,
     59getOldTorrentFilename( const tr_session * session,
    6060                       const tr_info *   inf )
    6161{
     
    6363    struct evbuffer * buf = evbuffer_new( );
    6464
    65     evbuffer_add_printf( buf, "%s%c%s", tr_getTorrentDir( handle ),
     65    evbuffer_add_printf( buf, "%s%c%s", tr_getTorrentDir( session ),
    6666                         TR_PATH_DELIMITER,
    6767                         inf->hashString );
    68     if( handle->tag )
    69         evbuffer_add_printf( buf, "-%s", handle->tag );
     68    if( session->tag )
     69        evbuffer_add_printf( buf, "-%s", session->tag );
    7070
    7171    ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
     
    7575
    7676void
    77 tr_metainfoMigrate( tr_handle * handle,
     77tr_metainfoMigrate( tr_session * session,
    7878                    tr_info *   inf )
    7979{
    8080    struct stat new_sb;
    81     char *      name = getTorrentFilename( handle, inf );
     81    char *      name = getTorrentFilename( session, inf );
    8282
    8383    if( stat( name, &new_sb ) || ( ( new_sb.st_mode & S_IFMT ) != S_IFREG ) )
    8484    {
    85         char *    old_name = getOldTorrentFilename( handle, inf );
     85        char *    old_name = getOldTorrentFilename( session, inf );
    8686        size_t    contentLen;
    8787        uint8_t * content;
    8888
    89         tr_mkdirp( tr_getTorrentDir( handle ), 0777 );
     89        tr_mkdirp( tr_getTorrentDir( session ), 0777 );
    9090        if( ( content = tr_loadFile( old_name, &contentLen ) ) )
    9191        {
     
    105105                    tr_free( inf->torrent );
    106106                    inf->torrent = tr_strdup( name );
    107                     tr_sessionSetTorrentFile( handle, inf->hashString, name );
     107                    tr_sessionSetTorrentFile( session, inf->hashString, name );
    108108                    unlink( old_name );
    109109                }
     
    341341
    342342static const char*
    343 tr_metainfoParseImpl( const tr_handle * handle,
     343tr_metainfoParseImpl( const tr_session * session,
    344344                      tr_info *         inf,
    345345                      const tr_benc *   meta_in )
     
    437437    /* filename of Transmission's copy */
    438438    tr_free( inf->torrent );
    439     inf->torrent = getTorrentFilename( handle, inf );
     439    inf->torrent = getTorrentFilename( session, inf );
    440440
    441441    return NULL;
     
    443443
    444444int
    445 tr_metainfoParse( const tr_handle * handle,
     445tr_metainfoParse( const tr_session * session,
    446446                  tr_info *         inf,
    447447                  const tr_benc *   meta_in )
    448448{
    449     const char * badTag = tr_metainfoParseImpl( handle, inf, meta_in );
     449    const char * badTag = tr_metainfoParseImpl( session, inf, meta_in );
    450450
    451451    if( badTag )
     
    489489
    490490void
    491 tr_metainfoRemoveSaved( const tr_handle * handle,
     491tr_metainfoRemoveSaved( const tr_session * session,
    492492                        const tr_info *   inf )
    493493{
    494494    char * filename;
    495495
    496     filename = getTorrentFilename( handle, inf );
     496    filename = getTorrentFilename( session, inf );
    497497    unlink( filename );
    498498    tr_free( filename );
    499499
    500     filename = getOldTorrentFilename( handle, inf );
     500    filename = getOldTorrentFilename( session, inf );
    501501    unlink( filename );
    502502    tr_free( filename );
  • trunk/libtransmission/metainfo.h

    r7151 r7385  
    3838struct tr_benc;
    3939
    40 int  tr_metainfoParse( const tr_handle *      handle,
    41                        tr_info *              info,
     40int  tr_metainfoParse( const tr_session     * session,
     41                       tr_info              * info,
    4242                       const struct tr_benc * benc );
    4343
    44 void tr_metainfoRemoveSaved( const tr_handle * handle,
    45                              const tr_info info );
     44void tr_metainfoRemoveSaved( const tr_session * session,
     45                             const tr_info    * info );
    4646
    47 void tr_metainfoMigrate( tr_handle * handle,
    48                          tr_info inf );
     47void tr_metainfoMigrate( tr_session * session,
     48                         tr_info    * inf );
    4949
    5050#ifdef __cplusplus
  • trunk/libtransmission/peer-io.h

    r7289 r7385  
    3333**/
    3434
    35 tr_peerIo*  tr_peerIoNewOutgoing( struct tr_handle        * session,
     35tr_peerIo*  tr_peerIoNewOutgoing( tr_session              * session,
    3636                                  const struct tr_address * addr,
    3737                                  tr_port                   port,
    3838                                  const  uint8_t          * torrentHash );
    3939
    40 tr_peerIo*  tr_peerIoNewIncoming( struct tr_handle        * session,
     40tr_peerIo*  tr_peerIoNewIncoming( tr_session              * session,
    4141                                  const struct tr_address * addr,
    4242                                  tr_port                   port,
  • trunk/libtransmission/peer-mgr.h

    r7289 r7385  
    2626#include "net.h"
    2727
    28 struct tr_handle;
    2928struct tr_peer_stat;
    3029struct tr_torrent;
     
    5049int tr_pexCompare( const void * a, const void * b );
    5150
    52 tr_peerMgr* tr_peerMgrNew( struct tr_handle * );
     51tr_peerMgr* tr_peerMgrNew( tr_session * );
    5352
    5453void tr_peerMgrFree( tr_peerMgr * manager );
  • trunk/libtransmission/platform.c

    r7373 r7385  
    353353
    354354static void
    355 migrateFiles( const tr_handle * handle )
     355migrateFiles( const tr_session * session )
    356356{
    357357    static int migrated = FALSE;
     
    364364
    365365        oldDir = getOldTorrentsDir( );
    366         newDir = tr_getTorrentDir( handle );
     366        newDir = tr_getTorrentDir( session );
    367367        moveFiles( oldDir, newDir );
    368368
    369369        oldDir = getOldCacheDir( );
    370         newDir = tr_getResumeDir( handle );
     370        newDir = tr_getResumeDir( session );
    371371        moveFiles( oldDir, newDir );
    372372    }
     
    374374
    375375void
    376 tr_setConfigDir( tr_handle *  handle,
     376tr_setConfigDir( tr_session * session,
    377377                 const char * configDir )
    378378{
    379379    char * path;
    380380
    381     handle->configDir = tr_strdup( configDir );
     381    session->configDir = tr_strdup( configDir );
    382382
    383383    path = tr_buildPath( configDir, RESUME_SUBDIR, NULL );
    384384    tr_mkdirp( path, 0777 );
    385     handle->resumeDir = path;
     385    session->resumeDir = path;
    386386
    387387    path = tr_buildPath( configDir, TORRENT_SUBDIR, NULL );
    388388    tr_mkdirp( path, 0777 );
    389     handle->torrentDir = path;
    390 
    391     migrateFiles( handle );
     389    session->torrentDir = path;
     390
     391    migrateFiles( session );
    392392}
    393393
    394394const char *
    395 tr_sessionGetConfigDir( const tr_handle * handle )
    396 {
    397     return handle->configDir;
     395tr_sessionGetConfigDir( const tr_session * session )
     396{
     397    return session->configDir;
    398398}
    399399
    400400const char *
    401 tr_getTorrentDir( const tr_handle * handle )
    402 {
    403     return handle->torrentDir;
     401tr_getTorrentDir( const tr_session * session )
     402{
     403    return session->torrentDir;
    404404}
    405405
    406406const char *
    407 tr_getResumeDir( const tr_handle * handle )
    408 {
    409     return handle->resumeDir;
     407tr_getResumeDir( const tr_session * session )
     408{
     409    return session->resumeDir;
    410410}
    411411
  • trunk/libtransmission/platform.h

    r7232 r7385  
    4343typedef struct tr_thread tr_thread;
    4444
    45 struct tr_handle;
     45void                tr_setConfigDir( tr_session * session,
     46                                     const char * configDir );
    4647
    47 void                tr_setConfigDir( struct tr_handle * handle,
    48                                      const char *       configDir );
     48const char *        tr_getResumeDir( const tr_session * );
    4949
    50 const char *        tr_getResumeDir( const struct tr_handle * );
     50const char *        tr_getTorrentDir( const tr_session * );
    5151
    52 const char *        tr_getTorrentDir( const struct tr_handle * );
    53 
    54 const char *        tr_getClutchDir( const struct tr_handle * );
     52const char *        tr_getClutchDir( const tr_session * );
    5553
    5654
  • trunk/libtransmission/port-forwarding.c

    r7240 r7385  
    205205tr_shared *
    206206tr_sharedInit( tr_session  * session,
    207                int           isEnabled,
    208                int           publicPort )
     207               tr_bool       isEnabled,
     208               tr_bool       publicPort )
    209209{
    210210    tr_shared * s = tr_new0( tr_shared, 1 );
     
    231231
    232232void
    233 tr_sharedSetPort( tr_shared * s,
    234                   int         port )
     233tr_sharedSetPort( tr_shared * s, tr_port  port )
    235234{
    236235    tr_torrent * tor = NULL;
     
    242241}
    243242
    244 int
     243tr_port
    245244tr_sharedGetPeerPort( const tr_shared * s )
    246245{
     
    249248
    250249void
    251 tr_sharedTraversalEnable( tr_shared * s,
    252                           int         isEnabled )
     250tr_sharedTraversalEnable( tr_shared * s, tr_bool isEnabled )
    253251{
    254252    s->isEnabled = isEnabled;
    255253}
    256254
    257 int
     255tr_bool
    258256tr_sharedTraversalIsEnabled( const tr_shared * s )
    259257{
  • trunk/libtransmission/port-forwarding.h

    r7151 r7385  
    3434typedef struct tr_shared tr_shared;
    3535
    36 tr_shared* tr_sharedInit(         tr_handle *,
    37                               int isEnabled,
    38                               int publicPort );
     36tr_shared* tr_sharedInit( tr_session*, tr_bool isEnabled, tr_bool publicPort );
    3937
    4038void       tr_sharedShuttingDown( tr_shared * );
    4139
    42 void       tr_sharedSetPort(         tr_shared *,
    43                                  int publicPort );
     40void       tr_sharedSetPort( tr_shared *, tr_port publicPort );
    4441
    45 void       tr_sharedTraversalEnable(         tr_shared *,
    46                                          int isEnabled );
     42void       tr_sharedTraversalEnable( tr_shared *, tr_bool isEnabled );
    4743
    48 int        tr_sharedGetPeerPort( const tr_shared * s );
     44tr_port    tr_sharedGetPeerPort( const tr_shared * s );
    4945
    50 int        tr_sharedTraversalIsEnabled( const tr_shared * s );
     46tr_bool    tr_sharedTraversalIsEnabled( const tr_shared * s );
    5147
    5248int        tr_sharedTraversalStatus( const tr_shared * );
  • trunk/libtransmission/rpc-server.c

    r7368 r7385  
    5353    tr_port            port;
    5454    struct evhttp *    httpd;
    55     tr_handle *        session;
     55    tr_session *       session;
    5656    char *             username;
    5757    char *             password;
     
    683683
    684684tr_rpc_server *
    685 tr_rpcInit( tr_handle  * session,
    686             tr_bool      isEnabled,
    687             tr_port      port,
    688             tr_bool      isWhitelistEnabled,
    689             const char * whitelist,
    690             tr_bool      isPasswordEnabled,
    691             const char * username,
    692             const char * password )
     685tr_rpcInit( tr_session  * session,
     686            tr_bool       isEnabled,
     687            tr_port       port,
     688            tr_bool       isWhitelistEnabled,
     689            const char  * whitelist,
     690            tr_bool       isPasswordEnabled,
     691            const char  * username,
     692            const char  * password )
    693693{
    694694    tr_rpc_server * s;
  • trunk/libtransmission/rpc-server.h

    r7368 r7385  
    2020typedef struct tr_rpc_server tr_rpc_server;
    2121
    22 tr_rpc_server * tr_rpcInit( struct tr_handle * session,
    23                             tr_bool            isEnabled,
    24                             tr_port            port,
    25                             tr_bool            isWhitelistEnabled,
    26                             const char       * whitelist,
    27                             tr_bool            isPasswordEnabled,
    28                             const char       * username,
    29                             const char       * password );
     22tr_rpc_server * tr_rpcInit( tr_session * session,
     23                            tr_bool       isEnabled,
     24                            tr_port       port,
     25                            tr_bool       isWhitelistEnabled,
     26                            const char  * whitelist,
     27                            tr_bool       isPasswordEnabled,
     28                            const char  * username,
     29                            const char  * password );
    3030
    3131void            tr_rpcClose( tr_rpc_server ** freeme );
  • trunk/libtransmission/rpcimpl.c

    r7348 r7385  
    3131
    3232static tr_rpc_callback_status
    33 notify( tr_handle * session,
     33notify( tr_session * session,
    3434        int          type,
    3535        tr_torrent * tor )
     
    4949
    5050static tr_torrent **
    51 getTorrents( tr_handle * handle,
    52              tr_benc args,
    53              int *      setmeCount )
     51getTorrents( tr_session * session,
     52             tr_benc    * args,
     53             int        * setmeCount )
    5454{
    5555    int           torrentCount = 0;
     
    7272            const char * str;
    7373            if( tr_bencGetInt( node, &id ) )
    74                 tor = tr_torrentFindFromId( handle, id );
     74                tor = tr_torrentFindFromId( session, id );
    7575            else if( tr_bencGetStr( node, &str ) )
    76                 tor = tr_torrentFindFromHashString( handle, str );
     76                tor = tr_torrentFindFromHashString( session, str );
    7777            if( tor )
    7878                torrents[torrentCount++] = tor;
     
    8484        tr_torrent * tor;
    8585        torrents = tr_new0( tr_torrent *, 1 );
    86         if( ( tor = tr_torrentFindFromId( handle, id ) ) )
     86        if( ( tor = tr_torrentFindFromId( session, id ) ) )
    8787            torrents[torrentCount++] = tor;
    8888    }
     
    9090    {
    9191        tr_torrent * tor = NULL;
    92         const int    n = tr_sessionCountTorrents( handle );
     92        const int    n = tr_sessionCountTorrents( session );
    9393        torrents = tr_new0( tr_torrent *, n );
    94         while( ( tor = tr_torrentNext( handle, tor ) ) )
     94        while( ( tor = tr_torrentNext( session, tor ) ) )
    9595            torrents[torrentCount++] = tor;
    9696    }
     
    101101
    102102static const char*
    103 torrentStart( tr_handle *        h,
    104               tr_benc *          args_in,
    105               tr_benc * args_out UNUSED )
     103torrentStart( tr_session * session,
     104              tr_benc    * args_in,
     105              tr_benc    * args_out UNUSED )
    106106{
    107107    int           i, torrentCount;
    108     tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );
     108    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
    109109
    110110    for( i = 0; i < torrentCount; ++i )
     
    112112        tr_torrent * tor = torrents[i];
    113113        tr_torrentStart( tor );
    114         notify( h, TR_RPC_TORRENT_STARTED, tor );
     114        notify( session, TR_RPC_TORRENT_STARTED, tor );
    115115    }
    116116    tr_free( torrents );
     
    119119
    120120static const char*
    121 torrentStop( tr_handle *        h,
    122              tr_benc *          args_in,
    123              tr_benc * args_out UNUSED )
     121torrentStop( tr_session * session,
     122             tr_benc    * args_in,
     123             tr_benc    * args_out UNUSED )
    124124{
    125125    int           i, torrentCount;
    126     tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );
     126    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
    127127
    128128    for( i = 0; i < torrentCount; ++i )
     
    130130        tr_torrent * tor = torrents[i];
    131131        tr_torrentStop( tor );
    132         notify( h, TR_RPC_TORRENT_STOPPED, tor );
     132        notify( session, TR_RPC_TORRENT_STOPPED, tor );
    133133    }
    134134    tr_free( torrents );
     
    137137
    138138static const char*
    139 torrentRemove( tr_handle   * h,
     139torrentRemove( tr_session  * session,
    140140               tr_benc     * args_in,
    141141               tr_benc     * args_out UNUSED )
     
    143143    int i;
    144144    int torrentCount;
    145     tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );
     145    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
    146146
    147147    for( i=0; i<torrentCount; ++i )
    148148    {
    149149        tr_torrent * tor = torrents[i];
    150         const tr_rpc_callback_status status = notify( h, TR_RPC_TORRENT_REMOVING, tor );
     150        const tr_rpc_callback_status status = notify( session, TR_RPC_TORRENT_REMOVING, tor );
    151151        int64_t deleteFlag;
    152152        if( tr_bencDictFindInt( args_in, "delete-local-data", &deleteFlag ) && deleteFlag )
     
    155155            tr_torrentRemove( tor );
    156156    }
     157
    157158    tr_free( torrents );
    158159    return NULL;
     
    160161
    161162static const char*
    162 torrentVerify( tr_handle *        h,
    163                tr_benc *          args_in,
    164                tr_benc * args_out UNUSED )
     163torrentVerify( tr_session  * session,
     164               tr_benc     * args_in,
     165               tr_benc     * args_out UNUSED )
    165166{
    166167    int           i, torrentCount;
    167     tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );
     168    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
    168169
    169170    for( i = 0; i < torrentCount; ++i )
     
    171172        tr_torrent * tor = torrents[i];
    172173        tr_torrentVerify( tor );
    173         notify( h, TR_RPC_TORRENT_CHANGED, tor );
    174     }
     174        notify( session, TR_RPC_TORRENT_CHANGED, tor );
     175    }
     176
    175177    tr_free( torrents );
    176178    return NULL;
     
    433435
    434436static const char*
    435 torrentGet( tr_handle * handle,
    436             tr_benc args_in,
    437             tr_benc args_out )
     437torrentGet( tr_session * session,
     438            tr_benc    * args_in,
     439            tr_benc    * args_out )
    438440{
    439441    int           i, torrentCount;
    440     tr_torrent ** torrents = getTorrents( handle, args_in, &torrentCount );
     442    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
    441443    tr_benc *     list = tr_bencDictAddList( args_out, "torrents",
    442444                                             torrentCount );
     
    520522
    521523static const char*
    522 torrentSet( tr_handle *        h,
    523             tr_benc *          args_in,
    524             tr_benc * args_out UNUSED )
     524torrentSet( tr_session * session,
     525            tr_benc    * args_in,
     526            tr_benc    * args_out UNUSED )
    525527{
    526528    int           i, torrentCount;
    527     tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );
     529    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
    528530
    529531    for( i = 0; i < torrentCount; ++i )
     
    557559                                    : TR_SPEEDLIMIT_GLOBAL );
    558560
    559         notify( h, TR_RPC_TORRENT_CHANGED, tor );
     561        notify( session, TR_RPC_TORRENT_CHANGED, tor );
    560562    }
    561563
     
    569571
    570572static const char*
    571 torrentAdd( tr_handle * h,
    572             tr_benc args_in,
    573             tr_benc args_out )
     573torrentAdd( tr_session * session,
     574            tr_benc    * args_in,
     575            tr_benc    * args_out )
    574576{
    575577    const char * filename = NULL;
     
    588590        tr_torrent * tor;
    589591
    590         ctor = tr_ctorNew( h );
     592        ctor = tr_ctorNew( session );
    591593
    592594        /* set the metainfo */
     
    609611            tr_ctorSetPeerLimit( ctor, TR_FORCE, i );
    610612
    611         tor = tr_torrentNew( h, ctor, &err );
     613        tor = tr_torrentNew( session, ctor, &err );
    612614        tr_ctorFree( ctor );
    613615
     
    621623            addInfo( tor, tr_bencDictAdd( args_out,
    622624                                          "torrent-added" ), &fields );
    623             notify( h, TR_RPC_TORRENT_ADDED, tor );
     625            notify( session, TR_RPC_TORRENT_ADDED, tor );
    624626            tr_bencFree( &fields );
    625627        }
     
    642644
    643645static const char*
    644 sessionSet( tr_handle *        h,
    645             tr_benc *          args_in,
    646             tr_benc * args_out UNUSED )
     646sessionSet( tr_session * session,
     647            tr_benc    * args_in,
     648            tr_benc    * args_out UNUSED )
    647649{
    648650    int64_t      i;
     
    650652
    651653    if( tr_bencDictFindStr( args_in, "download-dir", &str ) )
    652         tr_sessionSetDownloadDir( h, str );
     654        tr_sessionSetDownloadDir( session, str );
    653655    if( tr_bencDictFindInt( args_in, "peer-limit", &i ) )
    654         tr_sessionSetPeerLimit( h, i );
     656        tr_sessionSetPeerLimit( session, i );
    655657    if( tr_bencDictFindInt( args_in, "pex-allowed", &i ) )
    656         tr_sessionSetPexEnabled( h, i );
     658        tr_sessionSetPexEnabled( session, i );
    657659    if( tr_bencDictFindInt( args_in, "port", &i ) )
    658         tr_sessionSetPeerPort( h, i );
     660        tr_sessionSetPeerPort( session, i );
    659661    if( tr_bencDictFindInt( args_in, "port-forwarding-enabled", &i ) )
    660         tr_sessionSetPortForwardingEnabled( h, i );
     662        tr_sessionSetPortForwardingEnabled( session, i );
    661663    if( tr_bencDictFindInt( args_in, "speed-limit-down", &i ) )
    662         tr_sessionSetSpeedLimit( h, TR_DOWN, i );
     664        tr_sessionSetSpeedLimit( session, TR_DOWN, i );
    663665    if( tr_bencDictFindInt( args_in, "speed-limit-down-enabled", &i ) )
    664         tr_sessionSetSpeedLimitEnabled( h, TR_DOWN, i );
     666        tr_sessionSetSpeedLimitEnabled( session, TR_DOWN, i );
    665667    if( tr_bencDictFindInt( args_in, "speed-limit-up", &i ) )
    666         tr_sessionSetSpeedLimit( h, TR_UP, i );
     668        tr_sessionSetSpeedLimit( session, TR_UP, i );
    667669    if( tr_bencDictFindInt( args_in, "speed-limit-up-enabled", &i ) )
    668         tr_sessionSetSpeedLimitEnabled( h, TR_UP, i );
     670        tr_sessionSetSpeedLimitEnabled( session, TR_UP, i );
    669671    if( tr_bencDictFindStr( args_in, "encryption", &str ) )
    670672    {
    671673        if( !strcmp( str, "required" ) )
    672             tr_sessionSetEncryption( h, TR_ENCRYPTION_REQUIRED );
     674            tr_sessionSetEncryption( session, TR_ENCRYPTION_REQUIRED );
    673675        else if( !strcmp( str, "tolerated" ) )
    674             tr_sessionSetEncryption( h, TR_CLEAR_PREFERRED );
     676            tr_sessionSetEncryption( session, TR_CLEAR_PREFERRED );
    675677        else
    676             tr_sessionSetEncryption( h, TR_ENCRYPTION_PREFERRED );
    677     }
    678 
    679     notify( h, TR_RPC_SESSION_CHANGED, NULL );
     678            tr_sessionSetEncryption( session, TR_ENCRYPTION_PREFERRED );
     679    }
     680
     681    notify( session, TR_RPC_SESSION_CHANGED, NULL );
    680682
    681683    return NULL;
     
    683685
    684686static const char*
    685 sessionStats( tr_handle *       h,
    686               tr_benc * args_in UNUSED,
    687               tr_benc *         args_out )
    688 {
    689     tr_benc *    d = tr_bencDictAddDict( args_out, "session-stats", 10 );
    690     tr_torrent * tor = NULL;
    691     int          running = 0;
    692     int          total = 0;
    693 
    694     while( ( tor = tr_torrentNext( h, tor ) ) )
    695     {
     687sessionStats( tr_session  * session,
     688              tr_benc     * args_in UNUSED,
     689              tr_benc     * args_out )
     690{
     691    tr_benc    * d;
     692    tr_torrent * tor;
     693    int          running;
     694    int          total;
     695
     696    tor = NULL;
     697    total = running = 0;
     698    while(( tor = tr_torrentNext( session, tor ))) {
    696699        ++total;
    697700        if( tor->isRunning )
     
    699702    }
    700703
     704    d = tr_bencDictAddDict( args_out, "session-stats", 5 );
    701705    tr_bencDictAddInt( d, "activeTorrentCount", running );
    702     tr_bencDictAddInt( d, "downloadSpeed", (int)( tr_sessionGetPieceSpeed( h, TR_DOWN ) * 1024 ) );
     706    tr_bencDictAddInt( d, "downloadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_DOWN ) * 1024 ) );
    703707    tr_bencDictAddInt( d, "pausedTorrentCount", total - running );
    704708    tr_bencDictAddInt( d, "torrentCount", total );
    705     tr_bencDictAddInt( d, "uploadSpeed", (int)( tr_sessionGetPieceSpeed( h, TR_UP ) * 1024 ) );
     709    tr_bencDictAddInt( d, "uploadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_UP ) * 1024 ) );
    706710    return NULL;
    707711}
    708712
    709713static const char*
    710 sessionGet( tr_handle *       h,
    711             tr_benc * args_in UNUSED,
    712             tr_benc *        args_out )
     714sessionGet( tr_session * session,
     715            tr_benc    * args_in UNUSED,
     716            tr_benc    * args_out )
    713717{
    714718    const char * str;
    715719    tr_benc *    d = args_out;
    716720
    717     tr_bencDictAddStr( d, "download-dir",
    718                       tr_sessionGetDownloadDir( h ) );
    719     tr_bencDictAddInt( d, "peer-limit",
    720                       tr_sessionGetPeerLimit( h ) );
    721     tr_bencDictAddInt( d, "pex-allowed",
    722                       tr_sessionIsPexEnabled( h ) );
    723     tr_bencDictAddInt( d, "port",
    724                       tr_sessionGetPeerPort( h ) );
    725     tr_bencDictAddInt( d, "port-forwarding-enabled",
    726                       tr_sessionIsPortForwardingEnabled( h ) );
    727     tr_bencDictAddInt( d, "speed-limit-up",
    728                        tr_sessionGetSpeedLimit( h, TR_UP ) );
    729     tr_bencDictAddInt( d, "speed-limit-up-enabled",
    730                       tr_sessionIsSpeedLimitEnabled( h, TR_UP ) );
    731     tr_bencDictAddInt( d, "speed-limit-down",
    732                        tr_sessionGetSpeedLimit( h, TR_DOWN ) );
    733     tr_bencDictAddInt( d, "speed-limit-down-enabled",
    734                       tr_sessionIsSpeedLimitEnabled( h, TR_DOWN ) );
     721    tr_bencDictAddStr( d, "download-dir", tr_sessionGetDownloadDir( session ) );
     722    tr_bencDictAddInt( d, "peer-limit", tr_sessionGetPeerLimit( session ) );
     723    tr_bencDictAddInt( d, "pex-allowed", tr_sessionIsPexEnabled( session ) );
     724    tr_bencDictAddInt( d, "port", tr_sessionGetPeerPort( session ) );
     725    tr_bencDictAddInt( d, "port-forwarding-enabled", tr_sessionIsPortForwardingEnabled( session ) );
     726    tr_bencDictAddInt( d, "speed-limit-up", tr_sessionGetSpeedLimit( session, TR_UP ) );
     727    tr_bencDictAddInt( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimitEnabled( session, TR_UP ) );
     728    tr_bencDictAddInt( d, "speed-limit-down", tr_sessionGetSpeedLimit( session, TR_DOWN ) );
     729    tr_bencDictAddInt( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimitEnabled( session, TR_DOWN ) );
    735730    tr_bencDictAddStr( d, "version", LONG_VERSION_STRING );
    736     switch( tr_sessionGetEncryption( h ) )
    737     {
    738         case TR_CLEAR_PREFERRED:
    739             str = "tolerated"; break;
    740 
    741         case TR_ENCRYPTION_REQUIRED:
    742             str = "required"; break;
    743 
    744         default:
    745             str = "preferred"; break;
     731    switch( tr_sessionGetEncryption( session ) ) {
     732        case TR_CLEAR_PREFERRED: str = "tolerated"; break;
     733        case TR_ENCRYPTION_REQUIRED: str = "required"; break;
     734        default: str = "preferred"; break;
    746735    }
    747736    tr_bencDictAddStr( d, "encryption", str );
     
    754743***/
    755744
    756 typedef const char* ( handler )( tr_handle*, tr_benc*, tr_benc* );
     745typedef const char* ( handler )( tr_session*, tr_benc*, tr_benc* );
    757746
    758747static struct method
     
    774763
    775764static char*
    776 request_exec( struct tr_handle * handle,
    777               tr_benc *          request,
    778               int *              response_len )
     765request_exec( tr_session * session,
     766              tr_benc    * request,
     767              int        * response_len )
    779768{
    780769    int64_t      i;
     
    801790        result = i == n
    802791                 ? "method name not recognized"
    803                  : ( *methods[i].func )( handle, args_in, args_out );
     792                 : ( *methods[i].func )( session, args_in, args_out );
    804793    }
    805794
     
    816805
    817806char*
    818 tr_rpc_request_exec_json( struct tr_handle * handle,
    819                           const void *       request_json,
    820                           int                request_len,
    821                           int *              response_len )
     807tr_rpc_request_exec_json( tr_session * session,
     808                          const void * request_json,
     809                          int          request_len,
     810                          int        * response_len )
    822811{
    823812    tr_benc top;
     
    829818
    830819    have_content = !tr_jsonParse( request_json, request_len, &top, NULL );
    831     ret = request_exec( handle, have_content ? &top : NULL, response_len );
     820    ret = request_exec( session, have_content ? &top : NULL, response_len );
    832821
    833822    if( have_content )
     
    916905
    917906char*
    918 tr_rpc_request_exec_uri( struct tr_handle * handle,
    919                          const void *       request_uri,
    920                          int                request_len,
    921                          int *              response_len )
     907tr_rpc_request_exec_uri( tr_session * session,
     908                         const void * request_uri,
     909                         int          request_len,
     910                         int        * response_len )
    922911{
    923912    char *       ret = NULL;
     
    950939    }
    951940
    952     ret = request_exec( handle, &top, response_len );
     941    ret = request_exec( session, &top, response_len );
    953942
    954943    /* cleanup */
  • trunk/libtransmission/rpcimpl.h

    r6795 r7385  
    1919
    2020struct tr_benc;
    21 struct tr_handle;
    2221
    2322/* http://www.json.org/ */
    24 char*tr_rpc_request_exec_json( struct tr_handle * handle,
    25                                const void *      request_json,
    26                                int                request_len,
    27                                int *              response_len );
     23char*tr_rpc_request_exec_json( tr_session  * session,
     24                               const void  * request_json,
     25                               int           request_len,
     26                               int         * response_len );
    2827
    2928/* see the RPC spec's "Request URI Notation" section */
    30 char*tr_rpc_request_exec_uri( struct tr_handle * handle,
    31                               const void *      request_uri,
    32                               int                request_len,
    33                               int *              response_len );
     29char*tr_rpc_request_exec_uri( tr_session  * session,
     30                              const void  * request_uri,
     31                              int           request_len,
     32                              int         * response_len );
    3433
    3534void tr_rpc_parse_list_str( struct tr_benc * setme,
    36                             const char *    list_str,
     35                            const char     * list_str,
    3736                            size_t           list_str_len );
    3837
  • trunk/libtransmission/session.c

    r7374 r7385  
    344344}
    345345
    346 static void metainfoLookupRescan( tr_handle * h );
     346static void metainfoLookupRescan( tr_session * );
    347347
    348348tr_session *
     
    533533
    534534void
    535 tr_sessionSetDownloadDir( tr_handle *  handle,
    536                           const char * dir )
    537 {
    538     if( handle->downloadDir != dir )
    539     {
    540         tr_free( handle->downloadDir );
    541         handle->downloadDir = tr_strdup( dir );
     535tr_sessionSetDownloadDir( tr_session * session, const char * dir )
     536{
     537    if( session->downloadDir != dir )
     538    {
     539        tr_free( session->downloadDir );
     540        session->downloadDir = tr_strdup( dir );
    542541    }
    543542}
    544543
    545544const char *
    546 tr_sessionGetDownloadDir( const tr_handle * handle )
    547 {
    548     return handle->downloadDir;
    549 }
    550 
    551 /***
    552 ****
    553 ***/
    554 
    555 void
    556 tr_globalLock( struct tr_handle * handle )
    557 {
    558     tr_lockLock( handle->lock );
    559 }
    560 
    561 void
    562 tr_globalUnlock( struct tr_handle * handle )
    563 {
    564     tr_lockUnlock( handle->lock );
     545tr_sessionGetDownloadDir( const tr_session * session )
     546{
     547    return session->downloadDir;
     548}
     549
     550/***
     551****
     552***/
     553
     554void
     555tr_globalLock( tr_session * session )
     556{
     557    tr_lockLock( session->lock );
     558}
     559
     560void
     561tr_globalUnlock( tr_session * session )
     562{
     563    tr_lockUnlock( session->lock );
    565564}
    566565
    567566tr_bool
    568 tr_globalIsLocked( const struct tr_handle * handle )
    569 {
    570     return handle && tr_lockHave( handle->lock );
     567tr_globalIsLocked( const tr_session * session )
     568{
     569    return session && tr_lockHave( session->lock );
    571570}
    572571
     
    632631
    633632tr_port_forwarding
    634 tr_sessionGetPortForwarding( const tr_handle * h )
    635 {
    636     return tr_sharedTraversalStatus( h->shared );
     633tr_sessionGetPortForwarding( const tr_session * session )
     634{
     635    return tr_sharedTraversalStatus( session->shared );
    637636}
    638637
     
    700699
    701700void
    702 tr_sessionSetPeerLimit( tr_handle * handle UNUSED,
    703                         uint16_t           maxGlobalPeers )
     701tr_sessionSetPeerLimit( tr_session * session UNUSED,
     702                        uint16_t     maxGlobalPeers )
    704703{
    705704    tr_fdSetPeerLimit( maxGlobalPeers );
     
    729728
    730729int
    731 tr_sessionCountTorrents( const tr_handle * h )
    732 {
    733     return h->torrentCount;
     730tr_sessionCountTorrents( const tr_session * session )
     731{
     732    return session->torrentCount;
    734733}
    735734
    736735static int
    737 compareTorrentByCur( const void * va,
    738                      const void * vb )
     736compareTorrentByCur( const void * va, const void * vb )
    739737{
    740738    const tr_torrent * a = *(const tr_torrent**)va;
     
    752750tr_closeAllConnections( void * vsession )
    753751{
    754     tr_handle *   session = vsession;
     752    tr_session *  session = vsession;
    755753    tr_torrent *  tor;
    756754    int           i, n;
     
    799797
    800798void
    801 tr_sessionClose( tr_handle * session )
     799tr_sessionClose( tr_session * session )
    802800{
    803801    int            i;
     
    856854
    857855tr_torrent **
    858 tr_sessionLoadTorrents( tr_handle * h,
    859                         tr_ctor ctor,
    860                         int *      setmeCount )
     856tr_sessionLoadTorrents( tr_session * session,
     857                        tr_ctor    * ctor,
     858                        int        * setmeCount )
    861859{
    862860    int           i, n = 0;
    863861    struct stat   sb;
    864862    DIR *         odir = NULL;
    865     const char *  dirname = tr_getTorrentDir( h );
     863    const char *  dirname = tr_getTorrentDir( session );
    866864    tr_torrent ** torrents;
    867865    tr_list *     l = NULL, *list = NULL;
     
    882880                char * path = tr_buildPath( dirname, d->d_name, NULL );
    883881                tr_ctorSetMetainfoFromFile( ctor, path );
    884                 if(( tor = tr_torrentNew( h, ctor, NULL )))
     882                if(( tor = tr_torrentNew( session, ctor, NULL )))
    885883                {
    886884                    tr_list_append( &list, tor );
     
    956954
    957955tr_bool
    958 tr_sessionIsPortForwardingEnabled( const tr_handle * h )
    959 {
    960     return tr_sharedTraversalIsEnabled( h->shared );
     956tr_sessionIsPortForwardingEnabled( const tr_session * session )
     957{
     958    return tr_sharedTraversalIsEnabled( session->shared );
    961959}
    962960
     
    10511049
    10521050static void
    1053 metainfoLookupResort( tr_handle * h )
    1054 {
    1055     qsort( h->metainfoLookup,
    1056            h->metainfoLookupCount,
     1051metainfoLookupResort( tr_session * session )
     1052{
     1053    qsort( session->metainfoLookup,
     1054           session->metainfoLookupCount,
    10571055           sizeof( struct tr_metainfo_lookup ),
    10581056           compareLookupEntries );
     
    10701068
    10711069const char*
    1072 tr_sessionFindTorrentFile( const tr_handle * h,
    1073                            const char *      hashStr )
     1070tr_sessionFindTorrentFile( const tr_session * session,
     1071                           const char       * hashStr )
    10741072{
    10751073    struct tr_metainfo_lookup * l = bsearch( hashStr,
    1076                                              h->metainfoLookup,
    1077                                              h->metainfoLookupCount,
    1078                                              sizeof( struct
    1079                                                      tr_metainfo_lookup ),
     1074                                             session->metainfoLookup,
     1075                                             session->metainfoLookupCount,
     1076                                             sizeof( struct tr_metainfo_lookup ),
    10801077                                             compareHashStringToLookupEntry );
    10811078
     
    10841081
    10851082static void
    1086 metainfoLookupRescan( tr_handle * h )
     1083metainfoLookupRescan( tr_session * session )
    10871084{
    10881085    int          i;
    10891086    int          n;
    10901087    struct stat  sb;
    1091     const char * dirname = tr_getTorrentDir( h );
     1088    const char * dirname = tr_getTorrentDir( session );
    10921089    DIR *        odir = NULL;
    10931090    tr_ctor *    ctor = NULL;
     
    10951092
    10961093    /* walk through the directory and find the mappings */
    1097     ctor = tr_ctorNew( h );
     1094    ctor = tr_ctorNew( session );
    10981095    tr_ctorSetSave( ctor, FALSE ); /* since we already have them */
    1099     if( !stat( dirname,
    1100                &sb ) && S_ISDIR( sb.st_mode )
    1101       && ( ( odir = opendir( dirname ) ) ) )
     1096    if( !stat( dirname, &sb ) && S_ISDIR( sb.st_mode ) && ( ( odir = opendir( dirname ) ) ) )
    11021097    {
    11031098        struct dirent *d;
     
    11101105                char * path = tr_buildPath( dirname, d->d_name, NULL );
    11111106                tr_ctorSetMetainfoFromFile( ctor, path );
    1112                 if( !tr_torrentParse( h, ctor, &inf ) )
     1107                if( !tr_torrentParse( session, ctor, &inf ) )
    11131108                {
    11141109                    tr_list_append( &list, tr_strdup( inf.hashString ) );
     
    11241119
    11251120    n = tr_list_size( list ) / 2;
    1126     h->metainfoLookup = tr_new0( struct tr_metainfo_lookup, n );
    1127     h->metainfoLookupCount = n;
     1121    session->metainfoLookup = tr_new0( struct tr_metainfo_lookup, n );
     1122    session->metainfoLookupCount = n;
    11281123    for( i = 0; i < n; ++i )
    11291124    {
     
    11311126        char * filename = tr_list_pop_front( &list );
    11321127
    1133         memcpy( h->metainfoLookup[i].hashString, hashString,
     1128        memcpy( session->metainfoLookup[i].hashString, hashString,
    11341129                2 * SHA_DIGEST_LENGTH + 1 );
    11351130        tr_free( hashString );
    1136         h->metainfoLookup[i].filename = filename;
    1137     }
    1138 
    1139     metainfoLookupResort( h );
     1131        session->metainfoLookup[i].filename = filename;
     1132    }
     1133
     1134    metainfoLookupResort( session );
    11401135    tr_dbg( "Found %d torrents in \"%s\"", n, dirname );
    11411136}
    11421137
    11431138void
    1144 tr_sessionSetTorrentFile( tr_handle *  h,
     1139tr_sessionSetTorrentFile( tr_session * session,
    11451140                          const char * hashString,
    11461141                          const char * filename )
    11471142{
    11481143    struct tr_metainfo_lookup * l = bsearch( hashString,
    1149                                              h->metainfoLookup,
    1150                                              h->metainfoLookupCount,
    1151                                              sizeof( struct
    1152                                                      tr_metainfo_lookup ),
     1144                                             session->metainfoLookup,
     1145                                             session->metainfoLookupCount,
     1146                                             sizeof( struct tr_metainfo_lookup ),
    11531147                                             compareHashStringToLookupEntry );
    11541148
     
    11631157    else
    11641158    {
    1165         const int                   n = h->metainfoLookupCount++;
     1159        const int n = session->metainfoLookupCount++;
    11661160        struct tr_metainfo_lookup * node;
    1167         h->metainfoLookup = tr_renew( struct tr_metainfo_lookup,
    1168                                       h->metainfoLookup,
    1169                                       h->metainfoLookupCount );
    1170         node = h->metainfoLookup + n;
     1161        session->metainfoLookup = tr_renew( struct tr_metainfo_lookup,
     1162                                            session->metainfoLookup,
     1163                                            session->metainfoLookupCount );
     1164        node = session->metainfoLookup + n;
    11711165        memcpy( node->hashString, hashString, 2 * SHA_DIGEST_LENGTH + 1 );
    11721166        node->filename = tr_strdup( filename );
    1173         metainfoLookupResort( h );
     1167        metainfoLookupResort( session );
    11741168    }
    11751169}
    11761170
    11771171tr_torrent*
    1178 tr_torrentNext( tr_handle * session,
     1172tr_torrentNext( tr_session * session,
    11791173                tr_torrent * tor )
    11801174{
  • trunk/libtransmission/stats.c

    r7134 r7385  
    3131
    3232static char*
    33 getOldFilename( const tr_handle * handle )
    34 {
    35     return tr_buildPath( tr_sessionGetConfigDir( handle ), "stats.benc", NULL );
     33getOldFilename( const tr_session * session )
     34{
     35    return tr_buildPath( tr_sessionGetConfigDir( session ), "stats.benc", NULL );
    3636}
    3737
    3838static char*
    39 getFilename( const tr_handle * handle )
    40 {
    41     return tr_buildPath( tr_sessionGetConfigDir( handle ), "stats.json", NULL );
    42 }
    43 
    44 static void
    45 loadCumulativeStats( const tr_handle *  handle,
     39getFilename( const tr_session * session )
     40{
     41    return tr_buildPath( tr_sessionGetConfigDir( session ), "stats.json", NULL );
     42}
     43
     44static void
     45loadCumulativeStats( const tr_session * session,
    4646                     tr_session_stats * setme )
    4747{
     
    5050    tr_benc top;
    5151
    52     filename = getFilename( handle );
     52    filename = getFilename( session );
    5353    loaded = !tr_bencLoadJSONFile( filename, &top );
    5454    tr_free( filename );
     
    5656    if( !loaded )
    5757    {
    58         filename = getOldFilename( handle );
     58        filename = getOldFilename( session );
    5959        loaded = !tr_bencLoadFile( filename, &top );
    6060        tr_free( filename );
     
    8181
    8282static void
    83 saveCumulativeStats( const tr_handle *        handle,
     83saveCumulativeStats( const tr_session * session,
    8484                     const tr_session_stats * s )
    8585{
     
    9494    tr_bencDictAddInt( &top, "uploaded-bytes",   s->uploadedBytes );
    9595
    96     filename = getFilename( handle );
     96    filename = getFilename( session );
    9797    tr_deepLog( __FILE__, __LINE__, NULL, "Saving stats to \"%s\"", filename );
    9898    tr_bencSaveJSONFile( filename, &top );
     
    107107
    108108void
    109 tr_statsInit( tr_handle * handle )
     109tr_statsInit( tr_session * session )
    110110{
    111111    struct tr_stats_handle * stats = tr_new0( struct tr_stats_handle, 1 );
    112112
    113     loadCumulativeStats( handle, &stats->old );
     113    loadCumulativeStats( session, &stats->old );
    114114    stats->single.sessionCount = 1;
    115115    stats->startTime = time( NULL );
    116     handle->sessionStats = stats;
    117 }
    118 
    119 void
    120 tr_statsClose( tr_handle * handle )
     116    session->sessionStats = stats;
     117}
     118
     119void
     120tr_statsClose( tr_session * session )
    121121{
    122122    tr_session_stats cumulative = STATS_INIT;
    123123
    124     tr_sessionGetCumulativeStats( handle, &cumulative );
    125     saveCumulativeStats( handle, &cumulative );
    126 
    127     tr_free( handle->sessionStats );
    128     handle->sessionStats = NULL;
     124    tr_sessionGetCumulativeStats( session, &cumulative );
     125    saveCumulativeStats( session, &cumulative );
     126
     127    tr_free( session->sessionStats );
     128    session->sessionStats = NULL;
    129129}
    130130
    131131static struct tr_stats_handle *
    132 getStats( const tr_handle * handle )
    133 {
    134     return handle ? handle->sessionStats : NULL;
     132getStats( const tr_session * session )
     133{
     134    return session ? session->sessionStats : NULL;
    135135}
    136136
     
    160160
    161161void
    162 tr_sessionGetStats( const tr_handle *  handle,
     162tr_sessionGetStats( const tr_session * session,
    163163                    tr_session_stats * setme )
    164164{
    165     const struct tr_stats_handle * stats = getStats( handle );
     165    const struct tr_stats_handle * stats = getStats( session );
    166166    if( stats )
    167167    {
     
    173173
    174174void
    175 tr_sessionGetCumulativeStats( const tr_handle *  handle,
     175tr_sessionGetCumulativeStats( const tr_session * session,
    176176                              tr_session_stats * setme )
    177177{
    178     const struct tr_stats_handle * stats = getStats( handle );
     178    const struct tr_stats_handle * stats = getStats( session );
    179179    tr_session_stats current = STATS_INIT;
    180180
    181181    if( stats )
    182182    {
    183         tr_sessionGetStats( handle, &current );
     183        tr_sessionGetStats( session, &current );
    184184        addStats( setme, &stats->old, &current );
    185185    }
     
    187187
    188188void
    189 tr_sessionClearStats( tr_handle * handle )
     189tr_sessionClearStats( tr_session * session )
    190190{
    191191    tr_session_stats zero;
     
    197197    zero.sessionCount = 0;
    198198    zero.secondsActive = 0;
    199     handle->sessionStats->single = handle->sessionStats->old = zero;
    200 
    201     handle->sessionStats->startTime = time( NULL );
     199
     200    session->sessionStats->single = session->sessionStats->old = zero;
     201    session->sessionStats->startTime = time( NULL );
    202202}
    203203
     
    207207
    208208void
    209 tr_statsAddUploaded( tr_handle * handle,
     209tr_statsAddUploaded( tr_session * session,
    210210                     uint32_t    bytes )
    211211{
    212212    struct tr_stats_handle * s;
    213213
    214     if( ( s = getStats( handle ) ) )
     214    if( ( s = getStats( session ) ) )
    215215        s->single.uploadedBytes += bytes;
    216216}
    217217
    218218void
    219 tr_statsAddDownloaded( tr_handle * handle,
    220                        uint32_t    bytes )
     219tr_statsAddDownloaded( tr_session * session,
     220                       uint32_t     bytes )
    221221{
    222222    struct tr_stats_handle * s;
    223223
    224     if( ( s = getStats( handle ) ) )
     224    if( ( s = getStats( session ) ) )
    225225        s->single.downloadedBytes += bytes;
    226226}
    227227
    228228void
    229 tr_statsFileCreated( tr_handle * handle )
     229tr_statsFileCreated( tr_session * session )
    230230{
    231231    struct tr_stats_handle * s;
    232232
    233     if( ( s = getStats( handle ) ) )
     233    if( ( s = getStats( session ) ) )
    234234        s->single.filesAdded++;
    235235}
  • trunk/libtransmission/torrent.c

    r7368 r7385  
    6161
    6262tr_torrent*
    63 tr_torrentFindFromId( tr_handle * handle,
    64                       int         id )
     63tr_torrentFindFromId( tr_session * session, int id )
    6564{
    6665    tr_torrent * tor = NULL;
    6766
    68     while( ( tor = tr_torrentNext( handle, tor ) ) )
     67    while( ( tor = tr_torrentNext( session, tor ) ) )
    6968        if( tor->uniqueId == id )
    7069            return tor;
     
    7473
    7574tr_torrent*
    76 tr_torrentFindFromHashString( tr_handle *  handle,
    77                               const char * str )
     75tr_torrentFindFromHashString( tr_session *  session, const char * str )
    7876{
    7977    tr_torrent * tor = NULL;
    8078
    81     while( ( tor = tr_torrentNext( handle, tor ) ) )
     79    while( ( tor = tr_torrentNext( session, tor ) ) )
    8280        if( !strcmp( str, tor->info.hashString ) )
    8381            return tor;
     
    8785
    8886tr_bool
    89 tr_torrentExists( const tr_handle * handle,
    90                   const uint8_t *   torrentHash )
    91 {
    92     return tr_torrentFindFromHash( (tr_handle*)handle,
    93                                   torrentHash ) != NULL;
     87tr_torrentExists( const tr_session * session, const uint8_t *   torrentHash )
     88{
     89    return tr_torrentFindFromHash( (tr_session*)session, torrentHash ) != NULL;
    9490}
    9591
    9692tr_torrent*
    97 tr_torrentFindFromHash( tr_handle *     handle,
    98                         const uint8_t * torrentHash )
     93tr_torrentFindFromHash( tr_session * session, const uint8_t * torrentHash )
    9994{
    10095    tr_torrent * tor = NULL;
    10196
    102     while( ( tor = tr_torrentNext( handle, tor ) ) )
     97    while( ( tor = tr_torrentNext( session, tor ) ) )
    10398        if( *tor->info.hash == *torrentHash )
    10499            if( !memcmp( tor->info.hash, torrentHash, SHA_DIGEST_LENGTH ) )
     
    109104
    110105tr_torrent*
    111 tr_torrentFindFromObfuscatedHash( tr_handle *     handle,
     106tr_torrentFindFromObfuscatedHash( tr_session * session,
    112107                                  const uint8_t * obfuscatedTorrentHash )
    113108{
    114109    tr_torrent * tor = NULL;
    115110
    116     while( ( tor = tr_torrentNext( handle, tor ) ) )
     111    while( ( tor = tr_torrentNext( session, tor ) ) )
    117112        if( !memcmp( tor->obfuscatedHash, obfuscatedTorrentHash,
    118113                     SHA_DIGEST_LENGTH ) )
     
    467462
    468463static void
    469 torrentRealInit( tr_handle *     h,
    470                  tr_torrent *    tor,
    471                  const tr_ctor * ctor )
     464torrentRealInit( tr_session      * session,
     465                 tr_torrent      * tor,
     466                 const tr_ctor   * ctor )
    472467{
    473468    int        doStart;
     
    477472    static int nextUniqueId = 1;
    478473
    479     tr_globalLock( h );
    480 
    481     tor->session   = h;
     474    tr_globalLock( session );
     475
     476    tor->session   = session;
    482477    tor->uniqueId = nextUniqueId++;
    483478
    484479    randomizeTiers( info );
    485480
    486     tor->bandwidth = tr_bandwidthNew( h, h->bandwidth );
     481    tor->bandwidth = tr_bandwidthNew( session, session->bandwidth );
    487482
    488483    tor->blockSize = getBlockSize( info->pieceSize );
     
    532527             NULL );
    533528
    534     tr_peerMgrAddTorrent( h->peerMgr, tor );
    535 
    536     assert( h->isPortSet );
    537 
     529    tr_peerMgrAddTorrent( session->peerMgr, tor );
     530
     531    assert( session->isPortSet );
    538532    assert( !tor->downloadedCur );
    539533    assert( !tor->uploadedCur );
     
    570564        tr_torrent * it = NULL;
    571565        tr_torrent * last = NULL;
    572         while( ( it = tr_torrentNext( h, it ) ) )
     566        while( ( it = tr_torrentNext( session, it ) ) )
    573567            last = it;
    574568
    575569        if( !last )
    576             h->torrentList = tor;
     570            session->torrentList = tor;
    577571        else
    578572            last->next = tor;
    579         ++h->torrentCount;
    580     }
    581 
    582     tr_globalUnlock( h );
     573        ++session->torrentCount;
     574    }
     575
     576    tr_globalUnlock( session );
    583577
    584578    /* maybe save our own copy of the metainfo */
     
    595589    }
    596590
    597     tr_metainfoMigrate( h, &tor->info );
     591    tr_metainfoMigrate( session, &tor->info );
    598592
    599593    if( doStart )
     
    602596
    603597int
    604 tr_torrentParse( const tr_handle * handle,
    605                  const tr_ctor ctor,
    606                  tr_info *        setmeInfo )
     598tr_torrentParse( const tr_session  * session,
     599                 const tr_ctor     * ctor,
     600                 tr_info           * setmeInfo )
    607601{
    608602    int             err = 0;
     
    618612        return TR_EINVALID;
    619613
    620     err = tr_metainfoParse( handle, setmeInfo, metainfo );
     614    err = tr_metainfoParse( session, setmeInfo, metainfo );
    621615    doFree = !err && ( setmeInfo == &tmp );
    622616
     
    624618        err = TR_EINVALID;
    625619
    626     if( !err && tr_torrentExists( handle, setmeInfo->hash ) )
     620    if( !err && tr_torrentExists( session, setmeInfo->hash ) )
    627621        err = TR_EDUPLICATE;
    628622
     
    634628
    635629tr_torrent *
    636 tr_torrentNew( tr_handle *     handle,
    637                const tr_ctor * ctor,
    638                int *          setmeError )
     630tr_torrentNew( tr_session     * session,
     631               const tr_ctor  * ctor,
     632               int            * setmeError )
    639633{
    640634    int          err;
     
    642636    tr_torrent * tor = NULL;
    643637
    644     err = tr_torrentParse( handle, ctor, &tmpInfo );
     638    err = tr_torrentParse( session, ctor, &tmpInfo );
    645639    if( !err )
    646640    {
    647641        tor = tr_new0( tr_torrent, 1 );
    648642        tor->info = tmpInfo;
    649         torrentRealInit( handle, tor, ctor );
     643        torrentRealInit( session, tor, ctor );
    650644    }
    651645    else if( setmeError )
     
    10491043{
    10501044    tr_torrent * t;
    1051     tr_handle *  h = tor->session;
     1045    tr_session *  session = tor->session;
    10521046    tr_info *    inf = &tor->info;
    10531047
     
    10551049    assert( !tor->isRunning );
    10561050
    1057     tr_globalLock( h );
    1058 
    1059     tr_peerMgrRemoveTorrent( h->peerMgr, tor->info.hash );
     1051    tr_globalLock( session );
     1052
     1053    tr_peerMgrRemoveTorrent( session->peerMgr, tor->info.hash );
    10601054
    10611055    tr_cpClose( tor->completion );
     
    10721066    tr_free( tor->peer_id );
    10731067
    1074     if( tor == h->torrentList )
    1075         h->torrentList = tor->next;
    1076     else for( t = h->torrentList; t != NULL; t = t->next )
    1077         {
    1078             if( t->next == tor )
    1079             {
    1080                 t->next = tor->next;
    1081                 break;
    1082             }
     1068    if( tor == session->torrentList )
     1069        session->torrentList = tor->next;
     1070    else for( t = session->torrentList; t != NULL; t = t->next ) {
     1071        if( t->next == tor ) {
     1072            t->next = tor->next;
     1073            break;
    10831074        }
    1084 
    1085     assert( h->torrentCount >= 1 );
    1086     h->torrentCount--;
     1075    }
     1076
     1077    assert( session->torrentCount >= 1 );
     1078    session->torrentCount--;
    10871079
    10881080    tr_bandwidthFree( tor->bandwidth );
     
    10911083    tr_free( tor );
    10921084
    1093     tr_globalUnlock( h );
     1085    tr_globalUnlock( session );
    10941086}
    10951087
     
    12491241    if( tor )
    12501242    {
    1251         tr_handle * handle = tor->session;
    1252         tr_globalLock( handle );
     1243        tr_session * session = tor->session;
     1244        tr_globalLock( session );
    12531245
    12541246        tr_torrentClearCompletenessCallback( tor );
    1255         tr_runInEventThread( handle, closeTorrent, tor );
    1256 
    1257         tr_globalUnlock( handle );
     1247        tr_runInEventThread( session, closeTorrent, tor );
     1248
     1249        tr_globalUnlock( session );
    12581250    }
    12591251}
  • trunk/libtransmission/tracker.h

    r7238 r7385  
    3232void         tr_trackerFree( tr_tracker * );
    3333
    34 void         tr_trackerSessionClose( tr_handle * );
     34void         tr_trackerSessionClose( tr_session * );
    3535
    3636/**
  • trunk/libtransmission/trevent.c

    r7173 r7385  
    122122    int          fds[2];
    123123    tr_lock *    lock;
    124     tr_handle *  h;
     124    tr_session *  session;
    125125    tr_thread *  thread;
    126126    struct event_base * base;
     
    218218
    219219static void
    220 logFunc( int          severity,
    221          const char * message )
     220logFunc( int severity, const char * message )
    222221{
    223222    if( severity >= _EVENT_LOG_ERR )
     
    239238#endif
    240239
    241     eh->h->events = eh;
     240    eh->session->events = eh;
    242241
    243242    /* listen to the pipe's read fd */
     
    251250    tr_lockFree( eh->lock );
    252251    event_base_free( eh->base );
    253     eh->h->events = NULL;
     252    eh->session->events = NULL;
    254253    tr_free( eh );
    255254    tr_dbg( "Closing libevent thread" );
     
    257256
    258257void
    259 tr_eventInit( tr_handle * handle )
     258tr_eventInit( tr_session * session )
    260259{
    261260    tr_event_handle * eh;
     
    264263    eh->lock = tr_lockNew( );
    265264    pipe( eh->fds );
    266     eh->h = handle;
     265    eh->session = session;
    267266    eh->base = event_init( );
    268267    eh->thread = tr_threadNew( libeventThreadFunc, eh );
     
    270269
    271270void
    272 tr_eventClose( tr_handle * handle )
    273 {
    274     handle->events->die = TRUE;
     271tr_eventClose( tr_session * session )
     272{
     273    session->events->die = TRUE;
    275274    tr_deepLog( __FILE__, __LINE__, NULL, "closing trevent pipe" );
    276     EVUTIL_CLOSESOCKET( handle->events->fds[1] );
     275    EVUTIL_CLOSESOCKET( session->events->fds[1] );
    277276}
    278277
     
    282281
    283282int
    284 tr_amInEventThread( struct tr_handle * handle )
    285 {
    286     assert( handle );
    287     assert( handle->events );
    288 
    289     return tr_amInThread( handle->events->thread );
     283tr_amInEventThread( tr_session * session )
     284{
     285    assert( session );
     286    assert( session->events );
     287
     288    return tr_amInThread( session->events->thread );
    290289}
    291290
     
    295294
    296295static void
    297 timerCallback( int fd      UNUSED,
    298                short event UNUSED,
    299                void *      vtimer )
     296timerCallback( int    fd UNUSED,
     297               short  event UNUSED,
     298               void * vtimer )
    300299{
    301300    int               more;
     
    325324    if( timer && !timer->inCallback )
    326325    {
    327         assert( tr_amInEventThread( timer->eh->h ) );
     326        assert( tr_amInEventThread( timer->eh->session ) );
    328327        event_del( &timer->event );
    329328        tr_free( timer );
     
    332331
    333332tr_timer*
    334 tr_timerNew( struct tr_handle * handle,
    335              timer_func         func,
    336              void *            user_data,
    337              uint64_t           interval_milliseconds )
     333tr_timerNew( tr_session * session,
     334             timer_func   func,
     335             void       * user_data,
     336             uint64_t     interval_milliseconds )
    338337{
    339338    tr_timer * timer;
    340339
    341     assert( handle );
    342     assert( handle->events );
     340    assert( session );
     341    assert( session->events );
    343342
    344343    timer = tr_new0( tr_timer, 1 );
     
    346345    timer->func = func;
    347346    timer->user_data = user_data;
    348     timer->eh = handle->events;
     347    timer->eh = session->events;
    349348    evtimer_set( &timer->event, timerCallback, timer );
    350349
    351     if( tr_amInThread( handle->events->thread ) )
     350    if( tr_amInThread( session->events->thread ) )
    352351    {
    353352        evtimer_add( &timer->event,  &timer->tv );
     
    356355    {
    357356        const char ch = 't';
    358         int        fd = handle->events->fds[1];
    359         tr_lock *  lock = handle->events->lock;
     357        int        fd = session->events->fds[1];
     358        tr_lock *  lock = session->events->lock;
    360359
    361360        tr_lockLock( lock );
     
    369368
    370369void
    371 tr_runInEventThread( struct tr_handle *       handle,
    372                      void               func( void* ),
    373                      void *                   user_data )
    374 {
    375     assert( handle );
    376     assert( handle->events );
    377 
    378     if( tr_amInThread( handle->events->thread ) )
     370tr_runInEventThread( tr_session * session,
     371                     void func( void* ), void * user_data )
     372{
     373    assert( session );
     374    assert( session->events );
     375
     376    if( tr_amInThread( session->events->thread ) )
    379377    {
    380378        (func)( user_data );
     
    383381    {
    384382        const char         ch = 'r';
    385         int                fd = handle->events->fds[1];
    386         tr_lock *          lock = handle->events->lock;
     383        int                fd = session->events->fds[1];
     384        tr_lock *          lock = session->events->lock;
    387385        struct tr_run_data data;
    388386
  • trunk/libtransmission/trevent.h

    r7151 r7385  
    2424**/
    2525
    26 void      tr_eventInit( struct tr_handle * tr_handle );
     26void      tr_eventInit( tr_session * );
    2727
    28 void      tr_eventClose( struct tr_handle * tr_handle );
     28void      tr_eventClose( tr_session * );
    2929
    30 struct event_base * tr_eventGetBase( struct tr_handle * tr_handle );
     30struct event_base * tr_eventGetBase( tr_session * );
    3131
    3232
     
    3838 * Otherwise, it's called again after the same interval.
    3939 */
    40 tr_timer* tr_timerNew(
    41     struct tr_handle *               handle,
    42     int                 func( void * user_data ),
    43     void *                           user_data,
    44     uint64_t
    45                                      timeout_milliseconds );
     40tr_timer* tr_timerNew( tr_session * handle,
     41                       int func( void * user_data ),
     42                       void * user_data,
     43                       uint64_t timeout_milliseconds );
    4644
    4745/**
     
    5149
    5250
    53 int       tr_amInEventThread( struct tr_handle * handle );
     51int       tr_amInEventThread( tr_session * );
    5452
    55 void      tr_runInEventThread( struct tr_handle *       handle,
    56                                void               func( void* ),
    57                                void *                  user_data );
     53void      tr_runInEventThread( tr_session * session,
     54                               void         func( void* ),
     55                               void       * user_data );
    5856
    5957#endif
  • trunk/libtransmission/web.c

    r7245 r7385  
    9595{
    9696    struct tr_web_task * task = vtask;
    97     const tr_handle * session = task->session;
     97    const tr_session * session = task->session;
    9898
    9999    if( session && session->web )
  • trunk/libtransmission/web.h

    r6795 r7385  
    1414#define TR_HTTP_H
    1515
    16 struct tr_handle;
    1716typedef struct tr_web tr_web;
    1817
    19 tr_web*      tr_webInit( struct tr_handle * session );
     18tr_web*      tr_webInit( tr_session * session );
    2019
    2120void         tr_webClose( tr_web ** );
    2221
    23 typedef void ( tr_web_done_func )( struct tr_handle * session,
     22typedef void ( tr_web_done_func )( tr_session      * session,
    2423                                   long               response_code,
    25                                    const void *      response,
     24                                   const void       * response,
    2625                                   size_t             response_byte_count,
    27                                    void *            user_data );
     26                                   void             * user_data );
    2827
    2928const char * tr_webGetResponseStr( long response_code );
    3029
    31 void         tr_webRun( struct tr_handle * session,
    32                         const char *      url,
    33                         const char *      range,
    34                         tr_web_done_func   done_func,
    35                         void *            done_func_user_data );
     30void         tr_webRun( tr_session        * session,
     31                        const char        * url,
     32                        const char        * range,
     33                        tr_web_done_func    done_func,
     34                        void              * done_func_user_data );
    3635
    3736
  • trunk/libtransmission/webseed.c

    r7289 r7385  
    148148
    149149static void
    150 webResponseFunc( tr_handle     * session,
     150webResponseFunc( tr_session    * session,
    151151                 long            response_code,
    152152                 const void    * response,
Note: See TracChangeset for help on using the changeset viewer.