source: trunk/libtransmission/resume.c @ 5959

Last change on this file since 5959 was 5959, checked in by charles, 14 years ago

svn propset

  • Property svn:keywords set to Date Rev Author Id
File size: 14.6 KB
Line 
1/*
2 * This file Copyright (C) 2008 Charles Kerr <charles@rebelbase.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 5959 2008-05-28 17:20:11Z 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 "fastresume.h"
21#include "peer-mgr.h" /* pex */
22#include "platform.h" /* tr_getResumeDir */
23#include "resume.h"
24#include "torrent.h"
25#include "utils.h" /* tr_buildPath */
26
27#define KEY_CORRUPT      "corrupt"
28#define KEY_DOWNLOAD_DIR "destination"
29#define KEY_DND          "dnd"
30#define KEY_DOWNLOADED   "downloaded"
31#define KEY_MAX_PEERS    "max-peers"
32#define KEY_PAUSED       "paused"
33#define KEY_PEERS        "peers"
34#define KEY_PRIORITY     "priority"
35#define KEY_PROGRESS     "progress"
36#define KEY_SPEEDLIMIT   "speed-limit"
37#define KEY_UPLOADED     "uploaded"
38
39#define KEY_SPEEDLIMIT_DOWN_SPEED "down-speed"
40#define KEY_SPEEDLIMIT_DOWN_MODE  "down-mode"
41#define KEY_SPEEDLIMIT_UP_SPEED   "up-speed"
42#define KEY_SPEEDLIMIT_UP_MODE    "up-mode"
43
44#define KEY_PROGRESS_MTIMES   "mtimes"
45#define KEY_PROGRESS_BITFIELD "bitfield"
46
47static void
48getResumeFilename( char * buf, size_t buflen, const tr_torrent * tor )
49{
50    const char * dir = tr_getResumeDir( tor->handle );
51    char base[MAX_PATH_LENGTH];
52    snprintf( base, sizeof( base ), "%s.%16.16s.resume",
53              tor->info.name,
54              tor->info.hashString );
55    tr_buildPath( buf, buflen, dir, base, NULL );
56}
57
58/***
59****
60***/
61
62static void
63savePeers( tr_benc * dict, const tr_torrent * tor )
64{
65    tr_pex * pex = NULL;
66    const int count = tr_peerMgrGetPeers( tor->handle->peerMgr,
67                                          tor->info.hash, &pex );
68    if( count > 0 )
69        tr_bencDictAddRaw( dict, KEY_PEERS, pex, sizeof(tr_pex)*count );
70    tr_free( pex );
71}
72
73static uint64_t
74loadPeers( tr_benc * dict, tr_torrent * tor )
75{
76    uint64_t ret = 0;
77    tr_benc * p;
78
79    if(( p = tr_bencDictFindType( dict, KEY_PEERS, TYPE_STR )))
80    {
81        int i;
82        const char * str = p->val.s.s;
83        const size_t len = p->val.s.i;
84        const int count = len / sizeof( tr_pex );
85        for( i=0; i<count; ++i ) {
86            tr_pex pex;
87            memcpy( &pex, str + (i*sizeof(tr_pex)), sizeof(tr_pex) );
88            tr_peerMgrAddPex( tor->handle->peerMgr,
89                              tor->info.hash, TR_PEER_FROM_CACHE, &pex );
90        }
91        tr_tordbg( tor, "Loaded %d peers from resume file", count );
92        ret = TR_FR_PEERS;
93    }
94
95    return ret;
96}
97
98/***
99****
100***/
101
102static void
103saveDND( tr_benc * dict, const tr_torrent * tor )
104{
105    const tr_info * inf = tr_torrentInfo( tor );
106    const tr_file_index_t n = inf->fileCount;
107    tr_file_index_t i;
108    tr_benc * list;
109
110    list = tr_bencDictAddList( dict, KEY_DND, n );
111    for( i=0; i<n; ++i )
112        tr_bencListAddInt( list, inf->files[i].dnd ? 1 : 0 );
113}
114
115static uint64_t
116loadDND( tr_benc * dict, tr_torrent * tor )
117{
118    uint64_t ret = 0;
119    tr_info * inf = &tor->info;
120    const tr_file_index_t n = inf->fileCount;
121    tr_benc * list = NULL;
122
123    if( tr_bencDictFindList( dict, KEY_DND, &list )
124        && ( list->val.l.count == (int)n ) )
125    {
126        int64_t tmp;
127        tr_file_index_t * dl = tr_new( tr_file_index_t, n );
128        tr_file_index_t * dnd = tr_new( tr_file_index_t, n );
129        tr_file_index_t i, dlCount=0, dndCount=0;
130
131        for( i=0; i<n; ++i ) {
132            if( tr_bencGetInt( &list->val.l.vals[i], &tmp ) && tmp )
133                dnd[dndCount++] = i;
134            else
135                dl[dlCount++] = i;
136        }
137
138        if( dndCount ) {
139            tr_torrentInitFileDLs ( tor, dnd, dndCount, FALSE );
140            tr_tordbg( tor, "Resume file found %d files listed as dnd", dndCount );
141        }
142        if( dlCount ) {
143            tr_torrentInitFileDLs ( tor, dl, dlCount, TRUE );
144            tr_tordbg( tor, "Resume file found %d files marked for download", dlCount );
145        }
146
147        tr_free( dnd );
148        tr_free( dl );
149        ret = TR_FR_PRIORITY;
150    }
151    else
152    {
153        tr_tordbg( tor, "Couldn't load DND flags.  dnd list (%p) has %d children; torrent has %d files",
154                   list, ( list ? list->val.l.count : -1 ), (int)n );
155    }
156
157    return ret;
158}
159
160/***
161****
162***/
163
164static void
165savePriorities( tr_benc * dict, 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_PRIORITY, n );
173    for( i=0; i<n; ++i )
174        tr_bencListAddInt( list, inf->files[i].priority );
175}
176
177static uint64_t
178loadPriorities( tr_benc * dict, tr_torrent * tor )
179{
180    uint64_t ret = 0;
181    tr_info * inf = &tor->info;
182    const tr_file_index_t n = inf->fileCount;
183    tr_benc * list;
184
185    if( tr_bencDictFindList( dict, KEY_PRIORITY, &list )
186        && ( list->val.l.count == (int)n ) )
187    {
188        int64_t tmp;
189        tr_file_index_t i;
190        for( i=0; i<n; ++i )
191            if( tr_bencGetInt( &list->val.l.vals[i], &tmp ) )
192                inf->files[i].priority = tmp;
193        ret = TR_FR_PRIORITY;
194    }
195
196    return ret;
197}
198
199/***
200****
201***/
202
203static void
204saveSpeedLimits( tr_benc * dict, const tr_torrent * tor )
205{
206    tr_benc * d = tr_bencDictAddDict( dict, KEY_SPEEDLIMIT, 4 );
207    tr_bencDictAddInt( d, KEY_SPEEDLIMIT_DOWN_SPEED,
208                       tr_torrentGetSpeedLimit( tor, TR_DOWN ) );
209    tr_bencDictAddInt( d, KEY_SPEEDLIMIT_DOWN_MODE,
210                       tr_torrentGetSpeedMode( tor, TR_DOWN ) );
211    tr_bencDictAddInt( d, KEY_SPEEDLIMIT_UP_SPEED,
212                       tr_torrentGetSpeedLimit( tor, TR_UP ) );
213    tr_bencDictAddInt( d, KEY_SPEEDLIMIT_UP_MODE,
214                       tr_torrentGetSpeedMode( tor, TR_UP ) );
215}
216
217static uint64_t
218loadSpeedLimits( tr_benc * dict, tr_torrent * tor )
219{
220    uint64_t ret = 0;
221    tr_benc * d;
222
223    if( tr_bencDictFindDict( dict, KEY_SPEEDLIMIT, &d ) )
224    {
225        int64_t i;
226        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_SPEED, &i ) )
227            tr_torrentSetSpeedLimit( tor, TR_DOWN, i );
228        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_MODE, &i ) )
229            tr_torrentSetSpeedMode( tor, TR_DOWN, i );
230        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_SPEED, &i ) )
231            tr_torrentSetSpeedLimit( tor, TR_UP, i );
232        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_MODE, &i ) )
233            tr_torrentSetSpeedMode( tor, TR_UP, i );
234        ret = TR_FR_SPEEDLIMIT;
235    }
236
237    return ret;
238}
239
240/***
241****
242***/
243
244static void
245saveProgress( tr_benc * dict, const tr_torrent * tor )
246{
247    int i;
248    int n;
249    time_t * mtimes;
250    tr_benc * p;
251    tr_benc * m;
252    const tr_bitfield * bitfield;
253
254    p = tr_bencDictAdd( dict, KEY_PROGRESS );
255    tr_bencInitDict( p, 2 );
256
257    /* add the mtimes */
258    mtimes = tr_torrentGetMTimes( tor, &n );
259    m = tr_bencDictAddList( p, KEY_PROGRESS_MTIMES, n );
260    for( i=0; i<n; ++i ) {
261        if( !tr_torrentIsFileChecked( tor, i ) )
262            mtimes[i] = ~(time_t)0; /* force a recheck */
263        tr_bencListAddInt( m, mtimes[i] );
264    }
265
266    /* add the bitfield */
267    bitfield = tr_cpBlockBitfield( tor->completion );
268    tr_bencDictAddRaw( p, KEY_PROGRESS_BITFIELD,
269                       bitfield->bits, bitfield->len );
270
271    /* cleanup */
272    tr_free( mtimes );
273}
274
275static uint64_t
276loadProgress( tr_benc * dict, tr_torrent * tor )
277{
278    uint64_t ret = 0;
279    tr_benc * p;
280
281    if( tr_bencDictFindDict( dict, KEY_PROGRESS, &p ) )
282    {
283        tr_benc * m;
284        tr_benc * b;
285        int n;
286        time_t * curMTimes = tr_torrentGetMTimes( tor, &n );
287
288        if( tr_bencDictFindList( p, KEY_PROGRESS_MTIMES, &m )
289            && ( m->val.l.count == (int64_t)tor->info.fileCount )
290            && ( m->val.l.count == n ) )
291        {
292            int i;
293            for( i=0; i<n; ++i )
294            {
295                int64_t tmp;
296                if( !tr_bencGetInt( &m->val.l.vals[i], &tmp ) ) {
297                    tr_tordbg( tor, "File #%d needs to be verified - couldn't find benc entry", i );
298                    tr_torrentSetFileChecked( tor, i, FALSE );
299                } else {
300                    const time_t t = (time_t) tmp;
301                    if( t == curMTimes[i] )
302                        tr_torrentSetFileChecked( tor, i, TRUE );
303                    else {
304                        tr_tordbg( tor, "File #%d needs to be verified - times %lu and %lu don't match", i, t, curMTimes[i] );
305                        tr_torrentSetFileChecked( tor, i, FALSE );
306                    }
307                }
308            }
309        }
310        else
311        {
312            tr_torrentUncheck( tor );
313            tr_tordbg( tor, "Torrent needs to be verified - unable to find mtimes" );
314        }
315
316        if(( b = tr_bencDictFindType( p, KEY_PROGRESS_BITFIELD, TYPE_STR )))
317        {
318            tr_bitfield tmp;
319            tmp.len = b->val.s.i;
320            tmp.bits = (uint8_t*) b->val.s.s;
321            if( tr_cpBlockBitfieldSet( tor->completion, &tmp ) ) {
322                tr_torrentUncheck( tor );
323                tr_tordbg( tor, "Torrent needs to be verified - error loading bitfield" );
324            }
325        }
326        else
327        {
328            tr_torrentUncheck( tor );
329            tr_tordbg( tor, "Torrent needs to be verified - unable to find bitfield" );
330        }
331       
332        tr_free( curMTimes );
333        ret = TR_FR_PROGRESS;
334    }
335
336    return ret;
337}
338
339/***
340****
341***/
342
343void
344tr_torrentSaveResume( const tr_torrent * tor )
345{
346    tr_benc top;
347    char filename[MAX_PATH_LENGTH];
348
349    tr_bencInitDict( &top, 12 );
350    tr_bencDictAddInt( &top, KEY_CORRUPT,
351                             tor->corruptPrev + tor->corruptCur );
352    tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR,
353                             tor->downloadDir );
354    tr_bencDictAddInt( &top, KEY_DOWNLOADED,
355                             tor->downloadedPrev + tor->downloadedCur );
356    tr_bencDictAddInt( &top, KEY_UPLOADED,
357                             tor->uploadedPrev + tor->uploadedCur );
358    tr_bencDictAddInt( &top, KEY_MAX_PEERS,
359                             tor->maxConnectedPeers );
360    tr_bencDictAddInt( &top, KEY_PAUSED,
361                             tor->isRunning ? 0 : 1 );
362    savePeers( &top, tor );
363    savePriorities( &top, tor );
364    saveDND( &top, tor );
365    saveProgress( &top, tor );
366    saveSpeedLimits( &top, tor );
367
368    getResumeFilename( filename, sizeof( filename ), tor );
369    tr_bencSaveFile( filename, &top );
370
371    tr_bencFree( &top );
372}
373
374static uint64_t
375loadFromFile( tr_torrent    * tor,
376              uint64_t        fieldsToLoad )
377{
378    int64_t i;
379    const char * str;
380    uint64_t fieldsLoaded = 0;
381    char filename[MAX_PATH_LENGTH];
382    tr_benc top;
383
384    getResumeFilename( filename, sizeof( filename ), tor );
385
386    if( tr_bencLoadFile( filename, &top ) )
387    {
388        tr_tordbg( tor, "Couldn't read \"%s\"; trying old format.", filename );
389        fieldsLoaded = tr_fastResumeLoad( tor, fieldsToLoad );
390
391        if( ( fieldsLoaded != 0 ) && ( fieldsToLoad == ~(uint64_t)0 ) )
392        {
393            tr_torrentSaveResume( tor );
394            tr_fastResumeRemove( tor );
395            tr_tordbg( tor, "Migrated resume file to \"%s\"", filename );
396        }
397
398        return fieldsLoaded;
399    }
400
401    tr_tordbg( tor, "Read resume file \"%s\"", filename );
402
403    if( ( fieldsToLoad & TR_FR_CORRUPT )
404            && tr_bencDictFindInt( &top, KEY_CORRUPT, &i ) ) {
405        tor->corruptPrev = i;
406        fieldsLoaded |= TR_FR_CORRUPT;
407    }
408
409    if( ( fieldsToLoad & ( TR_FR_PROGRESS | TR_FR_DOWNLOAD_DIR ) )
410            && tr_bencDictFindStr( &top, KEY_DOWNLOAD_DIR, &str ) ) {
411        tr_free( tor->downloadDir );
412        tor->downloadDir = tr_strdup( str );
413        fieldsLoaded |= TR_FR_DOWNLOAD_DIR;
414    }
415
416    if( ( fieldsToLoad & TR_FR_DOWNLOADED )
417            && tr_bencDictFindInt( &top, KEY_DOWNLOADED, &i ) ) {
418        tor->downloadedPrev = i;
419        fieldsLoaded |= TR_FR_DOWNLOADED;
420    }
421
422    if( ( fieldsToLoad & TR_FR_UPLOADED )
423            && tr_bencDictFindInt( &top, KEY_UPLOADED, &i ) ) {
424        tor->uploadedPrev = i;
425        fieldsLoaded |= TR_FR_UPLOADED;
426    }
427
428    if( ( fieldsToLoad & TR_FR_MAX_PEERS )
429            && tr_bencDictFindInt( &top, KEY_MAX_PEERS, &i ) ) {
430        tor->maxConnectedPeers = i;
431        fieldsLoaded |= TR_FR_MAX_PEERS;
432    }
433
434    if( ( fieldsToLoad & TR_FR_RUN )
435            && tr_bencDictFindInt( &top, KEY_PAUSED, &i ) ) {
436        tor->isRunning = i ? 0 : 1;
437        fieldsLoaded |= TR_FR_RUN;
438    }
439
440    if( fieldsToLoad & TR_FR_PEERS )
441        fieldsLoaded |= loadPeers( &top, tor );
442
443    if( fieldsToLoad & TR_FR_PRIORITY )
444        fieldsLoaded |= loadPriorities( &top, tor );
445
446    if( fieldsToLoad & TR_FR_PROGRESS )
447        fieldsLoaded |= loadProgress( &top, tor );
448
449    if( fieldsToLoad & TR_FR_DND )
450        fieldsLoaded |= loadDND( &top, tor );
451
452    if( fieldsToLoad & TR_FR_SPEEDLIMIT )
453        fieldsLoaded |= loadSpeedLimits( &top, tor );
454
455    tr_bencFree( &top );
456    return fieldsLoaded;
457}
458
459static uint64_t
460setFromCtor( tr_torrent * tor, uint64_t fields, const tr_ctor * ctor, int mode )
461{
462    uint64_t ret = 0;
463
464    if( fields & TR_FR_RUN ) {
465        uint8_t isPaused;
466        if( !tr_ctorGetPaused( ctor, mode, &isPaused ) ) {
467            tor->isRunning = !isPaused;
468            ret |= TR_FR_RUN;
469        }
470    }
471
472    if( fields & TR_FR_MAX_PEERS ) 
473        if( !tr_ctorGetPeerLimit( ctor, mode, &tor->maxConnectedPeers ) )
474            ret |= TR_FR_MAX_PEERS;
475
476    if( fields & TR_FR_DOWNLOAD_DIR ) {
477        const char * downloadDir;
478        if( !tr_ctorGetDownloadDir( ctor, mode, &downloadDir ) ) {
479            ret |= TR_FR_DOWNLOAD_DIR;
480            tr_free( tor->downloadDir );
481            tor->downloadDir = tr_strdup( downloadDir );
482        }
483    }
484
485    return ret;
486}
487
488static uint64_t
489useManditoryFields( tr_torrent * tor, uint64_t fields, const tr_ctor * ctor )
490{
491    return setFromCtor( tor, fields, ctor, TR_FORCE );
492}
493
494static uint64_t
495useFallbackFields( tr_torrent * tor, uint64_t fields, const tr_ctor * ctor )
496{
497    return setFromCtor( tor, fields, ctor, TR_FALLBACK );
498}
499
500uint64_t
501tr_torrentLoadResume( tr_torrent    * tor,
502                      uint64_t        fieldsToLoad,
503                      const tr_ctor * ctor )
504{
505    uint64_t ret = 0;
506
507    ret |= useManditoryFields( tor, fieldsToLoad, ctor );
508    fieldsToLoad &= ~ret;
509    ret |= loadFromFile( tor, fieldsToLoad );
510    fieldsToLoad &= ~ret;
511    ret |= useFallbackFields( tor, fieldsToLoad, ctor );
512
513    return ret;
514}
515
516void
517tr_torrentRemoveResume( const tr_torrent * tor )
518{
519    char filename[MAX_PATH_LENGTH];
520    getResumeFilename( filename, sizeof( filename ), tor );
521    unlink( filename );
522    tr_fastResumeRemove( tor );
523}
Note: See TracBrowser for help on using the repository browser.