Changeset 565 for branch_0_3_1


Ignore:
Timestamp:
08/29/08 18:19:52 (11 years ago)
Author:
Eoin
Message:

Win32 exception catchers backported to branch.

Location:
branch_0_3_1
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed
  • branch_0_3_1/sln/Halite/Halite.vcproj

    r476 r565  
    548548                        </File> 
    549549                        <File 
     550                                RelativePath="..\..\src\HaliteWindow.cpp" 
     551                                > 
     552                        </File> 
     553                        <File 
    550554                                RelativePath="..\..\src\halTorrent.cpp" 
    551555                                > 
     
    625629                                > 
    626630                        </File> 
     631                        <File 
     632                                RelativePath="..\..\src\win32_exception.cpp" 
     633                                > 
     634                        </File> 
    627635                        <Filter 
    628636                                Name="advtabs" 
     
    982990                        </File> 
    983991                        <File 
    984                                 RelativePath="..\..\src\HaliteWindow.cpp" 
    985                                 > 
    986                         </File> 
    987                         <File 
    988992                                RelativePath="..\..\src\HaliteWindow.hpp" 
    989993                                > 
     
    10351039                        <File 
    10361040                                RelativePath="..\..\src\UxthemeWrapper.hpp" 
     1041                                > 
     1042                        </File> 
     1043                        <File 
     1044                                RelativePath="..\..\src\win32_exception.hpp" 
    10371045                                > 
    10381046                        </File> 
  • branch_0_3_1/src/HaliteWindow.cpp

    r523 r565  
    270270         
    271271        } 
    272         catch (std::exception& e) 
    273         { 
    274                 hal::event_log.post(shared_ptr<hal::EventDetail>(\ 
    275                         new hal::EventStdException(hal::event_logger::info, e, L"updateWindow"))); 
    276         } 
     272        HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::updateWindow()") 
    277273} 
    278274 
     
    292288         
    293289                } 
    294                 catch (std::exception& e) 
    295                 { 
    296                         hal::event_log.post(shared_ptr<hal::EventDetail>(\ 
    297                                 new hal::EventStdException(hal::event_logger::info, e, L"saveTimer"))); 
    298                 } 
     290                HAL_GENERIC_FN_EXCEPTION_CATCH(L"IniBase::OnTimer() - ID_SAVE_TIMER") 
    299291        } 
    300292        else  
     
    315307 
    316308        } 
    317         catch (std::exception& e) 
    318         { 
    319                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    320                         new hal::EventStdException(hal::event_logger::info, e, L"updateTimer"))); 
    321         } 
     309        HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::issueUiUpdate()") 
    322310} 
    323311 
     
    379367                        new hal::EventDebug(hal::event_logger::warning, L"filesystem error"))); 
    380368        } 
     369        HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::ProcessFile()") 
    381370} 
    382371 
  • branch_0_3_1/src/NewTorrentDialog.cpp

    r523 r565  
    140140 
    141141        } 
    142         catch(const std::exception& e) 
    143         { 
    144                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    145                         new hal::EventStdException(hal::event_logger::fatal, e, L"DetailsSheet::OnDirBrowse"))); 
    146         } 
     142        HAL_GENERIC_FN_EXCEPTION_CATCH(L"FilesSheet::OnDirBrowse()") 
    147143} 
    148144 
     
    187183 
    188184        } 
    189         catch(const std::exception& e) 
    190         { 
    191                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    192                         new hal::EventStdException(hal::event_logger::critical, e,  
    193                                 L"DetailsSheet::FileSizePairs"))); 
    194         } 
     185        HAL_GENERIC_FN_EXCEPTION_CATCH(L"FilesSheet::FileSizePairs()") 
    195186 
    196187        return filePairs; 
     
    427418 
    428419        } 
    429         catch(const std::exception& e) 
    430         { 
    431                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    432                         new hal::EventStdException(hal::event_logger::critical, e,  
    433                                 L"NewTorrentDialog::OnSave"))); 
    434         } 
     420        HAL_GENERIC_FN_EXCEPTION_CATCH(L"NewTorrentDialog::OnSave()") 
    435421 
    436422        return 0; 
  • branch_0_3_1/src/NewTorrentPeersLV.cpp

    r485 r565  
    9090 
    9191        } 
    92         catch(const std::exception& e) 
    93         { 
    94                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    95                         new hal::EventStdException(hal::event_logger::critical, e,  
    96                                 L"NewTorrent_PeersListViewCtrl::editItem"))); 
    97         } 
     92        HAL_GENERIC_FN_EXCEPTION_CATCH(L"NewTorrent_PeersListViewCtrl::editItem()") 
    9893} 
    9994 
  • branch_0_3_1/src/SplashDialog.hpp

    r523 r565  
    2525#endif 
    2626 
     27#include "win32_exception.hpp" 
    2728#include "halTorrent.hpp" 
    2829 
     
    109110        void SplashThread() 
    110111        { 
     112                win32_exception::install_handler(); 
     113 
     114                try 
     115                { 
     116 
    111117                hal::bittorrent().closeAll(boost::optional<boost::function<void (int)> >(bind(&SplashDialog::ReportNumActive, this, _1))); 
    112118                 
     
    122128                GetWindowRect(rect_); 
    123129                save_to_ini(); 
     130 
     131                } 
     132                HAL_GENERIC_FN_EXCEPTION_CATCH(L"SplashThread()") 
    124133 
    125134                EndDialog(0); 
  • branch_0_3_1/src/advtabs/Debug.hpp

    r485 r565  
    138138                 
    139139                } 
    140                 catch(...) 
    141                 {} 
     140                HAL_GENERIC_FN_EXCEPTION_CATCH(L"LogListViewCtrl::operator()") 
    142141        } 
    143142 
     
    163162 
    164163                } 
    165                 catch(...) 
    166                 {} 
     164                HAL_GENERIC_FN_EXCEPTION_CATCH(L"LogListViewCtrl::OnMessageLogPost()") 
    167165 
    168166                events_.pop_front(); 
  • branch_0_3_1/src/halConfig.cpp

    r523 r565  
    2424bool Config::settingsThread() 
    2525{        
    26         event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Applying BitTorrent session settings.")));         
    27  
    28         bittorrent().setMapping(mappingType);    
    29  
    30         event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    31                         hal::wform(L"Trying port in range %1% - %2%.") % portFrom % portTo))); 
    3226        try 
    3327        { 
    34         bool success = bittorrent().listenOn( 
    35                 std::make_pair(portFrom, portTo)); 
    36         if (!success) 
    37         { 
    38                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    39                         new hal::EventDebug(event_logger::critical, L"settingsThread, Init"))); 
     28                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Applying BitTorrent session settings.")));         
     29 
     30                bittorrent().setMapping(mappingType);    
     31 
     32                event_log.post(shared_ptr<EventDetail>(new EventMsg( 
     33                                hal::wform(L"Trying port in range %1% - %2%.") % portFrom % portTo))); 
     34                try 
     35                { 
     36                bool success = bittorrent().listenOn( 
     37                        std::make_pair(portFrom, portTo)); 
     38                if (!success) 
     39                { 
     40                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     41                                new hal::EventDebug(event_logger::critical, L"settingsThread, Init"))); 
     42                         
     43                        return false; 
     44                } 
     45                } 
     46                catch(const std::exception& e) 
     47                { 
     48                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     49                                new hal::EventStdException(event_logger::critical, e, L"settingsThread, Init")));  
     50                         
     51                        return false; 
     52                } 
     53 
     54                event_log.post(shared_ptr<EventDetail>(new EventMsg(hal::wform(L"Opened listen port; %1%.") % bittorrent().isListeningOn()))); 
    4055                 
    41                 return false; 
    42         } 
    43         } 
    44         catch(const std::exception& e) 
    45         { 
    46                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    47                         new hal::EventStdException(event_logger::critical, e, L"settingsThread, Init")));  
     56                try 
     57                { 
     58                if (enableIPFilter) 
     59                { 
     60                        ProgressDialog progDlg(L"Loading IP filters...", bind( 
     61                                &bit::ensureIpFilterOn, &bittorrent(), _1)); 
     62                        progDlg.DoModal(); 
     63                } 
     64                else 
     65                        bittorrent().ensureIpFilterOff(); 
     66                } 
     67                catch(const std::exception& e) 
     68                { 
     69                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     70                                new hal::EventStdException(event_logger::critical, e, L"settingsThread, Load IP Filter")));  
     71                }        
     72 
     73                try 
     74                { 
     75                if (enablePe) 
     76                { 
     77                        bittorrent().ensurePeOn(peEncLevel, peConInPolicy, peConOutPolicy, pePerferRc4); 
     78                } 
     79                else 
     80                        bittorrent().ensurePeOff(); 
     81                } 
     82                catch(const std::exception& e) 
     83                { 
     84                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     85                                        new hal::EventStdException(event_logger::critical, e, L"settingsThread, Protocol Encryption")));  
     86                } 
    4887                 
    49                 return false; 
    50         } 
     88                bittorrent().setSessionHalfOpenLimit(halfConnLimit); 
     89                 
     90                bittorrent().resumeAll();        
     91                 
     92                bittorrent().setSessionLimits( 
     93                        maxConnections, maxUploads); 
     94                bittorrent().setSessionSpeed( 
     95                        downRate, upRate); 
     96                         
     97                bittorrent().setTorrentDefaults(torrentMaxConnections, 
     98                        torrentMaxUploads, torrentDownRate, 
     99                        torrentUpRate); 
     100                 
     101                bittorrent().setDhtSettings(dhtMaxPeersReply,  
     102                        dhtSearchBranching, dhtServicePort,  
     103                        dhtMaxFailCount); 
    51104 
    52         event_log.post(shared_ptr<EventDetail>(new EventMsg(hal::wform(L"Opened listen port; %1%.") % bittorrent().isListeningOn()))); 
    53          
    54         try 
    55         { 
    56         if (enableIPFilter) 
    57         { 
    58                 ProgressDialog progDlg(L"Loading IP filters...", bind( 
    59                         &bit::ensureIpFilterOn, &bittorrent(), _1)); 
    60                 progDlg.DoModal(); 
    61         } 
    62         else 
    63                 bittorrent().ensureIpFilterOff(); 
    64         } 
    65         catch(const std::exception& e) 
    66         { 
    67                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    68                         new hal::EventStdException(event_logger::critical, e, L"settingsThread, Load IP Filter")));  
    69         }        
    70  
    71         try 
    72         { 
    73         if (enablePe) 
    74         { 
    75                 bittorrent().ensurePeOn(peEncLevel, peConInPolicy, peConOutPolicy, pePerferRc4); 
    76         } 
    77         else 
    78                 bittorrent().ensurePeOff(); 
    79         } 
    80         catch(const std::exception& e) 
    81         { 
    82                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    83                                 new hal::EventStdException(event_logger::critical, e, L"settingsThread, Protocol Encryption")));  
    84         } 
    85          
    86         bittorrent().setSessionHalfOpenLimit(halfConnLimit); 
    87          
    88         bittorrent().resumeAll();        
    89          
    90         bittorrent().setSessionLimits( 
    91                 maxConnections, maxUploads); 
    92         bittorrent().setSessionSpeed( 
    93                 downRate, upRate); 
     105                bittorrent().setTimeouts(peerTimeout, trackerTimeout); 
    94106                 
    95         bittorrent().setTorrentDefaults(torrentMaxConnections, 
    96                 torrentMaxUploads, torrentDownRate, 
    97                 torrentUpRate); 
    98          
    99         bittorrent().setDhtSettings(dhtMaxPeersReply,  
    100                 dhtSearchBranching, dhtServicePort,  
    101                 dhtMaxFailCount); 
    102  
    103         bittorrent().setTimeouts(peerTimeout, trackerTimeout); 
    104          
    105         if (enableDHT) 
    106         { 
    107                 if (!bittorrent().ensureDhtOn()) 
     107                if (enableDHT) 
    108108                { 
     109                        if (!bittorrent().ensureDhtOn()) 
     110                        { 
     111                                bittorrent().ensureDhtOff(); 
     112                                 
     113                                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     114                                        new hal::EventDebug(event_logger::critical, L"settingsThread, DHT Error")));  
     115                        } 
     116                } 
     117                else 
    109118                        bittorrent().ensureDhtOff(); 
    110119                         
    111                         hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    112                                 new hal::EventDebug(event_logger::critical, L"settingsThread, DHT Error")));  
    113                 } 
     120                // Settings seem to have applied ok! 
     121                save_to_ini();   
     122 
    114123        } 
    115         else 
    116                 bittorrent().ensureDhtOff(); 
    117                  
    118         // Settings seem to have applied ok! 
    119         save_to_ini();   
     124        HAL_GENERIC_FN_EXCEPTION_CATCH(L"Config::settingsThread()") 
     125 
    120126        return true; 
    121127} 
  • branch_0_3_1/src/halEvent.hpp

    r522 r565  
    2727#include <boost/smart_ptr.hpp> 
    2828 
     29#include <boost/preprocessor/cat.hpp> 
     30#include <boost/preprocessor/stringize.hpp> 
     31#include "win32_exception.hpp" 
     32 
    2933#include "global/wtl_app.hpp" 
    3034#include "global/string_conv.hpp" 
     
    3943#       define HAL_DEV_MSG(msg) 
    4044#endif 
     45 
     46#define HAL_GENERIC_FN_EXCEPTION_CATCH(FUNCTION) \ 
     47catch (const access_violation& e) \ 
     48{ \ 
     49        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     50                new hal::EventMsg(hal::wform(L"%1% access_violation (code %2$x) at %3$x. Bad address %4$x") % hal::to_wstr_shim(FUNCTION) % e.code() % (unsigned)e.where() % (unsigned)e.badAddress(), \ 
     51                        hal::event_logger::dev))); \ 
     52} \ 
     53catch (const win32_exception& e) \ 
     54{ \ 
     55        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     56                new hal::EventMsg(hal::wform(L"%1% win32_exception (code %2$x) at %3$x") % hal::to_wstr_shim(FUNCTION) % e.code() % (unsigned)e.where(), \ 
     57                        hal::event_logger::dev))); \ 
     58} \ 
     59catch(std::exception& e) \ 
     60{ \ 
     61        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     62                new hal::EventMsg(hal::wform(L"%1% std::exception, %2%") % hal::to_wstr_shim(FUNCTION) % hal::from_utf8(e.what()), \ 
     63                        hal::event_logger::dev))); \ 
     64} \ 
     65catch(...) \ 
     66{ \ 
     67        hal::event_log.post(shared_ptr<hal::EventDetail>( \ 
     68                new hal::EventMsg(hal::wform(L"%1% catch all") % hal::to_wstr_shim(FUNCTION), \ 
     69                        hal::event_logger::dev))); \ 
     70} \ 
    4171 
    4272namespace hal  
  • branch_0_3_1/src/halIni.hpp

    r485 r565  
    5454        bool load_standalone(const P& location) 
    5555        { 
     56                bool result = false; 
     57                 
    5658                try  
    5759                {                
     
    6365                ixml >> boost::serialization::make_nvp(name_.c_str(), *pT); 
    6466 
    65                 return true; 
    66                  
     67                result = true;   
     68 
    6769                } 
    68                 catch (const std::exception& e) 
    69                 {                        
    70                         hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    71                                 new hal::EventXmlException(hal::from_utf8(e.what()), L"load_standalone")));  
     70                HAL_GENERIC_FN_EXCEPTION_CATCH(L"IniBase::load_standalone()") 
    7271 
    73                         return false; 
    74                 } 
     72                return result; 
    7573        } 
    7674         
    7775        bool load_from_ini() 
    7876        { 
    79                 std::wstringstream xml_data;             
    80                 adapter_.load_stream_data(xml_data); 
     77                bool result = false; 
    8178                 
    8279                try  
    8380                { 
     81 
     82                std::wstringstream xml_data;             
     83                adapter_.load_stream_data(xml_data); 
    8484                 
    8585                boost::archive::xml_wiarchive ixml(xml_data);    
     
    8787                T* pT = static_cast<T*>(this);   
    8888                ixml >> boost::serialization::make_nvp(name_.c_str(), *pT); 
    89                  
     89 
     90                result = true;   
     91 
    9092                } 
    91                 catch (const std::exception& e) 
    92                 {                        
    93                         hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    94                                 new hal::EventXmlException(hal::from_utf8(e.what()), hal::from_utf8(name_))));  
     93                HAL_GENERIC_FN_EXCEPTION_CATCH(L"IniBase::load_from_ini()") 
    9594 
    96                         return false; 
    97                 } 
    98  
    99                 return true; 
     95                return result; 
    10096        } 
    10197         
  • branch_0_3_1/src/halTorrent.cpp

    r522 r565  
    301301                }        
    302302                } 
    303                 catch(std::exception& e) 
    304                 { 
    305                         hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    306                                 new hal::EventStdException(event_logger::critical, e, L"~BitTorrent_impl")));  
    307                 } 
     303                HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::~bit_impl()") 
    308304        } 
    309305 
     
    324320        void alertHandler() 
    325321        { 
    326                 mutex_t::scoped_lock l(mutex_); 
    327  
    328                 if (keepChecking_) 
     322                try 
    329323                { 
    330                  
    331                 std::auto_ptr<libt::alert> p_alert = theSession.pop_alert(); 
    332                  
    333                 class AlertHandler 
    334                 { 
    335                 public: 
    336                 AlertHandler(bit_impl& bit_impl) : 
    337                         bit_impl_(bit_impl) 
    338                 {} 
    339                  
    340                 void operator()(libt::torrent_finished_alert const& a) const 
    341                 { 
    342                         event_log.post(shared_ptr<EventDetail>( 
    343                                 new EventMsg((wform(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED))  
    344                                                 % get(a.handle)->name()),  
    345                                         event_logger::info, a.timestamp()))); 
    346                          
    347                         get(a.handle)->finished();       
    348                 } 
    349                  
    350                 void operator()(libt::torrent_paused_alert const& a) const 
    351                 { 
    352                         event_log.post(shared_ptr<EventDetail>( 
    353                                 new EventMsg((wform(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED))  
    354                                                 % get(a.handle)->name()),  
    355                                         event_logger::info, a.timestamp()))); 
    356  
    357                         get(a.handle)->signals().torrent_paused(); 
    358                 } 
    359                  
    360                 void operator()(libt::peer_error_alert const& a) const 
    361                 { 
    362                         event_log.post(shared_ptr<EventDetail>( 
    363                                 new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    364                                         wform(hal::app().res_wstr(HAL_PEER_ALERT)) 
    365                                                 % hal::from_utf8_safe(a.msg()) 
    366                                                 % hal::from_utf8_safe(a.ip.address().to_string())) 
    367                         )       );                               
    368                 } 
    369                          
    370                 void operator()(libt::peer_ban_alert const& a) const 
    371                 { 
    372                         event_log.post(shared_ptr<EventDetail>( 
    373                                 new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    374                                         wform(hal::app().res_wstr(HAL_PEER_BAN_ALERT)) 
    375                                                 % get(a.handle)->name() 
    376                                                 % hal::from_utf8_safe(a.ip.address().to_string())) 
    377                         )       );                               
    378                 } 
    379                          
    380                 void operator()(libt::hash_failed_alert const& a) const 
    381                 { 
    382                         event_log.post(shared_ptr<EventDetail>( 
    383                                 new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    384                                         wform(hal::app().res_wstr(HAL_HASH_FAIL_ALERT)) 
    385                                                 % get(a.handle)->name() 
    386                                                 % a.piece_index) 
    387                         )       );                               
    388                 } 
    389                          
    390                 void operator()(libt::url_seed_alert const& a) const 
    391                 { 
    392                         event_log.post(shared_ptr<EventDetail>( 
    393                                 new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    394                                         wform(hal::app().res_wstr(HAL_URL_SEED_ALERT)) 
    395                                                 % get(a.handle)->name() 
    396                                                 % hal::from_utf8_safe(a.url) 
    397                                                 % hal::from_utf8_safe(a.msg())) 
    398                         )       );                               
    399                 } 
    400                  
    401                 void operator()(libt::tracker_warning_alert const& a) const 
    402                 { 
    403                         event_log.post(shared_ptr<EventDetail>( 
    404                                 new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    405                                         wform(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT)) 
    406                                                 % get(a.handle)->name() 
    407                                                 % hal::from_utf8_safe(a.msg())) 
    408                         )       );                               
    409                 } 
    410                  
    411                 void operator()(libt::tracker_announce_alert const& a) const 
    412                 { 
    413                         event_log.post(shared_ptr<EventDetail>( 
    414                                 new EventMsg((wform(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT))  
    415                                                 % get(a.handle)->name()),  
    416                                         event_logger::info, a.timestamp()))); 
    417                 } 
    418                  
    419                 void operator()(libt::tracker_alert const& a) const 
    420                 { 
    421                         event_log.post(shared_ptr<EventDetail>( 
    422                                 new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    423                                         wform(hal::app().res_wstr(HAL_TRACKER_ALERT)) 
    424                                                 % get(a.handle)->name() 
    425                                                 % hal::from_utf8_safe(a.msg()) 
    426                                                 % a.times_in_row 
    427                                                 % a.status_code) 
    428                         )       );                               
    429                 } 
    430                  
    431                 void operator()(libt::tracker_reply_alert const& a) const 
    432                 { 
    433                         event_log.post(shared_ptr<EventDetail>( 
    434                                 new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    435                                         wform(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT)) 
    436                                                 % get(a.handle)->name() 
    437                                                 % hal::from_utf8_safe(a.msg()) 
    438                                                 % a.num_peers) 
    439                         )       );                               
    440                 } 
    441                  
    442                 void operator()(libt::fastresume_rejected_alert const& a) const 
    443                 { 
    444                         event_log.post(shared_ptr<EventDetail>( 
    445                                 new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    446                                         wform(hal::app().res_wstr(HAL_FAST_RESUME_ALERT)) 
    447                                                 % get(a.handle)->name() 
    448                                                 % hal::from_utf8_safe(a.msg())) 
    449                         )       );                               
    450                 } 
    451                  
    452                 void operator()(libt::piece_finished_alert const& a) const 
    453                 { 
    454                         event_log.post(shared_ptr<EventDetail>( 
    455                                 new EventGeneral(event_logger::debug, a.timestamp(), 
    456                                         wform(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT)) 
    457                                                 % get(a.handle)->name() 
    458                                                 % a.piece_index) 
    459                         )       );                               
    460                 } 
    461                  
    462                 void operator()(libt::block_finished_alert const& a) const 
    463                 { 
    464                         event_log.post(shared_ptr<EventDetail>( 
    465                                 new EventGeneral(event_logger::debug, a.timestamp(), 
    466                                         wform(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT)) 
    467                                                 % get(a.handle)->name() 
    468                                                 % a.block_index 
    469                                                 % a.piece_index) 
    470                         )       );                               
    471                 } 
    472                  
    473                 void operator()(libt::block_downloading_alert const& a) const 
    474                 { 
    475                         event_log.post(shared_ptr<EventDetail>( 
    476                                 new EventGeneral(event_logger::debug, a.timestamp(), 
    477                                         wform(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT)) 
    478                                                 % get(a.handle)->name() 
    479                                                 % a.block_index 
    480                                                 % a.piece_index) 
    481                         )       );                               
    482                 } 
    483                  
    484                 void operator()(libt::listen_failed_alert const& a) const 
    485                 { 
    486                         if (a.endpoint.address().is_v6()) 
    487                         {        
     324                        mutex_t::scoped_lock l(mutex_); 
     325 
     326                        if (keepChecking_) 
     327                        { 
     328                         
     329                        std::auto_ptr<libt::alert> p_alert = theSession.pop_alert(); 
     330                         
     331                        class AlertHandler 
     332                        { 
     333                        public: 
     334                        AlertHandler(bit_impl& bit_impl) : 
     335                                bit_impl_(bit_impl) 
     336                        {} 
     337                         
     338                        void operator()(libt::torrent_finished_alert const& a) const 
     339                        { 
     340                                event_log.post(shared_ptr<EventDetail>( 
     341                                        new EventMsg((wform(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED))  
     342                                                        % get(a.handle)->name()),  
     343                                                event_logger::info, a.timestamp()))); 
     344                                 
     345                                get(a.handle)->finished();       
     346                        } 
     347                         
     348                        void operator()(libt::torrent_paused_alert const& a) const 
     349                        { 
     350                                event_log.post(shared_ptr<EventDetail>( 
     351                                        new EventMsg((wform(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED))  
     352                                                        % get(a.handle)->name()),  
     353                                                event_logger::info, a.timestamp()))); 
     354 
     355                                get(a.handle)->signals().torrent_paused(); 
     356                        } 
     357                         
     358                        void operator()(libt::peer_error_alert const& a) const 
     359                        { 
     360                                event_log.post(shared_ptr<EventDetail>( 
     361                                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
     362                                                wform(hal::app().res_wstr(HAL_PEER_ALERT)) 
     363                                                        % hal::from_utf8_safe(a.msg()) 
     364                                                        % hal::from_utf8_safe(a.ip.address().to_string())) 
     365                                )       );                               
     366                        } 
     367                                 
     368                        void operator()(libt::peer_ban_alert const& a) const 
     369                        { 
     370                                event_log.post(shared_ptr<EventDetail>( 
     371                                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
     372                                                wform(hal::app().res_wstr(HAL_PEER_BAN_ALERT)) 
     373                                                        % get(a.handle)->name() 
     374                                                        % hal::from_utf8_safe(a.ip.address().to_string())) 
     375                                )       );                               
     376                        } 
     377                                 
     378                        void operator()(libt::hash_failed_alert const& a) const 
     379                        { 
     380                                event_log.post(shared_ptr<EventDetail>( 
     381                                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
     382                                                wform(hal::app().res_wstr(HAL_HASH_FAIL_ALERT)) 
     383                                                        % get(a.handle)->name() 
     384                                                        % a.piece_index) 
     385                                )       );                               
     386                        } 
     387                                 
     388                        void operator()(libt::url_seed_alert const& a) const 
     389                        { 
     390                                event_log.post(shared_ptr<EventDetail>( 
     391                                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
     392                                                wform(hal::app().res_wstr(HAL_URL_SEED_ALERT)) 
     393                                                        % get(a.handle)->name() 
     394                                                        % hal::from_utf8_safe(a.url) 
     395                                                        % hal::from_utf8_safe(a.msg())) 
     396                                )       );                               
     397                        } 
     398                         
     399                        void operator()(libt::tracker_warning_alert const& a) const 
     400                        { 
     401                                event_log.post(shared_ptr<EventDetail>( 
     402                                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
     403                                                wform(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT)) 
     404                                                        % get(a.handle)->name() 
     405                                                        % hal::from_utf8_safe(a.msg())) 
     406                                )       );                               
     407                        } 
     408                         
     409                        void operator()(libt::tracker_announce_alert const& a) const 
     410                        { 
     411                                event_log.post(shared_ptr<EventDetail>( 
     412                                        new EventMsg((wform(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT))  
     413                                                        % get(a.handle)->name()),  
     414                                                event_logger::info, a.timestamp()))); 
     415                        } 
     416                         
     417                        void operator()(libt::tracker_alert const& a) const 
     418                        { 
     419                                event_log.post(shared_ptr<EventDetail>( 
     420                                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
     421                                                wform(hal::app().res_wstr(HAL_TRACKER_ALERT)) 
     422                                                        % get(a.handle)->name() 
     423                                                        % hal::from_utf8_safe(a.msg()) 
     424                                                        % a.times_in_row 
     425                                                        % a.status_code) 
     426                                )       );                               
     427                        } 
     428                         
     429                        void operator()(libt::tracker_reply_alert const& a) const 
     430                        { 
     431                                event_log.post(shared_ptr<EventDetail>( 
     432                                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
     433                                                wform(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT)) 
     434                                                        % get(a.handle)->name() 
     435                                                        % hal::from_utf8_safe(a.msg()) 
     436                                                        % a.num_peers) 
     437                                )       );                               
     438                        } 
     439                         
     440                        void operator()(libt::fastresume_rejected_alert const& a) const 
     441                        { 
     442                                event_log.post(shared_ptr<EventDetail>( 
     443                                        new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
     444                                                wform(hal::app().res_wstr(HAL_FAST_RESUME_ALERT)) 
     445                                                        % get(a.handle)->name() 
     446                                                        % hal::from_utf8_safe(a.msg())) 
     447                                )       );                               
     448                        } 
     449                         
     450                        void operator()(libt::piece_finished_alert const& a) const 
     451                        { 
     452                                event_log.post(shared_ptr<EventDetail>( 
     453                                        new EventGeneral(event_logger::debug, a.timestamp(), 
     454                                                wform(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT)) 
     455                                                        % get(a.handle)->name() 
     456                                                        % a.piece_index) 
     457                                )       );                               
     458                        } 
     459                         
     460                        void operator()(libt::block_finished_alert const& a) const 
     461                        { 
     462                                event_log.post(shared_ptr<EventDetail>( 
     463                                        new EventGeneral(event_logger::debug, a.timestamp(), 
     464                                                wform(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT)) 
     465                                                        % get(a.handle)->name() 
     466                                                        % a.block_index 
     467                                                        % a.piece_index) 
     468                                )       );                               
     469                        } 
     470                         
     471                        void operator()(libt::block_downloading_alert const& a) const 
     472                        { 
     473                                event_log.post(shared_ptr<EventDetail>( 
     474                                        new EventGeneral(event_logger::debug, a.timestamp(), 
     475                                                wform(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT)) 
     476                                                        % get(a.handle)->name() 
     477                                                        % a.block_index 
     478                                                        % a.piece_index) 
     479                                )       );                               
     480                        } 
     481                         
     482                        void operator()(libt::listen_failed_alert const& a) const 
     483                        { 
     484                                if (a.endpoint.address().is_v6()) 
     485                                {        
     486                                        event_log.post(shared_ptr<EventDetail>( 
     487                                                new EventGeneral(event_logger::info, a.timestamp(), 
     488                                                        hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT)) 
     489                                        )       );               
     490                                } 
     491                                else 
     492                                { 
     493                                        event_log.post(shared_ptr<EventDetail>( 
     494                                                new EventGeneral(event_logger::info, a.timestamp(), 
     495                                                        wform(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT)) 
     496                                                                % hal::from_utf8_safe(a.msg())) 
     497                                        )       ); 
     498                                } 
     499                        } 
     500                         
     501                        void operator()(libt::listen_succeeded_alert const& a) const 
     502                        { 
    488503                                event_log.post(shared_ptr<EventDetail>( 
    489504                                        new EventGeneral(event_logger::info, a.timestamp(), 
    490                                                 hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT)) 
    491                                 )       );               
    492                         } 
    493                         else 
     505                                                wform(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT)) 
     506                                                        % hal::from_utf8_safe(a.msg())) 
     507                                )       );       
     508 
     509                                bit_impl_.signals.successful_listen(); 
     510                        } 
     511                         
     512                        void operator()(libt::peer_blocked_alert const& a) const 
    494513                        { 
    495514                                event_log.post(shared_ptr<EventDetail>( 
    496                                         new EventGeneral(event_logger::info, a.timestamp(), 
    497                                                 wform(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT)) 
     515                                        new EventGeneral(event_logger::debug, a.timestamp(), 
     516                                                wform(hal::app().res_wstr(HAL_IPFILTER_ALERT)) 
     517                                                        % hal::from_utf8_safe(a.ip.to_string()) 
    498518                                                        % hal::from_utf8_safe(a.msg())) 
    499                                 )       ); 
    500                         } 
    501                 } 
    502                  
    503                 void operator()(libt::listen_succeeded_alert const& a) const 
    504                 { 
    505                         event_log.post(shared_ptr<EventDetail>( 
    506                                 new EventGeneral(event_logger::info, a.timestamp(), 
    507                                         wform(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT)) 
    508                                                 % hal::from_utf8_safe(a.msg())) 
    509                         )       );       
    510  
    511                         bit_impl_.signals.successful_listen(); 
    512                 } 
    513                  
    514                 void operator()(libt::peer_blocked_alert const& a) const 
    515                 { 
    516                         event_log.post(shared_ptr<EventDetail>( 
    517                                 new EventGeneral(event_logger::debug, a.timestamp(), 
    518                                         wform(hal::app().res_wstr(HAL_IPFILTER_ALERT)) 
    519                                                 % hal::from_utf8_safe(a.ip.to_string()) 
    520                                                 % hal::from_utf8_safe(a.msg())) 
    521                         )       );                               
    522                 } 
    523                  
    524                 void operator()(libt::alert const& a) const 
    525                 { 
    526                         event_log.post(shared_ptr<EventDetail>( 
    527                                         new EventLibtorrent(lbtAlertToHalEvent(a.severity()),  
    528                                                 a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.msg()))));              
    529                 } 
    530                  
    531                 private: 
    532                         bit_impl& bit_impl_; 
    533                          
    534                         torrent_internal_ptr get(libt::torrent_handle h) const  
    535                         {  
    536                                 return bit_impl_.theTorrents.get(from_utf8_safe(h.get_torrent_info().name()));  
    537                         } 
    538                  
    539                 } handler(*this); 
    540                  
    541                 while (p_alert.get()) 
    542                 {        
    543                         try 
    544                         { 
    545                          
    546                         libt::handle_alert< 
    547                                 libt::torrent_finished_alert, 
    548                                 libt::torrent_paused_alert, 
    549                                 libt::peer_error_alert, 
    550                                 libt::peer_ban_alert, 
    551                                 libt::hash_failed_alert, 
    552                                 libt::url_seed_alert, 
    553                                 libt::tracker_alert, 
    554                                 libt::tracker_warning_alert, 
    555                                 libt::tracker_announce_alert, 
    556                                 libt::tracker_reply_alert, 
    557                                 libt::fastresume_rejected_alert, 
    558                                 libt::piece_finished_alert, 
    559                                 libt::block_finished_alert, 
    560                                 libt::block_downloading_alert, 
    561                                 libt::listen_failed_alert, 
    562                                 libt::listen_succeeded_alert, 
    563                                 libt::peer_blocked_alert, 
    564                                 libt::alert 
    565                         >::handle_alert(p_alert, handler);                       
    566                          
    567                         } 
    568                         catch(libt::unhandled_alert&) 
    569                         { 
    570                                 handler(*p_alert); 
    571                         } 
    572                         catch(std::exception& e) 
    573                         { 
    574                                 // These are logged as debug because they are rarely important to act on! 
    575                                 event_log.post(shared_ptr<EventDetail>(\ 
    576                                         new EventStdException(event_logger::debug, e, L"alertHandler"))); 
    577                         } 
    578                          
    579                         p_alert = theSession.pop_alert(); 
    580                 } 
    581                  
    582                 timer_.expires_from_now(boost::posix_time::seconds(2)); 
    583                 timer_.async_wait(bind(&bit_impl::alertHandler, this)); 
    584                 } 
     519                                )       );                               
     520                        } 
     521                         
     522                        void operator()(libt::alert const& a) const 
     523                        { 
     524                                event_log.post(shared_ptr<EventDetail>( 
     525                                                new EventLibtorrent(lbtAlertToHalEvent(a.severity()),  
     526                                                        a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.msg()))));              
     527                        } 
     528                         
     529                        private: 
     530                                bit_impl& bit_impl_; 
     531                                 
     532                                torrent_internal_ptr get(libt::torrent_handle h) const  
     533                                {  
     534                                        return bit_impl_.theTorrents.get(from_utf8_safe(h.get_torrent_info().name()));  
     535                                } 
     536                         
     537                        } handler(*this); 
     538                         
     539                        while (p_alert.get()) 
     540                        {        
     541                                try 
     542                                { 
     543                                 
     544                                libt::handle_alert< 
     545                                        libt::torrent_finished_alert, 
     546                                        libt::torrent_paused_alert, 
     547                                        libt::peer_error_alert, 
     548                                        libt::peer_ban_alert, 
     549                                        libt::hash_failed_alert, 
     550                                        libt::url_seed_alert, 
     551                                        libt::tracker_alert, 
     552                                        libt::tracker_warning_alert, 
     553                                        libt::tracker_announce_alert, 
     554                                        libt::tracker_reply_alert, 
     555                                        libt::fastresume_rejected_alert, 
     556                                        libt::piece_finished_alert, 
     557                                        libt::block_finished_alert, 
     558                                        libt::block_downloading_alert, 
     559                                        libt::listen_failed_alert, 
     560                                        libt::listen_succeeded_alert, 
     561                                        libt::peer_blocked_alert, 
     562                                        libt::alert 
     563                                >::handle_alert(p_alert, handler);                       
     564                                 
     565                                } 
     566                                catch(libt::unhandled_alert&) 
     567                                { 
     568                                        handler(*p_alert); 
     569                                } 
     570                                catch(std::exception& e) 
     571                                { 
     572                                        // These are logged as debug because they are rarely important to act on! 
     573                                        event_log.post(shared_ptr<EventDetail>(\ 
     574                                                new EventStdException(event_logger::debug, e, L"alertHandler"))); 
     575                                } 
     576                                 
     577                                p_alert = theSession.pop_alert(); 
     578                        } 
     579                         
     580                        timer_.expires_from_now(boost::posix_time::seconds(2)); 
     581                        timer_.async_wait(bind(&bit_impl::alertHandler, this)); 
     582                        } 
     583 
     584                } 
     585                HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::alertHandler()") 
    585586        } 
    586587         
     
    599600                } 
    600601                 
    601                 }                
    602                 catch(std::exception& e) 
    603                 { 
    604                         event_log.post(shared_ptr<EventDetail>(\ 
    605                                 new EventStdException(event_logger::critical, e, L"saveTorrentData"))); 
    606                 } 
     602                }        
     603                HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::saveTorrentData()") 
    607604        } 
    608605         
     
    631628                dht_on_(false) 
    632629        { 
    633                 torrent_internal::the_session_ = &theSession; 
    634                 torrent_internal::workingDir_ = workingDir(); 
    635                  
    636                 theSession.set_severity_level(libt::alert::debug);               
    637                 theSession.add_extension(&libt::create_metadata_plugin); 
    638                 theSession.add_extension(&libt::create_ut_pex_plugin); 
    639                 theSession.set_max_half_open_connections(10); 
    640                  
    641                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    642                         new hal::EventMsg(L"Loading BitTorrent.xml.", hal::event_logger::info)));                
    643                 bittorrentIni.load_data(); 
    644  
    645                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    646                         new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));    
    647                 theTorrents.load_from_ini(); 
    648  
    649                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    650                         new hal::EventMsg(L"Loading done!", hal::event_logger::info))); 
    651                  
    652630                try 
    653                 {                                                
    654                 if (fs::exists(workingDirectory/L"Torrents.xml")) 
    655631                { 
    656                         { 
    657                         fs::wifstream ifs(workingDirectory/L"Torrents.xml"); 
    658                  
    659                         event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml"))); 
    660                  
    661                         TorrentMap torrents; 
    662                         boost::archive::xml_wiarchive ia(ifs);   
    663                         ia >> boost::serialization::make_nvp("torrents", torrents); 
    664                          
    665                         theTorrents = torrents; 
    666                         } 
    667                          
    668                         event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    669                                 wform(L"Total %1%.") % theTorrents.size())));                            
    670                          
    671                         fs::rename(workingDirectory/L"Torrents.xml", workingDirectory/L"Torrents.xml.safe.to.delete"); 
    672                 }                        
    673                 } 
    674                 catch(const std::exception& e) 
    675                 { 
    676                         event_log.post(shared_ptr<EventDetail>( 
    677                                 new EventStdException(event_logger::fatal, e, L"Loading Old Torrents.xml"))); 
    678                 }                
     632                        torrent_internal::the_session_ = &theSession; 
     633                        torrent_internal::workingDir_ = workingDir(); 
     634                         
     635                        theSession.set_severity_level(libt::alert::debug);               
     636                        theSession.add_extension(&libt::create_metadata_plugin); 
     637                        theSession.add_extension(&libt::create_ut_pex_plugin); 
     638                        theSession.set_max_half_open_connections(10); 
     639                         
     640                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     641                                new hal::EventMsg(L"Loading BitTorrent.xml.", hal::event_logger::info)));                
     642                        bittorrentIni.load_data(); 
     643 
     644                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     645                                new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));    
     646                        theTorrents.load_from_ini(); 
     647 
     648                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     649                                new hal::EventMsg(L"Loading done!", hal::event_logger::info))); 
     650                         
     651                        try 
     652                        {                                                
     653                        if (fs::exists(workingDirectory/L"Torrents.xml")) 
     654                        { 
     655                                { 
     656                                fs::wifstream ifs(workingDirectory/L"Torrents.xml"); 
     657                         
     658                                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml"))); 
     659                         
     660                                TorrentMap torrents; 
     661                                boost::archive::xml_wiarchive ia(ifs);   
     662                                ia >> boost::serialization::make_nvp("torrents", torrents); 
    679663                                 
    680                 if (exists(workingDirectory/L"DHTState.bin")) 
    681                 { 
    682                         try 
    683                         { 
    684                                 dht_state_ = haldecode(workingDirectory/L"DHTState.bin"); 
     664                                theTorrents = torrents; 
     665                                } 
     666                                 
     667                                event_log.post(shared_ptr<EventDetail>(new EventMsg( 
     668                                        wform(L"Total %1%.") % theTorrents.size())));                            
     669                                 
     670                                fs::rename(workingDirectory/L"Torrents.xml", workingDirectory/L"Torrents.xml.safe.to.delete"); 
     671                        }                        
     672                        } 
     673                        catch(const std::exception& e) 
     674                        { 
     675                                event_log.post(shared_ptr<EventDetail>( 
     676                                        new EventStdException(event_logger::fatal, e, L"Loading Old Torrents.xml"))); 
    685677                        }                
    686                         catch(const std::exception& e) 
    687                         { 
    688                                 event_log.post(shared_ptr<EventDetail>( 
    689                                         new EventStdException(event_logger::critical, e, L"Loading DHTState.bin"))); 
    690                         } 
    691                 } 
    692                  
    693                 {       libt::session_settings settings = theSession.settings(); 
    694                         settings.user_agent = string("Halite ") + HALITE_VERSION_STRING; 
    695                         theSession.set_settings(settings); 
    696                 } 
    697                  
    698                 timer_.expires_from_now(boost::posix_time::seconds(5)); 
    699                 timer_.async_wait(bind(&bit_impl::alertHandler, this)); 
     678                                         
     679                        if (exists(workingDirectory/L"DHTState.bin")) 
     680                        { 
     681                                try 
     682                                { 
     683                                        dht_state_ = haldecode(workingDirectory/L"DHTState.bin"); 
     684                                }                
     685                                catch(const std::exception& e) 
     686                                { 
     687                                        event_log.post(shared_ptr<EventDetail>( 
     688                                                new EventStdException(event_logger::critical, e, L"Loading DHTState.bin"))); 
     689                                } 
     690                        } 
     691                         
     692                        {       libt::session_settings settings = theSession.settings(); 
     693                                settings.user_agent = string("Halite ") + HALITE_VERSION_STRING; 
     694                                theSession.set_settings(settings); 
     695                        } 
     696                         
     697                        timer_.expires_from_now(boost::posix_time::seconds(5)); 
     698                        timer_.async_wait(bind(&bit_impl::alertHandler, this)); 
     699                } 
     700                HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::bit_impl()") 
    700701        } 
    701702 
     
    778779                libt::entry e = t_info->create_torrent(); 
    779780                halencode(out_file, e); 
    780                 } 
    781                 catch(const std::exception& e) 
    782                 { 
    783                         event_log.post(shared_ptr<EventDetail>( 
    784                                 new EventStdException(event_logger::fatal, e, L"create_torrent"))); 
    785                 }        
     781 
     782                } 
     783                HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit_impl::create_torrent()") 
    786784 
    787785                return false; 
     
    11101108         
    11111109        } 
    1112         catch(const std::exception& e) 
    1113         {                
    1114                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    1115                         new hal::EventStdException(event_logger::critical, e, L"ensureIpFilterOn")));  
    1116  
    1117                 ensureIpFilterOff(); 
    1118         } 
     1110        HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit::ensureIpFilterOn") 
    11191111 
    11201112        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters on.")));        
     
    12011193         
    12021194        } 
    1203         catch(const std::exception& e) 
    1204         { 
    1205                 hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    1206                                 new hal::EventStdException(event_logger::critical, e, L"ensurePeOn")));  
    1207                                  
    1208                 ensurePeOff();           
    1209         } 
     1195        HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit::ensurePeOn") 
    12101196         
    12111197        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption on."))); 
     
    13261312         
    13271313        } 
    1328         catch(const std::exception& e) 
    1329         { 
    1330                 event_log.post(shared_ptr<EventDetail>( 
    1331                         new EventStdException(event_logger::critical, e, L"ip_filter_import_dat"))); 
    1332         } 
     1314        HAL_GENERIC_FN_EXCEPTION_CATCH(L"bit::ip_filter_import_dat()") 
    13331315 
    13341316        return false; 
  • branch_0_3_1/src/halTorrentInternal.hpp

    r532 r565  
    604604 
    605605                } 
    606                 catch(std::exception& e) 
    607                 { 
    608                         hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    609                                 new hal::EventStdException(event_logger::critical, e, L"addToSession")));  
    610                 } 
     606                HAL_GENERIC_FN_EXCEPTION_CATCH(L"torrent_internal::add_to_session()") 
    611607        } 
    612608         
     
    640636 
    641637                } 
    642                 catch(std::exception& e) 
    643                 { 
    644                         hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    645                                 new hal::EventStdException(event_logger::critical, e, L"removeFromSession")));  
    646                 } 
     638                HAL_GENERIC_FN_EXCEPTION_CATCH(L"torrent_internal::remove_from_session()") 
    647639        } 
    648640         
     
    16741666                        new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, to_utf8(name_), "getTorrentDetail_ptr"))); 
    16751667        } 
    1676         catch (const std::exception& e) 
    1677         { 
    1678                 event_log.post(shared_ptr<EventDetail>( 
    1679                         new EventTorrentException(event_logger::critical, event_logger::torrentException, e.what(), to_utf8(name_), "getTorrentDetail_ptr"))); 
    1680         } 
     1668        HAL_GENERIC_FN_EXCEPTION_CATCH(L"torrent_internal::getTorrentDetail_ptr()") 
    16811669         
    16821670        return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), app().res_wstr(HAL_TORRENT_STOPPED), app().res_wstr(HAL_NA))); 
Note: See TracChangeset for help on using the changeset viewer.