source: trunk/src/halTorrent.hpp @ 431

Revision 431, 16.1 KB checked in by Eoin, 12 years ago (diff)

Torrent creation soooooo close.

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 BitTorrent;
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() : url(L""), port(-1), type(L"") {}
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
384        file_size_pairs_t file_size_pairs;
385        fs::wpath root_path;
386
387        tracker_details_t trackers;
388        dht_node_details_t dht_nodes;
389        web_seed_details_t web_seeds;
390};
391
392class EventDetail;
393
394struct SessionDetail
395{
396        int port;
397       
398        std::pair<double, double> speed;
399       
400        bool dht_on;
401        size_t dht_nodes;
402        size_t dht_torrents;
403       
404        bool ip_filter_on;
405        size_t ip_ranges_filtered;
406};
407
408typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
409typedef boost::function<bool (size_t, std::wstring)> progress_callback;
410
411class BitTorrent_impl;
412class TorrentInternal;
413
414class BitTorrent
415{
416        class torrent
417        {
418                typedef torrent class_type;
419
420        public:
421                void set_ratio(float new_ratio);
422                float get_ratio() const;
423
424        public:
425                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type, 
426                        get_ratio, set_ratio, ratio);
427
428        private:
429                boost::shared_ptr<TorrentInternal> ptr;
430        };
431
432public: 
433        enum mappings
434        {
435                mappingNone = 0,
436                mappingUPnP,
437                mappingNatPMP
438        };
439
440        void shutDownSession();
441        void saveTorrentData();
442
443        void create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn);
444       
445        bool listenOn(std::pair<int, int> const& portRange);
446        int isListeningOn();
447        void stopListening();
448       
449        bool ensureDhtOn();
450        void ensureDhtOff();
451       
452        void ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4);
453        void ensurePeOff();
454       
455        void ensureIpFilterOn(progress_callback fn);
456        void ensureIpFilterOff();
457
458        void setMapping(int mapping);
459
460        void ip_v4_filter_block(asio::ip::address_v4 first, asio::ip::address_v4 last);
461        void ip_v6_filter_block(asio::ip::address_v6 first, asio::ip::address_v6 last);
462        void ip_filter_import_dat(boost::filesystem::path file, progress_callback fn, bool octalFix);
463        size_t ip_filter_size();
464        void clearIpFilter();   
465       
466        void setSessionHalfOpenLimit(int halfConn);
467        void setSessionLimits(int maxConn, int maxUpload);
468        void setSessionSpeed(float download, float upload);
469        void setDhtSettings(int max_peers_reply, int search_branching, 
470                int service_port, int max_fail_count);
471        void setTimeouts(int peers, int tracker);
472       
473        const SessionDetail getSessionDetails();
474
475        void setTorrentDefaults(int maxConn, int maxUpload, float download, float upload);     
476        void newTorrent(boost::filesystem::wpath filename, boost::filesystem::wpath files);
477        void addTorrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
478                bool startPaused=false, bool compactStorage=false, 
479                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false);
480       
481        void setTorrentRatio(const std::string&, float ratio);
482        void setTorrentRatio(const std::wstring&, float ratio);
483        float getTorrentRatio(const std::string&);
484        float getTorrentRatio(const std::wstring&);
485       
486        void getAllPeerDetails(const std::string& filename, PeerDetails& peerContainer);
487        void getAllPeerDetails(const std::wstring& filename, PeerDetails& peerContainer);
488        void getAllFileDetails(const std::string& filename, FileDetails& fileDetails);
489        void getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails);
490       
491        void resumeAll();
492        void closeAll();
493       
494        bool isTorrent(const std::string& filename);
495        bool isTorrent(const std::wstring& filename);   
496       
497        void pauseTorrent(const std::string& filename);
498        void pauseTorrent(const std::wstring& filename);
499        void resumeTorrent(const std::string& filename);
500        void resumeTorrent(const std::wstring& filename);
501        void stopTorrent(const std::string& filename);
502        void stopTorrent(const std::wstring& filename);
503        bool isTorrentActive(const std::string& filename);
504        bool isTorrentActive(const std::wstring& filename);
505        void reannounceTorrent(const std::string& filename);
506        void reannounceTorrent(const std::wstring& filename);
507        void recheckTorrent(const std::string& filename);
508        void recheckTorrent(const std::wstring& filename);
509       
510        void pauseAllTorrents();
511        void unpauseAllTorrents();
512       
513        void removeTorrent(const std::string& filename);
514        void removeTorrent(const std::wstring&  filename);
515        void removeTorrentWipeFiles(const std::string& filename);
516        void removeTorrentWipeFiles(const std::wstring&  filename);
517       
518        void setTorrentLogin(const std::string& filename, std::wstring username, std::wstring password);
519        void setTorrentLogin(const std::wstring& filename, std::wstring username, std::wstring password);
520        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::string& filename);
521        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::wstring&  filename);
522       
523        void setTorrentLimit(const std::string& filename, int maxConn, int maxUpload);
524        void setTorrentLimit(const std::wstring& filename, int maxConn, int maxUpload);
525        void setTorrentSpeed(const std::string& filename, float download, float upload);
526        void setTorrentSpeed(const std::wstring& filename, float download, float upload);
527        std::pair<int, int> getTorrentLimit(const std::string& filename);
528        std::pair<int, int> getTorrentLimit(const std::wstring& filename);
529        std::pair<float, float> getTorrentSpeed(const std::string& filename);
530        std::pair<float, float> getTorrentSpeed(const std::wstring& filename);
531       
532        void setTorrentTrackers(const std::string& filename, const std::vector<tracker_detail>& trackers);
533        void setTorrentTrackers(const std::wstring& filename, const std::vector<tracker_detail>& trackers);
534        void resetTorrentTrackers(const std::string& filename);
535        void resetTorrentTrackers(const std::wstring& filename);
536        std::vector<tracker_detail> getTorrentTrackers(const std::string& filename);
537        std::vector<tracker_detail> getTorrentTrackers(const std::wstring& filename);
538       
539        void setTorrentFilePriorities(const std::string& filename, std::vector<int> fileIndices, int priority);
540        void setTorrentFilePriorities(const std::wstring& filename, std::vector<int> fileIndices, int priority);
541
542        void startEventReceiver();
543        void stopEventReceiver();
544       
545        friend BitTorrent& bittorrent();
546       
547        int defTorrentMaxConn();
548        int defTorrentMaxUpload();
549        float defTorrentDownload();
550        float defTorrentUpload();       
551
552        const TorrentDetails& torrentDetails();
553        const TorrentDetails& updateTorrentDetails(const std::wstring& focused, const std::set<std::wstring>& selected);
554       
555private:
556        BitTorrent();
557        boost::scoped_ptr<BitTorrent_impl> pimpl;
558       
559        TorrentDetails torrentDetails_;
560};
561
562BitTorrent& bittorrent();
563
564};
Note: See TracBrowser for help on using the repository browser.