source: trunk/src/halTorrent.cpp @ 642

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