source: trunk/src/halTorrent.hpp @ 648

Revision 648, 25.3 KB checked in by Eoin, 11 years ago (diff)
Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2008.
3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
7#pragma once
8
9#include <string>
10#include <vector>
11#include <set>
12
13#include <boost/foreach.hpp>
14#include <boost/format.hpp>
15#include <boost/array.hpp>
16#include <boost/lexical_cast.hpp>
17#include <boost/bind.hpp>
18
19#include <boost/smart_ptr.hpp>
20
21#include <boost/noncopyable.hpp>
22
23#include <boost/signal.hpp>
24#include <boost/optional.hpp>
25#include <boost/function.hpp>
26
27#include <boost/smart_ptr.hpp>
28#include <boost/algorithm/string.hpp>
29
30#include <boost/filesystem/path.hpp>
31#include <boost/filesystem/operations.hpp>
32#include <boost/filesystem/fstream.hpp>
33
34#include <stlsoft/properties/method_properties.hpp>
35#include <stlsoft/util/operator_bool_adaptor.hpp>
36
37
38//#if BOOST_VERSION < 103500
39//#include <asio/ip/tcp.hpp>
40//#include <asio/ip/udp.hpp>
41//#else
42#include <boost/asio/ip/tcp.hpp>
43#include <boost/asio/ip/udp.hpp>
44//#endif
45
46#include "halTypes.hpp"
47
48namespace libtorrent { struct peer_info; }
49
50namespace hal
51{
52
53inline boost::wformat wform(const std::wstring & f_string) 
54{
55    using namespace boost::io;
56
57        boost::wformat fmter(f_string);
58    fmter.exceptions( no_error_bits  );
59    return fmter;
60}
61
62struct queue_settings
63{
64        friend class boost::serialization::access;
65        template<class Archive>
66        void serialize(Archive& ar, const unsigned int version)
67        {       
68                ar & BOOST_SERIALIZATION_NVP(auto_manage_interval);
69                ar & BOOST_SERIALIZATION_NVP(active_downloads);
70                ar & BOOST_SERIALIZATION_NVP(active_seeds);
71                ar & BOOST_SERIALIZATION_NVP(seeds_hard_limit);
72                ar & BOOST_SERIALIZATION_NVP(seed_ratio_limit);
73                ar & BOOST_SERIALIZATION_NVP(seed_ratio_time_limit);
74                ar & BOOST_SERIALIZATION_NVP(seed_time_limit);
75                ar & BOOST_SERIALIZATION_NVP(dont_count_slow_torrents);
76                ar & BOOST_SERIALIZATION_NVP(auto_scrape_min_interval);
77                ar & BOOST_SERIALIZATION_NVP(auto_scrape_interval);
78                ar & BOOST_SERIALIZATION_NVP(close_redundant_connections);
79        }
80
81        bool operator==(const queue_settings& s) const
82        {
83                return (auto_manage_interval == s.auto_manage_interval &&
84                        active_downloads == s.active_downloads &&
85                        active_seeds == s.active_seeds &&
86                        seeds_hard_limit == s.seeds_hard_limit &&
87                        seed_ratio_limit == s.seed_ratio_limit &&
88                        seed_ratio_time_limit == s.seed_ratio_time_limit &&
89                        seed_time_limit == s.seed_time_limit &&
90                        dont_count_slow_torrents == s.dont_count_slow_torrents &&
91                        auto_scrape_min_interval == s.auto_scrape_min_interval &&
92                        auto_scrape_interval == s.auto_scrape_interval &&
93                        close_redundant_connections == s.close_redundant_connections);
94        }
95       
96        bool operator!=(const queue_settings& s) const
97        {
98                return !(*this == s);
99        }
100
101        int auto_manage_interval;
102
103        int active_downloads;
104        int active_seeds;
105        int seeds_hard_limit;
106        float seed_ratio_limit;
107        float seed_ratio_time_limit;
108        int seed_time_limit;
109        bool dont_count_slow_torrents;
110
111        int auto_scrape_min_interval;
112        int auto_scrape_interval;
113        bool close_redundant_connections;
114};
115
116struct timeouts
117{
118        friend class boost::serialization::access;
119        template<class Archive>
120        void serialize(Archive& ar, const unsigned int version)
121        {       
122                ar & BOOST_SERIALIZATION_NVP(tracker_completion_timeout);
123                ar & BOOST_SERIALIZATION_NVP(tracker_receive_timeout);
124                ar & BOOST_SERIALIZATION_NVP(stop_tracker_timeout);
125
126                ar & BOOST_SERIALIZATION_NVP(request_queue_time);
127                ar & BOOST_SERIALIZATION_NVP(piece_timeout);
128                ar & BOOST_SERIALIZATION_NVP(min_reconnect_time);
129
130                ar & BOOST_SERIALIZATION_NVP(peer_timeout);
131                ar & BOOST_SERIALIZATION_NVP(urlseed_timeout);
132                ar & BOOST_SERIALIZATION_NVP(peer_connect_timeout);
133                ar & BOOST_SERIALIZATION_NVP(inactivity_timeout);
134                ar & BOOST_SERIALIZATION_NVP(handshake_timeout);
135        }
136
137        int tracker_completion_timeout;
138        int tracker_receive_timeout;
139        int stop_tracker_timeout;
140
141        float request_queue_time;
142        int piece_timeout;
143        int min_reconnect_time;
144
145        int peer_timeout;
146        int urlseed_timeout;
147        int peer_connect_timeout;
148        int inactivity_timeout;
149        int handshake_timeout;
150};
151
152struct dht_settings
153{
154        dht_settings() :
155                max_peers_reply(50),
156                search_branching(5),
157                service_port(6881),
158                max_fail_count(20)
159        {}
160
161        friend class boost::serialization::access;
162        template<class Archive>
163        void serialize(Archive& ar, const unsigned int version)
164        {       
165                ar & BOOST_SERIALIZATION_NVP(max_peers_reply);
166                ar & BOOST_SERIALIZATION_NVP(search_branching);
167                ar & BOOST_SERIALIZATION_NVP(service_port);
168                ar & BOOST_SERIALIZATION_NVP(max_fail_count);
169        }
170
171        int max_peers_reply;
172        int search_branching;
173        int service_port;
174        int max_fail_count;
175};
176
177struct cache_settings
178{
179        cache_settings() :
180                cache_size(512),
181                cache_expiry(60)
182        {}
183
184        friend class boost::serialization::access;
185        template<class Archive>
186        void serialize(Archive& ar, const unsigned int version)
187        {       
188                ar & BOOST_SERIALIZATION_NVP(cache_size);
189                ar & BOOST_SERIALIZATION_NVP(cache_expiry);
190        }
191
192        int cache_size;
193        int cache_expiry;
194};
195
196struct pe_settings
197{
198        pe_settings() :
199                encrypt_level(0),
200                prefer_rc4(false),
201                conn_in_policy(1),
202                conn_out_policy(1)
203        {}
204
205        friend class boost::serialization::access;
206        template<class Archive>
207        void serialize(Archive& ar, const unsigned int version)
208        {       
209                ar & BOOST_SERIALIZATION_NVP(encrypt_level);
210                ar & BOOST_SERIALIZATION_NVP(prefer_rc4);
211                ar & BOOST_SERIALIZATION_NVP(conn_in_policy);
212                ar & BOOST_SERIALIZATION_NVP(conn_out_policy);
213        }
214
215    int encrypt_level;
216    bool prefer_rc4;
217    int conn_in_policy;
218    int conn_out_policy;
219};
220
221struct connections
222{
223        connections() :
224                total(50),
225                uploads(10),
226                download_rate(-1),
227                upload_rate(-1)
228        {}
229
230        friend class boost::serialization::access;
231        template<class Archive>
232        void serialize(Archive& ar, const unsigned int version)
233        {       
234                ar & BOOST_SERIALIZATION_NVP(total);
235                ar & BOOST_SERIALIZATION_NVP(uploads);
236                ar & BOOST_SERIALIZATION_NVP(download_rate);
237                ar & BOOST_SERIALIZATION_NVP(upload_rate);
238        }
239
240    int total;
241    int uploads;
242    float download_rate;
243    float upload_rate;
244};
245
246struct cache_details
247{
248        cache_details() :
249                blocks_written(-1),
250                writes(-1),
251                blocks_read(-1),
252                blocks_read_hit(-1),
253                reads(-1),
254                cache_size(-1),
255                read_cache_size(-1),
256                write_ratio(-1),
257                read_ratio(-1),
258                write_cache_size(-1)
259        {}
260
261        cache_details(size_type b_w,
262                        size_type w,
263                        size_type b_r,
264                        size_type b_r_h,
265                        size_type r,
266                        int c_s,
267                        int r_c_s) :
268                blocks_written(b_w),
269                writes(w),
270                blocks_read(b_r),
271                blocks_read_hit(b_r_h),
272                reads(r),
273                cache_size(c_s),
274                read_cache_size(r_c_s),
275                write_cache_size(cache_size-read_cache_size)
276        {
277                write_ratio = (blocks_written == 0) ? 0 :
278                        static_cast<double>(blocks_written-writes) / blocks_written;
279
280                read_ratio = (blocks_read == 0) ? 0 :
281                        static_cast<double>(blocks_read_hit) / blocks_read;}
282
283    size_type blocks_written;
284    size_type writes;
285    size_type blocks_read;
286    size_type blocks_read_hit;
287    size_type reads;
288    int cache_size;
289    int read_cache_size;
290
291        double write_ratio;
292        double read_ratio;
293        int write_cache_size;
294};
295       
296struct torrentBriefDetail
297{
298        std::wstring filename;
299        std::wstring status;
300        std::pair<float,float> speed;
301        float completion;
302        int peers;
303        int seeds;
304};
305
306struct PeerDetail
307{
308        PeerDetail(const std::wstring& ip_address) :
309                ipAddress(ip_address)
310        {}
311        PeerDetail(libtorrent::peer_info& peerInfo);
312       
313        bool operator==(const PeerDetail& peer) const
314        {
315                return (ipAddress == peer.ipAddress);
316        }
317       
318        bool operator<(const PeerDetail& peer) const
319        {
320                return (ipAddress < peer.ipAddress);
321        }
322       
323        std::wstring ipAddress;
324        std::wstring country;
325        std::pair<float,float> speed;
326        bool seed;
327        std::wstring client;
328        std::wstring status;
329};
330
331typedef boost::shared_ptr<PeerDetail> PeerDetail_ptr;
332typedef std::vector<PeerDetail> PeerDetails;
333
334struct FileDetail
335{
336        FileDetail(boost::filesystem::wpath p, boost::int64_t s=0, boost::int64_t pg=0, int pr=1, size_t o=0, unsigned t=FileDetail::file) :
337                branch(p.parent_path()),
338                filename(p.filename()),
339                type(t),
340                size(s),
341                progress(pg),
342                priority(pr),
343                order_(o)
344        {}
345       
346        bool operator==(const FileDetail& file) const
347        {
348                return (branch == file.branch);
349        }
350       
351        bool operator<(const FileDetail& file) const
352        {
353                return (branch < file.branch);
354        }
355       
356        enum FileType
357        {
358                folder,
359                file
360        };
361       
362        size_t order() const { return order_; }
363       
364        boost::filesystem::wpath branch;
365        std::wstring filename;
366        unsigned type;
367        boost::int64_t size;
368        boost::int64_t progress;
369        int priority;
370       
371private:
372        size_t order_;
373};
374
375inline bool FileDetailNamesEqual(const FileDetail& l, const FileDetail& r)
376{
377        return l.filename == r.filename;
378}
379
380inline bool FileDetailNamesLess(const FileDetail& l, const FileDetail& r)
381{
382        return l.filename < r.filename;
383}
384
385typedef std::vector<FileDetail> FileDetails;
386
387class torrent_details 
388{
389public:
390        torrent_details(std::wstring n, std::wstring f, 
391                        std::wstring sd, 
392                        std::wstring s, 
393                        std::wstring cT, 
394                        std::pair<float,float> sp=std::pair<float,float>(0,0),
395                        float c=0,      float d=0, 
396                        size_type tWD=0, size_type tW=0, 
397                        size_type tU=0, size_type tpU=0, 
398                        size_type tD=0, size_type tpD=0, 
399                        boost::tuple<size_type, size_type, size_type, size_type> connections = 
400                                boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0), 
401                        float r=0, 
402                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), 
403                        boost::posix_time::time_duration uIn=boost::posix_time::seconds(0),
404                        boost::posix_time::time_duration actve=boost::posix_time::seconds(0), 
405                        boost::posix_time::time_duration seding=boost::posix_time::seconds(0), 
406                        boost::posix_time::ptime srt=boost::posix_time::second_clock::universal_time(), 
407                        boost::posix_time::ptime fin=boost::posix_time::second_clock::universal_time(), 
408                        int q_p=-1, 
409                        bool man=false) :
410                filename_(f),
411                name_(n),
412                saveDir_(sd),
413                state_(s),
414                currentTracker_(cT),
415                speed_(sp),
416                completion_(c),
417                distributed_copies_(d),
418                totalWantedDone_(tWD),
419                totalWanted_(tW),
420                totalUploaded_(tU),
421                totalPayloadUploaded_(tpU),
422                totalDownloaded_(tD),
423                totalPayloadDownloaded_(tpD),
424                peers_(connections.get<0>()),
425                connectedPeers_(connections.get<1>()),
426                seeds_(connections.get<2>()),
427                connectedSeeds_(connections.get<3>()),
428                ratio_(r),
429                estimatedTimeLeft_(eta),
430                updateTrackerIn_(uIn),
431                peerDetailsFilled_(false),
432                fileDetailsFilled_(false),
433                active_(actve),
434                seeding_(seding),
435                startTime_(srt),
436                finishTime_(fin),
437                queue_position_(q_p),
438                managed_(man)
439        {}
440
441        torrent_details() :     
442                peerDetailsFilled_(false),
443                fileDetailsFilled_(false)
444        {};     
445       
446        enum state
447        {
448                torrent_active = 0,
449                torrent_paused,
450                torrent_stopped,
451                torrent_pausing,
452                torrent_stopping
453        };
454       
455//      const std::wstring& filename() const { return filename_; }
456        const std::wstring& name() const { return name_; }
457        const std::wstring& save_directory() const { return saveDir_; }
458        const std::wstring& state() const { return state_; }
459        const std::wstring& currentTracker() const { return currentTracker_; }
460       
461        std::pair<float,float> speed() const { return speed_; }
462        const float& completion() const { return completion_; }
463        const float& distributedCopies() const { return distributed_copies_; }
464       
465        size_type totalUploaded() const { return totalUploaded_; }
466        size_type totalPayloadUploaded() const { return totalPayloadUploaded_; }
467        size_type totalDownloaded() const { return totalDownloaded_; }
468        size_type totalPayloadDownloaded() const { return totalPayloadDownloaded_; }
469        size_type totalWantedDone() const { return totalWantedDone_; }
470        size_type totalWanted() const { return totalWanted_; }
471       
472        size_type peers() const { return peers_; }
473        size_type peersConnected() const { return connectedPeers_; }
474        size_type seeds() const { return seeds_; }
475        size_type seedsConnected() const { return connectedSeeds_; }
476       
477        float ratio() { return ratio_; }
478       
479        const boost::posix_time::time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; }
480        const boost::posix_time::time_duration& updateTrackerIn() { return updateTrackerIn_; }
481       
482        const PeerDetails& peerDetails() const;
483        const FileDetails& fileDetails() const;
484       
485        const boost::posix_time::time_duration& active() { return active_; }
486        const boost::posix_time::time_duration& seeding() { return seeding_; }
487        const boost::posix_time::ptime& startTime() { return startTime_; }
488        const boost::posix_time::ptime& finishTime() { return finishTime_; }
489
490        int queue_position() const { return queue_position_; }
491        bool managed() const { return managed_; }
492       
493public:
494        std::wstring filename_;
495        std::wstring name_;
496        std::wstring saveDir_;
497        std::wstring state_;
498        std::wstring currentTracker_;
499
500        std::pair<float,float> speed_;         
501        float completion_;     
502        float distributed_copies_;
503       
504        size_type totalWantedDone_;
505        size_type totalWanted_;
506        size_type totalUploaded_;
507        size_type totalPayloadUploaded_;
508        size_type totalDownloaded_;
509        size_type totalPayloadDownloaded_;
510       
511        size_type peers_;
512        size_type connectedPeers_;
513        size_type seeds_;
514        size_type connectedSeeds_;
515       
516        float ratio_;
517       
518        boost::posix_time::time_duration estimatedTimeLeft_;
519        boost::posix_time::time_duration updateTrackerIn_;
520       
521        boost::posix_time::time_duration active_;
522        boost::posix_time::time_duration seeding_;
523        boost::posix_time::ptime startTime_;
524        boost::posix_time::ptime finishTime_;
525
526        int queue_position_;
527        bool managed_;
528       
529private:
530        mutable bool peerDetailsFilled_;
531        mutable PeerDetails peerDetails_;
532       
533        mutable bool fileDetailsFilled_;
534        mutable FileDetails fileDetails_;
535};
536
537typedef boost::shared_ptr<torrent_details> torrent_details_ptr;
538typedef boost::scoped_ptr<torrent_details> torrent_details_sptr;
539typedef boost::weak_ptr<torrent_details> torrent_details_wptr;
540typedef std::vector<torrent_details_ptr> torrent_details_vec;
541typedef std::map<std::wstring, torrent_details_ptr> torrent_details_map;
542
543class torrent_details_manager
544{
545public: 
546        void sort(boost::function<bool (const torrent_details_ptr&, const torrent_details_ptr&)> fn) const;
547       
548        const torrent_details_vec torrents() const 
549        {
550                mutex_t::scoped_lock l(mutex_); 
551                return torrents_; 
552        }
553       
554        const torrent_details_vec selectedTorrents() const 
555        { 
556                mutex_t::scoped_lock l(mutex_); 
557                return selectedTorrents_; 
558        }
559       
560        const torrent_details_ptr focusedTorrent() const 
561        {
562                mutex_t::scoped_lock l(mutex_); 
563                return selectedTorrent_; 
564        }
565       
566        const torrent_details_ptr get(std::wstring filename) const
567        {
568                mutex_t::scoped_lock l(mutex_); 
569               
570                torrent_details_map::const_iterator i = torrentMap_.find(filename);
571               
572                if (i != torrentMap_.end())
573                        return i->second;
574                else
575                        return torrent_details_ptr();
576        }
577       
578        friend class bit;
579
580private:
581        void clearAll(const mutex_t::scoped_lock&)
582        {
583                // !! No mutex lock, it should only be call from functions which
584                // have the lock themselves, hence the unused function param
585               
586                torrents_.clear();
587                torrentMap_.clear();
588                selectedTorrents_.clear();
589                selectedTorrent_.reset();
590        }
591
592        mutable torrent_details_vec torrents_;
593       
594        torrent_details_map torrentMap_;
595        torrent_details_vec selectedTorrents_;
596        torrent_details_ptr selectedTorrent_;
597       
598        mutable mutex_t mutex_;
599};
600
601struct tracker_detail
602{
603        tracker_detail() {}
604        tracker_detail(std::wstring u, int t) : url(u), tier(t) {}
605       
606        bool operator<(const tracker_detail& t) const
607        {
608                return (tier < t.tier);
609        }
610       
611        std::wstring url;
612        int tier;
613};
614
615typedef std::vector<tracker_detail> tracker_details_t;
616
617struct web_seed_or_dht_node_detail
618{
619        web_seed_or_dht_node_detail();
620        web_seed_or_dht_node_detail(std::wstring u);
621        web_seed_or_dht_node_detail(std::wstring u, int p);
622               
623        std::wstring url;
624        int port;
625        std::wstring type;
626};
627
628typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t;
629
630struct dht_node_detail
631{
632        dht_node_detail() {}
633        dht_node_detail(std::wstring u, int p) : url(u), port(p) {}
634       
635        std::wstring url;
636        int port;
637};
638
639typedef std::vector<dht_node_detail> dht_node_details_t;
640
641struct web_seed_detail
642{
643        web_seed_detail() {}
644        web_seed_detail(std::wstring u) : url(u) {}
645       
646        std::wstring url;
647};
648
649typedef std::vector<web_seed_detail> web_seed_details_t;
650
651struct create_torrent_params
652{
653        create_torrent_params() {}
654
655        std::wstring creator;
656        std::wstring comment;
657        int piece_size;
658        bool private_torrent;
659
660        file_size_pairs_t file_size_pairs;
661        fs::wpath root_path;
662
663        tracker_details_t trackers;
664        dht_node_details_t dht_nodes;
665        web_seed_details_t web_seeds;
666};
667
668class EventDetail;
669
670struct SessionDetail
671{
672        int port;
673       
674        std::pair<double, double> speed;
675       
676        bool dht_on;
677        size_t dht_nodes;
678        size_t dht_torrents;
679       
680        bool ip_filter_on;
681        size_t ip_ranges_filtered;
682};
683
684typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
685typedef boost::function<bool (size_t, std::wstring)> progress_callback;
686typedef boost::function<void (int)> report_num_active;
687typedef std::pair<wstring, wstring> wstring_pair;
688typedef std::pair<float, float> float_pair;
689typedef std::pair<int, int> int_pair;
690typedef std::pair<std::vector<int>, int> vec_int_pair;
691
692class bit_impl;
693class torrent_internal;
694
695class bit
696{
697public:         
698
699        enum mappings
700        {
701                mappingNone = 0,
702                mappingUPnP,
703                mappingNatPMP
704        };
705
706        enum allocations
707        {
708                sparse_allocation = 1,
709                compact_allocation,
710                full_allocation
711        };
712
713        enum queue_adjustments
714        {
715                move_up = 0,
716                move_down,
717                move_to_top,
718                move_to_bottom
719        };
720
721        class null_torrent : public std::exception
722        {
723        public:
724                null_torrent() {}               
725                virtual ~null_torrent() throw () {}
726        };
727
728        class torrent : public stlsoft::operator_bool_adaptor<torrent>
729        {
730                typedef torrent class_type;
731
732        public:
733                class exec_around_ptr
734                {
735                public:
736                        class proxy 
737                        {
738                        public:
739                                explicit proxy(torrent_internal* t);
740
741                                torrent_internal* operator->() 
742                                {
743                                        return t_;
744                                }
745
746                                ~proxy ();
747
748                        private:
749                                torrent_internal* t_;
750                                mutex_t::scoped_lock l_;
751                        };
752
753                        exec_around_ptr() {}
754                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {}
755
756                        proxy operator->() const
757                        {
758                                if (!ptr)
759                                        throw null_torrent();
760
761                                return proxy(&(*ptr));
762                        }
763
764                        operator bool() const { return ptr; }
765
766                private:
767                        boost::shared_ptr<torrent_internal> ptr;
768                };
769
770                torrent();
771                torrent(boost::shared_ptr<torrent_internal> p);
772
773                const std::wstring get_name() const;
774
775                float get_ratio() const;
776                void set_ratio(float new_ratio);
777               
778                std::pair<int, int> get_connection_limits() const;
779                void set_connection_limits(const std::pair<int, int>&);
780                std::pair<float, float> get_rate_limits() const;
781                void set_rate_limits(const std::pair<float, float>&);
782
783                wpath get_save_directory() const;
784                void set_save_directory(const wpath&);
785                wpath get_move_to_directory() const;
786                void set_move_to_directory(const wpath&);
787
788                std::pair<wstring, wstring> get_tracker_login() const;
789                void set_tracker_login(const std::pair<wstring, wstring>&);
790
791                std::vector<tracker_detail> get_trackers() const;
792                void set_trackers(const std::vector<tracker_detail>&);
793
794                bool get_is_active() const;
795                bool get_in_session() const;
796
797                void set_file_priorities(const vec_int_pair&);
798
799                void set_managed(bool);
800                bool get_managed() const;
801
802        public:
803                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(const std::wstring, class_type, 
804                        get_name, name);
805
806                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
807                        get_ratio, set_ratio, ratio);
808
809                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(int_pair, const int_pair&, class_type, 
810                        get_connection_limits, set_connection_limits, connection_limits);
811                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float_pair, const float_pair&, class_type, 
812                        get_rate_limits, set_rate_limits, rate_limits);
813               
814                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
815                        get_save_directory, set_save_directory, save_directory);
816                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
817                        get_move_to_directory, set_move_to_directory, move_to_directory);
818
819                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wstring_pair, const wstring_pair&, 
820                        class_type, get_tracker_login, set_tracker_login, tracker_login);
821
822                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
823                        get_is_active, is_active);
824                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
825                        get_in_session, in_session);
826
827                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(std::vector<tracker_detail>, const std::vector<tracker_detail>&, 
828                        class_type, get_trackers, set_trackers, trackers);
829
830                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(bool, bool, class_type, 
831                        get_managed, set_managed, managed);
832
833                STLSOFT_METHOD_PROPERTY_SET_EXTERNAL(const vec_int_pair&, class_type, 
834                        set_file_priorities, file_priorities);
835
836                void reset_trackers();
837                bool is_open() const;
838                void adjust_queue_position(bit::queue_adjustments adjust);
839
840        private:
841                exec_around_ptr ptr;
842        };
843
844        void shutdown_session();
845        void save_torrent_data();
846
847        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
848
849        template<typename T>
850        torrent get(T t)
851        {
852                return get_wstr(to_wstr_shim(t));
853        }
854       
855        template<>
856        torrent get(const hal::torrent_details_ptr t)
857        {
858                if (t) 
859                        return get_wstr(t->name());
860                else
861                        return torrent();
862        }       
863
864        torrent get_wstr(const std::wstring& filename);
865       
866        bool listen_on(std::pair<int, int> const& portRange);
867        int is_listening_on();
868        void stop_listening();
869       
870        bool ensure_dht_on(const dht_settings& dht);
871        void ensure_dht_off();
872       
873        void ensure_pe_on(const pe_settings& pe);
874        void ensure_pe_off();
875       
876        bool ensure_ip_filter_on(progress_callback fn);
877        void ensure_ip_filter_off();
878
879        void set_resolve_countries(bool);
880        void start_smart_ban_plugin();
881        void start_ut_pex_plugin();
882        void start_ut_metadata_plugin();
883        void start_metadata_plugin();
884
885        void set_mapping(bool upnp, bool nat_pmp);
886        std::wstring upnp_router_model();
887
888        void ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last);
889        void ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last);
890        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
891        size_t ip_filter_size();
892        void clear_ip_filter(); 
893       
894        void set_session_half_open_limit(int halfConn);
895        void set_session_limits(int maxConn, int maxUpload);
896        void set_session_speed(float download, float upload);
897
898        queue_settings get_queue_settings();
899        void set_queue_settings(const queue_settings& s);
900       
901        timeouts get_timeouts();
902        void set_timeouts(const timeouts& t);
903
904        const cache_details get_cache_details() const;
905
906        void set_cache_settings(const cache_settings& cache);
907        cache_settings get_cache_settings() const;
908       
909        const SessionDetail get_session_details();
910
911        void set_torrent_defaults(const connections& defaults); 
912        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
913                bool startPaused=false, bool managed=false, allocations alloc=hal::bit::sparse_allocation, 
914                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false);
915       
916        void get_all_peer_details(const std::string& filename, PeerDetails& peerContainer);
917        void get_all_peer_details(const std::wstring& filename, PeerDetails& peerContainer);
918        void get_all_file_details(const std::string& filename, FileDetails& fileDetails);
919        void get_all_file_details(const std::wstring& filename, FileDetails& fileDetails);
920       
921        void resume_all();
922        void close_all(boost::optional<report_num_active> fn);
923       
924        bool is_torrent(const std::string& filename);
925        bool is_torrent(const std::wstring& filename); 
926       
927        void pause_torrent(const std::string& filename);
928        void pause_torrent(const std::wstring& filename);
929        void resume_torrent(const std::string& filename);
930        void resume_torrent(const std::wstring& filename);
931        void stop_torrent(const std::string& filename);
932        void stop_torrent(const std::wstring& filename);
933        bool is_torrent_active(const std::string& filename);
934        bool is_torrent_active(const std::wstring& filename);
935        void reannounce_torrent(const std::string& filename);
936        void reannounce_torrent(const std::wstring& filename);
937        void recheck_torrent(const std::string& filename);
938        void recheck_torrent(const std::wstring& filename);
939       
940        void pause_all_torrents();
941        void unpause_all_torrents();
942
943        template<typename S>
944        void remove_torrent(S filename)
945        { 
946                remove_torrent_wstr(to_wstr_shim(filename)); 
947        }       
948
949        template<typename S>
950        void remove_torrent_wipe_files(S filename)
951        { 
952                remove_torrent_wipe_files_wstr(to_wstr_shim(filename)); 
953        }       
954
955        void start_event_receiver();
956        void stop_event_receiver();
957       
958        friend bit& bittorrent();
959       
960        int default_torrent_max_connections();
961        int default_torrent_max_uploads();
962        float default_torrent_download();
963        float default_torrent_upload(); 
964
965        const torrent_details_manager& torrentDetails();
966        const torrent_details_manager& updatetorrent_details_manager(const std::wstring& focused, const std::set<std::wstring>& selected);
967       
968private:
969        bit();
970
971        bit_impl* pimpl();
972        const bit_impl* pimpl() const;
973        boost::scoped_ptr<bit_impl> pimpl_;
974       
975        void remove_torrent_wstr(const std::wstring& filename);
976        void remove_torrent_wipe_files_wstr(const std::wstring&  filename);
977       
978        torrent_details_manager torrentDetails_;
979};
980
981bit& bittorrent();
982
983};
Note: See TracBrowser for help on using the repository browser.