source: trunk/src/halSession.cpp @ 590

Revision 590, 21.2 KB checked in by Eoin, 12 years ago (diff)

Supporting the new libtorrent interface to fast resume data. Not yet working!

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