Changeset 10945

Timestamp:

Jul 5, 2010, 9:04:17 PM (12 years ago)

Author:

charles

Message:

(trunk libT) #3383 "When port forwarding, check to see if the public port matches the private port" -- fixed

Location:

trunk/libtransmission

Files:

• announcer.c (modified) (1 diff)
• natpmp.c (modified) (11 diffs)
• natpmp.h (modified) (1 diff)
• peer-msgs.c (modified) (1 diff)
• port-forwarding.c (modified) (2 diffs)
• session.c (modified) (7 diffs)
• session.h (modified) (2 diffs)

trunk/libtransmission/announcer.c

@@ -746 +746 @@
                               torrent->info.hashEscaped,
                               torrent->peer_id,
-                              (int)tr_sessionGetPeerPort( announcer->session ),
+                              (int)tr_sessionGetPublicPeerPort( announcer->session ),
                               tier->byteCounts[TR_ANN_UP],
                               tier->byteCounts[TR_ANN_DOWN],

trunk/libtransmission/natpmp.c

@@ -45 +45 @@
 struct tr_natpmp
 {
-    tr_bool            isMapped;
-    tr_bool            hasDiscovered;
-    int                port;
-    time_t             renewTime;
-    time_t             commandTime;
-    tr_natpmp_state    state;
-    natpmp_t           natpmp;
+    tr_bool           has_discovered;
+    tr_bool           is_mapped;
+
+    tr_port           public_port;
+    tr_port           private_port;
+
+    time_t            renew_time;
+    time_t            command_time;
+    tr_natpmp_state   state;
+    natpmp_t          natpmp;
 };
 
@@ -80 +83 @@
     nat = tr_new0( struct tr_natpmp, 1 );
     nat->state = TR_NATPMP_DISCOVER;
-    nat->port = -1;
+    nat->public_port = 0;
+    nat->private_port = 0;
     nat->natpmp.s = -1; /* socket */
     return nat;
@@ -99 +103 @@
 canSendCommand( const struct tr_natpmp * nat )
 {
-    return tr_time( ) >= nat->commandTime;
+    return tr_time( ) >= nat->command_time;
 }
 
@@ -105 +109 @@
 setCommandTime( struct tr_natpmp * nat )
 {
-    nat->commandTime = tr_time( ) + COMMAND_WAIT_SECS;
+    nat->command_time = tr_time( ) + COMMAND_WAIT_SECS;
 }
 
 int
