Changeset 7710


Ignore:
Timestamp:
Jan 13, 2009, 9:00:05 PM (12 years ago)
Author:
charles
Message:

(trunk libT) peerMgr: operate directly on tr_torrent and not peerMgr+torrentHash

Location:
trunk/libtransmission
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/fastresume.c

    r7578 r7710  
    416416            tr_pex pex;
    417417            readBytes( &pex, &buf, sizeof( tr_pex ) );
    418             tr_peerMgrAddPex( tor->session->peerMgr, tor->info.hash,
    419                               TR_PEER_FROM_CACHE,
    420                               &pex );
     418            tr_peerMgrAddPex( tor, TR_PEER_FROM_CACHE, &pex );
    421419        }
    422420
  • trunk/libtransmission/handshake.c

    r7658 r7710  
    847847    {
    848848        const tr_bool clientIsSeed = tr_torrentIsSeed( tor );
    849         const tr_bool peerIsSeed = tr_peerMgrPeerIsSeed( handshake->session->peerMgr,
    850                                                          tor->info.hash,
    851                                                          tr_peerIoGetAddress( handshake->io, NULL ) );
     849        const tr_bool peerIsSeed = tr_peerMgrPeerIsSeed( tor, tr_peerIoGetAddress( handshake->io, NULL ) );
    852850        dbgmsg( handshake, "got INCOMING connection's encrypted handshake for torrent [%s]",
    853851                tor->info.name );
  • trunk/libtransmission/peer-mgr.c

    r7705 r7710  
     1
    12/*
    23 * This file Copyright (C) 2007-2009 Charles Kerr <charles@transmissionbt.com>
     
    116117};
    117118
    118 typedef struct
     119typedef struct tr_torrent_peers
    119120{
    120121    tr_bool         isRunning;
     
    139140{
    140141    tr_session      * session;
    141     tr_ptrArray       torrents; /* Torrent */
    142142    tr_ptrArray       incomingHandshakes; /* tr_handshake */
    143143    tr_timer        * bandwidthTimer;
     
    235235**/
    236236
    237 static int
    238 torrentCompare( const void * va,
    239                 const void * vb )
    240 {
    241     const Torrent * a = va;
    242     const Torrent * b = vb;
    243 
    244     return memcmp( a->hash, b->hash, SHA_DIGEST_LENGTH );
    245 }
    246 
    247 static int
    248 torrentCompareToHash( const void * va,
    249                       const void * vb )
    250 {
    251     const Torrent * a = va;
    252     const uint8_t * b_hash = vb;
    253 
    254     return memcmp( a->hash, b_hash, SHA_DIGEST_LENGTH );
    255 }
    256 
    257237static Torrent*
    258238getExistingTorrent( tr_peerMgr *    manager,
    259239                    const uint8_t * hash )
    260240{
    261     return (Torrent*) tr_ptrArrayFindSorted( &manager->torrents,
    262                                              hash,
    263                                              torrentCompareToHash );
     241    tr_torrent * tor = tr_torrentFindFromHash( manager->session, hash );
     242
     243    return tor == NULL ? NULL : tor->torrentPeers;
    264244}
    265245
     
    454434
    455435    m->session = session;
    456     m->torrents = TR_PTR_ARRAY_INIT;
    457436    m->incomingHandshakes = TR_PTR_ARRAY_INIT;
    458437    m->bandwidthTimer = tr_timerNew( session, bandwidthPulse, m, BANDWIDTH_PERIOD_MSEC );
     
    474453    tr_ptrArrayDestruct( &manager->incomingHandshakes, NULL );
    475454
    476     /* free the torrents. */
    477     tr_ptrArrayDestruct( &manager->torrents, torrentDestructor );
    478 
    479455    managerUnlock( manager );
    480456    tr_free( manager );
     
    498474
    499475tr_bool
    500 tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
    501                       const uint8_t     * torrentHash,
     476tr_peerMgrPeerIsSeed( const tr_torrent  * tor,
    502477                      const tr_address  * addr )
    503478{
    504479    tr_bool isSeed = FALSE;
    505     const Torrent * t = NULL;
    506     const struct peer_atom * atom = NULL;
    507 
    508     t = getExistingTorrent( (tr_peerMgr*)mgr, torrentHash );
    509     if( t )
    510         atom = getExistingAtom( t, addr );
     480    const Torrent * t = tor->torrentPeers;
     481    const struct peer_atom * atom = getExistingAtom( t, addr );
     482
    511483    if( atom )
    512484        isSeed = ( atom->flags & ADDED_F_SEED_FLAG ) != 0;
     
    10851057                tr_torrentSetHasPiece( tor, p, ok );
    10861058                tr_torrentSetPieceChecked( tor, p, TRUE );
    1087                 tr_peerMgrSetBlame( tor->session->peerMgr, tor->info.hash, p, ok );
     1059                tr_peerMgrSetBlame( tor, p, ok );
    10881060
    10891061                if( !ok )
     
    13341306
    13351307void
    1336 tr_peerMgrAddPex( tr_peerMgr *    manager,
    1337                   const uint8_t * torrentHash,
     1308tr_peerMgrAddPex( tr_torrent   *  tor,
    13381309                  uint8_t         from,
    13391310                  const tr_pex *  pex )
     
    13411312    if( tr_isPex( pex ) ) /* safeguard against corrupt data */
    13421313    {
    1343         Torrent * t;
    1344         managerLock( manager );
    1345 
    1346         t = getExistingTorrent( manager, torrentHash );
     1314        Torrent * t = tor->torrentPeers;
     1315        managerLock( t->manager );
     1316
    13471317        if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
    13481318            ensureAtomExists( t, &pex->addr, pex->port, pex->flags, from );
    13491319
    1350         managerUnlock( manager );
     1320        managerUnlock( t->manager );
    13511321    }
    13521322}
     
    14301400
    14311401void
    1432 tr_peerMgrSetBlame( tr_peerMgr *     manager,
    1433                     const uint8_t *  torrentHash,
     1402tr_peerMgrSetBlame( tr_torrent     * tor,
    14341403                    tr_piece_index_t pieceIndex,
    14351404                    int              success )
     
    14381407    {
    14391408        int        peerCount, i;
    1440         Torrent *  t = getExistingTorrent( manager, torrentHash );
     1409        Torrent *  t = tor->torrentPeers;
    14411410        tr_peer ** peers;
    14421411
     
    14901459
    14911460int
    1492 tr_peerMgrGetPeers( tr_peerMgr      * manager,
    1493                     const uint8_t   * torrentHash,
     1461tr_peerMgrGetPeers( tr_torrent      * tor,
    14941462                    tr_pex         ** setme_pex,
    14951463                    uint8_t           af)
    14961464{
    14971465    int peersReturning = 0;
    1498     const Torrent *  t;
    1499 
    1500     managerLock( manager );
    1501 
    1502     t = getExistingTorrent( manager, torrentHash );
    1503     if( t == NULL )
    1504     {
    1505         *setme_pex = NULL;
    1506     }
    1507     else
     1466    const Torrent * t = tor->torrentPeers;
     1467
     1468    managerLock( t->manager );
     1469
    15081470    {
    15091471        int i;
     
    15401502    }
    15411503
    1542     managerUnlock( manager );
     1504    managerUnlock( t->manager );
    15431505    return peersReturning;
    15441506}
     
    15491511
    15501512void
    1551 tr_peerMgrStartTorrent( tr_peerMgr *    manager,
    1552                         const uint8_t * torrentHash )
    1553 {
    1554     Torrent * t;
    1555 
    1556     managerLock( manager );
    1557 
    1558     t = getExistingTorrent( manager, torrentHash );
     1513tr_peerMgrStartTorrent( tr_torrent * tor )
     1514{
     1515    Torrent * t = tor->torrentPeers;
     1516
     1517    managerLock( t->manager );
    15591518
    15601519    assert( t );
     
    15821541    }
    15831542
    1584     managerUnlock( manager );
     1543    managerUnlock( t->manager );
    15851544}
    15861545
     
    16051564
    16061565void
    1607 tr_peerMgrStopTorrent( tr_peerMgr *    manager,
    1608                        const uint8_t * torrentHash )
    1609 {
    1610     managerLock( manager );
    1611 
    1612     stopTorrent( getExistingTorrent( manager, torrentHash ) );
    1613 
    1614     managerUnlock( manager );
     1566tr_peerMgrStopTorrent( tr_torrent * tor )
     1567{
     1568    Torrent * t = tor->torrentPeers;
     1569
     1570    managerLock( t->manager );
     1571
     1572    stopTorrent( t );
     1573
     1574    managerUnlock( t->manager );
    16151575}
    16161576
     
    16191579                      tr_torrent * tor )
    16201580{
    1621     Torrent * t;
    1622 
    16231581    managerLock( manager );
    16241582
    16251583    assert( tor );
    1626     assert( getExistingTorrent( manager, tor->info.hash ) == NULL );
    1627 
    1628     t = torrentConstructor( manager, tor );
    1629     tr_ptrArrayInsertSorted( &manager->torrents, t, torrentCompare );
     1584    assert( tor->torrentPeers == NULL );
     1585
     1586    tor->torrentPeers = torrentConstructor( manager, tor );
    16301587
    16311588    managerUnlock( manager );
     
    16331590
    16341591void
    1635 tr_peerMgrRemoveTorrent( tr_peerMgr *    manager,
    1636                          const uint8_t * torrentHash )
    1637 {
    1638     Torrent * t;
    1639 
    1640     managerLock( manager );
    1641 
    1642     t = getExistingTorrent( manager, torrentHash );
    1643     assert( t );
    1644     stopTorrent( t );
    1645     tr_ptrArrayRemoveSorted( &manager->torrents, t, torrentCompare );
    1646     torrentDestructor( t );
    1647 
    1648     managerUnlock( manager );
     1592tr_peerMgrRemoveTorrent( tr_torrent * tor )
     1593{
     1594    tr_torrentLock( tor );
     1595
     1596    stopTorrent( tor->torrentPeers );
     1597    torrentDestructor( tor->torrentPeers );
     1598
     1599    tr_torrentUnlock( tor );
    16491600}
    16501601
    16511602void
    1652 tr_peerMgrTorrentAvailability( const tr_peerMgr * manager,
    1653                                const uint8_t *    torrentHash,
    1654                                int8_t *           tab,
     1603tr_peerMgrTorrentAvailability( const tr_torrent * tor,
     1604                               int8_t           * tab,
    16551605                               unsigned int       tabCount )
    16561606{
    16571607    tr_piece_index_t   i;
    16581608    const Torrent *    t;
    1659     const tr_torrent * tor;
    16601609    float              interval;
    16611610    tr_bool            isSeed;
    16621611    int                peerCount;
    16631612    const tr_peer **   peers;
    1664     managerLock( manager );
    1665 
    1666     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
     1613    tr_torrentLock( tor );
     1614
     1615    t = tor->torrentPeers;
    16671616    tor = t->tor;
    16681617    interval = tor->info.pieceCount / (float)tabCount;
     
    16871636    }
    16881637
    1689     managerUnlock( manager );
     1638    tr_torrentUnlock( tor );
    16901639}
    16911640
    16921641/* Returns the pieces that are available from peers */
    16931642tr_bitfield*
    1694 tr_peerMgrGetAvailable( const tr_peerMgr * manager,
    1695                         const uint8_t *    torrentHash )
     1643tr_peerMgrGetAvailable( const tr_torrent * tor )
    16961644{
    16971645    int i;
    16981646    int peerCount;
    1699     Torrent * t;
     1647    Torrent * t = tor->torrentPeers;
    17001648    const tr_peer ** peers;
    17011649    tr_bitfield * pieces;
    1702     managerLock( manager );
    1703 
    1704     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
     1650    managerLock( t->manager );
     1651
    17051652    pieces = tr_bitfieldNew( t->tor->info.pieceCount );
    17061653    peerCount = tr_ptrArraySize( &t->peers );
     
    17091656        tr_bitfieldOr( pieces, peers[i]->have );
    17101657
    1711     managerUnlock( manager );
     1658    managerUnlock( t->manager );
    17121659    return pieces;
    17131660}
     
    17291676
    17301677void
    1731 tr_peerMgrTorrentStats( const tr_peerMgr * manager,
    1732                         const uint8_t    * torrentHash,
     1678tr_peerMgrTorrentStats( tr_torrent       * tor,
    17331679                        int              * setmePeersKnown,
    17341680                        int              * setmePeersConnected,
     
    17401686{
    17411687    int i, size;
    1742     const Torrent * t;
     1688    const Torrent * t = tor->torrentPeers;
    17431689    const tr_peer ** peers;
    17441690    const tr_webseed ** webseeds;
    17451691
    1746     managerLock( manager );
    1747 
    1748     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
     1692    managerLock( t->manager );
     1693
    17491694    peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
    17501695    size = tr_ptrArraySize( &t->peers );
     
    17881733            ++*setmeWebseedsSendingToUs;
    17891734
    1790     managerUnlock( manager );
     1735    managerUnlock( t->manager );
    17911736}
    17921737
    17931738float*
    1794 tr_peerMgrWebSpeeds( const tr_peerMgr * manager,
    1795                      const uint8_t *    torrentHash )
    1796 {
    1797     const Torrent * t;
     1739tr_peerMgrWebSpeeds( const tr_torrent * tor )
     1740{
     1741    const Torrent * t = tor->torrentPeers;
    17981742    const tr_webseed ** webseeds;
    17991743    int i;
     
    18021746    uint64_t now;
    18031747
    1804     assert( manager );
    1805     managerLock( manager );
    1806 
    1807     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
     1748    assert( t->manager );
     1749    managerLock( t->manager );
     1750
    18081751    webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
    18091752    webseedCount = tr_ptrArraySize( &t->webseeds );
    1810     assert( webseedCount == t->tor->info.webseedCount );
     1753    assert( webseedCount == tor->info.webseedCount );
    18111754    ret = tr_new0( float, webseedCount );
    18121755    now = tr_date( );
     
    18161759            ret[i] = -1.0;
    18171760
    1818     managerUnlock( manager );
     1761    managerUnlock( t->manager );
    18191762    return ret;
    18201763}
     
    18281771
    18291772struct tr_peer_stat *
    1830 tr_peerMgrPeerStats( const   tr_peerMgr  * manager,
    1831                      const   uint8_t     * torrentHash,
     1773tr_peerMgrPeerStats( const tr_torrent    * tor,
    18321774                     int                 * setmeCount )
    18331775{
    18341776    int i, size;
    1835     const Torrent * t;
     1777    const Torrent * t = tor->torrentPeers;
    18361778    const tr_peer ** peers;
    18371779    tr_peer_stat * ret;
    18381780    uint64_t now;
    18391781
    1840     assert( manager );
    1841     managerLock( manager );
    1842 
    1843     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
     1782    assert( t->manager );
     1783    managerLock( t->manager );
     1784
    18441785    size = tr_ptrArraySize( &t->peers );
    18451786    peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
     
    18911832    *setmeCount = size;
    18921833
    1893     managerUnlock( manager );
     1834    managerUnlock( t->manager );
    18941835    return ret;
    18951836}
     
    23712312pumpAllPeers( tr_peerMgr * mgr )
    23722313{
    2373     const int torrentCount = tr_ptrArraySize( &mgr->torrents );
    2374     int       i, j;
    2375 
    2376     for( i=0; i<torrentCount; ++i )
    2377     {
    2378         Torrent * t = tr_ptrArrayNth( &mgr->torrents, i );
     2314    tr_torrent * tor = NULL;
     2315
     2316    while(( tor = tr_torrentNext( mgr->session, tor )))
     2317    {
     2318        int j;
     2319        Torrent * t = tor->torrentPeers;
     2320
    23792321        for( j=0; j<tr_ptrArraySize( &t->peers ); ++j )
    23802322        {
  • trunk/libtransmission/peer-mgr.h

    r7705 r7710  
    106106void tr_peerMgrFree( tr_peerMgr * manager );
    107107
    108 tr_bool tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
    109                               const uint8_t     * torrentHash,
    110                               const tr_address  * addr );
     108tr_bool tr_peerMgrPeerIsSeed( const tr_torrent * tor,
     109                              const tr_address * addr );
    111110
    112111void tr_peerMgrAddIncoming( tr_peerMgr  * manager,
     
    131130                               size_t      * setme_pex_count );
    132131
    133 void tr_peerMgrAddPex( tr_peerMgr     * manager,
    134                        const uint8_t  * torrentHash,
     132void tr_peerMgrAddPex( tr_torrent     * tor,
    135133                       uint8_t          from,
    136134                       const tr_pex   * pex );
    137135
    138 void tr_peerMgrSetBlame( tr_peerMgr        * manager,
    139                          const uint8_t     * torrentHash,
     136void tr_peerMgrSetBlame( tr_torrent        * tor,
    140137                         tr_piece_index_t    pieceIndex,
    141138                         int                 success );
    142139
    143 int  tr_peerMgrGetPeers( tr_peerMgr      * manager,
    144                          const uint8_t   * torrentHash,
     140int  tr_peerMgrGetPeers( tr_torrent      * tor,
    145141                         tr_pex         ** setme_pex,
    146142                         uint8_t           af);
    147143
    148 void tr_peerMgrStartTorrent( tr_peerMgr     * manager,
    149                              const uint8_t  * torrentHash );
     144void tr_peerMgrStartTorrent( tr_torrent * tor );
    150145
    151 void tr_peerMgrStopTorrent( tr_peerMgr      * manager,
    152                              const uint8_t  * torrentHash );
     146void tr_peerMgrStopTorrent( tr_torrent * tor );
    153147
    154148void tr_peerMgrAddTorrent( tr_peerMgr         * manager,
    155149                           struct tr_torrent  * tor );
    156150
    157 void tr_peerMgrRemoveTorrent( tr_peerMgr     * manager,
    158                               const uint8_t  * torrentHash );
     151void tr_peerMgrRemoveTorrent( tr_torrent * tor );
    159152
    160 void tr_peerMgrTorrentAvailability( const tr_peerMgr * manager,
    161                                     const uint8_t    * torrentHash,
     153void tr_peerMgrTorrentAvailability( const tr_torrent * tor,
    162154                                    int8_t           * tab,
    163155                                    unsigned int       tabCount );
    164156
    165 struct tr_bitfield* tr_peerMgrGetAvailable( const tr_peerMgr * manager,
    166                                             const uint8_t    * torrentHash );
     157struct tr_bitfield* tr_peerMgrGetAvailable( const tr_torrent * tor );
    167158
    168159int tr_peerMgrHasConnections( const tr_peerMgr * manager,
    169160                              const uint8_t    * torrentHash );
    170161
    171 void tr_peerMgrTorrentStats( const tr_peerMgr * manager,
    172                              const uint8_t * torrentHash,
     162void tr_peerMgrTorrentStats( tr_torrent * tor,
    173163                             int * setmePeersKnown,
    174164                             int * setmePeersConnected,
     
    179169                             int * setmePeersFrom ); /* TR_PEER_FROM__MAX */
    180170
    181 struct tr_peer_stat* tr_peerMgrPeerStats( const tr_peerMgr  * manager,
    182                                           const uint8_t     * torrentHash,
    183                                           int               * setmeCount );
     171struct tr_peer_stat* tr_peerMgrPeerStats( const tr_torrent * tor,
     172                                          int              * setmeCount );
    184173
    185 float* tr_peerMgrWebSpeeds( const tr_peerMgr  * manager,
    186                             const uint8_t     * torrentHash );
     174float* tr_peerMgrWebSpeeds( const tr_torrent * tor );
    187175
    188176
  • trunk/libtransmission/peer-msgs.c

    r7705 r7710  
    10471047    uint8_t * tmp = tr_new( uint8_t, msglen );
    10481048    tr_benc val;
    1049     const tr_torrent * tor = msgs->torrent;
     1049    tr_torrent * tor = msgs->torrent;
    10501050    const uint8_t * added;
    10511051    size_t added_len;
     
    10671067                                        &n );
    10681068            for( i = 0; i < n; ++i )
    1069                 tr_peerMgrAddPex( msgs->session->peerMgr, tor->info.hash,
    1070                                   TR_PEER_FROM_PEX, pex + i );
     1069                tr_peerMgrAddPex( tor, TR_PEER_FROM_PEX, pex + i );
    10711070            tr_free( pex );
    10721071        }
     
    10831082                                         &n );
    10841083            for( i = 0; i < n; ++i )
    1085                 tr_peerMgrAddPex( msgs->session->peerMgr, tor->info.hash,
    1086                                   TR_PEER_FROM_PEX, pex + i );
     1084                tr_peerMgrAddPex( tor, TR_PEER_FROM_PEX, pex + i );
    10871085            tr_free( pex );
    10881086        }
     
    19141912        tr_pex * newPex = NULL;
    19151913        tr_pex * newPex6 = NULL;
    1916         const int newCount = tr_peerMgrGetPeers( msgs->session->peerMgr,
    1917                                                  msgs->torrent->info.hash,
    1918                                                  &newPex, TR_AF_INET );
    1919         const int newCount6 = tr_peerMgrGetPeers( msgs->session->peerMgr,
    1920                                                   msgs->torrent->info.hash,
    1921                                                   &newPex6, TR_AF_INET6 );
     1914        const int newCount = tr_peerMgrGetPeers( msgs->torrent, &newPex, TR_AF_INET );
     1915        const int newCount6 = tr_peerMgrGetPeers( msgs->torrent, &newPex6, TR_AF_INET6 );
    19221916
    19231917        /* build the diffs */
  • trunk/libtransmission/resume.c

    r7683 r7710  
    6969{
    7070    tr_pex * pex = NULL;
    71     int count = tr_peerMgrGetPeers( tor->session->peerMgr,
    72                                     tor->info.hash, &pex, TR_AF_INET );
     71    int count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET );
    7372
    7473    if( count > 0 )
     
    7877    pex = NULL;
    7978   
    80     count = tr_peerMgrGetPeers( tor->session->peerMgr, tor->info.hash, &pex,
    81                                 TR_AF_INET6 );
     79    count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET6 );
    8280    if( count > 0 )
    8381        tr_bencDictAddRaw( dict, KEY_PEERS6, pex, sizeof( tr_pex ) * count );
     
    102100            tr_pex pex;
    103101            memcpy( &pex, str + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
    104             tr_peerMgrAddPex( tor->session->peerMgr,
    105                               tor->info.hash, TR_PEER_FROM_CACHE, &pex );
     102            tr_peerMgrAddPex( tor, TR_PEER_FROM_CACHE, &pex );
    106103        }
    107104        tr_tordbg( tor, "Loaded %d IPv4 peers from resume file", count );
     
    117114            tr_pex pex;
    118115            memcpy( &pex, str + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
    119             tr_peerMgrAddPex( tor->session->peerMgr,
    120                               tor->info.hash, TR_PEER_FROM_CACHE, &pex );
     116            tr_peerMgrAddPex( tor, TR_PEER_FROM_CACHE, &pex );
    121117        }
    122118        tr_tordbg( tor, "Loaded %d IPv6 peers from resume file", count );
  • trunk/libtransmission/torrent.c

    r7687 r7710  
    206206                if( event->allAreSeeds )
    207207                    pex[i].flags |= ADDED_F_SEED_FLAG;
    208                 tr_peerMgrAddPex( tor->session->peerMgr, tor->info.hash,
    209                                   TR_PEER_FROM_TRACKER, pex + i );
     208                tr_peerMgrAddPex( tor, TR_PEER_FROM_TRACKER, pex + i );
    210209            }
    211210
     
    745744                             &s->downloaders );
    746745
    747     tr_peerMgrTorrentStats( tor->session->peerMgr,
    748                             tor->info.hash,
     746    tr_peerMgrTorrentStats( tor,
    749747                            &s->peersKnown,
    750748                            &s->peersConnected,
     
    800798    {
    801799        tr_piece_index_t i;
    802         tr_bitfield *    peerPieces = tr_peerMgrGetAvailable(
    803             tor->session->peerMgr,
    804             tor->info.
    805             hash );
     800        tr_bitfield *    peerPieces = tr_peerMgrGetAvailable( tor );
    806801        s->desiredAvailable = 0;
    807802        for( i = 0; i < tor->info.pieceCount; ++i )
     
    920915tr_torrentWebSpeeds( const tr_torrent * tor )
    921916{
    922     return tor ? tr_peerMgrWebSpeeds( tor->session->peerMgr, tor->info.hash )
    923            : NULL;
     917    return tor ? tr_peerMgrWebSpeeds( tor ) : NULL;
    924918}
    925919
     
    931925
    932926    if( tor )
    933         ret = tr_peerMgrPeerStats( tor->session->peerMgr,
    934                                    tor->info.hash, peerCount );
     927        ret = tr_peerMgrPeerStats( tor, peerCount );
    935928
    936929    return ret;
     
    949942                        int                size )
    950943{
    951     tr_peerMgrTorrentAvailability( tor->session->peerMgr,
    952                                    tor->info.hash,
    953                                    tab, size );
     944    tr_peerMgrTorrentAvailability( tor, tab, size );
    954945}
    955946
     
    10131004    tr_globalLock( session );
    10141005
    1015     tr_peerMgrRemoveTorrent( session->peerMgr, tor->info.hash );
     1006    tr_peerMgrRemoveTorrent( tor );
    10161007
    10171008    tr_cpDestruct( &tor->completion );
     
    10661057    tor->startDate = time( NULL );
    10671058    tr_trackerStart( tor->tracker );
    1068     tr_peerMgrStartTorrent( tor->session->peerMgr, tor->info.hash );
     1059    tr_peerMgrStartTorrent( tor );
    10691060
    10701061    tr_globalUnlock( tor->session );
     
    11551146
    11561147    tr_verifyRemove( tor );
    1157     tr_peerMgrStopTorrent( tor->session->peerMgr, tor->info.hash );
     1148    tr_peerMgrStopTorrent( tor );
    11581149    tr_trackerStop( tor->tracker );
    11591150
  • trunk/libtransmission/torrent.h

    r7707 r7710  
    2525struct tr_bandwidth;
    2626struct tr_ratecontrol;
     27struct tr_torrent_peers;
    2728
    2829/**
     
    198199
    199200    struct tr_bandwidth      * bandwidth;
     201
     202    struct tr_torrent_peers  * torrentPeers;
    200203};
    201204
Note: See TracChangeset for help on using the changeset viewer.