source: trunk/src/halSession.cpp @ 648

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