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

36 files changed, 4599 insertions, 0 deletions

diff --git a/libktorrent/util/Makefile.am b/libktorrent/util/Makefile.am
new file mode 100644
index 0000000..c7f46ae
--- /dev/null
+++ b/libktorrent/util/Makefile.am
@@ -0,0 +1,18 @@
+INCLUDES = -I$(srcdir)/../../libktorrent $(all_includes)
+
+METASOURCES = AUTO
+
+noinst_LTLIBRARIES = libutil.la
+libutil_la_LDFLAGS = $(all_libraries)
+
+
+libutil_la_SOURCES = array.cpp autorotatelogjob.cpp bitset.cpp error.cpp \
+	file.cpp fileops.cpp functions.cpp httprequest.cpp log.cpp mmapfile.cpp \
+	profiler.cpp ptrmap.cpp sha1hash.cpp sha1hashgen.cpp timer.cpp urlencoder.cpp \
+	waitjob.cpp
+
+
+
+
+KDE_CXXFLAGS = $(USE_EXCEPTIONS) $(USE_RTTI)
+noinst_HEADERS = autorotatelogjob.h profiler.h
diff --git a/libktorrent/util/array.cpp b/libktorrent/util/array.cpp
new file mode 100644
index 0000000..e57091d
--- /dev/null
+++ b/libktorrent/util/array.cpp
@@ -0,0 +1,27 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include "array.h"
+
+namespace bt
+{
+
+
+
+}
diff --git a/libktorrent/util/array.h b/libktorrent/util/array.h
new file mode 100644
index 0000000..1694e2a
--- /dev/null
+++ b/libktorrent/util/array.h
@@ -0,0 +1,73 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTARRAY_H
+#define BTARRAY_H
+
+#include "constants.h"
+
+namespace bt
+{
+
+	/**
+	 * @author Joris Guisson
+	 *
+	 * Template array classes, makes creating dynamic buffers easier
+	 * and safer.
+	 */
+	template<class T>
+	class Array
+	{
+		Uint32 num;
+		T* data;
+	public:
+		Array(Uint32 num = 0) : num(num),data(0)
+		{
+			if (num > 0)
+				data = new T[num];
+		}
+
+		~Array()
+		{
+			delete [] data;
+		}
+
+		T & operator [] (Uint32 i) {return data[i];}
+		const T & operator [] (Uint32 i) const {return data[i];}
+
+		operator const T* () const {return data;}
+		operator T* () {return data;}
+
+		/// Get the number of elements in the array
+		Uint32 size() const {return num;}
+
+		/**
+		 * Fill the array with a value
+		 * @param val The value
+		 */
+		void fill(T val)
+		{
+			for (Uint32 i = 0;i < num;i++)
+				data[i] = val;
+		}
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/autorotatelogjob.cpp b/libktorrent/util/autorotatelogjob.cpp
new file mode 100644
index 0000000..c43e304
--- /dev/null
+++ b/libktorrent/util/autorotatelogjob.cpp
@@ -0,0 +1,88 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.          *
+ ***************************************************************************/
+#include <kurl.h>
+#include <kprocess.h>
+#include <util/fileops.h>
+#include "autorotatelogjob.h"
+#include "log.h"
+
+namespace bt
+{
+
+	AutoRotateLogJob::AutoRotateLogJob(const QString & file,Log* lg)
+		: KIO::Job(false),file(file),cnt(10),lg(lg)
+	{
+		update();
+	}
+
+
+	AutoRotateLogJob::~AutoRotateLogJob()
+	{}
+
+	void AutoRotateLogJob::kill(bool)
+	{
+		m_error = 0;
+		emitResult();
+	}
+		
+	void AutoRotateLogJob::update()
+	{
+		while (cnt > 1)
+		{
+			QString prev = QString("%1-%2.gz").arg(file).arg(cnt - 1);
+			QString curr = QString("%1-%2.gz").arg(file).arg(cnt);
+			if (bt::Exists(prev)) // if file exists start the move job
+			{
+				KIO::Job* sj = KIO::file_move(KURL::fromPathOrURL(prev),KURL::fromPathOrURL(curr),-1,true,false,false);
+				connect(sj,SIGNAL(result(KIO::Job*)),this,SLOT(moveJobDone(KIO::Job* )));	
+				return;
+			}
+			else
+			{
+				cnt--;
+			}
+		}
+			
+		if (cnt == 1)
+		{
+				// move current log to 1 and zip it
+			bt::Move(file,file + "-1",true);
+			KIO::Job* sj = KIO::file_move(KURL::fromPathOrURL(file),KURL::fromPathOrURL(file + "-1"),-1,true,false,false);
+			connect(sj,SIGNAL(result(KIO::Job*)),this,SLOT(moveJobDone(KIO::Job* )));
+		}
+		else
+		{
+				// final log file is moved, now zip it and end the job
+			std::system(QString("gzip " + KProcess::quote(file + "-1")).local8Bit());
+			m_error = 0;
+			lg->logRotateDone();
+			emitResult();
+		}
+	}
+		
+	
+	void AutoRotateLogJob::moveJobDone(KIO::Job*)
+	{
+		cnt--; // decrease counter so the newt file will be moved in update
+		update(); // don't care about result of job
+	}
+
+}
+#include "autorotatelogjob.moc"
diff --git a/libktorrent/util/autorotatelogjob.h b/libktorrent/util/autorotatelogjob.h
new file mode 100644
index 0000000..11cf06a
--- /dev/null
+++ b/libktorrent/util/autorotatelogjob.h
@@ -0,0 +1,59 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTAUTOROTATELOGJOB_H
+#define BTAUTOROTATELOGJOB_H
+
+#include <kio/job.h>
+#include <cstdlib>
+
+namespace bt
+{
+	class Log;
+
+	/**
+		@author Joris Guisson <joris.guisson@gmail.com>
+		
+		Job which handles the rotation of the log file. 
+		This Job must do several move jobs which must be done sequentially.
+	*/
+	class AutoRotateLogJob : public KIO::Job
+	{
+		Q_OBJECT
+	public:
+		AutoRotateLogJob(const QString & file,Log* lg);
+		virtual ~AutoRotateLogJob();
+		
+		virtual void kill(bool quietly=true);
+		
+	private slots:
+		void moveJobDone(KIO::Job*);
+		
+	private:
+		void update();
+		
+	private:
+		QString file;
+		int cnt;
+		Log* lg;
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/bitset.cpp b/libktorrent/util/bitset.cpp
new file mode 100644
index 0000000..6139e01
--- /dev/null
+++ b/libktorrent/util/bitset.cpp
@@ -0,0 +1,111 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include <algorithm>
+#include "bitset.h"
+#include <string.h>
+
+namespace bt
+{
+	BitSet BitSet::null;
+
+	BitSet::BitSet(Uint32 num_bits) : num_bits(num_bits),data(0)
+	{
+		num_bytes = (num_bits / 8) + ((num_bits % 8 > 0) ? 1 : 0);
+		data = new Uint8[num_bytes];
+		std::fill(data,data+num_bytes,0x00);
+		num_on = 0;
+	}
+
+	BitSet::BitSet(const Uint8* d,Uint32 num_bits)  : num_bits(num_bits),data(0)
+	{
+		num_bytes = (num_bits / 8) + ((num_bits % 8 > 0) ? 1 : 0);
+		data = new Uint8[num_bytes];
+		memcpy(data,d,num_bytes);
+		num_on = 0;
+		Uint32 i = 0;
+		while (i < num_bits)
+		{
+			if (get(i))
+				num_on++;
+			i++;
+		}
+	}
+	
+	BitSet::BitSet(const BitSet & bs) : num_bits(bs.num_bits),num_bytes(bs.num_bytes),data(0),num_on(bs.num_on)
+	{
+		data = new Uint8[num_bytes];
+		std::copy(bs.data,bs.data+num_bytes,data);
+	}
+			
+	BitSet::~BitSet()
+	{
+		delete [] data;
+	}
+
+	
+
+	BitSet & BitSet::operator = (const BitSet & bs)
+	{
+		if (data)
+			delete [] data;
+		num_bytes = bs.num_bytes;
+		num_bits = bs.num_bits;
+		data = new Uint8[num_bytes];
+		std::copy(bs.data,bs.data+num_bytes,data);
+		num_on = bs.num_on;
+		return *this;
+	}
+	
+	void BitSet::setAll(bool on)
+	{
+		std::fill(data,data+num_bytes,on ? 0xFF : 0x00);
+		num_on = on ? num_bits : 0;
+	}
+
+	void BitSet::clear()
+	{
+		setAll(false);
+	}
+
+	void BitSet::orBitSet(const BitSet & other)
+	{
+		Uint32 i = 0;
+		while (i < num_bits)
+		{
+			bool val = get(i) || other.get(i);
+			set(i,val);
+			i++;
+		}
+	}
+
+	bool BitSet::allOn() const
+	{
+		return num_on == num_bits;
+	}
+
+	bool BitSet::operator == (const BitSet & bs)
+	{
+		if (this->getNumBits() != bs.getNumBits())
+			return false;
+
+		return memcmp(data,bs.data,num_bytes) == 0;
+	}
+}
+
diff --git a/libktorrent/util/bitset.h b/libktorrent/util/bitset.h
new file mode 100644
index 0000000..32e7e48
--- /dev/null
+++ b/libktorrent/util/bitset.h
@@ -0,0 +1,157 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTBITSET_H
+#define BTBITSET_H
+
+#include "constants.h"
+
+namespace bt
+{
+
+	/**
+	 * @author Joris Guisson
+	 * @brief Simple implementation of a BitSet
+	 * 
+	 * Simple implementation of a BitSet, can only turn on and off bits.
+	 * BitSet's are used to indicate which chunks we have or not.
+	 */
+	class BitSet
+	{
+		Uint32 num_bits,num_bytes;
+		Uint8* data;
+		Uint32 num_on;
+	public:
+		/**
+		 * Constructor.
+		 * @param num_bits The number of bits
+		 */
+		BitSet(Uint32 num_bits = 8);
+		
+		/**
+		 * Manually set data.
+		 * @param data The data
+		 * @param num_bits The number of bits
+		 */
+		BitSet(const Uint8* data,Uint32 num_bits);
+		
+		/**
+		 * Copy constructor.
+		 * @param bs BitSet to copy
+		 * @return 
+		 */
+		BitSet(const BitSet & bs);
+		virtual ~BitSet();
+
+		/// See if the BitSet is null
+		bool isNull() const {return num_bits == 0;}
+		
+		/**
+		 * Get the value of a bit, false means 0, true 1.
+		 * @param i Index of Bit
+		 */
+		bool get(Uint32 i) const;
+		
+		/**
+		 * Set the value of a bit, false means 0, true 1.
+		 * @param i Index of Bit
+		 * @param on False means 0, true 1
+		 */
+		void set(Uint32 i,bool on);
+		
+		/// Set all bits on or off
+		void setAll(bool on);
+		
+		Uint32 getNumBytes() const {return num_bytes;}
+		Uint32 getNumBits() const {return num_bits;}
+		const Uint8* getData() const {return data;}
+		Uint8* getData() {return data;}
+
+		/// Get the number of on bits
+		Uint32 numOnBits() const {return num_on;}
+		
+		/**
+		 * Set all bits to 0
+		 */
+		void clear();
+
+		/**
+		 * or this BitSet with another.
+		 * @param other The other BitSet
+		 */
+		void orBitSet(const BitSet & other);
+		
+		/**
+		 * Assignment operator.
+		 * @param bs BitSet to copy
+		 * @return *this
+		 */
+		BitSet & operator = (const BitSet & bs);
+
+		/// Check if all bit are set to 1
+		bool allOn() const;
+
+		/**
+		 * Check for equality of bitsets
+		 * @param bs BitSet to compare
+		 * @return true if equal 
+		 */
+		bool operator == (const BitSet & bs);
+		
+		/**
+		 * Opposite of operator == 
+		 */
+		bool operator != (const BitSet & bs) {return ! operator == (bs);}
+
+		static BitSet null;
+	};
+
+	inline bool BitSet::get(Uint32 i) const
+	{
+		if (i >= num_bits)
+			return false;
+		
+		Uint32 byte = i / 8;
+		Uint32 bit = i % 8;
+		Uint8 b = data[byte] & (0x01 << (7 - bit));
+		return b != 0x00;
+	}
+	
+	inline void BitSet::set(Uint32 i,bool on)
+	{
+		if (i >= num_bits)
+			return;
+		
+		Uint32 byte = i / 8;
+		Uint32 bit = i % 8;
+		if (on && !get(i))
+		{
+			num_on++;
+			data[byte] |= (0x01 << (7 - bit));
+		}
+		else if (!on && get(i))
+		{
+			num_on--;
+			Uint8 b = (0x01 << (7 - bit));
+			data[byte] &= (~b);
+		}
+	}
+}
+
+#endif
diff --git a/libktorrent/util/constants.h b/libktorrent/util/constants.h
new file mode 100644
index 0000000..e663978
--- /dev/null
+++ b/libktorrent/util/constants.h
@@ -0,0 +1,96 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTCONSTANTS_H
+#define BTCONSTANTS_H
+
+#include <qglobal.h>
+
+namespace bt
+{
+	typedef Q_UINT64 Uint64;
+	typedef Q_UINT32 Uint32;
+	typedef Q_UINT16 Uint16;
+	typedef Q_UINT8 Uint8;
+
+	typedef Q_INT64 Int64;
+	typedef Q_INT32 Int32;
+	typedef Q_INT16 Int16;
+	typedef Q_INT8 Int8;
+	
+	typedef Uint64 TimeStamp;
+	
+	typedef enum 
+	{
+		/* These are the old values, for compatability reasons with old chunk_info files we leave them here :
+		PREVIEW_PRIORITY = 4,
+		FIRST_PRIORITY = 3,
+		NORMAL_PRIORITY = 2,
+		LAST_PRIORITY = 1,
+		EXCLUDED = 0,
+		ONLY_SEED_PRIORITY = -1
+		*/
+		// make sure new values are different from old values
+		// also leave some room if we want to add new priorities in the future
+		PREVIEW_PRIORITY = 60,
+		FIRST_PRIORITY = 50,
+		NORMAL_PRIORITY = 40,
+		LAST_PRIORITY = 30,
+		ONLY_SEED_PRIORITY = 20,
+		EXCLUDED = 10
+	}Priority;
+	
+	enum ConfirmationResult
+	{
+		KEEP_DATA,
+		THROW_AWAY_DATA,
+		CANCELED
+	};
+	
+	const Uint32 MAX_MSGLEN = 9 + 131072;
+	const Uint16 MIN_PORT = 6881;
+	const Uint16 MAX_PORT = 6889;
+	const Uint32 MAX_PIECE_LEN = 16384;
+	
+	const Uint8 CHOKE = 0;
+	const Uint8 UNCHOKE = 1;
+	const Uint8 INTERESTED = 2;
+	const Uint8 NOT_INTERESTED = 3;
+	const Uint8 HAVE = 4;
+	const Uint8 BITFIELD = 5;
+	const Uint8 REQUEST = 6;
+	const Uint8 PIECE = 7;
+	const Uint8 CANCEL = 8;
+	const Uint8 PORT = 9;
+	const Uint8 SUGGEST_PIECE = 13;
+	const Uint8 HAVE_ALL = 14;
+	const Uint8 HAVE_NONE = 15;
+	const Uint8 REJECT_REQUEST = 16;
+	const Uint8 ALLOWED_FAST = 17;
+	const Uint8 EXTENDED = 20;  // extension protocol message
+	
+	
+	// flags for things which a peer supports
+	const Uint32 DHT_SUPPORT = 0x01;
+	const Uint32 EXT_PROT_SUPPORT = 0x10;
+	const Uint32 FAST_EXT_SUPPORT = 0x04;
+}
+
+
+#endif
diff --git a/libktorrent/util/error.cpp b/libktorrent/util/error.cpp
new file mode 100644
index 0000000..bb981db
--- /dev/null
+++ b/libktorrent/util/error.cpp
@@ -0,0 +1,33 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include "error.h"
+
+namespace bt
+{
+
+	Error::Error(const QString & msg) : msg(msg)
+	{}
+
+
+	Error::~Error()
+	{}
+
+
+}
diff --git a/libktorrent/util/error.h b/libktorrent/util/error.h
new file mode 100644
index 0000000..8b089e4
--- /dev/null
+++ b/libktorrent/util/error.h
@@ -0,0 +1,44 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTERROR_H
+#define BTERROR_H
+
+#include <qstring.h>
+
+namespace bt
+{
+
+	/**
+	@author Joris Guisson
+	*/
+	class Error
+	{
+		QString msg;
+	public:
+		Error(const QString & msg);
+		virtual ~Error();
+		
+		QString toString() const {return msg;}
+
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/file.cpp b/libktorrent/util/file.cpp
new file mode 100644
index 0000000..b898e07
--- /dev/null
+++ b/libktorrent/util/file.cpp
@@ -0,0 +1,150 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <qfile.h>
+#include "config.h"
+#include <klocale.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <torrent/globals.h>
+#include "file.h"
+#include "error.h"
+#include "log.h"
+
+namespace bt
+{
+
+	File::File() : fptr(0)
+	{}
+
+
+	File::~File() 
+	{
+		close();
+	}
+	
+	bool File::open(const QString & file,const QString & mode)
+	{
+		this->file = file;
+		if (fptr)
+			close();
+#if HAVE_FOPEN64
+		fptr = fopen64(QFile::encodeName(file),mode.ascii());
+#else
+		fptr = fopen(QFile::encodeName(file),mode.ascii());
+#endif
+		return fptr != 0;
+	}
+		
+	void File::close()
+	{
+		if (fptr)
+		{
+			fclose(fptr);
+			fptr = 0;
+		}
+	}
+	
+	void File::flush()
+	{
+		if (fptr)
+			fflush(fptr);
+	}
+
+	Uint32 File::write(const void* buf,Uint32 size)
+	{
+		if (!fptr)
+			return 0;
+
+		Uint32 ret = fwrite(buf,1,size,fptr);
+		if (ret != size)
+		{
+			if (errno == ENOSPC)
+				Out() << "Disk full !" << endl;
+			
+			throw Error(i18n("Cannot write to %1 : %2").arg(file).arg(strerror(errno)));
+		}
+		return ret;
+	}
+	
+	Uint32 File::read(void* buf,Uint32 size)
+	{
+		if (!fptr)
+			return 0;
+
+		Uint32 ret = fread(buf,1,size,fptr);
+		if (ferror(fptr))
+		{
+			clearerr(fptr);
+			throw Error(i18n("Cannot read from %1").arg(file));
+		}
+		return ret;
+	}
+
+	Uint64 File::seek(SeekPos from,Int64 num)
+	{
+	//	printf("sizeof(off_t) = %i\n",sizeof(__off64_t));
+		if (!fptr)
+			return 0;
+		
+		int p = SEEK_CUR; // use a default to prevent compiler warning
+		switch (from)
+		{
+			case BEGIN : p = SEEK_SET; break;
+			case END : p = SEEK_END; break;
+			case CURRENT : p = SEEK_CUR; break;
+			default:
+				break;
+		}
+#if HAVE_FSEEKO64
+		fseeko64(fptr,num,p);
+		return ftello64(fptr);
+#else
+		fseeko(fptr,num,p);
+		return ftello(fptr);
+#endif
+	}
+
+	bool File::eof() const
+	{
+		if (!fptr)
+			return true;
+		
+		return feof(fptr) != 0;
+	}
+
+	Uint64 File::tell() const
+	{
+		if (!fptr)
+			return 0;
+		
+		return ftello(fptr);
+	}
+
+	QString File::errorString() const
+	{
+		return QString(strerror(errno));
+	}
+}
diff --git a/libktorrent/util/file.h b/libktorrent/util/file.h
new file mode 100644
index 0000000..323a3a7
--- /dev/null
+++ b/libktorrent/util/file.h
@@ -0,0 +1,114 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTFILE_H
+#define BTFILE_H
+
+#include <stdio.h>
+#include <qstring.h>
+#include "constants.h"
+
+namespace bt
+{
+
+	/**
+	 * @author Joris Guisson
+	 * @brief Wrapper class for stdio's FILE
+	 *
+	 * Wrapper class for stdio's FILE.
+	 */
+	class File
+	{
+		FILE* fptr;
+		QString file;
+	public:
+		/**
+		 * Constructor.
+		 */
+		File();
+		
+		/**
+		 * Destructor, closes the file.
+		 */
+		virtual ~File();
+
+		/**
+		 * Open the file similar to fopen
+		 * @param file Filename
+		 * @param mode Mode
+		 * @return true upon succes
+		 */
+		bool open(const QString & file,const QString & mode);
+		
+		/**
+		 * Close the file.
+		 */
+		void close();
+		
+		/**
+		 * Flush the file.
+		 */
+		void flush();
+		
+		/**
+		 * Write a bunch of data. If anything goes wrong
+		 * an Error will be thrown.
+		 * @param buf The data
+		 * @param size Size of the data
+		 * @return The number of bytes written
+		 */
+		Uint32 write(const void* buf,Uint32 size);
+		
+		/**
+		 * Read a bunch of data. If anything goes wrong
+		 * an Error will be thrown.
+		 * @param buf The buffer to store the data
+		 * @param size Size of the buffer
+		 * @return The number of bytes read
+		 */
+		Uint32 read(void* buf,Uint32 size);
+
+		enum SeekPos
+		{
+			BEGIN,
+			END,
+			CURRENT
+		};
+		
+		/**
+		 * Seek in the file.
+		 * @param from Position to seek from
+		 * @param num Number of bytes to move
+		 * @return New position
+		 */
+		Uint64 seek(SeekPos from,Int64 num);
+
+		/// Check to see if we are at the end of the file.
+		bool eof() const;
+
+		/// Get the current position in the file.
+		Uint64 tell() const;
+
+		/// Get the error string.
+		QString errorString() const;
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/fileops.cpp b/libktorrent/util/fileops.cpp
new file mode 100644
index 0000000..3fcf03d
--- /dev/null
+++ b/libktorrent/util/fileops.cpp
@@ -0,0 +1,466 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <klocale.h>
+#include <kio/netaccess.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <qdir.h>
+#include <qfile.h>
+#include <qstringlist.h>
+#include "fileops.h"
+#include "error.h"
+#include "log.h"
+#include <torrent/globals.h>
+#include "file.h"
+#include "array.h"
+
+#ifdef HAVE_XFS_XFS_H
+
+#if !defined(HAVE___S64) || !defined(HAVE___U64)
+#include <stdint.h>
+#endif
+
+#ifndef HAVE___U64
+typedef	uint64_t	__u64;
+#endif
+
+#ifndef HAVE___S64
+typedef	int64_t		__s64;
+#endif
+
+#include <xfs/xfs.h>
+#endif
+
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0
+#endif
+
+#if HAVE_STATVFS
+#include <sys/statvfs.h>
+#else
+#include <sys/param.h>
+#include <sys/mount.h>
+#endif
+
+namespace bt
+{
+	void MakeDir(const QString & dir,bool nothrow)
+	{
+		if (mkdir(QFile::encodeName(dir),0777) < -1)
+		{
+			if (!nothrow)
+				throw Error(i18n("Cannot create directory %1: %2")
+					.arg(dir).arg(strerror(errno)));
+			else
+			{
+				Out() << QString("Error : Cannot create directory %1 : %2").arg(dir).arg(strerror(errno))<< endl;
+			}
+		}
+	}
+	
+	void SymLink(const QString & link_to,const QString & link_url,bool nothrow)
+	{
+		if (symlink(QFile::encodeName(link_to),QFile::encodeName(link_url)) != 0)
+		{
+			if (!nothrow)
+				throw Error(i18n("Cannot symlink %1 to %2: %3")
+					.arg(link_url.utf8()).arg(link_to.utf8())
+					.arg(strerror(errno)));
+			else
+				Out() << QString("Error : Cannot symlink %1 to %2: %3")
+						.arg(link_url.utf8()).arg(link_to.utf8())
+				.arg(strerror(errno)) << endl;
+		}
+	}
+
+	void Move(const QString & src,const QString & dst,bool nothrow)
+	{
+	//	Out() << "Moving " << src << " -> " << dst << endl;
+		if (!KIO::NetAccess::move(KURL::fromPathOrURL(src),KURL::fromPathOrURL(dst),0))
+		{
+			if (!nothrow)
+				throw Error(i18n("Cannot move %1 to %2: %3")
+					.arg(src).arg(dst)
+						.arg(KIO::NetAccess::lastErrorString()));
+			else
+				Out() << QString("Error : Cannot move %1 to %2: %3")
+						.arg(src).arg(dst)
+						.arg(KIO::NetAccess::lastErrorString()) << endl;
+		
+		}
+	}
+
+	void CopyFile(const QString & src,const QString & dst,bool nothrow)
+	{
+		if (!KIO::NetAccess::file_copy(KURL::fromPathOrURL(src),KURL::fromPathOrURL(dst)))
+		{
+			if (!nothrow)
+				throw Error(i18n("Cannot copy %1 to %2: %3")
+						.arg(src).arg(dst)
+						.arg(KIO::NetAccess::lastErrorString()));
+			else
+				Out() << QString("Error : Cannot copy %1 to %2: %3")
+						.arg(src).arg(dst)
+						.arg(KIO::NetAccess::lastErrorString()) << endl;
+	
+		}
+	}
+	
+	void CopyDir(const QString & src,const QString & dst,bool nothrow)
+	{
+		if (!KIO::NetAccess::dircopy(KURL::fromPathOrURL(src),KURL::fromPathOrURL(dst),0))
+		{
+			if (!nothrow)
+				throw Error(i18n("Cannot copy %1 to %2: %3")
+						.arg(src).arg(dst)
+						.arg(KIO::NetAccess::lastErrorString()));
+			else
+				Out() << QString("Error : Cannot copy %1 to %2: %3")
+						.arg(src).arg(dst)
+						.arg(KIO::NetAccess::lastErrorString()) << endl;
+	
+		}
+	}
+
+	bool Exists(const QString & url)
+	{
+	//	Out() << "Testing if " << url << " exists " << endl;
+		if (access(QFile::encodeName(url),F_OK) < 0)
+		{
+	//		Out() << "No " << endl;
+			return false;
+		}
+		else
+		{
+	//		Out() << "Yes " << endl;
+			return true;
+		}
+	}
+	
+	static bool DelDir(const QString & fn)
+	{
+		QDir d(fn);
+		QStringList subdirs = d.entryList(QDir::Dirs);
+		
+		for (QStringList::iterator i = subdirs.begin(); i != subdirs.end();i++)
+		{
+			QString entry = *i;
+
+			if (entry == ".." || entry == ".")
+				continue;
+			
+			if (!DelDir(d.absFilePath(entry)))
+			{
+				Out(SYS_GEN|LOG_DEBUG) << "Delete of " << fn << "/" << entry << " failed !" << endl;
+				return false;	
+			}
+		}
+		
+		QStringList files = d.entryList(QDir::Files | QDir::System | QDir::Hidden);
+		for (QStringList::iterator i = files.begin(); i != files.end();i++)
+		{
+			QString entry = *i;
+
+			if (remove(QFile::encodeName(d.absFilePath(entry))) < 0)
+			{
+				Out(SYS_GEN|LOG_DEBUG) << "Delete of " << fn << "/" << entry << " failed !" << endl;
+				return false;	
+			}
+		}
+		
+		if (!d.rmdir(d.absPath()))
+		{
+			Out(SYS_GEN|LOG_DEBUG) << "Failed to remove " << d.absPath() << endl;
+			return false;
+		}
+		
+		return true;
+	}
+
+	void Delete(const QString & url,bool nothrow)
+	{
+		QCString fn = QFile::encodeName(url);
+#if HAVE_STAT64
+		struct stat64 statbuf;
+		if (lstat64(fn, &statbuf) < 0)
+			return;
+#else
+		struct stat statbuf;
+		if (lstat(fn, &statbuf) < 0)
+			return;
+#endif
+		
+		bool ok = true;
+		// first see if it is a directory
+		if (S_ISDIR(statbuf.st_mode)) 
+		{
+			ok = DelDir(url);
+		}
+		else
+		{
+			ok = remove(fn) >= 0;
+		}
+		
+		if (!ok)
+		{
+			QString err = i18n("Cannot delete %1: %2")
+					.arg(url)
+					.arg(strerror(errno));
+			if (!nothrow)
+				throw Error(err);
+			else
+				Out() << "Error : " << err << endl;
+		}
+	}
+
+	void Touch(const QString & url,bool nothrow)
+	{
+		if (Exists(url))
+			return;
+		
+		File fptr;
+		if (!fptr.open(url,"wb"))
+		{
+			if (!nothrow)
+				throw Error(i18n("Cannot create %1: %2")
+						.arg(url)
+						.arg(fptr.errorString()));
+			else
+				Out() << "Error : Cannot create " << url << " : "
+						<< fptr.errorString() << endl;
+		
+		}
+	}
+	
+	Uint64 FileSize(const QString & url)
+	{
+		int ret = 0;
+#if HAVE_STAT64
+		struct stat64 sb;
+		ret = stat64(QFile::encodeName(url),&sb);
+#else
+		struct stat sb;
+		ret = stat(QFile::encodeName(url),&sb);
+#endif
+		if (ret < 0)
+			throw Error(i18n("Cannot calculate the filesize of %1: %2")
+					.arg(url).arg(strerror(errno)));
+		
+		return (Uint64)sb.st_size;
+	}
+	
+	Uint64 FileSize(int fd)
+	{
+		int ret = 0;
+#if HAVE_STAT64
+		struct stat64 sb;
+		ret = fstat64(fd,&sb);
+#else
+		struct stat sb;
+		ret = fstat(fd,&sb);
+#endif
+		if (ret < 0)
+			throw Error(i18n("Cannot calculate the filesize : %2").arg(strerror(errno)));
+		
+		return (Uint64)sb.st_size;
+	}
+
+	bool FatPreallocate(int fd,Uint64 size)
+	{
+		try
+		{
+			SeekFile(fd, size - 1, SEEK_SET);
+			char zero = 0;		
+			if (write(fd, &zero, 1) == -1)
+				return false;
+				
+			TruncateFile(fd,size,true);
+		}
+		catch (bt::Error & e)
+		{
+			Out() << e.toString() << endl;
+			return false;
+		}
+		return true;
+	}
+	
+	bool FatPreallocate(const QString & path,Uint64 size)
+	{
+		int fd = ::open(QFile::encodeName(path),O_RDWR | O_LARGEFILE);
+		if (fd < 0)
+			throw Error(i18n("Cannot open %1 : %2").arg(path).arg(strerror(errno)));
+		
+		bool ret = FatPreallocate(fd,size);
+		close(fd);
+		return ret;
+	}
+
+#ifdef HAVE_XFS_XFS_H
+	
+	bool XfsPreallocate(int fd, Uint64 size)
+	{
+		if( ! platform_test_xfs_fd(fd) )
+		{
+			return false;
+		}
+		
+		xfs_flock64_t allocopt;
+		allocopt.l_whence = 0;
+		allocopt.l_start = 0;
+		allocopt.l_len  = size;
+		
+		return (! static_cast<bool>(xfsctl(0, fd, XFS_IOC_RESVSP64, &allocopt)) );
+		
+	}
+	
+	bool XfsPreallocate(const QString & path, Uint64 size)
+	{
+		int fd = ::open(QFile::encodeName(path), O_RDWR | O_LARGEFILE);
+		if (fd < 0)
+			throw Error(i18n("Cannot open %1 : %2").arg(path).arg(strerror(errno)));
+		
+		bool ret = XfsPreallocate(fd,size);
+		close(fd);
+		return ret;
+	}
+
+#endif
+
+	void TruncateFile(int fd,Uint64 size,bool quick)
+	{
+		if (FileSize(fd) == size)
+			return;
+		
+		if (quick)
+		{
+#if HAVE_FTRUNCATE64
+			if (ftruncate64(fd,size) == -1)
+#else
+			if (ftruncate(fd,size) == -1)
+#endif	
+				throw Error(i18n("Cannot expand file : %1").arg(strerror(errno)));
+		}
+		else
+		{
+#if HAVE_POSIX_FALLOCATE64
+			if (posix_fallocate64(fd,0,size) != 0)
+				throw Error(i18n("Cannot expand file : %1").arg(strerror(errno)));
+#elif HAVE_POSIX_FALLOCATE
+			if (posix_fallocate(fd,0,size) != 0)
+				throw Error(i18n("Cannot expand file : %1").arg(strerror(errno)));
+#else
+			SeekFile(fd,0,SEEK_SET);
+			bt::Array<Uint8> buf(4096);
+			buf.fill(0);
+	
+			Uint64 written = 0;
+			while (written < size)
+			{
+				int to_write = size - written;
+				if (to_write > 4096)
+					to_write = 4096;
+				
+				int ret = write(fd,buf,to_write);
+				if (ret < 0)
+					throw Error(i18n("Cannot expand file : %1").arg(strerror(errno)));
+				else if (ret == 0 || ret != (int)to_write)
+					throw Error(i18n("Cannot expand file").arg(strerror(errno)));
+				else
+					written += to_write;
+			}
+#endif
+		}
+	}
+	
+	void TruncateFile(const QString & path,Uint64 size)
+	{
+		int fd = ::open(QFile::encodeName(path),O_RDWR | O_LARGEFILE);
+		if (fd < 0)
+			throw Error(i18n("Cannot open %1 : %2").arg(path).arg(strerror(errno)));
+		
+		try
+		{
+			TruncateFile(fd,size,true);
+			close(fd);
+		}
+		catch (...)
+		{
+			close(fd);
+			throw;
+		}
+	}
+	
+	void SeekFile(int fd,Int64 off,int whence)
+	{
+#if HAVE_LSEEK64
+		if (lseek64(fd,off,whence) == -1)
+#else
+		if (lseek(fd,off,whence) == -1)
+#endif
+			throw Error(i18n("Cannot seek in file : %1").arg(strerror(errno)));
+	}
+	
+	bool FreeDiskSpace(const QString & path,Uint64 & bytes_free)
+	{
+#if HAVE_STATVFS
+#if HAVE_STATVFS64
+		struct statvfs64 stfs;
+		if (statvfs64(path.local8Bit(), &stfs) == 0)
+#else
+		struct statvfs stfs;
+		if (statvfs(path.local8Bit(), &stfs) == 0)
+#endif
+		{
+			bytes_free = ((Uint64)stfs.f_bavail) * ((Uint64)stfs.f_frsize);
+			return true;
+		}
+		else
+		{
+			Out(SYS_GEN|LOG_DEBUG) << "Error : statvfs for " << path << " failed :  "
+						<< QString(strerror(errno)) << endl;
+
+			return false;
+		}
+#else
+		struct statfs stfs;
+		if (statfs(path.local8Bit(), &stfs) == 0)
+		{
+			bytes_free = ((Uint64)stfs.f_bavail) * ((Uint64)stfs.f_bsize);
+			return true;
+		}
+		else
+		{
+			Out(SYS_GEN|LOG_DEBUG) << "Error : statfs for " << path << " failed :  "
+						<< QString(strerror(errno)) << endl;
+
+			return false;
+		}
+#endif
+	}
+}
diff --git a/libktorrent/util/fileops.h b/libktorrent/util/fileops.h
new file mode 100644
index 0000000..253ee96
--- /dev/null
+++ b/libktorrent/util/fileops.h
@@ -0,0 +1,165 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTFILEOPS_H
+#define BTFILEOPS_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <util/constants.h>
+class QString;
+
+namespace bt
+{
+
+	/**
+	 * Creates a directory. Convenience function around
+	 * KIO::NetAccess::mkdir .
+	 * @param dir The url of the dir
+	 * @param nothrow wether or not we shouldn't throw an Error upon failure
+	 * @throw Error upon error
+	 */
+	void MakeDir(const QString & dir,bool nothrow = false);
+
+	/**
+	 * Create a symbolic link @a link_url which links to @a link_to 
+	 * @param link_to The file to link to
+	 * @param link_url The link url
+	 * @param nothrow wether or not we shouldn't throw an Error upon failure
+	 */
+	void SymLink(const QString & link_to,const QString & link_url,bool nothrow = false);
+
+	/**
+	 * Move a file/dir from one location to another
+	 * @param src The source file
+	 * @param dst The destination file / directory
+	 * @param nothrow wether or not we shouldn't throw an Error upon failure
+	 */
+	void Move(const QString & src,const QString & dst,bool nothrow = false);
+
+	/**
+	 * Copy a file.
+	 * @param src The source file
+	 * @param dst The destination dir/file
+	 * @param nothrow wether or not we shouldn't throw an Error upon failure
+	 */
+	void CopyFile(const QString & src,const QString & dst,bool nothrow = false);
+	
+	/**
+	 * Copy a file or directory
+	 * @param src The source file
+	 * @param dst The destination dir/file
+	 * @param nothrow wether or not we shouldn't throw an Error upon failure
+	 */
+	void CopyDir(const QString & src,const QString & dst,bool nothrow = false);
+	
+	/**
+	 * Check wether a file/dir exists
+	 * @param url The file/dir
+	 * @return true if it exits
+	 */
+	bool Exists(const QString & url);
+
+	/**
+	 * Delete a file or directory.
+	 * @param url The url of the file/dir
+	 * @param nothrow wether or not we shouldn't throw an Error upon failure
+	 */
+	void Delete(const QString & url,bool nothrow = false);
+
+	/**
+	 * Try to create a file. Doesn't do anything if the file
+	 * already exists.
+	 * @param url The url of the file
+	 * @param nothrow wether or not we shouldn't throw an Error upon failure
+	 */
+	void Touch(const QString & url,bool nothrow = false);
+	
+	/**
+	 * Calculates the size of a file
+	 * @param url Name of the file
+	 * @return The size of the file
+	 * @throw Error if the file doesn't exist, or something else goes wrong
+	 */
+	Uint64 FileSize(const QString & url);
+	
+	/**
+	 * Get the size of a file.
+	 * @param fd The file descriptor of the file
+	 * @return The size
+	 * @throw Error if the file doesn't exist, or something else goes wrong
+	 */
+	Uint64 FileSize(int fd);
+	
+	/**
+	 * Truncate a file (wrapper around ftruncate)
+	 * @param fd The file descriptor of the file
+	 * @param size The size to truncate to
+	 * @throw Error if the file doesn't exist, or something else goes wrong
+	 */
+	void TruncateFile(int fd,Uint64 size,bool quick);
+	
+	/**
+	 * Truncate a file (wrapper around ftruncate)
+	 * @param fd Path of the file
+	 * @param size The size to truncate to
+	 * @param quick Use the quick way (doesn't prevent fragmentationt)
+	 * @throw Error if the file doesn't exist, or something else goes wrong
+	 */
+	void TruncateFile(const QString & path,Uint64 size);
+	
+	/**
+	 * Special truncate for FAT file systems.
+	*/
+	bool FatPreallocate(int fd,Uint64 size);
+	
+	/**
+	 * Special truncate for FAT file systems.
+	 */
+	bool FatPreallocate(const QString & path,Uint64 size);
+
+#ifdef HAVE_XFS_XFS_H
+	/**
+	 * Special truncate for XFS file systems.
+	*/
+	bool XfsPreallocate(int fd,Uint64 size);
+	
+	/**
+	 * Special truncate for XFS file systems.
+	 */
+	bool XfsPreallocate(const QString & path,Uint64 size);
+
+#endif
+
+	/**
+	 * Seek in a file, wrapper around lseek
+	 * @param fd The file descriptor
+	 * @param off Offset
+	 * @param whence Position to seek from
+	 * @throw Error if something else goes wrong
+	 */
+	void SeekFile(int fd,Int64 off,int whence);
+
+	/// Calculate the number of bytes free on the filesystem path is located
+	bool FreeDiskSpace(const QString & path,Uint64 & bytes_free);
+}
+
+#endif
diff --git a/libktorrent/util/functions.cpp b/libktorrent/util/functions.cpp
new file mode 100644
index 0000000..744bf43
--- /dev/null
+++ b/libktorrent/util/functions.cpp
@@ -0,0 +1,239 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include <qdir.h>
+#include <qhostaddress.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <kio/netaccess.h>
+#include <klocale.h>
+#include <kmimetype.h>
+#include <kglobal.h>
+#include "functions.h"
+#include "error.h"
+#include "log.h"
+
+namespace bt
+{
+
+	bool IsMultimediaFile(const QString & filename)
+	{
+		KMimeType::Ptr ptr = KMimeType::findByPath(filename);
+		QString name = ptr->name();
+		return name.startsWith("audio") || name.startsWith("video") || name == "application/ogg";
+	}
+	
+	QHostAddress LookUpHost(const QString & host)
+	{
+		struct hostent * he = gethostbyname(host.ascii());
+		QHostAddress addr;
+		if (he)
+		{
+			addr.setAddress(inet_ntoa(*((struct in_addr *)he->h_addr)));
+		}
+		return addr;
+	}
+
+	QString DirSeparator()
+	{
+		QString tmp;
+		tmp.append(QDir::separator());
+		return tmp;
+	}
+
+	void WriteUint64(Uint8* buf,Uint32 off,Uint64 val)
+	{
+		buf[off + 0] = (Uint8) ((val & 0xFF00000000000000ULL) >> 56);
+		buf[off + 1] = (Uint8) ((val & 0x00FF000000000000ULL) >> 48);
+		buf[off + 2] = (Uint8) ((val & 0x0000FF0000000000ULL) >> 40);
+		buf[off + 3] = (Uint8) ((val & 0x000000FF00000000ULL) >> 32);
+		buf[off + 4] = (Uint8) ((val & 0x00000000FF000000ULL) >> 24);
+		buf[off + 5] = (Uint8) ((val & 0x0000000000FF0000ULL) >> 16);
+		buf[off + 6] = (Uint8) ((val & 0x000000000000FF00ULL) >> 8);
+		buf[off + 7] = (Uint8) ((val & 0x00000000000000FFULL) >> 0);
+	}
+	
+	Uint64 ReadUint64(const Uint8* buf,Uint64 off)
+	{
+		Uint64 tmp =
+				((Uint64)buf[off] << 56) |
+				((Uint64)buf[off+1] << 48) |
+				((Uint64)buf[off+2] << 40) |
+				((Uint64)buf[off+3] << 32) |
+				((Uint64)buf[off+4] << 24) |
+				((Uint64)buf[off+5] << 16) |
+				((Uint64)buf[off+6] << 8) |
+				((Uint64)buf[off+7] << 0);
+
+		return tmp;
+	}
+
+	void WriteUint32(Uint8* buf,Uint32 off,Uint32 val)
+	{
+		buf[off + 0] = (Uint8) ((val & 0xFF000000) >> 24);
+		buf[off + 1] = (Uint8) ((val & 0x00FF0000) >> 16);
+		buf[off + 2] = (Uint8) ((val & 0x0000FF00) >> 8);
+		buf[off + 3] = (Uint8) (val & 0x000000FF);
+	}
+	
+	Uint32 ReadUint32(const Uint8* buf,Uint32 off)
+	{
+		return (buf[off] << 24) | (buf[off+1] << 16) | (buf[off+2] << 8) | buf[off + 3];
+	}
+	
+	void WriteUint16(Uint8* buf,Uint32 off,Uint16 val)
+	{
+		buf[off + 0] = (Uint8) ((val & 0xFF00) >> 8);
+		buf[off + 1] = (Uint8) (val & 0x000FF);
+	}
+
+	Uint16 ReadUint16(const Uint8* buf,Uint32 off)
+	{
+		return (buf[off] << 8) | buf[off + 1];
+	}
+	
+	
+	void WriteInt64(Uint8* buf,Uint32 off,Int64 val)
+	{
+		buf[off + 0] = (Uint8) ((val & 0xFF00000000000000ULL) >> 56);
+		buf[off + 1] = (Uint8) ((val & 0x00FF000000000000ULL) >> 48);
+		buf[off + 2] = (Uint8) ((val & 0x0000FF0000000000ULL) >> 40);
+		buf[off + 3] = (Uint8) ((val & 0x000000FF00000000ULL) >> 32);
+		buf[off + 4] = (Uint8) ((val & 0x00000000FF000000ULL) >> 24);
+		buf[off + 5] = (Uint8) ((val & 0x0000000000FF0000ULL) >> 16);
+		buf[off + 6] = (Uint8) ((val & 0x000000000000FF00ULL) >> 8);
+		buf[off + 7] = (Uint8) ((val & 0x00000000000000FFULL) >> 0);
+	}
+	
+	Int64 ReadInt64(const Uint8* buf,Uint32 off)
+	{
+		Int64 tmp =
+				((Int64)buf[off] << 56) |
+				((Int64)buf[off+1] << 48) |
+				((Int64)buf[off+2] << 40) |
+				((Int64)buf[off+3] << 32) |
+				((Int64)buf[off+4] << 24) |
+				((Int64)buf[off+5] << 16) |
+				((Int64)buf[off+6] << 8) |
+				((Int64)buf[off+7] << 0);
+
+		return tmp;
+	}
+	
+	void WriteInt32(Uint8* buf,Uint32 off,Int32 val)
+	{
+		buf[off + 0] = (Uint8) ((val & 0xFF000000) >> 24);
+		buf[off + 1] = (Uint8) ((val & 0x00FF0000) >> 16);
+		buf[off + 2] = (Uint8) ((val & 0x0000FF00) >> 8);
+		buf[off + 3] = (Uint8) (val & 0x000000FF);
+	}
+	
+	Int32 ReadInt32(const Uint8* buf,Uint32 off)
+	{
+		return (Int32)(buf[off] << 24) | (buf[off+1] << 16) | (buf[off+2] << 8) | buf[off + 3];
+	}
+	
+	void WriteInt16(Uint8* buf,Uint32 off,Int16 val)
+	{
+		buf[off + 0] = (Uint8) ((val & 0xFF00) >> 8);
+		buf[off + 1] = (Uint8) (val & 0x000FF);
+	}
+	
+	Int16 ReadInt16(const Uint8* buf,Uint32 off)
+	{
+		return (Int16)(buf[off] << 8) | buf[off + 1];
+	}
+	
+	void UpdateCurrentTime()
+	{
+		global_time_stamp = Now();
+	}
+	
+	TimeStamp global_time_stamp = 0;
+	
+	Uint64 Now()
+	{
+		struct timeval tv;
+		gettimeofday(&tv,0);
+		global_time_stamp = (Uint64)tv.tv_sec * 1000 + (Uint64)tv.tv_usec * 0.001;
+		return global_time_stamp;
+	}
+	
+	Uint32 MaxOpenFiles()
+	{
+		struct rlimit lim;
+		getrlimit(RLIMIT_NOFILE,&lim);
+		return lim.rlim_cur;
+	}
+
+	bool MaximizeLimits()
+	{
+		// first get the current limits
+		struct rlimit lim;
+		getrlimit(RLIMIT_NOFILE,&lim);
+		
+		if (lim.rlim_cur != lim.rlim_max)
+		{
+			Out(SYS_GEN|LOG_DEBUG) << "Current limit for number of files : " << lim.rlim_cur 
+					<< " (" << lim.rlim_max << " max)" << endl;
+			lim.rlim_cur = lim.rlim_max;
+			if (setrlimit(RLIMIT_NOFILE,&lim) < 0)
+			{
+				Out(SYS_GEN|LOG_DEBUG) << "Failed to maximize file limit : " 
+						<< QString(strerror(errno)) << endl;
+				return false;
+			}
+		}
+		else
+		{
+			Out(SYS_GEN|LOG_DEBUG) << "File limit allready at maximum " << endl;
+		}
+		
+		getrlimit(RLIMIT_DATA,&lim);
+		if (lim.rlim_cur != lim.rlim_max)
+		{
+			Out(SYS_GEN|LOG_DEBUG) << "Current limit for data size : " << lim.rlim_cur 
+					<< " (" << 	lim.rlim_max << " max)" << endl;
+			lim.rlim_cur = lim.rlim_max;
+			if (setrlimit(RLIMIT_DATA,&lim) < 0)
+			{
+				Out(SYS_GEN|LOG_DEBUG) << "Failed to maximize data limit : " 
+						<< QString(strerror(errno)) << endl;
+				return false;
+			}
+		}
+		else
+		{
+			Out(SYS_GEN|LOG_DEBUG) << "Data limit allready at maximum " << endl;
+		}
+		
+		return true;
+	}
+
+
+	
+
+}
diff --git a/libktorrent/util/functions.h b/libktorrent/util/functions.h
new file mode 100644
index 0000000..4ace51b
--- /dev/null
+++ b/libktorrent/util/functions.h
@@ -0,0 +1,72 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTFUNCTIONS_H
+#define BTFUNCTIONS_H
+
+#include "constants.h"
+
+class QString;
+class QHostAddress;
+class KURL;
+
+namespace bt
+{
+
+	void WriteUint64(Uint8* buf,Uint32 off,Uint64 val);
+	Uint64 ReadUint64(const Uint8* buf,Uint64 off);
+	
+	void WriteUint32(Uint8* buf,Uint32 off,Uint32 val);
+	Uint32 ReadUint32(const Uint8* buf,Uint32 off);
+	
+	void WriteUint16(Uint8* buf,Uint32 off,Uint16 val);
+	Uint16 ReadUint16(const Uint8* buf,Uint32 off);
+
+	
+	void WriteInt64(Uint8* buf,Uint32 off,Int64 val);
+	Int64 ReadInt64(const Uint8* buf,Uint32 off);
+	
+	void WriteInt32(Uint8* buf,Uint32 off,Int32 val);
+	Int32 ReadInt32(const Uint8* buf,Uint32 off);
+	
+	void WriteInt16(Uint8* buf,Uint32 off,Int16 val);
+	Int16 ReadInt16(const Uint8* buf,Uint32 off);
+	
+	void UpdateCurrentTime();
+	
+	extern TimeStamp global_time_stamp;
+	
+	inline TimeStamp GetCurrentTime() {return global_time_stamp;}
+	
+	TimeStamp Now();
+	
+	QHostAddress LookUpHost(const QString & host);
+	QString DirSeparator();
+	bool IsMultimediaFile(const QString & filename);
+
+	/**
+	 * Maximize the file and memory limits using setrlimit.
+	 */
+	bool MaximizeLimits();
+	
+	/// Get the maximum number of open files
+	Uint32 MaxOpenFiles();
+}
+
+#endif
diff --git a/libktorrent/util/httprequest.cpp b/libktorrent/util/httprequest.cpp
new file mode 100644
index 0000000..d0652bc
--- /dev/null
+++ b/libktorrent/util/httprequest.cpp
@@ -0,0 +1,122 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include <qstringlist.h>
+#include <torrent/globals.h>
+#include "httprequest.h"
+#include "array.h"
+#include "log.h"
+
+
+namespace bt 
+{
+
+	HTTPRequest::HTTPRequest(const QString & hdr,const QString & payload,const QString & host,Uint16 port,bool verbose) : hdr(hdr),payload(payload),verbose(verbose)
+	{
+		sock = new KNetwork::KStreamSocket(host,QString::number(port),this,0);
+		sock->enableRead(true);
+		sock->enableWrite(true);
+		sock->setTimeout(30000);
+		sock->setBlocking(false);
+		connect(sock,SIGNAL(readyRead()),this,SLOT(onReadyRead()));
+		connect(sock,SIGNAL(gotError(int)),this,SLOT(onError(int )));
+		connect(sock,SIGNAL(timedOut()),this,SLOT(onTimeout()));
+		connect(sock,SIGNAL(connected(const KResolverEntry&)),
+				this, SLOT(onConnect( const KResolverEntry& )));
+	}
+	
+	
+	HTTPRequest::~HTTPRequest()
+	{
+		sock->close();
+		delete sock;
+	}
+	
+	void HTTPRequest::start()
+	{
+		sock->connect();
+	}
+	
+	void HTTPRequest::onConnect(const KResolverEntry&)
+	{
+		payload = payload.replace("$LOCAL_IP",sock->localAddress().nodeName());
+		hdr = hdr.replace("$CONTENT_LENGTH",QString::number(payload.length()));
+			
+		QString req = hdr + payload;
+		if (verbose)
+		{
+			Out(SYS_PNP|LOG_DEBUG) << "Sending " << endl;
+			Out(SYS_PNP|LOG_DEBUG) << hdr << payload << endl;
+		}
+		sock->writeBlock(req.ascii(),req.length());
+	}
+	
+	void HTTPRequest::onReadyRead()
+	{
+		Uint32 ba = sock->bytesAvailable();
+		if (ba == 0)
+		{
+			error(this,false);
+			sock->close();
+			return;
+		}
+			
+		Array<char> data(ba);
+		ba = sock->readBlock(data,ba);
+		QString strdata((const char*)data);
+		QStringList sl = QStringList::split("\r\n",strdata,false);	
+		
+		if (verbose)
+		{
+			Out(SYS_PNP|LOG_DEBUG) << "Got reply : " << endl;
+			Out(SYS_PNP|LOG_DEBUG) << strdata << endl;
+		}
+		
+		if (sl.first().contains("HTTP") && sl.first().contains("200"))
+		{
+			// emit reply OK
+			replyOK(this,sl.last());
+		}
+		else
+		{
+			// emit reply error
+			replyError(this,sl.last());
+		}
+		operationFinished(this);
+	}
+	
+	void HTTPRequest::onError(int)
+	{
+		Out() << "HTTPRequest error : " << sock->errorString() << endl;
+		error(this,false);
+		sock->close();
+		operationFinished(this);
+	}
+	
+	void HTTPRequest::onTimeout()
+	{
+		Out() << "HTTPRequest timeout" << endl;
+		error(this,true);
+		sock->close();
+		operationFinished(this);
+	}
+
+
+}
+#include "httprequest.moc"
diff --git a/libktorrent/util/httprequest.h b/libktorrent/util/httprequest.h
new file mode 100644
index 0000000..348a84e
--- /dev/null
+++ b/libktorrent/util/httprequest.h
@@ -0,0 +1,98 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTHTTPREQUEST_H
+#define BTHTTPREQUEST_H
+
+#include <qobject.h>
+#include <kurl.h>
+#include <kstreamsocket.h>
+#include <interfaces/exitoperation.h>
+#include "constants.h"
+
+using KNetwork::KResolverEntry;
+
+namespace bt 
+{
+	
+	/**
+	 * @author Joris Guisson
+	 * 
+	 * Just create one, fill in the fields,
+	 * connect to the right signals and forget about it. After the reply has been received or
+	 * an error occurred, the appropriate signal will be emitted.
+	*/
+	class HTTPRequest : public kt::ExitOperation
+	{
+		Q_OBJECT
+	public:
+		/**
+		 * Constructor, set the url and the request header.
+		 * @param hdr The http request header
+		 * @param payload The payload
+		 * @param host The host
+		 * @param port THe port
+		 * @param verbose Print traffic to the log
+		 */
+		HTTPRequest(const QString & hdr,const QString & payload,const QString & host,
+					Uint16 port,bool verbose);
+		virtual ~HTTPRequest();
+		
+		/**
+		 * Open a connetion and send the request.
+		 */
+		void start();
+		
+	signals:
+		/**
+		 * An OK reply was sent.
+	     * @param r The sender of the request
+		 * @param data The data of the reply
+		 */
+		void replyOK(bt::HTTPRequest* r,const QString & data);
+		
+		/**
+		 * Anything else but an 200 OK was sent.
+		 * @param r The sender of the request
+		 * @param data The data of the reply
+		 */
+		void replyError(bt::HTTPRequest* r,const QString & data);
+		
+		/**
+		 * No reply was sent and an error or timeout occurred.
+		 * @param r The sender of the request
+		 * @param timeout Wether or not a timeout occurred
+		 */
+		void error(bt::HTTPRequest* r,bool timeout);
+		
+	private slots:
+		void onReadyRead();
+		void onError(int);
+		void onTimeout();
+		void onConnect(const KResolverEntry&);
+		
+	private:
+		KNetwork::KStreamSocket* sock;
+		QString hdr,payload;
+		bool verbose;
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/log.cpp b/libktorrent/util/log.cpp
new file mode 100644
index 0000000..05682a8
--- /dev/null
+++ b/libktorrent/util/log.cpp
@@ -0,0 +1,249 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+
+#include <kurl.h>
+#include <kprocess.h>
+#include <klocale.h>
+#include <qdatetime.h>
+#include <qtextstream.h>
+#include <qfile.h>
+#include <qptrlist.h>
+#include <iostream>
+#include <stdlib.h>
+#include <torrent/globals.h>
+#include <interfaces/logmonitorinterface.h>
+#include <qmutex.h> 
+#include <util/fileops.h>
+#include <stdlib.h>
+#include "log.h"
+#include "error.h"
+#include "autorotatelogjob.h"
+
+using namespace kt;
+
+namespace bt
+{
+	const Uint32 MAX_LOG_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
+	
+	class Log::Private
+	{
+	public:
+		Log* parent;
+		QTextStream* out;
+		QFile fptr;
+		bool to_cout;
+		QPtrList<LogMonitorInterface> monitors;
+		QString tmp;
+		QMutex mutex;
+		unsigned int m_filter;
+		AutoRotateLogJob* rotate_job;
+	public:
+		Private(Log* parent) : parent(parent),out(0),to_cout(false),rotate_job(0)
+		{
+			out = new QTextStream();
+		}
+
+		~Private()
+		{
+			delete out;
+		}
+
+		
+		void setFilter(unsigned int filter)
+		{
+			m_filter = filter;
+		}
+		
+		void rotateLogs(const QString & file)
+		{
+			if (bt::Exists(file + "-10.gz"))
+				bt::Delete(file + "-10.gz",true);
+			
+			// move all log files one up
+			for (Uint32 i = 10;i > 1;i--)
+			{
+				QString prev = QString("%1-%2.gz").arg(file).arg(i - 1);
+				QString curr = QString("%1-%2.gz").arg(file).arg(i);
+				if (bt::Exists(prev))
+					bt::Move(prev,curr,true);
+			}
+			
+			// move current log to 1 and zip it
+			bt::Move(file,file + "-1",true);
+			system(QString("gzip " + KProcess::quote(file + "-1")).local8Bit());
+		}
+
+		void setOutputFile(const QString & file)
+		{
+			if (fptr.isOpen())
+				fptr.close();
+			
+			if (bt::Exists(file))
+				rotateLogs(file);
+
+			fptr.setName(file);
+			if (!fptr.open(IO_WriteOnly))
+				throw Error(i18n("Cannot open log file %1 : %2").arg(file).arg(fptr.errorString()));
+
+			out->setDevice(&fptr);
+		}
+
+		void write(const QString & line)
+		{
+			tmp += line;
+		}
+		
+		void finishLine()
+		{
+			// only add stuff when we are not rotating the logs
+			// this could result in the loss of some messages
+			if (!rotate_job) 
+			{
+				*out << QDateTime::currentDateTime().toString() << ": " << tmp << ::endl;
+				fptr.flush();
+				if (to_cout)
+					std::cout << tmp.local8Bit() << std::endl;
+				
+				if (monitors.count() > 0)
+				{
+					QPtrList<LogMonitorInterface>::iterator i = monitors.begin();
+					while (i != monitors.end())
+					{
+						kt::LogMonitorInterface* lmi = *i;
+						lmi->message(tmp,m_filter);
+						i++;
+					}
+				}
+			}
+			tmp = "";
+		}
+
+		void endline()
+		{
+			finishLine();
+			if (fptr.size() > MAX_LOG_FILE_SIZE && !rotate_job)
+			{
+				tmp = "Log larger then 10 MB, rotating";
+				finishLine();
+				QString file = fptr.name();
+				fptr.close(); // close the log file
+				out->setDevice(0);		
+				// start the rotate job
+				rotate_job = new AutoRotateLogJob(file,parent); 
+			}
+		}
+		
+		void logRotateDone()
+		{
+			fptr.open(IO_WriteOnly);
+			out->setDevice(&fptr);
+			rotate_job = 0;
+		}
+	};
+	
+	Log::Log() 
+	{
+		priv = new Private(this);
+	}
+	
+	
+	Log::~Log()
+	{
+		delete priv;
+	}
+	
+	
+	void Log::setOutputFile(const QString & file)
+	{
+		priv->setOutputFile(file);
+	}
+
+	void Log::addMonitor(kt::LogMonitorInterface* m)
+	{
+		priv->monitors.append(m);
+	}
+
+	void Log::removeMonitor(kt::LogMonitorInterface* m)
+	{
+		priv->monitors.remove(m);
+	}
+
+	void Log::setOutputToConsole(bool on)
+	{
+		priv->to_cout = on;
+	}
+
+	Log & endl(Log & lg)
+	{
+		lg.priv->endline();
+		lg.priv->mutex.unlock(); // unlock after end of line
+		return lg;
+	}
+
+	Log & Log::operator << (const KURL & url)
+	{
+		priv->write(url.prettyURL());
+		return *this;
+	}
+
+	Log & Log::operator << (const QString & s)
+	{
+		priv->write(s);
+		return *this;
+	}
+
+	Log & Log::operator << (const char* s)
+	{
+		priv->write(s);
+		return *this;
+	}
+
+	Log & Log::operator << (Uint64 v)
+	{
+		return operator << (QString::number(v));
+	}
+
+	Log & Log::operator << (Int64 v)
+	{
+		return operator << (QString::number(v));
+	}
+
+	void Log::setFilter(unsigned int filter)
+	{
+		priv->setFilter(filter);
+	}
+
+	void Log::lock()
+	{
+		priv->mutex.lock();
+	}
+	
+	void Log::logRotateDone()
+	{
+		priv->logRotateDone();
+	}
+	
+	Log & Out(unsigned int arg)
+	{
+		Log & lg = Globals::instance().getLog(arg);
+		lg.lock();
+		return lg;
+	}
+}
diff --git a/libktorrent/util/log.h b/libktorrent/util/log.h
new file mode 100644
index 0000000..2fe0ba6
--- /dev/null
+++ b/libktorrent/util/log.h
@@ -0,0 +1,209 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 JORISLOG_H
+#define JORISLOG_H
+
+
+#include "constants.h"
+#include <qstring.h>
+
+// LOG MESSAGES CONSTANTS
+#define LOG_NONE 0x00
+#define LOG_IMPORTANT 0x01
+#define LOG_NOTICE 0x03
+#define LOG_DEBUG 0x07
+#define LOG_ALL 0x0F
+
+#define SYS_GEN 0x0010 // Genereral info messages
+#define SYS_CON 0x0020 // Connections
+#define SYS_TRK 0x0040 // Tracker
+#define SYS_DHT 0x0080 // DHT
+#define SYS_DIO 0x0100 // Disk IO related stuff, saving and loading of chunks ...
+
+//plugins
+#define SYS_IPF 0x1000  // IPFilter
+#define SYS_SRC 0x2000  // Search plugin
+#define SYS_PNP 0x4000  // UPnP plugin
+#define SYS_INW 0x8000  // InfoWidget
+#define SYS_SNF 0x10000 // ScanFolder plugin
+#define SYS_PFI 0x20000 // Part file import
+#define SYS_SCD 0x40000 // Scheduler plugin
+#define SYS_RSS 0x80000 // RSS plugin
+#define SYS_WEB 0x100000 // WebInterface plugin
+#define SYS_ZCO 0x200000 // ZeroConf plugin
+
+class KURL;
+
+
+namespace kt
+{
+	class LogMonitorInterface;
+}
+
+namespace bt
+{
+	
+	
+	/**
+	* @author Joris Guisson
+	* @brief Class which writes messages to a logfile
+	*
+	* This class writes messages to a logfile. To use it, create an instance,
+	* set the output file and write stuff with the << operator.
+	*
+	* By default all messages will also be printed on the standard output. This
+	* can be turned down using the @a setOutputToConsole function.
+	*
+	* There is also the possibility to monitor what is written to the log using
+	* the LogMonitorInterface class.
+	*/
+	class Log 
+	{
+		class Private;
+		
+		Private* priv;
+	public:
+		/**
+		* Constructor.
+		*/
+		Log();
+		
+		/**
+		* Destructor, closes the file.
+		*/
+		virtual ~Log();
+	
+		/**
+		* Enable or disable the printing of log messages to the standard
+		* output.
+		* @param on Enable or disable
+		*/
+		void setOutputToConsole(bool on);
+
+		/**
+		 * Add a log monitor.
+		 * @param m The log monitor
+		 */
+		void addMonitor(kt::LogMonitorInterface* m);
+
+		/**
+		 * Remove a log monitor.
+		 * @param m The log monitor
+		 */
+		void removeMonitor(kt::LogMonitorInterface* m);
+		
+		/**
+		* Set the output logfile.
+		* @param file The name of the file
+		* @throw Exception if the file can't be opened
+		*/
+		void setOutputFile(const QString & file);
+		
+		/**
+		* Write a number to the log file.
+		* Anything which can be passed to QString::number will do.
+		* @param val The value
+		* @return This Log
+		*/
+		template <class T>
+		Log & operator << (T val)
+		{
+			return operator << (QString::number(val));
+		}
+		
+		/**
+		* Apply a function to the Log.
+		* @param func The function
+		* @return This Log
+		*/
+		Log & operator << (Log & (*func)(Log & ))
+		{
+			return func(*this);
+		}
+
+		
+		/**
+		 * Output a QString to the log.
+		 * @param s The QString
+		 * @return This Log
+		 */
+		Log & operator << (const char* s);
+
+		/**
+		 * Output a QString to the log.
+		 * @param s The QString
+		 * @return This Log
+		 */
+		Log & operator << (const QString & s);
+
+		/**
+		 * Output a 64 bit integer to the log.
+		 * @param v The integer
+		 * @return This Log
+		 */
+		Log & operator << (Uint64 v);
+
+		/**
+		 * Output a 64 bit integer to the log.
+		 * @param v The integer
+		 * @return This Log
+		 */
+		Log & operator << (Int64 v);
+		
+		/**
+		* Prints and endline character to the Log and flushes it.
+		* @param lg The Log
+		* @return @a lg
+		*/
+		friend Log & endl(Log & lg);
+
+		/**
+		 * Write an URL to the file.
+		 * @param text The KURL
+		 * @return This Log
+		 */
+		Log & operator << (const KURL & url);
+		
+		/**
+		 * Sets a filter for log messages. Applies only to listeners via LogMonitorInterface!
+		 * @param filter SYS & LOG flags combined with bitwise OR.
+		 */
+		void setFilter(unsigned int filter);
+		
+		/// Lock the mutex of the log, should be called in Out()
+		void lock();
+	
+		/// Called by the auto log rotate job when it has finished
+		void logRotateDone();
+	};
+
+	Log & endl(Log & lg);
+	
+	
+	Log & Out(unsigned int arg = 0x00);
+	inline Log & GenOut(unsigned int arg) {return Out(SYS_GEN|arg);}
+	inline Log & DHTOut(unsigned int arg) {return Out(SYS_DHT|arg);}
+	inline Log & ConOut(unsigned int arg) {return Out(SYS_CON|arg);}
+	inline Log & TrkOut(unsigned int arg) {return Out(SYS_TRK|arg);}
+
+}
+
+#endif
diff --git a/libktorrent/util/mmapfile.cpp b/libktorrent/util/mmapfile.cpp
new file mode 100644
index 0000000..579c67a
--- /dev/null
+++ b/libktorrent/util/mmapfile.cpp
@@ -0,0 +1,294 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <qfile.h>
+#include <kfileitem.h>
+#include <kio/netaccess.h>
+#include <klocale.h>
+#include <util/error.h>
+#include <util/log.h>
+#include <torrent/globals.h>
+#include "mmapfile.h"
+
+namespace bt
+{
+
+	MMapFile::MMapFile() : fd(-1),data(0),size(0),file_size(0),ptr(0),mode(READ)
+	{}
+
+
+	MMapFile::~MMapFile()
+	{
+		if (fd > 0)
+			close();
+	}
+
+	bool MMapFile::open(const QString & file,Mode mode)
+	{
+#if HAVE_STAT64
+		struct stat64 sb;
+		stat64(QFile::encodeName(file),&sb);
+#else
+		struct stat sb;
+		stat(QFile::encodeName(file),&sb);
+#endif
+		
+		return open(file,mode,(Uint64)sb.st_size);
+	}
+	
+	bool MMapFile::open(const QString & file,Mode mode,Uint64 size)
+	{
+		// close already open file
+		if (fd > 0)
+			close();
+		
+		// setup flags
+		int flag = 0,mmap_flag = 0;
+		switch (mode)
+		{
+			case READ:
+				flag = O_RDONLY;
+				mmap_flag = PROT_READ;
+				break;
+			case WRITE:
+				flag = O_WRONLY | O_CREAT;
+				mmap_flag = PROT_WRITE;
+				break;
+			case RW:
+				flag = O_RDWR | O_CREAT;
+				mmap_flag = PROT_READ|PROT_WRITE;
+				break;
+		}
+
+		// Not all systems have O_LARGEFILE as an explicit flag
+		// (for instance, FreeBSD. Solaris does, but only if
+		// _LARGEFILE_SOURCE is defined in the compile).
+		// So OR it in if it is defined.
+#ifdef O_LARGEFILE
+		flag |= O_LARGEFILE;
+#endif
+
+		// open the file
+		fd = ::open(QFile::encodeName(file) , flag);//(int)flag);
+		if (fd == -1)
+			return false;
+		
+		// read the file size
+		this->size = size;
+		this->mode = mode;
+		
+#if HAVE_STAT64
+		struct stat64 sb;
+		stat64(QFile::encodeName(file),&sb);
+#else
+		struct stat sb;
+		stat(QFile::encodeName(file),&sb);
+#endif
+		file_size = (Uint64)sb.st_size;
+		filename = file;
+		
+		// mmap the file
+#if HAVE_MMAP64
+		data = (Uint8*)mmap64(0, size, mmap_flag, MAP_SHARED, fd, 0);
+#else
+		data = (Uint8*)mmap(0, size, mmap_flag, MAP_SHARED, fd, 0);
+#endif
+		if (data == MAP_FAILED) 
+		{
+			::close(fd);
+			data = 0;
+			fd = -1;
+			ptr = 0;
+			return false;
+		}
+		ptr = 0;
+		return true;
+	}
+		
+	void MMapFile::close()
+	{
+		if (fd > 0)
+		{
+#if HAVE_MUNMAP64
+			munmap64(data,size);
+#else
+			munmap(data,size);
+#endif
+			::close(fd);
+			ptr = size = 0;
+			data = 0;
+			fd = -1;
+			filename = QString::null;
+		}
+	}
+		
+	void MMapFile::flush()
+	{
+		if (fd > 0)
+			msync(data,size,MS_SYNC);
+	}
+		
+	Uint32 MMapFile::write(const void* buf,Uint32 buf_size)
+	{
+		if (fd == -1 || mode == READ)
+			return 0;
+		
+		// check if data fits in memory mapping
+		if (ptr + buf_size > size)
+			throw Error(i18n("Cannot write beyond end of the mmap buffer!"));
+		
+		Out() << "MMapFile::write : " << (ptr + buf_size) << " " << file_size << endl;
+		// enlarge the file if necessary
+		if (ptr + buf_size > file_size)
+		{
+			growFile(ptr + buf_size);
+		}
+		
+		// memcpy data
+		memcpy(&data[ptr],buf,buf_size);
+		// update ptr
+		ptr += buf_size;
+		// update file size if necessary
+		if (ptr >= size)
+			size = ptr;
+		
+		return buf_size;
+	}
+	
+	void MMapFile::growFile(Uint64 new_size)
+	{
+		Out() << "Growing file to " << new_size << " bytes " << endl;
+		Uint64 to_write = new_size - file_size;
+		ssize_t written;
+		// jump to the end of the file
+		lseek(fd,0,SEEK_END);
+		
+		Uint8 buf[1024];
+		memset(buf,0,1024);
+		// write data until to_write is 0
+		while (to_write > 0)
+		{
+			ssize_t w = ::write(fd,buf, to_write > 1024 ? 1024 : to_write);
+			if (w > 0)
+			    to_write -= w;
+			else if (w < 0)
+			    break;
+		}
+		file_size = new_size;
+	}
+		
+	Uint32 MMapFile::read(void* buf,Uint32 buf_size)
+	{
+		if (fd == -1 || mode == WRITE)
+			return 0;
+		
+		// check if we aren't going to read past the end of the file
+		Uint32 to_read = ptr + buf_size >= size ? size - ptr : buf_size;
+		// read data
+		memcpy(buf,data+ptr,to_read);
+		ptr += to_read;
+		return to_read;
+	}
+
+	Uint64 MMapFile::seek(SeekPos from,Int64 num)
+	{
+		switch (from)
+		{
+			case BEGIN:
+				if (num > 0)
+					ptr = num; 
+				if (ptr >= size)
+					ptr = size - 1;
+				break;
+			case END:
+				{
+					Int64 np = (size - 1) + num;
+					if (np < 0)
+					{
+						ptr = 0;
+						break;
+					}
+					if (np >= (Int64) size)
+					{
+						ptr = size - 1;
+						break;
+					}
+					ptr = np;
+				}
+				break;
+			case CURRENT:
+				{
+					Int64 np = ptr + num;
+					if (np < 0)
+					{
+						ptr = 0;
+						break;
+					}
+					if (np >= (Int64) size)
+					{
+						ptr = size - 1;
+						break;
+					}
+					ptr = np;
+				}	
+				break;
+		}
+		return ptr;
+	}
+
+	bool MMapFile::eof() const
+	{
+		return ptr >= size;
+	}
+
+	Uint64 MMapFile::tell() const
+	{
+		return ptr;
+	}
+	
+	QString MMapFile::errorString() const
+	{
+		return strerror(errno);
+	}
+	
+	Uint64 MMapFile::getSize() const
+	{
+		return size;
+	}
+	
+	Uint8* MMapFile::getData(Uint64 off)
+	{
+		if (off >= size)
+			return 0;
+		return &data[off];
+	}
+}
+
diff --git a/libktorrent/util/mmapfile.h b/libktorrent/util/mmapfile.h
new file mode 100644
index 0000000..ca0d782
--- /dev/null
+++ b/libktorrent/util/mmapfile.h
@@ -0,0 +1,146 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTMMAPFILE_H
+#define BTMMAPFILE_H
+
+
+#include <qstring.h>
+#include <util/constants.h>
+
+namespace bt
+{
+
+	/**
+	 * @author Joris Guisson
+	 * @brief Memory mapped file
+	 *
+	 * This class allows to access memory mapped files. It's pretty similar to
+	 * File.
+	 * TODO: make sure large files work (not really needed for the blocklist)
+	*/
+	class MMapFile
+	{
+	public:
+		MMapFile();
+		virtual ~MMapFile();
+
+		enum Mode
+		{
+			READ,WRITE, RW
+		};
+		/**
+		 * Open the file. If mode is write and the file doesn't exist, it will
+		 * be created.
+		 * @param file Filename
+		 * @param mode Mode (READ, WRITE or RW)
+		 * @return true upon succes
+		 */
+		bool open(const QString & file,Mode mode);
+		
+		/**
+		 * Open the file. If mode is write and the file doesn't exist, it will
+		 * be created.
+		 * @param file Filename
+		 * @param mode Mode (READ, WRITE or RW)
+		 * @param size Size of the memory mapping (the file will be enlarged to this value)
+		 * @return true upon succes
+		 */
+		bool open(const QString & file,Mode mode,Uint64 size);
+		
+		/**
+		 * Close the file. Undoes the memory mapping.
+		 */
+		void close();
+		
+		/**
+		 * Flush the file.
+		 */
+		void flush();
+		
+		/**
+		 * Write a bunch of data.
+		 * @param buf The data
+		 * @param size Size of the data
+		 * @return The number of bytes written
+		 */
+		Uint32 write(const void* buf,Uint32 size);
+		
+		/**
+		 * Read a bunch of data
+		 * @param buf The buffer to store the data
+		 * @param size Size of the buffer
+		 * @return The number of bytes read
+		 */
+		Uint32 read(void* buf,Uint32 size);
+
+		enum SeekPos
+		{
+			BEGIN,
+			END,
+			CURRENT
+		};
+		
+		/**
+		 * Seek in the file.
+		 * @param from Position to seek from
+		 * @param num Number of bytes to move
+		 * @return New position
+		 */
+		Uint64 seek(SeekPos from,Int64 num);
+
+		/// Check to see if we are at the end of the file.
+		bool eof() const;
+
+		/// Get the current position in the file.
+		Uint64 tell() const;
+
+		/// Get the error string.
+		QString errorString() const;
+		
+		/// Get the file size
+		Uint64 getSize() const;
+
+		
+		/**
+		 * Get a pointer to the mmapped region of data.
+		 * @param off Offset into buffer, if invalid 0 will be returned
+		 * @return Pointer to a location in the mmapped region
+		 */
+		Uint8* getData(Uint64 off);
+		
+		/// Gets the data pointer
+		void* getDataPointer() { return data; }
+	private:
+		void growFile(Uint64 new_size);
+
+	private:
+		int fd;
+		Uint8* data;
+		Uint64 size;	// size of mmapping
+		Uint64 file_size; // size of file
+		Uint64 ptr; 
+		QString filename;
+		Mode mode;
+	};
+
+}
+
+
+#endif
diff --git a/libktorrent/util/profiler.cpp b/libktorrent/util/profiler.cpp
new file mode 100644
index 0000000..05c53bd
--- /dev/null
+++ b/libktorrent/util/profiler.cpp
@@ -0,0 +1,138 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.          *
+ ***************************************************************************/
+#ifdef KT_PROFILE
+#include <qfile.h>
+#include <qtextstream.h>
+#include <sys/time.h>
+#include "profiler.h"
+
+namespace bt
+{
+	Profile::Profile(Profile* parent,const QString & name) : parent(parent),name(name)
+	{
+		min = max = avg = 0.0;
+		count = 0;
+		start_time = 0.0;
+		children.setAutoDelete(true);
+	}
+	
+	Profile::~Profile()
+	{
+	}
+		
+	void Profile::start()
+	{
+		struct timeval tv;
+		gettimeofday(&tv,0);
+		start_time = tv.tv_sec * 1000.0 + tv.tv_usec * 0.001;
+	}
+		
+	void Profile::end()
+	{
+		struct timeval tv;
+		gettimeofday(&tv,0);
+		double end_time = tv.tv_sec * 1000.0 + tv.tv_usec * 0.001;
+		double d = end_time - start_time;
+		// update stuff
+		
+		if (d < min || count == 0)
+			min = d;
+		if (d > max || count == 0)
+			max = d;
+		
+		avg = (avg * count + d) / (count + 1);
+		count++;
+	}
+		
+	Profile* Profile::child(const QString & name)
+	{
+		QPtrList<Profile>::iterator i = children.begin();
+		while (i != children.end())
+		{
+			Profile* p = *i;
+			if (p->name == name)
+				return p;
+			i++;
+		}
+		
+		Profile* p = new Profile(this,name);
+		children.append(p);
+		return p;
+	}
+	
+	void Profile::save(QTextStream & out,const QString & base)
+	{
+		QString nb = base + "/" + name;
+		
+		out.precision(5);
+		out << qSetW(60) << nb << qSetW(10) << min << qSetW(10) << max << qSetW(10) << avg << qSetW(10) << count << endl;
+		
+		QPtrList<Profile>::iterator i = children.begin();
+		while (i != children.end())
+		{
+			Profile* p = *i;
+			p->save(out,nb);
+			i++;
+		} 
+	}
+	
+	/////////////////////
+	
+	Profiler Profiler::inst;
+
+	Profiler::Profiler() : curr(0),root(0)
+	{
+		root = new Profile(0,"root");
+		curr = root;
+	}
+
+
+	Profiler::~Profiler()
+	{
+		delete root;
+	}
+
+	void Profiler::start(const QString & s)
+	{
+		curr = curr->child(s);
+		curr->start();
+	}
+	
+	void Profiler::end()
+	{
+		curr->end();
+		curr = curr->getParent();
+	}
+
+	void Profiler::saveToFile(const QString & fn)
+	{
+		QFile fptr(fn);
+		if (!fptr.open(IO_WriteOnly))
+			return;
+		
+		QTextStream out(&fptr);
+		
+		out << qSetW(60) << "code" << qSetW(10) << "min" << qSetW(10) << "max" << qSetW(10) << "avg" << qSetW(10) << "count" << endl;
+		out << endl; 
+		
+		root->save(out,QString::null);
+	}
+}
+#endif
diff --git a/libktorrent/util/profiler.h b/libktorrent/util/profiler.h
new file mode 100644
index 0000000..6ab06e7
--- /dev/null
+++ b/libktorrent/util/profiler.h
@@ -0,0 +1,108 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTPROFILER_H
+#define BTPROFILER_H
+
+#ifdef KT_PROFILE
+#include <qptrlist.h>
+#include <util/constants.h>
+
+class QTextStream;
+
+
+namespace bt
+{
+	/**
+	 * Profile of one function or section of code.
+	 */
+	class Profile
+	{
+		Profile* parent;
+		QPtrList<Profile> children;
+		
+		QString name;
+		double min,max,avg;
+		Uint32 count;
+		double start_time;
+	public:	
+		Profile(Profile* parent,const QString & name);
+		virtual ~Profile();
+		
+		/**
+		 * We just entered the function and will profile it.
+		 */
+		void start();
+		
+		/**
+		 * We just left the function, internal variables will now be updated
+		 */
+		void end();
+		
+		/**
+		 * Get a child, if it doesn't exist it will be created.
+		 * @param name The name of the child
+		 * @return The child
+		 */
+		Profile* child(const QString & name);
+		
+		/**
+		 * Get the parent of the current profile.
+		 */
+		Profile* getParent() const {return parent;}
+		
+		/**
+		 * Save profile information to a file.
+		 * @param out Text stream to write to
+		 * @param base Base path of the profiles
+		 */
+		void save(QTextStream & out,const QString & base);
+	};
+
+	/**
+	 * @author Joris Guisson <joris.guisson@gmail.com>
+	 * 
+	 * Class used to profile ktorrent
+	*/
+	class Profiler
+	{
+		Profile* curr;
+		Profile* root;
+				
+		static Profiler inst;
+		
+		Profiler();
+	public:
+		virtual ~Profiler();
+
+		void start(const QString & s);
+		void end();
+		void saveToFile(const QString & fn);
+		
+		static Profiler & instance() {return inst;} 
+	};
+}
+#define KT_PROF_START(S) bt::Profiler::instance().start(S)
+#define KT_PROF_END()  bt::Profiler::instance().end()
+#else
+#define KT_PROF_START(S)
+#define KT_PROF_END()
+#endif
+
+#endif
diff --git a/libktorrent/util/ptrmap.cpp b/libktorrent/util/ptrmap.cpp
new file mode 100644
index 0000000..28a4340
--- /dev/null
+++ b/libktorrent/util/ptrmap.cpp
@@ -0,0 +1,24 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include "ptrmap.h"
+
+
+
+
diff --git a/libktorrent/util/ptrmap.h b/libktorrent/util/ptrmap.h
new file mode 100644
index 0000000..36e1c20
--- /dev/null
+++ b/libktorrent/util/ptrmap.h
@@ -0,0 +1,181 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTPTRMAP_H
+#define BTPTRMAP_H
+
+#include <map>
+
+namespace bt
+{
+	/**
+	* @author Joris Guisson
+	* @brief Map of pointers
+	*
+	* A Map where the data is a pointer. The PtrMap has an autodeletion feature.
+	* When autodelete is on, every time we remove something from the map, the data
+	* will be deleted.
+	*/
+	template <class Key,class Data>
+	class PtrMap
+	{
+		bool autodel;
+		std::map<Key,Data*> pmap;
+	public:
+		/**
+		* Constructor.
+		* @param auto_del Wether or not to enable auto deletion
+		*/
+		PtrMap(bool autodel = false) : autodel(autodel)
+		{}
+		
+		/**
+		* Destructor. Will delete all objects, if auto deletion is on.
+		*/
+		virtual ~PtrMap()
+		{
+			clear();
+		}
+		
+		
+		/**
+		* Return the number of key data pairs in the map.
+		*/
+		unsigned int count() const {return pmap.size();}
+		
+		/**
+		* Enable or disable auto deletion.
+		* @param yes Enable if true, disable if false
+		*/
+		void setAutoDelete(bool yes)
+		{
+			autodel = yes;
+		}
+		
+		typedef typename std::map<Key,Data*>::iterator iterator;
+		typedef typename std::map<Key,Data*>::const_iterator const_iterator;
+		
+		iterator begin() {return pmap.begin();}
+		iterator end() {return pmap.end();}
+		
+		const_iterator begin() const {return pmap.begin();}
+		const_iterator end() const {return pmap.end();}
+		
+		/**
+		* Remove all objects, will delete them if autodelete is on.
+		*/
+		void clear()
+		{
+			if (autodel)
+			{
+				for (iterator i = pmap.begin();i != pmap.end();i++)
+				{
+					delete i->second;
+					i->second = 0;
+				}
+			}
+			pmap.clear();
+		}
+		
+		/**
+		* Insert a key data pair.
+		* @param k The key
+		* @param d The data
+		* @param overwrite Wether or not to overwrite
+		* @return true if the insertion took place
+		*/
+		bool insert(const Key & k,Data* d,bool overwrite = true)
+		{
+			iterator itr =  pmap.find(k);
+			if (itr != pmap.end())
+			{
+				if (overwrite)
+				{
+					if (autodel)
+						delete itr->second;
+					itr->second = d;
+					return true;
+				}
+				else
+				{
+					return false;
+				}
+			}
+			else
+			{
+				pmap[k] = d;
+				return true;
+			}
+		}
+	
+		/**
+		* Find a key in the map and returns it's data.
+		* @param k The key
+		* @return The data of the key, 0 if the key isn't in the map
+		*/
+		Data* find(const Key & k)
+		{
+			iterator i = pmap.find(k);
+			return (i == pmap.end()) ? 0 : i->second;
+		}
+		
+		/**
+		* Find a key in the map and returns it's data.
+		* @param k The key
+		* @return The data of the key, 0 if the key isn't in the map
+		*/
+		const Data* find(const Key & k) const
+		{
+			const_iterator i = pmap.find(k);
+			return (i == pmap.end()) ? 0 : i->second;
+		}
+		
+		/**
+		* Check to see if a key is in the map.
+		* @param k The key
+		* @return true if it is part of the map
+		*/
+		bool contains(const Key & k) const
+		{
+			const_iterator i = pmap.find(k);
+			return i != pmap.end();
+		}
+		
+		/**
+		* Erase a key from the map. Will delete
+		* the data if autodelete is on.
+		* @param key The key
+		* @return true if an erase took place
+		*/
+		bool erase(const Key & key)
+		{
+			iterator i = pmap.find(key);
+			if (i == pmap.end())
+				return false;
+			
+			if (autodel)
+				delete i->second;
+			pmap.erase(i);
+			return true;
+		}
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/sha1hash.cpp b/libktorrent/util/sha1hash.cpp
new file mode 100644
index 0000000..c7b151c
--- /dev/null
+++ b/libktorrent/util/sha1hash.cpp
@@ -0,0 +1,131 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include <qurl.h>
+#include <string.h>
+#include <algorithm>
+#include "log.h"
+#include "sha1hash.h"
+#include "sha1hashgen.h"
+#include "urlencoder.h"
+
+#include <stdio.h>
+
+namespace bt
+{
+	SHA1Hash::SHA1Hash()
+	{
+		std::fill(hash,hash+20,'\0');
+	}
+
+	SHA1Hash::SHA1Hash(const SHA1Hash & other)
+	{
+		for (int i = 0;i < 20;i++)
+			hash[i] = other.hash[i];
+	}
+
+	SHA1Hash::SHA1Hash(const Uint8* h)
+	{
+		memcpy(hash,h,20);
+	}
+
+
+	SHA1Hash::~SHA1Hash()
+	{}
+
+	SHA1Hash & SHA1Hash::operator = (const SHA1Hash & other)
+	{
+		for (int i = 0;i < 20;i++)
+			hash[i] = other.hash[i];
+		return *this;
+	}
+
+	bool SHA1Hash::operator == (const SHA1Hash & other) const
+	{
+		for (int i = 0;i < 20;i++)
+			if (hash[i] != other.hash[i])
+				return false;
+
+		return true;
+	}
+
+	SHA1Hash SHA1Hash::generate(const Uint8* data,Uint32 len)
+	{
+		SHA1HashGen hg;
+
+		return hg.generate(data,len);
+	}
+
+	QString SHA1Hash::toString() const
+	{
+		char tmp[41];
+		QString fmt;
+		for (int i = 0;i < 20;i++)
+			fmt += "%02x";
+		tmp[40] = '\0';
+		snprintf(tmp,41,fmt.ascii(),
+				hash[0],hash[1],hash[2],hash[3],hash[4],
+				hash[5],hash[6],hash[7],hash[8],hash[9],
+				hash[10],hash[11],hash[12],hash[13],hash[14],
+				hash[15],hash[16],hash[17],hash[18],hash[19]);
+		return QString(tmp);
+	}
+	
+	QByteArray SHA1Hash::toByteArray() const
+	{
+		QByteArray arr(20);
+		arr.duplicate((const char*)hash,20);
+		return arr;
+	}
+
+	QString SHA1Hash::toURLString() const
+	{
+		return URLEncoder::encode((const char*)hash,20);
+	}
+
+	Log & operator << (Log & out,const SHA1Hash & h)
+	{
+		out << h.toString();
+		return out;
+	}
+
+	SHA1Hash operator ^ (const SHA1Hash & a,const SHA1Hash & b)
+	{
+		SHA1Hash k;
+		for (int i = 0;i < 20;i++)
+		{
+			k.hash[i] = a.hash[i] ^ b.hash[i];
+		}
+		return k;
+	}
+
+	bool operator < (const SHA1Hash & a,const SHA1Hash & b)
+	{
+		for (int i = 0;i < 20;i++)
+		{
+			if (a.hash[i] < b.hash[i])
+				return true;
+			else if (a.hash[i] > b.hash[i])
+				return false;
+		}
+		
+		return false;
+	}
+}
+
diff --git a/libktorrent/util/sha1hash.h b/libktorrent/util/sha1hash.h
new file mode 100644
index 0000000..a831d2d
--- /dev/null
+++ b/libktorrent/util/sha1hash.h
@@ -0,0 +1,148 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTSHA1HASH_H
+#define BTSHA1HASH_H
+
+#include <qcstring.h> 
+#include "constants.h"
+
+class QString;
+
+namespace bt
+{
+	class Log;
+
+	/**
+	 * @author Joris Guisson
+	 * @brief Stores a SHA1 hash
+	 *
+	 * This class keeps track of a SHA1 hash. A SHA1 hash is a 20 byte
+	 * array of bytes.
+	*/
+	class SHA1Hash
+	{
+	protected:
+		Uint8 hash[20];
+	public:
+		/**
+		 * Constructor, sets every byte in the hash to 0.
+		 */
+		SHA1Hash();
+		
+		/**
+		 * Copy constructor.
+		 * @param other Hash to copy
+		 */
+		SHA1Hash(const SHA1Hash & other);
+		
+		/**
+		 * Directly set the hash data.
+		 * @param h The hash data must be 20 bytes large
+		 */
+		SHA1Hash(const Uint8* h);
+		
+		/**
+		 * Destructor.
+		 */
+		virtual ~SHA1Hash();
+
+		/// Get the idx'th byte of the hash.
+		Uint8 operator [] (const Uint32 idx) const {return idx < 20 ? hash[idx] : 0;}
+		
+		/**
+		 * Assignment operator.
+		 * @param other Hash to copy
+		 */
+		SHA1Hash & operator = (const SHA1Hash & other);
+
+		/**
+		 * Test wether another hash is equal to this one.
+		 * @param other The other hash
+		 * @return true if equal, false otherwise
+		 */
+		bool operator == (const SHA1Hash & other) const;
+
+		/**
+		 * Test wether another hash is not equal to this one.
+		 * @param other The other hash
+		 * @return true if not equal, false otherwise
+		 */
+		bool operator != (const SHA1Hash & other) const {return !operator ==(other);}
+
+		/**
+		 * Generate an SHA1 hash from a bunch of data.
+		 * @param data The data
+		 * @param len Size in bytes of data
+		 * @return The generated SHA1 hash
+		 */
+		static SHA1Hash generate(const Uint8* data,Uint32 len);
+
+		/**
+		 * Convert the hash to a printable string.
+		 * @return The string
+		 */
+		QString toString() const;
+
+		/**
+		 * Convert the hash to a string, usable in http get requests.
+		 * @return The string
+		 */
+		QString toURLString() const;
+		
+		/**
+		 * Directly get pointer to the data.
+		 * @return The data
+		 */
+		const Uint8* getData() const {return hash;}
+
+		/**
+		 * Function to print a SHA1Hash to the Log.
+		 * @param out The Log
+		 * @param h The hash
+		 * @return out
+		 */
+		friend Log & operator << (Log & out,const SHA1Hash & h);
+		
+		
+		/**
+		 * XOR two SHA1Hashes
+		 * @param a The first hash
+		 * @param b The second
+		 * @return a xor b
+		 */
+		friend SHA1Hash operator ^ (const SHA1Hash & a,const SHA1Hash & b);
+		
+		/**
+		 * Function to compare 2 hashes
+		 * @param a The first hash
+		 * @param h The second hash
+		 * @return wether a is smaller then b
+		 */
+		friend bool operator < (const SHA1Hash & a,const SHA1Hash & b);
+		
+		/**
+		 * Convert the hash to a byte array.
+		 */
+		QByteArray toByteArray() const;
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/sha1hashgen.cpp b/libktorrent/util/sha1hashgen.cpp
new file mode 100644
index 0000000..5c0d9f5
--- /dev/null
+++ b/libktorrent/util/sha1hashgen.cpp
@@ -0,0 +1,340 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include <string.h>
+#include <arpa/inet.h>
+#include "sha1hashgen.h"
+#include "functions.h"
+
+
+
+namespace bt
+{
+	static inline Uint32 LeftRotate(Uint32 x,Uint32 n)
+	{
+		return ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)));
+	}
+	
+	
+
+	SHA1HashGen::SHA1HashGen() : tmp_len(0),total_len(0)
+	{
+		
+	}
+
+
+	SHA1HashGen::~SHA1HashGen()
+	{}
+
+	SHA1Hash SHA1HashGen::generate(const Uint8* data,Uint32 len)
+	{
+		h0 = 0x67452301;
+		h1 = 0xEFCDAB89;
+		h2 = 0x98BADCFE;
+		h3 = 0x10325476;
+		h4 = 0xC3D2E1F0;
+		
+		Uint32 num_64_byte_chunks = len / 64;
+		Uint32 left_over = len % 64; 
+		// proces regular data
+		for (Uint32 i = 0;i < num_64_byte_chunks;i++)
+		{
+			processChunk(data + (64*i));
+		}
+		
+		// calculate the low and high byte of the data length
+		Uint32 total[2] = {0,0};
+		total[0] += len;
+		total[0] &= 0xFFFFFFFF;
+		
+		if (total[0] < len)
+			total[1]++;
+		
+		Uint32 high = ( total[0] >> 29 ) | ( total[1] <<  3 );
+		Uint32 low  = ( total[0] <<  3 );
+		
+		if (left_over == 0)
+		{
+			tmp[0] = 0x80;
+			for (Uint32 i = 1;i < 56;i++)
+				tmp[i] = 0;
+			 
+			// put in the length as 64-bit integer (BIG-ENDIAN)
+			WriteUint32(tmp,56,high);
+			WriteUint32(tmp,60,low);
+			// process the padding
+			processChunk(tmp);
+		}
+		else if (left_over < 56)
+		{
+			Uint32 off = num_64_byte_chunks * 64;
+			// copy left over bytes in tmp
+			memcpy(tmp,data + off, left_over);
+			tmp[left_over] = 0x80;
+			for (Uint32 i = left_over + 1;i < 56;i++)
+				tmp[i] = 0;
+			
+			// put in the length as 64-bit integer (BIG-ENDIAN)
+			WriteUint32(tmp,56,high);
+			WriteUint32(tmp,60,low);
+			// process the padding
+			processChunk(tmp);
+		}
+		else
+		{
+			// now we need to process 2 chunks
+			Uint32 off = num_64_byte_chunks * 64;
+			// copy left over bytes in tmp
+			memcpy(tmp,data + off, left_over);
+			tmp[left_over] = 0x80;
+			for (Uint32 i = left_over + 1;i < 64;i++)
+				tmp[i] = 0;
+			
+			// process first chunk
+			processChunk(tmp);
+			
+			for (Uint32 i = 0;i < 56;i++)
+				tmp[i] = 0;
+			
+			// put in the length as 64-bit integer (BIG-ENDIAN)
+			WriteUint32(tmp,56,high);
+			WriteUint32(tmp,60,low);
+			// process the second chunk
+			processChunk(tmp);
+		}
+				
+		// construct final message
+		Uint8 hash[20];
+		WriteUint32(hash,0,h0);
+		WriteUint32(hash,4,h1);
+		WriteUint32(hash,8,h2);
+		WriteUint32(hash,12,h3);
+		WriteUint32(hash,16,h4);
+		
+		return SHA1Hash(hash);
+	}
+	
+	
+
+	void SHA1HashGen::processChunk(const Uint8* chunk)
+	{
+		Uint32 w[80];
+		for (int i = 0;i < 80;i++)
+		{
+			if (i < 16)
+			{
+				w[i] = ntohl(*(const Uint32*)(chunk + (4*i)));
+			/*	w[i] = (chunk[4*i] << 24) | 
+						(chunk[4*i + 1] << 16) | 
+						(chunk[4*i + 2] << 8) | 
+						chunk[4*i + 3];
+				*/
+			}
+			else
+			{
+				w[i] = LeftRotate(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16],1);
+			}
+		}
+		
+		Uint32 a = h0;
+		Uint32 b = h1;
+		Uint32 c = h2;
+		Uint32 d = h3;
+		Uint32 e = h4;
+		
+		for (int i = 0;i < 80;i++)
+		{
+			Uint32 f,k;
+			if (i < 20)
+			{
+				f = (b & c) | ((~b) & d);
+				k = 0x5A827999;
+			}
+			else if (i < 40)
+			{
+				f = b ^ c ^ d;
+				k = 0x6ED9EBA1;
+			}
+			else if (i < 60)
+			{
+				f = (b & c) | (b & d) | (c & d);
+				k = 0x8F1BBCDC;
+			}
+			else
+			{
+				f = b ^ c ^ d;
+				k = 0xCA62C1D6;
+			}
+
+			Uint32 temp = LeftRotate(a,5) + f + e + k + w[i];
+			e = d;
+			d = c;
+			c = LeftRotate(b,30);
+			b = a;
+			a = temp;
+		}
+		h0 = (h0 + a) & 0xffffffff;
+		h1 = (h1 + b) & 0xffffffff;
+		h2 = (h2 + c) & 0xffffffff;
+		h3 = (h3 + d) & 0xffffffff;
+		h4 = (h4 + e) & 0xffffffff;
+	}
+	
+	
+	void SHA1HashGen::start()
+	{
+		h0 = 0x67452301;
+		h1 = 0xEFCDAB89;
+		h2 = 0x98BADCFE;
+		h3 = 0x10325476;
+		h4 = 0xC3D2E1F0;
+		tmp_len = total_len = 0;
+		memset(tmp,0,64);
+	}
+		
+	void SHA1HashGen::update(const Uint8* data,Uint32 len)
+	{
+		if (tmp_len == 0)
+		{
+			Uint32 num_64_byte_chunks = len / 64;
+			Uint32 left_over = len % 64; 
+			// proces data in chunks of 64 byte
+			for (Uint32 i = 0;i < num_64_byte_chunks;i++)
+			{
+				processChunk(data + (64*i));
+			}
+			 
+			if (left_over > 0)
+			{
+				// if there is anything left over, copy it in tmp
+				memcpy(tmp,data + (64 * num_64_byte_chunks),left_over);
+				tmp_len = left_over;
+			}
+			total_len += len;
+		}
+		else
+		{
+			
+			if (tmp_len + len < 64)
+			{
+				// special case, not enough of data to fill tmp completely
+				memcpy(tmp + tmp_len,data,len);
+				tmp_len += len;
+				total_len += len;
+			}
+			else
+			{
+				// copy start of data in tmp and process it
+				Uint32 off = 64 - tmp_len;
+				memcpy(tmp + tmp_len,data, 64 - tmp_len);
+				processChunk(tmp); 
+				tmp_len = 0;
+				
+				Uint32 num_64_byte_chunks = (len - off) / 64;
+				Uint32 left_over = (len - off) % 64;
+				
+				for (Uint32 i = 0;i < num_64_byte_chunks;i++)
+				{
+					processChunk(data + (off + (64*i)));
+				}
+				
+				if (left_over > 0)
+				{
+				// if there is anything left over, copy it in tmp
+					memcpy(tmp,data + (off + 64 * num_64_byte_chunks),left_over);
+					tmp_len = left_over;
+				}
+				total_len += len;
+			}
+		}
+	}
+		
+	 
+	void SHA1HashGen::end()
+	{
+		// calculate the low and high byte of the data length
+		Uint32 total[2] = {0,0};
+		total[0] += total_len;
+		total[0] &= 0xFFFFFFFF;
+		
+		if (total[0] < total_len)
+			total[1]++;
+		
+		Uint32 high = ( total[0] >> 29 ) | ( total[1] <<  3 );
+		Uint32 low  = ( total[0] <<  3 );
+		
+		if (tmp_len == 0)
+		{
+			tmp[0] = 0x80;
+			for (Uint32 i = 1;i < 56;i++)
+				tmp[i] = 0;
+			 
+			// put in the length as 64-bit integer (BIG-ENDIAN)
+			WriteUint32(tmp,56,high);
+			WriteUint32(tmp,60,low);
+			// process the padding
+			processChunk(tmp);
+		}
+		else if (tmp_len < 56)
+		{
+			tmp[tmp_len] = 0x80;
+			for (Uint32 i = tmp_len + 1;i < 56;i++)
+				tmp[i] = 0;
+			
+			// put in the length as 64-bit integer (BIG-ENDIAN)
+			WriteUint32(tmp,56,high);
+			WriteUint32(tmp,60,low);
+			// process the padding
+			processChunk(tmp);
+		}
+		else
+		{
+			// now we need to process 2 chunks
+			tmp[tmp_len] = 0x80;
+			for (Uint32 i = tmp_len + 1;i < 56;i++)
+				tmp[i] = 0;
+			
+			// process first chunk
+			processChunk(tmp);
+			
+			for (Uint32 i = 0;i < 56;i++)
+				tmp[i] = 0;
+			
+			// put in the length as 64-bit integer (BIG-ENDIAN)
+			WriteUint32(tmp,56,high);
+			WriteUint32(tmp,60,low);
+			// process the second chunk
+			processChunk(tmp);
+		}
+	}
+		
+
+	SHA1Hash SHA1HashGen::get() const
+	{
+		// construct final message
+		Uint8 hash[20];
+		WriteUint32(hash,0,h0);
+		WriteUint32(hash,4,h1);
+		WriteUint32(hash,8,h2);
+		WriteUint32(hash,12,h3);
+		WriteUint32(hash,16,h4);
+		
+		return SHA1Hash(hash);
+	}
+}
diff --git a/libktorrent/util/sha1hashgen.h b/libktorrent/util/sha1hashgen.h
new file mode 100644
index 0000000..08cc3ad
--- /dev/null
+++ b/libktorrent/util/sha1hashgen.h
@@ -0,0 +1,90 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTSHA1HASHGEN_H
+#define BTSHA1HASHGEN_H
+
+#include "constants.h"
+#include "sha1hash.h"
+
+namespace bt
+{
+	
+	/**
+	 * @author Joris Guisson
+	 * 
+	 * Generates a SHA1 hash, code based on wikipedia's pseudocode
+	 * There are 2 ways to use this class :
+	 * - generate : all data is present from the start
+	 * - start, update and end : data can be delivered in chunks
+	 * 
+	 * Mixing the 2, is not a good idea
+	*/
+	class SHA1HashGen
+	{
+		Uint32 h0;
+		Uint32 h1;
+		Uint32 h2;
+		Uint32 h3;
+		Uint32 h4;
+		Uint8 tmp[64];
+		Uint32 tmp_len;
+		Uint32 total_len;
+	public:
+		SHA1HashGen();
+		~SHA1HashGen();
+
+		/**
+		 * Generate a hash from a bunch of data.
+		 * @param data The data
+		 * @param len The length
+		 * @return The SHA1 hash
+		 */
+		SHA1Hash generate(const Uint8* data,Uint32 len);
+		
+		/**
+		 * Start SHA1 hash generation in chunks.
+		 */
+		void start();
+		
+		/**
+		 * Update the hash.
+		 * @param data The data 
+		 * @param len Length of the data
+		 */
+		void update(const Uint8* data,Uint32 len);
+		
+		
+		/**
+		 * All data has been delivered, calculate the final hash. 
+		 * @return 
+		 */ 
+		void end();
+		
+		/**
+		 * Get the hash generated.
+		 */
+		SHA1Hash get() const;
+	private:
+		void processChunk(const Uint8* c);
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/timer.cpp b/libktorrent/util/timer.cpp
new file mode 100644
index 0000000..c06b728
--- /dev/null
+++ b/libktorrent/util/timer.cpp
@@ -0,0 +1,64 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+
+#include "timer.h"
+
+namespace bt
+{
+
+	Timer::Timer() : elapsed(0)
+	{
+		last = QTime::currentTime();
+	}
+
+	Timer::Timer(const Timer & t) : last(t.last),elapsed(t.elapsed)
+	{}
+			
+	Timer::~Timer()
+	{}
+
+
+	void Timer::update()
+	{
+		QTime now = QTime::currentTime();
+
+		int d = last.msecsTo(now);
+		if (d < 0)
+			d = 0;
+		elapsed = d;
+		last = now;
+	}
+	
+	Uint32 Timer::getElapsedSinceUpdate() const
+	{
+		QTime now = QTime::currentTime();
+		int d = last.msecsTo(now);
+		if (d < 0)
+			d = 0;
+		return d;
+	}
+	
+	Timer & Timer::operator = (const Timer & t)
+	{
+		last = t.last;
+		elapsed = t.elapsed;
+		return *this;
+	}
+}
diff --git a/libktorrent/util/timer.h b/libktorrent/util/timer.h
new file mode 100644
index 0000000..3277185
--- /dev/null
+++ b/libktorrent/util/timer.h
@@ -0,0 +1,49 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTTIMER_H
+#define BTTIMER_H
+
+#include <qdatetime.h>
+#include "constants.h"
+
+namespace bt
+{
+
+	/**
+	@author Joris Guisson
+	*/
+	class Timer
+	{
+		QTime last;
+		Uint32 elapsed;
+	public:
+		Timer();
+		Timer(const Timer & t);
+		virtual ~Timer();
+
+		void update();
+		Uint32 getElapsed() const {return elapsed;}
+		Uint32 getElapsedSinceUpdate() const;
+		Timer & operator = (const Timer & t);
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/urlencoder.cpp b/libktorrent/util/urlencoder.cpp
new file mode 100644
index 0000000..c1776de
--- /dev/null
+++ b/libktorrent/util/urlencoder.cpp
@@ -0,0 +1,92 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include "urlencoder.h"
+
+
+namespace bt
+{
+	QString hex[] = {
+		"%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
+		"%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f",
+		"%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
+		"%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",
+		"%20", "%21", "%22", "%23", "%24", "%25", "%26", "%27",
+		"%28", "%29", "%2a", "%2b", "%2c", "%2d", "%2e", "%2f",
+		"%30", "%31", "%32", "%33", "%34", "%35", "%36", "%37",
+		"%38", "%39", "%3a", "%3b", "%3c", "%3d", "%3e", "%3f",
+		"%40", "%41", "%42", "%43", "%44", "%45", "%46", "%47",
+		"%48", "%49", "%4a", "%4b", "%4c", "%4d", "%4e", "%4f",
+		"%50", "%51", "%52", "%53", "%54", "%55", "%56", "%57",
+		"%58", "%59", "%5a", "%5b", "%5c", "%5d", "%5e", "%5f",
+		"%60", "%61", "%62", "%63", "%64", "%65", "%66", "%67",
+		"%68", "%69", "%6a", "%6b", "%6c", "%6d", "%6e", "%6f",
+		"%70", "%71", "%72", "%73", "%74", "%75", "%76", "%77",
+		"%78", "%79", "%7a", "%7b", "%7c", "%7d", "%7e", "%7f",
+		"%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
+		"%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",
+		"%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
+		"%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f",
+		"%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7",
+		"%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",
+		"%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",
+		"%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf",
+		"%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7",
+		"%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf",
+		"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",
+		"%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",
+		"%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7",
+		"%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef",
+		"%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",
+		"%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"
+	};
+
+
+	QString URLEncoder::encode(const char* buf,Uint32 size)
+	{
+		QString res = "";
+		
+		for (Uint32 i = 0; i < size; i++) 
+		{
+			Uint8 ch = buf[i];
+			if (('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ('0' <= ch && ch <= '9'))
+			{		// 'A'..'Z'
+				res.append((char)ch);
+			} 
+			else if (ch == ' ') 
+			{			// space
+				res.append("%20");
+			}
+			else if (ch == '-' || ch == '_'		// unreserved
+				    || ch == '.' || ch == '!'
+					|| ch == '~' || ch == '*'
+					|| ch == '\'' || ch == '('
+					|| ch == ')') 
+			{
+				res.append((char)ch);
+			} 
+			else 
+			{		// other ASCII
+				res.append(hex[ch]);
+			} 
+		}
+		return res;
+	}
+
+}
diff --git a/libktorrent/util/urlencoder.h b/libktorrent/util/urlencoder.h
new file mode 100644
index 0000000..edac33a
--- /dev/null
+++ b/libktorrent/util/urlencoder.h
@@ -0,0 +1,40 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTURLENCODER_H
+#define BTURLENCODER_H
+
+#include <qstring.h>
+#include "constants.h"
+
+namespace bt
+{
+
+	/**
+	@author Joris Guisson
+	*/
+	class URLEncoder
+	{
+	public:
+		static QString encode(const char* buf,Uint32 size);
+	};
+
+}
+
+#endif
diff --git a/libktorrent/util/waitjob.cpp b/libktorrent/util/waitjob.cpp
new file mode 100644
index 0000000..d11fa14
--- /dev/null
+++ b/libktorrent/util/waitjob.cpp
@@ -0,0 +1,86 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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.             *
+ ***************************************************************************/
+#include <torrent/globals.h>
+#include <kio/netaccess.h>
+#include "waitjob.h"
+#include "log.h"
+
+namespace bt
+{
+
+	WaitJob::WaitJob(Uint32 millis) : KIO::Job(false)
+	{
+		connect(&timer,SIGNAL(timeout()),this,SLOT(timerDone()));
+		timer.start(millis,true);
+	}
+
+
+	WaitJob::~WaitJob()
+	{}
+
+	void WaitJob::kill(bool)
+	{
+		m_error = 0;
+		emitResult();
+	}
+		
+	void WaitJob::timerDone()
+	{
+		// set the error to null and emit the result
+		m_error = 0;
+		emitResult();
+	}
+	
+	void WaitJob::addExitOperation(kt::ExitOperation* op)
+	{
+		exit_ops.append(op);
+		connect(op,SIGNAL(operationFinished( kt::ExitOperation* )),
+				this,SLOT(operationFinished( kt::ExitOperation* )));
+	}
+	
+	void WaitJob::operationFinished(kt::ExitOperation* op)
+	{
+		if (exit_ops.count() > 0)
+		{
+			exit_ops.remove(op);
+			if (op->deleteAllowed())
+				op->deleteLater();
+			
+			if (exit_ops.count() == 0)
+				timerDone();
+		}
+	}
+	
+	void WaitJob::execute(WaitJob* job)
+	{
+		KIO::NetAccess::synchronousRun(job,0);
+	}
+	
+	void SynchronousWait(Uint32 millis)
+	{
+		Out() << "SynchronousWait" << endl;
+		WaitJob* j = new WaitJob(millis);
+		KIO::NetAccess::synchronousRun(j,0);
+	}
+
+}
+
+#include "waitjob.moc"
+
diff --git a/libktorrent/util/waitjob.h b/libktorrent/util/waitjob.h
new file mode 100644
index 0000000..a85ba63
--- /dev/null
+++ b/libktorrent/util/waitjob.h
@@ -0,0 +1,78 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Joris Guisson                                   *
+ *   joris.guisson@gmail.com                                               *
+ *                                                                         *
+ *   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 BTWAITJOB_H
+#define BTWAITJOB_H
+
+#include <qtimer.h>
+#include <kio/job.h>
+#include <qvaluelist.h>
+#include <interfaces/exitoperation.h>
+#include "constants.h"
+
+namespace bt
+{
+
+	/**
+	 * @author Joris Guisson <joris.guisson@gmail.com>
+	 * 
+	 * Job to wait for a certain amount of time or until one or more ExitOperation's have
+	 * finished.
+	*/
+	class WaitJob : public KIO::Job
+	{
+		Q_OBJECT
+	public:
+		WaitJob(Uint32 millis);
+		virtual ~WaitJob();
+
+		virtual void kill(bool quietly=true);
+		
+		/**
+		 * Add an ExitOperation;
+		 * @param op The operation
+		 */
+		void addExitOperation(kt::ExitOperation* op);
+		
+		
+		/**
+		 * Execute a WaitJob
+		 * @param job The Job
+		 */
+		static void execute(WaitJob* job);
+		
+		/// Are there any ExitOperation's we need to wait for
+		bool needToWait() const {return exit_ops.count() > 0;}
+		
+	private slots:
+		void timerDone();
+		void operationFinished(kt::ExitOperation* op);
+		
+	private:
+		QTimer timer;
+		QValueList<kt::ExitOperation*> exit_ops;
+	};
+	
+	void SynchronousWait(Uint32 millis);
+	
+	
+
+}
+
+#endif