source: trunk/libtransmission/metainfo.c @ 405

Last change on this file since 405 was 405, checked in by titer, 16 years ago

Don't assume that a download is a folder if there only is one
file (fixes #36)

  • Property svn:keywords set to Date Rev Author Id
File size: 10.2 KB
Line 
1/******************************************************************************
2 * $Id: metainfo.c 405 2006-06-20 02:34:34Z titer $
3 *
4 * Copyright (c) 2005-2006 Transmission authors and contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *****************************************************************************/
24
25#include "transmission.h"
26
27/***********************************************************************
28 * Local prototypes
29 **********************************************************************/
30static void strcatUTF8( char *, char * );
31
32/***********************************************************************
33 * tr_metainfoParse
34 ***********************************************************************
35 *
36 **********************************************************************/
37int tr_metainfoParse( tr_info_t * inf, const char * path,
38                      const char * savedHash, int saveCopy )
39{
40    FILE       * file;
41    char       * buf;
42    benc_val_t   meta, * beInfo, * list, * val;
43    char * s, * s2, * s3;
44    int          i;
45    struct stat sb;
46
47    assert( NULL == path || NULL == savedHash );
48    /* if savedHash isn't null, saveCopy should be false */
49    assert( NULL == savedHash || !saveCopy );
50
51    if ( NULL != savedHash )
52    {
53        snprintf( inf->torrent, MAX_PATH_LENGTH, "%s/%s",
54                  tr_getTorrentsDirectory(), savedHash );
55        path = inf->torrent;
56    }
57
58    if( stat( path, &sb ) )
59    {
60        fprintf( stderr, "Could not stat file (%s)\n", path );
61        return 1;
62    }
63    if( ( sb.st_mode & S_IFMT ) != S_IFREG )
64    {
65        fprintf( stderr, "Not a regular file (%s)\n", path );
66        return 1;
67    }
68    if( sb.st_size > 2097152 )
69    {
70        tr_err( "Torrent file is too big (%d bytes)", sb.st_size );
71        return 1;
72    }
73
74    /* Load the torrent file into our buffer */
75    file = fopen( path, "rb" );
76    if( !file )
77    {
78        fprintf( stderr, "Could not open file (%s)\n", path );
79        return 1;
80    }
81    buf = malloc( sb.st_size );
82    fseek( file, 0, SEEK_SET );
83    if( fread( buf, sb.st_size, 1, file ) != 1 )
84    {
85        fprintf( stderr, "Read error (%s)\n", path );
86        free( buf );
87        fclose( file );
88        return 1;
89    }
90    fclose( file );
91
92    /* Parse bencoded infos */
93    if( tr_bencLoad( buf, sb.st_size, &meta, NULL ) )
94    {
95        fprintf( stderr, "Error while parsing bencoded data\n" );
96        free( buf );
97        return 1;
98    }
99
100    /* Get info hash */
101    if( !( beInfo = tr_bencDictFind( &meta, "info" ) ) )
102    {
103        fprintf( stderr, "Could not find \"info\" dictionary\n" );
104        tr_bencFree( &meta );
105        free( buf );
106        return 1;
107    }
108    SHA1( (uint8_t *) beInfo->begin,
109          (long) beInfo->end - (long) beInfo->begin, inf->hash );
110    for( i = 0; i < SHA_DIGEST_LENGTH; i++ )
111    {
112        sprintf( inf->hashString + i * 2, "%02x", inf->hash[i] );
113    }
114
115    if( saveCopy )
116    {
117        /* Save a copy of the torrent file in the private torrent directory */
118        snprintf( inf->torrent, MAX_PATH_LENGTH, "%s/%s",
119                  tr_getTorrentsDirectory(), inf->hashString );
120        file = fopen( inf->torrent, "wb" );
121        if( !file )
122        {
123            fprintf( stderr, "Could not open file (%s) (%s)\n", inf->torrent, strerror(errno) );
124            tr_bencFree( &meta );
125            free( buf );
126            return 1;
127        }
128        fseek( file, 0, SEEK_SET );
129        if( fwrite( buf, sb.st_size, 1, file ) != 1 )
130        {
131            fprintf( stderr, "Write error (%s)\n", inf->torrent );
132            tr_bencFree( &meta );
133            free( buf );
134            fclose( file );
135            return 1;
136        }
137        fclose( file );
138    }
139    else
140    {
141        snprintf( inf->torrent, MAX_PATH_LENGTH, "%s", path );
142    }
143
144    /* We won't need this anymore */
145    free( buf );
146
147    if( !( val = tr_bencDictFind( &meta, "announce" ) ) )
148    {
149        fprintf( stderr, "No \"announce\" entry\n" );
150        tr_bencFree( &meta );
151        return 1;
152    }
153   
154    /* Skip spaces */
155    s3 = val->val.s.s;
156    while( *s3 && *s3 == ' ' )
157    {
158        s3++;
159    }
160
161    /* Parse announce URL */
162    if( strncmp( s3, "http://", 7 ) )
163    {
164        fprintf( stderr, "Invalid announce URL (%s)\n",
165                 inf->trackerAddress );
166        tr_bencFree( &meta );
167        return 1;
168    }
169    s  = strchr( s3 + 7, ':' );
170    s2 = strchr( s3 + 7, '/' );
171    if( s && s < s2 )
172    {
173        memcpy( inf->trackerAddress, s3 + 7,
174                (long) s - (long) s3 - 7 );
175        inf->trackerPort = atoi( s + 1 );
176    }
177    else if( s2 )
178    {
179        memcpy( inf->trackerAddress, s3 + 7,
180                (long) s2 - (long) s3 - 7 );
181        inf->trackerPort = 80;
182    }
183    else
184    {
185        fprintf( stderr, "Invalid announce URL (%s)\n",
186                 inf->trackerAddress );
187        tr_bencFree( &meta );
188        return 1;
189    }
190    snprintf( inf->trackerAnnounce, MAX_PATH_LENGTH, "%s", s2 );
191
192    /* Piece length */
193    if( !( val = tr_bencDictFind( beInfo, "piece length" ) ) )
194    {
195        fprintf( stderr, "No \"piece length\" entry\n" );
196        tr_bencFree( &meta );
197        return 1;
198    }
199    inf->pieceSize = val->val.i;
200
201    /* Hashes */
202    val = tr_bencDictFind( beInfo, "pieces" );
203    if( val->val.s.i % SHA_DIGEST_LENGTH )
204    {
205        fprintf( stderr, "Invalid \"piece\" string (size is %d)\n",
206                 val->val.s.i );
207        return 1;
208    }
209    inf->pieceCount = val->val.s.i / SHA_DIGEST_LENGTH;
210    inf->pieces = (uint8_t *) val->val.s.s; /* Ugly, but avoids a memcpy */
211    val->val.s.s = NULL;
212
213    /* TODO add more tests so we don't crash on weird files */
214
215    inf->totalSize = 0;
216    if( ( list = tr_bencDictFind( beInfo, "files" ) ) )
217    {
218        /* Multi-file mode */
219        int j;
220
221        val = tr_bencDictFind( beInfo, "name" );
222        strcatUTF8( inf->name, val->val.s.s );
223
224        inf->multifile = 1;
225        inf->fileCount = list->val.l.count;
226        inf->files     = calloc( inf->fileCount * sizeof( tr_file_t ), 1 );
227
228        for( i = 0; i < list->val.l.count; i++ )
229        {
230            val = tr_bencDictFind( &list->val.l.vals[i], "path" );
231            strcatUTF8( inf->files[i].name, inf->name );
232            for( j = 0; j < val->val.l.count; j++ )
233            {
234                strcatUTF8( inf->files[i].name, "/" );
235                strcatUTF8( inf->files[i].name,
236                            val->val.l.vals[j].val.s.s );
237            }
238            val = tr_bencDictFind( &list->val.l.vals[i], "length" );
239            inf->files[i].length  = val->val.i;
240            inf->totalSize       += val->val.i;
241        }
242
243    }
244    else
245    {
246        /* Single-file mode */
247        inf->multifile = 0;
248        inf->fileCount = 1;
249        inf->files     = calloc( sizeof( tr_file_t ), 1 );
250
251        val = tr_bencDictFind( beInfo, "name" );
252        strcatUTF8( inf->files[0].name, val->val.s.s );
253        strcatUTF8( inf->name, val->val.s.s );
254       
255        val = tr_bencDictFind( beInfo, "length" );
256        inf->files[0].length  = val->val.i;
257        inf->totalSize       += val->val.i;
258    }
259
260    if( (uint64_t) inf->pieceCount !=
261        ( inf->totalSize + inf->pieceSize - 1 ) / inf->pieceSize )
262    {
263        fprintf( stderr, "Size of hashes and files don't match\n" );
264        tr_bencFree( &meta );
265        return 1;
266    }
267
268    tr_bencFree( &meta );
269    return 0;
270}
271
272void tr_metainfoRemoveSaved( const char * hashString )
273{
274    char file[MAX_PATH_LENGTH];
275
276    snprintf( file, MAX_PATH_LENGTH, "%s/%s",
277              tr_getTorrentsDirectory(), hashString );
278    unlink(file);
279}
280
281/***********************************************************************
282 * strcatUTF8
283 ***********************************************************************
284 * According to the official specification, all strings in the torrent
285 * file are supposed to be UTF-8 encoded. However, there are
286 * non-compliant torrents around... If we encounter an invalid UTF-8
287 * character, we assume it is ISO 8859-1 and convert it to UTF-8.
288 **********************************************************************/
289static void strcatUTF8( char * s, char * append )
290{
291    char * p;
292
293    /* Go to the end of the destination string */
294    while( s[0] )
295    {
296        s++;
297    }
298
299    /* Now start appending, converting on the fly if necessary */
300    for( p = append; p[0]; )
301    {
302        if( !( p[0] & 0x80 ) )
303        {
304            /* ASCII character */
305            *(s++) = *(p++);
306            continue;
307        }
308
309        if( ( p[0] & 0xE0 ) == 0xC0 && ( p[1] & 0xC0 ) == 0x80 )
310        {
311            /* 2-bytes UTF-8 character */
312            *(s++) = *(p++); *(s++) = *(p++);
313            continue;
314        }
315
316        if( ( p[0] & 0xF0 ) == 0xE0 && ( p[1] & 0xC0 ) == 0x80 &&
317            ( p[2] & 0xC0 ) == 0x80 )
318        {
319            /* 3-bytes UTF-8 character */
320            *(s++) = *(p++); *(s++) = *(p++);
321            *(s++) = *(p++);
322            continue;
323        }
324
325        if( ( p[0] & 0xF8 ) == 0xF0 && ( p[1] & 0xC0 ) == 0x80 &&
326            ( p[2] & 0xC0 ) == 0x80 && ( p[3] & 0xC0 ) == 0x80 )
327        {
328            /* 4-bytes UTF-8 character */
329            *(s++) = *(p++); *(s++) = *(p++);
330            *(s++) = *(p++); *(s++) = *(p++);
331            continue;
332        }
333
334        /* ISO 8859-1 -> UTF-8 conversion */
335        *(s++) = 0xC0 | ( ( *p & 0xFF ) >> 6 );
336        *(s++) = 0x80 | ( *(p++) & 0x3F );
337    }
338}
Note: See TracBrowser for help on using the repository browser.