source: trunk/src/halTorrent.hpp @ 625

Revision 625, 24.7 KB checked in by Eoin, 12 years ago (diff)

Cache setting GUI in progress

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_cache_size(-1)
257        {}
258
259        cache_details(size_type b_w,
260                        size_type w,
261                        size_type b_r,
262                        size_type b_r_h,
263                        size_type r,
264                        int c_s,
265                        int r_c_s) :
266                blocks_written(b_w),
267                writes(w),
268                blocks_read(b_r),
269                blocks_read_hit(b_r_h),
270                reads(r),
271                cache_size(c_s),
272                read_cache_size(r_c_s),
273                write_cache_size(cache_size-read_cache_size)
274        {}
275
276    size_type blocks_written;
277    size_type writes;
278    size_type blocks_read;
279    size_type blocks_read_hit;
280    size_type reads;
281    int cache_size;
282    int read_cache_size;
283        int write_cache_size;
284};
285       
286struct torrentBriefDetail
287{
288        std::wstring filename;
289        std::wstring status;
290        std::pair<float,float> speed;
291        float completion;
292        int peers;
293        int seeds;
294};
295
296struct PeerDetail
297{
298        PeerDetail(const std::wstring& ip_address) :
299                ipAddress(ip_address)
300        {}
301        PeerDetail(libtorrent::peer_info& peerInfo);
302       
303        bool operator==(const PeerDetail& peer) const
304        {
305                return (ipAddress == peer.ipAddress);
306        }
307       
308        bool operator<(const PeerDetail& peer) const
309        {
310                return (ipAddress < peer.ipAddress);
311        }
312       
313        std::wstring ipAddress;
314        std::wstring country;
315        std::pair<float,float> speed;
316        bool seed;
317        std::wstring client;
318        std::wstring status;
319};
320
321typedef boost::shared_ptr<PeerDetail> PeerDetail_ptr;
322typedef std::vector<PeerDetail> PeerDetails;
323
324struct FileDetail
325{
326        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) :
327                branch(p.parent_path()),
328                filename(p.filename()),
329                type(t),
330                size(s),
331                progress(pg),
332                priority(pr),
333                order_(o)
334        {}
335       
336        bool operator==(const FileDetail& file) const
337        {
338                return (branch == file.branch);
339        }
340       
341        bool operator<(const FileDetail& file) const
342        {
343                return (branch < file.branch);
344        }
345       
346        enum FileType
347        {
348                folder,
349                file
350        };
351       
352        size_t order() const { return order_; }
353       
354        boost::filesystem::wpath branch;
355        std::wstring filename;
356        unsigned type;
357        boost::int64_t size;
358        boost::int64_t progress;
359        int priority;
360       
361private:
362        size_t order_;
363};
364
365inline bool FileDetailNamesEqual(const FileDetail& l, const FileDetail& r)
366{
367        return l.filename == r.filename;
368}
369
370inline bool FileDetailNamesLess(const FileDetail& l, const FileDetail& r)
371{
372        return l.filename < r.filename;
373}
374
375typedef std::vector<FileDetail> FileDetails;
376
377class torrent_details 
378{
379public:
380        torrent_details(std::wstring n, std::wstring f, 
381                        std::wstring sd, 
382                        std::wstring s, 
383                        std::wstring cT, 
384                        std::pair<float,float> sp=std::pair<float,float>(0,0),
385                        float c=0,      float d=0, 
386                        size_type tWD=0, size_type tW=0, 
387                        size_type tU=0, size_type tpU=0, 
388                        size_type tD=0, size_type tpD=0, 
389                        boost::tuple<size_type, size_type, size_type, size_type> connections = 
390                                boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0), 
391                        float r=0, 
392                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), 
393                        boost::posix_time::time_duration uIn=boost::posix_time::seconds(0),
394                        boost::posix_time::time_duration actve=boost::posix_time::seconds(0), 
395                        boost::posix_time::time_duration seding=boost::posix_time::seconds(0), 
396                        boost::posix_time::ptime srt=boost::posix_time::second_clock::universal_time(), 
397                        boost::posix_time::ptime fin=boost::posix_time::second_clock::universal_time(), 
398                        int q_p=-1, 
399                        bool man=false) :
400                filename_(f),
401                name_(n),
402                saveDir_(sd),
403                state_(s),
404                currentTracker_(cT),
405                speed_(sp),
406                completion_(c),
407                distributed_copies_(d),
408                totalWantedDone_(tWD),
409                totalWanted_(tW),
410                totalUploaded_(tU),
411                totalPayloadUploaded_(tpU),
412                totalDownloaded_(tD),
413                totalPayloadDownloaded_(tpD),
414                peers_(connections.get<0>()),
415                connectedPeers_(connections.get<1>()),
416                seeds_(connections.get<2>()),
417                connectedSeeds_(connections.get<3>()),
418                ratio_(r),
419                estimatedTimeLeft_(eta),
420                updateTrackerIn_(uIn),
421                peerDetailsFilled_(false),
422                fileDetailsFilled_(false),
423                active_(actve),
424                seeding_(seding),
425                startTime_(srt),
426                finishTime_(fin),
427                queue_position_(q_p),
428                managed_(man)
429        {}
430
431        torrent_details() :     
432                peerDetailsFilled_(false),
433                fileDetailsFilled_(false)
434        {};     
435       
436        enum state
437        {
438                torrent_active = 0,
439                torrent_paused,
440                torrent_stopped,
441                torrent_pausing,
442                torrent_stopping
443        };
444       
445//      const std::wstring& filename() const { return filename_; }
446        const std::wstring& name() const { return name_; }
447        const std::wstring& save_directory() const { return saveDir_; }
448        const std::wstring& state() const { return state_; }
449        const std::wstring& currentTracker() const { return currentTracker_; }
450       
451        std::pair<float,float> speed() const { return speed_; }
452        const float& completion() const { return completion_; }
453        const float& distributedCopies() const { return distributed_copies_; }
454       
455        size_type totalUploaded() const { return totalUploaded_; }
456        size_type totalPayloadUploaded() const { return totalPayloadUploaded_; }
457        size_type totalDownloaded() const { return totalDownloaded_; }
458        size_type totalPayloadDownloaded() const { return totalPayloadDownloaded_; }
459        size_type totalWantedDone() const { return totalWantedDone_; }
460        size_type totalWanted() const { return totalWanted_; }
461       
462        size_type peers() const { return peers_; }
463        size_type peersConnected() const { return connectedPeers_; }
464        size_type seeds() const { return seeds_; }
465        size_type seedsConnected() const { return connectedSeeds_; }
466       
467        float ratio() { return ratio_; }
468       
469        const boost::posix_time::time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; }
470        const boost::posix_time::time_duration& updateTrackerIn() { return updateTrackerIn_; }
471       
472        const PeerDetails& peerDetails() const;
473        const FileDetails& fileDetails() const;
474       
475        const boost::posix_time::time_duration& active() { return active_; }
476        const boost::posix_time::time_duration& seeding() { return seeding_; }
477        const boost::posix_time::ptime& startTime() { return startTime_; }
478        const boost::posix_time::ptime& finishTime() { return finishTime_; }
479
480        int queue_position() const { return queue_position_; }
481        bool managed() const { return managed_; }
482       
483public:
484        std::wstring filename_;
485        std::wstring name_;
486        std::wstring saveDir_;
487        std::wstring state_;
488        std::wstring currentTracker_;
489
490        std::pair<float,float> speed_;         
491        float completion_;     
492        float distributed_copies_;
493       
494        size_type totalWantedDone_;
495        size_type totalWanted_;
496        size_type totalUploaded_;
497        size_type totalPayloadUploaded_;
498        size_type totalDownloaded_;
499        size_type totalPayloadDownloaded_;
500       
501        size_type peers_;
502        size_type connectedPeers_;
503        size_type seeds_;
504        size_type connectedSeeds_;
505       
506        float ratio_;
507       
508        boost::posix_time::time_duration estimatedTimeLeft_;
509        boost::posix_time::time_duration updateTrackerIn_;
510       
511        boost::posix_time::time_duration active_;
512        boost::posix_time::time_duration seeding_;
513        boost::posix_time::ptime startTime_;
514        boost::posix_time::ptime finishTime_;
515
516        int queue_position_;
517        bool managed_;
518       
519private:
520        mutable bool peerDetailsFilled_;
521        mutable PeerDetails peerDetails_;
522       
523        mutable bool fileDetailsFilled_;
524        mutable FileDetails fileDetails_;
525};
526
527typedef boost::shared_ptr<torrent_details> torrent_details_ptr;
528typedef boost::scoped_ptr<torrent_details> torrent_details_sptr;
529typedef boost::weak_ptr<torrent_details> torrent_details_wptr;
530typedef std::vector<torrent_details_ptr> torrent_details_vec;
531typedef std::map<std::wstring, torrent_details_ptr> torrent_details_map;
532
533class torrent_details_manager
534{
535public: 
536        void sort(boost::function<bool (const torrent_details_ptr&, const torrent_details_ptr&)> fn) const;
537       
538        const torrent_details_vec torrents() const 
539        {
540                mutex_t::scoped_lock l(mutex_); 
541                return torrents_; 
542        }
543       
544        const torrent_details_vec selectedTorrents() const 
545        { 
546                mutex_t::scoped_lock l(mutex_); 
547                return selectedTorrents_; 
548        }
549       
550        const torrent_details_ptr focusedTorrent() const 
551        {
552                mutex_t::scoped_lock l(mutex_); 
553                return selectedTorrent_; 
554        }
555       
556        const torrent_details_ptr get(std::wstring filename) const
557        {
558                mutex_t::scoped_lock l(mutex_); 
559               
560                torrent_details_map::const_iterator i = torrentMap_.find(filename);
561               
562                if (i != torrentMap_.end())
563                        return i->second;
564                else
565                        return torrent_details_ptr();
566        }
567       
568        friend class bit;
569
570private:
571        void clearAll(const mutex_t::scoped_lock&)
572        {
573                // !! No mutex lock, it should only be call from functions which
574                // have the lock themselves, hence the unused function param
575               
576                torrents_.clear();
577                torrentMap_.clear();
578                selectedTorrents_.clear();
579                selectedTorrent_.reset();
580        }
581
582        mutable torrent_details_vec torrents_;
583       
584        torrent_details_map torrentMap_;
585        torrent_details_vec selectedTorrents_;
586        torrent_details_ptr selectedTorrent_;
587       
588        mutable mutex_t mutex_;
589};
590
591struct tracker_detail
592{
593        tracker_detail() {}
594        tracker_detail(std::wstring u, int t) : url(u), tier(t) {}
595       
596        bool operator<(const tracker_detail& t) const
597        {
598                return (tier < t.tier);
599        }
600       
601        std::wstring url;
602        int tier;
603};
604
605typedef std::vector<tracker_detail> tracker_details_t;
606
607struct web_seed_or_dht_node_detail
608{
609        web_seed_or_dht_node_detail();
610        web_seed_or_dht_node_detail(std::wstring u);
611        web_seed_or_dht_node_detail(std::wstring u, int p);
612               
613        std::wstring url;
614        int port;
615        std::wstring type;
616};
617
618typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t;
619
620struct dht_node_detail
621{
622        dht_node_detail() {}
623        dht_node_detail(std::wstring u, int p) : url(u), port(p) {}
624       
625        std::wstring url;
626        int port;
627};
628
629typedef std::vector<dht_node_detail> dht_node_details_t;
630
631struct web_seed_detail
632{
633        web_seed_detail() {}
634        web_seed_detail(std::wstring u) : url(u) {}
635       
636        std::wstring url;
637};
638
639typedef std::vector<web_seed_detail> web_seed_details_t;
640
641struct create_torrent_params
642{
643        create_torrent_params() {}
644
645        std::wstring creator;
646        std::wstring comment;
647        int piece_size;
648        bool private_torrent;
649
650        file_size_pairs_t file_size_pairs;
651        fs::wpath root_path;
652
653        tracker_details_t trackers;
654        dht_node_details_t dht_nodes;
655        web_seed_details_t web_seeds;
656};
657
658class EventDetail;
659
660struct SessionDetail
661{
662        int port;
663       
664        std::pair<double, double> speed;
665       
666        bool dht_on;
667        size_t dht_nodes;
668        size_t dht_torrents;
669       
670        bool ip_filter_on;
671        size_t ip_ranges_filtered;
672};
673
674typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
675typedef boost::function<bool (size_t, std::wstring)> progress_callback;
676typedef boost::function<void (int)> report_num_active;
677typedef std::pair<wstring, wstring> wstring_pair;
678typedef std::pair<float, float> float_pair;
679typedef std::pair<int, int> int_pair;
680typedef std::pair<std::vector<int>, int> vec_int_pair;
681
682class bit_impl;
683class torrent_internal;
684
685class bit
686{
687public:         
688
689        enum mappings
690        {
691                mappingNone = 0,
692                mappingUPnP,
693                mappingNatPMP
694        };
695
696        enum allocations
697        {
698                sparse_allocation = 1,
699                compact_allocation,
700                full_allocation
701        };
702
703        enum queue_adjustments
704        {
705                move_up = 0,
706                move_down,
707                move_to_top,
708                move_to_bottom
709        };
710
711        class null_torrent : public std::exception
712        {
713        public:
714                null_torrent() {}               
715                virtual ~null_torrent() throw () {}
716        };
717
718        class torrent : public stlsoft::operator_bool_adaptor<torrent>
719        {
720                typedef torrent class_type;
721
722        public:
723                class exec_around_ptr
724                {
725                public:
726                        class proxy 
727                        {
728                        public:
729                                explicit proxy(torrent_internal* t);
730
731                                torrent_internal* operator->() 
732                                {
733                                        return t_;
734                                }
735
736                                ~proxy ();
737
738                        private:
739                                torrent_internal* t_;
740                                mutex_t::scoped_lock l_;
741                        };
742
743                        exec_around_ptr() {}
744                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {}
745
746                        proxy operator->() const
747                        {
748                                if (!ptr)
749                                        throw null_torrent();
750
751                                return proxy(&(*ptr));
752                        }
753
754                        operator bool() const { return ptr; }
755
756                private:
757                        boost::shared_ptr<torrent_internal> ptr;
758                };
759
760                torrent();
761                torrent(boost::shared_ptr<torrent_internal> p);
762
763                const std::wstring get_name() const;
764
765                float get_ratio() const;
766                void set_ratio(float new_ratio);
767               
768                std::pair<int, int> get_connection_limits() const;
769                void set_connection_limits(const std::pair<int, int>&);
770                std::pair<float, float> get_rate_limits() const;
771                void set_rate_limits(const std::pair<float, float>&);
772
773                wpath get_save_directory() const;
774                void set_save_directory(const wpath&);
775                wpath get_move_to_directory() const;
776                void set_move_to_directory(const wpath&);
777
778                std::pair<wstring, wstring> get_tracker_login() const;
779                void set_tracker_login(const std::pair<wstring, wstring>&);
780
781                std::vector<tracker_detail> get_trackers() const;
782                void set_trackers(const std::vector<tracker_detail>&);
783
784                bool get_is_active() const;
785                bool get_in_session() const;
786
787                void set_file_priorities(const vec_int_pair&);
788
789                void set_managed(bool);
790                bool get_managed() const;
791
792        public:
793                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(const std::wstring, class_type, 
794                        get_name, name);
795
796                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
797                        get_ratio, set_ratio, ratio);
798
799                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(int_pair, const int_pair&, class_type, 
800                        get_connection_limits, set_connection_limits, connection_limits);
801                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float_pair, const float_pair&, class_type, 
802                        get_rate_limits, set_rate_limits, rate_limits);
803               
804                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
805                        get_save_directory, set_save_directory, save_directory);
806                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
807                        get_move_to_directory, set_move_to_directory, move_to_directory);
808
809                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wstring_pair, const wstring_pair&, 
810                        class_type, get_tracker_login, set_tracker_login, tracker_login);
811
812                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
813                        get_is_active, is_active);
814                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
815                        get_in_session, in_session);
816
817                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(std::vector<tracker_detail>, const std::vector<tracker_detail>&, 
818                        class_type, get_trackers, set_trackers, trackers);
819
820                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(bool, bool, class_type, 
821                        get_managed, set_managed, managed);
822
823                STLSOFT_METHOD_PROPERTY_SET_EXTERNAL(const vec_int_pair&, class_type, 
824                        set_file_priorities, file_priorities);
825
826                void reset_trackers();
827                bool is_open() const;
828                void adjust_queue_position(bit::queue_adjustments adjust);
829
830        private:
831                exec_around_ptr ptr;
832        };
833
834        void shutDownSession();
835        void save_torrent_data();
836
837        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
838
839        template<typename T>
840        torrent get(T t)
841        {
842                return get_wstr(to_wstr_shim(t));
843        }
844       
845        template<>
846        torrent get(const hal::torrent_details_ptr t)
847        {
848                if (t) 
849                        return get_wstr(t->name());
850                else
851                        return torrent();
852        }       
853
854        torrent get_wstr(const std::wstring& filename);
855       
856        bool listen_on(std::pair<int, int> const& portRange);
857        int is_listening_on();
858        void stop_listening();
859       
860        bool ensure_dht_on(const dht_settings& dht);
861        void ensure_dht_off();
862       
863        void ensure_pe_on(const pe_settings& pe);
864        void ensure_pe_off();
865       
866        bool ensure_ip_filter_on(progress_callback fn);
867        void ensure_ip_filter_off();
868
869        void set_mapping(bool upnp, bool nat_pmp);
870        std::wstring upnp_router_model();
871
872        void ip_v4_filter_block(boost::asio::ip::address_v4 first, boost::asio::ip::address_v4 last);
873        void ip_v6_filter_block(boost::asio::ip::address_v6 first, boost::asio::ip::address_v6 last);
874        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
875        size_t ip_filter_size();
876        void clear_ip_filter(); 
877       
878        void setSessionHalfOpenLimit(int halfConn);
879        void set_session_limits(int maxConn, int maxUpload);
880        void set_session_speed(float download, float upload);
881
882        queue_settings get_queue_settings();
883        void set_queue_settings(const queue_settings& s);
884       
885        timeouts get_timeouts();
886        void set_timeouts(const timeouts& t);
887
888        const cache_details get_cache_details() const;
889
890        void set_cache_settings(const cache_settings& cache);
891        cache_settings get_cache_settings() const;
892       
893        const SessionDetail getSessionDetails();
894
895        void set_torrent_defaults(const connections& defaults); 
896        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
897                bool startPaused=false, bool managed=false, allocations alloc=hal::bit::sparse_allocation, 
898                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false);
899       
900        void getAllPeerDetails(const std::string& filename, PeerDetails& peerContainer);
901        void getAllPeerDetails(const std::wstring& filename, PeerDetails& peerContainer);
902        void getAllFileDetails(const std::string& filename, FileDetails& fileDetails);
903        void getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails);
904       
905        void resume_all();
906        void close_all(boost::optional<report_num_active> fn);
907       
908        bool isTorrent(const std::string& filename);
909        bool isTorrent(const std::wstring& filename);   
910       
911        void pauseTorrent(const std::string& filename);
912        void pauseTorrent(const std::wstring& filename);
913        void resumeTorrent(const std::string& filename);
914        void resumeTorrent(const std::wstring& filename);
915        void stopTorrent(const std::string& filename);
916        void stopTorrent(const std::wstring& filename);
917        bool isTorrentActive(const std::string& filename);
918        bool isTorrentActive(const std::wstring& filename);
919        void reannounceTorrent(const std::string& filename);
920        void reannounceTorrent(const std::wstring& filename);
921        void recheckTorrent(const std::string& filename);
922        void recheckTorrent(const std::wstring& filename);
923       
924        void pauseAllTorrents();
925        void unpauseAllTorrents();
926
927        template<typename S>
928        void remove_torrent(S filename)
929        { 
930                remove_torrent_wstr(to_wstr_shim(filename)); 
931        }       
932
933        template<typename S>
934        void remove_torrent_wipe_files(S filename)
935        { 
936                remove_torrent_wipe_files_wstr(to_wstr_shim(filename)); 
937        }       
938
939        void startEventReceiver();
940        void stopEventReceiver();
941       
942        friend bit& bittorrent();
943       
944        int defTorrentMaxConn();
945        int defTorrentMaxUpload();
946        float defTorrentDownload();
947        float defTorrentUpload();       
948
949        const torrent_details_manager& torrentDetails();
950        const torrent_details_manager& updatetorrent_details_manager(const std::wstring& focused, const std::set<std::wstring>& selected);
951       
952private:
953        bit();
954        boost::scoped_ptr<bit_impl> pimpl;
955       
956        void remove_torrent_wstr(const std::wstring& filename);
957        void remove_torrent_wipe_files_wstr(const std::wstring&  filename);
958       
959        torrent_details_manager torrentDetails_;
960};
961
962bit& bittorrent();
963
964};
Note: See TracBrowser for help on using the repository browser.