source: trunk/src/halSession.cpp @ 484

Revision 484, 11.9 KB checked in by Eoin, 12 years ago (diff)

Compiling against 1.35

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 20
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::torrent_finished_alert const& a) const
188        {
189                event_log.post(shared_ptr<EventDetail>(
190                        new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED)) 
191                                        % get(a.handle)->name()), 
192                                event_logger::info, a.timestamp())));
193               
194                get(a.handle)->finished();     
195        }
196       
197        void operator()(libt::torrent_paused_alert const& a) const
198        {
199                event_log.post(shared_ptr<EventDetail>(
200                        new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED)) 
201                                        % get(a.handle)->name()), 
202                                event_logger::info, a.timestamp())));
203
204                get(a.handle)->signals().torrent_paused();
205        }
206       
207        void operator()(libt::peer_error_alert const& a) const
208        {
209                event_log.post(shared_ptr<EventDetail>(
210                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
211                                wformat(hal::app().res_wstr(HAL_PEER_ALERT))
212                                        % hal::from_utf8_safe(a.msg())
213                                        % hal::from_utf8_safe(a.ip.address().to_string()))
214                )       );                             
215        }
216               
217        void operator()(libt::peer_ban_alert const& a) const
218        {
219                event_log.post(shared_ptr<EventDetail>(
220                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
221                                wformat(hal::app().res_wstr(HAL_PEER_BAN_ALERT))
222                                        % get(a.handle)->name()
223                                        % hal::from_utf8_safe(a.ip.address().to_string()))
224                )       );                             
225        }
226               
227        void operator()(libt::hash_failed_alert const& a) const
228        {
229                event_log.post(shared_ptr<EventDetail>(
230                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
231                                wformat(hal::app().res_wstr(HAL_HASH_FAIL_ALERT))
232                                        % get(a.handle)->name()
233                                        % a.piece_index)
234                )       );                             
235        }
236               
237        void operator()(libt::url_seed_alert const& a) const
238        {
239                event_log.post(shared_ptr<EventDetail>(
240                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
241                                wformat(hal::app().res_wstr(HAL_URL_SEED_ALERT))
242                                        % get(a.handle)->name()
243                                        % hal::from_utf8_safe(a.url)
244                                        % hal::from_utf8_safe(a.msg()))
245                )       );                             
246        }
247       
248        void operator()(libt::tracker_warning_alert const& a) const
249        {
250                event_log.post(shared_ptr<EventDetail>(
251                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
252                                wformat(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT))
253                                        % get(a.handle)->name()
254                                        % hal::from_utf8_safe(a.msg()))
255                )       );                             
256        }
257       
258        void operator()(libt::tracker_announce_alert const& a) const
259        {
260                event_log.post(shared_ptr<EventDetail>(
261                        new EventMsg((wformat(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT)) 
262                                        % get(a.handle)->name()), 
263                                event_logger::info, a.timestamp())));
264        }
265       
266        void operator()(libt::tracker_error_alert const& a) const
267        {
268                event_log.post(shared_ptr<EventDetail>(
269                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
270                                wformat(hal::app().res_wstr(HAL_TRACKER_ALERT))
271                                        % get(a.handle)->name()
272                                        % hal::from_utf8_safe(a.msg())
273                                        % a.times_in_row
274                                        % a.status_code)
275                )       );                             
276        }
277       
278        void operator()(libt::tracker_reply_alert const& a) const
279        {
280                event_log.post(shared_ptr<EventDetail>(
281                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
282                                wformat(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT))
283                                        % get(a.handle)->name()
284                                        % hal::from_utf8_safe(a.msg())
285                                        % a.num_peers)
286                )       );                             
287        }
288       
289        void operator()(libt::fastresume_rejected_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_FAST_RESUME_ALERT))
294                                        % get(a.handle)->name()
295                                        % hal::from_utf8_safe(a.msg()))
296                )       );                             
297        }
298       
299        void operator()(libt::piece_finished_alert const& a) const
300        {
301                event_log.post(shared_ptr<EventDetail>(
302                        new EventGeneral(event_logger::debug, a.timestamp(),
303                                wformat(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT))
304                                        % get(a.handle)->name()
305                                        % a.piece_index)
306                )       );                             
307        }
308       
309        void operator()(libt::block_finished_alert const& a) const
310        {
311                event_log.post(shared_ptr<EventDetail>(
312                        new EventGeneral(event_logger::debug, a.timestamp(),
313                                wformat(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT))
314                                        % get(a.handle)->name()
315                                        % a.block_index
316                                        % a.piece_index)
317                )       );                             
318        }
319       
320        void operator()(libt::block_downloading_alert const& a) const
321        {
322                event_log.post(shared_ptr<EventDetail>(
323                        new EventGeneral(event_logger::debug, a.timestamp(),
324                                wformat(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT))
325                                        % get(a.handle)->name()
326                                        % a.block_index
327                                        % a.piece_index)
328                )       );                             
329        }
330       
331        void operator()(libt::listen_failed_alert const& a) const
332        {
333                if (a.endpoint.address().is_v6())
334                {       
335                        event_log.post(shared_ptr<EventDetail>(
336                                new EventGeneral(event_logger::info, a.timestamp(),
337                                        hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT))
338                        )       );             
339                }
340                else
341                {
342                        event_log.post(shared_ptr<EventDetail>(
343                                new EventGeneral(event_logger::info, a.timestamp(),
344                                        wformat(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT))
345                                                % hal::from_utf8_safe(a.msg()))
346                        )       );
347                }
348        }
349       
350        void operator()(libt::listen_succeeded_alert const& a) const
351        {
352                event_log.post(shared_ptr<EventDetail>(
353                        new EventGeneral(event_logger::info, a.timestamp(),
354                                wformat(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT))
355                                        % hal::from_utf8_safe(a.msg()))
356                )       );     
357
358                bit_impl_.signals.successful_listen();
359        }
360       
361        void operator()(libt::peer_blocked_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_IPFILTER_ALERT))
366                                        % hal::from_utf8_safe(a.ip.to_string())
367                                        % hal::from_utf8_safe(a.msg()))
368                )       );                             
369        }
370       
371        void operator()(libt::alert const& a) const
372        {
373                event_log.post(shared_ptr<EventDetail>(
374                                new EventLibtorrent(lbtAlertToHalEvent(a.severity()), 
375                                        a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.msg()))));             
376        }
377       
378        private:
379                bit_impl& bit_impl_;
380               
381                torrent_internal_ptr get(libt::torrent_handle h) const 
382                { 
383                        return bit_impl_.the_torrents_.get(from_utf8_safe(h.get_torrent_info().name())); 
384                }
385       
386        } handler(*this);
387       
388        while (p_alert.get())
389        {       
390                try
391                {
392               
393                libt::handle_alert<
394                        libt::torrent_finished_alert,
395                        libt::torrent_paused_alert,
396                        libt::peer_error_alert,
397                        libt::peer_ban_alert,
398                        libt::hash_failed_alert,
399                        libt::url_seed_alert,
400                        libt::tracker_error_alert,
401                        libt::tracker_warning_alert,
402                        libt::tracker_announce_alert,
403                        libt::tracker_reply_alert,
404                        libt::fastresume_rejected_alert,
405                        libt::piece_finished_alert,
406                        libt::block_finished_alert,
407                        libt::block_downloading_alert,
408                        libt::listen_failed_alert,
409                        libt::listen_succeeded_alert,
410                        libt::peer_blocked_alert,
411                        libt::alert
412                >::handle_alert(p_alert, handler);                     
413               
414                }
415                catch(libt::unhandled_alert&)
416                {
417                        handler(*p_alert);
418                }
419                catch(std::exception& e)
420                {
421                        // These are logged as debug because they are rarely important to act on!
422                        event_log.post(shared_ptr<EventDetail>(\
423                                new EventStdException(event_logger::debug, e, L"alertHandler")));
424                }
425               
426                p_alert = session_.pop_alert();
427        }
428       
429        timer_.expires_from_now(boost::posix_time::seconds(2));
430        timer_.async_wait(bind(&bit_impl::alert_handler, this));
431        }
432}
433
434}
Note: See TracBrowser for help on using the repository browser.