Box Backup 0.09 with a few tweeks

29 files changed, 5768 insertions, 0 deletions

diff --git a/lib/server/ConnectionException.txt b/lib/server/ConnectionException.txt
new file mode 100644
index 00000000..5056754f
--- /dev/null
+++ b/lib/server/ConnectionException.txt
@@ -0,0 +1,27 @@
+EXCEPTION Connection 7
+
+# for historic reasons not all numbers are used
+
+SocketWriteError			6	Probably a network issue between client and server.
+SocketReadError				7	Probably a network issue between client and server.
+SocketNameLookupError		9	Check hostname specified.
+SocketShutdownError			12
+SocketConnectError			15	Probably a network issue between client and server, bad hostname, or server not running.
+TLSHandshakeFailed			30
+TLSShutdownFailed			32
+TLSWriteFailed				33	Probably a network issue between client and server.
+TLSReadFailed				34	Probably a network issue between client and server.
+TLSNoPeerCertificate		36
+TLSPeerCertificateInvalid	37	Check certification process
+TLSClosedWhenWriting		38
+TLSHandshakeTimedOut		39
+Protocol_Timeout			41	Probably a network issue between client and server.
+Protocol_ObjTooBig			42
+Protocol_BadCommandRecieved				44
+Protocol_UnknownCommandRecieved			45
+Protocol_TriedToExecuteReplyCommand		46
+Protocol_UnexpectedReply				47	Server probably reported an error.
+Protocol_HandshakeFailed				48
+Protocol_StreamWhenObjExpected			49
+Protocol_ObjWhenStreamExpected			50
+Protocol_TimeOutWhenSendingStream		52	Probably a network issue between client and server.
diff --git a/lib/server/Daemon.cpp b/lib/server/Daemon.cpp
new file mode 100755
index 00000000..31997fb6
--- /dev/null
+++ b/lib/server/Daemon.cpp
@@ -0,0 +1,530 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    Daemon.cpp
+//		Purpose: Basic daemon functionality
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#include <stdio.h>
+#include <unistd.h>
+#include <syslog.h>
+#include <signal.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "Daemon.h"
+#include "Configuration.h"
+#include "ServerException.h"
+#include "Guards.h"
+#include "UnixUser.h"
+
+#include "MemLeakFindOn.h"
+
+Daemon *Daemon::spDaemon = 0;
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::Daemon()
+//		Purpose: Constructor
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+Daemon::Daemon()
+	: mpConfiguration(0),
+	  mReloadConfigWanted(false),
+	  mTerminateWanted(false)
+{
+	if(spDaemon != 0)
+	{
+		THROW_EXCEPTION(ServerException, AlreadyDaemonConstructed)
+	}
+	spDaemon = this;
+	
+	// And in debug builds, we'll switch on assert failure logging to syslog
+	ASSERT_FAILS_TO_SYSLOG_ON
+	// And trace goes to syslog too
+	TRACE_TO_SYSLOG(true)
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::~Daemon()
+//		Purpose: Destructor
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+Daemon::~Daemon()
+{
+	if(mpConfiguration)
+	{
+		delete mpConfiguration;
+		mpConfiguration = 0;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::Main(const char *, int, const char *[])
+//		Purpose: Starts the daemon off -- equivalent of C main() function
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+int Daemon::Main(const char *DefaultConfigFile, int argc, const char *argv[])
+{
+	// Banner (optional)
+	{
+		const char *banner = DaemonBanner();
+		if(banner != 0)
+		{
+			printf("%s", banner);
+		}
+	}
+
+	std::string pidFileName;
+	const char *configfile = 0;
+
+	try
+	{
+		// Find filename of config file
+		configfile = DefaultConfigFile;
+		if(argc >= 2)
+		{
+			// First argument is config file, or it's -c and the next arg is the config file
+			if(::strcmp(argv[1], "-c") == 0 && argc >= 3)
+			{
+				configfile = argv[2];
+			}
+			else
+			{
+				configfile = argv[1];
+			}
+		}
+		
+		// Test mode with no daemonisation?
+		bool asDaemon = true;
+		if(argc >= 3)
+		{
+			if(::strcmp(argv[2], "SINGLEPROCESS") == 0)
+			{
+				asDaemon = false;
+			}
+		}
+
+		// Load the configuration file.
+		std::string errors;
+		std::auto_ptr<Configuration> pconfig = Configuration::LoadAndVerify(configfile, GetConfigVerify(), errors);
+
+		// Got errors?
+		if(pconfig.get() == 0 || !errors.empty())
+		{
+			// Tell user about errors
+			fprintf(stderr, "%s: Errors in config file %s:\n%s", DaemonName(), configfile, errors.c_str());
+			// And give up
+			return 1;
+		}
+		
+		// Store configuration
+		mpConfiguration = pconfig.release();
+		
+		// Server configuration
+		const Configuration &serverConfig(mpConfiguration->GetSubConfiguration("Server"));
+		
+		// Let the derived class have a go at setting up stuff in the initial process
+		SetupInInitialProcess();
+		
+		// Set signal handler
+		if(::signal(SIGHUP, SignalHandler) == SIG_ERR || ::signal(SIGTERM, SignalHandler) == SIG_ERR)
+		{
+			THROW_EXCEPTION(ServerException, DaemoniseFailed)
+		}
+		
+		// Open PID file for writing
+		pidFileName = serverConfig.GetKeyValue("PidFile");
+		FileHandleGuard<(O_WRONLY | O_CREAT | O_TRUNC), (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)> pidFile(pidFileName.c_str());
+		
+		// Handle changing to a different user
+		if(serverConfig.KeyExists("User"))
+		{
+			// Config file specifies an user -- look up
+			UnixUser daemonUser(serverConfig.GetKeyValue("User").c_str());
+			
+			// Change the owner on the PID file, so it can be deleted properly on termination
+			if(::fchown(pidFile, daemonUser.GetUID(), daemonUser.GetGID()) != 0)
+			{
+				THROW_EXCEPTION(ServerException, CouldNotChangePIDFileOwner)
+			}
+			
+			// Change the process ID
+			daemonUser.ChangeProcessUser();
+		}
+	
+		if(asDaemon)
+		{
+			// Let's go... Daemonise...
+			switch(::fork())
+			{
+			case -1:
+				// error
+				THROW_EXCEPTION(ServerException, DaemoniseFailed)
+				break;
+
+			default:
+				// parent
+				_exit(0);
+				return 0;
+				break;
+
+			case 0:
+				// child
+				break;
+			}
+
+			// In child
+
+			// Set new session
+			if(::setsid() == -1)
+			{
+				::syslog(LOG_ERR, "can't setsid");
+				THROW_EXCEPTION(ServerException, DaemoniseFailed)
+			}
+
+			// Fork again...
+			switch(::fork())
+			{
+			case -1:
+				// error
+				THROW_EXCEPTION(ServerException, DaemoniseFailed)
+				break;
+
+			default:
+				// parent
+				_exit(0);
+				return 0;
+				break;
+
+			case 0:
+				// child
+				break;
+			}
+		}
+
+		// open the log
+		::openlog(DaemonName(), LOG_PID, LOG_LOCAL6);
+		// Log the start message
+		::syslog(LOG_INFO, "Starting daemon (config: %s) (version " BOX_VERSION ")", configfile);
+
+		// Write PID to file
+		char pid[32];
+		int pidsize = sprintf(pid, "%d", (int)getpid());
+		if(::write(pidFile, pid, pidsize) != pidsize)
+		{
+			::syslog(LOG_ERR, "can't write pid file");
+			THROW_EXCEPTION(ServerException, DaemoniseFailed)
+		}
+		
+		// Set up memory leak reporting
+		#ifdef BOX_MEMORY_LEAK_TESTING
+		{
+			char filename[256];
+			sprintf(filename, "%s.memleaks", DaemonName());
+			memleakfinder_setup_exit_report(filename, DaemonName());
+		}
+		#endif // BOX_MEMORY_LEAK_TESTING
+	
+		if(asDaemon)
+		{
+			// Close standard streams
+			::close(0);
+			::close(1);
+			::close(2);
+			
+			// Open and redirect them into /dev/null
+			int devnull = ::open(PLATFORM_DEV_NULL, O_RDWR, 0);
+			if(devnull == -1)
+			{
+				THROW_EXCEPTION(CommonException, OSFileError);
+			}
+			// Then duplicate them to all three handles
+			if(devnull != 0) dup2(devnull, 0);
+			if(devnull != 1) dup2(devnull, 1);
+			if(devnull != 2) dup2(devnull, 2);
+			// Close the original handle if it was opened above the std* range
+			if(devnull > 2)
+			{
+				::close(devnull);
+			}
+			
+			// And definately don't try and send anything to those file descriptors
+			// -- this has in the past sent text to something which isn't expecting it.
+			TRACE_TO_STDOUT(false);
+		}		
+	}
+	catch(BoxException &e)
+	{
+		fprintf(stderr, "%s: exception %s (%d/%d)\n", DaemonName(), e.what(), e.GetType(), e.GetSubType());
+		return 1;
+	}
+	catch(std::exception &e)
+	{
+		fprintf(stderr, "%s: exception %s\n", DaemonName(), e.what());
+		return 1;
+	}
+	catch(...)
+	{
+		fprintf(stderr, "%s: unknown exception\n", DaemonName());
+		return 1;
+	}
+	
+	// Main Daemon running
+	try
+	{
+		while(!mTerminateWanted)
+		{
+			Run();
+			
+			if(mReloadConfigWanted && !mTerminateWanted)
+			{
+				// Need to reload that config file...
+				::syslog(LOG_INFO, "Reloading configuration (config: %s)", configfile);
+				std::string errors;
+				std::auto_ptr<Configuration> pconfig = Configuration::LoadAndVerify(configfile, GetConfigVerify(), errors);
+
+				// Got errors?
+				if(pconfig.get() == 0 || !errors.empty())
+				{
+					// Tell user about errors
+					::syslog(LOG_ERR, "Errors in config file %s:\n%s", configfile, errors.c_str());
+					// And give up
+					return 1;
+				}
+				
+				// delete old configuration
+				delete mpConfiguration;
+				mpConfiguration = 0;
+
+				// Store configuration
+				mpConfiguration = pconfig.release();
+				
+				// Stop being marked for loading config again
+				mReloadConfigWanted = false;
+			}
+		}
+		
+		// Delete the PID file
+		::unlink(pidFileName.c_str());
+		
+		// Log
+		::syslog(LOG_INFO, "Terminating daemon");
+	}
+	catch(BoxException &e)
+	{
+		::syslog(LOG_ERR, "exception %s (%d/%d) -- terminating", e.what(), e.GetType(), e.GetSubType());
+		return 1;
+	}
+	catch(std::exception &e)
+	{
+		::syslog(LOG_ERR, "exception %s -- terminating", e.what());
+		return 1;
+	}
+	catch(...)
+	{
+		::syslog(LOG_ERR, "unknown exception -- terminating");
+		return 1;
+	}
+	
+	return 0;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::EnterChild()
+//		Purpose: Sets up for a child task of the main server. Call just after fork()
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+void Daemon::EnterChild()
+{
+	// Unset signal handlers
+	::signal(SIGHUP, SIG_DFL);
+	::signal(SIGTERM, SIG_DFL);
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::SignalHandler(int)
+//		Purpose: Signal handler
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+void Daemon::SignalHandler(int sigraised)
+{
+	if(spDaemon != 0)
+	{
+		switch(sigraised)
+		{
+		case SIGHUP:
+			spDaemon->mReloadConfigWanted = true;
+			break;
+			
+		case SIGTERM:
+			spDaemon->mTerminateWanted = true;
+			break;
+		
+		default:
+			break;
+		}
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::DaemonName() 
+//		Purpose: Returns name of the daemon
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+const char *Daemon::DaemonName() const
+{
+	return "generic-daemon";
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::DaemonBanner()
+//		Purpose: Returns the text banner for this daemon's startup
+//		Created: 1/1/04
+//
+// --------------------------------------------------------------------------
+const char *Daemon::DaemonBanner() const
+{
+	return 0;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::Run()
+//		Purpose: Main run function after basic Daemon initialisation
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+void Daemon::Run()
+{
+	while(!StopRun())
+	{
+		::sleep(10);
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::GetConfigVerify()
+//		Purpose: Returns the configuration file verification structure for this daemon
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+const ConfigurationVerify *Daemon::GetConfigVerify() const
+{
+	static ConfigurationVerifyKey verifyserverkeys[] = 
+	{
+		DAEMON_VERIFY_SERVER_KEYS
+	};
+
+	static ConfigurationVerify verifyserver[] = 
+	{
+		{
+			"Server",
+			0,
+			verifyserverkeys,
+			ConfigTest_Exists | ConfigTest_LastEntry,
+			0
+		}
+	};
+
+	static ConfigurationVerify verify =
+	{
+		"root",
+		verifyserver,
+		0,
+		ConfigTest_Exists | ConfigTest_LastEntry,
+		0
+	};
+
+	return &verify;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::GetConfiguration()
+//		Purpose: Returns the daemon configuration object
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+const Configuration &Daemon::GetConfiguration() const
+{
+	if(mpConfiguration == 0)
+	{
+		// Shouldn't get anywhere near this if a configuration file can't be loaded
+		THROW_EXCEPTION(ServerException, Internal)
+	}
+	
+	return *mpConfiguration;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Daemon::SetupInInitialProcess()
+//		Purpose: A chance for the daemon to do something initial setting up in the process which
+//				 initiates everything, and after the configuration file has been read and verified.
+//		Created: 2003/08/20
+//
+// --------------------------------------------------------------------------
+void Daemon::SetupInInitialProcess()
+{
+	// Base class doesn't do anything.
+}
+
+
+void Daemon::SetProcessTitle(const char *format, ...)
+{
+	// On OpenBSD, setproctitle() sets the process title to imagename: <text> (imagename)
+	// -- make sure other platforms include the image name somewhere so ps listings give
+	// useful information.
+
+#ifdef PLATFORM_HAVE_setproctitle
+	// optional arguments
+	va_list args;
+	va_start(args, format);
+
+	// Make the string
+	char title[256];
+	::vsnprintf(title, sizeof(title), format, args);
+	
+	// Set process title
+	::setproctitle("%s", title);
+	
+#endif // PLATFORM_HAVE_setproctitle
+}
+
+
diff --git a/lib/server/Daemon.h b/lib/server/Daemon.h
new file mode 100755
index 00000000..a7b9488b
--- /dev/null
+++ b/lib/server/Daemon.h
@@ -0,0 +1,75 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    Daemon.h
+//		Purpose: Basic daemon functionality
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+
+/*  NOTE: will log to local6: include a line like
+	local6.info                                             /var/log/box
+	in /etc/syslog.conf
+*/
+
+
+#ifndef DAEMON__H
+#define DAEMON__H
+
+class Configuration;
+class ConfigurationVerify;
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    Daemon
+//		Purpose: Basic daemon functionality
+//		Created: 2003/07/29
+//
+// --------------------------------------------------------------------------
+class Daemon
+{
+public:
+	Daemon();
+	virtual ~Daemon();
+private:
+	Daemon(const Daemon &rToCopy);
+public:
+
+	int Main(const char *DefaultConfigFile, int argc, const char *argv[]);
+	
+	virtual void Run();
+	const Configuration &GetConfiguration() const;
+	
+	virtual const char *DaemonName() const;
+	virtual const char *DaemonBanner() const;
+	virtual const ConfigurationVerify *GetConfigVerify() const;
+	
+	bool StopRun() {return mReloadConfigWanted | mTerminateWanted;}
+	bool IsReloadConfigWanted() {return mReloadConfigWanted;}
+	bool IsTerminateWanted() {return mTerminateWanted;}
+
+	// To allow derived classes to get these signals in other ways
+	void SetReloadConfigWanted() {mReloadConfigWanted = true;}
+	void SetTerminateWanted() {mTerminateWanted = true;}
+	
+	virtual void SetupInInitialProcess();
+	virtual void EnterChild();
+	
+	static void SetProcessTitle(const char *format, ...);
+	
+private:
+	static void SignalHandler(int sigraised);
+	
+private:
+	Configuration *mpConfiguration;
+	bool mReloadConfigWanted;
+	bool mTerminateWanted;
+	static Daemon *spDaemon;
+};
+
+#define DAEMON_VERIFY_SERVER_KEYS 	{"PidFile", 0, ConfigTest_Exists, 0}, \
+									{"User", 0, ConfigTest_LastEntry, 0}
+
+#endif // DAEMON__H
+
diff --git a/lib/server/LocalProcessStream.cpp b/lib/server/LocalProcessStream.cpp
new file mode 100644
index 00000000..f2a97c56
--- /dev/null
+++ b/lib/server/LocalProcessStream.cpp
@@ -0,0 +1,101 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    LocalProcessStream.cpp
+//		Purpose: Opens a process, and presents stdin/stdout as a stream.
+//		Created: 12/3/04
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "LocalProcessStream.h"
+#include "SocketStream.h"
+#include "autogen_ServerException.h"
+#include "Utils.h"
+
+#include "MemLeakFindOn.h"
+
+#define MAX_ARGUMENTS	64
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    LocalProcessStream(const char *, pid_t &)
+//		Purpose: Run a new process, and return a stream giving access to it's
+//				 stdin and stdout. Returns the PID of the new process -- this
+//				 must be waited on at some point to avoid zombies.
+//		Created: 12/3/04
+//
+// --------------------------------------------------------------------------
+std::auto_ptr<IOStream> LocalProcessStream(const char *CommandLine, pid_t &rPidOut)
+{
+	// Split up command
+	std::vector<std::string> command;
+	SplitString(std::string(CommandLine), ' ', command);
+	// Build arguments
+	char *args[MAX_ARGUMENTS + 4];
+	{
+		int a = 0;
+		std::vector<std::string>::const_iterator i(command.begin());
+		while(a < MAX_ARGUMENTS && i != command.end())
+		{
+			args[a++] = (char*)(*(i++)).c_str();
+		}
+		args[a] = NULL;
+	}
+
+	// Create a socket pair to communicate over.
+	int sv[2] = {-1,-1};
+	if(::socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, sv) != 0)
+	{
+		THROW_EXCEPTION(ServerException, SocketPairFailed)
+	}
+	
+	std::auto_ptr<IOStream> stream(new SocketStream(sv[0]));
+
+	// Fork
+	pid_t pid = 0;
+	switch(pid = vfork())
+	{
+	case -1:	// error
+		::close(sv[0]);
+		::close(sv[1]);
+		THROW_EXCEPTION(ServerException, ServerForkError)
+		break;
+		
+	case 0:		// child
+		// Close end of the socket not being used
+		::close(sv[0]);
+		// Duplicate the file handles to stdin and stdout
+		if(sv[1] != 0) ::dup2(sv[1], 0);
+		if(sv[1] != 1) ::dup2(sv[1], 1);
+		// Close the now redundant socket
+		if(sv[1] != 0 && sv[1] != 1)
+		{
+			::close(sv[1]);
+		}
+		// Execute command!
+		::execv(args[0], args);
+		::_exit(127);	// report error
+		break;
+	
+	default:
+		// just continue...
+		break;
+	}
+	
+	// Close the file descriptor not being used
+	::close(sv[1]);
+
+	// Return the stream object and PID
+	rPidOut = pid;
+	return stream;	
+}
+
+
+
+
diff --git a/lib/server/LocalProcessStream.h b/lib/server/LocalProcessStream.h
new file mode 100644
index 00000000..490c0f45
--- /dev/null
+++ b/lib/server/LocalProcessStream.h
@@ -0,0 +1,19 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    LocalProcessStream.h
+//		Purpose: Opens a process, and presents stdin/stdout as a stream.
+//		Created: 12/3/04
+//
+// --------------------------------------------------------------------------
+
+#ifndef LOCALPROCESSSTREAM__H
+#define LOCALPROCESSSTREAM__H
+
+#include <memory>
+#include "IOStream.h"
+
+std::auto_ptr<IOStream> LocalProcessStream(const char *CommandLine, pid_t &rPidOut);
+
+#endif // LOCALPROCESSSTREAM__H
+
diff --git a/lib/server/Makefile.extra b/lib/server/Makefile.extra
new file mode 100755
index 00000000..6cc0de2e
--- /dev/null
+++ b/lib/server/Makefile.extra
@@ -0,0 +1,11 @@
+
+MAKEEXCEPTION = ../../lib/common/makeexception.pl
+
+# AUTOGEN SEEDING
+autogen_ServerException.h autogen_ServerException.cpp:	$(MAKEEXCEPTION) ServerException.txt
+	perl $(MAKEEXCEPTION) ServerException.txt
+
+# AUTOGEN SEEDING
+autogen_ConnectionException.h autogen_ConnectionException.cpp:	$(MAKEEXCEPTION) ConnectionException.txt
+	perl $(MAKEEXCEPTION) ConnectionException.txt
+
diff --git a/lib/server/Protocol.cpp b/lib/server/Protocol.cpp
new file mode 100755
index 00000000..ca89bdf1
--- /dev/null
+++ b/lib/server/Protocol.cpp
@@ -0,0 +1,1120 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    Protocol.cpp
+//		Purpose: Generic protocol support
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <new>
+
+#include "Protocol.h"
+#include "ProtocolWire.h"
+#include "IOStream.h"
+#include "ServerException.h"
+#include "PartialReadStream.h"
+#include "ProtocolUncertainStream.h"
+
+#include "MemLeakFindOn.h"
+
+#ifdef NDEBUG
+	#define PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK	1024
+#else
+//	#define PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK	1024
+	#define PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK	4
+#endif
+
+#define UNCERTAIN_STREAM_SIZE_BLOCK	(64*1024)
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Protocol(IOStream &rStream)
+//		Purpose: Constructor
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+Protocol::Protocol(IOStream &rStream)
+	: mrStream(rStream),
+	  mHandshakeDone(false),
+	  mMaxObjectSize(PROTOCOL_DEFAULT_MAXOBJSIZE),
+	  mTimeout(PROTOCOL_DEFAULT_TIMEOUT),
+	  mpBuffer(0),
+	  mBufferSize(0),
+	  mReadOffset(-1),
+	  mWriteOffset(-1),
+	  mValidDataSize(-1),
+	  mLastErrorType(NoError),
+	  mLastErrorSubType(NoError)
+{
+	TRACE1("Send block allocation size is %d\n", PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::~Protocol()
+//		Purpose: Destructor
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+Protocol::~Protocol()
+{
+	// Free buffer?
+	if(mpBuffer != 0)
+	{
+		free(mpBuffer);
+		mpBuffer = 0;
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::GetLastError(int &, int &)
+//		Purpose: Returns true if there was an error, and type and subtype if there was.
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+bool Protocol::GetLastError(int &rTypeOut, int &rSubTypeOut)
+{
+	if(mLastErrorType == NoError)
+	{
+		// no error.
+		return false;
+	}
+	
+	// Return type and subtype in args
+	rTypeOut = mLastErrorType;
+	rSubTypeOut = mLastErrorSubType;
+	
+	// and unset them
+	mLastErrorType = NoError;
+	mLastErrorSubType = NoError;
+	
+	return true;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Handshake()
+//		Purpose: Handshake with peer (exchange ident strings)
+//		Created: 2003/08/20
+//
+// --------------------------------------------------------------------------
+void Protocol::Handshake()
+{
+	// Already done?
+	if(mHandshakeDone)
+	{
+		THROW_EXCEPTION(CommonException, Internal)
+	}
+
+	// Make handshake block
+	PW_Handshake hsSend;
+	::memset(&hsSend, 0, sizeof(hsSend));
+	// Copy in ident string
+	::strncpy(hsSend.mIdent, GetIdentString(), sizeof(hsSend.mIdent));
+	
+	// Send it
+	mrStream.Write(&hsSend, sizeof(hsSend));
+	mrStream.WriteAllBuffered();
+
+	// Receive a handshake from the peer
+	PW_Handshake hsReceive;
+	::memset(&hsReceive, 0, sizeof(hsReceive));
+	char *readInto = (char*)&hsReceive;
+	int bytesToRead = sizeof(hsReceive);
+	while(bytesToRead > 0)
+	{
+		// Get some data from the stream
+		int bytesRead = mrStream.Read(readInto, bytesToRead, mTimeout);
+		if(bytesRead == 0)
+		{
+			THROW_EXCEPTION(ConnectionException, Conn_Protocol_Timeout)
+		}
+		readInto += bytesRead;
+		bytesToRead -= bytesRead;
+	}
+	ASSERT(bytesToRead == 0);
+	
+	// Are they the same?
+	if(::memcmp(&hsSend, &hsReceive, sizeof(hsSend)) != 0)
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_HandshakeFailed)
+	}
+
+	// Mark as done
+	mHandshakeDone = true;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::CheckAndReadHdr(void *)
+//		Purpose: Check read for recieve call and get object header from stream.
+//				 Don't use type here to avoid dependency in .h file.
+//		Created: 2003/08/26
+//
+// --------------------------------------------------------------------------
+void Protocol::CheckAndReadHdr(void *hdr)
+{
+	// Check usage
+	if(mValidDataSize != -1 || mWriteOffset != -1 || mReadOffset != -1)
+	{
+		THROW_EXCEPTION(ServerException, Protocol_BadUsage)
+	}
+	
+	// Handshake done?
+	if(!mHandshakeDone)
+	{
+		Handshake();
+	}
+
+	// Get some data into this header
+	if(!mrStream.ReadFullBuffer(hdr, sizeof(PW_ObjectHeader), 0 /* not interested in bytes read if this fails */, mTimeout))
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_Timeout)
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Recieve()
+//		Purpose: Recieves an object from the stream, creating it from the factory object type
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+std::auto_ptr<ProtocolObject> Protocol::Receive()
+{
+	// Get object header
+	PW_ObjectHeader objHeader;
+	CheckAndReadHdr(&objHeader);
+	
+	// Hope it's not a stream
+	if(ntohl(objHeader.mObjType) == SPECIAL_STREAM_OBJECT_TYPE)
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_StreamWhenObjExpected)
+	}
+	
+	// Check the object size
+	u_int32_t objSize = ntohl(objHeader.mObjSize);
+	if(objSize < sizeof(objHeader) || objSize > mMaxObjectSize)
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_ObjTooBig)
+	}
+
+	// Create a blank object
+	std::auto_ptr<ProtocolObject> obj(MakeProtocolObject(ntohl(objHeader.mObjType)));
+
+	// Make sure memory is allocated to read it into
+	EnsureBufferAllocated(objSize);
+	
+	// Read data
+	if(!mrStream.ReadFullBuffer(mpBuffer, objSize - sizeof(objHeader), 0 /* not interested in bytes read if this fails */, mTimeout))
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_Timeout)
+	}
+
+	// Setup ready to read out data from the buffer
+	mValidDataSize = objSize - sizeof(objHeader);
+	mReadOffset = 0;
+
+	// Get the object to read its properties from the data recieved
+	try
+	{
+		obj->SetPropertiesFromStreamData(*this);
+	}
+	catch(...)
+	{
+		// Make sure state is reset!
+		mValidDataSize = -1;
+		mReadOffset = -1;
+		throw;
+	}
+	
+	// Any data left over?
+	bool dataLeftOver = (mValidDataSize != mReadOffset);
+	
+	// Unset read state, so future read calls don't fail
+	mValidDataSize = -1;
+	mReadOffset = -1;
+	
+	// Exception if not all the data was consumed
+	if(dataLeftOver)
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_BadCommandRecieved)
+	}
+
+	return obj;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Send()
+//		Purpose: Send an object to the other side of the connection.
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Send(const ProtocolObject &rObject)
+{
+	// Check usage
+	if(mValidDataSize != -1 || mWriteOffset != -1 || mReadOffset != -1)
+	{
+		THROW_EXCEPTION(ServerException, Protocol_BadUsage)
+	}
+
+	// Handshake done?
+	if(!mHandshakeDone)
+	{
+		Handshake();
+	}
+
+	// Make sure there's a little bit of space allocated
+	EnsureBufferAllocated(((sizeof(PW_ObjectHeader) + PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK - 1) / PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK) * PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK);
+	ASSERT(mBufferSize >= (int)sizeof(PW_ObjectHeader));
+	
+	// Setup for write operation
+	mValidDataSize = 0;		// Not used, but must not be -1
+	mWriteOffset = sizeof(PW_ObjectHeader);
+	
+	try
+	{
+		rObject.WritePropertiesToStreamData(*this);
+	}
+	catch(...)
+	{
+		// Make sure state is reset!
+		mValidDataSize = -1;
+		mWriteOffset = -1;
+		throw;
+	}
+
+	// How big?
+	int writtenSize = mWriteOffset;
+
+	// Reset write state
+	mValidDataSize = -1;
+	mWriteOffset = -1;	
+	
+	// Make header in the existing block
+	PW_ObjectHeader *pobjHeader = (PW_ObjectHeader*)(mpBuffer);
+	pobjHeader->mObjSize = htonl(writtenSize);
+	pobjHeader->mObjType = htonl(rObject.GetType());
+
+	// Write data
+	mrStream.Write(mpBuffer, writtenSize);
+	mrStream.WriteAllBuffered();
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::EnsureBufferAllocated(int)
+//		Purpose: Private. Ensures the buffer is at least the size requested.
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::EnsureBufferAllocated(int Size)
+{
+	if(mpBuffer != 0 && mBufferSize >= Size)
+	{
+		// Nothing to do!
+		return;
+	}
+	
+	// Need to allocate, or reallocate, the block
+	if(mpBuffer != 0)
+	{
+		// Reallocate
+		void *b = realloc(mpBuffer, Size);
+		if(b == 0)
+		{
+			throw std::bad_alloc();
+		}
+		mpBuffer = (char*)b;
+		mBufferSize = Size;
+	}
+	else
+	{
+		// Just allocate
+		mpBuffer = (char*)malloc(Size);
+		if(mpBuffer == 0)
+		{
+			throw std::bad_alloc();
+		}
+		mBufferSize = Size;
+	}
+}
+
+
+#define READ_START_CHECK														\
+	if(mValidDataSize == -1 || mWriteOffset != -1 || mReadOffset == -1)			\
+	{																			\
+		THROW_EXCEPTION(ServerException, Protocol_BadUsage)						\
+	}
+
+#define READ_CHECK_BYTES_AVAILABLE(bytesRequired)								\
+	if((mReadOffset + (int)(bytesRequired)) > mValidDataSize)					\
+	{																			\
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_BadCommandRecieved)	\
+	}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Read(void *, int)
+//		Purpose: Read raw data from the stream (buffered)
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Read(void *Buffer, int Size)
+{
+	READ_START_CHECK
+	READ_CHECK_BYTES_AVAILABLE(Size)
+	
+	// Copy data out
+	::memmove(Buffer, mpBuffer + mReadOffset, Size);
+	mReadOffset += Size;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Read(std::string &, int)
+//		Purpose: Read raw data from the stream (buffered), into a std::string
+//		Created: 2003/08/26
+//
+// --------------------------------------------------------------------------
+void Protocol::Read(std::string &rOut, int Size)
+{
+	READ_START_CHECK
+	READ_CHECK_BYTES_AVAILABLE(Size)
+	
+	rOut.assign(mpBuffer + mReadOffset, Size);
+	mReadOffset += Size;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Read(int64_t &)
+//		Purpose: Read a value from the stream (buffered)
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Read(int64_t &rOut)
+{
+	READ_START_CHECK
+	READ_CHECK_BYTES_AVAILABLE(sizeof(int64_t))
+	
+	rOut = ntoh64(*((int64_t*)(mpBuffer + mReadOffset)));
+	mReadOffset += sizeof(int64_t);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Read(int32_t &)
+//		Purpose: Read a value from the stream (buffered)
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Read(int32_t &rOut)
+{
+	READ_START_CHECK
+	READ_CHECK_BYTES_AVAILABLE(sizeof(int32_t))
+	
+	rOut = ntohl(*((int32_t*)(mpBuffer + mReadOffset)));
+	mReadOffset += sizeof(int32_t);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Read(int16_t &)
+//		Purpose: Read a value from the stream (buffered)
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Read(int16_t &rOut)
+{
+	READ_START_CHECK
+	READ_CHECK_BYTES_AVAILABLE(sizeof(int16_t))
+
+	rOut = ntohs(*((int16_t*)(mpBuffer + mReadOffset)));
+	mReadOffset += sizeof(int16_t);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Read(int8_t &)
+//		Purpose: Read a value from the stream (buffered)
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Read(int8_t &rOut)
+{
+	READ_START_CHECK
+	READ_CHECK_BYTES_AVAILABLE(sizeof(int8_t))
+
+	rOut = *((int8_t*)(mpBuffer + mReadOffset));
+	mReadOffset += sizeof(int8_t);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Read(std::string &)
+//		Purpose: Read a value from the stream (buffered)
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Read(std::string &rOut)
+{
+	// READ_START_CHECK implied
+	int32_t size;
+	Read(size);
+	
+	READ_CHECK_BYTES_AVAILABLE(size)
+	
+	// initialise string
+	rOut.assign(mpBuffer + mReadOffset, size);
+	mReadOffset += size;
+}
+
+
+
+
+#define WRITE_START_CHECK														\
+	if(mValidDataSize == -1 || mWriteOffset == -1 || mReadOffset != -1)			\
+	{																			\
+		THROW_EXCEPTION(ServerException, Protocol_BadUsage)						\
+	}
+
+#define WRITE_ENSURE_BYTES_AVAILABLE(bytesToWrite)								\
+	if(mWriteOffset + (int)(bytesToWrite) > mBufferSize)						\
+	{																			\
+		EnsureBufferAllocated((((mWriteOffset + (int)(bytesToWrite)) + PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK - 1) / PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK) * PROTOCOL_ALLOCATE_SEND_BLOCK_CHUNK); \
+		ASSERT(mWriteOffset + (int)(bytesToWrite) <= mBufferSize);			\
+	}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Write(const void *, int)
+//		Purpose: Writes the contents of a buffer to the stream
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Write(const void *Buffer, int Size)
+{
+	WRITE_START_CHECK
+	WRITE_ENSURE_BYTES_AVAILABLE(Size)
+	
+	::memmove(mpBuffer + mWriteOffset, Buffer, Size);
+	mWriteOffset += Size;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Write(int64_t)
+//		Purpose: Writes a value to the stream
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Write(int64_t Value)
+{
+	WRITE_START_CHECK
+	WRITE_ENSURE_BYTES_AVAILABLE(sizeof(int64_t))
+
+	*((int64_t*)(mpBuffer + mWriteOffset)) = hton64(Value);
+	mWriteOffset += sizeof(int64_t);
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Write(int32_t)
+//		Purpose: Writes a value to the stream
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Write(int32_t Value)
+{
+	WRITE_START_CHECK
+	WRITE_ENSURE_BYTES_AVAILABLE(sizeof(int32_t))
+
+	*((int32_t*)(mpBuffer + mWriteOffset)) = htonl(Value);
+	mWriteOffset += sizeof(int32_t);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Write(int16_t)
+//		Purpose: Writes a value to the stream
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Write(int16_t Value)
+{
+	WRITE_START_CHECK
+	WRITE_ENSURE_BYTES_AVAILABLE(sizeof(int16_t))
+
+	*((int16_t*)(mpBuffer + mWriteOffset)) = htons(Value);
+	mWriteOffset += sizeof(int16_t);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Write(int8_t)
+//		Purpose: Writes a value to the stream
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Write(int8_t Value)
+{
+	WRITE_START_CHECK
+	WRITE_ENSURE_BYTES_AVAILABLE(sizeof(int8_t))
+
+	*((int8_t*)(mpBuffer + mWriteOffset)) = Value;
+	mWriteOffset += sizeof(int8_t);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::Write(const std::string &)
+//		Purpose: Writes a value to the stream
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void Protocol::Write(const std::string &rValue)
+{
+	// WRITE_START_CHECK implied
+	Write((int32_t)(rValue.size()));
+	
+	WRITE_ENSURE_BYTES_AVAILABLE(rValue.size())
+	Write(rValue.c_str(), rValue.size());
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::ReceieveStream()
+//		Purpose: Receive a stream from the remote side
+//		Created: 2003/08/26
+//
+// --------------------------------------------------------------------------
+std::auto_ptr<IOStream> Protocol::ReceiveStream()
+{
+	// Get object header
+	PW_ObjectHeader objHeader;
+	CheckAndReadHdr(&objHeader);
+	
+	// Hope it's not an object
+	if(ntohl(objHeader.mObjType) != SPECIAL_STREAM_OBJECT_TYPE)
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_ObjWhenStreamExpected)
+	}
+	
+	// Get the stream size
+	u_int32_t streamSize = ntohl(objHeader.mObjSize);
+
+	// Inform sub class
+	InformStreamReceiving(streamSize);
+
+	// Return a stream object
+	return std::auto_ptr<IOStream>((streamSize == ProtocolStream_SizeUncertain)?
+		((IOStream*)(new ProtocolUncertainStream(mrStream)))
+		:((IOStream*)(new PartialReadStream(mrStream, streamSize))));
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::SendStream(IOStream &)
+//		Purpose: Send a stream to the remote side
+//		Created: 2003/08/26
+//
+// --------------------------------------------------------------------------
+void Protocol::SendStream(IOStream &rStream)
+{
+	// Check usage
+	if(mValidDataSize != -1 || mWriteOffset != -1 || mReadOffset != -1)
+	{
+		THROW_EXCEPTION(ServerException, Protocol_BadUsage)
+	}
+
+	// Handshake done?
+	if(!mHandshakeDone)
+	{
+		Handshake();
+	}
+
+	// How should this be streamed?
+	bool uncertainSize = false;
+	IOStream::pos_type streamSize = rStream.BytesLeftToRead();
+	if(streamSize == IOStream::SizeOfStreamUnknown
+		|| streamSize > 0x7fffffff)
+	{
+		// Can't send this using the fixed size header
+		uncertainSize = true;
+	}
+	
+	// Inform sub class
+	InformStreamSending(streamSize);
+	
+	// Make header
+	PW_ObjectHeader objHeader;
+	objHeader.mObjSize = htonl(uncertainSize?(ProtocolStream_SizeUncertain):streamSize);
+	objHeader.mObjType = htonl(SPECIAL_STREAM_OBJECT_TYPE);
+
+	// Write header
+	mrStream.Write(&objHeader, sizeof(objHeader));
+	// Could be sent in one of two ways
+	if(uncertainSize)
+	{
+		// Don't know how big this is going to be -- so send it in chunks
+		
+		// Allocate memory
+		uint8_t *blockA = (uint8_t *)malloc(UNCERTAIN_STREAM_SIZE_BLOCK + sizeof(int));
+		if(blockA == 0)
+		{
+			throw std::bad_alloc();
+		}
+		uint8_t *block = blockA + sizeof(int);	// so that everything is word aligned for reading, but can put the one byte header before it
+		
+		try
+		{
+			int bytesInBlock = 0;
+			while(rStream.StreamDataLeft())
+			{
+				// Read some of it
+				bytesInBlock += rStream.Read(block + bytesInBlock, UNCERTAIN_STREAM_SIZE_BLOCK - bytesInBlock);
+				
+				// Send as much as we can out
+				bytesInBlock -= SendStreamSendBlock(block, bytesInBlock);
+			}
+
+			// Everything recieved from stream, but need to send whatevers left in the block
+			while(bytesInBlock > 0)
+			{
+				bytesInBlock -= SendStreamSendBlock(block, bytesInBlock);
+			}
+			
+			// Send final byte to finish the stream
+			uint8_t endOfStream = ProtocolStreamHeader_EndOfStream;
+			mrStream.Write(&endOfStream, 1);
+		}
+		catch(...)
+		{
+			free(blockA);
+			throw;
+		}
+		
+		// Clean up
+		free(blockA);
+	}
+	else
+	{
+		// Fixed size stream, send it all in one go
+		if(!rStream.CopyStreamTo(mrStream, mTimeout, 4096 /* slightly larger buffer */))
+		{
+			THROW_EXCEPTION(ConnectionException, Conn_Protocol_TimeOutWhenSendingStream)
+		}
+	}
+	// Make sure everything is written
+	mrStream.WriteAllBuffered();
+	
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::SendStreamSendBlock(uint8_t *, int)
+//		Purpose: Sends as much of the block as can be sent, moves the remainer down to the beginning,
+//				 and returns the number of bytes sent. WARNING: Will write to Block[-1]
+//		Created: 5/12/03
+//
+// --------------------------------------------------------------------------
+int Protocol::SendStreamSendBlock(uint8_t *Block, int BytesInBlock)
+{
+	// Quick sanity check
+	if(BytesInBlock == 0)
+	{
+		return 0;
+	}
+	
+	// Work out the header byte
+	uint8_t header = 0;
+	int writeSize = 0;
+	if(BytesInBlock >= (64*1024))
+	{
+		header = ProtocolStreamHeader_SizeIs64k;
+		writeSize = (64*1024);
+	}
+	else
+	{
+		// Scan the table to find the most that can be written
+		for(int s = ProtocolStreamHeader_MaxEncodedSizeValue; s > 0; --s)
+		{
+			if(sProtocolStreamHeaderLengths[s] <= BytesInBlock)
+			{
+				header = s;
+				writeSize = sProtocolStreamHeaderLengths[s];
+				break;
+			}
+		}
+	}
+	ASSERT(header > 0);
+	
+	// Store the header
+	Block[-1] = header;
+	
+	// Write everything out
+	mrStream.Write(Block - 1, writeSize + 1);
+	
+	// move the remainer to the beginning of the block for the next time round
+	if(writeSize != BytesInBlock)
+	{
+		::memmove(Block, Block + writeSize, BytesInBlock - writeSize);
+	}
+	
+	return writeSize;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::InformStreamReceiving(u_int32_t)
+//		Purpose: Informs sub classes about streams being received
+//		Created: 2003/10/27
+//
+// --------------------------------------------------------------------------
+void Protocol::InformStreamReceiving(u_int32_t Size)
+{
+	// Do nothing
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Protocol::InformStreamSending(u_int32_t)
+//		Purpose: Informs sub classes about streams being sent
+//		Created: 2003/10/27
+//
+// --------------------------------------------------------------------------
+void Protocol::InformStreamSending(u_int32_t Size)
+{
+	// Do nothing
+}
+
+
+/* 
+perl code to generate the table below
+
+#!/usr/bin/perl
+use strict;
+open OUT,">protolengths.txt";
+my $len = 0;
+for(0 .. 255)
+{
+	print OUT "\t$len,\t// $_\n";
+	my $inc = 1;
+	$inc = 8 if $_ >= 64;
+	$inc = 16 if $_ >= 96;
+	$inc = 32 if $_ >= 112;
+	$inc = 64 if $_ >= 128;
+	$inc = 128 if $_ >= 135;
+	$inc = 256 if $_ >= 147;
+	$inc = 512 if $_ >= 159;
+	$inc = 1024 if $_ >= 231;
+	$len += $inc;
+}
+close OUT;
+
+*/
+const uint16_t Protocol::sProtocolStreamHeaderLengths[256] =
+{
+	0,	// 0
+	1,	// 1
+	2,	// 2
+	3,	// 3
+	4,	// 4
+	5,	// 5
+	6,	// 6
+	7,	// 7
+	8,	// 8
+	9,	// 9
+	10,	// 10
+	11,	// 11
+	12,	// 12
+	13,	// 13
+	14,	// 14
+	15,	// 15
+	16,	// 16
+	17,	// 17
+	18,	// 18
+	19,	// 19
+	20,	// 20
+	21,	// 21
+	22,	// 22
+	23,	// 23
+	24,	// 24
+	25,	// 25
+	26,	// 26
+	27,	// 27
+	28,	// 28
+	29,	// 29
+	30,	// 30
+	31,	// 31
+	32,	// 32
+	33,	// 33
+	34,	// 34
+	35,	// 35
+	36,	// 36
+	37,	// 37
+	38,	// 38
+	39,	// 39
+	40,	// 40
+	41,	// 41
+	42,	// 42
+	43,	// 43
+	44,	// 44
+	45,	// 45
+	46,	// 46
+	47,	// 47
+	48,	// 48
+	49,	// 49
+	50,	// 50
+	51,	// 51
+	52,	// 52
+	53,	// 53
+	54,	// 54
+	55,	// 55
+	56,	// 56
+	57,	// 57
+	58,	// 58
+	59,	// 59
+	60,	// 60
+	61,	// 61
+	62,	// 62
+	63,	// 63
+	64,	// 64
+	72,	// 65
+	80,	// 66
+	88,	// 67
+	96,	// 68
+	104,	// 69
+	112,	// 70
+	120,	// 71
+	128,	// 72
+	136,	// 73
+	144,	// 74
+	152,	// 75
+	160,	// 76
+	168,	// 77
+	176,	// 78
+	184,	// 79
+	192,	// 80
+	200,	// 81
+	208,	// 82
+	216,	// 83
+	224,	// 84
+	232,	// 85
+	240,	// 86
+	248,	// 87
+	256,	// 88
+	264,	// 89
+	272,	// 90
+	280,	// 91
+	288,	// 92
+	296,	// 93
+	304,	// 94
+	312,	// 95
+	320,	// 96
+	336,	// 97
+	352,	// 98
+	368,	// 99
+	384,	// 100
+	400,	// 101
+	416,	// 102
+	432,	// 103
+	448,	// 104
+	464,	// 105
+	480,	// 106
+	496,	// 107
+	512,	// 108
+	528,	// 109
+	544,	// 110
+	560,	// 111
+	576,	// 112
+	608,	// 113
+	640,	// 114
+	672,	// 115
+	704,	// 116
+	736,	// 117
+	768,	// 118
+	800,	// 119
+	832,	// 120
+	864,	// 121
+	896,	// 122
+	928,	// 123
+	960,	// 124
+	992,	// 125
+	1024,	// 126
+	1056,	// 127
+	1088,	// 128
+	1152,	// 129
+	1216,	// 130
+	1280,	// 131
+	1344,	// 132
+	1408,	// 133
+	1472,	// 134
+	1536,	// 135
+	1664,	// 136
+	1792,	// 137
+	1920,	// 138
+	2048,	// 139
+	2176,	// 140
+	2304,	// 141
+	2432,	// 142
+	2560,	// 143
+	2688,	// 144
+	2816,	// 145
+	2944,	// 146
+	3072,	// 147
+	3328,	// 148
+	3584,	// 149
+	3840,	// 150
+	4096,	// 151
+	4352,	// 152
+	4608,	// 153
+	4864,	// 154
+	5120,	// 155
+	5376,	// 156
+	5632,	// 157
+	5888,	// 158
+	6144,	// 159
+	6656,	// 160
+	7168,	// 161
+	7680,	// 162
+	8192,	// 163
+	8704,	// 164
+	9216,	// 165
+	9728,	// 166
+	10240,	// 167
+	10752,	// 168
+	11264,	// 169
+	11776,	// 170
+	12288,	// 171
+	12800,	// 172
+	13312,	// 173
+	13824,	// 174
+	14336,	// 175
+	14848,	// 176
+	15360,	// 177
+	15872,	// 178
+	16384,	// 179
+	16896,	// 180
+	17408,	// 181
+	17920,	// 182
+	18432,	// 183
+	18944,	// 184
+	19456,	// 185
+	19968,	// 186
+	20480,	// 187
+	20992,	// 188
+	21504,	// 189
+	22016,	// 190
+	22528,	// 191
+	23040,	// 192
+	23552,	// 193
+	24064,	// 194
+	24576,	// 195
+	25088,	// 196
+	25600,	// 197
+	26112,	// 198
+	26624,	// 199
+	27136,	// 200
+	27648,	// 201
+	28160,	// 202
+	28672,	// 203
+	29184,	// 204
+	29696,	// 205
+	30208,	// 206
+	30720,	// 207
+	31232,	// 208
+	31744,	// 209
+	32256,	// 210
+	32768,	// 211
+	33280,	// 212
+	33792,	// 213
+	34304,	// 214
+	34816,	// 215
+	35328,	// 216
+	35840,	// 217
+	36352,	// 218
+	36864,	// 219
+	37376,	// 220
+	37888,	// 221
+	38400,	// 222
+	38912,	// 223
+	39424,	// 224
+	39936,	// 225
+	40448,	// 226
+	40960,	// 227
+	41472,	// 228
+	41984,	// 229
+	42496,	// 230
+	43008,	// 231
+	44032,	// 232
+	45056,	// 233
+	46080,	// 234
+	47104,	// 235
+	48128,	// 236
+	49152,	// 237
+	50176,	// 238
+	51200,	// 239
+	52224,	// 240
+	53248,	// 241
+	54272,	// 242
+	55296,	// 243
+	56320,	// 244
+	57344,	// 245
+	58368,	// 246
+	59392,	// 247
+	60416,	// 248
+	61440,	// 249
+	62464,	// 250
+	63488,	// 251
+	64512,	// 252
+	0,		// 253 = 65536 / 64k
+	0,		// 254 = special (reserved)
+	0		// 255 = special (reserved)
+};
+
+
+
+
diff --git a/lib/server/Protocol.h b/lib/server/Protocol.h
new file mode 100755
index 00000000..e037e33c
--- /dev/null
+++ b/lib/server/Protocol.h
@@ -0,0 +1,201 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    Protocol.h
+//		Purpose: Generic protocol support
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+
+#ifndef PROTOCOL__H
+#define PROTOCOL__H
+
+#include <sys/types.h>
+
+class IOStream;
+#include "ProtocolObject.h"
+#include <memory>
+#include <vector>
+#include <string>
+
+// default timeout is 15 minutes
+#define PROTOCOL_DEFAULT_TIMEOUT	(15*60*1000)
+// 16 default maximum object size -- should be enough
+#define PROTOCOL_DEFAULT_MAXOBJSIZE	(16*1024)
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    Protocol
+//		Purpose: Generic command / response protocol support
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+class Protocol
+{
+public:
+	Protocol(IOStream &rStream);
+	virtual ~Protocol();
+	
+private:
+	Protocol(const Protocol &rToCopy);
+
+public:
+	void Handshake();
+	std::auto_ptr<ProtocolObject> Receive();
+	void Send(const ProtocolObject &rObject);
+	
+	std::auto_ptr<IOStream> ReceiveStream();
+	void SendStream(IOStream &rStream);
+	
+	enum
+	{
+		NoError = -1,
+		UnknownError = 0
+	};
+
+	bool GetLastError(int &rTypeOut, int &rSubTypeOut);
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    Protocol::SetTimeout(int)
+	//		Purpose: Sets the timeout for sending and reciving
+	//		Created: 2003/08/19
+	//
+	// --------------------------------------------------------------------------	
+	void SetTimeout(int NewTimeout) {mTimeout = NewTimeout;}
+	
+	
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    Protocol::GetTimeout() 
+	//		Purpose: Get current timeout for sending and receiving
+	//		Created: 2003/09/06
+	//
+	// --------------------------------------------------------------------------
+	int GetTimeout() {return mTimeout;}
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    Protocol::SetMaxObjectSize(int)
+	//		Purpose: Sets the maximum size of an object which will be accepted
+	//		Created: 2003/08/19
+	//
+	// --------------------------------------------------------------------------	
+	void SetMaxObjectSize(unsigned int NewMaxObjSize) {mMaxObjectSize = NewMaxObjSize;}
+
+	// For ProtocolObject derived classes
+	void Read(void *Buffer, int Size);
+	void Read(std::string &rOut, int Size);
+	void Read(int64_t &rOut);
+	void Read(int32_t &rOut);
+	void Read(int16_t &rOut);
+	void Read(int8_t &rOut);
+	void Read(bool &rOut) {int8_t read; Read(read); rOut = (read == true);}
+	void Read(std::string &rOut);
+	template<typename type>
+	void Read(type &rOut)
+	{
+		rOut.ReadFromProtocol(*this);
+	}
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    Protocol::ReadVector(std::vector<> &)
+	//		Purpose: Reads a vector/list of items from the stream
+	//		Created: 2003/08/19
+	//
+	// --------------------------------------------------------------------------
+	template<typename type>
+	void ReadVector(std::vector<type> &rOut)
+	{
+		rOut.clear();
+		int16_t num = 0;
+		Read(num);
+		for(int16_t n = 0; n < num; ++n)
+		{
+			type v;
+			Read(v);
+			rOut.push_back(v);
+		}
+	}
+	
+	void Write(const void *Buffer, int Size);
+	void Write(int64_t Value);
+	void Write(int32_t Value);
+	void Write(int16_t Value);
+	void Write(int8_t Value);
+	void Write(bool Value) {int8_t write = Value; Write(write);}
+	void Write(const std::string &rValue);
+	template<typename type>
+	void Write(const type &rValue)
+	{
+		rValue.WriteToProtocol(*this);
+	}
+	template<typename type>
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    Protocol::WriteVector(const std::vector<> &)
+	//		Purpose: Writes a vector/list of items from the stream
+	//		Created: 2003/08/19
+	//
+	// --------------------------------------------------------------------------
+	void WriteVector(const std::vector<type> &rValue)
+	{
+		int16_t num = rValue.size();
+		Write(num);
+		for(int16_t n = 0; n < num; ++n)
+		{
+			Write(rValue[n]);
+		}
+	}
+
+public:
+	static const uint16_t sProtocolStreamHeaderLengths[256];
+	enum
+	{
+		ProtocolStreamHeader_EndOfStream = 0,
+		ProtocolStreamHeader_MaxEncodedSizeValue = 252,
+		ProtocolStreamHeader_SizeIs64k = 253,
+		ProtocolStreamHeader_Reserved1 = 254,
+		ProtocolStreamHeader_Reserved2 = 255
+	};
+	enum
+	{
+		ProtocolStream_SizeUncertain = 0xffffffff
+	};
+
+protected:	
+	virtual std::auto_ptr<ProtocolObject> MakeProtocolObject(int ObjType) = 0;
+	virtual const char *GetIdentString() = 0;
+	void SetError(int Type, int SubType) {mLastErrorType = Type; mLastErrorSubType = SubType;}
+	void CheckAndReadHdr(void *hdr);	// don't use type here to avoid dependency
+	
+	// Will be used for logging
+	virtual void InformStreamReceiving(u_int32_t Size);
+	virtual void InformStreamSending(u_int32_t Size);
+	
+private:
+	void EnsureBufferAllocated(int Size);
+	int SendStreamSendBlock(uint8_t *Block, int BytesInBlock);
+
+private:
+	IOStream &mrStream;
+	bool mHandshakeDone;
+	unsigned int mMaxObjectSize;
+	int mTimeout;
+	char *mpBuffer;
+	int mBufferSize;
+	int mReadOffset;
+	int mWriteOffset;
+	int mValidDataSize;
+	int mLastErrorType;
+	int mLastErrorSubType;
+};
+
+#endif // PROTOCOL__H
+
diff --git a/lib/server/ProtocolObject.cpp b/lib/server/ProtocolObject.cpp
new file mode 100755
index 00000000..fb09f820
--- /dev/null
+++ b/lib/server/ProtocolObject.cpp
@@ -0,0 +1,125 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    ProtocolObject.h
+//		Purpose: Protocol object base class
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+#include "ProtocolObject.h"
+#include "CommonException.h"
+
+#include "MemLeakFindOn.h"
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolObject::ProtocolObject()
+//		Purpose: Default constructor
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+ProtocolObject::ProtocolObject()
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolObject::ProtocolObject()
+//		Purpose: Destructor
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+ProtocolObject::~ProtocolObject()
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolObject::ProtocolObject()
+//		Purpose: Copy constructor
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+ProtocolObject::ProtocolObject(const ProtocolObject &rToCopy)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolObject::IsError(int &, int &)
+//		Purpose: Does this represent an error, and if so, what is the type and subtype?
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+bool ProtocolObject::IsError(int &rTypeOut, int &rSubTypeOut) const
+{
+	return false;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolObject::IsConversationEnd()
+//		Purpose: Does this command end the conversation?
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+bool ProtocolObject::IsConversationEnd() const
+{
+	return false;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolObject::GetType()
+//		Purpose: Return type of the object
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+int ProtocolObject::GetType() const
+{
+	// This isn't implemented in the base class!
+	THROW_EXCEPTION(CommonException, Internal)
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolObject::SetPropertiesFromStreamData(Protocol &)
+//		Purpose: Set the properties of the object from the stream data ready in the Protocol object
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void ProtocolObject::SetPropertiesFromStreamData(Protocol &rProtocol)
+{
+	// This isn't implemented in the base class!
+	THROW_EXCEPTION(CommonException, Internal)
+}
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolObject::WritePropertiesToStreamData(Protocol &)
+//		Purpose: Write the properties of the object into the stream data in the Protocol object
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+void ProtocolObject::WritePropertiesToStreamData(Protocol &rProtocol) const
+{
+	// This isn't implemented in the base class!
+	THROW_EXCEPTION(CommonException, Internal)
+}
+
+
+
diff --git a/lib/server/ProtocolObject.h b/lib/server/ProtocolObject.h
new file mode 100755
index 00000000..0a127ab5
--- /dev/null
+++ b/lib/server/ProtocolObject.h
@@ -0,0 +1,41 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    ProtocolObject.h
+//		Purpose: Protocol object base class
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+
+#ifndef PROTOCOLOBJECT__H
+#define PROTOCOLOBJECT__H
+
+class Protocol;
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    ProtocolObject
+//		Purpose: Basic object representation of objects to pass through a Protocol session
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+class ProtocolObject
+{
+public:
+	ProtocolObject();
+	virtual ~ProtocolObject();
+	ProtocolObject(const ProtocolObject &rToCopy);
+
+	// Info about this object
+	virtual int GetType() const;
+	virtual bool IsError(int &rTypeOut, int &rSubTypeOut) const;
+	virtual bool IsConversationEnd() const;
+
+	// reading and writing with Protocol objects
+	virtual void SetPropertiesFromStreamData(Protocol &rProtocol);
+	virtual void WritePropertiesToStreamData(Protocol &rProtocol) const;	
+};
+
+#endif // PROTOCOLOBJECT__H
+
diff --git a/lib/server/ProtocolUncertainStream.cpp b/lib/server/ProtocolUncertainStream.cpp
new file mode 100755
index 00000000..60c1fa1d
--- /dev/null
+++ b/lib/server/ProtocolUncertainStream.cpp
@@ -0,0 +1,189 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    ProtocolUncertainStream.h
+//		Purpose: Read part of another stream
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+#include "ProtocolUncertainStream.h"
+#include "ServerException.h"
+#include "Protocol.h"
+
+#include "MemLeakFindOn.h"
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolUncertainStream::ProtocolUncertainStream(IOStream &, int)
+//		Purpose: Constructor, taking another stream.
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+ProtocolUncertainStream::ProtocolUncertainStream(IOStream &rSource)
+	: mrSource(rSource),
+	  mBytesLeftInCurrentBlock(0),
+	  mFinished(false)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolUncertainStream::~ProtocolUncertainStream()
+//		Purpose: Destructor. Won't absorb any unread bytes.
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+ProtocolUncertainStream::~ProtocolUncertainStream()
+{
+	if(!mFinished)
+	{
+		TRACE0("ProtocolUncertainStream::~ProtocolUncertainStream() destroyed when stream not complete\n");
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolUncertainStream::Read(void *, int, int)
+//		Purpose: As interface.
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+int ProtocolUncertainStream::Read(void *pBuffer, int NBytes, int Timeout)
+{
+	// Finished?
+	if(mFinished)
+	{
+		return 0;
+	}
+	
+	int read = 0;
+	while(read < NBytes)
+	{
+		// Anything we can get from the current block?
+		ASSERT(mBytesLeftInCurrentBlock >= 0);
+		if(mBytesLeftInCurrentBlock > 0)
+		{
+			// Yes, let's use some of these up
+			int toRead = (NBytes - read);
+			if(toRead > mBytesLeftInCurrentBlock)
+			{
+				// Adjust downwards to only read stuff out of the current block
+				toRead = mBytesLeftInCurrentBlock;
+			}
+			
+			// Read it
+			int r = mrSource.Read(((uint8_t*)pBuffer) + read, toRead, Timeout);
+			// Give up now if it didn't return anything
+			if(r == 0)
+			{
+				return read;
+			}
+			
+			// Adjust counts of bytes by the bytes recieved
+			read += r;
+			mBytesLeftInCurrentBlock -= r;
+			
+			// stop now if the stream returned less than we asked for -- avoid blocking
+			if(r != toRead)
+			{
+				return read;
+			}
+		}
+		else
+		{
+			// Read the header byte to find out how much there is in the next block
+			uint8_t header;
+			if(mrSource.Read(&header, 1, Timeout) == 0)
+			{
+				// Didn't get the byte, return now
+				return read;
+			}
+			
+			// Interpret the byte...
+			if(header == Protocol::ProtocolStreamHeader_EndOfStream)
+			{
+				// All done.
+				mFinished = true;
+				return read;
+			}
+			else if(header <= Protocol::ProtocolStreamHeader_MaxEncodedSizeValue)
+			{
+				// get size of the block from the Protocol's lovely list
+				mBytesLeftInCurrentBlock = Protocol::sProtocolStreamHeaderLengths[header];
+			}
+			else if(header == Protocol::ProtocolStreamHeader_SizeIs64k)
+			{
+				// 64k
+				mBytesLeftInCurrentBlock = (64*1024);
+			}
+			else
+			{
+				// Bad. It used the reserved values.
+				THROW_EXCEPTION(ServerException, ProtocolUncertainStreamBadBlockHeader)	
+			}
+		}
+	}
+
+	// Return the number read
+	return read;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolUncertainStream::BytesLeftToRead()
+//		Purpose: As interface.
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+IOStream::pos_type ProtocolUncertainStream::BytesLeftToRead()
+{
+	// Only know how much is left if everything is finished
+	return mFinished?(0):(IOStream::SizeOfStreamUnknown);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolUncertainStream::Write(const void *, int)
+//		Purpose: As interface. But will exception.
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+void ProtocolUncertainStream::Write(const void *pBuffer, int NBytes)
+{
+	THROW_EXCEPTION(ServerException, CantWriteToProtocolUncertainStream)
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolUncertainStream::StreamDataLeft()
+//		Purpose: As interface.
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+bool ProtocolUncertainStream::StreamDataLeft()
+{
+	return !mFinished;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ProtocolUncertainStream::StreamClosed()
+//		Purpose: As interface.
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+bool ProtocolUncertainStream::StreamClosed()
+{
+	// always closed
+	return true;
+}
+
diff --git a/lib/server/ProtocolUncertainStream.h b/lib/server/ProtocolUncertainStream.h
new file mode 100755
index 00000000..66397a39
--- /dev/null
+++ b/lib/server/ProtocolUncertainStream.h
@@ -0,0 +1,47 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    PartialReadStream.h
+//		Purpose: Read part of another stream
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+
+#ifndef PROTOCOLUNCERTAINSTREAM__H
+#define PROTOCOLUNCERTAINSTREAM__H
+
+#include "IOStream.h"
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    PartialReadStream
+//		Purpose: Read part of another stream
+//		Created: 2003/12/05
+//
+// --------------------------------------------------------------------------
+class ProtocolUncertainStream : public IOStream
+{
+public:
+	ProtocolUncertainStream(IOStream &rSource);
+	~ProtocolUncertainStream();
+private:
+	// no copying allowed
+	ProtocolUncertainStream(const IOStream &);
+	ProtocolUncertainStream(const ProtocolUncertainStream &);
+	
+public:
+	virtual int Read(void *pBuffer, int NBytes, int Timeout = IOStream::TimeOutInfinite);
+	virtual pos_type BytesLeftToRead();
+	virtual void Write(const void *pBuffer, int NBytes);
+	virtual bool StreamDataLeft();
+	virtual bool StreamClosed();
+
+private:
+	IOStream &mrSource;
+	int mBytesLeftInCurrentBlock;
+	bool mFinished;
+};
+
+#endif // PROTOCOLUNCERTAINSTREAM__H
+
diff --git a/lib/server/ProtocolWire.h b/lib/server/ProtocolWire.h
new file mode 100755
index 00000000..b6d3bd37
--- /dev/null
+++ b/lib/server/ProtocolWire.h
@@ -0,0 +1,43 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    ProtocolWire.h
+//		Purpose: On the wire structures for Protocol
+//		Created: 2003/08/19
+//
+// --------------------------------------------------------------------------
+
+#ifndef PROTOCOLWIRE__H
+#define PROTOCOLWIRE__H
+
+#include <sys/types.h>
+
+// set packing to one byte
+#ifdef STRUCTURE_PATCKING_FOR_WIRE_USE_HEADERS
+#include "BeginStructPackForWire.h"
+#else
+BEGIN_STRUCTURE_PACKING_FOR_WIRE
+#endif
+
+typedef struct
+{
+	char mIdent[32];
+} PW_Handshake;
+
+typedef struct
+{
+	u_int32_t	mObjSize;
+	u_int32_t	mObjType;
+} PW_ObjectHeader;
+
+#define SPECIAL_STREAM_OBJECT_TYPE		0xffffffff
+
+// Use default packing
+#ifdef STRUCTURE_PATCKING_FOR_WIRE_USE_HEADERS
+#include "EndStructPackForWire.h"
+#else
+END_STRUCTURE_PACKING_FOR_WIRE
+#endif
+
+#endif // PROTOCOLWIRE__H
+
diff --git a/lib/server/SSLLib.cpp b/lib/server/SSLLib.cpp
new file mode 100755
index 00000000..e9f3a59d
--- /dev/null
+++ b/lib/server/SSLLib.cpp
@@ -0,0 +1,83 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    SSLLib.cpp
+//		Purpose: Utility functions for dealing with the OpenSSL library
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#define TLS_CLASS_IMPLEMENTATION_CPP
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <openssl/rand.h>
+
+#include <syslog.h>
+
+#include "SSLLib.h"
+#include "ServerException.h"
+
+#include "MemLeakFindOn.h"
+
+#ifndef NDEBUG
+	bool SSLLib__TraceErrors = false;
+#endif
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SSLLib::Initialise()
+//		Purpose: Initialise SSL library
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+void SSLLib::Initialise()
+{
+	if(!::SSL_library_init())
+	{
+		LogError("Initialisation");
+		THROW_EXCEPTION(ServerException, SSLLibraryInitialisationError)
+	}
+	
+	// More helpful error messages
+	::SSL_load_error_strings();
+
+	// Extra seeding over and above what's already done by the library
+#ifndef PLATFORM_RANDOM_DEVICE_NONE
+	if(::RAND_load_file(PLATFORM_RANDOM_DEVICE, 1024) != 1024)
+	{
+		THROW_EXCEPTION(ServerException, SSLRandomInitFailed)
+	}
+#else
+	::fprintf(stderr, "No random device -- additional seeding of random number generator not performed.\n");
+#endif
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SSLLib::LogError(const char *)
+//		Purpose: Logs an error
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+void SSLLib::LogError(const char *ErrorDuringAction)
+{
+	unsigned long errcode;
+	char errname[256];		// SSL docs say at least 120 bytes
+	while((errcode = ERR_get_error()) != 0)
+	{
+		::ERR_error_string_n(errcode, errname, sizeof(errname));
+		#ifndef NDEBUG
+			if(SSLLib__TraceErrors)
+			{
+				TRACE2("SSL err during %s: %s\n", ErrorDuringAction, errname);
+			}
+		#endif
+		::syslog(LOG_ERR, "SSL err during %s: %s", ErrorDuringAction, errname);
+	}
+}
+
diff --git a/lib/server/SSLLib.h b/lib/server/SSLLib.h
new file mode 100755
index 00000000..cdff4f04
--- /dev/null
+++ b/lib/server/SSLLib.h
@@ -0,0 +1,36 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    SSLLib.h
+//		Purpose: Utility functions for dealing with the OpenSSL library
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+
+#ifndef SSLLIB__H
+#define SSLLIB__H
+
+#ifndef NDEBUG
+	extern bool SSLLib__TraceErrors;
+	#define SET_DEBUG_SSLLIB_TRACE_ERRORS {SSLLib__TraceErrors = true;}
+#else
+	#define SET_DEBUG_SSLLIB_TRACE_ERRORS
+#endif
+
+
+// --------------------------------------------------------------------------
+//
+// Namespace
+//		Name:    SSLLib
+//		Purpose: Utility functions for dealing with the OpenSSL library
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+namespace SSLLib
+{
+	void Initialise();
+	void LogError(const char *ErrorDuringAction);
+};
+
+#endif // SSLLIB__H
+
diff --git a/lib/server/ServerException.h b/lib/server/ServerException.h
new file mode 100755
index 00000000..8851b90a
--- /dev/null
+++ b/lib/server/ServerException.h
@@ -0,0 +1,46 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    ServerException.h
+//		Purpose: Exception
+//		Created: 2003/07/08
+//
+// --------------------------------------------------------------------------
+
+#ifndef SERVEREXCEPTION__H
+#define SERVEREXCEPTION__H
+
+// Compatibility header
+#include "autogen_ServerException.h"
+#include "autogen_ConnectionException.h"
+
+// Rename old connection exception names to new names without Conn_ prefix
+// This is all because ConnectionException used to be derived from ServerException
+// with some funky magic with subtypes. Perhaps a little unreliable, and the
+// usefulness of it never really was used.
+#define Conn_SocketWriteError			SocketWriteError	
+#define Conn_SocketReadError			SocketReadError	
+#define Conn_SocketNameLookupError		SocketNameLookupError
+#define Conn_SocketShutdownError		SocketShutdownError
+#define Conn_SocketConnectError			SocketConnectError	
+#define Conn_TLSHandshakeFailed			TLSHandshakeFailed	
+#define Conn_TLSShutdownFailed			TLSShutdownFailed	
+#define Conn_TLSWriteFailed				TLSWriteFailed		
+#define Conn_TLSReadFailed				TLSReadFailed		
+#define Conn_TLSNoPeerCertificate		TLSNoPeerCertificate
+#define Conn_TLSPeerCertificateInvalid	TLSPeerCertificateInvalid
+#define Conn_TLSClosedWhenWriting		TLSClosedWhenWriting
+#define Conn_TLSHandshakeTimedOut		TLSHandshakeTimedOut
+#define Conn_Protocol_Timeout			Protocol_Timeout	
+#define Conn_Protocol_ObjTooBig			Protocol_ObjTooBig	
+#define Conn_Protocol_BadCommandRecieved			Protocol_BadCommandRecieved	
+#define Conn_Protocol_UnknownCommandRecieved		Protocol_UnknownCommandRecieved
+#define Conn_Protocol_TriedToExecuteReplyCommand	Protocol_TriedToExecuteReplyCommand
+#define Conn_Protocol_UnexpectedReply				Protocol_UnexpectedReply		
+#define Conn_Protocol_HandshakeFailed				Protocol_HandshakeFailed		
+#define Conn_Protocol_StreamWhenObjExpected			Protocol_StreamWhenObjExpected	
+#define Conn_Protocol_ObjWhenStreamExpected			Protocol_ObjWhenStreamExpected	
+#define Conn_Protocol_TimeOutWhenSendingStream		Protocol_TimeOutWhenSendingStream
+
+#endif // SERVEREXCEPTION__H
+
diff --git a/lib/server/ServerException.txt b/lib/server/ServerException.txt
new file mode 100644
index 00000000..ed591b73
--- /dev/null
+++ b/lib/server/ServerException.txt
@@ -0,0 +1,39 @@
+EXCEPTION Server 3
+
+# for historic reasons, some codes are not used
+
+Internal						0
+FailedToLoadConfiguration		1
+DaemoniseFailed					2
+AlreadyDaemonConstructed		3
+BadSocketHandle					4
+DupError						5
+SocketAlreadyOpen				8
+SocketOpenError					10
+SocketPollError					11
+SocketCloseError				13
+SocketNameUNIXPathTooLong		14
+SocketBindError					16	Check the ListenAddresses directive in your config file -- must refer to local IP addresses only
+SocketAcceptError				17
+ServerStreamBadListenAddrs		18
+ServerForkError					19
+ServerWaitOnChildError			20
+TooManySocketsInMultiListen		21	There is a limit on how many addresses you can listen on simulatiously.
+ServerStreamTooManyListenAddresses	22
+TLSContextNotInitialised		23
+TLSAllocationFailed				24
+TLSLoadCertificatesFailed		25
+TLSLoadPrivateKeyFailed			26
+TLSLoadTrustedCAsFailed			27
+TLSSetCiphersFailed				28
+SSLLibraryInitialisationError	29
+TLSNoSSLObject					31
+TLSAlreadyHandshaked			35
+SocketSetNonBlockingFailed		40
+Protocol_BadUsage				43
+Protocol_UnsuitableStreamTypeForSending		51
+CantWriteToProtocolUncertainStream			53
+ProtocolUncertainStreamBadBlockHeader		54
+SocketPairFailed				55
+CouldNotChangePIDFileOwner		56
+SSLRandomInitFailed				57	Read from /dev/*random device failed
diff --git a/lib/server/ServerStream.h b/lib/server/ServerStream.h
new file mode 100755
index 00000000..d087a321
--- /dev/null
+++ b/lib/server/ServerStream.h
@@ -0,0 +1,340 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    ServerStream.h
+//		Purpose: Stream based server daemons
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+
+#ifndef SERVERSTREAM__H
+#define SERVERSTREAM__H
+
+#include <syslog.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/wait.h>
+
+#include "Daemon.h"
+#include "SocketListen.h"
+#include "Utils.h"
+#include "Configuration.h"
+#include "WaitForEvent.h"
+
+#include "MemLeakFindOn.h"
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    ServerStream
+//		Purpose: Stream based server daemon
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+template<typename StreamType, int Port, int ListenBacklog = 128, bool ForkToHandleRequests = true>
+class ServerStream : public Daemon
+{
+public:
+	ServerStream()
+	{
+	}
+	~ServerStream()
+	{
+		DeleteSockets();
+	}
+private:
+	ServerStream(const ServerStream &rToCopy)
+	{
+	}
+public:
+
+	virtual const char *DaemonName() const
+	{
+		return "generic-stream-server";
+	}
+
+	virtual void Run()
+	{
+		// Set process title as appropraite
+		SetProcessTitle(ForkToHandleRequests?"server":"idle");
+	
+		// Handle exceptions and child task quitting gracefully.
+		bool childExit = false;
+		try
+		{
+			Run2(childExit);
+		}
+		catch(BoxException &e)
+		{
+			if(childExit)
+			{
+				::syslog(LOG_ERR, "in server child, exception %s (%d/%d) -- terminating child", e.what(), e.GetType(), e.GetSubType());
+				_exit(1);
+			}
+			else throw;
+		}
+		catch(std::exception &e)
+		{
+			if(childExit)
+			{
+				::syslog(LOG_ERR, "in server child, exception %s -- terminating child", e.what());
+				_exit(1);
+			}
+			else throw;
+		}
+		catch(...)
+		{
+			if(childExit)
+			{
+				::syslog(LOG_ERR, "in server child, unknown exception -- terminating child");
+				_exit(1);
+			}
+			else throw;
+		}
+
+		// if it's a child fork, exit the process now
+		if(childExit)
+		{
+			// Child task, dump leaks to trace, which we make sure is on
+			#ifdef BOX_MEMORY_LEAK_TESTING
+				#ifndef NDEBUG
+					TRACE_TO_SYSLOG(true);
+					TRACE_TO_STDOUT(true);
+				#endif
+				memleakfinder_traceblocksinsection();
+			#endif
+
+			// If this is a child quitting, exit now to stop bad things happening
+			_exit(0);
+		}
+	}
+	
+	virtual void Run2(bool &rChildExit)
+	{
+		try
+		{
+			// Wait object with a timeout of 10 seconds, which is a reasonable time to wait before
+			// cleaning up finished child processes.
+			WaitForEvent connectionWait(10000);
+			
+			// BLOCK
+			{
+				// Get the address we need to bind to
+				// this-> in next line required to build under some gcc versions
+				const Configuration &config(this->GetConfiguration());
+				const Configuration &server(config.GetSubConfiguration("Server"));
+				std::string addrs = server.GetKeyValue("ListenAddresses");
+	
+				// split up the list of addresses
+				std::vector<std::string> addrlist;
+				SplitString(addrs, ',', addrlist);
+	
+				for(unsigned int a = 0; a < addrlist.size(); ++a)
+				{
+					// split the address up into components
+					std::vector<std::string> c;
+					SplitString(addrlist[a], ':', c);
+	
+					// listen!
+					SocketListen<StreamType, ListenBacklog> *psocket = new SocketListen<StreamType, ListenBacklog>;
+					try
+					{
+						if(c[0] == "inet")
+						{
+							// Check arguments
+							if(c.size() != 2 && c.size() != 3)
+							{
+								THROW_EXCEPTION(ServerException, ServerStreamBadListenAddrs)
+							}
+							
+							// Which port?
+							int port = Port;
+							
+							if(c.size() == 3)
+							{
+								// Convert to number
+								port = ::atol(c[2].c_str());
+								if(port <= 0 || port > ((64*1024)-1))
+								{
+									THROW_EXCEPTION(ServerException, ServerStreamBadListenAddrs)
+								}
+							}
+							
+							// Listen
+							psocket->Listen(Socket::TypeINET, c[1].c_str(), port);
+						}
+						else if(c[0] == "unix")
+						{
+							// Check arguments size
+							if(c.size() != 2)
+							{
+								THROW_EXCEPTION(ServerException, ServerStreamBadListenAddrs)
+							}
+
+							// unlink anything there
+							::unlink(c[1].c_str());
+							
+							psocket->Listen(Socket::TypeUNIX, c[1].c_str());
+						}
+						else
+						{
+							delete psocket;
+							THROW_EXCEPTION(ServerException, ServerStreamBadListenAddrs)
+						}
+						
+						// Add to list of sockets
+						mSockets.push_back(psocket);
+					}
+					catch(...)
+					{
+						delete psocket;
+						throw;
+					}
+
+					// Add to the list of things to wait on
+					connectionWait.Add(psocket);
+				}
+			}
+	
+			while(!StopRun())
+			{
+				// Wait for a connection, or timeout
+				SocketListen<StreamType, ListenBacklog> *psocket
+					= (SocketListen<StreamType, ListenBacklog> *)connectionWait.Wait();
+
+				if(psocket)
+				{
+					// Get the incomming connection (with zero wait time)
+					std::string logMessage;
+					std::auto_ptr<StreamType> connection(psocket->Accept(0, &logMessage));
+
+					// Was there one (there should be...)
+					if(connection.get())
+					{
+						// Since this is a template parameter, the if() will be optimised out by the compiler
+						if(ForkToHandleRequests)
+						{
+							pid_t pid = ::fork();
+							switch(pid)
+							{
+							case -1:
+								// Error!
+								THROW_EXCEPTION(ServerException, ServerForkError)
+								break;
+								
+							case 0:
+								// Child process
+								rChildExit = true;
+								// Close listening sockets
+								DeleteSockets();
+								
+								// Set up daemon
+								EnterChild();
+								SetProcessTitle("transaction");
+								
+								// Memory leak test the forked process
+								#ifdef BOX_MEMORY_LEAK_TESTING
+									memleakfinder_startsectionmonitor();
+								#endif
+								
+								// The derived class does some server magic with the connection
+								HandleConnection(*connection);
+								// Since rChildExit == true, the forked process will call _exit() on return from this fn
+								return;
+			
+							default:
+								// parent daemon process
+								break;
+							}
+							
+							// Log it
+							::syslog(LOG_INFO, "%s (handling in child %d)", logMessage.c_str(), pid);
+						}
+						else
+						{
+							// Just handle in this connection
+							SetProcessTitle("handling");
+							HandleConnection(*connection);
+							SetProcessTitle("idle");										
+						}
+					}
+				}
+				
+				// Clean up child processes (if forking daemon)
+				if(ForkToHandleRequests)
+				{
+					int status = 0;
+					int p = 0;
+					do
+					{
+						if((p = ::waitpid(0 /* any child in process group */, &status, WNOHANG)) == -1
+							&& errno != ECHILD && errno != EINTR)
+						{
+							THROW_EXCEPTION(ServerException, ServerWaitOnChildError)
+						}
+					} while(p > 0);
+				}
+			}
+		}
+		catch(...)
+		{
+			DeleteSockets();
+			throw;
+		}
+		
+		// Delete the sockets
+		DeleteSockets();
+	}
+
+	virtual void HandleConnection(StreamType &rStream)
+	{
+		Connection(rStream);
+	}
+
+	virtual void Connection(StreamType &rStream) = 0;
+	
+protected:
+	// For checking code in dervied classes -- use if you have an algorithm which
+	// depends on the forking model in case someone changes it later.
+	bool WillForkToHandleRequests()
+	{
+		return ForkToHandleRequests;
+	}
+
+private:
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    ServerStream::DeleteSockets()
+	//		Purpose: Delete sockets
+	//		Created: 9/3/04
+	//
+	// --------------------------------------------------------------------------
+	void DeleteSockets()
+	{
+		for(unsigned int l = 0; l < mSockets.size(); ++l)
+		{
+			if(mSockets[l])
+			{
+				mSockets[l]->Close();
+				delete mSockets[l];
+			}
+			mSockets[l] = 0;
+		}
+		mSockets.clear();
+	}
+
+private:
+	std::vector<SocketListen<StreamType, ListenBacklog> *> mSockets;
+};
+
+#define SERVERSTREAM_VERIFY_SERVER_KEYS(DEFAULT_ADDRESSES) \
+											{"ListenAddresses", DEFAULT_ADDRESSES, 0, 0}, \
+											DAEMON_VERIFY_SERVER_KEYS 
+
+#include "MemLeakFindOff.h"
+
+#endif // SERVERSTREAM__H
+
+
+
diff --git a/lib/server/ServerTLS.h b/lib/server/ServerTLS.h
new file mode 100755
index 00000000..71d35380
--- /dev/null
+++ b/lib/server/ServerTLS.h
@@ -0,0 +1,80 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    ServerTLS.h
+//		Purpose: Implementation of a server using TLS streams
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+
+#ifndef SERVERTLS__H
+#define SERVERTLS__H
+
+#include "ServerStream.h"
+#include "SocketStreamTLS.h"
+#include "SSLLib.h"
+#include "TLSContext.h"
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    ServerTLS
+//		Purpose: Implementation of a server using TLS streams
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+template<int Port, int ListenBacklog = 128, bool ForkToHandleRequests = true>
+class ServerTLS : public ServerStream<SocketStreamTLS, Port, ListenBacklog, ForkToHandleRequests>
+{
+public:
+	ServerTLS()
+	{
+		// Safe to call this here, as the Daemon class makes sure there is only one instance every of a Daemon.
+		SSLLib::Initialise();
+	}
+	
+	~ServerTLS()
+	{
+	}
+private:
+	ServerTLS(const ServerTLS &)
+	{
+	}
+public:
+
+	virtual void Run2(bool &rChildExit)
+	{
+		// First, set up the SSL context.
+		// Get parameters from the configuration
+		// this-> in next line required to build under some gcc versions
+		const Configuration &conf(this->GetConfiguration());
+		const Configuration &serverconf(conf.GetSubConfiguration("Server"));
+		std::string certFile(serverconf.GetKeyValue("CertificateFile"));
+		std::string keyFile(serverconf.GetKeyValue("PrivateKeyFile"));
+		std::string caFile(serverconf.GetKeyValue("TrustedCAsFile"));
+		mContext.Initialise(true /* as server */, certFile.c_str(), keyFile.c_str(), caFile.c_str());
+	
+		// Then do normal stream server stuff
+		ServerStream<SocketStreamTLS, Port, ListenBacklog>::Run2(rChildExit);
+	}
+	
+	virtual void HandleConnection(SocketStreamTLS &rStream)
+	{
+		rStream.Handshake(mContext, true /* is server */);
+		// this-> in next line required to build under some gcc versions
+		this->Connection(rStream);
+	}
+	
+private:
+	TLSContext mContext;
+};
+
+#define SERVERTLS_VERIFY_SERVER_KEYS(DEFAULT_ADDRESSES) \
+											{"CertificateFile", 0, ConfigTest_Exists, 0}, \
+											{"PrivateKeyFile", 0, ConfigTest_Exists, 0}, \
+											{"TrustedCAsFile", 0, ConfigTest_Exists, 0}, \
+											SERVERSTREAM_VERIFY_SERVER_KEYS(DEFAULT_ADDRESSES)
+
+
+#endif // SERVERTLS__H
+
diff --git a/lib/server/Socket.cpp b/lib/server/Socket.cpp
new file mode 100755
index 00000000..52eb79e3
--- /dev/null
+++ b/lib/server/Socket.cpp
@@ -0,0 +1,171 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    Socket.cpp
+//		Purpose: Socket related stuff
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <syslog.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <string.h>
+#include <stdio.h>
+
+#include "Socket.h"
+#include "ServerException.h"
+
+#include "MemLeakFindOn.h"
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Socket::NameLookupToSockAddr(SocketAllAddr &, int, char *, int)
+//		Purpose: Sets up a sockaddr structure given a name and type
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+void Socket::NameLookupToSockAddr(SocketAllAddr &addr, int &sockDomain, int Type, const char *Name, int Port, int &rSockAddrLenOut)
+{
+	int sockAddrLen = 0;
+
+	switch(Type)
+	{
+	case TypeINET:
+		sockDomain = AF_INET;
+		{
+			// Lookup hostname
+			struct hostent *phost = ::gethostbyname(Name);
+			if(phost != NULL)
+			{
+				if(phost->h_addr_list[0] != 0)
+				{
+					sockAddrLen = sizeof(addr.sa_inet);
+#ifndef PLATFORM_sockaddr_NO_len
+					addr.sa_inet.sin_len = sizeof(addr.sa_inet);
+#endif
+					addr.sa_inet.sin_family = PF_INET;
+					addr.sa_inet.sin_port = htons(Port);
+					addr.sa_inet.sin_addr = *((in_addr*)phost->h_addr_list[0]);
+					for(unsigned int l = 0; l < sizeof(addr.sa_inet.sin_zero); ++l)
+					{
+						addr.sa_inet.sin_zero[l] = 0;
+					}
+				}
+				else
+				{
+					THROW_EXCEPTION(ConnectionException, Conn_SocketNameLookupError);
+				}
+			}
+			else
+			{
+				THROW_EXCEPTION(ConnectionException, Conn_SocketNameLookupError);
+			}
+		}
+		break;
+	
+	case TypeUNIX:
+		sockDomain = AF_UNIX;
+		{
+			// Check length of name is OK
+			unsigned int nameLen = ::strlen(Name);
+			if(nameLen >= (sizeof(addr.sa_unix.sun_path) - 1))
+			{
+				THROW_EXCEPTION(ServerException, SocketNameUNIXPathTooLong);
+			}
+			sockAddrLen = nameLen + (((char*)(&(addr.sa_unix.sun_path[0]))) - ((char*)(&addr.sa_unix)));
+#ifndef PLATFORM_sockaddr_NO_len
+			addr.sa_unix.sun_len = sockAddrLen;
+#endif
+			addr.sa_unix.sun_family = PF_UNIX;
+			::strcpy(addr.sa_unix.sun_path, Name);
+		}
+		break;
+		
+	default:
+		THROW_EXCEPTION(CommonException, BadArguments)
+		break;
+	}
+	
+	// Return size of structure to caller
+	rSockAddrLenOut = sockAddrLen;
+}
+
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Socket::LogIncomingConnection(const struct sockaddr *, socklen_t)
+//		Purpose: Writes a message logging the connection to syslog
+//		Created: 2003/08/01
+//
+// --------------------------------------------------------------------------
+void Socket::LogIncomingConnection(const struct sockaddr *addr, socklen_t addrlen)
+{
+	if(addr == NULL) {THROW_EXCEPTION(CommonException, BadArguments)}
+
+	switch(addr->sa_family)
+	{
+	case AF_UNIX:
+		::syslog(LOG_INFO, "Incoming connection from local (UNIX socket)");
+		break;		
+	
+	case AF_INET:
+		{
+			sockaddr_in *a = (sockaddr_in*)addr;
+			::syslog(LOG_INFO, "Incoming connection from %s port %d", inet_ntoa(a->sin_addr), ntohs(a->sin_port));
+		}
+		break;		
+	
+	default:
+		::syslog(LOG_INFO, "Incoming connection of unknown type");
+		break;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    Socket::IncomingConnectionLogMessage(const struct sockaddr *, socklen_t)
+//		Purpose: Returns a string for use in log messages
+//		Created: 2003/08/01
+//
+// --------------------------------------------------------------------------
+std::string Socket::IncomingConnectionLogMessage(const struct sockaddr *addr, socklen_t addrlen)
+{
+	if(addr == NULL) {THROW_EXCEPTION(CommonException, BadArguments)}
+
+	switch(addr->sa_family)
+	{
+	case AF_UNIX:
+		return std::string("Incoming connection from local (UNIX socket)");
+		break;		
+	
+	case AF_INET:
+		{
+			char msg[256];	// more than enough
+			sockaddr_in *a = (sockaddr_in*)addr;
+			sprintf(msg, "Incoming connection from %s port %d", inet_ntoa(a->sin_addr), ntohs(a->sin_port));
+			return std::string(msg);
+		}
+		break;		
+	
+	default:
+		return std::string("Incoming connection of unknown type");
+		break;
+	}
+	
+	// Dummy.
+	return std::string();
+}
+
diff --git a/lib/server/Socket.h b/lib/server/Socket.h
new file mode 100755
index 00000000..86a06097
--- /dev/null
+++ b/lib/server/Socket.h
@@ -0,0 +1,47 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    Socket.h
+//		Purpose: Socket related stuff
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+
+#ifndef SOCKET__H
+#define SOCKET__H
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+
+#include <string>
+
+typedef union {
+	struct sockaddr sa_generic;
+	struct sockaddr_in sa_inet;
+	struct sockaddr_un sa_unix;
+} SocketAllAddr;
+
+// --------------------------------------------------------------------------
+//
+// Namespace
+//		Name:    Socket
+//		Purpose: Socket utilities
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+namespace Socket
+{
+	enum
+	{
+		TypeINET = 1,
+		TypeUNIX = 2
+	};
+
+	void NameLookupToSockAddr(SocketAllAddr &addr, int &sockDomain, int Type, const char *Name, int Port, int &rSockAddrLenOut);
+	void LogIncomingConnection(const struct sockaddr *addr, socklen_t addrlen);
+	std::string IncomingConnectionLogMessage(const struct sockaddr *addr, socklen_t addrlen);
+};
+
+#endif // SOCKET__H
+
diff --git a/lib/server/SocketListen.h b/lib/server/SocketListen.h
new file mode 100755
index 00000000..f1f5e377
--- /dev/null
+++ b/lib/server/SocketListen.h
@@ -0,0 +1,265 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    SocketListen.h
+//		Purpose: Stream based sockets for servers
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+
+#ifndef SOCKETLISTEN__H
+#define SOCKETLISTEN__H
+
+#include <errno.h>
+#include <unistd.h>
+#include <new>
+#include <poll.h>
+#include <memory>
+#include <string>
+#ifndef PLATFORM_KQUEUE_NOT_SUPPORTED
+	#include <sys/event.h>
+	#include <sys/time.h>
+#endif
+
+#include "Socket.h"
+#include "ServerException.h"
+
+#include "MemLeakFindOn.h"
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    _NoSocketLocking
+//		Purpose: Default locking class for SocketListen
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+class _NoSocketLocking
+{
+public:
+	_NoSocketLocking(int sock)
+	{
+	}
+	
+	~_NoSocketLocking()
+	{
+	}
+	
+	bool HaveLock()
+	{
+		return true;
+	}
+	
+private:
+	_NoSocketLocking(const _NoSocketLocking &rToCopy)
+	{
+	}
+};
+
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    SocketListen
+//		Purpose: 
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+template<typename SocketType, int ListenBacklog = 128, typename SocketLockingType = _NoSocketLocking, int MaxMultiListenSockets = 16>
+class SocketListen
+{
+public:
+	// Initialise
+	SocketListen()
+		: mSocketHandle(-1)
+	{
+	}
+	// Close socket nicely
+	~SocketListen()
+	{
+		Close();
+	}
+private:
+	SocketListen(const SocketListen &rToCopy)
+	{
+	}
+public:
+
+	enum
+	{
+		MaxMultipleListenSockets = MaxMultiListenSockets
+	};
+
+	void Close()
+	{
+		if(mSocketHandle != -1)
+		{
+			if(::close(mSocketHandle) == -1)
+			{
+				THROW_EXCEPTION(ServerException, SocketCloseError)
+			}
+		}
+		mSocketHandle = -1;
+	}
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    SocketListen::Listen(int, char*, int)
+	//		Purpose: Initialises, starts the socket listening.
+	//		Created: 2003/07/31
+	//
+	// --------------------------------------------------------------------------
+	void Listen(int Type, const char *Name, int Port = 0)
+	{
+		if(mSocketHandle != -1) {THROW_EXCEPTION(ServerException, SocketAlreadyOpen)}
+		
+		// Setup parameters based on type, looking up names if required
+		int sockDomain = 0;
+		SocketAllAddr addr;
+		int addrLen = 0;
+		Socket::NameLookupToSockAddr(addr, sockDomain, Type, Name, Port, addrLen);
+	
+		// Create the socket
+		mSocketHandle = ::socket(sockDomain, SOCK_STREAM, 0 /* let OS choose protocol */);
+		if(mSocketHandle == -1)
+		{
+			THROW_EXCEPTION(ServerException, SocketOpenError)
+		}
+		
+		// Set an option to allow reuse (useful for -HUP situations!)
+		int option = true;
+		if(::setsockopt(mSocketHandle, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) == -1)
+		{
+			THROW_EXCEPTION(ServerException, SocketOpenError)
+		}
+
+		// Bind it to the right port, and start listening
+		if(::bind(mSocketHandle, &addr.sa_generic, addrLen) == -1
+			|| ::listen(mSocketHandle, ListenBacklog) == -1)
+		{
+			// Dispose of the socket
+			::close(mSocketHandle);
+			mSocketHandle = -1;
+			THROW_EXCEPTION(ServerException, SocketBindError)
+		}	
+	}
+	
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    SocketListen::Accept(int)
+	//		Purpose: Accepts a connection, returning a pointer to a class of
+	//				 the specified type. May return a null pointer if a signal happens,
+	//				 or there's a timeout. Timeout specified in milliseconds, defaults to infinite time.
+	//		Created: 2003/07/31
+	//
+	// --------------------------------------------------------------------------
+	std::auto_ptr<SocketType> Accept(int Timeout = INFTIM, std::string *pLogMsg = 0)
+	{
+		if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+		
+		// Do the accept, using the supplied locking type
+		int sock;
+		struct sockaddr addr;
+		socklen_t addrlen = sizeof(addr);
+		// BLOCK
+		{
+			SocketLockingType socklock(mSocketHandle);
+			
+			if(!socklock.HaveLock())
+			{
+				// Didn't get the lock for some reason. Wait a while, then
+				// return nothing.
+				::sleep(1);
+				return std::auto_ptr<SocketType>();
+			}
+			
+			// poll this socket
+			struct pollfd p;
+			p.fd = mSocketHandle;
+			p.events = POLLIN;
+			p.revents = 0;
+			switch(::poll(&p, 1, Timeout))
+			{
+			case -1:
+				// signal?
+				if(errno == EINTR)
+				{
+					// return nothing
+					return std::auto_ptr<SocketType>();
+				}
+				else
+				{
+					THROW_EXCEPTION(ServerException, SocketPollError)
+				}
+				break;
+			case 0:	// timed out
+				return std::auto_ptr<SocketType>();
+				break;
+			default:	// got some thing...
+				// control flows on...
+				break;
+			}
+			
+			sock = ::accept(mSocketHandle, &addr, &addrlen);
+		}
+		// Got socket (or error), unlock (implcit in destruction)
+		if(sock == -1)
+		{
+			THROW_EXCEPTION(ServerException, SocketAcceptError)
+		}
+
+		// Log it
+		if(pLogMsg)
+		{
+			*pLogMsg = Socket::IncomingConnectionLogMessage(&addr, addrlen);
+		}
+		else
+		{
+			// Do logging ourselves
+			Socket::LogIncomingConnection(&addr, addrlen);
+		}
+
+		return std::auto_ptr<SocketType>(new SocketType(sock));
+	}
+	
+	// Functions to allow adding to WaitForEvent class, for efficient waiting
+	// on multiple sockets.
+#ifndef PLATFORM_KQUEUE_NOT_SUPPORTED
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    SocketListen::FillInKEevent
+	//		Purpose: Fills in a kevent structure for this socket
+	//		Created: 9/3/04
+	//
+	// --------------------------------------------------------------------------
+	void FillInKEvent(struct kevent &rEvent, int Flags = 0) const
+	{
+		EV_SET(&rEvent, mSocketHandle, EVFILT_READ, 0, 0, 0, (void*)this);
+	}
+#else
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    SocketListen::FillInPoll
+	//		Purpose: Fills in the data necessary for a poll operation
+	//		Created: 9/3/04
+	//
+	// --------------------------------------------------------------------------
+	void FillInPoll(int &fd, short &events, int Flags = 0) const
+	{
+		fd = mSocketHandle;
+		events = POLLIN;
+	}
+#endif
+	
+private:
+	int mSocketHandle;
+};
+
+#include "MemLeakFindOff.h"
+
+#endif // SOCKETLISTEN__H
+
diff --git a/lib/server/SocketStream.cpp b/lib/server/SocketStream.cpp
new file mode 100755
index 00000000..3c8bf453
--- /dev/null
+++ b/lib/server/SocketStream.cpp
@@ -0,0 +1,405 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    SocketStream.cpp
+//		Purpose: I/O stream interface for sockets
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <poll.h>
+#include <errno.h>
+
+#include "SocketStream.h"
+#include "ServerException.h"
+#include "CommonException.h"
+#include "Socket.h"
+
+#include "MemLeakFindOn.h"
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::SocketStream()
+//		Purpose: Constructor (create stream ready for Open() call)
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+SocketStream::SocketStream()
+	: mSocketHandle(-1),
+	  mReadClosed(false),
+	  mWriteClosed(false)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::SocketStream(int)
+//		Purpose: Create stream from existing socket handle
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+SocketStream::SocketStream(int socket)
+	: mSocketHandle(socket),
+	  mReadClosed(false),
+	  mWriteClosed(false)
+{
+	if(socket < 0)
+	{
+		THROW_EXCEPTION(ServerException, BadSocketHandle);
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::SocketStream(const SocketStream &)
+//		Purpose: Copy constructor (dup()s socket)
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+SocketStream::SocketStream(const SocketStream &rToCopy)
+	: mSocketHandle(::dup(rToCopy.mSocketHandle)),
+	  mReadClosed(rToCopy.mReadClosed),
+	  mWriteClosed(rToCopy.mWriteClosed)
+
+{
+	if(rToCopy.mSocketHandle < 0)
+	{
+		THROW_EXCEPTION(ServerException, BadSocketHandle);
+	}
+	if(mSocketHandle == -1)
+	{
+		THROW_EXCEPTION(ServerException, DupError);
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::~SocketStream()
+//		Purpose: Destructor, closes stream if open
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+SocketStream::~SocketStream()
+{
+	if(mSocketHandle != -1)
+	{
+		Close();
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::Attach(int)
+//		Purpose: Attach a socket handle to this stream
+//		Created: 11/12/03
+//
+// --------------------------------------------------------------------------
+void SocketStream::Attach(int socket)
+{
+	if(mSocketHandle != -1) {THROW_EXCEPTION(ServerException, SocketAlreadyOpen)}
+
+	mSocketHandle = socket;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::Open(int, char *, int)
+//		Purpose: Opens a connection to a listening socket (INET or UNIX)
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+void SocketStream::Open(int Type, const char *Name, int Port)
+{
+	if(mSocketHandle != -1) {THROW_EXCEPTION(ServerException, SocketAlreadyOpen)}
+	
+	// Setup parameters based on type, looking up names if required
+	int sockDomain = 0;
+	SocketAllAddr addr;
+	int addrLen = 0;
+	Socket::NameLookupToSockAddr(addr, sockDomain, Type, Name, Port, addrLen);
+
+	// Create the socket
+	mSocketHandle = ::socket(sockDomain, SOCK_STREAM, 0 /* let OS choose protocol */);
+	if(mSocketHandle == -1)
+	{
+		THROW_EXCEPTION(ServerException, SocketOpenError)
+	}
+	
+	// Connect it
+	if(::connect(mSocketHandle, &addr.sa_generic, addrLen) == -1)
+	{
+		// Dispose of the socket
+		::close(mSocketHandle);
+		mSocketHandle = -1;
+		THROW_EXCEPTION(ConnectionException, Conn_SocketConnectError)
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::Read(void *pBuffer, int NBytes)
+//		Purpose: Reads data from stream. Maybe returns less than asked for.
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+int SocketStream::Read(void *pBuffer, int NBytes, int Timeout)
+{
+	if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+
+	if(Timeout != IOStream::TimeOutInfinite)
+	{
+		struct pollfd p;
+		p.fd = mSocketHandle;
+		p.events = POLLIN;
+		p.revents = 0;
+		switch(::poll(&p, 1, (Timeout == IOStream::TimeOutInfinite)?INFTIM:Timeout))
+		{
+		case -1:
+			// error
+			if(errno == EINTR)
+			{
+				// Signal. Just return 0 bytes
+				return 0;
+			}
+			else
+			{
+				// Bad!
+				THROW_EXCEPTION(ServerException, SocketPollError)
+			}
+			break;
+			
+		case 0:
+			// no data
+			return 0;
+			break;
+			
+		default:
+			// good to go!
+			break;
+		}
+	}
+
+	int r = ::read(mSocketHandle, pBuffer, NBytes);
+	if(r == -1)
+	{
+		if(errno == EINTR)
+		{
+			// Nothing could be read
+			return 0;
+		}
+		else
+		{
+			// Other error
+			THROW_EXCEPTION(ConnectionException, Conn_SocketReadError)
+		}
+	}
+	// Closed for reading?
+	if(r == 0)
+	{
+		mReadClosed = true;
+	}
+	
+	return r;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::Write(void *pBuffer, int NBytes)
+//		Purpose: Writes data, blocking until it's all done.
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+void SocketStream::Write(const void *pBuffer, int NBytes)
+{
+	if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+	
+	// Buffer in byte sized type.
+	ASSERT(sizeof(char) == 1);
+	const char *buffer = (char *)pBuffer;
+	
+	// Bytes left to send
+	int bytesLeft = NBytes;
+	
+	while(bytesLeft > 0)
+	{
+		// Try to send.
+		int sent = ::write(mSocketHandle, buffer, bytesLeft);
+		if(sent == -1)
+		{
+			// Error.
+			mWriteClosed = true;	// assume can't write again
+			THROW_EXCEPTION(ConnectionException, Conn_SocketWriteError)
+		}
+		
+		// Knock off bytes sent
+		bytesLeft -= sent;
+		// Move buffer pointer
+		buffer += sent;
+		
+		// Need to wait until it can send again?
+		if(bytesLeft > 0)
+		{
+			TRACE3("Waiting to send data on socket %d, (%d to send of %d)\n", mSocketHandle, bytesLeft, NBytes);
+			
+			// Wait for data to send.
+			struct pollfd p;
+			p.fd = mSocketHandle;
+			p.events = POLLOUT;
+			p.revents = 0;
+			
+			if(::poll(&p, 1, 16000 /* 16 seconds */) == -1)
+			{
+				// Don't exception if it's just a signal
+				if(errno != EINTR)
+				{
+					THROW_EXCEPTION(ServerException, SocketPollError)
+				}
+			}
+		}
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::Close()
+//		Purpose: Closes connection to remote socket
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+void SocketStream::Close()
+{
+	if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+	
+	if(::close(mSocketHandle) == -1)
+	{
+		THROW_EXCEPTION(ServerException, SocketCloseError)
+	}
+	mSocketHandle = -1;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::Shutdown(bool, bool)
+//		Purpose: Shuts down a socket for further reading and/or writing
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+void SocketStream::Shutdown(bool Read, bool Write)
+{
+	if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+	
+	// Do anything?
+	if(!Read && !Write) return;
+	
+	int how = SHUT_RDWR;
+	if(Read && !Write) how = SHUT_RD;
+	if(!Read && Write) how = SHUT_WR;
+	
+	// Shut it down!
+	if(::shutdown(mSocketHandle, how) == -1)
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_SocketShutdownError)
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::StreamDataLeft()
+//		Purpose: Still capable of reading data?
+//		Created: 2003/08/02
+//
+// --------------------------------------------------------------------------
+bool SocketStream::StreamDataLeft()
+{
+	return !mReadClosed;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::StreamClosed()
+//		Purpose: Connection been closed?
+//		Created: 2003/08/02
+//
+// --------------------------------------------------------------------------
+bool SocketStream::StreamClosed()
+{
+	return mWriteClosed;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::GetSocketHandle()
+//		Purpose: Returns socket handle for this stream (derived classes only).
+//				 Will exception if there's no valid socket.
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+int SocketStream::GetSocketHandle()
+{
+	if(mSocketHandle == -1) {THROW_EXCEPTION(ServerException, BadSocketHandle)}
+	return mSocketHandle;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStream::GetPeerCredentials(uid_t &, gid_t &)
+//		Purpose: Returns true if the peer credientials are available.
+//				 (will work on UNIX domain sockets only)
+//		Created: 19/2/04
+//
+// --------------------------------------------------------------------------
+bool SocketStream::GetPeerCredentials(uid_t &rUidOut, gid_t &rGidOut)
+{
+#ifdef PLATFORM_HAVE_getpeereid
+	uid_t remoteEUID = 0xffff;
+	gid_t remoteEGID = 0xffff;
+
+	if(::getpeereid(mSocketHandle, &remoteEUID, &remoteEGID) == 0)
+	{
+		rUidOut = remoteEUID;
+		rGidOut = remoteEGID;
+		return true;
+	}
+#endif // PLATFORM_HAVE_getpeereid
+
+#ifdef PLATFORM_HAVE_getsockopt_SO_PEERCRED
+	struct ucred cred;
+	socklen_t credLen = sizeof(cred);
+
+	if(::getsockopt(mSocketHandle, SOL_SOCKET, SO_PEERCRED, &cred, &credLen) == 0)
+	{
+		rUidOut = cred.uid;
+		rGidOut = cred.gid;
+		return true;
+	}
+#endif // PLATFORM_HAVE_getsockopt_SO_PEERCRED
+
+	// Not available
+	return false;
+}
+
+
+
+
diff --git a/lib/server/SocketStream.h b/lib/server/SocketStream.h
new file mode 100755
index 00000000..9b16dbfc
--- /dev/null
+++ b/lib/server/SocketStream.h
@@ -0,0 +1,56 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    SocketStream.h
+//		Purpose: I/O stream interface for sockets
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+
+#ifndef SOCKETSTREAM__H
+#define SOCKETSTREAM__H
+
+#include "IOStream.h"
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    SocketStream
+//		Purpose: Stream interface for sockets
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+class SocketStream : public IOStream
+{
+public:
+	SocketStream();
+	SocketStream(int socket);
+	SocketStream(const SocketStream &rToCopy);
+	~SocketStream();
+	
+	void Open(int Type, const char *Name, int Port = 0);
+	void Attach(int socket);
+
+	virtual int Read(void *pBuffer, int NBytes, int Timeout = IOStream::TimeOutInfinite);
+	virtual void Write(const void *pBuffer, int NBytes);
+	virtual void Close();
+	virtual bool StreamDataLeft();
+	virtual bool StreamClosed();
+
+	virtual void Shutdown(bool Read = true, bool Write = true);
+
+	virtual bool GetPeerCredentials(uid_t &rUidOut, gid_t &rGidOut);
+
+protected:
+	int GetSocketHandle();
+	void MarkAsReadClosed() {mReadClosed = true;}
+	void MarkAsWriteClosed() {mWriteClosed = true;}
+
+private:
+	int mSocketHandle;
+	bool mReadClosed;
+	bool mWriteClosed;
+};
+
+#endif // SOCKETSTREAM__H
+
diff --git a/lib/server/SocketStreamTLS.cpp b/lib/server/SocketStreamTLS.cpp
new file mode 100755
index 00000000..63ac7bb5
--- /dev/null
+++ b/lib/server/SocketStreamTLS.cpp
@@ -0,0 +1,457 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    SocketStreamTLS.cpp
+//		Purpose: Socket stream encrpyted and authenticated by TLS
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#define TLS_CLASS_IMPLEMENTATION_CPP
+#include <openssl/ssl.h>
+#include <openssl/bio.h>
+#include <poll.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+
+#include "SocketStreamTLS.h"
+#include "SSLLib.h"
+#include "ServerException.h"
+#include "TLSContext.h"
+
+#include "MemLeakFindOn.h"
+
+// Allow 5 minutes to handshake (in milliseconds)
+#define TLS_HANDSHAKE_TIMEOUT (5*60*1000)
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::SocketStreamTLS()
+//		Purpose: Constructor
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+SocketStreamTLS::SocketStreamTLS()
+	: mpSSL(0), mpBIO(0)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::SocketStreamTLS(int)
+//		Purpose: Constructor, taking previously connected socket
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+SocketStreamTLS::SocketStreamTLS(int socket)
+	: SocketStream(socket),
+	  mpSSL(0), mpBIO(0)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::~SocketStreamTLS()
+//		Purpose: Destructor
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+SocketStreamTLS::~SocketStreamTLS()
+{
+	if(mpSSL)
+	{
+		// Attempt to close to avoid problems
+		Close();
+		
+		// And if that didn't work...
+		if(mpSSL)
+		{
+			::SSL_free(mpSSL);
+			mpSSL = 0;
+			mpBIO = 0;	// implicity freed by the SSL_free call
+		}
+	}
+	
+	// If we only got to creating that BIO.
+	if(mpBIO)
+	{
+		::BIO_free(mpBIO);
+		mpBIO = 0;
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::Open(const TLSContext &, int, const char *, int)
+//		Purpose: Open connection, and perform TLS handshake
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+void SocketStreamTLS::Open(const TLSContext &rContext, int Type, const char *Name, int Port)
+{
+	SocketStream::Open(Type, Name, Port);
+	Handshake(rContext);
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::Handshake(const TLSContext &, bool)
+//		Purpose: Perform TLS handshake
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+void SocketStreamTLS::Handshake(const TLSContext &rContext, bool IsServer)
+{
+	if(mpBIO || mpSSL) {THROW_EXCEPTION(ServerException, TLSAlreadyHandshaked)}
+
+	// Create a BIO for this socket
+	mpBIO = ::BIO_new(::BIO_s_socket());
+	if(mpBIO == 0)
+	{
+		SSLLib::LogError("Create socket bio");
+		THROW_EXCEPTION(ServerException, TLSAllocationFailed)
+	}
+	int socket = GetSocketHandle();
+	BIO_set_fd(mpBIO, socket, BIO_NOCLOSE);
+	
+	// Then the SSL object
+	mpSSL = ::SSL_new(rContext.GetRawContext());
+	if(mpSSL == 0)
+	{
+		SSLLib::LogError("Create ssl");
+		THROW_EXCEPTION(ServerException, TLSAllocationFailed)
+	}
+
+	// Make the socket non-blocking so timeouts on Read work
+	int nonblocking = true;
+	if(::ioctl(socket, FIONBIO, &nonblocking) == -1)
+	{
+		THROW_EXCEPTION(ServerException, SocketSetNonBlockingFailed)
+	}
+	
+	// Set the two to know about each other
+	::SSL_set_bio(mpSSL, mpBIO, mpBIO);
+
+	bool waitingForHandshake = true;
+	while(waitingForHandshake)
+	{
+		// Attempt to do the handshake
+		int r = 0;
+		if(IsServer)
+		{
+			r = ::SSL_accept(mpSSL);
+		}
+		else
+		{
+			r = ::SSL_connect(mpSSL);
+		}
+
+		// check return code
+		int se;
+		switch((se = ::SSL_get_error(mpSSL, r)))
+		{
+		case SSL_ERROR_NONE:
+			// No error, handshake succeeded
+			waitingForHandshake = false;
+			break;
+
+		case SSL_ERROR_WANT_READ:
+		case SSL_ERROR_WANT_WRITE:
+			// wait for the requried data
+			if(WaitWhenRetryRequired(se, TLS_HANDSHAKE_TIMEOUT) == false)
+			{
+				// timed out
+				THROW_EXCEPTION(ConnectionException, Conn_TLSHandshakeTimedOut)
+			}
+			break;
+			
+		default: // (and SSL_ERROR_ZERO_RETURN)
+			// Error occured
+			if(IsServer)
+			{
+				SSLLib::LogError("Accept");
+				THROW_EXCEPTION(ConnectionException, Conn_TLSHandshakeFailed)
+			}
+			else
+			{
+				SSLLib::LogError("Connect");
+				THROW_EXCEPTION(ConnectionException, Conn_TLSHandshakeFailed)
+			}
+		}
+	}
+	
+	// And that's it
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WaitWhenRetryRequired(int, int)
+//		Purpose: Waits until the condition required by the TLS layer is met.
+//				 Returns true if the condition is met, false if timed out.
+//		Created: 2003/08/15
+//
+// --------------------------------------------------------------------------
+bool SocketStreamTLS::WaitWhenRetryRequired(int SSLErrorCode, int Timeout)
+{
+	struct pollfd p;
+	p.fd = GetSocketHandle();
+	switch(SSLErrorCode)
+	{
+	case SSL_ERROR_WANT_READ:
+		p.events = POLLIN;
+		break;
+		
+	case SSL_ERROR_WANT_WRITE:
+		p.events = POLLOUT;
+		break;
+
+	default:
+		// Not good!
+		THROW_EXCEPTION(ServerException, Internal)
+		break;
+	}
+	p.revents = 0;
+	switch(::poll(&p, 1, (Timeout == IOStream::TimeOutInfinite)?INFTIM:Timeout))
+	{
+	case -1:
+		// error
+		if(errno == EINTR)
+		{
+			// Signal. Do "time out"
+			return false;
+		}
+		else
+		{
+			// Bad!
+			THROW_EXCEPTION(ServerException, SocketPollError)
+		}
+		break;
+
+	case 0:
+		// Condition not met, timed out
+		return false;
+		break;
+
+	default:
+		// good to go!
+		return true;
+		break;
+	}
+
+	return true;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::Read(void *, int, int Timeout)
+//		Purpose: See base class
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+int SocketStreamTLS::Read(void *pBuffer, int NBytes, int Timeout)
+{
+	if(!mpSSL) {THROW_EXCEPTION(ServerException, TLSNoSSLObject)}
+
+	// Make sure zero byte reads work as expected
+	if(NBytes == 0)
+	{
+		return 0;
+	}
+	
+	while(true)
+	{
+		int r = ::SSL_read(mpSSL, pBuffer, NBytes);
+
+		int se;
+		switch((se = ::SSL_get_error(mpSSL, r)))
+		{
+		case SSL_ERROR_NONE:
+			// No error, return number of bytes read
+			return r;
+			break;
+
+		case SSL_ERROR_ZERO_RETURN:
+			// Connection closed
+			MarkAsReadClosed();
+			return 0;
+			break;
+
+		case SSL_ERROR_WANT_READ:
+		case SSL_ERROR_WANT_WRITE:
+			// wait for the requried data
+			// Will only get once around this loop, so don't need to calculate timeout values
+			if(WaitWhenRetryRequired(se, Timeout) == false)
+			{
+				// timed out
+				return 0;
+			}
+			break;
+			
+		default:
+			SSLLib::LogError("Read");
+			THROW_EXCEPTION(ConnectionException, Conn_TLSReadFailed)
+			break;
+		}
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::Write(const void *, int)
+//		Purpose: See base class
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+void SocketStreamTLS::Write(const void *pBuffer, int NBytes)
+{
+	if(!mpSSL) {THROW_EXCEPTION(ServerException, TLSNoSSLObject)}
+	
+	// Make sure zero byte writes work as expected
+	if(NBytes == 0)
+	{
+		return;
+	}
+	
+	// from man SSL_write
+	//
+	// SSL_write() will only return with success, when the
+	// complete contents of buf of length num has been written.
+	//
+	// So no worries about partial writes and moving the buffer around
+	
+	while(true)
+	{
+		// try the write
+		int r = ::SSL_write(mpSSL, pBuffer, NBytes);
+		
+		int se;
+		switch((se = ::SSL_get_error(mpSSL, r)))
+		{
+		case SSL_ERROR_NONE:
+			// No error, data sent, return success
+			return;
+			break;
+
+		case SSL_ERROR_ZERO_RETURN:
+			// Connection closed
+			MarkAsWriteClosed();
+			THROW_EXCEPTION(ConnectionException, Conn_TLSClosedWhenWriting)
+			break;
+
+		case SSL_ERROR_WANT_READ:
+		case SSL_ERROR_WANT_WRITE:
+			// wait for the requried data
+			{
+			#ifndef NDEBUG
+				bool conditionmet = 
+			#endif
+				WaitWhenRetryRequired(se, IOStream::TimeOutInfinite);
+				ASSERT(conditionmet);
+			}
+			break;
+		
+		default:
+			SSLLib::LogError("Write");
+			THROW_EXCEPTION(ConnectionException, Conn_TLSWriteFailed)
+			break;
+		}
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::Close()
+//		Purpose: See base class
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+void SocketStreamTLS::Close()
+{
+	if(!mpSSL) {THROW_EXCEPTION(ServerException, TLSNoSSLObject)}
+
+	// Base class to close
+	SocketStream::Close();
+
+	// Free resources
+	::SSL_free(mpSSL);
+	mpSSL = 0;
+	mpBIO = 0;	// implicitly freed by SSL_free
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::Shutdown()
+//		Purpose: See base class
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+void SocketStreamTLS::Shutdown(bool Read, bool Write)
+{
+	if(!mpSSL) {THROW_EXCEPTION(ServerException, TLSNoSSLObject)}
+
+	if(::SSL_shutdown(mpSSL) < 0)
+	{
+		SSLLib::LogError("Shutdown");
+		THROW_EXCEPTION(ConnectionException, Conn_TLSShutdownFailed)
+	}
+
+	// Don't ask the base class to shutdown -- BIO does this, apparently.
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    SocketStreamTLS::GetPeerCommonName()
+//		Purpose: Returns the common name of the other end of the connection
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+std::string SocketStreamTLS::GetPeerCommonName()
+{
+	if(!mpSSL) {THROW_EXCEPTION(ServerException, TLSNoSSLObject)}
+
+	// Get certificate
+	X509 *cert = ::SSL_get_peer_certificate(mpSSL);
+	if(cert == 0)
+	{
+		::X509_free(cert);
+		THROW_EXCEPTION(ConnectionException, Conn_TLSNoPeerCertificate)
+	}
+
+	// Subject details	
+	X509_NAME *subject = ::X509_get_subject_name(cert); 
+	if(subject == 0)
+	{
+		::X509_free(cert);
+		THROW_EXCEPTION(ConnectionException, Conn_TLSPeerCertificateInvalid)
+	}
+	
+	// Common name
+	char commonName[256];
+	if(::X509_NAME_get_text_by_NID(subject, NID_commonName, commonName, sizeof(commonName)) <= 0)
+	{
+		::X509_free(cert);
+		THROW_EXCEPTION(ConnectionException, Conn_TLSPeerCertificateInvalid)
+	}
+	// Terminate just in case
+	commonName[sizeof(commonName)-1] = '\0';
+	
+	// Done.
+	return std::string(commonName);
+}
+
+
diff --git a/lib/server/SocketStreamTLS.h b/lib/server/SocketStreamTLS.h
new file mode 100755
index 00000000..64e52833
--- /dev/null
+++ b/lib/server/SocketStreamTLS.h
@@ -0,0 +1,60 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    SocketStreamTLS.h
+//		Purpose: Socket stream encrpyted and authenticated by TLS
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+
+#ifndef SOCKETSTREAMTLS__H
+#define SOCKETSTREAMTLS__H
+
+#include <string>
+
+#include "SocketStream.h"
+
+class TLSContext;
+#ifndef TLS_CLASS_IMPLEMENTATION_CPP
+	class SSL;
+	class BIO;
+#endif
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    SocketStreamTLS
+//		Purpose: Socket stream encrpyted and authenticated by TLS
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+class SocketStreamTLS : public SocketStream
+{
+public:
+	SocketStreamTLS();
+	SocketStreamTLS(int socket);
+	~SocketStreamTLS();
+private:
+	SocketStreamTLS(const SocketStreamTLS &rToCopy);
+public:
+
+	void Open(const TLSContext &rContext, int Type, const char *Name, int Port = 0);
+	void Handshake(const TLSContext &rContext, bool IsServer = false);
+	
+	virtual int Read(void *pBuffer, int NBytes, int Timeout = IOStream::TimeOutInfinite);
+	virtual void Write(const void *pBuffer, int NBytes);
+	virtual void Close();
+	virtual void Shutdown(bool Read = true, bool Write = true);
+
+	std::string GetPeerCommonName();
+
+private:
+	bool WaitWhenRetryRequired(int SSLErrorCode, int Timeout);
+
+private:
+	SSL *mpSSL;
+	BIO *mpBIO;
+};
+
+#endif // SOCKETSTREAMTLS__H
+
diff --git a/lib/server/TLSContext.cpp b/lib/server/TLSContext.cpp
new file mode 100755
index 00000000..cc125d00
--- /dev/null
+++ b/lib/server/TLSContext.cpp
@@ -0,0 +1,120 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    TLSContext.h
+//		Purpose: TLS (SSL) context for connections
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#define TLS_CLASS_IMPLEMENTATION_CPP
+#include <openssl/ssl.h>
+
+#include "TLSContext.h"
+#include "ServerException.h"
+#include "SSLLib.h"
+#include "TLSContext.h"
+
+#include "MemLeakFindOn.h"
+
+#define MAX_VERIFICATION_DEPTH		2
+#define CIPHER_LIST					"ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH"
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    TLSContext::TLSContext()
+//		Purpose: Constructor
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+TLSContext::TLSContext()
+	: mpContext(0)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    TLSContext::~TLSContext()
+//		Purpose: Destructor
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+TLSContext::~TLSContext()
+{
+	if(mpContext != 0)
+	{
+		::SSL_CTX_free(mpContext);
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    TLSContext::Initialise(bool, const char *, const char *, const char *)
+//		Purpose: Initialise the context, loading in the specified certificate and private key files
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+void TLSContext::Initialise(bool AsServer, const char *CertificatesFile, const char *PrivateKeyFile, const char *TrustedCAsFile)
+{
+	mpContext = ::SSL_CTX_new(AsServer?TLSv1_server_method():TLSv1_client_method());
+	if(mpContext == NULL)
+	{
+		THROW_EXCEPTION(ServerException, TLSAllocationFailed)
+	}
+	
+	// Setup our identity
+	if(::SSL_CTX_use_certificate_chain_file(mpContext, CertificatesFile) != 1)
+	{
+		SSLLib::LogError("Load certificates");
+		THROW_EXCEPTION(ServerException, TLSLoadCertificatesFailed)
+	}
+	if(::SSL_CTX_use_PrivateKey_file(mpContext, PrivateKeyFile, SSL_FILETYPE_PEM) != 1)
+	{
+		SSLLib::LogError("Load private key");
+		THROW_EXCEPTION(ServerException, TLSLoadPrivateKeyFailed)
+	}
+	
+	// Setup the identify of CAs we trust
+	if(::SSL_CTX_load_verify_locations(mpContext, TrustedCAsFile, NULL) != 1)
+	{
+		SSLLib::LogError("Load CA cert");
+		THROW_EXCEPTION(ServerException, TLSLoadTrustedCAsFailed)
+	}
+	
+	// Setup options to require these certificates
+	::SSL_CTX_set_verify(mpContext, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
+	// and a sensible maximum depth
+	::SSL_CTX_set_verify_depth(mpContext, MAX_VERIFICATION_DEPTH);
+	
+	// Setup allowed ciphers
+	if(::SSL_CTX_set_cipher_list(mpContext, CIPHER_LIST) != 1)
+	{
+		SSLLib::LogError("Set cipher list");
+		THROW_EXCEPTION(ServerException, TLSSetCiphersFailed)
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    TLSContext::GetRawContext()
+//		Purpose: Get the raw context for OpenSSL API
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+SSL_CTX *TLSContext::GetRawContext() const
+{
+	if(mpContext == 0)
+	{
+		THROW_EXCEPTION(ServerException, TLSContextNotInitialised)
+	}
+	return mpContext;
+}
+
+
+
diff --git a/lib/server/TLSContext.h b/lib/server/TLSContext.h
new file mode 100755
index 00000000..f52f5457
--- /dev/null
+++ b/lib/server/TLSContext.h
@@ -0,0 +1,41 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    TLSContext.h
+//		Purpose: TLS (SSL) context for connections
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+
+#ifndef TLSCONTEXT__H
+#define TLSCONTEXT__H
+
+#ifndef TLS_CLASS_IMPLEMENTATION_CPP
+	class SSL_CTX;
+#endif
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    TLSContext
+//		Purpose: TLS (SSL) context for connections
+//		Created: 2003/08/06
+//
+// --------------------------------------------------------------------------
+class TLSContext
+{
+public:
+	TLSContext();
+	~TLSContext();
+private:
+	TLSContext(const TLSContext &);
+public:
+	void Initialise(bool AsServer, const char *CertificatesFile, const char *PrivateKeyFile, const char *TrustedCAsFile);
+	SSL_CTX *GetRawContext() const;
+
+private:
+	SSL_CTX *mpContext;
+};
+
+#endif // TLSCONTEXT__H
+
diff --git a/lib/server/makeprotocol.pl b/lib/server/makeprotocol.pl
new file mode 100755
index 00000000..2a69c59c
--- /dev/null
+++ b/lib/server/makeprotocol.pl
@@ -0,0 +1,993 @@
+#!/usr/bin/perl
+use strict;
+
+# Make protocol C++ classes from a protocol description file
+
+# built in type info (values are is basic type, C++ typename)
+# may get stuff added to it later if protocol uses extra types
+my %translate_type_info =
+(
+	'int64' => [1, 'int64_t'],
+	'int32' => [1, 'int32_t'],
+	'int16' => [1, 'int16_t'],
+	'int8' => [1, 'int8_t'],
+	'bool' => [1, 'bool'],
+	'string' => [0, 'std::string']
+);
+
+# built in instructions for logging various types
+# may be added to
+my %log_display_types = 
+(
+	'int64' => ['0x%llx', 'VAR'],
+	'int32' => ['0x%x', 'VAR'],
+	'int16' => ['0x%x', 'VAR'],
+	'int8' => ['0x%x', 'VAR'],
+	'bool' => ['%s', '((VAR)?"true":"false")'],
+	'string' => ['%s', 'VAR.c_str()']
+);
+
+
+
+my ($type, $file) = @ARGV;
+
+if($type ne 'Server' && $type ne 'Client')
+{
+	die "Neither Server or Client is specified on command line\n";
+}
+
+open IN, $file or die "Can't open input file $file\n";
+
+print "Making $type protocol classes from $file...\n";
+
+my @extra_header_files;
+
+my $implement_syslog = 0;
+my $implement_filelog = 0;
+
+# read attributes
+my %attr;
+while(<IN>)
+{
+	# get and clean line
+	my $l = $_; $l =~ s/#.*\Z//; $l =~ s/\A\s+//; $l =~ s/\s+\Z//; next unless $l =~ m/\S/;
+	
+	last if $l eq 'BEGIN_OBJECTS';
+	
+	my ($k,$v) = split /\s+/,$l,2;
+	
+	if($k eq 'ClientType')
+	{
+		add_type($v) if $type eq 'Client';
+	}
+	elsif($k eq 'ServerType')
+	{
+		add_type($v) if $type eq 'Server';
+	}
+	elsif($k eq 'ImplementLog')
+	{
+		my ($log_if_type,$log_type) = split /\s+/,$v;
+		if($type eq $log_if_type)
+		{
+			if($log_type eq 'syslog')
+			{
+				$implement_syslog = 1;
+			}
+			elsif($log_type eq 'file')
+			{
+				$implement_filelog = 1;
+			}
+			else
+			{
+				printf("ERROR: Unknown log type for implementation: $log_type\n");
+				exit(1);
+			}
+		}
+	}
+	elsif($k eq 'LogTypeToText')
+	{
+		my ($log_if_type,$type_name,$printf_format,$arg_template) = split /\s+/,$v;
+		if($type eq $log_if_type)
+		{
+			$log_display_types{$type_name} = [$printf_format,$arg_template]
+		}
+	}
+	else
+	{
+		$attr{$k} = $v;
+	}
+}
+
+sub add_type
+{
+	my ($protocol_name, $cpp_name, $header_file) = split /\s+/,$_[0];
+	
+	$translate_type_info{$protocol_name} = [0, $cpp_name];
+	push @extra_header_files, $header_file;
+}
+
+# check attributes
+for(qw/Name ServerContextClass IdentString/)
+{
+	if(!exists $attr{$_})
+	{
+		die "Attribute $_ is required, but not specified\n";
+	}
+}
+
+my $protocol_name = $attr{'Name'};
+my ($context_class, $context_class_inc) = split /\s+/,$attr{'ServerContextClass'};
+my $ident_string = $attr{'IdentString'};
+
+my $current_cmd = '';
+my %cmd_contents;
+my %cmd_attributes;
+my %cmd_constants;
+my %cmd_id;
+my @cmd_list;
+
+# read in the command definitions
+while(<IN>)
+{
+	# get and clean line
+	my $l = $_; $l =~ s/#.*\Z//; $l =~ s/\s+\Z//; next unless $l =~ m/\S/;
+	
+	# definitions or new command thing?
+	if($l =~ m/\A\s+/)
+	{
+		die "No command defined yet" if $current_cmd eq '';
+	
+		# definition of component
+		$l =~ s/\A\s+//;
+		
+		my ($type,$name,$value) = split /\s+/,$l;
+		if($type eq 'CONSTANT')
+		{
+			push @{$cmd_constants{$current_cmd}},"$name = $value"
+		}
+		else
+		{
+			push @{$cmd_contents{$current_cmd}},$type,$name;
+		}
+	}
+	else
+	{
+		# new command
+		my ($name,$id,@attributes) = split /\s+/,$l;
+		$cmd_attributes{$name} = [@attributes];
+		$cmd_id{$name} = int($id);
+		$current_cmd = $name;
+		push @cmd_list,$name;
+	}
+}
+
+close IN;
+
+
+
+# open files
+my $h_filename = 'autogen_'.$protocol_name.'Protocol'.$type.'.h';
+open CPP,'>autogen_'.$protocol_name.'Protocol'.$type.'.cpp';
+open H,">$h_filename";
+
+print CPP <<__E;
+
+// Auto-generated file -- do not edit
+
+#include "Box.h"
+#include "$h_filename"
+#include "IOStream.h"
+
+__E
+
+if($implement_syslog)
+{
+	print H qq~#include <syslog.h>\n~;
+}
+
+
+my $guardname = uc 'AUTOGEN_'.$protocol_name.'Protocol'.$type.'_H';
+print H <<__E;
+
+// Auto-generated file -- do not edit
+
+#ifndef $guardname
+#define $guardname
+
+#include "Protocol.h"
+#include "ProtocolObject.h"
+#include "ServerException.h"
+
+class IOStream;
+
+__E
+
+if($implement_filelog)
+{
+	print H qq~#include <stdio.h>\n~;
+}
+
+# extra headers
+for(@extra_header_files)
+{
+	print H qq~#include "$_"\n~
+}
+print H "\n";
+
+if($type eq 'Server')
+{
+	# need utils file for the server
+	print H '#include "Utils.h"',"\n\n"
+}
+
+
+my $derive_objects_from = 'ProtocolObject';
+my $objects_extra_h = '';
+my $objects_extra_cpp = '';
+if($type eq 'Server')
+{
+	# define the context
+	print H "class $context_class;\n\n";
+	print CPP "#include \"$context_class_inc\"\n\n";
+	
+	# change class we derive the objects from
+	$derive_objects_from = $protocol_name.'ProtocolObject';
+	
+	$objects_extra_h = <<__E;
+	virtual std::auto_ptr<ProtocolObject> DoCommand(${protocol_name}ProtocolServer &rProtocol, $context_class &rContext);
+__E
+	$objects_extra_cpp = <<__E;
+std::auto_ptr<ProtocolObject> ${derive_objects_from}::DoCommand(${protocol_name}ProtocolServer &rProtocol, $context_class &rContext)
+{
+	THROW_EXCEPTION(ConnectionException, Conn_Protocol_TriedToExecuteReplyCommand)
+}
+__E
+}
+
+print CPP qq~#include "MemLeakFindOn.h"\n~;
+
+if($type eq 'Client' && ($implement_syslog || $implement_filelog))
+{
+	# change class we derive the objects from
+	$derive_objects_from = $protocol_name.'ProtocolObjectCl';
+}
+if($implement_syslog)
+{
+	$objects_extra_h .= <<__E;
+	virtual void LogSysLog(const char *Action) const = 0;
+__E
+}
+if($implement_filelog)
+{
+	$objects_extra_h .= <<__E;
+	virtual void LogFile(const char *Action, FILE *file) const = 0;
+__E
+}
+
+if($derive_objects_from ne 'ProtocolObject')
+{	
+	# output a definition for the protocol object derviced class
+	print H <<__E;
+class ${protocol_name}ProtocolServer;
+	
+class $derive_objects_from : public ProtocolObject
+{
+public:
+	$derive_objects_from();
+	virtual ~$derive_objects_from();
+	$derive_objects_from(const $derive_objects_from &rToCopy);
+	
+$objects_extra_h
+};
+__E
+
+	# and some cpp definitions
+	print CPP <<__E;
+${derive_objects_from}::${derive_objects_from}()
+{
+}
+${derive_objects_from}::~${derive_objects_from}()
+{
+}
+${derive_objects_from}::${derive_objects_from}(const $derive_objects_from &rToCopy)
+{
+}
+$objects_extra_cpp
+__E
+}
+
+
+
+my $classname_base = $protocol_name.'Protocol'.$type;
+
+# output the classes
+for my $cmd (@cmd_list)
+{
+	print H <<__E;
+class $classname_base$cmd : public $derive_objects_from
+{
+public:
+	$classname_base$cmd();
+	$classname_base$cmd(const $classname_base$cmd &rToCopy);
+	~$classname_base$cmd();
+	int GetType() const;
+	enum
+	{
+		TypeID = $cmd_id{$cmd}
+	};
+__E
+	# constants
+	if(exists $cmd_constants{$cmd})
+	{
+		print H "\tenum\n\t{\n\t\t";
+		print H join(",\n\t\t",@{$cmd_constants{$cmd}});
+		print H "\n\t};\n";
+	}
+	# flags
+	if(obj_is_type($cmd,'EndsConversation'))
+	{
+		print H "\tbool IsConversationEnd() const;\n";
+	}
+	if(obj_is_type($cmd,'IsError'))
+	{
+		print H "\tbool IsError(int &rTypeOut, int &rSubTypeOut) const;\n";
+	}
+	if($type eq 'Server' && obj_is_type($cmd, 'Command'))
+	{
+		print H "\tstd::auto_ptr<ProtocolObject> DoCommand(${protocol_name}ProtocolServer &rProtocol, $context_class &rContext); // IMPLEMENT THIS\n"
+	}
+
+	# want to be able to read from streams?
+	my $read_from_streams = (obj_is_type($cmd,'Command') && $type eq 'Server') || (obj_is_type($cmd,'Reply') && $type eq 'Client');
+	my $write_to_streams = (obj_is_type($cmd,'Command') && $type eq 'Client') || (obj_is_type($cmd,'Reply') && $type eq 'Server');
+	
+	if($read_from_streams)
+	{
+		print H "\tvoid SetPropertiesFromStreamData(Protocol &rProtocol);\n";
+		
+		# write Get functions
+		for(my $x = 0; $x < $#{$cmd_contents{$cmd}}; $x+=2)
+		{
+			my ($ty,$nm) = (${$cmd_contents{$cmd}}[$x], ${$cmd_contents{$cmd}}[$x+1]);
+			
+			print H "\t".translate_type_to_arg_type($ty)." Get$nm() {return m$nm;}\n";
+		}
+	}
+	my $param_con_args = '';
+	if($write_to_streams)
+	{
+		# extra constructor?
+		if($#{$cmd_contents{$cmd}} >= 0)
+		{
+			my @a;
+			for(my $x = 0; $x < $#{$cmd_contents{$cmd}}; $x+=2)
+			{
+				my ($ty,$nm) = (${$cmd_contents{$cmd}}[$x], ${$cmd_contents{$cmd}}[$x+1]);
+
+				push @a,translate_type_to_arg_type($ty)." $nm";
+			}		
+			$param_con_args = join(', ',@a);
+			print H "\t$classname_base$cmd(".$param_con_args.");\n";
+		}
+		print H "\tvoid WritePropertiesToStreamData(Protocol &rProtocol) const;\n";
+		# set functions
+		for(my $x = 0; $x < $#{$cmd_contents{$cmd}}; $x+=2)
+		{
+			my ($ty,$nm) = (${$cmd_contents{$cmd}}[$x], ${$cmd_contents{$cmd}}[$x+1]);
+			
+			print H "\tvoid Set$nm(".translate_type_to_arg_type($ty)." $nm) {m$nm = $nm;}\n";
+		}
+	}
+	
+	if($implement_syslog)
+	{
+		print H "\tvirtual void LogSysLog(const char *Action) const;\n";
+	}
+	if($implement_filelog)
+	{
+		print H "\tvirtual void LogFile(const char *Action, FILE *file) const;\n";
+	}
+
+	
+	# write member variables and setup for cpp file
+	my @def_constructor_list;
+	my @copy_constructor_list;
+	my @param_constructor_list;
+	
+	print H "private:\n";
+	for(my $x = 0; $x < $#{$cmd_contents{$cmd}}; $x+=2)
+	{
+		my ($ty,$nm) = (${$cmd_contents{$cmd}}[$x], ${$cmd_contents{$cmd}}[$x+1]);
+
+		print H "\t".translate_type_to_member_type($ty)." m$nm;\n";
+		
+		my ($basic,$typename) = translate_type($ty);
+		if($basic)
+		{
+			push @def_constructor_list, "m$nm(0)";
+		}
+		push @copy_constructor_list, "m$nm(rToCopy.m$nm)";
+		push @param_constructor_list, "m$nm($nm)";
+	}
+	
+	# finish off
+	print H "};\n\n";
+	
+	# now the cpp file...
+	my $def_con_vars = join(",\n\t  ",@def_constructor_list);
+	$def_con_vars = "\n\t: ".$def_con_vars if $def_con_vars ne '';
+	my $copy_con_vars = join(",\n\t  ",@copy_constructor_list);
+	$copy_con_vars = "\n\t: ".$copy_con_vars if $copy_con_vars ne '';
+	my $param_con_vars = join(",\n\t  ",@param_constructor_list);
+	$param_con_vars = "\n\t: ".$param_con_vars if $param_con_vars ne '';
+
+	my $class = "$classname_base$cmd".'::';
+	print CPP <<__E;
+$class$classname_base$cmd()$def_con_vars
+{
+}
+$class$classname_base$cmd(const $classname_base$cmd &rToCopy)$copy_con_vars
+{
+}
+$class~$classname_base$cmd()
+{
+}
+int ${class}GetType() const
+{
+	return $cmd_id{$cmd};
+}
+__E
+	if($read_from_streams)
+	{
+		print CPP "void ${class}SetPropertiesFromStreamData(Protocol &rProtocol)\n{\n";
+		for(my $x = 0; $x < $#{$cmd_contents{$cmd}}; $x+=2)
+		{
+			my ($ty,$nm) = (${$cmd_contents{$cmd}}[$x], ${$cmd_contents{$cmd}}[$x+1]);
+			if($ty =~ m/\Avector/)
+			{
+				print CPP "\trProtocol.ReadVector(m$nm);\n";
+			}
+			else
+			{
+				print CPP "\trProtocol.Read(m$nm);\n";
+			}
+		}
+		print CPP "}\n";
+	}
+	if($write_to_streams)
+	{
+		# implement extra constructor?
+		if($param_con_vars ne '')
+		{
+			print CPP "$class$classname_base$cmd($param_con_args)$param_con_vars\n{\n}\n";
+		}
+		print CPP "void ${class}WritePropertiesToStreamData(Protocol &rProtocol) const\n{\n";
+		for(my $x = 0; $x < $#{$cmd_contents{$cmd}}; $x+=2)
+		{
+			my ($ty,$nm) = (${$cmd_contents{$cmd}}[$x], ${$cmd_contents{$cmd}}[$x+1]);
+			if($ty =~ m/\Avector/)
+			{
+				print CPP "\trProtocol.WriteVector(m$nm);\n";
+			}
+			else
+			{
+				print CPP "\trProtocol.Write(m$nm);\n";
+			}
+		}
+		print CPP "}\n";
+	}
+	if(obj_is_type($cmd,'EndsConversation'))
+	{
+		print CPP "bool ${class}IsConversationEnd() const\n{\n\treturn true;\n}\n";
+	}
+	if(obj_is_type($cmd,'IsError'))
+	{
+		# get parameters
+		my ($mem_type,$mem_subtype) = split /,/,obj_get_type_params($cmd,'IsError');
+		print CPP <<__E;
+bool ${class}IsError(int &rTypeOut, int &rSubTypeOut) const
+{
+	rTypeOut = m$mem_type;
+	rSubTypeOut = m$mem_subtype;
+	return true;
+}
+__E
+	}
+
+	if($implement_syslog)
+	{
+		my ($format,$args) = make_log_strings($cmd);
+		print CPP <<__E;
+void ${class}LogSysLog(const char *Action) const
+{
+	::syslog(LOG_INFO,"%s $format",Action$args);
+}
+__E
+	}
+	if($implement_filelog)
+	{
+		my ($format,$args) = make_log_strings($cmd);
+		print CPP <<__E;
+void ${class}LogFile(const char *Action, FILE *File) const
+{
+	::fprintf(File,"%s $format\\n",Action$args);
+	::fflush(File);
+}
+__E
+	}
+}
+
+# finally, the protocol object itself
+print H <<__E;
+class $classname_base : public Protocol
+{
+public:
+	$classname_base(IOStream &rStream);
+	virtual ~$classname_base();
+
+	std::auto_ptr<$derive_objects_from> Receive();
+	void Send(const ${derive_objects_from} &rObject);
+__E
+if($implement_syslog)
+{
+	print H "\tvoid SetLogToSysLog(bool Log = false) {mLogToSysLog = Log;}\n";
+}
+if($implement_filelog)
+{
+	print H "\tvoid SetLogToFile(FILE *File = 0) {mLogToFile = File;}\n";
+}
+if($type eq 'Server')
+{
+	# need to put in the conversation function
+	print H "\tvoid DoServer($context_class &rContext);\n\n";
+	# and the send vector thing
+	print H "\tvoid SendStreamAfterCommand(IOStream *pStream);\n\n";
+}
+if($type eq 'Client')
+{
+	# add plain object taking query functions
+	my $with_params;
+	for my $cmd (@cmd_list)
+	{
+		if(obj_is_type($cmd,'Command'))
+		{
+			my $has_stream = obj_is_type($cmd,'StreamWithCommand');
+			my $argextra = $has_stream?', IOStream &rStream':'';
+			my $queryextra = $has_stream?', rStream':'';
+			my $reply = obj_get_type_params($cmd,'Command');
+			print H "\tstd::auto_ptr<$classname_base$reply> Query(const $classname_base$cmd &rQuery$argextra);\n";
+			my @a;
+			my @na;
+			for(my $x = 0; $x < $#{$cmd_contents{$cmd}}; $x+=2)
+			{
+				my ($ty,$nm) = (${$cmd_contents{$cmd}}[$x], ${$cmd_contents{$cmd}}[$x+1]);
+				push @a,translate_type_to_arg_type($ty)." $nm";
+				push @na,"$nm";
+			}
+			my $ar = join(', ',@a);
+			my $nar = join(', ',@na);
+			$nar = "($nar)" if $nar ne '';
+
+			$with_params .= "\tinline std::auto_ptr<$classname_base$reply> Query$cmd($ar$argextra)\n\t{\n";
+			$with_params .= "\t\t$classname_base$cmd send$nar;\n";
+			$with_params .= "\t\treturn Query(send$queryextra);\n";
+			$with_params .= "\t}\n";
+		}
+	}
+	# quick hack to correct bad argument lists for commands with zero paramters but with streams
+	$with_params =~ s/\(, /(/g;
+	print H "\n",$with_params,"\n";
+}
+print H <<__E;
+private:
+	$classname_base(const $classname_base &rToCopy);
+__E
+if($type eq 'Server')
+{
+	# need to put the streams to send vector
+	print H "\tstd::vector<IOStream*> mStreamsToSend;\n\tvoid DeleteStreamsToSend();\n";
+}
+
+if($implement_filelog || $implement_syslog)
+{
+	print H <<__E;
+	virtual void InformStreamReceiving(u_int32_t Size);
+	virtual void InformStreamSending(u_int32_t Size);
+__E
+}
+
+if($implement_syslog)
+{
+	print H "private:\n\tbool mLogToSysLog;\n";
+}
+if($implement_filelog)
+{
+	print H "private:\n\tFILE *mLogToFile;\n";
+}
+print H <<__E;
+
+protected:	
+	virtual std::auto_ptr<ProtocolObject> MakeProtocolObject(int ObjType);
+	virtual const char *GetIdentString();
+};
+
+__E
+
+my $construtor_extra = '';
+$construtor_extra .= ', mLogToSysLog(false)' if $implement_syslog;
+$construtor_extra .= ', mLogToFile(0)' if $implement_filelog;
+
+my $destructor_extra = ($type eq 'Server')?"\n\tDeleteStreamsToSend();":'';
+
+my $prefix = $classname_base.'::';
+print CPP <<__E;
+$prefix$classname_base(IOStream &rStream)
+	: Protocol(rStream)$construtor_extra
+{
+}
+$prefix~$classname_base()
+{$destructor_extra
+}
+const char *${prefix}GetIdentString()
+{
+	return "$ident_string";
+}
+std::auto_ptr<ProtocolObject> ${prefix}MakeProtocolObject(int ObjType)
+{
+	switch(ObjType)
+	{
+__E
+
+# do objects within this
+for my $cmd (@cmd_list)
+{
+	print CPP <<__E;
+	case $cmd_id{$cmd}:
+		return std::auto_ptr<ProtocolObject>(new $classname_base$cmd);
+		break;
+__E
+}
+
+print CPP <<__E;
+	default:
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_UnknownCommandRecieved)
+	}
+}
+__E
+# write receieve and send functions
+print CPP <<__E;
+std::auto_ptr<$derive_objects_from> ${prefix}Receive()
+{
+	std::auto_ptr<${derive_objects_from}> preply((${derive_objects_from}*)(Protocol::Receive().release()));
+
+__E
+	if($implement_syslog)
+	{
+		print CPP <<__E;
+	if(mLogToSysLog)
+	{
+		preply->LogSysLog("Receive");
+	}
+__E
+	}
+	if($implement_filelog)
+	{
+		print CPP <<__E;
+	if(mLogToFile != 0)
+	{
+		preply->LogFile("Receive", mLogToFile);
+	}
+__E
+	}
+print CPP <<__E;
+
+	return preply;
+}
+
+void ${prefix}Send(const ${derive_objects_from} &rObject)
+{
+__E
+	if($implement_syslog)
+	{
+		print CPP <<__E;
+	if(mLogToSysLog)
+	{
+		rObject.LogSysLog("Send");
+	}
+__E
+	}
+	if($implement_filelog)
+	{
+		print CPP <<__E;
+	if(mLogToFile != 0)
+	{
+		rObject.LogFile("Send", mLogToFile);
+	}
+__E
+	}
+
+print CPP <<__E;
+	Protocol::Send(rObject);
+}
+
+__E
+# write server function?
+if($type eq 'Server')
+{
+	print CPP <<__E;
+void ${prefix}DoServer($context_class &rContext)
+{
+	// Handshake with client
+	Handshake();
+
+	// Command processing loop
+	bool inProgress = true;
+	while(inProgress)
+	{
+		// Get an object from the conversation
+		std::auto_ptr<${derive_objects_from}> pobj(Receive());
+
+__E
+	if($implement_syslog)
+	{
+		print CPP <<__E;
+		if(mLogToSysLog)
+		{
+			pobj->LogSysLog("Receive");
+		}
+__E
+	}
+	if($implement_filelog)
+	{
+		print CPP <<__E;
+		if(mLogToFile != 0)
+		{
+			pobj->LogFile("Receive", mLogToFile);
+		}
+__E
+	}
+	print CPP <<__E;
+
+		// Run the command
+		std::auto_ptr<${derive_objects_from}> preply((${derive_objects_from}*)(pobj->DoCommand(*this, rContext).release()));
+		
+__E
+	if($implement_syslog)
+	{
+		print CPP <<__E;
+		if(mLogToSysLog)
+		{
+			preply->LogSysLog("Send");
+		}
+__E
+	}
+	if($implement_filelog)
+	{
+		print CPP <<__E;
+		if(mLogToFile != 0)
+		{
+			preply->LogFile("Send", mLogToFile);
+		}
+__E
+	}
+	print CPP <<__E;
+
+		// Send the reply
+		Send(*(preply.get()));
+
+		// Send any streams
+		for(unsigned int s = 0; s < mStreamsToSend.size(); s++)
+		{
+			// Send the streams
+			SendStream(*mStreamsToSend[s]);
+		}
+		// Delete these streams
+		DeleteStreamsToSend();
+
+		// Does this end the conversation?
+		if(pobj->IsConversationEnd())
+		{
+			inProgress = false;
+		}
+	}	
+}
+
+void ${prefix}SendStreamAfterCommand(IOStream *pStream)
+{
+	ASSERT(pStream != NULL);
+	mStreamsToSend.push_back(pStream);
+}
+
+void ${prefix}DeleteStreamsToSend()
+{
+	for(std::vector<IOStream*>::iterator i(mStreamsToSend.begin()); i != mStreamsToSend.end(); ++i)
+	{
+		delete (*i);
+	}
+	mStreamsToSend.clear();
+}
+
+__E
+}
+
+# write logging functions?
+if($implement_filelog || $implement_syslog)
+{
+	my ($fR,$fS);
+
+	if($implement_syslog)
+	{
+		$fR .= qq~\tif(mLogToSysLog) { ::syslog(LOG_INFO, (Size==Protocol::ProtocolStream_SizeUncertain)?"Receiving stream, size uncertain":"Receiving stream, size %d", Size); }\n~;
+		$fS .= qq~\tif(mLogToSysLog) { ::syslog(LOG_INFO, (Size==Protocol::ProtocolStream_SizeUncertain)?"Sending stream, size uncertain":"Sending stream, size %d", Size); }\n~;
+	}
+	if($implement_filelog)
+	{
+		$fR .= qq~\tif(mLogToFile) { ::fprintf(mLogToFile, (Size==Protocol::ProtocolStream_SizeUncertain)?"Receiving stream, size uncertain":"Receiving stream, size %d\\n", Size); ::fflush(mLogToFile); }\n~;
+		$fS .= qq~\tif(mLogToFile) { ::fprintf(mLogToFile, (Size==Protocol::ProtocolStream_SizeUncertain)?"Sending stream, size uncertain":"Sending stream, size %d\\n", Size); ::fflush(mLogToFile); }\n~;
+	}
+
+	print CPP <<__E;
+
+void ${prefix}InformStreamReceiving(u_int32_t Size)
+{
+$fR}
+
+void ${prefix}InformStreamSending(u_int32_t Size)
+{
+$fS}
+
+__E
+}
+
+
+# write client Query functions?
+if($type eq 'Client')
+{
+	for my $cmd (@cmd_list)
+	{
+		if(obj_is_type($cmd,'Command'))
+		{
+			my $reply = obj_get_type_params($cmd,'Command');
+			my $reply_id = $cmd_id{$reply};
+			my $has_stream = obj_is_type($cmd,'StreamWithCommand');
+			my $argextra = $has_stream?', IOStream &rStream':'';
+			my $send_stream_extra = '';
+			if($has_stream)
+			{
+				$send_stream_extra = <<__E;
+	
+	// Send stream after the command
+	SendStream(rStream);
+__E
+			}
+			print CPP <<__E;
+std::auto_ptr<$classname_base$reply> ${classname_base}::Query(const $classname_base$cmd &rQuery$argextra)
+{
+	// Send query
+	Send(rQuery);
+	$send_stream_extra
+	// Wait for the reply
+	std::auto_ptr<${derive_objects_from}> preply(Receive().release());
+
+	if(preply->GetType() == $reply_id)
+	{
+		// Correct response
+		return std::auto_ptr<$classname_base$reply>(($classname_base$reply*)preply.release());
+	}
+	else
+	{
+		// Set protocol error
+		int type, subType;
+		if(preply->IsError(type, subType))
+		{
+			SetError(type, subType);
+			TRACE2("Protocol: Error received %d/%d\\n", type, subType);
+		}
+		else
+		{
+			SetError(Protocol::UnknownError, Protocol::UnknownError);
+		}
+		
+		// Throw an exception
+		THROW_EXCEPTION(ConnectionException, Conn_Protocol_UnexpectedReply)
+	}
+}
+__E
+		}
+	}
+}
+
+
+
+print H <<__E;
+#endif // $guardname
+
+__E
+
+# close files
+close H;
+close CPP;
+
+
+sub obj_is_type
+{
+	my ($c,$ty) = @_;
+	for(@{$cmd_attributes{$c}})
+	{
+		return 1 if $_ =~ m/\A$ty/;
+	}
+	
+	return 0;
+}
+
+sub obj_get_type_params
+{
+	my ($c,$ty) = @_;
+	for(@{$cmd_attributes{$c}})
+	{
+		return $1 if $_ =~ m/\A$ty\((.+?)\)\Z/;
+	}
+	die "Can't find attribute $ty\n"
+}
+
+# returns (is basic type, typename)
+sub translate_type
+{
+	my $ty = $_[0];
+	
+	if($ty =~ m/\Avector\<(.+?)\>\Z/)
+	{
+		my $v_type = $1;
+		my (undef,$v_ty) = translate_type($v_type);
+		return (0, 'std::vector<'.$v_ty.'>')
+	}
+	else
+	{
+		if(!exists $translate_type_info{$ty})
+		{
+			die "Don't know about type name $ty\n";
+		}
+		return @{$translate_type_info{$ty}}
+	}
+}
+
+sub translate_type_to_arg_type
+{
+	my ($basic,$typename) = translate_type(@_);
+	return $basic?$typename:'const '.$typename.'&'
+}
+
+sub translate_type_to_member_type
+{
+	my ($basic,$typename) = translate_type(@_);
+	return $typename
+}
+
+sub make_log_strings
+{
+	my ($cmd) = @_;
+
+	my @str;
+	my @arg;
+	for(my $x = 0; $x < $#{$cmd_contents{$cmd}}; $x+=2)
+	{
+		my ($ty,$nm) = (${$cmd_contents{$cmd}}[$x], ${$cmd_contents{$cmd}}[$x+1]);
+		
+		if(exists $log_display_types{$ty})
+		{
+			# need to translate it
+			my ($format,$arg) = @{$log_display_types{$ty}};
+			push @str,$format;
+			$arg =~ s/VAR/m$nm/g;
+			push @arg,$arg;
+		}
+		else
+		{
+			# is opaque
+			push @str,'OPAQUE';
+		}
+	}
+	return ($cmd.'('.join(',',@str).')', join(',','',@arg));
+}
+
+