source: trunk/src/halTorrent.cpp @ 634

Revision 634, 19.1 KB checked in by Eoin, 11 years ago (diff)

Fixed small issues with file progress and paused states with unmanaged torrents.

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