Changeset 9550

Timestamp:

Nov 24, 2009, 2:16:31 AM (13 years ago)

Author:

charles

Message:

(trunk) #2096: Magnet, BEP #9 support

Location:

trunk

Files:

• gtk/add-dialog.c (modified) (2 diffs)
• gtk/icons.c (modified) (1 diff)
• gtk/icons.h (modified) (1 diff)
• gtk/torrent-cell-renderer.c (modified) (1 diff)
• gtk/tr-core.c (modified) (3 diffs)
• gtk/util.c (modified) (1 diff)
• libtransmission/Makefile.am (modified) (2 diffs)
• libtransmission/completion.c (modified) (3 diffs)
• libtransmission/metainfo.c (modified) (9 diffs)
• libtransmission/metainfo.h (modified) (3 diffs)
• libtransmission/peer-mgr.c (modified) (7 diffs)
• libtransmission/peer-mgr.h (modified) (2 diffs)
• libtransmission/peer-msgs.c (modified) (30 diffs)
• libtransmission/rpcimpl.c (modified) (1 diff)
• libtransmission/torrent-ctor.c (modified) (4 diffs)
• libtransmission/torrent-magnet.c (added)
• libtransmission/torrent-magnet.h (added)
• libtransmission/torrent.c (modified) (16 diffs)
• libtransmission/torrent.h (modified) (8 diffs)
• libtransmission/transmission.h (modified) (1 diff)
• libtransmission/utils-test.c (modified) (2 diffs)
• libtransmission/utils.c (modified) (1 diff)
• libtransmission/utils.h (modified) (1 diff)

trunk/gtk/add-dialog.c

@@ -493 +493 @@
             else
             {
-                GtkWidget * w = gtk_message_dialog_new( GTK_WINDOW( dialog ),
-                                                        GTK_DIALOG_MODAL,
+                GtkWidget * w = gtk_message_dialog_new( GTK_WINDOW( dialog ), 0,
                                                         GTK_MESSAGE_ERROR,
                                                         GTK_BUTTONS_CLOSE,
@@ -500 +499 @@
                 gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ),
                     _( "Transmission doesn't know how to use \"%s\"" ), url );
-                gtk_dialog_run( GTK_DIALOG( w ) );
-                gtk_widget_destroy( w );
+                g_signal_connect_swapped( w, "response",
+                                          G_CALLBACK( gtk_widget_destroy ), w );
+                gtk_widget_show( w );
                 destroy = FALSE;
             }

trunk/gtk/icons.c

@@ -231 +231 @@
     const char * stock_name;
 
-    if( !strcmp( mime_type, DIRECTORY_MIME_TYPE ) )
+    if( !strcmp( mime_type, UNKNOWN_MIME_TYPE ) )
+        stock_name = GTK_STOCK_MISSING_IMAGE;
+    else if( !strcmp( mime_type, DIRECTORY_MIME_TYPE ) )
         stock_name = GTK_STOCK_DIRECTORY;
     else

trunk/gtk/icons.h

@@ -8 +8 @@
 
 #define DIRECTORY_MIME_TYPE "folder"
+#define UNKNOWN_MIME_TYPE "unknown"
 
 const char * get_mime_type_from_filename( const char *file );

trunk/gtk/torrent-cell-renderer.c

@@ -307 +307 @@
     const tr_info * info = tr_torrentInfo( tor );
 
-    if( info->fileCount > 1 )
+    if( info->fileCount == 0  )
+        mime_type = UNKNOWN_MIME_TYPE;
+    else if( info->fileCount > 1 )
         mime_type = DIRECTORY_MIME_TYPE;
     else

trunk/gtk/tr-core.c

@@ -1024 +1024 @@
 tr_core_add_from_url( TrCore * core, const char * url )
 {
+    tr_session * session = tr_core_session( core );
+
     if( gtr_is_magnet_link( url ) )
     {
-        g_message( "FIXME: magnet link \"%s\" not handled", url );
+        tr_ctor * ctor = tr_ctorNew( session );
+        int err = tr_ctorSetMagnet( ctor, url );
+        if( !err ) 
+        {
+            tr_session * session = tr_core_session( core );
+            TrTorrent * gtor = tr_torrent_new_ctor( session, ctor, &err );
+            if( !err )
+                tr_core_add_torrent( core, gtor, FALSE );
+            else
+                g_message( "tr_torrent_new_ctor err %d", err );
+        }
+        else
+        {
+            GtkWidget * w = gtk_message_dialog_new( NULL, 0,
+                                                    GTK_MESSAGE_ERROR,
+                                                    GTK_BUTTONS_CLOSE,
+                                                    "%s", _( "Unrecognized URL" ) );
+            gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ),
+                _( "Transmission doesn't know how to use \"%s\"" ), url );
+            g_signal_connect_swapped( w, "response",
+                                      G_CALLBACK( gtk_widget_destroy ), w );
+            gtk_widget_show( w );
+            tr_ctorFree( ctor );
+        }
     }
     else
@@ -1032 +1057 @@
         struct url_dialog_data * data = g_new( struct url_dialog_data, 1 );
         data->core = core;
-        tr_webRun( tr_core_session( core ), url, NULL, onURLDone, data );
+        tr_webRun( session, url, NULL, onURLDone, data );
     }
 }
@@ -1052 +1077 @@
         return;
 
