Changeset 541 for trunk


Ignore:
Timestamp:
08/15/08 15:50:02 (11 years ago)
Author:
Eoin
Message:

Updating halConfig serialization.

Location:
trunk
Files:
10 edited

Legend:

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

    r503 r541  
    142142  </PropertyGroup> 
    143143  <ItemGroup> 
    144     <WixExtension Include="C:\Program Files (x86)\Windows Installer XML v3\bin\WixUIExtension.dll" /> 
     144    <WixExtension Include="WixUIExtension"> 
     145      <HintPath>C:\Program Files (x86)\Windows Installer XML v3\bin\WixUIExtension.dll</HintPath> 
     146    </WixExtension> 
    145147  </ItemGroup> 
    146148  <ItemGroup> 
  • trunk/src/ConfigOptions.hpp

    r506 r541  
    200200 
    201201    BEGIN_DDX_MAP(thisClass) 
    202         DDX_CHECK(HAL_BC_PORTCHECK, hal::config().portRange) 
    203         DDX_INT(HAL_BC_PORTFROM, hal::config().portFrom) 
    204         DDX_INT(HAL_BC_PORTTO, hal::config().portTo)             
    205         DDX_CHECK(HAL_BC_HALFCONN_CHECK, hal::config().halfConn) 
    206         DDX_EX_INT_POSITIVE(HAL_BC_HALFCONN_NUM, hal::config().halfConnLimit) 
    207         DDX_CHECK(HAL_BC_DHT, hal::config().enableDHT) 
    208         DDX_INT(HAL_BC_DHTPORT, hal::config().dhtServicePort) 
    209         DDX_RADIO(HAL_BITT_GPORTFORWARD_NONE, hal::config().mappingType) 
    210202    END_DDX_MAP() 
    211203 
     
    280272        DDX_CHECK(HAL_BC_HALFCONN_CHECK, hal::config().halfConn) 
    281273        DDX_EX_INT_POSITIVE(HAL_BC_HALFCONN_NUM, hal::config().halfConnLimit) 
    282         DDX_CHECK(HAL_BC_DHT, hal::config().enableDHT) 
    283         DDX_INT(HAL_BC_DHTPORT, hal::config().dhtServicePort) 
     274        DDX_CHECK(HAL_BC_DHT, hal::config().enable_dht_) 
     275        DDX_INT(HAL_BC_DHTPORT, hal::config().dht_settings_.service_port) 
    284276        DDX_RADIO(HAL_BITT_GPORTFORWARD_NONE, hal::config().mappingType) 
    285277    END_DDX_MAP() 
     
    515507    BEGIN_DDX_MAP(thisClass) 
    516508        DDX_CHECK(HAL_BC_FILTERCHECK, hal::config().enableIPFilter) 
    517         DDX_CHECK(HAL_SC_ENABLE_PE, hal::config().enablePe) 
    518         DDX_RADIO(HAL_SC_PE_ENC_PLAIN, hal::config().peEncLevel) 
    519         DDX_CHECK(HAL_SC_PE_ENC_RC4_PERFER, hal::config().pePerferRc4) 
    520         DDX_RADIO(HAL_SC_PE_CP_IN_FORCED, hal::config().peConInPolicy) 
    521         DDX_RADIO(HAL_SC_PE_CP_OUT_FORCED, hal::config().peConOutPolicy) 
     509        DDX_CHECK(HAL_SC_ENABLE_PE, hal::config().enable_pe_) 
     510        DDX_RADIO(HAL_SC_PE_ENC_PLAIN, hal::config().pe_settings_.encrypt_level) 
     511        DDX_CHECK(HAL_SC_PE_ENC_RC4_PERFER, hal::config().pe_settings_.prefer_rc4) 
     512        DDX_RADIO(HAL_SC_PE_CP_IN_FORCED, hal::config().pe_settings_.conn_in_policy) 
     513        DDX_RADIO(HAL_SC_PE_CP_OUT_FORCED, hal::config().pe_settings_.conn_out_policy) 
    522514    END_DDX_MAP() 
    523515         
     
    727719                gUploadRate_.Attach(GetDlgItem(HAL_BC_UPRATE)); 
    728720 
    729                 gTotalConnections_ = hal::config().maxConnections; 
    730                 gUploadConnections_ = hal::config().maxUploads; 
    731                 gDownloadRate_ = hal::config().downRate; 
    732                 gUploadRate_ = hal::config().upRate; 
     721                gTotalConnections_ = hal::config().globals_.total; 
     722                gUploadConnections_ = hal::config().globals_.uploads; 
     723                gDownloadRate_ = hal::config().globals_.download_rate; 
     724                gUploadRate_ = hal::config().globals_.upload_rate; 
    733725 
    734726                active_downloads_.Attach(GetDlgItem(HAL_CGLOBAL_ACTDOWN)); 
     
    758750                        new hal::EventMsg(L"Applying torrent options.", hal::event_logger::info))); 
    759751 
    760                 hal::config().maxConnections = gTotalConnections_; 
    761                 hal::config().maxUploads = gUploadConnections_; 
    762                 hal::config().downRate = gDownloadRate_; 
    763                 hal::config().upRate = gUploadRate_; 
     752                hal::config().globals_.total = gTotalConnections_; 
     753                hal::config().globals_.uploads = gUploadConnections_; 
     754                hal::config().globals_.download_rate = gDownloadRate_; 
     755                hal::config().globals_.upload_rate = gUploadRate_; 
    764756         
    765757                hal::config().queue_settings_.active_downloads = active_downloads_; 
     
    868860                tUploadRate_.Attach(GetDlgItem(HAL_BC_TUPRATE)); 
    869861         
    870                 tTotalConnections_ = hal::config().torrentMaxConnections; 
    871                 tUploadConnections_ = hal::config().torrentMaxUploads; 
    872                 tDownloadRate_ = hal::config().torrentDownRate; 
    873                 tUploadRate_ = hal::config().torrentUpRate; 
     862                tTotalConnections_ = hal::config().torrent_defaults_.total; 
     863                tUploadConnections_ = hal::config().torrent_defaults_.uploads; 
     864                tDownloadRate_ = hal::config().torrent_defaults_.download_rate; 
     865                tUploadRate_ = hal::config().torrent_defaults_.upload_rate; 
    874866         
    875867                BOOL retval =  DoDataExchange(false); 
     
    923915                        new hal::EventMsg(L"Applying torrent options.", hal::event_logger::info))); 
    924916 
    925                 hal::config().torrentMaxConnections = tTotalConnections_; 
    926                 hal::config().torrentMaxUploads = tUploadConnections_; 
    927                 hal::config().torrentDownRate = tDownloadRate_; 
    928                 hal::config().torrentUpRate = tUploadRate_; 
     917                hal::config().torrent_defaults_.total = tTotalConnections_; 
     918                hal::config().torrent_defaults_.uploads = tUploadConnections_; 
     919                hal::config().torrent_defaults_.download_rate = tDownloadRate_; 
     920                hal::config().torrent_defaults_.upload_rate = tUploadRate_; 
    929921                 
    930922                return DoDataExchange(true); 
  • trunk/src/Halite.hpp

    r531 r541  
    104104        void serialize(Archive& ar, const unsigned int version) 
    105105        {        
    106         ar & BOOST_SERIALIZATION_NVP(oneInst); 
    107                 ar & BOOST_SERIALIZATION_NVP(logDebug_); 
    108                 ar & boost::serialization::make_nvp("showMessage", showMessage_); 
    109                  
    110                 ar & BOOST_SERIALIZATION_NVP(logToFile_); 
    111                 if (version > 1) 
    112                         ar & BOOST_SERIALIZATION_NVP(logListLen_); 
    113                 if (version > 0) 
    114                         ar & BOOST_SERIALIZATION_NVP(dll_); 
     106                using boost::serialization::make_nvp; 
     107 
     108                switch (version) 
     109                { 
     110                case 4: 
     111                ar      & make_nvp("one_inst", oneInst) 
     112                        & make_nvp("show_message", showMessage_) 
     113                        & make_nvp("log_debug", logDebug_) 
     114                        & make_nvp("log_list_length", logListLen_) 
     115                        & make_nvp("log_to_file", logToFile_) 
     116                        & make_nvp("lang_dll", dll_); 
     117                break; 
     118 
     119                case 3: 
     120                case 2: 
     121                ar      & make_nvp("dll_", dll_); 
     122                case 1: 
     123                ar      & make_nvp("logListLen_", logListLen_); 
     124                case 0: 
     125                ar      & make_nvp("oneInst", oneInst) 
     126                        & make_nvp("logDebug_", logDebug_) 
     127                        & make_nvp("showMessage", showMessage_) 
     128                        & make_nvp("logToFile_", logToFile_); 
     129                } 
    115130        }        
    116131         
     
    139154Halite& halite(); 
    140155 
    141 BOOST_CLASS_VERSION(Halite, 3) 
     156BOOST_CLASS_VERSION(Halite, 4) 
  • trunk/src/global/txml.hpp

    r536 r541  
    3030#define TIXML_USE_STL 
    3131#endif 
    32  
    33 #define HAL_BOOST_SERIALIZATION_COMPAT 
    3432 
    3533#ifdef _MSC_VER 
  • trunk/src/global/txml_iarchive.hpp

    r539 r541  
    210210                                failsafe_current = previous_child_node_->next_sibling(location.leaf()); 
    211211                                previous_child_node_ = 0; 
     212                                 
     213                                if (!failsafe_current)  
     214                                        failsafe_current = current_node_->first_child(location.leaf());; 
    212215                        } 
    213216                        else 
  • trunk/src/halConfig.cpp

    r531 r541  
    7171        try 
    7272        { 
    73         if (enablePe) 
     73        if (enable_pe_) 
    7474        { 
    75                 bittorrent().ensure_pe_on(peEncLevel, peConInPolicy, peConOutPolicy, pePerferRc4); 
     75                bittorrent().ensure_pe_on(pe_settings_); 
    7676        } 
    7777        else 
     
    8888        bittorrent().resume_all();       
    8989         
    90         bittorrent().set_session_limits(maxConnections, maxUploads); 
    91         bittorrent().set_session_speed( downRate, upRate); 
     90        bittorrent().set_session_limits(globals_.total, globals_.uploads); 
     91        bittorrent().set_session_speed(globals_.download_rate, globals_.upload_rate); 
    9292                 
    93         bittorrent().setTorrentDefaults(torrentMaxConnections, 
    94                 torrentMaxUploads, torrentDownRate,     torrentUpRate); 
    95          
    96         bittorrent().set_dht_settings(dhtMaxPeersReply,  
    97                 dhtSearchBranching, dhtServicePort, dhtMaxFailCount); 
     93        bittorrent().set_torrent_defaults(torrent_defaults_); 
    9894 
    9995        bittorrent().set_timeouts(timeouts_);    
    10096        bittorrent().set_queue_settings(queue_settings_); 
    10197         
    102         if (enableDHT) 
     98        if (enable_dht_) 
    10399        { 
    104                 if (!bittorrent().ensure_dht_on()) 
     100                if (!bittorrent().ensure_dht_on(dht_settings_)) 
    105101                { 
    106102                        bittorrent().ensure_dht_off(); 
  • trunk/src/halConfig.hpp

    r519 r541  
    3131        Config() : 
    3232                hal::IniBase<Config>("globals/bittorrent", "Config"), 
    33                 maxConnections(200), 
    34                 maxUploads(20), 
    35                 downRate(-1), 
    36                 upRate(-1), 
    37                 torrentMaxConnections(50), 
    38                 torrentMaxUploads(10), 
    39                 torrentDownRate(-1), 
    40                 torrentUpRate(-1), 
     33                globals_(), 
     34                torrent_defaults_(), 
    4135                portFrom(6881), 
    4236                portTo(6881), 
    4337                portRange(false), 
    44                 enableDHT(false), 
    45                 dhtMaxPeersReply(50), 
    46                 dhtSearchBranching(5),           
    47                 dhtServicePort(6881), 
    48                 dhtMaxFailCount(20), 
     38                enable_dht_(true), 
     39                dht_settings_(), 
    4940                enableIPFilter(false), 
    5041                enableProxy(false), 
     
    5445                useMoveTo(false), 
    5546                savePrompt(true), 
    56                 enablePe(false), 
    57                 peEncLevel(0), 
    58                 pePerferRc4(false), 
    59                 peConInPolicy(1), 
    60                 peConOutPolicy(1), 
     47                enable_pe_(false), 
     48                pe_settings_(), 
    6149                halfConn(true), 
    6250                halfConnLimit(10), 
     
    7260        {        
    7361                using boost::serialization::make_nvp; 
     62                switch (version) 
     63                { 
     64                case 6: 
     65                ar      & make_nvp("globals", globals_) 
     66                        & make_nvp("torrent_defaults", torrent_defaults_) 
     67                        & make_nvp("queue_settings", queue_settings_) 
     68                        & make_nvp("timeouts", timeouts_) 
     69                        & make_nvp("enable_dht", enable_dht_) 
     70                        & make_nvp("dht_settings", dht_settings_) 
     71                        & make_nvp("enable_pe", enable_pe_) 
     72                        & make_nvp("pe_settings", pe_settings_); 
     73                break; 
    7474 
    75                 ar & BOOST_SERIALIZATION_NVP(maxConnections); 
    76                 ar & BOOST_SERIALIZATION_NVP(maxUploads); 
    77                 ar & BOOST_SERIALIZATION_NVP(downRate); 
    78                 ar & BOOST_SERIALIZATION_NVP(upRate); 
    79                 ar & BOOST_SERIALIZATION_NVP(portFrom); 
    80                 ar & BOOST_SERIALIZATION_NVP(portTo); 
     75                case 4: 
     76                ar      & BOOST_SERIALIZATION_NVP(defaultMoveToFolder); 
     77                        & BOOST_SERIALIZATION_NVP(useMoveTo); 
     78 
     79                case 3: 
     80                ar      & BOOST_SERIALIZATION_NVP(mappingType); 
     81 
     82                case 2: 
     83                ar      & BOOST_SERIALIZATION_NVP(halfConn) 
     84                        & BOOST_SERIALIZATION_NVP(halfConnLimit); 
     85 
     86                case 1: 
     87                ar      & make_nvp("enablePe", enable_pe_) 
     88                        & make_nvp("peEncLevel", pe_settings_.encrypt_level) 
     89                        & make_nvp("pePerferRc4", pe_settings_.prefer_rc4) 
     90                        & make_nvp("peConInPolicy", pe_settings_.conn_in_policy) 
     91                        & make_nvp("peConOutPolicy", pe_settings_.conn_out_policy); 
     92 
     93                case 0: 
     94                ar      & make_nvp("maxConnections", globals_.total) 
     95                        & make_nvp("maxUploads", globals_.uploads) 
     96                        & make_nvp("downRate", globals_.download_rate) 
     97                        & make_nvp("upRate", globals_.upload_rate) 
     98                        & BOOST_SERIALIZATION_NVP(portFrom) 
     99                        & BOOST_SERIALIZATION_NVP(portTo); 
    81100                 
    82                 ar & BOOST_SERIALIZATION_NVP(enableDHT); 
    83                 ar & BOOST_SERIALIZATION_NVP(dhtMaxPeersReply); 
    84                 ar & BOOST_SERIALIZATION_NVP(dhtSearchBranching); 
    85                 ar & BOOST_SERIALIZATION_NVP(dhtServicePort); 
    86                 ar & BOOST_SERIALIZATION_NVP(dhtMaxFailCount); 
    87                 ar & BOOST_SERIALIZATION_NVP(enableIPFilter); 
    88                 ar & BOOST_SERIALIZATION_NVP(portRange); 
     101                ar      & make_nvp("enableDHT", enable_dht_) 
     102                        & make_nvp("dhtMaxPeersReply", dht_settings_.max_peers_reply) 
     103                        & make_nvp("dhtSearchBranching", dht_settings_.search_branching) 
     104                        & make_nvp("dhtServicePort", dht_settings_.service_port) 
     105                        & make_nvp("dhtMaxFailCount", dht_settings_.max_fail_count); 
    89106                 
    90                 ar & BOOST_SERIALIZATION_NVP(torrentMaxConnections); 
    91                 ar & BOOST_SERIALIZATION_NVP(torrentMaxUploads); 
    92                 ar & BOOST_SERIALIZATION_NVP(torrentDownRate); 
    93                 ar & BOOST_SERIALIZATION_NVP(torrentUpRate); 
    94                  
    95                 if (version <= 1) { 
    96                         ar & BOOST_SERIALIZATION_NVP(enableProxy); 
    97                         ar & BOOST_SERIALIZATION_NVP(proxyHost); 
    98                         ar & BOOST_SERIALIZATION_NVP(proxyPort); 
    99                         ar & BOOST_SERIALIZATION_NVP(proxyUsername); 
    100                         ar & BOOST_SERIALIZATION_NVP(proxyPassword); 
    101                 } 
    102                  
    103                 ar & BOOST_SERIALIZATION_NVP(defaultSaveFolder); 
    104                 if (version > 3) { 
    105                         ar & BOOST_SERIALIZATION_NVP(defaultMoveToFolder); 
    106                         ar & BOOST_SERIALIZATION_NVP(useMoveTo); 
    107                 } 
    108                 ar & BOOST_SERIALIZATION_NVP(savePrompt); 
    109                  
    110                 if (version > 0) { 
    111                         ar & BOOST_SERIALIZATION_NVP(enablePe); 
    112                         ar & BOOST_SERIALIZATION_NVP(peEncLevel); 
    113                         ar & BOOST_SERIALIZATION_NVP(pePerferRc4); 
    114                         ar & BOOST_SERIALIZATION_NVP(peConInPolicy); 
    115                         ar & BOOST_SERIALIZATION_NVP(peConOutPolicy); 
    116                 } 
    117                 if (version > 1) { 
    118                         ar & BOOST_SERIALIZATION_NVP(halfConn); 
    119                         ar & BOOST_SERIALIZATION_NVP(halfConnLimit); 
    120                 } 
    121                 if (version > 2) { 
    122                         ar & BOOST_SERIALIZATION_NVP(mappingType); 
    123                 } 
     107                ar      & make_nvp("peerTimeout", timeouts_.peer_connect_timeout) 
     108                        & make_nvp("trackerTimeout", timeouts_.tracker_receive_timeout); 
    124109 
    125                 if (version > 2 && version < 6) { 
    126                         ar & make_nvp("peerTimeout", timeouts_.peer_connect_timeout); 
    127                         ar & make_nvp("trackerTimeout", timeouts_.tracker_receive_timeout); 
    128                 } else if (version > 5) { 
    129                         ar & make_nvp("queue_settings", queue_settings_); 
    130                         ar & make_nvp("timeouts", timeouts_); 
     110                ar      & BOOST_SERIALIZATION_NVP(enableIPFilter) 
     111                        & BOOST_SERIALIZATION_NVP(portRange) 
     112                        & make_nvp("torrentMaxConnections", torrent_defaults_.total) 
     113                        & make_nvp("torrentMaxUploads", torrent_defaults_.uploads) 
     114                        & make_nvp("torrentDownRate", torrent_defaults_.download_rate) 
     115                        & make_nvp("torrentUpRate", torrent_defaults_.upload_rate) 
     116                        & BOOST_SERIALIZATION_NVP(defaultSaveFolder) 
     117                        & BOOST_SERIALIZATION_NVP(savePrompt); 
    131118                } 
    132119        } 
     
    145132        bool settingsThread(); 
    146133         
    147         int maxConnections; 
    148         int maxUploads; 
    149          
    150         float downRate; 
    151         float upRate; 
    152  
    153         int torrentMaxConnections; 
    154         int torrentMaxUploads; 
    155          
    156         float torrentDownRate; 
    157         float torrentUpRate; 
     134        hal::connections globals_; 
     135        hal::connections torrent_defaults_; 
    158136         
    159137        int portFrom; 
     
    161139        bool portRange; 
    162140         
    163         bool enableDHT; 
    164         int dhtMaxPeersReply; 
    165         int dhtSearchBranching; 
    166         int dhtServicePort; 
    167         int dhtMaxFailCount; 
     141        bool enable_dht_; 
     142        hal::dht_settings dht_settings_; 
    168143         
    169144        bool enableIPFilter; 
     
    180155        bool savePrompt; 
    181156 
    182     bool enablePe; 
    183     int peEncLevel; 
    184     bool pePerferRc4; 
    185     int peConInPolicy; 
    186     int peConOutPolicy; 
     157    bool enable_pe_; 
     158        hal::pe_settings pe_settings_; 
    187159         
    188160        bool halfConn; 
  • trunk/src/halSession.hpp

    r531 r541  
    267267        } 
    268268 
    269         bool ensure_dht_on() 
    270         { 
     269        bool ensure_dht_on(const dht_settings& dht) 
     270        {                
     271                libt::dht_settings settings; 
     272                settings.max_peers_reply = dht.max_peers_reply; 
     273                settings.search_branching = dht.search_branching; 
     274                settings.service_port = dht.service_port; 
     275                settings.max_fail_count = dht.max_fail_count; 
     276                 
     277                if (dht_settings_ != settings) 
     278                { 
     279                        dht_settings_ = settings; 
     280                        session_.set_dht_settings(dht_settings_); 
     281                } 
     282 
    271283                if (!dht_on_) 
    272284                {                
     
    288300                        session_.stop_dht();             
    289301                        dht_on_ = false; 
    290                 } 
    291         } 
    292  
    293         void set_dht_settings(int max_peers_reply, int search_branching,  
    294                 int service_port, int max_fail_count) 
    295         { 
    296                 libt::dht_settings settings; 
    297                 settings.max_peers_reply = max_peers_reply; 
    298                 settings.search_branching = search_branching; 
    299                 settings.service_port = service_port; 
    300                 settings.max_fail_count = max_fail_count; 
    301                  
    302                 if (dht_settings_ != settings) 
    303                 { 
    304                         dht_settings_ = settings; 
    305                         session_.set_dht_settings(dht_settings_); 
    306302                } 
    307303        } 
     
    501497 
    502498        #ifndef TORRENT_DISABLE_ENCRYPTION       
    503         void ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
     499        void ensure_pe_on(const pe_settings& pe_s) 
    504500        { 
    505501                libt::pe_settings pe; 
    506502                 
    507                 switch (enc_level) 
     503                switch (pe_s.encrypt_level) 
    508504                { 
    509505                        case 0: 
     
    521517                                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    522518                                        new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    523                                                 (hal::wform(hal::app().res_wstr(HAL_INCORRECT_ENCODING_LEVEL)) % enc_level).str()))); 
    524                 } 
    525  
    526                 switch (in_enc_policy) 
     519                                                (hal::wform(hal::app().res_wstr(HAL_INCORRECT_ENCODING_LEVEL)) % pe_s.encrypt_level).str()))); 
     520                } 
     521 
     522                switch (pe_s.conn_in_policy) 
    527523                { 
    528524                        case 0: 
     
    540536                                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    541537                                        new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    542                                                 (hal::wform(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
    543                 } 
    544  
    545                 switch (out_enc_policy) 
     538                                                (hal::wform(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % pe_s.conn_in_policy).str()))); 
     539                } 
     540 
     541                switch (pe_s.conn_out_policy) 
    546542                { 
    547543                        case 0: 
     
    559555                                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    560556                                        new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    561                                                 (hal::wform(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
    562                 } 
    563                  
    564                 pe.prefer_rc4 = prefer_rc4; 
     557                                                (hal::wform(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % pe_s.conn_out_policy).str()))); 
     558                } 
     559                 
     560                pe.prefer_rc4 = pe_s.prefer_rc4; 
    565561                 
    566562                try 
  • trunk/src/halTorrent.cpp

    r531 r541  
    157157} 
    158158 
    159 bool bit::ensure_dht_on() 
    160 { 
    161         return pimpl->ensure_dht_on(); 
     159bool bit::ensure_dht_on(const hal::dht_settings& dht) 
     160{ 
     161        return pimpl->ensure_dht_on(dht); 
    162162} 
    163163 
     
    165165{ 
    166166        pimpl->ensure_dht_off(); 
    167 } 
    168  
    169 void bit::set_dht_settings(int max_peers_reply, int search_branching,  
    170         int service_port, int max_fail_count) 
    171 { 
    172         pimpl->set_dht_settings(max_peers_reply, search_branching, service_port, max_fail_count); 
    173167} 
    174168 
     
    220214#ifndef TORRENT_DISABLE_ENCRYPTION       
    221215 
    222 void bit::ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
    223 { 
    224         pimpl->ensure_pe_on(enc_level, in_enc_policy, out_enc_policy, prefer_rc4); 
     216void bit::ensure_pe_on(const pe_settings& pe) 
     217{ 
     218        pimpl->ensure_pe_on(pe); 
    225219} 
    226220 
     
    286280} 
    287281 
    288 void bit::setTorrentDefaults(int maxConn, int maxUpload, float download, float upload) 
    289 { 
    290         pimpl->defTorrentMaxConn_ = maxConn; 
    291         pimpl->defTorrentMaxUpload_ = maxUpload; 
     282void bit::set_torrent_defaults(const connections& defaults) 
     283{ 
     284        pimpl->defTorrentMaxConn_ = defaults.total; 
     285        pimpl->defTorrentMaxUpload_ = defaults.uploads; 
    292286 
    293287        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    294                 hal::wform(L"Set torrent connections total %1% and uploads %2%.") % maxConn % maxUpload))); 
    295  
    296         pimpl->defTorrentDownload_ = download; 
    297         pimpl->defTorrentUpload_ = upload; 
     288                hal::wform(L"Set torrent connections total %1% and uploads %2%.")  
     289                        % defaults.total % defaults.uploads))); 
     290 
     291        pimpl->defTorrentDownload_ = defaults.download_rate; 
     292        pimpl->defTorrentUpload_ = defaults.upload_rate; 
    298293 
    299294        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    300                 hal::wform(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") % download % upload))); 
     295                hal::wform(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.")  
     296                        % defaults.download_rate % defaults.upload_rate))); 
    301297} 
    302298 
  • trunk/src/halTorrent.hpp

    r531 r541  
    148148        int inactivity_timeout; 
    149149        int handshake_timeout; 
     150}; 
     151 
     152struct dht_settings 
     153{ 
     154        dht_settings() : 
     155                max_peers_reply(50), 
     156                search_branching(5), 
     157                service_port(6881), 
     158                max_fail_count(20) 
     159        {} 
     160 
     161        friend class boost::serialization::access; 
     162        template<class Archive> 
     163        void serialize(Archive& ar, const unsigned int version) 
     164        {        
     165                ar & BOOST_SERIALIZATION_NVP(max_peers_reply); 
     166                ar & BOOST_SERIALIZATION_NVP(search_branching); 
     167                ar & BOOST_SERIALIZATION_NVP(service_port); 
     168                ar & BOOST_SERIALIZATION_NVP(max_fail_count); 
     169        } 
     170 
     171        int max_peers_reply; 
     172        int search_branching; 
     173        int service_port; 
     174        int max_fail_count; 
     175}; 
     176 
     177struct pe_settings 
     178{ 
     179        pe_settings() : 
     180                encrypt_level(0), 
     181                prefer_rc4(false), 
     182                conn_in_policy(1), 
     183                conn_out_policy(1) 
     184        {} 
     185 
     186        friend class boost::serialization::access; 
     187        template<class Archive> 
     188        void serialize(Archive& ar, const unsigned int version) 
     189        {        
     190                ar & BOOST_SERIALIZATION_NVP(encrypt_level); 
     191                ar & BOOST_SERIALIZATION_NVP(prefer_rc4); 
     192                ar & BOOST_SERIALIZATION_NVP(conn_in_policy); 
     193                ar & BOOST_SERIALIZATION_NVP(conn_out_policy); 
     194        } 
     195 
     196    int encrypt_level; 
     197    bool prefer_rc4; 
     198    int conn_in_policy; 
     199    int conn_out_policy; 
     200}; 
     201 
     202struct connections 
     203{ 
     204        connections() : 
     205                total(50), 
     206                uploads(10), 
     207                download_rate(-1), 
     208                upload_rate(-1) 
     209        {} 
     210 
     211        friend class boost::serialization::access; 
     212        template<class Archive> 
     213        void serialize(Archive& ar, const unsigned int version) 
     214        {        
     215                ar & BOOST_SERIALIZATION_NVP(total); 
     216                ar & BOOST_SERIALIZATION_NVP(uploads); 
     217                ar & BOOST_SERIALIZATION_NVP(download_rate); 
     218                ar & BOOST_SERIALIZATION_NVP(upload_rate); 
     219        } 
     220 
     221    int total; 
     222    int uploads; 
     223    float download_rate; 
     224    float upload_rate; 
    150225}; 
    151226         
     
    683758        void stop_listening(); 
    684759         
    685         bool ensure_dht_on(); 
     760        bool ensure_dht_on(const dht_settings& dht); 
    686761        void ensure_dht_off(); 
    687762         
    688         void ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4); 
     763        void ensure_pe_on(const pe_settings& pe); 
    689764        void ensure_pe_off(); 
    690765         
     
    703778        void set_session_limits(int maxConn, int maxUpload); 
    704779        void set_session_speed(float download, float upload); 
    705         void set_dht_settings(int max_peers_reply, int search_branching, int service_port, int max_fail_count); 
    706780 
    707781        queue_settings get_queue_settings(); 
     
    713787        const SessionDetail getSessionDetails(); 
    714788 
    715         void setTorrentDefaults(int maxConn, int maxUpload, float download, float upload);       
     789        void set_torrent_defaults(const connections& defaults);  
    716790        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory,  
    717791                bool startPaused=false, bool compactStorage=false,  
Note: See TracChangeset for help on using the changeset viewer.