Changeset 480

Timestamp:

06/05/08 19:27:01 (13 years ago)

Author:

Eoin

Message:

Much more refactoring my session code into seperate file.

Location:

trunk

Files:

• sln/Halite/Halite.vcproj (modified) (1 diff)
• src/halSession.cpp (added)
• src/halSession.hpp (modified) (8 diffs)
• src/halTorrent.cpp (modified) (9 diffs)
• src/halTorrentInternal.hpp (modified) (5 diffs)

trunk/sln/Halite/Halite.vcproj

@@ -548 +548 @@
                         </File>
                         <File
+                                RelativePath="..\..\src\halSession.cpp"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\halTorrent.cpp"
                                 >

trunk/src/halSession.hpp

@@ -34 +34 @@
 #include "halTypes.hpp"
 #include "halEvent.hpp"
+#include "halTorrentInternal.hpp"
 #include "halSignaler.hpp"
+
+namespace boost {
+namespace serialization {
+
+#define IP_SAVE  3
+
+template<class Archive, class address_type>
+void save(Archive& ar, const address_type& ip, const unsigned int version)
+{       
+#if IP_SAVE == 1
+        typename address_type::bytes_type bytes = ip.to_bytes();        
+        for (typename address_type::bytes_type::iterator i=bytes.begin(); i != bytes.end(); ++i)
+                ar & BOOST_SERIALIZATION_NVP(*i);
+#elif IP_SAVE == 2
+        string dotted = ip.to_string(); 
+        ar & BOOST_SERIALIZATION_NVP(dotted);
+#elif IP_SAVE == 3
+        unsigned long addr = ip.to_ulong();     
+        ar & BOOST_SERIALIZATION_NVP(addr);
+#endif
+}
+
+template<class Archive, class address_type>
+void load(Archive& ar, address_type& ip, const unsigned int version)
+{       
+#if IP_SAVE == 1
+        typename address_type::bytes_type bytes;        
+        for (typename address_type::bytes_type::iterator i=bytes.begin(); i != bytes.end(); ++i)
+                ar & BOOST_SERIALIZATION_NVP(*i);       
+        ip = address_type(bytes);
+#elif IP_SAVE == 2      
+        string dotted;
+        ar & BOOST_SERIALIZATION_NVP(dotted);   
+        ip = address_type::from_string(dotted);
+#elif IP_SAVE == 3
+        unsigned long addr;
+        ar & BOOST_SERIALIZATION_NVP(addr);     
+        ip = address_type(addr);
+#endif
+}
+
+template<class Archive, class String, class Traits>
+void save(Archive& ar, const boost::filesystem::basic_path<String, Traits>& p, const unsigned int version)
+{       
+        String str = p.string();
+        ar & BOOST_SERIALIZATION_NVP(str);
+}
+
+template<class Archive, class String, class Traits>
+void load(Archive& ar, boost::filesystem::basic_path<String, Traits>& p, const unsigned int version)
+{       
+        String str;
+        ar & BOOST_SERIALIZATION_NVP(str);
+
+        p = str;
+}
+
+template<class Archive, class String, class Traits>
+inline void serialize(
+        Archive & ar,
+        boost::filesystem::basic_path<String, Traits>& p,
+        const unsigned int file_version
+){
+        split_free(ar, p, file_version);            
+}
+
+template<class Archive, class address_type>
+void serialize(Archive& ar, libtorrent::ip_range<address_type>& addr, const unsigned int version)
+{       
+        ar & BOOST_SERIALIZATION_NVP(addr.first);
+        ar & BOOST_SERIALIZATION_NVP(addr.last);
+        addr.flags = libtorrent::ip_filter::blocked;
+}
+
+template<class Archive>
+void serialize(Archive& ar, hal::tracker_detail& tracker, const unsigned int version)
+{       
+        ar & BOOST_SERIALIZATION_NVP(tracker.url);
+        ar & BOOST_SERIALIZATION_NVP(tracker.tier);
+}
+
+} // namespace serialization
+} // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(asio::ip::address_v4)
+BOOST_SERIALIZATION_SPLIT_FREE(asio::ip::address_v6)
+
+namespace libtorrent
+{
+
+template<class Addr>
+bool operator==(const libtorrent::ip_range<Addr>& lhs, const int flags)
+{
+        return (lhs.flags == flags);
+}
+
+inline
+std::ostream& operator<<(std::ostream& os, libtorrent::ip_range<asio::ip::address_v4>& ip)
+{
+        os << ip.first.to_ulong();
+        os << ip.last.to_ulong();
+        
+        return os;
+}
+
+} // namespace libtorrent
 
 namespace hal
 {
 
+namespace libt = libtorrent;
+
+inline
 bool operator!=(const libt::dht_settings& lhs, const libt::dht_settings& rhs)
 {
@@ -141 +251 @@
         }
 
+        bool listenOn(std::pair<int, int> const& range)
+        {
+                try
+                {
+                
+                if (!session_.is_listening())
+                {
+                        return session_.listen_on(range);
+                }
+                else
+                {
+                        int port = session_.listen_port();
+                        
+                        if (port < range.first || port > range.second)
+                                return session_.listen_on(range);       
+                        else
+                        {
+                                signals.successful_listen();
+                                
+                                return true;
+                        }
+                }
+                
+                }
+                catch (const std::exception& e)
+                {
+                        event_log.post(shared_ptr<EventDetail>(
+                                new EventStdException(event_logger::fatal, e, L"From bit::listenOn.")));
+
+                        return false;
+                }
+                catch(...)
+                {
+                        return false;
+                }
+        }
+
+        int isListeningOn() 
+        {
+                if (!session_.is_listening())
+                        return -1;      
+                else
+                        return session_.listen_port();
+        }
+
+        void stopListening()
+        {
+                ensureDhtOff();
+                session_.listen_on(std::make_pair(0, 0));
+        }
+
+        bool ensureDhtOn()
+        {
+                if (!dht_on_)
+                {               
+                        try
+                        {
+                        session_.start_dht(dht_state_);
+                        dht_on_ = true;
+                        }
+                        catch(...)
+                        {}
+                }
+                        return dht_on_;
+        }
+
+        void ensureDhtOff()
+        {
+                if (dht_on_)
+                {
+                        session_.stop_dht();            
+                        dht_on_ = false;
+                }
+        }
+
+        void setDhtSettings(int max_peers_reply, int search_branching, 
+                int service_port, int max_fail_count)
+        {
+                libt::dht_settings settings;
+                settings.max_peers_reply = max_peers_reply;
+                settings.search_branching = search_branching;
+                settings.service_port = service_port;
+                settings.max_fail_count = max_fail_count;
+                
+                if (dht_settings_ != settings)
+                {
+                        dht_settings_ = settings;
+                        session_.set_dht_settings(dht_settings_);
+                }
+        }
+
+        void setMapping(int mapping)
+        {
+                if (mapping != bit::mappingNone)
+                {
+                        if (mapping == bit::mappingUPnP)
+                        {
+                                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting UPnP mapping.")));
+                                session_.stop_upnp();
+                                session_.stop_natpmp();
+
+                                signals.successful_listen.connect_once(bind(&libt::session::start_upnp, &session_));
+                        }
+                        else
+                        {
+                                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting NAT-PMP mapping.")));
+                                session_.stop_upnp();
+                                session_.stop_natpmp();
+
+                                signals.successful_listen.connect_once(bind(&libt::session::start_natpmp, &session_));
+                        }
+                }
+                else
+                {
+                        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"No mapping.")));
+                        session_.stop_upnp();
+                        session_.stop_natpmp();
+                }
+        }
+
+        void setTimeouts(int peers, int tracker)
+        {
+                libt::session_settings settings = session_.settings();
+                settings.peer_connect_timeout = peers;
+                settings.tracker_completion_timeout = tracker;
+
+                session_.set_settings(settings);
+
+                event_log.post(shared_ptr<EventDetail>(new EventMsg(
+                        wformat(L"Set Timeouts, peer %1%, tracker %2%") % peers % tracker)));
+        }
+
+        void setSessionLimits(int maxConn, int maxUpload)
+        {               
+                session_.set_max_uploads(maxUpload);
+                session_.set_max_connections(maxConn);
+                
+                event_log.post(shared_ptr<EventDetail>(new EventMsg(
+                        wformat(L"Set connections totals %1% and uploads %2%.") 
+                                % maxConn % maxUpload)));
+        }
+
+        void setSessionSpeed(float download, float upload)
+        {
+                int down = (download > 0) ? static_cast<int>(download*1024) : -1;
+                session_.set_download_rate_limit(down);
+                int up = (upload > 0) ? static_cast<int>(upload*1024) : -1;
+                session_.set_upload_rate_limit(up);
+                
+                event_log.post(shared_ptr<EventDetail>(new EventMsg(
+                        wformat(L"Set session rates at download %1% and upload %2%.") 
+                                % session_.download_rate_limit() % session_.upload_rate_limit())));
+        }
+
+        bool ensureIpFilterOn(progress_callback fn)
+        {
+                try
+                {
+                
+                if (!ip_filter_loaded_)
+                {
+                        ip_filter_load(fn);
+                        ip_filter_loaded_ = true;
+                }
+                
+                if (!ip_filter_on_)
+                {
+                        session_.set_ip_filter(ip_filter_);
+                        ip_filter_on_ = true;
+                        ip_filter_count();
+                }
+                
+                }
+                catch(const std::exception& e)
+                {               
+                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>(
+                                new hal::EventStdException(event_logger::critical, e, L"ensureIpFilterOn"))); 
+
+                        ensureIpFilterOff();
+                }
+
+                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters on.")));       
+
+                return false;
+        }
+
+        void ensureIpFilterOff()
+        {
+                session_.set_ip_filter(libt::ip_filter());
+                ip_filter_on_ = false;
+                
+                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters off.")));      
+        }
+
+        #ifndef TORRENT_DISABLE_ENCRYPTION      
+        void ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4)
+        {
+                libt::pe_settings pe;
+                
+                switch (enc_level)
+                {
+                        case 0:
+                                pe.allowed_enc_level = libt::pe_settings::plaintext;
+                                break;
+                        case 1:
+                                pe.allowed_enc_level = libt::pe_settings::rc4;
+                                break;
+                        case 2:
+                                pe.allowed_enc_level = libt::pe_settings::both;
+                                break;
+                        default:
+                                pe.allowed_enc_level = libt::pe_settings::both;
+                                
+                                hal::event_log.post(shared_ptr<hal::EventDetail>(
+                                        new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, 
+                                                (wformat(hal::app().res_wstr(HAL_INCORRECT_ENCODING_LEVEL)) % enc_level).str())));
+                }
+
+                switch (in_enc_policy)
+                {
+                        case 0:
+                                pe.in_enc_policy = libt::pe_settings::forced;
+                                break;
+                        case 1:
+                                pe.in_enc_policy = libt::pe_settings::enabled;
+                                break;
+                        case 2:
+                                pe.in_enc_policy = libt::pe_settings::disabled;
+                                break;
+                        default:
+                                pe.in_enc_policy = libt::pe_settings::enabled;
+                                
+                                hal::event_log.post(shared_ptr<hal::EventDetail>(
+                                        new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, 
+                                                (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str())));
+                }
+
+                switch (out_enc_policy)
+                {
+                        case 0:
+                                pe.out_enc_policy = libt::pe_settings::forced;
+                                break;
+                        case 1:
+                                pe.out_enc_policy = libt::pe_settings::enabled;
+                                break;
+                        case 2:
+                                pe.out_enc_policy = libt::pe_settings::disabled;
+                                break;
+                        default:
+                                pe.out_enc_policy = libt::pe_settings::enabled;
+                                
+                                hal::event_log.post(shared_ptr<hal::EventDetail>(
+                                        new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, 
+                                                (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str())));
+                }
+                
+                pe.prefer_rc4 = prefer_rc4;
+                
+                try
+                {
+                
+                session_.set_pe_settings(pe);
+                
+                }
+                catch(const std::exception& e)
+                {
+                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>(
+                                        new hal::EventStdException(event_logger::critical, e, L"ensurePeOn"))); 
+                                        
+                        ensurePeOff();          
+                }
+                
+                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption on.")));
+        }
+
+        void ensurePeOff()
+        {
+                libt::pe_settings pe;
+                pe.out_enc_policy = libt::pe_settings::disabled;
+                pe.in_enc_policy = libt::pe_settings::disabled;
+                
+                pe.allowed_enc_level = libt::pe_settings::both;
+                pe.prefer_rc4 = true;
+                
+                session_.set_pe_settings(pe);
+
+                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption off.")));
+        }
+        #endif
+
+        void ip_v4_filter_block(asio::ip::address_v4 first, asio::ip::address_v4 last)
+        {
+                ip_filter_.add_rule(first, last, libt::ip_filter::blocked);
+                ip_filter_count();
+                ip_filter_changed_ = true;
+        }
+
+        void ip_v6_filter_block(asio::ip::address_v6 first, asio::ip::address_v6 last)
+        {
+                ip_filter_.add_rule(first, last, libt::ip_filter::blocked);
+                ip_filter_count();
+                ip_filter_changed_ = true;
+        }
+
+        size_t ip_filter_size()
+        {
+                return ip_filter_count_;
+        }
+
+        void clearIpFilter()
+        {
+                ip_filter_ = libt::ip_filter();
+                session_.set_ip_filter(libt::ip_filter());      
+                ip_filter_changed_ = true;
+                ip_filter_count();
+        }
+
+        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
+
         struct 
         {
@@ -148 +577 @@
         signals;
 
-        void stopAlertHandler()
-        {
-                mutex_t::scoped_lock l(mutex_);
-
-                keepChecking_ = false;
-        }
-                
-        void alertHandler()
-        {
-                mutex_t::scoped_lock l(mutex_);
-
-                if (keepChecking_)
-                {
-                
-                std::auto_ptr<libt::alert> p_alert = theSession.pop_alert();
-                
-                class AlertHandler
-                {
-                public:
-                AlertHandler(bit_impl& bit_impl) :
-                        bit_impl_(bit_impl)
-                {}
-                
-                void operator()(libt::torrent_finished_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED)) 
-                                                % get(a.handle)->name()), 
-                                        event_logger::info, a.timestamp())));
-                        
-                        get(a.handle)->finished();      
-                }
-                
-                void operator()(libt::torrent_paused_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED)) 
-                                                % get(a.handle)->name()), 
-                                        event_logger::info, a.timestamp())));
-
-                        get(a.handle)->signals().torrent_paused();
-                }
-                
-                void operator()(libt::peer_error_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_PEER_ALERT))
-                                                % hal::from_utf8_safe(a.msg())
-                                                % hal::from_utf8_safe(a.ip.address().to_string()))
-                        )       );                              
-                }
-                        
-                void operator()(libt::peer_ban_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_PEER_BAN_ALERT))
-                                                % get(a.handle)->name()
-                                                % hal::from_utf8_safe(a.ip.address().to_string()))
-                        )       );                              
-                }
-                        
-                void operator()(libt::hash_failed_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_HASH_FAIL_ALERT))
-                                                % get(a.handle)->name()
-                                                % a.piece_index)
-                        )       );                              
-                }
-                        
-                void operator()(libt::url_seed_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_URL_SEED_ALERT))
-                                                % get(a.handle)->name()
-                                                % hal::from_utf8_safe(a.url)
-                                                % hal::from_utf8_safe(a.msg()))
-                        )       );                              
-                }
-                
-                void operator()(libt::tracker_warning_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT))
-                                                % get(a.handle)->name()
-                                                % hal::from_utf8_safe(a.msg()))
-                        )       );                              
-                }
-                
-                void operator()(libt::tracker_announce_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventMsg((wformat(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT)) 
-                                                % get(a.handle)->name()), 
-                                        event_logger::info, a.timestamp())));
-                }
-                
-                void operator()(libt::tracker_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_TRACKER_ALERT))
-                                                % get(a.handle)->name()
-                                                % hal::from_utf8_safe(a.msg())
-                                                % a.times_in_row
-                                                % a.status_code)
-                        )       );                              
-                }
-                
-                void operator()(libt::tracker_reply_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT))
-                                                % get(a.handle)->name()
-                                                % hal::from_utf8_safe(a.msg())
-                                                % a.num_peers)
-                        )       );                              
-                }
-                
-                void operator()(libt::fastresume_rejected_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_FAST_RESUME_ALERT))
-                                                % get(a.handle)->name()
-                                                % hal::from_utf8_safe(a.msg()))
-                        )       );                              
-                }
-                
-                void operator()(libt::piece_finished_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(event_logger::debug, a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT))
-                                                % get(a.handle)->name()
-                                                % a.piece_index)
-                        )       );                              
-                }
-                
-                void operator()(libt::block_finished_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(event_logger::debug, a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT))
-                                                % get(a.handle)->name()
-                                                % a.block_index
-                                                % a.piece_index)
-                        )       );                              
-                }
-                
-                void operator()(libt::block_downloading_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(event_logger::debug, a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT))
-                                                % get(a.handle)->name()
-                                                % a.block_index
-                                                % a.piece_index)
-                        )       );                              
-                }
-                
-                void operator()(libt::listen_failed_alert const& a) const
-                {
-                        if (a.endpoint.address().is_v6())
-                        {       
-                                event_log.post(shared_ptr<EventDetail>(
-                                        new EventGeneral(event_logger::info, a.timestamp(),
-                                                hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT))
-                                )       );              
-                        }
-                        else
-                        {
-                                event_log.post(shared_ptr<EventDetail>(
-                                        new EventGeneral(event_logger::info, a.timestamp(),
-                                                wformat(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT))
-                                                        % hal::from_utf8_safe(a.msg()))
-                                )       );
-                        }
-                }
-                
-                void operator()(libt::listen_succeeded_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(event_logger::info, a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT))
-                                                % hal::from_utf8_safe(a.msg()))
-                        )       );      
-
-                        bit_impl_.signals.successful_listen();
-                }
-                
-                void operator()(libt::peer_blocked_alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                new EventGeneral(event_logger::debug, a.timestamp(),
-                                        wformat(hal::app().res_wstr(HAL_IPFILTER_ALERT))
-                                                % hal::from_utf8_safe(a.ip.to_string())
-                                                % hal::from_utf8_safe(a.msg()))
-                        )       );                              
-                }
-                
-                void operator()(libt::alert const& a) const
-                {
-                        event_log.post(shared_ptr<EventDetail>(
-                                        new EventLibtorrent(lbtAlertToHalEvent(a.severity()), 
-                                                a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.msg()))));             
-                }
-                
-                private:
-                        bit_impl& bit_impl_;
-                        
-                        torrent_internal_ptr get(libt::torrent_handle h) const 
-                        { 
-                                return bit_impl_.theTorrents.get(from_utf8_safe(h.get_torrent_info().name())); 
-                        }
-                
-                } handler(*this);
-                
-                while (p_alert.get())
-                {       
-                        try
-                        {
-                        
-                        libt::handle_alert<
-                                libt::torrent_finished_alert,
-                                libt::torrent_paused_alert,
-                                libt::peer_error_alert,
-                                libt::peer_ban_alert,
-                                libt::hash_failed_alert,
-                                libt::url_seed_alert,
-                                libt::tracker_alert,
-                                libt::tracker_warning_alert,
-                                libt::tracker_announce_alert,
-                                libt::tracker_reply_alert,
-                                libt::fastresume_rejected_alert,
-                                libt::piece_finished_alert,
-                                libt::block_finished_alert,
-                                libt::block_downloading_alert,
-                                libt::listen_failed_alert,
-                                libt::listen_succeeded_alert,
-                                libt::peer_blocked_alert,
-                                libt::alert
-                        >::handle_alert(p_alert, handler);                      
-                        
-                        }
-                        catch(libt::unhandled_alert&)
-                        {
-                                handler(*p_alert);
-                        }
-                        catch(std::exception& e)
-                        {
-                                // These are logged as debug because they are rarely important to act on!
-                                event_log.post(shared_ptr<EventDetail>(\
-                                        new EventStdException(event_logger::debug, e, L"alertHandler")));
-                        }
-                        
-                        p_alert = theSession.pop_alert();
-                }
-                
-                timer_.expires_from_now(boost::posix_time::seconds(2));
-                timer_.async_wait(bind(&bit_impl::alertHandler, this));
-                }
-        }
+        void stopAlertHandler();
+        void alertHandler();
         
         void saveTorrentData()
