source: trunk/src/halTorrent.cpp @ 614

Revision 614, 18.3 KB checked in by Eoin, 11 years ago (diff)

ListView? grouping works. But a lacking on the API side means it's incompatible with sorting!

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2008.
3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
7#include "stdAfx.hpp"
8
9#include "global/wtl_app.hpp"
10#include "global/string_conv.hpp"
11#include "global/ini_adapter.hpp"
12
13#include "halTorrent.hpp"
14#include "halTypes.hpp"
15#include "halEvent.hpp"
16#include "halSignaler.hpp"
17
18#include "halTorrentInternal.hpp"
19#include "halSession.hpp"
20//#include "halSessionAlert.hpp"
21
22namespace hal
23{
24        libtorrent::session* torrent_internal::the_session_ = 0;
25}
26
27namespace hal
28{
29
30bit& bittorrent()
31{
32        static bit t;
33        return t;
34}
35
36const PeerDetails& torrent_details::peerDetails() const
37{
38        if (!peerDetailsFilled_)
39        {
40                bittorrent().getAllPeerDetails(hal::to_utf8(name_), peerDetails_);
41                peerDetailsFilled_ = true;
42        }
43       
44        return peerDetails_;
45}
46
47const FileDetails& torrent_details::fileDetails() const
48{
49        if (!fileDetailsFilled_)
50        {
51                bittorrent().getAllFileDetails(hal::to_utf8(name_), fileDetails_);
52                fileDetailsFilled_ = true;
53        }
54       
55        return fileDetails_;
56}
57
58bool nameLess(const torrent_details_ptr& left, const torrent_details_ptr& right)
59{
60        return left->state() < right->state();
61}
62
63void torrent_details_manager::sort(
64        boost::function<bool (const torrent_details_ptr&, const torrent_details_ptr&)> fn) const
65{
66        std::stable_sort(torrents_.begin(), torrents_.end(), fn);
67}
68
69web_seed_or_dht_node_detail::web_seed_or_dht_node_detail() : 
70        url(L""), 
71        port(-1), 
72        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_WEB)) 
73{}
74
75web_seed_or_dht_node_detail::web_seed_or_dht_node_detail(std::wstring u) : 
76        url(u), 
77        port(-1), 
78        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_WEB)) 
79{}
80
81web_seed_or_dht_node_detail::web_seed_or_dht_node_detail(std::wstring u, int p) : 
82        url(u), 
83        port(p), 
84        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_DHT)) 
85{}
86
87bit::bit() :
88        pimpl(new bit_impl())
89{}
90
91void bit::shutDownSession()
92{
93        HAL_DEV_MSG(L"Commence shutDownSession()"); 
94
95        pimpl.reset();
96
97        HAL_DEV_MSG(L"End shutDownSession()"); 
98}
99
100void bit::save_torrent_data()
101{
102        pimpl->save_torrent_data();
103}
104
105bool bit::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn)
106{
107        return pimpl->create_torrent(params, out_file, fn);
108}
109
110bit::torrent bit::get_wstr(const std::wstring& filename)
111{
112        return bit::torrent(pimpl->the_torrents_.get(filename));
113}
114
115bool bit::listen_on(std::pair<int, int> const& range)
116{
117        return pimpl->listen_on(range);
118}
119
120int bit::is_listening_on() 
121{
122        return pimpl->is_listening_on();
123}
124
125void bit::stop_listening()
126{
127        pimpl->stop_listening();
128}
129
130bool bit::ensure_dht_on(const hal::dht_settings& dht)
131{
132        return pimpl->ensure_dht_on(dht);
133}
134
135void bit::ensure_dht_off()
136{
137        pimpl->ensure_dht_off();
138}
139
140void bit::set_mapping(bool upnp, bool nat_pmp)
141{
142        pimpl->set_mapping(upnp, nat_pmp);
143}
144
145queue_settings bit::get_queue_settings()
146{
147        return pimpl->get_queue_settings();
148}
149
150void bit::set_queue_settings(const queue_settings& s)
151{
152        pimpl->set_queue_settings(s);
153}
154
155timeouts bit::get_timeouts()
156{
157        return pimpl->get_timeouts();
158}
159
160void bit::set_timeouts(const timeouts& t)
161{
162        pimpl->set_timeouts(t);
163}
164
165void bit::set_session_limits(int maxConn, int maxUpload)
166{               
167        pimpl->set_session_limits(maxConn, maxUpload);
168}
169
170void bit::set_session_speed(float download, float upload)
171{
172        pimpl->set_session_speed(download, upload);
173}
174
175bool bit::ensure_ip_filter_on(progress_callback fn)
176{
177        return pimpl->ensure_ip_filter_on(fn);
178}
179
180void bit::ensure_ip_filter_off()
181{
182        pimpl->ensure_ip_filter_off();
183}
184
185#ifndef TORRENT_DISABLE_ENCRYPTION     
186
187void bit::ensure_pe_on(const pe_settings& pe)
188{
189        pimpl->ensure_pe_on(pe);
190}
191
192void bit::ensure_pe_off()
193{
194        pimpl->ensure_pe_off();
195}
196#endif
197
198void bit::ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last)
199{
200        pimpl->ip_filter_.add_rule(first, last, libt::ip_filter::blocked);
201        pimpl->ip_filter_count();
202        pimpl->ip_filter_changed_ = true;
203}
204
205void bit::ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last)
206{
207        pimpl->ip_v6_filter_block(first, last);
208}
209
210size_t bit::ip_filter_size()
211{
212        return pimpl->ip_filter_size();
213}
214
215void bit::clear_ip_filter()
216{
217        pimpl->clear_ip_filter();
218}
219
220bool bit::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
221{
222        return pimpl->ip_filter_import_dat(file, fn, octalFix);
223}
224
225const SessionDetail bit::getSessionDetails()
226{
227        SessionDetail details;
228       
229        details.port = pimpl->session_.is_listening() ? pimpl->session_.listen_port() : -1;
230       
231        libt::session_status status = pimpl->session_.status();
232       
233        details.speed = std::pair<double, double>(status.download_rate, status.upload_rate);
234       
235        details.dht_on = pimpl->dht_on_;
236        details.dht_nodes = status.dht_nodes;
237        details.dht_torrents = status.dht_torrents;
238       
239        details.ip_filter_on = pimpl->ip_filter_on_;
240        details.ip_ranges_filtered = pimpl->ip_filter_count_;
241       
242        return details;
243}
244
245void bit::setSessionHalfOpenLimit(int halfConn)
246{
247        pimpl->session_.set_max_half_open_connections(halfConn);
248
249        event_log.post(shared_ptr<EventDetail>(new EventMsg(
250                hal::wform(L"Set half-open connections limit to %1%.") % pimpl->session_.max_half_open_connections())));
251}
252
253void bit::set_torrent_defaults(const connections& defaults)
254{
255        pimpl->defTorrentMaxConn_ = defaults.total;
256        pimpl->defTorrentMaxUpload_ = defaults.uploads;
257
258        event_log.post(shared_ptr<EventDetail>(new EventMsg(
259                hal::wform(L"Set torrent connections total %1% and uploads %2%.") 
260                        % defaults.total % defaults.uploads)));
261
262        pimpl->defTorrentDownload_ = defaults.download_rate;
263        pimpl->defTorrentUpload_ = defaults.upload_rate;
264
265        event_log.post(shared_ptr<EventDetail>(new EventMsg(
266                hal::wform(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") 
267                        % defaults.download_rate % defaults.upload_rate)));
268}
269
270void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, allocations alloc, 
271                boost::filesystem::wpath moveToDirectory, bool useMoveTo) 
272{
273        pimpl->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory, useMoveTo);
274}
275
276const torrent_details_manager& bit::torrentDetails()
277{
278        return torrentDetails_;
279}
280
281const torrent_details_manager& bit::updatetorrent_details_manager(const wstring& focused, const std::set<wstring>& selected)
282{
283        try {
284       
285        mutex_t::scoped_lock l(torrentDetails_.mutex_); 
286       
287        torrentDetails_.clearAll(l);   
288        torrentDetails_.torrents_.reserve(pimpl->the_torrents_.size());
289       
290        for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end(); i != e; ++i)
291        {
292                wstring utf8Name = (*i).torrent->name();
293                torrent_details_ptr pT = (*i).torrent->gettorrent_details_ptr();
294               
295                if (selected.find(utf8Name) != selected.end())
296                {
297                        torrentDetails_.selectedTorrents_.push_back(pT);
298                }
299               
300                if (focused == utf8Name)
301                        torrentDetails_.selectedTorrent_ = pT;
302               
303                torrentDetails_.torrentMap_[(*i).torrent->name()] = pT;
304                torrentDetails_.torrents_.push_back(pT);
305        }
306       
307        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "updatetorrent_details_manager")
308       
309        return torrentDetails_;
310}
311
312void bit::resume_all()
313{
314        pimpl->resume_all();
315}
316
317void bit::close_all(boost::optional<report_num_active> fn)
318{
319        pimpl->close_all(fn);
320}
321
322PeerDetail::PeerDetail(libt::peer_info& peerInfo) :
323        ipAddress(hal::from_utf8_safe(peerInfo.ip.address().to_string())),
324        country(L""),
325        speed(std::make_pair(peerInfo.payload_down_speed, peerInfo.payload_up_speed)),
326        client(hal::from_utf8_safe(peerInfo.client))
327{
328        std::vector<wstring> status_vec;
329       
330#ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES
331        if (peerInfo.country[0] != 0 && peerInfo.country[1] != 0)
332                country = (hal::wform(L"(%1%)") % hal::from_utf8_safe(string(peerInfo.country, 2))).str().c_str();
333#endif 
334
335        if (peerInfo.flags & libt::peer_info::handshake)
336        {
337                status_vec.push_back(app().res_wstr(HAL_PEER_HANDSHAKE));
338        }               
339        else if (peerInfo.flags & libt::peer_info::connecting)
340        {
341                status_vec.push_back(app().res_wstr(HAL_PEER_CONNECTING));
342        }
343        else
344        {
345        #ifndef TORRENT_DISABLE_ENCRYPTION             
346                if (peerInfo.flags & libt::peer_info::rc4_encrypted)
347                        status_vec.push_back(app().res_wstr(HAL_PEER_RC4_ENCRYPTED));           
348                if (peerInfo.flags & libt::peer_info::plaintext_encrypted)
349                        status_vec.push_back(app().res_wstr(HAL_PEER_PLAINTEXT_ENCRYPTED));
350        #endif
351               
352                if (peerInfo.flags & libt::peer_info::interesting)
353                        status_vec.push_back(app().res_wstr(HAL_PEER_INTERESTING));     
354                if (peerInfo.flags & libt::peer_info::choked)
355                        status_vec.push_back(app().res_wstr(HAL_PEER_CHOKED)); 
356                if (peerInfo.flags & libt::peer_info::remote_interested)
357                        status_vec.push_back(app().res_wstr(HAL_PEER_REMOTE_INTERESTING));     
358                if (peerInfo.flags & libt::peer_info::remote_choked)
359                        status_vec.push_back(app().res_wstr(HAL_PEER_REMOTE_CHOKED));   
360                if (peerInfo.flags & libt::peer_info::supports_extensions)
361                        status_vec.push_back(app().res_wstr(HAL_PEER_SUPPORT_EXTENSIONS));     
362        //      if (peerInfo.flags & libt::peer_info::local_connection)                                         // Not sure whats up here?
363        //              status_vec.push_back(app().res_wstr(HAL_PEER_LOCAL_CONNECTION));                       
364                if (peerInfo.flags & libt::peer_info::queued)
365                        status_vec.push_back(app().res_wstr(HAL_PEER_QUEUED));
366        }
367       
368        seed = (peerInfo.flags & libt::peer_info::seed) ? true : false;
369       
370        if (!status_vec.empty()) status = status_vec[0];
371       
372        if (status_vec.size() > 1)
373        {
374                for (size_t i=1; i<status_vec.size(); ++i)
375                {
376                        status += L"; ";
377                        status += status_vec[i];
378                }
379        }       
380}
381
382void bit::getAllPeerDetails(const std::string& filename, PeerDetails& peerContainer)
383{
384        getAllPeerDetails(from_utf8_safe(filename), peerContainer);
385}
386
387void bit::getAllPeerDetails(const std::wstring& filename, PeerDetails& peerContainer)
388{
389        try {
390       
391        pimpl->the_torrents_.get(filename)->getPeerDetails(peerContainer);
392       
393        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllPeerDetails")
394}
395
396void bit::getAllFileDetails(const std::string& filename, FileDetails& fileDetails)
397{
398        getAllFileDetails(from_utf8_safe(filename), fileDetails);
399}
400
401void bit::getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails)
402{
403        try {
404       
405        pimpl->the_torrents_.get(filename)->getFileDetails(fileDetails);
406       
407        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllFileDetails")
408}
409
410bool bit::isTorrent(const std::string& filename)
411{       
412        return isTorrent(hal::to_wstr_shim(filename));
413}
414
415bool bit::isTorrent(const std::wstring& filename)
416{       
417        try {
418       
419        return pimpl->the_torrents_.exists(filename);
420       
421        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrent")
422       
423        return false;
424}
425
426void bit::pauseTorrent(const std::string& filename)
427{
428        pauseTorrent(hal::to_wstr_shim(filename));
429}
430
431void bit::pauseTorrent(const std::wstring& filename)
432{
433        try {
434       
435        pimpl->the_torrents_.get(filename)->pause();
436       
437        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pauseTorrent")
438}
439
440void bit::resumeTorrent(const std::string& filename)
441{
442        resumeTorrent(hal::to_wstr_shim(filename));
443}
444
445void bit::resumeTorrent(const std::wstring& filename)
446{
447        try {
448       
449        pimpl->the_torrents_.get(filename)->resume();
450       
451        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resumeTorrent")
452}
453
454void bit::stopTorrent(const std::string& filename)
455{
456        stopTorrent(hal::to_wstr_shim(filename));
457}
458
459void bit::stopTorrent(const std::wstring& filename)
460{
461        try {
462       
463        pimpl->the_torrents_.get(filename)->stop();
464       
465        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stopTorrent")
466}
467
468bool bit::isTorrentActive(const std::string& filename)
469{
470        return isTorrentActive(hal::to_wstr_shim(filename));
471}
472
473bool bit::isTorrentActive(const std::wstring& filename)
474{
475        try {
476       
477        return pimpl->the_torrents_.get(filename)->is_active();
478       
479        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrentActive")
480       
481        return false; // ??? is this correct
482}
483
484void bit::reannounceTorrent(const std::string& filename)
485{
486        reannounceTorrent(hal::to_wstr_shim(filename));
487}
488
489void bit::reannounceTorrent(const std::wstring& filename)
490{
491        try {
492       
493        pimpl->the_torrents_.get(filename)->handle().force_reannounce();
494       
495        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounceTorrent")
496}
497
498
499void bit::recheckTorrent(const std::string& filename)
500{
501        recheckTorrent(hal::to_wstr_shim(filename));
502}
503
504void bit::recheckTorrent(const std::wstring& filename)
505{
506        try {
507       
508        pimpl->the_torrents_.get(filename)->force_recheck();
509       
510        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheckTorrent")
511}
512
513void bit::remove_torrent_wstr(const std::wstring& filename)
514{
515        pimpl->remove_torrent(filename);
516}
517
518void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename)
519{
520        pimpl->remove_torrent_wipe_files(hal::to_wstr_shim(filename));
521}
522
523void bit::pauseAllTorrents()
524{       
525        try {
526       
527        for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end();
528                i != e; ++i)
529        {               
530                if ((*i).torrent->in_session())
531                        (*i).torrent->pause();
532        }
533       
534        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "pauseAllTorrents")
535}
536
537void bit::unpauseAllTorrents()
538{       
539        try {
540       
541        for (TorrentManager::torrentByName::iterator i=pimpl->the_torrents_.begin(), e=pimpl->the_torrents_.end();
542                i != e; ++i)
543        {
544                if ((*i).torrent->in_session() && (*i).torrent->state() == torrent_details::torrent_paused)
545                        (*i).torrent->resume();
546        }
547       
548        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "unpauseAllTorrents")
549}
550
551bit::torrent::torrent()
552{}
553
554bit::torrent::torrent(boost::shared_ptr<torrent_internal> p) :
555        ptr(p)
556{}
557
558bool bit::torrent::is_open() const
559{
560        return ptr;
561}
562
563bit::torrent::exec_around_ptr::proxy::proxy(torrent_internal* t) : 
564        t_(t),
565        l_(t->mutex_)
566{
567//      HAL_DEV_MSG(L"Ctor proxy");
568}
569
570bit::torrent::exec_around_ptr::proxy::~proxy() 
571{
572//      HAL_DEV_MSG(L"Dtor proxy");
573}
574
575const std::wstring bit::torrent::get_name() const
576{
577        try {
578       
579        return ptr->name();
580       
581        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Torrent Unknown", "torrent::get_name()")
582       
583        return 0;
584}
585
586float bit::torrent::get_ratio() const
587{
588        try {
589       
590        return ptr->get_ratio();
591       
592        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_ratio")
593       
594        return 0;
595}
596
597void bit::torrent::set_ratio(float r)
598{
599        try {
600
601        ptr->set_ratio(r);
602       
603        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_ratio")
604}
605
606std::pair<int, int> bit::torrent::get_connection_limits() const
607{
608        try {
609       
610        return ptr->getConnectionLimit();
611       
612        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_connection_limits")
613       
614        return std::make_pair(-1, -1);
615}
616
617void bit::torrent::set_connection_limits(const std::pair<int, int>& l)
618{
619        try {
620       
621        ptr->setConnectionLimit(l.first, l.second);
622       
623        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_connection_limits")
624}
625
626std::pair<float, float> bit::torrent::get_rate_limits() const
627{
628        try {
629       
630        return ptr->getTransferSpeed();
631       
632        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_rate_limits")
633       
634        return std::pair<float, float>(-1.0, -1.0);
635}
636
637void bit::torrent::set_rate_limits(const std::pair<float, float>& l)
638{
639        try {
640       
641        ptr->setTransferSpeed(l.first, l.second);
642       
643        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_rate_limits")
644}
645
646wpath bit::torrent::get_save_directory() const
647{
648        try {
649       
650        return ptr->get_save_directory();
651       
652        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
653       
654        return L"";
655}
656
657void bit::torrent::set_save_directory(const wpath& s)
658{
659        try {
660       
661        ptr->set_save_directory(s);
662       
663        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_save_directory")
664}
665
666wpath bit::torrent::get_move_to_directory() const
667{
668        try {
669       
670        return ptr->get_move_to_directory();
671       
672        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
673       
674        return L"";
675}
676
677void bit::torrent::set_move_to_directory(const wpath& m)
678{
679        try {
680       
681        ptr->set_move_to_directory(m);
682       
683        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_move_to_directory")
684}
685
686std::pair<wstring, wstring> bit::torrent::get_tracker_login() const
687{
688        try {
689       
690        return ptr->getTrackerLogin();
691       
692        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("get_tracker_login")
693       
694        return std::make_pair(L"!!! exception thrown !!!", L"!!! exception thrown !!!");
695}
696
697void bit::torrent::set_tracker_login(const std::pair<wstring, wstring>& p)
698{
699        try {
700       
701        ptr->setTrackerLogin(p.first, p.second);
702       
703        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_tracker_login")
704}
705
706bool bit::torrent::get_is_active() const
707{
708        try {
709       
710        return ptr->is_active();
711       
712        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_is_active")
713       
714        return L"";
715}
716
717bool bit::torrent::get_in_session() const
718{
719        try {
720       
721        return ptr->in_session();
722       
723        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_in_session")
724       
725        return L"";
726}
727
728std::vector<tracker_detail> bit::torrent::get_trackers() const
729{
730        try {
731       
732        return ptr->getTrackers();
733       
734        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_trackers")
735       
736        return std::vector<tracker_detail>();
737}
738
739void bit::torrent::set_trackers(const std::vector<tracker_detail>& trackers)
740{
741        try {
742       
743        ptr->setTrackers(trackers);
744       
745        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
746}
747
748void bit::torrent::reset_trackers()
749{
750        try {
751       
752        ptr->resetTrackers();
753       
754        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
755}
756
757void bit::torrent::set_file_priorities(const std::pair<std::vector<int>, int>& p)
758{
759        try { 
760
761        ptr->setFilePriorities(p.first, p.second);
762       
763        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
764}
765
766void bit::startEventReceiver()
767{
768        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting event handler.")));
769
770        pimpl->start_alert_handler();
771}
772
773void bit::stopEventReceiver()
774{
775        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event handler.")));
776
777        pimpl->stop_alert_handler();
778}
779
780int bit::defTorrentMaxConn() { return pimpl->defTorrentMaxConn_; }
781int bit::defTorrentMaxUpload() { return pimpl->defTorrentMaxUpload_; }
782float bit::defTorrentDownload() { return pimpl->defTorrentDownload_; }
783float bit::defTorrentUpload() { return pimpl->defTorrentUpload_; }
784       
785};
Note: See TracBrowser for help on using the repository browser.