-tr_natpmpPulse( struct tr_natpmp * nat,
-                int                port,
-                int                isEnabled )
+tr_natpmpPulse( struct tr_natpmp * nat, tr_port private_port, tr_bool is_enabled, tr_port * public_port )
 {
     int ret;
 
-    if( isEnabled && ( nat->state == TR_NATPMP_DISCOVER ) )
+    if( is_enabled && ( nat->state == TR_NATPMP_DISCOVER ) )
     {
         int val = initnatpmp( &nat->natpmp );
@@ -122 +124 @@
         logVal( "sendpublicaddressrequest", val );
         nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_PUB;
-        nat->hasDiscovered = 1;
+        nat->has_discovered = TRUE;
         setCommandTime( nat );
     }
@@ -129 +131 @@
     {
         natpmpresp_t response;
-        const int    val = readnatpmpresponseorretry( &nat->natpmp,
-                                                      &response );
+        const int val = readnatpmpresponseorretry( &nat->natpmp, &response );
         logVal( "readnatpmpresponseorretry", val );
         if( val >= 0 )
         {
-            tr_ninf( getKey( ), _(
-                        "Found public address \"%s\"" ),
-                    inet_ntoa( response.pnu.publicaddress.addr ) );
+            tr_ninf( getKey( ), _( "Found public address \"%s\"" ),
+                     inet_ntoa( response.pnu.publicaddress.addr ) );
             nat->state = TR_NATPMP_IDLE;
         }
@@ -147 +147 @@
     if( ( nat->state == TR_NATPMP_IDLE ) || ( nat->state == TR_NATPMP_ERR ) )
     {
-        if( nat->isMapped && ( !isEnabled || ( nat->port != port ) ) )
+        if( nat->is_mapped && ( !is_enabled || ( nat->private_port != private_port ) ) )
             nat->state = TR_NATPMP_SEND_UNMAP;
     }
@@ -153 +153 @@
     if( ( nat->state == TR_NATPMP_SEND_UNMAP ) && canSendCommand( nat ) )
     {
-        const int val =
-            sendnewportmappingrequest( &nat->natpmp, NATPMP_PROTOCOL_TCP,
-                                       nat->port, nat->port,
-                                       0 );
+        const int val = sendnewportmappingrequest( &nat->natpmp, NATPMP_PROTOCOL_TCP,
+                                                   nat->private_port,
+                                                   nat->public_port,
+                                                   0 );
         logVal( "sendnewportmappingrequest", val );
         nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_UNMAP;
@@ -163 +163 @@
 
     if( nat->state == TR_NATPMP_RECV_UNMAP )
+    {
+        natpmpresp_t resp;
+        const int val = readnatpmpresponseorretry( &nat->natpmp, &resp );
+        logVal( "readnatpmpresponseorretry", val );
+        if( val >= 0 )
+        {
+            const int private_port = resp.pnu.newportmapping.privateport;
+
+            tr_ninf( getKey( ), _( "no longer forwarding port %d" ), private_port );
+
+            if( nat->private_port == private_port )
+            {
+                nat->private_port = 0;
+                nat->public_port = 0;
+                nat->state = TR_NATPMP_IDLE;
+                nat->is_mapped = FALSE;
+            }
+        }
+        else if( val != NATPMP_TRYAGAIN )
+        {
+            nat->state = TR_NATPMP_ERR;
+        }
+    }
+
+    if( nat->state == TR_NATPMP_IDLE )
+    {
+        if( is_enabled && !nat->is_mapped && nat->has_discovered )
+            nat->state = TR_NATPMP_SEND_MAP;
+
+        else if( nat->is_mapped && tr_time( ) >= nat->renew_time )
+            nat->state = TR_NATPMP_SEND_MAP;
+    }
+
+    if( ( nat->state == TR_NATPMP_SEND_MAP ) && canSendCommand( nat ) )
+    {
+        const int val = sendnewportmappingrequest( &nat->natpmp, NATPMP_PROTOCOL_TCP, private_port, private_port, LIFETIME_SECS );
+        logVal( "sendnewportmappingrequest", val );
+        nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_MAP;
+        setCommandTime( nat );
+    }
+
+    if( nat->state == TR_NATPMP_RECV_MAP )
     {
         natpmpresp_t resp;
@@ -169 +211 @@
         if( val >= 0 )
         {
-            const int p = resp.pnu.newportmapping.privateport;
-            tr_ninf( getKey( ), _( "no longer forwarding port %d" ), p );
-            if( nat->port == p )
-            {
-                nat->port = -1;
-                nat->state = TR_NATPMP_IDLE;
-                nat->isMapped = 0;
-            }
+            nat->state = TR_NATPMP_IDLE;
+            nat->is_mapped = TRUE;
+            nat->renew_time = tr_time( ) + LIFETIME_SECS;
+            nat->private_port = resp.pnu.newportmapping.privateport;
+            nat->public_port = resp.pnu.newportmapping.mappedpublicport;
+            tr_ninf( getKey( ), _( "Port %d forwarded successfully" ), nat->private_port );
         }
         else if( val != NATPMP_TRYAGAIN )
@@ -184 +224 @@
     }
 
-    if( nat->state == TR_NATPMP_IDLE )
-    {
-        if( isEnabled && !nat->isMapped && nat->hasDiscovered )
-            nat->state = TR_NATPMP_SEND_MAP;
-
-        else if( nat->isMapped && tr_time( ) >= nat->renewTime )
-            nat->state = TR_NATPMP_SEND_MAP;
-    }
-
-    if( ( nat->state == TR_NATPMP_SEND_MAP ) && canSendCommand( nat ) )
-    {
-        const int val =
-            sendnewportmappingrequest( &nat->natpmp, NATPMP_PROTOCOL_TCP,
-                                       port,
-                                       port,
-                                       LIFETIME_SECS );
-        logVal( "sendnewportmappingrequest", val );
-        nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_MAP;
-        setCommandTime( nat );
-    }
-
-    if( nat->state == TR_NATPMP_RECV_MAP )
-    {
-        natpmpresp_t resp;
-        const int    val = readnatpmpresponseorretry( &nat->natpmp, &resp );
-        logVal( "readnatpmpresponseorretry", val );
-        if( val >= 0 )
-        {
-            nat->state = TR_NATPMP_IDLE;
-            nat->isMapped = 1;
-            nat->renewTime = tr_time( ) + LIFETIME_SECS;
-            nat->port = resp.pnu.newportmapping.privateport;
-            tr_ninf( getKey( ), _(
-                         "Port %d forwarded successfully" ), nat->port );
-        }
-        else if( val != NATPMP_TRYAGAIN )
-        {
-            nat->state = TR_NATPMP_ERR;
-        }
-    }
-
     switch( nat->state )
     {
         case TR_NATPMP_IDLE:
-            ret = nat->isMapped ? TR_PORT_MAPPED : TR_PORT_UNMAPPED; break;
+            *public_port = nat->public_port;
+            return nat->is_mapped ? TR_PORT_MAPPED : TR_PORT_UNMAPPED;
+            break;
 
         case TR_NATPMP_DISCOVER:

trunk/libtransmission/natpmp.h

@@ -27 +27 @@
 tr_natpmp * tr_natpmpInit( void );
 
-void        tr_natpmpClose( tr_natpmp * );
+void tr_natpmpClose( tr_natpmp * );
 
-int         tr_natpmpPulse(         tr_natpmp *,
-                                int port,
-                                int isEnabled );
+int tr_natpmpPulse( tr_natpmp *, tr_port port, tr_bool isEnabled, tr_port * public_port );
 
 /* @} */

trunk/libtransmission/peer-msgs.c

@@ -846 +846 @@
                             && ( msgs->torrent->infoDictLength > 0 ) )
         tr_bencDictAddInt( &val, "metadata_size", msgs->torrent->infoDictLength );
-    tr_bencDictAddInt( &val, "p", tr_sessionGetPeerPort( getSession(msgs) ) );
+    tr_bencDictAddInt( &val, "p", tr_sessionGetPublicPeerPort( getSession(msgs) ) );
     tr_bencDictAddInt( &val, "reqq", REQQ );
     tr_bencDictAddInt( &val, "upload_only", tr_torrentIsSeed( msgs->torrent ) );

trunk/libtransmission/port-forwarding.c

@@ -67 +67 @@
 
 static void
-natPulse( tr_shared * s, tr_bool doPortCheck )
-{
-    const tr_port port = s->session->peerPort;
-    const int isEnabled = s->isEnabled && !s->isShuttingDown;
+natPulse( tr_shared * s, tr_bool do_check )
+{
+    const tr_port private_peer_port = s->session->private_peer_port;
+    const int is_enabled = s->isEnabled && !s->isShuttingDown;
+    tr_port public_peer_port;
     int oldStatus;
     int newStatus;
@@ -80 +81 @@
 
     oldStatus = tr_sharedTraversalStatus( s );
-    s->natpmpStatus = tr_natpmpPulse( s->natpmp, port, isEnabled );
-    s->upnpStatus = tr_upnpPulse( s->upnp, port, isEnabled, doPortCheck );
+
+    s->natpmpStatus = tr_natpmpPulse( s->natpmp, private_peer_port, is_enabled, &public_peer_port );
+    if( s->natpmpStatus == TR_PORT_MAPPED )
+        s->session->public_peer_port = public_peer_port;
+
+    s->upnpStatus = tr_upnpPulse( s->upnp, private_peer_port, is_enabled, do_check );
+
     newStatus = tr_sharedTraversalStatus( s );
 

trunk/libtransmission/session.c

@@ -200 +200 @@
     /* bind an ipv4 port to listen for incoming peers... */
     b = session->public_ipv4;
-    b->socket = tr_netBindTCP( &b->addr, session->peerPort, FALSE );
+    b->socket = tr_netBindTCP( &b->addr, session->private_peer_port, FALSE );
     if( b->socket >= 0 ) {
         event_set( &b->ev, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session );
@@ -207 +207 @@
 
     /* and do the exact same thing for ipv6, if it's supported... */
-    if( tr_net_hasIPv6( session->peerPort ) ) {
+    if( tr_net_hasIPv6( session->private_peer_port ) ) {
         b = session->public_ipv6;
-        b->socket = tr_netBindTCP( &b->addr, session->peerPort, FALSE );
+        b->socket = tr_netBindTCP( &b->addr, session->private_peer_port, FALSE );
         if( b->socket >= 0 ) {
             event_set( &b->ev, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session );
@@ -763 +763 @@
         tr_sessionSetPeerPortRandomOnStart( session, boolVal );
     if( !tr_bencDictFindInt( settings, TR_PREFS_KEY_PEER_PORT, &i ) )
-        i = session->peerPort;
+        i = session->private_peer_port;
     setPeerPort( session, boolVal ? getRandomPort( session ) : i );
     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PORT_FORWARDING, &boolVal ) )
@@ -1001 +1001 @@
 setPeerPort( tr_session * session, tr_port port )
 {
-    session->peerPort = port;
+    session->private_peer_port = port;
+    session->public_peer_port = port;
 
     tr_runInEventThread( session, peerPortChanged, session );
@@ -1011 +1012 @@
     assert( tr_isSession( session ) );
 
-    if( session->peerPort != port )
+    if( session->private_peer_port != port )
     {
         setPeerPort( session, port );
@@ -1022 +1023 @@
     assert( tr_isSession( session ) );
 
-    return session->peerPort;
+    return session->private_peer_port;
 }
 
@@ -1031 +1032 @@
 
     tr_sessionSetPeerPort( session, getRandomPort( session ) );
-    return session->peerPort;
+    return session->private_peer_port;
 }
 

trunk/libtransmission/session.h

@@ -123 +123 @@
     int                          uploadSlotsPerTorrent;
 
-    tr_port                      peerPort;
+    /* The open port on the local machine for incoming peer requests */
+    tr_port                      private_peer_port;
+
+    /**
+     * The open port on the public device for incoming peer requests.
+     * This is usually the same as private_peer_port but can differ
+     * if the public device is a router and it decides to use a different
+     * port than the one requested by Transmission.
+     */
+    tr_port                      public_peer_port;
+
     tr_port                      randomPortLow;
     tr_port                      randomPortHigh;
@@ -186 +196 @@
 };
 
+static inline tr_port
+tr_sessionGetPublicPeerPort( const tr_session * session )
+{
+    return session->public_peer_port;
+}
+
 tr_bool      tr_sessionAllowsDHT( const tr_session * session );