@@ -429 +591 @@
                 if (dht_on_) 
                 {       
-                        halencode(workingDirectory/L"DHTState.bin", theSession.dht_state());
+                        halencode(workingDirectory/L"DHTState.bin", session_.dht_state());
                 }
                 
@@ -449 +611 @@
 private:
         bit_impl() :
-                theSession(libt::fingerprint(HALITE_FINGERPRINT)),
+                session_(libt::fingerprint(HALITE_FINGERPRINT)),
                 timer_(io_),
                 keepChecking_(false),
@@ -464 +626 @@
                 dht_on_(false)
         {
-                torrent_internal::the_session_ = &theSession;
+                torrent_internal::the_session_ = &session_;
                 torrent_internal::workingDir_ = workingDir();
                 
-                theSession.set_severity_level(libt::alert::debug);              
-                theSession.add_extension(&libt::create_metadata_plugin);
-                theSession.add_extension(&libt::create_ut_pex_plugin);
-                theSession.set_max_half_open_connections(10);
+                session_.set_severity_level(libt::alert::debug);                
+                session_.add_extension(&libt::create_metadata_plugin);
+                session_.add_extension(&libt::create_ut_pex_plugin);
+                session_.set_max_half_open_connections(10);
                 
                 hal::event_log.post(shared_ptr<hal::EventDetail>(
@@ -522 +684 @@
                 }
                 
-                {       libt::session_settings settings = theSession.settings();
+                {       libt::session_settings settings = session_.settings();
                         settings.user_agent = string("Halite ") + HALITE_VERSION_STRING;
-                        theSession.set_settings(settings);
+                        session_.set_settings(settings);
                 }
                 
@@ -622 +784 @@
         void removalThread(torrent_internal_ptr pIT, bool wipeFiles);
         
-        libt::session theSession;       
+        libt::session session_; 
         mutable mutex_t mutex_;
 

trunk/src/halTorrent.cpp

@@ -6 +6 @@
 
 #include "stdAfx.hpp"
-
-#define TORRENT_MAX_ALERT_TYPES 20
 
 #include <libtorrent/file.hpp>
@@ -34 +32 @@
 #include "halTorrentInternal.hpp"
 #include "halSession.hpp"
-
-namespace boost {
-namespace serialization {
-
-#define IP_SAVE  3
-
-template<class Archive, class address_type>
-void save(Archive& ar, const address_type& ip, const unsigned int version)
-{       
-#if IP_SAVE == 1
-        typename address_type::bytes_type bytes = ip.to_bytes();        
-        for (typename address_type::bytes_type::iterator i=bytes.begin(); i != bytes.end(); ++i)
-                ar & BOOST_SERIALIZATION_NVP(*i);
-#elif IP_SAVE == 2
-        string dotted = ip.to_string(); 
-        ar & BOOST_SERIALIZATION_NVP(dotted);
-#elif IP_SAVE == 3
-        unsigned long addr = ip.to_ulong();     
-        ar & BOOST_SERIALIZATION_NVP(addr);
-#endif
-}
-
-template<class Archive, class address_type>
-void load(Archive& ar, address_type& ip, const unsigned int version)
-{       
-#if IP_SAVE == 1
-        typename address_type::bytes_type bytes;        
-        for (typename address_type::bytes_type::iterator i=bytes.begin(); i != bytes.end(); ++i)
-                ar & BOOST_SERIALIZATION_NVP(*i);       
-        ip = address_type(bytes);
-#elif IP_SAVE == 2      
-        string dotted;
-        ar & BOOST_SERIALIZATION_NVP(dotted);   
-        ip = address_type::from_string(dotted);
-#elif IP_SAVE == 3
-        unsigned long addr;
-        ar & BOOST_SERIALIZATION_NVP(addr);     
-        ip = address_type(addr);
-#endif
-}
-
-template<class Archive, class String, class Traits>
-void save(Archive& ar, const boost::filesystem::basic_path<String, Traits>& p, const unsigned int version)
-{       
-        String str = p.string();
-        ar & BOOST_SERIALIZATION_NVP(str);
-}
-
-template<class Archive, class String, class Traits>
-void load(Archive& ar, boost::filesystem::basic_path<String, Traits>& p, const unsigned int version)
-{       
-        String str;
-        ar & BOOST_SERIALIZATION_NVP(str);
-
-        p = str;
-}
-
-template<class Archive, class String, class Traits>
-inline void serialize(
-        Archive & ar,
-        boost::filesystem::basic_path<String, Traits>& p,
-        const unsigned int file_version
-){
-        split_free(ar, p, file_version);            
-}
-
-template<class Archive, class address_type>
-void serialize(Archive& ar, libtorrent::ip_range<address_type>& addr, const unsigned int version)
-{       
-        ar & BOOST_SERIALIZATION_NVP(addr.first);
-        ar & BOOST_SERIALIZATION_NVP(addr.last);
-        addr.flags = libtorrent::ip_filter::blocked;
-}
-
-template<class Archive>
-void serialize(Archive& ar, hal::tracker_detail& tracker, const unsigned int version)
-{       
-        ar & BOOST_SERIALIZATION_NVP(tracker.url);
-        ar & BOOST_SERIALIZATION_NVP(tracker.tier);
-}
-
-} // namespace serialization
-} // namespace boost
-
-BOOST_SERIALIZATION_SPLIT_FREE(asio::ip::address_v4)
-BOOST_SERIALIZATION_SPLIT_FREE(asio::ip::address_v6)
-
-namespace libtorrent
-{
-template<class Addr>
-bool operator==(const libtorrent::ip_range<Addr>& lhs, const int flags)
-{
-        return (lhs.flags == flags);
-}
-
-std::ostream& operator<<(std::ostream& os, libtorrent::ip_range<asio::ip::address_v4>& ip)
-{
-        os << ip.first.to_ulong();
-        os << ip.last.to_ulong();
-        
-        return os;
-}
-
-} // namespace libtorrent
-
+//#include "halSessionAlert.hpp"
 
 namespace hal 
@@ -267 +161 @@
 bool bit::listenOn(std::pair<int, int> const& range)
 {
-        try
-        {
-        
-        if (!pimpl->theSession.is_listening())
-        {
-                return pimpl->theSession.listen_on(range);
-        }
-        else
-        {
-                int port = pimpl->theSession.listen_port();
-                
-                if (port < range.first || port > range.second)
-                        return pimpl->theSession.listen_on(range);      
-                else
-                {
-                        pimpl->signals.successful_listen();
-                        
-                        return true;
-                }
-        }
-        
-        }
-        catch (const std::exception& e)
-        {
-                event_log.post(shared_ptr<EventDetail>(
-                        new EventStdException(event_logger::fatal, e, L"From bit::listenOn.")));
-
-                return false;
-        }
-        catch(...)
-        {
-                return false;
-        }
+        return pimpl->listenOn(range);
 }
 
 int bit::isListeningOn() 
 {
-        if (!pimpl->theSession.is_listening())
-                return -1;      
-        else
-                return pimpl->theSession.listen_port();
+        return pimpl->isListeningOn();
 }
 
 void bit::stopListening()
 {
-        ensureDhtOff();
-        pimpl->theSession.listen_on(std::make_pair(0, 0));
+        pimpl->stopListening();
 }
 
 bool bit::ensureDhtOn()
 {
-        if (!pimpl->dht_on_)
-        {               
-                try
-                {
-                pimpl->theSession.start_dht(pimpl->dht_state_);
-                pimpl->dht_on_ = true;
-                }
-                catch(...)
-                {}
-        }
-                return pimpl->dht_on_;
+        return pimpl->ensureDhtOn();
 }
 
 void bit::ensureDhtOff()
 {
-        if (pimpl->dht_on_)
-        {
-                pimpl->theSession.stop_dht();           
-                pimpl->dht_on_ = false;
-        }
+        pimpl->ensureDhtOff();
 }
 
@@ -343 +187 @@
         int service_port, int max_fail_count)
 {
-        libt::dht_settings settings;
-        settings.max_peers_reply = max_peers_reply;
-        settings.search_branching = search_branching;
-        settings.service_port = service_port;
-        settings.max_fail_count = max_fail_count;
-        
-        if (pimpl->dht_settings_ != settings)
-        {
-                pimpl->dht_settings_ = settings;
-                pimpl->theSession.set_dht_settings(pimpl->dht_settings_);
-        }
+        pimpl->setDhtSettings(max_peers_reply, search_branching, service_port, max_fail_count);
 }
 
 void bit::setMapping(int mapping)
 {
-        if (mapping != mappingNone)
-        {
-                if (mapping == mappingUPnP)
-                {
-                        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting UPnP mapping.")));
-                        pimpl->theSession.stop_upnp();
-                        pimpl->theSession.stop_natpmp();
-
-                        pimpl->signals.successful_listen.connect_once(bind(&libt::session::start_upnp, &pimpl->theSession));
-                }
-                else
-                {
-                        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting NAT-PMP mapping.")));
-                        pimpl->theSession.stop_upnp();
-                        pimpl->theSession.stop_natpmp();
-
-                        pimpl->signals.successful_listen.connect_once(bind(&libt::session::start_natpmp, &pimpl->theSession));
-                }
-        }
-        else
-        {
-                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"No mapping.")));
-                pimpl->theSession.stop_upnp();
-                pimpl->theSession.stop_natpmp();
-        }
+        pimpl->setMapping(mapping);
 }
 
 void bit::setTimeouts(int peers, int tracker)
 {
-        libt::session_settings settings = pimpl->theSession.settings();
-        settings.peer_connect_timeout = peers;
-        settings.tracker_completion_timeout = tracker;
-
-        pimpl->theSession.set_settings(settings);
-
-        event_log.post(shared_ptr<EventDetail>(new EventMsg(
-                wformat(L"Set Timeouts, peer %1%, tracker %2%") % peers % tracker)));
+        pimpl->setTimeouts(peers, tracker);
 }
 
 void bit::setSessionLimits(int maxConn, int maxUpload)
 {               
-        pimpl->theSession.set_max_uploads(maxUpload);
-        pimpl->theSession.set_max_connections(maxConn);
-        
-        event_log.post(shared_ptr<EventDetail>(new EventMsg(
-                wformat(L"Set connections totals %1% and uploads %2%.") 
-                        % maxConn % maxUpload)));
+        pimpl->setSessionLimits(maxConn, maxUpload);
 }
 
 void bit::setSessionSpeed(float download, float upload)
 {
-        int down = (download > 0) ? static_cast<int>(download*1024) : -1;
-        pimpl->theSession.set_download_rate_limit(down);
-        int up = (upload > 0) ? static_cast<int>(upload*1024) : -1;
-        pimpl->theSession.set_upload_rate_limit(up);
-        
-        event_log.post(shared_ptr<EventDetail>(new EventMsg(
-                wformat(L"Set session rates at download %1% and upload %2%.") 
-                        % pimpl->theSession.download_rate_limit() % pimpl->theSession.upload_rate_limit())));
-}
-
-void bit_impl::ip_filter_count()
-{
-        libt::ip_filter::filter_tuple_t vectors = ip_filter_.export_filter();
-        
-        vectors.get<0>().erase(std::remove(vectors.get<0>().begin(), vectors.get<0>().end(), 0),
-                vectors.get<0>().end());
-        vectors.get<1>().erase(std::remove(vectors.get<1>().begin(), vectors.get<1>().end(), 0),
-                vectors.get<1>().end());
-        ip_filter_count_ = vectors.get<0>().size() + vectors.get<1>().size();
-}
-
-void bit_impl::ip_filter_load(progress_callback fn)
-{
-        fs::ifstream ifs(workingDirectory/L"IPFilter.bin", std::ios::binary);
-        if (ifs)
-        {
-                size_t v4_size;
-                ifs >> v4_size;
-                
-                size_t total = v4_size/100;
-                size_t previous = 0;
-                
-                for(unsigned i=0; i<v4_size; ++i)
-                {
-                        if (i-previous > total)
-                        {
-                                previous = i;
-
-                                if (fn) if (fn(size_t(i/total), hal::app().res_wstr(HAL_TORRENT_LOAD_FILTERS))) break;
-                        }
-                        
-                        read_range_to_filter<asio::ip::address_v4>(ifs, ip_filter_);
-                }
-        }       
-}
-
-void  bit_impl::ip_filter_import(std::vector<libt::ip_range<asio::ip::address_v4> >& v4,
-        std::vector<libt::ip_range<asio::ip::address_v6> >& v6)
-{
-        for(std::vector<libt::ip_range<asio::ip::address_v4> >::iterator i=v4.begin();
-                i != v4.end(); ++i)
-        {
-                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked);
-        }
-/*      for(std::vector<libt::ip_range<asio::ip::address_v6> >::iterator i=v6.begin();
-                i != v6.end(); ++i)
-        {
-                ip_filter_.add_rule(i->first, i->last, libt::ip_filter::blocked);
-        }
-*/      
-        /* Note here we do not set ip_filter_changed_ */
+        pimpl->setSessionSpeed(download, upload);
 }
 
 bool bit::ensureIpFilterOn(progress_callback fn)
 {
-        try
-        {
-        
-        if (!pimpl->ip_filter_loaded_)
-        {
-                pimpl->ip_filter_load(fn);
-                pimpl->ip_filter_loaded_ = true;
-        }
-        
-        if (!pimpl->ip_filter_on_)
-        {
-                pimpl->theSession.set_ip_filter(pimpl->ip_filter_);
-                pimpl->ip_filter_on_ = true;
-                pimpl->ip_filter_count();
-        }
-        
-        }
-        catch(const std::exception& e)
-        {               
-                hal::event_log.post(boost::shared_ptr<hal::EventDetail>(
-                        new hal::EventStdException(event_logger::critical, e, L"ensureIpFilterOn"))); 
-
-                ensureIpFilterOff();
-        }
-
-        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters on.")));       
-
-        return false;
+        return pimpl->ensureIpFilterOn(fn);
 }
 
 void bit::ensureIpFilterOff()
 {
-        pimpl->theSession.set_ip_filter(libt::ip_filter());
-        pimpl->ip_filter_on_ = false;
-        
-        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters off.")));      
+        pimpl->ensureIpFilterOff();
 }
 
 #ifndef TORRENT_DISABLE_ENCRYPTION      
