source: trunk/src/halTorrent.cpp @ 482

Revision 482, 19.3 KB checked in by Eoin, 12 years ago (diff)

... not yet it doesn't!

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