transmission 0.1.0

data/ext/inout.h

@@ -0,0 +1,38 @@
+/******************************************************************************
+ * $Id: inout.h 346 2006-06-13 00:28:03Z titer $
+ *
+ * Copyright (c) 2005-2006 Transmission authors and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *****************************************************************************/
+
+#ifndef TR_IO_H
+#define TR_IO_H 1
+
+typedef struct tr_io_s tr_io_t;
+
+void      tr_ioLoadResume  ( tr_torrent_t * );
+
+tr_io_t * tr_ioInit        ( tr_torrent_t * );
+int       tr_ioRead        ( tr_io_t *, int, int, int, uint8_t * );
+int       tr_ioWrite       ( tr_io_t *, int, int, int, uint8_t * );
+void      tr_ioClose       ( tr_io_t * );
+void      tr_ioSaveResume  ( tr_io_t * );
+
+#endif

data/ext/internal.h

@@ -0,0 +1,202 @@
+/******************************************************************************
+ * $Id: internal.h 310 2006-06-09 19:53:35Z joshe $
+ *
+ * Copyright (c) 2005-2006 Transmission authors and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *****************************************************************************/
+
+#ifndef TR_INTERNAL_H
+#define TR_INTERNAL_H 1
+
+/* Standard headers used here and there.
+   That is probably ugly to put them all here, but it is sooo
+   convenient */
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/resource.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <fcntl.h>
+#include <assert.h>
+#ifdef BEOS_NETSERVER
+#  define in_port_t uint16_t
+#else
+#  include <arpa/inet.h>
+#endif
+
+#ifdef __GNUC__
+#  define UNUSED __attribute__((unused))
+#else
+#  define UNUSED
+#endif
+
+/* We use OpenSSL whenever possible, since it is likely to be more
+   optimized and it is ok to use it with a MIT-licensed application.
+   Otherwise, we use the included implementation by vi@nwr.jp. */
+#ifdef HAVE_OPENSSL
+#  undef SHA_DIGEST_LENGTH
+#  include <openssl/sha.h>
+#else
+#  include "sha1.h"
+#  define SHA1(p,i,h) \
+   { \
+     sha1_state_s pms; \
+     sha1_init( &pms ); \
+     sha1_update( &pms, (sha1_byte_t *) p, i ); \
+     sha1_finish( &pms, (sha1_byte_t *) h ); \
+   }
+#endif
+
+/* Convenient macros to perform uint32_t endian conversions with
+   char pointers */
+#define TR_NTOHL(p,a) (a) = tr_ntohl((p))
+#define TR_HTONL(a,p) tr_htonl((a), (p))
+static inline uint32_t tr_ntohl( uint8_t * p )
+{
+	uint32_t u;
+	memcpy( &u, p, sizeof( uint32_t ) );
+	return ntohl( u );
+}
+static inline void tr_htonl( uint32_t a, uint8_t * p )
+{
+	uint32_t u;
+	u = htonl( a );
+	memcpy ( p, &u, sizeof( uint32_t ) );
+}
+
+/* Sometimes the system defines MAX/MIN, sometimes not. In the latter
+   case, define those here since we will use them */
+#ifndef MAX
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#endif
+#ifndef MIN
+#define MIN(a,b) ((a)>(b)?(b):(a))
+#endif
+
+#define TR_MAX_PEER_COUNT 60
+
+typedef struct tr_completion_s tr_completion_t;
+
+#include "platform.h"
+#include "bencode.h"
+#include "metainfo.h"
+#include "tracker.h"
+#include "fdlimit.h"
+#include "peer.h"
+#include "net.h"
+#include "inout.h"
+#include "ratecontrol.h"
+#include "clients.h"
+#include "choking.h"
+
+struct tr_torrent_s
+{
+    tr_info_t info;
+
+    tr_ratecontrol_t * globalUpload;
+    tr_ratecontrol_t * globalDownload;
+    tr_ratecontrol_t * upload;
+    tr_ratecontrol_t * download;
+    tr_fd_t          * fdlimit;
+
+    int               status;
+    int               error;
+    char              trackerError[128];
+    int               finished;
+
+    char            * id;
+    char            * key;
+    int             * bindPort;
+
+    /* An escaped string used to include the hash in HTTP queries */
+    char              hashString[3*SHA_DIGEST_LENGTH+1];
+
+    char              scrape[MAX_PATH_LENGTH];
+
+    /* Where to download */
+    char            * destination;
+    
+    /* How many bytes we ask for per request */
+    int               blockSize;
+    int               blockCount;
+    
+    tr_completion_t * completion;
+
+    volatile char     die;
+    tr_thread_t       thread;
+    tr_lock_t         lock;
+
+    tr_tracker_t    * tracker;
+    tr_io_t         * io;
+    uint64_t          stopDate;
+
+    int               peerCount;
+    tr_peer_t       * peers[TR_MAX_PEER_COUNT];
+
+    uint64_t          date;
+    uint64_t          downloaded;
+    uint64_t          uploaded;
+
+    tr_stat_t         stats[2];
+    int               statCur;
+
+    tr_torrent_t    * prev;
+    tr_torrent_t    * next;
+};
+
+#include "utils.h"
+#include "completion.h"
+
+struct tr_handle_s
+{
+    int            torrentCount;
+    tr_torrent_t * torrentList;
+
+    tr_ratecontrol_t * upload;
+    tr_ratecontrol_t * download;
+    tr_fd_t      * fdlimit;
+    tr_choking_t * choking;
+
+    int            bindPort;
+    int            bindSocket;
+
+    int            acceptPeerCount;
+    tr_peer_t    * acceptPeers[TR_MAX_PEER_COUNT];
+
+    char           id[21];
+    char           key[21];
+
+    volatile char  acceptDie;
+    tr_thread_t    acceptThread;
+    tr_lock_t      acceptLock;
+};
+
+#endif