+
 void bit::ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4)
 {
-        libt::pe_settings pe;
-        
-        switch (enc_level)
-        {
-                case 0:
-                        pe.allowed_enc_level = libt::pe_settings::plaintext;
-                        break;
-                case 1:
-                        pe.allowed_enc_level = libt::pe_settings::rc4;
-                        break;
-                case 2:
-                        pe.allowed_enc_level = libt::pe_settings::both;
-                        break;
-                default:
-                        pe.allowed_enc_level = libt::pe_settings::both;
-                        
-                        hal::event_log.post(shared_ptr<hal::EventDetail>(
-                                new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, 
-                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_ENCODING_LEVEL)) % enc_level).str())));
-        }
-
-        switch (in_enc_policy)
-        {
-                case 0:
-                        pe.in_enc_policy = libt::pe_settings::forced;
-                        break;
-                case 1:
-                        pe.in_enc_policy = libt::pe_settings::enabled;
-                        break;
-                case 2:
-                        pe.in_enc_policy = libt::pe_settings::disabled;
-                        break;
-                default:
-                        pe.in_enc_policy = libt::pe_settings::enabled;
-                        
-                        hal::event_log.post(shared_ptr<hal::EventDetail>(
-                                new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, 
-                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str())));
-        }
-
-        switch (out_enc_policy)
-        {
-                case 0:
-                        pe.out_enc_policy = libt::pe_settings::forced;
-                        break;
-                case 1:
-                        pe.out_enc_policy = libt::pe_settings::enabled;
-                        break;
-                case 2:
-                        pe.out_enc_policy = libt::pe_settings::disabled;
-                        break;
-                default:
-                        pe.out_enc_policy = libt::pe_settings::enabled;
-                        
-                        hal::event_log.post(shared_ptr<hal::EventDetail>(
-                                new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified, 
-                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str())));
-        }
-        
-        pe.prefer_rc4 = prefer_rc4;
-        
-        try
-        {
-        
-        pimpl->theSession.set_pe_settings(pe);
-        
-        }
-        catch(const std::exception& e)
-        {
-                hal::event_log.post(boost::shared_ptr<hal::EventDetail>(
-                                new hal::EventStdException(event_logger::critical, e, L"ensurePeOn"))); 
-                                
-                ensurePeOff();          
-        }
-        
-        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption on.")));
+        pimpl->ensurePeOn(enc_level, in_enc_policy, out_enc_policy, prefer_rc4);
 }
 
 void bit::ensurePeOff()
 {
-        libt::pe_settings pe;
-        pe.out_enc_policy = libt::pe_settings::disabled;
-        pe.in_enc_policy = libt::pe_settings::disabled;
-        
-        pe.allowed_enc_level = libt::pe_settings::both;
-        pe.prefer_rc4 = true;
-        
-        pimpl->theSession.set_pe_settings(pe);
-
-        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption off.")));
+        pimpl->ensurePeOff();
 }
 #endif
