Changeset 5819


Ignore:
Timestamp:
May 12, 2008, 4:33:17 PM (14 years ago)
Author:
charles
Message:

ipc: add session accessor/mutators.
transmission.h: make the session API more consistent.

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/transmissioncli.c

    r5757 r5819  
    284284            gotsig = 0;
    285285            tr_torrentStop( tor );
    286             tr_natTraversalEnable( h, 0 );
     286            tr_sessionSetPortForwardingEnabled( h, 0 );
    287287        }
    288288       
     
    356356
    357357    /* Try for 5 seconds to delete any port mappings for nat traversal */
    358     tr_natTraversalEnable( h, 0 );
     358    tr_sessionSetPortForwardingEnabled( h, 0 );
    359359    for( i = 0; i < 10; i++ )
    360360    {
  • trunk/daemon/torrents.c

    r5818 r5819  
    378378    }
    379379
    380     tr_natTraversalEnable( gl_handle, 0 );
     380    tr_sessionSetPortForwardingEnabled( gl_handle, 0 );
    381381    starttimer( 1 );
    382382}
     
    405405    {
    406406        gl_port = port;
    407         tr_setBindPort( gl_handle, port );
     407        tr_sessionSetPublicPort( gl_handle, port );
    408408        savestate();
    409409    }
     
    426426        gl_pex = pex;
    427427
    428         tr_setPexEnabled( gl_handle, gl_pex );
     428        tr_sessionSetPexEnabled( gl_handle, gl_pex );
    429429
    430430        savestate( );
     
    444444    assert( !gl_exiting );
    445445    gl_mapping = ( automap ? 1 : 0 );
    446     tr_natTraversalEnable( gl_handle, gl_mapping );
     446    tr_sessionSetPortForwardingEnabled( gl_handle, gl_mapping );
    447447    savestate();
    448448}
     
    460460    assert( !gl_exiting );
    461461    gl_uplimit = uplimit;
    462     tr_setGlobalSpeedLimit   ( gl_handle, TR_UP, uplimit );
    463     tr_setUseGlobalSpeedLimit( gl_handle, TR_UP, uplimit > 0 );
     462    tr_sessionSetSpeedLimit( gl_handle, TR_UP, uplimit );
     463    tr_sessionSetSpeedLimitEnabled( gl_handle, TR_UP, uplimit > 0 );
    464464    savestate();
    465465}
     
    477477    assert( !gl_exiting );
    478478    gl_downlimit = downlimit;
    479     tr_setGlobalSpeedLimit   ( gl_handle, TR_DOWN, downlimit );
    480     tr_setUseGlobalSpeedLimit( gl_handle, TR_DOWN, downlimit > 0 );
     479    tr_sessionSetSpeedLimit( gl_handle, TR_DOWN, downlimit );
     480    tr_sessionSetSpeedLimitEnabled( gl_handle, TR_DOWN, downlimit > 0 );
    481481    savestate();
    482482}
     
    507507torrent_set_encryption(tr_encryption_mode mode)
    508508{
    509     tr_setEncryptionMode(gl_handle, mode);
     509    tr_sessionSetEncryption( gl_handle, mode );
    510510    gl_crypto = mode;
    511511    savestate();
     
    515515torrent_get_encryption(void)
    516516{
    517     return tr_getEncryptionMode(gl_handle);
     517    return tr_sessionGetEncryption( gl_handle );
    518518}
    519519
  • trunk/doc/ipc-json-spec.txt

    r5817 r5819  
    137137   "destination"      | string    path to download the torrent to
    138138   "filename"         | string    location of the .torrent file
    139    "max-peers"        | int       maximum number of peers
     139   "peer-limit"       | int       maximum number of peers
    140140
    141141   The "filename" argument is required; all others are optional.
     
    150150   string             | value type & description
    151151   -------------------+-------------------------------------------------
    152    "max-peers"        | int            maximum number of peers
     152   "peer-limit"       | int            maximum number of peers
    153153   "speed-limit-down" | int            maximum download speed (in KiB/s)
    154154   "speed-limit-up"   | int            maximum upload speed (in KiB/s)
     
    1971974.1.  Session Arguments
    198198
    199    string             | value type & description
    200    -------------------+-------------------------------------------------
    201    "autostart"        | boolean   true means to auto-start torrents
    202    "destination"      | string    path to download torrents to
    203    "encryption"       | string    "required", "preferred", or "plaintext"
    204    "max-peers"        | int       maximum global number of peers
    205    "port"             | int       port number
    206    "port-forwarding"  | boolean   true means enabled.
    207    "pex-allowed"      | boolean   true means allow pex for public torrents
    208    "speed-limit-down" | int       maximum global download speed (in KiB/s)
    209    "speed-limit-up"   | int       maximum global upload speed (in KiB/s)
     199   string                     | value type & description
     200   ---------------------------+-------------------------------------------------
     201   "encryption"               | string   "required", "preferred", "tolerated"
     202   "peer-limit"               | int      maximum global number of peers
     203   "port"                     | int      port number
     204   "port-forwarding-enabled"  | boolean  true means enabled.
     205   "pex-allowed"              | boolean  true means allow pex in public torrents
     206   "speed-limit-down"         | int      max global download speed (in KiB/s)
     207   "speed-limit-down-enabled" | int      max global download speed (in KiB/s)
     208   "speed-limit-up"           | int      max global upload speed (in KiB/s)
     209   "speed-limit-up-enabled"   | int      max global upload speed (in KiB/s)
    210210
    2112114.2.  Mutators
  • trunk/gtk/details.c

    r5673 r5819  
    10201020{
    10211021  const uint16_t n = gtk_spin_button_get_value( spin );
    1022   tr_torrentSetMaxConnectedPeers( tr_torrent_handle( gtor ), n );
     1022  tr_torrentSetPeerLimit( tr_torrent_handle( gtor ), n );
    10231023}
    10241024
     
    10661066  hig_workarea_add_section_title (t, &row, _("Peer Connections"));
    10671067
    1068     maxConnectedPeers = tr_torrentGetMaxConnectedPeers( tor );
     1068    maxConnectedPeers = tr_torrentGetPeerLimit( tor );
    10691069    w = gtk_spin_button_new_with_range( 1, 3000, 5 );
    10701070    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), maxConnectedPeers );
  • trunk/gtk/main.c

    r5761 r5819  
    854854    {
    855855        const gboolean crypto_only = pref_flag_get( key );
    856         tr_setEncryptionMode( tr, crypto_only ? TR_ENCRYPTION_REQUIRED
    857                                               : TR_ENCRYPTION_PREFERRED );
     856        tr_sessionSetEncryption( tr, crypto_only ? TR_ENCRYPTION_REQUIRED
     857                                                 : TR_ENCRYPTION_PREFERRED );
    858858    }
    859859    else if( !strcmp( key, PREF_KEY_PORT ) )
    860860    {
    861861        const int port = pref_int_get( key );
    862         tr_setBindPort( tr, port );
     862        tr_sessionSetPublicPort( tr, port );
    863863    }
    864864    else if( !strcmp( key, PREF_KEY_DL_LIMIT_ENABLED ) )
    865865    {
    866866        const gboolean b = pref_flag_get( key );
    867         tr_setUseGlobalSpeedLimit( tr, TR_DOWN, b );
     867        tr_sessionSetSpeedLimitEnabled( tr, TR_DOWN, b );
    868868    }
    869869    else if( !strcmp( key, PREF_KEY_DL_LIMIT ) )
    870870    {
    871871        const int limit = pref_int_get( key );
    872         tr_setGlobalSpeedLimit( tr, TR_DOWN, limit );
     872        tr_sessionSetSpeedLimit( tr, TR_DOWN, limit );
    873873    }
    874874    else if( !strcmp( key, PREF_KEY_UL_LIMIT_ENABLED ) )
    875875    {
    876876        const gboolean b = pref_flag_get( key );
    877         tr_setUseGlobalSpeedLimit( tr, TR_UP, b );
     877        tr_sessionSetSpeedLimitEnabled( tr, TR_UP, b );
    878878    }
    879879    else if( !strcmp( key, PREF_KEY_UL_LIMIT ) )
    880880    {
    881881        const int limit = pref_int_get( key );
    882         tr_setGlobalSpeedLimit( tr, TR_UP, limit );
     882        tr_sessionSetSpeedLimit( tr, TR_UP, limit );
    883883    }
    884884    else if( !strcmp( key, PREF_KEY_NAT ) )
    885885    {
    886886        const gboolean enabled = pref_flag_get( key );
    887         tr_natTraversalEnable( tr, enabled );
     887        tr_sessionSetPortForwardingEnabled( tr, enabled );
    888888    }
    889889    else if( !strcmp( key, PREF_KEY_PEX ) )
    890890    {
    891         const gboolean enabled = pref_flag_get( key );
    892         tr_setPexEnabled( tr_core_handle( cbdata->core ), enabled );
     891        const gboolean b = pref_flag_get( key );
     892        tr_sessionSetPortForwardingEnabled( tr_core_handle( cbdata->core ), b );
    893893    }
    894894}
  • trunk/gtk/tr-core.c

    r5673 r5819  
    324324        tr_ctorSetDeleteSource( ctor, pref_flag_get( PREF_KEY_TRASH_ORIGINAL ) );
    325325
    326     if( tr_ctorGetMaxConnectedPeers( ctor, TR_FORCE, NULL ) )
    327         tr_ctorSetMaxConnectedPeers( ctor, TR_FORCE,
    328                               pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
     326    if( tr_ctorGetPeerLimit( ctor, TR_FORCE, NULL ) )
     327        tr_ctorSetPeerLimit( ctor, TR_FORCE,
     328                             pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
    329329
    330330    if( tr_ctorGetDestination( ctor, TR_FORCE, NULL ) ) {
     
    444444    {
    445445        const uint16_t val = pref_int_get( key );
    446         tr_setGlobalPeerLimit( tr_core_handle( core ), val );
     446        tr_sessionSetPeerLimit( tr_core_handle( core ), val );
    447447    }
    448448#ifdef HAVE_GIO
     
    659659        tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
    660660    tr_ctorSetDestination( ctor, TR_FALLBACK, path );
    661     tr_ctorSetMaxConnectedPeers( ctor, TR_FALLBACK,
    662                                  pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
     661    tr_ctorSetPeerLimit( ctor, TR_FALLBACK,
     662                         pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
    663663
    664664    torrents = tr_loadTorrents ( tr_core_handle( self ), ctor, &count );
  • trunk/libtransmission/ipc.c

    r5817 r5819  
    247247        tr_torrent * tor = torrents[i];
    248248        tr_benc * d = tr_bencListAddDict( list, 4 );
    249         tr_bencDictAddInt( d, "id",
    250                            tor->uniqueId );
    251         tr_bencDictAddInt( d, "max-peers",
    252                            tr_torrentGetMaxConnectedPeers( tor ) );
     249        tr_bencDictAddInt( d, "id", tor->uniqueId );
     250        tr_bencDictAddInt( d, "peer-limit",
     251                           tr_torrentGetPeerLimit( tor ) );
    253252        tr_bencDictAddInt( d, "speed-limit-down",
    254253                           tr_torrentGetSpeedLimit( tor, TR_DOWN ) );
     
    271270        int64_t tmp;
    272271        tr_torrent * tor = torrents[i];
    273         if( tr_bencDictFindInt( args_in, "max-peers", &tmp ) )
    274             tr_torrentSetMaxConnectedPeers( tor, tmp );
     272        if( tr_bencDictFindInt( args_in, "peer-limit", &tmp ) )
     273            tr_torrentSetPeerLimit( tor, tmp );
    275274        if( tr_bencDictFindInt( args_in, "speed-limit-down", &tmp ) )
    276275            tr_torrentSetSpeedLimit( tor, TR_DOWN, tmp );
     
    442441        if( tr_bencDictFindInt( args_in, "autostart", &i ) )
    443442            tr_ctorSetPaused( ctor, TR_FORCE, !i );
    444         if( tr_bencDictFindInt( args_in, "max-peers", &i ) )
    445             tr_ctorSetMaxConnectedPeers( ctor, TR_FORCE, i );
     443        if( tr_bencDictFindInt( args_in, "peer-limit", &i ) )
     444            tr_ctorSetPeerLimit( ctor, TR_FORCE, i );
    446445        if( tr_bencDictFindStr( args_in, "destination", &str ) )
    447446            tr_ctorSetDestination( ctor, TR_FORCE, str );
     
    465464
    466465static const char*
    467 sessionSet( tr_handle * handle UNUSED, tr_benc * args_in UNUSED, tr_benc * args_out UNUSED )
    468 {
    469     /* TODO */
    470     return NULL;
    471 }
    472 
    473 static const char*
    474 sessionGet( tr_handle * handle UNUSED, tr_benc * args_in UNUSED, tr_benc * args_out UNUSED )
    475 {
    476     /* TODO */
     466sessionSet( tr_handle * h, tr_benc * args_in, tr_benc * args_out UNUSED )
     467{
     468    int64_t i;
     469    const char * str;
     470
     471    if( tr_bencDictFindInt( args_in, "peer-limit", &i ) )
     472        tr_sessionSetPeerLimit( h, i );
     473    if( tr_bencDictFindInt( args_in, "port", &i ) )
     474        tr_sessionSetPublicPort( h, i );
     475    if( tr_bencDictFindInt( args_in, "port-forwarding-enabled", &i ) )
     476        tr_sessionSetPortForwardingEnabled( h, i );
     477    if( tr_bencDictFindInt( args_in, "pex-allowed", &i ) )
     478        tr_sessionSetPexEnabled( h, i );
     479    if( tr_bencDictFindInt( args_in, "speed-limit-down", &i ) )
     480        tr_sessionSetSpeedLimit( h, TR_DOWN, i );
     481    if( tr_bencDictFindInt( args_in, "speed-limit-down-enabled", &i ) )
     482        tr_sessionSetSpeedLimitEnabled( h, TR_DOWN, i );
     483    if( tr_bencDictFindInt( args_in, "speed-limit-up", &i ) )
     484        tr_sessionSetSpeedLimit( h, TR_UP, i );
     485    if( tr_bencDictFindInt( args_in, "speed-limit-up-enabled", &i ) )
     486        tr_sessionSetSpeedLimitEnabled( h, TR_UP, i );
     487    if( tr_bencDictFindStr( args_in, "encryption", &str ) ) {
     488        if( !strcmp( str, "required" ) )
     489            tr_sessionSetEncryption( h, TR_ENCRYPTION_REQUIRED );
     490        else if( !strcmp( str, "tolerated" ) )
     491            tr_sessionSetEncryption( h, TR_PLAINTEXT_PREFERRED );
     492        else
     493            tr_sessionSetEncryption( h, TR_ENCRYPTION_PREFERRED );
     494    }
     495
     496    return NULL;
     497}
     498
     499static const char*
     500sessionGet( tr_handle * h, tr_benc * args_in UNUSED, tr_benc * args_out )
     501{
     502    const char * str;
     503    tr_benc * d = tr_bencDictAddDict( args_out, "session", 9 );
     504
     505    tr_bencDictAddInt( d, "peer-limit",
     506                          tr_sessionGetPeerLimit( h ) );
     507    tr_bencDictAddInt( d, "port",
     508                          tr_sessionGetPublicPort( h ) );
     509    tr_bencDictAddInt( d, "port-forwarding-enabled",
     510                          tr_sessionIsPortForwardingEnabled( h ) );
     511    tr_bencDictAddInt( d, "pex-allowed",
     512                          tr_sessionIsPexEnabled( h ) );
     513    tr_bencDictAddInt( d, "speed-limit-up",
     514                          tr_sessionGetSpeedLimit( h, TR_UP ) );
     515    tr_bencDictAddInt( d, "speed-limit-up-enabled",
     516                          tr_sessionIsSpeedLimitEnabled( h, TR_UP ) );
     517    tr_bencDictAddInt( d, "speed-limit-down",
     518                          tr_sessionGetSpeedLimit( h, TR_DOWN ) );
     519    tr_bencDictAddInt( d, "speed-limit-down-enabled",
     520                          tr_sessionIsSpeedLimitEnabled( h, TR_DOWN ) );
     521    switch( tr_sessionGetEncryption( h ) ) {
     522        case TR_PLAINTEXT_PREFERRED: str = "tolerated"; break;
     523        case TR_ENCRYPTION_REQUIRED: str = "required"; break;
     524        default: str = "preferred"; break;
     525    }
     526    tr_bencDictAddStr( d, "encryption", str );
     527
     528
     529   
    477530    return NULL;
    478531}
  • trunk/libtransmission/peer-msgs.c

    r5745 r5819  
    872872    tr_bencInitDict( &val, 4 );
    873873    tr_bencDictAddInt( &val, "e", msgs->handle->encryptionMode != TR_PLAINTEXT_PREFERRED );
    874     tr_bencDictAddInt( &val, "p", tr_getPublicPort( msgs->handle ) );
     874    tr_bencDictAddInt( &val, "p", tr_sessionGetPublicPort( msgs->handle ) );
    875875    tr_bencDictAddStr( &val, "v", TR_NAME " " USERAGENT_PREFIX );
    876876    m  = tr_bencDictAddDict( &val, "m", 1 );
  • trunk/libtransmission/port-forwarding.c

    r5796 r5819  
    227227
    228228int
     229tr_sharedTraversalIsEnabled( const tr_shared * s )
     230{
     231    return s->isEnabled;
     232}
     233
     234int
    229235tr_sharedTraversalStatus( const tr_shared * s )
    230236{
  • trunk/libtransmission/port-forwarding.h

    r5585 r5819  
    11/******************************************************************************
    2  * $Id:$
     2 * $Id$
    33 *
    44 * Copyright (c) 2005-2008 Transmission authors and contributors
     
    3030typedef struct tr_shared tr_shared;
    3131
    32 tr_shared* tr_sharedInit            ( tr_handle *, int isEnabled, int publicPort );
    33 void       tr_sharedShuttingDown    ( tr_shared * );
    34 void       tr_sharedSetPort         ( tr_shared *, int publicPort );
    35 void       tr_sharedTraversalEnable ( tr_shared *, int isEnabled );
    36 int        tr_sharedGetPublicPort   ( const tr_shared * s );
     32tr_shared* tr_sharedInit              ( tr_handle *, int isEnabled,
     33                                                     int publicPort );
     34void       tr_sharedShuttingDown      ( tr_shared * );
     35void       tr_sharedSetPort           ( tr_shared *, int publicPort );
     36void       tr_sharedTraversalEnable   ( tr_shared *, int isEnabled );
     37int        tr_sharedGetPublicPort     ( const tr_shared * s );
     38int        tr_sharedTraversalIsEnabled( const tr_shared * s );
    3739int        tr_sharedTraversalStatus ( const tr_shared * );
    3840
  • trunk/libtransmission/resume.c

    r5667 r5819  
    471471
    472472    if( fields & TR_FR_MAX_PEERS )
    473         if( !tr_ctorGetMaxConnectedPeers( ctor, mode, &tor->maxConnectedPeers ) )
     473        if( !tr_ctorGetPeerLimit( ctor, mode, &tor->maxConnectedPeers ) )
    474474            ret |= TR_FR_MAX_PEERS;
    475475
  • trunk/libtransmission/session.c

    r5796 r5819  
    9494
    9595tr_encryption_mode
    96 tr_getEncryptionMode( tr_session * session )
     96tr_sessionGetEncryption( tr_session * session )
    9797{
    9898    assert( session != NULL );
     
    102102
    103103void
    104 tr_setEncryptionMode( tr_session * session, tr_encryption_mode mode )
     104tr_sessionSetEncryption( tr_session * session, tr_encryption_mode mode )
    105105{
    106106    assert( session != NULL );
     
    269269
    270270void
    271 tr_setBindPort( tr_handle * handle, int port )
     271tr_sessionSetPublicPort( tr_handle * handle, int port )
    272272{
    273273    struct bind_port_data * data = tr_new( struct bind_port_data, 1 );
     
    278278
    279279int
    280 tr_getPublicPort( const tr_handle * h )
     280tr_sessionGetPublicPort( const tr_handle * h )
    281281{
    282282    assert( h != NULL );
     
    284284}
    285285
    286 void tr_natTraversalEnable( tr_handle * h, int enable )
    287 {
    288     tr_globalLock( h );
    289     tr_sharedTraversalEnable( h->shared, enable );
    290     tr_globalUnlock( h );
    291 }
    292 
    293286const tr_handle_status *
    294287tr_handleStatus( tr_handle * h )
     
    314307
    315308void
    316 tr_setUseGlobalSpeedLimit( tr_handle  * h,
    317                            int          up_or_down,
    318                            int          use_flag )
     309tr_sessionSetSpeedLimitEnabled( tr_handle  * h,
     310                                int          up_or_down,
     311                                int          use_flag )
    319312{
    320313    if( up_or_down == TR_UP )
     
    324317}
    325318
    326 void
    327 tr_setGlobalSpeedLimit( tr_handle  * h,
    328                         int          up_or_down,
    329                         int          KiB_sec )
     319int
     320tr_sessionIsSpeedLimitEnabled( const tr_handle * h, int up_or_down )
     321{
     322       return up_or_down==TR_UP ? h->useUploadLimit : h->useDownloadLimit;
     323}
     324
     325void
     326tr_sessionSetSpeedLimit( tr_handle  * h,
     327                         int          up_or_down,
     328                         int          KiB_sec )
    330329{
    331330    if( up_or_down == TR_DOWN )
     
    335334}
    336335
    337 void
    338 tr_getGlobalSpeedLimit( tr_handle  * h,
    339                         int          up_or_down,
    340                         int        * setme_enabled,
    341                         int          * setme_KiBsec )
    342 {
    343     if( setme_enabled != NULL )
    344        *setme_enabled = up_or_down==TR_UP ? h->useUploadLimit
    345                                           : h->useDownloadLimit;
    346     if( setme_KiBsec != NULL )
    347        *setme_KiBsec = tr_rcGetLimit( up_or_down==TR_UP ? h->upload
    348                                                         : h->download );
    349 }
    350 
    351 
    352 void
    353 tr_setGlobalPeerLimit( tr_handle * handle UNUSED,
    354                        uint16_t    maxGlobalPeers )
     336int
     337tr_sessionGetSpeedLimit( const tr_handle * h, int up_or_down )
     338{
     339    return tr_rcGetLimit( up_or_down==TR_UP ? h->upload : h->download );
     340}
     341
     342/***
     343****
     344***/
     345
     346void
     347tr_sessionSetPeerLimit( tr_handle * handle UNUSED,
     348                        uint16_t    maxGlobalPeers )
    355349{
    356350    tr_fdSetPeerLimit( maxGlobalPeers );
     
    358352
    359353uint16_t
    360 tr_getGlobalPeerLimit( const tr_handle * handle UNUSED )
     354tr_sessionGetPeerLimit( const tr_handle * handle UNUSED )
    361355{
    362356    return tr_fdGetPeerLimit( );
    363357}
     358
     359/***
     360****
     361***/
    364362
    365363void
     
    503501
    504502void
    505 tr_setPexEnabled( tr_handle * handle, int isPexEnabled )
     503tr_sessionSetPexEnabled( tr_handle * handle, int isPexEnabled )
    506504{
    507505    handle->isPexEnabled = isPexEnabled ? 1 : 0;
     
    509507
    510508int
    511 tr_isPexEnabled( const tr_handle * handle )
     509tr_sessionIsPexEnabled( const tr_handle * handle )
    512510{
    513511    return handle->isPexEnabled;
     512}
     513
     514/***
     515****
     516***/
     517
     518void
     519tr_sessionSetPortForwardingEnabled( tr_handle * h, int enable )
     520{
     521    tr_globalLock( h );
     522    tr_sharedTraversalEnable( h->shared, enable );
     523    tr_globalUnlock( h );
     524}
     525
     526int
     527tr_sessionIsPortForwardingEnabled( const tr_handle * h )
     528{
     529    return tr_sharedTraversalIsEnabled( h->shared );
    514530}
    515531
  • trunk/libtransmission/torrent-ctor.c

    r5613 r5819  
    2828
    2929    unsigned int isPaused : 1;
    30     uint16_t maxConnectedPeers;
     30    uint16_t peerLimit;
    3131    char destination[MAX_PATH_LENGTH];
    3232};
     
    192192
    193193void
    194 tr_ctorSetMaxConnectedPeers( tr_ctor        * ctor,
    195                              tr_ctorMode      mode,
    196                              uint16_t         maxConnectedPeers )
     194tr_ctorSetPeerLimit( tr_ctor        * ctor,
     195                     tr_ctorMode      mode,
     196                     uint16_t         peerLimit )
    197197{
    198198    struct optional_args * args = &ctor->optionalArgs[mode];
    199199    args->isSet_connected = 1;
    200     args->maxConnectedPeers = maxConnectedPeers;
     200    args->peerLimit = peerLimit;
    201201}
    202202
     
    212212
    213213int
    214 tr_ctorGetMaxConnectedPeers( const tr_ctor  * ctor,
    215                              tr_ctorMode      mode,
    216                              uint16_t       * setmeCount )
     214tr_ctorGetPeerLimit( const tr_ctor  * ctor,
     215                     tr_ctorMode      mode,
     216                     uint16_t       * setmeCount )
    217217{
    218218    int err = 0;
     
    222222        err = 1;
    223223    else if( setmeCount )
    224         *setmeCount = args->maxConnectedPeers;
     224        *setmeCount = args->peerLimit;
    225225
    226226    return err;
     
    282282    tr_ctor * ctor = tr_new0( struct tr_ctor, 1 );
    283283    ctor->handle = handle;
    284     tr_ctorSetMaxConnectedPeers( ctor, TR_FALLBACK, DEFAULT_MAX_CONNECTED_PEERS );
     284    tr_ctorSetPeerLimit( ctor, TR_FALLBACK, DEFAULT_MAX_CONNECTED_PEERS );
    285285    tr_ctorSetPaused( ctor, TR_FALLBACK, FALSE );
    286286    tr_ctorSetSave( ctor, TRUE );
  • trunk/libtransmission/torrent.c

    r5813 r5819  
    460460
    461461    if( !h->isPortSet )
    462         tr_setBindPort( h, TR_DEFAULT_PORT );
     462        tr_sessionSetPublicPort( h, TR_DEFAULT_PORT );
    463463
    464464    assert( !tor->downloadedCur );
     
    475475
    476476    if( !(loaded & TR_FR_SPEEDLIMIT ) ) {
    477         int limit, enabled;
    478         tr_getGlobalSpeedLimit( tor->handle, TR_UP, &enabled, &limit );
    479         tr_torrentSetSpeedLimit( tor, TR_UP, limit );
    480         tr_getGlobalSpeedLimit( tor->handle, TR_DOWN, &enabled, &limit );
    481         tr_torrentSetSpeedLimit( tor, TR_DOWN, limit );
     477        tr_torrentSetSpeedLimit( tor, TR_UP,
     478                tr_sessionGetSpeedLimit( tor->handle, TR_UP ) );
     479        tr_torrentSetSpeedLimit( tor, TR_DOWN,
     480                tr_sessionGetSpeedLimit( tor->handle, TR_DOWN ) );
    482481    }
    483482
     
    13841383
    13851384void
    1386 tr_torrentSetMaxConnectedPeers( tr_torrent  * tor,
    1387                                 uint16_t      maxConnectedPeers )
     1385tr_torrentSetPeerLimit( tr_torrent  * tor,
     1386                        uint16_t      maxConnectedPeers )
    13881387{
    13891388    tor->maxConnectedPeers = maxConnectedPeers;
     
    13911390
    13921391uint16_t
    1393 tr_torrentGetMaxConnectedPeers( const tr_torrent  * tor )
     1392tr_torrentGetPeerLimit( const tr_torrent  * tor )
    13941393{
    13951394    return tor->maxConnectedPeers;
  • trunk/libtransmission/transmission.h

    r5817 r5819  
    150150tr_encryption_mode;
    151151
    152 tr_encryption_mode tr_getEncryptionMode( tr_handle * handle );
    153 
    154 void tr_setEncryptionMode( tr_handle * handle, tr_encryption_mode mode );
     152tr_encryption_mode tr_sessionGetEncryption( tr_handle * handle );
     153
     154void tr_sessionSetEncryption( tr_handle * handle, tr_encryption_mode mode );
    155155
    156156/***********************************************************************
     
    214214*/
    215215
    216 void tr_setBindPort( tr_handle *, int );
    217 
    218 void tr_natTraversalEnable( tr_handle *, int enable );
    219 
    220 int tr_getPublicPort( const tr_handle * );
     216void tr_sessionSetPortForwardingEnabled( tr_handle *, int enable );
     217
     218int tr_sessionIsPortForwardingEnabled( const tr_handle * );
     219
     220void tr_sessionSetPublicPort( tr_handle *, int );
     221
     222int tr_sessionGetPublicPort( const tr_handle * );
    221223
    222224typedef enum
     
    278280void tr_torrentSetSpeedLimit( tr_torrent   * tor,
    279281                              int            up_or_down,
    280                               int            single_KiB_sec );
     282                              int            KiB_sec );
    281283
    282284int tr_torrentGetSpeedLimit( const tr_torrent  * tor,
    283285                             int                 up_or_down );
    284286
    285 void tr_setUseGlobalSpeedLimit( tr_handle * handle,
    286                                 int           up_or_down,
    287                                 int           use_flag );
    288 
    289 void tr_setGlobalSpeedLimit( tr_handle * handle,
    290                              int           up_or_down,
    291                              int           global_KiB_sec );
    292 
    293 void tr_getGlobalSpeedLimit( tr_handle * handle,
    294                              int           up_or_down,
    295                              int         * setme_is_enabled,
    296                              int         * setme_KiBsec );
     287void tr_sessionSetSpeedLimitEnabled( tr_handle   * session,
     288                                     int           up_or_down,
     289                                     int           isEnabled );
     290
     291int tr_sessionIsSpeedLimitEnabled( const tr_handle   * session,
     292                                   int                 up_or_down );
     293
     294void tr_sessionSetSpeedLimit( tr_handle   * session,
     295                              int           up_or_down,
     296                              int           KiB_sec );
     297
     298int tr_sessionGetSpeedLimit( const tr_handle   * session,
     299                             int                 up_or_down );
    297300
    298301
     
    301304**/
    302305
    303 void tr_torrentSetMaxConnectedPeers( tr_torrent  * tor,
    304                                      uint16_t      maxConnectedPeers);
    305 
    306 uint16_t tr_torrentGetMaxConnectedPeers( const tr_torrent  * tor );
    307 
    308 void tr_setGlobalPeerLimit( tr_handle * handle,
    309                             uint16_t    maxGlobalPeers );
    310 
    311 uint16_t tr_getGlobalPeerLimit( const tr_handle * handle );
     306void tr_torrentSetPeerLimit( tr_torrent  * tor,
     307                             uint16_t      peerLimit );
     308
     309uint16_t tr_torrentGetPeerLimit( const tr_torrent  * tor );
     310
     311void tr_sessionSetPeerLimit( tr_handle * handle,
     312                             uint16_t    maxGlobalPeers );
     313
     314uint16_t tr_sessionGetPeerLimit( const tr_handle * handle );
    312315
    313316
     
    453456                                         const char     * hashString );
    454457
    455 void     tr_ctorSetMaxConnectedPeers   ( tr_ctor        * ctor,
     458void     tr_ctorSetPeerLimit           ( tr_ctor        * ctor,
    456459                                         tr_ctorMode      mode,
    457                                          uint16_t         maxConnectedPeers );
     460                                         uint16_t         peerLimit );
    458461
    459462void     tr_ctorSetDestination         ( tr_ctor        * ctor,
     
    465468                                         uint8_t          isPaused );
    466469
    467 int      tr_ctorGetMaxConnectedPeers   ( const tr_ctor  * ctor,
     470int      tr_ctorGetPeerLimit           ( const tr_ctor  * ctor,
    468471                                         tr_ctorMode      mode,
    469472                                         uint16_t       * setmeCount );
     
    533536 * In public torrents, PEX is enabled by default.
    534537 */
    535 void tr_setPexEnabled( tr_handle *, int isEnabled );
    536 
    537 int tr_isPexEnabled( const tr_handle * );
     538void tr_sessionSetPexEnabled( tr_handle *, int isEnabled );
     539
     540int tr_sessionIsPexEnabled( const tr_handle * );
    538541
    539542const tr_info * tr_torrentInfo( const tr_torrent * );
Note: See TracChangeset for help on using the changeset viewer.