source: trunk/src/halTorrent.hpp @ 614

Revision 614, 23.1 KB checked in by Eoin, 12 years ago (diff)

ListView? grouping works. But a lacking on the API side means it's incompatible with sorting!

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