Changeset 7767

Timestamp:

Jan 20, 2009, 6:31:37 PM (12 years ago)

Author:

charles

Message:

(1.5x) backport trunk changes to 1.5x branch

Location:

branches/1.5x

Files:

• daemon/remote.c (modified) (3 diffs)
• daemon/transmission-remote.1 (modified) (2 diffs)
• gtk/main.c (modified) (1 diff)
• gtk/util.c (modified) (2 diffs)
• libtransmission/ConvertUTF.c (modified) (2 diffs)
• libtransmission/ConvertUTF.h (modified) (2 diffs)
• libtransmission/bandwidth.c (modified) (1 diff)
• libtransmission/fdlimit.c (modified) (1 diff)
• libtransmission/peer-io.c (modified) (11 diffs)
• libtransmission/peer-io.h (modified) (3 diffs)
• libtransmission/peer-mgr.c (modified) (9 diffs)
• libtransmission/rpc-server.c (modified) (3 diffs)
• libtransmission/rpcimpl.c (modified) (21 diffs)
• libtransmission/rpcimpl.h (modified) (1 diff)
• libtransmission/utils-test.c (modified) (1 diff)
• libtransmission/utils.c (modified) (3 diffs)
• libtransmission/utils.h (modified) (1 diff)

branches/1.5x/daemon/remote.c

@@ -59 +59 @@
 static tr_option opts[] =
 {
-    { 'a', "add",                  "Add torrent files", "a",  0, NULL },
+    { 'a', "add",                  "Add torrent files by filename or URL", "a",  0, NULL },
     { 'b', "debug",                "Print debugging information", "b",  0, NULL },
     { 'd', "downlimit",            "Set the maximum global download speed in KB/s", "d",  1, "<speed>" },
@@ -301 +301 @@
                     else
                     {
-                        fprintf( stderr, "Couldn't add file: %s\n", optarg );
-                        addArg = FALSE;
+                        tr_bencDictAddStr( &top, "method", "torrent-add" );
+                        tr_bencDictAddStr( args, "filename", optarg );
                     }
                 }
@@ -947 +947 @@
                         }
                         printf( "%3d: %3.0f%% %-8s %-3s %9s  %s\n",
-                                ( j + 1 ),
+                                j,
                                 ( 100.0 * percent ),
                                 pristr,

branches/1.5x/daemon/transmission-remote.1

@@ -12 +12 @@
 .Nm
 .Op Ar host:port | host | port
-.Op Fl a Ar torrent-files
+.Op Fl a Ar filenames-or-URLs
 .Op Fl b
 .Op Fl d Ar number | Fl D
@@ -52 +52 @@
 .Sh OPTIONS
 .Bl -tag -width Ds
-.It Fl a Fl -add Ar torrent-file(s)
-Add
-.Ar torrent-file(s)
-into transmission.
+.It Fl a Fl -add Ar filenames-or-URLs
+Add torrents to transmission.
 
 .It Fl b Fl -debug

branches/1.5x/gtk/main.c

@@ -1381 +1381 @@
     tr_session * session = tr_core_session( data->core );
     const char * cmd = "{ \"method\": \"torrent-stop\" }";
-    tr_rpc_request_exec_json( session, cmd, strlen( cmd ), NULL );
+    tr_rpc_request_exec_json( session, cmd, strlen( cmd ), NULL, NULL );
 }
 

branches/1.5x/gtk/util.c

@@ -24 +24 @@
 
 #include <ctype.h> /* isxdigit() */
+#include <errno.h>
 #include <stdarg.h>
 #include <stdlib.h> /* free() */
@@ -522 +523 @@
         gboolean trashed = FALSE;
 #ifdef HAVE_GIO
+        GError * err = NULL;
         GFile *  file = g_file_new_for_path( filename );
-        trashed = g_file_trash( file, NULL, NULL );
+        trashed = g_file_trash( file, NULL, &err );
+        if( err )
+            g_message( "Unable to trash file \"%s\": %s", filename, err->message );
+        g_clear_error( &err );
         g_object_unref( G_OBJECT( file ) );
-#endif
-        if( !trashed )
-            g_unlink( filename );
+       
+        
+#endif
+        if( !trashed ) {
+            if( g_unlink( filename ) ) {
+                const int err = errno;
+                g_message( "Unable to unlink file \"%s\": %s", filename, g_strerror( err ) );
+            }
+        }
     }
 

branches/1.5x/libtransmission/ConvertUTF.c

@@ -44 +44 @@
 #endif
 #include <string.h> /* strlen() */
-#include <unistd.h> /* ssize_t */
 #include "ConvertUTF.h"
 
@@ -352 +351 @@
  */
 Boolean
