source: trunk/src/halTorrent.cpp @ 714

Revision 714, 25.2 KB checked in by Eoin, 11 years ago (diff)
Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2009.
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#include <functional>
9
10#include "global/wtl_app.hpp"
11#include "global/string_conv.hpp"
12#include "global/ini_adapter.hpp"
13
14#include "halTorrent.hpp"
15#include "halTypes.hpp"
16#include "halEvent.hpp"
17#include "halSignaler.hpp"
18
19#include "halTorrentInternal.hpp"
20#include "halSession.hpp"
21#include "halConfig.hpp"
22
23namespace hal
24{
25        libtorrent::session* torrent_internal::the_session_ = 0;
26}
27
28namespace hal
29{
30
31bit& bittorrent()
32{
33        static bit t;
34        return t;
35}
36
37bool file_details::less(const file_details& r, size_t index) const
38{       
39        switch (index)
40        {
41        case branch_e: return branch < r.branch;
42        case filename_e: return filename < r.filename;
43
44        case type_e: return type < r.type;
45        case size_e: return size < r.size;
46
47        case progress_e: return (static_cast<double>(progress)/size) < (static_cast<double>(r.progress)/r.size);
48        case priority_e: return priority < r.priority;
49
50        default: return false; // ???
51        };
52}
53
54std::wstring file_details::to_wstring(size_t index)
55{
56        switch (index)
57        {
58        case branch_e: return branch.string();
59        case filename_e: return filename;
60
61        case type_e: return L"(Undefined)"; // ???
62
63        case size_e: return (wform(L"%1$.2fMB") % (static_cast<double>(size)/(1024*1024))).str();
64        case progress_e: return (wform(L"%1$.2f%%") % (static_cast<double>(progress)/size*100)).str(); 
65
66        case priority_e:               
67                {
68                        switch (priority)
69                        {
70                        case 0:
71                                return hal::app().res_wstr(HAL_FILE_PRIORITY_0);
72                        case 1:
73                                return hal::app().res_wstr(HAL_FILE_PRIORITY_1);
74                        case 2:
75                                return hal::app().res_wstr(HAL_FILE_PRIORITY_2);
76                        case 3:
77                                return hal::app().res_wstr(HAL_FILE_PRIORITY_3);
78                        case 4:
79                                return hal::app().res_wstr(HAL_FILE_PRIORITY_4);
80                        case 5:
81                                return hal::app().res_wstr(HAL_FILE_PRIORITY_5);
82                        case 6:
83                                return hal::app().res_wstr(HAL_FILE_PRIORITY_6);
84                        case 7:
85                                return hal::app().res_wstr(HAL_FILE_PRIORITY_7);
86                        default:
87                                return hal::app().res_wstr(HAL_FILE_PRIORITY_0);
88                        };
89                } 
90
91        default: return L"(Undefined)"; // ???
92        };
93}
94
95void file_details_sort(file_details_vec& p, size_t index, bool cmp_less)
96{
97        std::stable_sort(p.begin(), p.end(), 
98                bind(&hal_details_compare<const file_details&>, _1, _2, index, cmp_less));
99}
100
101const peer_details_vec& torrent_details::get_peer_details() const
102{
103        if (!peer_details_filled_)
104        {
105                bittorrent().get_all_peer_details(hal::to_utf8(name_), peer_details_);
106                peer_details_filled_ = true;
107        }
108       
109        return peer_details_;
110}
111
112const file_details_vec& torrent_details::get_file_details() const
113{
114        if (!file_details_filled_)
115        {
116                bittorrent().get_all_file_details(hal::to_utf8(name_), file_details_);
117                file_details_filled_ = true;
118        }
119       
120        return file_details_;
121}
122
123bool torrent_details::less(const torrent_details& r, size_t index) const
124{
125        switch (index)
126        {
127        case name_e: return name_ < r.name_;
128        case state_e: return state_ < r.state_;
129
130        case speed_down_e: return speed_.first < r.speed_.first;
131        case speed_up_e: return speed_.second < r.speed_.second;
132        case progress_e: return completion_ < r.completion_;
133        case distributed_copies_e: return distributed_copies_ < r.distributed_copies_;
134
135        case remaining_e: 
136                {
137                boost::int64_t left = total_wanted_-total_wanted_done_;
138                boost::int64_t right = r.total_wanted_-r.total_wanted_done_;
139
140                return left < right;
141                }
142
143        case total_wanted_e: return total_wanted_ < r.total_wanted_;
144        case completed_e: return total_wanted_done_ < r.total_wanted_done_; 
145
146        case uploaded_e: return total_payload_uploaded_ < r.total_payload_uploaded_;
147        case downloaded_e: return total_payload_downloaded_ < r.total_payload_downloaded_;
148
149        case peers_e: return peers_ < r.peers_;
150        case seeds_e: return seeds_ < r.seeds_;
151
152        case ratio_e: 
153                {
154                float left = (total_payload_downloaded_) 
155                                ? static_cast<float>(total_payload_uploaded_)
156                                        / static_cast<float>(total_payload_downloaded_)
157                                : 0;
158               
159                float right = (r.total_payload_downloaded_) 
160                                ? static_cast<float>(r.total_payload_uploaded_)
161                                        / static_cast<float>(r.total_payload_downloaded_)
162                                : 0;
163               
164                return left < right; 
165                }
166
167        case eta_e: return estimated_time_left_ < r.estimated_time_left_;
168        case tracker: return currentTracker_ < r.currentTracker_;
169        case update_tracker_in_e: return update_tracker_in_ < r.update_tracker_in_;
170
171        case active_time_e: return active_ < r.active_;
172        case seeding_time_e: return seeding_ < r.seeding_;
173        case start_time_e: return start_time_ < r.start_time_;
174        case finish_time_e: return finish_time_ < r.finish_time_;
175
176        case queue_position_e: return queue_position_ < r.queue_position_;
177        case managed_e: return managed_ < r.managed_;
178
179        default: return false; // ???
180        };
181}
182
183std::wstring torrent_details::to_wstring(size_t index)
184{
185        switch (index)
186        {
187        case name_e: return name_;
188        case state_e: return state_;
189
190        case progress_e: return (wform(L"%1$.2f%%") % (completion_*100)).str(); 
191        case speed_down_e: return (wform(L"%1$.2fkb/s") % (speed_.first/1024)).str(); 
192        case speed_up_e: return (wform(L"%1$.2fkb/s") % (speed_.second/1024)).str(); 
193
194        case distributed_copies_e: 
195                {
196                float copies = distributed_copies_;
197               
198                if (copies < 0)
199                        return L"Seeding"; 
200                else
201                        return (hal::wform(L"%1$.2f") % copies).str(); 
202                }
203
204        case remaining_e: 
205                {
206                return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_-total_wanted_done_)/(1024*1024))).str(); 
207                }
208
209        case completed_e: return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_done_)/(1024*1024))).str();
210
211        case total_wanted_e: 
212                {
213                return (wform(L"%1$.2fMB") % (static_cast<float>(total_wanted_-total_wanted_done_)/(1024*1024))).str(); 
214                }
215
216        case uploaded_e: 
217                {
218                return (wform(L"%1$.2fMB") % (static_cast<float>(total_payload_uploaded_)/(1024*1024))).str(); 
219                }
220
221        case downloaded_e: 
222                {
223                return (wform(L"%1$.2fMB") % (static_cast<float>(total_payload_downloaded_)/(1024*1024))).str(); 
224                }
225
226        case peers_e: return (wform(L"%1% (%2%)") % connected_peers_ % peers_).str(); 
227        case seeds_e: return (wform(L"%1% (%2%)") % connected_seeds_ % seeds_).str(); 
228
229        case ratio_e: 
230                {
231                        float ratio = (total_payload_downloaded_) 
232                                ? static_cast<float>(total_payload_uploaded_)
233                                        / static_cast<float>(total_payload_downloaded_)
234                                : 0;
235                       
236                        return (wform(L"%1$.2f") % ratio).str(); 
237                }
238
239        case eta_e: 
240                { 
241                if (!estimated_time_left_.is_special())
242                        return hal::from_utf8(
243                                boost::posix_time::to_simple_string(estimated_time_left_));
244                else
245                        return app().res_wstr(HAL_INF);         
246                }       
247
248        case tracker: return currentTracker_;
249
250        case update_tracker_in_e:               
251                { 
252                if (!update_tracker_in_.is_special())
253                        return from_utf8(
254                                boost::posix_time::to_simple_string(update_tracker_in_));
255                else
256                        return app().res_wstr(HAL_INF);         
257                }       
258
259        case active_time_e: 
260                {
261                if (!active_.is_special())
262                        return from_utf8(
263                                boost::posix_time::to_simple_string(active_));
264                else
265                        return app().res_wstr(HAL_INF);         
266                }
267
268        case seeding_time_e: 
269                { 
270                if (!seeding_.is_special())
271                        return from_utf8(
272                                boost::posix_time::to_simple_string(seeding_));
273                else
274                        return app().res_wstr(HAL_INF);
275                }       
276
277        case start_time_e: 
278                { 
279                if (!start_time_.is_special())
280                        return from_utf8(
281                                boost::posix_time::to_simple_string(start_time_));
282                else
283                        return app().res_wstr(IDS_NA);
284                }               
285
286        case finish_time_e:             
287                { 
288                if (!finish_time_.is_special())
289                        return from_utf8(
290                                boost::posix_time::to_simple_string(finish_time_));
291                else
292                        return app().res_wstr(IDS_NA); 
293                }               
294
295        case queue_position_e: 
296                {
297                        if (queue_position_ != -1)
298                                return (wform(L"%1%") % queue_position_).str(); 
299                        else
300                                return app().res_wstr(IDS_NA);         
301                }
302
303        case managed_e: return managed_ ?  L"Yes" : L"No";
304
305        default: return L"(Undefined)"; // ???
306        };
307}
308
309void torrent_details_manager::sort(size_t column_index, bool cmp_less) const
310{
311        std::stable_sort(torrents_.begin(), torrents_.end(), 
312                bind(&hal_details_ptr_compare<torrent_details_ptr>, _1, _2, column_index, cmp_less));
313}
314
315web_seed_or_dht_node_detail::web_seed_or_dht_node_detail() : 
316        url(L""), 
317        port(-1), 
318        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_WEB)) 
319{}
320
321web_seed_or_dht_node_detail::web_seed_or_dht_node_detail(std::wstring u) : 
322        url(u), 
323        port(-1), 
324        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_WEB)) 
325{}
326
327web_seed_or_dht_node_detail::web_seed_or_dht_node_detail(std::wstring u, int p) : 
328        url(u), 
329        port(p), 
330        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_DHT)) 
331{}
332
333bit::bit() :
334        pimpl_(new bit_impl())
335{}
336
337bit_impl* bit::pimpl()
338{
339        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer");
340
341        return &*pimpl_;
342}
343
344const bit_impl* bit::pimpl() const
345{
346        if (!pimpl_) throw std::runtime_error("bittorrent() accessed after destructer");
347
348        return &*pimpl_;
349}
350
351void bit::shutdown_session()
352{
353        HAL_DEV_MSG(L"Commence shutdown_session()"); 
354
355        pimpl_.reset();
356
357        HAL_DEV_MSG(L"End shutdown_session()"); 
358}
359
360void bit::save_torrent_data()
361{
362        pimpl()->save_torrent_data();
363}
364
365bool bit::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn)
366{
367        return pimpl()->create_torrent(params, out_file, fn);
368}
369
370bit::torrent bit::get_wstr(const std::wstring& filename)
371{
372        return bit::torrent(pimpl()->the_torrents_.get(filename));
373}
374
375bool bit::listen_on(std::pair<int, int> const& range)
376{
377        return pimpl()->listen_on(range);
378}
379
380int bit::is_listening_on() 
381{
382        return pimpl()->is_listening_on();
383}
384
385void bit::stop_listening()
386{
387        pimpl()->stop_listening();
388}
389
390bool bit::ensure_dht_on(const hal::dht_settings& dht)
391{
392        return pimpl()->ensure_dht_on(dht);
393}
394
395void bit::ensure_dht_off()
396{
397        pimpl()->ensure_dht_off();
398}
399
400void bit::set_mapping(bool upnp, bool nat_pmp)
401{
402        pimpl()->set_mapping(upnp, nat_pmp);
403}
404
405std::wstring bit::upnp_router_model()
406{
407        return pimpl()->upnp_router_model();
408}
409
410queue_settings bit::get_queue_settings()
411{
412        return pimpl()->get_queue_settings();
413}
414
415void bit::set_queue_settings(const queue_settings& s)
416{
417        pimpl()->set_queue_settings(s);
418}
419
420timeouts bit::get_timeouts()
421{
422        return pimpl()->get_timeouts();
423}
424
425void bit::set_timeouts(const timeouts& t)
426{
427        pimpl()->set_timeouts(t);
428}
429
430void bit::set_session_limits(int maxConn, int maxUpload)
431{               
432        pimpl()->set_session_limits(maxConn, maxUpload);
433}
434
435void bit::set_session_speed(float download, float upload)
436{
437        pimpl()->set_session_speed(download, upload);
438}
439
440bool bit::ensure_ip_filter_on(progress_callback fn)
441{
442        return pimpl()->ensure_ip_filter_on(fn);
443}
444
445void bit::ensure_ip_filter_off()
446{
447        pimpl()->ensure_ip_filter_off();
448}
449
450void bit::set_resolve_countries(bool b)
451{
452        pimpl()->set_resolve_countries(b);
453}
454
455void bit::start_smart_ban_plugin()
456{
457        pimpl()->start_smart_ban_plugin();
458}
459
460void bit::start_ut_pex_plugin()
461{
462        pimpl()->start_ut_pex_plugin();
463}
464
465void bit::start_ut_metadata_plugin()
466{
467        pimpl()->start_ut_metadata_plugin();
468}
469
470void bit::start_metadata_plugin()
471{
472        pimpl()->start_metadata_plugin();
473}
474
475#ifndef TORRENT_DISABLE_ENCRYPTION     
476
477void bit::ensure_pe_on(const pe_settings& pe)
478{
479        pimpl()->ensure_pe_on(pe);
480}
481
482void bit::ensure_pe_off()
483{
484        pimpl()->ensure_pe_off();
485}
486#endif
487
488void bit::ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last)
489{
490        pimpl()->ip_filter_.add_rule(first, last, libt::ip_filter::blocked);
491        pimpl()->ip_filter_count();
492        pimpl()->ip_filter_changed_ = true;
493}
494
495void bit::ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last)
496{
497        pimpl()->ip_v6_filter_block(first, last);
498}
499
500size_t bit::ip_filter_size()
501{
502        return pimpl()->ip_filter_size();
503}
504
505void bit::clear_ip_filter()
506{
507        pimpl()->clear_ip_filter();
508}
509
510bool bit::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
511{
512        return pimpl()->ip_filter_import_dat(file, fn, octalFix);
513}
514
515const SessionDetail bit::get_session_details()
516{
517        SessionDetail details;
518       
519        details.port = pimpl()->session_.is_listening() ? pimpl()->session_.listen_port() : -1;
520       
521        libt::session_status status = pimpl()->session_.status();
522       
523        details.speed = std::pair<double, double>(status.download_rate, status.upload_rate);
524       
525        details.dht_on = pimpl()->dht_on_;
526        details.dht_nodes = status.dht_nodes;
527        details.dht_torrents = status.dht_torrents;
528       
529        details.ip_filter_on = pimpl()->ip_filter_on_;
530        details.ip_ranges_filtered = pimpl()->ip_filter_count_;
531       
532        return details;
533}
534
535void bit::set_session_half_open_limit(int halfConn)
536{
537        pimpl()->session_.set_max_half_open_connections(halfConn);
538
539        event_log.post(shared_ptr<EventDetail>(new EventMsg(
540                hal::wform(L"Set half-open connections limit to %1%.") % pimpl()->session_.max_half_open_connections())));
541}
542
543void bit::set_torrent_defaults(const connections& defaults)
544{
545        pimpl()->default_torrent_max_connections_ = defaults.total;
546        pimpl()->default_torrent_max_uploads_ = defaults.uploads;
547
548        event_log.post(shared_ptr<EventDetail>(new EventMsg(
549                hal::wform(L"Set torrent connections total %1% and uploads %2%.") 
550                        % defaults.total % defaults.uploads)));
551
552        pimpl()->default_torrent_download_ = defaults.download_rate;
553        pimpl()->default_torrent_upload_ = defaults.upload_rate;
554
555        event_log.post(shared_ptr<EventDetail>(new EventMsg(
556                hal::wform(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") 
557                        % defaults.download_rate % defaults.upload_rate)));
558}
559
560void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, allocations alloc, 
561                boost::filesystem::wpath moveToDirectory, bool useMoveTo) 
562{
563        pimpl()->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory, useMoveTo);
564}
565
566const torrent_details_manager& bit::torrentDetails()
567{
568        return torrentDetails_;
569}
570
571const torrent_details_manager& bit::updatetorrent_details_manager(const wstring& focused, const std::set<wstring>& selected)
572{
573        try {
574       
575        mutex_t::scoped_lock l(torrentDetails_.mutex_); 
576       
577        torrentDetails_.clearAll(l);   
578        torrentDetails_.selected_names_ = selected;
579        torrentDetails_.torrents_.reserve(pimpl()->the_torrents_.size());
580       
581        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end(); i != e; ++i)
582        {
583                wstring utf8Name = (*i).torrent->name();
584                torrent_details_ptr pT = (*i).torrent->get_torrent_details_ptr();
585               
586                if (selected.find(utf8Name) != selected.end())
587                {
588                        torrentDetails_.selectedTorrents_.push_back(pT);
589                }
590               
591                if (focused == utf8Name)
592                        torrentDetails_.selectedTorrent_ = pT;
593               
594                torrentDetails_.torrentMap_[(*i).torrent->name()] = pT;
595                torrentDetails_.torrents_.push_back(pT);
596        }
597       
598        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "updatetorrent_details_manager")
599       
600        return torrentDetails_;
601}
602
603void bit::resume_all()
604{
605        pimpl()->resume_all();
606}
607
608void bit::close_all(boost::optional<report_num_active> fn)
609{
610        pimpl()->close_all(fn);
611}
612
613const cache_details bit::get_cache_details() const
614{
615        return pimpl()->get_cache_details();
616}
617
618void bit::get_all_peer_details(const std::string& filename, peer_details_vec& peer_container)
619{
620        get_all_peer_details(from_utf8_safe(filename), peer_container);
621}
622
623void bit::get_all_peer_details(const std::wstring& filename, peer_details_vec& peer_container)
624{
625        try {
626       
627        pimpl()->the_torrents_.get(filename)->get_peer_details(peer_container);
628       
629        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_peer_details")
630}
631
632void bit::get_all_file_details(const std::string& filename, file_details_vec& file_details)
633{
634        get_all_file_details(from_utf8_safe(filename), file_details);
635}
636
637void bit::get_all_file_details(const std::wstring& filename, file_details_vec& file_details)
638{
639        try {
640       
641        pimpl()->the_torrents_.get(filename)->get_file_details(file_details);
642       
643        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "get_all_file_details")
644}
645
646bool bit::is_torrent(const std::string& filename)
647{       
648        return is_torrent(hal::to_wstr_shim(filename));
649}
650
651bool bit::is_torrent(const std::wstring& filename)
652{       
653        try {
654       
655        return pimpl()->the_torrents_.exists(filename);
656       
657        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "is_torrent")
658       
659        return false;
660}
661
662void bit::pause_torrent(const std::string& filename)
663{
664        pause_torrent(hal::to_wstr_shim(filename));
665}
666
667void bit::pause_torrent(const std::wstring& filename)
668{
669        try {
670       
671        pimpl()->the_torrents_.get(filename)->pause();
672       
673        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pause_torrent")
674}
675
676void bit::resume_torrent(const std::string& filename)
677{
678        resume_torrent(hal::to_wstr_shim(filename));
679}
680
681void bit::resume_torrent(const std::wstring& filename)
682{
683        try {
684       
685        pimpl()->the_torrents_.get(filename)->resume();
686       
687        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resume_torrent")
688}
689
690void bit::stop_torrent(const std::string& filename)
691{
692        stop_torrent(hal::to_wstr_shim(filename));
693}
694
695void bit::stop_torrent(const std::wstring& filename)
696{
697        try {
698       
699        pimpl()->the_torrents_.get(filename)->stop();
700       
701        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stop_torrent")
702}
703
704bool bit::is_torrent_active(const std::string& filename)
705{
706        return is_torrent_active(hal::to_wstr_shim(filename));
707}
708
709bool bit::is_torrent_active(const std::wstring& filename)
710{
711        try {
712       
713        return pimpl()->the_torrents_.get(filename)->is_active();
714       
715        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "is_torrent_active")
716       
717        return false; // ??? is this correct
718}
719
720void bit::reannounce_torrent(const std::string& filename)
721{
722        reannounce_torrent(hal::to_wstr_shim(filename));
723}
724
725void bit::reannounce_torrent(const std::wstring& filename)
726{
727        try {
728       
729        pimpl()->the_torrents_.get(filename)->handle().force_reannounce();
730       
731        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounce_torrent")
732}
733
734
735void bit::recheck_torrent(const std::string& filename)
736{
737        recheck_torrent(hal::to_wstr_shim(filename));
738}
739
740void bit::recheck_torrent(const std::wstring& filename)
741{
742        try {
743       
744//      pimpl()->the_torrents_.get(filename)->output_torrent_debug_details();
745
746        pimpl()->the_torrents_.get(filename)->force_recheck();
747       
748        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "recheck_torrent")
749}
750
751void bit::remove_torrent_wstr(const std::wstring& filename)
752{
753        pimpl()->remove_torrent(filename);
754}
755
756void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename)
757{
758        pimpl()->remove_torrent_wipe_files(hal::to_wstr_shim(filename));
759}
760
761void bit::pause_all_torrents()
762{       
763        try {
764       
765        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
766                i != e; ++i)
767        {               
768                if ((*i).torrent->in_session())
769                        (*i).torrent->pause();
770        }
771       
772        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "pauseAllTorrents")
773}
774
775void bit::unpause_all_torrents()
776{       
777        try {
778       
779        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
780                i != e; ++i)
781        {
782                if ((*i).torrent->in_session() && (*i).torrent->get_state() == torrent_details::torrent_paused)
783                        (*i).torrent->resume();
784        }
785       
786        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "unpauseAllTorrents")
787}
788
789bool bit::is_any_torrent_active()
790{
791        bool result = false;
792       
793        try {
794       
795        for (torrent_manager::torrent_by_name::iterator i=pimpl()->the_torrents_.begin(), e=pimpl()->the_torrents_.end();
796                i != e; ++i)
797        {
798                if ((*i).torrent->is_active())
799                {
800                        result = true;
801                        break;
802                }
803        }
804       
805        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "unpauseAllTorrents")
806       
807        return result;
808}
809
810bit::torrent::torrent()
811{}
812
813bit::torrent::torrent(boost::shared_ptr<torrent_internal> p) :
814        ptr(p)
815{}
816
817bool bit::torrent::is_open() const
818{
819        return ptr;
820}
821
822bit::torrent::exec_around_ptr::proxy::proxy(torrent_internal* t) : 
823        t_(t),
824        l_(t->mutex_)
825{
826//      HAL_DEV_MSG(L"Ctor proxy");
827}
828
829bit::torrent::exec_around_ptr::proxy::~proxy() 
830{
831//      HAL_DEV_MSG(L"Dtor proxy");
832}
833
834const std::wstring bit::torrent::get_name() const
835{
836        try {
837       
838        return ptr->name();
839       
840        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Torrent Unknown", "torrent::get_name()")
841       
842        return 0;
843}
844
845float bit::torrent::get_ratio() const
846{
847        try {
848       
849        return ptr->get_ratio();
850       
851        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_ratio")
852       
853        return 0;
854}
855
856void bit::torrent::set_ratio(float r)
857{
858        try {
859
860        ptr->set_ratio(r);
861       
862        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_ratio")
863}
864
865std::pair<int, int> bit::torrent::get_connection_limits() const
866{
867        try {
868       
869        return ptr->get_connection_limit();
870       
871        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_connection_limits")
872       
873        return std::make_pair(-1, -1);
874}
875
876void bit::torrent::set_connection_limits(const std::pair<int, int>& l)
877{
878        try {
879       
880        ptr->set_connection_limit(l.first, l.second);
881       
882        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_connection_limits")
883}
884
885std::pair<float, float> bit::torrent::get_rate_limits() const
886{
887        try {
888       
889        return ptr->get_transfer_speed();
890       
891        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_rate_limits")
892       
893        return std::pair<float, float>(-1.0, -1.0);
894}
895
896void bit::torrent::set_rate_limits(const std::pair<float, float>& l)
897{
898        try {
899       
900        ptr->set_transfer_speed(l.first, l.second);
901       
902        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_rate_limits")
903}
904
905wpath bit::torrent::get_save_directory() const
906{
907        try {
908       
909        return ptr->get_save_directory();
910       
911        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
912       
913        return L"";
914}
915
916void bit::torrent::set_save_directory(const wpath& s)
917{
918        try {
919       
920        ptr->set_save_directory(s);
921       
922        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_save_directory")
923}
924
925wpath bit::torrent::get_move_to_directory() const
926{
927        try {
928       
929        return ptr->get_move_to_directory();
930       
931        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_save_directory")
932       
933        return L"";
934}
935
936void bit::torrent::set_move_to_directory(const wpath& m)
937{
938        try {
939       
940        ptr->set_move_to_directory(m);
941       
942        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_move_to_directory")
943}
944
945std::pair<wstring, wstring> bit::torrent::get_tracker_login() const
946{
947        try {
948       
949        return ptr->get_tracker_login();
950       
951        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("get_tracker_login")
952       
953        return std::make_pair(L"!!! exception thrown !!!", L"!!! exception thrown !!!");
954}
955
956void bit::torrent::set_tracker_login(const std::pair<wstring, wstring>& p)
957{
958        try {
959       
960        ptr->set_tracker_login(p.first, p.second);
961       
962        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_tracker_login")
963}
964
965bool bit::torrent::get_is_active() const
966{
967        try {
968       
969        return ptr->is_active();
970       
971        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_is_active")
972       
973        return L"";
974}
975
976bool bit::torrent::get_in_session() const
977{
978        try {
979       
980        return ptr->in_session();
981       
982        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_in_session")
983       
984        return L"";
985}
986
987std::vector<tracker_detail> bit::torrent::get_trackers() const
988{
989        try {
990       
991        return ptr->get_trackers();
992       
993        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_trackers")
994       
995        return std::vector<tracker_detail>();
996}
997
998void bit::torrent::set_trackers(const std::vector<tracker_detail>& trackers)
999{
1000        try {
1001       
1002        ptr->set_trackers(trackers);
1003       
1004        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
1005}
1006
1007void bit::torrent::reset_trackers()
1008{
1009        try {
1010       
1011        ptr->reset_trackers();
1012       
1013        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
1014}
1015
1016void bit::torrent::set_file_priorities(const std::pair<std::vector<int>, int>& p)
1017{
1018        try { 
1019
1020        ptr->set_file_priorities(p.first, p.second);
1021       
1022        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers")
1023}
1024
1025void bit::torrent::adjust_queue_position(bit::queue_adjustments adjust)
1026{
1027        try { 
1028
1029        ptr->adjust_queue_position(adjust);
1030       
1031        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::adjust_queue_position")
1032}
1033
1034bool bit::torrent::get_managed() const
1035{
1036        try {
1037       
1038        return ptr->is_managed();
1039       
1040        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::get_managed")
1041       
1042        return false;
1043}
1044
1045void bit::torrent::set_managed(bool m)
1046{
1047        try {
1048       
1049        ptr->set_managed(m);
1050       
1051        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_managed")
1052}
1053
1054void bit::start_event_receiver()
1055{
1056        try {
1057
1058        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting event handler.")));
1059
1060        pimpl()->start_alert_handler();
1061       
1062        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::start_event_receiver()")
1063}
1064
1065void bit::stop_event_receiver()
1066{
1067        try {
1068
1069        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event handler.")));
1070
1071        pimpl()->stop_alert_handler();
1072       
1073        } HAL_GENERIC_PIMPL_EXCEPTION_CATCH("bit::stop_event_receiver()")
1074}
1075
1076int bit::default_torrent_max_connections() { return pimpl()->default_torrent_max_connections_; }
1077int bit::default_torrent_max_uploads() { return pimpl()->default_torrent_max_uploads_; }
1078float bit::default_torrent_download() { return pimpl()->default_torrent_download_; }
1079float bit::default_torrent_upload() { return pimpl()->default_torrent_upload_; }
1080       
1081};
Note: See TracBrowser for help on using the repository browser.