source: trunk/libtransmission/torrent-ctor.c @ 6612

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

bencode cleanup: remove unused functions and unnecessary #includes

  • Property svn:keywords set to Date Rev Author Id
File size: 6.7 KB
Line 
1/*
2 * This file Copyright (C) 2007-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: torrent-ctor.c 6612 2008-08-21 14:57:59Z charles $
11 */
12
13#include <libgen.h> /* basename */
14#include "transmission.h"
15#include "bencode.h"
16#include "platform.h"
17#include "session.h" /* tr_sessionFindTorrentFile */
18#include "utils.h"
19
20#define DEFAULT_MAX_CONNECTED_PEERS 50
21
22struct optional_args
23{
24    unsigned int isSet_paused : 1;
25    unsigned int isSet_connected : 1;
26    unsigned int isSet_downloadDir : 1;
27
28    unsigned int isPaused : 1;
29    uint16_t peerLimit;
30    char downloadDir[MAX_PATH_LENGTH];
31};
32
33/** Opaque class used when instantiating torrents.
34  * @ingroup tr_ctor */
35struct tr_ctor
36{
37    const tr_handle * handle;
38    unsigned int saveInOurTorrentsDir : 1;
39    unsigned int doDelete : 1;
40
41    unsigned int isSet_metainfo : 1;
42    unsigned int isSet_delete : 1;
43    tr_benc metainfo;
44    char * sourceFile;
45
46    struct optional_args optionalArgs[2];
47};
48
49/***
50****
51***/
52
53static void
54setSourceFile( tr_ctor * ctor, const char * sourceFile )
55{
56    tr_free( ctor->sourceFile );
57    ctor->sourceFile = tr_strdup( sourceFile );
58}
59
60static void
61clearMetainfo( tr_ctor * ctor )
62{
63    if( ctor->isSet_metainfo ) {
64        ctor->isSet_metainfo = 0;
65        tr_bencFree( &ctor->metainfo );
66    }
67
68    setSourceFile( ctor, NULL );
69}
70
71int
72tr_ctorSetMetainfo( tr_ctor        * ctor,
73                    const uint8_t  * metainfo,
74                    size_t           len )
75{
76    int err;
77    clearMetainfo( ctor );
78    err = tr_bencLoad( metainfo, len, &ctor->metainfo, NULL );
79    ctor->isSet_metainfo = !err;
80    return err;
81}
82
83const char*
84tr_ctorGetSourceFile( const tr_ctor * ctor )
85{
86    return ctor->sourceFile;
87}
88
89int
90tr_ctorSetMetainfoFromFile( tr_ctor        * ctor,
91                            const char     * filename )
92{
93    uint8_t * metainfo;
94    size_t len;
95    int err;
96
97    metainfo = tr_loadFile( filename, &len );
98    if( metainfo && len )
99        err = tr_ctorSetMetainfo( ctor, metainfo, len );
100    else {
101        clearMetainfo( ctor );
102        err = 1;
103    }
104
105    setSourceFile( ctor, filename );
106
107    /* if no `name' field was set, then set it from the filename */
108    if( ctor->isSet_metainfo ) {
109        tr_benc * info;
110        if( tr_bencDictFindDict( &ctor->metainfo, "info", &info ) ) {
111            const char * name;
112            if( !tr_bencDictFindStr( info, "name.utf-8", &name ) )
113                if( !tr_bencDictFindStr( info, "name", &name ) )
114                    name = NULL;
115            if( !name || !*name ) {
116                char * tmp = tr_strdup( filename );
117                tr_bencDictAddStr( info, "name", basename( tmp ) );
118                tr_free( tmp );
119            }
120        }
121    }
122
123    tr_free( metainfo );
124    return err;
125}
126
127int
128tr_ctorSetMetainfoFromHash( tr_ctor        * ctor,
129                            const char     * hashString )
130{
131    int err;
132    const char * filename;
133
134    if(( filename = tr_sessionFindTorrentFile( ctor->handle, hashString )))
135        err = tr_ctorSetMetainfoFromFile( ctor, filename ); 
136    else
137        err = TR_ERROR;
138
139    return err;
140}
141
142/***
143****
144***/
145
146void
147tr_ctorSetDeleteSource( tr_ctor  * ctor,
148                        uint8_t    deleteSource )
149{
150    ctor->doDelete = deleteSource ? 1 : 0;
151    ctor->isSet_delete = 1;
152}
153
154int
155tr_ctorGetDeleteSource( const tr_ctor  * ctor,
156                        uint8_t        * setme )
157{
158    int err = 0;
159
160    if( !ctor->isSet_delete )
161        err = 1;
162    else if( setme )
163        *setme = ctor->doDelete ? 1 : 0;
164
165    return err;
166}
167
168/***
169****
170***/
171
172void
173tr_ctorSetSave( tr_ctor  * ctor,
174                int        saveInOurTorrentsDir )
175{
176    ctor->saveInOurTorrentsDir = saveInOurTorrentsDir ? 1 : 0;
177}
178
179int
180tr_ctorGetSave( const tr_ctor * ctor )
181{
182    return ctor && ctor->saveInOurTorrentsDir;
183}
184
185void
186tr_ctorSetPaused( tr_ctor        * ctor,
187                  tr_ctorMode      mode,
188                  uint8_t          isPaused )
189{
190    struct optional_args * args = &ctor->optionalArgs[mode];
191    args->isSet_paused = 1;
192    args->isPaused = isPaused ? 1 : 0;
193}
194
195void
196tr_ctorSetPeerLimit( tr_ctor        * ctor,
197                     tr_ctorMode      mode,
198                     uint16_t         peerLimit )
199{
200    struct optional_args * args = &ctor->optionalArgs[mode];
201    args->isSet_connected = 1;
202    args->peerLimit = peerLimit;
203}
204
205void
206tr_ctorSetDownloadDir( tr_ctor        * ctor,
207                       tr_ctorMode      mode,
208                       const char     * directory )
209{
210    struct optional_args * args = &ctor->optionalArgs[mode];
211    if( directory ) {
212        args->isSet_downloadDir = 1;
213        tr_strlcpy( args->downloadDir, directory, sizeof( args->downloadDir ) );
214    } else {
215        args->isSet_downloadDir = 0;
216        *args->downloadDir = '\0';
217    }
218}
219
220int
221tr_ctorGetPeerLimit( const tr_ctor  * ctor,
222                     tr_ctorMode      mode,
223                     uint16_t       * setmeCount )
224{
225    int err = 0;
226    const struct optional_args * args = &ctor->optionalArgs[mode];
227
228    if( !args->isSet_connected )
229        err = 1;
230    else if( setmeCount )
231        *setmeCount = args->peerLimit;
232
233    return err;
234}
235
236int
237tr_ctorGetPaused( const tr_ctor  * ctor,
238                  tr_ctorMode      mode,
239                  uint8_t        * setmeIsPaused )
240{
241    int err = 0;
242    const struct optional_args * args = &ctor->optionalArgs[mode];
243
244    if( !args->isSet_paused )
245        err = 1;
246    else if( setmeIsPaused )
247        *setmeIsPaused = args->isPaused ? 1 : 0;
248
249    return err;
250}
251
252int
253tr_ctorGetDownloadDir( const tr_ctor  * ctor,
254                       tr_ctorMode      mode,
255                       const char    ** setmeDownloadDir )
256{
257    int err = 0;
258    const struct optional_args * args = &ctor->optionalArgs[mode];
259
260    if( !args->isSet_downloadDir )
261        err = 1;
262    else if( setmeDownloadDir )
263        *setmeDownloadDir = args->downloadDir;
264
265    return err;
266}
267
268int
269tr_ctorGetMetainfo( const tr_ctor    * ctor,
270                    const tr_benc   ** setme )
271{
272    int err = 0;
273
274    if( !ctor->isSet_metainfo )
275        err = 1;
276    else if( setme )
277        *setme = &ctor->metainfo;
278
279    return err;
280}
281
282/***
283****
284***/
285
286tr_ctor*
287tr_ctorNew( const tr_handle * handle )
288{
289    tr_ctor * ctor = tr_new0( struct tr_ctor, 1 );
290    ctor->handle = handle;
291    tr_ctorSetPeerLimit( ctor, TR_FALLBACK, DEFAULT_MAX_CONNECTED_PEERS );
292    tr_ctorSetPaused( ctor, TR_FALLBACK, FALSE );
293    tr_ctorSetDownloadDir( ctor, TR_FALLBACK, handle->downloadDir );
294    tr_ctorSetSave( ctor, TRUE );
295    return ctor;
296}
297
298void
299tr_ctorFree( tr_ctor * ctor )
300{
301    clearMetainfo( ctor );
302    tr_free( ctor );
303}
Note: See TracBrowser for help on using the repository browser.