source: trunk/src/halSession.cpp @ 759

Revision 759, 24.0 KB checked in by Eoin, 10 years ago (diff)

Adding an asio based threadpool instead of manually try to approximate the behaviour.

RevLine 
[480]1
[690]2//         Copyright Eóin O'Callaghan 2006 - 2009.
[480]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
[496]9#define TORRENT_MAX_ALERT_TYPES 32
[480]10
[503]11#include <boost/utility/in_place_factory.hpp>
12#include <boost/none.hpp>
13
[564]14#include "win32_exception.hpp"
15
[480]16#include "global/wtl_app.hpp"
17#include "global/string_conv.hpp"
18#include "global/ini_adapter.hpp"
19
20#include "halIni.hpp"
21#include "halTypes.hpp"
22#include "halEvent.hpp"
23#include "halSignaler.hpp"
24#include "halSession.hpp"
25
[573]26#pragma warning (push, 1)
27#       include <libtorrent/create_torrent.hpp>
28#pragma warning (pop)
29
[480]30namespace hal
31{
32
[503]33bit_impl::bit_impl() :
[759]34        keep_checking_(false),
[696]35        bittorrent_ini_(L"BitTorrent.xml"),
36        the_torrents_(bittorrent_ini_),
[642]37        default_torrent_max_connections_(-1),
38        default_torrent_max_uploads_(-1),
39        default_torrent_download_(-1),
40        default_torrent_upload_(-1),
41        resolve_countries_(true),
[503]42        ip_filter_on_(false),
43        ip_filter_loaded_(false),
44        ip_filter_changed_(false),
45        ip_filter_count_(0),
46        dht_on_(false)
47{
[746]48        session_ = boost::in_place(libt::fingerprint(HALITE_FINGERPRINT));
49
[569]50        try
51        {
52
[503]53        torrent_internal::the_session_ = &session_;
[571]54
[746]55        session_->session::set_alert_mask(libt::alert::all_categories);         
56        session_->add_extension(&libt::create_metadata_plugin);
57        session_->add_extension(&libt::create_ut_pex_plugin);
58        session_->set_max_half_open_connections(10);
[503]59       
[745]60        hal::event_log().post(shared_ptr<hal::EventDetail>(
[503]61                new hal::EventMsg(L"Loading BitTorrent.xml.", hal::event_logger::info)));               
[696]62        bittorrent_ini_.load_data();
[745]63        hal::event_log().post(shared_ptr<hal::EventDetail>(
[503]64                new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));   
65        the_torrents_.load_from_ini();
[745]66        hal::event_log().post(shared_ptr<hal::EventDetail>(
[503]67                new hal::EventMsg(L"Loading done!", hal::event_logger::info)));
68       
[696]69#       if 0
[503]70        try
71        {                                               
[569]72        if (fs::exists(hal::app().get_working_directory()/L"Torrents.xml"))
[503]73        {
[570]74                assert(false);
[503]75                {
[569]76                fs::wifstream ifs(hal::app().get_working_directory()/L"Torrents.xml");
[503]77       
[745]78                event_log().post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml")));
[503]79       
80                TorrentMap torrents;
81                boost::archive::xml_wiarchive ia(ifs); 
82                ia >> boost::serialization::make_nvp("torrents", torrents);
83               
84                the_torrents_ = torrents;
85                }
86               
[745]87                event_log().post(shared_ptr<EventDetail>(new EventMsg(
[531]88                        hal::wform(L"Total %1%.") % the_torrents_.size())));                           
[503]89               
[569]90                fs::rename(hal::app().get_working_directory()/L"Torrents.xml", hal::app().get_working_directory()/L"Torrents.xml.safe.to.delete");
[696]91
[503]92        }                       
93        }
94        catch(const std::exception& e)
95        {
[745]96                event_log().post(shared_ptr<EventDetail>(
[503]97                        new EventStdException(event_logger::fatal, e, L"Loading Old Torrents.xml")));
98        }               
[696]99#       endif
100
[569]101        if (exists(hal::app().get_working_directory()/L"DHTState.bin"))
[503]102        {
103                try
104                {
[569]105                        dht_state_ = haldecode(hal::app().get_working_directory()/L"DHTState.bin");
[503]106                }               
107                catch(const std::exception& e)
108                {
[745]109                        event_log().post(shared_ptr<EventDetail>(
[503]110                                new EventStdException(event_logger::critical, e, L"Loading DHTState.bin")));
111                }
112        }
113       
[746]114        {       libt::session_settings settings = session_->settings();
[503]115                settings.user_agent = string("Halite ") + HALITE_VERSION_STRING;
[746]116                session_->set_settings(settings);
[503]117        }
118       
[759]119        acquire_work_object();
120
121        service_threads_.push_back(shared_thread_ptr(new 
122                thread_t(bind(&bit_impl::service_thread, this, service_threads_.size()))));
123
[503]124        start_alert_handler();
[569]125
126        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::bit_impl()")
[503]127}
128
129bit_impl::~bit_impl()
[569]130{       
131        try
132        {
[564]133        HAL_DEV_MSG(L"Commence ~BitTorrent_impl"); 
134
[759]135        discard_work_object();
136
137        stop_alert_handler();
138
139        for (std::vector<shared_thread_ptr>::iterator i=service_threads_.begin(), e=service_threads_.end(); i != e; ++i)
140                (*i)->join();
141
[503]142        //save_torrent_data();
143       
[648]144        HAL_DEV_MSG(L"Handler stopped!"); 
[503]145        if (ip_filter_changed_)
146        {       
[648]147                HAL_DEV_MSG(L"IP Filter needs saving."); 
148
[569]149                fs::ofstream ofs(hal::app().get_working_directory()/L"IPFilter.bin", std::ios::binary);
150//              boost::archive::binary_oarchive oba(ofs);
[503]151               
152                libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();   
153               
[554]154                std::vector<libt::ip_range<boost::asio::ip::address_v4> > v4(vectors.get<0>());
155                std::vector<libt::ip_range<boost::asio::ip::address_v6> > v6(vectors.get<1>());
[503]156               
157                v4.erase(std::remove(v4.begin(), v4.end(), 0), v4.end());
158                v6.erase(std::remove(v6.begin(), v6.end(), 0), v6.end());
159
160                write_vec_range(ofs, v4);
[569]161//              write_vec_range(ofs, v6);
[503]162        }       
[564]163
[569]164        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"~BitTorrent_impl")
[503]165}
166
[480]167void bit_impl::ip_filter_count()
168{
169        libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();
170       
171        vectors.get<0>().erase(std::remove(vectors.get<0>().begin(), vectors.get<0>().end(), 0),
172                vectors.get<0>().end());
173        vectors.get<1>().erase(std::remove(vectors.get<1>().begin(), vectors.get<1>().end(), 0),
174                vectors.get<1>().end());
175        ip_filter_count_ = vectors.get<0>().size() + vectors.get<1>().size();
176}
177
178void bit_impl::ip_filter_load(progress_callback fn)
179{
[569]180        fs::ifstream ifs(hal::app().get_working_directory()/L"IPFilter.bin", std::ios::binary);
[480]181        if (ifs)
182        {
183                size_t v4_size;
184                ifs >> v4_size;
185               
186                size_t total = v4_size/100;
187                size_t previous = 0;
188               
189                for(unsigned i=0; i<v4_size; ++i)
190                {
191                        if (i-previous > total)
192                        {
193                                previous = i;
194
[701]195                                if (fn) if (fn(i, v4_size, hal::app().res_wstr(HAL_TORRENT_LOAD_FILTERS))) break;
[480]196                        }
197                       
[554]198                        read_range_to_filter<boost::asio::ip::address_v4>(ifs, ip_filter_);
[480]199                }
200        }       
201}
202
[696]203void bit_impl::ip_filter_import(std::vector<libt::ip_range<boost::asio::ip::address_v4> >& v4,
[554]204        std::vector<libt::ip_range<boost::asio::ip::address_v6> >& v6)
[480]205{
[554]206        for(std::vector<libt::ip_range<boost::asio::ip::address_v4> >::iterator i=v4.begin();
[480]207                i != v4.end(); ++i)
208        {
209                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked);
210        }
[554]211/*      for(std::vector<libt::ip_range<boost::asio::ip::address_v6> >::iterator i=v6.begin();
[480]212                i != v6.end(); ++i)
213        {
214                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked);
215        }
216*/     
217        /* Note here we do not set ip_filter_changed_ */
218}
219
220bool bit_impl::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
221{
222        try
223        {
224
225        fs::ifstream ifs(file); 
226        if (ifs)
227        {
[701]228                boost::uintmax_t total = fs::file_size(file);
[480]229                boost::uintmax_t progress = 0;
230                boost::uintmax_t previous = 0;
231               
232                boost::regex reg("\\s*(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s*-\\s*(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s*.*");
233                boost::regex ip_reg("0*(\\d*)\\.0*(\\d*)\\.0*(\\d*)\\.0*(\\d*)");
234                boost::smatch m;
235               
236                string ip_address_line;         
237                while (!std::getline(ifs, ip_address_line).eof())
238                {               
239                        progress += (ip_address_line.length() + 2);
240                        if (progress-previous > total)
241                        {
242                                previous = progress;
243                                if (fn)
244                                {
[727]245                                        if (fn(boost::numeric_cast<size_t>(progress), boost::numeric_cast<size_t>(total), 
246                                                        hal::app().res_wstr(HAL_TORRENT_IMPORT_FILTERS))) 
[480]247                                                break;
248                                }
249                        }
250                       
251                        if (boost::regex_match(ip_address_line, m, reg))
252                        {
253                                string first = m[1];
254                                string last = m[2];
255                               
256                                if (octalFix)
257                                {
258                                        if (boost::regex_match(first, m, ip_reg))
259                                        {
260                                                first = ((m.length(1) != 0) ? m[1] : string("0")) + "." +
261                                                                ((m.length(2) != 0) ? m[2] : string("0")) + "." +
262                                                                ((m.length(3) != 0) ? m[3] : string("0")) + "." +
263                                                                ((m.length(4) != 0) ? m[4] : string("0"));
264                                        }                                       
265                                        if (boost::regex_match(last, m, ip_reg))
266                                        {
267                                                last = ((m.length(1) != 0) ? m[1] : string("0")) + "." +
268                                                           ((m.length(2) != 0) ? m[2] : string("0")) + "." +
269                                                           ((m.length(3) != 0) ? m[3] : string("0")) + "." +
270                                                           ((m.length(4) != 0) ? m[4] : string("0"));
271                                        }
272                                }
273                               
274                                try
275                                {                       
[696]276                                        ip_filter_.add_rule(boost::asio::ip::address_v4::from_string(first),
277                                                boost::asio::ip::address_v4::from_string(last), libt::ip_filter::blocked);     
[480]278                                }
279                                catch(...)
280                                {
[745]281                                        hal::event_log().post(shared_ptr<hal::EventDetail>(
[480]282                                                new hal::EventDebug(hal::event_logger::info, 
[554]283                                                from_utf8((boost::format("Invalid IP range: %1%-%2%.") % first % last).str()))));
[480]284                                }
285                        }
286                }
287        }
288       
289        ip_filter_changed_ = true;
290        ip_filter_count();
291       
292        }
293        catch(const std::exception& e)
294        {
[745]295                event_log().post(shared_ptr<EventDetail>(
[480]296                        new EventStdException(event_logger::critical, e, L"ip_filter_import_dat")));
297        }
298
299        return false;
300}
301
[508]302bool bit_impl::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn)
303{               
[569]304        try
305        {
[508]306        libt::file_storage fs;
307        libt::file_pool f_pool;
308
309        HAL_DEV_MSG(L"Files");
310        for (file_size_pairs_t::const_iterator i = params.file_size_pairs.begin(), e = params.file_size_pairs.end();
311                        i != e; ++i)
312        {
[531]313                HAL_DEV_MSG(hal::wform(L"file path: %1%, size: %2%") % (*i).first % (*i).second);
[512]314                fs.add_file(to_utf8((*i).first.string()), (*i).second);
[508]315        }
316
317        int piece_size = params.piece_size;
[531]318        HAL_DEV_MSG(hal::wform(L"piece size: %1%") % piece_size);
[508]319       
320        libt::create_torrent t(fs, piece_size);
321       
[512]322/*      boost::scoped_ptr<libt::storage_interface> store(
[508]323                libt::default_storage_constructor(t_info, to_utf8(params.root_path.string()),
324                        f_pool));
[512]325*/
[508]326        HAL_DEV_MSG(L"Trackers");
327        for (tracker_details_t::const_iterator i = params.trackers.begin(), e = params.trackers.end();
328                        i != e; ++i)
329        {
[531]330                HAL_DEV_MSG(hal::wform(L"URL: %1%, Tier: %2%") % (*i).url % (*i).tier);
[512]331                t.add_tracker(to_utf8((*i).url), (*i).tier);
[508]332        }
333
334        HAL_DEV_MSG(L"Web Seeds");
335        for (web_seed_details_t::const_iterator i = params.web_seeds.begin(), e = params.web_seeds.end();
336                        i != e; ++i)
337        {
[531]338                HAL_DEV_MSG(hal::wform(L"URL: %1%") % (*i).url);
[512]339                t.add_url_seed(to_utf8((*i).url));
[508]340        }
341
342        HAL_DEV_MSG(L"DHT Nodes");
343        for (dht_node_details_t::const_iterator i = params.dht_nodes.begin(), e = params.dht_nodes.end();
344                        i != e; ++i)
345        {
[531]346                HAL_DEV_MSG(hal::wform(L"URL: %1%, port: %2%") % (*i).url % (*i).port);
[512]347                t.add_node(hal::make_pair(to_utf8((*i).url), (*i).port));
[508]348        }
[513]349
[698]350        HAL_DEV_MSG(hal::wform(L"root_path: %1%") % params.root_path.string());
351
[701]352        set_piece_hashes(t, to_utf8(params.root_path.string()),
353                boost::bind(fn, _1, t.num_pieces(), hal::app().res_wstr(HAL_NEWT_HASHING_PIECES)));
[508]354
[701]355        t.set_creator(to_utf8(params.creator).c_str());
356        t.set_comment(to_utf8(params.comment).c_str());
[508]357       
[701]358        t.set_priv(params.private_torrent);
[508]359
360        // create the torrent and print it to out
[512]361        libt::entry e = t.generate();
[647]362       
363        HAL_DEV_MSG(hal::wform(L"Writing to: %1%") % out_file);
[698]364        fs::ofstream out(out_file, std::ios_base::binary);
365        libt::bencode(std::ostream_iterator<char>(out), t.generate());
[512]366
[569]367        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::create_torrent()")
[647]368       
369        HAL_DEV_MSG(L"Torrent creation completed!");
[508]370
371        return false;
372}
373
[503]374void bit_impl::start_alert_handler()
375{
376        mutex_t::scoped_lock l(mutex_);
377
[759]378        if (!keep_checking_)
379        {
380                keep_checking_ = true;
381
382                boost::asio::deadline_timer t(io_service_, pt::milliseconds(100));
383                io_service_.post(bind(&bit_impl::alert_handler, this));
384        }
385        else
386        {
387                HAL_DEV_MSG(hal::wform(L"Alert handler already active"));
388        }
389
390/*      if (alert_checker_ == boost::none)
[583]391        {       
392                HAL_DEV_MSG(hal::wform(L"start_alert_handler"));
[503]393
[583]394                boost::function<void (void)> f = bind(&bit_impl::alert_handler, this);
395
396                keepChecking_ = true;
397                alert_checker_ = boost::in_place<boost::function<void (void)> >(bind(&bit_impl::alert_handler, this));
[759]398        }       */
[503]399}
400       
[482]401void bit_impl::stop_alert_handler()
[480]402{
403        mutex_t::scoped_lock l(mutex_);
404
[759]405        if (keep_checking_)
[503]406        {
[759]407                HAL_DEV_MSG(hal::wform(L"Stopping alert handler..."));         
[564]408
[759]409                keep_checking_ = false;
[503]410        }
[564]411        else
412        {
413                HAL_DEV_MSG(hal::wform(L"Alert handler already stopped"));
414        }
[480]415}
416       
[759]417void bit_impl::service_thread(size_t id)
[480]418{
[564]419        win32_exception::install_handler();
420
[759]421        HAL_DEV_MSG(hal::wform(L"Begining a service thread, id %1%") % id);
422
423        for ( ; ; )
[564]424        {
[759]425                try
426                {
427                        io_service_.run();
[564]428
[759]429                        // run exited normally
430                        break; 
431
432                } 
433                HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::service_thread()")
434        }
435
436        HAL_DEV_MSG(hal::wform(L"Service thread id %1% exiting normally") % id);
437}
438
439void bit_impl::alert_handler_wait(const boost::system::error_code& /*e*/)
440{
441        if (keep_checking_)
442                alert_handler();
443}
444
445void bit_impl::alert_handler()
446{
447        try
[480]448        {
449       
[746]450        std::auto_ptr<libt::alert> p_alert = session_->pop_alert();
[480]451       
452        class AlertHandler
453        {
454        public:
455        AlertHandler(bit_impl& bit_impl) :
456                bit_impl_(bit_impl)
457        {}
[496]458
459        void operator()(libt::external_ip_alert const& a) const
460        {
[745]461                event_log().post(shared_ptr<EventDetail>(
[571]462                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]463                                hal::wform(hal::app().res_wstr(HAL_EXTERNAL_IP_ALERT))
[496]464                                        % hal::from_utf8_safe(a.message())
465                                        % hal::from_utf8_safe(a.external_address.to_string()))
466                )       );                             
467        }
468
469        void operator()(libt::portmap_error_alert const& a) const
470        {
[745]471                event_log().post(shared_ptr<EventDetail>(
[571]472                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]473                                hal::wform(hal::app().res_wstr(HAL_PORTMAP_ERROR_ALERT))
[496]474                                % (a.type == 0 ? 
475                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_PMP) : 
476                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_UPNP)))
477                )       );                             
478        }
479
480        void operator()(libt::portmap_alert const& a) const
481        {
[745]482                event_log().post(shared_ptr<EventDetail>(
[571]483                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]484                                hal::wform(hal::app().res_wstr(HAL_PORTMAP_ALERT))
[496]485                                % (a.type == 0 ? 
486                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_PMP) : 
487                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_UPNP))
488                                % a.external_port)
489                )       );                             
490        }
[480]491       
[496]492        void operator()(libt::file_error_alert const& a) const
493        {
[745]494                event_log().post(shared_ptr<EventDetail>(
[571]495                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]496                                hal::wform(hal::app().res_wstr(HAL_FILE_ERROR_ALERT))
[496]497                                % hal::from_utf8_safe(a.file)
498                                % hal::from_utf8_safe(a.msg))
499                )       );                             
500        }
501       
502        void operator()(libt::dht_reply_alert const& a) const
503        {
[745]504                event_log().post(shared_ptr<EventDetail>(
[571]505                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]506                                hal::wform(hal::app().res_wstr(HAL_DHT_REPLY_ALERT))
[730]507                                        % a.num_peers
508                                        % get(a.handle)->name())
[496]509                )       );                             
510        }
511
[480]512        void operator()(libt::torrent_finished_alert const& a) const
513        {
[745]514                event_log().post(shared_ptr<EventDetail>(
[531]515                        new EventMsg((hal::wform(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED)) 
[480]516                                        % get(a.handle)->name()), 
517                                event_logger::info, a.timestamp())));
518               
519                get(a.handle)->finished();     
520        }
521       
522        void operator()(libt::torrent_paused_alert const& a) const
523        {
524                get(a.handle)->signals().torrent_paused();
[688]525
[693]526                wstring err = get(a.handle)->check_error();
527
528                if (err == L"")
[695]529                {
[745]530                        event_log().post(shared_ptr<EventDetail>(
[695]531                                new EventMsg((hal::wform(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED)) 
532                                                % get(a.handle)->name()), 
533                                        event_logger::debug, a.timestamp())));
[706]534                       
535                        HAL_DEV_MSG(hal::wform(L"Torrent Paused alert, %1%.") % get(a.handle)->name());
[695]536
[693]537                        get(a.handle)->locked_process_event(ev_paused_alert());
[695]538                }
[693]539                else
[695]540                {
[706]541                        HAL_DEV_MSG(hal::wform(L"Torrent Error alert %2%, %1%.") % get(a.handle)->name() % err);
542
[745]543                        event_log().post(shared_ptr<EventDetail>(
[695]544                                new EventMsg((hal::wform(hal::app().res_wstr(HAL_TORRENT_ERROR_PAUSE_ALERT)) 
545                                                % err
546                                                % get(a.handle)->name()), 
547                                        event_logger::warning, a.timestamp())));
548
[693]549                        get(a.handle)->locked_process_event(ev_error_alert(err));
[695]550                }
[480]551        }
552       
[690]553        void operator()(libt::torrent_resumed_alert const& a) const
554        {
[745]555                event_log().post(shared_ptr<EventDetail>(
[695]556                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_TORRENT_RESUME_ALERT)) 
557                                        % get(a.handle)->name()), 
558                                event_logger::debug, a.timestamp())));
[690]559
560                get(a.handle)->locked_process_event(ev_resumed_alert());
561        }
562       
[590]563        void operator()(libt::save_resume_data_alert const& a) const
564        {
[745]565                event_log().post(shared_ptr<EventDetail>(
[590]566                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_WRITE_RESUME_ALERT)) 
567                                        % get(a.handle)->name()), 
568                                event_logger::info, a.timestamp())));
569
570                if (a.resume_data)
571                        get(a.handle)->write_resume_data(*a.resume_data);
[695]572
[590]573                get(a.handle)->signals().resume_data();
[689]574                get(a.handle)->locked_process_event(ev_resume_data_alert());
[590]575        }
576       
[689]577        void operator()(libt::save_resume_data_failed_alert const& a) const
578        {
[745]579                event_log().post(shared_ptr<EventDetail>(
[695]580                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_WRITE_RESUME_FAIL_ALERT)) 
[689]581                                        % get(a.handle)->name()), 
[695]582                                event_logger::warning, a.timestamp())));
[689]583
584                get(a.handle)->locked_process_event(ev_resume_data_failed_alert());
585        }
586       
[480]587        void operator()(libt::peer_error_alert const& a) const
588        {
[745]589                event_log().post(shared_ptr<EventDetail>(
[571]590                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]591                                hal::wform(hal::app().res_wstr(HAL_PEER_ALERT))
[496]592                                        % hal::from_utf8_safe(a.message())
[480]593                                        % hal::from_utf8_safe(a.ip.address().to_string()))
594                )       );                             
595        }
596               
597        void operator()(libt::peer_ban_alert const& a) const
598        {
[745]599                event_log().post(shared_ptr<EventDetail>(
[571]600                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]601                                hal::wform(hal::app().res_wstr(HAL_PEER_BAN_ALERT))
[480]602                                        % get(a.handle)->name()
603                                        % hal::from_utf8_safe(a.ip.address().to_string()))
604                )       );                             
605        }
606               
607        void operator()(libt::hash_failed_alert const& a) const
608        {
[745]609                event_log().post(shared_ptr<EventDetail>(
[571]610                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]611                                hal::wform(hal::app().res_wstr(HAL_HASH_FAIL_ALERT))
[480]612                                        % get(a.handle)->name()
613                                        % a.piece_index)
614                )       );                             
615        }
616               
617        void operator()(libt::url_seed_alert const& a) const
618        {
[745]619                event_log().post(shared_ptr<EventDetail>(
[571]620                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]621                                hal::wform(hal::app().res_wstr(HAL_URL_SEED_ALERT))
[480]622                                        % get(a.handle)->name()
623                                        % hal::from_utf8_safe(a.url)
[496]624                                        % hal::from_utf8_safe(a.message()))
[480]625                )       );                             
626        }
627       
628        void operator()(libt::tracker_warning_alert const& a) const
629        {
[745]630                event_log().post(shared_ptr<EventDetail>(
[571]631                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]632                                hal::wform(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT))
[480]633                                        % get(a.handle)->name()
[496]634                                        % hal::from_utf8_safe(a.message()))
[480]635                )       );                             
636        }
637       
638        void operator()(libt::tracker_announce_alert const& a) const
639        {
[745]640                event_log().post(shared_ptr<EventDetail>(
[531]641                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT)) 
[480]642                                        % get(a.handle)->name()), 
643                                event_logger::info, a.timestamp())));
644        }
645       
[484]646        void operator()(libt::tracker_error_alert const& a) const
[480]647        {
[745]648                event_log().post(shared_ptr<EventDetail>(
[571]649                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]650                                hal::wform(hal::app().res_wstr(HAL_TRACKER_ALERT))
[480]651                                        % get(a.handle)->name()
[496]652                                        % hal::from_utf8_safe(a.message())
[480]653                                        % a.times_in_row
654                                        % a.status_code)
655                )       );                             
656        }
657       
658        void operator()(libt::tracker_reply_alert const& a) const
659        {
[745]660                event_log().post(shared_ptr<EventDetail>(
[571]661                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]662                                hal::wform(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT))
[480]663                                        % get(a.handle)->name()
[496]664                                        % hal::from_utf8_safe(a.message())
[480]665                                        % a.num_peers)
666                )       );                             
667        }
668       
669        void operator()(libt::fastresume_rejected_alert const& a) const
670        {
[745]671                event_log().post(shared_ptr<EventDetail>(
[571]672                        new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(),
[531]673                                hal::wform(hal::app().res_wstr(HAL_FAST_RESUME_ALERT))
[480]674                                        % get(a.handle)->name()
[496]675                                        % hal::from_utf8_safe(a.message()))
[480]676                )       );                             
677        }
678       
679        void operator()(libt::piece_finished_alert const& a) const
680        {
[745]681                event_log().post(shared_ptr<EventDetail>(
[480]682                        new EventGeneral(event_logger::debug, a.timestamp(),
[531]683                                hal::wform(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT))
[480]684                                        % get(a.handle)->name()
685                                        % a.piece_index)
686                )       );                             
687        }
688       
689        void operator()(libt::block_finished_alert const& a) const
690        {
[745]691                event_log().post(shared_ptr<EventDetail>(
[480]692                        new EventGeneral(event_logger::debug, a.timestamp(),
[531]693                                hal::wform(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT))
[480]694                                        % get(a.handle)->name()
695                                        % a.block_index
696                                        % a.piece_index)
697                )       );                             
698        }
699       
700        void operator()(libt::block_downloading_alert const& a) const
701        {
[745]702                event_log().post(shared_ptr<EventDetail>(
[480]703                        new EventGeneral(event_logger::debug, a.timestamp(),
[531]704                                hal::wform(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT))
[480]705                                        % get(a.handle)->name()
706                                        % a.block_index
707                                        % a.piece_index)
708                )       );                             
709        }
710       
711        void operator()(libt::listen_failed_alert const& a) const
712        {
713                if (a.endpoint.address().is_v6())
714                {       
[745]715                        event_log().post(shared_ptr<EventDetail>(
[480]716                                new EventGeneral(event_logger::info, a.timestamp(),
717                                        hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT))
718                        )       );             
719                }
720                else
721                {
[745]722                        event_log().post(shared_ptr<EventDetail>(
[480]723                                new EventGeneral(event_logger::info, a.timestamp(),
[531]724                                        hal::wform(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT))
[496]725                                                % hal::from_utf8_safe(a.message()))
[480]726                        )       );
727                }
728        }
729       
730        void operator()(libt::listen_succeeded_alert const& a) const
731        {
[745]732                event_log().post(shared_ptr<EventDetail>(
[480]733                        new EventGeneral(event_logger::info, a.timestamp(),
[531]734                                hal::wform(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT))
[496]735                                        % hal::from_utf8_safe(a.message()))
[480]736                )       );     
737
[590]738                //bit_impl_.signals.successful_listen();
[480]739        }
740       
741        void operator()(libt::peer_blocked_alert const& a) const
742        {
[745]743                event_log().post(shared_ptr<EventDetail>(
[480]744                        new EventGeneral(event_logger::debug, a.timestamp(),
[531]745                                hal::wform(hal::app().res_wstr(HAL_IPFILTER_ALERT))
[480]746                                        % hal::from_utf8_safe(a.ip.to_string())
[496]747                                        % hal::from_utf8_safe(a.message()))
[480]748                )       );                             
749        }
750       
[554]751/*      void operator()(libt::alert const& a) const
[480]752        {
[745]753                event_log().post(shared_ptr<EventDetail>(
[480]754                                new EventLibtorrent(lbtAlertToHalEvent(a.severity()),
[496]755                                        a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.message()))));         
[554]756        }*/
[480]757       
758        private:
759                bit_impl& bit_impl_;
760               
761                torrent_internal_ptr get(libt::torrent_handle h) const 
762                { 
[740]763                        torrent_internal_ptr p = bit_impl_.the_torrents_.get(from_utf8_safe(h.get_torrent_info().name())); 
764
765                        if (p)
766                                return p;
767                        else
768                                throw bit::null_torrent();
[480]769                }
770       
771        } handler(*this);
772       
773        while (p_alert.get())
774        {       
775                try
776                {
[759]777                //mutex_t::scoped_lock l(mutex_);
[480]778               
779                libt::handle_alert<
[554]780                        libt::save_resume_data_alert,
[689]781                        libt::save_resume_data_failed_alert,
[496]782                        libt::external_ip_alert,
783                        libt::portmap_error_alert,
784                        libt::portmap_alert,
785                        libt::file_error_alert,
[480]786                        libt::torrent_finished_alert,
787                        libt::torrent_paused_alert,
[690]788                        libt::torrent_resumed_alert,
[480]789                        libt::peer_error_alert,
790                        libt::peer_ban_alert,
791                        libt::hash_failed_alert,
792                        libt::url_seed_alert,
[496]793                        libt::dht_reply_alert,
[484]794                        libt::tracker_error_alert,
[480]795                        libt::tracker_warning_alert,
796                        libt::tracker_announce_alert,
797                        libt::tracker_reply_alert,
798                        libt::fastresume_rejected_alert,
799                        libt::piece_finished_alert,
800                        libt::block_finished_alert,
801                        libt::block_downloading_alert,
802                        libt::listen_failed_alert,
803                        libt::listen_succeeded_alert,
[554]804                        libt::peer_blocked_alert
[480]805                >::handle_alert(p_alert, handler);                     
806               
807                }
[741]808                catch(const libt::unhandled_alert&)
[480]809                {
[554]810//                      handler(*p_alert);
[480]811                }
[741]812                catch(const bit::null_torrent&)
[740]813                {
814                        // These are logged as debug because they are rarely important to act on!
[745]815                        event_log().post(shared_ptr<EventDetail>(\
[740]816                                new EventMsg(L"null_torrent exception", event_logger::info)));
817                }
[741]818                catch(const std::exception& e)
[480]819                {
820                        // These are logged as debug because they are rarely important to act on!
[745]821                        event_log().post(shared_ptr<EventDetail>(\
[648]822                                new EventStdException(event_logger::debug, e, L"bit_impl::alert_handler()")));
[480]823                }
824               
[746]825                p_alert = session_->pop_alert();
[503]826
[554]827                boost::this_thread::interruption_point();
[503]828        }       
[480]829       
[759]830        boost::asio::deadline_timer t(io_service_, pt::milliseconds(100));
831        t.async_wait(bind(&bit_impl::alert_handler_wait, this, _1));
[648]832       
833        } 
[759]834/*      catch(boost::thread_interrupted&)
[648]835        {
836                // Not an error!
837
[745]838                event_log().post(shared_ptr<EventDetail>(
[648]839                        new EventMsg(L"thread_interrupted exception", event_logger::info)));
840
841                return;
[759]842        }*/
[648]843        HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::alert_handler()")
[480]844}
845
846}
Note: See TracBrowser for help on using the repository browser.