source: trunk/src/halTorrent.cpp @ 656

Revision 656, 25.4 KB checked in by Eoin, 11 years ago (diff)

Halite ListView? sorting fully working. Clean up to follow.

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