source: trunk/src/halTorrent.cpp @ 648

Revision 648, 20.1 KB checked in by Eoin, 11 years ago (diff)
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().get_all_peer_details(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().get_all_file_details(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
91bit_impl* bit::pimpl()
92{
93        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer");
94
95        return &*pimpl_;
96}
97
98const bit_impl* bit::pimpl() const
99{
100        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer");
101
102        return &*pimpl_;
103}
104
105void bit::shutdown_session()
106{
107        HAL_DEV_MSG(L"Commence shutdown_session()"); 
108
109        pimpl_.reset();
110
111        HAL_DEV_MSG(L"End shutdown_session()"); 
112}
113
114void bit::save_torrent_data()
115{
116        pimpl()->save_torrent_data();
117}
118
119bool bit::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn)
120{
121        return pimpl()->create_torrent(params, out_file, fn);
122}
123
124bit::torrent bit::get_wstr(const std::wstring& filename)
125{
126        return bit::torrent(pimpl()->the_torrents_.get(filename));
127}
128
129bool bit::listen_on(std::pair<int, int> const& range)
130{
131        return pimpl()->listen_on(range);
132}
133
134int bit::is_listening_on() 
135{
136        return pimpl()->is_listening_on();
137}
138
139void bit::stop_listening()
140{
141        pimpl()->stop_listening();
142}
143
144bool bit::ensure_dht_on(const hal::dht_settings& dht)
145{
146        return pimpl()->ensure_dht_on(dht);
147}
148
149void bit::ensure_dht_off()
150{
151        pimpl()->ensure_dht_off();
152}
153
154void bit::set_mapping(bool upnp, bool nat_pmp)
155{
156        pimpl()->set_mapping(upnp, nat_pmp);
157}
158
159std::wstring bit::upnp_router_model()
160{
161        return pimpl()->upnp_router_model();
162}
163
164queue_settings bit::get_queue_settings()
165{
166        return pimpl()->get_queue_settings();
167}
168
169void bit::set_queue_settings(const queue_settings& s)
170{
171        pimpl()->set_queue_settings(s);
172}
173
174timeouts bit::get_timeouts()
175{
176        return pimpl()->get_timeouts();
177}
178
179void bit::set_timeouts(const timeouts& t)
180{
181        pimpl()->set_timeouts(t);
182}
183
184void bit::set_session_limits(int maxConn, int maxUpload)
185{               
186        pimpl()->set_session_limits(maxConn, maxUpload);
187}
188
189void bit::set_session_speed(float download, float upload)
190{
191        pimpl()->set_session_speed(download, upload);
192}
193
194bool bit::ensure_ip_filter_on(progress_callback fn)
195{
196        return pimpl()->ensure_ip_filter_on(fn);
197}
198
199void bit::ensure_ip_filter_off()
200{
201        pimpl()->ensure_ip_filter_off();
202}
203
204void bit::set_resolve_countries(bool b)
205{
206        pimpl()->set_resolve_countries(b);
207}
208
209void bit::start_smart_ban_plugin()
210{
211        pimpl()->start_smart_ban_plugin();
212}
213
214void bit::start_ut_pex_plugin()
215{
216        pimpl()->start_ut_pex_plugin();
217}
218
219void bit::start_ut_metadata_plugin()
220{
221        pimpl()->start_ut_metadata_plugin();
222}
223
224void bit::start_metadata_plugin()
225{
226        pimpl()->start_metadata_plugin();
227}
228
229#ifndef TORRENT_DISABLE_ENCRYPTION     
230
231void bit::ensure_pe_on(const pe_settings& pe)
232{
233        pimpl()->ensure_pe_on(pe);
234}
235
236void bit::ensure_pe_off()
237{
238        pimpl()->ensure_pe_off();
239}
240#endif
241
242void bit::ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last)
243{
244        pimpl()->ip_filter_.add_rule(first, last, libt::ip_filter::blocked);
245        pimpl()->ip_filter_count();
246        pimpl()->ip_filter_changed_ = true;
247}
248
249void bit::ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last)
250{
251        pimpl()->ip_v6_filter_block(first, last);
252}
253
254size_t bit::ip_filter_size()
255{
256        return pimpl()->ip_filter_size();
257}
258
259void bit::clear_ip_filter()
260{
261        pimpl()->clear_ip_filter();
262}
263
264bool bit::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
265{
266        return pimpl()->ip_filter_import_dat(file, fn, octalFix);
267}
268
269const SessionDetail bit::get_session_details()
270{
271        SessionDetail details;
272       
273        details.port = pimpl()->session_.is_listening() ? pimpl()->session_.listen_port() : -1;
274       
275        libt::session_status status = pimpl()->session_.status();
276       
277        details.speed = std::pair<double, double>(status.download_rate, status.upload_rate);
278       
279        details.dht_on = pimpl()->dht_on_;
280        details.dht_nodes = status.dht_nodes;
281        details.dht_torrents = status.dht_torrents;
282       
283        details.ip_filter_on = pimpl()->ip_filter_on_;
284        details.ip_ranges_filtered = pimpl()->ip_filter_count_;
285       
286        return details;
287}
288
289void bit::set_session_half_open_limit(int halfConn)
290{
291        pimpl()->session_.set_max_half_open_connections(halfConn);
292
293        event_log.post(shared_ptr<EventDetail>(new EventMsg(
294                hal::wform(L"Set half-open connections limit to %1%.") % pimpl()->session_.max_half_open_connections())));
295}
296
297void bit::set_torrent_defaults(const connections& defaults)
298{
299        pimpl()->default_torrent_max_connections_ = defaults.total;
300        pimpl()->default_torrent_max_uploads_ = defaults.uploads;
301
302        event_log.post(shared_ptr<EventDetail>(new EventMsg(
303                hal::wform(L"Set torrent connections total %1% and uploads %2%.") 
304                        % defaults.total % defaults.uploads)));
305
306        pimpl()->default_torrent_download_ = defaults.download_rate;
307        pimpl()->default_torrent_upload_ = defaults.upload_rate;
308
309        event_log.post(shared_ptr<EventDetail>(new EventMsg(
310                hal::wform(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") 
311                        % defaults.download_rate % defaults.upload_rate)));
312}
313
314void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, allocations alloc, 
315                boost::filesystem::wpath moveToDirectory, bool useMoveTo) 
316{
317        pimpl()->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory, useMoveTo);
318}
319
320const torrent_details_manager& bit::torrentDetails()
321{
322        return torrentDetails_;
323}
324
325const torrent_details_manager& bit::updatetorrent_details_manager(const wstring& focused, const std::set<wstring>& selected)
326{
327        try {
328       
329        mutex_t::scoped_lock l(torrentDetails_.mutex_); 
330       
331        torrentDetails_.clearAll(l);   
332        torrentDetails_.torrents_.reserve(pimpl()->the_torrents_.size());
333       
334        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); i != e; ++i)
335        {
336                wstring utf8Name = (*i).torrent->name();
337                torrent_details_ptr pT = (*i).torrent->get_torrent_details_ptr();
338               
339                if (selected.find(utf8Name) != selected.end())
340                {
341                        torrentDetails_.selectedTorrents_.push_back(pT);
342                }
343               
344                if (focused == utf8Name)
345                        torrentDetails_.selectedTorrent_ = pT;
346               
347                torrentDetails_.torrentMap_[(*i).torrent->name()] = pT;
348                torrentDetails_.torrents_.push_back(pT);
349        }
350       
351        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "updatetorrent_details_manager")
352       
353        return torrentDetails_;
354}
355
356void bit::resume_all()
357{
358        pimpl()->resume_all();
359}
360
361void bit::close_all(boost::optional<report_num_active> fn)
362{
363        pimpl()->close_all(fn);
364}
365
366PeerDetail::PeerDetail(libt::peer_info& peerInfo) :
367        ipAddress(hal::from_utf8_safe(peerInfo.ip.address().to_string())),
368        country(L""),
369        speed(std::make_pair(peerInfo.payload_down_speed, peerInfo.payload_up_speed)),
370        client(hal::from_utf8_safe(peerInfo.client))
371{
372        std::vector<wstring> status_vec;
373       
374#ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES
375        if (peerInfo.country[0] != 0 && peerInfo.country[1] != 0)
376                country = (hal::wform(L"(%1%)") % hal::from_utf8_safe(string(peerInfo.country, 2))).str().c_str();
377#endif 
378
379        if (peerInfo.flags & libt::peer_info::handshake)
380        {
381                status_vec.push_back(app().res_wstr(HAL_PEER_HANDSHAKE));
382        }               
383        else if (peerInfo.flags & libt::peer_info::connecting)
384        {
385                status_vec.push_back(app().res_wstr(HAL_PEER_CONNECTING));
386        }
387        else
388        {
389        #ifndef TORRENT_DISABLE_ENCRYPTION             
390                if (peerInfo.flags & libt::peer_info::rc4_encrypted)
391                        status_vec.push_back(app().res_wstr(HAL_PEER_RC4_ENCRYPTED));           
392                if (peerInfo.flags & libt::peer_info::plaintext_encrypted)
393                        status_vec.push_back(app().res_wstr(HAL_PEER_PLAINTEXT_ENCRYPTED));
394        #endif
395               
396                if (peerInfo.flags & libt::peer_info::interesting)
397                        status_vec.push_back(app().res_wstr(HAL_PEER_INTERESTING));     
398                if (peerInfo.flags & libt::peer_info::choked)
399                        status_vec.push_back(app().res_wstr(HAL_PEER_CHOKED)); 
400                if (peerInfo.flags & libt::peer_info::remote_interested)
401                        status_vec.push_back(app().res_wstr(HAL_PEER_REMOTE_INTERESTING));     
402                if (peerInfo.flags & libt::peer_info::remote_choked)
403                        status_vec.push_back(app().res_wstr(HAL_PEER_REMOTE_CHOKED));   
404                if (peerInfo.flags & libt::peer_info::supports_extensions)
405                        status_vec.push_back(app().res_wstr(HAL_PEER_SUPPORT_EXTENSIONS));     
406        //      if (peerInfo.flags & libt::peer_info::local_connection)                                         // Not sure whats up here?
407        //              status_vec.push_back(app().res_wstr(HAL_PEER_LOCAL_CONNECTION));                       
408                if (peerInfo.flags & libt::peer_info::queued)
409                        status_vec.push_back(app().res_wstr(HAL_PEER_QUEUED));
410        }
411       
412        seed = (peerInfo.flags & libt::peer_info::seed) ? true : false;
413       
414        if (!status_vec.empty()) status = status_vec[0];
415       
416        if (status_vec.size() > 1)
417        {
418                for (size_t i=1; i<status_vec.size(); ++i)
419                {
420                        status += L"; ";
421                        status += status_vec[i];
422                }
423        }       
424}
425
426const cache_details bit::get_cache_details() const
427{
428        return pimpl()->get_cache_details();
429}
430
431void bit::get_all_peer_details(const std::string& filename, PeerDetails& peerContainer)
432{
433        get_all_peer_details(from_utf8_safe(filename), peerContainer);
434}
435
436void bit::get_all_peer_details(const std::wstring& filename, PeerDetails& peerContainer)
437{
438        try {
439       
440        pimpl()->the_torrents_.get(filename)->get_peer_details(peerContainer);
441       
442        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_peer_details")
443}
444
445void bit::get_all_file_details(const std::string& filename, FileDetails& fileDetails)
446{
447        get_all_file_details(from_utf8_safe(filename), fileDetails);
448}
449
450void bit::get_all_file_details(const std::wstring& filename, FileDetails& fileDetails)
451{
452        try {
453       
454        pimpl()->the_torrents_.get(filename)->get_file_details(fileDetails);
455       
456        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_file_details")
457}
458
459bool bit::is_torrent(const std::string& filename)
460{       
461        return is_torrent(hal::to_wstr_shim(filename));
462}
463
464bool bit::is_torrent(const std::wstring& filename)
465{       
466        try {
467       
468        return pimpl()->the_torrents_.exists(filename);
469       
470        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrent")
471       
472        return false;
473}
474
475void bit::pause_torrent(const std::string& filename)
476{
477        pause_torrent(hal::to_wstr_shim(filename));
478}
479
480void bit::pause_torrent(const std::wstring& filename)
481{
482        try {
483       
484        pimpl()->the_torrents_.get(filename)->pause();
485       
486        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pauseTorrent")
487}
488
489void bit::resume_torrent(const std::string& filename)
490{
491        resume_torrent(hal::to_wstr_shim(filename));
492}
493
494void bit::resume_torrent(const std::wstring& filename)
495{
496        try {
497       
498        pimpl()->the_torrents_.get(filename)->resume();
499       
500        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resumeTorrent")
501}
502
503void bit::stop_torrent(const std::string& filename)
504{
505        stop_torrent(hal::to_wstr_shim(filename));
506}
507
508void bit::stop_torrent(const std::wstring& filename)
509{
510        try {
511       
512        pimpl()->the_torrents_.get(filename)->stop();
513       
514        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stopTorrent")
515}
516
517bool bit::is_torrent_active(const std::string& filename)
518{
519        return is_torrent_active(hal::to_wstr_shim(filename));
520}
521
522bool bit::is_torrent_active(const std::wstring& filename)
523{
524        try {
525       
526        return pimpl()->the_torrents_.get(filename)->is_active();
527       
528        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrentActive")
529       
530        return false; // ??? is this correct
531}
532
533void bit::reannounce_torrent(const std::string& filename)
534{
535        reannounce_torrent(hal::to_wstr_shim(filename));
536}
537
538void bit::reannounce_torrent(const std::wstring& filename)
539{
540        try {
541       
542        pimpl()->the_torrents_.get(filename)->handle().force_reannounce();
543       
544        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounceTorrent")
545}
546
547
548void bit::recheck_torrent(const std::string& filename)
549{
550        recheck_torrent(hal::to_wstr_shim(filename));
551}
552
553void bit::recheck_torrent(const std::wstring& filename)
554{
555        try {
556       
557        pimpl()->the_torrents_.get(filename)->force_recheck();
558       
559        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheckTorrent")
560}
561
562void bit::remove_torrent_wstr(const std::wstring& filename)
563{
564        pimpl()->remove_torrent(filename);
565}
566
567void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename)
568{
569        pimpl()->remove_torrent_wipe_files(hal::to_wstr_shim(filename));
570}
571
572void bit::pause_all_torrents()
573{       
574        try {
575       
576        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
577                i != e; ++i)
578        {               
579                if ((*i).torrent->in_session())
580                        (*i).torrent->pause();
581        }
582       
583        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "pauseAllTorrents")
584}
585
586void bit::unpause_all_torrents()
587{       
588        try {
589       
590        for (TorrentManager::torrentByName::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
591                i != e; ++i)
592        {
593                if ((*i).torrent->in_session() && (*i).torrent->get_state() == torrent_details::torrent_paused)
594                        (*i).torrent->resume();
595        }
596       
597        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "unpauseAllTorrents")
598}
599
600bit::torrent::torrent()
601{}
602
603bit::torrent::torrent(boost::shared_ptr<torrent_internal> p) :
604        ptr(p)
605{}
606
607bool bit::torrent::is_open() const
608{
609        return ptr;
610}
611
612bit::torrent::exec_around_ptr::proxy::proxy(torrent_internal* t) : 
613        t_(t),
614        l_(t->mutex_)
615{
616//      HAL_DEV_MSG(L"Ctor proxy");
617}
618
619bit::torrent::exec_around_ptr::proxy::~proxy() 
620{
621//      HAL_DEV_MSG(L"Dtor proxy");
622}
623
624const std::wstring bit::torrent::get_name() const
625{
626        try {
627       
628        return ptr->name();
629       
630        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Torrent Unknown", "torrent::get_name()")
631       
632        return 0;
633}
634
635float bit::torrent::get_ratio() const
636{
637        try {
638       
639        return ptr->get_ratio();
640       
641        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_ratio")
642       
643        return 0;
644}
645
646void bit::torrent::set_ratio(float r)
647{
648        try {
649
650        ptr->set_ratio(r);
651       
652        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_ratio")
653}
654
655std::pair<int, int> bit::torrent::get_connection_limits() const
656{
657        try {
658       
659        return ptr->get_connection_limit();
660       
661        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_connection_limits")
662       
663        return std::make_pair(-1, -1);
664}
665
666void bit::torrent::set_connection_limits(const std::pair<int, int>& l)
667{
668        try {
669       
670        ptr->set_connection_limit(l.first, l.second);
671       
672        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_connection_limits")
673}
674
675std::pair<float, float> bit::torrent::get_rate_limits() const
676{
677        try {
678       
679        return ptr->get_transfer_speed();
680       
681        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_rate_limits")
682       
683        return std::pair<float, float>(-1.0, -1.0);
684}
685
686void bit::torrent::set_rate_limits(const std::pair<float, float>& l)
687{
688        try {
689       
690        ptr->set_transfer_speed(l.first, l.second);
691       
692        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_rate_limits")
693}
694
695wpath bit::torrent::get_save_directory() const
696{
697        try {
698       
699        return ptr->get_save_directory();
700       
701        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
702       
703        return L"";
704}
705
706void bit::torrent::set_save_directory(const wpath& s)
707{
708        try {
709       
710        ptr->set_save_directory(s);
711       
712        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_save_directory")
713}
714
715wpath bit::torrent::get_move_to_directory() const
716{
717        try {
718       
719        return ptr->get_move_to_directory();
720       
721        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
722       
723        return L"";
724}
725
726void bit::torrent::set_move_to_directory(const wpath& m)
727{
728        try {
729       
730        ptr->set_move_to_directory(m);
731       
732        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_move_to_directory")
733}
734
735std::pair<wstring, wstring> bit::torrent::get_tracker_login() const
736{
737        try {
738       
739        return ptr->get_tracker_login();
740       
741        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("get_tracker_login")
742       
743        return std::make_pair(L"!!! exception thrown !!!", L"!!! exception thrown !!!");
744}
745
746void bit::torrent::set_tracker_login(const std::pair<wstring, wstring>& p)
747{
748        try {
749       
750        ptr->set_tracker_login(p.first, p.second);
751       
752        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_tracker_login")
753}
754
755bool bit::torrent::get_is_active() const
756{
757        try {
758       
759        return ptr->is_active();
760       
761        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_is_active")
762       
763        return L"";
764}
765
766bool bit::torrent::get_in_session() const
767{
768        try {
769       
770        return ptr->in_session();
771       
772        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_in_session")
773       
774        return L"";
775}
776
777std::vector<tracker_detail> bit::torrent::get_trackers() const
778{
779        try {
780       
781        return ptr->get_trackers();
782       
783        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_trackers")
784       
785        return std::vector<tracker_detail>();
786}
787
788void bit::torrent::set_trackers(const std::vector<tracker_detail>& trackers)
789{
790        try {
791       
792        ptr->set_trackers(trackers);
793       
794        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
795}
796
797void bit::torrent::reset_trackers()
798{
799        try {
800       
801        ptr->reset_trackers();
802       
803        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
804}
805
806void bit::torrent::set_file_priorities(const std::pair<std::vector<int>, int>& p)
807{
808        try { 
809
810        ptr->set_file_priorities(p.first, p.second);
811       
812        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
813}
814
815void bit::torrent::adjust_queue_position(bit::queue_adjustments adjust)
816{
817        try { 
818
819        ptr->adjust_queue_position(adjust);
820       
821        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::adjust_queue_position")
822}
823
824bool bit::torrent::get_managed() const
825{
826        try {
827       
828        return ptr->is_managed();
829       
830        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_managed")
831       
832        return false;
833}
834
835void bit::torrent::set_managed(bool m)
836{
837        try {
838       
839        ptr->set_managed(m);
840       
841        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_managed")
842}
843
844void bit::start_event_receiver()
845{
846        try {
847
848        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting event handler.")));
849
850        pimpl()->start_alert_handler();
851       
852        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::start_event_receiver()")
853}
854
855void bit::stop_event_receiver()
856{
857        try {
858
859        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event handler.")));
860
861        pimpl()->stop_alert_handler();
862       
863        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::stop_event_receiver()")
864}
865
866int bit::default_torrent_max_connections() { return pimpl()->default_torrent_max_connections_; }
867int bit::default_torrent_max_uploads() { return pimpl()->default_torrent_max_uploads_; }
868float bit::default_torrent_download() { return pimpl()->default_torrent_download_; }
869float bit::default_torrent_upload() { return pimpl()->default_torrent_upload_; }
870       
871};
Note: See TracBrowser for help on using the repository browser.