source: trunk/src/halSession.cpp @ 496

Revision 496, 13.7 KB checked in by Eoin, 11 years ago (diff)

Added more alert reports.

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 <libtorrent/alert_types.hpp>
12#include <libtorrent/entry.hpp>
13#include <libtorrent/session.hpp>
14#include <libtorrent/ip_filter.hpp>
15#include <libtorrent/torrent_handle.hpp>
16
17#include "global/wtl_app.hpp"
18#include "global/string_conv.hpp"
19#include "global/ini_adapter.hpp"
20
21#include "halIni.hpp"
22#include "halTypes.hpp"
23#include "halEvent.hpp"
24#include "halSignaler.hpp"
25#include "halSession.hpp"
26
27namespace hal
28{
29
30void bit_impl::ip_filter_count()
31{
32        libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();
33       
34        vectors.get<0>().erase(std::remove(vectors.get<0>().begin(), vectors.get<0>().end(), 0),
35                vectors.get<0>().end());
36        vectors.get<1>().erase(std::remove(vectors.get<1>().begin(), vectors.get<1>().end(), 0),
37                vectors.get<1>().end());
38        ip_filter_count_ = vectors.get<0>().size() + vectors.get<1>().size();
39}
40
41void bit_impl::ip_filter_load(progress_callback fn)
42{
43        fs::ifstream ifs(workingDirectory/L"IPFilter.bin", std::ios::binary);
44        if (ifs)
45        {
46                size_t v4_size;
47                ifs >> v4_size;
48               
49                size_t total = v4_size/100;
50                size_t previous = 0;
51               
52                for(unsigned i=0; i<v4_size; ++i)
53                {
54                        if (i-previous > total)
55                        {
56                                previous = i;
57
58                                if (fn) if (fn(size_t(i/total), hal::app().res_wstr(HAL_TORRENT_LOAD_FILTERS))) break;
59                        }
60                       
61                        read_range_to_filter<asio::ip::address_v4>(ifs, ip_filter_);
62                }
63        }       
64}
65
66void  bit_impl::ip_filter_import(std::vector<libt::ip_range<asio::ip::address_v4> >& v4,
67        std::vector<libt::ip_range<asio::ip::address_v6> >& v6)
68{
69        for(std::vector<libt::ip_range<asio::ip::address_v4> >::iterator i=v4.begin();
70                i != v4.end(); ++i)
71        {
72                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked);
73        }
74/*      for(std::vector<libt::ip_range<asio::ip::address_v6> >::iterator i=v6.begin();
75                i != v6.end(); ++i)
76        {
77                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked);
78        }
79*/     
80        /* Note here we do not set ip_filter_changed_ */
81}
82
83bool bit_impl::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
84{
85        try
86        {
87
88        fs::ifstream ifs(file); 
89        if (ifs)
90        {
91                boost::uintmax_t total = fs::file_size(file)/100;
92                boost::uintmax_t progress = 0;
93                boost::uintmax_t previous = 0;
94               
95                boost::regex reg("\\s*(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s*-\\s*(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s*.*");
96                boost::regex ip_reg("0*(\\d*)\\.0*(\\d*)\\.0*(\\d*)\\.0*(\\d*)");
97                boost::smatch m;
98               
99                string ip_address_line;         
100                while (!std::getline(ifs, ip_address_line).eof())
101                {               
102                        progress += (ip_address_line.length() + 2);
103                        if (progress-previous > total)
104                        {
105                                previous = progress;
106                                if (fn)
107                                {
108                                        if (fn(size_t(progress/total), hal::app().res_wstr(HAL_TORRENT_IMPORT_FILTERS))) 
109                                                break;
110                                }
111                        }
112                       
113                        if (boost::regex_match(ip_address_line, m, reg))
114                        {
115                                string first = m[1];
116                                string last = m[2];
117                               
118                                if (octalFix)
119                                {
120                                        if (boost::regex_match(first, m, ip_reg))
121                                        {
122                                                first = ((m.length(1) != 0) ? m[1] : string("0")) + "." +
123                                                                ((m.length(2) != 0) ? m[2] : string("0")) + "." +
124                                                                ((m.length(3) != 0) ? m[3] : string("0")) + "." +
125                                                                ((m.length(4) != 0) ? m[4] : string("0"));
126                                        }                                       
127                                        if (boost::regex_match(last, m, ip_reg))
128                                        {
129                                                last = ((m.length(1) != 0) ? m[1] : string("0")) + "." +
130                                                           ((m.length(2) != 0) ? m[2] : string("0")) + "." +
131                                                           ((m.length(3) != 0) ? m[3] : string("0")) + "." +
132                                                           ((m.length(4) != 0) ? m[4] : string("0"));
133                                        }
134                                }
135                               
136                                try
137                                {                       
138                                ip_filter_.add_rule(asio::ip::address_v4::from_string(first),
139                                        asio::ip::address_v4::from_string(last), libt::ip_filter::blocked);     
140                                }
141                                catch(...)
142                                {
143                                        hal::event_log.post(shared_ptr<hal::EventDetail>(
144                                                new hal::EventDebug(hal::event_logger::info, 
145                                                        from_utf8((format("Invalid IP range: %1%-%2%.") % first % last).str()))));
146                                }
147                        }
148                }
149        }
150       
151        ip_filter_changed_ = true;
152        ip_filter_count();
153       
154        }
155        catch(const std::exception& e)
156        {
157                event_log.post(shared_ptr<EventDetail>(
158                        new EventStdException(event_logger::critical, e, L"ip_filter_import_dat")));
159        }
160
161        return false;
162}
163
164void bit_impl::stop_alert_handler()
165{
166        mutex_t::scoped_lock l(mutex_);
167
168        keepChecking_ = false;
169}
170       
171void bit_impl::alert_handler()
172{
173        mutex_t::scoped_lock l(mutex_);
174
175        if (keepChecking_)
176        {
177       
178        std::auto_ptr<libt::alert> p_alert = session_.pop_alert();
179       
180        class AlertHandler
181        {
182        public:
183        AlertHandler(bit_impl& bit_impl) :
184                bit_impl_(bit_impl)
185        {}
186
187        void operator()(libt::external_ip_alert const& a) const
188        {
189                event_log.post(shared_ptr<EventDetail>(
190                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
191                                wformat(hal::app().res_wstr(HAL_EXTERNAL_IP_ALERT))
192                                        % hal::from_utf8_safe(a.message())
193                                        % hal::from_utf8_safe(a.external_address.to_string()))
194                )       );                             
195        }
196
197        void operator()(libt::portmap_error_alert const& a) const
198        {
199                event_log.post(shared_ptr<EventDetail>(
200                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
201                                wformat(hal::app().res_wstr(HAL_PORTMAP_ERROR_ALERT))
202                                % (a.type == 0 ? 
203                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_PMP) : 
204                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_UPNP)))
205                )       );                             
206        }
207
208        void operator()(libt::portmap_alert const& a) const
209        {
210                event_log.post(shared_ptr<EventDetail>(
211                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
212                                wformat(hal::app().res_wstr(HAL_PORTMAP_ALERT))
213                                % (a.type == 0 ? 
214                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_PMP) : 
215                                        hal::app().res_wstr(HAL_PORTMAP_TYPE_UPNP))
216                                % a.external_port)
217                )       );                             
218        }
219       
220        void operator()(libt::file_error_alert const& a) const
221        {
222                event_log.post(shared_ptr<EventDetail>(
223                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
224                                wformat(hal::app().res_wstr(HAL_FILE_ERROR_ALERT))
225                                % hal::from_utf8_safe(a.file)
226                                % hal::from_utf8_safe(a.msg))
227                )       );                             
228        }
229       
230        void operator()(libt::dht_reply_alert const& a) const
231        {
232                event_log.post(shared_ptr<EventDetail>(
233                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
234                                wformat(hal::app().res_wstr(HAL_DHT_REPLY_ALERT))
235                                        % a.num_peers)
236                )       );                             
237        }
238
239        void operator()(libt::torrent_finished_alert const& a) const
240        {
241                event_log.post(shared_ptr<EventDetail>(
242                        new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED)) 
243                                        % get(a.handle)->name()), 
244                                event_logger::info, a.timestamp())));
245               
246                get(a.handle)->finished();     
247        }
248       
249        void operator()(libt::torrent_paused_alert const& a) const
250        {
251                event_log.post(shared_ptr<EventDetail>(
252                        new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED)) 
253                                        % get(a.handle)->name()), 
254                                event_logger::info, a.timestamp())));
255
256                get(a.handle)->signals().torrent_paused();
257        }
258       
259        void operator()(libt::peer_error_alert const& a) const
260        {
261                event_log.post(shared_ptr<EventDetail>(
262                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
263                                wformat(hal::app().res_wstr(HAL_PEER_ALERT))
264                                        % hal::from_utf8_safe(a.message())
265                                        % hal::from_utf8_safe(a.ip.address().to_string()))
266                )       );                             
267        }
268               
269        void operator()(libt::peer_ban_alert const& a) const
270        {
271                event_log.post(shared_ptr<EventDetail>(
272                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
273                                wformat(hal::app().res_wstr(HAL_PEER_BAN_ALERT))
274                                        % get(a.handle)->name()
275                                        % hal::from_utf8_safe(a.ip.address().to_string()))
276                )       );                             
277        }
278               
279        void operator()(libt::hash_failed_alert const& a) const
280        {
281                event_log.post(shared_ptr<EventDetail>(
282                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
283                                wformat(hal::app().res_wstr(HAL_HASH_FAIL_ALERT))
284                                        % get(a.handle)->name()
285                                        % a.piece_index)
286                )       );                             
287        }
288               
289        void operator()(libt::url_seed_alert const& a) const
290        {
291                event_log.post(shared_ptr<EventDetail>(
292                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
293                                wformat(hal::app().res_wstr(HAL_URL_SEED_ALERT))
294                                        % get(a.handle)->name()
295                                        % hal::from_utf8_safe(a.url)
296                                        % hal::from_utf8_safe(a.message()))
297                )       );                             
298        }
299       
300        void operator()(libt::tracker_warning_alert const& a) const
301        {
302                event_log.post(shared_ptr<EventDetail>(
303                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
304                                wformat(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT))
305                                        % get(a.handle)->name()
306                                        % hal::from_utf8_safe(a.message()))
307                )       );                             
308        }
309       
310        void operator()(libt::tracker_announce_alert const& a) const
311        {
312                event_log.post(shared_ptr<EventDetail>(
313                        new EventMsg((wformat(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT)) 
314                                        % get(a.handle)->name()), 
315                                event_logger::info, a.timestamp())));
316        }
317       
318        void operator()(libt::tracker_error_alert const& a) const
319        {
320                event_log.post(shared_ptr<EventDetail>(
321                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
322                                wformat(hal::app().res_wstr(HAL_TRACKER_ALERT))
323                                        % get(a.handle)->name()
324                                        % hal::from_utf8_safe(a.message())
325                                        % a.times_in_row
326                                        % a.status_code)
327                )       );                             
328        }
329       
330        void operator()(libt::tracker_reply_alert const& a) const
331        {
332                event_log.post(shared_ptr<EventDetail>(
333                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
334                                wformat(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT))
335                                        % get(a.handle)->name()
336                                        % hal::from_utf8_safe(a.message())
337                                        % a.num_peers)
338                )       );                             
339        }
340       
341        void operator()(libt::fastresume_rejected_alert const& a) const
342        {
343                event_log.post(shared_ptr<EventDetail>(
344                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
345                                wformat(hal::app().res_wstr(HAL_FAST_RESUME_ALERT))
346                                        % get(a.handle)->name()
347                                        % hal::from_utf8_safe(a.message()))
348                )       );                             
349        }
350       
351        void operator()(libt::piece_finished_alert const& a) const
352        {
353                event_log.post(shared_ptr<EventDetail>(
354                        new EventGeneral(event_logger::debug, a.timestamp(),
355                                wformat(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT))
356                                        % get(a.handle)->name()
357                                        % a.piece_index)
358                )       );                             
359        }
360       
361        void operator()(libt::block_finished_alert const& a) const
362        {
363                event_log.post(shared_ptr<EventDetail>(
364                        new EventGeneral(event_logger::debug, a.timestamp(),
365                                wformat(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT))
366                                        % get(a.handle)->name()
367                                        % a.block_index
368                                        % a.piece_index)
369                )       );                             
370        }
371       
372        void operator()(libt::block_downloading_alert const& a) const
373        {
374                event_log.post(shared_ptr<EventDetail>(
375                        new EventGeneral(event_logger::debug, a.timestamp(),
376                                wformat(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT))
377                                        % get(a.handle)->name()
378                                        % a.block_index
379                                        % a.piece_index)
380                )       );                             
381        }
382       
383        void operator()(libt::listen_failed_alert const& a) const
384        {
385                if (a.endpoint.address().is_v6())
386                {       
387                        event_log.post(shared_ptr<EventDetail>(
388                                new EventGeneral(event_logger::info, a.timestamp(),
389                                        hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT))
390                        )       );             
391                }
392                else
393                {
394                        event_log.post(shared_ptr<EventDetail>(
395                                new EventGeneral(event_logger::info, a.timestamp(),
396                                        wformat(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT))
397                                                % hal::from_utf8_safe(a.message()))
398                        )       );
399                }
400        }
401       
402        void operator()(libt::listen_succeeded_alert const& a) const
403        {
404                event_log.post(shared_ptr<EventDetail>(
405                        new EventGeneral(event_logger::info, a.timestamp(),
406                                wformat(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT))
407                                        % hal::from_utf8_safe(a.message()))
408                )       );     
409
410                bit_impl_.signals.successful_listen();
411        }
412       
413        void operator()(libt::peer_blocked_alert const& a) const
414        {
415                event_log.post(shared_ptr<EventDetail>(
416                        new EventGeneral(event_logger::debug, a.timestamp(),
417                                wformat(hal::app().res_wstr(HAL_IPFILTER_ALERT))
418                                        % hal::from_utf8_safe(a.ip.to_string())
419                                        % hal::from_utf8_safe(a.message()))
420                )       );                             
421        }
422       
423        void operator()(libt::alert const& a) const
424        {
425                event_log.post(shared_ptr<EventDetail>(
426                                new EventLibtorrent(lbtAlertToHalEvent(a.severity()), 
427                                        a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.message()))));         
428        }
429       
430        private:
431                bit_impl& bit_impl_;
432               
433                torrent_internal_ptr get(libt::torrent_handle h) const 
434                { 
435                        return bit_impl_.the_torrents_.get(from_utf8_safe(h.get_torrent_info().name())); 
436                }
437       
438        } handler(*this);
439       
440        while (p_alert.get())
441        {       
442                try
443                {
444               
445                libt::handle_alert<
446                        libt::external_ip_alert,
447                        libt::portmap_error_alert,
448                        libt::portmap_alert,
449                        libt::file_error_alert,
450                        libt::torrent_finished_alert,
451                        libt::torrent_paused_alert,
452                        libt::peer_error_alert,
453                        libt::peer_ban_alert,
454                        libt::hash_failed_alert,
455                        libt::url_seed_alert,
456                        libt::dht_reply_alert,
457                        libt::tracker_error_alert,
458                        libt::tracker_warning_alert,
459                        libt::tracker_announce_alert,
460                        libt::tracker_reply_alert,
461                        libt::fastresume_rejected_alert,
462                        libt::piece_finished_alert,
463                        libt::block_finished_alert,
464                        libt::block_downloading_alert,
465                        libt::listen_failed_alert,
466                        libt::listen_succeeded_alert,
467                        libt::peer_blocked_alert,
468                        libt::alert
469                >::handle_alert(p_alert, handler);                     
470               
471                }
472                catch(libt::unhandled_alert&)
473                {
474                        handler(*p_alert);
475                }
476                catch(std::exception& e)
477                {
478                        // These are logged as debug because they are rarely important to act on!
479                        event_log.post(shared_ptr<EventDetail>(\
480                                new EventStdException(event_logger::debug, e, L"alertHandler")));
481                }
482               
483                p_alert = session_.pop_alert();
484        }
485       
486        timer_.expires_from_now(boost::posix_time::seconds(2));
487        timer_.async_wait(bind(&bit_impl::alert_handler, this));
488        }
489}
490
491}
Note: See TracBrowser for help on using the repository browser.