source: trunk/src/halTorrent.hpp @ 656

Revision 656, 25.7 KB checked in by Eoin, 11 years ago (diff)

Halite ListView? sorting fully working. Clean up to follow.

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        enum details
456        {
457                name_e = 0,
458                state_e,
459                progress_e,
460                speed_down_e,
461                speed_up_e,
462                peers_e,
463                seeds_e,
464                eta_e,
465                distributed_copies_e,
466                tracker,
467                update_tracker_in_e,
468                ratio_e,
469                total_wanted_e,
470                completed_e,
471                remaining_e,
472                downloaded_e,
473                uploaded_e,
474                active_time_e,
475                seeding_time_e,
476                start_time_e,
477                finish_time_e,
478                managed_e,
479                queue_position_e
480        };
481
482       
483//      const std::wstring& filename() const { return filename_; }
484        const std::wstring& name() const { return name_; }
485        const std::wstring& save_directory() const { return saveDir_; }
486        const std::wstring& state() const { return state_; }
487        const std::wstring& currentTracker() const { return currentTracker_; }
488       
489        std::pair<float,float> speed() const { return speed_; }
490        const float& completion() const { return completion_; }
491        const float& distributedCopies() const { return distributed_copies_; }
492       
493        size_type totalUploaded() const { return totalUploaded_; }
494        size_type totalPayloadUploaded() const { return totalPayloadUploaded_; }
495        size_type totalDownloaded() const { return totalDownloaded_; }
496        size_type totalPayloadDownloaded() const { return totalPayloadDownloaded_; }
497        size_type totalWantedDone() const { return totalWantedDone_; }
498        size_type totalWanted() const { return totalWanted_; }
499       
500        size_type peers() const { return peers_; }
501        size_type peersConnected() const { return connectedPeers_; }
502        size_type seeds() const { return seeds_; }
503        size_type seedsConnected() const { return connectedSeeds_; }
504       
505        float ratio() { return ratio_; }
506       
507        const boost::posix_time::time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; }
508        const boost::posix_time::time_duration& updateTrackerIn() { return updateTrackerIn_; }
509       
510        const PeerDetails& peerDetails() const;
511        const FileDetails& fileDetails() const;
512       
513        const boost::posix_time::time_duration& active() { return active_; }
514        const boost::posix_time::time_duration& seeding() { return seeding_; }
515        const boost::posix_time::ptime& startTime() { return startTime_; }
516        const boost::posix_time::ptime& finishTime() { return finishTime_; }
517
518        int queue_position() const { return queue_position_; }
519        bool managed() const { return managed_; }
520
521        bool less(const torrent_details& r, size_t index = 0) const;
522        std::wstring to_wstring(size_t index = 0);
523       
524public:
525        std::wstring filename_;
526        std::wstring name_;
527        std::wstring saveDir_;
528        std::wstring state_;
529        std::wstring currentTracker_;
530
531        std::pair<float,float> speed_;         
532        float completion_;     
533        float distributed_copies_;
534       
535        size_type totalWantedDone_;
536        size_type totalWanted_;
537        size_type totalUploaded_;
538        size_type totalPayloadUploaded_;
539        size_type totalDownloaded_;
540        size_type totalPayloadDownloaded_;
541       
542        size_type peers_;
543        size_type connectedPeers_;
544        size_type seeds_;
545        size_type connectedSeeds_;
546       
547        float ratio_;
548       
549        boost::posix_time::time_duration estimatedTimeLeft_;
550        boost::posix_time::time_duration updateTrackerIn_;
551       
552        boost::posix_time::time_duration active_;
553        boost::posix_time::time_duration seeding_;
554        boost::posix_time::ptime startTime_;
555        boost::posix_time::ptime finishTime_;
556
557        int queue_position_;
558        bool managed_;
559       
560private:
561        mutable bool peerDetailsFilled_;
562        mutable PeerDetails peerDetails_;
563       
564        mutable bool fileDetailsFilled_;
565        mutable FileDetails fileDetails_;
566};
567
568typedef boost::shared_ptr<torrent_details> torrent_details_ptr;
569typedef boost::scoped_ptr<torrent_details> torrent_details_sptr;
570typedef boost::weak_ptr<torrent_details> torrent_details_wptr;
571typedef std::vector<torrent_details_ptr> torrent_details_vec;
572typedef std::map<std::wstring, torrent_details_ptr> torrent_details_map;
573
574class torrent_details_manager
575{
576public: 
577        void sort(size_t index, bool cmp_less = true) const;
578       
579        const torrent_details_vec torrents() const 
580        {
581                mutex_t::scoped_lock l(mutex_); 
582                return torrents_; 
583        }
584       
585        const torrent_details_vec selectedTorrents() const 
586        { 
587                mutex_t::scoped_lock l(mutex_); 
588                return selectedTorrents_; 
589        }
590       
591        const torrent_details_ptr focusedTorrent() const 
592        {
593                mutex_t::scoped_lock l(mutex_); 
594                return selectedTorrent_; 
595        }
596       
597        const torrent_details_ptr get(std::wstring filename) const
598        {
599                mutex_t::scoped_lock l(mutex_); 
600               
601                torrent_details_map::const_iterator i = torrentMap_.find(filename);
602               
603                if (i != torrentMap_.end())
604                        return i->second;
605                else
606                        return torrent_details_ptr();
607        }
608       
609        friend class bit;
610
611private:
612        void clearAll(const mutex_t::scoped_lock&)
613        {
614                // !! No mutex lock, it should only be called from functions which
615                // have the lock themselves, hence the unused function param
616               
617                torrents_.clear();
618                torrentMap_.clear();
619                selectedTorrents_.clear();
620                selectedTorrent_.reset();
621        }
622
623        mutable torrent_details_vec torrents_;
624       
625        torrent_details_map torrentMap_;
626        torrent_details_vec selectedTorrents_;
627        torrent_details_ptr selectedTorrent_;
628       
629        mutable mutex_t mutex_;
630};
631
632struct tracker_detail
633{
634        tracker_detail() {}
635        tracker_detail(std::wstring u, int t) : url(u), tier(t) {}
636       
637        bool operator<(const tracker_detail& t) const
638        {
639                return (tier < t.tier);
640        }
641       
642        std::wstring url;
643        int tier;
644};
645
646typedef std::vector<tracker_detail> tracker_details_t;
647
648struct web_seed_or_dht_node_detail
649{
650        web_seed_or_dht_node_detail();
651        web_seed_or_dht_node_detail(std::wstring u);
652        web_seed_or_dht_node_detail(std::wstring u, int p);
653               
654        std::wstring url;
655        int port;
656        std::wstring type;
657};
658
659typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t;
660
661struct dht_node_detail
662{
663        dht_node_detail() {}
664        dht_node_detail(std::wstring u, int p) : url(u), port(p) {}
665       
666        std::wstring url;
667        int port;
668};
669
670typedef std::vector<dht_node_detail> dht_node_details_t;
671
672struct web_seed_detail
673{
674        web_seed_detail() {}
675        web_seed_detail(std::wstring u) : url(u) {}
676       
677        std::wstring url;
678};
679
680typedef std::vector<web_seed_detail> web_seed_details_t;
681
682struct create_torrent_params
683{
684        create_torrent_params() {}
685
686        std::wstring creator;
687        std::wstring comment;
688        int piece_size;
689        bool private_torrent;
690
691        file_size_pairs_t file_size_pairs;
692        fs::wpath root_path;
693
694        tracker_details_t trackers;
695        dht_node_details_t dht_nodes;
696        web_seed_details_t web_seeds;
697};
698
699class EventDetail;
700
701struct SessionDetail
702{
703        int port;
704       
705        std::pair<double, double> speed;
706       
707        bool dht_on;
708        size_t dht_nodes;
709        size_t dht_torrents;
710       
711        bool ip_filter_on;
712        size_t ip_ranges_filtered;
713};
714
715typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
716typedef boost::function<bool (size_t, std::wstring)> progress_callback;
717typedef boost::function<void (int)> report_num_active;
718typedef std::pair<wstring, wstring> wstring_pair;
719typedef std::pair<float, float> float_pair;
720typedef std::pair<int, int> int_pair;
721typedef std::pair<std::vector<int>, int> vec_int_pair;
722
723class bit_impl;
724class torrent_internal;
725
726class bit
727{
728public:         
729
730        enum mappings
731        {
732                mappingNone = 0,
733                mappingUPnP,
734                mappingNatPMP
735        };
736
737        enum allocations
738        {
739                sparse_allocation = 1,
740                compact_allocation,
741                full_allocation
742        };
743
744        enum queue_adjustments
745        {
746                move_up = 0,
747                move_down,
748                move_to_top,
749                move_to_bottom
750        };
751
752        class null_torrent : public std::exception
753        {
754        public:
755                null_torrent() {}               
756                virtual ~null_torrent() throw () {}
757        };
758
759        class torrent : public stlsoft::operator_bool_adaptor<torrent>
760        {
761                typedef torrent class_type;
762
763        public:
764                class exec_around_ptr
765                {
766                public:
767                        class proxy 
768                        {
769                        public:
770                                explicit proxy(torrent_internal* t);
771
772                                torrent_internal* operator->() 
773                                {
774                                        return t_;
775                                }
776
777                                ~proxy ();
778
779                        private:
780                                torrent_internal* t_;
781                                mutex_t::scoped_lock l_;
782                        };
783
784                        exec_around_ptr() {}
785                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {}
786
787                        proxy operator->() const
788                        {
789                                if (!ptr)
790                                        throw null_torrent();
791
792                                return proxy(&(*ptr));
793                        }
794
795                        operator bool() const { return ptr; }
796
797                private:
798                        boost::shared_ptr<torrent_internal> ptr;
799                };
800
801                torrent();
802                torrent(boost::shared_ptr<torrent_internal> p);
803
804                const std::wstring get_name() const;
805
806                float get_ratio() const;
807                void set_ratio(float new_ratio);
808               
809                std::pair<int, int> get_connection_limits() const;
810                void set_connection_limits(const std::pair<int, int>&);
811                std::pair<float, float> get_rate_limits() const;
812                void set_rate_limits(const std::pair<float, float>&);
813
814                wpath get_save_directory() const;
815                void set_save_directory(const wpath&);
816                wpath get_move_to_directory() const;
817                void set_move_to_directory(const wpath&);
818
819                std::pair<wstring, wstring> get_tracker_login() const;
820                void set_tracker_login(const std::pair<wstring, wstring>&);
821
822                std::vector<tracker_detail> get_trackers() const;
823                void set_trackers(const std::vector<tracker_detail>&);
824
825                bool get_is_active() const;
826                bool get_in_session() const;
827
828                void set_file_priorities(const vec_int_pair&);
829
830                void set_managed(bool);
831                bool get_managed() const;
832
833        public:
834                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(const std::wstring, class_type, 
835                        get_name, name);
836
837                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
838                        get_ratio, set_ratio, ratio);
839
840                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(int_pair, const int_pair&, class_type, 
841                        get_connection_limits, set_connection_limits, connection_limits);
842                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float_pair, const float_pair&, class_type, 
843                        get_rate_limits, set_rate_limits, rate_limits);
844               
845                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
846                        get_save_directory, set_save_directory, save_directory);
847                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
848                        get_move_to_directory, set_move_to_directory, move_to_directory);
849
850                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wstring_pair, const wstring_pair&, 
851                        class_type, get_tracker_login, set_tracker_login, tracker_login);
852
853                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
854                        get_is_active, is_active);
855                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
856                        get_in_session, in_session);
857
858                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(std::vector<tracker_detail>, const std::vector<tracker_detail>&, 
859                        class_type, get_trackers, set_trackers, trackers);
860
861                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(bool, bool, class_type, 
862                        get_managed, set_managed, managed);
863
864                STLSOFT_METHOD_PROPERTY_SET_EXTERNAL(const vec_int_pair&, class_type, 
865                        set_file_priorities, file_priorities);
866
867                void reset_trackers();
868                bool is_open() const;
869                void adjust_queue_position(bit::queue_adjustments adjust);
870
871        private:
872                exec_around_ptr ptr;
873        };
874
875        void shutdown_session();
876        void save_torrent_data();
877
878        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
879
880        template<typename T>
881        torrent get(T t)
882        {
883                return get_wstr(to_wstr_shim(t));
884        }
885       
886        template<>
887        torrent get(const hal::torrent_details_ptr t)
888        {
889                if (t) 
890                        return get_wstr(t->name());
891                else
892                        return torrent();
893        }       
894
895        torrent get_wstr(const std::wstring& filename);
896       
897        bool listen_on(std::pair<int, int> const& portRange);
898        int is_listening_on();
899        void stop_listening();
900       
901        bool ensure_dht_on(const dht_settings& dht);
902        void ensure_dht_off();
903       
904        void ensure_pe_on(const pe_settings& pe);
905        void ensure_pe_off();
906       
907        bool ensure_ip_filter_on(progress_callback fn);
908        void ensure_ip_filter_off();
909
910        void set_resolve_countries(bool);
911        void start_smart_ban_plugin();
912        void start_ut_pex_plugin();
913        void start_ut_metadata_plugin();
914        void start_metadata_plugin();
915
916        void set_mapping(bool upnp, bool nat_pmp);
917        std::wstring upnp_router_model();
918
919        void ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last);
920        void ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last);
921        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
922        size_t ip_filter_size();
923        void clear_ip_filter(); 
924       
925        void set_session_half_open_limit(int halfConn);
926        void set_session_limits(int maxConn, int maxUpload);
927        void set_session_speed(float download, float upload);
928
929        queue_settings get_queue_settings();
930        void set_queue_settings(const queue_settings& s);
931       
932        timeouts get_timeouts();
933        void set_timeouts(const timeouts& t);
934
935        const cache_details get_cache_details() const;
936
937        void set_cache_settings(const cache_settings& cache);
938        cache_settings get_cache_settings() const;
939       
940        const SessionDetail get_session_details();
941
942        void set_torrent_defaults(const connections& defaults); 
943        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
944                bool startPaused=false, bool managed=false, allocations alloc=hal::bit::sparse_allocation, 
945                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false);
946       
947        void get_all_peer_details(const std::string& filename, PeerDetails& peerContainer);
948        void get_all_peer_details(const std::wstring& filename, PeerDetails& peerContainer);
949        void get_all_file_details(const std::string& filename, FileDetails& fileDetails);
950        void get_all_file_details(const std::wstring& filename, FileDetails& fileDetails);
951       
952        void resume_all();
953        void close_all(boost::optional<report_num_active> fn);
954       
955        bool is_torrent(const std::string& filename);
956        bool is_torrent(const std::wstring& filename); 
957       
958        void pause_torrent(const std::string& filename);
959        void pause_torrent(const std::wstring& filename);
960        void resume_torrent(const std::string& filename);
961        void resume_torrent(const std::wstring& filename);
962        void stop_torrent(const std::string& filename);
963        void stop_torrent(const std::wstring& filename);
964        bool is_torrent_active(const std::string& filename);
965        bool is_torrent_active(const std::wstring& filename);
966        void reannounce_torrent(const std::string& filename);
967        void reannounce_torrent(const std::wstring& filename);
968        void recheck_torrent(const std::string& filename);
969        void recheck_torrent(const std::wstring& filename);
970       
971        void pause_all_torrents();
972        void unpause_all_torrents();
973
974        template<typename S>
975        void remove_torrent(S filename)
976        { 
977                remove_torrent_wstr(to_wstr_shim(filename)); 
978        }       
979
980        template<typename S>
981        void remove_torrent_wipe_files(S filename)
982        { 
983                remove_torrent_wipe_files_wstr(to_wstr_shim(filename)); 
984        }       
985
986        void start_event_receiver();
987        void stop_event_receiver();
988       
989        friend bit& bittorrent();
990       
991        int default_torrent_max_connections();
992        int default_torrent_max_uploads();
993        float default_torrent_download();
994        float default_torrent_upload(); 
995
996        const torrent_details_manager& torrentDetails();
997        const torrent_details_manager& updatetorrent_details_manager(const std::wstring& focused, const std::set<std::wstring>& selected);
998       
999private:
1000        bit();
1001
1002        bit_impl* pimpl();
1003        const bit_impl* pimpl() const;
1004        boost::scoped_ptr<bit_impl> pimpl_;
1005       
1006        void remove_torrent_wstr(const std::wstring& filename);
1007        void remove_torrent_wipe_files_wstr(const std::wstring&  filename);
1008       
1009        torrent_details_manager torrentDetails_;
1010};
1011
1012bit& bittorrent();
1013
1014};
Note: See TracBrowser for help on using the repository browser.