Changeset 479


Ignore:
Timestamp:
06/05/08 13:36:40 (12 years ago)
Author:
Eoin
Message:

Refactoring my session code into seperate file.

Location:
trunk
Files:
1 added
5 edited

Legend:

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

    r474 r479  
    990990                        </File> 
    991991                        <File 
     992                                RelativePath="..\..\src\halSession.hpp" 
     993                                > 
     994                        </File> 
     995                        <File 
    992996                                RelativePath="..\..\src\halSignaler.hpp" 
    993997                                > 
  • trunk/src/halEvent.hpp

    r478 r479  
    7878 
    7979private: 
    80         std::vector<boost::signals::scoped_connection> connections_; 
    8180        boost::shared_ptr<event_impl> pimpl_; 
    8281}; 
  • trunk/src/halTorrent.cpp

    r478 r479  
    3232#include "halSignaler.hpp" 
    3333 
    34 #define foreach BOOST_FOREACH 
     34#include "halTorrentInternal.hpp" 
     35#include "halSession.hpp" 
    3536 
    3637namespace boost { 
     
    138139} // namespace libtorrent 
    139140 
    140 #include "halTorrentInternal.hpp" 
    141141 
    142142namespace hal  
     
    153153        static bit t; 
    154154        return t; 
    155 } 
    156  
    157 bool operator!=(const libt::dht_settings& lhs, const libt::dht_settings& rhs) 
    158 { 
    159         return lhs.max_peers_reply != rhs.max_peers_reply || 
    160                    lhs.search_branching != rhs.search_branching || 
    161                    lhs.service_port != rhs.service_port || 
    162            lhs.max_fail_count != rhs.max_fail_count; 
    163 } 
    164  
    165 template<typename Addr> 
    166 void write_range(fs::ofstream& ofs, const libt::ip_range<Addr>& range) 
    167 {  
    168         const typename Addr::bytes_type first = range.first.to_bytes(); 
    169         const typename Addr::bytes_type last = range.last.to_bytes(); 
    170         ofs.write((char*)first.elems, first.size()); 
    171         ofs.write((char*)last.elems, last.size()); 
    172 } 
    173  
    174 template<typename Addr> 
    175 void write_vec_range(fs::ofstream& ofs, const std::vector<libt::ip_range<Addr> >& vec) 
    176 {  
    177         ofs << vec.size(); 
    178          
    179         for (typename std::vector<libt::ip_range<Addr> >::const_iterator i=vec.begin();  
    180                 i != vec.end(); ++i) 
    181         { 
    182                 write_range(ofs, *i); 
    183         } 
    184 } 
    185  
    186 template<typename Addr> 
    187 void read_range_to_filter(fs::ifstream& ifs, libt::ip_filter& ip_filter) 
    188 {  
    189         typename Addr::bytes_type first; 
    190         typename Addr::bytes_type last; 
    191         ifs.read((char*)first.elems, first.size()); 
    192         ifs.read((char*)last.elems, last.size());        
    193          
    194         ip_filter.add_rule(Addr(first), Addr(last), 
    195                 libt::ip_filter::blocked); 
    196 } 
    197  
    198 static event_logger::eventLevel lbtAlertToHalEvent(libt::alert::severity_t severity) 
    199 { 
    200         switch (severity) 
    201         { 
    202         case libt::alert::debug: 
    203                 return event_logger::debug; 
    204          
    205         case libt::alert::info: 
    206                 return event_logger::info; 
    207          
    208         case libt::alert::warning: 
    209                 return event_logger::warning; 
    210          
    211         case libt::alert::critical: 
    212         case libt::alert::fatal: 
    213                 return event_logger::critical; 
    214          
    215         default: 
    216                 return event_logger::none; 
    217         } 
    218155} 
    219156 
     
    268205        type(hal::app().res_wstr(HAL_INT_NEWT_ADD_PEERS_DHT))  
    269206{} 
    270  
    271 class bit_impl 
    272 { 
    273         friend class bit; 
    274          
    275 public: 
    276          
    277         ~bit_impl() 
    278         { 
    279                 stopAlertHandler(); 
    280                  
    281                 //saveTorrentData(); 
    282                  
    283                 try 
    284                 { 
    285                  
    286                 if (ip_filter_changed_) 
    287                 {        
    288                         fs::ofstream ofs(workingDirectory/L"IPFilter.bin", std::ios::binary); 
    289 //                      boost::archive::binary_oarchive oba(ofs); 
    290                          
    291                         libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();    
    292                          
    293                         std::vector<libt::ip_range<asio::ip::address_v4> > v4(vectors.get<0>()); 
    294                         std::vector<libt::ip_range<asio::ip::address_v6> > v6(vectors.get<1>()); 
    295                          
    296                         v4.erase(std::remove(v4.begin(), v4.end(), 0), v4.end()); 
    297                         v6.erase(std::remove(v6.begin(), v6.end(), 0), v6.end()); 
    298  
    299                         write_vec_range(ofs, v4); 
    300 //                      write_vec_range(ofs, v6); 
    301                 }        
    302                 } 
    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                 } 
    308         } 
    309  
    310         struct  
    311         { 
    312                 signaler<> successful_listen; 
    313                 signaler<> torrent_finished; 
    314         }  
    315         signals; 
    316  
    317         void stopAlertHandler() 
    318         { 
    319                 mutex_t::scoped_lock l(mutex_); 
    320  
    321                 keepChecking_ = false; 
    322         } 
    323                  
    324         void alertHandler() 
    325         { 
    326                 mutex_t::scoped_lock l(mutex_); 
    327  
    328                 if (keepChecking_) 
    329                 { 
    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((wformat(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((wformat(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                                         wformat(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                                         wformat(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                                         wformat(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                                         wformat(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                                         wformat(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((wformat(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                                         wformat(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                                         wformat(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                                         wformat(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                                         wformat(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                                         wformat(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                                         wformat(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                         {        
    488                                 event_log.post(shared_ptr<EventDetail>( 
    489                                         new EventGeneral(event_logger::info, a.timestamp(), 
    490                                                 hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT)) 
    491                                 )       );               
    492                         } 
    493                         else 
    494                         { 
    495                                 event_log.post(shared_ptr<EventDetail>( 
    496                                         new EventGeneral(event_logger::info, a.timestamp(), 
    497                                                 wformat(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT)) 
    498                                                         % 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                                         wformat(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                                         wformat(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                 } 
    585         } 
    586          
    587         void saveTorrentData() 
    588         {        
    589                 mutex_t::scoped_lock l(mutex_); 
    590                 try 
    591                 { 
    592                  
    593                 theTorrents.save(); 
    594                 bittorrentIni.save_data(); 
    595                          
    596                 if (dht_on_)  
    597                 {        
    598                         halencode(workingDirectory/L"DHTState.bin", theSession.dht_state()); 
    599                 } 
    600                  
    601                 }                
    602                 catch(std::exception& e) 
    603                 { 
    604                         event_log.post(shared_ptr<EventDetail>(\ 
    605                                 new EventStdException(event_logger::critical, e, L"saveTorrentData"))); 
    606                 } 
    607         } 
    608          
    609         int defTorrentMaxConn() { return defTorrentMaxConn_; } 
    610         int defTorrentMaxUpload() { return defTorrentMaxUpload_; } 
    611         float defTorrentDownload() { return defTorrentDownload_; } 
    612         float defTorrentUpload() { return defTorrentUpload_; } 
    613          
    614         const wpath workingDir() { return workingDirectory; }; 
    615  
    616 private: 
    617         bit_impl() : 
    618                 theSession(libt::fingerprint(HALITE_FINGERPRINT)), 
    619                 timer_(io_), 
    620                 keepChecking_(false), 
    621                 bittorrentIni(L"BitTorrent.xml"), 
    622                 theTorrents(bittorrentIni), 
    623                 defTorrentMaxConn_(-1), 
    624                 defTorrentMaxUpload_(-1), 
    625                 defTorrentDownload_(-1), 
    626                 defTorrentUpload_(-1), 
    627                 ip_filter_on_(false), 
    628                 ip_filter_loaded_(false), 
    629                 ip_filter_changed_(false), 
    630                 ip_filter_count_(0), 
    631                 dht_on_(false) 
    632         { 
    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                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    645                         new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));    
    646                 theTorrents.load(); 
    647                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    648                         new hal::EventMsg(L"Loading done!", hal::event_logger::info))); 
    649                  
    650                 try 
    651                 {                                                
    652                 if (fs::exists(workingDirectory/L"Torrents.xml")) 
    653                 { 
    654                         { 
    655                         fs::wifstream ifs(workingDirectory/L"Torrents.xml"); 
    656                  
    657                         event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml"))); 
    658                  
    659                         TorrentMap torrents; 
    660                         boost::archive::xml_wiarchive ia(ifs);   
    661                         ia >> boost::serialization::make_nvp("torrents", torrents); 
    662                          
    663                         theTorrents = torrents; 
    664                         } 
    665                          
    666                         event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    667                                 wformat(L"Total %1%.") % theTorrents.size())));                          
    668                          
    669                         fs::rename(workingDirectory/L"Torrents.xml", workingDirectory/L"Torrents.xml.safe.to.delete"); 
    670                 }                        
    671                 } 
    672                 catch(const std::exception& e) 
    673                 { 
    674                         event_log.post(shared_ptr<EventDetail>( 
    675                                 new EventStdException(event_logger::fatal, e, L"Loading Old Torrents.xml"))); 
    676                 }                
    677                                  
    678                 if (exists(workingDirectory/L"DHTState.bin")) 
    679                 { 
    680                         try 
    681                         { 
    682                                 dht_state_ = haldecode(workingDirectory/L"DHTState.bin"); 
    683                         }                
    684                         catch(const std::exception& e) 
    685                         { 
    686                                 event_log.post(shared_ptr<EventDetail>( 
    687                                         new EventStdException(event_logger::critical, e, L"Loading DHTState.bin"))); 
    688                         } 
    689                 } 
    690                  
    691                 {       libt::session_settings settings = theSession.settings(); 
    692                         settings.user_agent = string("Halite ") + HALITE_VERSION_STRING; 
    693                         theSession.set_settings(settings); 
    694                 } 
    695                  
    696                 timer_.expires_from_now(boost::posix_time::seconds(5)); 
    697                 timer_.async_wait(bind(&bit_impl::alertHandler, this)); 
    698         } 
    699  
    700         bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn) 
    701         {                
    702         try 
    703         { 
    704                 boost::intrusive_ptr<libt::torrent_info> t_info(new libt::torrent_info); 
    705  
    706                 int piece_size = params.piece_size; 
    707                 HAL_DEV_MSG(wformat(L"piece size: %1%") % piece_size); 
    708                 t_info->set_piece_size(piece_size); 
    709  
    710                 HAL_DEV_MSG(L"Files"); 
    711                 for (file_size_pairs_t::const_iterator i = params.file_size_pairs.begin(), e = params.file_size_pairs.end(); 
    712                                 i != e; ++i) 
    713                 { 
    714                         HAL_DEV_MSG(wformat(L"file path: %1%, size: %2%") % (*i).first % (*i).second); 
    715                         t_info->add_file(to_utf8((*i).first.string()), (*i).second); 
    716                 } 
    717  
    718                 libt::file_pool f_pool; 
    719                  
    720                 boost::scoped_ptr<libt::storage_interface> store( 
    721                         libt::default_storage_constructor(t_info, to_utf8(params.root_path.string()), 
    722                                 f_pool)); 
    723  
    724                 HAL_DEV_MSG(L"Trackers"); 
    725                 for (tracker_details_t::const_iterator i = params.trackers.begin(), e = params.trackers.end(); 
    726                                 i != e; ++i) 
    727                 { 
    728                         HAL_DEV_MSG(wformat(L"URL: %1%, Tier: %2%") % (*i).url % (*i).tier); 
    729                         t_info->add_tracker(to_utf8((*i).url), (*i).tier); 
    730                 } 
    731  
    732                 HAL_DEV_MSG(L"Web Seeds"); 
    733                 for (web_seed_details_t::const_iterator i = params.web_seeds.begin(), e = params.web_seeds.end(); 
    734                                 i != e; ++i) 
    735                 { 
    736                         HAL_DEV_MSG(wformat(L"URL: %1%") % (*i).url); 
    737                         t_info->add_url_seed(to_utf8((*i).url)); 
    738                 } 
    739  
    740                 HAL_DEV_MSG(L"DHT Nodes"); 
    741                 for (dht_node_details_t::const_iterator i = params.dht_nodes.begin(), e = params.dht_nodes.end(); 
    742                                 i != e; ++i) 
    743                 { 
    744                         HAL_DEV_MSG(wformat(L"URL: %1%, port: %2%") % (*i).url % (*i).port); 
    745                         t_info->add_node(hal::make_pair(to_utf8((*i).url), (*i).port)); 
    746                 } 
    747  
    748                 // calculate the hash for all pieces 
    749                 int num = t_info->num_pieces(); 
    750                 std::vector<char> piece_buf(piece_size); 
    751  
    752                 for (int i = 0; i < num; ++i) 
    753                 { 
    754                         store->read(&piece_buf[0], i, 0, t_info->piece_size(i)); 
    755  
    756                         libt::hasher h(&piece_buf[0], t_info->piece_size(i)); 
    757                         t_info->set_hash(i, h.final()); 
    758  
    759                         if (fn(100*i / num, hal::app().res_wstr(HAL_NEWT_HASHING_PIECES))) 
    760                         { 
    761                                 // User canceled torrent creation. 
    762  
    763                                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    764                                         new hal::EventMsg(hal::app().res_wstr(HAL_NEWT_CREATION_CANCELED), hal::event_logger::info))); 
    765  
    766                                 return true; 
    767                         } 
    768                 } 
    769  
    770                 t_info->set_creator(to_utf8(params.creator).c_str()); 
    771                 t_info->set_comment(to_utf8(params.comment).c_str()); 
    772                  
    773                 t_info->set_priv(params.private_torrent); 
    774  
    775                 // create the torrent and print it to out 
    776                 libt::entry e = t_info->create_torrent(); 
    777                 halencode(out_file, e); 
    778                 } 
    779                 catch(const std::exception& e) 
    780                 { 
    781                         event_log.post(shared_ptr<EventDetail>( 
    782                                 new EventStdException(event_logger::fatal, e, L"create_torrent"))); 
    783                 }        
    784  
    785                 return false; 
    786         } 
    787          
    788         std::pair<libt::entry, libt::entry> prepTorrent(wpath filename, wpath saveDirectory); 
    789         void removalThread(torrent_internal_ptr pIT, bool wipeFiles); 
    790          
    791         libt::session theSession;        
    792         mutable mutex_t mutex_; 
    793  
    794         asio::io_service io_; 
    795         asio::deadline_timer timer_; 
    796         bool keepChecking_; 
    797          
    798         static wpath workingDirectory; 
    799         ini_file bittorrentIni; 
    800         TorrentManager theTorrents;      
    801          
    802         int defTorrentMaxConn_; 
    803         int defTorrentMaxUpload_; 
    804         float defTorrentDownload_; 
    805         float defTorrentUpload_; 
    806          
    807         bool ip_filter_on_; 
    808         bool ip_filter_loaded_; 
    809         bool ip_filter_changed_; 
    810         libt::ip_filter ip_filter_; 
    811         size_t ip_filter_count_; 
    812          
    813         void ip_filter_count(); 
    814         void ip_filter_load(progress_callback fn); 
    815         void ip_filter_import(std::vector<libt::ip_range<asio::ip::address_v4> >& v4, 
    816                 std::vector<libt::ip_range<asio::ip::address_v6> >& v6); 
    817          
    818         bool dht_on_; 
    819         libt::dht_settings dht_settings_; 
    820         libt::entry dht_state_; 
    821          
    822 }; 
    823  
    824207wpath bit_impl::workingDirectory = hal::app().working_directory(); 
    825208 
  • trunk/src/halTorrentInternal.hpp

    r478 r479  
    7070#define HAL_NEWT_CREATION_CANCELED              HAL_TORRENT_INT_BEGIN + 30 
    7171 
    72  
    7372#ifndef RC_INVOKED 
     73 
     74#include <libtorrent/file.hpp> 
     75#include <libtorrent/hasher.hpp> 
     76#include <libtorrent/storage.hpp> 
     77#include <libtorrent/file_pool.hpp> 
     78#include <libtorrent/alert_types.hpp> 
     79#include <libtorrent/entry.hpp> 
     80#include <libtorrent/bencode.hpp> 
     81#include <libtorrent/session.hpp> 
     82#include <libtorrent/ip_filter.hpp> 
     83#include <libtorrent/torrent_handle.hpp> 
     84#include <libtorrent/peer_connection.hpp> 
     85#include <libtorrent/extensions/metadata_transfer.hpp> 
     86#include <libtorrent/extensions/ut_pex.hpp> 
    7487 
    7588#include <boost/tuple/tuple.hpp> 
  • trunk/src/halTypes.hpp

    r447 r479  
    3838        using fs::path; 
    3939} 
     40 
     41#define foreach BOOST_FOREACH 
Note: See TracChangeset for help on using the changeset viewer.