void *
tr_cpCreatePieceBitfield (const tr_completion * cp, size_t * byte_count)
{
void * ret;
tr_piece_index_t n;
tr_bitfield pieces;
assert (tr_torrentHasMetadata (cp->tor));
n = cp->tor->info.pieceCount;
tr_bitfieldConstruct (&pieces, n);
if (tr_cpHasAll (cp))
{
tr_bitfieldSetHasAll (&pieces);
}
else if (!tr_cpHasNone (cp))
{
tr_piece_index_t i;
bool * flags = tr_new (bool, n);
for (i=0; i<n; ++i)
flags[i] = tr_cpPieceIsComplete (cp, i);
tr_bitfieldSetFromFlags (&pieces, flags, n);
tr_free (flags);
}
void
tr_torrentSetMetadataSizeHint( tr_torrent * tor, int size )
{
if( !tr_torrentHasMetadata( tor ) )
{
if( tor->incompleteMetadata == NULL )
{
int i;
struct tr_incomplete_metadata * m;
const int n = ( size + ( METADATA_PIECE_SIZE - 1 ) ) / METADATA_PIECE_SIZE;
dbgmsg( tor, "metadata is %d bytes in %d pieces", size, n );
m = tr_new( struct tr_incomplete_metadata, 1 );
m->pieceCount = n;
m->metadata = tr_new( uint8_t, size );
m->metadata_size = size;
m->piecesNeededCount = n;
m->piecesNeeded = tr_new( struct metadata_node, n );
for( i=0; i<n; ++i ) {
m->piecesNeeded[i].piece = i;
m->piecesNeeded[i].requestedAt = 0;
}
tor->incompleteMetadata = m;
}
}
tr_completeness
tr_cpGetStatus( const tr_completion * cp )
{
if( tr_cpHasAll( cp ) ) return TR_SEED;
if( !tr_torrentHasMetadata( cp->tor ) ) return TR_LEECH;
if( cp->sizeNow == tr_cpSizeWhenDone( cp ) ) return TR_PARTIAL_SEED;
return TR_LEECH;
}
void tr_torrentSaveResume(tr_torrent* tor)
{
int err;
tr_variant top;
char* filename;
if (!tr_isTorrent(tor))
{
return;
}
tr_variantInitDict(&top, 50); /* arbitrary "big enough" number */
tr_variantDictAddInt(&top, TR_KEY_seeding_time_seconds, tor->secondsSeeding);
tr_variantDictAddInt(&top, TR_KEY_downloading_time_seconds, tor->secondsDownloading);
tr_variantDictAddInt(&top, TR_KEY_activity_date, tor->activityDate);
tr_variantDictAddInt(&top, TR_KEY_added_date, tor->addedDate);
tr_variantDictAddInt(&top, TR_KEY_corrupt, tor->corruptPrev + tor->corruptCur);
tr_variantDictAddInt(&top, TR_KEY_done_date, tor->doneDate);
tr_variantDictAddStr(&top, TR_KEY_destination, tor->downloadDir);
if (tor->incompleteDir != NULL)
{
tr_variantDictAddStr(&top, TR_KEY_incomplete_dir, tor->incompleteDir);
}
tr_variantDictAddInt(&top, TR_KEY_downloaded, tor->downloadedPrev + tor->downloadedCur);
tr_variantDictAddInt(&top, TR_KEY_uploaded, tor->uploadedPrev + tor->uploadedCur);
tr_variantDictAddInt(&top, TR_KEY_max_peers, tor->maxConnectedPeers);
tr_variantDictAddInt(&top, TR_KEY_bandwidth_priority, tr_torrentGetPriority(tor));
tr_variantDictAddBool(&top, TR_KEY_paused, !tor->isRunning && !tor->isQueued);
savePeers(&top, tor);
if (tr_torrentHasMetadata(tor))
{
saveFilePriorities(&top, tor);
saveDND(&top, tor);
saveProgress(&top, tor);
}
saveSpeedLimits(&top, tor);
saveRatioLimits(&top, tor);
saveIdleLimits(&top, tor);
saveFilenames(&top, tor);
saveName(&top, tor);
filename = getResumeFilename(tor);
if ((err = tr_variantToFile(&top, TR_VARIANT_FMT_BENC, filename)) != 0)
{
tr_torrentSetLocalError(tor, "Unable to save resume file: %s", tr_strerror(err));
}
tr_free(filename);
tr_variantFree(&top);
}
static char*
getShortTransferString( const tr_torrent * tor,
const tr_stat * torStat,
double uploadSpeed,
double downloadSpeed,
char * buf,
size_t buflen )
{
char downStr[32], upStr[32];
const int haveMeta = tr_torrentHasMetadata( tor );
const int haveDown = haveMeta && torStat->peersSendingToUs > 0;
const int haveUp = haveMeta && torStat->peersGettingFromUs > 0;
if( haveDown )
tr_strlspeed( downStr, downloadSpeed, sizeof( downStr ) );
if( haveUp )
tr_strlspeed( upStr, uploadSpeed, sizeof( upStr ) );
if( haveDown && haveUp )
/* 1==down speed, 2==down arrow, 3==up speed, 4==down arrow */
g_snprintf( buf, buflen, _( "%1$s %2$s, %3$s %4$s" ),
gtr_get_unicode_string( GTR_UNICODE_DOWN ), downStr,
gtr_get_unicode_string( GTR_UNICODE_UP ), upStr );
else if( haveDown )
/* bandwidth speed + unicode arrow */
g_snprintf( buf, buflen, _( "%1$s %2$s" ),
gtr_get_unicode_string( GTR_UNICODE_DOWN ), downStr );
else if( haveUp )
/* bandwidth speed + unicode arrow */
g_snprintf( buf, buflen, _( "%1$s %2$s" ),
gtr_get_unicode_string( GTR_UNICODE_UP ), upStr );
else if( tr_torrentHasMetadata( tor ) )
/* the torrent isn't uploading or downloading */
g_strlcpy( buf, _( "Idle" ), buflen );
else
*buf = '\0';
return buf;
}
static char*
getShortTransferString (const tr_torrent * tor,
const tr_stat * st,
double uploadSpeed_KBps,
double downloadSpeed_KBps,
char * buf,
size_t buflen)
{
const int haveMeta = tr_torrentHasMetadata (tor);
const int haveUp = haveMeta && st->peersGettingFromUs > 0;
const int haveDown = haveMeta && ((st->peersSendingToUs > 0) || (st->webseedsSendingToUs > 0));
if (haveDown)
{
char dnStr[32], upStr[32];
tr_formatter_speed_KBps (dnStr, downloadSpeed_KBps, sizeof (dnStr));
tr_formatter_speed_KBps (upStr, uploadSpeed_KBps, sizeof (upStr));
/* down speed, down symbol, up speed, up symbol */
g_snprintf (buf, buflen, _("%1$s %2$s %3$s %4$s"),
dnStr,
gtr_get_unicode_string (GTR_UNICODE_DOWN),
upStr,
gtr_get_unicode_string (GTR_UNICODE_UP));
}
else if (haveUp)
{
char upStr[32];
tr_formatter_speed_KBps (upStr, uploadSpeed_KBps, sizeof (upStr));
/* up speed, up symbol */
g_snprintf (buf, buflen, _("%1$s %2$s"),
upStr,
gtr_get_unicode_string (GTR_UNICODE_UP));
}
else if (st->isStalled)
{
g_strlcpy (buf, _("Stalled"), buflen);
}
else
{
*buf = '\0';
}
return buf;
}
void
tr_torrentSaveResume( tr_torrent * tor )
{
int err;
tr_benc top;
char * filename;
if( !tr_isTorrent( tor ) )
return;
tr_bencInitDict( &top, 50 ); /* arbitrary "big enough" number */
tr_bencDictAddInt( &top, KEY_TIME_SEEDING, tor->secondsSeeding );
tr_bencDictAddInt( &top, KEY_TIME_DOWNLOADING, tor->secondsDownloading );
tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE, tor->activityDate );
tr_bencDictAddInt( &top, KEY_ADDED_DATE, tor->addedDate );
tr_bencDictAddInt( &top, KEY_CORRUPT, tor->corruptPrev + tor->corruptCur );
tr_bencDictAddInt( &top, KEY_DONE_DATE, tor->doneDate );
tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR, tor->downloadDir );
if( tor->incompleteDir != NULL )
tr_bencDictAddStr( &top, KEY_INCOMPLETE_DIR, tor->incompleteDir );
tr_bencDictAddInt( &top, KEY_DOWNLOADED, tor->downloadedPrev + tor->downloadedCur );
tr_bencDictAddInt( &top, KEY_UPLOADED, tor->uploadedPrev + tor->uploadedCur );
tr_bencDictAddInt( &top, KEY_MAX_PEERS, tor->maxConnectedPeers );
tr_bencDictAddInt( &top, KEY_BANDWIDTH_PRIORITY, tr_torrentGetPriority( tor ) );
tr_bencDictAddBool( &top, KEY_PAUSED, !tor->isRunning );
savePeers( &top, tor );
if( tr_torrentHasMetadata( tor ) )
{
saveFilePriorities( &top, tor );
saveDND( &top, tor );
saveProgress( &top, tor );
}
saveSpeedLimits( &top, tor );
saveRatioLimits( &top, tor );
saveIdleLimits( &top, tor );
filename = getResumeFilename( tor );
if(( err = tr_bencToFile( &top, TR_FMT_BENC, filename )))
tr_torrentSetLocalError( tor, "Unable to save resume file: %s", tr_strerror( err ) );
tr_free( filename );
tr_bencFree( &top );
}
static void
updateTorrent( struct OpenData * o )
{
const gboolean isLocalFile = tr_ctorGetSourceFile( o->ctor ) != NULL;
gtk_widget_set_sensitive( o->trash_check, isLocalFile );
if( !o->tor )
{
gtr_file_list_clear( o->file_list );
gtk_widget_set_sensitive( o->file_list, FALSE );
}
else
{
tr_torrentSetDownloadDir( o->tor, o->downloadDir );
gtk_widget_set_sensitive( o->file_list, tr_torrentHasMetadata( o->tor ) );
gtr_file_list_set_torrent( o->file_list, tr_torrentId( o->tor ) );
tr_torrentVerify( o->tor );
}
}
static char*
getShortTransferString( const tr_torrent * tor,
const tr_stat * st,
double uploadSpeed_KBps,
double downloadSpeed_KBps,
char * buf,
size_t buflen )
{
char downStr[32], upStr[32];
const int haveMeta = tr_torrentHasMetadata( tor );
const int haveUp = haveMeta && st->peersGettingFromUs > 0;
const int haveDown = haveMeta && ( ( st->peersSendingToUs > 0 ) || ( st->webseedsSendingToUs > 0 ) );
if( haveDown )
tr_formatter_speed_KBps( downStr, downloadSpeed_KBps, sizeof( downStr ) );
if( haveUp )
tr_formatter_speed_KBps( upStr, uploadSpeed_KBps, sizeof( upStr ) );
if( haveDown && haveUp )
/* 1==down arrow, 2==down speed, 3==up arrow, 4==down speed */
g_snprintf( buf, buflen, _( "%1$s %2$s, %3$s %4$s" ),
gtr_get_unicode_string( GTR_UNICODE_DOWN ), downStr,
gtr_get_unicode_string( GTR_UNICODE_UP ), upStr );
else if( haveDown )
/* bandwidth speed + unicode arrow */
g_snprintf( buf, buflen, _( "%1$s %2$s" ),
gtr_get_unicode_string( GTR_UNICODE_DOWN ), downStr );
else if( haveUp )
/* bandwidth speed + unicode arrow */
g_snprintf( buf, buflen, _( "%1$s %2$s" ),
gtr_get_unicode_string( GTR_UNICODE_UP ), upStr );
else if( st->isStalled )
g_strlcpy( buf, _( "Stalled" ), buflen );
else if( haveMeta )
g_strlcpy( buf, _( "Idle" ), buflen );
else
*buf = '\0';
return buf;
}
static uint64_t
calculateHaveValid( const tr_completion * ccp )
{
uint64_t b = 0;
tr_piece_index_t i;
const tr_torrent * tor = ccp->tor;
const uint64_t pieceSize = tor->info.pieceSize;
const uint64_t lastPieceSize = tor->lastPieceSize;
const tr_piece_index_t lastPiece = tor->info.pieceCount - 1;
if( !tr_torrentHasMetadata( tor ) )
return 0;
for( i=0; i!=lastPiece; ++i )
if( tr_cpPieceIsComplete( ccp, i ) )
b += pieceSize;
if( tr_cpPieceIsComplete( ccp, lastPiece ) )
b += lastPieceSize;
return b;
}
static void
getStatusString( GString * gstr,
const tr_torrent * tor,
const tr_stat * st,
const double uploadSpeed_KBps,
const double downloadSpeed_KBps )
{
if( st->error )
{
const char * fmt[] = { NULL, N_( "Tracker gave a warning: \"%s\"" ),
N_( "Tracker gave an error: \"%s\"" ),
N_( "Error: %s" ) };
g_string_append_printf( gstr, _( fmt[st->error] ), st->errorString );
}
else switch( st->activity )
{
case TR_STATUS_STOPPED:
case TR_STATUS_CHECK_WAIT:
case TR_STATUS_CHECK:
case TR_STATUS_DOWNLOAD_WAIT:
case TR_STATUS_SEED_WAIT:
{
getShortStatusString( gstr, tor, st, uploadSpeed_KBps, downloadSpeed_KBps );
break;
}
case TR_STATUS_DOWNLOAD:
{
if( tr_torrentHasMetadata( tor ) )
{
g_string_append_printf( gstr,
ngettext( "Downloading from %1$'d of %2$'d connected peer",
"Downloading from %1$'d of %2$'d connected peers",
st->webseedsSendingToUs + st->peersSendingToUs ),
st->webseedsSendingToUs + st->peersSendingToUs,
st->webseedsSendingToUs + st->peersConnected );
}
else
{
g_string_append_printf( gstr,
ngettext( "Downloading metadata from %1$'d peer (%2$d%% done)",
"Downloading metadata from %1$'d peers (%2$d%% done)",
st->peersConnected + st->peersConnected ),
st->peersConnected + st->webseedsSendingToUs,
(int)(100.0*st->metadataPercentComplete) );
}
break;
}
case TR_STATUS_SEED:
g_string_append_printf( gstr,
ngettext( "Seeding to %1$'d of %2$'d connected peer",
"Seeding to %1$'d of %2$'d connected peers",
st->peersConnected ),
st->peersGettingFromUs,
st->peersConnected );
break;
}
if( ( st->activity != TR_STATUS_CHECK_WAIT ) &&
( st->activity != TR_STATUS_CHECK ) &&
( st->activity != TR_STATUS_DOWNLOAD_WAIT ) &&
( st->activity != TR_STATUS_SEED_WAIT ) &&
( st->activity != TR_STATUS_STOPPED ) )
{
char buf[256];
getShortTransferString( tor, st, uploadSpeed_KBps, downloadSpeed_KBps, buf, sizeof( buf ) );
if( *buf )
g_string_append_printf( gstr, " - %s", buf );
}
}
static void getStatusString(GString* gstr, tr_torrent const* tor, tr_stat const* st, double const uploadSpeed_KBps,
double const downloadSpeed_KBps)
{
if (st->error != 0)
{
char const* fmt[] =
{
NULL,
N_("Tracker gave a warning: \"%s\""),
N_("Tracker gave an error: \"%s\""),
N_("Error: %s")
};
g_string_append_printf(gstr, _(fmt[st->error]), st->errorString);
}
else
{
switch (st->activity)
{
case TR_STATUS_STOPPED:
case TR_STATUS_CHECK_WAIT:
case TR_STATUS_CHECK:
case TR_STATUS_DOWNLOAD_WAIT:
case TR_STATUS_SEED_WAIT:
{
getShortStatusString(gstr, tor, st, uploadSpeed_KBps, downloadSpeed_KBps);
break;
}
case TR_STATUS_DOWNLOAD:
{
if (!tr_torrentHasMetadata(tor))
{
/* Downloading metadata from 2 peer (s)(50% done) */
g_string_append_printf(gstr, _("Downloading metadata from %1$'d %2$s (%3$d%% done)"), st->peersConnected,
ngettext("peer", "peers", st->peersConnected), (int)(100.0 * st->metadataPercentComplete));
}
else if (st->peersSendingToUs != 0 && st->webseedsSendingToUs != 0)
{
/* Downloading from 2 of 3 peer (s) and 2 webseed (s) */
g_string_append_printf(gstr, _("Downloading from %1$'d of %2$'d %3$s and %4$'d %5$s"), st->peersSendingToUs,
st->peersConnected, ngettext("peer", "peers", st->peersConnected), st->webseedsSendingToUs,
ngettext("web seed", "web seeds", st->webseedsSendingToUs));
}
else if (st->webseedsSendingToUs != 0)
{
/* Downloading from 3 web seed (s) */
g_string_append_printf(gstr, _("Downloading from %1$'d %2$s"), st->webseedsSendingToUs,
ngettext("web seed", "web seeds", st->webseedsSendingToUs));
}
else
{
/* Downloading from 2 of 3 peer (s) */
g_string_append_printf(gstr, _("Downloading from %1$'d of %2$'d %3$s"), st->peersSendingToUs,
st->peersConnected, ngettext("peer", "peers", st->peersConnected));
}
break;
}
case TR_STATUS_SEED:
g_string_append_printf(gstr, ngettext("Seeding to %1$'d of %2$'d connected peer",
"Seeding to %1$'d of %2$'d connected peers", st->peersConnected), st->peersGettingFromUs, st->peersConnected);
break;
}
}
if (st->activity != TR_STATUS_CHECK_WAIT && st->activity != TR_STATUS_CHECK && st->activity != TR_STATUS_DOWNLOAD_WAIT &&
st->activity != TR_STATUS_SEED_WAIT && st->activity != TR_STATUS_STOPPED)
{
char buf[256];
getShortTransferString(tor, st, uploadSpeed_KBps, downloadSpeed_KBps, buf, sizeof(buf));
if (*buf != '\0')
{
g_string_append_printf(gstr, " - %s", buf);
}
}
}
static char*
getStatusString( const tr_torrent * tor,
const tr_stat * st,
const double uploadSpeed_KBps,
const double downloadSpeed_KBps )
{
const int isActive = st->activity != TR_STATUS_STOPPED;
const int isChecking = st->activity == TR_STATUS_CHECK
|| st->activity == TR_STATUS_CHECK_WAIT;
GString * gstr = g_string_new( NULL );
if( st->error )
{
const char * fmt[] = { NULL, N_( "Tracker gave a warning: \"%s\"" ),
N_( "Tracker gave an error: \"%s\"" ),
N_( "Error: %s" ) };
g_string_append_printf( gstr, _( fmt[st->error] ), st->errorString );
}
else switch( st->activity )
{
case TR_STATUS_STOPPED:
case TR_STATUS_CHECK_WAIT:
case TR_STATUS_CHECK:
{
char * pch = getShortStatusString( tor, st, uploadSpeed_KBps, downloadSpeed_KBps );
g_string_assign( gstr, pch );
g_free( pch );
break;
}
case TR_STATUS_DOWNLOAD:
{
if( tr_torrentHasMetadata( tor ) )
{
g_string_append_printf( gstr,
gtr_ngettext( "Downloading from %1$'d of %2$'d connected peer",
"Downloading from %1$'d of %2$'d connected peers",
st->webseedsSendingToUs + st->peersSendingToUs ),
st->webseedsSendingToUs + st->peersSendingToUs,
st->webseedsSendingToUs + st->peersConnected );
}
else
{
g_string_append_printf( gstr,
gtr_ngettext( "Downloading metadata from %1$'d peer (%2$d%% done)",
"Downloading metadata from %1$'d peers (%2$d%% done)",
st->peersConnected + st->peersConnected ),
st->peersConnected + st->webseedsSendingToUs,
(int)(100.0*st->metadataPercentComplete) );
}
break;
}
case TR_STATUS_SEED:
g_string_append_printf( gstr,
gtr_ngettext( "Seeding to %1$'d of %2$'d connected peer",
"Seeding to %1$'d of %2$'d connected peers",
st->peersConnected ),
st->peersGettingFromUs,
st->peersConnected );
break;
}
if( isActive && !isChecking )
{
char buf[256];
getShortTransferString( tor, st, uploadSpeed_KBps, downloadSpeed_KBps, buf, sizeof( buf ) );
if( *buf )
g_string_append_printf( gstr, " - %s", buf );
}
return g_string_free( gstr, FALSE );
}
bool TorrentObject::IsMagnet() const
{
return !tr_torrentHasMetadata( fTorrentHandle );
}
