source: src/halTorrent.hpp @ 260

Revision 260, 9.6 KB checked in by Eoin, 13 years ago (diff)
Line 
1
2#pragma once
3
4#include <string>
5#include <vector>
6#include <set>
7
8#include <boost/signal.hpp>
9#include <boost/optional.hpp>
10#include <boost/function.hpp>
11#include <boost/date_time/posix_time/posix_time.hpp>
12#include <boost/smart_ptr.hpp>
13#include <boost/algorithm/string.hpp>
14#include <boost/filesystem/path.hpp>
15#include <boost/filesystem/operations.hpp>
16#include <boost/filesystem/fstream.hpp>
17
18#include <asio/ip/tcp.hpp>
19#include <asio/ip/udp.hpp>
20
21using boost::filesystem::path;
22using boost::posix_time::time_duration;
23
24namespace libtorrent { struct peer_info; }
25
26namespace hal
27{
28
29struct torrentBriefDetail
30{
31        std::wstring filename;
32        std::wstring status;
33        std::pair<float,float> speed;
34        float completion;
35        int peers;
36        int seeds;
37};
38
39struct PeerDetail
40{
41        PeerDetail(const std::wstring& ip_address) :
42                ipAddress(ip_address)
43        {}
44        PeerDetail(libtorrent::peer_info& peerInfo);
45       
46        bool operator==(const PeerDetail& peer) const
47        {
48                return (ipAddress == peer.ipAddress);
49        }
50       
51        bool operator<(const PeerDetail& peer) const
52        {
53                return (ipAddress < peer.ipAddress);
54        }
55       
56        wstring ipAddress;
57        wstring country;
58        std::pair<float,float> speed;
59        bool seed;
60        std::wstring client;
61        std::wstring status;
62};
63
64typedef shared_ptr<PeerDetail> PeerDetail_ptr;
65typedef std::vector<PeerDetail> PeerDetails;
66
67class TorrentDetail 
68{
69public:
70        TorrentDetail(std::wstring f, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0),
71                        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, int prs=0, int prsCnt=0, int sds=0, int sdsCnt=0,  float r=0, 
72                        time_duration eta=boost::posix_time::seconds(0), time_duration uIn=boost::posix_time::seconds(0)) :
73                filename_(f),
74                state_(s),
75                currentTracker_(cT),
76                speed_(sp),
77                completion_(c),
78                distributed_copies_(d),
79                totalWantedDone_(tWD),
80                totalWanted_(tW),
81                totalUploaded_(tU),
82                totalPayloadUploaded_(tpU),
83                totalDownloaded_(tD),
84                totalPayloadDownloaded_(tpD),
85                peers_(prs),
86                connectedPeers_(prsCnt),
87                seeds_(sds),
88                connectedSeeds_(sdsCnt),
89                ratio_(r),
90                estimatedTimeLeft_(eta),
91                updateTrackerIn_(uIn),
92                peerDetailsFilled_(false)
93        {}
94
95        TorrentDetail() :       
96                peerDetailsFilled_(false)
97        {};     
98       
99        enum state
100        {
101                torrent_active = 0,
102                torrent_paused,
103                torrent_stopped
104        };
105       
106        const std::wstring& filename() const { return filename_; }
107        const std::wstring& state() const { return state_; }
108        const std::wstring& currentTracker() const { return currentTracker_; }
109       
110        std::pair<float,float> speed() const { return speed_; }
111        const float& completion() const { return completion_; }
112        const float& distributedCopies() const { return distributed_copies_; }
113       
114        const boost::int64_t& totalUploaded() const { return totalUploaded_; }
115        const boost::int64_t& totalPayloadUploaded() const { return totalPayloadUploaded_; }
116        const boost::int64_t& totalDownloaded() const { return totalDownloaded_; }
117        const boost::int64_t& totalPayloadDownloaded() const { return totalPayloadDownloaded_; }
118        const boost::int64_t& totalWantedDone() const { return totalWantedDone_; }
119        const boost::int64_t& totalWanted() const { return totalWanted_; }
120       
121        int peers() const { return peers_; }
122        int peersConnected() const { return connectedPeers_; }
123        int seeds() const { return seeds_; }
124        int seedsConnected() const { return connectedSeeds_; }
125       
126        float ratio() { return ratio_; }
127       
128        const time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; }
129        const time_duration& updateTrackerIn() { return updateTrackerIn_; }
130       
131        const PeerDetails& peerDetails() const;
132       
133public:
134        std::wstring filename_;
135        std::wstring state_;
136        std::wstring currentTracker_;
137
138        std::pair<float,float> speed_;         
139        float completion_;     
140        float distributed_copies_;
141       
142        boost::int64_t totalWantedDone_;
143        boost::int64_t totalWanted_;
144        boost::int64_t totalUploaded_;
145        boost::int64_t totalPayloadUploaded_;
146        boost::int64_t totalDownloaded_;
147        boost::int64_t totalPayloadDownloaded_;
148       
149        int peers_;
150        int connectedPeers_;
151        int seeds_;
152        int connectedSeeds_;
153       
154        float ratio_;
155       
156        time_duration estimatedTimeLeft_;
157        time_duration updateTrackerIn_;
158       
159private:
160        mutable bool peerDetailsFilled_;
161        mutable PeerDetails peerDetails_;
162};
163
164typedef shared_ptr<TorrentDetail> TorrentDetail_ptr;
165typedef std::vector<TorrentDetail_ptr> TorrentDetail_vec;
166typedef std::map<std::wstring, TorrentDetail_ptr> TorrentDetail_map;
167
168class TorrentDetails
169{
170public: 
171        void sort(boost::function<bool (const TorrentDetail_ptr&, const TorrentDetail_ptr&)> fn) const;
172       
173        const TorrentDetail_vec torrents() const 
174        {
175                mutex_t::scoped_lock l(mutex_); 
176                return torrents_; 
177        }
178       
179        const TorrentDetail_vec selectedTorrents() const 
180        { 
181                mutex_t::scoped_lock l(mutex_); 
182                return selectedTorrents_; 
183        }
184       
185        const TorrentDetail_ptr focusedTorrent() const 
186        {
187                mutex_t::scoped_lock l(mutex_); 
188                return selectedTorrent_; 
189        }
190       
191        const TorrentDetail_ptr selectedTorrent() const { return focusedTorrent(); }
192       
193        const TorrentDetail_ptr get(std::wstring filename) const
194        {
195                mutex_t::scoped_lock l(mutex_); 
196               
197                TorrentDetail_map::const_iterator i = torrentMap_.find(filename);
198               
199                if (i != torrentMap_.end())
200                        return i->second;
201                else
202                        return TorrentDetail_ptr();
203        }
204       
205        friend class BitTorrent;
206
207private:
208        void clearAll(const mutex_t::scoped_lock&)
209        {
210                // !! No mutex lock, it should only be call from functions which
211                // have the lock themselves, hence the unused function param
212               
213                torrents_.clear();
214                torrentMap_.clear();
215                selectedTorrents_.clear();
216                selectedTorrent_.reset();
217        }
218
219        mutable TorrentDetail_vec torrents_;
220       
221        TorrentDetail_map torrentMap_;
222        TorrentDetail_vec selectedTorrents_;
223        TorrentDetail_ptr selectedTorrent_;
224       
225        mutable mutex_t mutex_;
226};
227
228struct TrackerDetail
229{
230        TrackerDetail() {}
231        TrackerDetail(std::wstring u, int t) : url(u), tier(t) {}
232       
233        std::wstring url;
234        int tier;
235};
236
237class EventDetail;
238
239struct SessionDetail
240{
241        int port;
242       
243        std::pair<double, double> speed;
244       
245        bool dht_on;
246        size_t dht_nodes;
247        size_t dht_torrents;
248       
249        bool ip_filter_on;
250        size_t ip_ranges_filtered;
251};
252
253typedef boost::function<bool (size_t, size_t, size_t)> filterCallback;
254typedef boost::function<bool (size_t)> progressCallback;
255
256class BitTorrent_impl;
257
258class BitTorrent
259{
260public: 
261        void shutDownSession();
262        void saveTorrentData();
263       
264        bool listenOn(std::pair<int, int> const& portRange);
265        int isListeningOn();
266        void stopListening();
267       
268        bool ensure_dht_on();
269        void ensure_dht_off();
270       
271        void ensure_ip_filter_on(progressCallback fn);
272        void ensure_ip_filter_off();
273        void ip_v4_filter_block(asio::ip::address_v4 first, asio::ip::address_v4 last);
274        void ip_v6_filter_block(asio::ip::address_v6 first, asio::ip::address_v6 last);
275        void ip_filter_import_dat(boost::filesystem::path file, progressCallback fn, bool octalFix);
276        size_t ip_filter_size();
277        void clearIpFilter();
278       
279        void ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4);
280        void ensure_pe_off();
281       
282        void setSessionHalfOpenLimit(int halfConn);
283        void setSessionLimits(int maxConn, int maxUpload);
284        void setSessionSpeed(float download, float upload);
285        void setDhtSettings(int max_peers_reply, int search_branching, 
286                int service_port, int max_fail_count);
287       
288        const SessionDetail getSessionDetails();
289
290        void setTorrentDefaults(int maxConn, int maxUpload, float download, float upload);     
291        void newTorrent(boost::filesystem::wpath filename, boost::filesystem::wpath files);
292        void addTorrent(boost::filesystem::wpath file, wpath saveDirectory);
293        void getAllTorrentDetail_vec(TorrentDetail_vec& torrentsContainer);
294        TorrentDetail_ptr getTorrentDetail_vec(std::string filename);   
295       
296        void setTorrentRatio(std::string, float ratio);
297        float getTorrentRatio(std::string);
298       
299        void getAllPeerDetails(std::string filename, PeerDetails& peerContainer);
300       
301        void resumeAll();
302        void closeAll();
303       
304        bool isTorrent(std::string filename);
305       
306        void pauseTorrent(std::string filename);
307        void resumeTorrent(std::string filename);
308        void stopTorrent(std::string filename);
309        bool isTorrentActive(std::string filename);
310       
311        void pauseAllTorrents();
312        void unpauseAllTorrents();
313       
314        void removeTorrent(std::string filename);
315        void removeTorrentWipeFiles(std::string filename);
316        void reannounceTorrent(std::string filename);
317       
318        void setTorrentLogin(std::string filename, std::wstring username, std::wstring password);
319        std::pair<std::wstring, std::wstring> getTorrentLogin(std::string filename);
320       
321        void setTorrentLimit(std::string filename, int maxConn, int maxUpload);
322        void setTorrentSpeed(std::string filename, float download, float upload);
323        pair<int, int> getTorrentLimit(std::string filename);
324        pair<float, float> getTorrentSpeed(std::string filename);
325       
326        void setTorrentTrackers(std::string filename, const std::vector<TrackerDetail>& trackers);
327        void resetTorrentTrackers(std::string filename);
328        std::vector<TrackerDetail> getTorrentTrackers(std::string filename);
329
330        void startEventReceiver();
331        void stopEventReceiver();
332       
333        friend BitTorrent& bittorrent();
334       
335        int defTorrentMaxConn();
336        int defTorrentMaxUpload();
337        float defTorrentDownload();
338        float defTorrentUpload();       
339
340        const TorrentDetails& torrentDetails();
341//      const TorrentDetails& getTorrentDetails(std::string selected, std::set<std::string> allSelected);       
342        const TorrentDetails& updateTorrentDetails(std::string focused, std::set<std::string> selected);
343       
344private:
345        BitTorrent();
346        boost::scoped_ptr<BitTorrent_impl> pimpl;
347       
348        TorrentDetails torrentDetails_;
349};
350
351BitTorrent& bittorrent();
352
353};
Note: See TracBrowser for help on using the repository browser.