-tr_utf8_validate( const char * str, ssize_t max_len, const char ** end )
+tr_utf8_validate( const char * str, int max_len, const char ** end )
 {
     const UTF8* source = (const UTF8*) str;

branches/1.5x/libtransmission/ConvertUTF.h

@@ -5 +5 @@
 #error only libtransmission should #include this header.
 #endif
-
-#include <unistd.h> /* ssize_t */
 
 /*
@@ -154 +152 @@
 
 /* intended to work the same as g_utf8_validate */
-Boolean tr_utf8_validate( const char * str, ssize_t max_len, const char ** end );
+Boolean tr_utf8_validate( const char * str, int max_len, const char ** end );
 
 

branches/1.5x/libtransmission/bandwidth.c

@@ -224 +224 @@
     {
         const size_t increment = 1024;
-        const ssize_t bytesUsed = tr_peerIoFlush( peers[i], dir, increment );
-
-        dbgmsg( "peer #%d of %d used %zd bytes in this pass", i, n, bytesUsed );
-
-        if( bytesUsed == (ssize_t)increment )
+        const int bytesUsed = tr_peerIoFlush( peers[i], dir, increment );
+
+        dbgmsg( "peer #%d of %d used %d bytes in this pass", i, n, bytesUsed );
+
+        if( bytesUsed == (int)increment )
             ++i;
         else {

branches/1.5x/libtransmission/fdlimit.c

@@ -612 +612 @@
     tr_lockFree( gFd->lock );
 
+    tr_free( gFd->openFiles );
     tr_free( gFd );
     gFd = NULL;

branches/1.5x/libtransmission/peer-io.c

@@ -191 +191 @@
     assert( tr_isPeerIo( io ) );
 
+    io->hasFinishedConnecting = TRUE;
+
     curlen = EVBUFFER_LENGTH( io->inbuf );
     howmuch = curlen >= max ? 0 : max - curlen;
@@ -235 +237 @@
 }
 
-static ssize_t
+static int
 tr_evbuffer_write( tr_peerIo * io, int fd, size_t howmuch )
 {
     int e;
-    ssize_t n;
+    int n;
     struct evbuffer * buffer = io->outbuf;
 
@@ -246 +248 @@
     errno = 0;
 #ifdef WIN32
-    n = send(fd, buffer->buffer, howmuch,  0 );
+    n = (int) send(fd, buffer->buffer, howmuch,  0 );
 #else
-    n = write(fd, buffer->buffer, howmuch );
+    n = (int) write(fd, buffer->buffer, howmuch );
 #endif
     e = errno;
-    dbgmsg( io, "wrote %zd to peer (%s)", n, (n==-1?strerror(e):"") );
+    dbgmsg( io, "wrote %d to peer (%s)", n, (n==-1?strerror(e):"") );
 
     if( n > 0 )
@@ -270 +272 @@
 
     assert( tr_isPeerIo( io ) );
+
+    io->hasFinishedConnecting = TRUE;
 
     dbgmsg( io, "libevent says this peer is ready to write" );
@@ -353 +357 @@
     io->socket = socket;
     io->isIncoming = isIncoming != 0;
+    io->hasFinishedConnecting = FALSE;
     io->timeCreated = time( NULL );
     io->inbuf = evbuffer_new( );
@@ -758 +763 @@
 ***/
 
-static ssize_t
+static int
 tr_peerIoTryRead( tr_peerIo * io, size_t howmuch )
 {
-    ssize_t res = 0;
+    int res = 0;
 
     if(( howmuch = tr_bandwidthClamp( &io->bandwidth, TR_DOWN, howmuch )))
@@ -770 +775 @@
         e = errno;
 
-        dbgmsg( io, "read %zd from peer (%s)", res, (res==-1?strerror(e):"") );
+        dbgmsg( io, "read %d from peer (%s)", res, (res==-1?strerror(e):"") );
 
         if( EVBUFFER_LENGTH( io->inbuf ) )
@@ -780 +785 @@
             if( res == 0 )
                 what |= EVBUFFER_EOF;
-            dbgmsg( io, "tr_peerIoTryRead got an error. res is %zd, what is %hd, errno is %d (%s)", res, what, e, strerror( e ) );
+            dbgmsg( io, "tr_peerIoTryRead got an error. res is %d, what is %hd, errno is %d (%s)", res, what, e, strerror( e ) );
             io->gotError( io, what, io->userData );
         }
@@ -788 +793 @@
 }
 
-static ssize_t
+static int
 tr_peerIoTryWrite( tr_peerIo * io, size_t howmuch )
 {
-    ssize_t n = 0;
+    int n = 0;
 
     if(( howmuch = tr_bandwidthClamp( &io->bandwidth, TR_UP, howmuch )))
@@ -806 +811 @@
         {
             const short what = EVBUFFER_WRITE | EVBUFFER_ERROR;
-            dbgmsg( io, "tr_peerIoTryWrite got an error. res is %zd, what is %hd, errno is %d (%s)", n, what, e, strerror( e ) );
+            dbgmsg( io, "tr_peerIoTryWrite got an error. res is %d, what is %hd, errno is %d (%s)", n, what, e, strerror( e ) );
             io->gotError( io, what, io->userData );
         }
@@ -814 +819 @@
 }
 
-ssize_t
+int
 tr_peerIoFlush( tr_peerIo  * io, tr_direction dir, size_t limit )
 {
-    ssize_t bytesUsed;
+    int bytesUsed = 0;
 
     assert( tr_isPeerIo( io ) );
     assert( tr_isDirection( dir ) );
 
-    if( dir == TR_DOWN )
-        bytesUsed = tr_peerIoTryRead( io, limit );
-    else
-        bytesUsed = tr_peerIoTryWrite( io, limit );
-
-    dbgmsg( io, "flushing peer-io, direction %d, limit %zu, bytesUsed %zd", (int)dir, limit, bytesUsed );
+    if( io->hasFinishedConnecting )
+    {
+        if( dir == TR_DOWN )
+            bytesUsed = tr_peerIoTryRead( io, limit );
+        else
+            bytesUsed = tr_peerIoTryWrite( io, limit );
+    }
+
+    dbgmsg( io, "flushing peer-io, direction %d, limit %zu, bytesUsed %d", (int)dir, limit, bytesUsed );
     return bytesUsed;
 }

branches/1.5x/libtransmission/peer-io.h

@@ -65 +65 @@
     tr_bool               fastExtensionSupported;
 
+    /* we create the socket in a nonblocking way, so this flag is initially
+     * false and then set to true when libevent says that the socket is ready
+     * for reading or writing */
+    tr_bool               hasFinishedConnecting;
+
     int                   magicNumber;
 
@@ -72 +77 @@
     int                   socket;
 
-    ssize_t               refCount;
+    int                   refCount;
 
     uint8_t               peerId[SHA_DIGEST_LENGTH];
@@ -356 +361 @@
                                tr_bool        isEnabled );
                        
-ssize_t   tr_peerIoFlush( tr_peerIo     * io,
+int       tr_peerIoFlush( tr_peerIo     * io,
                           tr_direction    dir,
                           size_t          byteLimit );

branches/1.5x/libtransmission/peer-mgr.c

@@ -1984 +1984 @@
 ***/
 
-static int
-shouldPeerBeClosed( const Torrent * t,
-                    const tr_peer * peer,
-                    int             peerCount )
+typedef enum
+{
+    TR_CAN_KEEP,
+    TR_CAN_CLOSE,
+    TR_MUST_CLOSE,
+}
+tr_close_type_t;
+
+static tr_close_type_t
+shouldPeerBeClosed( const Torrent    * t,
+                    const tr_peer    * peer,
+                    int                peerCount )
 {
     const tr_torrent *       tor = t->tor;
@@ -1998 +2006 @@
         tordbg( t, "purging peer %s because its doPurge flag is set",
                 tr_peerIoAddrStr( &atom->addr, atom->port ) );
-        return TRUE;
+        return TR_MUST_CLOSE;
     }
 
@@ -2021 +2029 @@
             tordbg( t, "purging peer %s because we're both seeds",
                     tr_peerIoAddrStr( &atom->addr, atom->port ) );
-            return TRUE;
+            return TR_MUST_CLOSE;
         }
     }
