Changeset 864

Timestamp:

Sep 17, 2006, 11:00:51 PM (16 years ago)

Author:

joshe

Message:

Add nat traversal support (ie: NAT-PMP and UPnP)

Location:

branches/nat-traversal

Files:

• cli/transmissioncli.1 (modified) (2 diffs)
• cli/transmissioncli.c (modified) (8 diffs)
• gtk/conf.c (modified) (1 diff)
• gtk/conf.h (modified) (1 diff)
• gtk/dialogs.c (modified) (9 diffs)
• gtk/dialogs.h (modified) (1 diff)
• gtk/ipc.c (modified) (1 diff)
• gtk/main.c (modified) (4 diffs)
• libtransmission/bencode.c (modified) (10 diffs)
• libtransmission/bencode.h (modified) (1 diff)
• libtransmission/fastresume.h (modified) (1 diff)
• libtransmission/http.c (added)
• libtransmission/http.h (added)
• libtransmission/inout.c (modified) (1 diff)
• libtransmission/internal.h (modified) (5 diffs)
• libtransmission/metainfo.c (modified) (1 diff)
• libtransmission/natpmp.c (added)
• libtransmission/natpmp.h (added)
• libtransmission/net.c (modified) (11 diffs)
• libtransmission/net.h (modified) (3 diffs)
• libtransmission/peer.c (modified) (1 diff)
• libtransmission/peerutils.h (modified) (1 diff)
• libtransmission/platform.c (modified) (1 diff)
• libtransmission/platform.h (modified) (1 diff)
• libtransmission/tracker.c (modified) (18 diffs)
• libtransmission/transmission.c (modified) (5 diffs)
• libtransmission/transmission.h (modified) (1 diff)
• libtransmission/upnp.c (added)
• libtransmission/upnp.h (added)
• libtransmission/utils.c (modified) (6 diffs)
• libtransmission/utils.h (modified) (2 diffs)
• libtransmission/xml.c (added)
• libtransmission/xml.h (added)
• mk/common.mk (modified) (1 diff)
• mk/lib.mk (modified) (1 diff)

branches/nat-traversal/cli/transmissioncli.1

@@ -27 +27 @@
 .Op Fl s Ar torrent-file
 .Op Fl v Ar level
+.Op Fl n
 .Op Fl p Ar port
 .Op Fl u Ar upload-rate
@@ -51 +52 @@
 Sets debugging options.  The current range is 0-2, with the highest
 level producing the most output.  The default is 0.
+.It Fl n, Fl -nat-traversal
+Attempt to use the NAT-PMP and UPnP IGD protocols to establish a port
+mapping for allowing incoming peer connections.
 .It Fl p, -port Ar port
 Specifies an alternate port for the client to listen on.  The default is

branches/nat-traversal/cli/transmissioncli.c

@@ -38 +38 @@
 "Usage: %s [options] file.torrent [options]\n\n" \
 "Options:\n" \
+"  -d, --download <int> Maximum download rate (-1 = no limit, default = -1)\n"\
+"  -f, --finish <shell script> Command you wish to run on completion\n" \
 "  -h, --help           Print this help and exit\n" \
 "  -i, --info           Print metainfo and exit\n" \
+"  -n  --nat-traversal  Attempt NAT traversal using NAT-PMP or UPnP IGD\n" \
+"  -p, --port <int>     Port we should listen on (default = %d)\n" \
 "  -s, --scrape         Print counts of seeders/leechers and exit\n" \
-"  -v, --verbose <int>  Verbose level (0 to 2, default = 0)\n" \
-"  -p, --port <int>     Port we should listen on (default = %d)\n" \
 "  -u, --upload <int>   Maximum upload rate (-1 = no limit, default = 20)\n" \
-"  -d, --download <int> Maximum download rate (-1 = no limit, default = -1)\n" \
-"  -f, --finish <shell script> Command you wish to run on completion\n"
+"  -v, --verbose <int>  Verbose level (0 to 2, default = 0)\n"
 
 static int           showHelp      = 0;
@@ -56 +57 @@
 static char          * torrentPath = NULL;
 static volatile char mustDie       = 0;
+static int           natTraversal  = 0;
 
 static char          * finishCall   = NULL;