+g_message( "filename [%s]", filename );
     if( gtr_is_supported_url( filename ) || gtr_is_magnet_link( filename ) )
     {

trunk/gtk/util.c

@@ -347 +347 @@
     for( i=0; i<argc; ++i )
     {
-        if( gtr_is_supported_url( argv[i] ) )
+        if( gtr_is_supported_url( argv[i] ) || gtr_is_magnet_link( argv[i] ) )
         {
             ret = g_slist_prepend( ret, g_strdup( argv[i] ) );

trunk/libtransmission/Makefile.am

@@ -48 +48 @@
     torrent.c \
     torrent-ctor.c \
+    torrent-magnet.c \
     tr-dht.c \
     tr-getopt.c \
@@ -95 +96 @@
     stats.h \
     torrent.h \
+    torrent-magnet.h \
     tr-getopt.h \
     transmission.h \

trunk/libtransmission/completion.c

@@ -17 +17 @@
 #include "completion.h"
 #include "torrent.h"
+#include "torrent-magnet.h"
 #include "utils.h"
 
@@ -241 +242 @@
 tr_cpGetStatus( const tr_completion * cp )
 {
+    if( !tr_torrentHasMetadata( cp->tor ) ) return TR_LEECH;
     if( cp->sizeNow == cp->tor->info.totalSize ) return TR_SEED;
     if( cp->sizeNow == tr_cpSizeWhenDone( cp ) ) return TR_PARTIAL_SEED;
@@ -255 +257 @@
     const uint64_t            lastPieceSize  = tor->lastPieceSize;
     const tr_piece_index_t    lastPiece      = tor->info.pieceCount - 1;
+
+    if( !tr_torrentHasMetadata( tor ) )
+        return 0;
 
     for( i=0; i!=lastPiece; ++i )

trunk/libtransmission/metainfo.c

@@ -38 +38 @@
 #include "bencode.h"
 #include "crypto.h" /* tr_sha1 */
+#include "magnet.h"
 #include "metainfo.h"
 #include "platform.h"
@@ -228 +229 @@
 
 static char *
-announceToScrape( const char * announce )
+tr_convertAnnounceToScrape( const char * announce )
 {
     char *       scrape = NULL;
@@ -295 +296 @@
                         t->tier = validTiers;
                         t->announce = tr_strdup( url );
-                        t->scrape = announceToScrape( url );
+                        t->scrape = tr_convertAnnounceToScrape( url );
 
                         anyAdded = TRUE;
@@ -325 +326 @@
             trackers[trackerCount].tier = 0;
             trackers[trackerCount].announce = tr_strdup( url );
-            trackers[trackerCount++].scrape = announceToScrape( url );
+            trackers[trackerCount++].scrape = tr_convertAnnounceToScrape( url );
             /*fprintf( stderr, "single announce: [%s]\n", url );*/
         }
@@ -382 +383 @@
 static const char*
 tr_metainfoParseImpl( const tr_session * session,
-                      tr_info *         inf,
-                      const tr_benc *   meta_in )
+                      tr_info          * inf,
+                      int              * infoDictOffset,
+                      int              * infoDictLength,
+                      const tr_benc    * meta_in )
 {
     int64_t         i;
@@ -405 +408 @@
         tr_sha1_to_hex( inf->hashString, inf->hash );
         escape( inf->hashEscaped, inf->hash, SHA_DIGEST_LENGTH );
+
+        if( infoDictLength != NULL )
+            *infoDictLength = len;
+
+        if( infoDictOffset != NULL )
+        {
+            int mlen = 0;
+            char * mstr = tr_bencToStr( meta_in, TR_FMT_BENC, &mlen );
+            const char * offset = tr_memmem( mstr, mlen, bstr, len );
+            if( offset != NULL )
+                *infoDictOffset = offset - mstr;
+            tr_free( mstr );
+            if( offset == NULL )
+                return "info";
+        }
+
         tr_free( bstr );
     }
@@ -484 +503 @@
 tr_metainfoParse( const tr_session * session,
                   tr_info          * inf,
+                  int              * infoDictOffset,
+                  int              * infoDictLength,
                   const tr_benc    * meta_in )
 {
-    const char * badTag = tr_metainfoParseImpl( session, inf, meta_in );
+    const char * badTag = tr_metainfoParseImpl( session,
+                                                inf,
+                                                infoDictOffset,
+                                                infoDictLength,
+                                                meta_in );
     const tr_bool success = badTag == NULL;
 
@@ -501 +526 @@
 tr_metainfoFree( tr_info * inf )
 {
+    int i;
     tr_file_index_t ff;
-    int             i;
 
     for( i = 0; i < inf->webseedCount; ++i )
@@ -543 +568 @@
 }
 
+/***
+****
+***/
+
+void
+tr_metainfoSetFromMagnet( tr_info * inf, const tr_magnet_info * m )
+{
+    /* hash */
+    memcpy( inf->hash, m->hash, 20 );
+    tr_sha1_to_hex( inf->hashString, inf->hash );
+    escape( inf->hashEscaped, inf->hash, SHA_DIGEST_LENGTH );
+
+    /* name */
+    if( *m->displayName )
+        inf->name = tr_strdup( m->displayName );
+    else
+        inf->name = tr_strdup( inf->hashString );
+
+    /* trackers */
+    if( m->announceCount > 0 )
+    {
+        int i;
+        const int n = m->announceCount;
+
+        inf->trackerCount = n;
+        inf->trackers = tr_new0( tr_tracker_info, n );
+        for( i=0; i<n; ++i ) {
+            const char * url = m->announceURLs[i];
+            inf->trackers[i].tier = i;
+            inf->trackers[i].announce = tr_strdup( url );
+            inf->trackers[i].scrape = tr_convertAnnounceToScrape( url );
+        }
+    }
+}

trunk/libtransmission/metainfo.h

@@ -24 +24 @@
 
 #ifndef __TRANSMISSION__
-#error only libtransmission should #include this header.
+ #error only libtransmission should #include this header.
 #endif
 
@@ -33 +33 @@
 
 struct tr_benc;
+struct tr_magnet_info;
 
 tr_bool  tr_metainfoParse( const tr_session     * session,
-                           tr_info              * info,
+                           tr_info              * setmeInfo,
+                           int                  * setmeInfoDictLength,
+                           int                  * setmeInfoDictOffset,
                            const struct tr_benc * benc );
 
@@ -44 +47 @@
                          tr_info    * inf );
 
+void tr_metainfoSetFromMagnet( tr_info * inf, const struct tr_magnet_info * m );
+
+
 #endif

trunk/libtransmission/peer-mgr.c

@@ -344 +344 @@
 {
     tr_peer * peer = tr_new0( tr_peer, 1 );
+    tr_bitsetConstructor( &peer->have, 0 );
     peer->atom = atom;
     return peer;
@@ -384 +385 @@
     tr_peerIoUnref( peer->io ); /* balanced by the ref in handshakeDoneCB() */
 
-    tr_bitfieldFree( peer->have );
+    tr_bitsetDestructor( &peer->have );
     tr_bitfieldFree( peer->blame );
     tr_free( peer->client );
@@ -907 +908 @@
     Torrent * t;
     struct weighted_piece * pieces;
-    const tr_bitfield * have = peer->have;
+    const tr_bitset * have = &peer->have;
     const time_t now = time( NULL );
 
@@ -929 +930 @@
 
         /* if the peer has this piece that we want... */
-        if( tr_bitfieldHasFast( have, p->index ) )
+        if( tr_bitsetHasFast( have, p->index ) )
         {
             tr_block_index_t b = tr_torPieceFirstBlock( tor, p->index );
@@ -1942 +1943 @@
             int j;
             for( j = 0; j < peerCount; ++j )
-                if( tr_bitfieldHas( peers[j]->have, i ) )
+                if( tr_bitsetHas( &peers[j]->have, i ) )
                     ++tab[i];
         }
@@ -1965 +1966 @@
     peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
     for( i=0; i<peerCount; ++i )
-        tr_bitfieldOr( pieces, peers[i]->have );
+        tr_bitsetOr( pieces, &peers[i]->have );
 
     managerUnlock( t->manager );
@@ -2352 +2353 @@
         else {
             tr_bitfield * tmp = tr_bitfieldDup( tr_cpPieceBitfield( &tor->completion ) );
-            tr_bitfieldDifference( tmp, peer->have );
+            tr_bitsetDifference( tmp, &peer->have );
             peerHasEverything = tr_bitfieldCountTrueBits( tmp ) == 0;
             tr_bitfieldFree( tmp );

trunk/libtransmission/peer-mgr.h

@@ -25 +25 @@
 
 #include "bitfield.h"
+#include "bitset.h"
 #include "net.h"
 #include "peer-common.h" /* struct peer_request */
@@ -94 +95 @@
 
     struct tr_bitfield     * blame;
-    struct tr_bitfield     * have;
+    struct tr_bitset         have;
 
     /** how complete the peer's copy of the torrent is. [0.0...1.0] */

trunk/libtransmission/peer-msgs.c

@@ -36 +36 @@
 #include "stats.h"
 #include "torrent.h"
+#include "torrent-magnet.h"
 #include "tr-dht.h"
 #include "utils.h"
@@ -67 +68 @@
     LTEP_HANDSHAKE          = 0,
 
-    TR_LTEP_PEX             = 1,
+    UT_PEX_ID               = 1,
+    UT_METADATA_ID          = 3,
 
     MAX_PEX_PEER_COUNT      = 50,
 
-    MIN_CHOKE_PERIOD_SEC    = ( 10 ),
+    MIN_CHOKE_PERIOD_SEC    = 10,
 
     /* idle seconds before we send a keepalive */
@@ -79 +81 @@
 
     REQQ                    = 512,
+
+    METADATA_REQQ           = 64,
 
     MAX_BLOCK_SIZE          = ( 1024 * 16 ),
@@ -92 +96 @@
 
     /* number of pieces we'll allow in our fast set */
-    MAX_FAST_SET_SIZE = 3
+    MAX_FAST_SET_SIZE = 3,
+
+    /* defined in BEP #9 */
+    METADATA_MSG_TYPE_REQUEST = 0,
+    METADATA_MSG_TYPE_DATA = 1,
+    METADATA_MSG_TYPE_REJECT = 2
 };
 
@@ -166 +175 @@
 {
     tr_bool         peerSupportsPex;
+    tr_bool         peerSupportsMetadataXfer;
     tr_bool         clientSentLtepHandshake;
     tr_bool         peerSentLtepHandshake;
+    tr_bool         requestingMetadataFromPeer;
+
     /*tr_bool         haveFastSet;*/
 
@@ -182 +194 @@
     uint8_t         state;
     uint8_t         ut_pex_id;
+    uint8_t         ut_metadata_id;
     uint16_t        pexCount;
     uint16_t        pexCount6;
@@ -200 +213 @@
     struct peer_request    peerAskedFor[REQQ];
     int                    peerAskedForCount;
- 
+
+    int                    peerAskedForMetadata[METADATA_REQQ];
+    int                    peerAskedForMetadataCount;
+
     tr_pex               * pex;
     tr_pex               * pex6;
@@ -219 +235 @@
     struct event          pexTimer;
 };
+
+/**
+***
+**/
+
+#if 0
+static tr_bitfield*
+getHave( const struct tr_peermsgs * msgs )
+{
+    if( msgs->peer->have == NULL )
+        msgs->peer->have = tr_bitfieldNew( msgs->torrent->info.pieceCount );
+    return msgs->peer->have;
+}
+#endif
 
 static TR_INLINE tr_session*
@@ -655 +685 @@
     const tr_torrent * torrent = msgs->torrent;
 
-    return ( !torrent->info.pieces[piece].dnd )                 /* we want it */
+    return ( !torrent->info.pieces[piece].dnd )                  /* we want it */
           && ( !tr_cpPieceIsComplete( &torrent->completion, piece ) ) /* !have */
-          && ( tr_bitfieldHas( msgs->peer->have, piece ) );    /* peer has it */
+          && ( tr_bitsetHas( &msgs->peer->have, piece ) );      /* peer has it */
 }
 
@@ -678 +708 @@
     bitfield = tr_cpPieceBitfield( &torrent->completion );
 
-    if( !msgs->peer->have )
-        return TRUE;
-
-    assert( bitfield->byteCount == msgs->peer->have->byteCount );
-
     for( i = 0; i < torrent->info.pieceCount; ++i )
         if( isPieceInteresting( msgs, i ) )
@@ -715 +740 @@
     if( i != msgs->peer->clientIsInterested )
         sendInterest( msgs, i );
+}
+
+static tr_bool
+popNextMetadataRequest( tr_peermsgs * msgs, int * piece )
+{
+    if( msgs->peerAskedForMetadataCount == 0 )
+        return FALSE;
+
+    *piece = msgs->peerAskedForMetadata[0];
+
+    memmove( msgs->peerAskedForMetadata,
+             msgs->peerAskedForMetadata + 1,
+             sizeof( int ) * --msgs->peerAskedForMetadataCount );
+
+    return TRUE;
 }
 
@@ -820 +860 @@
     char * buf;
     int len;
-    int pex;
+    tr_bool allow_pex;
+    tr_bool allow_metadata_xfer;
     struct evbuffer * out = msgs->outMessages;
     const unsigned char * ipv6 = tr_globalIPv6();
@@ -830 +871 @@
     msgs->clientSentLtepHandshake = 1;
 
+    /* decide if we want to advertise metadata xfer support (BEP 9) */
+    if( tr_torrentIsPrivate( msgs->torrent ) )
+        allow_metadata_xfer = 0;
+    else
+        allow_metadata_xfer = 1;
+
     /* decide if we want to advertise pex support */
     if( !tr_torrentAllowsPex( msgs->torrent ) )
-        pex = 0;
+        allow_pex = 0;
     else if( msgs->peerSentLtepHandshake )
-        pex = msgs->peerSupportsPex ? 1 : 0;
+        allow_pex = msgs->peerSupportsPex ? 1 : 0;
     else
-        pex = 1;
-
-    tr_bencInitDict( &val, 7 );
+        allow_pex = 1;
+
+    tr_bencInitDict( &val, 8 );
     tr_bencDictAddInt( &val, "e", getSession(msgs)->encryptionMode != TR_CLEAR_PREFERRED );
-    if( ipv6 )
+    if( ipv6 != NULL )
         tr_bencDictAddRaw( &val, "ipv6", ipv6, 16 );
+    if( allow_metadata_xfer && tr_torrentHasMetadata( msgs->torrent )
+                            && ( msgs->torrent->infoDictLength > 0 ) )
+        tr_bencDictAddInt( &val, "metadata_size", msgs->torrent->infoDictLength );
     tr_bencDictAddInt( &val, "p", tr_sessionGetPeerPort( getSession(msgs) ) );
     tr_bencDictAddInt( &val, "reqq", REQQ );
     tr_bencDictAddInt( &val, "upload_only", tr_torrentIsSeed( msgs->torrent ) );
     tr_bencDictAddStr( &val, "v", TR_NAME " " USERAGENT_PREFIX );
-    m  = tr_bencDictAddDict( &val, "m", 1 );
-    if( pex )
-        tr_bencDictAddInt( m, "ut_pex", TR_LTEP_PEX );
+    m  = tr_bencDictAddDict( &val, "m", 2 );
+    if( allow_metadata_xfer )
+        tr_bencDictAddInt( m, "ut_metadata", UT_METADATA_ID );
+    if( allow_pex )
+        tr_bencDictAddInt( m, "ut_pex", UT_PEX_ID );
+
     buf = tr_bencToStr( &val, TR_FMT_BENC, &len );
 
@@ -899 +952 @@
     /* check supported messages for utorrent pex */
     msgs->peerSupportsPex = 0;
+    msgs->peerSupportsMetadataXfer = 0;
+
     if( tr_bencDictFindDict( &val, "m", &sub ) ) {
         if( tr_bencDictFindInt( sub, "ut_pex", &i ) ) {
+            msgs->peerSupportsPex = i != 0;
             msgs->ut_pex_id = (uint8_t) i;
-            msgs->peerSupportsPex = msgs->ut_pex_id == 0 ? 0 : 1;
             dbgmsg( msgs, "msgs->ut_pex is %d", (int)msgs->ut_pex_id );
         }
-    }
+        if( tr_bencDictFindInt( sub, "ut_metadata", &i ) ) {
+            msgs->peerSupportsMetadataXfer = i != 0;
+            msgs->ut_metadata_id = (uint8_t) i;
+            dbgmsg( msgs, "msgs->ut_metadata_id is %d", (int)msgs->ut_metadata_id );
+        }
+    }
+
+    /* look for metainfo size (BEP 9) */
+    if( tr_bencDictFindInt( &val, "metadata_size", &i ) )
+        tr_torrentSetMetadataSizeHint( msgs->torrent, i );
 
     /* look for upload_only (BEP 21) */
@@ -926 +990 @@
         tr_peerMgrAddPex( msgs->torrent, TR_PEER_FROM_ALT, &pex );
     }