@@ -617 +242 @@
 void bit::ip_v6_filter_block(asio::ip::address_v6 first, asio::ip::address_v6 last)
 {
-        pimpl->ip_filter_.add_rule(first, last, libt::ip_filter::blocked);
-        pimpl->ip_filter_count();
-        pimpl->ip_filter_changed_ = true;
+        pimpl->ip_v6_filter_block(first, last);
 }
 
 size_t bit::ip_filter_size()
 {
-        return pimpl->ip_filter_count_;
+        return pimpl->ip_filter_size();
 }
 
 void bit::clearIpFilter()
 {
-        pimpl->ip_filter_ = libt::ip_filter();
-        pimpl->theSession.set_ip_filter(libt::ip_filter());     
-        pimpl->ip_filter_changed_ = true;
-        pimpl->ip_filter_count();
+        pimpl->clearIpFilter();
 }
 
 bool bit::ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix)
 {
-        try
-        {
-
-        fs::ifstream ifs(file); 
-        if (ifs)
-        {
-                boost::uintmax_t total = fs::file_size(file)/100;
-                boost::uintmax_t progress = 0;
-                boost::uintmax_t previous = 0;
-                
-                boost::regex reg("\\s*(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s*-\\s*(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s*.*");
-                boost::regex ip_reg("0*(\\d*)\\.0*(\\d*)\\.0*(\\d*)\\.0*(\\d*)");
-                boost::smatch m;
-                
-                string ip_address_line;         
-                while (!std::getline(ifs, ip_address_line).eof())
-                {               
-                        progress += (ip_address_line.length() + 2);
-                        if (progress-previous > total)
-                        {
-                                previous = progress;
-                                if (fn)
-                                {
-                                        if (fn(size_t(progress/total), hal::app().res_wstr(HAL_TORRENT_IMPORT_FILTERS))) 
-                                                break;
-                                }
-                        }
-                        
-                        if (boost::regex_match(ip_address_line, m, reg))
-                        {
-                                string first = m[1];
-                                string last = m[2];
-                                
-                                if (octalFix)
-                                {
-                                        if (boost::regex_match(first, m, ip_reg))
-                                        {
-                                                first = ((m.length(1) != 0) ? m[1] : string("0")) + "." +
-                                                                ((m.length(2) != 0) ? m[2] : string("0")) + "." +
-                                                                ((m.length(3) != 0) ? m[3] : string("0")) + "." +
-                                                                ((m.length(4) != 0) ? m[4] : string("0"));
-                                        }                                       
-                                        if (boost::regex_match(last, m, ip_reg))
-                                        {
-                                                last = ((m.length(1) != 0) ? m[1] : string("0")) + "." +
-                                                           ((m.length(2) != 0) ? m[2] : string("0")) + "." +
-                                                           ((m.length(3) != 0) ? m[3] : string("0")) + "." +
-                                                           ((m.length(4) != 0) ? m[4] : string("0"));
-                                        }
-                                }
-                                
-                                try
-                                {                       
-                                pimpl->ip_filter_.add_rule(asio::ip::address_v4::from_string(first),
-                                        asio::ip::address_v4::from_string(last), libt::ip_filter::blocked);     
-                                }
-                                catch(...)
-                                {
-                                        hal::event_log.post(shared_ptr<hal::EventDetail>(
-                                                new hal::EventDebug(hal::event_logger::info, 
-                                                        from_utf8((format("Invalid IP range: %1%-%2%.") % first % last).str()))));
-                                }
-                        }
-                }
-        }
-        
-        pimpl->ip_filter_changed_ = true;
-        pimpl->ip_filter_count();
-        
-        }
-        catch(const std::exception& e)
-        {
-                event_log.post(shared_ptr<EventDetail>(
-                        new EventStdException(event_logger::critical, e, L"ip_filter_import_dat")));
-        }
-
-        return false;
+        return pimpl->ip_filter_import_dat(file, fn, octalFix);
 }
 
