source: trunk/libtransmission/resume.c @ 11506

Last change on this file since 11506 was 11506, checked in by charles, 11 years ago

(trunk libT) #2955 "Lazy Verification (aka Just-in-Time Verification)" -- implemented.

  • Property svn:keywords set to Date Rev Author Id
File size: 21.3 KB
Line 
1/*
2 * This file Copyright (C) 2008-2010 Mnemosyne LLC
3 *
4 * This file is licensed by the GPL version 2.  Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: resume.c 11506 2010-12-09 20:43:23Z charles $
11 */
12
13#include <unistd.h> /* unlink */
14
15#include <string.h>
16
17#include "transmission.h"
18#include "bencode.h"
19#include "completion.h"
20#include "metainfo.h" /* tr_metainfoGetBasename() */
21#include "peer-mgr.h" /* pex */
22#include "platform.h" /* tr_getResumeDir() */
23#include "resume.h"
24#include "session.h"
25#include "torrent.h"
26#include "utils.h" /* tr_buildPath */
27
28#define KEY_ACTIVITY_DATE       "activity-date"
29#define KEY_ADDED_DATE          "added-date"
30#define KEY_CORRUPT             "corrupt"
31#define KEY_DONE_DATE           "done-date"
32#define KEY_DOWNLOAD_DIR        "destination"
33#define KEY_DND                 "dnd"
34#define KEY_DOWNLOADED          "downloaded"
35#define KEY_INCOMPLETE_DIR      "incomplete-dir"
36#define KEY_MAX_PEERS           "max-peers"
37#define KEY_PAUSED              "paused"
38#define KEY_PEERS               "peers2"
39#define KEY_PEERS6              "peers2-6"
40#define KEY_FILE_PRIORITIES     "priority"
41#define KEY_BANDWIDTH_PRIORITY  "bandwidth-priority"
42#define KEY_PROGRESS            "progress"
43#define KEY_SPEEDLIMIT_OLD      "speed-limit"
44#define KEY_SPEEDLIMIT_UP       "speed-limit-up"
45#define KEY_SPEEDLIMIT_DOWN     "speed-limit-down"
46#define KEY_RATIOLIMIT          "ratio-limit"
47#define KEY_IDLELIMIT           "idle-limit"
48#define KEY_UPLOADED            "uploaded"
49
50#define KEY_SPEED_KiBps            "speed"
51#define KEY_SPEED_Bps              "speed-Bps"
52#define KEY_USE_GLOBAL_SPEED_LIMIT "use-global-speed-limit"
53#define KEY_USE_SPEED_LIMIT        "use-speed-limit"
54#define KEY_SPEEDLIMIT_DOWN_SPEED  "down-speed"
55#define KEY_SPEEDLIMIT_DOWN_MODE   "down-mode"
56#define KEY_SPEEDLIMIT_UP_SPEED    "up-speed"
57#define KEY_SPEEDLIMIT_UP_MODE     "up-mode"
58#define KEY_RATIOLIMIT_RATIO       "ratio-limit"
59#define KEY_RATIOLIMIT_MODE        "ratio-mode"
60#define KEY_IDLELIMIT_MINS         "idle-limit"
61#define KEY_IDLELIMIT_MODE         "idle-mode"
62
63#define KEY_PROGRESS_CHECKTIME "time-checked"
64#define KEY_PROGRESS_BITFIELD  "bitfield"
65#define KEY_PROGRESS_HAVE      "have"
66
67enum
68{
69    MAX_REMEMBERED_PEERS = 200
70};
71
72static char*
73getResumeFilename( const tr_torrent * tor )
74{
75    char * base = tr_metainfoGetBasename( tr_torrentInfo( tor ) );
76    char * filename = tr_strdup_printf( "%s" TR_PATH_DELIMITER_STR "%s.resume",
77                                        tr_getResumeDir( tor->session ), base );
78    tr_free( base );
79    return filename;
80}
81
82/***
83****
84***/
85
86static void
87savePeers( tr_benc * dict, const tr_torrent * tor )
88{
89    int count;
90    tr_pex * pex;
91
92    count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET, TR_PEERS_ALL, MAX_REMEMBERED_PEERS );
93    if( count > 0 )
94        tr_bencDictAddRaw( dict, KEY_PEERS, pex, sizeof( tr_pex ) * count );
95    tr_free( pex );
96
97    count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET6, TR_PEERS_ALL, MAX_REMEMBERED_PEERS );
98    if( count > 0 )
99        tr_bencDictAddRaw( dict, KEY_PEERS6, pex, sizeof( tr_pex ) * count );
100
101    tr_free( pex );
102}
103
104static tr_bool
105tr_isPex( const tr_pex * pex )
106{
107    return tr_isAddress( &pex->addr )
108        && ( pex->flags & 3 ) == pex->flags;
109}
110
111static int
112addPeers( tr_torrent * tor, const uint8_t * buf, int buflen )
113{
114    int i;
115    int numAdded = 0;
116    const int count = buflen / sizeof( tr_pex );
117
118    for( i=0; i<count && numAdded<MAX_REMEMBERED_PEERS; ++i )
119    {
120        tr_pex pex;
121        memcpy( &pex, buf + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
122        if( tr_isPex( &pex ) )
123        {
124            tr_peerMgrAddPex( tor, TR_PEER_FROM_RESUME, &pex, -1 );
125            ++numAdded;
126        }
127    }
128
129    return numAdded;
130}
131
132
133static uint64_t
134loadPeers( tr_benc * dict, tr_torrent * tor )
135{
136    uint64_t        ret = 0;
137    const uint8_t * str;
138    size_t          len;
139
140    if( tr_bencDictFindRaw( dict, KEY_PEERS, &str, &len ) )
141    {
142        const int numAdded = addPeers( tor, str, len );
143        tr_tordbg( tor, "Loaded %d IPv4 peers from resume file", numAdded );
144        ret = TR_FR_PEERS;
145    }
146
147    if( tr_bencDictFindRaw( dict, KEY_PEERS6, &str, &len ) )
148    {
149        const int numAdded = addPeers( tor, str, len );
150        tr_tordbg( tor, "Loaded %d IPv6 peers from resume file", numAdded );
151        ret = TR_FR_PEERS;
152    }
153
154    return ret;
155}
156
157/***
158****
159***/
160
161static void
162saveDND( tr_benc *          dict,
163         const tr_torrent * tor )
164{
165    const tr_info *       inf = tr_torrentInfo( tor );
166    const tr_file_index_t n = inf->fileCount;
167    tr_file_index_t       i;
168    tr_benc *             list;
169
170    list = tr_bencDictAddList( dict, KEY_DND, n );
171    for( i = 0; i < n; ++i )
172        tr_bencListAddInt( list, inf->files[i].dnd ? 1 : 0 );
173}
174
175static uint64_t
176loadDND( tr_benc *    dict,
177         tr_torrent * tor )
178{
179    uint64_t              ret = 0;
180    tr_info *             inf = &tor->info;
181    const tr_file_index_t n = inf->fileCount;
182    tr_benc *             list = NULL;
183
184    if( tr_bencDictFindList( dict, KEY_DND, &list )
185      && ( tr_bencListSize( list ) == n ) )
186    {
187        int64_t           tmp;
188        tr_file_index_t * dl = tr_new( tr_file_index_t, n );
189        tr_file_index_t * dnd = tr_new( tr_file_index_t, n );
190        tr_file_index_t   i, dlCount = 0, dndCount = 0;
191
192        for( i = 0; i < n; ++i )
193        {
194            if( tr_bencGetInt( tr_bencListChild( list, i ), &tmp ) && tmp )
195                dnd[dndCount++] = i;
196            else
197                dl[dlCount++] = i;
198        }
199
200        if( dndCount )
201        {
202            tr_torrentInitFileDLs ( tor, dnd, dndCount, FALSE );
203            tr_tordbg( tor, "Resume file found %d files listed as dnd",
204                       dndCount );
205        }
206        if( dlCount )
207        {
208            tr_torrentInitFileDLs ( tor, dl, dlCount, TRUE );
209            tr_tordbg( tor,
210                       "Resume file found %d files marked for download",
211                       dlCount );
212        }
213
214        tr_free( dnd );
215        tr_free( dl );
216        ret = TR_FR_DND;
217    }
218    else
219    {
220        tr_tordbg(
221            tor,
222            "Couldn't load DND flags.  dnd list (%p) has %zu children; torrent has %d files",
223            list, tr_bencListSize( list ), (int)n );
224    }
225
226    return ret;
227}
228
229/***
230****
231***/
232
233static void
234saveFilePriorities( tr_benc * dict, const tr_torrent * tor )
235{
236    const tr_info *       inf = tr_torrentInfo( tor );
237    const tr_file_index_t n = inf->fileCount;
238    tr_file_index_t       i;
239    tr_benc *             list;
240
241    list = tr_bencDictAddList( dict, KEY_FILE_PRIORITIES, n );
242    for( i = 0; i < n; ++i )
243        tr_bencListAddInt( list, inf->files[i].priority );
244}
245
246static uint64_t
247loadFilePriorities( tr_benc * dict, tr_torrent * tor )
248{
249    uint64_t              ret = 0;
250    tr_info *             inf = &tor->info;
251    const tr_file_index_t n = inf->fileCount;
252    tr_benc *             list;
253
254    if( tr_bencDictFindList( dict, KEY_FILE_PRIORITIES, &list )
255      && ( tr_bencListSize( list ) == n ) )
256    {
257        int64_t priority;
258        tr_file_index_t i;
259        for( i = 0; i < n; ++i )
260            if( tr_bencGetInt( tr_bencListChild( list, i ), &priority ) )
261                tr_torrentInitFilePriority( tor, i, priority );
262        ret = TR_FR_FILE_PRIORITIES;
263    }
264
265    return ret;
266}
267
268/***
269****
270***/
271
272static void
273saveSingleSpeedLimit( tr_benc * d, const tr_torrent * tor, tr_direction dir )
274{
275    tr_bencDictReserve( d, 3 );
276    tr_bencDictAddInt( d, KEY_SPEED_Bps, tr_torrentGetSpeedLimit_Bps( tor, dir ) );
277    tr_bencDictAddBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits( tor ) );
278    tr_bencDictAddBool( d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit( tor, dir ) );
279}
280
281static void
282saveSpeedLimits( tr_benc * dict, const tr_torrent * tor )
283{
284    saveSingleSpeedLimit( tr_bencDictAddDict( dict, KEY_SPEEDLIMIT_DOWN, 0 ), tor, TR_DOWN );
285    saveSingleSpeedLimit( tr_bencDictAddDict( dict, KEY_SPEEDLIMIT_UP, 0 ), tor, TR_UP );
286}
287
288static void
289saveRatioLimits( tr_benc * dict, const tr_torrent * tor )
290{
291    tr_benc * d = tr_bencDictAddDict( dict, KEY_RATIOLIMIT, 2 );
292    tr_bencDictAddReal( d, KEY_RATIOLIMIT_RATIO, tr_torrentGetRatioLimit( tor ) );
293    tr_bencDictAddInt( d, KEY_RATIOLIMIT_MODE, tr_torrentGetRatioMode( tor ) );
294}
295
296static void
297saveIdleLimits( tr_benc * dict, const tr_torrent * tor )
298{
299    tr_benc * d = tr_bencDictAddDict( dict, KEY_IDLELIMIT, 2 );
300    tr_bencDictAddInt( d, KEY_IDLELIMIT_MINS, tr_torrentGetIdleLimit( tor ) );
301    tr_bencDictAddInt( d, KEY_IDLELIMIT_MODE, tr_torrentGetIdleMode( tor ) );
302}
303
304static void
305loadSingleSpeedLimit( tr_benc * d, tr_direction dir, tr_torrent * tor )
306{
307    int64_t i;
308    tr_bool boolVal;
309
310    if( tr_bencDictFindInt( d, KEY_SPEED_Bps, &i ) )
311        tr_torrentSetSpeedLimit_Bps( tor, dir, i );
312    else if( tr_bencDictFindInt( d, KEY_SPEED_KiBps, &i ) )
313        tr_torrentSetSpeedLimit_Bps( tor, dir, i*1024 );
314
315    if( tr_bencDictFindBool( d, KEY_USE_SPEED_LIMIT, &boolVal ) )
316        tr_torrentUseSpeedLimit( tor, dir, boolVal );
317
318    if( tr_bencDictFindBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal ) )
319        tr_torrentUseSessionLimits( tor, boolVal );
320}
321
322enum old_speed_modes
323{
324    TR_SPEEDLIMIT_GLOBAL,   /* only follow the overall speed limit */
325    TR_SPEEDLIMIT_SINGLE    /* only follow the per-torrent limit */
326};
327
328static uint64_t
329loadSpeedLimits( tr_benc * dict, tr_torrent * tor )
330{
331    uint64_t  ret = 0;
332    tr_benc * d;
333
334    if( tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_UP, &d ) )
335    {
336        loadSingleSpeedLimit( d, TR_UP, tor );
337        ret = TR_FR_SPEEDLIMIT;
338    }
339    if( tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_DOWN, &d ) )
340    {
341        loadSingleSpeedLimit( d, TR_DOWN, tor );
342        ret = TR_FR_SPEEDLIMIT;
343    }
344
345    /* older speedlimit structure */
346    if( !ret && tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_OLD, &d ) )
347    {
348
349        int64_t i;
350        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_SPEED, &i ) )
351            tr_torrentSetSpeedLimit_Bps( tor, TR_DOWN, i*1024 );
352        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_MODE, &i ) ) {
353            tr_torrentUseSpeedLimit( tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE );
354            tr_torrentUseSessionLimits( tor, i==TR_SPEEDLIMIT_GLOBAL );
355         }
356        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_SPEED, &i ) )
357            tr_torrentSetSpeedLimit_Bps( tor, TR_UP, i*1024 );
358        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_MODE, &i ) ) {
359            tr_torrentUseSpeedLimit( tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE );
360            tr_torrentUseSessionLimits( tor, i==TR_SPEEDLIMIT_GLOBAL );
361        }
362        ret = TR_FR_SPEEDLIMIT;
363    }
364
365    return ret;
366}
367
368static uint64_t
369loadRatioLimits( tr_benc *    dict,
370                 tr_torrent * tor )
371{
372    uint64_t  ret = 0;
373    tr_benc * d;
374
375    if( tr_bencDictFindDict( dict, KEY_RATIOLIMIT, &d ) )
376    {
377        int64_t i;
378        double dratio;
379        if( tr_bencDictFindReal( d, KEY_RATIOLIMIT_RATIO, &dratio ) )
380            tr_torrentSetRatioLimit( tor, dratio );
381        if( tr_bencDictFindInt( d, KEY_RATIOLIMIT_MODE, &i ) )
382            tr_torrentSetRatioMode( tor, i );
383      ret = TR_FR_RATIOLIMIT;
384    }
385
386    return ret;
387}
388
389static uint64_t
390loadIdleLimits( tr_benc *    dict,
391                      tr_torrent * tor )
392{
393    uint64_t  ret = 0;
394    tr_benc * d;
395
396    if( tr_bencDictFindDict( dict, KEY_IDLELIMIT, &d ) )
397    {
398        int64_t i;
399        int64_t imin;
400        if( tr_bencDictFindInt( d, KEY_IDLELIMIT_MINS, &imin ) )
401            tr_torrentSetIdleLimit( tor, imin );
402        if( tr_bencDictFindInt( d, KEY_IDLELIMIT_MODE, &i ) )
403            tr_torrentSetIdleMode( tor, i );
404      ret = TR_FR_IDLELIMIT;
405    }
406
407    return ret;
408}
409/***
410****
411***/
412
413static void
414saveProgress( tr_benc *          dict,
415              const tr_torrent * tor )
416{
417    size_t              i, n;
418    tr_benc *           p;
419    tr_benc *           m;
420    const tr_bitfield * bitfield;
421
422    p = tr_bencDictAdd( dict, KEY_PROGRESS );
423    tr_bencInitDict( p, 2 );
424
425    /* add each piece's timeChecked */
426    n = tor->info.pieceCount;
427    m = tr_bencDictAddList( p, KEY_PROGRESS_CHECKTIME, n );
428    for( i=0; i<n; ++i )
429        tr_bencListAddInt( m, tor->info.pieces[i].timeChecked );
430
431    /* add the progress */
432    if( tor->completeness == TR_SEED )
433        tr_bencDictAddStr( p, KEY_PROGRESS_HAVE, "all" );
434    bitfield = tr_cpBlockBitfield( &tor->completion );
435    tr_bencDictAddRaw( p, KEY_PROGRESS_BITFIELD,
436                       bitfield->bits, bitfield->byteCount );
437}
438
439static uint64_t
440loadProgress( tr_benc *    dict,
441              tr_torrent * tor )
442{
443    size_t    i, n;
444    uint64_t  ret = 0;
445    tr_benc * p;
446
447    for( i=0, n=tor->info.pieceCount; i<n; ++i )
448        tor->info.pieces[i].timeChecked = 0;
449
450    if( tr_bencDictFindDict( dict, KEY_PROGRESS, &p ) )
451    {
452        const char * err;
453        const char * str;
454        const uint8_t * raw;
455        size_t          rawlen;
456        tr_benc *       m;
457        int64_t  timeChecked;
458
459        /* load in the timestamp of when we last checked each piece */
460        if( tr_bencDictFindList( p, KEY_PROGRESS_CHECKTIME, &m ) )
461            for( i=0, n=tor->info.pieceCount; i<n; ++i )
462                if( tr_bencGetInt( tr_bencListChild( m, i ), &timeChecked ) )
463                    tor->info.pieces[i].timeChecked = (time_t)timeChecked;
464
465        err = NULL;
466        if( tr_bencDictFindStr( p, KEY_PROGRESS_HAVE, &str ) )
467        {
468            if( !strcmp( str, "all" ) )
469                tr_cpSetHaveAll( &tor->completion );
470            else
471                err = "Invalid value for HAVE";
472        }
473        else if( tr_bencDictFindRaw( p, KEY_PROGRESS_BITFIELD, &raw, &rawlen ) )
474        {
475            tr_bitfield tmp;
476            tmp.byteCount = rawlen;
477            tmp.bitCount = tmp.byteCount * 8;
478            tmp.bits = (uint8_t*) raw;
479            if( !tr_cpBlockBitfieldSet( &tor->completion, &tmp ) )
480                err = "Error loading bitfield";
481        }
482        else err = "Couldn't find 'have' or 'bitfield'";
483
484        if( err != NULL )
485            tr_tordbg( tor, "Torrent needs to be verified - %s", err );
486
487        ret = TR_FR_PROGRESS;
488    }
489
490    return ret;
491}
492
493/***
494****
495***/
496
497void
498tr_torrentSaveResume( tr_torrent * tor )
499{
500    int err;
501    tr_benc top;
502    char * filename;
503
504    if( !tr_isTorrent( tor ) )
505        return;
506
507    tr_bencInitDict( &top, 50 ); /* arbitrary "big enough" number */
508    tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE, tor->activityDate );
509    tr_bencDictAddInt( &top, KEY_ADDED_DATE, tor->addedDate );
510    tr_bencDictAddInt( &top, KEY_CORRUPT, tor->corruptPrev + tor->corruptCur );
511    tr_bencDictAddInt( &top, KEY_DONE_DATE, tor->doneDate );
512    tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR, tor->downloadDir );
513    if( tor->incompleteDir != NULL )
514        tr_bencDictAddStr( &top, KEY_INCOMPLETE_DIR, tor->incompleteDir );
515    tr_bencDictAddInt( &top, KEY_DOWNLOADED, tor->downloadedPrev + tor->downloadedCur );
516    tr_bencDictAddInt( &top, KEY_UPLOADED, tor->uploadedPrev + tor->uploadedCur );
517    tr_bencDictAddInt( &top, KEY_MAX_PEERS, tor->maxConnectedPeers );
518    tr_bencDictAddInt( &top, KEY_BANDWIDTH_PRIORITY, tr_torrentGetPriority( tor ) );
519    tr_bencDictAddBool( &top, KEY_PAUSED, !tor->isRunning );
520    savePeers( &top, tor );
521    if( tr_torrentHasMetadata( tor ) )
522    {
523        saveFilePriorities( &top, tor );
524        saveDND( &top, tor );
525        saveProgress( &top, tor );
526    }
527    saveSpeedLimits( &top, tor );
528    saveRatioLimits( &top, tor );
529    saveIdleLimits( &top, tor );
530
531    filename = getResumeFilename( tor );
532    if(( err = tr_bencToFile( &top, TR_FMT_BENC, filename )))
533        tr_torrentSetLocalError( tor, "Unable to save resume file: %s", tr_strerror( err ) );
534    tr_free( filename );
535
536    tr_bencFree( &top );
537}
538
539static uint64_t
540loadFromFile( tr_torrent * tor,
541              uint64_t     fieldsToLoad )
542{
543    int64_t  i;
544    const char * str;
545    uint64_t fieldsLoaded = 0;
546    char * filename;
547    tr_benc top;
548    tr_bool boolVal;
549    const tr_bool  wasDirty = tor->isDirty;
550
551    assert( tr_isTorrent( tor ) );
552
553    filename = getResumeFilename( tor );
554
555    if( tr_bencLoadFile( &top, TR_FMT_BENC, filename ) )
556    {
557        tr_tordbg( tor, "Couldn't read \"%s\"", filename );
558
559        tr_free( filename );
560        return fieldsLoaded;
561    }
562
563    tr_tordbg( tor, "Read resume file \"%s\"", filename );
564
565    if( ( fieldsToLoad & TR_FR_CORRUPT )
566      && tr_bencDictFindInt( &top, KEY_CORRUPT, &i ) )
567    {
568        tor->corruptPrev = i;
569        fieldsLoaded |= TR_FR_CORRUPT;
570    }
571
572    if( ( fieldsToLoad & ( TR_FR_PROGRESS | TR_FR_DOWNLOAD_DIR ) )
573      && ( tr_bencDictFindStr( &top, KEY_DOWNLOAD_DIR, &str ) )
574      && ( str && *str ) )
575    {
576        tr_free( tor->downloadDir );
577        tor->downloadDir = tr_strdup( str );
578        fieldsLoaded |= TR_FR_DOWNLOAD_DIR;
579    }
580
581    if( ( fieldsToLoad & ( TR_FR_PROGRESS | TR_FR_INCOMPLETE_DIR ) )
582      && ( tr_bencDictFindStr( &top, KEY_INCOMPLETE_DIR, &str ) )
583      && ( str && *str ) )
584    {
585        tr_free( tor->incompleteDir );
586        tor->incompleteDir = tr_strdup( str );
587        fieldsLoaded |= TR_FR_INCOMPLETE_DIR;
588    }
589
590    if( ( fieldsToLoad & TR_FR_DOWNLOADED )
591      && tr_bencDictFindInt( &top, KEY_DOWNLOADED, &i ) )
592    {
593        tor->downloadedPrev = i;
594        fieldsLoaded |= TR_FR_DOWNLOADED;
595    }
596
597    if( ( fieldsToLoad & TR_FR_UPLOADED )
598      && tr_bencDictFindInt( &top, KEY_UPLOADED, &i ) )
599    {
600        tor->uploadedPrev = i;
601        fieldsLoaded |= TR_FR_UPLOADED;
602    }
603
604    if( ( fieldsToLoad & TR_FR_MAX_PEERS )
605      && tr_bencDictFindInt( &top, KEY_MAX_PEERS, &i ) )
606    {
607        tor->maxConnectedPeers = i;
608        fieldsLoaded |= TR_FR_MAX_PEERS;
609    }
610
611    if( ( fieldsToLoad & TR_FR_RUN )
612      && tr_bencDictFindBool( &top, KEY_PAUSED, &boolVal ) )
613    {
614        tor->isRunning = !boolVal;
615        fieldsLoaded |= TR_FR_RUN;
616    }
617
618    if( ( fieldsToLoad & TR_FR_ADDED_DATE )
619      && tr_bencDictFindInt( &top, KEY_ADDED_DATE, &i ) )
620    {
621        tor->addedDate = i;
622        fieldsLoaded |= TR_FR_ADDED_DATE;
623    }
624
625    if( ( fieldsToLoad & TR_FR_DONE_DATE )
626      && tr_bencDictFindInt( &top, KEY_DONE_DATE, &i ) )
627    {
628        tor->doneDate = i;
629        fieldsLoaded |= TR_FR_DONE_DATE;
630    }
631
632    if( ( fieldsToLoad & TR_FR_ACTIVITY_DATE )
633      && tr_bencDictFindInt( &top, KEY_ACTIVITY_DATE, &i ) )
634    {
635        tr_torrentSetActivityDate( tor, i );
636        fieldsLoaded |= TR_FR_ACTIVITY_DATE;
637    }
638
639    if( ( fieldsToLoad & TR_FR_BANDWIDTH_PRIORITY )
640      && tr_bencDictFindInt( &top, KEY_BANDWIDTH_PRIORITY, &i )
641      && tr_isPriority( i ) )
642    {
643        tr_torrentSetPriority( tor, i );
644        fieldsLoaded |= TR_FR_BANDWIDTH_PRIORITY;
645    }
646
647    if( fieldsToLoad & TR_FR_PEERS )
648        fieldsLoaded |= loadPeers( &top, tor );
649
650    if( fieldsToLoad & TR_FR_FILE_PRIORITIES )
651        fieldsLoaded |= loadFilePriorities( &top, tor );
652
653    if( fieldsToLoad & TR_FR_PROGRESS )
654        fieldsLoaded |= loadProgress( &top, tor );
655
656    if( fieldsToLoad & TR_FR_DND )
657        fieldsLoaded |= loadDND( &top, tor );
658
659    if( fieldsToLoad & TR_FR_SPEEDLIMIT )
660        fieldsLoaded |= loadSpeedLimits( &top, tor );
661
662    if( fieldsToLoad & TR_FR_RATIOLIMIT )
663        fieldsLoaded |= loadRatioLimits( &top, tor );
664
665    if( fieldsToLoad & TR_FR_IDLELIMIT )
666        fieldsLoaded |= loadIdleLimits( &top, tor );
667
668    /* loading the resume file triggers of a lot of changes,
669     * but none of them needs to trigger a re-saving of the
670     * same resume information... */
671    tor->isDirty = wasDirty;
672
673    tr_bencFree( &top );
674    tr_free( filename );
675    return fieldsLoaded;
676}
677
678static uint64_t
679setFromCtor( tr_torrent *    tor,
680             uint64_t        fields,
681             const tr_ctor * ctor,
682             int             mode )
683{
684    uint64_t ret = 0;
685
686    if( fields & TR_FR_RUN )
687    {
688        uint8_t isPaused;
689        if( !tr_ctorGetPaused( ctor, mode, &isPaused ) )
690        {
691            tor->isRunning = !isPaused;
692            ret |= TR_FR_RUN;
693        }
694    }
695
696    if( fields & TR_FR_MAX_PEERS )
697        if( !tr_ctorGetPeerLimit( ctor, mode, &tor->maxConnectedPeers ) )
698            ret |= TR_FR_MAX_PEERS;
699
700    if( fields & TR_FR_DOWNLOAD_DIR )
701    {
702        const char * path;
703        if( !tr_ctorGetDownloadDir( ctor, mode, &path ) && path && *path )
704        {
705            ret |= TR_FR_DOWNLOAD_DIR;
706            tr_free( tor->downloadDir );
707            tor->downloadDir = tr_strdup( path );
708        }
709    }
710
711    return ret;
712}
713
714static uint64_t
715useManditoryFields( tr_torrent *    tor,
716                    uint64_t        fields,
717                    const tr_ctor * ctor )
718{
719    return setFromCtor( tor, fields, ctor, TR_FORCE );
720}
721
722static uint64_t
723useFallbackFields( tr_torrent *    tor,
724                   uint64_t        fields,
725                   const tr_ctor * ctor )
726{
727    return setFromCtor( tor, fields, ctor, TR_FALLBACK );
728}
729
730uint64_t
731tr_torrentLoadResume( tr_torrent *    tor,
732                      uint64_t        fieldsToLoad,
733                      const tr_ctor * ctor )
734{
735    uint64_t ret = 0;
736
737    assert( tr_isTorrent( tor ) );
738
739    ret |= useManditoryFields( tor, fieldsToLoad, ctor );
740    fieldsToLoad &= ~ret;
741    ret |= loadFromFile( tor, fieldsToLoad );
742    fieldsToLoad &= ~ret;
743    ret |= useFallbackFields( tor, fieldsToLoad, ctor );
744
745    return ret;
746}
747
748void
749tr_torrentRemoveResume( const tr_torrent * tor )
750{
751    char * filename = getResumeFilename( tor );
752    unlink( filename );
753    tr_free( filename );
754}
755
Note: See TracBrowser for help on using the repository browser.