source: trunk/libtransmission/resume.c @ 11599

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

(trunk) Join the 21st century and use only 1 space at the end sentences. This commit is nearly as important as the semi-annual ones that remove trailing spaces from the ends of lines of code... :)

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