@@ -2032 +2040 @@
          * if we have zero connections, strictness is 0% */
         const float strictness = peerCount >= relaxStrictnessIfFewerThanN
-            ? 1.0
-            : peerCount / (float)relaxStrictnessIfFewerThanN;
+                               ? 1.0
+                               : peerCount / (float)relaxStrictnessIfFewerThanN;
         const int lo = MIN_UPLOAD_IDLE_SECS;
         const int hi = MAX_UPLOAD_IDLE_SECS;
@@ -2042 +2050 @@
             tordbg( t, "purging peer %s because it's been %d secs since we shared anything",
                        tr_peerIoAddrStr( &atom->addr, atom->port ), idleTime );
-            return TRUE;
-        }
-    }
-
-    return FALSE;
+            return TR_CAN_CLOSE;
+        }
+    }
+
+    return TR_CAN_KEEP;
 }
 
 static tr_peer **
-getPeersToClose( Torrent * t, int * setmeSize )
+getPeersToClose( Torrent * t, tr_close_type_t closeType, int * setmeSize )
 {
     int i, peerCount, outsize;
@@ -2059 +2067 @@
 
     for( i = outsize = 0; i < peerCount; ++i )
-        if( shouldPeerBeClosed( t, peers[i], peerCount ) )
+        if( shouldPeerBeClosed( t, peers[i], peerCount ) == closeType )
             ret[outsize++] = peers[i];
 
@@ -2187 +2195 @@
 }
 
+static void
+closePeer( Torrent * t, tr_peer * peer )
+{
+    struct peer_atom * atom;
+
+    assert( t != NULL );
+    assert( peer != NULL );
+
+    /* if we transferred piece data, then they might be good peers,
+       so reset their `numFails' weight to zero.  otherwise we connected
+       to them fruitlessly, so mark it as another fail */
+    atom = getExistingAtom( t, &peer->addr );
+    if( atom->piece_data_time )
+        atom->numFails = 0;
+    else
+        ++atom->numFails;
+
+    tordbg( t, "removing bad peer %s", tr_peerIoGetAddrStr( peer->io ) );
+    removePeer( t, peer );
+}
+
 static int
 reconnectPulse( void * vtorrent )