@@ -720 +264 @@
         SessionDetail details;
         
-        details.port = pimpl->theSession.is_listening() ? pimpl->theSession.listen_port() : -1;
-        
-        libt::session_status status = pimpl->theSession.status();
+        details.port = pimpl->session_.is_listening() ? pimpl->session_.listen_port() : -1;
+        
+        libt::session_status status = pimpl->session_.status();
         
         details.speed = std::pair<double, double>(status.download_rate, status.upload_rate);
@@ -738 +282 @@
 void bit::setSessionHalfOpenLimit(int halfConn)
 {
-        pimpl->theSession.set_max_half_open_connections(halfConn);
+        pimpl->session_.set_max_half_open_connections(halfConn);
 
         event_log.post(shared_ptr<EventDetail>(new EventMsg(
-                wformat(L"Set half-open connections limit to %1%.") % pimpl->theSession.max_half_open_connections())));
+                wformat(L"Set half-open connections limit to %1%.") % pimpl->session_.max_half_open_connections())));
 }
 
@@ -1176 +720 @@
         if (!wipeFiles)
         {
-                theSession.remove_torrent(pIT->handle());
+                session_.remove_torrent(pIT->handle());
         }
         else
@@ -1182 +726 @@
                 if (pIT->in_session())
                 {
-                        theSession.remove_torrent(pIT->handle(), libt::session::delete_files);
+                        session_.remove_torrent(pIT->handle(), libt::session::delete_files);
                 }
                 else

