source: src/halTorrent.hpp @ 345

Revision 345, 14.0 KB checked in by Eoin, 12 years ago (diff)

Minor renaming and attempts to decouple GUI from Torrents.

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