@@ -2210 +2239 @@
     else
     {
-        int i, nCandidates, nBad;
-        struct peer_atom ** candidates = getPeerCandidates( t, &nCandidates );
-        struct tr_peer ** connections = getPeersToClose( t, &nBad );
-
-        //if( nBad || nCandidates )
-            tordbg( t, "reconnect pulse for [%s]: %d bad connections, "
-                    "%d connection candidates, %d atoms, max per pulse is %d",
-                    t->tor->info.name, nBad, nCandidates,
-                    tr_ptrArraySize( &t->pool ),
-                    (int)MAX_RECONNECTIONS_PER_PULSE );
-
-        /* disconnect some peers.
-           if we transferred piece data, then they might be good peers,
-           so reset their `numFails' weight to zero.  otherwise we connected
-           to them fruitlessly, so mark it as another fail */
-        for( i = 0; i < nBad; ++i ) {
-            tr_peer * peer = connections[i];
-            struct peer_atom * atom = getExistingAtom( t, &peer->addr );
-            if( atom->piece_data_time )
-                atom->numFails = 0;
-            else
-                ++atom->numFails;
-            tordbg( t, "removing bad peer %s", tr_peerIoGetAddrStr( peer->io ) );
-            removePeer( t, peer );
-        }
-
-tordbg( t, "nCandidates is %d, MAX_RECONNECTIONS_PER_PULSE is %d, getPeerCount(t) is %d, getMaxPeerCount(t) is %d, newConnectionsThisSecond is %d, MAX_CONNECTIONS_PER_SECOND is %d",
-        (int)nCandidates, (int)MAX_RECONNECTIONS_PER_PULSE, (int)getPeerCount( t ), (int)getMaxPeerCount( t->tor ), (int)newConnectionsThisSecond, (int)MAX_CONNECTIONS_PER_SECOND );
+        int i;
+        int canCloseCount;
+        int mustCloseCount;
+        int candidateCount;
+        int maxCandidates;
+        struct tr_peer ** canClose = getPeersToClose( t, TR_CAN_CLOSE, &canCloseCount );
+        struct tr_peer ** mustClose = getPeersToClose( t, TR_MUST_CLOSE, &mustCloseCount );
+        struct peer_atom ** candidates = getPeerCandidates( t, &candidateCount );
+
+        tordbg( t, "reconnect pulse for [%s]: "
+                   "%d must-close connections, "
+                   "%d can-close connections, "
+                   "%d connection candidates, "
+                   "%d atoms, "
+                   "max per pulse is %d",
+                   t->tor->info.name,
+                   mustCloseCount,
+                   canCloseCount,
+                   candidateCount,
+                   tr_ptrArraySize( &t->pool ),
+                   MAX_RECONNECTIONS_PER_PULSE );
+
+        /* disconnect the really bad peers */
+        for( i=0; i<mustCloseCount; ++i )
+            closePeer( t, mustClose[i] );
+
+        /* decide how many peers can we try to add in this pass */
+        maxCandidates = candidateCount;
+        maxCandidates = MIN( maxCandidates, MAX_RECONNECTIONS_PER_PULSE );
+        maxCandidates = MIN( maxCandidates, getMaxPeerCount( t->tor ) - getPeerCount( t ) );
+        maxCandidates = MIN( maxCandidates, MAX_CONNECTIONS_PER_SECOND - newConnectionsThisSecond );
+
+        /* maybe disconnect some lesser peers, if we have candidates to replace them with */
+        for( i=0; ( i<canCloseCount ) && ( i<maxCandidates ); ++i )
+            closePeer( t, canClose[i] );
+
+        tordbg( t, "candidateCount is %d, MAX_RECONNECTIONS_PER_PULSE is %d,"
+                   " getPeerCount(t) is %d, getMaxPeerCount(t) is %d, "
+                   "newConnectionsThisSecond is %d, MAX_CONNECTIONS_PER_SECOND is %d",
+                   candidateCount,
+                   MAX_RECONNECTIONS_PER_PULSE,
+                   getPeerCount( t ),
+                   getMaxPeerCount( t->tor ),
+                   newConnectionsThisSecond, MAX_CONNECTIONS_PER_SECOND );
 
         /* add some new ones */
-        for( i = 0;    ( i < nCandidates )
-           && ( i < MAX_RECONNECTIONS_PER_PULSE )
-           && ( getPeerCount( t ) < getMaxPeerCount( t->tor ) )
-           && ( newConnectionsThisSecond < MAX_CONNECTIONS_PER_SECOND ); ++i )
+        for( i=0; i<maxCandidates; ++i )
         {
-            tr_peerMgr *       mgr = t->manager;
-            struct peer_atom * atom = candidates[i];
-            tr_peerIo *        io;
+            tr_peerMgr        * mgr = t->manager;
+            struct peer_atom  * atom = candidates[i];
+            tr_peerIo         * io;
 
             tordbg( t, "Starting an OUTGOING connection with %s",
@@ -2281 +2323 @@
 
         /* cleanup */
-        tr_free( connections );
         tr_free( candidates );
+        tr_free( mustClose );
+        tr_free( canClose );
     }
 

branches/1.5x/libtransmission/rpc-server.c

@@ -177 +177 @@
                                                   EVBUFFER_DATA( json ),
                                                   EVBUFFER_LENGTH( json ),
-                                                  NULL );
+                                                  NULL, NULL );
 
                         tr_releaseBuffer( json );
@@ -375 +375 @@
 }
 
+struct rpc_response_data
+{
+    struct evhttp_request * req;
+    struct tr_rpc_server  * server;
+};
+
+static void
+rpc_response_func( tr_session      * session UNUSED,
+                   const char      * response,
+                   size_t            response_len,
+                   void            * user_data )
+{
+    struct rpc_response_data * data = user_data;
+    struct evbuffer * buf = tr_getBuffer( );
+
+    add_response( data->req, data->server, buf, response, response_len );
+    evhttp_add_header( data->req->output_headers,
+                           "Content-Type", "application/json; charset=UTF-8" );
+    evhttp_send_reply( data->req, HTTP_OK, "OK", buf );
+
+    tr_releaseBuffer( buf );
+    tr_free( data );
+}
+
+
 static void
 handle_rpc( struct evhttp_request * req,
             struct tr_rpc_server  * server )
 {
-    struct evbuffer * response = tr_getBuffer( );
-
+    struct rpc_response_data * data = tr_new0( struct rpc_response_data, 1 );
+
+    data->req = req;
+    data->server = server;
+    
     if( req->type == EVHTTP_REQ_GET )
     {
         const char * q;
         if( ( q = strchr( req->uri, '?' ) ) )
-            tr_rpc_request_exec_uri( server->session, q + 1, strlen( q + 1 ), response );
+            tr_rpc_request_exec_uri( server->session, q+1, -1, rpc_response_func, data );
     }
     else if( req->type == EVHTTP_REQ_POST )
@@ -392 +420 @@
                                   EVBUFFER_DATA( req->input_buffer ),
                                   EVBUFFER_LENGTH( req->input_buffer ),
-                                  response );
-    }
-
-    {
-        struct evbuffer * buf = tr_getBuffer( );
-        add_response( req, server, buf,
-                      EVBUFFER_DATA( response ),
-                      EVBUFFER_LENGTH( response ) );
-        evhttp_add_header( req->output_headers, "Content-Type",
-                                                "application/json; charset=UTF-8" );
-        evhttp_send_reply( req, HTTP_OK, "OK", buf );
-        tr_releaseBuffer( buf );
-    }
-
-    /* cleanup */
-    tr_releaseBuffer( response );
+                                  rpc_response_func, data );
+    }
+
 }
 

branches/1.5x/libtransmission/rpcimpl.c

@@ -16 +16 @@
 #include <string.h> /* strcmp */
 
+#include <event.h> /* evbuffer */
+
 #include "transmission.h"
 #include "bencode.h"
@@ -21 +23 @@
 #include "json.h"
 #include "session.h"
+#include "stats.h"
 #include "torrent.h"
 #include "utils.h"
+#include "web.h"
 
 #define TR_N_ELEMENTS( ary ) ( sizeof( ary ) / sizeof( *ary ) )
