Changeset 1425


Ignore:
Timestamp:
Jan 21, 2007, 7:42:11 PM (15 years ago)
Author:
titer
Message:

More simplifications

Location:
trunk/libtransmission
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/fdlimit.c

    r1420 r1425  
    102102    for( j = 0; j < i; j++ )
    103103    {
    104         tr_netClose( s[j] );
     104#ifdef BEOS_NETSERVER
     105            closesocket( s[j] );
     106#else
     107            close( s[j] );
     108#endif
    105109    }
    106110
     
    261265}
    262266
    263 /***********************************************************************
    264  * tr_fdSocketWillCreate
    265  **********************************************************************/
    266 int tr_fdSocketWillCreate( int reserved )
    267 {
    268     int ret;
    269 
    270     tr_lockLock( &gFd->lock );
    271 
    272     if( reserved )
    273     {
    274         if( gFd->reserved < TR_RESERVED_FDS )
    275         {
    276             ret = 0;
    277             (gFd->reserved)++;
    278         }
     267
     268/***********************************************************************
     269 * Sockets
     270 **********************************************************************/
     271typedef struct
     272{
     273    int socket;
     274    int priority;
     275}
     276tr_socket_t;
     277
     278/* Remember the priority of every socket we open, so that we can keep
     279 * track of how many reserved file descriptors we are using */
     280static tr_socket_t * gSockets = NULL;
     281static int gSocketsSize = 0;
     282static int gSocketsCount = 0;
     283static void SocketSetPriority( int s, int priority )
     284{
     285    if( gSocketsSize < 1 )
     286    {
     287        gSocketsSize = 256;
     288        gSockets = malloc( gSocketsSize * sizeof( tr_socket_t ) );
     289    }
     290    if( gSocketsSize <= gSocketsCount )
     291    {
     292        gSocketsSize *= 2;
     293        gSockets = realloc( gSockets, gSocketsSize * sizeof( tr_socket_t ) );
     294    }
     295    gSockets[gSocketsCount].socket = s;
     296    gSockets[gSocketsCount].priority = priority;
     297    gSocketsCount++;
     298}
     299static int SocketGetPriority( int s )
     300{
     301    int i, ret;
     302    for( i = 0; i < gSocketsCount; i++ )
     303        if( gSockets[i].socket == s )
     304            break;
     305    if( i >= gSocketsCount )
     306    {
     307        tr_err( "could not find that socket (%d)!", s );
     308        return -1;
     309    }
     310    ret = gSockets[i].priority;
     311    gSocketsCount--;
     312    memmove( &gSockets[i], &gSockets[i+1],
     313            ( gSocketsCount - i ) * sizeof( tr_socket_t ) );
     314}
     315
     316/***********************************************************************
     317 * tr_fdSocketCreate
     318 **********************************************************************/
     319int tr_fdSocketCreate( int type, int priority )
     320{
     321    int s = -1;
     322
     323    tr_lockLock( &gFd->lock );
     324    if( ( priority && gFd->reserved < TR_RESERVED_FDS ) ||
     325        ( !priority && gFd->normal < gFd->normalMax ) )
     326    {
     327       if( ( s = socket( AF_INET, type, 0 ) ) < 0 )
     328       {
     329           tr_err( "Could not create socket (%s)", strerror( errno ) );
     330       }
     331    }
     332    if( s > -1 )
     333    {
     334        SocketSetPriority( s, priority );
     335        if( priority )
     336            gFd->reserved++;
    279337        else
    280         {
    281             ret = 1;
    282         }
    283     }
     338            gFd->normal++;
     339    }
     340    tr_lockUnlock( &gFd->lock );
     341
     342    return s;
     343}
     344
     345int tr_fdSocketAccept( int b, struct in_addr * addr, in_port_t * port )
     346{
     347    int s = -1;
     348    unsigned len;
     349    struct sockaddr_in sock;
     350
     351    tr_lockLock( &gFd->lock );
     352    if( gFd->normal < gFd->normalMax )
     353    {
     354        len = sizeof( sock );
     355        s = accept( b, (struct sockaddr *) &sock, &len );
     356    }
     357    if( s > -1 )
     358    {
     359        SocketSetPriority( s, 0 );
     360        *addr = sock.sin_addr;
     361        *port = sock.sin_port;
     362        gFd->normal++;
     363    }
     364    tr_lockUnlock( &gFd->lock );
     365
     366    return s;
     367}
     368
     369/***********************************************************************
     370 * tr_fdSocketClose
     371 **********************************************************************/
     372void tr_fdSocketClose( int s )
     373{
     374    tr_lockLock( &gFd->lock );
     375#ifdef BEOS_NETSERVER
     376    closesocket( s );
     377#else
     378    close( s );
     379#endif
     380    if( SocketGetPriority( s ) )
     381        gFd->reserved--;
    284382    else
    285     {
    286         if( gFd->normal < gFd->normalMax )
    287         {
    288             ret = 0;
    289             (gFd->normal)++;
    290         }
    291         else
    292         {
    293             ret = 1;
    294         }
    295     }
    296 
    297     tr_lockUnlock( &gFd->lock );
    298 
    299     return ret;
    300 }
    301 
    302 /***********************************************************************
    303  * tr_fdSocketClosed
    304  **********************************************************************/
    305 void tr_fdSocketClosed( int reserved )
    306 {
    307     tr_lockLock( &gFd->lock );
    308 
    309     if( reserved )
    310     {
    311         (gFd->reserved)--;
    312     }
    313     else
    314     {
    315         (gFd->normal)--;
    316     }
    317 
     383        gFd->normal--;
    318384    tr_lockUnlock( &gFd->lock );
    319385}
  • trunk/libtransmission/fdlimit.h

    r1420 r1425  
    5959
    6060/***********************************************************************
    61  * tr_fdSocketWillCreate
     61 * Sockets
    6262 **********************************************************************/
    63 int tr_fdSocketWillCreate( int );
    64 
    65 /***********************************************************************
    66  * tr_fdSocketClosed
    67  **********************************************************************/
    68 void tr_fdSocketClosed( int );
    69 
     63int  tr_fdSocketCreate( int type, int priority );
     64int  tr_fdSocketAccept( int b, struct in_addr * addr, in_port_t * port );
     65void tr_fdSocketClose( int s );
    7066
    7167/***********************************************************************
  • trunk/libtransmission/http.c

    r1356 r1425  
    546546            if( !tr_netResolve( http->host, &addr ) )
    547547            {
    548                 http->sock = tr_netOpenTCP( addr, htons( http->port ) );
     548                http->sock = tr_netOpenTCP( addr, htons( http->port ), 1 );
    549549                http->state = HTTP_STATE_CONNECT;
    550550                break;
     
    568568                    tr_netResolveClose( http->resolve );
    569569                    http->resolve = NULL;
    570                     http->sock = tr_netOpenTCP( addr, htons( http->port ) );
     570                    http->sock = tr_netOpenTCP( addr, htons( http->port ), 1 );
    571571                    http->state = HTTP_STATE_CONNECT;
    572572            }
  • trunk/libtransmission/natpmp.c

    r1420 r1425  
    472472        tr_netClose( *fd );
    473473        *fd = -1;
    474         tr_fdSocketClosed( 0 );
    475474    }
    476475}
     
    489488    }
    490489    ret->fd = -1;
    491     if( tr_fdSocketWillCreate( 0 ) )
    492     {
    493         goto err;
    494     }
    495     ret->fd = tr_netOpenUDP( addr, htons( PMP_PORT ) );
     490    ret->fd = tr_netOpenUDP( addr, htons( PMP_PORT ), 1 );
    496491    if( 0 > ret->fd )
    497492    {
     
    584579    struct in_addr addr;
    585580
    586     if( tr_fdSocketWillCreate( 0 ) )
    587     {
    588         return -1;
    589     }
    590 
    591581    addr.s_addr = inet_addr( PMP_MCAST_ADDR );
    592582    fd = tr_netMcastOpen( PMP_PORT, addr );
    593583    if( 0 > fd )
    594584    {
    595         tr_fdSocketClosed( 0 );
    596585        return -1;
    597586    }
  • trunk/libtransmission/net.c

    r1420 r1425  
    223223
    224224/***********************************************************************
    225  * TCP sockets
     225 * TCP/UDP sockets
    226226 **********************************************************************/
    227227
     
    248248}
    249249
    250 static int createSocket( int type )
     250static int createSocket( int type, int priority )
    251251{
    252252    int s;
    253 
    254     s = socket( AF_INET, type, 0 );
    255     if( s < 0 )
    256     {
    257         tr_err( "Could not create socket (%s)", strerror( errno ) );
    258         return -1;
    259     }
    260 
     253    if( ( s = tr_fdSocketCreate( type, priority ) ) < 0 )
     254    {
     255        return -1;
     256    }
    261257    return makeSocketNonBlocking( s );
    262258}
    263259
    264 int tr_netOpen( struct in_addr addr, in_port_t port, int type )
     260int tr_netOpen( struct in_addr addr, in_port_t port, int type, int priority )
    265261{
    266262    int s;
    267263    struct sockaddr_in sock;
    268264
    269     s = createSocket( type );
    270     if( s < 0 )
     265    if( ( s = createSocket( type, priority ) ) < 0 )
    271266    {
    272267        return -1;
     
    329324#endif
    330325
    331     s = createSocket( type );
    332     if( s < 0 )
     326    if( ( s = createSocket( type, 1 ) ) < 0 )
    333327    {
    334328        return -1;
     
    364358}
    365359
    366 int tr_netAccept( int s, struct in_addr * addr, in_port_t * port )
    367 {
    368     int t;
    369     unsigned len;
    370     struct sockaddr_in sock;
    371 
    372     len = sizeof( sock );
    373     t   = accept( s, (struct sockaddr *) &sock, &len );
    374 
    375     if( t < 0 )
    376     {
    377         return -1;
    378     }
    379    
    380     *addr = sock.sin_addr;
    381     *port = sock.sin_port;
    382 
    383     return makeSocketNonBlocking( t );
     360int tr_netAccept( int b, struct in_addr * addr, in_port_t * port )
     361{
     362    int s;
     363    if( ( s = tr_fdSocketAccept( b, addr, port ) ) < 0 )
     364    {
     365        return -1;
     366    }
     367    return makeSocketNonBlocking( s );
    384368}
    385369
     
    432416void tr_netClose( int s )
    433417{
    434 #ifdef BEOS_NETSERVER
    435     closesocket( s );
    436 #else
    437     close( s );
    438 #endif
     418    tr_fdSocketClose( s );
    439419}
    440420
  • trunk/libtransmission/net.h

    r920 r1425  
    3838
    3939/***********************************************************************
    40  * TCP sockets
     40 * TCP and UDP sockets
    4141 **********************************************************************/
    42 #define tr_netOpenTCP( addr, port ) tr_netOpen( (addr), (port), SOCK_STREAM )
    43 #define tr_netOpenUDP( addr, port ) tr_netOpen( (addr), (port), SOCK_DGRAM )
    44 int  tr_netOpen    ( struct in_addr addr, in_port_t port, int type );
     42#define tr_netOpenTCP( addr, port, priority ) \
     43    tr_netOpen( (addr), (port), SOCK_STREAM, (priority) )
     44#define tr_netOpenUDP( addr, port, priority ) \
     45    tr_netOpen( (addr), (port), SOCK_DGRAM, (priority) )
     46int  tr_netOpen    ( struct in_addr addr, in_port_t port, int type,
     47                     int priority );
    4548int  tr_netMcastOpen( int port, struct in_addr addr );
    4649#define tr_netBindTCP( port ) tr_netBind( (port), SOCK_STREAM )
  • trunk/libtransmission/peer.c

    r1424 r1425  
    186186    {
    187187        tr_netClose( peer->socket );
    188         tr_fdSocketClosed( 0 );
    189188    }
    190189    tr_rcClose( peer->download );
     
    315314
    316315    /* Connect */
    317     if( ( peer->status & PEER_STATUS_IDLE ) &&
    318             !tr_fdSocketWillCreate( 0 ) )
    319     {
    320         peer->socket = tr_netOpenTCP( peer->addr, peer->port );
     316    if( peer->status & PEER_STATUS_IDLE )
     317    {
     318        peer->socket = tr_netOpenTCP( peer->addr, peer->port, 0 );
    321319        if( peer->socket < 0 )
    322320        {
    323             peer_dbg( "connection failed" );
    324             tr_fdSocketClosed( 0 );
    325321            return TR_ERROR;
    326322        }
     
    333329        uint8_t buf[68];
    334330        tr_info_t * inf = &tor->info;
    335         int ret;
    336331
    337332        buf[0] = 19;
  • trunk/libtransmission/peerutils.h

    r1424 r1425  
    5959static int checkPeer( tr_peer_t * peer )
    6060{
    61     tr_torrent_t * tor = peer->tor;
    62 
    6361    if( peer->status < PEER_STATUS_CONNECTED &&
    6462        tr_date() > peer->date + 8000 )
  • trunk/libtransmission/shared.c

    r1420 r1425  
    105105    {
    106106        tr_netClose( s->bindSocket );
    107         tr_fdSocketClosed( 0 );
    108107    }
    109108    tr_lockClose( &s->lock );
     
    157156    {
    158157        tr_netClose( s->bindSocket );
    159         tr_fdSocketClosed( 0 );
    160158    }
    161159
    162160    /* Create the new one */
    163     if( !tr_fdSocketWillCreate( 0 ) )
    164     {
    165         /* XXX should handle failure here in a better way */
    166         s->bindSocket = tr_netBindTCP( port );
    167         if( 0 > s->bindSocket )
    168         {
    169             tr_fdSocketClosed( 0 );
    170         }
    171         else
    172         {
    173             tr_inf( "Bound listening port %d", port );
    174             listen( s->bindSocket, 5 );
    175         }
     161    /* XXX should handle failure here in a better way */
     162    s->bindSocket = tr_netBindTCP( port );
     163    if( s->bindSocket >= 0 )
     164    {
     165        tr_inf( "Bound listening port %d", port );
     166        listen( s->bindSocket, 5 );
    176167    }
    177168
     
    312303    for( ;; )
    313304    {
    314         if( s->bindSocket < 0 || s->peerCount >= MAX_PEER_COUNT ||
    315             tr_fdSocketWillCreate( 0 ) )
    316         {
    317             break;;
     305        if( s->bindSocket < 0 || s->peerCount >= MAX_PEER_COUNT )
     306        {
     307            break;
    318308        }
    319309
     
    321311        if( socket < 0 )
    322312        {
    323             tr_fdSocketClosed( 0 );
    324313            break;
    325314        }
  • trunk/libtransmission/tracker.c

    r1420 r1425  
    346346        tc->randOffset = tr_rand( 60000 );
    347347       
    348         if( tr_fdSocketWillCreate( 1 ) )
    349         {
    350             return;
    351         }
    352348        tc->dateTry = tr_date();
    353349       
     
    460456    if( ( NULL == tc->httpScrape ) && shouldScrape( tc ) )
    461457    {
    462         if( tr_fdSocketWillCreate( 1 ) )
    463         {
    464             return;
    465         }
    466458        tc->dateScrape = tr_date();
    467459       
     
    11661158    {
    11671159        tr_httpClose( *http );
    1168         tr_fdSocketClosed( 1 );
    11691160        *http = NULL;
    11701161    }
  • trunk/libtransmission/upnp.c

    r1420 r1425  
    335335    if( 0 > fd )
    336336    {
    337         if( tr_fdSocketWillCreate( 0 ) )
    338         {
    339             return -1;
    340         }
    341337        fd = tr_netBindUDP( 0 );
    342338        if( 0 > fd )
    343339        {
    344             tr_fdSocketClosed( 0 );
    345340            return -1;
    346341        }
     
    387382    struct in_addr addr;
    388383
    389     if( tr_fdSocketWillCreate( 0 ) )
    390     {
    391         return -1;
    392     }
    393 
    394384    addr.s_addr = inet_addr( SSDP_ADDR );
    395385    fd = tr_netMcastOpen( SSDP_PORT, addr );
    396386    if( 0 > fd )
    397387    {
    398         tr_fdSocketClosed( 0 );
    399388        return -1;
    400389    }
     
    410399        tr_netClose( *sock );
    411400        *sock = -1;
    412         tr_fdSocketClosed( 0 );
    413401    }
    414402}
     
    419407    tr_httpClose( *http );
    420408    *http = NULL;
    421     tr_fdSocketClosed( 0 );
    422409}
    423410
     
    850837    tr_http_t  * ret;
    851838    char numstr[6];
    852 
    853     if( tr_fdSocketWillCreate( 0 ) )
    854     {
    855         return NULL;
    856     }
    857839
    858840    ret = NULL;
     
    914896    }
    915897
    916     if( NULL == ret )
    917     {
    918         tr_fdSocketClosed( 0 );
    919     }
    920 
    921898    return ret;
    922899}
Note: See TracChangeset for help on using the changeset viewer.