source: trunk/src/halSession.cpp @ 647

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