Changeset 6832


Ignore:
Timestamp:
Oct 2, 2008, 3:53:33 PM (13 years ago)
Author:
charles
Message:

(libT) housekeeping: tr_torrent.handle --> tr_torrent.session

Location:
trunk/libtransmission
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/fastresume.c

    r6795 r6832  
    616616            tr_pex pex;
    617617            readBytes( &pex, &buf, sizeof( tr_pex ) );
    618             tr_peerMgrAddPex( tor->handle->peerMgr, tor->info.hash,
     618            tr_peerMgrAddPex( tor->session->peerMgr, tor->info.hash,
    619619                              TR_PEER_FROM_CACHE,
    620620                              &pex );
     
    714714    uint8_t *    ret = NULL;
    715715    char         path[MAX_PATH_LENGTH];
    716     const char * cacheDir = tr_getResumeDir( tor->handle );
     716    const char * cacheDir = tr_getResumeDir( tor->session );
    717717    const char * hash = tor->info.hashString;
    718718
    719     if( !ret && tor->handle->tag )
     719    if( !ret && tor->session->tag )
    720720    {
    721721        char base[1024];
    722         tr_snprintf( base, sizeof( base ), "%s-%s", hash, tor->handle->tag );
     722        tr_snprintf( base, sizeof( base ), "%s-%s", hash, tor->session->tag );
    723723        tr_buildPath( path, sizeof( path ), cacheDir, base, NULL );
    724724        ret = tr_loadFile( path, len );
     
    777777{
    778778    char         path[MAX_PATH_LENGTH];
    779     const char * cacheDir = tr_getResumeDir( tor->handle );
     779    const char * cacheDir = tr_getResumeDir( tor->session );
    780780    const char * hash = tor->info.hashString;
    781781
    782     if( tor->handle->tag )
     782    if( tor->session->tag )
    783783    {
    784784        char base[1024];
    785         tr_snprintf( base, sizeof( base ), "%s-%s", hash, tor->handle->tag );
     785        tr_snprintf( base, sizeof( base ), "%s-%s", hash, tor->session->tag );
    786786        tr_buildPath( path, sizeof( path ), cacheDir, base, NULL );
    787787        unlink( path );
  • trunk/libtransmission/inout.c

    r6795 r6832  
    8585
    8686    if( ( err == TR_OK ) && ( !fileExists ) && ( ioMode == TR_IO_WRITE ) )
    87         tr_statsFileCreated( tor->handle );
     87        tr_statsFileCreated( tor->session );
    8888
    8989    if( fd >= 0 )
  • trunk/libtransmission/peer-mgr.c

    r6795 r6832  
    890890            tor->activityDate = now;
    891891            tor->uploadedCur += e->length;
    892             tr_statsAddUploaded( tor->handle, e->length );
     892            tr_statsAddUploaded( tor->session, e->length );
    893893            if( peer )
    894894            {
     
    913913            if( peer )
    914914                tor->downloadedCur += e->length;
    915             tr_statsAddDownloaded( tor->handle, e->length );
     915            tr_statsAddDownloaded( tor->session, e->length );
    916916            if( peer )
    917917            {
     
    972972                tr_torrentSetHasPiece( tor, p, !err );
    973973                tr_torrentSetPieceChecked( tor, p, TRUE );
    974                 tr_peerMgrSetBlame( tor->handle->peerMgr, tor->info.hash, p,
     974                tr_peerMgrSetBlame( tor->session->peerMgr, tor->info.hash, p,
    975975                                    !err );
    976976
  • trunk/libtransmission/peer-msgs.c

    r6795 r6832  
    20932093    m->publisher = tr_publisherNew( );
    20942094    m->info = info;
    2095     m->session = torrent->handle;
     2095    m->session = torrent->session;
    20962096    m->torrent = torrent;
    20972097    m->io = info->io;
  • trunk/libtransmission/resume.c

    r6795 r6832  
    5252{
    5353    return tr_strdup_printf( "%s%c%s.%16.16s.resume",
    54                              tr_getResumeDir( tor->handle ),
     54                             tr_getResumeDir( tor->session ),
    5555                             TR_PATH_DELIMITER,
    5656                             tor->info.name,
     
    6767{
    6868    tr_pex *  pex = NULL;
    69     const int count = tr_peerMgrGetPeers( tor->handle->peerMgr,
     69    const int count = tr_peerMgrGetPeers( tor->session->peerMgr,
    7070                                          tor->info.hash, &pex );
    7171
     
    9191            tr_pex pex;
    9292            memcpy( &pex, str + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
    93             tr_peerMgrAddPex( tor->handle->peerMgr,
     93            tr_peerMgrAddPex( tor->session->peerMgr,
    9494                              tor->info.hash, TR_PEER_FROM_CACHE, &pex );
    9595        }
  • trunk/libtransmission/torrent.c

    r6795 r6832  
    127127tr_torrentLock( const tr_torrent * tor )
    128128{
    129     tr_globalLock( tor->handle );
     129    tr_globalLock( tor->session );
    130130}
    131131
     
    133133tr_torrentUnlock( const tr_torrent * tor )
    134134{
    135     tr_globalUnlock( tor->handle );
     135    tr_globalUnlock( tor->session );
    136136}
    137137
     
    223223                if( event->allAreSeeds )
    224224                    pex[i].flags |= ADDED_F_SEED_FLAG;
    225                 tr_peerMgrAddPex( tor->handle->peerMgr, tor->info.hash,
     225                tr_peerMgrAddPex( tor->session->peerMgr, tor->info.hash,
    226226                                  TR_PEER_FROM_TRACKER, pex + i );
    227227            }
     
    462462    tr_globalLock( h );
    463463
    464     tor->handle   = h;
     464    tor->session   = h;
    465465    tor->uniqueId = nextUniqueId++;
    466466
     
    538538    {
    539539        tr_torrentSetSpeedLimit( tor, TR_UP,
    540                                 tr_sessionGetSpeedLimit( tor->handle, TR_UP ) );
     540                                tr_sessionGetSpeedLimit( tor->session, TR_UP ) );
    541541        tr_torrentSetSpeedLimit( tor, TR_DOWN,
    542                                 tr_sessionGetSpeedLimit( tor->handle,
     542                                tr_sessionGetSpeedLimit( tor->session,
    543543                                                         TR_DOWN ) );
    544544    }
     
    574574            const char * filename = tor->info.torrent;
    575575            tr_bencSaveFile( filename, val );
    576             tr_sessionSetTorrentFile( tor->handle, tor->info.hashString,
     576            tr_sessionSetTorrentFile( tor->session, tor->info.hashString,
    577577                                      filename );
    578578        }
     
    681681{
    682682    return tor
    683            && tor->handle->isPexEnabled
     683           && tor->session->isPexEnabled
    684684           && !tr_torrentIsPrivate( tor );
    685685}
     
    697697tr_torrentManualUpdate( tr_torrent * tor )
    698698{
    699     tr_runInEventThread( tor->handle, tr_torrentManualUpdateImpl, tor );
     699    tr_runInEventThread( tor->session, tr_torrentManualUpdateImpl, tor );
    700700}
    701701
     
    770770                         &s->leechers,
    771771                         &s->seeders );
    772     tr_peerMgrTorrentStats( tor->handle->peerMgr,
     772    tr_peerMgrTorrentStats( tor->session->peerMgr,
    773773                            tor->info.hash,
    774774                            &s->peersKnown,
     
    822822        tr_piece_index_t i;
    823823        tr_bitfield *    peerPieces = tr_peerMgrGetAvailable(
    824             tor->handle->peerMgr,
     824            tor->session->peerMgr,
    825825            tor->info.
    826826            hash );
     
    942942tr_torrentWebSpeeds( const tr_torrent * tor )
    943943{
    944     return tor ? tr_peerMgrWebSpeeds( tor->handle->peerMgr, tor->info.hash )
     944    return tor ? tr_peerMgrWebSpeeds( tor->session->peerMgr, tor->info.hash )
    945945           : NULL;
    946946}
     
    953953
    954954    if( tor )
    955         ret = tr_peerMgrPeerStats( tor->handle->peerMgr,
     955        ret = tr_peerMgrPeerStats( tor->session->peerMgr,
    956956                                   tor->info.hash, peerCount );
    957957
     
    971971                        int                size )
    972972{
    973     tr_peerMgrTorrentAvailability( tor->handle->peerMgr,
     973    tr_peerMgrTorrentAvailability( tor->session->peerMgr,
    974974                                   tor->info.hash,
    975975                                   tab, size );
     
    10271027{
    10281028    tr_torrent * t;
    1029     tr_handle *  h = tor->handle;
     1029    tr_handle *  h = tor->session;
    10301030    tr_info *    inf = &tor->info;
    10311031
     
    10781078    tr_torrent * tor = vtor;
    10791079
    1080     tr_globalLock( tor->handle );
     1080    tr_globalLock( tor->session );
    10811081
    10821082    tor->isRunning  = 1;
     
    10871087    tor->startDate = time( NULL );
    10881088    tr_trackerStart( tor->tracker );
    1089     tr_peerMgrStartTorrent( tor->handle->peerMgr, tor->info.hash );
    1090 
    1091     tr_globalUnlock( tor->handle );
     1089    tr_peerMgrStartTorrent( tor->session->peerMgr, tor->info.hash );
     1090
     1091    tr_globalUnlock( tor->session );
    10921092}
    10931093
     
    10951095checkAndStartCB( tr_torrent * tor )
    10961096{
    1097     tr_runInEventThread( tor->handle, checkAndStartImpl, tor );
     1097    tr_runInEventThread( tor->session, checkAndStartImpl, tor );
    10981098}
    10991099
     
    11021102              int          reloadProgress )
    11031103{
    1104     tr_globalLock( tor->handle );
     1104    tr_globalLock( tor->session );
    11051105
    11061106    if( !tor->isRunning )
     
    11121112    }
    11131113
    1114     tr_globalUnlock( tor->handle );
     1114    tr_globalUnlock( tor->session );
    11151115}
    11161116
     
    11311131torrentRecheckDoneCB( tr_torrent * tor )
    11321132{
    1133     tr_runInEventThread( tor->handle, torrentRecheckDoneImpl, tor );
     1133    tr_runInEventThread( tor->session, torrentRecheckDoneImpl, tor );
    11341134}
    11351135
     
    11391139    tr_verifyRemove( tor );
    11401140
    1141     tr_globalLock( tor->handle );
     1141    tr_globalLock( tor->session );
    11421142
    11431143    tr_torrentUncheck( tor );
    11441144    tr_verifyAdd( tor, torrentRecheckDoneCB );
    11451145
    1146     tr_globalUnlock( tor->handle );
     1146    tr_globalUnlock( tor->session );
    11471147}
    11481148
     
    11551155
    11561156    tr_verifyRemove( tor );
    1157     tr_peerMgrStopTorrent( tor->handle->peerMgr, tor->info.hash );
     1157    tr_peerMgrStopTorrent( tor->session->peerMgr, tor->info.hash );
    11581158    tr_trackerStop( tor->tracker );
    11591159
     
    11731173    if( tor )
    11741174    {
    1175         tr_globalLock( tor->handle );
     1175        tr_globalLock( tor->session );
    11761176
    11771177        tor->isRunning = 0;
    11781178        if( !tor->isDeleting )
    11791179            tr_torrentSaveResume( tor );
    1180         tr_runInEventThread( tor->handle, stopTorrent, tor );
    1181 
    1182         tr_globalUnlock( tor->handle );
     1180        tr_runInEventThread( tor->session, stopTorrent, tor );
     1181
     1182        tr_globalUnlock( tor->session );
    11831183    }
    11841184}
     
    11941194    if( tor->isDeleting )
    11951195    {
    1196         tr_metainfoRemoveSaved( tor->handle, &tor->info );
     1196        tr_metainfoRemoveSaved( tor->session, &tor->info );
    11971197        tr_torrentRemoveResume( tor );
    11981198    }
     
    12051205    if( tor )
    12061206    {
    1207         tr_handle * handle = tor->handle;
     1207        tr_handle * handle = tor->session;
    12081208        tr_globalLock( handle );
    12091209
     
    17031703        /* try to parse it back again, to make sure it's good */
    17041704        memset( &tmpInfo, 0, sizeof( tr_info ) );
    1705         if( !tr_metainfoParse( tor->handle, &tmpInfo, &metainfo ) )
     1705        if( !tr_metainfoParse( tor->session, &tmpInfo, &metainfo ) )
    17061706        {
    17071707            /* if it's good, save it and use it */
  • trunk/libtransmission/torrent.h

    r6795 r6832  
    4242                                   int              has );
    4343
    44 void        tr_torrentLock( const tr_torrent * );
    45 
    46 void        tr_torrentUnlock( const tr_torrent * );
    47 
    48 int         tr_torrentIsSeed( const tr_torrent * );
    49 
    50 void        tr_torrentChangeMyPort( tr_torrent * );
    51 
    52 int         tr_torrentExists( const tr_handle *,
    53                               const uint8_t * );
    54 
    55 tr_torrent* tr_torrentFindFromId(                     tr_handle *,
    56                                                   int id );
    57 
    58 tr_torrent* tr_torrentFindFromHash(                               tr_handle *,
    59                                                             const uint8_t * );
    60 
    61 tr_torrent* tr_torrentFindFromHashString(
    62           tr_handle *,
    63     const char * );
    64 
    65 tr_torrent* tr_torrentFindFromObfuscatedHash(
    66     tr_handle *,
    67     const
    68     uint8_t* );
     44void        tr_torrentLock( const tr_torrent * session );
     45
     46void        tr_torrentUnlock( const tr_torrent * session );
     47
     48int         tr_torrentIsSeed( const tr_torrent * session );
     49
     50void        tr_torrentChangeMyPort( tr_torrent * session );
     51
     52int         tr_torrentExists( const tr_session * session,
     53                              const uint8_t    * hash );
     54
     55tr_torrent* tr_torrentFindFromId( tr_session * session,
     56                                  int          id );
     57
     58tr_torrent* tr_torrentFindFromHash( tr_session *    session,
     59                                    const uint8_t * hash );
     60
     61tr_torrent* tr_torrentFindFromHashString( tr_session * session,
     62                                          const char * hashString );
     63
     64tr_torrent* tr_torrentFindFromObfuscatedHash( tr_session    * session,
     65                                              const uint8_t * hash );
    6966
    7067int         tr_torrentAllowsPex( const tr_torrent * );
     
    154151struct tr_torrent
    155152{
    156     tr_handle *              handle;
     153    tr_session *             session;
    157154    tr_info                  info;
    158155
  • trunk/libtransmission/tracker.c

    r6795 r6832  
    914914    tr_tracker *    t;
    915915
    916     ensureGlobalsExist( torrent->handle );
     916    ensureGlobalsExist( torrent->session );
    917917
    918918    t = tr_new0( tr_tracker, 1 );
    919919    t->publisher = tr_publisherNew( );
    920     t->session                  = torrent->handle;
     920    t->session                  = torrent->session;
    921921    t->scrapeIntervalSec        = DEFAULT_SCRAPE_INTERVAL_SEC;
    922922    t->retryScrapeIntervalSec   = FIRST_SCRAPE_RETRY_INTERVAL_SEC;
  • trunk/libtransmission/webseed.c

    r6795 r6832  
    301301  long)tr_torPieceCountBytes(w->torrent,piece), (unsigned long)have, (unsigned
    302302  long)left, (unsigned long)thisPass );*/
    303     tr_webRun( w->torrent->handle, url, range, webResponseFunc, w );
     303    tr_webRun( w->torrent->session, url, range, webResponseFunc, w );
    304304    tr_free( range );
    305305    tr_free( url );
Note: See TracChangeset for help on using the changeset viewer.