source: trunk/src/halSession.cpp @ 760

Revision 760, 26.1 KB checked in by Eoin, 10 years ago (diff)

Auto exit after a (currently hardcoded) time working.

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