Changeset 7812


Ignore:
Timestamp:
Jan 29, 2009, 4:56:43 PM (12 years ago)
Author:
charles
Message:

(trunk libT) yet even *more* assertions for Biiaru and persept :)

Location:
trunk/libtransmission
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/session.c

    r7810 r7812  
    380380    session->lock = tr_lockNew( );
    381381    session->tag = tr_strdup( tag );
     382    session->magicNumber = SESSION_MAGIC_NUMBER;
     383
    382384    dbgmsg( "tr_sessionInit: the session's top-level bandwidth object is %p", session->bandwidth );
    383385
     
    541543{
    542544    tr_session * session = vsession;
     545
     546    assert( tr_isSession( session ) );
    543547 
    544548    /* first %s is the application name
     
    559563tr_sessionSetDownloadDir( tr_session * session, const char * dir )
    560564{
     565    assert( tr_isSession( session ) );
     566
    561567    if( session->downloadDir != dir )
    562568    {
     
    569575tr_sessionGetDownloadDir( const tr_session * session )
    570576{
     577    assert( tr_isSession( session ) );
     578
    571579    return session->downloadDir;
    572580}
     
    579587tr_globalLock( tr_session * session )
    580588{
     589    assert( tr_isSession( session ) );
     590
    581591    tr_lockLock( session->lock );
    582592}
     
    585595tr_globalUnlock( tr_session * session )
    586596{
     597    assert( tr_isSession( session ) );
     598
    587599    tr_lockUnlock( session->lock );
    588600}
     
    591603tr_globalIsLocked( const tr_session * session )
    592604{
    593     return session && tr_lockHave( session->lock );
     605    return tr_isSession( session ) && tr_lockHave( session->lock );
    594606}
    595607
     
    622634setPortImpl( tr_session * session, tr_port port )
    623635{
    624     struct bind_port_data * data = tr_new( struct bind_port_data, 1 );
     636    struct bind_port_data * data;
     637
     638    assert( tr_isSession( session ) );
     639
     640    data = tr_new( struct bind_port_data, 1 );
    625641    data->session = session;
    626642    data->port = port;
     
    632648                       tr_port      port )
    633649{
     650    assert( tr_isSession( session ) );
     651
    634652    session->isPortRandom = FALSE;
    635653    session->peerPort = port;
     
    640658tr_sessionSetPeerPortRandom( tr_session * session )
    641659{
     660    assert( tr_isSession( session ) );
     661
    642662    session->isPortRandom = TRUE;
    643663    session->peerPort = getRandomPort( session );
     
    649669tr_sessionGetPeerPort( const tr_session * session )
    650670{
    651     assert( session );
     671    assert( tr_isSession( session ) );
    652672
    653673    return session->peerPort;
     
    657677tr_sessionGetPortForwarding( const tr_session * session )
    658678{
     679    assert( tr_isSession( session ) );
     680
    659681    return tr_sharedTraversalStatus( session->shared );
    660682}
     
    667689updateBandwidth( tr_session * session, tr_direction dir )
    668690{
    669     const tr_bool zeroCase = session->speedLimit[dir] < 1 && session->isSpeedLimited[dir];
     691    tr_bool zeroCase;
     692
     693    assert( tr_isSession( session ) );
     694
     695    zeroCase = session->speedLimit[dir] < 1 && session->isSpeedLimited[dir];
    670696
    671697    tr_bandwidthSetLimited( session->bandwidth, dir, session->isSpeedLimited[dir] && !zeroCase );
     
    679705                                tr_bool           isLimited )
    680706{
    681     assert( session );
     707    assert( tr_isSession( session ) );
    682708    assert( tr_isDirection( dir ) );
    683709
     
    691717                         int             desiredSpeed )
    692718{
    693     assert( session );
     719    assert( tr_isSession( session ) );
    694720    assert( tr_isDirection( dir ) );
    695721
     
    702728                               tr_direction        dir )
    703729{
    704     assert( session );
     730    assert( tr_isSession( session ) );
    705731    assert( tr_isDirection( dir ) );
    706732
     
    712738                         tr_direction        dir )
    713739{
    714     assert( session );
     740    assert( tr_isSession( session ) );
    715741    assert( tr_isDirection( dir ) );
    716742
     
    723749
    724750void
    725 tr_sessionSetPeerLimit( tr_session * session UNUSED,
     751tr_sessionSetPeerLimit( tr_session * session,
    726752                        uint16_t     maxGlobalPeers )
    727753{
     754    assert( tr_isSession( session ) );
     755
    728756    tr_fdSetPeerLimit( maxGlobalPeers );
    729757}
    730758
    731759uint16_t
    732 tr_sessionGetPeerLimit( const tr_session * session UNUSED )
    733 {
     760tr_sessionGetPeerLimit( const tr_session * session )
     761{
     762    assert( tr_isSession( session ) );
     763
    734764    return tr_fdGetPeerLimit( );
    735765}
     
    738768tr_sessionSetPeerLimitPerTorrent( tr_session  * session, uint16_t n )
    739769{
     770    assert( tr_isSession( session ) );
     771
    740772    session->peerLimitPerTorrent = n;
    741773}
     
    744776tr_sessionGetPeerLimitPerTorrent( const tr_session * session )
    745777{
     778    assert( tr_isSession( session ) );
     779
    746780    return session->peerLimitPerTorrent;
    747781}
     
    754788tr_sessionGetPieceSpeed( const tr_session * session, tr_direction dir )
    755789{
    756     return session ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
     790    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
    757791}
    758792
     
    760794tr_sessionGetRawSpeed( const tr_session * session, tr_direction dir )
    761795{
    762     return session ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
     796    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
    763797}
    764798
     
    766800tr_sessionCountTorrents( const tr_session * session )
    767801{
    768     return session->torrentCount;
     802    return tr_isSession( session ) ? session->torrentCount : 0;
    769803}
    770804
     
    790824    int           i, n;
    791825    tr_torrent ** torrents;
     826
     827    assert( tr_isSession( session ) );
    792828
    793829    tr_statsClose( session );
     
    832868    const int      maxwait_msec = SHUTDOWN_MAX_SECONDS * 1000;
    833869    const uint64_t deadline = tr_date( ) + maxwait_msec;
     870
     871    assert( tr_isSession( session ) );
    834872
    835873    dbgmsg( "shutting down transmission session %p", session );
     
    894932    tr_torrent ** torrents;
    895933    tr_list *     l = NULL, *list = NULL;
     934
     935    assert( tr_isSession( session ) );
    896936
    897937    tr_ctorSetSave( ctor, FALSE ); /* since we already have them */
     
    944984                         tr_bool      enabled )
    945985{
     986    assert( tr_isSession( session ) );
     987
    946988    session->isPexEnabled = enabled != 0;
    947989}
     
    950992tr_sessionIsPexEnabled( const tr_session * session )
    951993{
     994    assert( tr_isSession( session ) );
     995
    952996    return session->isPexEnabled;
    953997}
     
    9611005                                  tr_bool      enabled )
    9621006{
     1007    assert( tr_isSession( session ) );
     1008
    9631009    session->useLazyBitfield = enabled != 0;
    9641010}
     
    9671013tr_sessionIsLazyBitfieldEnabled( const tr_session * session )
    9681014{
     1015    assert( tr_isSession( session ) );
     1016
    9691017    return session->useLazyBitfield;
    9701018}
     
    9781026                                    tr_bool       enabled )
    9791027{
     1028    assert( tr_isSession( session ) );
     1029
    9801030    tr_globalLock( session );
    9811031    tr_sharedTraversalEnable( session->shared, enabled );
     
    9861036tr_sessionIsPortForwardingEnabled( const tr_session * session )
    9871037{
     1038    assert( tr_isSession( session ) );
     1039
    9881040    return tr_sharedTraversalIsEnabled( session->shared );
    9891041}
     
    9991051    tr_list * l;
    10001052
     1053    assert( tr_isSession( session ) );
     1054
    10011055    for( l = session->blocklists; l; l = l->next )
    10021056        n += _tr_blocklistGetRuleCount( l->data );
     
    10071061tr_blocklistIsEnabled( const tr_session * session )
    10081062{
     1063    assert( tr_isSession( session ) );
     1064
    10091065    return session->isBlocklistEnabled;
    10101066}
     
    10161072    tr_list * l;
    10171073
     1074    assert( tr_isSession( session ) );
     1075
    10181076    session->isBlocklistEnabled = isEnabled != 0;
    10191077
     
    10251083tr_blocklistExists( const tr_session * session )
    10261084{
     1085    assert( tr_isSession( session ) );
     1086
    10271087    return session->blocklists != NULL;
    10281088}
     
    10351095    tr_blocklist * b;
    10361096    const char *   defaultName = "level1.bin";
     1097
     1098    assert( tr_isSession( session ) );
    10371099
    10381100    for( b = NULL, l = session->blocklists; !b && l; l = l->next )
     
    10581120    tr_list * l;
    10591121
     1122    assert( tr_isSession( session ) );
     1123
    10601124    for( l = session->blocklists; l; l = l->next )
    10611125        if( _tr_blocklistHasAddress( l->data, addr ) )
     
    10691133
    10701134static int
    1071 compareLookupEntries( const void * va,
    1072                       const void * vb )
     1135compareLookupEntries( const void * va, const void * vb )
    10731136{
    10741137    const struct tr_metainfo_lookup * a = va;
     
    10811144metainfoLookupResort( tr_session * session )
    10821145{
     1146    assert( tr_isSession( session ) );
     1147
    10831148    qsort( session->metainfoLookup,
    10841149           session->metainfoLookupCount,
     
    10881153
    10891154static int
    1090 compareHashStringToLookupEntry( const void * va,
    1091                                 const void * vb )
     1155compareHashStringToLookupEntry( const void * va, const void * vb )
    10921156{
    10931157    const char *                      a = va;
     
    11201184    tr_ctor *    ctor = NULL;
    11211185    tr_list *    list = NULL;
     1186
     1187    assert( tr_isSession( session ) );
    11221188
    11231189    /* walk through the directory and find the mappings */
     
    12031269                tr_torrent * tor )
    12041270{
     1271    assert( tr_isSession( session ) );
     1272
    12051273    return tor ? tor->next : session->torrentList;
    12061274}
     
    12141282                         tr_bool      isEnabled )
    12151283{
     1284    assert( tr_isSession( session ) );
     1285
    12161286    tr_rpcSetEnabled( session->rpcServer, isEnabled );
    12171287}
     
    12201290tr_sessionIsRPCEnabled( const tr_session * session )
    12211291{
     1292    assert( tr_isSession( session ) );
     1293
    12221294    return tr_rpcIsEnabled( session->rpcServer );
    12231295}
     
    12271299                      tr_port      port )
    12281300{
     1301    assert( tr_isSession( session ) );
     1302
    12291303    tr_rpcSetPort( session->rpcServer, port );
    12301304}
     
    12331307tr_sessionGetRPCPort( const tr_session * session )
    12341308{
     1309    assert( tr_isSession( session ) );
     1310
    12351311    return tr_rpcGetPort( session->rpcServer );
    12361312}
     
    12411317                          void *       user_data )
    12421318{
     1319    assert( tr_isSession( session ) );
     1320
    12431321    session->rpc_func = func;
    12441322    session->rpc_func_user_data = user_data;
     
    12491327                           const char * whitelist )
    12501328{
     1329    assert( tr_isSession( session ) );
     1330
    12511331    tr_rpcSetWhitelist( session->rpcServer, whitelist );
    12521332}
     
    12551335tr_sessionGetRPCWhitelist( const tr_session * session )
    12561336{
     1337    assert( tr_isSession( session ) );
     1338
    12571339    return tr_rpcGetWhitelist( session->rpcServer );
    12581340}
     
    12621344                                  tr_bool      isEnabled )
    12631345{
     1346    assert( tr_isSession( session ) );
     1347
    12641348    tr_rpcSetWhitelistEnabled( session->rpcServer, isEnabled );
    12651349}
     
    12681352tr_sessionGetRPCWhitelistEnabled( const tr_session * session )
    12691353{
     1354    assert( tr_isSession( session ) );
     1355
    12701356    return tr_rpcGetWhitelistEnabled( session->rpcServer );
    12711357}
     
    12761362                          const char * password )
    12771363{
     1364    assert( tr_isSession( session ) );
     1365
    12781366    tr_rpcSetPassword( session->rpcServer, password );
    12791367}
     
    12821370tr_sessionGetRPCPassword( const tr_session * session )
    12831371{
     1372    assert( tr_isSession( session ) );
     1373
    12841374    return tr_rpcGetPassword( session->rpcServer );
    12851375}
     
    12891379                          const char * username )
    12901380{
     1381    assert( tr_isSession( session ) );
     1382
    12911383    tr_rpcSetUsername( session->rpcServer, username );
    12921384}
     
    12951387tr_sessionGetRPCUsername( const tr_session * session )
    12961388{
     1389    assert( tr_isSession( session ) );
     1390
    12971391    return tr_rpcGetUsername( session->rpcServer );
    12981392}
     
    13021396                                 tr_bool      isEnabled )
    13031397{
     1398    assert( tr_isSession( session ) );
     1399
    13041400    tr_rpcSetPasswordEnabled( session->rpcServer, isEnabled );
    13051401}
     
    13081404tr_sessionIsRPCPasswordEnabled( const tr_session * session )
    13091405{
     1406    assert( tr_isSession( session ) );
     1407
    13101408    return tr_rpcIsPasswordEnabled( session->rpcServer );
    13111409}
     
    13181416tr_sessionIsProxyEnabled( const tr_session * session )
    13191417{
     1418    assert( tr_isSession( session ) );
     1419
    13201420    return session->isProxyEnabled;
    13211421}
     
    13251425                           tr_bool      isEnabled )
    13261426{
     1427    assert( tr_isSession( session ) );
     1428
    13271429    session->isProxyEnabled = isEnabled != 0;
    13281430}
     
    13311433tr_sessionGetProxyType( const tr_session * session )
    13321434{
     1435    assert( tr_isSession( session ) );
     1436
    13331437    return session->proxyType;
    13341438}
     
    13381442                        tr_proxy_type type )
    13391443{
     1444    assert( tr_isSession( session ) );
     1445
    13401446    session->proxyType = type;
    13411447}
     
    13441450tr_sessionGetProxy( const tr_session * session )
    13451451{
     1452    assert( tr_isSession( session ) );
     1453
    13461454    return session->proxy;
    13471455}
     
    13501458tr_sessionGetProxyPort( const tr_session * session )
    13511459{
     1460    assert( tr_isSession( session ) );
     1461
    13521462    return session->proxyPort;
    13531463}
     
    13571467                    const char * proxy )
    13581468{
     1469    assert( tr_isSession( session ) );
     1470
    13591471    if( proxy != session->proxy )
    13601472    {
     
    13681480                        tr_port      port )
    13691481{
     1482    assert( tr_isSession( session ) );
     1483
    13701484    session->proxyPort = port;
    13711485}
     
    13741488tr_sessionIsProxyAuthEnabled( const tr_session * session )
    13751489{
     1490    assert( tr_isSession( session ) );
     1491
    13761492    return session->isProxyAuthEnabled;
    13771493}
     
    13811497                               tr_bool      isEnabled )
    13821498{
     1499    assert( tr_isSession( session ) );
     1500
    13831501    session->isProxyAuthEnabled = isEnabled != 0;
    13841502}
     
    13871505tr_sessionGetProxyUsername( const tr_session * session )
    13881506{
     1507    assert( tr_isSession( session ) );
     1508
    13891509    return session->proxyUsername;
    13901510}
     
    13941514                            const char * username )
    13951515{
     1516    assert( tr_isSession( session ) );
     1517
    13961518    if( username != session->proxyUsername )
    13971519    {
     
    14041526tr_sessionGetProxyPassword( const tr_session * session )
    14051527{
     1528    assert( tr_isSession( session ) );
     1529
    14061530    return session->proxyPassword;
    14071531}
     
    14111535                            const char * password )
    14121536{
     1537    assert( tr_isSession( session ) );
     1538
    14131539    if( password != session->proxyPassword )
    14141540    {
     
    14231549    int ret = 0;
    14241550    tr_torrent * tor = NULL;
     1551
     1552    assert( tr_isSession( session ) );
    14251553
    14261554    while(( tor = tr_torrentNext( session, tor )))
  • trunk/libtransmission/session.h

    r7810 r7812  
    7070    tr_bool                      isSpeedLimited[2];
    7171    int                          speedLimit[2];
     72    int                          magicNumber;
    7273
    7374    tr_encryption_mode           encryptionMode;
     
    148149tr_bool      tr_globalIsLocked( const tr_session * );
    149150
     151enum
     152{
     153    SESSION_MAGIC_NUMBER = 3845
     154};
     155
     156static inline tr_bool tr_isSession( const tr_session * session )
     157{
     158    return ( session != NULL ) && ( session->magicNumber == SESSION_MAGIC_NUMBER );
     159}
     160
    150161#endif
  • trunk/libtransmission/torrent.c

    r7775 r7812  
    10651065checkAndStartCB( tr_torrent * tor )
    10661066{
     1067    assert( tor );
     1068    assert( tr_isSession( tor->session ) );
     1069
    10671070    tr_runInEventThread( tor->session, checkAndStartImpl, tor );
    10681071}
  • trunk/libtransmission/trevent.c

    r7811 r7812  
    280280tr_eventClose( tr_session * session )
    281281{
     282    assert( tr_isSession( session ) );
     283
    282284    session->events->die = TRUE;
    283285    tr_deepLog( __FILE__, __LINE__, NULL, "closing trevent pipe" );
     
    292294tr_amInEventThread( tr_session * session )
    293295{
    294     assert( session );
     296    assert( tr_isSession( session ) );
    295297    assert( session->events );
    296298
     
    347349    tr_timer * timer;
    348350
    349     assert( session != NULL );
     351    assert( tr_isSession( session ) );
    350352    assert( session->events != NULL );
    351353
     
    380382                     void func( void* ), void * user_data )
    381383{
    382     assert( session != NULL );
     384    assert( tr_isSession( session ) );
    383385    assert( session->events != NULL );
    384386
     
    406408tr_eventGetBase( tr_session * session )
    407409{
     410    assert( tr_isSession( session ) );
     411
    408412    return session->events->base;
    409413}
Note: See TracChangeset for help on using the changeset viewer.