+
+#if 0
+#define dbgmsg(fmt, ...) \
+    do { \
+        fprintf( stderr, "%s:%d"#fmt, __FILE__, __LINE__, __VA_ARGS__ ); \
+        fprintf( stderr, "\n" ); \
+    } while( 0 )
+#else
+#define dbgmsg( ... ) \
+    do { \
+        if( tr_deepLoggingIsActive( ) ) \
+            tr_deepLog( __FILE__, __LINE__, "RPC", __VA_ARGS__ ); \
+    } while( 0 )
+#endif
+
 
 /***
@@ -42 +61 @@
 
     return status;
+}
+
+/***
+****
+***/
+
+/* For functions that can't be immediately executed, like torrentAdd,
+ * this is the callback data used to pass a response to the caller
+ * when the task is complete */
+struct tr_rpc_idle_data
+{
+    tr_session            * session;
+    tr_benc               * response;
+    tr_benc               * args_out;
+    tr_rpc_response_func    callback;
+    void                  * callback_user_data;
+};
+
+static void
+tr_idle_function_done( struct tr_rpc_idle_data * data, const char * result )
+{
+    struct evbuffer * buf = tr_getBuffer( );
+
+    if( result == NULL )
+        result = "success";
+    tr_bencDictAddStr( data->response, "result", result );
+
+    tr_bencSaveAsJSON( data->response, buf );
+    (*data->callback)( data->session, (const char*)EVBUFFER_DATA(buf),
+                       EVBUFFER_LENGTH(buf), data->callback_user_data );
+
+    tr_releaseBuffer( buf );
+    tr_bencFree( data->response );
+    tr_free( data->response );
+    tr_free( data );
 }
 
@@ -100 +154 @@
 
 static const char*
-torrentStart( tr_session * session,
-              tr_benc    * args_in,
-              tr_benc    * args_out UNUSED )
+torrentStart( tr_session               * session,
+              tr_benc                  * args_in,
+              tr_benc                  * args_out UNUSED,
+              struct tr_rpc_idle_data  * idle_data )
 {
     int           i, torrentCount;
     tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+
+    assert( idle_data == NULL );
 
     for( i = 0; i < torrentCount; ++i )
@@ -118 +175 @@
 
 static const char*
-torrentStop( tr_session * session,
-             tr_benc    * args_in,
-             tr_benc    * args_out UNUSED )
+torrentStop( tr_session               * session,
+             tr_benc                  * args_in,
+             tr_benc                  * args_out UNUSED,
+             struct tr_rpc_idle_data  * idle_data )
 {
     int           i, torrentCount;
     tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+
+    assert( idle_data == NULL );
 
     for( i = 0; i < torrentCount; ++i )
@@ -136 +196 @@
 
 static const char*
-torrentRemove( tr_session  * session,
-               tr_benc     * args_in,
-               tr_benc     * args_out UNUSED )
+torrentRemove( tr_session               * session,
+               tr_benc                  * args_in,
+               tr_benc                  * args_out UNUSED,
+               struct tr_rpc_idle_data  * idle_data )
 {
     int i;
     int torrentCount;
     tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+
+    assert( idle_data == NULL );
 
     for( i=0; i<torrentCount; ++i )
@@ -160 +223 @@
 
 static const char*
-torrentVerify( tr_session  * session,
-               tr_benc     * args_in,
-               tr_benc     * args_out UNUSED )
+torrentVerify( tr_session               * session,
+               tr_benc                  * args_in,
+               tr_benc                  * args_out UNUSED,
+               struct tr_rpc_idle_data  * idle_data )
 {
     int           i, torrentCount;
     tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+
+    assert( idle_data == NULL );
 
     for( i = 0; i < torrentCount; ++i )
@@ -436 +502 @@
 
 static const char*
-torrentGet( tr_session * session,
-            tr_benc    * args_in,
-            tr_benc    * args_out )
+torrentGet( tr_session               * session,
+            tr_benc                  * args_in,
+            tr_benc                  * args_out,
+            struct tr_rpc_idle_data  * idle_data )
 {
     int           i, torrentCount;
     tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
-    tr_benc *     list = tr_bencDictAddList( args_out, "torrents",
-                                             torrentCount );
+    tr_benc *     list = tr_bencDictAddList( args_out, "torrents", torrentCount );
     tr_benc *     fields;
     char *        msg = NULL;
+
+    assert( idle_data == NULL );
 
     if( !tr_bencDictFindList( args_in, "fields", &fields ) )
@@ -523 +591 @@
 
 static const char*
-torrentSet( tr_session * session,
-            tr_benc    * args_in,
-            tr_benc    * args_out UNUSED )
+torrentSet( tr_session               * session,
+            tr_benc                  * args_in,
+            tr_benc                  * args_out UNUSED,
+            struct tr_rpc_idle_data  * idle_data )
 {
     int           i, torrentCount;
     tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+
+    assert( idle_data == NULL );
 
     for( i = 0; i < torrentCount; ++i )
@@ -571 +642 @@
 ***/
 
+static void
+addTorrentImpl( struct tr_rpc_idle_data * data, tr_ctor * ctor )
+{
+    int err = 0;
+    const char * result = NULL;
+    tr_torrent * tor = tr_torrentNew( data->session, ctor, &err );
+
+    tr_ctorFree( ctor );
+
+    if( tor )
+    {
+        tr_benc fields;
+        tr_bencInitList( &fields, 3 );
+        tr_bencListAddStr( &fields, "id" );
+        tr_bencListAddStr( &fields, "name" );
+        tr_bencListAddStr( &fields, "hashString" );
+        addInfo( tor, tr_bencDictAdd( data->args_out, "torrent-added" ), &fields );
+        notify( data->session, TR_RPC_TORRENT_ADDED, tor );
+        tr_bencFree( &fields );
+    }
+    else if( err == TR_EDUPLICATE )
+    {
+        result = "duplicate torrent";
+    }
+    else if( err == TR_EINVALID )
+    {
+        result = "invalid or corrupt torrent file";
+    }
+
+    tr_idle_function_done( data, result );
+}
+
+
+struct add_torrent_idle_data
+{
+    struct tr_rpc_idle_data * data;
+    tr_ctor * ctor;
+};
+
+static void
+gotMetadataFromURL( tr_session       * session UNUSED,
+                    long               response_code,
+                    const void       * response,
+                    size_t             response_byte_count,
+                    void             * user_data )
+{
+    struct add_torrent_idle_data * data = user_data;
+
+    dbgmsg( "torrentAdd: HTTP response code was %ld (%s); response length was %zu bytes",
+            response_code, tr_webGetResponseStr( response_code ), response_byte_count );
+
+    if( response_code == 200 )
+    {
+        tr_ctorSetMetainfo( data->ctor, response, response_byte_count );
+        addTorrentImpl( data->data, data->ctor );
+    }
+    else
+    {
+        char result[1024];
+        tr_snprintf( result, sizeof( result ), "http error %ld: %s",
+                     response_code, tr_webGetResponseStr( response_code ) );
+        tr_idle_function_done( data->data, result );
+    }
+
+    tr_free( data );
+}
+
+static tr_bool
+isCurlURL( const char * filename )
+{
+    if( filename == NULL )
+        return FALSE;
+
+    return ( strstr( filename, "ftp://" ) != NULL )
+        || ( strstr( filename, "http://" ) != NULL )
+        || ( strstr( filename, "https://" ) != NULL );
+}
+
 static const char*
-torrentAdd( tr_session * session,
-            tr_benc    * args_in,
-            tr_benc    * args_out )
+torrentAdd( tr_session               * session,
+            tr_benc                  * args_in,
+            tr_benc                  * args_out UNUSED,
+            struct tr_rpc_idle_data  * idle_data )
 {
     const char * filename = NULL;
     const char * metainfo_base64 = NULL;
+
+    assert( idle_data != NULL );
 
     tr_bencDictFindStr( args_in, "filename", &filename );
@@ -586 +738 @@
     {
         int64_t      i;
-        int          err = 0;
         const char * str;
-        tr_ctor *    ctor;
-        tr_torrent * tor;
-
-        ctor = tr_ctorNew( session );
-
-        /* set the metainfo */
-        if( filename )
-            tr_ctorSetMetainfoFromFile( ctor, filename );
-        else
-        {
-            int    len;
-            char * metainfo = tr_base64_decode( metainfo_base64, -1,  &len );
-            tr_ctorSetMetainfo( ctor, (uint8_t*)metainfo, len );
-            tr_free( metainfo );
-        }
+        tr_ctor    * ctor = tr_ctorNew( session );
 
         /* set the optional arguments */
@@ -612 +749 @@
             tr_ctorSetPeerLimit( ctor, TR_FORCE, i );
 
-        tor = tr_torrentNew( session, ctor, &err );
-        tr_ctorFree( ctor );
-
-        if( tor )
+        dbgmsg( "torrentAdd: filename is \"%s\"", filename );
+
+        if( isCurlURL( filename ) )
         {
-            tr_benc fields;
-            tr_bencInitList( &fields, 3 );
-            tr_bencListAddStr( &fields, "id" );
-            tr_bencListAddStr( &fields, "name" );
-            tr_bencListAddStr( &fields, "hashString" );
-            addInfo( tor, tr_bencDictAdd( args_out,
-                                          "torrent-added" ), &fields );
-            notify( session, TR_RPC_TORRENT_ADDED, tor );
-            tr_bencFree( &fields );
+            struct add_torrent_idle_data * d = tr_new0( struct add_torrent_idle_data, 1 );
+            d->data = idle_data;
+            d->ctor = ctor;
+            tr_webRun( session, filename, NULL, gotMetadataFromURL, d );
         }
-        else if( err == TR_EDUPLICATE )
+        else
         {
-            return "duplicate torrent";
+            if( filename != NULL )
+                tr_ctorSetMetainfoFromFile( ctor, filename );
+            else {
+                int len;
+                char * metainfo = tr_base64_decode( metainfo_base64, -1,  &len );
+                tr_ctorSetMetainfo( ctor, (uint8_t*)metainfo, len );
+                tr_free( metainfo );
+            }
+            addTorrentImpl( idle_data, ctor );
         }
-        else if( err == TR_EINVALID )
-        {
-            return "invalid or corrupt torrent file";
-        }
+
     }
 
@@ -645 +781 @@
 
 static const char*
-sessionSet( tr_session * session,
-            tr_benc    * args_in,
-            tr_benc    * args_out UNUSED )
+sessionSet( tr_session               * session,
+            tr_benc                  * args_in,
+            tr_benc                  * args_out UNUSED,
+            struct tr_rpc_idle_data  * idle_data )
 {
     int64_t      i;
     const char * str;
+
+    assert( idle_data == NULL );
 
     if( tr_bencDictFindStr( args_in, "download-dir", &str ) )
@@ -686 +825 @@
 
 static const char*
-sessionStats( tr_session  * session,
-              tr_benc     * args_in UNUSED,
-              tr_benc     * args_out )
+sessionStats( tr_session               * session,
+              tr_benc                  * args_in UNUSED,
+              tr_benc                  * args_out,
+              struct tr_rpc_idle_data  * idle_data )
 {
     int running = 0;
     int total = 0;
+    tr_benc * d;  
+    tr_session_stats currentStats = { 0.0f, 0, 0, 0, 0, 0 }; 
+    tr_session_stats cumulativeStats = { 0.0f, 0, 0, 0, 0, 0 }; 
     tr_torrent * tor = NULL;
+
+    assert( idle_data == NULL );
 
     while(( tor = tr_torrentNext( session, tor ))) {
@@ -699 +844 @@
             ++running;
     }
+
+    tr_sessionGetStats( session, &currentStats ); 
+    tr_sessionGetCumulativeStats( session, &cumulativeStats ); 
 
     tr_bencDictAddInt( args_out, "activeTorrentCount", running );
@@ -705 +853 @@
     tr_bencDictAddInt( args_out, "torrentCount", total );
     tr_bencDictAddInt( args_out, "uploadSpeed", (int)( tr_sessionGetPieceSpeed( session, TR_UP ) * 1024 ) );
+
+    d = tr_bencDictAddDict( args_out, "cumulative-stats", 5 );  
+    tr_bencDictAddInt( d, "downloadedBytes", cumulativeStats.downloadedBytes ); 
+    tr_bencDictAddInt( d, "filesAdded", cumulativeStats.filesAdded ); 
+    tr_bencDictAddInt( d, "secondsActive", cumulativeStats.secondsActive ); 
+    tr_bencDictAddInt( d, "sessionCount", cumulativeStats.sessionCount ); 
+    tr_bencDictAddInt( d, "uploadedBytes", cumulativeStats.uploadedBytes ); 
+
+    d = tr_bencDictAddDict( args_out, "current-stats", 5 );  
+    tr_bencDictAddInt( d, "downloadedBytes", currentStats.downloadedBytes ); 
+    tr_bencDictAddInt( d, "filesAdded", currentStats.filesAdded ); 
+    tr_bencDictAddInt( d, "secondsActive", currentStats.secondsActive ); 
+    tr_bencDictAddInt( d, "sessionCount", currentStats.sessionCount ); 
+    tr_bencDictAddInt( d, "uploadedBytes", currentStats.uploadedBytes ); 
+
     return NULL;
 }
 
 static const char*
-sessionGet( tr_session * session,
-            tr_benc    * args_in UNUSED,
-            tr_benc    * args_out )
+sessionGet( tr_session               * session,
+            tr_benc                  * args_in UNUSED,
+            tr_benc                  * args_out,
+            struct tr_rpc_idle_data  * idle_data )
 {
     const char * str;
     tr_benc *    d = args_out;
+
+    assert( idle_data == NULL );
 
     tr_bencDictAddStr( d, "download-dir", tr_sessionGetDownloadDir( session ) );
@@ -742 +908 @@
 ***/
 
-typedef const char* ( handler )( tr_session*, tr_benc*, tr_benc* );
+typedef const char* ( *handler )( tr_session*, tr_benc*, tr_benc*, struct tr_rpc_idle_data * );
 
 static struct method
 {
     const char *  name;
-    handler *     func;
-} methods[] = {
-    { "session-get",    sessionGet          },
-    { "session-set",    sessionSet          },
-    { "session-stats",  sessionStats        },
-    { "torrent-add",    torrentAdd          },
-    { "torrent-get",    torrentGet          },
-    { "torrent-remove", torrentRemove       },
-    { "torrent-set",    torrentSet          },
-    { "torrent-start",  torrentStart        },
-    { "torrent-stop",   torrentStop         },
-    { "torrent-verify", torrentVerify       }
+    tr_bool       immediate;
+    handler       func;
+}
+methods[] =
+{
+    { "session-get",    TRUE,  sessionGet          },
+    { "session-set",    TRUE,  sessionSet          },
+    { "session-stats",  TRUE,  sessionStats        },
+    { "torrent-add",    FALSE, torrentAdd          },
+    { "torrent-get",    TRUE,  torrentGet          },
+    { "torrent-remove", TRUE,  torrentRemove       },
+    { "torrent-set",    TRUE,  torrentSet          },
+    { "torrent-start",  TRUE,  torrentStart        },
+    { "torrent-stop",   TRUE,  torrentStop         },
+    { "torrent-verify", TRUE,  torrentVerify       }
 };
 
 static void
-request_exec( tr_session       * session,
-              tr_benc          * request,
-              struct evbuffer  * response_buf )
-{
-    int64_t      i;
+noop_response_callback( tr_session * session UNUSED,
+                        const char * response UNUSED,
+                        size_t       response_len UNUSED,
+                        void       * user_data UNUSED )
+{
+}
+
+static void
+request_exec( tr_session             * session,
+              tr_benc                * request,
+              tr_rpc_response_func     callback,
+              void                   * callback_user_data )
+{
+    int i;
     const char * str;
-    tr_benc      response;
-    tr_benc *    args_in = tr_bencDictFind( request, "arguments" );
-    tr_benc *    args_out = NULL;
+    tr_benc * args_in = tr_bencDictFind( request, "arguments" );
     const char * result = NULL;
 
-    /* build the response skeleton */
-    tr_bencInitDict( &response, 3 );
-    args_out = tr_bencDictAddDict( &response, "arguments", 0 );
+    if( callback == NULL )
+        callback = noop_response_callback;
 
     /* parse the request */
     if( !tr_bencDictFindStr( request, "method", &str ) )
         result = "no method name";
-    else
-    {
+    else {
         const int n = TR_N_ELEMENTS( methods );
         for( i = 0; i < n; ++i )
             if( !strcmp( str, methods[i].name ) )
                 break;
-        result = i == n
-                 ? "method name not recognized"
-                 : ( *methods[i].func )( session, args_in, args_out );
-    }
-
-    /* serialize & return the response */
-    if( !result )
-        result = "success";
-    tr_bencDictAddStr( &response, "result", result );
-    if( tr_bencDictFindInt( request, "tag", &i ) )
-        tr_bencDictAddInt( &response, "tag", i );
-    if( response_buf != NULL )
-        tr_bencSaveAsJSON( &response, response_buf );
-    tr_bencFree( &response );
+        if( i ==n )
+            result = "method name not recognized";
+    }
+
+    /* if we couldn't figure out which method to use, return an error */
+    if( result != NULL )
+    {
+        int64_t tag;
+        tr_benc response;
+        struct evbuffer * buf = tr_getBuffer( );
+
+        tr_bencInitDict( &response, 3 );
+        tr_bencDictAddDict( &response, "arguments", 0 );
+        tr_bencDictAddStr( &response, "result", result );
+        if( tr_bencDictFindInt( request, "tag", &tag ) )
+            tr_bencDictAddInt( &response, "tag", tag );
+        tr_bencSaveAsJSON( &response, buf );
+        (*callback)( session, (const char*)EVBUFFER_DATA(buf),
+                     EVBUFFER_LENGTH( buf ), callback_user_data );
+
+        tr_releaseBuffer( buf );
+        tr_bencFree( &response );
+    }
+
+    if( methods[i].immediate )
+    {
+        int64_t tag;
+        tr_benc response;
+        tr_benc * args_out;
+        struct evbuffer * buf = tr_getBuffer( );
+
+        tr_bencInitDict( &response, 3 );
+        args_out = tr_bencDictAddDict( &response, "arguments", 0 );
+        result = (*methods[i].func)( session, args_in, args_out, NULL );
+        if( result == NULL )
+            result = "success";
+        tr_bencDictAddStr( &response, "result", result );
+        if( tr_bencDictFindInt( request, "tag", &tag ) )
+            tr_bencDictAddInt( &response, "tag", tag );
+        tr_bencSaveAsJSON( &response, buf );
+        (*callback)( session, (const char*)EVBUFFER_DATA(buf),
+                     EVBUFFER_LENGTH(buf), callback_user_data );
+
+        tr_releaseBuffer( buf );
+        tr_bencFree( &response );
+    }
+    else
+    {
+        int64_t tag;
+        struct tr_rpc_idle_data * data = tr_new0( struct tr_rpc_idle_data, 1 );
+        data->session = session;
+        data->response = tr_new0( tr_benc, 1 );
+        tr_bencInitDict( data->response, 3 );
+        if( tr_bencDictFindInt( request, "tag", &tag ) )
+            tr_bencDictAddInt( data->response, "tag", tag );
+        data->args_out = tr_bencDictAddDict( data->response, "arguments", 0 );
+        data->callback = callback;
+        data->callback_user_data = callback_user_data;
+        (*methods[i].func)( session, args_in, data->args_out, data );
+    }
 }
 
 void
-tr_rpc_request_exec_json( tr_session      * session,
-                          const void      * request_json,
-                          int               request_len,
-                          struct evbuffer * response )
+tr_rpc_request_exec_json( tr_session            * session,
+                          const void            * request_json,
+                          int                     request_len,
+                          tr_rpc_response_func    callback,
+                          void                  * callback_user_data )
 {
     tr_benc top;
@@ -815 +1036 @@
 
     have_content = !tr_jsonParse( request_json, request_len, &top, NULL );
-    request_exec( session, have_content ? &top : NULL, response );
+    request_exec( session, have_content ? &top : NULL, callback, callback_user_data );
 
     if( have_content )
@@ -854 +1075 @@
  */
 void
-tr_rpc_parse_list_str( tr_benc *    setme,
-                       const char * str_in,
-                       size_t       len )
+tr_rpc_parse_list_str( tr_benc     * setme,
+                       const char  * str_in,
+                       int           len )
 
 {
@@ -901 +1122 @@
 
 void
-tr_rpc_request_exec_uri( tr_session      * session,
-                         const void      * request_uri,
-                         int               request_len,
-                         struct evbuffer * response )
+tr_rpc_request_exec_uri( tr_session           * session,
+                         const void           * request_uri,
+                         int                    request_len,
+                         tr_rpc_response_func   callback,
+                         void                 * callback_user_data )
 {
     tr_benc      top, * args;
@@ -934 +1156 @@
     }
 
-    request_exec( session, &top, response );
+    request_exec( session, &top, callback, callback_user_data );
 
     /* cleanup */

branches/1.5x/libtransmission/rpcimpl.h

@@ -18 +18 @@
 ***/
 
-struct evbuffer;
 struct tr_benc;
 
+typedef void( *tr_rpc_response_func )( tr_session      * session,
+                                       const char      * response,
+                                       size_t            response_len,
+                                       void            * user_data );
 /* http://www.json.org/ */
-void tr_rpc_request_exec_json( tr_session       * session,
-                               const void       * request_json,
-                               int                request_len,
-                               struct evbuffer  * setme_response );
+void tr_rpc_request_exec_json( tr_session            * session,
+                               const void            * request_json,
+                               int                     request_len,
+                               tr_rpc_response_func    callback,
+                               void                  * callback_user_data );
 
 /* see the RPC spec's "Request URI Notation" section */
-void tr_rpc_request_exec_uri( tr_session        * session,
-                              const void        * request_uri,
-                               int                request_len,
-                              struct evbuffer   * setme_response );
+void tr_rpc_request_exec_uri( tr_session           * session,
+                              const void           * request_uri,
+                              int                    request_len,
+                              tr_rpc_response_func   callback,
+                              void                 * callback_user_data );
 
 void tr_rpc_parse_list_str( struct tr_benc * setme,
                             const char     * list_str,
-                            size_t           list_str_len );
+                            int              list_str_len );
 
 

branches/1.5x/libtransmission/utils-test.c

@@ -2 +2 @@
 #include <string.h> /* strcmp */
 #include "transmission.h"
-#include <unistd.h> /* ssize_t */
 #include "ConvertUTF.h" /* tr_utf8_validate*/
 #include "platform.h"

branches/1.5x/libtransmission/utils.c

@@ -638 +638 @@
 
 char*
-tr_strndup( const void * in,
-            int          len )
+tr_strndup( const void * in, int len )
 {
     char * out = NULL;
@@ -1327 +1326 @@
 
 char*
-tr_utf8clean( const char * str, ssize_t max_len, tr_bool * err )
+tr_utf8clean( const char * str, int max_len, tr_bool * err )
 {
     const char zero = '\0';
@@ -1338 +1337 @@
 
     if( max_len < 0 )
-        max_len = (ssize_t) strlen( str );
+        max_len = (int) strlen( str );
 
     while( !tr_utf8_validate ( str, max_len, &end ) )
     {
-        const ssize_t good_len = end - str;
+        const int good_len = end - str;
 
         evbuffer_add( buf, str, good_len );

branches/1.5x/libtransmission/utils.h

@@ -239 +239 @@
 
 char*          tr_utf8clean( const char  * str,
-                             ssize_t       max_len,
+                             int           max_len,
                              tr_bool     * err );