Changeset 1425

Timestamp:

Jan 21, 2007, 7:42:11 PM (15 years ago)

Author:

titer

Message:

More simplifications

Location:

trunk/libtransmission

Files:

• fdlimit.c (modified) (2 diffs)
• fdlimit.h (modified) (1 diff)
• http.c (modified) (2 diffs)
• natpmp.c (modified) (3 diffs)
• net.c (modified) (5 diffs)
• net.h (modified) (1 diff)
• peer.c (modified) (3 diffs)
• peerutils.h (modified) (1 diff)
• shared.c (modified) (4 diffs)
• tracker.c (modified) (3 diffs)
• upnp.c (modified) (6 diffs)

trunk/libtransmission/fdlimit.c

@@ -102 +102 @@
     for( j = 0; j < i; j++ )
     {
-        tr_netClose( s[j] );
+#ifdef BEOS_NETSERVER
+            closesocket( s[j] );
+#else
+            close( s[j] );
+#endif
     }
 
@@ -261 +265 @@
 }
 
-/***********************************************************************
- * tr_fdSocketWillCreate
- **********************************************************************/
-int tr_fdSocketWillCreate( int reserved )
-{
-    int ret;
-
-    tr_lockLock( &gFd->lock );
-
-    if( reserved )
-    {
-        if( gFd->reserved < TR_RESERVED_FDS )
-        {
-            ret = 0;
-            (gFd->reserved)++;
-        }
+
+/***********************************************************************
+ * Sockets
+ **********************************************************************/
+typedef struct
+{
+    int socket;
+    int priority;
+}
+tr_socket_t;
+
+/* Remember the priority of every socket we open, so that we can keep
+ * track of how many reserved file descriptors we are using */
+static tr_socket_t * gSockets = NULL;
+static int gSocketsSize = 0;
+static int gSocketsCount = 0;
+static void SocketSetPriority( int s, int priority )
+{
+    if( gSocketsSize < 1 )
+    {
+        gSocketsSize = 256;
+        gSockets = malloc( gSocketsSize * sizeof( tr_socket_t ) );
+    }
+    if( gSocketsSize <= gSocketsCount )
+    {
+        gSocketsSize *= 2;
+        gSockets = realloc( gSockets, gSocketsSize * sizeof( tr_socket_t ) );
+    }
+    gSockets[gSocketsCount].socket = s;
+    gSockets[gSocketsCount].priority = priority;
+    gSocketsCount++;
+}
+static int SocketGetPriority( int s )
+{
+    int i, ret;
+    for( i = 0; i < gSocketsCount; i++ )
+        if( gSockets[i].socket == s )
+            break;
+    if( i >= gSocketsCount )
+    {
+        tr_err( "could not find that socket (%d)!", s );
+        return -1;
+    }
+    ret = gSockets[i].priority;
+    gSocketsCount--;
+    memmove( &gSockets[i], &gSockets[i+1],
+            ( gSocketsCount - i ) * sizeof( tr_socket_t ) );
+}
+
+/***********************************************************************
+ * tr_fdSocketCreate
+ **********************************************************************/
+int tr_fdSocketCreate( int type, int priority )
+{
+    int s = -1;
+
+    tr_lockLock( &gFd->lock );
+    if( ( priority && gFd->reserved < TR_RESERVED_FDS ) ||
+        ( !priority && gFd->normal < gFd->normalMax ) )
+    {
+       if( ( s = socket( AF_INET, type, 0 ) ) < 0 )
+       {
+           tr_err( "Could not create socket (%s)", strerror( errno ) );
+       }
+    }
+    if( s > -1 )
+    {
+        SocketSetPriority( s, priority );
+        if( priority )
+            gFd->reserved++;
         else
-        {
-            ret = 1;
-        }
-    }
+            gFd->normal++;
+    }
+    tr_lockUnlock( &gFd->lock );
+
+    return s;
+}
+
+int tr_fdSocketAccept( int b, struct in_addr * addr, in_port_t * port )
+{
+    int s = -1;
+    unsigned len;
+    struct sockaddr_in sock;
+
+    tr_lockLock( &gFd->lock );
+    if( gFd->normal < gFd->normalMax )
+    {
+        len = sizeof( sock );
+        s = accept( b, (struct sockaddr *) &sock, &len );
+    }
+    if( s > -1 )
+    {
+        SocketSetPriority( s, 0 );
+        *addr = sock.sin_addr;
+        *port = sock.sin_port;
+        gFd->normal++;
+    }
+    tr_lockUnlock( &gFd->lock );
+
+    return s;
+}
+
+/***********************************************************************
+ * tr_fdSocketClose
+ **********************************************************************/
+void tr_fdSocketClose( int s )
+{
+    tr_lockLock( &gFd->lock );
+#ifdef BEOS_NETSERVER
+    closesocket( s );
+#else
+    close( s );
+#endif
+    if( SocketGetPriority( s ) )
+        gFd->reserved--;
     else
-    {
-        if( gFd->normal < gFd->normalMax )
-        {
-            ret = 0;
-            (gFd->normal)++;
-        }
-        else
-        {
-            ret = 1;
-        }
-    }
-
-    tr_lockUnlock( &gFd->lock );
-
-    return ret;
-}
-
-/***********************************************************************
- * tr_fdSocketClosed
- **********************************************************************/
-void tr_fdSocketClosed( int reserved )
-{
-    tr_lockLock( &gFd->lock );
-
-    if( reserved )
-    {
-        (gFd->reserved)--;
-    }
-    else
-    {
-        (gFd->normal)--;
-    }
-
+        gFd->normal--;
     tr_lockUnlock( &gFd->lock );
 }

trunk/libtransmission/fdlimit.h

@@ -59 +59 @@
 
 /***********************************************************************
- * tr_fdSocketWillCreate
+ * Sockets
  **********************************************************************/
-int tr_fdSocketWillCreate( int );
-
-/***********************************************************************
- * tr_fdSocketClosed
- **********************************************************************/
-void tr_fdSocketClosed( int );
-
+int  tr_fdSocketCreate( int type, int priority );
+int  tr_fdSocketAccept( int b, struct in_addr * addr, in_port_t * port );
+void tr_fdSocketClose( int s );
 
 /***********************************************************************

trunk/libtransmission/http.c

@@ -546 +546 @@
             if( !tr_netResolve( http->host, &addr ) )
             {
-                http->sock = tr_netOpenTCP( addr, htons( http->port ) );
+                http->sock = tr_netOpenTCP( addr, htons( http->port ), 1 );
                 http->state = HTTP_STATE_CONNECT;
                 break;
@@ -568 +568 @@
                     tr_netResolveClose( http->resolve );
                     http->resolve = NULL;
-                    http->sock = tr_netOpenTCP( addr, htons( http->port ) );
+                    http->sock = tr_netOpenTCP( addr, htons( http->port ), 1 );
                     http->state = HTTP_STATE_CONNECT;
             }

trunk/libtransmission/natpmp.c

@@ -472 +472 @@
         tr_netClose( *fd );
         *fd = -1;
-        tr_fdSocketClosed( 0 );
     }
 }
@@ -489 +488 @@
     }
     ret->fd = -1;
-    if( tr_fdSocketWillCreate( 0 ) )
-    {
-        goto err;
-    }
-    ret->fd = tr_netOpenUDP( addr, htons( PMP_PORT ) );
+    ret->fd = tr_netOpenUDP( addr, htons( PMP_PORT ), 1 );
     if( 0 > ret->fd )
     {
@@ -584 +579 @@
     struct in_addr addr;
 
-    if( tr_fdSocketWillCreate( 0 ) )
-    {
-        return -1;
-    }
-
     addr.s_addr = inet_addr( PMP_MCAST_ADDR );
     fd = tr_netMcastOpen( PMP_PORT, addr );
     if( 0 > fd )
     {
-        tr_fdSocketClosed( 0 );
         return -1;
     }

trunk/libtransmission/net.c

@@ -223 +223 @@
 
 /***********************************************************************
- * TCP sockets
+ * TCP/UDP sockets
  **********************************************************************/
 
@@ -248 +248 @@
 }
 
