source: trunk/src/halTorrent.hpp @ 659

Revision 659, 25.5 KB checked in by Eoin, 11 years ago (diff)

Peer list sorting fixed and so more naming conventions consistency work.

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