- 
+
     if( tr_bencDictFindRaw( &val, "ipv6", &addr, &addr_len) && addr_len == 16 ) {
         pex.addr.type = TR_AF_INET6;
@@ -938 +1002 @@
 
     tr_bencFree( &val );
+    tr_free( tmp );
+}
+
+static void
+parseUtMetadata( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
+{
+    tr_benc dict;
+    char * msg_end;
+    char * benc_end;
+    int64_t msg_type = -1;
+    int64_t piece = -1;
+    int64_t total_size = 0;
+    uint8_t * tmp = tr_new( uint8_t, msglen );
+
+    tr_peerIoReadBytes( msgs->peer->io, inbuf, tmp, msglen );
+    msg_end = (char*)tmp + msglen;
+
+    if( !tr_bencLoad( tmp, msglen, &dict, &benc_end ) )
+    {
+        tr_bencDictFindInt( &dict, "msg_type", &msg_type );
+        tr_bencDictFindInt( &dict, "piece", &piece );
+        tr_bencDictFindInt( &dict, "total_size", &total_size );
+        tr_bencFree( &dict );
+    }
+
+    dbgmsg( msgs, "got ut_metadata msg: type %d, piece %d, total_size %d",
+            (int)msg_type, (int)piece, (int)total_size );
+
+    if( msg_type == METADATA_MSG_TYPE_REJECT )
+    {
+        /* NOOP */
+    }
+
+    if( ( msg_type == METADATA_MSG_TYPE_DATA )
+        && ( !tr_torrentHasMetadata( msgs->torrent ) )
+        && ( msg_end - benc_end <= METADATA_PIECE_SIZE )
+        && ( piece * METADATA_PIECE_SIZE + (msg_end - benc_end) <= total_size ) )
+    {
+        const int pieceLen = msg_end - benc_end;
+dbgmsg( msgs, "got a metadata piece... calling tr_torrentSetMetadataPiece" );
+        msgs->requestingMetadataFromPeer = FALSE;
+        tr_torrentSetMetadataPiece( msgs->torrent, piece, benc_end, pieceLen );
+    }
+
+    if( msg_type == METADATA_MSG_TYPE_REQUEST )
+    {
+        if( ( piece >= 0 )
+            && tr_torrentHasMetadata( msgs->torrent )
+            && !tr_torrentIsPrivate( msgs->torrent )
+            && ( msgs->peerAskedForMetadataCount < METADATA_REQQ ) )
+        {
+            msgs->peerAskedForMetadata[msgs->peerAskedForMetadataCount++] = piece;
+        }
+        else
+        {
+            tr_benc tmp;
+            int payloadLen;
+            char * payload;
+            tr_peerIo  * io  = msgs->peer->io;
+            struct evbuffer * out = msgs->outMessages;
+
+            /* build the rejection message */
+            tr_bencInitDict( &tmp, 2 );
+            tr_bencDictAddInt( &tmp, "msg_type", METADATA_MSG_TYPE_REJECT );
+            tr_bencDictAddInt( &tmp, "piece", piece );
+            payload = tr_bencToStr( &tmp, TR_FMT_BENC, &payloadLen );
+            tr_bencFree( &tmp );
+
+            /* write it out as a LTEP message to our outMessages buffer */
+            tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + payloadLen );
+            tr_peerIoWriteUint8 ( io, out, BT_LTEP );
+            tr_peerIoWriteUint8 ( io, out, msgs->ut_metadata_id );
+            tr_peerIoWriteBytes ( io, out, payload, payloadLen );
+            pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
+            dbgOutMessageLen( msgs );
+
+            tr_free( payload );
+        }
+    }
+
     tr_free( tmp );
 }
