source: trunk/libtransmission/resume.c @ 5994

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

#981: add tr_stat.dateAdded to libT; add "sort by age" to gtk+ client

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