Changeset 632 for trunk


Ignore:
Timestamp:
11/14/08 20:12:23 (11 years ago)
Author:
Eoin
Message:

Pausing, resuming and stopping torrents correctly working with libtorrent 0.14

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/sln/HaliteWix/HaliteWix.wixproj

    r556 r632  
    1 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> 
     1<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> 
    22  <PropertyGroup> 
    33    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> 
     
    1414    <IntermediateOutputPath>obj\$(Configuration)\</IntermediateOutputPath> 
    1515    <DefineConstants>Debug;MyCPU=x86;platform=Win32</DefineConstants> 
     16    <WixVariables>WixUILicenseRtf=Boost.rtf</WixVariables> 
    1617  </PropertyGroup> 
    1718  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' "> 
  • trunk/sln/HaliteWix/Product.wxs

    r558 r632  
    77<?define VerBuild = "0550" ?> 
    88 
    9 <?define GMmbVer = "$(var.VerGeneration).$(var.VerMajor).$(var.VerMinor).$(var.VerUpdate)" ?> 
    10 <?define GMmbHex = "$(var.VerGeneration)$(var.VerMajor)$(var.VerMinor)$(var.VerUpdate)" ?> 
     9<?define FullGMmbVersion = "$(var.VerGeneration).$(var.VerMajor).$(var.VerMinor).$(var.VerUpdate) Build $(var.VerBuild)" ?> 
     10<?define ShortGMmbVersion = "$(var.VerMajor).$(var.VerMinor).$(var.VerUpdate)" ?> 
    1111<?define UpgradeMinVer = "0.3.1" ?> 
    12  
    13 <?define ProductName = "Halite" ?> 
    1412 
    1513<?if $(var.MyCPU) = "x64" ?> 
    1614<?define CpuId = "2" ?> 
    17 <?define PFilesFolder = "ProgramFiles64Folder" ?> 
     15<?define ProgFilesFolder = "ProgramFiles64Folder" ?> 
    1816<?define Platforms = "x64" ?> 
    1917<?define CpuPostfix = " (x64 edition)" ?> 
     
    2220<?else ?> 
    2321<?define CpuId = "1" ?> 
    24 <?define PFilesFolder = "ProgramFilesFolder" ?> 
    25 <?define Platforms = "Intel" ?> 
     22<?define ProgFilesFolder = "ProgramFilesFolder" ?> 
     23<?define Platforms = "x86" ?> 
    2624<?define CpuPostfix = "" ?> 
    2725<?define Is64 = "no" ?> 
     
    2927<?endif ?> 
    3028 
    31 <?define BaseId = "E3A8BF7D-962F-476$(var.CpuId)" ?> 
    32 <?define BaseIdVer = "$(var.BaseId)-$(var.GMmbHex)-$(var.VerBuild)" ?> 
    33 <?define ProductId   = "$(var.BaseIdVer)01000000" ?> 
    34 <?define PackageId   = "$(var.BaseIdVer)02000000" ?> 
    35 <?define CompId      = "$(var.BaseIdVer)03000000" ?> 
    36 <?define UpgradeCode = "$(var.BaseId)-0000-000004000000" ?> 
     29<?define ProductName = "Halite" ?> 
     30<?define ProductFullName = "$(var.ProductName) $(var.FullGMmbVersion)$(var.CpuPostfix)" ?> 
    3731 
    3832<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi"> 
    3933  <Product 
    40       Id="$(var.ProductId)" 
    41       UpgradeCode="$(var.UpgradeCode)" 
    42       Name="$(var.ProductName) $(var.GMmbVer)$(var.CpuPostfix)" 
     34      Id="9A922120-7458-4C6D-9DA9-512923EAD311" 
     35      UpgradeCode="45A10CBE-B399-48E5-865E-DBCE99A411E5" 
     36      Name="$(var.ProductName)" 
    4337      Language="1033" 
    44       Version="$(var.GMmbVer)" 
     38      Version="$(var.ShortGMmbVersion)" 
    4539      Manufacturer="BinaryNotions.com"> 
    4640 
    4741      <Package 
    48           Description="$(var.ProductName)$(var.CpuPostfix) Package" 
    49           Comments="$(var.ProductName)$(var.CpuPostfix) Package" 
     42          Description="$(var.ProductFullName) Package" 
     43          Comments="$(var.ProductFullName) Package" 
    5044          InstallerVersion="200" 
    5145          Compressed="yes" 
    52           Platforms="$(var.Platforms)" 
     46          ShortNames="no" 
     47          Platform="$(var.Platforms)" 
    5348        /> 
    5449 
     
    7873      </Directory> 
    7974 
    80       <Directory Id="$(var.PFilesFolder)" Name="Files"> 
     75      <Directory Id="$(var.ProgFilesFolder)" Name="Files"> 
    8176        <Directory Id="INSTALLDIR" Name="Halite"> 
    8277 
  • trunk/src/HaliteWindow.cpp

    r620 r632  
    401401        hal::bittorrent().close_all(0); 
    402402 
    403         hal::bittorrent().stopEventReceiver(); 
     403        hal::bittorrent().stop_event_receiver(); 
    404404        Sleep(3000); 
    405405 
    406         hal::bittorrent().shutDownSession(); 
     406        hal::bittorrent().shutdown_session(); 
    407407 
    408408        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::ShutdownThread()") 
     
    540540LRESULT HaliteWindow::OnPauseAll(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    541541{ 
    542         hal::bittorrent().pauseAllTorrents(); 
     542        hal::bittorrent().pause_all_torrents(); 
    543543         
    544544        issueUiUpdate(); 
     
    548548LRESULT HaliteWindow::OnResumeAll(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    549549{ 
    550         hal::bittorrent().unpauseAllTorrents(); 
     550        hal::bittorrent().unpause_all_torrents(); 
    551551         
    552552        issueUiUpdate(); 
  • trunk/src/SplashDialog.hpp

    r569 r632  
    1818 
    1919#ifndef RC_INVOKED 
     20 
     21#include <boost/utility/in_place_factory.hpp> 
     22#include <boost/none.hpp> 
    2023 
    2124#ifndef HALITE_MINI 
     
    8588                CenterWindow(); 
    8689 
    87                 DoDataExchange(false); 
     90                DoDataExchange(false);           
    8891                 
    89                 thread_ptr.reset(new thread(bind(&SplashDialog::SplashThread, this))); 
     92                thread_splash = boost::in_place<boost::function<void (void)> >(bind(&SplashDialog::SplashThread, this)); 
    9093                 
    9194                return 0; 
     
    9396 
    9497        void OnForceClose(UINT, int, HWND hWnd) 
     98        {                
     99                thread_splash->interrupt(); 
     100                thread_splash = boost::none; 
     101                Sleep(2000); 
     102                 
     103                RequiredToEnd(); 
     104        } 
     105 
     106        void RequiredToEnd() 
    95107        { 
    96                 thread_ptr.reset(); 
    97                 Sleep(200); 
     108                SetDlgItemText(HAL_CSPLASH_NUM_ACT, hal::app().res_wstr(HAL_CSPLASH_SHUTDOWN_MSG).c_str()); 
     109 
     110                HAL_DEV_MSG(L"SplashThread() calling hal::bittorrent().stop_event_receiver()"); 
     111                hal::bittorrent().stop_event_receiver(); 
     112                HAL_DEV_MSG(L"SplashThread() calling hal::bittorrent().shutdown_session()"); 
     113                hal::bittorrent().shutdown_session(); 
     114 
     115                DoDataExchange(true); 
    98116 
    99117                GetWindowRect(rect_); 
    100118                save_to_ini(); 
    101                 EndDialog(0); 
    102119        } 
    103120 
     
    116133                HAL_DEV_MSG(L"SplashThread() calling hal::bittorrent().close_all()"); 
    117134 
    118                 hal::bittorrent().close_all(boost::optional<boost::function<void (int)> >(bind(&SplashDialog::ReportNumActive, this, _1))); 
     135                hal::bittorrent().close_all(boost::optional<boost::function<void (int)> > 
     136                        (bind(&SplashDialog::ReportNumActive, this, _1))); 
    119137                 
    120                 SetDlgItemText(HAL_CSPLASH_NUM_ACT, hal::app().res_wstr(HAL_CSPLASH_SHUTDOWN_MSG).c_str()); 
    121  
    122                 HAL_DEV_MSG(L"SplashThread() calling hal::bittorrent().stopEventReceiver()"); 
    123                 hal::bittorrent().stopEventReceiver(); 
    124                 HAL_DEV_MSG(L"SplashThread() calling hal::bittorrent().shutDownSession()"); 
    125                 hal::bittorrent().shutDownSession(); 
    126                  
    127                 DoDataExchange(true); 
    128  
    129                 GetWindowRect(rect_); 
    130                 save_to_ini(); 
     138                RequiredToEnd();                 
    131139 
    132140                } HAL_GENERIC_FN_EXCEPTION_CATCH(L"SplashThread()") 
     
    141149         
    142150private: 
    143         boost::scoped_ptr<thread> thread_ptr; 
     151        boost::optional<hal::thread_t> thread_splash; 
    144152 
    145153        WTL::CRect rect_; 
  • trunk/src/halSession.hpp

    r625 r632  
    966966                                (*i).torrent->prepare(file);     
    967967 
    968                                 switch ((*i).torrent->state()) 
     968                                switch ((*i).torrent->get_state()) 
    969969                                { 
    970970                                        case torrent_details::torrent_stopped: 
     
    10381038 
    10391039                        if (fn) (*fn)(num_active); 
    1040                         Sleep(200); 
     1040                        boost::this_thread::sleep(pt::milliseconds(500)); 
    10411041                } 
    10421042                 
  • trunk/src/halTorrent.cpp

    r624 r632  
    8989{} 
    9090 
    91 void bit::shutDownSession() 
    92 { 
    93         HAL_DEV_MSG(L"Commence shutDownSession()");  
     91void bit::shutdown_session() 
     92{ 
     93        HAL_DEV_MSG(L"Commence shutdown_session()");  
    9494 
    9595        pimpl.reset(); 
    9696 
    97         HAL_DEV_MSG(L"End shutDownSession()");  
     97        HAL_DEV_MSG(L"End shutdown_session()");  
    9898} 
    9999 
     
    531531} 
    532532 
    533 void bit::pauseAllTorrents() 
     533void bit::pause_all_torrents() 
    534534{        
    535535        try { 
     
    545545} 
    546546 
    547 void bit::unpauseAllTorrents() 
     547void bit::unpause_all_torrents() 
    548548{        
    549549        try { 
     
    552552                i != e; ++i) 
    553553        { 
    554                 if ((*i).torrent->in_session() && (*i).torrent->state() == torrent_details::torrent_paused) 
     554                if ((*i).torrent->in_session() && (*i).torrent->get_state() == torrent_details::torrent_paused) 
    555555                        (*i).torrent->resume(); 
    556556        } 
     
    810810} 
    811811 
    812 void bit::stopEventReceiver() 
     812void bit::stop_event_receiver() 
    813813{ 
    814814        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event handler."))); 
  • trunk/src/halTorrent.hpp

    r628 r632  
    842842        }; 
    843843 
    844         void shutDownSession(); 
     844        void shutdown_session(); 
    845845        void save_torrent_data(); 
    846846 
     
    932932        void recheckTorrent(const std::wstring& filename); 
    933933         
    934         void pauseAllTorrents(); 
    935         void unpauseAllTorrents(); 
     934        void pause_all_torrents(); 
     935        void unpause_all_torrents(); 
    936936 
    937937        template<typename S> 
     
    948948 
    949949        void startEventReceiver(); 
    950         void stopEventReceiver(); 
     950        void stop_event_receiver(); 
    951951         
    952952        friend bit& bittorrent(); 
  • trunk/src/halTorrentInternal.hpp

    r620 r632  
    339339        torrent_internal() :     
    340340                TORRENT_INTERNALS_DEFAULTS, 
    341                 allocation_(bit::sparse_allocation), 
    342                 state_(torrent_details::torrent_stopped) 
    343         { 
     341                allocation_(bit::sparse_allocation) 
     342        { 
     343                state(torrent_details::torrent_stopped); 
    344344                TORRENT_STATE_LOG(L"Torrent state machine initiate"); 
    345345                machine_.initiate(); 
     
    350350                save_directory_(saveDirectory.string()), 
    351351                move_to_directory_(move_to_directory.string()), 
    352                 allocation_(alloc),      
    353                 state_(torrent_details::torrent_stopped) 
    354         { 
     352                allocation_(alloc) 
     353        { 
     354                state(torrent_details::torrent_stopped); 
    355355                assert(the_session_);    
    356356                 
     
    386386                } 
    387387                 
    388                 wstring state; 
    389                  
    390                 switch (state_) 
     388                wstring state_str; 
     389                 
     390                switch (state()) 
    391391                { 
    392392                case torrent_details::torrent_paused: 
    393                         state = app().res_wstr(HAL_TORRENT_PAUSED); 
     393                        state_str = app().res_wstr(HAL_TORRENT_PAUSED); 
    394394                        break; 
    395395                         
    396396                case torrent_details::torrent_pausing: 
    397                         state = app().res_wstr(HAL_TORRENT_PAUSING); 
     397                        state_str = app().res_wstr(HAL_TORRENT_PAUSING); 
    398398                        break; 
    399399                         
    400400                case torrent_details::torrent_stopped: 
    401                         state = app().res_wstr(HAL_TORRENT_STOPPED); 
     401                        state_str = app().res_wstr(HAL_TORRENT_STOPPED); 
    402402                        break; 
    403403                         
    404404                case torrent_details::torrent_stopping: 
    405                         state = app().res_wstr(HAL_TORRENT_STOPPING); 
     405                        state_str = app().res_wstr(HAL_TORRENT_STOPPING); 
    406406                        break; 
    407407                         
     
    410410                        { 
    411411                        case libt::torrent_status::queued_for_checking: 
    412                                 state = app().res_wstr(HAL_TORRENT_QUEUED_CHECKING); 
     412                                state_str = app().res_wstr(HAL_TORRENT_QUEUED_CHECKING); 
    413413                                break; 
    414414                        case libt::torrent_status::checking_files: 
    415                                 state = app().res_wstr(HAL_TORRENT_CHECKING_FILES); 
     415                                state_str = app().res_wstr(HAL_TORRENT_CHECKING_FILES); 
    416416                                break; 
    417417//                      case libt::torrent_status::connecting_to_tracker: 
     
    419419//                              break; 
    420420                        case libt::torrent_status::downloading_metadata: 
    421                                 state = app().res_wstr(HAL_TORRENT_METADATA); 
     421                                state_str = app().res_wstr(HAL_TORRENT_METADATA); 
    422422                                break; 
    423423                        case libt::torrent_status::downloading: 
    424                                 state = app().res_wstr(HAL_TORRENT_DOWNLOADING); 
     424                                state_str = app().res_wstr(HAL_TORRENT_DOWNLOADING); 
    425425                                break; 
    426426                        case libt::torrent_status::finished: 
    427                                 state = app().res_wstr(HAL_TORRENT_FINISHED); 
     427                                state_str = app().res_wstr(HAL_TORRENT_FINISHED); 
    428428                                break; 
    429429                        case libt::torrent_status::seeding: 
    430                                 state = app().res_wstr(HAL_TORRENT_SEEDING); 
     430                                state_str = app().res_wstr(HAL_TORRENT_SEEDING); 
    431431                                break; 
    432432                        case libt::torrent_status::allocating: 
    433                                 state = app().res_wstr(HAL_TORRENT_ALLOCATING); 
     433                                state_str = app().res_wstr(HAL_TORRENT_ALLOCATING); 
    434434                                break; 
    435435                        }        
     
    465465                        name_, filename_,  
    466466                        save_directory().string(),  
    467                         state,  
     467                        state_str,  
    468468                        hal::from_utf8(statusMemory_.current_tracker),  
    469469                        std::pair<float, float>( 
     
    633633 
    634634                if (handle_.is_paused()) 
    635                         state_ = torrent_details::torrent_paused;        
     635                        state(torrent_details::torrent_paused);  
    636636 
    637637                } 
     
    639639                { 
    640640                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    641                                 new hal::EventStdException(event_logger::critical, e, L"addToSession")));  
     641                                new hal::EventStdException(event_logger::critical, e, L"add_to_session")));  
    642642                } 
    643643        } 
     
    680680                { 
    681681                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    682                                 new hal::EventStdException(event_logger::critical, e, L"remove_fromSession")));  
     682                                new hal::EventStdException(event_logger::critical, e, L"remove_from_session()")));  
    683683                        return false; 
    684684                } 
     
    695695        { 
    696696                mutex_t::scoped_lock l(mutex_); 
    697  
    698                 if (state_ == torrent_details::torrent_stopped) 
     697                HAL_DEV_MSG(hal::wform(L"resume() - %1%") % name_); 
     698 
     699                if (state() == torrent_details::torrent_stopped) 
    699700                {        
    700701                        add_to_session(false); 
     
    707708                }        
    708709                 
    709                 state_ = torrent_details::torrent_active;                        
     710                state(torrent_details::torrent_active);                  
    710711                //assert(!handle_.is_paused()); 
    711712        } 
     
    714715        { 
    715716                mutex_t::scoped_lock l(mutex_); 
    716  
    717                 if (state_ == torrent_details::torrent_stopped) 
     717                HAL_DEV_MSG(hal::wform(L"pause() - %1%") % name_); 
     718 
     719                if (state() == torrent_details::torrent_stopped) 
    718720                {        
    719721                        add_to_session(true); 
     
    732734                        signals().torrent_paused.connect(bind(&signaler_wrapper<>::operator(), sig)); 
    733735 
    734                         state_ = torrent_details::torrent_pausing;       
     736                        state(torrent_details::torrent_pausing);         
    735737                }                        
    736738        } 
     
    739741        { 
    740742                mutex_t::scoped_lock l(mutex_); 
    741  
    742                 if (state_ != torrent_details::torrent_stopped) 
    743                 { 
    744                         if (state_ == torrent_details::torrent_active) 
     743                HAL_DEV_MSG(hal::wform(L"stop() - %1%") % name_); 
     744 
     745                HAL_DEV_MSG(hal::wform(L"stop() requesting")); 
     746 
     747                if (state() != torrent_details::torrent_stopped) 
     748                { 
     749                        if (state() == torrent_details::torrent_active) 
    745750                        { 
    746751                                assert(in_session()); 
     752                                assert(!(handle_.is_paused())); 
    747753 
    748754                                signaler_wrapper<>* sig = new signaler_wrapper<>(bind(&torrent_internal::completed_stop, this)); 
     
    752758                                handle_.pause(); 
    753759 
    754                                 state_ = torrent_details::torrent_stopping; 
     760                                state(torrent_details::torrent_stopping); 
    755761                        } 
    756                         else if (state_ == torrent_details::torrent_paused) 
     762                        else if (state() == torrent_details::torrent_paused) 
    757763                        {                        
    758764                                remove_from_session(); 
    759                                 state_ = torrent_details::torrent_stopped;                               
     765                                state(torrent_details::torrent_stopped);                                 
    760766                        } 
    761767                } 
     
    764770        void set_state_stopped() 
    765771        { 
    766                 state_ = torrent_details::torrent_stopped; 
     772                state(torrent_details::torrent_stopped); 
    767773        } 
    768774 
     
    772778                HAL_DEV_MSG(L"force_recheck()"); 
    773779 
    774                 switch (state_) 
     780                switch (state()) 
    775781                { 
    776782                case torrent_details::torrent_stopped: 
     
    787793//                      signals().torrent_paused.connect_once(bind(&torrent_internal::handle_recheck, this)); 
    788794                        handle_.pause(); 
    789                         state_ = torrent_details::torrent_pausing; 
     795                        state(torrent_details::torrent_pausing); 
    790796                        break; 
    791797 
     
    889895        } 
    890896         
    891         bool is_active() const { return state_ == torrent_details::torrent_active; } 
    892          
    893         unsigned state() const { return state_; } 
     897        bool is_active() const { return state() == torrent_details::torrent_active; } 
     898 
     899        unsigned get_state() 
     900        { 
     901                return state_; 
     902        } 
    894903         
    895904        void setTrackerLogin(wstring username, wstring password) 
     
    11641173                        fs::create_directory(save_directory_); 
    11651174 
     1175                // These here should not make state changes based on torrent  
     1176                // session status since it has not been initialized yet. 
    11661177                if (state_ == torrent_details::torrent_stopping) 
    1167                         state_ = torrent_details::torrent_stopped; 
     1178                        state(torrent_details::torrent_stopped); 
    11681179                else if (state_ == torrent_details::torrent_pausing) 
    1169                         state_ = torrent_details::torrent_paused; 
     1180                        state(torrent_details::torrent_paused); 
    11701181        } 
    11711182         
     
    13221333                HAL_DEV_MSG(L"completed_pause()"); 
    13231334                                 
    1324                 state_ = torrent_details::torrent_paused;        
     1335                state(torrent_details::torrent_paused); 
    13251336 
    13261337                return true; 
     
    13391350                } 
    13401351 
    1341                 state_ = torrent_details::torrent_stopped; 
     1352                state(torrent_details::torrent_stopped); 
    13421353 
    13431354                return true; 
     
    13471358        { 
    13481359                mutex_t::scoped_lock l(mutex_); 
    1349                 state_ = torrent_details::torrent_stopped; 
     1360                state(torrent_details::torrent_stopped); 
    13501361 
    13511362                remove_from_session(false); 
     
    13591370                HAL_DEV_MSG(L"handle_recheck()"); 
    13601371        } 
     1372 
     1373        void state(unsigned s) 
     1374        { 
     1375                switch (s) 
     1376                { 
     1377                case torrent_details::torrent_stopped: 
     1378                        HAL_DEV_MSG(L"state() - stopped"); 
     1379                        break; 
     1380                case torrent_details::torrent_stopping: 
     1381                        HAL_DEV_MSG(L"state() - stopping"); 
     1382                        break; 
     1383                case torrent_details::torrent_pausing: 
     1384                        HAL_DEV_MSG(L"state() - pausing"); 
     1385                        break; 
     1386                case torrent_details::torrent_active: 
     1387                        HAL_DEV_MSG(L"state() - active"); 
     1388                        break; 
     1389                case torrent_details::torrent_paused: 
     1390                        HAL_DEV_MSG(L"state() - paused"); 
     1391                        break; 
     1392                default: 
     1393                        HAL_DEV_MSG(L"state() - unknown"); 
     1394                        break; 
     1395                }; 
     1396                state_ = s; 
     1397        }        
     1398         
     1399        unsigned state() const  
     1400        {  
     1401                if (in_session()) 
     1402                { 
     1403                        if (handle_.is_paused()) 
     1404                        { 
     1405                                if (state_ != torrent_details::torrent_paused) 
     1406                                {                        
     1407                                        HAL_DEV_MSG(L"Should really be paused!"); 
     1408                                        state_ = torrent_details::torrent_paused; 
     1409                                } 
     1410                        } 
     1411                        else                             
     1412                        {                        
     1413                                if (state_ != torrent_details::torrent_active && 
     1414                                        state_ != torrent_details::torrent_pausing && 
     1415                                        state_ != torrent_details::torrent_stopping) 
     1416                                {                        
     1417                                        HAL_DEV_MSG(L"Should really be active!"); 
     1418                                        state_ = torrent_details::torrent_active; 
     1419                                } 
     1420                        }                        
     1421                } 
     1422                else 
     1423                { 
     1424                        if (state_ != torrent_details::torrent_stopped) 
     1425                        {                        
     1426                                HAL_DEV_MSG(L"Should really be stopped!"); 
     1427                                state_ = torrent_details::torrent_stopped; 
     1428                        } 
     1429                } 
     1430                 
     1431                return state_;  
     1432        } 
    13611433                 
    13621434        static libt::session* the_session_; 
     
    13681440        std::pair<float, float> transferLimit_; 
    13691441         
    1370         unsigned state_; 
     1442        mutable unsigned state_; 
    13711443        int connections_; 
    13721444        int uploads_; 
Note: See TracChangeset for help on using the changeset viewer.