source: trunk/src/halTorrent.cpp @ 541

Revision 541, 19.4 KB checked in by Eoin, 11 years ago (diff)

Updating halConfig serialization.

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