@@ -1018 +1162 @@
         }
     }
-    else if( ltep_msgid == TR_LTEP_PEX )
+    else if( ltep_msgid == UT_PEX_ID )
     {
         dbgmsg( msgs, "got ut pex" );
         msgs->peerSupportsPex = 1;
         parseUtPex( msgs, msglen, inbuf );
+    }
+    else if( ltep_msgid == UT_METADATA_ID )
+    {
+        dbgmsg( msgs, "got ut metadata" );
+        msgs->peerSupportsMetadataXfer = 1;
+        parseUtMetadata( msgs, msglen, inbuf );
     }
     else
@@ -1088 +1238 @@
 updatePeerProgress( tr_peermsgs * msgs )
 {
-    msgs->peer->progress = tr_bitfieldCountTrueBits( msgs->peer->have ) / (float)msgs->torrent->info.pieceCount;
+    msgs->peer->progress = tr_bitsetPercent( &msgs->peer->have );
     dbgmsg( msgs, "peer progress is %f", msgs->peer->progress );
     updateFastSet( msgs );
@@ -1287 +1437 @@
             tr_peerIoReadUint32( msgs->peer->io, inbuf, &ui32 );
             dbgmsg( msgs, "got Have: %u", ui32 );
-            if( tr_bitfieldAdd( msgs->peer->have, ui32 ) ) {
+            if( tr_bitsetAdd( &msgs->peer->have, ui32 ) ) {
                 fireError( msgs, ERANGE );
                 return READ_ERR;
@@ -1296 +1446 @@
         case BT_BITFIELD:
             dbgmsg( msgs, "got a bitfield" );
-            tr_peerIoReadBytes( msgs->peer->io, inbuf, msgs->peer->have->bits, msglen );
+            tr_bitsetReserve( &msgs->peer->have, msglen*8 );
+            tr_peerIoReadBytes( msgs->peer->io, inbuf, msgs->peer->have.bitfield.bits, msglen );
             updatePeerProgress( msgs );
             break;
@@ -1319 +1470 @@
             tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.length );
             dbgmsg( msgs, "got a Cancel %u:%u->%u", r.index, r.offset, r.length );
+
             for( i=0; i<msgs->peerAskedForCount; ++i ) {
                 const struct peer_request * req = msgs->peerAskedFor + i;
@@ -1324 +1476 @@
                     break;
             }
+
             if( i < msgs->peerAskedForCount )
-                memmove( msgs->peerAskedFor+i, msgs->peerAskedFor+i+1, --msgs->peerAskedForCount-i );
+                memmove( msgs->peerAskedFor+i,
+                         msgs->peerAskedFor+i+1,
+                         sizeof(struct peer_request) *( --msgs->peerAskedForCount-i) );
             break;
         }
@@ -1367 +1522 @@
             dbgmsg( msgs, "Got a BT_FEXT_HAVE_ALL" );
             if( fext ) {
-                tr_bitfieldAddRange( msgs->peer->have, 0, msgs->torrent->info.pieceCount );
+                tr_bitsetSetHaveAll( &msgs->peer->have );
                 updatePeerProgress( msgs );
             } else {
@@ -1378 +1533 @@
             dbgmsg( msgs, "Got a BT_FEXT_HAVE_NONE" );
             if( fext ) {
-                tr_bitfieldClear( msgs->peer->have );
+                tr_bitsetSetHaveNone( &msgs->peer->have );
                 updatePeerProgress( msgs );
             } else {
@@ -1587 +1742 @@
 
 static void
-updateRequests( tr_peermsgs * msgs )
+updateMetadataRequests( tr_peermsgs * msgs, time_t now )
+{
+    int piece;
+
+    if( msgs->peerSupportsMetadataXfer
+        && !msgs->requestingMetadataFromPeer
+        && tr_torrentGetNextMetadataRequest( msgs->torrent, now, &piece ) )
+    {
+        tr_benc tmp;
+        int payloadLen;
+        char * payload;
+        tr_peerIo  * io  = msgs->peer->io;
+        struct evbuffer * out = msgs->outMessages;
+
+        /* build the data message */
+        tr_bencInitDict( &tmp, 3 );
+        tr_bencDictAddInt( &tmp, "msg_type", METADATA_MSG_TYPE_REQUEST );
+        tr_bencDictAddInt( &tmp, "piece", piece );
+        payload = tr_bencToStr( &tmp, TR_FMT_BENC, &payloadLen );
+        tr_bencFree( &tmp );
+
+        dbgmsg( msgs, "requesting metadata piece #%d", piece );
+
+        /* write it out as a LTEP message to our outMessages buffer */
+        tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + payloadLen );
+        tr_peerIoWriteUint8 ( io, out, BT_LTEP );
+        tr_peerIoWriteUint8 ( io, out, msgs->ut_metadata_id );
+        tr_peerIoWriteBytes ( io, out, payload, payloadLen );
+        pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
+        dbgOutMessageLen( msgs );
+
+        msgs->requestingMetadataFromPeer = TRUE;
+
+        tr_free( payload );
+    }
+}
+
+static void
+updateBlockRequests( tr_peermsgs * msgs )
 {
     const int MIN_BATCH_SIZE = 4;
@@ -1642 +1835 @@
 fillOutputBuffer( tr_peermsgs * msgs, time_t now )
 {
+    int piece;
     size_t bytesWritten = 0;
     struct peer_request req;
@@ -1669 +1863 @@
 
     /**
-    ***  Blocks
+    ***  Metadata Pieces
+    **/
+
+    if( ( tr_peerIoGetWriteBufferSpace( msgs->peer->io, now ) >= METADATA_PIECE_SIZE )
+        && popNextMetadataRequest( msgs, &piece ) )
+    {
+        char * data;
+        int dataLen;
+        tr_bool ok = FALSE;
+
+        data = tr_torrentGetMetadataPiece( msgs->torrent, piece, &dataLen );
+        if( ( dataLen > 0 ) && ( data != NULL ) )
+        {
+            tr_benc tmp;
+            int payloadLen;
+            char * payload;
+            tr_peerIo  * io  = msgs->peer->io;
+            struct evbuffer * out = msgs->outMessages;
+
+            /* build the data message */
+            tr_bencInitDict( &tmp, 3 );
+            tr_bencDictAddInt( &tmp, "msg_type", METADATA_MSG_TYPE_DATA );
+            tr_bencDictAddInt( &tmp, "piece", piece );
+            tr_bencDictAddInt( &tmp, "total_size", dataLen );
+            payload = tr_bencToStr( &tmp, TR_FMT_BENC, &payloadLen );
+            tr_bencFree( &tmp );
+
+            /* write it out as a LTEP message to our outMessages buffer */
+            tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + payloadLen + dataLen );
+            tr_peerIoWriteUint8 ( io, out, BT_LTEP );
+            tr_peerIoWriteUint8 ( io, out, msgs->ut_metadata_id );
+            tr_peerIoWriteBytes ( io, out, payload, payloadLen );
+            tr_peerIoWriteBytes ( io, out, data, dataLen );
+            pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
+            dbgOutMessageLen( msgs );
+
+            tr_free( payload );
+            tr_free( data );
+
+            ok = TRUE;
+        }
+
+        if( !ok ) /* send a rejection message */
+        {
+            tr_benc tmp;
+            int payloadLen;
+            char * payload;
+            tr_peerIo  * io  = msgs->peer->io;
+            struct evbuffer * out = msgs->outMessages;
+
+            /* build the rejection message */
+            tr_bencInitDict( &tmp, 2 );
+            tr_bencDictAddInt( &tmp, "msg_type", METADATA_MSG_TYPE_REJECT );
+            tr_bencDictAddInt( &tmp, "piece", piece );
+            payload = tr_bencToStr( &tmp, TR_FMT_BENC, &payloadLen );
+            tr_bencFree( &tmp );
+
+            /* write it out as a LTEP message to our outMessages buffer */
+            tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + payloadLen );
+            tr_peerIoWriteUint8 ( io, out, BT_LTEP );
+            tr_peerIoWriteUint8 ( io, out, msgs->ut_metadata_id );
+            tr_peerIoWriteBytes ( io, out, payload, payloadLen );
+            pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
+            dbgOutMessageLen( msgs );
+
+            tr_free( payload );
+        }
+    }
+
+    /**
+    ***  Data Blocks
     **/
 
@@ -1750 +2014 @@
     if ( tr_isPeerIo( msgs->peer->io ) ) {
         updateDesiredRequestCount( msgs, now );
-        updateRequests( msgs );
+        updateBlockRequests( msgs );
+        updateMetadataRequests( msgs, now );
     }
 
@@ -2112 +2377 @@
     m->peer->clientIsInterested = 0;
     m->peer->peerIsInterested = 0;
-    m->peer->have = tr_bitfieldNew( torrent->info.pieceCount );
     m->state = AWAITING_BT_LENGTH;
     m->outMessages = evbuffer_new( );
@@ -2168 +2432 @@
     tr_publisherUnsubscribe( &peer->publisher, tag );
 }
-

trunk/libtransmission/rpcimpl.c

@@ -1094 +1094 @@
         else
         {
-            if( filename != NULL )
-                tr_ctorSetMetainfoFromFile( ctor, filename );
-            else {
+            if( filename == NULL )
+            {
                 int len;
-                char * metainfo = tr_base64_decode( metainfo_base64, -1,  &len );
+                char * metainfo = tr_base64_decode( metainfo_base64, -1, &len );
                 tr_ctorSetMetainfo( ctor, (uint8_t*)metainfo, len );
                 tr_free( metainfo );
             }
+            else if( !strncmp( filename, "magnet:?", 8 ) )
+            {
+                tr_ctorSetMagnet( ctor, filename );
+            }
+            else
+            {
+                tr_ctorSetMetainfoFromFile( ctor, filename );
+            }
+
             addTorrentImpl( idle_data, ctor );
         }

trunk/libtransmission/torrent-ctor.c

@@ -14 +14 @@
 #include "transmission.h"
 #include "bencode.h"
+#include "magnet.h"
 #include "platform.h"
 #include "session.h" /* tr_sessionFindTorrentFile() */
@@ -42 +43 @@
     tr_benc                 metainfo;
     char *                  sourceFile;
+
+    tr_magnet_info        * magnetInfo;
 
     struct optional_args    optionalArgs[2];
@@ -100 +103 @@
 {
     return ctor->sourceFile;
+}
+
+int
+tr_ctorSetMagnet( tr_ctor * ctor, const char * uri )
+{
+    int err;
+
+    if( ctor->magnetInfo != NULL )
+        tr_magnetFree( ctor->magnetInfo );
+
+    ctor->magnetInfo = tr_magnetParse( uri );
+
+    err = ctor->magnetInfo == NULL;
+    return err;
 }
 
@@ -373 +390 @@
 
 int
+tr_ctorGetMagnet( const tr_ctor * ctor, const tr_magnet_info ** setme )
+{
+    int err = 0;
+
+    if( ctor->magnetInfo == NULL )
+        err = 1;
+    else
+        *setme = ctor->magnetInfo;
+
+    return err;
+}
+
+int
 tr_ctorGetMetainfo( const tr_ctor *  ctor,
                     const tr_benc ** setme )

trunk/libtransmission/torrent.c

@@ -33 +33 @@
 #include "resume.h"
 #include "fdlimit.h" /* tr_fdTorrentClose */
+#include "magnet.h"
 #include "metainfo.h"
 #include "peer-mgr.h"
@@ -44 +45 @@
 #include "verify.h"
 
-#define MAX_BLOCK_SIZE ( 1024 * 16 )
+enum
+{
+    MAX_BLOCK_SIZE = 1024 * 16
+};
 
 /***
@@ -551 +555 @@
 }
 
-static void refreshCurrentDir( tr_torrent * tor );;
+static void refreshCurrentDir( tr_torrent * tor );
 
 static void
-torrentRealInit( tr_torrent * tor, const tr_ctor * ctor )
-{
-    int          doStart;
-    uint64_t     loaded;
-    uint64_t     t;
-    const char * dir;
-    static int   nextUniqueId = 1;
-    tr_info    * info = &tor->info;
-    tr_session * session = tr_ctorGetSession( ctor );
-
-    assert( session != NULL );
-
-    tr_globalLock( session );
-
-    tor->session   = session;
-    tor->uniqueId = nextUniqueId++;
-    tor->magicNumber = TORRENT_MAGIC_NUMBER;
-
-    randomizeTiers( info );
-
-    tor->bandwidth = tr_bandwidthNew( session, session->bandwidth );
+torrentInitFromInfo( tr_torrent * tor )
+{
+    uint64_t t;
+    tr_info * info = &tor->info;
 
     tor->blockSize = getBlockSize( info->pieceSize );
 
-    if( !tr_ctorGetDownloadDir( ctor, TR_FORCE, &dir ) ||
-        !tr_ctorGetDownloadDir( ctor, TR_FALLBACK, &dir ) )
-            tor->downloadDir = tr_strdup( dir );
-
-    if( tr_ctorGetIncompleteDir( ctor, &dir ) )
-        dir = tr_sessionGetIncompleteDir( session );
-    if( tr_sessionIsIncompleteDirEnabled( session ) )
-        tor->incompleteDir = tr_strdup( dir );
-
-    tor->lastPieceSize = info->totalSize % info->pieceSize;
+    if( info->pieceSize )
+        tor->lastPieceSize = info->totalSize % info->pieceSize;
 
     if( !tor->lastPieceSize )
         tor->lastPieceSize = info->pieceSize;
 
-    tor->lastBlockSize = info->totalSize % tor->blockSize;
+    if( tor->blockSize )
+        tor->lastBlockSize = info->totalSize % tor->blockSize;
 
     if( !tor->lastBlockSize )
         tor->lastBlockSize = tor->blockSize;
 
-    tor->blockCount =
-        ( info->totalSize + tor->blockSize - 1 ) / tor->blockSize;
-
-    tor->blockCountInPiece =
-        info->pieceSize / tor->blockSize;
-
-    tor->blockCountInLastPiece =
-        ( tor->lastPieceSize + tor->blockSize - 1 ) / tor->blockSize;
+    tor->blockCount = tor->blockSize
+        ? ( info->totalSize + tor->blockSize - 1 ) / tor->blockSize
+        : 0;
+
+    tor->blockCountInPiece = tor->blockSize
+        ? info->pieceSize / tor->blockSize
+        : 0;
+
+    tor->blockCountInLastPiece = tor->blockSize
+        ? ( tor->lastPieceSize + tor->blockSize - 1 ) / tor->blockSize
+        : 0;
 
     /* check our work */
-    assert( ( info->pieceSize % tor->blockSize ) == 0 );
+    if( tor->blockSize != 0 )
+        assert( ( info->pieceSize % tor->blockSize ) == 0 );
     t = info->pieceCount - 1;
     t *= info->pieceSize;
@@ -625 +609 @@
     tr_torrentInitFilePieces( tor );
 
+    tr_bitfieldConstruct( &tor->checkedPieces, tor->info.pieceCount );
+
+    tor->completeness = tr_cpGetStatus( &tor->completion );
+}
+
+void
+tr_torrentGotNewInfoDict( tr_torrent * tor )
+{
+    torrentInitFromInfo( tor );
+}
+
+static void
+torrentInit( tr_torrent * tor, const tr_ctor * ctor )
+{
+    int doStart;
+    uint64_t loaded;
+    const char * dir;
+    static int nextUniqueId = 1;
+    tr_session * session = tr_ctorGetSession( ctor );
+
+    assert( session != NULL );
+
+    tr_globalLock( session );
+
+    tor->session   = session;
+    tor->uniqueId = nextUniqueId++;
+    tor->magicNumber = TORRENT_MAGIC_NUMBER;
+
+    randomizeTiers( &tor->info );
+
     tr_sha1( tor->obfuscatedHash, "req2", 4,
-             info->hash, SHA_DIGEST_LENGTH,
+             tor->info.hash, SHA_DIGEST_LENGTH,
              NULL );
+
+    if( !tr_ctorGetDownloadDir( ctor, TR_FORCE, &dir ) ||
+        !tr_ctorGetDownloadDir( ctor, TR_FALLBACK, &dir ) )
+            tor->downloadDir = tr_strdup( dir );
+
+    if( tr_ctorGetIncompleteDir( ctor, &dir ) )
+        dir = tr_sessionGetIncompleteDir( session );
+    if( tr_sessionIsIncompleteDirEnabled( session ) )
+        tor->incompleteDir = tr_strdup( dir );
+
+    tor->bandwidth = tr_bandwidthNew( session, session->bandwidth );
+
+    tor->error = TR_STAT_OK;
 
     tr_peerMgrAddTorrent( session->peerMgr, tor );
@@ -638 +665 @@
     tr_ctorInitTorrentWanted( ctor, tor );
 
-    tor->error = TR_STAT_OK;
-
-    tr_bitfieldConstruct( &tor->checkedPieces, tor->info.pieceCount );
     tr_torrentUncheck( tor );
 
@@ -668 +692 @@
     }
 
-    tor->completeness = tr_cpGetStatus( &tor->completion );
-
     {
         tr_torrent * it = NULL;
@@ -683 +705 @@
     }
 
-    tr_globalUnlock( session );
+    torrentInitFromInfo( tor );
 
     /* maybe save our own copy of the metainfo */
@@ -691 +713 @@
         if( !tr_ctorGetMetainfo( ctor, &val ) )
         {
-            const char * filename = tor->info.torrent;
-            tr_bencToFile( val, TR_FMT_BENC, filename );
-            tr_sessionSetTorrentFile( tor->session, tor->info.hashString, filename );
+            const char * path = tor->info.torrent;
+            tr_bencToFile( val, TR_FMT_BENC, path );
+            tr_sessionSetTorrentFile( tor->session, tor->info.hashString, path );
         }
     }
 