trunk/src/halTorrentInternal.hpp

@@ -114 +114 @@
 namespace libt = libtorrent;
 
+inline
 libt::entry haldecode(const wpath &file) 
 {
@@ -125 +126 @@
 }
 
+inline
 bool halencode(const wpath &file, const libt::entry &e) 
 {
@@ -146 +148 @@
 }
 
+inline
 std::pair<std::string, std::string> extract_names(const wpath &file)
 {
@@ -558 +561 @@
         #undef TORRENT_INTERNALS_DEFAULTS
         
-        TorrentDetail_ptr getTorrentDetail_ptr();
-        void setTransferSpeed(float down, float up);
-        void setConnectionLimit(int maxConn, int maxUpload);
-        std::pair<float, float> getTransferSpeed();
-        std::pair<int, int> getConnectionLimit();
+        TorrentDetail_ptr getTorrentDetail_ptr()
+        {       
+                mutex_t::scoped_lock l(mutex_);
+
+                try
+                {
+
+                if (in_session())
+                {
+                        statusMemory_ = handle_.status();
+                        progress_ = statusMemory_.progress;
+                }
+                else
+                {
+                        // Wipe these cause they don't make sense for a non-active torrent.
+                        
+                        statusMemory_.download_payload_rate = 0;
+                        statusMemory_.upload_payload_rate = 0;
+                        statusMemory_.next_announce = boost::posix_time::seconds(0);            
+                }
+                
+                wstring state;
+                
+                switch (state_)
+                {
+                case TorrentDetail::torrent_paused:
+                        state = app().res_wstr(HAL_TORRENT_PAUSED);
+                        break;
+                        
+                case TorrentDetail::torrent_pausing:
+                        state = app().res_wstr(HAL_TORRENT_PAUSING);
+                        break;
+                        
+                case TorrentDetail::torrent_stopped:
+                        state = app().res_wstr(HAL_TORRENT_STOPPED);
+                        break;
+                        
+                case TorrentDetail::torrent_stopping:
+                        state = app().res_wstr(HAL_TORRENT_STOPPING);
+                        break;
+                        
+                default:
+                        switch (statusMemory_.state)
+                        {
+                        case libt::torrent_status::queued_for_checking:
+                                state = app().res_wstr(HAL_TORRENT_QUEUED_CHECKING);
+                                break;
+                        case libt::torrent_status::checking_files:
+                                state = app().res_wstr(HAL_TORRENT_CHECKING_FILES);
+                                break;
+                        case libt::torrent_status::connecting_to_tracker:
+                                state = app().res_wstr(HAL_TORRENT_CONNECTING);
+                                break;
+                        case libt::torrent_status::downloading_metadata:
+                                state = app().res_wstr(HAL_TORRENT_METADATA);
+                                break;
+                        case libt::torrent_status::downloading:
+                                state = app().res_wstr(HAL_TORRENT_DOWNLOADING);
+                                break;
+                        case libt::torrent_status::finished:
+                                state = app().res_wstr(HAL_TORRENT_FINISHED);
+                                break;
+                        case libt::torrent_status::seeding:
+                                state = app().res_wstr(HAL_TORRENT_SEEDING);
+                                break;
+                        case libt::torrent_status::allocating:
+                                state = app().res_wstr(HAL_TORRENT_ALLOCATING);
+                                break;
+                        }       
+                }
+                
+                pt::time_duration td(pt::pos_infin);
+                
+                if (statusMemory_.download_payload_rate != 0)
+                {
+                        td = boost::posix_time::seconds(        
+                                long(float(statusMemory_.total_wanted-statusMemory_.total_wanted_done) / statusMemory_.download_payload_rate));
+                }
+                
+                totalUploaded_ += (statusMemory_.total_payload_upload - totalBase_);
+                totalBase_ = statusMemory_.total_payload_upload;
+                
+                uploaded_.update(statusMemory_.total_upload);
+                payloadUploaded_.update(statusMemory_.total_payload_upload);
+                downloaded_.update(statusMemory_.total_download);
+                payloadDownloaded_.update(statusMemory_.total_payload_download);
+                
+                if (is_active())
+                {
+                        activeDuration_.update();
+                        
+                        if (libt::torrent_status::seeding == statusMemory_.state)
+                                seedingDuration_.update();
+                }       
+                
+                boost::tuple<size_t, size_t, size_t, size_t> connections = updatePeers();       
+
+                return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), state, hal::from_utf8(statusMemory_.current_tracker), 
+                        std::pair<float, float>(statusMemory_.download_payload_rate, statusMemory_.upload_payload_rate),
+                        progress_, statusMemory_.distributed_copies, statusMemory_.total_wanted_done, statusMemory_.total_wanted, uploaded_, payloadUploaded_,
+                        downloaded_, payloadDownloaded_, connections, ratio_, td, statusMemory_.next_announce, activeDuration_, seedingDuration_, startTime_, finishTime_));
+
+                }
+                catch (const libt::invalid_handle&)
+                {
+                        event_log.post(shared_ptr<EventDetail>(
+                                new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, to_utf8(name_), "getTorrentDetail_ptr")));
+                }
+                catch (const std::exception& e)
+                {
+                        event_log.post(shared_ptr<EventDetail>(
+                                new EventTorrentException(event_logger::critical, event_logger::torrentException, e.what(), to_utf8(name_), "getTorrentDetail_ptr")));
+                }
+                
+                return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), app().res_wstr(HAL_TORRENT_STOPPED), app().res_wstr(HAL_NA)));
+        }
+
+        void setTransferSpeed(float down, float up)
+        {       
+                mutex_t::scoped_lock l(mutex_);
+
+                transferLimit_ = std::make_pair(down, up);
+                
+                applyTransferSpeed();
+        }
+
+        void setConnectionLimit(int maxConn, int maxUpload)             
+        {
+                mutex_t::scoped_lock l(mutex_);
+
+                connections_ = maxConn;
+                uploads_ = maxUpload;
+                
+                applyConnectionLimit();
+        }
+
+        std::pair<float, float> getTransferSpeed()
+        {
+                return transferLimit_;
+        }
+
+        std::pair<int, int> getConnectionLimit()
+        {
+                return std::make_pair(connections_, uploads_);
+        }
         
         const wstring& name() const { return name_; }
