source: trunk/src/halSession.cpp @ 554

Revision 554, 20.9 KB checked in by Eoin, 12 years ago (diff)

Implementing a new signaler infrastructure.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2008.
3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
7#include "stdAfx.hpp"
8
9#define TORRENT_MAX_ALERT_TYPES 32
10
11#include <boost/utility/in_place_factory.hpp>
12#include <boost/none.hpp>
13
14#include <libtorrent/alert_types.hpp>
15#include <libtorrent/entry.hpp>
16#include <libtorrent/session.hpp>
17#include <libtorrent/ip_filter.hpp>
18#include <libtorrent/torrent_handle.hpp>
19#include <libtorrent/create_torrent.hpp>
20
21#include "global/wtl_app.hpp"
22#include "global/string_conv.hpp"
23#include "global/ini_adapter.hpp"
24
25#include "halIni.hpp"
26#include "halTypes.hpp"
27#include "halEvent.hpp"
28#include "halSignaler.hpp"
29#include "halSession.hpp"
30
31namespace hal
32{
33
34bit_impl::bit_impl() :
35        session_(libt::fingerprint(HALITE_FINGERPRINT)),
36        keepChecking_(false),
37        bittorrentIni(L"BitTorrent.xml"),
38        the_torrents_(bittorrentIni),
39        defTorrentMaxConn_(-1),
40        defTorrentMaxUpload_(-1),
41        defTorrentDownload_(-1),
42        defTorrentUpload_(-1),
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        torrent_internal::the_session_ = &session_;
50        torrent_internal::workingDir_ = workingDir();
51       
52        session_.set_severity_level(libt::alert::debug);               
53        session_.add_extension(&libt::create_metadata_plugin);
54        session_.add_extension(&libt::create_ut_pex_plugin);
55        session_.set_max_half_open_connections(10);
56       
57        hal::event_log.post(shared_ptr<hal::EventDetail>(
58                new hal::EventMsg(L"Loading BitTorrent.xml.", hal::event_logger::info)));               
59        bittorrentIni.load_data();
60        hal::event_log.post(shared_ptr<hal::EventDetail>(
61                new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));   
62        the_torrents_.load_from_ini();
63        hal::event_log.post(shared_ptr<hal::EventDetail>(
64                new hal::EventMsg(L"Loading done!", hal::event_logger::info)));
65       
66        try
67        {                                               
68        if (fs::exists(workingDirectory/L"Torrents.xml"))
69        {
70                {
71                fs::wifstream ifs(workingDirectory/L"Torrents.xml");
72       
73                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml")));
74       
75                TorrentMap torrents;
76                boost::archive::xml_wiarchive ia(ifs); 
77                ia >> boost::serialization::make_nvp("torrents", torrents);
78               
79                the_torrents_ = torrents;
80                }
81               
82                event_log.post(shared_ptr<EventDetail>(new EventMsg(
83                        hal::wform(L"Total %1%.") % the_torrents_.size())));                           
84               
85                fs::rename(workingDirectory/L"Torrents.xml", workingDirectory/L"Torrents.xml.safe.to.delete");
86        }                       
87        }
88        catch(const std::exception& e)
89        {
90                event_log.post(shared_ptr<EventDetail>(
91                        new EventStdException(event_logger::fatal, e, L"Loading Old Torrents.xml")));
92        }               
93                       
94        if (exists(workingDirectory/L"DHTState.bin"))
95        {
96                try
97                {
98                        dht_state_ = haldecode(workingDirectory/L"DHTState.bin");
99                }               
100                catch(const std::exception& e)
101                {
102                        event_log.post(shared_ptr<EventDetail>(
103                                new EventStdException(event_logger::critical, e, L"Loading DHTState.bin")));
104                }
105        }
106       
107        {       libt::session_settings settings = session_.settings();
108                settings.user_agent = string("Halite ") + HALITE_VERSION_STRING;
109                session_.set_settings(settings);
110        }
111       
112        start_alert_handler();
113}
114
115bit_impl::~bit_impl()
116{
117        stop_alert_handler();
118       
119        //save_torrent_data();
120       
121        try
122        {
123       
124        if (ip_filter_changed_)
125        {       
126                fs::ofstream ofs(workingDirectory/L"IPFilter.bin", std::ios::binary);
127//                      boost::archive::binary_oarchive oba(ofs);
128               
129                libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();   
130               
131                std::vector<libt::ip_range<boost::asio::ip::address_v4> > v4(vectors.get<0>());
132                std::vector<libt::ip_range<boost::asio::ip::address_v6> > v6(vectors.get<1>());
133               
134                v4.erase(std::remove(v4.begin(), v4.end(), 0), v4.end());
135                v6.erase(std::remove(v6.begin(), v6.end(), 0), v6.end());
136
137                write_vec_range(ofs, v4);
138//                      write_vec_range(ofs, v6);
139        }       
140        }
141        catch(std::exception& e)
142        {
143                hal::event_log.post(boost::shared_ptr<hal::EventDetail>(
144                        new hal::EventStdException(event_logger::critical, e, L"~BitTorrent_impl"))); 
145        }
146}
147
148void bit_impl::ip_filter_count()
149{
150        libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();
151       
152        vectors.get<0>().erase(std::remove(vectors.get<0>().begin(), vectors.get<0>().end(), 0),
153                vectors.get<0>().end());
154        vectors.get<1>().erase(std::remove(vectors.get<1>().begin(), vectors.get<1>().end(), 0),
155                vectors.get<1>().end());
156        ip_filter_count_ = vectors.get<0>().size() + vectors.get<1>().size();
157}
158
159void bit_impl::ip_filter_load(progress_callback fn)
160{
161        fs::ifstream ifs(workingDirectory/L"IPFilter.bin", std::ios::binary);
162        if (ifs)
163        {
164                size_t v4_size;
165                ifs >> v4_size;
166               
167                size_t total = v4_size/100;
168                size_t previous = 0;
169               
170                for(unsigned i=0; i<v4_size; ++i)
171                {
172                        if (i-previous > total)
173                        {
174                                previous = i;
175
176                                if (fn) if (fn(size_t(i/total), hal::app().res_wstr(HAL_TORRENT_LOAD_FILTERS))) break;
177                        }
178                       
179                        read_range_to_filter<boost::asio::ip::address_v4>(ifs, ip_filter_);
180                }
181        }       
182}
183
184void  bit_impl::ip_filter_import(std::vector<libt::ip_range<boost::asio::ip::address_v4> >& v4,
185        std::vector<libt::ip_range<boost::asio::ip::address_v6> >& v6)
186{
187        for(std::vector<libt::ip_range<boost::asio::ip::address_v4> >::iterator i=v4.begin();
188                i != v4.end(); ++i)
189        {
190                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked);
191        }
192/*      for(std::vector<libt::ip_range<boost::asio::ip::address_v6> >::iterator i=v6.begin();
193                i != v6.end(); ++i)
194        {
195                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked);
196        }
197*/     
198        /* Note here we do not set ip_filter_changed_ */
199}
200
201bool bit_impl::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
202{
203        try
204        {
205
206        fs::ifstream ifs(file); 
207        if (ifs)
208        {
209                boost::uintmax_t total = fs::file_size(file)/100;
210                boost::uintmax_t progress = 0;
211                boost::uintmax_t previous = 0;
212               
213                boost::regex reg("\\s*(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s*-\\s*(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s*.*");
214                boost::regex ip_reg("0*(\\d*)\\.0*(\\d*)\\.0*(\\d*)\\.0*(\\d*)");
215                boost::smatch m;
216               
217                string ip_address_line;         
218                while (!std::getline(ifs, ip_address_line).eof())
219                {               
220                        progress += (ip_address_line.length() + 2);
221                        if (progress-previous > total)
222                        {
223                                previous = progress;
224                                if (fn)
225                                {
226                                        if (fn(size_t(progress/total), hal::app().res_wstr(HAL_TORRENT_IMPORT_FILTERS))) 
227                                                break;
228                                }
229                        }
230                       
231                        if (boost::regex_match(ip_address_line, m, reg))
232                        {
233                                string first = m[1];
234                                string last = m[2];
235                               
236                                if (octalFix)
237                                {
238                                        if (boost::regex_match(first, m, ip_reg))
239                                        {
240                                                first = ((m.length(1) != 0) ? m[1] : string("0")) + "." +
241                                                                ((m.length(2) != 0) ? m[2] : string("0")) + "." +
242                                                                ((m.length(3) != 0) ? m[3] : string("0")) + "." +
243                                                                ((m.length(4) != 0) ? m[4] : string("0"));
244                                        }                                       
245                                        if (boost::regex_match(last, m, ip_reg))
246                                        {
247                                                last = ((m.length(1) != 0) ? m[1] : string("0")) + "." +
248                                                           ((m.length(2) != 0) ? m[2] : string("0")) + "." +
249                                                           ((m.length(3) != 0) ? m[3] : string("0")) + "." +
250                                                           ((m.length(4) != 0) ? m[4] : string("0"));
251                                        }
252                                }
253                               
254                                try
255                                {                       
256                                ip_filter_.add_rule(boost::asio::ip::address_v4::from_string(first),
257                                        boost::asio::ip::address_v4::from_string(last), libt::ip_filter::blocked);     
258                                }
259                                catch(...)
260                                {
261                                        hal::event_log.post(shared_ptr<hal::EventDetail>(
262                                                new hal::EventDebug(hal::event_logger::info, 
263                                                from_utf8((boost::format("Invalid IP range: %1%-%2%.") % first % last).str()))));
264                                }
265                        }
266                }
267        }
268       
269        ip_filter_changed_ = true;
270        ip_filter_count();
271       
272        }
273        catch(const std::exception& e)
274        {
275                event_log.post(shared_ptr<EventDetail>(
276                        new EventStdException(event_logger::critical, e, L"ip_filter_import_dat")));
277        }
278
279        return false;
280}
281
282bool bit_impl::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn)
283{               
284try
285{
286        libt::file_storage fs;
287        libt::file_pool f_pool;
288
289        HAL_DEV_MSG(L"Files");
290        for (file_size_pairs_t::const_iterator i = params.file_size_pairs.begin(), e = params.file_size_pairs.end();
291                        i != e; ++i)
292        {
293                HAL_DEV_MSG(hal::wform(L"file path: %1%, size: %2%") % (*i).first % (*i).second);
294                fs.add_file(to_utf8((*i).first.string()), (*i).second);
295        }
296
297        int piece_size = params.piece_size;
298        HAL_DEV_MSG(hal::wform(L"piece size: %1%") % piece_size);
299       
300        libt::create_torrent t(fs, piece_size);
301       
302/*      boost::scoped_ptr<libt::storage_interface> store(
303                libt::default_storage_constructor(t_info, to_utf8(params.root_path.string()),
304                        f_pool));
305*/
306        HAL_DEV_MSG(L"Trackers");
307        for (tracker_details_t::const_iterator i = params.trackers.begin(), e = params.trackers.end();
308                        i != e; ++i)
309        {
310                HAL_DEV_MSG(hal::wform(L"URL: %1%, Tier: %2%") % (*i).url % (*i).tier);
311                t.add_tracker(to_utf8((*i).url), (*i).tier);
312        }
313
314        HAL_DEV_MSG(L"Web Seeds");
315        for (web_seed_details_t::const_iterator i = params.web_seeds.begin(), e = params.web_seeds.end();
316                        i != e; ++i)
317        {
318                HAL_DEV_MSG(hal::wform(L"URL: %1%") % (*i).url);
319                t.add_url_seed(to_utf8((*i).url));
320        }
321
322        HAL_DEV_MSG(L"DHT Nodes");
323        for (dht_node_details_t::const_iterator i = params.dht_nodes.begin(), e = params.dht_nodes.end();
324                        i != e; ++i)
325        {
326                HAL_DEV_MSG(hal::wform(L"URL: %1%, port: %2%") % (*i).url % (*i).port);
327                t.add_node(hal::make_pair(to_utf8((*i).url), (*i).port));
328        }
329
330        boost::scoped_ptr<libt::storage_interface> store(
331                default_storage_constructor(const_cast<libt::file_storage&>(t.files()), to_utf8(params.root_path.string()),
332                        f_pool));
333
334        // calculate the hash for all pieces
335        int num = t.num_pieces();
336        std::vector<char> piece_buf(t.piece_length());
337
338        for (int i = 0; i < num; ++i)
339        {
340                store->read(&piece_buf[0], i, 0, t.piece_size(i));
341
342                libt::hasher h(&piece_buf[0], t.piece_size(i));
343                t.set_hash(i, h.final());
344
345                if (fn(100*i / num, hal::app().res_wstr(HAL_NEWT_HASHING_PIECES)))
346                {
347                        // User canceled torrent creation.
348
349                        hal::event_log.post(shared_ptr<hal::EventDetail>(
350                                new hal::EventMsg(hal::app().res_wstr(HAL_NEWT_CREATION_CANCELED), hal::event_logger::info)));
351
352                        return true;
353                }
354        }
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        halencode(out_file, e);
364
365        }
366        catch(const std::exception& e)
367        {
368                event_log.post(shared_ptr<EventDetail>(
369                        new EventStdException(event_logger::fatal, e, L"create_torrent")));
370        }       
371
372        return false;
373}
374
375
376void bit_impl::start_alert_handler()
377{
378        mutex_t::scoped_lock l(mutex_);
379       
380        HAL_DEV_MSG(hal::wform(L"start_alert_handler"));
381
382
383        boost::function<void (void)> f = bind(&bit_impl::alert_handler, this);
384
385        keepChecking_ = true;
386        alert_checker_ = boost::in_place<boost::function<void (void)> >(bind(&bit_impl::alert_handler, this));
387}
388       
389void bit_impl::stop_alert_handler()
390{
391        mutex_t::scoped_lock l(mutex_);
392
393        keepChecking_ = false;
394
395        if (alert_checker_)
396        {
397                alert_checker_->interrupt();
398                alert_checker_ = boost::none;
399        }
400}
401       
402void bit_impl::alert_handler()
403{
404        while (keepChecking_)
405        {
406       
407        std::auto_ptr<libt::alert> p_alert = session_.pop_alert();
408       
409        class AlertHandler
410        {
411        public:
412        AlertHandler(bit_impl& bit_impl) :
413                bit_impl_(bit_impl)
414        {}
415
416        void operator()(libt::external_ip_alert const& a) const
417        {
418                event_log.post(shared_ptr<EventDetail>(
419                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
420                                hal::wform(hal::app().res_wstr(HAL_EXTERNAL_IP_ALERT))
421                                        % hal::from_utf8_safe(a.message())
422                                        % hal::from_utf8_safe(a.external_address.to_string()))
423                )       );                             
424        }
425
426        void operator()(libt::portmap_error_alert const& a) const
427        {
428                event_log.post(shared_ptr<EventDetail>(
429                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
430                                hal::wform(hal::app().res_wstr(HAL_PORTMAP_ERROR_ALERT))
431                                % (a.type == 0 ? 
432                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_PMP) : 
433                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_UPNP)))
434                )       );                             
435        }
436
437        void operator()(libt::portmap_alert const& a) const
438        {
439                event_log.post(shared_ptr<EventDetail>(
440                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
441                                hal::wform(hal::app().res_wstr(HAL_PORTMAP_ALERT))
442                                % (a.type == 0 ? 
443                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_PMP) : 
444                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_UPNP))
445                                % a.external_port)
446                )       );                             
447        }
448       
449        void operator()(libt::file_error_alert const& a) const
450        {
451                event_log.post(shared_ptr<EventDetail>(
452                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
453                                hal::wform(hal::app().res_wstr(HAL_FILE_ERROR_ALERT))
454                                % hal::from_utf8_safe(a.file)
455                                % hal::from_utf8_safe(a.msg))
456                )       );                             
457        }
458       
459        void operator()(libt::dht_reply_alert const& a) const
460        {
461                event_log.post(shared_ptr<EventDetail>(
462                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
463                                hal::wform(hal::app().res_wstr(HAL_DHT_REPLY_ALERT))
464                                        % a.num_peers)
465                )       );                             
466        }
467
468        void operator()(libt::torrent_finished_alert const& a) const
469        {
470                HAL_DEV_MSG(L"torrent_finished_alert");
471
472                event_log.post(shared_ptr<EventDetail>(
473                        new EventMsg((hal::wform(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED)) 
474                                        % get(a.handle)->name()), 
475                                event_logger::info, a.timestamp())));
476               
477                get(a.handle)->finished();     
478        }
479       
480        void operator()(libt::torrent_paused_alert const& a) const
481        {
482                HAL_DEV_MSG(L"torrent_paused_alert");
483
484                event_log.post(shared_ptr<EventDetail>(
485                        new EventMsg((hal::wform(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED)) 
486                                        % get(a.handle)->name()), 
487                                event_logger::info, a.timestamp())));
488
489                get(a.handle)->signals().torrent_paused();
490        }
491       
492        void operator()(libt::peer_error_alert const& a) const
493        {
494                event_log.post(shared_ptr<EventDetail>(
495                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
496                                hal::wform(hal::app().res_wstr(HAL_PEER_ALERT))
497                                        % hal::from_utf8_safe(a.message())
498                                        % hal::from_utf8_safe(a.ip.address().to_string()))
499                )       );                             
500        }
501               
502        void operator()(libt::peer_ban_alert const& a) const
503        {
504                event_log.post(shared_ptr<EventDetail>(
505                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
506                                hal::wform(hal::app().res_wstr(HAL_PEER_BAN_ALERT))
507                                        % get(a.handle)->name()
508                                        % hal::from_utf8_safe(a.ip.address().to_string()))
509                )       );                             
510        }
511               
512        void operator()(libt::hash_failed_alert const& a) const
513        {
514                event_log.post(shared_ptr<EventDetail>(
515                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
516                                hal::wform(hal::app().res_wstr(HAL_HASH_FAIL_ALERT))
517                                        % get(a.handle)->name()
518                                        % a.piece_index)
519                )       );                             
520        }
521               
522        void operator()(libt::url_seed_alert const& a) const
523        {
524                event_log.post(shared_ptr<EventDetail>(
525                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
526                                hal::wform(hal::app().res_wstr(HAL_URL_SEED_ALERT))
527                                        % get(a.handle)->name()
528                                        % hal::from_utf8_safe(a.url)
529                                        % hal::from_utf8_safe(a.message()))
530                )       );                             
531        }
532       
533        void operator()(libt::tracker_warning_alert const& a) const
534        {
535                event_log.post(shared_ptr<EventDetail>(
536                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
537                                hal::wform(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT))
538                                        % get(a.handle)->name()
539                                        % hal::from_utf8_safe(a.message()))
540                )       );                             
541        }
542       
543        void operator()(libt::tracker_announce_alert const& a) const
544        {
545                HAL_DEV_MSG(hal::wform(L"HAL_TRACKER_ANNOUNCE_ALERT"));
546
547                event_log.post(shared_ptr<EventDetail>(
548                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT)) 
549                                        % get(a.handle)->name()), 
550                                event_logger::info, a.timestamp())));
551        }
552       
553        void operator()(libt::tracker_error_alert const& a) const
554        {
555                event_log.post(shared_ptr<EventDetail>(
556                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
557                                hal::wform(hal::app().res_wstr(HAL_TRACKER_ALERT))
558                                        % get(a.handle)->name()
559                                        % hal::from_utf8_safe(a.message())
560                                        % a.times_in_row
561                                        % a.status_code)
562                )       );                             
563        }
564       
565        void operator()(libt::tracker_reply_alert const& a) const
566        {
567                event_log.post(shared_ptr<EventDetail>(
568                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
569                                hal::wform(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT))
570                                        % get(a.handle)->name()
571                                        % hal::from_utf8_safe(a.message())
572                                        % a.num_peers)
573                )       );                             
574        }
575       
576        void operator()(libt::save_resume_data_alert const& a) const
577        {
578                event_log.post(shared_ptr<EventDetail>(
579                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
580                                hal::wform(hal::app().res_wstr(HAL_FAST_RESUME_ALERT))
581                                        % get(a.handle)->name()
582                                        % hal::from_utf8_safe(a.message()))
583                )       );             
584        }
585       
586        void operator()(libt::fastresume_rejected_alert const& a) const
587        {
588                event_log.post(shared_ptr<EventDetail>(
589                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
590                                hal::wform(hal::app().res_wstr(HAL_FAST_RESUME_ALERT))
591                                        % get(a.handle)->name()
592                                        % hal::from_utf8_safe(a.message()))
593                )       );                             
594        }
595       
596        void operator()(libt::piece_finished_alert const& a) const
597        {
598                event_log.post(shared_ptr<EventDetail>(
599                        new EventGeneral(event_logger::debug, a.timestamp(),
600                                hal::wform(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT))
601                                        % get(a.handle)->name()
602                                        % a.piece_index)
603                )       );                             
604        }
605       
606        void operator()(libt::block_finished_alert const& a) const
607        {
608                event_log.post(shared_ptr<EventDetail>(
609                        new EventGeneral(event_logger::debug, a.timestamp(),
610                                hal::wform(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT))
611                                        % get(a.handle)->name()
612                                        % a.block_index
613                                        % a.piece_index)
614                )       );                             
615        }
616       
617        void operator()(libt::block_downloading_alert const& a) const
618        {
619                event_log.post(shared_ptr<EventDetail>(
620                        new EventGeneral(event_logger::debug, a.timestamp(),
621                                hal::wform(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT))
622                                        % get(a.handle)->name()
623                                        % a.block_index
624                                        % a.piece_index)
625                )       );                             
626        }
627       
628        void operator()(libt::listen_failed_alert const& a) const
629        {
630                if (a.endpoint.address().is_v6())
631                {       
632                        event_log.post(shared_ptr<EventDetail>(
633                                new EventGeneral(event_logger::info, a.timestamp(),
634                                        hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT))
635                        )       );             
636                }
637                else
638                {
639                        event_log.post(shared_ptr<EventDetail>(
640                                new EventGeneral(event_logger::info, a.timestamp(),
641                                        hal::wform(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT))
642                                                % hal::from_utf8_safe(a.message()))
643                        )       );
644                }
645        }
646       
647        void operator()(libt::listen_succeeded_alert const& a) const
648        {
649                event_log.post(shared_ptr<EventDetail>(
650                        new EventGeneral(event_logger::info, a.timestamp(),
651                                hal::wform(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT))
652                                        % hal::from_utf8_safe(a.message()))
653                )       );     
654
655                bit_impl_.signals.successful_listen();
656        }
657       
658        void operator()(libt::peer_blocked_alert const& a) const
659        {
660                event_log.post(shared_ptr<EventDetail>(
661                        new EventGeneral(event_logger::debug, a.timestamp(),
662                                hal::wform(hal::app().res_wstr(HAL_IPFILTER_ALERT))
663                                        % hal::from_utf8_safe(a.ip.to_string())
664                                        % hal::from_utf8_safe(a.message()))
665                )       );                             
666        }
667       
668/*      void operator()(libt::alert const& a) const
669        {
670                event_log.post(shared_ptr<EventDetail>(
671                                new EventLibtorrent(lbtAlertToHalEvent(a.severity()),
672                                        a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.message()))));         
673        }*/
674       
675        private:
676                bit_impl& bit_impl_;
677               
678                torrent_internal_ptr get(libt::torrent_handle h) const 
679                { 
680                        return bit_impl_.the_torrents_.get(from_utf8_safe(h.get_torrent_info().name())); 
681                }
682       
683        } handler(*this);
684       
685        while (p_alert.get())
686        {       
687                try
688                {
689                mutex_t::scoped_lock l(mutex_);
690       
691                HAL_DEV_MSG(hal::wform(L"DEV_MSG: %1%") % from_utf8(p_alert->message()));
692               
693                libt::handle_alert<
694                        libt::save_resume_data_alert,
695                        libt::external_ip_alert,
696                        libt::portmap_error_alert,
697                        libt::portmap_alert,
698                        libt::file_error_alert,
699                        libt::torrent_finished_alert,
700                        libt::torrent_paused_alert,
701                        libt::peer_error_alert,
702                        libt::peer_ban_alert,
703                        libt::hash_failed_alert,
704                        libt::url_seed_alert,
705                        libt::dht_reply_alert,
706                        libt::tracker_error_alert,
707                        libt::tracker_warning_alert,
708                        libt::tracker_announce_alert,
709                        libt::tracker_reply_alert,
710                        libt::fastresume_rejected_alert,
711                        libt::piece_finished_alert,
712                        libt::block_finished_alert,
713                        libt::block_downloading_alert,
714                        libt::listen_failed_alert,
715                        libt::listen_succeeded_alert,
716                        libt::peer_blocked_alert
717                >::handle_alert(p_alert, handler);                     
718               
719                }
720                catch(libt::unhandled_alert&)
721                {
722//                      handler(*p_alert);
723                }
724                catch(std::exception& e)
725                {
726                        // These are logged as debug because they are rarely important to act on!
727                        event_log.post(shared_ptr<EventDetail>(\
728                                new EventStdException(event_logger::debug, e, L"alertHandler")));
729                }
730               
731                p_alert = session_.pop_alert();
732
733                boost::this_thread::interruption_point();
734        }       
735       
736        }
737}
738
739}
Note: See TracBrowser for help on using the repository browser.