-    tor->tiers = tr_announcerAddTorrent( session->announcer, tor );
+    tor->tiers = tr_announcerAddTorrent( tor->session->announcer, tor );
     tor->tiersSubscription = tr_announcerSubscribe( tor->tiers, onTrackerResponse, tor );
-
-    tr_metainfoMigrate( session, &tor->info );
 
     if( doStart )
         torrentStart( tor );
+
+    tr_globalUnlock( session );
 }
 
@@ -723 +745 @@
         return TR_PARSE_ERR;
 
-    didParse = tr_metainfoParse( session, setmeInfo, metainfo );
+    didParse = tr_metainfoParse( session, setmeInfo, NULL, NULL, metainfo );
     doFree = didParse && ( setmeInfo == &tmp );
 
@@ -745 +767 @@
                int            * setmeError )
 {
-    int          err;
-    tr_info      tmpInfo;
+    int err;
+    tr_info tmpInfo;
     tr_torrent * tor = NULL;
+    const tr_magnet_info * magnetInfo;
 
     assert( ctor != NULL );
     assert( tr_isSession( tr_ctorGetSession( ctor ) ) );
 
-    err = tr_torrentParse( ctor, &tmpInfo );
-    if( !err )
+    if( !tr_ctorGetMagnet( ctor, &magnetInfo ) )
     {
         tor = tr_new0( tr_torrent, 1 );
-        tor->info = tmpInfo;
-        torrentRealInit( tor, ctor );
-    }
-    else if( setmeError )
-    {
-        *setmeError = err;
+        tr_metainfoSetFromMagnet( &tor->info, magnetInfo );
+        torrentInit( tor, ctor );
+    }
+    else
+    {
+        err = tr_torrentParse( ctor, &tmpInfo );
+        if( !err )
+        {
+            tor = tr_new0( tr_torrent, 1 );
+            tor->info = tmpInfo;
+            torrentInit( tor, ctor );
+        }
+        else if( setmeError )
+        {
+            *setmeError = err;
+        }
     }
 
@@ -989 +1021 @@
                 tor->etaDLSpeedCalculatedAt = now;
             }
