source: trunk/src/halSession.cpp @ 508

Revision 508, 20.0 KB checked in by Eoin, 12 years ago (diff)

Major SortList? de-blobbing.

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