data/ext/metainfo.c

@@ -0,0 +1,339 @@
+/******************************************************************************
+ * $Id: metainfo.c 405 2006-06-20 02:34:34Z titer $
+ *
+ * Copyright (c) 2005-2006 Transmission authors and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *****************************************************************************/
+
+#include "transmission.h"
+
+/***********************************************************************
+ * Local prototypes
+ **********************************************************************/
+static void strcatUTF8( char *, char * );
+
+/***********************************************************************
+ * tr_metainfoParse
+ ***********************************************************************
+ *
+ **********************************************************************/
+int tr_metainfoParse( tr_info_t * inf, const char * path,
+                      const char * savedHash, int saveCopy )
+{
+    FILE       * file;
+    char       * buf;
+    benc_val_t   meta, * beInfo, * list, * val;
+    char * s, * s2, * s3;
+    int          i;
+    struct stat sb;
+
+    assert( NULL == path || NULL == savedHash );
+    /* if savedHash isn't null, saveCopy should be false */
+    assert( NULL == savedHash || !saveCopy );
+
+    if ( NULL != savedHash )
+    {
+        snprintf( inf->torrent, MAX_PATH_LENGTH, "%s/%s",
+                  tr_getTorrentsDirectory(), savedHash );
+        path = inf->torrent;
+    }
+
+    if( stat( path, &sb ) )
+    {
+/*        fprintf( stderr, "Could not stat file (%s)\n", path );*/
+        return TR_PARSE_STAT;
+    }
+    if( ( sb.st_mode & S_IFMT ) != S_IFREG )
+    {
+/*        fprintf( stderr, "Not a regular file (%s)\n", path );*/
+        return TR_PARSE_FILE_TYPE;
+    }
+    if( sb.st_size > 2097152 )
+    {
+/*        tr_err( "Torrent file is too big (%d bytes)", sb.st_size );*/
+        return TR_PARSE_TOO_BIG;
+    }
+
+    /* Load the torrent file into our buffer */
+    file = fopen( path, "rb" );
+    if( !file )
+    {
+/*        fprintf( stderr, "Could not open file (%s)\n", path );*/
+        return TR_PARSE_FILE;
+    }
+    buf = malloc( sb.st_size );
+    fseek( file, 0, SEEK_SET );
+    if( fread( buf, sb.st_size, 1, file ) != 1 )
+    {
+/*        fprintf( stderr, "Read error (%s)\n", path );*/
+        free( buf );
+        fclose( file );
+        return TR_PARSE_READ;
+    }
+    fclose( file );
+
+    /* Parse bencoded infos */
+    if( tr_bencLoad( buf, sb.st_size, &meta, NULL ) )
+    {
+/*        fprintf( stderr, "Error while parsing bencoded data\n" );*/
+        free( buf );
+        return TR_PARSE_BENCODE;
+    }
+
+    /* Get info hash */
+    if( !( beInfo = tr_bencDictFind( &meta, "info" ) ) )
+    {
+/*        fprintf( stderr, "Could not find \"info\" dictionary\n" );*/
+        tr_bencFree( &meta );
+        free( buf );
+        return TR_PARSE_INFO_DIR;
+    }
+    SHA1( (uint8_t *) beInfo->begin,
+          (long) beInfo->end - (long) beInfo->begin, inf->hash );
+    for( i = 0; i < SHA_DIGEST_LENGTH; i++ )
+    {
+        sprintf( inf->hashString + i * 2, "%02x", inf->hash[i] );
+    }
+
+    if( saveCopy )
+    {
+        /* Save a copy of the torrent file in the private torrent directory */
+        snprintf( inf->torrent, MAX_PATH_LENGTH, "%s/%s",
+                  tr_getTorrentsDirectory(), inf->hashString );
+        file = fopen( inf->torrent, "wb" );
+        if( !file )
+        {
+/*            fprintf( stderr, "Could not open file (%s) (%s)\n", inf->torrent, strerror(errno) );*/
+            tr_bencFree( &meta );
+            free( buf );
+            return TR_PARSE_FILE;
+        }
+        fseek( file, 0, SEEK_SET );
+        if( fwrite( buf, sb.st_size, 1, file ) != 1 )
+        {
+/*            fprintf( stderr, "Write error (%s)\n", inf->torrent );*/
+            tr_bencFree( &meta );
+            free( buf );
+            fclose( file );
+            return TR_PARSE_WRITE;
+        }
+        fclose( file );
+    }
+    else
+    {
+        snprintf( inf->torrent, MAX_PATH_LENGTH, "%s", path );
+    }
+
+    /* We won't need this anymore */
+    free( buf );
+
+    if( !( val = tr_bencDictFind( &meta, "announce" ) ) )
+    {
+/*        fprintf( stderr, "No \"announce\" entry\n" );*/
+        tr_bencFree( &meta );
+        return TR_PARSE_ANN;
+    }
+    
+    /* Skip spaces */
+    s3 = val->val.s.s;
+    while( *s3 && *s3 == ' ' )
+    {
+        s3++;
+    }
+
+    /* Parse announce URL */
+    if( strncmp( s3, "http://", 7 ) )
+    {
+/*        fprintf( stderr, "Invalid announce URL (%s)\n",
+                 inf->trackerAddress );
+*/                 
+        tr_bencFree( &meta );
+        return TR_PARSE_ANN_URL;
+    }
+    s  = strchr( s3 + 7, ':' );
+    s2 = strchr( s3 + 7, '/' );
+    if( s && s < s2 )
+    {
+        memcpy( inf->trackerAddress, s3 + 7,
+                (long) s - (long) s3 - 7 );
+        inf->trackerPort = atoi( s + 1 );
+    }
+    else if( s2 )
+    {
+        memcpy( inf->trackerAddress, s3 + 7,
+                (long) s2 - (long) s3 - 7 );
+        inf->trackerPort = 80;
+    }
+    else
+    {
+/*        fprintf( stderr, "Invalid announce URL (%s)\n",
+                 inf->trackerAddress );*/
+        tr_bencFree( &meta );
+        return TR_PARSE_ANN_URL;
+    }
+    snprintf( inf->trackerAnnounce, MAX_PATH_LENGTH, "%s", s2 );
+
+    /* Piece length */
+    if( !( val = tr_bencDictFind( beInfo, "piece length" ) ) )
+    {
+/*        fprintf( stderr, "No \"piece length\" entry\n" );*/
+        tr_bencFree( &meta );
+        return TR_PARSE_PIECE;
+    }
+    inf->pieceSize = val->val.i;
+
+    /* Hashes */
+    val = tr_bencDictFind( beInfo, "pieces" );
+    if( val->val.s.i % SHA_DIGEST_LENGTH )
+    {
+/*        fprintf( stderr, "Invalid \"piece\" string (size is %d)\n",*/
+/*                 val->val.s.i );*/
+        return TR_PARSE_PIECE;
+    }
+    inf->pieceCount = val->val.s.i / SHA_DIGEST_LENGTH;
+    inf->pieces = (uint8_t *) val->val.s.s; /* Ugly, but avoids a memcpy */
+    val->val.s.s = NULL;
+
+    /* TODO add more tests so we don't crash on weird files */
+
+    inf->totalSize = 0;
+    if( ( list = tr_bencDictFind( beInfo, "files" ) ) )
+    {
+        /* Multi-file mode */
+        int j;
+
+        val = tr_bencDictFind( beInfo, "name" );
+        strcatUTF8( inf->name, val->val.s.s );
+
+        inf->multifile = 1;
+        inf->fileCount = list->val.l.count;
+        inf->files     = calloc( inf->fileCount * sizeof( tr_file_t ), 1 );
+
+        for( i = 0; i < list->val.l.count; i++ )
+        {
+            val = tr_bencDictFind( &list->val.l.vals[i], "path" );
+            strcatUTF8( inf->files[i].name, inf->name );
+            for( j = 0; j < val->val.l.count; j++ )
+            {
+                strcatUTF8( inf->files[i].name, "/" );
+                strcatUTF8( inf->files[i].name,
+                            val->val.l.vals[j].val.s.s );
+            }
+            val = tr_bencDictFind( &list->val.l.vals[i], "length" );
+            inf->files[i].length  = val->val.i;
+            inf->totalSize       += val->val.i;
+        }
+
+    }
+    else
+    {
+        /* Single-file mode */
+        inf->multifile = 0;
+        inf->fileCount = 1;
+        inf->files     = calloc( sizeof( tr_file_t ), 1 );
+
+        val = tr_bencDictFind( beInfo, "name" );
+        strcatUTF8( inf->files[0].name, val->val.s.s );
+        strcatUTF8( inf->name, val->val.s.s );
+        
+        val = tr_bencDictFind( beInfo, "length" );
+        inf->files[0].length  = val->val.i;
+        inf->totalSize       += val->val.i;
+    }
+
+    if( (uint64_t) inf->pieceCount !=
+        ( inf->totalSize + inf->pieceSize - 1 ) / inf->pieceSize )
+    {
+/*        fprintf( stderr, "Size of hashes and files don't match\n" );*/
+        tr_bencFree( &meta );
+        return TR_PARSE_HASH;
+    }
+
+    tr_bencFree( &meta );
+    return 0;
+}
+
+void tr_metainfoRemoveSaved( const char * hashString )
+{
+    char file[MAX_PATH_LENGTH];
+
+    snprintf( file, MAX_PATH_LENGTH, "%s/%s",
+              tr_getTorrentsDirectory(), hashString );
+    unlink(file);
+}
+
+/***********************************************************************
+ * strcatUTF8
+ ***********************************************************************
+ * According to the official specification, all strings in the torrent
+ * file are supposed to be UTF-8 encoded. However, there are
+ * non-compliant torrents around... If we encounter an invalid UTF-8
+ * character, we assume it is ISO 8859-1 and convert it to UTF-8.
+ **********************************************************************/
+static void strcatUTF8( char * s, char * append )
+{
+    char * p;
+
+    /* Go to the end of the destination string */
+    while( s[0] )
+    {
+        s++;
+    }
+
+    /* Now start appending, converting on the fly if necessary */
+    for( p = append; p[0]; )
+    {
+        if( !( p[0] & 0x80 ) )
+        {
+            /* ASCII character */
+            *(s++) = *(p++);
+            continue;
+        }
+
+        if( ( p[0] & 0xE0 ) == 0xC0 && ( p[1] & 0xC0 ) == 0x80 )
+        {
+            /* 2-bytes UTF-8 character */
+            *(s++) = *(p++); *(s++) = *(p++);
+            continue;
+        }
+
+        if( ( p[0] & 0xF0 ) == 0xE0 && ( p[1] & 0xC0 ) == 0x80 &&
+            ( p[2] & 0xC0 ) == 0x80 )
+        {
+            /* 3-bytes UTF-8 character */
+            *(s++) = *(p++); *(s++) = *(p++);
+            *(s++) = *(p++);
+            continue;
+        }
+
+        if( ( p[0] & 0xF8 ) == 0xF0 && ( p[1] & 0xC0 ) == 0x80 &&
+            ( p[2] & 0xC0 ) == 0x80 && ( p[3] & 0xC0 ) == 0x80 )
+        {
+            /* 4-bytes UTF-8 character */
+            *(s++) = *(p++); *(s++) = *(p++);
+            *(s++) = *(p++); *(s++) = *(p++);
+            continue;
+        }
+
+        /* ISO 8859-1 -> UTF-8 conversion */
+        *(s++) = 0xC0 | ( ( *p & 0xFF ) >> 6 );
+        *(s++) = 0x80 | ( *(p++) & 0x3F );
+    }
+}