source: trunk/src/halTorrent.hpp @ 384

Revision 384, 14.6 KB checked in by Eoin, 12 years ago (diff)

Added 'Open Download Folder'.

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/thread/thread.hpp>
20#include <boost/thread/recursive_mutex.hpp>
21#include <boost/smart_ptr.hpp>
22
23#include <boost/noncopyable.hpp>
24
25#include <boost/tuple/tuple.hpp>
26#include <boost/signal.hpp>
27#include <boost/optional.hpp>
28#include <boost/function.hpp>
29
30#include <boost/date_time/posix_time/posix_time.hpp>
31#include <boost/smart_ptr.hpp>
32#include <boost/algorithm/string.hpp>
33
34#include <boost/filesystem/path.hpp>
35#include <boost/filesystem/operations.hpp>
36#include <boost/filesystem/fstream.hpp>
37
38#include <asio/ip/tcp.hpp>
39#include <asio/ip/udp.hpp>
40
41namespace libtorrent { struct peer_info; }
42
43namespace hal
44{
45
46typedef boost::recursive_mutex mutex_t;
47typedef boost::thread thread_t;
48       
49struct torrentBriefDetail
50{
51        std::wstring filename;
52        std::wstring status;
53        std::pair<float,float> speed;
54        float completion;
55        int peers;
56        int seeds;
57};
58
59struct PeerDetail
60{
61        PeerDetail(const std::wstring& ip_address) :
62                ipAddress(ip_address)
63        {}
64        PeerDetail(libtorrent::peer_info& peerInfo);
65       
66        bool operator==(const PeerDetail& peer) const
67        {
68                return (ipAddress == peer.ipAddress);
69        }
70       
71        bool operator<(const PeerDetail& peer) const
72        {
73                return (ipAddress < peer.ipAddress);
74        }
75       
76        std::wstring ipAddress;
77        std::wstring country;
78        std::pair<float,float> speed;
79        bool seed;
80        std::wstring client;
81        std::wstring status;
82};
83
84typedef boost::shared_ptr<PeerDetail> PeerDetail_ptr;
85typedef std::vector<PeerDetail> PeerDetails;
86
87struct FileDetail
88{
89        FileDetail(boost::filesystem::wpath p, boost::int64_t s=0, float pg=0, int pr=1, size_t o=0, unsigned t=FileDetail::file) :
90                branch(p.branch_path()),
91                filename(p.leaf()),
92                type(t),
93                size(s),
94                progress(pg),
95                priority(pr),
96                order_(o)
97        {}
98       
99        bool operator==(const FileDetail& file) const
100        {
101                return (branch == file.branch);
102        }
103       
104        bool operator<(const FileDetail& file) const
105        {
106                return (branch < file.branch);
107        }
108       
109        enum FileType
110        {
111                folder,
112                file
113        };
114       
115        size_t order() const { return order_; }
116       
117        boost::filesystem::wpath branch;
118        std::wstring filename;
119        unsigned type;
120        boost::int64_t size;
121        float progress;
122        int priority;
123       
124private:
125        size_t order_;
126};
127
128inline bool FileDetailNamesEqual(const FileDetail& l, const FileDetail& r)
129{
130        return l.filename == r.filename;
131}
132
133inline bool FileDetailNamesLess(const FileDetail& l, const FileDetail& r)
134{
135        return l.filename < r.filename;
136}
137
138typedef std::vector<FileDetail> FileDetails;
139
140class TorrentDetail 
141{
142public:
143        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),
144                        float c=0, float d=0, boost::int64_t tWD=0, boost::int64_t tW=0, boost::int64_t tU=0, boost::int64_t tpU=0, boost::int64_t tD=0, boost::int64_t tpD=0, boost::tuple<size_t, size_t, size_t, size_t> connections = boost::tuple<size_t, size_t, size_t, size_t>(0,0,0,0), float r=0, 
145                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), boost::posix_time::time_duration uIn=boost::posix_time::seconds(0),
146                        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()) :
147                filename_(f),
148                name_(n),
149                saveDir_(sd),
150                state_(s),
151                currentTracker_(cT),
152                speed_(sp),
153                completion_(c),
154                distributed_copies_(d),
155                totalWantedDone_(tWD),
156                totalWanted_(tW),
157                totalUploaded_(tU),
158                totalPayloadUploaded_(tpU),
159                totalDownloaded_(tD),
160                totalPayloadDownloaded_(tpD),
161                peers_(connections.get<0>()),
162                connectedPeers_(connections.get<1>()),
163                seeds_(connections.get<2>()),
164                connectedSeeds_(connections.get<3>()),
165                ratio_(r),
166                estimatedTimeLeft_(eta),
167                updateTrackerIn_(uIn),
168                peerDetailsFilled_(false),
169                fileDetailsFilled_(false),
170                active_(actve),
171                seeding_(seding),
172                startTime_(srt),
173                finishTime_(fin)
174        {}
175
176        TorrentDetail() :       
177                peerDetailsFilled_(false),
178                fileDetailsFilled_(false)
179        {};     
180       
181        enum state
182        {
183                torrent_active = 0,
184                torrent_paused,
185                torrent_stopped,
186                torrent_pausing,
187                torrent_stopping
188        };
189       
190//      const std::wstring& filename() const { return filename_; }
191        const std::wstring& name() const { return name_; }
192        const std::wstring& saveDirectory() const { return saveDir_; }
193        const std::wstring& state() const { return state_; }
194        const std::wstring& currentTracker() const { return currentTracker_; }
195       
196        std::pair<float,float> speed() const { return speed_; }
197        const float& completion() const { return completion_; }
198        const float& distributedCopies() const { return distributed_copies_; }
199       
200        const boost::int64_t& totalUploaded() const { return totalUploaded_; }
201        const boost::int64_t& totalPayloadUploaded() const { return totalPayloadUploaded_; }
202        const boost::int64_t& totalDownloaded() const { return totalDownloaded_; }
203        const boost::int64_t& totalPayloadDownloaded() const { return totalPayloadDownloaded_; }
204        const boost::int64_t& totalWantedDone() const { return totalWantedDone_; }
205        const boost::int64_t& totalWanted() const { return totalWanted_; }
206       
207        int peers() const { return peers_; }
208        int peersConnected() const { return connectedPeers_; }
209        int seeds() const { return seeds_; }
210        int seedsConnected() const { return connectedSeeds_; }
211       
212        float ratio() { return ratio_; }
213       
214        const boost::posix_time::time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; }
215        const boost::posix_time::time_duration& updateTrackerIn() { return updateTrackerIn_; }
216       
217        const PeerDetails& peerDetails() const;
218        const FileDetails& fileDetails() const;
219       
220        const boost::posix_time::time_duration& active() { return active_; }
221        const boost::posix_time::time_duration& seeding() { return seeding_; }
222        const boost::posix_time::ptime& startTime() { return startTime_; }
223        const boost::posix_time::ptime& finishTime() { return finishTime_; }
224       
225public:
226        std::wstring filename_;
227        std::wstring name_;
228        std::wstring saveDir_;
229        std::wstring state_;
230        std::wstring currentTracker_;
231
232        std::pair<float,float> speed_;         
233        float completion_;     
234        float distributed_copies_;
235       
236        boost::int64_t totalWantedDone_;
237        boost::int64_t totalWanted_;
238        boost::int64_t totalUploaded_;
239        boost::int64_t totalPayloadUploaded_;
240        boost::int64_t totalDownloaded_;
241        boost::int64_t totalPayloadDownloaded_;
242       
243        int peers_;
244        int connectedPeers_;
245        int seeds_;
246        int connectedSeeds_;
247       
248        float ratio_;
249       
250        boost::posix_time::time_duration estimatedTimeLeft_;
251        boost::posix_time::time_duration updateTrackerIn_;
252       
253        boost::posix_time::time_duration active_;
254        boost::posix_time::time_duration seeding_;
255        boost::posix_time::ptime startTime_;
256        boost::posix_time::ptime finishTime_;
257       
258private:
259        mutable bool peerDetailsFilled_;
260        mutable PeerDetails peerDetails_;
261       
262        mutable bool fileDetailsFilled_;
263        mutable FileDetails fileDetails_;
264};
265
266typedef boost::shared_ptr<TorrentDetail> TorrentDetail_ptr;
267typedef boost::scoped_ptr<TorrentDetail> TorrentDetail_sptr;
268typedef boost::weak_ptr<TorrentDetail> TorrentDetail_wptr;
269typedef std::vector<TorrentDetail_ptr> TorrentDetail_vec;
270typedef std::map<std::wstring, TorrentDetail_ptr> TorrentDetail_map;
271
272class TorrentDetails
273{
274public: 
275        void sort(boost::function<bool (const TorrentDetail_ptr&, const TorrentDetail_ptr&)> fn) const;
276       
277        const TorrentDetail_vec torrents() const 
278        {
279                mutex_t::scoped_lock l(mutex_); 
280                return torrents_; 
281        }
282       
283        const TorrentDetail_vec selectedTorrents() const 
284        { 
285                mutex_t::scoped_lock l(mutex_); 
286                return selectedTorrents_; 
287        }
288       
289        const TorrentDetail_ptr focusedTorrent() const 
290        {
291                mutex_t::scoped_lock l(mutex_); 
292                return selectedTorrent_; 
293        }
294       
295        const TorrentDetail_ptr get(std::wstring filename) const
296        {
297                mutex_t::scoped_lock l(mutex_); 
298               
299                TorrentDetail_map::const_iterator i = torrentMap_.find(filename);
300               
301                if (i != torrentMap_.end())
302                        return i->second;
303                else
304                        return TorrentDetail_ptr();
305        }
306       
307        friend class BitTorrent;
308
309private:
310        void clearAll(const mutex_t::scoped_lock&)
311        {
312                // !! No mutex lock, it should only be call from functions which
313                // have the lock themselves, hence the unused function param
314               
315                torrents_.clear();
316                torrentMap_.clear();
317                selectedTorrents_.clear();
318                selectedTorrent_.reset();
319        }
320
321        mutable TorrentDetail_vec torrents_;
322       
323        TorrentDetail_map torrentMap_;
324        TorrentDetail_vec selectedTorrents_;
325        TorrentDetail_ptr selectedTorrent_;
326       
327        mutable mutex_t mutex_;
328};
329
330struct TrackerDetail
331{
332        TrackerDetail() {}
333        TrackerDetail(std::wstring u, int t) : url(u), tier(t) {}
334       
335        bool operator<(const TrackerDetail& t) const
336        {
337                return (tier < t.tier);
338        }
339       
340        std::wstring url;
341        int tier;
342};
343
344class EventDetail;
345
346struct SessionDetail
347{
348        int port;
349       
350        std::pair<double, double> speed;
351       
352        bool dht_on;
353        size_t dht_nodes;
354        size_t dht_torrents;
355       
356        bool ip_filter_on;
357        size_t ip_ranges_filtered;
358};
359
360typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
361typedef boost::function<bool (size_t)> progressCallback;
362
363class BitTorrent_impl;
364
365class BitTorrent
366{
367public: 
368        enum mappings
369        {
370                mappingNone = 0,
371                mappingUPnP,
372                mappingNatPMP
373        };
374
375        void shutDownSession();
376        void saveTorrentData();
377       
378        bool listenOn(std::pair<int, int> const& portRange);
379        int isListeningOn();
380        void stopListening();
381       
382        bool ensureDhtOn();
383        void ensureDhtOff();
384       
385        void ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4);
386        void ensurePeOff();
387       
388        void ensureIpFilterOn(progressCallback fn);
389        void ensureIpFilterOff();
390
391        void setMapping(int mapping);
392
393        void ip_v4_filter_block(asio::ip::address_v4 first, asio::ip::address_v4 last);
394        void ip_v6_filter_block(asio::ip::address_v6 first, asio::ip::address_v6 last);
395        void ip_filter_import_dat(boost::filesystem::path file, progressCallback fn, bool octalFix);
396        size_t ip_filter_size();
397        void clearIpFilter();
398       
399       
400        void setSessionHalfOpenLimit(int halfConn);
401        void setSessionLimits(int maxConn, int maxUpload);
402        void setSessionSpeed(float download, float upload);
403        void setDhtSettings(int max_peers_reply, int search_branching, 
404                int service_port, int max_fail_count);
405        void setTimeouts(int peers, int tracker);
406       
407        const SessionDetail getSessionDetails();
408
409        void setTorrentDefaults(int maxConn, int maxUpload, float download, float upload);     
410        void newTorrent(boost::filesystem::wpath filename, boost::filesystem::wpath files);
411        void addTorrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory, 
412                bool startPaused=false, bool compactStorage=false);
413       
414        void setTorrentRatio(const std::string&, float ratio);
415        void setTorrentRatio(const std::wstring&, float ratio);
416        float getTorrentRatio(const std::string&);
417        float getTorrentRatio(const std::wstring&);
418       
419        void getAllPeerDetails(const std::string& filename, PeerDetails& peerContainer);
420        void getAllPeerDetails(const std::wstring& filename, PeerDetails& peerContainer);
421        void getAllFileDetails(const std::string& filename, FileDetails& fileDetails);
422        void getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails);
423       
424        void resumeAll();
425        void closeAll();
426       
427        bool isTorrent(const std::string& filename);
428        bool isTorrent(const std::wstring& filename);   
429       
430        void pauseTorrent(const std::string& filename);
431        void pauseTorrent(const std::wstring& filename);
432        void resumeTorrent(const std::string& filename);
433        void resumeTorrent(const std::wstring& filename);
434        void stopTorrent(const std::string& filename);
435        void stopTorrent(const std::wstring& filename);
436        bool isTorrentActive(const std::string& filename);
437        bool isTorrentActive(const std::wstring& filename);
438        void reannounceTorrent(const std::string& filename);
439        void reannounceTorrent(const std::wstring& filename);
440       
441        void pauseAllTorrents();
442        void unpauseAllTorrents();
443       
444        void removeTorrent(const std::string& filename);
445        void removeTorrent(const std::wstring&  filename);
446        void removeTorrentWipeFiles(const std::string& filename);
447        void removeTorrentWipeFiles(const std::wstring&  filename);
448       
449        void setTorrentLogin(const std::string& filename, std::wstring username, std::wstring password);
450        void setTorrentLogin(const std::wstring& filename, std::wstring username, std::wstring password);
451        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::string& filename);
452        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::wstring&  filename);
453       
454        void setTorrentLimit(const std::string& filename, int maxConn, int maxUpload);
455        void setTorrentLimit(const std::wstring& filename, int maxConn, int maxUpload);
456        void setTorrentSpeed(const std::string& filename, float download, float upload);
457        void setTorrentSpeed(const std::wstring& filename, float download, float upload);
458        std::pair<int, int> getTorrentLimit(const std::string& filename);
459        std::pair<int, int> getTorrentLimit(const std::wstring& filename);
460        std::pair<float, float> getTorrentSpeed(const std::string& filename);
461        std::pair<float, float> getTorrentSpeed(const std::wstring& filename);
462       
463        void setTorrentTrackers(const std::string& filename, const std::vector<TrackerDetail>& trackers);
464        void setTorrentTrackers(const std::wstring& filename, const std::vector<TrackerDetail>& trackers);
465        void resetTorrentTrackers(const std::string& filename);
466        void resetTorrentTrackers(const std::wstring& filename);
467        std::vector<TrackerDetail> getTorrentTrackers(const std::string& filename);
468        std::vector<TrackerDetail> getTorrentTrackers(const std::wstring& filename);
469       
470        void setTorrentFilePriorities(const std::string& filename, std::vector<int> fileIndices, int priority);
471        void setTorrentFilePriorities(const std::wstring& filename, std::vector<int> fileIndices, int priority);
472
473        void startEventReceiver();
474        void stopEventReceiver();
475       
476        friend BitTorrent& bittorrent();
477       
478        int defTorrentMaxConn();
479        int defTorrentMaxUpload();
480        float defTorrentDownload();
481        float defTorrentUpload();       
482
483        const TorrentDetails& torrentDetails();
484        const TorrentDetails& updateTorrentDetails(const std::wstring& focused, const std::set<std::wstring>& selected);
485       
486private:
487        BitTorrent();
488        boost::scoped_ptr<BitTorrent_impl> pimpl;
489       
490        TorrentDetails torrentDetails_;
491};
492
493BitTorrent& bittorrent();
494
495};
Note: See TracBrowser for help on using the repository browser.