@@ -1537 +1680 @@
 };
 
-void torrent_internal::setConnectionLimit(int maxConn, int maxUpload)
-{
-        mutex_t::scoped_lock l(mutex_);
-
-        connections_ = maxConn;
-        uploads_ = maxUpload;
-        
-        applyConnectionLimit();
-}
-
-std::pair<int, int> torrent_internal::getConnectionLimit()
-{
-        return std::make_pair(connections_, uploads_);
-}
-
-void torrent_internal::setTransferSpeed(float download, float upload)
-{       
-        mutex_t::scoped_lock l(mutex_);
-
-        transferLimit_ = std::make_pair(download, upload);
-        
-        applyTransferSpeed();
-}
-
-std::pair<float, float> torrent_internal::getTransferSpeed()
-{
-        return transferLimit_;
-}
-
-TorrentDetail_ptr torrent_internal::getTorrentDetail_ptr()
-{       
-        mutex_t::scoped_lock l(mutex_);
-
-        try
-        {
-
-        if (in_session())
-        {
-                statusMemory_ = handle_.status();
-                progress_ = statusMemory_.progress;
-        }
-        else
-        {
-                // Wipe these cause they don't make sense for a non-active torrent.
-                
-                statusMemory_.download_payload_rate = 0;
-                statusMemory_.upload_payload_rate = 0;
-                statusMemory_.next_announce = boost::posix_time::seconds(0);            
-        }
-        
-        wstring state;
-        
-        switch (state_)
-        {
-        case TorrentDetail::torrent_paused:
-                state = app().res_wstr(HAL_TORRENT_PAUSED);
-                break;
-                
-        case TorrentDetail::torrent_pausing:
-                state = app().res_wstr(HAL_TORRENT_PAUSING);
-                break;
-                
-        case TorrentDetail::torrent_stopped:
-                state = app().res_wstr(HAL_TORRENT_STOPPED);
-                break;
-                
-        case TorrentDetail::torrent_stopping:
-                state = app().res_wstr(HAL_TORRENT_STOPPING);
-                break;
-                
-        default:
-                switch (statusMemory_.state)
-                {
-                case libt::torrent_status::queued_for_checking:
-                        state = app().res_wstr(HAL_TORRENT_QUEUED_CHECKING);
-                        break;
-                case libt::torrent_status::checking_files:
-                        state = app().res_wstr(HAL_TORRENT_CHECKING_FILES);
-                        break;
-                case libt::torrent_status::connecting_to_tracker:
-                        state = app().res_wstr(HAL_TORRENT_CONNECTING);
-                        break;
-                case libt::torrent_status::downloading_metadata:
-                        state = app().res_wstr(HAL_TORRENT_METADATA);
-                        break;
-                case libt::torrent_status::downloading:
-                        state = app().res_wstr(HAL_TORRENT_DOWNLOADING);
-                        break;
-                case libt::torrent_status::finished:
-                        state = app().res_wstr(HAL_TORRENT_FINISHED);
-                        break;
-                case libt::torrent_status::seeding:
-                        state = app().res_wstr(HAL_TORRENT_SEEDING);
-                        break;
-                case libt::torrent_status::allocating:
-                        state = app().res_wstr(HAL_TORRENT_ALLOCATING);
-                        break;
-                }       
-        }
-        
-        pt::time_duration td(pt::pos_infin);
-        
-        if (statusMemory_.download_payload_rate != 0)
-        {
-                td = boost::posix_time::seconds(        
-                        long(float(statusMemory_.total_wanted-statusMemory_.total_wanted_done) / statusMemory_.download_payload_rate));
-        }
-        
-        totalUploaded_ += (statusMemory_.total_payload_upload - totalBase_);
-        totalBase_ = statusMemory_.total_payload_upload;
-        
-        uploaded_.update(statusMemory_.total_upload);
-        payloadUploaded_.update(statusMemory_.total_payload_upload);
-        downloaded_.update(statusMemory_.total_download);
-        payloadDownloaded_.update(statusMemory_.total_payload_download);
-        
-        if (is_active())
-        {
-                activeDuration_.update();
-                
-                if (libt::torrent_status::seeding == statusMemory_.state)
-                        seedingDuration_.update();
-        }       
-        
-        boost::tuple<size_t, size_t, size_t, size_t> connections = updatePeers();       
-
-        return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), state, hal::from_utf8(statusMemory_.current_tracker), 
-                std::pair<float, float>(statusMemory_.download_payload_rate, statusMemory_.upload_payload_rate),
-                progress_, statusMemory_.distributed_copies, statusMemory_.total_wanted_done, statusMemory_.total_wanted, uploaded_, payloadUploaded_,
-                downloaded_, payloadDownloaded_, connections, ratio_, td, statusMemory_.next_announce, activeDuration_, seedingDuration_, startTime_, finishTime_));
-
-        }
-        catch (const libt::invalid_handle&)
-        {
-                event_log.post(shared_ptr<EventDetail>(
-                        new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, to_utf8(name_), "getTorrentDetail_ptr")));
-        }
-        catch (const std::exception& e)
-        {
-                event_log.post(shared_ptr<EventDetail>(
-                        new EventTorrentException(event_logger::critical, event_logger::torrentException, e.what(), to_utf8(name_), "getTorrentDetail_ptr")));
-        }
-        
-        return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), app().res_wstr(HAL_TORRENT_STOPPED), app().res_wstr(HAL_NA)));
-}
-
 } // namespace hal