Changeset 4311


Ignore:
Timestamp:
Dec 24, 2007, 7:02:40 AM (14 years ago)
Author:
charles
Message:

(gtk) fix startup port issue by hitting it with a damn big hammer

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/gtk/main.c

    r4306 r4311  
    658658initializeFromPrefs( struct cbdata * cbdata )
    659659{
    660     size_t i;
    661     const char * keys[] =
    662     {
    663         PREF_KEY_PORT,
    664         PREF_KEY_DL_LIMIT_ENABLED,
    665         PREF_KEY_DL_LIMIT,
    666         PREF_KEY_UL_LIMIT_ENABLED,
    667         PREF_KEY_UL_LIMIT,
    668         PREF_KEY_NAT,
    669         PREF_KEY_PEX,
    670         PREF_KEY_SYSTRAY,
    671         PREF_KEY_ENCRYPTED_ONLY
    672     };
    673 
    674     for( i=0; i<G_N_ELEMENTS(keys); ++i )
    675         prefschanged( NULL, keys[i], cbdata );
     660    prefschanged( NULL, PREF_KEY_SYSTRAY, cbdata );
    676661}
    677662

  • trunk/gtk/tr_core.c

    r4284 r4311  
    324324tr_core_init( GTypeInstance * instance, gpointer g_class SHUTUP )
    325325{
     326    tr_handle * h;
    326327    TrCore * self = (TrCore *) instance;
    327328    GtkListStore * store;
    … …  
    338339    };
    339340
     341    h = tr_initFull( "gtk",
     342                     pref_flag_get( PREF_KEY_PEX ),
     343                     pref_flag_get( PREF_KEY_NAT ),
     344                     pref_int_get( PREF_KEY_PORT ),
     345                     pref_flag_get( PREF_KEY_ENCRYPTED_ONLY )
     346                         ? TR_ENCRYPTION_REQUIRED
     347                         : TR_ENCRYPTION_PREFERRED,
     348                     pref_flag_get( PREF_KEY_UL_LIMIT_ENABLED ),
     349                     pref_int_get( PREF_KEY_UL_LIMIT ),
     350                     pref_flag_get( PREF_KEY_DL_LIMIT_ENABLED ),
     351                     pref_int_get( PREF_KEY_DL_LIMIT ),
     352                     pref_int_get( PREF_KEY_MAX_PEERS_GLOBAL ) );
     353
    340354    /* create the model used to store torrent data */
    341355    g_assert( ALEN( types ) == MC_ROW_COUNT );
    … …  
    343357
    344358    self->model    = GTK_TREE_MODEL( store );
    345     self->handle   = tr_init( "gtk" );
     359    self->handle   = h;
    346360    self->nextid   = 1;
    347361    self->quitting = FALSE;

  • trunk/libtransmission/fdlimit.c

    r4255 r4311  
    8787enum
    8888{
    89     TR_MAX_PEER_SOCKETS = 512,
    90 
    9189    TR_MAX_OPEN_FILES = 16, /* real files, not sockets */
    9290
    … …  
    453451
    454452void
    455 tr_fdInit( void )
    456 {
    457     int i, j, s[TR_MAX_PEER_SOCKETS];
     453tr_fdInit( int globalPeerLimit )
     454{
     455    int i, j, *s;
    458456
    459457    assert( gFd == NULL );
    … …  
    462460    gFd->lock = tr_lockNew( );
    463461
     462    s = tr_new( int, globalPeerLimit );
     463
    464464    /* count the max number of sockets we can use */
    465     for( i=0; i<TR_MAX_PEER_SOCKETS; ++i )
     465    for( i=0; i<globalPeerLimit; ++i )
    466466        if( ( s[i] = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
    467467            break;
    … …  
    475475    for( i=0; i<TR_MAX_OPEN_FILES; ++i )
    476476        gFd->open[i].fd = -1;
    477          
     477
     478    tr_free( s );
    478479}
    479480
    … …  
    503504tr_fdGetPeerLimit( void )
    504505{
    505     return gFd ? gFd->normalMax : TR_MAX_PEER_SOCKETS;
    506 }
     506    return gFd ? gFd->normalMax : -1;
     507}

  • trunk/libtransmission/fdlimit.h

    r4255 r4311  
    3030 * Detect the maximum number of open files and initializes things.
    3131 **********************************************************************/
    32 void tr_fdInit( void );
     32void tr_fdInit( int globalPeerLimit );
    3333
    3434void tr_fdClose( void );

  • trunk/libtransmission/shared.c

    r4102 r4311  
    169169
    170170tr_shared *
    171 tr_sharedInit( tr_handle * h )
     171tr_sharedInit( tr_handle * h, int isEnabled, int publicPort )
    172172{
    173173    tr_shared * s = tr_new0( tr_shared, 1 );
    174174
    175175    s->h            = h;
    176     s->publicPort   = -1;
     176    s->publicPort   = publicPort;
    177177    s->bindPort     = -1;
    178178    s->bindSocket   = -1;
    … …  
    180180    s->upnp         = tr_upnpInit();
    181181    s->pulseTimer   = tr_timerNew( h, sharedPulse, s, 500 );
    182     s->isEnabled    = 0;
     182    s->isEnabled    = isEnabled ? 1 : 0;
    183183    s->natStatus    = TR_NAT_TRAVERSAL_UNMAPPED;
    184184

  • trunk/libtransmission/shared.h

    r4092 r4311  
    3030typedef struct tr_shared tr_shared;
    3131
    32 tr_shared* tr_sharedInit            ( tr_handle * );
     32tr_shared* tr_sharedInit            ( tr_handle *, int isEnabled, int publicPort );
    3333void       tr_sharedShuttingDown    ( tr_shared * );
    3434void       tr_sharedSetPort         ( tr_shared *, int publicPort );

  • trunk/libtransmission/transmission.c

    r4306 r4311  
    104104***/
    105105
    106 
    107 /***********************************************************************
    108  * tr_init
    109  ***********************************************************************
    110  * Allocates a tr_handle structure and initializes a few things
    111  **********************************************************************/
    112 tr_handle * tr_init( const char * tag )
     106tr_handle *
     107tr_initFull( const char * tag,
     108             int          isPexEnabled,
     109             int          isNatEnabled,
     110             int          publicPort,
     111             int          encryptionMode,
     112             int          isUploadLimitEnabled,
     113             int          uploadLimit,
     114             int          isDownloadLimitEnabled,
     115             int          downloadLimit,
     116             int          globalPeerLimit )
    113117{
    114118    tr_handle * h;
    … …  
    119123#endif
    120124
    121     tr_msgInit();
     125    tr_msgInit( );
    122126
    123127    h = tr_new0( tr_handle, 1 );
    124     if( !h )
    125         return NULL;
    126 
    127128    h->lock = tr_lockNew( );
    128     h->isPexEnabled = 1;
    129     h->encryptionMode = TR_ENCRYPTION_PREFERRED;
     129    h->isPexEnabled = isPexEnabled ? 1 : 0;
     130    h->encryptionMode = encryptionMode;
    130131
    131132    tr_netInit(); /* must go before tr_eventInit */
    … …  
    144145
    145146    /* Initialize rate and file descripts controls */
    146     h->upload   = tr_rcInit();
     147
     148    h->upload = tr_rcInit();
     149    tr_rcSetLimit( h->upload, uploadLimit );
     150    h->useUploadLimit = isUploadLimitEnabled;
     151
    147152    h->download = tr_rcInit();
    148 
    149     tr_fdInit();
    150     h->shared = tr_sharedInit( h );
     153    tr_rcSetLimit( h->download, downloadLimit );
     154    h->useDownloadLimit = isDownloadLimitEnabled;
     155
     156    tr_fdInit( globalPeerLimit );
     157    h->shared = tr_sharedInit( h, isNatEnabled, publicPort );
     158    h->isPortSet = publicPort >= 0;
    151159
    152160    tr_inf( TR_NAME " " LONG_VERSION_STRING " started" );
    … …  
    155163
    156164    return h;
     165}
     166
     167tr_handle * tr_init( const char * tag )
     168{
     169    return tr_initFull( tag,
     170                        TRUE, /* pex enabled */
     171                        FALSE, /* nat enabled */
     172                        -1, /* public port */
     173                        TR_ENCRYPTION_PREFERRED, /* encryption mode */
     174                        FALSE, /* use upload speed limit? */
     175                        -1, /* upload speed limit */
     176                        FALSE, /* use download speed limit? */
     177                        -1, /* download speed limit */
     178                        512 ); /* globalPeerLimit */
    157179}
    158180

  • trunk/libtransmission/transmission.h

    r4306 r4311  
    112112void tr_close( tr_handle * );
    113113
     114tr_handle * tr_initFull( const char * tag,
     115                         int          isPexEnabled,
     116                         int          isNatEnabled,
     117                         int          publicPort,
     118                         int          encryptionMode,
     119                         int          isUploadLimitEnabled,
     120                         int          uploadLimit,
     121                         int          isDownloadLimitEnabled,
     122                         int          downloadLimit,
     123                         int          globalPeerLimit );
     124
    114125
    115126/**

  • trunk/libtransmission/upnp.c

    r4251 r4311  
    134134    if( handle->state == TR_UPNP_MAP )
    135135    {
     136        int err = -1;
    136137        char portStr[16];
    137138        snprintf( portStr, sizeof(portStr), "%d", port );
    138139        errno = 0;
    139         handle->isMapped = ( handle->urls.controlURL != NULL ) &&
    140                            ( handle->data.servicetype != NULL ) &&
    141                            ( UPNP_AddPortMapping( handle->urls.controlURL,
    142                                                   handle->data.servicetype,
    143                                                   portStr, portStr, handle->lanaddr,
    144                                                   "Transmission", "TCP" ) );
     140
     141        if( !handle->urls.controlURL || !handle->data.servicetype )
     142            handle->isMapped = 0;
     143        else {
     144            err = UPNP_AddPortMapping( handle->urls.controlURL,
     145                                       handle->data.servicetype,
     146                                       portStr, portStr, handle->lanaddr,
     147                                       "Transmission", "TCP" );
     148            handle->isMapped = !err;
     149        }
    145150        tr_inf( KEY "Port forwarding via '%s', service '%s'.  (local address: %s:%d)",
    146151                handle->urls.controlURL, handle->data.servicetype, handle->lanaddr, port );
    … …  
    150155            handle->state = TR_UPNP_IDLE;
    151156        } else {
    152             tr_err( KEY "Port forwarding failed (errno %d - %s)", errno, strerror(errno) );
     157            tr_err( KEY "Port forwarding failed with err %d (%d - %s)", err, errno, strerror(errno) );
    153158            tr_err( KEY "If your router supports UPnP, please make sure UPnP is enabled!" );
    154159            handle->port = -1;
Note: See TracChangeset for help on using the changeset viewer.