-static int createSocket( int type )
+static int createSocket( int type, int priority )
 {
     int s;
-
-    s = socket( AF_INET, type, 0 );
-    if( s < 0 )
-    {
-        tr_err( "Could not create socket (%s)", strerror( errno ) );
-        return -1;
-    }
-
+    if( ( s = tr_fdSocketCreate( type, priority ) ) < 0 )
+    {
+        return -1;
+    }
     return makeSocketNonBlocking( s );
 }
 
-int tr_netOpen( struct in_addr addr, in_port_t port, int type )
+int tr_netOpen( struct in_addr addr, in_port_t port, int type, int priority )
 {
     int s;
     struct sockaddr_in sock;
 
-    s = createSocket( type );
-    if( s < 0 )
+    if( ( s = createSocket( type, priority ) ) < 0 )
     {
         return -1;
@@ -329 +324 @@
 #endif
 
-    s = createSocket( type );
-    if( s < 0 )
+    if( ( s = createSocket( type, 1 ) ) < 0 )
     {
         return -1;
@@ -364 +358 @@
 }
 
-int tr_netAccept( int s, struct in_addr * addr, in_port_t * port )
-{
-    int t;
-    unsigned len;
-    struct sockaddr_in sock;
-
-    len = sizeof( sock );
-    t   = accept( s, (struct sockaddr *) &sock, &len );
-
-    if( t < 0 )
-    {
-        return -1;
-    }
-    
-    *addr = sock.sin_addr;
-    *port = sock.sin_port;
-
-    return makeSocketNonBlocking( t );
+int tr_netAccept( int b, struct in_addr * addr, in_port_t * port )
+{
+    int s;
+    if( ( s = tr_fdSocketAccept( b, addr, port ) ) < 0 )
+    {
+        return -1;
+    }
+    return makeSocketNonBlocking( s );
 }
 
@@ -432 +416 @@
 void tr_netClose( int s )
 {
-#ifdef BEOS_NETSERVER
-    closesocket( s );
-#else
-    close( s );
-#endif
+    tr_fdSocketClose( s );
 }
 

trunk/libtransmission/net.h

@@ -38 +38 @@
 
 /***********************************************************************
- * TCP sockets
+ * TCP and UDP sockets
  **********************************************************************/
-#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 );
+#define tr_netOpenTCP( addr, port, priority ) \
+    tr_netOpen( (addr), (port), SOCK_STREAM, (priority) )
+#define tr_netOpenUDP( addr, port, priority ) \
+    tr_netOpen( (addr), (port), SOCK_DGRAM, (priority) )
+int  tr_netOpen    ( struct in_addr addr, in_port_t port, int type,
+                     int priority );
 int  tr_netMcastOpen( int port, struct in_addr addr );
 #define tr_netBindTCP( port ) tr_netBind( (port), SOCK_STREAM )

trunk/libtransmission/peer.c

@@ -186 +186 @@
     {
         tr_netClose( peer->socket );
-        tr_fdSocketClosed( 0 );
     }
     tr_rcClose( peer->download );
@@ -315 +314 @@
 
     /* Connect */
-    if( ( peer->status & PEER_STATUS_IDLE ) &&
-            !tr_fdSocketWillCreate( 0 ) )
-    {
-        peer->socket = tr_netOpenTCP( peer->addr, peer->port );
+    if( peer->status & PEER_STATUS_IDLE )
+    {
+        peer->socket = tr_netOpenTCP( peer->addr, peer->port, 0 );
         if( peer->socket < 0 )
         {
-            peer_dbg( "connection failed" );
-            tr_fdSocketClosed( 0 );
             return TR_ERROR;
         }
@@ -333 +329 @@
         uint8_t buf[68];
         tr_info_t * inf = &tor->info;
-        int ret;
 
         buf[0] = 19;

trunk/libtransmission/peerutils.h

@@ -59 +59 @@
 static int checkPeer( tr_peer_t * peer )
 {
-    tr_torrent_t * tor = peer->tor;
-
     if( peer->status < PEER_STATUS_CONNECTED &&
         tr_date() > peer->date + 8000 )

trunk/libtransmission/shared.c

@@ -105 +105 @@
     {
         tr_netClose( s->bindSocket );
-        tr_fdSocketClosed( 0 );
     }
     tr_lockClose( &s->lock );
@@ -157 +156 @@
     {
         tr_netClose( s->bindSocket );
-        tr_fdSocketClosed( 0 );
     }
 
     /* Create the new one */
-    if( !tr_fdSocketWillCreate( 0 ) )
-    {
-        /* XXX should handle failure here in a better way */
-        s->bindSocket = tr_netBindTCP( port );
-        if( 0 > s->bindSocket )
-        {
-            tr_fdSocketClosed( 0 );
-        }
-        else
-        {
-            tr_inf( "Bound listening port %d", port );
-            listen( s->bindSocket, 5 );
-        }
+    /* XXX should handle failure here in a better way */
+    s->bindSocket = tr_netBindTCP( port );
+    if( s->bindSocket >= 0 )
+    {
+        tr_inf( "Bound listening port %d", port );
+        listen( s->bindSocket, 5 );
     }
 
@@ -312 +303 @@
     for( ;; )
     {
-        if( s->bindSocket < 0 || s->peerCount >= MAX_PEER_COUNT ||
-            tr_fdSocketWillCreate( 0 ) )
-        {
-            break;;
+        if( s->bindSocket < 0 || s->peerCount >= MAX_PEER_COUNT )
+        {
+            break;
         }
 
@@ -321 +311 @@
         if( socket < 0 )
         {
-            tr_fdSocketClosed( 0 );
             break;
         }

trunk/libtransmission/tracker.c

@@ -346 +346 @@
         tc->randOffset = tr_rand( 60000 );
         
-        if( tr_fdSocketWillCreate( 1 ) )
-        {
-            return;
-        }
         tc->dateTry = tr_date();
         
@@ -460 +456 @@
     if( ( NULL == tc->httpScrape ) && shouldScrape( tc ) )
     {
-        if( tr_fdSocketWillCreate( 1 ) )
-        {
-            return;
-        }
         tc->dateScrape = tr_date();
         
@@ -1166 +1158 @@
     {
         tr_httpClose( *http );
-        tr_fdSocketClosed( 1 );
         *http = NULL;
     }

trunk/libtransmission/upnp.c

@@ -335 +335 @@
     if( 0 > fd )
     {
-        if( tr_fdSocketWillCreate( 0 ) )
-        {
-            return -1;
-        }
         fd = tr_netBindUDP( 0 );
         if( 0 > fd )
         {
-            tr_fdSocketClosed( 0 );
             return -1;
         }
@@ -387 +382 @@
     struct in_addr addr;
 
-    if( tr_fdSocketWillCreate( 0 ) )
-    {
-        return -1;
-    }
-
     addr.s_addr = inet_addr( SSDP_ADDR );
     fd = tr_netMcastOpen( SSDP_PORT, addr );
     if( 0 > fd )
     {
-        tr_fdSocketClosed( 0 );
         return -1;
     }
@@ -410 +399 @@
         tr_netClose( *sock );
         *sock = -1;
-        tr_fdSocketClosed( 0 );
     }
 }
@@ -419 +407 @@
     tr_httpClose( *http );
     *http = NULL;
-    tr_fdSocketClosed( 0 );
 }
 
@@ -850 +837 @@
     tr_http_t  * ret;
     char numstr[6];
-
-    if( tr_fdSocketWillCreate( 0 ) )
-    {
-        return NULL;
-    }
 
     ret = NULL;
@@ -914 +896 @@
     }
 
-    if( NULL == ret )
-    {
-        tr_fdSocketClosed( 0 );
-    }
-
     return ret;
 }