source: trunk/src/halTorrent.hpp @ 542

Revision 542, 22.7 KB checked in by Eoin, 11 years ago (diff)

Updating HaliteWindow? serialization.

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