source: trunk/src/halSession.cpp @ 564

Revision 564, 22.1 KB checked in by Eoin, 11 years ago (diff)

Added win32_exception class.

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