-            
+
             if( s->leftUntilDone > s->desiredAvailable )
                 s->eta = TR_ETA_NOT_AVAIL;
@@ -1007 +1039 @@
                     tor->etaULSpeedCalculatedAt = now;
                 }
-                
+
                 if( s->pieceUploadSpeed < 0.1 )
                     s->eta = TR_ETA_UNKNOWN;
@@ -1021 +1053 @@
             break;
     }
-    
-    if( !checkSeedRatio || s->ratio >= seedRatio || s->ratio == TR_RATIO_INF ) 
-        s->percentRatio = 1.0; 
-    else if( s->ratio == TR_RATIO_NA ) 
-        s->percentRatio = 0.0; 
-    else 
-        s->percentRatio = s->ratio / seedRatio; 
+
+    if( !checkSeedRatio || s->ratio >= seedRatio || s->ratio == TR_RATIO_INF )
+        s->percentRatio = 1.0;
+    else if( s->ratio == TR_RATIO_NA )
+        s->percentRatio = 0.0;
+    else
+        s->percentRatio = s->ratio / seedRatio;
 
     tr_torrentUnlock( tor );
@@ -2097 +2129 @@
         /* try to parse it back again, to make sure it's good */
         memset( &tmpInfo, 0, sizeof( tr_info ) );
