static uint64_t
parseProgress( tr_torrent * tor,
const uint8_t * buf,
uint32_t len )
{
uint64_t ret = 0;
if( len == FR_PROGRESS_LEN( tor ) )
{
int i;
int n;
tr_bitfield bitfield;
/* compare file mtimes */
tr_time_t * curMTimes = getMTimes( tor, &n );
const uint8_t * walk = buf;
tr_time_t mtime;
for( i = 0; i < n; ++i )
{
readBytes( &mtime, &walk, sizeof( tr_time_t ) );
if( curMTimes[i] == mtime )
tr_torrentSetFileChecked( tor, i, TRUE );
else
{
tr_torrentSetFileChecked( tor, i, FALSE );
tr_tordbg( tor, "Torrent needs to be verified" );
}
}
free( curMTimes );
/* get the completion bitfield */
memset( &bitfield, 0, sizeof bitfield );
bitfield.byteCount = FR_BLOCK_BITFIELD_LEN( tor );
bitfield.bitCount = bitfield.byteCount * 8;
bitfield.bits = (uint8_t*) walk;
if( tr_cpBlockBitfieldSet( tor->completion, &bitfield ) )
ret = TR_FR_PROGRESS;
else {
tr_torrentUncheck( tor );
tr_tordbg( tor, "Torrent needs to be verified" );
}
}
/* the files whose mtimes are wrong,
remove from completion pending a recheck... */
{
tr_piece_index_t i;
for( i = 0; i < tor->info.pieceCount; ++i )
if( !tr_torrentIsPieceChecked( tor, i ) )
tr_cpPieceRem( tor->completion, i );
}
return ret;
}
static uint64_t
loadProgress( tr_benc * dict, tr_torrent * tor )
{
size_t i, n;
uint64_t ret = 0;
tr_benc * prog;
const tr_info * inf = tr_torrentInfo( tor );
for( i=0, n=inf->pieceCount; i<n; ++i )
inf->pieces[i].timeChecked = 0;
if( tr_bencDictFindDict( dict, KEY_PROGRESS, &prog ) )
{
const char * err;
const char * str;
const uint8_t * raw;
size_t rawlen;
tr_benc * l;
if( tr_bencDictFindList( prog, KEY_PROGRESS_CHECKTIME, &l ) )
{
/* per-piece timestamps were added in 2.20.
If some of a file's pieces have been checked more recently than
the file's mtime, and some lest recently, then that file will
have a list containing timestamps for each piece.
However, the most common use case is that the file doesn't change
after it's downloaded. To reduce overhead in the .resume file,
only a single timestamp is saved for the file if *all* or *none*
of the pieces were tested more recently than the file's mtime. */
tr_file_index_t fi;
for( fi=0; fi<inf->fileCount; ++fi )
{
tr_benc * b = tr_bencListChild( l, fi );
const tr_file * f = &inf->files[fi];
tr_piece * p = &inf->pieces[f->firstPiece];
const tr_piece * pend = &inf->pieces[f->lastPiece];
if( tr_bencIsInt( b ) )
{
int64_t t;
tr_bencGetInt( b, &t );
for( ; p!=pend; ++p )
p->timeChecked = (time_t)t;
}
else if( tr_bencIsList( b ) )
{
int i = 0;
int64_t offset = 0;
const int pieces = f->lastPiece + 1 - f->firstPiece;
tr_bencGetInt( tr_bencListChild( b, 0 ), &offset );
for( i=0; i<pieces; ++i )
{
int64_t t = 0;
tr_bencGetInt( tr_bencListChild( b, i+1 ), &t );
inf->pieces[f->firstPiece+i].timeChecked = (time_t)(t + offset);
}
}
}
}
else if( tr_bencDictFindList( prog, KEY_PROGRESS_MTIMES, &l ) )
{
tr_file_index_t fi;
/* Before 2.20, we stored the files' mtimes in the .resume file.
When loading the .resume file, a torrent's file would be flagged
as untested if its stored mtime didn't match its real mtime. */
for( fi=0; fi<inf->fileCount; ++fi )
{
int64_t t;
if( tr_bencGetInt( tr_bencListChild( l, fi ), &t ) )
{
const tr_file * f = &inf->files[fi];
tr_piece * p = &inf->pieces[f->firstPiece];
const tr_piece * pend = &inf->pieces[f->lastPiece];
const time_t mtime = tr_torrentGetFileMTime( tor, fi );
const time_t timeChecked = mtime==t ? mtime : 0;
for( ; p!=pend; ++p )
p->timeChecked = timeChecked;
}
}
}
err = NULL;
if( tr_bencDictFindStr( prog, KEY_PROGRESS_HAVE, &str ) )
{
if( !strcmp( str, "all" ) )
tr_cpSetHaveAll( &tor->completion );
else
err = "Invalid value for HAVE";
}
else if( tr_bencDictFindRaw( prog, KEY_PROGRESS_BITFIELD, &raw, &rawlen ) )
{
tr_bitfield tmp;
tmp.byteCount = rawlen;
tmp.bitCount = tmp.byteCount * 8;
tmp.bits = (uint8_t*) raw;
if( !tr_cpBlockBitfieldSet( &tor->completion, &tmp ) )
err = "Error loading bitfield";
}
else err = "Couldn't find 'have' or 'bitfield'";
if( err != NULL )
tr_tordbg( tor, "Torrent needs to be verified - %s", err );
ret = TR_FR_PROGRESS;
}
return ret;
}
static uint64_t
loadProgress( tr_benc * dict,
tr_torrent * tor )
{
uint64_t ret = 0;
tr_benc * p;
if( tr_bencDictFindDict( dict, KEY_PROGRESS, &p ) )
{
const uint8_t * raw;
size_t rawlen;
tr_benc * m;
size_t n;
time_t * curMTimes = tr_torrentGetMTimes( tor, &n );
if( tr_bencDictFindList( p, KEY_PROGRESS_MTIMES, &m )
&& ( n == tor->info.fileCount )
&& ( n == tr_bencListSize( m ) ) )
{
size_t i;
for( i = 0; i < n; ++i )
{
int64_t tmp;
if( !tr_bencGetInt( tr_bencListChild( m, i ), &tmp ) )
{
tr_tordbg(
tor,
"File #%zu needs to be verified - couldn't find benc entry",
i );
tr_torrentSetFileChecked( tor, i, FALSE );
}
else
{
const time_t t = (time_t) tmp;
if( t == curMTimes[i] )
tr_torrentSetFileChecked( tor, i, TRUE );
else
{
tr_tordbg(
tor,
"File #%zu needs to be verified - times %lu and %lu don't match",
i, t, curMTimes[i] );
tr_torrentSetFileChecked( tor, i, FALSE );
}
}
}
}
else
{
tr_torrentUncheck( tor );
tr_tordbg(
tor, "Torrent needs to be verified - unable to find mtimes" );
}
if( tr_bencDictFindRaw( p, KEY_PROGRESS_BITFIELD, &raw, &rawlen ) )
{
tr_bitfield tmp;
tmp.byteCount = rawlen;
tmp.bitCount = tmp.byteCount * 8;
tmp.bits = (uint8_t*) raw;
if( !tr_cpBlockBitfieldSet( tor->completion, &tmp ) )
{
tr_torrentUncheck( tor );
tr_tordbg(
tor,
"Torrent needs to be verified - error loading bitfield" );
}
}
else
{
tr_torrentUncheck( tor );
tr_tordbg(
tor,
"Torrent needs to be verified - unable to find bitfield" );
}
tr_free( curMTimes );
ret = TR_FR_PROGRESS;
}
return ret;
}