@@ -64 +66 @@
 int main( int argc, char ** argv )
 {
-    int i, error;
+    int i, error, nat;
     tr_handle_t  * h;
     tr_torrent_t * tor;
@@ -164 +166 @@
     tr_setUploadLimit( h, uploadLimit );
     tr_setDownloadLimit( h, downloadLimit );
+
+    if( natTraversal )
+    {
+        tr_natTraversalEnable( h );
+    }
+    else
+    {
+        tr_natTraversalDisable( h );
+    }
     
     tr_torrentSetFolder( tor, "." );
@@ -201 +212 @@
         memset( &string[chars], ' ', 79 - chars );
         string[79] = '\0';
-        fprintf( stderr, "\r%s", string );
+        //fprintf( stderr, "\r%s", string );
 
         if( s->error & TR_ETRACKER )
@@ -219 +230 @@
     fprintf( stderr, "\n" );
 
-    /* Try for 5 seconds to notice the tracker that we are leaving */
+    /* Try for 5 seconds to notify the tracker that we are leaving
+       and to delete any port mappings for nat traversal */
     tr_torrentStop( tor );
+    tr_natTraversalDisable( h );
     for( i = 0; i < 10; i++ )
     {
         s = tr_torrentStat( tor );
-        if( s->status & TR_STATUS_PAUSE )
-        {
-            /* The 'stopped' message was sent */
+        nat = tr_natTraversalStatus( h );
+        if( s->status & TR_STATUS_PAUSE && TR_NAT_TRAVERSAL_DISABLED == nat )
+        {
+            /* The 'stopped' tracker message was sent
+               and port mappings were deleted */
             break;
         }
@@ -254 +269 @@
             { "download", required_argument, NULL, 'd' },
             { "finish",   required_argument, NULL, 'f' },
+            { "nat-traversal", no_argument,  NULL, 'n' },
             { 0, 0, 0, 0} };
 
         int c, optind = 0;
-        c = getopt_long( argc, argv, "hisv:p:u:d:f:", long_options, &optind );
+        c = getopt_long( argc, argv, "hisv:p:u:d:f:n", long_options, &optind );
         if( c < 0 )
         {
@@ -287 +303 @@
             case 'f':
                 finishCall = optarg;
+                break;
+            case 'n':
+                natTraversal = 1;
                 break;
             default:

branches/nat-traversal/gtk/conf.c

@@ -359 +359 @@
   GError *err;
   char *datastr;
-  size_t len;
+  int len;
   gsize written;
 

branches/nat-traversal/gtk/conf.h

@@ -60 +60 @@
 #define PREF_ADDIPC             "add-behavior-ipc"
 #define PREF_MSGLEVEL           "message-level"
+#define PREF_NAT                "use-nat-traversal"
 
 #endif /* TG_CONF_H */

branches/nat-traversal/gtk/dialogs.c

@@ -42 +42 @@
 #define DEF_UPLIMIT             20
 #define DEF_USEUPLIMIT          TRUE
+#define DEF_NAT                 TRUE
 
 struct prefdata {
@@ -171 +172 @@
    GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
    GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
-  const unsigned int rowcount = 8;
+  const unsigned int rowcount = 9;
   GtkWidget *table = gtk_table_new(rowcount, 2, FALSE);
   GtkWidget *portnum = gtk_spin_button_new_with_range(1, 0xffff, 1);
+  GtkWidget *natcheck = gtk_check_button_new_with_mnemonic(
+    _("Use NAT _Traversal (NAT-PMP and UPnP)"));
   GtkWidget *dirstr = gtk_file_chooser_button_new(
     _("Choose a download directory"),
@@ -197 +200 @@
   GtkTreeIter iter;
   GtkCellRenderer *rend;
+  gboolean boolval;
+  int intval;
 
   g_free(title);
@@ -207 +212 @@
 
   data->prefwidgets = makeglist(portnum, lim[0].on, lim[0].num, lim[1].on,
-    lim[1].num, dirstr, addstd, addipc, NULL);
+    lim[1].num, dirstr, addstd, addipc, natcheck, NULL);
   data->parent = parent;
   data->back = back;
@@ -252 +257 @@
   gtk_table_attach_defaults(GTK_TABLE(table), label,           0, 1, RN(ii));
   gtk_table_attach_defaults(GTK_TABLE(table), portnum,         1, 2, RN(ii));
+  ii++;
+
+  /* NAT traversal checkbox */
+  intval = tr_natTraversalStatus(tr_backend_handle(back));
+  boolval = !TR_NAT_TRAVERSAL_IS_DISABLED( intval );
+  setupprefwidget(natcheck, PREF_NAT, boolval);
+  gtk_table_attach_defaults(GTK_TABLE(table), natcheck,        0, 2, RN(ii));
   ii++;
 
@@ -341 +353 @@
     }
 
+    applyprefs(data->back);
     /* XXX would be nice to have errno strings, are they printed to stdout? */
-
-    tr_setBindPort(tr_backend_handle(data->back),
-                   strtol(cf_getpref(PREF_PORT), NULL, 10));
-    setlimit(data->back);
   }
 
@@ -353 +362 @@
 
 void
-setlimit(TrBackend *back) {
+applyprefs(TrBackend *back) {
   struct { void (*func)(tr_handle_t*, int);
     const char *use; const char *num; gboolean defuse; long def; } lim[] = {
@@ -362 +371 @@
   };
   const char *pref;
-  unsigned int ii;
+  int ii;
   tr_handle_t *tr = tr_backend_handle(back);
-
-  for(ii = 0; ii < ALEN(lim); ii++) {
+  gboolean boolval;
+
+  /* set upload and download limits */
+  for(ii = 0; ii < (int)ALEN(lim); ii++) {
     pref = cf_getpref(lim[ii].use);
     if(!(NULL == pref ? lim[ii].defuse : strbool(pref)))
@@ -374 +385 @@
     }
   }
+
+  /* set the listening port */
+  if(NULL != (pref = cf_getpref(PREF_PORT)) &&
+     0 < (ii = strtol(pref, NULL, 10)) && 0xffff >= ii)
+    tr_setBindPort(tr, ii);
+
+  /* enable/disable NAT traversal */
+  boolval = (NULL == (pref = cf_getpref(PREF_NAT)) ? DEF_NAT : strbool(pref));
+  if( boolval )
+    tr_natTraversalEnable(tr);
+  else
+    tr_natTraversalDisable(tr);
 }
 

branches/nat-traversal/gtk/dialogs.h

@@ -33 +33 @@
 makeprefwindow(GtkWindow *parent, TrBackend *back);
 
-/* set the upload limit based on saved prefs */
+/* set various things based on saved prefs */
 void
-setlimit(TrBackend *back);
+applyprefs(TrBackend *back);
 
 /* show the "add a torrent" dialog */

branches/nat-traversal/gtk/ipc.c

@@ -264 +264 @@
 send_msg(struct constate *con, const char *name, benc_val_t *val) {
   char *buf;
-  size_t used, total;
+  int used, total;
   benc_val_t dict;
   char stupid;

branches/nat-traversal/gtk/main.c

@@ -178 +178 @@
   TrBackend *back;
   benc_val_t *state;
-  const char *pref;
-  long intval;
   GList *argfiles;
   gboolean didinit, didlock;
@@ -234 +232 @@
       back = tr_backend_new();
 
-      /* set the upload limit */
-      setlimit(back);
-
-      /* set the listening port */
-      if(NULL != (pref = cf_getpref(PREF_PORT)) &&
-         0 < (intval = strtol(pref, NULL, 10)) && 0xffff >= intval)
-        tr_setBindPort(tr_backend_handle(back), intval);
+      /* apply a few prefs */
+      applyprefs(back);
 
       makewind(mainwind, back, state, argfiles);
@@ -524 +517 @@
   tr_backend_stop_torrents(data->back);
 
+  /* shut down nat traversal */
+  tr_natTraversalDisable(tr_backend_handle(data->back));
+
   /* set things up to wait for torrents to stop */
   edata = g_new0(struct exitdata, 1);
@@ -545 +541 @@
 exitcheck(gpointer gdata) {
   struct exitdata *data = gdata;
-
-  /* keep going if we still have torrents and haven't hit the exit timeout */
+  int natstat = tr_natTraversalStatus(tr_backend_handle(data->cbdata->back));
+
+  /* keep going if we haven't hit the exit timeout and
+     we either have torrents left or nat traversal is stopping */
   if(time(NULL) - data->started < TRACKER_EXIT_TIMEOUT &&
-     !tr_backend_torrents_stopped(data->cbdata->back)) {
+     !tr_backend_torrents_stopped(data->cbdata->back) &&
+     TR_NAT_TRAVERSAL_DISABLED != natstat) {
     updatemodel(data->cbdata);
     return TRUE;

branches/nat-traversal/libtransmission/bencode.c

@@ -26 +26 @@
 
 #define LIST_SIZE   20
-#define OUTBUF_SIZE 100
-
-static int tr_bencSprintf( char ** buf, size_t * used, size_t * max,
-                           char * format, ... )
-#ifdef __GNUC__
-    __attribute__ ((format (printf, 4, 5)))
-#endif
-    ;
-
-int _tr_bencLoad( char * buf, size_t len, benc_val_t * val, char ** end )
+
+int _tr_bencLoad( char * buf, int len, benc_val_t * val, char ** end )
 {
     char * p, * e, * foo;
@@ -90 +82 @@
         cur              = &buf[1];
         str_expected     = 1;
-        while( (size_t)(cur - buf) < len && cur[0] != 'e' )
+        while( cur - buf < len && cur[0] != 'e' )
         {
             if( val->val.l.count == val->val.l.alloc )
@@ -140 +132 @@
 
         if( p != e || 0 > val->val.s.i ||
-            (size_t)(val->val.s.i) > len - ((p + 1) - buf) )
+            val->val.s.i > len - ((p + 1) - buf) )
         {
             return 1;
@@ -241 +233 @@
 }
 
-char * tr_bencSaveMalloc( benc_val_t * val, size_t * len )
+char * tr_bencSaveMalloc( benc_val_t * val, int * len )
 {
     char * buf   = NULL;
-    size_t alloc = 0;
+    int alloc = 0;
 
     *len = 0;
@@ -260 +252 @@
 }
 
-int tr_bencSave( benc_val_t * val, char ** buf, size_t * used, size_t * max )
+int tr_bencSave( benc_val_t * val, char ** buf, int * used, int * max )
 {
     int ii;    
@@ -267 +259 @@
     {
         case TYPE_INT:
-            if( tr_bencSprintf( buf, used, max, "i%"PRIu64"e", val->val.i ) )
+            if( tr_sprintf( buf, used, max, "i%"PRIu64"e", val->val.i ) )
             {
                 return 1;
@@ -278 +270 @@
                 return 1;
             }
-            if( tr_bencSprintf( buf, used, max, "%i:%s",
-                                val->val.s.i, val->val.s.s ) )
+            if( tr_sprintf( buf, used, max, "%i:%s",
+                            val->val.s.i, val->val.s.s ) )
             {
                 return 1;
@@ -287 +279 @@
         case TYPE_LIST:
         case TYPE_DICT:
-            if( tr_bencSprintf( buf, used, max,
-                                (TYPE_LIST == val->type ? "l" : "d") ) )
+            if( tr_sprintf( buf, used, max,
+                            (TYPE_LIST == val->type ? "l" : "d") ) )
             {
                 return 1;
@@ -299 +291 @@
                 }
             }
-            if( tr_bencSprintf( buf, used, max, "e" ) )
+            if( tr_sprintf( buf, used, max, "e" ) )
             {
                 return 1;
@@ -308 +300 @@
     return 0;
 }
-
-static int tr_bencSprintf( char ** buf, size_t * used, size_t * max,
-                           char * format, ... )
-{
-    va_list ap;
-    int     want;
-    char  * newbuf;
-
-    va_start( ap, format );
-    want = vsnprintf( NULL, 0, format, ap );
-    va_end(ap);
-
-    while( *used + want + 1 > *max )
-    {
-        *max += OUTBUF_SIZE;
-        newbuf = realloc( *buf, *max );
-        if( NULL == newbuf )
-        {
-            return 1;
-        }
-        *buf = newbuf;
-    }
-
-    va_start( ap, format );
-    *used += vsnprintf( *buf + *used, *max - *used, format, ap );
-    va_end( ap );
-
-    return 0;
-}

branches/nat-traversal/libtransmission/bencode.h

@@ -53 +53 @@
 
 #define tr_bencLoad(b,l,v,e) _tr_bencLoad((char*)(b),(l),(v),(char**)(e))
-int          _tr_bencLoad( char * buf, size_t len, benc_val_t * val,
+int          _tr_bencLoad( char * buf, int len, benc_val_t * val,
                            char ** end );
 void         tr_bencPrint( benc_val_t * val );
 void         tr_bencFree( benc_val_t * val );
 benc_val_t * tr_bencDictFind( benc_val_t * val, char * key );
-char *       tr_bencSaveMalloc( benc_val_t * val, size_t * len );
+char *       tr_bencSaveMalloc( benc_val_t * val, int * len );
 int          tr_bencSave( benc_val_t * val, char ** buf,
-                          size_t * used, size_t * max );
+                          int * used, int * max );
 
 #endif

branches/nat-traversal/libtransmission/fastresume.h

@@ -249 +249 @@
     {
         tr_inf( "Wrong size for resume file (%d bytes, %d expected)",
-                ftell( file ), size );
+                (int)ftell( file ), size );
         fclose( file );
         return 1;

branches/nat-traversal/libtransmission/inout.c

@@ -417 +417 @@
     {
         /* Should not happen */
-        tr_err( "readOrWriteBytes: offset out of range (%lld, %d, %d)",
+        tr_err( "readOrWriteBytes: offset out of range (%"PRIu64", %d, %d)",
                 offset, size, isWrite );
         goto fail;

branches/nat-traversal/libtransmission/internal.h

@@ -29 +29 @@
    That is probably ugly to put them all here, but it is sooo
    convenient */
+#if ( defined( __unix__ ) || defined( unix ) ) && !defined( USG )
+#include <sys/param.h>
+#endif
 #include <stdio.h>
 #include <stdarg.h>
@@ -51 +54 @@
 #ifdef BEOS_NETSERVER
 #  define in_port_t uint16_t
+#  define socklen_t uint32_t
 #else
 #  include <arpa/inet.h>
 #endif
 
+#ifndef INADDR_NONE
+#define INADDR_NONE             0xffffffff
+#endif
+
 #ifdef __GNUC__
 #  define UNUSED __attribute__((unused))
+#  define PRINTF( fmt, args ) __attribute__((format (printf, fmt, args)))
 #else
 #  define UNUSED
+#  define PRINTF( fmt, args )
 #endif
 
@@ -108 +118 @@
 typedef struct tr_completion_s tr_completion_t;
 
+typedef enum { TR_OK, TR_ERROR, TR_WAIT } tr_tristate_t;
+
 #include "platform.h"
 #include "bencode.h"
@@ -119 +131 @@
 #include "clients.h"
 #include "choking.h"
+#include "natpmp.h"
+#include "upnp.h"
+#include "http.h"
+#include "xml.h"
 
 struct tr_torrent_s
@@ -188 +204 @@
     tr_fd_t      * fdlimit;
     tr_choking_t * choking;
+    tr_natpmp_t  * natpmp;
+    tr_upnp_t    * upnp;
 
     int            bindPort;

branches/nat-traversal/libtransmission/metainfo.c

@@ -70 +70 @@
     if( sb.st_size > TORRENT_MAX_SIZE )
     {
-        tr_err( "Torrent file is too big (%d bytes)", sb.st_size );
+        tr_err( "Torrent file is too big (%d bytes)", (int)sb.st_size );
         return 1;
     }

branches/nat-traversal/libtransmission/net.c

@@ -36 +36 @@
  * Returns a non-zero value if an error occurs.
  **********************************************************************/
-int tr_netResolve( char * address, struct in_addr * addr )
+int tr_netResolve( const char * address, struct in_addr * addr )
 {
     addr->s_addr = inet_addr( address );
@@ -53 +53 @@
 struct tr_resolve_s
 {
-    int            status;
+    tr_tristate_t  status;
     char           * address;
     struct in_addr addr;
@@ -95 +95 @@
  * Adds an address to the resolution queue.
  **********************************************************************/
-tr_resolve_t * tr_netResolveInit( char * address )
+tr_resolve_t * tr_netResolveInit( const char * address )
 {
     tr_resolve_t * r;
 
     r           = malloc( sizeof( tr_resolve_t ) );
-    r->status   = TR_RESOLVE_WAIT;
+    r->status   = TR_WAIT;
     r->address  = strdup( address );
     r->refcount = 2;
@@ -126 +126 @@
  * Checks the current status of a resolution.
  **********************************************************************/
-int tr_netResolvePulse( tr_resolve_t * r, struct in_addr * addr )
-{
-    int ret;
+tr_tristate_t tr_netResolvePulse( tr_resolve_t * r, struct in_addr * addr )
+{
+    tr_tristate_t ret;
 
     tr_lockLock( &resolveLock );
     ret = r->status;
-    if( ret == TR_RESOLVE_OK )
+    if( ret == TR_OK )
     {
         *addr = r->addr;
@@ -202 +202 @@
         {
             memcpy( &r->addr, host->h_addr, host->h_length );
-            r->status = TR_RESOLVE_OK;
+            r->status = TR_OK;
         }
         else
         {
-            r->status = TR_RESOLVE_ERROR;
+            r->status = TR_ERROR;
         }
         
@@ -252 +252 @@
 }
 
-static int createSocket()
+static int createSocket( int type )
 {
     int s;
 
-    s = socket( AF_INET, SOCK_STREAM, 0 );
+    s = socket( AF_INET, type, 0 );
     if( s < 0 )
     {
@@ -266 +266 @@
 }
 
-int tr_netOpen( struct in_addr addr, in_port_t port )
+int tr_netOpen( struct in_addr addr, in_port_t port, int type )
 {
     int s;
     struct sockaddr_in sock;
 
-    s = createSocket();
+    s = createSocket( type );
     if( s < 0 )
     {
@@ -294 +294 @@
 }
 
-int tr_netBind( int port )
+#ifdef IP_ADD_MEMBERSHIP
+int tr_netMcastOpen( int port, struct in_addr addr )
+{
+    int fd;
+    struct ip_mreq req;
+
+    fd = tr_netBindUDP( port );
+    if( 0 > fd )
+    {
+        return -1;
+    }
+
+    memset( &req, 0, sizeof( req ) );
+    req.imr_multiaddr.s_addr = addr.s_addr;
+    req.imr_interface.s_addr = htonl( INADDR_ANY );
+    if( setsockopt( fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &req, sizeof ( req ) ) )
+    {
+        tr_err( "Could not join multicast group (%s)", strerror( errno ) );
+        tr_netClose( fd );
+        return -1;
+    }
+
+    return fd;
+}
+#else /* IP_ADD_MEMBERSHIP */
+int tr_netMcastOpen( int port UNUSED, struct in_addr addr UNUSED )
+{
+    return -1;
+}
+#endif /* IP_ADD_MEMBERSHIP */
+
+int tr_netBind( int port, int type )
 {
     int s;
     struct sockaddr_in sock;
-#ifdef SO_REUSEADDR
+#if defined( SO_REUSEADDR ) || defined( SO_REUSEPORT )
     int optval;
 #endif
 
-    s = createSocket();
+    s = createSocket( type );
     if( s < 0 )
     {
@@ -313 +344 @@
 #endif
 
+#ifdef SO_REUSEPORT
+    if( SOCK_DGRAM == type )
+    {
+        optval = 1;
+        setsockopt( s, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof( optval ) );
+    }
+#endif
+
     memset( &sock, 0, sizeof( sock ) );
     sock.sin_family      = AF_INET;
@@ -325 +364 @@
         return -1;
     }
-   
-    tr_inf( "Binded port %d", port );
-    listen( s, 5 );
 
     return s;
@@ -372 +408 @@
 }
 
-int tr_netRecv( int s, uint8_t * buf, int size )
-{
-    int ret;
-
-    ret = recv( s, buf, size, 0 );
+int tr_netRecvFrom( int s, uint8_t * buf, int size, struct sockaddr_in * addr )
+{
+    socklen_t len;
+    int       ret;
+
+    len = ( NULL == addr ? 0 : sizeof( *addr ) );
+    ret = recvfrom( s, buf, size, 0, ( struct sockaddr * ) addr, &len );
     if( ret < 0 )
     {

branches/nat-traversal/libtransmission/net.h

@@ -27 +27 @@
  * DNS resolution
  **********************************************************************/
-int tr_netResolve( char *, struct in_addr * );
+int tr_netResolve( const char *, struct in_addr * );
 
-#define TR_RESOLVE_WAIT  0
-#define TR_RESOLVE_ERROR 1
-#define TR_RESOLVE_OK    2
 typedef struct tr_resolve_s tr_resolve_t;
 void           tr_netResolveThreadInit();
 void           tr_netResolveThreadClose();
-tr_resolve_t * tr_netResolveInit( char * );
-int            tr_netResolvePulse( tr_resolve_t *, struct in_addr * );
+tr_resolve_t * tr_netResolveInit( const char * );
+tr_tristate_t  tr_netResolvePulse( tr_resolve_t *, struct in_addr * );
 void           tr_netResolveClose( tr_resolve_t * );
 
@@ -43 +40 @@
  * TCP sockets
  **********************************************************************/
-int  tr_netOpen    ( struct in_addr addr, in_port_t port );
-int  tr_netBind    ( int );
+#define tr_netOpenTCP( addr, port ) tr_netOpen( (addr), (port), SOCK_STREAM )
+#define tr_netOpenUDP( addr, port ) tr_netOpen( (addr), (port), SOCK_DGRAM )
+int  tr_netOpen    ( struct in_addr addr, in_port_t port, int type );
+int  tr_netMcastOpen( int port, struct in_addr addr );
+#define tr_netBindTCP( port ) tr_netBind( (port), SOCK_STREAM )
+#define tr_netBindUDP( port ) tr_netBind( (port), SOCK_DGRAM )
+int  tr_netBind    ( int port, int type );
 int  tr_netAccept  ( int s, struct in_addr *, in_port_t * );
 void tr_netClose   ( int s );
@@ -51 +53 @@
 #define TR_NET_CLOSE 0x40000000
 int  tr_netSend    ( int s, uint8_t * buf, int size );
-int  tr_netRecv    ( int s, uint8_t * buf, int size );
+#define tr_netRecv( s, buf, size ) tr_netRecvFrom( (s), (buf), (size), NULL )
+int  tr_netRecvFrom( int s, uint8_t * buf, int size, struct sockaddr_in * );
 
 void tr_netNtop( const struct in_addr * addr, char * buf, int len );

branches/nat-traversal/libtransmission/peer.c

@@ -101 +101 @@
 
 #define peer_dbg( a... ) __peer_dbg( peer, ## a )
+static void __peer_dbg( tr_peer_t * peer, char * msg, ... ) PRINTF( 2, 3 );
+
 static void __peer_dbg( tr_peer_t * peer, char * msg, ... )
 {

branches/nat-traversal/libtransmission/peerutils.h

@@ -152 +152 @@
         !tr_fdSocketWillCreate( tor->fdlimit, 0 ) )
     {
-        peer->socket = tr_netOpen( peer->addr, peer->port );
+        peer->socket = tr_netOpenTCP( peer->addr, peer->port );
         if( peer->socket < 0 )
         {

branches/nat-traversal/libtransmission/platform.c

@@ -197 +197 @@
 }
 
+#if defined( BSD )
+
+#include <sys/sysctl.h>
+#include <net/route.h>
+
+static uint8_t *
+getroute( int * buflen );
+static int
+parseroutes( uint8_t * buf, int len, struct in_addr * addr );
+
+int
+tr_getDefaultRoute( struct in_addr * addr )
+{
+    uint8_t * buf;
+    int len;
+
+    buf = getroute( &len );
+    if( NULL == buf )
+    {
+        tr_err( "failed to get default route (BSD)" );
+        return 1;
+    }
+
+    len = parseroutes( buf, len, addr );
+    free( buf );
+
+    return len;
+}
+
+#ifndef SA_SIZE
+#define ROUNDUP( a, size ) \
+    ( ( (a) & ( (size) - 1 ) ) ? ( 1 + ( (a) | ( (size) - 1 ) ) ) : (a) )
+#define SA_SIZE( sap ) \
+    ( sap->sa_len ? ROUNDUP( (sap)->sa_len, sizeof( u_long ) ) : \
+                    sizeof( u_long ) )
+#endif /* !SA_SIZE */
+#define NEXT_SA( sap ) \
+    (struct sockaddr *) ( (caddr_t) (sap) + ( SA_SIZE( (sap) ) ) )
+
+static uint8_t *
+getroute( int * buflen )
+{
+    int     mib[6];
+    size_t  len;
+    uint8_t * buf;
+
+    mib[0] = CTL_NET;
+    mib[1] = PF_ROUTE;
+    mib[2] = 0;
+    mib[3] = AF_INET;
+    mib[4] = NET_RT_FLAGS;
+    mib[5] = RTF_GATEWAY;
+
+    if( sysctl( mib, 6, NULL, &len, NULL, 0 ) )
+    {
+        if( ENOENT != errno )
+        {
+            tr_err( "sysctl net.route.0.inet.flags.gateway failed (%s)",
+                    strerror( errno ) );
+        }
+        *buflen = 0;
+        return NULL;
+    }
+
+    buf = malloc( len );
+    if( NULL == buf )
+    {
+        *buflen = 0;
+        return NULL;
+    }
+
+    if( sysctl( mib, 6, buf, &len, NULL, 0 ) )
+    {
+        tr_err( "sysctl net.route.0.inet.flags.gateway failed (%s)",
+                strerror( errno ) );
+        free( buf );
+        *buflen = 0;
+        return NULL;
+    }
+
+    *buflen = len;
+
+    return buf;
+}
+
+static int
+parseroutes( uint8_t * buf, int len, struct in_addr * addr )
+{
+    uint8_t            * end;
+    struct rt_msghdr   * rtm;
+    struct sockaddr    * sa;
+    struct sockaddr_in * sin;
+    int                  ii;
+    struct in_addr       dest, gw;
+
+    end = buf + len;
+    while( end > buf + sizeof( *rtm ) )
+    {
+        rtm = (struct rt_msghdr *) buf;
+        buf += rtm->rtm_msglen;
+        if( end >= buf )
+        {
+            dest.s_addr = INADDR_NONE;
+            gw.s_addr   = INADDR_NONE;
+            sa = (struct sockaddr *) ( rtm + 1 );
+
+            for( ii = 0; ii < RTAX_MAX && (uint8_t *) sa < buf; ii++ )
+            {
+                if( buf < (uint8_t *) NEXT_SA( sa ) )
+                {
+                    break;
+                }
+
+                if( rtm->rtm_addrs & ( 1 << ii ) )
+                {
+                    if( AF_INET == sa->sa_family )
+                    {
+                        sin = (struct sockaddr_in *) sa;
+                        switch( ii )
+                        {
+                            case RTAX_DST:
+                                dest = sin->sin_addr;
+                                break;
+                            case RTAX_GATEWAY:
+                                gw = sin->sin_addr;
+                                break;
+                        }
+                    }
+                    sa = NEXT_SA( sa );
+                }
+            }
+
+            if( INADDR_ANY == dest.s_addr && INADDR_NONE != gw.s_addr )
+            {
+                *addr = gw;
+                return 0;
+            }
+        }
+    }
+
+    return 1;
+}
+
+#elif defined( linux ) || defined( __linux ) || defined( __linux__ )
+
+#include <linux/types.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+#define SEQNUM 195909
+
+static int
+getsock( void );
+static uint8_t *
+getroute( int fd, unsigned int * buflen );
+static int
+parseroutes( uint8_t * buf, unsigned int len, struct in_addr * addr );
+
+int
+tr_getDefaultRoute( struct in_addr * addr )
+{
+    int fd, ret;
+    unsigned int len;
+    uint8_t * buf;
+
+    ret = 1;
+    fd = getsock();
+    if( 0 <= fd )
+    {
+        while( ret )
+        {
+            buf = getroute( fd, &len );
+            if( NULL == buf )
+            {
+                break;
+            }
+            ret = parseroutes( buf, len, addr );
+            free( buf );
+        }
+        close( fd );
+    }
+
+    if( ret )
+    {
+        tr_err( "failed to get default route (Linux)" );
+    }
+
+    return ret;
+}
+
+static int
+getsock( void )
+{
+    int fd, flags;
+    struct
+    {
+        struct nlmsghdr nlh;
+        struct rtgenmsg rtg;
+    } req;
+    struct sockaddr_nl snl;
+
+    fd = socket( PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE );
+    if( 0 > fd )
+    {
+        tr_err( "failed to create routing socket (%s)", strerror( errno ) );
+        return -1;
+    }
+
+    flags = fcntl( fd, F_GETFL );
+    if( 0 > flags || 0 > fcntl( fd, F_SETFL, O_NONBLOCK | flags ) )
+    {
+        tr_err( "failed to set socket nonblocking (%s)", strerror( errno ) );
+        close( fd );
+        return -1;
+    }
+
+    bzero( &snl, sizeof( snl ) );
+    snl.nl_family = AF_NETLINK;
+
+    bzero( &req, sizeof( req ) );
+    req.nlh.nlmsg_len = NLMSG_LENGTH( sizeof( req.rtg ) );
+    req.nlh.nlmsg_type = RTM_GETROUTE;
+    req.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+    req.nlh.nlmsg_seq = SEQNUM;
+    req.nlh.nlmsg_pid = 0;
+    req.rtg.rtgen_family = AF_INET;
+
+    if( 0 > sendto( fd, &req, sizeof( req ), 0,
+                    (struct sockaddr *) &snl, sizeof( snl ) ) )
+    {
+        tr_err( "failed to write to routing socket (%s)", strerror( errno ) );
+        close( fd );
+        return -1;
+    }
+
+    return fd;
+}
+
+static uint8_t *
+getroute( int fd, unsigned int * buflen )
+{
+    void             * buf;
+    unsigned int       len;
+    ssize_t            res;
+    struct sockaddr_nl snl;
+    socklen_t          slen;
+
+    len = 8192;
+    buf = calloc( 1, len );
+    if( NULL == buf )
+    {
+        *buflen = 0;
+        return NULL;
+    }
+
+    for( ;; )
+    {
+        bzero( &snl, sizeof( snl ) );
+        slen = sizeof( snl );
+        res = recvfrom( fd, buf, len, 0, (struct sockaddr *) &snl, &slen );
+        if( 0 > res )
+        {
+            if( EAGAIN != errno )
+            {
+                tr_err( "failed to read from routing socket (%s)",
+                        strerror( errno ) );
+            }
+            free( buf );
+            *buflen = 0;
+            return NULL;
+        }
+        if( slen < sizeof( snl ) || AF_NETLINK != snl.nl_family )
+        {
+            tr_err( "bad address" );
+            free( buf );
+            *buflen = 0;
+            return NULL;
+        }
+
+        if( 0 == snl.nl_pid )
+        {
+            break;
+        }
+    }
+
+    *buflen = res;
+
+    return buf;
+}
+
+static int
+parseroutes( uint8_t * buf, unsigned int len, struct in_addr * addr )
+{
+    struct nlmsghdr * nlm;
+    struct nlmsgerr * nle;
+    struct rtmsg    * rtm;
+    struct rtattr   * rta;
+    int               rtalen;
+    struct in_addr    gw, dst;
+
+    nlm = ( struct nlmsghdr * ) buf;
+    while( NLMSG_OK( nlm, len ) )
+    {
+        gw.s_addr = INADDR_ANY;
+        dst.s_addr = INADDR_ANY;
+        if( NLMSG_ERROR == nlm->nlmsg_type )
+        {
+            nle = (struct nlmsgerr *) NLMSG_DATA( nlm );
+            if( NLMSG_LENGTH( NLMSG_ALIGN( sizeof( struct nlmsgerr ) ) ) >
+                nlm->nlmsg_len )
+            {
+                tr_err( "truncated netlink error" );
+            }
+            else
+            {
+                tr_err( "netlink error (%s)", strerror( nle->error ) );
+            }
+            return 1;
+        }
+        else if( RTM_NEWROUTE == nlm->nlmsg_type && SEQNUM == nlm->nlmsg_seq &&
+                 getpid() == (pid_t) nlm->nlmsg_pid &&
+                 NLMSG_LENGTH( sizeof( struct rtmsg ) ) <= nlm->nlmsg_len )
+        {
+            rtm = NLMSG_DATA( nlm );
+            rta = RTM_RTA( rtm );
+            rtalen = RTM_PAYLOAD( nlm );
+
+            while( RTA_OK( rta, rtalen ) )
+            {
+                if( sizeof( struct in_addr ) <= RTA_PAYLOAD( rta ) )
+                {
+                    switch( rta->rta_type )
+                    {
+                        case RTA_GATEWAY:
+                            memcpy( &gw, RTA_DATA( rta ), sizeof( gw ) );
+                            break;
+                        case RTA_DST:
+                            memcpy( &dst, RTA_DATA( rta ), sizeof( dst ) );
+                            break;
+                    }
+                }
+                rta = RTA_NEXT( rta, rtalen );
+            }
+        }
+
+        if( INADDR_NONE != gw.s_addr && INADDR_ANY != gw.s_addr &&
+            INADDR_ANY == dst.s_addr )
+        {
+            *addr = gw;
+            return 0;
+        }
+
+        nlm = NLMSG_NEXT( nlm, len );
+    }
+
+    return 1;
+}
+
+#else /* not BSD or Linux */
+
+int
+tr_getDefaultRoute( struct in_addr * addr UNUSED )
+{
+    tr_inf( "don't know how to get default route on this platform" );
+    return 1;
+}
+
+#endif

branches/nat-traversal/libtransmission/platform.h

@@ -61 +61 @@
 }
 
+int
+tr_getDefaultRoute( struct in_addr * addr );
+
 #endif

branches/nat-traversal/libtransmission/tracker.c

@@ -43 +43 @@
     uint64_t       dateOk;
 
-#define TC_STATUS_IDLE    1
-#define TC_STATUS_RESOLVE 2
-#define TC_STATUS_CONNECT 4
-#define TC_STATUS_RECV    8
-    char           status;
-
 #define TC_ATTEMPT_NOREACH 1
 #define TC_ATTEMPT_ERROR   2
@@ -54 +48 @@
     char           lastAttempt;
 
-    tr_resolve_t * resolve;
-    int            socket;
-    uint8_t      * buf;
-    int            size;
-    int            pos;
+    tr_http_t    * http;
 
     int            bindPort;
@@ -67 +57 @@
 };
 
-static void sendQuery  ( tr_tracker_t * tc );
-static void recvAnswer ( tr_tracker_t * tc );
+static tr_http_t * getQuery   ( tr_tracker_t * tc );
+static void        readAnswer ( tr_tracker_t * tc, const char *, int );
 
 tr_tracker_t * tr_trackerInit( tr_torrent_t * tor )
@@ -84 +74 @@
     tc->leechers = -1;
 
-    tc->status   = TC_STATUS_IDLE;
     tc->lastAttempt = TC_ATTEMPT_NOREACH;
-    tc->size     = 1024;
-    tc->buf      = malloc( tc->size );
 
     tc->bindPort = *(tor->bindPort);
@@ -160 +147 @@
     tr_torrent_t * tor = tc->tor;
     tr_info_t    * inf = &tor->info;
-    uint64_t       now = tr_date();
-
-    if( ( tc->status & TC_STATUS_IDLE ) && shouldConnect( tc ) )
-    {
-        tc->resolve = tr_netResolveInit( inf->trackerAddress );
+    const char   * data;
+    int            len;
+
+    if( ( NULL == tc->http ) && shouldConnect( tc ) )
+    {
+        if( tr_fdSocketWillCreate( tor->fdlimit, 1 ) )
+        {
+            return 0;
+        }
+        tc->http = getQuery( tc );
 
         tr_inf( "Tracker: connecting to %s:%d (%s)",
@@ -173 +165 @@
                     ( 0 < tc->newPort ? "sending 'stopped' to change port" :
                       "getting peers" ) ) ) );
-
-        tc->status  = TC_STATUS_RESOLVE;
-        tc->dateTry = tr_date();
-    }
-
-    if( tc->status & TC_STATUS_RESOLVE )
-    {
-        int ret;
-        struct in_addr addr;
-
-        ret = tr_netResolvePulse( tc->resolve, &addr );
-        if( ret == TR_RESOLVE_WAIT )
-        {
-            return 0;
-        }
-        else
-        {
-            tr_netResolveClose( tc->resolve );
-        }
-        
-        if( ret == TR_RESOLVE_ERROR )
-        {
-            tc->status = TC_STATUS_IDLE;
-            return 0;
-        }
-
-        if( tr_fdSocketWillCreate( tor->fdlimit, 1 ) )
-        {
-            tc->status = TC_STATUS_IDLE;
-            return 0;
-        }
-
-        tc->socket = tr_netOpen( addr, htons( inf->trackerPort ) );
-        if( tc->socket < 0 )
-        {
-            tr_fdSocketClosed( tor->fdlimit, 1 );
-            tc->status = TC_STATUS_IDLE;
-            return 0;
-        }
-
-        tc->status = TC_STATUS_CONNECT;
-    }
-
-    if( tc->status & TC_STATUS_CONNECT )
-    {
-        /* We are connecting to the tracker. Try to send the query */
-        sendQuery( tc );
-    }
-
-    if( tc->status & TC_STATUS_RECV )
-    {
-        /* Try to get something */
-        recvAnswer( tc );
-    }
-
-    if( tc->status > TC_STATUS_IDLE && now > tc->dateTry + 60000 )
-    {
-        /* Give up if the request wasn't successful within 60 seconds */
-        tr_inf( "Tracker: timeout reached (60 s)" );
-
-        tr_netClose( tc->socket );
-        tr_fdSocketClosed( tor->fdlimit, 1 );
-
-        tc->status  = TC_STATUS_IDLE;
-        tc->dateTry = tr_date();
+    }
+
+    if( NULL != tc->http )
+    {
+        switch( tr_httpPulse( tc->http, &data, &len ) )
+        {
+            case TR_WAIT:
+                return 0;
+
+            case TR_ERROR:
+                tr_httpClose( tc->http );
+                tr_fdSocketClosed( tor->fdlimit, 1 );
+                tc->http = NULL;
+                return 0;
+
+            case TR_OK:
+                readAnswer( tc, data, len );
+                tr_httpClose( tc->http );
+                tc->http = NULL;
+                tr_fdSocketClosed( tor->fdlimit, 1 );
+                break;
+        }
     }
 
@@ -254 +203 @@
     tr_torrent_t * tor = tc->tor;
 
-    if( tc->status > TC_STATUS_CONNECT )
+    if( NULL != tc->http )
     {
         /* If we are already sendy a query at the moment, we need to
            reconnect */
-        tr_netClose( tc->socket );
+        tr_httpClose( tc->http );
+        tc->http = NULL;
         tr_fdSocketClosed( tor->fdlimit, 1 );
-        tc->status = TC_STATUS_IDLE;
     }
 
@@ -268 +217 @@
 
     /* Even if we have connected recently, reconnect right now */
-    if( tc->status & TC_STATUS_IDLE )
-    {
-        tc->dateTry = 0;
-    }
+    tc->dateTry = 0;
 }
 
@@ -278 +224 @@
     tr_torrent_t * tor = tc->tor;
 
-    if( tc->status == TC_STATUS_RESOLVE )
-    {
-        tr_netResolveClose( tc->resolve );
-    }
-    else if( tc->status > TC_STATUS_RESOLVE )
-    {
-        tr_netClose( tc->socket );
+    if( NULL != tc->http )
+    {
+        tr_httpClose( tc->http );
         tr_fdSocketClosed( tor->fdlimit, 1 );
     }
-    free( tc->buf );
     free( tc );
 }
 
-static void sendQuery( tr_tracker_t * tc )
+static tr_http_t * getQuery( tr_tracker_t * tc )
 {
     tr_torrent_t * tor = tc->tor;
     tr_info_t    * inf = &tor->info;
 
-    char     * event;
-    uint64_t   left;
-    int        ret;
-    uint64_t   down;
-    uint64_t   up;
+    char         * event;
+    uint64_t       left;
+    uint64_t       down;
+    uint64_t       up;
 
     assert( tor->downloaded >= tc->download && tor->uploaded >= tc->upload );
@@ -331 +271 @@
     left = tr_cpLeftBytes( tor->completion );
 
-    ret = snprintf( (char *) tc->buf, tc->size,
-            "GET %s?"
-            "info_hash=%s&"
-            "peer_id=%s&"
-            "port=%d&"
-            "uploaded=%"PRIu64"&"
-            "downloaded=%"PRIu64"&"
-            "left=%"PRIu64"&"
-            "compact=1&"
-            "numwant=50&"
-            "key=%s"
-            "%s "
-            "HTTP/1.1\r\n"
-            "Host: %s\r\n"
-            "User-Agent: Transmission/%d.%d\r\n"
-            "Connection: close\r\n\r\n",
-            inf->trackerAnnounce, tor->hashString, tc->id,
-            tc->bindPort, up, down,
-            left, tor->key, event, inf->trackerAddress,
-            VERSION_MAJOR, VERSION_MINOR );
-
-    ret = tr_netSend( tc->socket, tc->buf, ret );
-    if( ret & TR_NET_CLOSE )
-    {
-        tr_inf( "Tracker: connection failed" );
-        tr_netClose( tc->socket );
-        tr_fdSocketClosed( tor->fdlimit, 1 );
-        tc->status  = TC_STATUS_IDLE;
-        tc->dateTry = tr_date();
-    }
-    else if( !( ret & TR_NET_BLOCK ) )
-    {
-        // printf( "Tracker: sent %s", tc->buf );
-        tc->status = TC_STATUS_RECV;
-        tc->pos    = 0;
-    }
-}
-
-static void recvAnswer( tr_tracker_t * tc )
+    return tr_httpClient( TR_HTTP_GET, inf->trackerAddress,
+                          inf->trackerPort,
+                          "%s?"
+                          "info_hash=%s&"
+                          "peer_id=%s&"
+                          "port=%d&"
+                          "uploaded=%"PRIu64"&"
+                          "downloaded=%"PRIu64"&"
+                          "left=%"PRIu64"&"
+                          "compact=1&"
+                          "numwant=50&"
+                          "key=%s"
+                          "%s ",
+                          inf->trackerAnnounce, tor->hashString, tc->id,
+                          tc->bindPort, up, down, left, tor->key, event );
+}
+
+static void readAnswer( tr_tracker_t * tc, const char * data, int len )
 {
     tr_torrent_t * tor = tc->tor;
-    int ret;
     int i;
+    int code;
     benc_val_t   beAll;
     benc_val_t * bePeers, * beFoo;
-    uint8_t * body;
+    const uint8_t * body;
     int bodylen;
     int shouldfree;
 
-    if( tc->pos == tc->size )
-    {
-        tc->size *= 2;
-        tc->buf   = realloc( tc->buf, tc->size );
-    }
-    
-    ret = tr_netRecv( tc->socket, &tc->buf[tc->pos],
-                    tc->size - tc->pos );
-
-    if( ret & TR_NET_BLOCK )
-    {
-        return;
-    }
-    if( !( ret & TR_NET_CLOSE ) )
-    {
-        // printf( "got %d bytes\n", ret );
-        tc->pos += ret;
-        return;
-    }
-
-    tr_netClose( tc->socket );
-    tr_fdSocketClosed( tor->fdlimit, 1 );
-    // printf( "connection closed, got total %d bytes\n", tc->pos );
-
-    tc->status  = TC_STATUS_IDLE;
     tc->dateTry = tr_date();
-
-    if( tc->pos < 12 || ( 0 != memcmp( tc->buf, "HTTP/1.0 ", 9 ) &&
-                          0 != memcmp( tc->buf, "HTTP/1.1 ", 9 ) ) )
-    {
-        /* We don't have a complete HTTP status line */
-        tr_inf( "Tracker: incomplete HTTP status line" );
+    code = tr_httpResponseCode( data, len );
+    if( 0 > code )
+    {
+        /* We don't have a valid HTTP status line */
+        tr_inf( "Tracker: invalid HTTP status line" );
         tc->lastAttempt = TC_ATTEMPT_NOREACH;
         return;
     }
 
-    if( '2' != tc->buf[9] )
+    if( !TR_HTTP_STATUS_OK( code ) )
     {
         /* we didn't get a 2xx status code */
-        tr_err( "Tracker: invalid HTTP status code: %c%c%c",
-                tc->buf[9], tc->buf[10], tc->buf[11] );
+        tr_err( "Tracker: invalid HTTP status code: %i", code );
         tc->lastAttempt = TC_ATTEMPT_ERROR;
         return;
@@ -426 +318 @@
 
     /* find the end of the http headers */
-    body = tr_memmem( tc->buf, tc->pos, "\015\012\015\012", 4 );
-    if( NULL != body )
-    {
-        body += 4;
-    }
-    /* hooray for trackers that violate the HTTP spec */
-    else if( NULL != ( body = tr_memmem( tc->buf, tc->pos, "\015\015", 2 ) ) ||
-             NULL != ( body = tr_memmem( tc->buf, tc->pos, "\012\012", 2 ) ) )
-    {
-        body += 2;
-    }
-    else
+    body = (uint8_t *) tr_httpParse( data, len, NULL );
+    if( NULL == body )
     {
         tr_err( "Tracker: could not find end of HTTP headers" );
@@ -443 +325 @@
         return;
     }
-    bodylen = tc->pos - (body - tc->buf);
+    bodylen = len - (body - (const uint8_t*)data);
 
     /* Find and load the dictionary */
@@ -611 +493 @@
     tr_info_t * inf = &tor->info;
 
-    int s, i, ret;
-    uint8_t buf[1024];
-    benc_val_t scrape, * val1, * val2;
-    struct in_addr addr;
-    uint64_t date;
-    int pos, len;
-    tr_resolve_t * resolve;
+    tr_http_t  * http;
+    const char * data, * body;
+    int          datalen, bodylen;
+    int          code, ii;
+    benc_val_t   scrape, * val1, * val2;
 
     if( !tor->scrape[0] )
@@ -625 +505 @@
     }
 
-    resolve = tr_netResolveInit( inf->trackerAddress );
-    for( date = tr_date();; )
-    {
-        ret = tr_netResolvePulse( resolve, &addr );
-        if( ret == TR_RESOLVE_OK )
-        {
-            tr_netResolveClose( resolve );
+    http = tr_httpClient( TR_HTTP_GET, inf->trackerAddress, inf->trackerPort,
+                          "%s?info_hash=%s", tor->scrape, tor->hashString );
+
+    data = NULL;
+    while( NULL == data )
+    {
+        switch( tr_httpPulse( http, &data, &datalen ) )
+        {
+            case TR_WAIT:
+                break;
+
+            case TR_ERROR:
+                tr_httpClose( http );
+                return 1;
+
+            case TR_OK:
+                if( NULL == data || 0 >= datalen )
+                {
+                    tr_httpClose( http );
+                    return 1;
+                }
+                break;
+        }
+        tr_wait( 10 );
+    }
+
+    code = tr_httpResponseCode( data, datalen );
+    if( !TR_HTTP_STATUS_OK( code ) )
+    {
+        tr_httpClose( http );
+        return 1;
+    }
+
+    body = tr_httpParse( data, datalen , NULL );
+    if( NULL == body )
+    {
+        tr_httpClose( http );
+        return 1;
+    }
+    bodylen = datalen - ( body - data );
+
+    for( ii = 0; ii < bodylen - 8; ii++ )
+    {
+        if( !memcmp( body + ii, "d5:files", 8 ) )
+        {
             break;
         }
-        if( ret == TR_RESOLVE_ERROR ||
-            ( ret == TR_RESOLVE_WAIT && tr_date() > date + 10000 ) )
-        {
-            tr_err( "Could not resolve %s", inf->trackerAddress );
-            tr_netResolveClose( resolve );
-            return 1;
-        }
-        tr_wait( 10 );
-    }
-
-    s = tr_netOpen( addr, htons( inf->trackerPort ) );
-    if( s < 0 )
-    {
-        return 1;
-    }
-
-    len = snprintf( (char *) buf, sizeof( buf ),
-              "GET %s?info_hash=%s HTTP/1.1\r\n"
-              "Host: %s\r\n"
-              "Connection: close\r\n\r\n",
-              tor->scrape, tor->hashString,
-              inf->trackerAddress );
-
-    for( date = tr_date();; )
-    {
-        ret = tr_netSend( s, buf, len );
-        if( ret & TR_NET_CLOSE )
-        {
-            tr_err( "Could not connect to tracker" );
-            tr_netClose( s );
-            return 1;
-        }
-        else if( ret & TR_NET_BLOCK )
-        {
-            if( tr_date() > date + 10000 )
-            {
-                tr_err( "Could not connect to tracker" );
-                tr_netClose( s );
-                return 1;
-            }
-        }
-        else
-        {
-            break;
-        }
-        tr_wait( 10 );
-    }
-
-    pos = 0;
-    for( date = tr_date();; )
-    {
-        ret = tr_netRecv( s, &buf[pos], sizeof( buf ) - pos );
-        if( ret & TR_NET_CLOSE )
-        {
-            break;
-        }
-        else if( ret & TR_NET_BLOCK )
-        {
-            if( tr_date() > date + 10000 )
-            {
-                tr_err( "Could not read from tracker" );
-                tr_netClose( s );
-                return 1;
-            }
-        }
-        else
-        {
-            pos += ret;
-        }
-        tr_wait( 10 );
-    }
-
-    if( pos < 1 )
-    {
-        tr_err( "Could not read from tracker" );
-        tr_netClose( s );
-        return 1;
-    }
-
-    for( i = 0; i < pos - 8; i++ )
-    {
-        if( !memcmp( &buf[i], "d5:files", 8 ) )
-        {
-            break;
-        }
-    }
-    if( i >= pos - 8 )
-    {
-        return 1;
-    }
-    if( tr_bencLoad( &buf[i], pos - i, &scrape, NULL ) )
-    {
+    }
+    if( ii >= bodylen - 8 )
+    {
+        tr_httpClose( http );
+        return 1;
+    }
+    if( tr_bencLoad( body + ii, bodylen - ii, &scrape, NULL ) )
+    {
+        tr_httpClose( http );
         return 1;
     }
@@ -732 +567 @@
     if( !val1 )
     {
+        tr_bencFree( &scrape );
+        tr_httpClose( http );
         return 1;
     }
@@ -737 +574 @@
     if( !val1 )
     {
+        tr_bencFree( &scrape );
+        tr_httpClose( http );
         return 1;
     }
@@ -742 +581 @@
     if( !val2 )
     {
+        tr_bencFree( &scrape );
+        tr_httpClose( http );
         return 1;
     }
@@ -748 +589 @@
     if( !val2 )
     {
+        tr_bencFree( &scrape );
+        tr_httpClose( http );
         return 1;
     }
     *leechers = val2->val.i;
     tr_bencFree( &scrape );
+    tr_httpClose( http );
 
     return 0;

branches/nat-traversal/libtransmission/transmission.c

@@ -75 +75 @@
     h->fdlimit  = tr_fdInit();
     h->choking  = tr_chokingInit( h );
+    h->natpmp   = tr_natpmpInit( h->fdlimit );
+    h->upnp     = tr_upnpInit( h->fdlimit );
 
     h->bindPort = -1;
@@ -105 +107 @@
     {
         /* XXX should handle failure here in a better way */
-        sock = tr_netBind( port );
+        sock = tr_netBindTCP( port );
+        if( 0 > sock)
+        {
+            tr_fdSocketClosed( h->fdlimit, 0 );
+        }
+        else
+        {   
+            tr_inf( "Bound listening port %d", port );
+            listen( sock, 5 );
+        }
     }
 #else
@@ -133 +144 @@
     h->bindSocket = sock;
 
+    tr_natpmpForwardPort( h->natpmp, port );
+    tr_upnpForwardPort( h->upnp, port );
+
     tr_lockUnlock( &h->acceptLock );
+}
+
+void tr_natTraversalEnable( tr_handle_t * h )
+{
+    tr_natpmpStart( h->natpmp );
+    tr_upnpStart( h->upnp );
+}
+
+void tr_natTraversalDisable( tr_handle_t * h )
+{
+    tr_natpmpStop( h->natpmp );
+    tr_upnpStop( h->upnp );
+}
+
+int tr_natTraversalStatus( tr_handle_t * h )
+{
+    int statuses[] = {
+        TR_NAT_TRAVERSAL_MAPPED,
+        TR_NAT_TRAVERSAL_MAPPING,
+        TR_NAT_TRAVERSAL_UNMAPPING,
+        TR_NAT_TRAVERSAL_ERROR,
+        TR_NAT_TRAVERSAL_NOTFOUND,
+        TR_NAT_TRAVERSAL_DISABLED,
+        -1,
+    };
+    int natpmp, upnp, ii;
+
+    natpmp = tr_natpmpStatus( h->natpmp );
+    upnp = tr_upnpStatus( h->upnp );
+
+    for( ii = 0; 0 <= statuses[ii]; ii++ )
+    {
+        if( statuses[ii] == natpmp || statuses[ii] == upnp )
+        {
+            return statuses[ii];
+        }
+    }
+
+    assert( 0 );
+
+    return TR_NAT_TRAVERSAL_ERROR;
 }
 
@@ -630 +685 @@
 {
     acceptStop( h );
+    tr_natpmpClose( h->natpmp );
+    tr_upnpClose( h->upnp );
     tr_chokingClose( h->choking );
     tr_fdClose( h->fdlimit );
@@ -735 +792 @@
     {
         date1 = tr_date();
+
+        /* do NAT-PMP and UPnP pulses here since there's nowhere better */
+        tr_natpmpPulse( h->natpmp );
+        tr_upnpPulse( h->upnp );
 
         /* Check for incoming connections */

branches/nat-traversal/libtransmission/transmission.h

@@ -100 +100 @@
  * tr_setBindPort
  ***********************************************************************
- * Sets the port to listen for incoming peer connections
+ * Sets the port to listen for incoming peer connections.
+ * This can be safely called even with active torrents.
  **********************************************************************/
 void tr_setBindPort( tr_handle_t *, int );
+
+/***********************************************************************
+ * tr_natTraversalEnable
+ * tr_natTraversalDisable
+ ***********************************************************************
+ * Enable or disable NAT traversal using NAT-PMP or UPnP IGD.
+ **********************************************************************/
+void tr_natTraversalEnable( tr_handle_t * );
+void tr_natTraversalDisable( tr_handle_t * );
+
+/***********************************************************************
+ * tr_natTraversalStatus
+ ***********************************************************************
+ * Return the status of NAT traversal
+ **********************************************************************/
+#define TR_NAT_TRAVERSAL_MAPPING        1
+#define TR_NAT_TRAVERSAL_MAPPED         2
+#define TR_NAT_TRAVERSAL_NOTFOUND       3
+#define TR_NAT_TRAVERSAL_ERROR          4
+#define TR_NAT_TRAVERSAL_UNMAPPING      5
+#define TR_NAT_TRAVERSAL_DISABLED       6
+#define TR_NAT_TRAVERSAL_IS_DISABLED( st ) \
+  ( TR_NAT_TRAVERSAL_DISABLED == (st) || TR_NAT_TRAVERSAL_UNMAPPING == (st) )
+int tr_natTraversalStatus( tr_handle_t * );
 
 /***********************************************************************

branches/nat-traversal/libtransmission/utils.c

@@ -25 +25 @@
 #include "transmission.h"
 
+#define SPRINTF_BUFSIZE         100
+
 static tr_lock_t      * messageLock = NULL;
 static int              messageLevel = 0;
@@ -97 +99 @@
 void tr_msg( int level, char * msg, ... )
 {
-    va_list          args;
+    va_list         args1, args2;
     tr_msg_list_t * newmsg;
+    int             len1, len2;
 
     assert( NULL != messageLock );
@@ -113 +116 @@
     if( messageLevel >= level )
     {
-        va_start( args, msg );
+        va_start( args1, msg );
         if( messageQueuing )
         {
@@ -121 +124 @@
                 newmsg->level = level;
                 newmsg->when = time( NULL );
-                vasprintf( &newmsg->message, msg, args );
+                len1 = len2 = 0;
+                va_start( args2, msg );
+                tr_vsprintf( &newmsg->message, &len1, &len2, msg,
+                             args1, args2 );
+                va_end( args2 );
                 if( NULL == newmsg->message )
                 {
@@ -135 +142 @@
         else
         {
-            vfprintf( stderr, msg, args );
+            vfprintf( stderr, msg, args1 );
             fputc( '\n', stderr );
         }
-        va_end( args );
+        va_end( args1 );
     }
 
@@ -235 +242 @@
     return 0;
 }
+
+#define UPPER( cc ) \
+    ( 'a' <= (cc) && 'z' >= (cc) ? (cc) - ( 'a' - 'A' ) : (cc) )
+
+int tr_strncasecmp( const char * first, const char * second, int len )
+{
+    int ii;
+    char firstchar, secondchar;
+
+    if( 0 > len )
+    {
+        len = strlen( first );
+        ii = strlen( second );
+        len = MIN( len, ii );
+    }
+
+    for( ii = 0; ii < len; ii++ )
+    {
+        if( first[ii] != second[ii] )
+        {
+            firstchar = UPPER( first[ii] );
+            secondchar = UPPER( second[ii] );
+            if( firstchar > secondchar )
+            {
+                return 1;
+            }
+            else if( firstchar < secondchar )
+            {
+                return -1;
+            }
+        }
+        if( '\0' == first[ii] )
+        {
+            /* if first[ii] is '\0' then second[ii] is too */
+            return 0;
+        }
+    }
+
+    return 0;
+}
+
+int tr_sprintf( char ** buf, int * used, int * max, const char * format, ... )
+{
+    va_list ap1, ap2;
+    int     ret;
+
+    va_start( ap1, format );
+    va_start( ap2, format );
+    ret = tr_vsprintf( buf, used, max, format, ap1, ap2 );
+    va_end( ap2 );
+    va_end( ap1 );
+
+    return ret;
+}
+
+int tr_vsprintf( char ** buf, int * used, int * max, const char * fmt,
+                 va_list ap1, va_list ap2 )
+{
+    int     want;
+    char  * newbuf;
+
+    want = vsnprintf( NULL, 0, fmt, ap1 );
+
+    while( *used + want + 1 > *max )
+    {
+        *max += SPRINTF_BUFSIZE;
+        newbuf = realloc( *buf, *max );
+        if( NULL == newbuf )
+        {
+            return 1;
+        }
+        *buf = newbuf;
+    }
+
+    *used += vsnprintf( *buf + *used, *max - *used, fmt, ap2 );
+
+    return 0;
+}
+
+char *
+tr_dupstr( const char * base, int len )
+{
+    char * ret;
+
+    ret = malloc( len + 1 );
+    if( NULL != ret )
+    {
+        memcpy( ret, base, len );
+        ret[len] = '\0';
+    }
+
+    return ret;
+}

branches/nat-traversal/libtransmission/utils.h

@@ -31 +31 @@
 #define tr_inf( a... ) tr_msg( TR_MSG_INF, ## a )
 #define tr_dbg( a... ) tr_msg( TR_MSG_DBG, ## a )
-void tr_msg  ( int level, char * msg, ... );
+void tr_msg  ( int level, char * msg, ... ) PRINTF( 2, 3 );
 
 int  tr_rand ( int );
@@ -44 +44 @@
  **********************************************************************/
 int tr_mkdir( char * path );
+
+/***********************************************************************
+ * tr_strcasecmp
+ ***********************************************************************
+ * A case-insensitive strncmp()
+ **********************************************************************/
+#define tr_strcasecmp( ff, ss ) ( tr_strncasecmp( (ff), (ss), -1 ) )
+int tr_strncasecmp( const char * first, const char * second, int len );
+
+/***********************************************************************
+ * tr_sprintf
+ ***********************************************************************
+ * Appends to the end of a buffer using printf formatting,
+ * growing the buffer if needed
+ **********************************************************************/
+int tr_sprintf( char ** buf, int * used, int * max,
+                const char * format, ... ) PRINTF( 4, 5 );
+/* gee, it sure would be nice if BeOS had va_copy() */
+int tr_vsprintf( char **, int *, int *, const char *, va_list, va_list );
+
+/***********************************************************************
+ * tr_dupstr
+ ***********************************************************************
+ * Creates a nul-terminated string 
+ **********************************************************************/
+char * tr_dupstr( const char * base, int len );
 
 /***********************************************************************

branches/nat-traversal/mk/common.mk

@@ -1 +1 @@
 # $Id$
 
-TMPCFLAGS   = -g -Wall -W -O3 -funroll-loops -D_FILE_OFFSET_BITS=64 \
+TMPCFLAGS   = -g -Wall -W -D_FILE_OFFSET_BITS=64 \
               -D_LARGEFILE_SOURCE -D_GNU_SOURCE \
               -DSYS_$(shell echo $(SYSTEM) | tr a-z A-Z)

branches/nat-traversal/mk/lib.mk

@@ -6 +6 @@
 SRCS = transmission.c bencode.c net.c tracker.c peer.c inout.c \
        metainfo.c sha1.c utils.c fdlimit.c clients.c completion.c \
-       platform.c ratecontrol.c choking.c
+       platform.c ratecontrol.c choking.c natpmp.c upnp.c http.c xml.c
 OBJS = $(SRCS:%.c=%.o)