-        if( tr_metainfoParse( tor->session, &tmpInfo, &metainfo ) )
+        if( tr_metainfoParse( tor->session, &tmpInfo,
+                              &tor->infoDictOffset,
+                              &tor->infoDictLength,
+                              &metainfo ) )
         {
             /* it's good, so keep these new trackers and free the old ones */
@@ -2368 +2403 @@
         tr_free( path );
 
-       
         tmp = tr_torrentBuildPartial( tor, 0 );
         path = tr_buildPath( tor->currentDir, tmp, NULL );
@@ -2657 +2691 @@
 }
 
-
 char*
 tr_torrentFindFile( const tr_torrent * tor, tr_file_index_t fileNum )

trunk/libtransmission/torrent.h

@@ -26 +26 @@
 struct tr_ratecontrol;
 struct tr_torrent_tiers;
+struct tr_magnet_info;
 
 /**
@@ -35 +36 @@
 
 int         tr_ctorGetSave( const tr_ctor * ctor );
+
+int         tr_ctorGetMagnet( const tr_ctor * ctor, const struct tr_magnet_info ** setme );
 
 void        tr_ctorInitTorrentPriorities( const tr_ctor * ctor, tr_torrent * tor );
@@ -132 +135 @@
                                            tr_verify_state   state );
 
+struct tr_incomplete_metadata;
+
 struct tr_torrent
 {
@@ -143 +148 @@
 
     uint8_t                  obfuscatedHash[SHA_DIGEST_LENGTH];
+
+    /* Used when the torrent has been created with a magnet link
+     * and we're in the process of downloading the metainfo from
+     * other peers */
+    struct tr_incomplete_metadata  * incompleteMetadata;
 
     /* If the initiator of the connection receives a handshake in which the
@@ -159 +169 @@
     char * incompleteDir;
 
+    /* Length, in bytes, of the "info" dict in the .torrent file */
+    int infoDictLength;
+
+    /* Offset, in bytes, of the beginning of the "info" dict in the .torrent file */
+    int infoDictOffset;
+
     /* Where the files are now.
      * This pointer will be equal to downloadDir or incompleteDir */
