Updated to final KDE3 ktorrent release (2.2.6)

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/ktorrent@1077377 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 509 insertions, 0 deletions

diff --git a/libktorrent/interfaces/torrentinterface.h b/libktorrent/interfaces/torrentinterface.h
new file mode 100644
index 0000000..95d5766
--- /dev/null
+++ b/libktorrent/interfaces/torrentinterface.h
@@ -0,0 +1,509 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   [email protected]                                               *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.             *
+ ***************************************************************************/
+#ifndef KTTORRENTINTERFACE_H
+#define KTTORRENTINTERFACE_H
+
+#include <qobject.h>
+#include <util/constants.h>
+#include <interfaces/trackerslist.h>
+
+#include <kurl.h>
+
+namespace bt
+{
+	class BitSet;
+	class DataCheckerListener;
+	class SHA1Hash;
+	class WaitJob;
+	class PeerID;
+}
+
+namespace kt
+{
+	using bt::Uint32;
+	using bt::Uint64;
+
+	class MonitorInterface;
+	class TorrentFileInterface;
+	class PeerSource;
+	
+	enum TorrentStatus
+	{
+		NOT_STARTED,
+		SEEDING_COMPLETE,
+		DOWNLOAD_COMPLETE,
+		SEEDING,
+		DOWNLOADING,
+		STALLED,
+		STOPPED,
+		ALLOCATING_DISKSPACE,
+		ERROR,
+		QUEUED,
+		CHECKING_DATA,
+  		NO_SPACE_LEFT
+	};
+	
+	enum TorrentStartResponse
+	{
+		START_OK,
+		USER_CANCELED,
+		NOT_ENOUGH_DISKSPACE, 
+		MAX_SHARE_RATIO_REACHED, 
+		BUSY_WITH_DATA_CHECK, 
+		QM_LIMITS_REACHED // Max seeds or downloads reached
+	};
+	
+	enum AutoStopReason
+	{
+		MAX_RATIO_REACHED,
+		MAX_SEED_TIME_REACHED
+	};
+
+	struct TorrentStats
+	{
+		/// The number of bytes imported (igore these for average speed)
+		Uint64 imported_bytes;
+		/// Total number of bytes downloaded.
+		Uint64 bytes_downloaded;
+		/// Total number of bytes uploaded.
+		Uint64 bytes_uploaded;
+		/// The number of bytes left (gets sent to the tracker)
+		Uint64 bytes_left;
+		/// The number of bytes left to download (bytes_left - excluded bytes)
+		Uint64 bytes_left_to_download;
+		/// total number of bytes in torrent
+		Uint64 total_bytes;
+		/// The total number of bytes which need to be downloaded
+		Uint64 total_bytes_to_download;
+		/// The download rate in bytes per sec
+		Uint32 download_rate;
+		/// The upload rate in bytes per sec
+		Uint32 upload_rate;
+		/// The number of peers we are connected to
+		Uint32 num_peers;
+		/// The number of chunks we are currently downloading
+		Uint32 num_chunks_downloading;
+		/// The total number of chunks
+		Uint32 total_chunks;
+		/// The number of chunks which have been downloaded
+		Uint32 num_chunks_downloaded;
+		/// Get the number of chunks which have been excluded
+		Uint32 num_chunks_excluded;
+		/// Get the number of chunks left
+		Uint32 num_chunks_left;
+		/// Size of each chunk
+		Uint32 chunk_size;
+		/// Total seeders in swarm
+		Uint32 seeders_total;
+		/// Num seeders connected to
+		Uint32 seeders_connected_to;
+		/// Total leechers in swarm
+		Uint32 leechers_total;
+		/// Num leechers connected to
+		Uint32 leechers_connected_to;
+		/// Status of the download
+		TorrentStatus status;
+		/// The status of the tracker
+		QString trackerstatus;
+		/// The number of bytes downloaded in this session
+		Uint64 session_bytes_downloaded;
+		/// The number of bytes uploaded in this session
+		Uint64 session_bytes_uploaded;
+		/// The number of bytes downloaded since the last started event, this gets sent to the tracker
+		Uint64 trk_bytes_downloaded;
+		/// The number of bytes upload since the last started event, this gets sent to the tracker
+		Uint64 trk_bytes_uploaded;
+		/// Name of the torrent
+		QString torrent_name;
+		/// Path of the dir or file where the data will get saved
+		QString output_path;
+		/// See if we are running
+		bool running;
+		/// See if the torrent has been started
+		bool started;
+		/// See if we are allowed to startup this torrent automatically.
+		bool autostart;
+		/// See if we have a multi file torrent
+		bool multi_file_torrent;
+		/// See if the torrent is stopped by error
+		bool stopped_by_error;
+		/// See if the download is completed
+		bool completed;
+		/// See if this torrent is controlled by user
+		bool user_controlled;
+		/// Maximum share ratio
+		float max_share_ratio;
+		/// Maximum seed time
+		float max_seed_time;
+		/// Private torrent (i.e. no use of DHT)
+		bool priv_torrent;
+		/// Number of corrupted chunks found since the last check
+		Uint32 num_corrupted_chunks;
+	};
+	
+		
+	struct DHTNode
+	{
+		QString ip;
+		bt::Uint16 port;
+	};
+	
+	enum TorrentFeature
+	{
+		DHT_FEATURE, 
+		UT_PEX_FEATURE // µTorrent peer exchange
+	};
+	
+
+	/**
+	 * @author Joris Guisson
+	 * @brief Interface for an object which controls one torrent
+	 *
+	 * This class is the interface for an object which controls the
+	 * up- and download of one torrent.
+	*/
+	class TorrentInterface : public QObject
+	{
+		Q_OBJECT
+	public:
+		TorrentInterface();
+		virtual ~TorrentInterface();
+
+	
+		/**
+		 * Update the object, should be called periodically.
+		 */
+		virtual void update() = 0;
+		
+		/**
+		 * Start the download of the torrent.
+		 */
+		virtual void start() = 0;
+		
+		/**
+		 * Stop the download, closes all connections.
+		 * @param user wether or not the user did this explicitly
+		 * @param wjob WaitJob, used when KT is shutting down, 
+		 * 	so that we can wait for all stopped events to reach the tracker
+		 */
+		virtual void stop(bool user,bt::WaitJob* wjob = 0) = 0;
+		
+		/**
+		 * Update the tracker, this should normally handled internally.
+		 * We leave it public so that the user can do a manual announce.
+		 */
+		virtual void updateTracker() = 0;
+
+		/// Get the torrent's statistics
+		const TorrentStats & getStats() const {return stats;}
+
+		/**
+		 * Checks if torrent is multimedial and chunks needed for preview are downloaded
+		 * @param start_chunk The index of starting chunk to check
+		 * @param end_chunk The index of the last chunk to check
+		 * In case of single torrent file defaults can be used (0,1)
+		 **/
+		virtual bool readyForPreview(int start_chunk = 0, int end_chunk = 1) = 0;
+
+		/**
+		 * Get the torX directory of this torrent. Temporary stuff like the index
+		 * file get stored there.
+		 */
+		virtual QString getTorDir() const = 0;
+
+		/// Get the data directory of this torrent
+		virtual QString getDataDir() const = 0;
+
+		/// Get a short error message
+		virtual QString getShortErrorMessage() const = 0;
+
+		/**
+		 * Get the download running time of this torrent in seconds
+		 * @return Uint32 - time in seconds
+		 */
+		virtual Uint32 getRunningTimeDL() const = 0;
+		
+		/**
+		 * Get the upload running time of this torrent in seconds
+		 * @return Uint32 - time in seconds
+		 */
+		virtual Uint32 getRunningTimeUL() const = 0;
+
+		/**
+		 * Change to a new data dir. If this fails
+		 * we will fall back on the old directory.
+		 * @param new_dir The new directory
+		 * @return true upon succes
+		 */
+		virtual bool changeDataDir(const QString & new_dir) = 0;
+		
+		/**
+		 * Change torrents output directory. If this fails we will fall back on the old directory.
+		 * @param new_dir The new directory
+		 * @param moveFiles Wheather to actually move the files or just change the directory without moving them.
+		 * @return true upon success.
+		 */
+		virtual bool changeOutputDir(const QString& new_dir, bool moveFiles = true) = 0;
+
+		/**
+		 * Roll back the previous changeDataDir call.
+		 * Does nothing if there was no previous changeDataDir call.
+		 */
+		virtual void rollback() = 0;
+
+		/**
+		 * Get a BitSet of the status of all Chunks
+		 */
+		virtual const bt::BitSet & downloadedChunksBitSet() const = 0;
+
+		/**
+		 * Get a BitSet of the availability of all Chunks
+		 */
+		virtual const bt::BitSet & availableChunksBitSet() const = 0;
+
+		/**
+		 * Get a BitSet of the excluded Chunks
+		 */
+		virtual const bt::BitSet & excludedChunksBitSet() const = 0;
+		
+		/**
+		 * Get a bitset of only seed chunks
+		 */
+		virtual const bt::BitSet & onlySeedChunksBitSet() const = 0;
+
+		/// Set the monitor
+		virtual void setMonitor(MonitorInterface* tmo) = 0;
+
+		/// Get the time to the next tracker update in seconds.
+		virtual Uint32 getTimeToNextTrackerUpdate() const = 0;
+
+		/// Get the number of files in a multifile torrent (0 if we do not have a multifile torrent)
+		virtual Uint32 getNumFiles() const = 0;
+
+		/**
+		 * Get the index'th file of a multifile torrent
+		 * @param index The index
+		 * @return The TorrentFileInterface (isNull() will be true in case of error)
+		 */
+		virtual TorrentFileInterface & getTorrentFile(Uint32 index) = 0;
+		
+		///Get a pointer to TrackersList object
+		virtual TrackersList* getTrackersList() = 0;
+		
+		///Get a pointer to TrackersList object
+		virtual const TrackersList* getTrackersList() const = 0;
+		
+		///Get the torrent queue number. Zero if not in queue
+		virtual int getPriority() const = 0;
+		
+		///Set the torrent queue number.
+		virtual void setPriority(int p) = 0;
+		
+		/// Set the max share ratio
+		virtual void setMaxShareRatio(float ratio) = 0;
+		
+		/// Get the max share ratio
+		virtual float getMaxShareRatio() const = 0;
+		
+		/// Set the max seed time in hours (0 is no limit)
+		virtual void setMaxSeedTime(float hours) = 0;
+		
+		/// Get the max seed time
+		virtual float getMaxSeedTime() const = 0;
+		
+		/// Make a string of the current status
+		virtual QString statusToString() const = 0;
+		
+		///Is manual announce allowed?
+		virtual bool announceAllowed() = 0;
+		
+		
+		/**
+		 * Returns estimated time left for finishing download. Returned value is in seconds.
+		 * Uses TimeEstimator class to calculate this value.
+		 */
+		virtual Uint32 getETA() = 0;
+		
+		/**
+		 * Verify the correctness of all data.
+		 * @param lst The listener
+		 * @param auto_import Wether or not this is an initial import
+		 */
+		virtual void startDataCheck(bt::DataCheckerListener* lst,bool auto_import) = 0;
+		
+		/**
+		 * Data check has been finished, this should be called.
+		 */
+		virtual void afterDataCheck() = 0;
+		
+		/**
+		 * Are we doing a data check on this torrent.
+		 * @param finished This will be set to true if the data check is finished
+		 */
+		virtual bool isCheckingData(bool & finished) const = 0;
+		
+		/**
+		 * Test all files and see if they are not missing.
+		 * If so put them in a list
+		 */
+		virtual bool hasMissingFiles(QStringList & sl) = 0;
+		
+		/**
+		 * Recreate missing files.
+		*/
+		virtual void recreateMissingFiles() = 0;
+		
+		/**
+		 * Mark missing files as do not download.
+		 */
+		virtual void dndMissingFiles() = 0;
+		
+		
+		/// Get the number of initial DHT nodes
+		virtual Uint32 getNumDHTNodes() const = 0;
+		
+		/// Get a DHT node
+		virtual const DHTNode & getDHTNode(Uint32 i) const = 0;
+	
+		/** Delete the data files of the torrent,
+		 * they will be lost permanently
+		 */
+		virtual void deleteDataFiles() = 0;
+		
+		///Checks if a seeding torrent has reached its maximum share ratio
+		virtual bool overMaxRatio() = 0;
+		
+		/// Checks if a seeding torrent has reached it's max seed time
+		virtual bool overMaxSeedTime() = 0;
+		
+		/// Handle an error
+		virtual void handleError(const QString & err) = 0;
+		
+		/// Get the info_hash.
+		virtual const bt::SHA1Hash & getInfoHash() const  = 0;
+		
+		/**
+		 * Add a new PeerSource
+		 * @param ps 
+		 */
+		virtual void addPeerSource(PeerSource* ps) = 0;
+		
+		/**
+		 * Remove a nPeerSource
+		 * @param ps 
+		 */
+		virtual void removePeerSource(PeerSource* ps) = 0;
+		
+		/// Is a feature enabled
+		virtual bool isFeatureEnabled(TorrentFeature tf) = 0;
+		
+		/// Disable or enable a feature
+		virtual void setFeatureEnabled(TorrentFeature tf,bool on) = 0;
+		
+		/// Get our PeerID
+		virtual const bt::PeerID & getOwnPeerID() const = 0;
+		
+		/// Set the traffic limits for this torrent
+		virtual void setTrafficLimits(Uint32 up,Uint32 down) = 0;
+		
+		/// Get the traffic limits
+		virtual void getTrafficLimits(Uint32 & up,Uint32 & down) = 0;
+		
+		/// Check if there is enough diskspace available for this torrent
+		virtual bool checkDiskSpace(bool emit_sig = true) = 0;
+		
+		/// Are we in the process of moving files
+		virtual bool isMovingFiles() const = 0;
+	signals:
+		/**
+		 * Emited when we have finished downloading.
+		 * @param me The object who emitted the signal
+		 */
+		void finished(kt::TorrentInterface* me);
+
+		/**
+		 * Emited when a Torrent download is stopped by error
+		 * @param me The object who emitted the signal
+		 * @param msg Error message
+		 */
+		void stoppedByError(kt::TorrentInterface* me, QString msg);
+		
+		/**
+		 * Emited when maximum share ratio for this torrent is changed
+		 * @param me The object which emitted the signal.
+		 */
+		void maxRatioChanged(kt::TorrentInterface* me);
+		
+		/**
+		 * Emited then torrent is stopped from seeding by KTorrent. 
+		 * Happens when torrent has reached maximum share ratio and maybe we'll add something more...
+		 * @param me The object which emitted the signal.
+		 */
+		void seedingAutoStopped(kt::TorrentInterface* me,kt::AutoStopReason reason);
+		
+		/**
+		 * Emitted just before the torrent is started, this should be used to do some
+		 * checks on the files in the cache.
+		 * @param me The torrent which emitted the signal
+		 * @param ret The return value
+		 */
+		void aboutToBeStarted(kt::TorrentInterface* me,bool & ret);
+		
+		/**
+		 * Emitted when missing files have been marked as dnd.
+		 * The intention of this signal is to update the GUI.
+		 * @param me The torrent which emitted the signal
+		*/
+		void missingFilesMarkedDND(kt::TorrentInterface* me);
+		
+		/**
+		 * A corrupted chunk has been found during upload.
+		 * @param me The torrent which emitted the signal
+		 */
+		void corruptedDataFound(kt::TorrentInterface* me);
+		
+		/**
+		 * Disk is running out of space.
+		 * @param me The torrent which emitted the signal
+		 * @param toStop should this torrent be stopped or not
+		 */
+		void diskSpaceLow(kt::TorrentInterface* me, bool toStop);
+		
+		/**
+		 * Torrent has been stopped
+		 * @param me The torrent which emitted the signal
+		 */
+		void torrentStopped(kt::TorrentInterface* me);
+
+	protected:
+		TorrentStats stats;
+	};
+
+
+	/**
+	 * Calculates the share ratio of a torrent.
+	 * @param stats The stats of the torrent
+	 * @return The share ratio
+	 */
+	float ShareRatio(const TorrentStats & stats);
+
+}
+
+#endif