Changeset 2377


Ignore:
Timestamp:
Jul 16, 2007, 7:57:34 PM (15 years ago)
Author:
charles
Message:

fix overlap bug in file-selection where files adjacent to a "do not download" file could end up missing a few bytes.

Location:
trunk/libtransmission
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/fastresume.c

    r2348 r2377  
    234234
    235235static int
    236 fastResumeLoadPriorities( tr_torrent_t * tor,
    237                           FILE         * file )
     236loadPriorities( tr_torrent_t * tor,
     237                FILE         * file )
    238238{
    239239    const size_t n = tor->info.fileCount;
    240240    const size_t len = 2 * n;
     241    int *dnd = NULL, dndCount = 0;
     242    int *dl = NULL, dlCount = 0;
    241243    char * buf = tr_new0( char, len );
    242244    char * walk = buf;
     
    262264
    263265    /* set the dnd flags */
    264     for( i=0; i<n; ++i ) {
    265         int j;
    266         const char ch = *walk++;
    267         tr_file_t * file = &tor->info.files[i];
    268         file->dnd = ch == 't';
    269         for( j=file->firstPiece; j<=file->lastPiece; ++j )
    270             tor->info.pieces[j].dnd = file->dnd;
    271     }
    272 
    273     free( buf );
     266    dl = tr_new( int, len );
     267    dnd = tr_new( int, len );
     268    for( i=0; i<n; ++i )
     269        if( *walk++ == 't' ) /* 't' means the DND flag is true */
     270            dnd[dndCount++] = i;
     271        else
     272            dl[dlCount++] = i;
     273
     274    if( dndCount )
     275        tr_torrentSetFileDLs ( tor, dnd, dndCount, FALSE );
     276    if( dlCount )
     277        tr_torrentSetFileDLs ( tor, dl, dlCount, TRUE );
     278
     279    tr_free( dnd );
     280    tr_free( dl );
     281    tr_free( buf );
    274282    return TR_OK;
    275283}
     
    427435                if( len == (uint32_t)(2 * tor->info.fileCount) )
    428436                {
    429                     ret = fastResumeLoadPriorities( tor, file );
     437                    ret = loadPriorities( tor, file );
    430438
    431439                    if( ret && ( feof(file) || ferror(file) ) )
  • trunk/libtransmission/internal.h

    r2374 r2377  
    205205    uint64_t          startDate;
    206206    uint64_t          stopDate;
    207     int               ioLoaded;
     207    char              ioLoaded;
     208    char              fastResumeDirty;
    208209
    209210    int               peerCount;
     
    218219    uint8_t           pexDisabled;
    219220
     221    int8_t            statCur;
    220222    tr_stat_t         stats[2];
    221     int               statCur;
    222223
    223224    tr_torrent_t    * next;
  • trunk/libtransmission/torrent.c

    r2374 r2377  
    993993        /* sleep a little while */
    994994        tr_wait( tor->runStatus == TR_RUN_STOPPED ? 1600 : 600 );
     995
     996        if( tor->fastResumeDirty ) {
     997            tor->fastResumeDirty = FALSE;
     998            fastResumeSave( tor );
     999        }
    9951000
    9961001        /* if we're stopping... */
     
    11581163
    11591164
    1160 /***
    1161 ****
    1162 ****  File prioritization
    1163 ****
    1164 ***/
    1165 
    1166 static void
    1167 tr_torrentSetFilePriorityImpl( tr_torrent_t   * tor,
    1168                                int              fileIndex,
    1169                                tr_priority_t    priority,
    1170                                int              doSave )
     1165/**
     1166***  File priorities
     1167**/
     1168
     1169void
     1170tr_torrentSetFilePriority( tr_torrent_t   * tor,
     1171                           int              fileIndex,
     1172                           tr_priority_t    priority )
    11711173{
    11721174    int i;
     
    11881190             priority, tor->info.files[fileIndex].name );
    11891191
    1190     if( doSave )
    1191         fastResumeSave( tor );
     1192    tor->fastResumeDirty = TRUE;
    11921193
    11931194    tr_torrentWriterUnlock( tor );
    1194 }
    1195 
    1196 void
    1197 tr_torrentSetFilePriority( tr_torrent_t   * tor,
    1198                            int              fileIndex,
    1199                            tr_priority_t    priority )
    1200 {
    1201     tr_torrentSetFilePriorityImpl( tor, fileIndex, priority, TRUE );
    12021195}
    12031196
     
    12091202{
    12101203    int i;
    1211     for( i=0; i<fileCount; ++i ) {
    1212         const int fileIndex = files[i];
    1213         tr_torrentSetFilePriorityImpl( tor, fileIndex, priority, FALSE );
    1214     }
    1215     fastResumeSave( tor );
     1204    for( i=0; i<fileCount; ++i )
     1205        tr_torrentSetFilePriority( tor, files[i], priority );
    12161206}
    12171207
     
    12461236}
    12471237
     1238/**
     1239***  File DND
     1240**/
     1241
    12481242int
    12491243tr_torrentGetFileDL( const tr_torrent_t * tor,
    12501244                     int                  file )
    12511245{
    1252     int do_download;
     1246    int doDownload;
    12531247    tr_torrentReaderLock( tor );
    12541248
    12551249    assert( 0<=file && file<tor->info.fileCount );
    1256     do_download = !tor->info.files[file].dnd;
     1250    doDownload = !tor->info.files[file].dnd;
    12571251
    12581252    tr_torrentReaderUnlock( tor );
    1259     return do_download != 0;
     1253    return doDownload != 0;
    12601254}
    12611255
     
    12631257tr_torrentSetFileDL( tr_torrent_t  * tor,
    12641258                     int             fileIndex,
    1265                      int             do_download )
    1266 {
     1259                     int             doDownload )
     1260{
     1261    const tr_file_t * file;
     1262    const int dnd = !doDownload;
     1263    int firstPiece, firstPieceDND;
     1264    int lastPiece, lastPieceDND;
    12671265    int i;
    1268     tr_file_t * file;
    1269     const int dnd = !do_download;
    12701266
    12711267    tr_torrentWriterLock( tor );
    12721268
    1273     assert( 0<=fileIndex && fileIndex<tor->info.fileCount );
    12741269    file = &tor->info.files[fileIndex];
    1275     file->dnd = dnd;
    1276     for( i=file->firstPiece; i<=file->lastPiece; ++i )
    1277       tor->info.pieces[i].dnd = dnd;
    1278     fastResumeSave( tor );
     1270    firstPiece = file->firstPiece;
     1271    lastPiece = file->lastPiece;
     1272
     1273    /* can't set the first piece to DND unless
     1274       every file using that piece is DND */
     1275    firstPieceDND = dnd;
     1276    for( i=fileIndex-1; firstPieceDND && i>=0; --i ) {
     1277        if( tor->info.files[i].lastPiece != firstPiece )
     1278            break;
     1279        firstPieceDND = tor->info.files[i].dnd;
     1280    }
     1281
     1282    /* can't set the last piece to DND unless
     1283       every file using that piece is DND */
     1284    lastPieceDND = dnd;
     1285    for( i=fileIndex+1; lastPieceDND && i<tor->info.fileCount; ++i ) {
     1286        if( tor->info.files[i].firstPiece != lastPiece )
     1287            break;
     1288        lastPieceDND = tor->info.files[i].dnd;
     1289    }
     1290
     1291    if( firstPiece == lastPiece )
     1292    {
     1293        tor->info.pieces[firstPiece].dnd = firstPieceDND && lastPieceDND;
     1294    }
     1295    else
     1296    {
     1297        tor->info.pieces[firstPiece].dnd = firstPieceDND;
     1298        tor->info.pieces[lastPiece].dnd = lastPieceDND;
     1299        for( i=firstPiece+1; i<lastPiece-1; ++i )
     1300            tor->info.pieces[i].dnd = dnd;
     1301    }
     1302
     1303    tor->fastResumeDirty = TRUE;
    12791304
    12801305    tr_torrentWriterUnlock( tor );
     
    12851310                       int            * files,
    12861311                       int              fileCount,
    1287                        int              do_download )
    1288 {
    1289     int i, j;
    1290     const int dnd = !do_download;
    1291 
    1292     tr_torrentWriterLock( tor );
    1293 
    1294     for( i=0; i<fileCount; ++i ) {
    1295         const int fileIndex = files[i];
    1296         tr_file_t * file = &tor->info.files[fileIndex];
    1297         file->dnd = dnd;
    1298         for( j=file->firstPiece; j<=file->lastPiece; ++j )
    1299             tor->info.pieces[j].dnd = dnd;
    1300     }
    1301 
    1302     fastResumeSave( tor );
    1303 
    1304     tr_torrentWriterUnlock( tor );
    1305 }
     1312                       int              doDownload )
     1313{
     1314    int i;
     1315    for( i=0; i<fileCount; ++i )
     1316        tr_torrentSetFileDL( tor, files[i], doDownload );
     1317}
Note: See TracChangeset for help on using the changeset viewer.