@@ -340 +356 @@
 /* set a flag indicating that the torrent's .resume file
  * needs to be saved when the torrent is closed */
-static TR_INLINE void tr_torrentSetDirty( tr_torrent * tor )
+static TR_INLINE
+void tr_torrentSetDirty( tr_torrent * tor )
 {
     assert( tr_isTorrent( tor ) );
@@ -347 +364 @@
 }
 
-static TR_INLINE const char * tr_torrentName( const tr_torrent * tor )
+static TR_INLINE
+const char * tr_torrentName( const tr_torrent * tor )
 {
     assert( tr_isTorrent( tor ) );
@@ -383 +401 @@
 char* tr_torrentBuildPartial( const tr_torrent *, tr_file_index_t fileNo );
 
+/* for when the info dict has been fundamentally changed wrt files,
+ * piece size, etc. such as in BEP 9 where peers exchange metadata */
+void tr_torrentGotNewInfoDict( tr_torrent * tor );
 
 #endif

trunk/libtransmission/transmission.h

@@ -859 +859 @@
                                     tr_bool   doDelete );
 
+int         tr_ctorSetMagnet( tr_ctor * ctor,
+                              const char * url );
+
 int         tr_ctorSetMetainfo( tr_ctor *       ctor,
                                 const uint8_t * metainfo,

trunk/libtransmission/utils-test.c

@@ -298 +298 @@
 }
 
+static int
+test_array( void )
+{
+    int i;
+    int array[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+    int n = sizeof( array ) / sizeof( array[0] );
+
+    tr_removeElementFromArray( array, 5, sizeof( int ), n-- );
+    for( i=0; i<n; ++i )
+        check( array[i] == ( i<5 ? i : i+1 ) );
+
+    tr_removeElementFromArray( array, 0, sizeof( int ), n-- );
+    for( i=0; i<n; ++i )
+        check( array[i] == ( i<4 ? i+1 : i+2 ) );
+
+    tr_removeElementFromArray( array, n-1, sizeof( int ), n ); n--;
+    for( i=0; i<n; ++i )
+        check( array[i] == ( i<4 ? i+1 : i+2 ) );
+
+    return 0;
+}
+
 int
 main( void )
@@ -339 +361 @@
     if( ( i = test_memmem( ) ) )
         return i;
+    if( ( i = test_array( ) ) )
+        return i;
 
     /* test that tr_cryptoRandInt() stays in-bounds */

trunk/libtransmission/utils.c

@@ -1416 +1416 @@
     return 0;
 }
+
+/***
+****
+***/
+
+void
+tr_removeElementFromArray( void * array, int index_to_remove,
+                           size_t sizeof_element, size_t nmemb )
+{
+    char * a = array;
+
+    memmove( a + sizeof_element * index_to_remove,
+             a + sizeof_element * ( index_to_remove  + 1 ),
+             sizeof_element * ( --nmemb - index_to_remove ) );
+}

trunk/libtransmission/utils.h

@@ -425 +425 @@
 
 /** on success, return 0.  on failure, return -1 and set errno */
-int tr_moveFile( const char * oldpath, const char * newpath, tr_bool * renamed ) TR_GNUC_NONNULL(1,2);
-
+int tr_moveFile( const char * oldpath, const char * newpath,
+                 tr_bool * renamed ) TR_GNUC_NONNULL(1,2);
+
+void tr_removeElementFromArray( void * array, int index_to_remove,
+                                size_t sizeof_element, size_t nmemb );
 
 #ifdef __cplusplus