source: trunk/src/halTorrent.hpp @ 441

Revision 441, 17.4 KB checked in by Eoin, 12 years ago (diff)

Revamped the CloseSplash? Dialog.
Cleaned some UI rough edges.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2007.
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
36#include <asio/ip/tcp.hpp>
37#include <asio/ip/udp.hpp>
38
39#include "halTypes.hpp"
40
41namespace libtorrent { struct peer_info; }
42
43namespace hal
44{
45       
46struct torrentBriefDetail
47{
48        std::wstring filename;
49        std::wstring status;
50        std::pair<float,float> speed;
51        float completion;
52        int peers;
53        int seeds;
54};
55
56struct PeerDetail
57{
58        PeerDetail(const std::wstring& ip_address) :
59                ipAddress(ip_address)
60        {}
61        PeerDetail(libtorrent::peer_info& peerInfo);
62       
63        bool operator==(const PeerDetail& peer) const
64        {
65                return (ipAddress == peer.ipAddress);
66        }
67       
68        bool operator<(const PeerDetail& peer) const
69        {
70                return (ipAddress < peer.ipAddress);
71        }
72       
73        std::wstring ipAddress;
74        std::wstring country;
75        std::pair<float,float> speed;
76        bool seed;
77        std::wstring client;
78        std::wstring status;
79};
80
81typedef boost::shared_ptr<PeerDetail> PeerDetail_ptr;
82typedef std::vector<PeerDetail> PeerDetails;
83
84struct FileDetail
85{
86        FileDetail(boost::filesystem::wpath p, boost::int64_t s=0, float pg=0, int pr=1, size_t o=0, unsigned t=FileDetail::file) :
87                branch(p.branch_path()),
88                filename(p.leaf()),
89                type(t),
90                size(s),
91                progress(pg),
92                priority(pr),
93                order_(o)
94        {}
95       
96        bool operator==(const FileDetail& file) const
97        {
98                return (branch == file.branch);
99        }
100       
101        bool operator<(const FileDetail& file) const
102        {
103                return (branch < file.branch);
104        }
105       
106        enum FileType
107        {
108                folder,
109                file
110        };
111       
112        size_t order() const { return order_; }
113       
114        boost::filesystem::wpath branch;
115        std::wstring filename;
116        unsigned type;
117        boost::int64_t size;
118        float progress;
119        int priority;
120       
121private:
122        size_t order_;
123};
124
125inline bool FileDetailNamesEqual(const FileDetail& l, const FileDetail& r)
126{
127        return l.filename == r.filename;
128}
129
130inline bool FileDetailNamesLess(const FileDetail& l, const FileDetail& r)
131{
132        return l.filename < r.filename;
133}
134
135typedef std::vector<FileDetail> FileDetails;
136
137class TorrentDetail 
138{
139public:
140        TorrentDetail(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),
141                        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, 
142                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), boost::posix_time::time_duration uIn=boost::posix_time::seconds(0),
143                        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()) :
144                filename_(f),
145                name_(n),
146                saveDir_(sd),
147                state_(s),
148                currentTracker_(cT),
149                speed_(sp),
150                completion_(c),
151                distributed_copies_(d),
152                totalWantedDone_(tWD),
153                totalWanted_(tW),
154                totalUploaded_(tU),
155                totalPayloadUploaded_(tpU),
156                totalDownloaded_(tD),
157                totalPayloadDownloaded_(tpD),
158                peers_(connections.get<0>()),
159                connectedPeers_(connections.get<1>()),
160                seeds_(connections.get<2>()),
161                connectedSeeds_(connections.get<3>()),
162                ratio_(r),
163                estimatedTimeLeft_(eta),
164                updateTrackerIn_(uIn),
165                peerDetailsFilled_(false),
166                fileDetailsFilled_(false),
167                active_(actve),
168                seeding_(seding),
169                startTime_(srt),
170                finishTime_(fin)
171        {}
172
173        TorrentDetail() :       
174                peerDetailsFilled_(false),
175                fileDetailsFilled_(false)
176        {};     
177       
178        enum state
179        {
180                torrent_active = 0,
181                torrent_paused,
182                torrent_stopped,
183                torrent_pausing,
184                torrent_stopping
185        };
186       
187//      const std::wstring& filename() const { return filename_; }
188        const std::wstring& name() const { return name_; }
189        const std::wstring& saveDirectory() const { return saveDir_; }
190        const std::wstring& state() const { return state_; }
191        const std::wstring& currentTracker() const { return currentTracker_; }
192       
193        std::pair<float,float> speed() const { return speed_; }
194        const float& completion() const { return completion_; }
195        const float& distributedCopies() const { return distributed_copies_; }
196       
197        size_type totalUploaded() const { return totalUploaded_; }
198        size_type totalPayloadUploaded() const { return totalPayloadUploaded_; }
199        size_type totalDownloaded() const { return totalDownloaded_; }
200        size_type totalPayloadDownloaded() const { return totalPayloadDownloaded_; }
201        size_type totalWantedDone() const { return totalWantedDone_; }
202        size_type totalWanted() const { return totalWanted_; }
203       
204        size_type peers() const { return peers_; }
205        size_type peersConnected() const { return connectedPeers_; }
206        size_type seeds() const { return seeds_; }
207        size_type seedsConnected() const { return connectedSeeds_; }
208       
209        float ratio() { return ratio_; }
210       
211        const boost::posix_time::time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; }
212        const boost::posix_time::time_duration& updateTrackerIn() { return updateTrackerIn_; }
213       
214        const PeerDetails& peerDetails() const;
215        const FileDetails& fileDetails() const;
216       
217        const boost::posix_time::time_duration& active() { return active_; }
218        const boost::posix_time::time_duration& seeding() { return seeding_; }
219        const boost::posix_time::ptime& startTime() { return startTime_; }
220        const boost::posix_time::ptime& finishTime() { return finishTime_; }
221       
222public:
223        std::wstring filename_;
224        std::wstring name_;
225        std::wstring saveDir_;
226        std::wstring state_;
227        std::wstring currentTracker_;
228
229        std::pair<float,float> speed_;         
230        float completion_;     
231        float distributed_copies_;
232       
233        size_type totalWantedDone_;
234        size_type totalWanted_;
235        size_type totalUploaded_;
236        size_type totalPayloadUploaded_;
237        size_type totalDownloaded_;
238        size_type totalPayloadDownloaded_;
239       
240        size_type peers_;
241        size_type connectedPeers_;
242        size_type seeds_;
243        size_type connectedSeeds_;
244       
245        float ratio_;
246       
247        boost::posix_time::time_duration estimatedTimeLeft_;
248        boost::posix_time::time_duration updateTrackerIn_;
249       
250        boost::posix_time::time_duration active_;
251        boost::posix_time::time_duration seeding_;
252        boost::posix_time::ptime startTime_;
253        boost::posix_time::ptime finishTime_;
254       
255private:
256        mutable bool peerDetailsFilled_;
257        mutable PeerDetails peerDetails_;
258       
259        mutable bool fileDetailsFilled_;
260        mutable FileDetails fileDetails_;
261};
262
263typedef boost::shared_ptr<TorrentDetail> TorrentDetail_ptr;
264typedef boost::scoped_ptr<TorrentDetail> TorrentDetail_sptr;
265typedef boost::weak_ptr<TorrentDetail> TorrentDetail_wptr;
266typedef std::vector<TorrentDetail_ptr> TorrentDetail_vec;
267typedef std::map<std::wstring, TorrentDetail_ptr> TorrentDetail_map;
268
269class TorrentDetails
270{
271public: 
272        void sort(boost::function<bool (const TorrentDetail_ptr&, const TorrentDetail_ptr&)> fn) const;
273       
274        const TorrentDetail_vec torrents() const 
275        {
276                mutex_t::scoped_lock l(mutex_); 
277                return torrents_; 
278        }
279       
280        const TorrentDetail_vec selectedTorrents() const 
281        { 
282                mutex_t::scoped_lock l(mutex_); 
283                return selectedTorrents_; 
284        }
285       
286        const TorrentDetail_ptr focusedTorrent() const 
287        {
288                mutex_t::scoped_lock l(mutex_); 
289                return selectedTorrent_; 
290        }
291       
292        const TorrentDetail_ptr get(std::wstring filename) const
293        {
294                mutex_t::scoped_lock l(mutex_); 
295               
296                TorrentDetail_map::const_iterator i = torrentMap_.find(filename);
297               
298                if (i != torrentMap_.end())
299                        return i->second;
300                else
301                        return TorrentDetail_ptr();
302        }
303       
304        friend class bit;
305
306private:
307        void clearAll(const mutex_t::scoped_lock&)
308        {
309                // !! No mutex lock, it should only be call from functions which
310                // have the lock themselves, hence the unused function param
311               
312                torrents_.clear();
313                torrentMap_.clear();
314                selectedTorrents_.clear();
315                selectedTorrent_.reset();
316        }
317
318        mutable TorrentDetail_vec torrents_;
319       
320        TorrentDetail_map torrentMap_;
321        TorrentDetail_vec selectedTorrents_;
322        TorrentDetail_ptr selectedTorrent_;
323       
324        mutable mutex_t mutex_;
325};
326
327struct tracker_detail
328{
329        tracker_detail() {}
330        tracker_detail(std::wstring u, int t) : url(u), tier(t) {}
331       
332        bool operator<(const tracker_detail& t) const
333        {
334                return (tier < t.tier);
335        }
336       
337        std::wstring url;
338        int tier;
339};
340
341typedef std::vector<tracker_detail> tracker_details_t;
342
343struct web_seed_or_dht_node_detail
344{
345        web_seed_or_dht_node_detail();
346        web_seed_or_dht_node_detail(std::wstring u);
347        web_seed_or_dht_node_detail(std::wstring u, int p);
348               
349        std::wstring url;
350        int port;
351        std::wstring type;
352};
353
354typedef std::vector<pair<fs::wpath, size_type> > file_size_pairs_t;
355
356struct dht_node_detail
357{
358        dht_node_detail() {}
359        dht_node_detail(std::wstring u, int p) : url(u), port(p) {}
360       
361        std::wstring url;
362        int port;
363};
364
365typedef std::vector<dht_node_detail> dht_node_details_t;
366
367struct web_seed_detail
368{
369        web_seed_detail() {}
370        web_seed_detail(std::wstring u) : url(u) {}
371       
372        std::wstring url;
373};
374
375typedef std::vector<web_seed_detail> web_seed_details_t;
376
377struct create_torrent_params
378{
379        create_torrent_params() {}
380
381        std::wstring creator;
382        std::wstring comment;
383        bool private_torrent;
384
385        file_size_pairs_t file_size_pairs;
386        fs::wpath root_path;
387
388        tracker_details_t trackers;
389        dht_node_details_t dht_nodes;
390        web_seed_details_t web_seeds;
391};
392
393class EventDetail;
394
395struct SessionDetail
396{
397        int port;
398       
399        std::pair<double, double> speed;
400       
401        bool dht_on;
402        size_t dht_nodes;
403        size_t dht_torrents;
404       
405        bool ip_filter_on;
406        size_t ip_ranges_filtered;
407};
408
409typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
410typedef boost::function<bool (size_t, std::wstring)> progress_callback;
411typedef boost::function<void (int)> report_num_active;
412
413class bit_impl;
414class torrent_internal;
415
416class bit
417{
418public: 
419
420        class torrent
421        {
422                typedef torrent class_type;
423
424        public:
425                class exec_around_ptr
426                {
427                public:
428                        class proxy 
429                        {
430                        public:
431                                explicit proxy(torrent_internal* t);
432
433                                torrent_internal* operator->() 
434                                {
435                                        return t_;
436                                }
437
438                                ~proxy ();
439
440                        private:
441                                torrent_internal* t_;
442                                mutex_t::scoped_lock l_;
443                        };
444
445                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {}
446
447                        proxy operator->() const
448                        {
449                                return proxy(&(*ptr));
450                        }
451
452                private:
453                        boost::shared_ptr<torrent_internal> ptr;
454                };
455
456                torrent(boost::shared_ptr<torrent_internal> p);
457
458                float get_ratio() const;
459                void set_ratio(float new_ratio);
460
461                wpath get_save_directory() const;
462                void set_save_directory(const wpath&);
463                wpath get_move_to_directory() const;
464                void set_move_to_directory(const wpath&);
465
466                bool get_is_active() const;
467                bool get_in_session() const;
468
469        public:
470                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
471                        get_ratio, set_ratio, ratio);
472               
473                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
474                        get_save_directory, set_save_directory, save_directory);
475                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type, 
476                        get_move_to_directory, set_move_to_directory, move_to_directory);
477
478                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
479                        get_is_active, is_active);
480                STLSOFT_METHOD_PROPERTY_GET_EXTERNAL(bool, class_type, 
481                        get_in_session, in_session);
482
483        private:
484                exec_around_ptr ptr;
485        };
486
487        enum mappings
488        {
489                mappingNone = 0,
490                mappingUPnP,
491                mappingNatPMP
492        };
493
494        void shutDownSession();
495        void saveTorrentData();
496
497        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
498
499        template<typename T>
500        torrent get(T t)
501        {
502                return get_wstr(to_wstr_shim(t));
503        }
504
505        torrent get_wstr(const std::wstring& filename);
506       
507        bool listenOn(std::pair<int, int> const& portRange);
508        int isListeningOn();
509        void stopListening();
510       
511        bool ensureDhtOn();
512        void ensureDhtOff();
513       
514        void ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4);
515        void ensurePeOff();
516       
517        bool ensureIpFilterOn(progress_callback fn);
518        void ensureIpFilterOff();
519
520        void setMapping(int mapping);
521
522        void ip_v4_filter_block(asio::ip::address_v4 first, asio::ip::address_v4 last);
523        void ip_v6_filter_block(asio::ip::address_v6 first, asio::ip::address_v6 last);
524        bool ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
525        size_t ip_filter_size();
526        void clearIpFilter();   
527       
528        void setSessionHalfOpenLimit(int halfConn);
529        void setSessionLimits(int maxConn, int maxUpload);
530        void setSessionSpeed(float download, float upload);
531        void setDhtSettings(int max_peers_reply, int search_branching, 
532                int service_port, int max_fail_count);
533        void setTimeouts(int peers, int tracker);
534       
535        const SessionDetail getSessionDetails();
536
537        void setTorrentDefaults(int maxConn, int maxUpload, float download, float upload);     
538        void newTorrent(boost::filesystem::wpath filename, boost::filesystem::wpath files);
539        void addTorrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
540                bool startPaused=false, bool compactStorage=false, 
541                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false);
542       
543        void setTorrentRatio(const std::string&, float ratio);
544        void setTorrentRatio(const std::wstring&, float ratio);
545        float getTorrentRatio(const std::string&);
546        float getTorrentRatio(const std::wstring&);
547       
548        void getAllPeerDetails(const std::string& filename, PeerDetails& peerContainer);
549        void getAllPeerDetails(const std::wstring& filename, PeerDetails& peerContainer);
550        void getAllFileDetails(const std::string& filename, FileDetails& fileDetails);
551        void getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails);
552       
553        void resumeAll();
554        void closeAll(report_num_active fn);
555       
556        bool isTorrent(const std::string& filename);
557        bool isTorrent(const std::wstring& filename);   
558       
559        void pauseTorrent(const std::string& filename);
560        void pauseTorrent(const std::wstring& filename);
561        void resumeTorrent(const std::string& filename);
562        void resumeTorrent(const std::wstring& filename);
563        void stopTorrent(const std::string& filename);
564        void stopTorrent(const std::wstring& filename);
565        bool isTorrentActive(const std::string& filename);
566        bool isTorrentActive(const std::wstring& filename);
567        void reannounceTorrent(const std::string& filename);
568        void reannounceTorrent(const std::wstring& filename);
569        void recheckTorrent(const std::string& filename);
570        void recheckTorrent(const std::wstring& filename);
571       
572        void pauseAllTorrents();
573        void unpauseAllTorrents();
574       
575        void removeTorrent(const std::string& filename);
576        void removeTorrent(const std::wstring&  filename);
577        void removeTorrentWipeFiles(const std::string& filename);
578        void removeTorrentWipeFiles(const std::wstring&  filename);
579       
580        void setTorrentLogin(const std::string& filename, std::wstring username, std::wstring password);
581        void setTorrentLogin(const std::wstring& filename, std::wstring username, std::wstring password);
582        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::string& filename);
583        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::wstring&  filename);
584       
585        void setTorrentLimit(const std::string& filename, int maxConn, int maxUpload);
586        void setTorrentLimit(const std::wstring& filename, int maxConn, int maxUpload);
587        void setTorrentSpeed(const std::string& filename, float download, float upload);
588        void setTorrentSpeed(const std::wstring& filename, float download, float upload);
589        std::pair<int, int> getTorrentLimit(const std::string& filename);
590        std::pair<int, int> getTorrentLimit(const std::wstring& filename);
591        std::pair<float, float> getTorrentSpeed(const std::string& filename);
592        std::pair<float, float> getTorrentSpeed(const std::wstring& filename);
593       
594        void setTorrentTrackers(const std::string& filename, const std::vector<tracker_detail>& trackers);
595        void setTorrentTrackers(const std::wstring& filename, const std::vector<tracker_detail>& trackers);
596        void resetTorrentTrackers(const std::string& filename);
597        void resetTorrentTrackers(const std::wstring& filename);
598        std::vector<tracker_detail> getTorrentTrackers(const std::string& filename);
599        std::vector<tracker_detail> getTorrentTrackers(const std::wstring& filename);
600       
601        void setTorrentFilePriorities(const std::string& filename, std::vector<int> fileIndices, int priority);
602        void setTorrentFilePriorities(const std::wstring& filename, std::vector<int> fileIndices, int priority);
603
604        void startEventReceiver();
605        void stopEventReceiver();
606       
607        friend bit& bittorrent();
608       
609        int defTorrentMaxConn();
610        int defTorrentMaxUpload();
611        float defTorrentDownload();
612        float defTorrentUpload();       
613
614        const TorrentDetails& torrentDetails();
615        const TorrentDetails& updateTorrentDetails(const std::wstring& focused, const std::set<std::wstring>& selected);
616       
617private:
618        bit();
619        boost::scoped_ptr<bit_impl> pimpl;
620       
621        TorrentDetails torrentDetails_;
622};
623
624bit& bittorrent();
625
626};
Note: See TracBrowser for help on using the repository browser.