mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

clean up

This commit is contained in:
Eric Petit 2007-01-19 11:19:20 +00:00
parent a083936c72
commit 4a567871bb
7 changed files with 76 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libtransmission/fastresume.h
View File

@ -376,7 +376,7 @@ static int fastResumeLoad( tr_io_t * io )
fclose( file );
return 1;
}
tr_peerAddCompactMany( tor, buf, len );
tr_peerAddCompact( tor, buf, len / 6 );
free( buf );
continue;
}

2
libtransmission/fdlimit.c
View File

@ -370,6 +370,7 @@ static int OpenFile( tr_fd_t * f, int i, char * folder, char * name,
{
if( mkdir( path, 0777 ) )
{
tr_err( "Could not create folder '%s'", path );
free( path );
return ErrorFromErrno();
}
@ -378,6 +379,7 @@ static int OpenFile( tr_fd_t * f, int i, char * folder, char * name,
{
if( !S_ISDIR( sb.st_mode ) )
{
tr_err( "Is not a folder: '%s'", path );
free( path );
return TR_ERROR_IO_OTHER;
}

36
libtransmission/peer.c
View File

@ -124,52 +124,22 @@ static void __peer_dbg( tr_peer_t * peer, char * msg, ... )
#include "peerutils.h"
#include "peerparse.h"
/***********************************************************************
* tr_peerAddOld
***********************************************************************
* Tries to add a peer given its IP and port (received from a tracker
* which doesn't support the "compact" extension).
**********************************************************************/
void tr_peerAddOld( tr_torrent_t * tor, char * ip, int port )
{
struct in_addr addr;
if( tr_netResolve( ip, &addr ) )
{
return;
}
addWithAddr( tor, addr, htons( port ) );
}
/***********************************************************************
* tr_peerAddCompact
***********************************************************************
* Tries to add a peer, using 'addr' and 'port' to connect to the peer.
**********************************************************************/
void tr_peerAddCompact( tr_torrent_t * tor, struct in_addr addr,
in_port_t port )
{
addWithAddr( tor, addr, port );
}
/***********************************************************************
* tr_peerAddCompactMany
***********************************************************************
* Adds several peers in compact form
**********************************************************************/
void tr_peerAddCompactMany( tr_torrent_t * tor, uint8_t * buf, int len )
void tr_peerAddCompact( tr_torrent_t * tor, uint8_t * buf, int count )
{
struct in_addr addr;
in_port_t port;
int i;
len /= 6;
for( i = 0; i < len; i++ )
for( i = 0; i < count; i++ )
{
memcpy( &addr, buf, 4 ); buf += 4;
memcpy( &port, buf, 2 ); buf += 2;
tr_peerAddCompact( tor, addr, port );
addWithAddr( tor, addr, port );
}
}

3
libtransmission/peer.h
View File

@ -30,8 +30,7 @@
typedef struct tr_peer_s tr_peer_t;
void tr_peerAddOld ( tr_torrent_t *, char *, int );
void tr_peerAddCompact ( tr_torrent_t *, struct in_addr, in_port_t );
void tr_peerAddCompactMany( tr_torrent_t *, uint8_t *, int );
void tr_peerAddCompact ( tr_torrent_t *, uint8_t *, int );
tr_peer_t * tr_peerInit ( struct in_addr, in_port_t, int );
void tr_peerAttach ( tr_torrent_t *, tr_peer_t * );
void tr_peerDestroy ( tr_fd_t *, tr_peer_t * );

19
libtransmission/torrent.c
View File

@ -255,11 +255,19 @@ int tr_getFinished( tr_torrent_t * tor )
void tr_manualUpdate( tr_torrent_t * tor )
{
int peerCount;
uint8_t * peerCompact;
if( !( tor->status & TR_STATUS_ACTIVE ) )
return;
tr_lockLock( &tor->lock );
tr_trackerAnnouncePulse( tor->tracker, 1 );
tr_trackerAnnouncePulse( tor->tracker, &peerCount, &peerCompact, 1 );
if( peerCount > 0 )
{
tr_peerAddCompact( tor, peerCompact, peerCount );
free( peerCompact );
}
tr_lockUnlock( &tor->lock );
}
@ -545,6 +553,8 @@ static void downloadLoop( void * _tor )
tr_torrent_t * tor = _tor;
uint64_t date1, date2;
int ret;
int peerCount;
uint8_t * peerCompact;
tr_lockLock( &tor->lock );
@ -579,7 +589,12 @@ static void downloadLoop( void * _tor )
}
/* Try to get new peers or to send a message to the tracker */
tr_trackerPulse( tor->tracker );
tr_trackerPulse( tor->tracker, &peerCount, &peerCompact );
if( peerCount > 0 )
{
tr_peerAddCompact( tor, peerCompact, peerCount );
free( peerCompact );
}
if( tor->status & TR_STATUS_STOPPED )
{

106
libtransmission/tracker.c
View File

@ -94,7 +94,8 @@ static void setAnnounce ( tr_tracker_t * tc, tr_announce_list_ptr_t
static void failureAnnouncing( tr_tracker_t * tc );
static tr_http_t * getQuery ( tr_tracker_t * tc );
static tr_http_t * getScrapeQuery ( tr_tracker_t * tc );
static void readAnswer ( tr_tracker_t * tc, const char *, int );
static void readAnswer ( tr_tracker_t * tc, const char *, int,
int * peerCount, uint8_t ** peerCompact );
static void readScrapeAnswer ( tr_tracker_t * tc, const char *, int );
static void killHttp ( tr_http_t ** http, tr_fd_t * fdlimit );
@ -321,7 +322,8 @@ void tr_trackerChangePort( tr_tracker_t * tc, int port )
tc->newPort = port;
}
void tr_trackerAnnouncePulse( tr_tracker_t * tc, int manual )
void tr_trackerAnnouncePulse( tr_tracker_t * tc, int * peerCount,
uint8_t ** peerCompact, int manual )
{
tr_torrent_t * tor = tc->tor;
tr_info_t * inf = &tor->info;
@ -329,6 +331,9 @@ void tr_trackerAnnouncePulse( tr_tracker_t * tc, int manual )
char * address, * announce;
int len, i, port;
tr_announce_list_ptr_t * announcePtr, * prevAnnouncePtr;
*peerCount = 0;
*peerCompact = NULL;
if( ( NULL == tc->http ) && ( manual || shouldConnect( tc ) ) )
{
@ -443,27 +448,11 @@ void tr_trackerAnnouncePulse( tr_tracker_t * tc, int manual )
failureAnnouncing( tc );
tc->lastError = 1;
if ( tc->shouldChangeAnnounce == TC_CHANGE_NEXT )
{
tr_trackerPulse( tc );
return;
}
break;
case TR_NET_OK:
readAnswer( tc, data, len );
readAnswer( tc, data, len, peerCount, peerCompact );
killHttp( &tc->http, tor->fdlimit );
/* Something happened to need to try next address */
if ( tc->shouldChangeAnnounce == TC_CHANGE_NEXT
|| tc->shouldChangeAnnounce == TC_CHANGE_REDIRECT )
{
tr_trackerPulse( tc );
return;
}
break;
}
}
@ -638,7 +627,8 @@ static tr_http_t * getScrapeQuery( tr_tracker_t * tc )
tc->trackerScrape, start, tor->escapedHashString );
}
static void readAnswer( tr_tracker_t * tc, const char * data, int len )
static void readAnswer( tr_tracker_t * tc, const char * data, int len,
int * _peerCount, uint8_t ** _peerCompact )
{
tr_torrent_t * tor = tc->tor;
int i;
@ -648,6 +638,11 @@ static void readAnswer( tr_tracker_t * tc, const char * data, int len )
const uint8_t * body;
int bodylen, shouldfree, scrapeNeeded;
char * address;
int peerCount;
uint8_t * peerCompact;
*_peerCount = peerCount = 0;
*_peerCompact = peerCompact = NULL;
tc->dateTry = tr_date();
code = tr_httpResponseCode( data, len );
@ -841,58 +836,55 @@ static void readAnswer( tr_tracker_t * tc, const char * data, int len )
if( bePeers->type & TYPE_LIST )
{
char * ip;
int port;
/* Original protocol */
tr_inf( "Tracker: got %d peers", bePeers->val.l.count );
for( i = 0; i < bePeers->val.l.count; i++ )
if( bePeers->val.l.count > 0 )
{
beFoo = tr_bencDictFind( &bePeers->val.l.vals[i], "ip" );
if( !beFoo )
continue;
ip = beFoo->val.s.s;
beFoo = tr_bencDictFind( &bePeers->val.l.vals[i], "port" );
if( !beFoo )
continue;
port = beFoo->val.i;
struct in_addr addr;
in_port_t port;
tr_peerAddOld( tor, ip, port );
}
peerCount = 0;
peerCompact = malloc( 6 * bePeers->val.l.count );
if( bePeers->val.l.count >= 50 )
{
tc->hasManyPeers = 1;
/* Convert to compact form */
for( i = 0; i < bePeers->val.l.count; i++ )
{
if( !( beFoo = tr_bencDictFind(
&bePeers->val.l.vals[i], "ip" ) ) )
continue;
if( tr_netResolve( beFoo->val.s.s, &addr ) )
continue;
memcpy( &peerCompact[6 * peerCount], &addr, 4 );
if( !( beFoo = tr_bencDictFind(
&bePeers->val.l.vals[i], "port" ) ) )
continue;
port = htons( beFoo->val.i );
memcpy( &peerCompact[6 * peerCount + 4], &port, 2 );
peerCount++;
}
}
}
else if( bePeers->type & TYPE_STR )
{
struct in_addr addr;
in_port_t port;
/* "Compact" extension */
if( bePeers->val.s.i % 6 )
if( bePeers->val.s.i >= 6 )
{
tr_err( "Tracker: \"peers\" of size %d",
bePeers->val.s.i );
tr_lockUnlock( &tor->lock );
goto cleanup;
peerCount = bePeers->val.s.i / 6;
peerCompact = malloc( bePeers->val.s.i );
memcpy( peerCompact, bePeers->val.s.s, bePeers->val.s.i );
}
}
tr_inf( "Tracker: got %d peers", bePeers->val.s.i / 6 );
for( i = 0; i < bePeers->val.s.i / 6; i++ )
{
memcpy( &addr, &bePeers->val.s.s[6*i], 4 );
memcpy( &port, &bePeers->val.s.s[6*i+4], 2 );
tr_peerAddCompact( tor, addr, port );
}
if( bePeers->val.s.i / 6 >= 50 )
if( peerCount > 0 )
{
tr_inf( "Tracker: got %d peers", peerCount );
if( peerCount >= 50 )
{
tc->hasManyPeers = 1;
}
*_peerCount = peerCount;
*_peerCompact = peerCompact;
}
nodict:

5
libtransmission/tracker.h
View File

@ -30,8 +30,9 @@ typedef struct tr_tracker_s tr_tracker_t;
tr_tracker_t * tr_trackerInit ( tr_torrent_t * );
void tr_trackerChangePort( tr_tracker_t *, int );
#define tr_trackerPulse( tc ) tr_trackerAnnouncePulse( (tc), 0 )
void tr_trackerAnnouncePulse( tr_tracker_t *, int );
#define tr_trackerPulse(tc,a,b) tr_trackerAnnouncePulse((tc),(a),(b),0)
void tr_trackerAnnouncePulse( tr_tracker_t *, int * peerCount,
uint8_t ** peerCompact, int );
void tr_trackerCompleted( tr_tracker_t * );
void tr_trackerStopped ( tr_tracker_t * );