source: trunk/libtransmission/resume.c @ 8021

Last change on this file since 8021 was 8021, checked in by charles, 13 years ago

(trunk) libT and gtk+ parts for #1889: per-torrent vs. global speed limit confusion

  • Property svn:keywords set to Date Rev Author Id
File size: 19.9 KB
Line 
1/*
2 * This file Copyright (C) 2008-2009 Charles Kerr <charles@transmissionbt.com>
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 8021 2009-03-04 19:52:57Z charles $
11 */
12
13#include <unistd.h> /* unlink */
14
15#include <string.h>
16
17#include "transmission.h"
18#include "session.h"
19#include "bencode.h"
20#include "completion.h"
21#include "fastresume.h"
22#include "peer-mgr.h" /* pex */
23#include "platform.h" /* tr_getResumeDir */
24#include "resume.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_MAX_PEERS       "max-peers"
36#define KEY_PAUSED          "paused"
37#define KEY_PEERS           "peers"
38#define KEY_PEERS6          "peers6"
39#define KEY_PRIORITY        "priority"
40#define KEY_PROGRESS        "progress"
41#define KEY_SPEEDLIMIT_OLD  "speed-limit"
42#define KEY_SPEEDLIMIT_UP   "speed-limit-up"
43#define KEY_SPEEDLIMIT_DOWN "speed-limit-down"
44#define KEY_RATIOLIMIT      "ratio-limit"
45#define KEY_UPLOADED        "uploaded"
46
47#define KEY_SPEED                  "speed"
48#define KEY_USE_GLOBAL_SPEED_LIMIT "use-global-speed-limit"
49#define KEY_USE_SPEED_LIMIT        "use-speed-limit"
50#define KEY_SPEEDLIMIT_DOWN_SPEED  "down-speed"
51#define KEY_SPEEDLIMIT_DOWN_MODE   "down-mode"
52#define KEY_SPEEDLIMIT_UP_SPEED    "up-speed"
53#define KEY_SPEEDLIMIT_UP_MODE     "up-mode"
54#define KEY_RATIOLIMIT_RATIO       "ratio-limit"
55#define KEY_RATIOLIMIT_MODE        "ratio-mode"
56
57#define KEY_PROGRESS_MTIMES   "mtimes"
58#define KEY_PROGRESS_BITFIELD "bitfield"
59
60static char*
61getResumeFilename( const tr_torrent * tor )
62{
63    return tr_strdup_printf( "%s%c%s.%16.16s.resume",
64                             tr_getResumeDir( tor->session ),
65                             TR_PATH_DELIMITER,
66                             tor->info.name,
67                             tor->info.hashString );
68}
69
70/***
71****
72***/
73
74static void
75savePeers( tr_benc *          dict,
76           const tr_torrent * tor )
77{
78    tr_pex * pex = NULL;
79    int count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET );
80
81    if( count > 0 )
82        tr_bencDictAddRaw( dict, KEY_PEERS, pex, sizeof( tr_pex ) * count );
83
84    tr_free( pex );
85    pex = NULL;
86   
87    count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET6 );
88    if( count > 0 )
89        tr_bencDictAddRaw( dict, KEY_PEERS6, pex, sizeof( tr_pex ) * count );
90   
91    tr_free( pex );
92}
93
94static uint64_t
95loadPeers( tr_benc *    dict,
96           tr_torrent * tor )
97{
98    uint64_t        ret = 0;
99    const uint8_t * str;
100    size_t          len;
101
102    if( tr_bencDictFindRaw( dict, KEY_PEERS, &str, &len ) )
103    {
104        int       i;
105        const int count = len / sizeof( tr_pex );
106        for( i = 0; i < count; ++i )
107        {
108            tr_pex pex;
109            memcpy( &pex, str + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
110            tr_peerMgrAddPex( tor, TR_PEER_FROM_CACHE, &pex );
111        }
112        tr_tordbg( tor, "Loaded %d IPv4 peers from resume file", count );
113        ret = TR_FR_PEERS;
114    }
115   
116    if( tr_bencDictFindRaw( dict, KEY_PEERS6, &str, &len ) )
117    {
118        int       i;
119        const int count = len / sizeof( tr_pex );
120        for( i = 0; i < count; ++i )
121        {
122            tr_pex pex;
123            memcpy( &pex, str + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
124            tr_peerMgrAddPex( tor, TR_PEER_FROM_CACHE, &pex );
125        }
126        tr_tordbg( tor, "Loaded %d IPv6 peers from resume file", count );
127        ret = TR_FR_PEERS;
128    }
129
130    return ret;
131}
132
133/***
134****
135***/
136
137static void
138saveDND( tr_benc *          dict,
139         const tr_torrent * tor )
140{
141    const tr_info *       inf = tr_torrentInfo( tor );
142    const tr_file_index_t n = inf->fileCount;
143    tr_file_index_t       i;
144    tr_benc *             list;
145
146    list = tr_bencDictAddList( dict, KEY_DND, n );
147    for( i = 0; i < n; ++i )
148        tr_bencListAddInt( list, inf->files[i].dnd ? 1 : 0 );
149}
150
151static uint64_t
152loadDND( tr_benc *    dict,
153         tr_torrent * tor )
154{
155    uint64_t              ret = 0;
156    tr_info *             inf = &tor->info;
157    const tr_file_index_t n = inf->fileCount;
158    tr_benc *             list = NULL;
159
160    if( tr_bencDictFindList( dict, KEY_DND, &list )
161      && ( tr_bencListSize( list ) == n ) )
162    {
163        int64_t           tmp;
164        tr_file_index_t * dl = tr_new( tr_file_index_t, n );
165        tr_file_index_t * dnd = tr_new( tr_file_index_t, n );
166        tr_file_index_t   i, dlCount = 0, dndCount = 0;
167
168        for( i = 0; i < n; ++i )
169        {
170            if( tr_bencGetInt( tr_bencListChild( list, i ), &tmp ) && tmp )
171                dnd[dndCount++] = i;
172            else
173                dl[dlCount++] = i;
174        }
175
176        if( dndCount )
177        {
178            tr_torrentInitFileDLs ( tor, dnd, dndCount, FALSE );
179            tr_tordbg( tor, "Resume file found %d files listed as dnd",
180                       dndCount );
181        }
182        if( dlCount )
183        {
184            tr_torrentInitFileDLs ( tor, dl, dlCount, TRUE );
185            tr_tordbg( tor,
186                       "Resume file found %d files marked for download",
187                       dlCount );
188        }
189
190        tr_free( dnd );
191        tr_free( dl );
192        ret = TR_FR_PRIORITY;
193    }
194    else
195    {
196        tr_tordbg(
197            tor,
198            "Couldn't load DND flags.  dnd list (%p) has %zu children; torrent has %d files",
199            list, tr_bencListSize( list ), (int)n );
200    }
201
202    return ret;
203}
204
205/***
206****
207***/
208
209static void
210savePriorities( tr_benc *          dict,
211                const tr_torrent * tor )
212{
213    const tr_info *       inf = tr_torrentInfo( tor );
214    const tr_file_index_t n = inf->fileCount;
215    tr_file_index_t       i;
216    tr_benc *             list;
217
218    list = tr_bencDictAddList( dict, KEY_PRIORITY, n );
219    for( i = 0; i < n; ++i )
220        tr_bencListAddInt( list, inf->files[i].priority );
221}
222
223static uint64_t
224loadPriorities( tr_benc *    dict,
225                tr_torrent * tor )
226{
227    uint64_t              ret = 0;
228    tr_info *             inf = &tor->info;
229    const tr_file_index_t n = inf->fileCount;
230    tr_benc *             list;
231
232    if( tr_bencDictFindList( dict, KEY_PRIORITY, &list )
233      && ( tr_bencListSize( list ) == n ) )
234    {
235        int64_t priority;
236        tr_file_index_t i;
237        for( i = 0; i < n; ++i )
238            if( tr_bencGetInt( tr_bencListChild( list, i ), &priority ) )
239                tr_torrentInitFilePriority( tor, i, priority );
240        ret = TR_FR_PRIORITY;
241    }
242
243    return ret;
244}
245
246/***
247****
248***/
249
250static void
251saveSingleSpeedLimit( tr_benc * d, const tr_torrent * tor, tr_direction dir )
252{
253    tr_bencDictReserve( d, 3 );
254    tr_bencDictAddInt( d, KEY_SPEED, tr_torrentGetSpeedLimit( tor, dir ) );
255    tr_bencDictAddInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentIsUsingGlobalSpeedLimit( tor, dir ) );
256    tr_bencDictAddInt( d, KEY_USE_SPEED_LIMIT, tr_torrentIsUsingSpeedLimit( tor, dir ) );
257}
258
259static void
260saveSpeedLimits( tr_benc * dict, const tr_torrent * tor )
261{
262    saveSingleSpeedLimit( tr_bencDictAddDict( dict, KEY_SPEEDLIMIT_DOWN, 0 ), tor, TR_DOWN );
263    saveSingleSpeedLimit( tr_bencDictAddDict( dict, KEY_SPEEDLIMIT_UP, 0 ), tor, TR_UP );
264}
265
266static void
267saveRatioLimits( tr_benc * dict, const tr_torrent * tor )
268{
269    tr_benc * d = tr_bencDictAddDict( dict, KEY_RATIOLIMIT, 4 );
270
271    tr_bencDictAddDouble( d, KEY_RATIOLIMIT_RATIO,
272                      tr_torrentGetRatioLimit( tor ) );
273    tr_bencDictAddInt( d, KEY_RATIOLIMIT_MODE,
274                      tr_torrentGetRatioMode( tor ) );
275}
276
277static void
278loadSingleSpeedLimit( tr_benc * d, tr_direction dir, tr_torrent * tor )
279{
280    int64_t i;
281    if( tr_bencDictFindInt( d, KEY_SPEED, &i ) )
282        tr_torrentSetSpeedLimit( tor, dir, i );
283    if( tr_bencDictFindInt( d, KEY_USE_SPEED_LIMIT, &i ) )
284        tr_torrentUseSpeedLimit( tor, dir, i!=0 );
285    if( tr_bencDictFindInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, &i ) )
286        tr_torrentUseGlobalSpeedLimit( tor, dir, i!=0 );
287}
288
289enum old_speed_modes
290{
291    TR_SPEEDLIMIT_GLOBAL,   /* only follow the overall speed limit */
292    TR_SPEEDLIMIT_SINGLE    /* only follow the per-torrent limit */
293};
294
295static uint64_t
296loadSpeedLimits( tr_benc * dict, tr_torrent * tor )
297{
298    uint64_t  ret = 0;
299    tr_benc * d;
300
301    if( tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_UP, &d ) )
302    {
303        loadSingleSpeedLimit( d, TR_UP, tor );
304        ret = TR_FR_SPEEDLIMIT;
305    }
306    if( tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_DOWN, &d ) )
307    {
308        loadSingleSpeedLimit( d, TR_DOWN, tor );
309        ret = TR_FR_SPEEDLIMIT;
310    }
311
312    /* older speedlimit structure */
313    if( !ret && tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_OLD, &d ) )
314    {
315
316        int64_t i;
317        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_SPEED, &i ) )
318            tr_torrentSetSpeedLimit( tor, TR_DOWN, i );
319        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_MODE, &i ) ) {
320            tr_torrentUseSpeedLimit ( tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE );
321            tr_torrentUseGlobalSpeedLimit( tor, TR_DOWN, i==TR_SPEEDLIMIT_GLOBAL );
322         }
323        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_SPEED, &i ) )
324            tr_torrentSetSpeedLimit( tor, TR_UP, i );
325        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_MODE, &i ) ) {
326            tr_torrentUseSpeedLimit ( tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE );
327            tr_torrentUseGlobalSpeedLimit( tor, TR_UP, i==TR_SPEEDLIMIT_GLOBAL );
328        }
329        ret = TR_FR_SPEEDLIMIT;
330    }
331
332    return ret;
333}
334
335static uint64_t
336loadRatioLimits( tr_benc *    dict,
337                 tr_torrent * tor )
338{
339    uint64_t  ret = 0;
340    tr_benc * d;
341
342    if( tr_bencDictFindDict( dict, KEY_RATIOLIMIT, &d ) )
343    {
344        int64_t i;
345        double dratio;
346          if( tr_bencDictFindDouble( d, KEY_RATIOLIMIT_RATIO, &dratio ) )
347            tr_torrentSetRatioLimit( tor, dratio );
348        if( tr_bencDictFindInt( d, KEY_RATIOLIMIT_MODE, &i ) )
349            tr_torrentSetRatioMode( tor, i );
350      ret = TR_FR_RATIOLIMIT;
351    }
352
353    return ret;
354}
355/***
356****
357***/
358
359static void
360saveProgress( tr_benc *          dict,
361              const tr_torrent * tor )
362{
363    size_t              i, n;
364    time_t *            mtimes;
365    tr_benc *           p;
366    tr_benc *           m;
367    const tr_bitfield * bitfield;
368
369    p = tr_bencDictAdd( dict, KEY_PROGRESS );
370    tr_bencInitDict( p, 2 );
371
372    /* add the mtimes */
373    mtimes = tr_torrentGetMTimes( tor, &n );
374    m = tr_bencDictAddList( p, KEY_PROGRESS_MTIMES, n );
375    for( i = 0; i < n; ++i )
376    {
377        if( !tr_torrentIsFileChecked( tor, i ) )
378            mtimes[i] = ~(time_t)0; /* force a recheck */
379        tr_bencListAddInt( m, mtimes[i] );
380    }
381
382    /* add the bitfield */
383    bitfield = tr_cpBlockBitfield( &tor->completion );
384    tr_bencDictAddRaw( p, KEY_PROGRESS_BITFIELD,
385                       bitfield->bits, bitfield->byteCount );
386
387    /* cleanup */
388    tr_free( mtimes );
389}
390
391static uint64_t
392loadProgress( tr_benc *    dict,
393              tr_torrent * tor )
394{
395    uint64_t  ret = 0;
396    tr_benc * p;
397
398    if( tr_bencDictFindDict( dict, KEY_PROGRESS, &p ) )
399    {
400        const uint8_t * raw;
401        size_t          rawlen;
402        tr_benc *       m;
403        size_t          n;
404        time_t *        curMTimes = tr_torrentGetMTimes( tor, &n );
405
406        if( tr_bencDictFindList( p, KEY_PROGRESS_MTIMES, &m )
407          && ( n == tor->info.fileCount )
408          && ( n == tr_bencListSize( m ) ) )
409        {
410            size_t i;
411            for( i = 0; i < n; ++i )
412            {
413                int64_t tmp;
414                if( !tr_bencGetInt( tr_bencListChild( m, i ), &tmp ) )
415                {
416                    tr_tordbg(
417                        tor,
418                        "File #%zu needs to be verified - couldn't find benc entry",
419                        i );
420                    tr_torrentSetFileChecked( tor, i, FALSE );
421                }
422                else
423                {
424                    const time_t t = (time_t) tmp;
425                    if( t == curMTimes[i] )
426                        tr_torrentSetFileChecked( tor, i, TRUE );
427                    else
428                    {
429                        tr_tordbg(
430                            tor,
431                            "File #%zu needs to be verified - times %lu and %lu don't match",
432                            i, t, curMTimes[i] );
433                        tr_torrentSetFileChecked( tor, i, FALSE );
434                    }
435                }
436            }
437        }
438        else
439        {
440            tr_torrentUncheck( tor );
441            tr_tordbg(
442                tor, "Torrent needs to be verified - unable to find mtimes" );
443        }
444
445        if( tr_bencDictFindRaw( p, KEY_PROGRESS_BITFIELD, &raw, &rawlen ) )
446        {
447            tr_bitfield tmp;
448            tmp.byteCount = rawlen;
449            tmp.bitCount = tmp.byteCount * 8;
450            tmp.bits = (uint8_t*) raw;
451            if( !tr_cpBlockBitfieldSet( &tor->completion, &tmp ) )
452            {
453                tr_torrentUncheck( tor );
454                tr_tordbg(
455                    tor,
456                    "Torrent needs to be verified - error loading bitfield" );
457            }
458        }
459        else
460        {
461            tr_torrentUncheck( tor );
462            tr_tordbg(
463                tor,
464                "Torrent needs to be verified - unable to find bitfield" );
465        }
466
467        tr_free( curMTimes );
468        ret = TR_FR_PROGRESS;
469    }
470
471    return ret;
472}
473
474/***
475****
476***/
477
478void
479tr_torrentSaveResume( const tr_torrent * tor )
480{
481    tr_benc top;
482    char *  filename;
483
484    if( !tor )
485        return;
486
487    tr_bencInitDict( &top, 14 );
488    tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE,
489                       tor->activityDate );
490    tr_bencDictAddInt( &top, KEY_ADDED_DATE,
491                       tor->addedDate );
492    tr_bencDictAddInt( &top, KEY_CORRUPT,
493                       tor->corruptPrev + tor->corruptCur );
494    tr_bencDictAddInt( &top, KEY_DONE_DATE,
495                       tor->doneDate );
496    tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR,
497                       tor->downloadDir );
498    tr_bencDictAddInt( &top, KEY_DOWNLOADED,
499                       tor->downloadedPrev + tor->downloadedCur );
500    tr_bencDictAddInt( &top, KEY_UPLOADED,
501                       tor->uploadedPrev + tor->uploadedCur );
502    tr_bencDictAddInt( &top, KEY_MAX_PEERS,
503                       tor->maxConnectedPeers );
504    tr_bencDictAddInt( &top, KEY_PAUSED,
505                       tor->isRunning ? 0 : 1 );
506    savePeers( &top, tor );
507    savePriorities( &top, tor );
508    saveDND( &top, tor );
509    saveProgress( &top, tor );
510    saveSpeedLimits( &top, tor );
511    saveRatioLimits( &top, tor );
512
513    filename = getResumeFilename( tor );
514    tr_bencSaveFile( filename, &top );
515    tr_free( filename );
516
517    tr_bencFree( &top );
518}
519
520static uint64_t
521loadFromFile( tr_torrent * tor,
522              uint64_t     fieldsToLoad )
523{
524    int64_t      i;
525    const char * str;
526    uint64_t     fieldsLoaded = 0;
527    char *       filename;
528    tr_benc      top;
529
530    filename = getResumeFilename( tor );
531
532    if( tr_bencLoadFile( filename, &top ) )
533    {
534        tr_tordbg( tor, "Couldn't read \"%s\"; trying old format.",
535                   filename );
536        fieldsLoaded = tr_fastResumeLoad( tor, fieldsToLoad );
537
538        if( ( fieldsLoaded != 0 ) && ( fieldsToLoad == ~(uint64_t)0 ) )
539        {
540            tr_torrentSaveResume( tor );
541            tr_fastResumeRemove( tor );
542            tr_tordbg( tor, "Migrated resume file to \"%s\"", filename );
543        }
544
545        tr_free( filename );
546        return fieldsLoaded;
547    }
548
549    tr_tordbg( tor, "Read resume file \"%s\"", filename );
550
551    if( ( fieldsToLoad & TR_FR_CORRUPT )
552      && tr_bencDictFindInt( &top, KEY_CORRUPT, &i ) )
553    {
554        tor->corruptPrev = i;
555        fieldsLoaded |= TR_FR_CORRUPT;
556    }
557
558    if( ( fieldsToLoad & ( TR_FR_PROGRESS | TR_FR_DOWNLOAD_DIR ) )
559      && ( tr_bencDictFindStr( &top, KEY_DOWNLOAD_DIR, &str ) )
560      && ( str && *str ) )
561    {
562        tr_free( tor->downloadDir );
563        tor->downloadDir = tr_strdup( str );
564        fieldsLoaded |= TR_FR_DOWNLOAD_DIR;
565    }
566
567    if( ( fieldsToLoad & TR_FR_DOWNLOADED )
568      && tr_bencDictFindInt( &top, KEY_DOWNLOADED, &i ) )
569    {
570        tor->downloadedPrev = i;
571        fieldsLoaded |= TR_FR_DOWNLOADED;
572    }
573
574    if( ( fieldsToLoad & TR_FR_UPLOADED )
575      && tr_bencDictFindInt( &top, KEY_UPLOADED, &i ) )
576    {
577        tor->uploadedPrev = i;
578        fieldsLoaded |= TR_FR_UPLOADED;
579    }
580
581    if( ( fieldsToLoad & TR_FR_MAX_PEERS )
582      && tr_bencDictFindInt( &top, KEY_MAX_PEERS, &i ) )
583    {
584        tor->maxConnectedPeers = i;
585        fieldsLoaded |= TR_FR_MAX_PEERS;
586    }
587
588    if( ( fieldsToLoad & TR_FR_RUN )
589      && tr_bencDictFindInt( &top, KEY_PAUSED, &i ) )
590    {
591        tor->isRunning = i ? 0 : 1;
592        fieldsLoaded |= TR_FR_RUN;
593    }
594
595    if( ( fieldsToLoad & TR_FR_ADDED_DATE )
596      && tr_bencDictFindInt( &top, KEY_ADDED_DATE, &i ) )
597    {
598        tor->addedDate = i;
599        fieldsLoaded |= TR_FR_ADDED_DATE;
600    }
601
602    if( ( fieldsToLoad & TR_FR_DONE_DATE )
603      && tr_bencDictFindInt( &top, KEY_DONE_DATE, &i ) )
604    {
605        tor->doneDate = i;
606        fieldsLoaded |= TR_FR_DONE_DATE;
607    }
608
609    if( ( fieldsToLoad & TR_FR_ACTIVITY_DATE )
610      && tr_bencDictFindInt( &top, KEY_ACTIVITY_DATE, &i ) )
611    {
612        tor->activityDate = i;
613        fieldsLoaded |= TR_FR_ACTIVITY_DATE;
614    }
615
616    if( fieldsToLoad & TR_FR_PEERS )
617        fieldsLoaded |= loadPeers( &top, tor );
618
619    if( fieldsToLoad & TR_FR_PRIORITY )
620        fieldsLoaded |= loadPriorities( &top, tor );
621
622    if( fieldsToLoad & TR_FR_PROGRESS )
623        fieldsLoaded |= loadProgress( &top, tor );
624
625    if( fieldsToLoad & TR_FR_DND )
626        fieldsLoaded |= loadDND( &top, tor );
627
628    if( fieldsToLoad & TR_FR_SPEEDLIMIT )
629        fieldsLoaded |= loadSpeedLimits( &top, tor );
630   
631    if( fieldsToLoad & TR_FR_RATIOLIMIT )
632        fieldsLoaded |= loadRatioLimits( &top, tor );
633
634    tr_bencFree( &top );
635    tr_free( filename );
636    return fieldsLoaded;
637}
638
639static uint64_t
640setFromCtor( tr_torrent *    tor,
641             uint64_t        fields,
642             const tr_ctor * ctor,
643             int             mode )
644{
645    uint64_t ret = 0;
646
647    if( fields & TR_FR_RUN )
648    {
649        uint8_t isPaused;
650        if( !tr_ctorGetPaused( ctor, mode, &isPaused ) )
651        {
652            tor->isRunning = !isPaused;
653            ret |= TR_FR_RUN;
654        }
655    }
656
657    if( fields & TR_FR_MAX_PEERS )
658        if( !tr_ctorGetPeerLimit( ctor, mode, &tor->maxConnectedPeers ) )
659            ret |= TR_FR_MAX_PEERS;
660
661    if( fields & TR_FR_DOWNLOAD_DIR )
662    {
663        const char * path;
664        if( !tr_ctorGetDownloadDir( ctor, mode, &path ) && path && *path )
665        {
666            ret |= TR_FR_DOWNLOAD_DIR;
667            tr_free( tor->downloadDir );
668            tor->downloadDir = tr_strdup( path );
669        }
670    }
671
672    return ret;
673}
674
675static uint64_t
676useManditoryFields( tr_torrent *    tor,
677                    uint64_t        fields,
678                    const tr_ctor * ctor )
679{
680    return setFromCtor( tor, fields, ctor, TR_FORCE );
681}
682
683static uint64_t
684useFallbackFields( tr_torrent *    tor,
685                   uint64_t        fields,
686                   const tr_ctor * ctor )
687{
688    return setFromCtor( tor, fields, ctor, TR_FALLBACK );
689}
690
691uint64_t
692tr_torrentLoadResume( tr_torrent *    tor,
693                      uint64_t        fieldsToLoad,
694                      const tr_ctor * ctor )
695{
696    uint64_t ret = 0;
697
698    ret |= useManditoryFields( tor, fieldsToLoad, ctor );
699    fieldsToLoad &= ~ret;
700    ret |= loadFromFile( tor, fieldsToLoad );
701    fieldsToLoad &= ~ret;
702    ret |= useFallbackFields( tor, fieldsToLoad, ctor );
703
704    return ret;
705}
706
707void
708tr_torrentRemoveResume( const tr_torrent * tor )
709{
710    char * filename = getResumeFilename( tor );
711
712    unlink( filename );
713    tr_fastResumeRemove( tor );
714    tr_free( filename );
715}
716
Note: See TracBrowser for help on using the repository browser.