Changeset 7385
- Timestamp:
- Dec 14, 2008, 11:21:11 AM (12 years ago)
- Location:
- trunk/libtransmission
- Files:
-
- 26 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/libtransmission/handshake.c
r7340 r7385 93 93 tr_peerIo * io; 94 94 tr_crypto * crypto; 95 struct tr_handle * handle;95 tr_session * session; 96 96 uint8_t myPublicKey[KEY_LEN]; 97 97 uint8_t mySecret[KEY_LEN]; … … 207 207 uint8_t * walk = buf; 208 208 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 ); 210 210 const uint8_t * peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( ); 211 211 … … 266 266 tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof( hash ) ); 267 267 assert( tr_peerIoHasTorrentHash( handshake->io ) ); 268 if( !tr_torrentExists( handshake-> handle, hash )268 if( !tr_torrentExists( handshake->session, hash ) 269 269 || memcmp( hash, tr_peerIoGetTorrentHash( handshake->io ), 270 270 SHA_DIGEST_LENGTH ) ) … … 284 284 handshake->peer_id ); 285 285 286 tor = tr_torrentFindFromHash( handshake-> handle, hash );286 tor = tr_torrentFindFromHash( handshake->session, hash ); 287 287 peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( ); 288 288 if( !memcmp( handshake->peer_id, peer_id, PEER_ID_LEN ) ) … … 665 665 if( tr_peerIoIsIncoming( handshake->io ) ) 666 666 { 667 if( !tr_torrentExists( handshake-> handle, hash ) )667 if( !tr_torrentExists( handshake->session, hash ) ) 668 668 { 669 669 dbgmsg( handshake, "peer is trying to connect to us for a torrent we don't have." ); … … 725 725 726 726 /* 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 ) ); 728 728 peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( ); 729 729 peerIsGood = memcmp( handshake->peer_id, peer_id, PEER_ID_LEN ) != 0; … … 845 845 obfuscatedTorrentHash[i] = req2[i] ^ req3[i]; 846 846 if( ( tor = 847 tr_torrentFindFromObfuscatedHash( handshake-> handle,847 tr_torrentFindFromObfuscatedHash( handshake->session, 848 848 obfuscatedTorrentHash ) ) ) 849 849 { … … 852 852 tr_peerIoSetTorrentHash( handshake->io, tor->info.hash ); 853 853 if( !tr_torrentAllowsPex( tor ) 854 && tr_peerMgrPeerIsSeed( handshake-> handle->peerMgr,854 && tr_peerMgrPeerIsSeed( handshake->session->peerMgr, 855 855 tor->info.hash, 856 856 tr_peerIoGetAddress( handshake->io, NULL ) ) ) … … 1164 1164 handshake->doneCB = doneCB; 1165 1165 handshake->doneUserData = doneUserData; 1166 handshake-> handle= tr_peerIoGetSession( io );1166 handshake->session = tr_peerIoGetSession( io ); 1167 1167 tr_peerIoSetTimeoutSecs( io, 15 ); 1168 1168 -
trunk/libtransmission/iobuf.c
r7157 r7385 74 74 short enabled; /* events that are currently enabled */ 75 75 76 struct tr_handle* session;76 tr_session * session; 77 77 struct tr_bandwidth * bandwidth; 78 78 }; … … 246 246 247 247 struct tr_iobuf * 248 tr_iobuf_new( struct tr_handle* session,248 tr_iobuf_new( tr_session * session, 249 249 tr_bandwidth * bandwidth, 250 250 int fd, -
trunk/libtransmission/iobuf.h
r7154 r7385 69 69 70 70 /** @brief create a new tr_iobuf object. */ 71 struct tr_iobuf* tr_iobuf_new( struct tr_handle* session,71 struct tr_iobuf* tr_iobuf_new( tr_session * session, 72 72 struct tr_bandwidth * bandwidth, 73 73 int fd, -
trunk/libtransmission/makemeta.c
r6945 r7385 114 114 115 115 tr_metainfo_builder* 116 tr_metaInfoBuilderCreate( tr_ handle * handle,116 tr_metaInfoBuilderCreate( tr_session * session, 117 117 const char * topFile ) 118 118 { … … 123 123 124 124 ret->top = tr_strdup( topFile ); 125 ret->handle = handle;125 ret->handle = session; 126 126 { 127 127 struct stat sb; … … 445 445 446 446 static tr_lock* 447 getQueueLock( tr_ handle * h)447 getQueueLock( tr_session * session ) 448 448 { 449 449 static tr_lock * lock = NULL; 450 451 tr_globalLock( h ); 450 tr_globalLock( session ); 451 452 452 if( !lock ) 453 453 lock = tr_lockNew( ); 454 tr_globalUnlock( h ); 455 454 455 tr_globalUnlock( session ); 456 456 return lock; 457 457 } … … 460 460 makeMetaWorkerFunc( void * user_data ) 461 461 { 462 tr_ handle * handle = (tr_handle *)user_data;462 tr_session * session = user_data; 463 463 464 464 for( ; ; ) … … 467 467 468 468 /* find the next builder to process */ 469 tr_lock * lock = getQueueLock ( handle);469 tr_lock * lock = getQueueLock( session ); 470 470 tr_lockLock( lock ); 471 471 if( queue ) -
trunk/libtransmission/makemeta.h
r6795 r7385 46 46 uint32_t pieceCount; 47 47 int isSingleFile; 48 tr_ handle *handle;48 tr_session * handle; 49 49 50 50 /** … … 88 88 89 89 90 tr_metainfo_builder*tr_metaInfoBuilderCreate( tr_ handle * handle,90 tr_metainfo_builder*tr_metaInfoBuilderCreate( tr_session * session, 91 91 const char * topFile ); 92 92 -
trunk/libtransmission/metainfo.c
r6842 r7385 46 46 47 47 static char* 48 getTorrentFilename( const tr_ handle * handle,48 getTorrentFilename( const tr_session * session, 49 49 const tr_info * inf ) 50 50 { 51 51 return tr_strdup_printf( "%s%c%s.%16.16s.torrent", 52 tr_getTorrentDir( handle),52 tr_getTorrentDir( session ), 53 53 TR_PATH_DELIMITER, 54 54 inf->name, … … 57 57 58 58 static char* 59 getOldTorrentFilename( const tr_ handle * handle,59 getOldTorrentFilename( const tr_session * session, 60 60 const tr_info * inf ) 61 61 { … … 63 63 struct evbuffer * buf = evbuffer_new( ); 64 64 65 evbuffer_add_printf( buf, "%s%c%s", tr_getTorrentDir( handle),65 evbuffer_add_printf( buf, "%s%c%s", tr_getTorrentDir( session ), 66 66 TR_PATH_DELIMITER, 67 67 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 ); 70 70 71 71 ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) ); … … 75 75 76 76 void 77 tr_metainfoMigrate( tr_ handle * handle,77 tr_metainfoMigrate( tr_session * session, 78 78 tr_info * inf ) 79 79 { 80 80 struct stat new_sb; 81 char * name = getTorrentFilename( handle, inf );81 char * name = getTorrentFilename( session, inf ); 82 82 83 83 if( stat( name, &new_sb ) || ( ( new_sb.st_mode & S_IFMT ) != S_IFREG ) ) 84 84 { 85 char * old_name = getOldTorrentFilename( handle, inf );85 char * old_name = getOldTorrentFilename( session, inf ); 86 86 size_t contentLen; 87 87 uint8_t * content; 88 88 89 tr_mkdirp( tr_getTorrentDir( handle), 0777 );89 tr_mkdirp( tr_getTorrentDir( session ), 0777 ); 90 90 if( ( content = tr_loadFile( old_name, &contentLen ) ) ) 91 91 { … … 105 105 tr_free( inf->torrent ); 106 106 inf->torrent = tr_strdup( name ); 107 tr_sessionSetTorrentFile( handle, inf->hashString, name );107 tr_sessionSetTorrentFile( session, inf->hashString, name ); 108 108 unlink( old_name ); 109 109 } … … 341 341 342 342 static const char* 343 tr_metainfoParseImpl( const tr_ handle * handle,343 tr_metainfoParseImpl( const tr_session * session, 344 344 tr_info * inf, 345 345 const tr_benc * meta_in ) … … 437 437 /* filename of Transmission's copy */ 438 438 tr_free( inf->torrent ); 439 inf->torrent = getTorrentFilename( handle, inf );439 inf->torrent = getTorrentFilename( session, inf ); 440 440 441 441 return NULL; … … 443 443 444 444 int 445 tr_metainfoParse( const tr_ handle * handle,445 tr_metainfoParse( const tr_session * session, 446 446 tr_info * inf, 447 447 const tr_benc * meta_in ) 448 448 { 449 const char * badTag = tr_metainfoParseImpl( handle, inf, meta_in );449 const char * badTag = tr_metainfoParseImpl( session, inf, meta_in ); 450 450 451 451 if( badTag ) … … 489 489 490 490 void 491 tr_metainfoRemoveSaved( const tr_ handle * handle,491 tr_metainfoRemoveSaved( const tr_session * session, 492 492 const tr_info * inf ) 493 493 { 494 494 char * filename; 495 495 496 filename = getTorrentFilename( handle, inf );496 filename = getTorrentFilename( session, inf ); 497 497 unlink( filename ); 498 498 tr_free( filename ); 499 499 500 filename = getOldTorrentFilename( handle, inf );500 filename = getOldTorrentFilename( session, inf ); 501 501 unlink( filename ); 502 502 tr_free( filename ); -
trunk/libtransmission/metainfo.h
r7151 r7385 38 38 struct tr_benc; 39 39 40 int tr_metainfoParse( const tr_ handle * handle,41 tr_info *info,40 int tr_metainfoParse( const tr_session * session, 41 tr_info * info, 42 42 const struct tr_benc * benc ); 43 43 44 void tr_metainfoRemoveSaved( const tr_ handle * handle,45 const tr_info *info );44 void tr_metainfoRemoveSaved( const tr_session * session, 45 const tr_info * info ); 46 46 47 void tr_metainfoMigrate( tr_ handle * handle,48 tr_info *inf );47 void tr_metainfoMigrate( tr_session * session, 48 tr_info * inf ); 49 49 50 50 #ifdef __cplusplus -
trunk/libtransmission/peer-io.h
r7289 r7385 33 33 **/ 34 34 35 tr_peerIo* tr_peerIoNewOutgoing( struct tr_handle* session,35 tr_peerIo* tr_peerIoNewOutgoing( tr_session * session, 36 36 const struct tr_address * addr, 37 37 tr_port port, 38 38 const uint8_t * torrentHash ); 39 39 40 tr_peerIo* tr_peerIoNewIncoming( struct tr_handle* session,40 tr_peerIo* tr_peerIoNewIncoming( tr_session * session, 41 41 const struct tr_address * addr, 42 42 tr_port port, -
trunk/libtransmission/peer-mgr.h
r7289 r7385 26 26 #include "net.h" 27 27 28 struct tr_handle;29 28 struct tr_peer_stat; 30 29 struct tr_torrent; … … 50 49 int tr_pexCompare( const void * a, const void * b ); 51 50 52 tr_peerMgr* tr_peerMgrNew( struct tr_handle* );51 tr_peerMgr* tr_peerMgrNew( tr_session * ); 53 52 54 53 void tr_peerMgrFree( tr_peerMgr * manager ); -
trunk/libtransmission/platform.c
r7373 r7385 353 353 354 354 static void 355 migrateFiles( const tr_ handle * handle)355 migrateFiles( const tr_session * session ) 356 356 { 357 357 static int migrated = FALSE; … … 364 364 365 365 oldDir = getOldTorrentsDir( ); 366 newDir = tr_getTorrentDir( handle);366 newDir = tr_getTorrentDir( session ); 367 367 moveFiles( oldDir, newDir ); 368 368 369 369 oldDir = getOldCacheDir( ); 370 newDir = tr_getResumeDir( handle);370 newDir = tr_getResumeDir( session ); 371 371 moveFiles( oldDir, newDir ); 372 372 } … … 374 374 375 375 void 376 tr_setConfigDir( tr_ handle * handle,376 tr_setConfigDir( tr_session * session, 377 377 const char * configDir ) 378 378 { 379 379 char * path; 380 380 381 handle->configDir = tr_strdup( configDir );381 session->configDir = tr_strdup( configDir ); 382 382 383 383 path = tr_buildPath( configDir, RESUME_SUBDIR, NULL ); 384 384 tr_mkdirp( path, 0777 ); 385 handle->resumeDir = path;385 session->resumeDir = path; 386 386 387 387 path = tr_buildPath( configDir, TORRENT_SUBDIR, NULL ); 388 388 tr_mkdirp( path, 0777 ); 389 handle->torrentDir = path;390 391 migrateFiles( handle);389 session->torrentDir = path; 390 391 migrateFiles( session ); 392 392 } 393 393 394 394 const char * 395 tr_sessionGetConfigDir( const tr_ handle * handle)396 { 397 return handle->configDir;395 tr_sessionGetConfigDir( const tr_session * session ) 396 { 397 return session->configDir; 398 398 } 399 399 400 400 const char * 401 tr_getTorrentDir( const tr_ handle * handle)402 { 403 return handle->torrentDir;401 tr_getTorrentDir( const tr_session * session ) 402 { 403 return session->torrentDir; 404 404 } 405 405 406 406 const char * 407 tr_getResumeDir( const tr_ handle * handle)408 { 409 return handle->resumeDir;407 tr_getResumeDir( const tr_session * session ) 408 { 409 return session->resumeDir; 410 410 } 411 411 -
trunk/libtransmission/platform.h
r7232 r7385 43 43 typedef struct tr_thread tr_thread; 44 44 45 struct tr_handle; 45 void tr_setConfigDir( tr_session * session, 46 const char * configDir ); 46 47 47 void tr_setConfigDir( struct tr_handle * handle, 48 const char * configDir ); 48 const char * tr_getResumeDir( const tr_session * ); 49 49 50 const char * tr_get ResumeDir( const struct tr_handle* );50 const char * tr_getTorrentDir( const tr_session * ); 51 51 52 const char * tr_getTorrentDir( const struct tr_handle * ); 53 54 const char * tr_getClutchDir( const struct tr_handle * ); 52 const char * tr_getClutchDir( const tr_session * ); 55 53 56 54 -
trunk/libtransmission/port-forwarding.c
r7240 r7385 205 205 tr_shared * 206 206 tr_sharedInit( tr_session * session, 207 intisEnabled,208 intpublicPort )207 tr_bool isEnabled, 208 tr_bool publicPort ) 209 209 { 210 210 tr_shared * s = tr_new0( tr_shared, 1 ); … … 231 231 232 232 void 233 tr_sharedSetPort( tr_shared * s, 234 int port ) 233 tr_sharedSetPort( tr_shared * s, tr_port port ) 235 234 { 236 235 tr_torrent * tor = NULL; … … 242 241 } 243 242 244 int243 tr_port 245 244 tr_sharedGetPeerPort( const tr_shared * s ) 246 245 { … … 249 248 250 249 void 251 tr_sharedTraversalEnable( tr_shared * s, 252 int isEnabled ) 250 tr_sharedTraversalEnable( tr_shared * s, tr_bool isEnabled ) 253 251 { 254 252 s->isEnabled = isEnabled; 255 253 } 256 254 257 int 255 tr_bool 258 256 tr_sharedTraversalIsEnabled( const tr_shared * s ) 259 257 { -
trunk/libtransmission/port-forwarding.h
r7151 r7385 34 34 typedef struct tr_shared tr_shared; 35 35 36 tr_shared* tr_sharedInit( tr_handle *, 37 int isEnabled, 38 int publicPort ); 36 tr_shared* tr_sharedInit( tr_session*, tr_bool isEnabled, tr_bool publicPort ); 39 37 40 38 void tr_sharedShuttingDown( tr_shared * ); 41 39 42 void tr_sharedSetPort( tr_shared *, 43 int publicPort ); 40 void tr_sharedSetPort( tr_shared *, tr_port publicPort ); 44 41 45 void tr_sharedTraversalEnable( tr_shared *, 46 int isEnabled ); 42 void tr_sharedTraversalEnable( tr_shared *, tr_bool isEnabled ); 47 43 48 inttr_sharedGetPeerPort( const tr_shared * s );44 tr_port tr_sharedGetPeerPort( const tr_shared * s ); 49 45 50 inttr_sharedTraversalIsEnabled( const tr_shared * s );46 tr_bool tr_sharedTraversalIsEnabled( const tr_shared * s ); 51 47 52 48 int tr_sharedTraversalStatus( const tr_shared * ); -
trunk/libtransmission/rpc-server.c
r7368 r7385 53 53 tr_port port; 54 54 struct evhttp * httpd; 55 tr_ handle *session;55 tr_session * session; 56 56 char * username; 57 57 char * password; … … 683 683 684 684 tr_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 )685 tr_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 ) 693 693 { 694 694 tr_rpc_server * s; -
trunk/libtransmission/rpc-server.h
r7368 r7385 20 20 typedef struct tr_rpc_server tr_rpc_server; 21 21 22 tr_rpc_server * tr_rpcInit( struct tr_handle* session,23 tr_bool 24 tr_port 25 tr_bool 26 const char 27 tr_bool 28 const char 29 const char 22 tr_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 ); 30 30 31 31 void tr_rpcClose( tr_rpc_server ** freeme ); -
trunk/libtransmission/rpcimpl.c
r7348 r7385 31 31 32 32 static tr_rpc_callback_status 33 notify( tr_ handle *session,33 notify( tr_session * session, 34 34 int type, 35 35 tr_torrent * tor ) … … 49 49 50 50 static tr_torrent ** 51 getTorrents( tr_ handle * handle,52 tr_benc *args,53 int *setmeCount )51 getTorrents( tr_session * session, 52 tr_benc * args, 53 int * setmeCount ) 54 54 { 55 55 int torrentCount = 0; … … 72 72 const char * str; 73 73 if( tr_bencGetInt( node, &id ) ) 74 tor = tr_torrentFindFromId( handle, id );74 tor = tr_torrentFindFromId( session, id ); 75 75 else if( tr_bencGetStr( node, &str ) ) 76 tor = tr_torrentFindFromHashString( handle, str );76 tor = tr_torrentFindFromHashString( session, str ); 77 77 if( tor ) 78 78 torrents[torrentCount++] = tor; … … 84 84 tr_torrent * tor; 85 85 torrents = tr_new0( tr_torrent *, 1 ); 86 if( ( tor = tr_torrentFindFromId( handle, id ) ) )86 if( ( tor = tr_torrentFindFromId( session, id ) ) ) 87 87 torrents[torrentCount++] = tor; 88 88 } … … 90 90 { 91 91 tr_torrent * tor = NULL; 92 const int n = tr_sessionCountTorrents( handle);92 const int n = tr_sessionCountTorrents( session ); 93 93 torrents = tr_new0( tr_torrent *, n ); 94 while( ( tor = tr_torrentNext( handle, tor ) ) )94 while( ( tor = tr_torrentNext( session, tor ) ) ) 95 95 torrents[torrentCount++] = tor; 96 96 } … … 101 101 102 102 static const char* 103 torrentStart( tr_ handle * h,104 tr_benc *args_in,105 tr_benc * args_out UNUSED )103 torrentStart( tr_session * session, 104 tr_benc * args_in, 105 tr_benc * args_out UNUSED ) 106 106 { 107 107 int i, torrentCount; 108 tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );108 tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount ); 109 109 110 110 for( i = 0; i < torrentCount; ++i ) … … 112 112 tr_torrent * tor = torrents[i]; 113 113 tr_torrentStart( tor ); 114 notify( h, TR_RPC_TORRENT_STARTED, tor );114 notify( session, TR_RPC_TORRENT_STARTED, tor ); 115 115 } 116 116 tr_free( torrents ); … … 119 119 120 120 static const char* 121 torrentStop( tr_ handle * h,122 tr_benc *args_in,123 tr_benc * args_out UNUSED )121 torrentStop( tr_session * session, 122 tr_benc * args_in, 123 tr_benc * args_out UNUSED ) 124 124 { 125 125 int i, torrentCount; 126 tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );126 tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount ); 127 127 128 128 for( i = 0; i < torrentCount; ++i ) … … 130 130 tr_torrent * tor = torrents[i]; 131 131 tr_torrentStop( tor ); 132 notify( h, TR_RPC_TORRENT_STOPPED, tor );132 notify( session, TR_RPC_TORRENT_STOPPED, tor ); 133 133 } 134 134 tr_free( torrents ); … … 137 137 138 138 static const char* 139 torrentRemove( tr_ handle * h,139 torrentRemove( tr_session * session, 140 140 tr_benc * args_in, 141 141 tr_benc * args_out UNUSED ) … … 143 143 int i; 144 144 int torrentCount; 145 tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );145 tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount ); 146 146 147 147 for( i=0; i<torrentCount; ++i ) 148 148 { 149 149 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 ); 151 151 int64_t deleteFlag; 152 152 if( tr_bencDictFindInt( args_in, "delete-local-data", &deleteFlag ) && deleteFlag ) … … 155 155 tr_torrentRemove( tor ); 156 156 } 157 157 158 tr_free( torrents ); 158 159 return NULL; … … 160 161 161 162 static const char* 162 torrentVerify( tr_ handle * h,163 tr_benc *args_in,164 tr_benc * args_out UNUSED )163 torrentVerify( tr_session * session, 164 tr_benc * args_in, 165 tr_benc * args_out UNUSED ) 165 166 { 166 167 int i, torrentCount; 167 tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );168 tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount ); 168 169 169 170 for( i = 0; i < torrentCount; ++i ) … … 171 172 tr_torrent * tor = torrents[i]; 172 173 tr_torrentVerify( tor ); 173 notify( h, TR_RPC_TORRENT_CHANGED, tor ); 174 } 174 notify( session, TR_RPC_TORRENT_CHANGED, tor ); 175 } 176 175 177 tr_free( torrents ); 176 178 return NULL; … … 433 435 434 436 static const char* 435 torrentGet( tr_ handle * handle,436 tr_benc *args_in,437 tr_benc *args_out )437 torrentGet( tr_session * session, 438 tr_benc * args_in, 439 tr_benc * args_out ) 438 440 { 439 441 int i, torrentCount; 440 tr_torrent ** torrents = getTorrents( handle, args_in, &torrentCount );442 tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount ); 441 443 tr_benc * list = tr_bencDictAddList( args_out, "torrents", 442 444 torrentCount ); … … 520 522 521 523 static const char* 522 torrentSet( tr_ handle * h,523 tr_benc *args_in,524 tr_benc * args_out UNUSED )524 torrentSet( tr_session * session, 525 tr_benc * args_in, 526 tr_benc * args_out UNUSED ) 525 527 { 526 528 int i, torrentCount; 527 tr_torrent ** torrents = getTorrents( h, args_in, &torrentCount );529 tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount ); 528 530 529 531 for( i = 0; i < torrentCount; ++i ) … … 557 559 : TR_SPEEDLIMIT_GLOBAL ); 558 560 559 notify( h, TR_RPC_TORRENT_CHANGED, tor );561 notify( session, TR_RPC_TORRENT_CHANGED, tor ); 560 562 } 561 563 … … 569 571 570 572 static const char* 571 torrentAdd( tr_ handle * h,572 tr_benc *args_in,573 tr_benc *args_out )573 torrentAdd( tr_session * session, 574 tr_benc * args_in, 575 tr_benc * args_out ) 574 576 { 575 577 const char * filename = NULL; … … 588 590 tr_torrent * tor; 589 591 590 ctor = tr_ctorNew( h);592 ctor = tr_ctorNew( session ); 591 593 592 594 /* set the metainfo */ … … 609 611 tr_ctorSetPeerLimit( ctor, TR_FORCE, i ); 610 612 611 tor = tr_torrentNew( h, ctor, &err );613 tor = tr_torrentNew( session, ctor, &err ); 612 614 tr_ctorFree( ctor ); 613 615 … … 621 623 addInfo( tor, tr_bencDictAdd( args_out, 622 624 "torrent-added" ), &fields ); 623 notify( h, TR_RPC_TORRENT_ADDED, tor );625 notify( session, TR_RPC_TORRENT_ADDED, tor ); 624 626 tr_bencFree( &fields ); 625 627 } … … 642 644 643 645 static const char* 644 sessionSet( tr_ handle * h,645 tr_benc *args_in,646 tr_benc * args_out UNUSED )646 sessionSet( tr_session * session, 647 tr_benc * args_in, 648 tr_benc * args_out UNUSED ) 647 649 { 648 650 int64_t i; … … 650 652 651 653 if( tr_bencDictFindStr( args_in, "download-dir", &str ) ) 652 tr_sessionSetDownloadDir( h, str );654 tr_sessionSetDownloadDir( session, str ); 653 655 if( tr_bencDictFindInt( args_in, "peer-limit", &i ) ) 654 tr_sessionSetPeerLimit( h, i );656 tr_sessionSetPeerLimit( session, i ); 655 657 if( tr_bencDictFindInt( args_in, "pex-allowed", &i ) ) 656 tr_sessionSetPexEnabled( h, i );658 tr_sessionSetPexEnabled( session, i ); 657 659 if( tr_bencDictFindInt( args_in, "port", &i ) ) 658 tr_sessionSetPeerPort( h, i );660 tr_sessionSetPeerPort( session, i ); 659 661 if( tr_bencDictFindInt( args_in, "port-forwarding-enabled", &i ) ) 660 tr_sessionSetPortForwardingEnabled( h, i );662 tr_sessionSetPortForwardingEnabled( session, i ); 661 663 if( tr_bencDictFindInt( args_in, "speed-limit-down", &i ) ) 662 tr_sessionSetSpeedLimit( h, TR_DOWN, i );664 tr_sessionSetSpeedLimit( session, TR_DOWN, i ); 663 665 if( tr_bencDictFindInt( args_in, "speed-limit-down-enabled", &i ) ) 664 tr_sessionSetSpeedLimitEnabled( h, TR_DOWN, i );666 tr_sessionSetSpeedLimitEnabled( session, TR_DOWN, i ); 665 667 if( tr_bencDictFindInt( args_in, "speed-limit-up", &i ) ) 666 tr_sessionSetSpeedLimit( h, TR_UP, i );668 tr_sessionSetSpeedLimit( session, TR_UP, i ); 667 669 if( tr_bencDictFindInt( args_in, "speed-limit-up-enabled", &i ) ) 668 tr_sessionSetSpeedLimitEnabled( h, TR_UP, i );670 tr_sessionSetSpeedLimitEnabled( session, TR_UP, i ); 669 671 if( tr_bencDictFindStr( args_in, "encryption", &str ) ) 670 672 { 671 673 if( !strcmp( str, "required" ) ) 672 tr_sessionSetEncryption( h, TR_ENCRYPTION_REQUIRED );674 tr_sessionSetEncryption( session, TR_ENCRYPTION_REQUIRED ); 673 675 else if( !strcmp( str, "tolerated" ) ) 674 tr_sessionSetEncryption( h, TR_CLEAR_PREFERRED );676 tr_sessionSetEncryption( session, TR_CLEAR_PREFERRED ); 675 677 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 ); 680 682 681 683 return NULL; … … 683 685 684 686 static 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 { 687 sessionStats( 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 ))) { 696 699 ++total; 697 700 if( tor->isRunning ) … … 699 702 } 700 703 704 d = tr_bencDictAddDict( args_out, "session-stats", 5 ); 701 705 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 ) ); 703 707 tr_bencDictAddInt( d, "pausedTorrentCount", total - running ); 704 708 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 ) ); 706 710 return NULL; 707 711 } 708 712 709 713 static const char* 710 sessionGet( tr_ handle * h,711 tr_benc * args_in UNUSED,712 tr_benc *args_out )714 sessionGet( tr_session * session, 715 tr_benc * args_in UNUSED, 716 tr_benc * args_out ) 713 717 { 714 718 const char * str; 715 719 tr_benc * d = args_out; 716 720 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 ) ); 735 730 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; 746 735 } 747 736 tr_bencDictAddStr( d, "encryption", str ); … … 754 743 ***/ 755 744 756 typedef const char* ( handler )( tr_ handle*, tr_benc*, tr_benc* );745 typedef const char* ( handler )( tr_session*, tr_benc*, tr_benc* ); 757 746 758 747 static struct method … … 774 763 775 764 static char* 776 request_exec( struct tr_handle * handle,777 tr_benc *request,778 int *response_len )765 request_exec( tr_session * session, 766 tr_benc * request, 767 int * response_len ) 779 768 { 780 769 int64_t i; … … 801 790 result = i == n 802 791 ? "method name not recognized" 803 : ( *methods[i].func )( handle, args_in, args_out );792 : ( *methods[i].func )( session, args_in, args_out ); 804 793 } 805 794 … … 816 805 817 806 char* 818 tr_rpc_request_exec_json( struct tr_handle * handle,819 const void * 820 int 821 int *response_len )807 tr_rpc_request_exec_json( tr_session * session, 808 const void * request_json, 809 int request_len, 810 int * response_len ) 822 811 { 823 812 tr_benc top; … … 829 818 830 819 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 ); 832 821 833 822 if( have_content ) … … 916 905 917 906 char* 918 tr_rpc_request_exec_uri( struct tr_handle * handle,919 const void * 920 int 921 int *response_len )907 tr_rpc_request_exec_uri( tr_session * session, 908 const void * request_uri, 909 int request_len, 910 int * response_len ) 922 911 { 923 912 char * ret = NULL; … … 950 939 } 951 940 952 ret = request_exec( handle, &top, response_len );941 ret = request_exec( session, &top, response_len ); 953 942 954 943 /* cleanup */ -
trunk/libtransmission/rpcimpl.h
r6795 r7385 19 19 20 20 struct tr_benc; 21 struct tr_handle;22 21 23 22 /* http://www.json.org/ */ 24 char*tr_rpc_request_exec_json( struct tr_handle * handle,25 const void *request_json,26 int 27 int *response_len );23 char*tr_rpc_request_exec_json( tr_session * session, 24 const void * request_json, 25 int request_len, 26 int * response_len ); 28 27 29 28 /* 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 33 int *response_len );29 char*tr_rpc_request_exec_uri( tr_session * session, 30 const void * request_uri, 31 int request_len, 32 int * response_len ); 34 33 35 34 void tr_rpc_parse_list_str( struct tr_benc * setme, 36 const char *list_str,35 const char * list_str, 37 36 size_t list_str_len ); 38 37 -
trunk/libtransmission/session.c
r7374 r7385 344 344 } 345 345 346 static void metainfoLookupRescan( tr_ handle * h);346 static void metainfoLookupRescan( tr_session * ); 347 347 348 348 tr_session * … … 533 533 534 534 void 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 ); 535 tr_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 ); 542 541 } 543 542 } 544 543 545 544 const 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 );545 tr_sessionGetDownloadDir( const tr_session * session ) 546 { 547 return session->downloadDir; 548 } 549 550 /*** 551 **** 552 ***/ 553 554 void 555 tr_globalLock( tr_session * session ) 556 { 557 tr_lockLock( session->lock ); 558 } 559 560 void 561 tr_globalUnlock( tr_session * session ) 562 { 563 tr_lockUnlock( session->lock ); 565 564 } 566 565 567 566 tr_bool 568 tr_globalIsLocked( const struct tr_handle * handle)569 { 570 return handle && tr_lockHave( handle->lock );567 tr_globalIsLocked( const tr_session * session ) 568 { 569 return session && tr_lockHave( session->lock ); 571 570 } 572 571 … … 632 631 633 632 tr_port_forwarding 634 tr_sessionGetPortForwarding( const tr_ handle * h)635 { 636 return tr_sharedTraversalStatus( h->shared );633 tr_sessionGetPortForwarding( const tr_session * session ) 634 { 635 return tr_sharedTraversalStatus( session->shared ); 637 636 } 638 637 … … 700 699 701 700 void 702 tr_sessionSetPeerLimit( tr_ handle * handleUNUSED,703 uint16_t 701 tr_sessionSetPeerLimit( tr_session * session UNUSED, 702 uint16_t maxGlobalPeers ) 704 703 { 705 704 tr_fdSetPeerLimit( maxGlobalPeers ); … … 729 728 730 729 int 731 tr_sessionCountTorrents( const tr_ handle * h)732 { 733 return h->torrentCount;730 tr_sessionCountTorrents( const tr_session * session ) 731 { 732 return session->torrentCount; 734 733 } 735 734 736 735 static int 737 compareTorrentByCur( const void * va, 738 const void * vb ) 736 compareTorrentByCur( const void * va, const void * vb ) 739 737 { 740 738 const tr_torrent * a = *(const tr_torrent**)va; … … 752 750 tr_closeAllConnections( void * vsession ) 753 751 { 754 tr_ handle *session = vsession;752 tr_session * session = vsession; 755 753 tr_torrent * tor; 756 754 int i, n; … … 799 797 800 798 void 801 tr_sessionClose( tr_ handle* session )799 tr_sessionClose( tr_session * session ) 802 800 { 803 801 int i; … … 856 854 857 855 tr_torrent ** 858 tr_sessionLoadTorrents( tr_ handle * h,859 tr_ctor *ctor,860 int *setmeCount )856 tr_sessionLoadTorrents( tr_session * session, 857 tr_ctor * ctor, 858 int * setmeCount ) 861 859 { 862 860 int i, n = 0; 863 861 struct stat sb; 864 862 DIR * odir = NULL; 865 const char * dirname = tr_getTorrentDir( h);863 const char * dirname = tr_getTorrentDir( session ); 866 864 tr_torrent ** torrents; 867 865 tr_list * l = NULL, *list = NULL; … … 882 880 char * path = tr_buildPath( dirname, d->d_name, NULL ); 883 881 tr_ctorSetMetainfoFromFile( ctor, path ); 884 if(( tor = tr_torrentNew( h, ctor, NULL )))882 if(( tor = tr_torrentNew( session, ctor, NULL ))) 885 883 { 886 884 tr_list_append( &list, tor ); … … 956 954 957 955 tr_bool 958 tr_sessionIsPortForwardingEnabled( const tr_ handle * h)959 { 960 return tr_sharedTraversalIsEnabled( h->shared );956 tr_sessionIsPortForwardingEnabled( const tr_session * session ) 957 { 958 return tr_sharedTraversalIsEnabled( session->shared ); 961 959 } 962 960 … … 1051 1049 1052 1050 static void 1053 metainfoLookupResort( tr_ handle * h)1054 { 1055 qsort( h->metainfoLookup,1056 h->metainfoLookupCount,1051 metainfoLookupResort( tr_session * session ) 1052 { 1053 qsort( session->metainfoLookup, 1054 session->metainfoLookupCount, 1057 1055 sizeof( struct tr_metainfo_lookup ), 1058 1056 compareLookupEntries ); … … 1070 1068 1071 1069 const char* 1072 tr_sessionFindTorrentFile( const tr_ handle * h,1073 const char *hashStr )1070 tr_sessionFindTorrentFile( const tr_session * session, 1071 const char * hashStr ) 1074 1072 { 1075 1073 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 ), 1080 1077 compareHashStringToLookupEntry ); 1081 1078 … … 1084 1081 1085 1082 static void 1086 metainfoLookupRescan( tr_ handle * h)1083 metainfoLookupRescan( tr_session * session ) 1087 1084 { 1088 1085 int i; 1089 1086 int n; 1090 1087 struct stat sb; 1091 const char * dirname = tr_getTorrentDir( h);1088 const char * dirname = tr_getTorrentDir( session ); 1092 1089 DIR * odir = NULL; 1093 1090 tr_ctor * ctor = NULL; … … 1095 1092 1096 1093 /* walk through the directory and find the mappings */ 1097 ctor = tr_ctorNew( h);1094 ctor = tr_ctorNew( session ); 1098 1095 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 ) ) ) ) 1102 1097 { 1103 1098 struct dirent *d; … … 1110 1105 char * path = tr_buildPath( dirname, d->d_name, NULL ); 1111 1106 tr_ctorSetMetainfoFromFile( ctor, path ); 1112 if( !tr_torrentParse( h, ctor, &inf ) )1107 if( !tr_torrentParse( session, ctor, &inf ) ) 1113 1108 { 1114 1109 tr_list_append( &list, tr_strdup( inf.hashString ) ); … … 1124 1119 1125 1120 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; 1128 1123 for( i = 0; i < n; ++i ) 1129 1124 { … … 1131 1126 char * filename = tr_list_pop_front( &list ); 1132 1127 1133 memcpy( h->metainfoLookup[i].hashString, hashString,1128 memcpy( session->metainfoLookup[i].hashString, hashString, 1134 1129 2 * SHA_DIGEST_LENGTH + 1 ); 1135 1130 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 ); 1140 1135 tr_dbg( "Found %d torrents in \"%s\"", n, dirname ); 1141 1136 } 1142 1137 1143 1138 void 1144 tr_sessionSetTorrentFile( tr_ handle * h,1139 tr_sessionSetTorrentFile( tr_session * session, 1145 1140 const char * hashString, 1146 1141 const char * filename ) 1147 1142 { 1148 1143 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 ), 1153 1147 compareHashStringToLookupEntry ); 1154 1148 … … 1163 1157 else 1164 1158 { 1165 const int n = h->metainfoLookupCount++;1159 const int n = session->metainfoLookupCount++; 1166 1160 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; 1171 1165 memcpy( node->hashString, hashString, 2 * SHA_DIGEST_LENGTH + 1 ); 1172 1166 node->filename = tr_strdup( filename ); 1173 metainfoLookupResort( h);1167 metainfoLookupResort( session ); 1174 1168 } 1175 1169 } 1176 1170 1177 1171 tr_torrent* 1178 tr_torrentNext( tr_ handle *session,1172 tr_torrentNext( tr_session * session, 1179 1173 tr_torrent * tor ) 1180 1174 { -
trunk/libtransmission/stats.c
r7134 r7385 31 31 32 32 static char* 33 getOldFilename( const tr_ handle * handle)34 { 35 return tr_buildPath( tr_sessionGetConfigDir( handle), "stats.benc", NULL );33 getOldFilename( const tr_session * session ) 34 { 35 return tr_buildPath( tr_sessionGetConfigDir( session ), "stats.benc", NULL ); 36 36 } 37 37 38 38 static 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,39 getFilename( const tr_session * session ) 40 { 41 return tr_buildPath( tr_sessionGetConfigDir( session ), "stats.json", NULL ); 42 } 43 44 static void 45 loadCumulativeStats( const tr_session * session, 46 46 tr_session_stats * setme ) 47 47 { … … 50 50 tr_benc top; 51 51 52 filename = getFilename( handle);52 filename = getFilename( session ); 53 53 loaded = !tr_bencLoadJSONFile( filename, &top ); 54 54 tr_free( filename ); … … 56 56 if( !loaded ) 57 57 { 58 filename = getOldFilename( handle);58 filename = getOldFilename( session ); 59 59 loaded = !tr_bencLoadFile( filename, &top ); 60 60 tr_free( filename ); … … 81 81 82 82 static void 83 saveCumulativeStats( const tr_ handle * handle,83 saveCumulativeStats( const tr_session * session, 84 84 const tr_session_stats * s ) 85 85 { … … 94 94 tr_bencDictAddInt( &top, "uploaded-bytes", s->uploadedBytes ); 95 95 96 filename = getFilename( handle);96 filename = getFilename( session ); 97 97 tr_deepLog( __FILE__, __LINE__, NULL, "Saving stats to \"%s\"", filename ); 98 98 tr_bencSaveJSONFile( filename, &top ); … … 107 107 108 108 void 109 tr_statsInit( tr_ handle * handle)109 tr_statsInit( tr_session * session ) 110 110 { 111 111 struct tr_stats_handle * stats = tr_new0( struct tr_stats_handle, 1 ); 112 112 113 loadCumulativeStats( handle, &stats->old );113 loadCumulativeStats( session, &stats->old ); 114 114 stats->single.sessionCount = 1; 115 115 stats->startTime = time( NULL ); 116 handle->sessionStats = stats;117 } 118 119 void 120 tr_statsClose( tr_ handle * handle)116 session->sessionStats = stats; 117 } 118 119 void 120 tr_statsClose( tr_session * session ) 121 121 { 122 122 tr_session_stats cumulative = STATS_INIT; 123 123 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; 129 129 } 130 130 131 131 static struct tr_stats_handle * 132 getStats( const tr_ handle * handle)133 { 134 return handle ? handle->sessionStats : NULL;132 getStats( const tr_session * session ) 133 { 134 return session ? session->sessionStats : NULL; 135 135 } 136 136 … … 160 160 161 161 void 162 tr_sessionGetStats( const tr_ handle * handle,162 tr_sessionGetStats( const tr_session * session, 163 163 tr_session_stats * setme ) 164 164 { 165 const struct tr_stats_handle * stats = getStats( handle);165 const struct tr_stats_handle * stats = getStats( session ); 166 166 if( stats ) 167 167 { … … 173 173 174 174 void 175 tr_sessionGetCumulativeStats( const tr_ handle * handle,175 tr_sessionGetCumulativeStats( const tr_session * session, 176 176 tr_session_stats * setme ) 177 177 { 178 const struct tr_stats_handle * stats = getStats( handle);178 const struct tr_stats_handle * stats = getStats( session ); 179 179 tr_session_stats current = STATS_INIT; 180 180 181 181 if( stats ) 182 182 { 183 tr_sessionGetStats( handle, ¤t );183 tr_sessionGetStats( session, ¤t ); 184 184 addStats( setme, &stats->old, ¤t ); 185 185 } … … 187 187 188 188 void 189 tr_sessionClearStats( tr_ handle * handle)189 tr_sessionClearStats( tr_session * session ) 190 190 { 191 191 tr_session_stats zero; … … 197 197 zero.sessionCount = 0; 198 198 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 ); 202 202 } 203 203 … … 207 207 208 208 void 209 tr_statsAddUploaded( tr_ handle * handle,209 tr_statsAddUploaded( tr_session * session, 210 210 uint32_t bytes ) 211 211 { 212 212 struct tr_stats_handle * s; 213 213 214 if( ( s = getStats( handle) ) )214 if( ( s = getStats( session ) ) ) 215 215 s->single.uploadedBytes += bytes; 216 216 } 217 217 218 218 void 219 tr_statsAddDownloaded( tr_ handle * handle,220 uint32_t bytes )219 tr_statsAddDownloaded( tr_session * session, 220 uint32_t bytes ) 221 221 { 222 222 struct tr_stats_handle * s; 223 223 224 if( ( s = getStats( handle) ) )224 if( ( s = getStats( session ) ) ) 225 225 s->single.downloadedBytes += bytes; 226 226 } 227 227 228 228 void 229 tr_statsFileCreated( tr_ handle * handle)229 tr_statsFileCreated( tr_session * session ) 230 230 { 231 231 struct tr_stats_handle * s; 232 232 233 if( ( s = getStats( handle) ) )233 if( ( s = getStats( session ) ) ) 234 234 s->single.filesAdded++; 235 235 } -
trunk/libtransmission/torrent.c
r7368 r7385 61 61 62 62 tr_torrent* 63 tr_torrentFindFromId( tr_handle * handle, 64 int id ) 63 tr_torrentFindFromId( tr_session * session, int id ) 65 64 { 66 65 tr_torrent * tor = NULL; 67 66 68 while( ( tor = tr_torrentNext( handle, tor ) ) )67 while( ( tor = tr_torrentNext( session, tor ) ) ) 69 68 if( tor->uniqueId == id ) 70 69 return tor; … … 74 73 75 74 tr_torrent* 76 tr_torrentFindFromHashString( tr_handle * handle, 77 const char * str ) 75 tr_torrentFindFromHashString( tr_session * session, const char * str ) 78 76 { 79 77 tr_torrent * tor = NULL; 80 78 81 while( ( tor = tr_torrentNext( handle, tor ) ) )79 while( ( tor = tr_torrentNext( session, tor ) ) ) 82 80 if( !strcmp( str, tor->info.hashString ) ) 83 81 return tor; … … 87 85 88 86 tr_bool 89 tr_torrentExists( const tr_handle * handle, 90 const uint8_t * torrentHash ) 91 { 92 return tr_torrentFindFromHash( (tr_handle*)handle, 93 torrentHash ) != NULL; 87 tr_torrentExists( const tr_session * session, const uint8_t * torrentHash ) 88 { 89 return tr_torrentFindFromHash( (tr_session*)session, torrentHash ) != NULL; 94 90 } 95 91 96 92 tr_torrent* 97 tr_torrentFindFromHash( tr_handle * handle, 98 const uint8_t * torrentHash ) 93 tr_torrentFindFromHash( tr_session * session, const uint8_t * torrentHash ) 99 94 { 100 95 tr_torrent * tor = NULL; 101 96 102 while( ( tor = tr_torrentNext( handle, tor ) ) )97 while( ( tor = tr_torrentNext( session, tor ) ) ) 103 98 if( *tor->info.hash == *torrentHash ) 104 99 if( !memcmp( tor->info.hash, torrentHash, SHA_DIGEST_LENGTH ) ) … … 109 104 110 105 tr_torrent* 111 tr_torrentFindFromObfuscatedHash( tr_ handle * handle,106 tr_torrentFindFromObfuscatedHash( tr_session * session, 112 107 const uint8_t * obfuscatedTorrentHash ) 113 108 { 114 109 tr_torrent * tor = NULL; 115 110 116 while( ( tor = tr_torrentNext( handle, tor ) ) )111 while( ( tor = tr_torrentNext( session, tor ) ) ) 117 112 if( !memcmp( tor->obfuscatedHash, obfuscatedTorrentHash, 118 113 SHA_DIGEST_LENGTH ) ) … … 467 462 468 463 static void 469 torrentRealInit( tr_ handle * h,470 tr_torrent *tor,471 const tr_ctor * ctor )464 torrentRealInit( tr_session * session, 465 tr_torrent * tor, 466 const tr_ctor * ctor ) 472 467 { 473 468 int doStart; … … 477 472 static int nextUniqueId = 1; 478 473 479 tr_globalLock( h);480 481 tor->session = h;474 tr_globalLock( session ); 475 476 tor->session = session; 482 477 tor->uniqueId = nextUniqueId++; 483 478 484 479 randomizeTiers( info ); 485 480 486 tor->bandwidth = tr_bandwidthNew( h, h->bandwidth );481 tor->bandwidth = tr_bandwidthNew( session, session->bandwidth ); 487 482 488 483 tor->blockSize = getBlockSize( info->pieceSize ); … … 532 527 NULL ); 533 528 534 tr_peerMgrAddTorrent( h->peerMgr, tor ); 535 536 assert( h->isPortSet ); 537 529 tr_peerMgrAddTorrent( session->peerMgr, tor ); 530 531 assert( session->isPortSet ); 538 532 assert( !tor->downloadedCur ); 539 533 assert( !tor->uploadedCur ); … … 570 564 tr_torrent * it = NULL; 571 565 tr_torrent * last = NULL; 572 while( ( it = tr_torrentNext( h, it ) ) )566 while( ( it = tr_torrentNext( session, it ) ) ) 573 567 last = it; 574 568 575 569 if( !last ) 576 h->torrentList = tor;570 session->torrentList = tor; 577 571 else 578 572 last->next = tor; 579 ++ h->torrentCount;580 } 581 582 tr_globalUnlock( h);573 ++session->torrentCount; 574 } 575 576 tr_globalUnlock( session ); 583 577 584 578 /* maybe save our own copy of the metainfo */ … … 595 589 } 596 590 597 tr_metainfoMigrate( h, &tor->info );591 tr_metainfoMigrate( session, &tor->info ); 598 592 599 593 if( doStart ) … … 602 596 603 597 int 604 tr_torrentParse( const tr_ handle * handle,605 const tr_ctor *ctor,606 tr_info *setmeInfo )598 tr_torrentParse( const tr_session * session, 599 const tr_ctor * ctor, 600 tr_info * setmeInfo ) 607 601 { 608 602 int err = 0; … … 618 612 return TR_EINVALID; 619 613 620 err = tr_metainfoParse( handle, setmeInfo, metainfo );614 err = tr_metainfoParse( session, setmeInfo, metainfo ); 621 615 doFree = !err && ( setmeInfo == &tmp ); 622 616 … … 624 618 err = TR_EINVALID; 625 619 626 if( !err && tr_torrentExists( handle, setmeInfo->hash ) )620 if( !err && tr_torrentExists( session, setmeInfo->hash ) ) 627 621 err = TR_EDUPLICATE; 628 622 … … 634 628 635 629 tr_torrent * 636 tr_torrentNew( tr_ handle * handle,637 const tr_ctor * ctor,638 int *setmeError )630 tr_torrentNew( tr_session * session, 631 const tr_ctor * ctor, 632 int * setmeError ) 639 633 { 640 634 int err; … … 642 636 tr_torrent * tor = NULL; 643 637 644 err = tr_torrentParse( handle, ctor, &tmpInfo );638 err = tr_torrentParse( session, ctor, &tmpInfo ); 645 639 if( !err ) 646 640 { 647 641 tor = tr_new0( tr_torrent, 1 ); 648 642 tor->info = tmpInfo; 649 torrentRealInit( handle, tor, ctor );643 torrentRealInit( session, tor, ctor ); 650 644 } 651 645 else if( setmeError ) … … 1049 1043 { 1050 1044 tr_torrent * t; 1051 tr_ handle * h= tor->session;1045 tr_session * session = tor->session; 1052 1046 tr_info * inf = &tor->info; 1053 1047 … … 1055 1049 assert( !tor->isRunning ); 1056 1050 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 ); 1060 1054 1061 1055 tr_cpClose( tor->completion ); … … 1072 1066 tr_free( tor->peer_id ); 1073 1067 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; 1083 1074 } 1084 1085 assert( h->torrentCount >= 1 ); 1086 h->torrentCount--; 1075 } 1076 1077 assert( session->torrentCount >= 1 ); 1078 session->torrentCount--; 1087 1079 1088 1080 tr_bandwidthFree( tor->bandwidth ); … … 1091 1083 tr_free( tor ); 1092 1084 1093 tr_globalUnlock( h);1085 tr_globalUnlock( session ); 1094 1086 } 1095 1087 … … 1249 1241 if( tor ) 1250 1242 { 1251 tr_ handle * handle= tor->session;1252 tr_globalLock( handle);1243 tr_session * session = tor->session; 1244 tr_globalLock( session ); 1253 1245 1254 1246 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 ); 1258 1250 } 1259 1251 } -
trunk/libtransmission/tracker.h
r7238 r7385 32 32 void tr_trackerFree( tr_tracker * ); 33 33 34 void tr_trackerSessionClose( tr_ handle* );34 void tr_trackerSessionClose( tr_session * ); 35 35 36 36 /** -
trunk/libtransmission/trevent.c
r7173 r7385 122 122 int fds[2]; 123 123 tr_lock * lock; 124 tr_ handle * h;124 tr_session * session; 125 125 tr_thread * thread; 126 126 struct event_base * base; … … 218 218 219 219 static void 220 logFunc( int severity, 221 const char * message ) 220 logFunc( int severity, const char * message ) 222 221 { 223 222 if( severity >= _EVENT_LOG_ERR ) … … 239 238 #endif 240 239 241 eh-> h->events = eh;240 eh->session->events = eh; 242 241 243 242 /* listen to the pipe's read fd */ … … 251 250 tr_lockFree( eh->lock ); 252 251 event_base_free( eh->base ); 253 eh-> h->events = NULL;252 eh->session->events = NULL; 254 253 tr_free( eh ); 255 254 tr_dbg( "Closing libevent thread" ); … … 257 256 258 257 void 259 tr_eventInit( tr_ handle * handle)258 tr_eventInit( tr_session * session ) 260 259 { 261 260 tr_event_handle * eh; … … 264 263 eh->lock = tr_lockNew( ); 265 264 pipe( eh->fds ); 266 eh-> h = handle;265 eh->session = session; 267 266 eh->base = event_init( ); 268 267 eh->thread = tr_threadNew( libeventThreadFunc, eh ); … … 270 269 271 270 void 272 tr_eventClose( tr_ handle * handle)273 { 274 handle->events->die = TRUE;271 tr_eventClose( tr_session * session ) 272 { 273 session->events->die = TRUE; 275 274 tr_deepLog( __FILE__, __LINE__, NULL, "closing trevent pipe" ); 276 EVUTIL_CLOSESOCKET( handle->events->fds[1] );275 EVUTIL_CLOSESOCKET( session->events->fds[1] ); 277 276 } 278 277 … … 282 281 283 282 int 284 tr_amInEventThread( struct tr_handle * handle)285 { 286 assert( handle);287 assert( handle->events );288 289 return tr_amInThread( handle->events->thread );283 tr_amInEventThread( tr_session * session ) 284 { 285 assert( session ); 286 assert( session->events ); 287 288 return tr_amInThread( session->events->thread ); 290 289 } 291 290 … … 295 294 296 295 static void 297 timerCallback( int fdUNUSED,298 short event UNUSED,299 void * 296 timerCallback( int fd UNUSED, 297 short event UNUSED, 298 void * vtimer ) 300 299 { 301 300 int more; … … 325 324 if( timer && !timer->inCallback ) 326 325 { 327 assert( tr_amInEventThread( timer->eh-> h) );326 assert( tr_amInEventThread( timer->eh->session ) ); 328 327 event_del( &timer->event ); 329 328 tr_free( timer ); … … 332 331 333 332 tr_timer* 334 tr_timerNew( struct tr_handle * handle,335 timer_func 336 void *user_data,337 uint64_t 333 tr_timerNew( tr_session * session, 334 timer_func func, 335 void * user_data, 336 uint64_t interval_milliseconds ) 338 337 { 339 338 tr_timer * timer; 340 339 341 assert( handle);342 assert( handle->events );340 assert( session ); 341 assert( session->events ); 343 342 344 343 timer = tr_new0( tr_timer, 1 ); … … 346 345 timer->func = func; 347 346 timer->user_data = user_data; 348 timer->eh = handle->events;347 timer->eh = session->events; 349 348 evtimer_set( &timer->event, timerCallback, timer ); 350 349 351 if( tr_amInThread( handle->events->thread ) )350 if( tr_amInThread( session->events->thread ) ) 352 351 { 353 352 evtimer_add( &timer->event, &timer->tv ); … … 356 355 { 357 356 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; 360 359 361 360 tr_lockLock( lock ); … … 369 368 370 369 void 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 ) ) 370 tr_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 ) ) 379 377 { 380 378 (func)( user_data ); … … 383 381 { 384 382 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; 387 385 struct tr_run_data data; 388 386 -
trunk/libtransmission/trevent.h
r7151 r7385 24 24 **/ 25 25 26 void tr_eventInit( struct tr_handle * tr_handle);26 void tr_eventInit( tr_session * ); 27 27 28 void tr_eventClose( struct tr_handle * tr_handle);28 void tr_eventClose( tr_session * ); 29 29 30 struct event_base * tr_eventGetBase( struct tr_handle * tr_handle);30 struct event_base * tr_eventGetBase( tr_session * ); 31 31 32 32 … … 38 38 * Otherwise, it's called again after the same interval. 39 39 */ 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 ); 40 tr_timer* tr_timerNew( tr_session * handle, 41 int func( void * user_data ), 42 void * user_data, 43 uint64_t timeout_milliseconds ); 46 44 47 45 /** … … 51 49 52 50 53 int tr_amInEventThread( struct tr_handle * handle);51 int tr_amInEventThread( tr_session * ); 54 52 55 void tr_runInEventThread( struct tr_handle * handle,56 void 57 void *user_data );53 void tr_runInEventThread( tr_session * session, 54 void func( void* ), 55 void * user_data ); 58 56 59 57 #endif -
trunk/libtransmission/web.c
r7245 r7385 95 95 { 96 96 struct tr_web_task * task = vtask; 97 const tr_ handle* session = task->session;97 const tr_session * session = task->session; 98 98 99 99 if( session && session->web ) -
trunk/libtransmission/web.h
r6795 r7385 14 14 #define TR_HTTP_H 15 15 16 struct tr_handle;17 16 typedef struct tr_web tr_web; 18 17 19 tr_web* tr_webInit( struct tr_handle* session );18 tr_web* tr_webInit( tr_session * session ); 20 19 21 20 void tr_webClose( tr_web ** ); 22 21 23 typedef void ( tr_web_done_func )( struct tr_handle* session,22 typedef void ( tr_web_done_func )( tr_session * session, 24 23 long response_code, 25 const void *response,24 const void * response, 26 25 size_t response_byte_count, 27 void *user_data );26 void * user_data ); 28 27 29 28 const char * tr_webGetResponseStr( long response_code ); 30 29 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 );30 void 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 ); 36 35 37 36 -
trunk/libtransmission/webseed.c
r7289 r7385 148 148 149 149 static void 150 webResponseFunc( tr_ handle* session,150 webResponseFunc( tr_session * session, 151 151 long response_code, 152 152 const void * response,
Note: See TracChangeset
for help on using the changeset viewer.