initial commit

19 files changed, 7462 insertions, 0 deletions

diff --git a/bin/bbackupd/BackupClientContext.cpp b/bin/bbackupd/BackupClientContext.cpp
new file mode 100644
index 00000000..2445b077
--- /dev/null
+++ b/bin/bbackupd/BackupClientContext.cpp
@@ -0,0 +1,671 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupClientContext.cpp
+//		Purpose: Keep track of context
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#ifdef HAVE_SYSLOG_H
+	#include <syslog.h>
+#endif
+#ifdef HAVE_SIGNAL_H
+	#include <signal.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+	#include <sys/time.h>
+#endif
+
+#include "BoxPortsAndFiles.h"
+#include "BoxTime.h"
+#include "BackupClientContext.h"
+#include "SocketStreamTLS.h"
+#include "Socket.h"
+#include "BackupStoreConstants.h"
+#include "BackupStoreException.h"
+#include "BackupDaemon.h"
+#include "autogen_BackupProtocolClient.h"
+#include "BackupStoreFile.h"
+
+#include "MemLeakFindOn.h"
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::BackupClientContext(BackupDaemon &, TLSContext &, const std::string &, int32_t, bool)
+//		Purpose: Constructor
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+BackupClientContext::BackupClientContext(BackupDaemon &rDaemon, TLSContext &rTLSContext, const std::string &rHostname,
+			int32_t AccountNumber, bool ExtendedLogging)
+	: mrDaemon(rDaemon),
+	  mrTLSContext(rTLSContext),
+	  mHostname(rHostname),
+	  mAccountNumber(AccountNumber),
+	  mpSocket(0),
+	  mpConnection(0),
+	  mExtendedLogging(ExtendedLogging),
+	  mClientStoreMarker(ClientStoreMarker_NotKnown),
+	  mpDeleteList(0),
+	  mpCurrentIDMap(0),
+	  mpNewIDMap(0),
+	  mStorageLimitExceeded(false),
+	  mpExcludeFiles(0),
+	  mpExcludeDirs(0),
+	  mbIsManaged(false),
+	  mTimeMgmtEpoch(0)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::~BackupClientContext()
+//		Purpose: Destructor
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+BackupClientContext::~BackupClientContext()
+{
+	CloseAnyOpenConnection();
+	
+	// Delete delete list
+	if(mpDeleteList != 0)
+	{
+		delete mpDeleteList;
+		mpDeleteList = 0;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::GetConnection()
+//		Purpose: Returns the connection, making the connection and logging into
+//				 the backup store if necessary.
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+BackupProtocolClient &BackupClientContext::GetConnection()
+{
+	// Already got it? Just return it.
+	if(mpConnection != 0)
+	{
+		return *mpConnection;
+	}
+	
+	// Get a socket connection
+	if(mpSocket == 0)
+	{
+		mpSocket = new SocketStreamTLS;
+		ASSERT(mpSocket != 0);	// will have exceptioned if this was a problem
+	}
+	
+	try
+	{
+		// Defensive.
+		if(mpConnection != 0)
+		{
+			delete mpConnection;
+			mpConnection = 0;
+		}
+		
+		// Log intention
+		::syslog(LOG_INFO, "Opening connection to server %s...", mHostname.c_str());
+
+		// Connect!
+		mpSocket->Open(mrTLSContext, Socket::TypeINET, mHostname.c_str(), BOX_PORT_BBSTORED);
+		
+		// And create a procotol object
+		mpConnection = new BackupProtocolClient(*mpSocket);
+		
+		// Set logging option
+		mpConnection->SetLogToSysLog(mExtendedLogging);
+		
+		// Handshake
+		mpConnection->Handshake();
+		
+		// Check the version of the server
+		{
+			std::auto_ptr<BackupProtocolClientVersion> serverVersion(mpConnection->QueryVersion(BACKUP_STORE_SERVER_VERSION));
+			if(serverVersion->GetVersion() != BACKUP_STORE_SERVER_VERSION)
+			{
+				THROW_EXCEPTION(BackupStoreException, WrongServerVersion)
+			}
+		}
+
+		// Login -- if this fails, the Protocol will exception
+		std::auto_ptr<BackupProtocolClientLoginConfirmed> loginConf(mpConnection->QueryLogin(mAccountNumber, 0 /* read/write */));
+		
+		// Check that the client store marker is the one we expect
+		if(mClientStoreMarker != ClientStoreMarker_NotKnown)
+		{
+			if(loginConf->GetClientStoreMarker() != mClientStoreMarker)
+			{
+				// Not good... finish the connection, abort, etc, ignoring errors
+				try
+				{
+					mpConnection->QueryFinished();
+					mpSocket->Shutdown();
+					mpSocket->Close();
+				}
+				catch(...)
+				{
+					// IGNORE
+				}
+				
+				// Then throw an exception about this
+				THROW_EXCEPTION(BackupStoreException, ClientMarkerNotAsExpected)
+			}
+		}
+		
+		// Log success
+		::syslog(LOG_INFO, "Connection made, login successful");
+
+		// Check to see if there is any space available on the server
+		int64_t softLimit = loginConf->GetBlocksSoftLimit();
+		int64_t hardLimit = loginConf->GetBlocksHardLimit();
+		// Threshold for uploading new stuff
+		int64_t stopUploadThreshold = softLimit + ((hardLimit - softLimit) / 3);
+		if(loginConf->GetBlocksUsed() > stopUploadThreshold)
+		{
+			// no -- flag so only things like deletions happen
+			mStorageLimitExceeded = true;
+			// Log
+			::syslog(LOG_INFO, "Exceeded storage limits on server -- not uploading changes to files");
+		}
+	}
+	catch(...)
+	{
+		// Clean up.
+		delete mpConnection;
+		mpConnection = 0;
+		delete mpSocket;
+		mpSocket = 0;
+		throw;
+	}
+	
+	return *mpConnection;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::CloseAnyOpenConnection()
+//		Purpose: Closes a connection, if it's open
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+void BackupClientContext::CloseAnyOpenConnection()
+{
+	if(mpConnection)
+	{
+		try
+		{
+			// Need to set a client store marker?
+			if(mClientStoreMarker == ClientStoreMarker_NotKnown)
+			{
+				// Yes, choose one, the current time will do
+				box_time_t marker = GetCurrentBoxTime();
+				
+				// Set it on the store
+				mpConnection->QuerySetClientStoreMarker(marker);
+				
+				// Record it so that it can be picked up later.
+				mClientStoreMarker = marker;
+			}
+		
+			// Quit nicely
+			mpConnection->QueryFinished();
+		}
+		catch(...)
+		{
+			// Ignore errors here
+		}
+		
+		// Delete it anyway.
+		delete mpConnection;
+		mpConnection = 0;
+	}
+	
+	if(mpSocket)
+	{
+		try
+		{
+			// Be nice about closing the socket
+			mpSocket->Shutdown();
+			mpSocket->Close();
+		}
+		catch(...)
+		{
+			// Ignore errors
+		}
+		
+		// Delete object
+		delete mpSocket;
+		mpSocket = 0;
+	}
+
+	// Delete any pending list
+	if(mpDeleteList != 0)
+	{
+		delete mpDeleteList;
+		mpDeleteList = 0;
+	}
+}
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::GetTimeout()
+//		Purpose: Gets the current timeout time.
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+int BackupClientContext::GetTimeout() const
+{
+	if(mpConnection)
+	{
+		return mpConnection->GetTimeout();
+	}
+	
+	return (15*60*1000);
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::GetDeleteList()
+//		Purpose: Returns the delete list, creating one if necessary
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+BackupClientDeleteList &BackupClientContext::GetDeleteList()
+{
+	// Already created?
+	if(mpDeleteList == 0)
+	{
+		mpDeleteList = new BackupClientDeleteList;
+	}
+
+	// Return reference to object	
+	return *mpDeleteList;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    
+//		Purpose: 
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientContext::PerformDeletions()
+{
+	// Got a list?
+	if(mpDeleteList == 0)
+	{
+		// Nothing to do
+		return;
+	}
+	
+	// Delegate to the delete list object
+	mpDeleteList->PerformDeletions(*this);
+	
+	// Delete the object
+	delete mpDeleteList;
+	mpDeleteList = 0;
+}
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::GetCurrentIDMap() const
+//		Purpose: Return a (const) reference to the current ID map
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+const BackupClientInodeToIDMap &BackupClientContext::GetCurrentIDMap() const
+{
+	ASSERT(mpCurrentIDMap != 0);
+	if(mpCurrentIDMap == 0)
+	{
+		THROW_EXCEPTION(CommonException, Internal)
+	}
+	return *mpCurrentIDMap;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::GetNewIDMap() const
+//		Purpose: Return a reference to the new ID map
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+BackupClientInodeToIDMap &BackupClientContext::GetNewIDMap() const
+{
+	ASSERT(mpNewIDMap != 0);
+	if(mpNewIDMap == 0)
+	{
+		THROW_EXCEPTION(CommonException, Internal)
+	}
+	return *mpNewIDMap;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::FindFilename(int64_t, int64_t, std::string &, bool &) const
+//		Purpose: Attempts to find the pathname of an object with a given ID on the server.
+//				 Returns true if it can be found, in which case rPathOut is the local filename,
+//				 and rIsDirectoryOut == true if the local object is a directory.
+//		Created: 12/11/03
+//
+// --------------------------------------------------------------------------
+bool BackupClientContext::FindFilename(int64_t ObjectID, int64_t ContainingDirectory, std::string &rPathOut, bool &rIsDirectoryOut,
+	bool &rIsCurrentVersionOut, box_time_t *pModTimeOnServer, box_time_t *pAttributesHashOnServer, BackupStoreFilenameClear *pLeafname)
+{
+	// Make a connection to the server
+	BackupProtocolClient &connection(GetConnection());
+
+	// Request filenames from the server, in a "safe" manner to ignore errors properly
+	{
+		BackupProtocolClientGetObjectName send(ObjectID, ContainingDirectory);
+		connection.Send(send);
+	}
+	std::auto_ptr<BackupProtocolObjectCl> preply(connection.Receive());
+
+	// Is it of the right type?
+	if(preply->GetType() != BackupProtocolClientObjectName::TypeID)
+	{
+		// Was an error or something
+		return false;
+	}
+
+	// Cast to expected type.
+	BackupProtocolClientObjectName *names = (BackupProtocolClientObjectName *)(preply.get());
+
+	// Anything found?
+	int32_t numElements = names->GetNumNameElements();
+	if(numElements <= 0)
+	{
+		// No.
+		return false;
+	}
+	
+	// Get the stream containing all the names
+	std::auto_ptr<IOStream> nameStream(connection.ReceiveStream());
+
+	// Path
+	std::string path;
+
+	// Remember this is in reverse order!
+	for(int l = 0; l < numElements; ++l)
+	{
+		BackupStoreFilenameClear elementName;
+		elementName.ReadFromStream(*nameStream, GetTimeout());
+
+		// Store leafname for caller?
+		if(l == 0 && pLeafname)
+		{
+			*pLeafname = elementName;
+		}
+
+		// Is it part of the filename in the location?
+		if(l < (numElements - 1))
+		{
+			// Part of filename within
+			path = (path.empty())?(elementName.GetClearFilename()):(elementName.GetClearFilename() + DIRECTORY_SEPARATOR_ASCHAR + path);
+		}
+		else
+		{
+			// Location name -- look up in daemon's records
+			std::string locPath;
+			if(!mrDaemon.FindLocationPathName(elementName.GetClearFilename(), locPath))
+			{
+				// Didn't find the location... so can't give the local filename
+				return false;
+			}
+
+			// Add in location path
+			path = (path.empty())?(locPath):(locPath + DIRECTORY_SEPARATOR_ASCHAR + path);
+		}
+	}
+
+	// Is it a directory?
+	rIsDirectoryOut = ((names->GetFlags() & BackupProtocolClientListDirectory::Flags_Dir) == BackupProtocolClientListDirectory::Flags_Dir);
+	
+	// Is it the current version?
+	rIsCurrentVersionOut = ((names->GetFlags() & (BackupProtocolClientListDirectory::Flags_OldVersion | BackupProtocolClientListDirectory::Flags_Deleted)) == 0);
+
+	// And other information which may be required
+	if(pModTimeOnServer) *pModTimeOnServer = names->GetModificationTime();
+	if(pAttributesHashOnServer) *pAttributesHashOnServer = names->GetAttributesHash();
+
+	// Tell caller about the pathname
+	rPathOut = path;
+
+	// Found
+	return true;
+}
+
+
+// maximum time to spend diffing
+static int sMaximumDiffTime = 600;
+// maximum time of SSL inactivity (keep-alive interval)
+static int sKeepAliveTime = 0;
+
+void BackupClientContext::SetMaximumDiffingTime(int iSeconds)
+{
+	sMaximumDiffTime = iSeconds < 0 ? 0 : iSeconds;
+	TRACE1("Set maximum diffing time to %d seconds\n", sMaximumDiffTime);
+}
+
+void BackupClientContext::SetKeepAliveTime(int iSeconds)
+{
+	sKeepAliveTime = iSeconds < 0 ? 0 : iSeconds;
+	TRACE1("Set keep-alive time to %d seconds\n", sKeepAliveTime);
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    static TimerSigHandler(int)
+//		Purpose: Signal handler
+//		Created: 19/3/04
+//
+// --------------------------------------------------------------------------
+static void TimerSigHandler(int iUnused)
+{
+	BackupStoreFile::DiffTimerExpired();	
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::ManageDiffProcess()
+//		Purpose: Initiates a file diff control timer
+//		Created: 04/19/2005
+//
+// --------------------------------------------------------------------------
+void BackupClientContext::ManageDiffProcess()
+{
+	if (mbIsManaged || !mpConnection)
+		return;
+
+	ASSERT(mTimeMgmtEpoch == 0);
+
+#ifdef PLATFORM_CYGWIN
+	::signal(SIGALRM, TimerSigHandler);
+#elif defined WIN32
+	// no support for SIGVTALRM
+	SetTimerHandler(TimerSigHandler);
+#else
+	::signal(SIGVTALRM, TimerSigHandler);
+#endif // PLATFORM_CYGWIN
+
+	struct itimerval timeout;
+	memset(&timeout, 0, sizeof(timeout));
+
+	//
+	//
+	//
+	if (sMaximumDiffTime <= 0 && sKeepAliveTime <= 0)
+	{
+		TRACE0("Diff control not requested - letting things run wild\n");
+		return;
+	}
+	else if (sMaximumDiffTime > 0 && sKeepAliveTime > 0)
+	{
+		timeout.it_value.tv_sec = sKeepAliveTime < sMaximumDiffTime ? sKeepAliveTime : sMaximumDiffTime;
+		timeout.it_interval.tv_sec = sKeepAliveTime < sMaximumDiffTime ? sKeepAliveTime : sMaximumDiffTime;
+	}
+	else
+	{
+		timeout.it_value.tv_sec = sKeepAliveTime > 0 ? sKeepAliveTime : sMaximumDiffTime;
+		timeout.it_interval.tv_sec = sKeepAliveTime > 0 ? sKeepAliveTime : sMaximumDiffTime;
+	}
+
+	// avoid race
+	mTimeMgmtEpoch = time(NULL);
+
+#ifdef PLATFORM_CYGWIN
+	if(::setitimer(ITIMER_REAL, &timeout, NULL) != 0)
+#else
+	if(::setitimer(ITIMER_VIRTUAL, &timeout, NULL) != 0)
+#endif // PLATFORM_CYGWIN
+	{
+		mTimeMgmtEpoch = 0;
+
+		TRACE0("WARNING: couldn't set file diff control timeout\n");
+		THROW_EXCEPTION(BackupStoreException, Internal)
+	}
+
+	mbIsManaged = true;
+	TRACE0("Initiated timer for file diff control\n");
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::UnManageDiffProcess()
+//		Purpose: suspends file diff control timer
+//		Created: 04/19/2005
+//
+// --------------------------------------------------------------------------
+void BackupClientContext::UnManageDiffProcess()
+{
+	if (!mbIsManaged /* don't test for active connection, just do it */)
+		return;
+
+	struct itimerval timeout;
+	memset(&timeout, 0, sizeof(timeout));
+
+#ifdef PLATFORM_CYGWIN
+	if(::setitimer(ITIMER_REAL, &timeout, NULL) != 0)
+#else
+	if(::setitimer(ITIMER_VIRTUAL, &timeout, NULL) != 0)
+#endif // PLATFORM_CYGWIN
+	{
+		TRACE0("WARNING: couldn't clear file diff control timeout\n");
+		THROW_EXCEPTION(BackupStoreException, Internal)
+	}
+
+	mbIsManaged = false;
+	mTimeMgmtEpoch = 0;
+
+	TRACE0("Suspended timer for file diff control\n");
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::DoKeepAlive()
+//		Purpose: Does something inconsequential over the SSL link to keep it up
+//		Created: 04/19/2005
+//
+// --------------------------------------------------------------------------
+void BackupClientContext::DoKeepAlive()
+{
+	if (!mpConnection)
+	{
+		::syslog(LOG_ERR, "DoKeepAlive() called with no connection!");
+		return;
+	}
+
+	mpConnection->QueryGetIsAlive();
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientContext::GetTimeMgmtEpoch()
+//		Purpose: Returns the unix time when the diff was started, or zero
+//				 if the diff process is unmanaged.
+//		Created: 04/19/2005
+//
+// --------------------------------------------------------------------------
+time_t BackupClientContext::GetTimeMgmtEpoch() 
+{
+	return mTimeMgmtEpoch;
+}
+
+int BackupClientContext::GetMaximumDiffingTime() 
+{
+	return sMaximumDiffTime;
+}
+
+int BackupClientContext::GetKeepaliveTime() 
+{
+	return sKeepAliveTime;
+}
diff --git a/bin/bbackupd/BackupClientContext.h b/bin/bbackupd/BackupClientContext.h
new file mode 100644
index 00000000..d41dc78a
--- /dev/null
+++ b/bin/bbackupd/BackupClientContext.h
@@ -0,0 +1,252 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupClientContext.h
+//		Purpose: Keep track of context
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+
+#ifndef BACKUPCLIENTCONTEXT__H
+#define BACKUPCLIENTCONTEXT__H
+
+#include "BoxTime.h"
+#include "BackupClientDeleteList.h"
+#include "BackupStoreFile.h"
+#include "ExcludeList.h"
+
+class TLSContext;
+class BackupProtocolClient;
+class SocketStreamTLS;
+class BackupClientInodeToIDMap;
+class BackupDaemon;
+class BackupStoreFilenameClear;
+
+#include <string>
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    BackupClientContext
+//		Purpose: 
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+class BackupClientContext : public DiffTimer
+{
+public:
+	BackupClientContext(BackupDaemon &rDaemon, TLSContext &rTLSContext, const std::string &rHostname,
+		int32_t AccountNumber, bool ExtendedLogging);
+	virtual ~BackupClientContext();
+private:
+	BackupClientContext(const BackupClientContext &);
+public:
+
+	BackupProtocolClient &GetConnection();
+	
+	void CloseAnyOpenConnection();
+	
+	int GetTimeout() const;
+	
+	BackupClientDeleteList &GetDeleteList();
+	void PerformDeletions();
+
+	enum
+	{
+		ClientStoreMarker_NotKnown = 0
+	};
+
+	void SetClientStoreMarker(int64_t ClientStoreMarker) {mClientStoreMarker = ClientStoreMarker;}
+	int64_t GetClientStoreMarker() const {return mClientStoreMarker;}
+	
+	bool StorageLimitExceeded() {return mStorageLimitExceeded;}
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::SetIDMaps(const BackupClientInodeToIDMap *, BackupClientInodeToIDMap *)
+	//		Purpose: Store pointers to the Current and New ID maps
+	//		Created: 11/11/03
+	//
+	// --------------------------------------------------------------------------
+	void SetIDMaps(const BackupClientInodeToIDMap *pCurrent, BackupClientInodeToIDMap *pNew)
+	{
+		ASSERT(pCurrent != 0);
+		ASSERT(pNew != 0);
+		mpCurrentIDMap = pCurrent;
+		mpNewIDMap = pNew;
+	}
+	const BackupClientInodeToIDMap &GetCurrentIDMap() const;
+	BackupClientInodeToIDMap &GetNewIDMap() const;
+	
+	
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::SetExcludeLists(ExcludeList *, ExcludeList *)
+	//		Purpose: Sets the exclude lists for the operation. Can be 0.
+	//		Created: 28/1/04
+	//
+	// --------------------------------------------------------------------------
+	void SetExcludeLists(ExcludeList *pExcludeFiles, ExcludeList *pExcludeDirs)
+	{
+		mpExcludeFiles = pExcludeFiles;
+		mpExcludeDirs = pExcludeDirs;
+	}
+	
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::ExcludeFile(const std::string &)
+	//		Purpose: Returns true is this file should be excluded from the backup
+	//		Created: 28/1/04
+	//
+	// --------------------------------------------------------------------------
+	inline bool ExcludeFile(const std::string &rFullFilename)
+	{
+		if(mpExcludeFiles != 0)
+		{
+			return mpExcludeFiles->IsExcluded(rFullFilename);
+		}
+		// If no list, don't exclude anything
+		return false;
+	}
+	
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::ExcludeDir(const std::string &)
+	//		Purpose: Returns true is this directory should be excluded from the backup
+	//		Created: 28/1/04
+	//
+	// --------------------------------------------------------------------------
+	inline bool ExcludeDir(const std::string &rFullDirName)
+	{
+		if(mpExcludeDirs != 0)
+		{
+			return mpExcludeDirs->IsExcluded(rFullDirName);
+		}
+		// If no list, don't exclude anything
+		return false;
+	}
+
+	// Utility functions -- may do a lot of work
+	bool FindFilename(int64_t ObjectID, int64_t ContainingDirectory, std::string &rPathOut, bool &rIsDirectoryOut,
+		bool &rIsCurrentVersionOut, box_time_t *pModTimeOnServer = 0, box_time_t *pAttributesHashOnServer = 0,
+		BackupStoreFilenameClear *pLeafname = 0); // not const as may connect to server
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::SetMaximumDiffingTime()
+	//		Purpose: Sets the maximum time that will be spent diffing a file
+	//		Created: 04/19/2005
+	//
+	// --------------------------------------------------------------------------
+	static void SetMaximumDiffingTime(int iSeconds);
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::SetKeepAliveTime()
+	//		Purpose: Sets the time interval for repetitive keep-alive operation
+	//		Created: 04/19/2005
+	//
+	// --------------------------------------------------------------------------
+	static void SetKeepAliveTime(int iSeconds);
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::ManageDiffProcess()
+	//		Purpose: Initiates an SSL connection/session keep-alive process
+	//		Created: 04/19/2005
+	//
+	// --------------------------------------------------------------------------
+	void ManageDiffProcess();
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::UnManageDiffProcess()
+	//		Purpose: Suspends an SSL connection/session keep-alive process
+	//		Created: 04/19/2005
+	//
+	// --------------------------------------------------------------------------
+	void UnManageDiffProcess();
+
+	// --------------------------------------------------------------------------
+	//
+	// Function
+	//		Name:    BackupClientContext::DoKeepAlive()
+	//		Purpose: Does something inconsequential over the SSL link to 
+	//				 keep it up, implements DiffTimer interface
+	//		Created: 04/19/2005
+	//
+	// --------------------------------------------------------------------------
+	virtual void   DoKeepAlive();
+	virtual time_t GetTimeMgmtEpoch();
+	virtual int    GetMaximumDiffingTime();
+	virtual int    GetKeepaliveTime();
+	
+private:
+	BackupDaemon &mrDaemon;
+	TLSContext &mrTLSContext;
+	std::string mHostname;
+	int32_t mAccountNumber;
+	SocketStreamTLS *mpSocket;
+	BackupProtocolClient *mpConnection;
+	bool mExtendedLogging;
+	int64_t mClientStoreMarker;
+	BackupClientDeleteList *mpDeleteList;
+	const BackupClientInodeToIDMap *mpCurrentIDMap;
+	BackupClientInodeToIDMap *mpNewIDMap;
+	bool mStorageLimitExceeded;
+	ExcludeList *mpExcludeFiles;
+	ExcludeList *mpExcludeDirs;
+
+	bool mbIsManaged;
+	// unix time when diff was started
+	time_t mTimeMgmtEpoch;
+};
+
+
+#endif // BACKUPCLIENTCONTEXT__H
diff --git a/bin/bbackupd/BackupClientDeleteList.cpp b/bin/bbackupd/BackupClientDeleteList.cpp
new file mode 100644
index 00000000..30f8ab47
--- /dev/null
+++ b/bin/bbackupd/BackupClientDeleteList.cpp
@@ -0,0 +1,233 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupClientDeleteList.cpp
+//		Purpose: List of pending deletes for backup
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#include <algorithm>
+
+#include "BackupClientDeleteList.h"
+#include "BackupClientContext.h"
+#include "autogen_BackupProtocolClient.h"
+
+#include "MemLeakFindOn.h"
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDeleteList::BackupClientDeleteList()
+//		Purpose: Constructor
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+BackupClientDeleteList::BackupClientDeleteList()
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDeleteList::~BackupClientDeleteList()
+//		Purpose: Destructor
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+BackupClientDeleteList::~BackupClientDeleteList()
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDeleteList::AddDirectoryDelete(int64_t)
+//		Purpose: Add a directory to the list of directories to be deleted.
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientDeleteList::AddDirectoryDelete(int64_t ObjectID)
+{
+	// Only add the delete to the list if it's not in the "no delete" set
+	if(mDirectoryNoDeleteList.find(ObjectID) == mDirectoryNoDeleteList.end())
+	{
+		// Not in the list, so should delete it
+		mDirectoryList.push_back(ObjectID);
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDeleteList::AddFileDelete(int64_t, BackupStoreFilenameClear &)
+//		Purpose: 
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientDeleteList::AddFileDelete(int64_t DirectoryID, const BackupStoreFilename &rFilename)
+{
+	// Try to find it in the no delete list
+	std::vector<std::pair<int64_t, BackupStoreFilename> >::iterator delEntry(mFileNoDeleteList.begin());
+	while(delEntry != mFileNoDeleteList.end())
+	{
+		if((delEntry)->first == DirectoryID && (delEntry)->second == rFilename)
+		{
+			// Found!
+			break;
+		}
+		++delEntry;
+	}
+	
+	// Only add it to the delete list if it wasn't in the no delete list
+	if(delEntry == mFileNoDeleteList.end())
+	{
+		mFileList.push_back(std::pair<int64_t, BackupStoreFilename>(DirectoryID, rFilename));
+	}
+}
+
+
+	
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDeleteList::PerformDeletions(BackupClientContext &rContext)
+//		Purpose: Perform all the pending deletes
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientDeleteList::PerformDeletions(BackupClientContext &rContext)
+{
+	// Anything to do?
+	if(mDirectoryList.empty() && mFileList.empty())
+	{
+		// Nothing!
+		return;
+	}
+	
+	// Get a connection
+	BackupProtocolClient &connection(rContext.GetConnection());
+	
+	// Do the deletes
+	for(std::vector<int64_t>::iterator i(mDirectoryList.begin()); i != mDirectoryList.end(); ++i)
+	{
+		connection.QueryDeleteDirectory(*i);
+	}
+	
+	// Clear the directory list
+	mDirectoryList.clear();
+	
+	// Delete the files
+	for(std::vector<std::pair<int64_t, BackupStoreFilename> >::iterator i(mFileList.begin()); i != mFileList.end(); ++i)
+	{
+		connection.QueryDeleteFile(i->first, i->second);
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDeleteList::StopDirectoryDeletion(int64_t)
+//		Purpose: Stop a directory being deleted
+//		Created: 19/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientDeleteList::StopDirectoryDeletion(int64_t ObjectID)
+{
+	// First of all, is it in the delete vector?
+	std::vector<int64_t>::iterator delEntry(std::find(mDirectoryList.begin(), mDirectoryList.end(), ObjectID));
+	if(delEntry != mDirectoryList.end())
+	{
+		// erase this entry
+		mDirectoryList.erase(delEntry);
+	}
+	else
+	{
+		// Haven't been asked to delete it yet, put it in the no delete list
+		mDirectoryNoDeleteList.insert(ObjectID);
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDeleteList::StopFileDeletion(int64_t, const BackupStoreFilename &)
+//		Purpose: Stop a file from being deleted
+//		Created: 19/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientDeleteList::StopFileDeletion(int64_t DirectoryID, const BackupStoreFilename &rFilename)
+{
+	// Find this in the delete list
+	std::vector<std::pair<int64_t, BackupStoreFilename> >::iterator delEntry(mFileList.begin());
+	while(delEntry != mFileList.end())
+	{
+		if((delEntry)->first == DirectoryID && (delEntry)->second == rFilename)
+		{
+			// Found!
+			break;
+		}
+		++delEntry;
+	}
+	
+	if(delEntry != mFileList.end())
+	{
+		// erase this entry
+		mFileList.erase(delEntry);
+	}
+	else
+	{
+		// Haven't been asked to delete it yet, put it in the no delete list
+		mFileNoDeleteList.push_back(std::pair<int64_t, BackupStoreFilename>(DirectoryID, rFilename));
+	}
+
+}
+
+
+
+
+
diff --git a/bin/bbackupd/BackupClientDeleteList.h b/bin/bbackupd/BackupClientDeleteList.h
new file mode 100644
index 00000000..5a6fc212
--- /dev/null
+++ b/bin/bbackupd/BackupClientDeleteList.h
@@ -0,0 +1,89 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupClientDeleteList.h
+//		Purpose: List of pending deletes for backup
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+
+#ifndef BACKUPCLIENTDELETELIST__H
+#define BACKUPCLIENTDELETELIST__H
+
+#include "BackupStoreFilename.h"
+
+class BackupClientContext;
+
+#include <vector>
+#include <utility>
+#include <set>
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    BackupClientDeleteList
+//		Purpose: List of pending deletes for backup
+//		Created: 10/11/03
+//
+// --------------------------------------------------------------------------
+class BackupClientDeleteList
+{
+public:
+	BackupClientDeleteList();
+	~BackupClientDeleteList();
+	
+	void AddDirectoryDelete(int64_t ObjectID);
+	void AddFileDelete(int64_t DirectoryID, const BackupStoreFilename &rFilename);
+
+	void StopDirectoryDeletion(int64_t ObjectID);
+	void StopFileDeletion(int64_t DirectoryID, const BackupStoreFilename &rFilename);
+	
+	void PerformDeletions(BackupClientContext &rContext);
+	
+private:
+	std::vector<int64_t> mDirectoryList;
+	std::set<int64_t> mDirectoryNoDeleteList;	// note: things only get in this list if they're not present in mDirectoryList when they are 'added'
+	std::vector<std::pair<int64_t, BackupStoreFilename> > mFileList;
+	std::vector<std::pair<int64_t, BackupStoreFilename> > mFileNoDeleteList;
+};
+
+#endif // BACKUPCLIENTDELETELIST__H
+
diff --git a/bin/bbackupd/BackupClientDirectoryRecord.cpp b/bin/bbackupd/BackupClientDirectoryRecord.cpp
new file mode 100644
index 00000000..cccf2f9b
--- /dev/null
+++ b/bin/bbackupd/BackupClientDirectoryRecord.cpp
@@ -0,0 +1,1445 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupClientDirectoryRecord.cpp
+//		Purpose: Implementation of record about directory for backup client
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#ifdef HAVE_DIRENT_H
+	#include <dirent.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+
+#include "BackupClientDirectoryRecord.h"
+#include "autogen_BackupProtocolClient.h"
+#include "BackupClientContext.h"
+#include "IOStream.h"
+#include "MemBlockStream.h"
+#include "CommonException.h"
+#include "CollectInBufferStream.h"
+#include "BackupStoreFile.h"
+#include "BackupClientInodeToIDMap.h"
+#include "FileModificationTime.h"
+#include "BackupDaemon.h"
+#include "BackupStoreException.h"
+#include "Archive.h"
+
+#include "MemLeakFindOn.h"
+
+typedef std::map<std::string, BackupStoreDirectory::Entry *> DecryptedEntriesMap_t;
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::BackupClientDirectoryRecord()
+//		Purpose: Constructor
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+BackupClientDirectoryRecord::BackupClientDirectoryRecord(int64_t ObjectID, const std::string &rSubDirName)
+	: mObjectID(ObjectID),
+	  mSubDirName(rSubDirName),
+	  mInitialSyncDone(false),
+	  mSyncDone(false),
+	  mpPendingEntries(0)
+{
+	::memset(mStateChecksum, 0, sizeof(mStateChecksum));
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::~BackupClientDirectoryRecord()
+//		Purpose: Destructor
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+BackupClientDirectoryRecord::~BackupClientDirectoryRecord()
+{
+	// Make deletion recursive
+	DeleteSubDirectories();
+	
+	// Delete maps
+	if(mpPendingEntries != 0)
+	{
+		delete mpPendingEntries;
+		mpPendingEntries = 0;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::DeleteSubDirectories();
+//		Purpose: Delete all sub directory entries
+//		Created: 2003/10/09
+//
+// --------------------------------------------------------------------------
+void BackupClientDirectoryRecord::DeleteSubDirectories()
+{
+	// Delete all pointers
+	for(std::map<std::string, BackupClientDirectoryRecord *>::iterator i = mSubDirectories.begin();
+		i != mSubDirectories.end(); ++i)
+	{
+		delete i->second;
+	}
+	
+	// Empty list
+	mSubDirectories.clear();
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::SyncDirectory(BackupClientDirectoryRecord::SyncParams &, int64_t, const std::string &, bool)
+//		Purpose: Syncronise, recusively, a local directory with the server.
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+void BackupClientDirectoryRecord::SyncDirectory(BackupClientDirectoryRecord::SyncParams &rParams, int64_t ContainingDirectoryID,
+	const std::string &rLocalPath, bool ThisDirHasJustBeenCreated)
+{
+	// Signal received by daemon?
+	if(rParams.mrDaemon.StopRun())
+	{
+		// Yes. Stop now.
+		THROW_EXCEPTION(BackupStoreException, SignalReceived)
+	}
+
+	// Start by making some flag changes, marking this sync as not done,
+	// and on the immediate sub directories.
+	mSyncDone = false;
+	for(std::map<std::string, BackupClientDirectoryRecord *>::iterator i = mSubDirectories.begin();
+		i != mSubDirectories.end(); ++i)
+	{
+		i->second->mSyncDone = false;
+	}
+
+	// Work out the time in the future after which the file should be uploaded regardless.
+	// This is a simple way to avoid having too many problems with file servers when they have
+	// clients with badly out of sync clocks.
+	rParams.mUploadAfterThisTimeInTheFuture = GetCurrentBoxTime() + rParams.mMaxFileTimeInFuture;
+	
+	// Build the current state checksum to compare against while getting info from dirs
+	// Note checksum is used locally only, so byte order isn't considered.
+	MD5Digest currentStateChecksum;
+	
+	// Stat the directory, to get attribute info
+	{
+		struct stat st;
+		if(::stat(rLocalPath.c_str(), &st) != 0)
+		{
+			// The directory has probably been deleted, so just ignore this error.
+			// In a future scan, this deletion will be noticed, deleted from server, and this object deleted.
+			TRACE1("Stat failed for '%s' (directory)\n", 
+				rLocalPath.c_str());
+			return;
+		}
+		// Store inode number in map so directories are tracked in case they're renamed
+		{
+			BackupClientInodeToIDMap &idMap(rParams.mrContext.GetNewIDMap());
+			idMap.AddToMap(st.st_ino, mObjectID, ContainingDirectoryID);
+		}
+		// Add attributes to checksum
+		currentStateChecksum.Add(&st.st_mode, sizeof(st.st_mode));
+		currentStateChecksum.Add(&st.st_uid, sizeof(st.st_uid));
+		currentStateChecksum.Add(&st.st_gid, sizeof(st.st_gid));
+		// Inode to be paranoid about things moving around
+		currentStateChecksum.Add(&st.st_ino, sizeof(st.st_ino));
+#ifdef HAVE_STRUCT_STAT_ST_FLAGS
+		currentStateChecksum.Add(&st.st_flags, sizeof(st.st_flags));
+#endif
+
+		StreamableMemBlock xattr;
+		BackupClientFileAttributes::FillExtendedAttr(xattr, rLocalPath.c_str());
+		currentStateChecksum.Add(xattr.GetBuffer(), xattr.GetSize());
+	}
+	
+	// Read directory entries, building arrays of names
+	// First, need to read the contents of the directory.
+	std::vector<std::string> dirs;
+	std::vector<std::string> files;
+	bool downloadDirectoryRecordBecauseOfFutureFiles = false;
+	// BLOCK
+	{		
+		// read the contents...
+		DIR *dirHandle = 0;
+		try
+		{
+			dirHandle = ::opendir(rLocalPath.c_str());
+			if(dirHandle == 0)
+			{
+				// Report the error (logs and eventual email to administrator)
+				SetErrorWhenReadingFilesystemObject(rParams, rLocalPath.c_str());
+				// Ignore this directory for now.
+				return;
+			}
+			
+			// Basic structure for checksum info
+			struct {
+				box_time_t mModificationTime;
+				box_time_t mAttributeModificationTime;
+				int64_t mSize;
+				// And then the name follows
+			} checksum_info;
+			// Be paranoid about structure packing
+			::memset(&checksum_info, 0, sizeof(checksum_info));
+	
+			struct dirent *en = 0;
+			struct stat st;
+			std::string filename;
+			while((en = ::readdir(dirHandle)) != 0)
+			{
+				// Don't need to use LinuxWorkaround_FinishDirentStruct(en, rLocalPath.c_str());
+				// on Linux, as a stat is performed to get all this info
+
+				if(en->d_name[0] == '.' && 
+					(en->d_name[1] == '\0' || (en->d_name[1] == '.' && en->d_name[2] == '\0')))
+				{
+					// ignore, it's . or ..
+					continue;
+				}
+
+				// Stat file to get info
+				filename = rLocalPath + DIRECTORY_SEPARATOR + 
+					en->d_name;
+
+				if(::lstat(filename.c_str(), &st) != 0)
+				{
+					// Report the error (logs and 
+					// eventual email to administrator)
+					SetErrorWhenReadingFilesystemObject(
+						rParams, filename.c_str());
+
+					// Ignore this entry for now.
+					continue;
+				}
+
+				int type = st.st_mode & S_IFMT;
+				if(type == S_IFREG || type == S_IFLNK)
+				{
+					// File or symbolic link
+
+					// Exclude it?
+					if(rParams.mrContext.ExcludeFile(filename))
+					{
+						// Next item!
+						continue;
+					}
+
+					// Store on list
+					files.push_back(std::string(en->d_name));
+				}
+				else if(type == S_IFDIR)
+				{
+					// Directory
+
+					// Exclude it?
+					if(rParams.mrContext.ExcludeDir(filename))
+					{
+						// Next item!
+						continue;
+					}
+
+					// Store on list
+					dirs.push_back(std::string(en->d_name));
+				}
+				else
+				{
+					continue;
+				}
+				
+				// Here if the object is something to back up (file, symlink or dir, not excluded)
+				// So make the information for adding to the checksum
+				checksum_info.mModificationTime = FileModificationTime(st);
+				checksum_info.mAttributeModificationTime = FileAttrModificationTime(st);
+				checksum_info.mSize = st.st_size;
+				currentStateChecksum.Add(&checksum_info, sizeof(checksum_info));
+				currentStateChecksum.Add(en->d_name, strlen(en->d_name));
+				
+				// If the file has been modified madly into the future, download the 
+				// directory record anyway to ensure that it doesn't get uploaded
+				// every single time the disc is scanned.
+				if(checksum_info.mModificationTime > rParams.mUploadAfterThisTimeInTheFuture)
+				{
+					downloadDirectoryRecordBecauseOfFutureFiles = true;
+					// Log that this has happened
+					if(!rParams.mHaveLoggedWarningAboutFutureFileTimes)
+					{
+						::syslog(LOG_ERR, "Some files have modification times excessively in the future. Check clock syncronisation.\n");
+						::syslog(LOG_ERR, "Example file (only one shown) : %s\n", filename.c_str());
+						rParams.mHaveLoggedWarningAboutFutureFileTimes = true;
+					}
+				}
+			}
+	
+			if(::closedir(dirHandle) != 0)
+			{
+				THROW_EXCEPTION(CommonException, OSFileError)
+			}
+			dirHandle = 0;
+		}
+		catch(...)
+		{
+			if(dirHandle != 0)
+			{
+				::closedir(dirHandle);
+			}
+			throw;
+		}
+	}
+
+	// Finish off the checksum, and compare with the one currently stored
+	bool checksumDifferent = true;
+	currentStateChecksum.Finish();
+	if(mInitialSyncDone && currentStateChecksum.DigestMatches(mStateChecksum))
+	{
+		// The checksum is the same, and there was one to compare with
+		checksumDifferent = false;
+	}
+
+	// Pointer to potentially downloaded store directory info
+	BackupStoreDirectory *pdirOnStore = 0;
+	
+	try
+	{
+		// Want to get the directory listing?
+		if(ThisDirHasJustBeenCreated)
+		{
+			// Avoid sending another command to the server when we know it's empty
+			pdirOnStore = new BackupStoreDirectory(mObjectID, ContainingDirectoryID);
+		}
+		else
+		{
+			// Consider asking the store for it
+			if(!mInitialSyncDone || checksumDifferent || downloadDirectoryRecordBecauseOfFutureFiles)
+			{
+				pdirOnStore = FetchDirectoryListing(rParams);
+			}
+		}
+				
+		// Make sure the attributes are up to date -- if there's space on the server
+		// and this directory has not just been created (because it's attributes will be correct in this case)
+		// and the checksum is different, implying they *MIGHT* be different.
+		if((!ThisDirHasJustBeenCreated) && checksumDifferent && (!rParams.mrContext.StorageLimitExceeded()))
+		{
+			UpdateAttributes(rParams, pdirOnStore, rLocalPath);
+		}
+		
+		// Create the list of pointers to directory entries
+		std::vector<BackupStoreDirectory::Entry *> entriesLeftOver;
+		if(pdirOnStore)
+		{
+			entriesLeftOver.resize(pdirOnStore->GetNumberOfEntries(), 0);
+			BackupStoreDirectory::Iterator i(*pdirOnStore);
+			// Copy in pointers to all the entries
+			for(unsigned int l = 0; l < pdirOnStore->GetNumberOfEntries(); ++l)
+			{
+				entriesLeftOver[l] = i.Next();
+			}
+		}
+		
+		// Do the directory reading
+		bool updateCompleteSuccess = UpdateItems(rParams, rLocalPath, pdirOnStore, entriesLeftOver, files, dirs);
+		
+		// LAST THING! (think exception safety)
+		// Store the new checksum -- don't fetch things unnecessarily in the future
+		// But... only if 1) the storage limit isn't exceeded -- make sure things are done again if
+		// the directory is modified later
+		// and 2) All the objects within the directory were stored successfully.
+		if(!rParams.mrContext.StorageLimitExceeded() && updateCompleteSuccess)
+		{
+			currentStateChecksum.CopyDigestTo(mStateChecksum);
+		}
+	}
+	catch(...)
+	{
+		// Bad things have happened -- clean up
+		if(pdirOnStore != 0)
+		{
+			delete pdirOnStore;
+			pdirOnStore = 0;
+		}
+		
+		// Set things so that we get a full go at stuff later
+		::memset(mStateChecksum, 0, sizeof(mStateChecksum));
+		
+		throw;
+	}
+	
+	// Clean up directory on store
+	if(pdirOnStore != 0)
+	{
+		delete pdirOnStore;
+		pdirOnStore = 0;
+	}
+	
+	// Flag things as having happened.
+	mInitialSyncDone = true;
+	mSyncDone = true;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::FetchDirectoryListing(BackupClientDirectoryRecord::SyncParams &)
+//		Purpose: Fetch the directory listing of this directory from the store.
+//		Created: 2003/10/09
+//
+// --------------------------------------------------------------------------
+BackupStoreDirectory *BackupClientDirectoryRecord::FetchDirectoryListing(BackupClientDirectoryRecord::SyncParams &rParams)
+{
+	BackupStoreDirectory *pdir = 0;
+	
+	try
+	{
+		// Get connection to store
+		BackupProtocolClient &connection(rParams.mrContext.GetConnection());
+
+		// Query the directory
+		std::auto_ptr<BackupProtocolClientSuccess> dirreply(connection.QueryListDirectory(
+				mObjectID,
+				BackupProtocolClientListDirectory::Flags_INCLUDE_EVERYTHING,	// both files and directories
+				BackupProtocolClientListDirectory::Flags_Deleted | BackupProtocolClientListDirectory::Flags_OldVersion, // exclude old/deleted stuff
+				true /* want attributes */));
+
+		// Retrieve the directory from the stream following
+		pdir = new BackupStoreDirectory;
+		ASSERT(pdir != 0);
+		std::auto_ptr<IOStream> dirstream(connection.ReceiveStream());
+		pdir->ReadFromStream(*dirstream, connection.GetTimeout());
+	}
+	catch(...)
+	{
+		delete pdir;
+		pdir = 0;
+		throw;
+	}
+	
+	return pdir;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::UpdateAttributes(BackupClientDirectoryRecord::SyncParams &, const std::string &)
+//		Purpose: Sets the attributes of the directory on the store, if necessary
+//		Created: 2003/10/09
+//
+// --------------------------------------------------------------------------
+void BackupClientDirectoryRecord::UpdateAttributes(BackupClientDirectoryRecord::SyncParams &rParams, BackupStoreDirectory *pDirOnStore, const std::string &rLocalPath)
+{
+	// Get attributes for the directory
+	BackupClientFileAttributes attr;
+	box_time_t attrModTime = 0;
+	attr.ReadAttributes(rLocalPath.c_str(), true /* directories have zero mod times */,
+		0 /* no modification time */, &attrModTime);
+
+	// Assume attributes need updating, unless proved otherwise
+	bool updateAttr = true;
+
+	// Got a listing to compare with?
+	ASSERT(pDirOnStore == 0 || (pDirOnStore != 0 && pDirOnStore->HasAttributes()));
+	if(pDirOnStore != 0 && pDirOnStore->HasAttributes())
+	{
+		const StreamableMemBlock &storeAttrEnc(pDirOnStore->GetAttributes());
+		// Explict decryption
+		BackupClientFileAttributes storeAttr(storeAttrEnc);
+		// Compare the attributes
+		if(attr.Compare(storeAttr, true, true /* ignore both modification times */))
+		{
+			// No update necessary
+			updateAttr = false;
+		}
+	}
+
+	// Update them?
+	if(updateAttr)
+	{
+		// Get connection to store
+		BackupProtocolClient &connection(rParams.mrContext.GetConnection());
+
+		// Exception thrown if this doesn't work
+		MemBlockStream attrStream(attr);
+		connection.QueryChangeDirAttributes(mObjectID, attrModTime, attrStream);
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::UpdateItems(BackupClientDirectoryRecord::SyncParams &, const std::string &, BackupStoreDirectory *, std::vector<BackupStoreDirectory::Entry *> &)
+//		Purpose: Update the items stored on the server. The rFiles vector will be erased after it's used to save space.
+//				 Returns true if all items were updated successfully. (If not, the failures will have been logged).
+//		Created: 2003/10/09
+//
+// --------------------------------------------------------------------------
+bool BackupClientDirectoryRecord::UpdateItems(BackupClientDirectoryRecord::SyncParams &rParams,
+	const std::string &rLocalPath, BackupStoreDirectory *pDirOnStore,
+	std::vector<BackupStoreDirectory::Entry *> &rEntriesLeftOver,
+	std::vector<std::string> &rFiles, const std::vector<std::string> &rDirs)
+{
+	bool allUpdatedSuccessfully = true;
+
+	// Decrypt all the directory entries.
+	// It would be nice to be able to just compare the encrypted versions, however this doesn't work
+	// in practise because there can be multiple encodings of the same filename using different 
+	// methods (although each method will result in the same string for the same filename.) This
+	// happens when the server fixes a broken store, and gives plain text generated filenames.
+	// So if we didn't do things like this, then you wouldn't be able to recover from bad things
+	// happening with the server.
+	DecryptedEntriesMap_t decryptedEntries;
+	if(pDirOnStore != 0)
+	{
+		BackupStoreDirectory::Iterator i(*pDirOnStore);
+		BackupStoreDirectory::Entry *en = 0;
+		while((en = i.Next()) != 0)
+		{
+			decryptedEntries[BackupStoreFilenameClear(en->GetName()).GetClearFilename()] = en;
+		}
+	}
+
+	// Do files
+	for(std::vector<std::string>::const_iterator f = rFiles.begin();
+		f != rFiles.end(); ++f)
+	{
+		// Filename of this file
+		std::string filename(rLocalPath + DIRECTORY_SEPARATOR + *f);
+
+		// Get relevant info about file
+		box_time_t modTime = 0;
+		uint64_t attributesHash = 0;
+		int64_t fileSize = 0;
+		InodeRefType inodeNum = 0;
+		bool hasMultipleHardLinks = true;
+		// BLOCK
+		{
+			// Stat the file
+			struct stat st;
+			if(::lstat(filename.c_str(), &st) != 0)
+			{
+				THROW_EXCEPTION(CommonException, OSFileError)
+			}
+			
+			// Extract required data
+			modTime = FileModificationTime(st);
+			fileSize = st.st_size;
+			inodeNum = st.st_ino;
+			hasMultipleHardLinks = (st.st_nlink > 1);
+			attributesHash = BackupClientFileAttributes::GenerateAttributeHash(st, filename, *f);
+		}
+
+		// See if it's in the listing (if we have one)
+		BackupStoreFilenameClear storeFilename(*f);
+		BackupStoreDirectory::Entry *en = 0;
+		int64_t latestObjectID = 0;
+		if(pDirOnStore != 0)
+		{
+			DecryptedEntriesMap_t::iterator i(decryptedEntries.find(*f));
+			if(i != decryptedEntries.end())
+			{
+				en = i->second;
+				latestObjectID = en->GetObjectID();
+			}
+		}
+
+		// Check that the entry which might have been found is in fact a file
+		if((en != 0) && ((en->GetFlags() & BackupStoreDirectory::Entry::Flags_File) == 0))
+		{
+			// Directory exists in the place of this file -- sort it out
+			RemoveDirectoryInPlaceOfFile(rParams, pDirOnStore, en->GetObjectID(), *f);
+			en = 0;
+		}
+		
+		// Check for renaming?
+		if(pDirOnStore != 0 && en == 0)
+		{
+			// We now know...
+			// 1) File has just been added
+			// 2) It's not in the store
+			
+			// Do we know about the inode number?
+			const BackupClientInodeToIDMap &idMap(rParams.mrContext.GetCurrentIDMap());
+			int64_t renameObjectID = 0, renameInDirectory = 0;
+			if(idMap.Lookup(inodeNum, renameObjectID, renameInDirectory))
+			{
+				// Look up on the server to get the name, to build the local filename
+				std::string localPotentialOldName;
+				bool isDir = false;
+				bool isCurrentVersion = false;
+				box_time_t srvModTime = 0, srvAttributesHash = 0;
+				BackupStoreFilenameClear oldLeafname;
+				if(rParams.mrContext.FindFilename(renameObjectID, renameInDirectory, localPotentialOldName, isDir, isCurrentVersion, &srvModTime, &srvAttributesHash, &oldLeafname))
+				{	
+					// Only interested if it's a file and the latest version
+					if(!isDir && isCurrentVersion)
+					{
+						// Check that the object we found in the ID map doesn't exist on disc
+						struct stat st;
+						if(::stat(localPotentialOldName.c_str(), &st) != 0 && errno == ENOENT)
+						{
+							// Doesn't exist locally, but does exist on the server.
+							// Therefore we can safely rename it to this new file.
+
+							// Get the connection to the server 
+							BackupProtocolClient &connection(rParams.mrContext.GetConnection());
+
+							// Only do this step if there is room on the server.
+							// This step will be repeated later when there is space available
+							if(!rParams.mrContext.StorageLimitExceeded())
+							{
+								// Rename the existing files (ie include old versions) on the server
+								connection.QueryMoveObject(renameObjectID, renameInDirectory, mObjectID /* move to this directory */,
+									BackupProtocolClientMoveObject::Flags_MoveAllWithSameName | BackupProtocolClientMoveObject::Flags_AllowMoveOverDeletedObject,
+									storeFilename);
+									
+								// Stop the attempt to delete the file in the original location
+								BackupClientDeleteList &rdelList(rParams.mrContext.GetDeleteList());
+								rdelList.StopFileDeletion(renameInDirectory, oldLeafname);
+								
+								// Create new entry in the directory for it
+								// -- will be near enough what's actually on the server for the rest to work.
+								en = pDirOnStore->AddEntry(storeFilename, srvModTime, renameObjectID, 0 /* size in blocks unknown, but not needed */,
+									BackupStoreDirectory::Entry::Flags_File, srvAttributesHash);
+							
+								// Store the object ID for the inode lookup map later
+								latestObjectID = renameObjectID;
+							}
+						}
+					}
+				}
+			}
+		}
+		
+		// Is it in the mPendingEntries list?
+		box_time_t pendingFirstSeenTime = 0;		// ie not seen
+		if(mpPendingEntries != 0)
+		{
+			std::map<std::string, box_time_t>::const_iterator i(mpPendingEntries->find(*f));
+			if(i != mpPendingEntries->end())
+			{
+				// found it -- set flag
+				pendingFirstSeenTime = i->second;
+			}
+		}
+		
+		// If pDirOnStore == 0, then this must have been after an initial sync:
+		ASSERT(pDirOnStore != 0 || mInitialSyncDone);
+		// So, if pDirOnStore == 0, then we know that everything before syncPeriodStart
+		// is either on the server, or in the toupload list. If the directory had changed,
+		// we'd have got a directory listing.
+		//
+		// At this point, if (pDirOnStore == 0 && en == 0), we can assume it's on the server with a
+		// mod time < syncPeriodStart, or didn't exist before that time.
+		//
+		// But if en != 0, then we need to compare modification times to avoid uploading it again.
+
+		// Need to update?
+		//
+		// Condition for upload:
+		//    modifiction time within sync period
+		//    if it's been seen before but not uploaded, is the time from this first sight longer than the MaxUploadWait
+		//	  and if we know about it from a directory listing, that it hasn't got the same upload time as on the store
+		if(
+			(
+				// Check the file modified within the acceptable time period we're checking
+				// If the file isn't on the server, the acceptable time starts at zero.
+				// Check pDirOnStore and en, because if we didn't download a directory listing,
+				// pDirOnStore will be zero, but we know it's on the server.
+				( ((pDirOnStore != 0 && en == 0) || (modTime >= rParams.mSyncPeriodStart)) && modTime < rParams.mSyncPeriodEnd)
+
+				// However, just in case things are continually modified, we check the first seen time.
+				// The two compares of syncPeriodEnd and pendingFirstSeenTime are because the values are unsigned.
+				|| (pendingFirstSeenTime != 0 &&
+					(rParams.mSyncPeriodEnd > pendingFirstSeenTime)
+						&& ((rParams.mSyncPeriodEnd - pendingFirstSeenTime) > rParams.mMaxUploadWait))
+
+				// Then make sure that if files are added with a time less than the sync period start
+				// (which can easily happen on file server), it gets uploaded. The directory contents checksum
+				// will pick up the fact it has been added, so the store listing will be available when this happens.
+				|| ((modTime <= rParams.mSyncPeriodStart) && (en != 0) && (en->GetModificationTime() != modTime))
+				
+				// And just to catch really badly off clocks in the future for file server clients,
+				// just upload the file if it's madly in the future.
+				|| (modTime > rParams.mUploadAfterThisTimeInTheFuture)
+			)			
+			// But even then, only upload it if the mod time locally is different to that on the server.
+			&& (en == 0 || en->GetModificationTime() != modTime))
+		{
+			// Make sure we're connected -- must connect here so we know whether
+			// the storage limit has been exceeded, and hence whether or not
+			// to actually upload the file.
+			rParams.mrContext.GetConnection();
+
+			// Only do this step if there is room on the server.
+			// This step will be repeated later when there is space available
+			if(!rParams.mrContext.StorageLimitExceeded())
+			{
+				// Upload the file to the server, recording the object ID it returns
+				bool noPreviousVersionOnServer = ((pDirOnStore != 0) && (en == 0));
+				
+				// Surround this in a try/catch block, to catch errrors, but still continue
+				bool uploadSuccess = false;
+				try
+				{
+					latestObjectID = UploadFile(rParams, filename, storeFilename, fileSize, modTime, attributesHash, noPreviousVersionOnServer);
+					uploadSuccess = true;
+				}
+				catch(ConnectionException &e)
+				{
+					// Connection errors should just be passed on to the main handler, retries
+					// would probably just cause more problems.
+					throw;
+				}
+				catch(BoxException &e)
+				{
+					// an error occured -- make return code false, to show error in directory
+					allUpdatedSuccessfully = false;
+					// Log it.
+					SetErrorWhenReadingFilesystemObject(rParams, filename.c_str());
+					// Log error.
+					::syslog(LOG_ERR, "Error code when uploading was (%d/%d), %s", e.GetType(), e.GetSubType(), e.what());
+				}
+
+				// Update structures if the file was uploaded successfully.
+				if(uploadSuccess)
+				{
+					// delete from pending entries
+					if(pendingFirstSeenTime != 0 && mpPendingEntries != 0)
+					{
+						mpPendingEntries->erase(*f);
+					}
+				}
+			}
+		}
+		else if(en != 0 && en->GetAttributesHash() != attributesHash)
+		{
+			// Attributes have probably changed, upload them again.
+			// If the attributes have changed enough, the directory hash will have changed too,
+			// and so the dir will have been downloaded, and the entry will be available.
+
+			// Get connection
+			BackupProtocolClient &connection(rParams.mrContext.GetConnection());
+
+			// Only do this step if there is room on the server.
+			// This step will be repeated later when there is space available
+			if(!rParams.mrContext.StorageLimitExceeded())
+			{
+				// Update store
+				BackupClientFileAttributes attr;
+				attr.ReadAttributes(filename.c_str(), false /* put mod times in the attributes, please */);
+				MemBlockStream attrStream(attr);
+				connection.QuerySetReplacementFileAttributes(mObjectID, attributesHash, storeFilename, attrStream);
+			}
+		}
+
+		if(modTime >= rParams.mSyncPeriodEnd)
+		{
+			// Allocate?
+			if(mpPendingEntries == 0)
+			{
+				mpPendingEntries = new std::map<std::string, box_time_t>;
+			}
+			// Adding to mPendingEntries list 
+			if(pendingFirstSeenTime == 0)
+			{
+				// Haven't seen this before -- add to list!
+				(*mpPendingEntries)[*f] = modTime;
+			}
+		}
+		
+		// Zero pointer in rEntriesLeftOver, if we have a pointer to zero
+		if(en != 0)
+		{
+			for(unsigned int l = 0; l < rEntriesLeftOver.size(); ++l)
+			{
+				if(rEntriesLeftOver[l] == en)
+				{
+					rEntriesLeftOver[l] = 0;
+					break;
+				}
+			}
+		}
+		
+		// Does this file need an entry in the ID map?
+		if(fileSize >= rParams.mFileTrackingSizeThreshold)
+		{
+			// Get the map
+			BackupClientInodeToIDMap &idMap(rParams.mrContext.GetNewIDMap());
+		
+			// Need to get an ID from somewhere...
+			if(latestObjectID != 0)
+			{
+				// Use this one
+				idMap.AddToMap(inodeNum, latestObjectID, mObjectID /* containing directory */);
+			}
+			else
+			{
+				// Don't know it -- haven't sent anything to the store, and didn't get a listing.
+				// Look it up in the current map, and if it's there, use that.
+				const BackupClientInodeToIDMap &currentIDMap(rParams.mrContext.GetCurrentIDMap());
+				int64_t objid = 0, dirid = 0;
+				if(currentIDMap.Lookup(inodeNum, objid, dirid))
+				{
+					// Found
+					ASSERT(dirid == mObjectID);
+					// NOTE: If the above assert fails, an inode number has been reused by the OS,
+					// or there is a problem somewhere. If this happened on a short test run, look
+					// into it. However, in a long running process this may happen occasionally and
+					// not indiciate anything wrong.
+					// Run the release version for real life use, where this check is not made.
+					idMap.AddToMap(inodeNum, objid, mObjectID /* containing directory */);				
+				}
+			}
+		}
+	}
+
+	// Erase contents of files to save space when recursing
+	rFiles.clear();
+
+	// Delete the pending entries, if the map is entry
+	if(mpPendingEntries != 0 && mpPendingEntries->size() == 0)
+	{
+		TRACE1("Deleting mpPendingEntries from dir ID %lld\n", mObjectID);
+		delete mpPendingEntries;
+		mpPendingEntries = 0;
+	}
+	
+	// Do directories
+	for(std::vector<std::string>::const_iterator d = rDirs.begin();
+		d != rDirs.end(); ++d)
+	{
+		// Get the local filename
+		std::string dirname(rLocalPath + DIRECTORY_SEPARATOR + *d);		
+	
+		// See if it's in the listing (if we have one)
+		BackupStoreFilenameClear storeFilename(*d);
+		BackupStoreDirectory::Entry *en = 0;
+		if(pDirOnStore != 0)
+		{
+			DecryptedEntriesMap_t::iterator i(decryptedEntries.find(*d));
+			if(i != decryptedEntries.end())
+			{
+				en = i->second;
+			}
+		}
+		
+		// Check that the entry which might have been found is in fact a directory
+		if((en != 0) && ((en->GetFlags() & BackupStoreDirectory::Entry::Flags_Dir) == 0))
+		{
+			// Entry exists, but is not a directory. Bad. Get rid of it.
+			BackupProtocolClient &connection(rParams.mrContext.GetConnection());
+			connection.QueryDeleteFile(mObjectID /* in directory */, storeFilename);
+			
+			// Nothing found
+			en = 0;
+		}
+
+		// Flag for having created directory, so can optimise the recusive call not to
+		// read it again, because we know it's empty.
+		bool haveJustCreatedDirOnServer = false;
+
+		// Next, see if it's in the list of sub directories
+		BackupClientDirectoryRecord *psubDirRecord = 0;
+		std::map<std::string, BackupClientDirectoryRecord *>::iterator e(mSubDirectories.find(*d));
+		if(e != mSubDirectories.end())
+		{
+			// In the list, just use this pointer
+			psubDirRecord = e->second;
+		}
+		else if(!rParams.mrContext.StorageLimitExceeded())	// know we've got a connection if we get this far, as dir will have been modified.
+		{
+			// Note: only think about adding directory records if there's space left on the server.
+			// If there isn't, this step will be repeated when there is some available.
+		
+			// Need to create the record. But do we need to create the directory on the server?
+			int64_t subDirObjectID = 0;
+			if(en != 0)
+			{
+				// No. Exists on the server, and we know about it from the listing.
+				subDirObjectID = en->GetObjectID();
+			}
+			else
+			{
+				// Yes, creation required!
+				// It is known that the it doesn't exist:
+				//   if pDirOnStore == 0, then the directory has had an initial sync, and hasn't been modified.
+				//	 so it has definately been created already.
+				//   if en == 0 but pDirOnStore != 0, well... obviously it doesn't exist.
+
+				// Get attributes
+				box_time_t attrModTime = 0;
+				InodeRefType inodeNum = 0;
+				BackupClientFileAttributes attr;
+				attr.ReadAttributes(dirname.c_str(), true /* directories have zero mod times */,
+					0 /* not interested in mod time */, &attrModTime, 0 /* not file size */,
+					&inodeNum);
+
+				// Check to see if the directory been renamed
+				// First, do we have a record in the ID map?
+				int64_t renameObjectID = 0, renameInDirectory = 0;
+				bool renameDir = false;
+				const BackupClientInodeToIDMap &idMap(rParams.mrContext.GetCurrentIDMap());
+				if(idMap.Lookup(inodeNum, renameObjectID, renameInDirectory))
+				{
+					// Look up on the server to get the name, to build the local filename
+					std::string localPotentialOldName;
+					bool isDir = false;
+					bool isCurrentVersion = false;
+					if(rParams.mrContext.FindFilename(renameObjectID, renameInDirectory, localPotentialOldName, isDir, isCurrentVersion))
+					{	
+						// Only interested if it's a directory
+						if(isDir && isCurrentVersion)
+						{
+							// Check that the object doesn't exist already
+							struct stat st;
+							if(::stat(localPotentialOldName.c_str(), &st) != 0 && errno == ENOENT)
+							{
+								// Doesn't exist locally, but does exist on the server.
+								// Therefore we can safely rename it.
+								renameDir = true;
+							}
+						}
+					}
+				}
+
+				// Get connection
+				BackupProtocolClient &connection(rParams.mrContext.GetConnection());
+				
+				// Don't do a check for storage limit exceeded here, because if we get to this
+				// stage, a connection will have been opened, and the status known, so the check 
+				// in the else if(...) above will be correct.
+
+				// Build attribute stream for sending
+				MemBlockStream attrStream(attr);
+
+				if(renameDir)
+				{
+					// Rename the existing directory on the server
+					connection.QueryMoveObject(renameObjectID, renameInDirectory, mObjectID /* move to this directory */,
+						BackupProtocolClientMoveObject::Flags_MoveAllWithSameName | BackupProtocolClientMoveObject::Flags_AllowMoveOverDeletedObject,
+						storeFilename);
+						
+					// Put the latest attributes on it
+					connection.QueryChangeDirAttributes(renameObjectID, attrModTime, attrStream);
+
+					// Stop it being deleted later
+					BackupClientDeleteList &rdelList(rParams.mrContext.GetDeleteList());
+					rdelList.StopDirectoryDeletion(renameObjectID);
+
+					// This is the ID for the renamed directory
+					subDirObjectID = renameObjectID;
+				}
+				else
+				{
+					// Create a new directory
+					std::auto_ptr<BackupProtocolClientSuccess> dirCreate(connection.QueryCreateDirectory(
+						mObjectID, attrModTime, storeFilename, attrStream));
+					subDirObjectID = dirCreate->GetObjectID(); 
+					
+					// Flag as having done this for optimisation later
+					haveJustCreatedDirOnServer = true;
+				}
+			}
+			
+			// New an object for this
+			psubDirRecord = new BackupClientDirectoryRecord(subDirObjectID, *d);
+			
+			// Store in list
+			try
+			{
+				mSubDirectories[*d] = psubDirRecord;
+			}
+			catch(...)
+			{
+				delete psubDirRecord;
+				psubDirRecord = 0;
+				throw;
+			}
+		}
+		
+		ASSERT(psubDirRecord != 0 || rParams.mrContext.StorageLimitExceeded());
+		
+		if(psubDirRecord)
+		{
+			// Sync this sub directory too
+			psubDirRecord->SyncDirectory(rParams, mObjectID, dirname, haveJustCreatedDirOnServer);
+		}
+
+		// Zero pointer in rEntriesLeftOver, if we have a pointer to zero
+		if(en != 0)
+		{
+			for(unsigned int l = 0; l < rEntriesLeftOver.size(); ++l)
+			{
+				if(rEntriesLeftOver[l] == en)
+				{
+					rEntriesLeftOver[l] = 0;
+					break;
+				}
+			}
+		}
+	}
+	
+	// Delete everything which is on the store, but not on disc
+	for(unsigned int l = 0; l < rEntriesLeftOver.size(); ++l)
+	{
+		if(rEntriesLeftOver[l] != 0)
+		{
+			BackupStoreDirectory::Entry *en = rEntriesLeftOver[l];
+		
+			// These entries can't be deleted immediately, as it would prevent
+			// renaming and moving of objects working properly. So we add them
+			// to a list, which is actually deleted at the very end of the session.
+			// If there's an error during the process, it doesn't matter if things
+			// aren't actually deleted, as the whole state will be reset anyway.
+			BackupClientDeleteList &rdel(rParams.mrContext.GetDeleteList());
+			
+			// Delete this entry -- file or directory?
+			if((en->GetFlags() & BackupStoreDirectory::Entry::Flags_File) != 0)
+			{
+				// Set a pending deletion for the file
+				rdel.AddFileDelete(mObjectID, en->GetName());				
+			}
+			else if((en->GetFlags() & BackupStoreDirectory::Entry::Flags_Dir) != 0)
+			{
+				// Set as a pending deletion for the directory
+				rdel.AddDirectoryDelete(en->GetObjectID());
+				
+				// If there's a directory record for it in the sub directory map, delete it now
+				BackupStoreFilenameClear dirname(en->GetName());
+				std::map<std::string, BackupClientDirectoryRecord *>::iterator e(mSubDirectories.find(dirname.GetClearFilename()));
+				if(e != mSubDirectories.end())
+				{
+					// Carefully delete the entry from the map
+					BackupClientDirectoryRecord *rec = e->second;
+					mSubDirectories.erase(e);
+					delete rec;
+					TRACE2("Deleted directory record for %s/%s\n", rLocalPath.c_str(), dirname.GetClearFilename().c_str());
+				}				
+			}
+		}
+	}
+
+	// Return success flag (will be false if some files failed)
+	return allUpdatedSuccessfully;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::RemoveDirectoryInPlaceOfFile(SyncParams &, BackupStoreDirectory *, int64_t, const std::string &)
+//		Purpose: Called to resolve difficulties when a directory is found on the
+//				 store where a file is to be uploaded.
+//		Created: 9/7/04
+//
+// --------------------------------------------------------------------------
+void BackupClientDirectoryRecord::RemoveDirectoryInPlaceOfFile(SyncParams &rParams, BackupStoreDirectory *pDirOnStore, int64_t ObjectID, const std::string &rFilename)
+{
+	// First, delete the directory
+	BackupProtocolClient &connection(rParams.mrContext.GetConnection());
+	connection.QueryDeleteDirectory(ObjectID);
+
+	// Then, delete any directory record
+	std::map<std::string, BackupClientDirectoryRecord *>::iterator e(mSubDirectories.find(rFilename));
+	if(e != mSubDirectories.end())
+	{
+		// A record exists for this, remove it
+		BackupClientDirectoryRecord *psubDirRecord = e->second;
+		mSubDirectories.erase(e);
+
+		// And delete the object
+		delete psubDirRecord;
+	}
+}
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::UploadFile(BackupClientDirectoryRecord::SyncParams &, const std::string &, const BackupStoreFilename &, int64_t, box_time_t, box_time_t, bool)
+//		Purpose: Private. Upload a file to the server -- may send a patch instead of the whole thing
+//		Created: 20/1/04
+//
+// --------------------------------------------------------------------------
+int64_t BackupClientDirectoryRecord::UploadFile(BackupClientDirectoryRecord::SyncParams &rParams, const std::string &rFilename, const BackupStoreFilename &rStoreFilename,
+			int64_t FileSize, box_time_t ModificationTime, box_time_t AttributesHash, bool NoPreviousVersionOnServer)
+{
+	// Get the connection
+	BackupProtocolClient &connection(rParams.mrContext.GetConnection());
+
+	// Info
+	int64_t objID = 0;
+	bool doNormalUpload = true;
+	
+	// Use a try block to catch store full errors
+	try
+	{
+		// Might an old version be on the server, and is the file size over the diffing threshold?
+		if(!NoPreviousVersionOnServer && FileSize >= rParams.mDiffingUploadSizeThreshold)
+		{
+			// YES -- try to do diff, if possible
+			// First, query the server to see if there's an old version available
+			std::auto_ptr<BackupProtocolClientSuccess> getBlockIndex(connection.QueryGetBlockIndexByName(mObjectID, rStoreFilename));
+			int64_t diffFromID = getBlockIndex->GetObjectID();
+			
+			if(diffFromID != 0)
+			{
+				// Found an old version -- get the index
+				std::auto_ptr<IOStream> blockIndexStream(connection.ReceiveStream());
+			
+				//
+				// Diff the file
+				//
+
+				rParams.mrContext.ManageDiffProcess();
+
+				bool isCompletelyDifferent = false;
+				std::auto_ptr<IOStream> patchStream(
+					BackupStoreFile::EncodeFileDiff(
+						rFilename.c_str(),
+						mObjectID,	/* containing directory */
+						rStoreFilename, diffFromID, *blockIndexStream,
+						connection.GetTimeout(), 
+						&rParams.mrContext, // DiffTimer implementation
+						0 /* not interested in the modification time */, 
+						&isCompletelyDifferent));
+	
+				rParams.mrContext.UnManageDiffProcess();
+
+				//
+				// Upload the patch to the store
+				//
+				std::auto_ptr<BackupProtocolClientSuccess> stored(connection.QueryStoreFile(mObjectID, ModificationTime,
+						AttributesHash, isCompletelyDifferent?(0):(diffFromID), rStoreFilename, *patchStream));
+				
+				// Don't attempt to upload it again!
+				doNormalUpload = false;
+			} 
+		}
+	
+		if(doNormalUpload)
+		{
+			// below threshold or nothing to diff from, so upload whole
+			
+			// Prepare to upload, getting a stream which will encode the file as we go along
+			std::auto_ptr<IOStream> upload(BackupStoreFile::EncodeFile(rFilename.c_str(), mObjectID, rStoreFilename));
+		
+			// Send to store
+			std::auto_ptr<BackupProtocolClientSuccess> stored(
+				connection.QueryStoreFile(
+					mObjectID, ModificationTime,
+					AttributesHash, 
+					0 /* no diff from file ID */, 
+					rStoreFilename, *upload));
+	
+			// Get object ID from the result		
+			objID = stored->GetObjectID();
+		}
+	}
+	catch(BoxException &e)
+	{
+		rParams.mrContext.UnManageDiffProcess();
+
+		if(e.GetType() == ConnectionException::ExceptionType && e.GetSubType() == ConnectionException::Protocol_UnexpectedReply)
+		{
+			// Check and see what error the protocol has -- as it might be an error...
+			int type, subtype;
+			if(connection.GetLastError(type, subtype)
+				&& type == BackupProtocolClientError::ErrorType
+				&& subtype == BackupProtocolClientError::Err_StorageLimitExceeded)
+			{
+				// The hard limit was exceeded on the server, notify!
+				rParams.mrDaemon.NotifySysadmin(BackupDaemon::NotifyEvent_StoreFull);
+			}
+		}
+		
+		// Send the error on it's way
+		throw;
+	}
+
+	// Return the new object ID of this file
+	return objID;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::SetErrorWhenReadingFilesystemObject(SyncParams &, const char *)
+//		Purpose: Sets the error state when there were problems reading an object
+//				 from the filesystem.
+//		Created: 29/3/04
+//
+// --------------------------------------------------------------------------
+void BackupClientDirectoryRecord::SetErrorWhenReadingFilesystemObject(BackupClientDirectoryRecord::SyncParams &rParams, const char *Filename)
+{
+	// Zero hash, so it gets synced properly next time round.
+	::memset(mStateChecksum, 0, sizeof(mStateChecksum));
+
+	// Log the error
+	::syslog(LOG_ERR, "Backup object failed, error when reading %s", Filename);
+
+	// Mark that an error occured in the parameters object
+	rParams.mReadErrorsOnFilesystemObjects = true;
+}
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::SyncParams::SyncParams(BackupClientContext &)
+//		Purpose: Constructor
+//		Created: 8/3/04
+//
+// --------------------------------------------------------------------------
+BackupClientDirectoryRecord::SyncParams::SyncParams(BackupDaemon &rDaemon, BackupClientContext &rContext)
+	: mSyncPeriodStart(0),
+	  mSyncPeriodEnd(0),
+	  mMaxUploadWait(0),
+	  mMaxFileTimeInFuture(99999999999999999LL),
+	  mFileTrackingSizeThreshold(16*1024),
+	  mDiffingUploadSizeThreshold(16*1024),
+	  mrDaemon(rDaemon),
+	  mrContext(rContext),
+	  mReadErrorsOnFilesystemObjects(false),
+	  mUploadAfterThisTimeInTheFuture(99999999999999999LL),
+	  mHaveLoggedWarningAboutFutureFileTimes(false)
+{
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::SyncParams::~SyncParams()
+//		Purpose: Destructor
+//		Created: 8/3/04
+//
+// --------------------------------------------------------------------------
+BackupClientDirectoryRecord::SyncParams::~SyncParams()
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::Deserialize(Archive & rArchive)
+//		Purpose: Deserializes this object instance from a stream of bytes, using an Archive abstraction.
+//
+//		Created: 2005/04/11
+//
+// --------------------------------------------------------------------------
+void BackupClientDirectoryRecord::Deserialize(Archive & rArchive)
+{
+	// Make deletion recursive
+	DeleteSubDirectories();
+
+	// Delete maps
+	if(mpPendingEntries != 0)
+	{
+		delete mpPendingEntries;
+		mpPendingEntries = 0;
+	}
+
+	//
+	//
+	//
+	rArchive.Read(mObjectID);
+	rArchive.Read(mSubDirName);
+	rArchive.Read(mInitialSyncDone);
+	rArchive.Read(mSyncDone);
+
+	//
+	//
+	//
+	int64_t iCount = 0;
+	rArchive.Read(iCount);
+
+	if (iCount != sizeof(mStateChecksum)/sizeof(mStateChecksum[0]))
+	{
+		// we have some kind of internal system representation change: throw for now
+		THROW_EXCEPTION(CommonException, Internal)
+	}
+
+	for (int v = 0; v < iCount; v++)
+	{
+		// Load each checksum entry
+		rArchive.Read(mStateChecksum[v]);
+	}
+
+	//
+	//
+	//
+	iCount = 0;
+	rArchive.Read(iCount);
+
+	if (iCount > 0)
+	{
+		// load each pending entry
+		mpPendingEntries = new std::map<std::string, box_time_t>;
+		if (!mpPendingEntries)
+		{
+			throw std::bad_alloc();
+		}
+
+		for (int v = 0; v < iCount; v++)
+		{
+			std::string strItem;
+			box_time_t btItem;
+
+			rArchive.Read(strItem);
+			rArchive.Read(btItem);
+			(*mpPendingEntries)[strItem] = btItem;
+		}
+	}
+
+	//
+	//
+	//
+	iCount = 0;
+	rArchive.Read(iCount);
+
+	if (iCount > 0)
+	{
+		for (int v = 0; v < iCount; v++)
+		{
+			std::string strItem;
+			rArchive.Read(strItem);
+
+			BackupClientDirectoryRecord* pSubDirRecord = 
+				new BackupClientDirectoryRecord(0, ""); 
+			// will be deserialized anyway, give it id 0 for now
+
+			if (!pSubDirRecord)
+			{
+				throw std::bad_alloc();
+			}
+
+			/***** RECURSE *****/
+			pSubDirRecord->Deserialize(rArchive);
+			mSubDirectories[strItem] = pSubDirRecord;
+		}
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientDirectoryRecord::Serialize(Archive & rArchive)
+//		Purpose: Serializes this object instance into a stream of bytes, using an Archive abstraction.
+//
+//		Created: 2005/04/11
+//
+// --------------------------------------------------------------------------
+void BackupClientDirectoryRecord::Serialize(Archive & rArchive) const
+{
+	//
+	//
+	//
+	rArchive.Write(mObjectID);
+	rArchive.Write(mSubDirName);
+	rArchive.Write(mInitialSyncDone);
+	rArchive.Write(mSyncDone);
+
+	//
+	//
+	//
+	int64_t iCount = 0;
+
+	// when reading back the archive, we will 
+	// need to know how many items there are.
+	iCount = sizeof(mStateChecksum) / sizeof(mStateChecksum[0]);
+	rArchive.Write(iCount); 
+
+	for (int v = 0; v < iCount; v++)
+	{
+		rArchive.Write(mStateChecksum[v]);
+	}
+
+	//
+	//
+	//
+	if (!mpPendingEntries)
+	{
+		iCount = 0;
+		rArchive.Write(iCount);
+	}
+	else
+	{
+		iCount = mpPendingEntries->size();
+		rArchive.Write(iCount);
+
+		for (std::map<std::string, box_time_t>::const_iterator
+			i =  mpPendingEntries->begin(); 
+			i != mpPendingEntries->end(); i++)
+		{
+			rArchive.Write(i->first);
+			rArchive.Write(i->second);
+		}
+	}
+	//
+	//
+	//
+	iCount = mSubDirectories.size();
+	rArchive.Write(iCount);
+
+	for (std::map<std::string, BackupClientDirectoryRecord*>::const_iterator
+		i =  mSubDirectories.begin(); 
+		i != mSubDirectories.end(); i++)
+	{
+		const BackupClientDirectoryRecord* pSubItem = i->second;
+		ASSERT(pSubItem);
+
+		rArchive.Write(i->first);
+		pSubItem->Serialize(rArchive);
+	}
+}
diff --git a/bin/bbackupd/BackupClientDirectoryRecord.h b/bin/bbackupd/BackupClientDirectoryRecord.h
new file mode 100644
index 00000000..2e192a96
--- /dev/null
+++ b/bin/bbackupd/BackupClientDirectoryRecord.h
@@ -0,0 +1,157 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupClientDirectoryRecord.h
+//		Purpose: Implementation of record about directory for backup client
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+
+#ifndef BACKUPCLIENTDIRECTORYRECORD__H
+#define BACKUPCLIENTDIRECTORYRECORD__H
+
+#include <string>
+#include <map>
+
+#include "BoxTime.h"
+#include "BackupClientFileAttributes.h"
+#include "BackupStoreDirectory.h"
+#include "MD5Digest.h"
+
+class Archive;
+class BackupClientContext;
+class BackupDaemon;
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    BackupClientDirectoryRecord
+//		Purpose: Implementation of record about directory for backup client
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+class BackupClientDirectoryRecord
+{
+public:
+	BackupClientDirectoryRecord(int64_t ObjectID, const std::string &rSubDirName);
+	~BackupClientDirectoryRecord();
+
+	void Deserialize(Archive & rArchive);
+	void Serialize(Archive & rArchive) const;
+private:
+	BackupClientDirectoryRecord(const BackupClientDirectoryRecord &);
+public:
+
+	enum
+	{
+		UnknownDirectoryID = 0
+	};
+
+	// --------------------------------------------------------------------------
+	//
+	// Class
+	//		Name:    BackupClientDirectoryRecord::SyncParams
+	//		Purpose: Holds parameters etc for directory syncing. Not passed as
+	//				 const, some parameters may be modified during sync.
+	//		Created: 8/3/04
+	//
+	// --------------------------------------------------------------------------
+	class SyncParams
+	{
+	public:
+		SyncParams(BackupDaemon &rDaemon, BackupClientContext &rContext);
+		~SyncParams();
+	private:
+		// No copying
+		SyncParams(const SyncParams&);
+		SyncParams &operator=(const SyncParams&);
+	public:
+
+		// Data members are public, as accessors are not justified here
+		box_time_t mSyncPeriodStart;
+		box_time_t mSyncPeriodEnd;
+		box_time_t mMaxUploadWait;
+		box_time_t mMaxFileTimeInFuture;
+		int32_t mFileTrackingSizeThreshold;
+		int32_t mDiffingUploadSizeThreshold;
+		BackupDaemon &mrDaemon;
+		BackupClientContext &mrContext;
+		bool mReadErrorsOnFilesystemObjects;
+		
+		// Member variables modified by syncing process
+		box_time_t mUploadAfterThisTimeInTheFuture;
+		bool mHaveLoggedWarningAboutFutureFileTimes;
+	};
+
+	void SyncDirectory(SyncParams &rParams, int64_t ContainingDirectoryID, const std::string &rLocalPath,
+		bool ThisDirHasJustBeenCreated = false);
+
+private:
+	void DeleteSubDirectories();
+	BackupStoreDirectory *FetchDirectoryListing(SyncParams &rParams);
+	void UpdateAttributes(SyncParams &rParams, BackupStoreDirectory *pDirOnStore, const std::string &rLocalPath);
+	bool UpdateItems(SyncParams &rParams, const std::string &rLocalPath, BackupStoreDirectory *pDirOnStore,
+		std::vector<BackupStoreDirectory::Entry *> &rEntriesLeftOver,
+		std::vector<std::string> &rFiles, const std::vector<std::string> &rDirs);
+	int64_t UploadFile(SyncParams &rParams, const std::string &rFilename, const BackupStoreFilename &rStoreFilename,
+		int64_t FileSize, box_time_t ModificationTime, box_time_t AttributesHash, bool NoPreviousVersionOnServer);
+	void SetErrorWhenReadingFilesystemObject(SyncParams &rParams, const char *Filename);
+	void RemoveDirectoryInPlaceOfFile(SyncParams &rParams, BackupStoreDirectory *pDirOnStore, int64_t ObjectID, const std::string &rFilename);
+
+private:
+	int64_t 		mObjectID;
+	std::string 	mSubDirName;
+	bool 			mInitialSyncDone;
+	bool 			mSyncDone;
+
+	// Checksum of directory contents and attributes, used to detect changes
+	uint8_t mStateChecksum[MD5Digest::DigestLength];
+
+	std::map<std::string, box_time_t>						*mpPendingEntries;
+	std::map<std::string, BackupClientDirectoryRecord *>	mSubDirectories;
+	// mpPendingEntries is a pointer rather than simple a member
+	// variables, because most of the time it'll be empty. This would waste a lot
+	// of memory because of STL allocation policies.
+};
+
+#endif // BACKUPCLIENTDIRECTORYRECORD__H
+
+
diff --git a/bin/bbackupd/BackupClientInodeToIDMap.cpp b/bin/bbackupd/BackupClientInodeToIDMap.cpp
new file mode 100644
index 00000000..5ffe98f9
--- /dev/null
+++ b/bin/bbackupd/BackupClientInodeToIDMap.cpp
@@ -0,0 +1,362 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupClientInodeToIDMap.cpp
+//		Purpose: Map of inode numbers to file IDs on the store
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#ifdef HAVE_DB
+	// Include db headers and other OS files if they're needed for the disc implementation
+	#include <sys/types.h>
+	#include <fcntl.h>
+	#include <limits.h>
+	#include <db.h>
+	#include <sys/stat.h>
+#endif
+
+#define BACKIPCLIENTINODETOIDMAP_IMPLEMENTATION
+#include "BackupClientInodeToIDMap.h"
+
+#include "BackupStoreException.h"
+
+
+#include "MemLeakFindOn.h"
+
+// What type of Berkeley DB shall we use?
+#define TABLE_DATABASE_TYPE DB_HASH
+
+typedef struct
+{
+	int64_t mObjectID;
+	int64_t mInDirectory;
+} IDBRecord;
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientInodeToIDMap::BackupClientInodeToIDMap()
+//		Purpose: Constructor
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+BackupClientInodeToIDMap::BackupClientInodeToIDMap()
+#ifndef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	: mReadOnly(true),
+	  mEmpty(false),
+	  dbp(0)
+#endif
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientInodeToIDMap::~BackupClientInodeToIDMap()
+//		Purpose: Destructor
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+BackupClientInodeToIDMap::~BackupClientInodeToIDMap()
+{
+#ifndef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	if(dbp != 0)
+	{
+#if BDB_VERSION_MAJOR >= 3
+		dbp->close(0);
+#else
+		dbp->close(dbp);
+#endif
+	}
+#endif
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientInodeToIDMap::Open(const char *, bool, bool)
+//		Purpose: Open the database map, creating a file on disc to store everything
+//		Created: 20/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientInodeToIDMap::Open(const char *Filename, bool ReadOnly, bool CreateNew)
+{
+#ifndef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	// Correct arguments?
+	ASSERT(!(CreateNew && ReadOnly));
+	
+	// Correct usage?
+	ASSERT(dbp == 0);
+	ASSERT(!mEmpty);
+	
+	// Open the database file
+#if BDB_VERSION_MAJOR >= 3
+	dbp = new Db(0,0);
+	dbp->set_pagesize(1024);		/* Page size: 1K. */
+	dbp->set_cachesize(0, 32 * 1024, 0);
+	dbp->open(NULL, Filename, NULL, DB_HASH, DB_CREATE, 0664);
+#else
+	dbp = dbopen(Filename, (CreateNew?O_CREAT:0) | (ReadOnly?O_RDONLY:O_RDWR), S_IRUSR | S_IWUSR | S_IRGRP, TABLE_DATABASE_TYPE, NULL);
+#endif
+	if(dbp == NULL)
+	{
+		THROW_EXCEPTION(BackupStoreException, BerkelyDBFailure);
+	}
+	
+	// Read only flag
+	mReadOnly = ReadOnly;
+#endif
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientInodeToIDMap::OpenEmpty()
+//		Purpose: 'Open' this map. Not associated with a disc file. Useful for when a map
+//				 is required, but is against an empty file on disc which shouldn't be created.
+//				 Implies read only.
+//		Created: 20/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientInodeToIDMap::OpenEmpty()
+{
+#ifndef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	ASSERT(dbp == 0);
+	mEmpty = true;
+	mReadOnly = true;
+#endif
+}
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientInodeToIDMap::Close()
+//		Purpose: Close the database file
+//		Created: 20/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientInodeToIDMap::Close()
+{
+#ifndef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	if(dbp != 0)
+	{
+#if BDB_VERSION_MAJOR >= 3
+		if(dbp->close(0) != 0)
+#else
+		if(dbp->close(dbp) != 0)
+#endif
+		{
+			THROW_EXCEPTION(BackupStoreException, BerkelyDBFailure);
+		}
+		dbp = 0;
+	}
+#endif
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientInodeToIDMap::AddToMap(InodeRefType, int64_t, int64_t)
+//		Purpose: Adds an entry to the map. Overwrites any existing entry.
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+void BackupClientInodeToIDMap::AddToMap(InodeRefType InodeRef, int64_t ObjectID, int64_t InDirectory)
+{
+#ifdef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	mMap[InodeRef] = std::pair<int64_t, int64_t>(ObjectID, InDirectory);
+#else
+	if(mReadOnly)
+	{
+		THROW_EXCEPTION(BackupStoreException, InodeMapIsReadOnly);
+	}
+
+	if(dbp == 0)
+	{
+		THROW_EXCEPTION(BackupStoreException, InodeMapNotOpen);
+	}
+
+	// Setup structures
+	IDBRecord rec;
+	rec.mObjectID = ObjectID;
+	rec.mInDirectory = InDirectory;
+
+#if BDB_VERSION_MAJOR >= 3
+	Dbt key(&InodeRef, sizeof(InodeRef));
+	Dbt data(&rec, sizeof(rec));
+
+	if (dbp->put(0, &key, &data, 0) != 0) {
+		THROW_EXCEPTION(BackupStoreException, BerkelyDBFailure);
+	}
+#else
+	
+	DBT key;
+	key.data = &InodeRef;
+	key.size = sizeof(InodeRef);
+	
+	DBT data;
+	data.data = &rec;
+	data.size = sizeof(rec);
+	
+	// Add to map (or replace existing entry)
+	if(dbp->put(dbp, &key, &data, 0) != 0)
+	{
+		THROW_EXCEPTION(BackupStoreException, BerkelyDBFailure);
+	}
+#endif
+#endif
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupClientInodeToIDMap::Lookup(InodeRefType, int64_t &, int64_t &) const
+//		Purpose: Looks up an inode in the map, returning true if it exists, and the object
+//				 ids of it and the directory it's in the reference arguments.
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+bool BackupClientInodeToIDMap::Lookup(InodeRefType InodeRef, int64_t &rObjectIDOut, int64_t &rInDirectoryOut) const
+{
+#ifdef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	std::map<InodeRefType, std::pair<int64_t, int64_t> >::const_iterator i(mMap.find(InodeRef));
+	
+	// Found?
+	if(i == mMap.end())
+	{
+		return false;
+	}
+
+	// Yes. Return the details
+	rObjectIDOut = i->second.first;
+	rInDirectoryOut = i->second.second;
+	return true;
+#else
+	if(mEmpty)
+	{
+		// Map is empty
+		return false;
+	}
+
+	if(dbp == 0)
+	{
+		THROW_EXCEPTION(BackupStoreException, InodeMapNotOpen);
+	}
+
+#if BDB_VERSION_MAJOR >= 3
+	Dbt key(&InodeRef, sizeof(InodeRef));
+	Dbt data(0, 0);
+	switch(dbp->get(NULL, &key, &data, 0))
+#else
+	DBT key;
+	key.data = &InodeRef;
+	key.size = sizeof(InodeRef);
+	
+	DBT data;
+	data.data = 0;
+	data.size = 0;
+
+	switch(dbp->get(dbp, &key, &data, 0))
+#endif
+	
+	{
+	case 1:	// key not in file
+		return false;
+	
+	case -1:	// error
+	default:	// not specified in docs
+		THROW_EXCEPTION(BackupStoreException, BerkelyDBFailure);
+		return false;
+	
+	case 0:		// success, found it
+		break;		
+	}
+
+	// Check for sensible return
+#if BDB_VERSION_MAJOR >= 3
+	if(key.get_data() == 0 || data.get_size() != sizeof(IDBRecord))
+	{
+		// Assert in debug version
+		ASSERT(key.get_data() == 0 || data.get_size() != sizeof(IDBRecord));
+		
+		// Invalid entries mean it wasn't found
+		return false;
+	}
+
+	// Data alignment isn't guaranteed to be on a suitable boundary
+	IDBRecord rec;
+
+	::memcpy(&rec, data.get_data(), sizeof(rec));
+#else
+	if(key.data == 0 || data.size != sizeof(IDBRecord))
+	{
+		// Assert in debug version
+		ASSERT(key.data == 0 || data.size != sizeof(IDBRecord));
+		
+		// Invalid entries mean it wasn't found
+		return false;
+	}
+	
+	// Data alignment isn't guaranteed to be on a suitable boundary
+	IDBRecord rec;
+
+	::memcpy(&rec, data.data, sizeof(rec));
+#endif
+	
+	// Return data
+	rObjectIDOut = rec.mObjectID;
+	rInDirectoryOut = rec.mInDirectory;
+
+	// Don't have to worry about freeing the returned data
+
+	// Found
+	return true;
+#endif
+}
+
+
diff --git a/bin/bbackupd/BackupClientInodeToIDMap.h b/bin/bbackupd/BackupClientInodeToIDMap.h
new file mode 100644
index 00000000..fdf77cba
--- /dev/null
+++ b/bin/bbackupd/BackupClientInodeToIDMap.h
@@ -0,0 +1,111 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupClientInodeToIDMap.h
+//		Purpose: Map of inode numbers to file IDs on the store
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+
+#ifndef BACKUPCLIENTINODETOIDMAP_H
+#define BACKUPCLIENTINODETOIDMAP__H
+
+#include <sys/types.h>
+
+#include <map>
+#include <utility>
+
+// Use in memory implementation if there isn't access to the Berkely DB on this platform
+#ifndef HAVE_DB
+	#define BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+#endif
+
+// avoid having to include the DB files when not necessary
+#ifndef BACKIPCLIENTINODETOIDMAP_IMPLEMENTATION
+#ifdef BERKELY_V4
+	class Db;
+#else
+	class DB;
+#endif
+#endif
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    BackupClientInodeToIDMap
+//		Purpose: Map of inode numbers to file IDs on the store
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+class BackupClientInodeToIDMap
+{
+public:
+	BackupClientInodeToIDMap();
+	~BackupClientInodeToIDMap();
+private:
+	BackupClientInodeToIDMap(const BackupClientInodeToIDMap &rToCopy);	// not allowed
+public:
+
+	void Open(const char *Filename, bool ReadOnly, bool CreateNew);
+	void OpenEmpty();
+
+	void AddToMap(InodeRefType InodeRef, int64_t ObjectID, int64_t InDirectory);
+	bool Lookup(InodeRefType InodeRef, int64_t &rObjectIDOut, int64_t &rInDirectoryOut) const;
+
+	void Close();
+
+private:
+#ifdef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	std::map<InodeRefType, std::pair<int64_t, int64_t> > mMap;
+#else
+	bool mReadOnly;
+	bool mEmpty;
+#ifdef BERKELY_V4
+	Db *dbp;	// c++ style implimentation
+#else
+	DB *dbp;	// C style interface, use notation from documentation
+#endif // BERKELY_V4
+#endif // BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+};
+
+#endif // BACKUPCLIENTINODETOIDMAP__H
+
+
diff --git a/bin/bbackupd/BackupDaemon.cpp b/bin/bbackupd/BackupDaemon.cpp
new file mode 100644
index 00000000..5db7cb8b
--- /dev/null
+++ b/bin/bbackupd/BackupDaemon.cpp
@@ -0,0 +1,2470 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupDaemon.cpp
+//		Purpose: Backup daemon
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#ifdef HAVE_UNISTD_H
+	#include <unistd.h>
+#endif
+#ifdef HAVE_SIGNAL_H
+	#include <signal.h>
+#endif
+#ifdef HAVE_SYSLOG_H
+	#include <syslog.h>
+#endif
+#ifdef HAVE_SYS_PARAM_H
+	#include <sys/param.h>
+#endif
+#ifdef HAVE_SYS_WAIT_H
+	#include <sys/wait.h>
+#endif
+#ifdef HAVE_SYS_MOUNT_H
+	#include <sys/mount.h>
+#endif
+#ifdef HAVE_MNTENT_H
+	#include <mntent.h>
+#endif 
+#ifdef HAVE_SYS_MNTTAB_H
+	#include <cstdio>
+	#include <sys/mnttab.h>
+#endif
+#ifdef HAVE_PROCESS_H
+	#include <process.h>
+#endif
+
+#include "Configuration.h"
+#include "IOStream.h"
+#include "MemBlockStream.h"
+#include "CommonException.h"
+#include "BoxPortsAndFiles.h"
+
+#include "SSLLib.h"
+#include "TLSContext.h"
+
+#include "BackupDaemon.h"
+#include "BackupDaemonConfigVerify.h"
+#include "BackupClientContext.h"
+#include "BackupClientDirectoryRecord.h"
+#include "BackupStoreDirectory.h"
+#include "BackupClientFileAttributes.h"
+#include "BackupStoreFilenameClear.h"
+#include "BackupClientInodeToIDMap.h"
+#include "autogen_BackupProtocolClient.h"
+#include "BackupClientCryptoKeys.h"
+#include "BannerText.h"
+#include "BackupStoreFile.h"
+#include "Random.h"
+#include "ExcludeList.h"
+#include "BackupClientMakeExcludeList.h"
+#include "IOStreamGetLine.h"
+#include "Utils.h"
+#include "FileStream.h"
+#include "BackupStoreException.h"
+#include "BackupStoreConstants.h"
+#include "LocalProcessStream.h"
+#include "IOStreamGetLine.h"
+#include "Conversion.h"
+#include "Archive.h"
+
+#include "MemLeakFindOn.h"
+
+static const time_t MAX_SLEEP_TIME = 1024;
+
+// Make the actual sync period have a little bit of extra time, up to a 64th of the main sync period.
+// This prevents repetative cycles of load on the server
+#define		SYNC_PERIOD_RANDOM_EXTRA_TIME_SHIFT_BY	6
+
+#ifdef WIN32
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    HelperThread()
+//		Purpose: Background thread function, called by Windows,
+//			calls the BackupDaemon's RunHelperThread method
+//			to listen for and act on control communications
+//		Created: 18/2/04
+//
+// --------------------------------------------------------------------------
+unsigned int WINAPI HelperThread(LPVOID lpParam) 
+{ 
+	((BackupDaemon *)lpParam)->RunHelperThread();
+
+	return 0;
+}
+#endif
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::BackupDaemon()
+//		Purpose: constructor
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+BackupDaemon::BackupDaemon()
+	: mState(BackupDaemon::State_Initialising),
+	  mpCommandSocketInfo(0),
+	  mDeleteUnusedRootDirEntriesAfter(0)
+{
+	// Only ever one instance of a daemon
+	SSLLib::Initialise();
+	
+	// Initialise notifcation sent status
+	for(int l = 0; l <= NotifyEvent__MAX; ++l)
+	{
+		mNotificationsSent[l] = false;
+	}
+
+#ifdef WIN32
+	// Create a thread to handle the named pipe
+	HANDLE hThread;
+	unsigned int dwThreadId;
+
+	hThread = (HANDLE) _beginthreadex( 
+        	NULL,                        // default security attributes 
+        	0,                           // use default stack size  
+        	HelperThread,                // thread function 
+        	this,                        // argument to thread function 
+        	0,                           // use default creation flags 
+        	&dwThreadId);                // returns the thread identifier 
+#endif
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::~BackupDaemon()
+//		Purpose: Destructor
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+BackupDaemon::~BackupDaemon()
+{
+	DeleteAllLocations();
+	DeleteAllIDMaps();
+	
+	if(mpCommandSocketInfo != 0)
+	{
+		delete mpCommandSocketInfo;
+		mpCommandSocketInfo = 0;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::DaemonName()
+//		Purpose: Get name of daemon
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+const char *BackupDaemon::DaemonName() const
+{
+	return "bbackupd";
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::DaemonBanner()
+//		Purpose: Daemon banner
+//		Created: 1/1/04
+//
+// --------------------------------------------------------------------------
+const char *BackupDaemon::DaemonBanner() const
+{
+#ifndef NDEBUG
+	// Don't display banner in debug builds
+	return 0;
+#else
+	return BANNER_TEXT("Backup Client");
+#endif
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::GetConfigVerify()
+//		Purpose: Get configuration specification
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+const ConfigurationVerify *BackupDaemon::GetConfigVerify() const
+{
+	// Defined elsewhere
+	return &BackupDaemonConfigVerify;
+}
+
+#ifdef PLATFORM_CANNOT_FIND_PEER_UID_OF_UNIX_SOCKET
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::SetupInInitialProcess()
+//		Purpose: Platforms with non-checkable credentials on 
+//			local sockets only.
+//			Prints a warning if the command socket is used.
+//		Created: 25/2/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::SetupInInitialProcess()
+{
+	// Print a warning on this platform if the CommandSocket is used.
+	if(GetConfiguration().KeyExists("CommandSocket"))
+	{
+		printf(
+				"==============================================================================\n"
+				"SECURITY WARNING: This platform cannot check the credentials of connections to\n"
+				"the command socket. This is a potential DoS security problem.\n"
+				"Remove the CommandSocket directive from the bbackupd.conf file if bbackupctl\n"
+				"is not used.\n"
+				"==============================================================================\n"
+			);
+	}
+}
+#endif
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::DeleteAllLocations()
+//		Purpose: Deletes all records stored
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::DeleteAllLocations()
+{
+	// Run through, and delete everything
+	for(std::vector<Location *>::iterator i = mLocations.begin();
+		i != mLocations.end(); ++i)
+	{
+		delete *i;
+	}
+
+	// Clear the contents of the map, so it is empty
+	mLocations.clear();
+	
+	// And delete everything from the assoicated mount vector
+	mIDMapMounts.clear();
+}
+
+#ifdef WIN32
+void BackupDaemon::RunHelperThread(void)
+{
+	mpCommandSocketInfo = new CommandSocketInfo;
+	this->mReceivedCommandConn = false;
+
+	// loop until the parent process exits
+	while (TRUE)
+	{
+		try
+		{
+			mpCommandSocketInfo->mListeningSocket.Accept(
+				BOX_NAMED_PIPE_NAME);
+
+			// This next section comes from Ben's original function
+			// Log
+			::syslog(LOG_INFO, "Connection from command socket");
+
+			// Send a header line summarising the configuration 
+			// and current state
+			const Configuration &conf(GetConfiguration());
+			char summary[256];
+			size_t summarySize = sprintf(summary, 
+				"bbackupd: %d %d %d %d\nstate %d\n",
+				conf.GetKeyValueBool("AutomaticBackup"),
+				conf.GetKeyValueInt("UpdateStoreInterval"),
+				conf.GetKeyValueInt("MinimumFileAge"),
+				conf.GetKeyValueInt("MaxUploadWait"),
+				mState);
+
+			mpCommandSocketInfo->mListeningSocket.Write(summary, summarySize);
+			mpCommandSocketInfo->mListeningSocket.Write("ping\n", 5);
+
+			IOStreamGetLine readLine(mpCommandSocketInfo->mListeningSocket);
+			std::string command;
+
+			while (mpCommandSocketInfo->mListeningSocket.IsConnected() &&
+			       readLine.GetLine(command) )
+			{
+				TRACE1("Receiving command '%s' over "
+					"command socket\n", command.c_str());
+
+				bool sendOK = false;
+				bool sendResponse = true;
+				bool disconnect = false;
+
+				// Command to process!
+				if(command == "quit" || command == "")
+				{
+					// Close the socket.
+					disconnect = true;
+					sendResponse = false;
+				}
+				else if(command == "sync")
+				{
+					// Sync now!
+					this->mDoSyncFlagOut = true;
+					this->mSyncIsForcedOut = false;
+					sendOK = true;
+				}
+				else if(command == "force-sync")
+				{
+					// Sync now (forced -- overrides any SyncAllowScript)
+					this->mDoSyncFlagOut = true;
+					this->mSyncIsForcedOut = true;
+					sendOK = true;
+				}
+				else if(command == "reload")
+				{
+					// Reload the configuration
+					SetReloadConfigWanted();
+					sendOK = true;
+				}
+				else if(command == "terminate")
+				{
+					// Terminate the daemon cleanly
+					SetTerminateWanted();
+					sendOK = true;
+				}
+
+				// Send a response back?
+				if (sendResponse)
+				{
+					const char* response = sendOK ? "ok\n" : "error\n";
+					mpCommandSocketInfo->mListeningSocket.Write(
+						response, strlen(response));
+				}
+
+				if (disconnect) 
+				{
+					break;
+				}
+
+				this->mReceivedCommandConn = true;
+			}
+
+			mpCommandSocketInfo->mListeningSocket.Close();
+		}
+		catch (BoxException &e)
+		{
+			::syslog(LOG_ERR, "Communication error with "
+				"control client: %s", e.what());
+		}
+		catch (...)
+		{
+			::syslog(LOG_ERR, "Communication error with control client");
+		}
+	}
+} 
+#endif
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::Run()
+//		Purpose: Run function for daemon
+//		Created: 18/2/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::Run()
+{
+#ifdef WIN32
+	// init our own timer for file diff timeouts
+	InitTimer();
+
+	try
+	{
+		Run2();
+	}
+	catch(...)
+	{
+		FiniTimer();
+		throw;
+	}
+
+	FiniTimer();
+#else // ! WIN32
+	// Ignore SIGPIPE (so that if a command connection is broken, the daemon doesn't terminate)
+	::signal(SIGPIPE, SIG_IGN);
+
+	// Create a command socket?
+	const Configuration &conf(GetConfiguration());
+	if(conf.KeyExists("CommandSocket"))
+	{
+		// Yes, create a local UNIX socket
+		mpCommandSocketInfo = new CommandSocketInfo;
+		const char *socketName = conf.GetKeyValue("CommandSocket").c_str();
+		::unlink(socketName);
+		mpCommandSocketInfo->mListeningSocket.Listen(Socket::TypeUNIX, socketName);
+	}
+
+	// Handle things nicely on exceptions
+	try
+	{
+		Run2();
+	}
+	catch(...)
+	{
+		if(mpCommandSocketInfo != 0)
+		{
+			try 
+			{
+				delete mpCommandSocketInfo;
+			}
+			catch(...)
+			{
+				::syslog(LOG_WARNING,
+					"Error closing command socket "
+					"after exception, ignored.");
+			}
+			mpCommandSocketInfo = 0;
+		}
+
+		throw;
+	}
+
+	// Clean up
+	if(mpCommandSocketInfo != 0)
+	{
+		delete mpCommandSocketInfo;
+		mpCommandSocketInfo = 0;
+	}
+#endif
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::Run2()
+//		Purpose: Run function for daemon (second stage)
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::Run2()
+{
+	// Read in the certificates creating a TLS context
+	TLSContext tlsContext;
+	const Configuration &conf(GetConfiguration());
+	std::string certFile(conf.GetKeyValue("CertificateFile"));
+	std::string keyFile(conf.GetKeyValue("PrivateKeyFile"));
+	std::string caFile(conf.GetKeyValue("TrustedCAsFile"));
+	tlsContext.Initialise(false /* as client */, certFile.c_str(), keyFile.c_str(), caFile.c_str());
+	
+	// Set up the keys for various things
+	BackupClientCryptoKeys_Setup(conf.GetKeyValue("KeysFile").c_str());
+
+	// max diffing time, keep-alive time
+	if(conf.KeyExists("MaximumDiffingTime"))
+	{
+		BackupClientContext::SetMaximumDiffingTime(conf.GetKeyValueInt("MaximumDiffingTime"));
+	}
+	if(conf.KeyExists("KeepAliveTime"))
+	{
+		BackupClientContext::SetKeepAliveTime(conf.GetKeyValueInt("KeepAliveTime"));
+	}
+
+	// Setup various timings
+	
+	// How often to connect to the store (approximate)
+	box_time_t updateStoreInterval = SecondsToBoxTime(conf.GetKeyValueInt("UpdateStoreInterval"));
+
+	// But are we connecting automatically?
+	bool automaticBackup = conf.GetKeyValueBool("AutomaticBackup");
+	
+	// The minimum age a file needs to be before it will be considered for uploading
+	box_time_t minimumFileAge = SecondsToBoxTime(conf.GetKeyValueInt("MinimumFileAge"));
+
+	// The maximum time we'll wait to upload a file, regardless of how often it's modified
+	box_time_t maxUploadWait = SecondsToBoxTime(conf.GetKeyValueInt("MaxUploadWait"));
+	// Adjust by subtracting the minimum file age, so is relative to sync period end in comparisons
+	maxUploadWait = (maxUploadWait > minimumFileAge)?(maxUploadWait - minimumFileAge):(0);
+
+	// When the next sync should take place -- which is ASAP
+	box_time_t nextSyncTime = 0;
+
+	// When the last sync started (only updated if the store was not full when the sync ended)
+	box_time_t lastSyncTime = 0;
+
+ 	// --------------------------------------------------------------------------------------------
+ 
+	// And what's the current client store marker?
+	int64_t clientStoreMarker = 
+		BackupClientContext::ClientStoreMarker_NotKnown;
+	// haven't contacted the store yet
+
+ 	bool deserialised = DeserializeStoreObjectInfo(clientStoreMarker, 
+		lastSyncTime, nextSyncTime);
+ 
+	// --------------------------------------------------------------------------------------------
+	
+
+	// Set state
+	SetState(State_Idle);
+
+	// Loop around doing backups
+	do
+	{
+		// Flags used below
+		bool storageLimitExceeded = false;
+		bool doSync = false;
+		bool doSyncForcedByCommand = false;
+
+		// Is a delay necessary?
+		{
+			box_time_t currentTime;
+			do
+			{
+				// Need to check the stop run thing here too, so this loop isn't run if we should be stopping
+				if(StopRun()) break;
+				
+				currentTime = GetCurrentBoxTime();
+	
+				// Pause a while, but no more than MAX_SLEEP_TIME seconds (use the conditional because times are unsigned)
+				box_time_t requiredDelay = (nextSyncTime < currentTime)?(0):(nextSyncTime - currentTime);
+				// If there isn't automatic backup happening, set a long delay. And limit delays at the same time.
+				if(!automaticBackup || requiredDelay > SecondsToBoxTime(MAX_SLEEP_TIME))
+					requiredDelay = SecondsToBoxTime(MAX_SLEEP_TIME);
+
+				// Only do the delay if there is a delay required
+				if(requiredDelay > 0)
+				{
+					// Sleep somehow. There are choices on how this should be done, depending on the state of the control connection
+					if(mpCommandSocketInfo != 0)
+					{
+						// A command socket exists, so sleep by handling connections with it
+						WaitOnCommandSocket(requiredDelay, doSync, doSyncForcedByCommand);
+					}
+					else
+					{
+						// No command socket or connection, just do a normal sleep
+						time_t sleepSeconds = BoxTimeToSeconds(requiredDelay);
+						::sleep((sleepSeconds <= 0)?1:sleepSeconds);
+					}
+				}
+				
+			} while((!automaticBackup || (currentTime < nextSyncTime)) && !doSync && !StopRun());
+		}
+
+		// Time of sync start, and if it's time for another sync (and we're doing automatic syncs), set the flag
+		box_time_t currentSyncStartTime = GetCurrentBoxTime();
+		if(automaticBackup && currentSyncStartTime >= nextSyncTime)
+		{
+			doSync = true;
+		}
+		
+		// Use a script to see if sync is allowed now?
+		if(!doSyncForcedByCommand && doSync && !StopRun())
+		{
+			int d = UseScriptToSeeIfSyncAllowed();
+			if(d > 0)
+			{
+				// Script has asked for a delay
+				nextSyncTime = GetCurrentBoxTime() + SecondsToBoxTime(d);
+				doSync = false;
+			}
+		}
+
+		// Ready to sync? (but only if we're not supposed to be stopping)
+		if(doSync && !StopRun())
+		{
+			// Touch a file to record times in filesystem
+			TouchFileInWorkingDir("last_sync_start");
+		
+			// Tell anything connected to the command socket
+			SendSyncStartOrFinish(true /* start */);
+			
+			// Reset statistics on uploads
+			BackupStoreFile::ResetStats();
+			
+			// Calculate the sync period of files to examine
+			box_time_t syncPeriodStart = lastSyncTime;
+			box_time_t syncPeriodEnd = currentSyncStartTime - minimumFileAge;
+			// Check logic
+			ASSERT(syncPeriodEnd > syncPeriodStart);
+			// Paranoid check on sync times
+			if(syncPeriodStart >= syncPeriodEnd) continue;
+			
+			// Adjust syncPeriodEnd to emulate snapshot behaviour properly
+			box_time_t syncPeriodEndExtended = syncPeriodEnd;
+			// Using zero min file age?
+			if(minimumFileAge == 0)
+			{
+				// Add a year on to the end of the end time, to make sure we sync
+				// files which are modified after the scan run started.
+				// Of course, they may be eligable to be synced again the next time round,
+				// but this should be OK, because the changes only upload should upload no data.
+				syncPeriodEndExtended += SecondsToBoxTime((time_t)(356*24*3600));
+			}
+
+			// Delete the serialised store object file,
+			// so that we don't try to reload it after a
+			// partially completed backup
+			if(deserialised && !DeleteStoreObjectInfo())
+			{
+				::syslog(LOG_ERR, "Failed to delete the "
+					"StoreObjectInfoFile, backup cannot "
+					"continue safely.");
+				continue;
+			}
+			
+			// Do sync
+			bool errorOccurred = false;
+			int errorCode = 0, errorSubCode = 0;
+			const char* errorString = "unknown";
+
+			try
+			{
+				// Set state and log start
+				SetState(State_Connected);
+				::syslog(LOG_INFO, "Beginning scan of local files");
+
+				// Then create a client context object (don't just connect, as this may be unnecessary)
+				BackupClientContext clientContext(*this, tlsContext, conf.GetKeyValue("StoreHostname"),
+					conf.GetKeyValueInt("AccountNumber"), conf.GetKeyValueBool("ExtendedLogging"));
+					
+				// Set up the sync parameters
+				BackupClientDirectoryRecord::SyncParams params(*this, clientContext);
+				params.mSyncPeriodStart = syncPeriodStart;
+				params.mSyncPeriodEnd = syncPeriodEndExtended; // use potentially extended end time
+				params.mMaxUploadWait = maxUploadWait;
+				params.mFileTrackingSizeThreshold = conf.GetKeyValueInt("FileTrackingSizeThreshold");
+				params.mDiffingUploadSizeThreshold = conf.GetKeyValueInt("DiffingUploadSizeThreshold");
+				params.mMaxFileTimeInFuture = SecondsToBoxTime(conf.GetKeyValueInt("MaxFileTimeInFuture"));
+				
+				// Set store marker
+				clientContext.SetClientStoreMarker(clientStoreMarker);
+				
+				// Set up the locations, if necessary -- need to do it here so we have a (potential) connection to use
+				if(mLocations.empty())
+				{
+					const Configuration &locations(conf.GetSubConfiguration("BackupLocations"));
+					
+					// Make sure all the directory records are set up
+					SetupLocations(clientContext, locations);
+				}
+				
+				// Get some ID maps going
+				SetupIDMapsForSync();
+
+				// Delete any unused directories?
+				DeleteUnusedRootDirEntries(clientContext);
+								
+				// Go through the records, syncing them
+				for(std::vector<Location *>::const_iterator i(mLocations.begin()); i != mLocations.end(); ++i)
+				{
+					// Set current and new ID map pointers in the context
+					clientContext.SetIDMaps(mCurrentIDMaps[(*i)->mIDMapIndex], mNewIDMaps[(*i)->mIDMapIndex]);
+				
+					// Set exclude lists (context doesn't take ownership)
+					clientContext.SetExcludeLists((*i)->mpExcludeFiles, (*i)->mpExcludeDirs);
+
+					// Sync the directory
+					(*i)->mpDirectoryRecord->SyncDirectory(params, BackupProtocolClientListDirectory::RootDirectory, (*i)->mPath);
+
+					// Unset exclude lists (just in case)
+					clientContext.SetExcludeLists(0, 0);
+				}
+				
+				// Errors reading any files?
+				if(params.mReadErrorsOnFilesystemObjects)
+				{
+					// Notify administrator
+					NotifySysadmin(NotifyEvent_ReadError);
+				}
+				else
+				{
+					// Unset the read error flag, so the error is
+					// reported again in the future
+					mNotificationsSent[NotifyEvent_ReadError] = false;
+				}
+				
+				// Perform any deletions required -- these are delayed until the end
+				// to allow renaming to happen neatly.
+				clientContext.PerformDeletions();
+
+				// Close any open connection
+				clientContext.CloseAnyOpenConnection();
+				
+				// Get the new store marker
+				clientStoreMarker = clientContext.GetClientStoreMarker();
+				
+				// Check the storage limit
+				if(clientContext.StorageLimitExceeded())
+				{
+					// Tell the sysadmin about this
+					NotifySysadmin(NotifyEvent_StoreFull);
+				}
+				else
+				{
+					// The start time of the next run is the end time of this run
+					// This is only done if the storage limit wasn't exceeded (as things won't have been done properly if it was)
+					lastSyncTime = syncPeriodEnd;
+					// unflag the storage full notify flag so that next time the store is full, and alert will be sent
+					mNotificationsSent[NotifyEvent_StoreFull] = false;
+				}
+				
+				// Calculate when the next sync run should be
+				nextSyncTime = currentSyncStartTime + updateStoreInterval + Random::RandomInt(updateStoreInterval >> SYNC_PERIOD_RANDOM_EXTRA_TIME_SHIFT_BY);
+			
+				// Commit the ID Maps
+				CommitIDMapsAfterSync();
+
+				// Log
+				::syslog(LOG_INFO, "Finished scan of local files");
+
+				// --------------------------------------------------------------------------------------------
+
+				// We had a successful backup, save the store info
+				SerializeStoreObjectInfo(clientStoreMarker, lastSyncTime, nextSyncTime);
+
+				// --------------------------------------------------------------------------------------------
+			}
+			catch(BoxException &e)
+			{
+				errorOccurred = true;
+				errorString = e.what();
+				errorCode = e.GetType();
+				errorSubCode = e.GetSubType();
+			}
+			catch(...)
+			{
+				// TODO: better handling of exceptions here... need to be very careful
+				errorOccurred = true;
+			}
+			
+			if(errorOccurred)
+			{
+				// Is it a berkely db failure?
+				bool isBerkelyDbFailure = (errorCode == BackupStoreException::ExceptionType
+					&& errorSubCode == BackupStoreException::BerkelyDBFailure);
+				if(isBerkelyDbFailure)
+				{
+					// Delete corrupt files
+					DeleteCorruptBerkelyDbFiles();
+				}
+
+				// Clear state data
+				syncPeriodStart = 0;	// go back to beginning of time
+				clientStoreMarker = BackupClientContext::ClientStoreMarker_NotKnown;	// no store marker, so download everything
+				DeleteAllLocations();
+				DeleteAllIDMaps();
+
+				// Handle restart?
+				if(StopRun())
+				{
+					::syslog(LOG_INFO, "Exception (%d/%d) due to signal", errorCode, errorSubCode);
+					return;
+				}
+
+				// If the Berkely db files get corrupted, delete them and try again immediately
+				if(isBerkelyDbFailure)
+				{
+					::syslog(LOG_ERR, "Berkely db inode map files corrupted, deleting and restarting scan. Renamed files and directories will not be tracked until after this scan.\n");
+					::sleep(1);
+				}
+				else
+				{
+					// Not restart/terminate, pause and retry
+					SetState(State_Error);
+					::syslog(LOG_ERR, 
+						"Exception caught (%s %d/%d), "
+						"reset state and waiting "
+						"to retry...", 
+						errorString, errorCode, 
+						errorSubCode);
+					::sleep(10);
+					nextSyncTime = currentSyncStartTime + 
+						SecondsToBoxTime(90) +
+						Random::RandomInt(
+							updateStoreInterval >> 
+							SYNC_PERIOD_RANDOM_EXTRA_TIME_SHIFT_BY);
+				}
+			}
+
+			// Log the stats
+			::syslog(LOG_INFO, "File statistics: total file size uploaded %lld, bytes already on server %lld, encoded size %lld",
+				BackupStoreFile::msStats.mBytesInEncodedFiles, BackupStoreFile::msStats.mBytesAlreadyOnServer,
+				BackupStoreFile::msStats.mTotalFileStreamSize);
+			BackupStoreFile::ResetStats();
+
+			// Tell anything connected to the command socket
+			SendSyncStartOrFinish(false /* finish */);
+
+			// Touch a file to record times in filesystem
+			TouchFileInWorkingDir("last_sync_finish");
+		}
+		
+		// Set state
+		SetState(storageLimitExceeded?State_StorageLimitExceeded:State_Idle);
+
+	} while(!StopRun());
+	
+	// Make sure we have a clean start next time round (if restart)
+	DeleteAllLocations();
+	DeleteAllIDMaps();
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::UseScriptToSeeIfSyncAllowed()
+//		Purpose: Private. Use a script to see if the sync should be allowed (if configured)
+//				 Returns -1 if it's allowed, time in seconds to wait otherwise.
+//		Created: 21/6/04
+//
+// --------------------------------------------------------------------------
+int BackupDaemon::UseScriptToSeeIfSyncAllowed()
+{
+	const Configuration &conf(GetConfiguration());
+
+	// Got a script to run?
+	if(!conf.KeyExists("SyncAllowScript"))
+	{
+		// No. Do sync.
+		return -1;
+	}
+
+	// If there's no result, try again in five minutes
+	int waitInSeconds = (60*5);
+
+	// Run it?
+	pid_t pid = 0;
+	try
+	{
+		std::auto_ptr<IOStream> pscript(LocalProcessStream(conf.GetKeyValue("SyncAllowScript").c_str(), pid));
+
+		// Read in the result
+		IOStreamGetLine getLine(*pscript);
+		std::string line;
+		if(getLine.GetLine(line, true, 30000)) // 30 seconds should be enough
+		{
+			// Got a string, intepret
+			if(line == "now")
+			{
+				// Script says do it now. Obey.
+				waitInSeconds = -1;
+			}
+			else
+			{
+				// How many seconds to wait?
+				waitInSeconds = BoxConvert::Convert<int32_t, const std::string&>(line);
+				::syslog(LOG_INFO, "Delaying sync by %d seconds (SyncAllowScript '%s')", waitInSeconds, conf.GetKeyValue("SyncAllowScript").c_str());
+			}
+		}
+		
+		// Wait and then cleanup child process
+		int status = 0;
+		::waitpid(pid, &status, 0);
+	}
+	catch(...)
+	{
+		// Ignore any exceptions
+		// Log that something bad happened
+		::syslog(LOG_ERR, "Error running SyncAllowScript '%s'", conf.GetKeyValue("SyncAllowScript").c_str());
+		// Clean up though
+		if(pid != 0)
+		{
+			int status = 0;
+			::waitpid(pid, &status, 0);
+		}
+	}
+
+	return waitInSeconds;
+}
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::WaitOnCommandSocket(box_time_t, bool &, bool &)
+//		Purpose: Waits on a the command socket for a time of UP TO the required time
+//				 but may be much less, and handles a command if necessary.
+//		Created: 18/2/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::WaitOnCommandSocket(box_time_t RequiredDelay, bool &DoSyncFlagOut, bool &SyncIsForcedOut)
+{
+#ifdef WIN32
+	// Really could use some interprocess protection, mutex etc
+	// any side effect should be too bad???? :)
+	DWORD timeout = (DWORD)BoxTimeToMilliSeconds(RequiredDelay);
+
+	while ( this->mReceivedCommandConn == false )
+	{
+		Sleep(1);
+
+		if ( timeout == 0 )
+		{
+			DoSyncFlagOut = false;
+			SyncIsForcedOut = false;
+			return;
+		}
+		timeout--;
+	}
+	this->mReceivedCommandConn = false;
+	DoSyncFlagOut = this->mDoSyncFlagOut;
+	SyncIsForcedOut = this->mSyncIsForcedOut;
+
+	return;
+#else // ! WIN32
+	ASSERT(mpCommandSocketInfo != 0);
+	if(mpCommandSocketInfo == 0) {::sleep(1); return;} // failure case isn't too bad
+	
+	TRACE1("Wait on command socket, delay = %lld\n", RequiredDelay);
+	
+	try
+	{
+		// Timeout value for connections and things
+		int timeout = ((int)BoxTimeToMilliSeconds(RequiredDelay)) + 1;
+		// Handle bad boundary cases
+		if(timeout <= 0) timeout = 1;
+		if(timeout == INFTIM) timeout = 100000;
+
+		// Wait for socket connection, or handle a command?
+		if(mpCommandSocketInfo->mpConnectedSocket.get() == 0)
+		{
+			// No connection, listen for a new one
+			mpCommandSocketInfo->mpConnectedSocket.reset(mpCommandSocketInfo->mListeningSocket.Accept(timeout).release());
+			
+			if(mpCommandSocketInfo->mpConnectedSocket.get() == 0)
+			{
+				// If a connection didn't arrive, there was a timeout, which means we've
+				// waited long enough and it's time to go.
+				return;
+			}
+			else
+			{
+#ifdef PLATFORM_CANNOT_FIND_PEER_UID_OF_UNIX_SOCKET
+				bool uidOK = true;
+				::syslog(LOG_WARNING, "On this platform, no security check can be made on the credientials of peers connecting to the command socket. (bbackupctl)");
+#else
+				// Security check -- does the process connecting to this socket have
+				// the same UID as this process?
+				bool uidOK = false;
+				// BLOCK
+				{
+					uid_t remoteEUID = 0xffff;
+					gid_t remoteEGID = 0xffff;
+					if(mpCommandSocketInfo->mpConnectedSocket->GetPeerCredentials(remoteEUID, remoteEGID))
+					{
+						// Credentials are available -- check UID
+						if(remoteEUID == ::getuid())
+						{
+							// Acceptable
+							uidOK = true;
+						}
+					}
+				}
+#endif // PLATFORM_CANNOT_FIND_PEER_UID_OF_UNIX_SOCKET
+				
+				// Is this an acceptable connection?
+				if(!uidOK)
+				{
+					// Dump the connection
+					::syslog(LOG_ERR, "Incoming command connection from peer had different user ID than this process, or security check could not be completed.");
+					mpCommandSocketInfo->mpConnectedSocket.reset();
+					return;
+				}
+				else
+				{
+					// Log
+					::syslog(LOG_INFO, "Connection from command socket");
+					
+					// Send a header line summarising the configuration and current state
+					const Configuration &conf(GetConfiguration());
+					char summary[256];
+					int summarySize = sprintf(summary, "bbackupd: %d %d %d %d\nstate %d\n",
+						conf.GetKeyValueBool("AutomaticBackup"),
+						conf.GetKeyValueInt("UpdateStoreInterval"),
+						conf.GetKeyValueInt("MinimumFileAge"),
+						conf.GetKeyValueInt("MaxUploadWait"),
+						mState);
+					mpCommandSocketInfo->mpConnectedSocket->Write(summary, summarySize);
+					
+					// Set the timeout to something very small, so we don't wait too long on waiting
+					// for any incoming data
+					timeout = 10; // milliseconds
+				}
+			}
+		}
+
+		// So there must be a connection now.
+		ASSERT(mpCommandSocketInfo->mpConnectedSocket.get() != 0);
+		
+		// Is there a getline object ready?
+		if(mpCommandSocketInfo->mpGetLine == 0)
+		{
+			// Create a new one
+			mpCommandSocketInfo->mpGetLine = new IOStreamGetLine(*(mpCommandSocketInfo->mpConnectedSocket.get()));
+		}
+		
+		// Ping the remote side, to provide errors which will mean the socket gets closed
+		mpCommandSocketInfo->mpConnectedSocket->Write("ping\n", 5);
+		
+		// Wait for a command or something on the socket
+		std::string command;
+		while(mpCommandSocketInfo->mpGetLine != 0 && !mpCommandSocketInfo->mpGetLine->IsEOF()
+			&& mpCommandSocketInfo->mpGetLine->GetLine(command, false /* no preprocessing */, timeout))
+		{
+			TRACE1("Receiving command '%s' over command socket\n", command.c_str());
+			
+			bool sendOK = false;
+			bool sendResponse = true;
+		
+			// Command to process!
+			if(command == "quit" || command == "")
+			{
+				// Close the socket.
+				CloseCommandConnection();
+				sendResponse = false;
+			}
+			else if(command == "sync")
+			{
+				// Sync now!
+				DoSyncFlagOut = true;
+				SyncIsForcedOut = false;
+				sendOK = true;
+			}
+			else if(command == "force-sync")
+			{
+				// Sync now (forced -- overrides any SyncAllowScript)
+				DoSyncFlagOut = true;
+				SyncIsForcedOut = true;
+				sendOK = true;
+			}
+			else if(command == "reload")
+			{
+				// Reload the configuration
+				SetReloadConfigWanted();
+				sendOK = true;
+			}
+			else if(command == "terminate")
+			{
+				// Terminate the daemon cleanly
+				SetTerminateWanted();
+				sendOK = true;
+			}
+			
+			// Send a response back?
+			if(sendResponse)
+			{
+				mpCommandSocketInfo->mpConnectedSocket->Write(sendOK?"ok\n":"error\n", sendOK?3:6);
+			}
+			
+			// Set timeout to something very small, so this just checks for data which is waiting
+			timeout = 1;
+		}
+		
+		// Close on EOF?
+		if(mpCommandSocketInfo->mpGetLine != 0 && mpCommandSocketInfo->mpGetLine->IsEOF())
+		{
+			CloseCommandConnection();
+		}
+	}
+	catch(...)
+	{
+		// If an error occurs, and there is a connection active, just close that
+		// connection and continue. Otherwise, let the error propagate.
+		if(mpCommandSocketInfo->mpConnectedSocket.get() == 0)
+		{
+			throw;
+		}
+		else
+		{
+			// Close socket and ignore error
+			CloseCommandConnection();
+		}
+	}
+#endif // WIN32
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::CloseCommandConnection()
+//		Purpose: Close the command connection, ignoring any errors
+//		Created: 18/2/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::CloseCommandConnection()
+{
+#ifndef WIN32
+	try
+	{
+		TRACE0("Closing command connection\n");
+		
+		if(mpCommandSocketInfo->mpGetLine)
+		{
+			delete mpCommandSocketInfo->mpGetLine;
+			mpCommandSocketInfo->mpGetLine = 0;
+		}
+		mpCommandSocketInfo->mpConnectedSocket.reset();
+	}
+	catch(...)
+	{
+		// Ignore any errors
+	}
+#endif
+}
+
+
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupDaemon.cpp
+//		Purpose: Send a start or finish sync message to the command socket, if it's connected.
+//				 
+//		Created: 18/2/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::SendSyncStartOrFinish(bool SendStart)
+{
+	// The bbackupctl program can't rely on a state change, because it may never
+	// change if the server doesn't need to be contacted.
+
+#ifdef __MINGW32__
+#warning race condition: what happens if socket is closed?
+#endif
+
+	if (mpCommandSocketInfo != NULL &&
+#ifdef WIN32
+	    mpCommandSocketInfo->mListeningSocket.IsConnected()
+#else
+	    mpCommandSocketInfo->mpConnectedSocket.get() != 0
+#endif
+	    )
+	{
+		const char* message = SendStart ? "start-sync\n" : "finish-sync\n";
+		try
+		{
+#ifdef WIN32
+			mpCommandSocketInfo->mListeningSocket.Write(message, 
+				(int)strlen(message));
+#else
+			mpCommandSocketInfo->mpConnectedSocket->Write(message,
+				strlen(message));
+#endif
+		}
+		catch(...)
+		{
+			CloseCommandConnection();
+		}
+	}
+}
+
+
+
+
+#if !defined(HAVE_STRUCT_STATFS_F_MNTONNAME) && !defined(HAVE_STRUCT_STATVFS_F_NMTONNAME)
+	// string comparison ordering for when mount points are handled
+	// by code, rather than the OS.
+	typedef struct
+	{
+		bool operator()(const std::string &s1, const std::string &s2)
+		{
+			if(s1.size() == s2.size())
+			{
+				// Equal size, sort according to natural sort order
+				return s1 < s2;
+			}
+			else
+			{
+				// Make sure longer strings go first
+				return s1.size() > s2.size();
+			}
+		}
+	} mntLenCompare;
+#endif
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::SetupLocations(BackupClientContext &, const Configuration &)
+//		Purpose: Makes sure that the list of directories records is correctly set up
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::SetupLocations(BackupClientContext &rClientContext, const Configuration &rLocationsConf)
+{
+	if(!mLocations.empty())
+	{
+		// Looks correctly set up
+		return;
+	}
+
+	// Make sure that if a directory is reinstated, then it doesn't get deleted	
+	mDeleteUnusedRootDirEntriesAfter = 0;
+	mUnusedRootDirEntries.clear();
+
+	// Just a check to make sure it's right.
+	DeleteAllLocations();
+	
+	// Going to need a copy of the root directory. Get a connection, and fetch it.
+	BackupProtocolClient &connection(rClientContext.GetConnection());
+	
+	// Ask server for a list of everything in the root directory, which is a directory itself
+	std::auto_ptr<BackupProtocolClientSuccess> dirreply(connection.QueryListDirectory(
+			BackupProtocolClientListDirectory::RootDirectory,
+			BackupProtocolClientListDirectory::Flags_Dir,	// only directories
+			BackupProtocolClientListDirectory::Flags_Deleted | BackupProtocolClientListDirectory::Flags_OldVersion, // exclude old/deleted stuff
+			false /* no attributes */));
+
+	// Retrieve the directory from the stream following
+	BackupStoreDirectory dir;
+	std::auto_ptr<IOStream> dirstream(connection.ReceiveStream());
+	dir.ReadFromStream(*dirstream, connection.GetTimeout());
+	
+	// Map of mount names to ID map index
+	std::map<std::string, int> mounts;
+	int numIDMaps = 0;
+
+#ifdef HAVE_MOUNTS
+#if !defined(HAVE_STRUCT_STATFS_F_MNTONNAME) && !defined(HAVE_STRUCT_STATVFS_F_MNTONNAME)
+	// Linux and others can't tell you where a directory is mounted. So we
+	// have to read the mount entries from /etc/mtab! Bizarre that the OS
+	// itself can't tell you, but there you go.
+	std::set<std::string, mntLenCompare> mountPoints;
+	// BLOCK
+	FILE *mountPointsFile = 0;
+
+#ifdef HAVE_STRUCT_MNTENT_MNT_DIR
+	// Open mounts file
+	mountPointsFile = ::setmntent("/proc/mounts", "r");
+	if(mountPointsFile == 0)
+	{
+		mountPointsFile = ::setmntent("/etc/mtab", "r");
+	}
+	if(mountPointsFile == 0)
+	{
+		THROW_EXCEPTION(CommonException, OSFileError);
+	}
+
+	try
+	{
+		// Read all the entries, and put them in the set
+		struct mntent *entry = 0;
+		while((entry = ::getmntent(mountPointsFile)) != 0)
+		{
+			TRACE1("Found mount point at %s\n", entry->mnt_dir);
+			mountPoints.insert(std::string(entry->mnt_dir));
+		}
+
+		// Close mounts file
+		::endmntent(mountPointsFile);
+	}
+	catch(...)
+	{
+			::endmntent(mountPointsFile);
+		throw;
+	}
+#else // ! HAVE_STRUCT_MNTENT_MNT_DIR
+	// Open mounts file
+	mountPointsFile = ::fopen("/etc/mnttab", "r");
+	if(mountPointsFile == 0)
+	{
+		THROW_EXCEPTION(CommonException, OSFileError);
+	}
+
+	try
+	{
+
+		// Read all the entries, and put them in the set
+		struct mnttab entry;
+		while(getmntent(mountPointsFile, &entry) == 0)
+		{
+			TRACE1("Found mount point at %s\n", entry.mnt_mountp);
+			mountPoints.insert(std::string(entry.mnt_mountp));
+		}
+
+		// Close mounts file
+		::fclose(mountPointsFile);
+	}
+	catch(...)
+	{
+		::fclose(mountPointsFile);
+		throw;
+	}
+#endif // HAVE_STRUCT_MNTENT_MNT_DIR
+	// Check sorting and that things are as we expect
+	ASSERT(mountPoints.size() > 0);
+#ifndef NDEBUG
+	{
+		std::set<std::string, mntLenCompare>::const_reverse_iterator i(mountPoints.rbegin());
+		ASSERT(*i == "/");
+	}
+#endif // n NDEBUG
+#endif // n HAVE_STRUCT_STATFS_F_MNTONNAME || n HAVE_STRUCT_STATVFS_F_MNTONNAME
+#endif // HAVE_MOUNTS
+
+	// Then... go through each of the entries in the configuration,
+	// making sure there's a directory created for it.
+	for(std::list<std::pair<std::string, Configuration> >::const_iterator i = rLocationsConf.mSubConfigurations.begin();
+		i != rLocationsConf.mSubConfigurations.end(); ++i)
+	{
+TRACE0("new location\n");
+		// Create a record for it
+		Location *ploc = new Location;
+		try
+		{
+			// Setup names in the location record
+			ploc->mName = i->first;
+			ploc->mPath = i->second.GetKeyValue("Path");
+			
+			// Read the exclude lists from the Configuration
+			ploc->mpExcludeFiles = BackupClientMakeExcludeList_Files(i->second);
+			ploc->mpExcludeDirs = BackupClientMakeExcludeList_Dirs(i->second);
+			
+			// Do a fsstat on the pathname to find out which mount it's on
+			{
+
+#if defined HAVE_STRUCT_STATFS_F_MNTONNAME || defined HAVE_STRUCT_STATVFS_F_MNTONNAME || defined WIN32
+
+				// BSD style statfs -- includes mount point, which is nice.
+#ifdef HAVE_STRUCT_STATVFS_F_MNTONNAME
+				struct statvfs s;
+				if(::statvfs(ploc->mPath.c_str(), &s) != 0)
+#else // HAVE_STRUCT_STATVFS_F_MNTONNAME
+				struct statfs s;
+				if(::statfs(ploc->mPath.c_str(), &s) != 0)
+#endif // HAVE_STRUCT_STATVFS_F_MNTONNAME
+				{
+					THROW_EXCEPTION(CommonException, OSFileError)
+				}
+
+				// Where the filesystem is mounted
+				std::string mountName(s.f_mntonname);
+
+#else // !HAVE_STRUCT_STATFS_F_MNTONNAME && !WIN32
+
+				// Warn in logs if the directory isn't absolute
+				if(ploc->mPath[0] != '/')
+				{
+					::syslog(LOG_ERR, "Location path '%s' isn't absolute", ploc->mPath.c_str());
+				}
+				// Go through the mount points found, and find a suitable one
+				std::string mountName("/");
+				{
+					std::set<std::string, mntLenCompare>::const_iterator i(mountPoints.begin());
+					TRACE1("%d potential mount points\n", mountPoints.size());
+					for(; i != mountPoints.end(); ++i)
+					{
+						// Compare first n characters with the filename
+						// If it matches, the file belongs in that mount point
+						// (sorting order ensures this)
+						TRACE1("checking against mount point %s\n", i->c_str());
+						if(::strncmp(i->c_str(), ploc->mPath.c_str(), i->size()) == 0)
+						{
+							// Match
+							mountName = *i;
+							break;
+						}
+					}
+					TRACE2("mount point chosen for %s is %s\n", ploc->mPath.c_str(), mountName.c_str());
+				}
+
+#endif
+				
+				// Got it?
+				std::map<std::string, int>::iterator f(mounts.find(mountName));
+				if(f != mounts.end())
+				{
+					// Yes -- store the index
+					ploc->mIDMapIndex = f->second;
+				}
+				else
+				{
+					// No -- new index
+					ploc->mIDMapIndex = numIDMaps;
+					mounts[mountName] = numIDMaps;
+					
+					// Store the mount name
+					mIDMapMounts.push_back(mountName);
+					
+					// Increment number of maps
+					++numIDMaps;
+				}
+			}
+		
+			// Does this exist on the server?
+			BackupStoreDirectory::Iterator iter(dir);
+			BackupStoreFilenameClear dirname(ploc->mName);	// generate the filename
+			BackupStoreDirectory::Entry *en = iter.FindMatchingClearName(dirname);
+			int64_t oid = 0;
+			if(en != 0)
+			{
+				oid = en->GetObjectID();
+				
+				// Delete the entry from the directory, so we get a list of
+				// unused root directories at the end of this.
+				dir.DeleteEntry(oid);
+			}
+			else
+			{
+				// Doesn't exist, so it has to be created on the server. Let's go!
+				// First, get the directory's attributes and modification time
+				box_time_t attrModTime = 0;
+				BackupClientFileAttributes attr;
+				attr.ReadAttributes(ploc->mPath.c_str(), true /* directories have zero mod times */,
+					0 /* not interested in mod time */, &attrModTime /* get the attribute modification time */);
+				
+				// Execute create directory command
+				MemBlockStream attrStream(attr);
+				std::auto_ptr<BackupProtocolClientSuccess> dirCreate(connection.QueryCreateDirectory(
+					BackupProtocolClientListDirectory::RootDirectory,
+					attrModTime, dirname, attrStream));
+					
+				// Object ID for later creation
+				oid = dirCreate->GetObjectID();
+			}
+
+			// Create and store the directory object for the root of this location
+			ASSERT(oid != 0);
+			BackupClientDirectoryRecord *precord = new BackupClientDirectoryRecord(oid, i->first);
+			ploc->mpDirectoryRecord.reset(precord);
+			
+			// Push it back on the vector of locations
+			mLocations.push_back(ploc);
+		}
+		catch(...)
+		{
+			delete ploc;
+			ploc = 0;
+			throw;
+		}
+	}
+	
+	// Any entries in the root directory which need deleting?
+	if(dir.GetNumberOfEntries() > 0)
+	{
+		::syslog(LOG_INFO, "%d redundant locations in root directory found, will delete from store after %d seconds.",
+			dir.GetNumberOfEntries(), BACKUP_DELETE_UNUSED_ROOT_ENTRIES_AFTER);
+
+		// Store directories in list of things to delete
+		mUnusedRootDirEntries.clear();
+		BackupStoreDirectory::Iterator iter(dir);
+		BackupStoreDirectory::Entry *en = 0;
+		while((en = iter.Next()) != 0)
+		{
+			// Add name to list
+			BackupStoreFilenameClear clear(en->GetName());
+			const std::string &name(clear.GetClearFilename());
+			mUnusedRootDirEntries.push_back(std::pair<int64_t,std::string>(en->GetObjectID(), name));
+			// Log this
+			::syslog(LOG_INFO, "Unused location in root: %s", name.c_str());
+		}
+		ASSERT(mUnusedRootDirEntries.size() > 0);
+		// Time to delete them
+		mDeleteUnusedRootDirEntriesAfter =
+			GetCurrentBoxTime() + SecondsToBoxTime(BACKUP_DELETE_UNUSED_ROOT_ENTRIES_AFTER);
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::SetupIDMapsForSync()
+//		Purpose: Sets up ID maps for the sync process -- make sure they're all there
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::SetupIDMapsForSync()
+{
+	// Need to do different things depending on whether it's an in memory implementation,
+	// or whether it's all stored on disc.
+	
+#ifdef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+
+	// Make sure we have some blank, empty ID maps
+	DeleteIDMapVector(mNewIDMaps);
+	FillIDMapVector(mNewIDMaps, true /* new maps */);
+
+	// Then make sure that the current maps have objects, even if they are empty
+	// (for the very first run)
+	if(mCurrentIDMaps.empty())
+	{
+		FillIDMapVector(mCurrentIDMaps, false /* current maps */);
+	}
+
+#else
+
+	// Make sure we have some blank, empty ID maps
+	DeleteIDMapVector(mNewIDMaps);
+	FillIDMapVector(mNewIDMaps, true /* new maps */);
+	DeleteIDMapVector(mCurrentIDMaps);
+	FillIDMapVector(mCurrentIDMaps, false /* new maps */);
+
+#endif
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::FillIDMapVector(std::vector<BackupClientInodeToIDMap *> &)
+//		Purpose: Fills the vector with the right number of empty ID maps
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::FillIDMapVector(std::vector<BackupClientInodeToIDMap *> &rVector, bool NewMaps)
+{
+	ASSERT(rVector.size() == 0);
+	rVector.reserve(mIDMapMounts.size());
+	
+	for(unsigned int l = 0; l < mIDMapMounts.size(); ++l)
+	{
+		// Create the object
+		BackupClientInodeToIDMap *pmap = new BackupClientInodeToIDMap();
+		try
+		{
+			// Get the base filename of this map
+			std::string filename;
+			MakeMapBaseName(l, filename);
+			
+			// If it's a new one, add a suffix
+			if(NewMaps)
+			{
+				filename += ".n";
+			}
+
+			// If it's not a new map, it may not exist in which case an empty map should be created
+			if(!NewMaps && !FileExists(filename.c_str()))
+			{
+				pmap->OpenEmpty();
+			}
+			else
+			{
+				// Open the map
+				pmap->Open(filename.c_str(), !NewMaps /* read only */, NewMaps /* create new */);
+			}
+			
+			// Store on vector
+			rVector.push_back(pmap);
+		}
+		catch(...)
+		{
+			delete pmap;
+			throw;
+		}
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::DeleteCorruptBerkelyDbFiles()
+//		Purpose: Delete the Berkely db files from disc after they have been corrupted.
+//		Created: 14/9/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::DeleteCorruptBerkelyDbFiles()
+{
+	for(unsigned int l = 0; l < mIDMapMounts.size(); ++l)
+	{
+		// Get the base filename of this map
+		std::string filename;
+		MakeMapBaseName(l, filename);
+		
+		// Delete the file
+		TRACE1("Deleting %s\n", filename.c_str());
+		::unlink(filename.c_str());
+		
+		// Add a suffix for the new map
+		filename += ".n";
+
+		// Delete that too
+		TRACE1("Deleting %s\n", filename.c_str());
+		::unlink(filename.c_str());
+	}
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    MakeMapBaseName(unsigned int, std::string &)
+//		Purpose: Makes the base name for a inode map
+//		Created: 20/11/03
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::MakeMapBaseName(unsigned int MountNumber, std::string &rNameOut) const
+{
+	// Get the directory for the maps
+	const Configuration &config(GetConfiguration());
+	std::string dir(config.GetKeyValue("DataDirectory"));
+
+	// Make a leafname
+	std::string leaf(mIDMapMounts[MountNumber]);
+	for(unsigned int z = 0; z < leaf.size(); ++z)
+	{
+		if(leaf[z] == DIRECTORY_SEPARATOR_ASCHAR)
+		{
+			leaf[z] = '_';
+		}
+	}
+
+	// Build the final filename
+	rNameOut = dir + DIRECTORY_SEPARATOR "mnt" + leaf;
+}
+
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::CommitIDMapsAfterSync()
+//		Purpose: Commits the new ID maps, so the 'new' maps are now the 'current' maps.
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::CommitIDMapsAfterSync()
+{
+	// Need to do different things depending on whether it's an in memory implementation,
+	// or whether it's all stored on disc.
+	
+#ifdef BACKIPCLIENTINODETOIDMAP_IN_MEMORY_IMPLEMENTATION
+	// Remove the current ID maps
+	DeleteIDMapVector(mCurrentIDMaps);
+
+	// Copy the (pointers to) "new" maps over to be the new "current" maps
+	mCurrentIDMaps = mNewIDMaps;
+	
+	// Clear the new ID maps vector (not delete them!)
+	mNewIDMaps.clear();
+
+#else
+
+	// Get rid of the maps in memory (leaving them on disc of course)
+	DeleteIDMapVector(mCurrentIDMaps);
+	DeleteIDMapVector(mNewIDMaps);
+
+	// Then move the old maps into the new places
+	for(unsigned int l = 0; l < mIDMapMounts.size(); ++l)
+	{
+		std::string target;
+		MakeMapBaseName(l, target);
+		std::string newmap(target + ".n");
+		
+		// Try to rename
+#ifdef WIN32
+		// win32 rename doesn't overwrite existing files
+		::remove(target.c_str());
+#endif
+		if(::rename(newmap.c_str(), target.c_str()) != 0)
+		{
+			THROW_EXCEPTION(CommonException, OSFileError)
+		}
+	}
+
+#endif
+}
+
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::DeleteIDMapVector(std::vector<BackupClientInodeToIDMap *> &)
+//		Purpose: Deletes the contents of a vector of ID maps
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::DeleteIDMapVector(std::vector<BackupClientInodeToIDMap *> &rVector)
+{
+	while(!rVector.empty())
+	{
+		// Pop off list
+		BackupClientInodeToIDMap *toDel = rVector.back();
+		rVector.pop_back();
+		
+		// Close and delete
+		toDel->Close();
+		delete toDel;
+	}
+	ASSERT(rVector.size() == 0);
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::FindLocationPathName(const std::string &, std::string &) const
+//		Purpose: Tries to find the path of the root of a backup location. Returns true (and path in rPathOut)
+//				 if it can be found, false otherwise.
+//		Created: 12/11/03
+//
+// --------------------------------------------------------------------------
+bool BackupDaemon::FindLocationPathName(const std::string &rLocationName, std::string &rPathOut) const
+{
+	// Search for the location
+	for(std::vector<Location *>::const_iterator i(mLocations.begin()); i != mLocations.end(); ++i)
+	{
+		if((*i)->mName == rLocationName)
+		{
+			rPathOut = (*i)->mPath;
+			return true;
+		}
+	}
+	
+	// Didn't find it
+	return false;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::SetState(int)
+//		Purpose: Record current action of daemon, and update process title to reflect this
+//		Created: 11/12/03
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::SetState(int State)
+{
+	// Two little checks
+	if(State == mState) return;
+	if(State < 0) return;
+
+	// Update
+	mState = State;
+	
+	// Set process title
+	const static char *stateText[] = {"idle", "connected", "error -- waiting for retry", "over limit on server -- not backing up"};
+	SetProcessTitle(stateText[State]);
+
+	// If there's a command socket connected, then inform it -- disconnecting from the
+	// command socket if there's an error
+
+	char newState[64];
+	char newStateSize = sprintf(newState, "state %d\n", State);
+
+#ifdef WIN32
+	#ifndef _MSC_VER
+		#warning FIX ME: race condition
+	#endif
+
+	// what happens if the socket is closed by the other thread before
+	// we can write to it? Null pointer deref at best.
+	if (mpCommandSocketInfo && 
+	    mpCommandSocketInfo->mListeningSocket.IsConnected())
+	{
+		try
+		{
+			mpCommandSocketInfo->mListeningSocket.Write(newState, newStateSize);
+		}
+		catch(...)
+		{
+			CloseCommandConnection();
+		}
+	}
+#else
+	if(mpCommandSocketInfo != 0 && mpCommandSocketInfo->mpConnectedSocket.get() != 0)
+	{
+		// Something connected to the command socket, tell it about the new state
+		try
+		{
+			mpCommandSocketInfo->mpConnectedSocket->Write(newState, newStateSize);
+		}
+		catch(...)
+		{
+			CloseCommandConnection();
+		}
+	}
+#endif
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::TouchFileInWorkingDir(const char *)
+//		Purpose: Make sure a zero length file of the name exists in the working directory.
+//				 Use for marking times of events in the filesystem.
+//		Created: 21/2/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::TouchFileInWorkingDir(const char *Filename)
+{
+	// Filename
+	const Configuration &config(GetConfiguration());
+	std::string fn(config.GetKeyValue("DataDirectory") + DIRECTORY_SEPARATOR_ASCHAR);
+	fn += Filename;
+	
+	// Open and close it to update the timestamp
+	FileStream touch(fn.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::NotifySysadmin(int)
+//		Purpose: Run the script to tell the sysadmin about events which need attention.
+//		Created: 25/2/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::NotifySysadmin(int Event)
+{
+	static const char *sEventNames[] = {"store-full", "read-error", 0};
+
+	TRACE1("BackupDaemon::NotifySysadmin() called, event = %d\n", Event);
+
+	if(Event < 0 || Event > NotifyEvent__MAX)
+	{
+		THROW_EXCEPTION(BackupStoreException, BadNotifySysadminEventCode);
+	}
+
+	// Don't send lots of repeated messages
+	if(mNotificationsSent[Event])
+	{
+		return;
+	}
+
+	// Is there a notifation script?
+	const Configuration &conf(GetConfiguration());
+	if(!conf.KeyExists("NotifyScript"))
+	{
+		// Log, and then return
+		::syslog(LOG_ERR, "Not notifying administrator about event %s -- set NotifyScript to do this in future", sEventNames[Event]);
+		return;
+	}
+
+	// Script to run
+	std::string script(conf.GetKeyValue("NotifyScript") + ' ' + sEventNames[Event]);
+	
+	// Log what we're about to do
+	::syslog(LOG_INFO, "About to notify administrator about event %s, running script '%s'", sEventNames[Event], script.c_str());
+	
+	// Then do it
+	if(::system(script.c_str()) != 0)
+	{
+		::syslog(LOG_ERR, "Notify script returned an error code. ('%s')", script.c_str());
+	}
+
+	// Flag that this is done so the administrator isn't constantly bombarded with lots of errors
+	mNotificationsSent[Event] = true;
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::DeleteUnusedRootDirEntries(BackupClientContext &)
+//		Purpose: Deletes any unused entries in the root directory, if they're scheduled to be deleted.
+//		Created: 13/5/04
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::DeleteUnusedRootDirEntries(BackupClientContext &rContext)
+{
+	if(mUnusedRootDirEntries.empty() || mDeleteUnusedRootDirEntriesAfter == 0)
+	{
+		// Nothing to do.
+		return;
+	}
+	
+	// Check time
+	if(GetCurrentBoxTime() < mDeleteUnusedRootDirEntriesAfter)
+	{
+		// Too early to delete files
+		return;
+	}
+
+	// Entries to delete, and it's the right time to do so...
+	::syslog(LOG_INFO, "Deleting unused locations from store root...");
+	BackupProtocolClient &connection(rContext.GetConnection());
+	for(std::vector<std::pair<int64_t,std::string> >::iterator i(mUnusedRootDirEntries.begin()); i != mUnusedRootDirEntries.end(); ++i)
+	{
+		connection.QueryDeleteDirectory(i->first);
+		
+		// Log this
+		::syslog(LOG_INFO, "Deleted %s (ID %08llx) from store root", i->second.c_str(), i->first);
+	}
+
+	// Reset state
+	mDeleteUnusedRootDirEntriesAfter = 0;
+	mUnusedRootDirEntries.clear();
+}
+
+// --------------------------------------------------------------------------
+
+typedef struct
+{
+	int32_t mMagicValue;	// also the version number
+	int32_t mNumEntries;
+	int64_t mObjectID;		// this object ID
+	int64_t mContainerID;	// ID of container
+	uint64_t mAttributesModTime;
+	int32_t mOptionsPresent;	// bit mask of optional sections / features present
+
+} loc_StreamFormat;
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::Location::Location()
+//		Purpose: Constructor
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+BackupDaemon::Location::Location()
+	: mIDMapIndex(0),
+	  mpExcludeFiles(0),
+	  mpExcludeDirs(0)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::Location::~Location()
+//		Purpose: Destructor
+//		Created: 11/11/03
+//
+// --------------------------------------------------------------------------
+BackupDaemon::Location::~Location()
+{
+	// Clean up exclude locations
+	if(mpExcludeDirs != 0)
+	{
+		delete mpExcludeDirs;
+		mpExcludeDirs = 0;
+	}
+	if(mpExcludeFiles != 0)
+	{
+		delete mpExcludeFiles;
+		mpExcludeFiles = 0;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::Location::Deserialize(Archive & rArchive)
+//		Purpose: Deserializes this object instance from a stream of bytes, using an Archive abstraction.
+//
+//		Created: 2005/04/11
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::Location::Deserialize(Archive &rArchive)
+{
+	//
+	//
+	//
+	mpDirectoryRecord.reset(NULL);
+	if (mpExcludeFiles)
+	{
+		delete mpExcludeFiles;
+		mpExcludeFiles = NULL;
+	}
+	if (mpExcludeDirs)
+	{
+		delete mpExcludeDirs;
+		mpExcludeDirs = NULL;
+	}
+
+	//
+	//
+	//
+	rArchive.Read(mName);
+	rArchive.Read(mPath);
+	rArchive.Read(mIDMapIndex);
+
+	//
+	//
+	//
+	int64_t aMagicMarker = 0;
+	rArchive.Read(aMagicMarker);
+
+	if (aMagicMarker == ARCHIVE_MAGIC_VALUE_NOOP)
+	{
+		// NOOP
+	}
+	else if (aMagicMarker == ARCHIVE_MAGIC_VALUE_RECURSE)
+	{
+		BackupClientDirectoryRecord *pSubRecord = new BackupClientDirectoryRecord(0, "");
+		if (!pSubRecord)
+			throw std::bad_alloc();
+
+		mpDirectoryRecord.reset(pSubRecord);
+		mpDirectoryRecord->Deserialize(rArchive);
+	}
+	else
+	{
+		// there is something going on here
+		THROW_EXCEPTION(CommonException, Internal)
+	}
+
+	//
+	//
+	//
+	rArchive.Read(aMagicMarker);
+
+	if (aMagicMarker == ARCHIVE_MAGIC_VALUE_NOOP)
+	{
+		// NOOP
+	}
+	else if (aMagicMarker == ARCHIVE_MAGIC_VALUE_RECURSE)
+	{
+		mpExcludeFiles = new ExcludeList;
+		if (!mpExcludeFiles)
+			throw std::bad_alloc();
+
+		mpExcludeFiles->Deserialize(rArchive);
+	}
+	else
+	{
+		// there is something going on here
+		THROW_EXCEPTION(CommonException, Internal)
+	}
+
+	//
+	//
+	//
+	rArchive.Read(aMagicMarker);
+
+	if (aMagicMarker == ARCHIVE_MAGIC_VALUE_NOOP)
+	{
+		// NOOP
+	}
+	else if (aMagicMarker == ARCHIVE_MAGIC_VALUE_RECURSE)
+	{
+		mpExcludeDirs = new ExcludeList;
+		if (!mpExcludeDirs)
+			throw std::bad_alloc();
+
+		mpExcludeDirs->Deserialize(rArchive);
+	}
+	else
+	{
+		// there is something going on here
+		THROW_EXCEPTION(CommonException, Internal)
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::Location::Serialize(Archive & rArchive)
+//		Purpose: Serializes this object instance into a stream of bytes, using an Archive abstraction.
+//
+//		Created: 2005/04/11
+//
+// --------------------------------------------------------------------------
+void BackupDaemon::Location::Serialize(Archive & rArchive) const
+{
+	//
+	//
+	//
+	rArchive.Write(mName);
+	rArchive.Write(mPath);
+	rArchive.Write(mIDMapIndex);
+
+	//
+	//
+	//
+	if (mpDirectoryRecord.get() == NULL)
+	{
+		int64_t aMagicMarker = ARCHIVE_MAGIC_VALUE_NOOP;
+		rArchive.Write(aMagicMarker);
+	}
+	else
+	{
+		int64_t aMagicMarker = ARCHIVE_MAGIC_VALUE_RECURSE; // be explicit about whether recursion follows
+		rArchive.Write(aMagicMarker);
+
+		mpDirectoryRecord->Serialize(rArchive);
+	}
+
+	//
+	//
+	//
+	if (!mpExcludeFiles)
+	{
+		int64_t aMagicMarker = ARCHIVE_MAGIC_VALUE_NOOP;
+		rArchive.Write(aMagicMarker);
+	}
+	else
+	{
+		int64_t aMagicMarker = ARCHIVE_MAGIC_VALUE_RECURSE; // be explicit about whether recursion follows
+		rArchive.Write(aMagicMarker);
+
+		mpExcludeFiles->Serialize(rArchive);
+	}
+
+	//
+	//
+	//
+	if (!mpExcludeDirs)
+	{
+		int64_t aMagicMarker = ARCHIVE_MAGIC_VALUE_NOOP;
+		rArchive.Write(aMagicMarker);
+	}
+	else
+	{
+		int64_t aMagicMarker = ARCHIVE_MAGIC_VALUE_RECURSE; // be explicit about whether recursion follows
+		rArchive.Write(aMagicMarker);
+
+		mpExcludeDirs->Serialize(rArchive);
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::CommandSocketInfo::CommandSocketInfo()
+//		Purpose: Constructor
+//		Created: 18/2/04
+//
+// --------------------------------------------------------------------------
+BackupDaemon::CommandSocketInfo::CommandSocketInfo()
+	: mpGetLine(0)
+{
+}
+
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::CommandSocketInfo::~CommandSocketInfo()
+//		Purpose: Destructor
+//		Created: 18/2/04
+//
+// --------------------------------------------------------------------------
+BackupDaemon::CommandSocketInfo::~CommandSocketInfo()
+{
+	if(mpGetLine)
+	{
+		delete mpGetLine;
+		mpGetLine = 0;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::SerializeStoreObjectInfo(int64_t aClientStoreMarker, box_time_t theLastSyncTime, box_time_t theNextSyncTime)
+//		Purpose: Serializes remote directory and file information into a stream of bytes, using an Archive abstraction.
+//
+//		Created: 2005/04/11
+//
+// --------------------------------------------------------------------------
+
+static const int STOREOBJECTINFO_MAGIC_ID_VALUE = 0x7777525F;
+static const std::string STOREOBJECTINFO_MAGIC_ID_STRING = "BBACKUPD-STATE";
+static const int STOREOBJECTINFO_VERSION = 1;
+
+void BackupDaemon::SerializeStoreObjectInfo(int64_t aClientStoreMarker, box_time_t theLastSyncTime, box_time_t theNextSyncTime) const
+{
+	if(!GetConfiguration().KeyExists("StoreObjectInfoFile"))
+	{
+		return;
+	}
+
+	std::string StoreObjectInfoFile = 
+		GetConfiguration().GetKeyValue("StoreObjectInfoFile");
+
+	if (StoreObjectInfoFile.size() <= 0)
+	{
+		return;
+	}
+
+	try
+	{
+		FileStream aFile(StoreObjectInfoFile.c_str(), 
+			O_WRONLY | O_CREAT | O_TRUNC);
+		Archive anArchive(aFile, 0);
+
+		anArchive.Write(STOREOBJECTINFO_MAGIC_ID_VALUE);
+		anArchive.Write(STOREOBJECTINFO_MAGIC_ID_STRING); 
+		anArchive.Write(STOREOBJECTINFO_VERSION);
+		anArchive.Write(GetLoadedConfigModifiedTime());
+		anArchive.Write(aClientStoreMarker);
+		anArchive.Write(theLastSyncTime);
+		anArchive.Write(theNextSyncTime);
+
+		//
+		//
+		//
+		int64_t iCount = mLocations.size();
+		anArchive.Write(iCount);
+
+		for (int v = 0; v < iCount; v++)
+		{
+			ASSERT(mLocations[v]);
+			mLocations[v]->Serialize(anArchive);
+		}
+
+		//
+		//
+		//
+		iCount = mIDMapMounts.size();
+		anArchive.Write(iCount);
+
+		for (int v = 0; v < iCount; v++)
+			anArchive.Write(mIDMapMounts[v]);
+
+		//
+		//
+		//
+		aFile.Close();
+		::syslog(LOG_INFO, "Saved store object info file '%s'", 
+			StoreObjectInfoFile.c_str());
+	}
+	catch (...)
+	{
+		::syslog(LOG_WARNING, "Requested store object info file '%s' "
+			"not accessible or could not be created", 
+			StoreObjectInfoFile.c_str());
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::DeserializeStoreObjectInfo(int64_t & aClientStoreMarker, box_time_t & theLastSyncTime, box_time_t & theNextSyncTime)
+//		Purpose: Deserializes remote directory and file information from a stream of bytes, using an Archive abstraction.
+//
+//		Created: 2005/04/11
+//
+// --------------------------------------------------------------------------
+bool BackupDaemon::DeserializeStoreObjectInfo(int64_t & aClientStoreMarker, box_time_t & theLastSyncTime, box_time_t & theNextSyncTime)
+{
+	//
+	//
+	//
+	DeleteAllLocations();
+
+	//
+	//
+	//
+	if(!GetConfiguration().KeyExists("StoreObjectInfoFile"))
+	{
+		return false;
+	}
+
+	std::string StoreObjectInfoFile = 
+		GetConfiguration().GetKeyValue("StoreObjectInfoFile");
+
+	if (StoreObjectInfoFile.size() <= 0)
+	{
+		return false;
+	}
+
+	try
+	{
+		FileStream aFile(StoreObjectInfoFile.c_str(), O_RDONLY);
+		Archive anArchive(aFile, 0);
+
+		//
+		// see if the content looks like a valid serialised archive
+		//
+		int iMagicValue = 0;
+		anArchive.Read(iMagicValue);
+
+		if (iMagicValue != STOREOBJECTINFO_MAGIC_ID_VALUE)
+		{
+			::syslog(LOG_WARNING, "Store object info file '%s' "
+				"is not a valid or compatible serialised "
+				"archive. Will re-cache from store.", 
+				StoreObjectInfoFile.c_str());
+			return false;
+		}
+
+		//
+		// get a bit optimistic and read in a string identifier
+		//
+		std::string strMagicValue;
+		anArchive.Read(strMagicValue);
+
+		if (strMagicValue != STOREOBJECTINFO_MAGIC_ID_STRING)
+		{
+			::syslog(LOG_WARNING, "Store object info file '%s' "
+				"is not a valid or compatible serialised "
+				"archive. Will re-cache from store.", 
+				StoreObjectInfoFile.c_str());
+			return false;
+		}
+
+		//
+		// check if we are loading some future format
+		// version by mistake
+		//
+		int iVersion = 0;
+		anArchive.Read(iVersion);
+
+		if (iVersion != STOREOBJECTINFO_VERSION)
+		{
+			::syslog(LOG_WARNING, "Store object info file '%s' "
+				"version %d unsupported. "
+				"Will re-cache from store.", 
+				StoreObjectInfoFile.c_str(), 
+				iVersion);
+			return false;
+		}
+
+		//
+		// check if this state file is even valid 
+		// for the loaded bbackupd.conf file
+		//
+		box_time_t lastKnownConfigModTime;
+		anArchive.Read(lastKnownConfigModTime);
+
+		if (lastKnownConfigModTime != GetLoadedConfigModifiedTime())
+		{
+			::syslog(LOG_WARNING, "Store object info file '%s' "
+				"out of date. Will re-cache from store", 
+				StoreObjectInfoFile.c_str());
+			return false;
+		}
+
+		//
+		// this is it, go at it
+		//
+		anArchive.Read(aClientStoreMarker);
+		anArchive.Read(theLastSyncTime);
+		anArchive.Read(theNextSyncTime);
+
+		//
+		//
+		//
+		int64_t iCount = 0;
+		anArchive.Read(iCount);
+
+		for (int v = 0; v < iCount; v++)
+		{
+			Location* pLocation = new Location;
+			if (!pLocation)
+				throw std::bad_alloc();
+
+			pLocation->Deserialize(anArchive);
+			mLocations.push_back(pLocation);
+		}
+
+		//
+		//
+		//
+		iCount = 0;
+		anArchive.Read(iCount);
+
+		for (int v = 0; v < iCount; v++)
+		{
+			std::string strItem;
+			anArchive.Read(strItem);
+
+			mIDMapMounts.push_back(strItem);
+		}
+
+		//
+		//
+		//
+		aFile.Close();
+		::syslog(LOG_INFO, "Loaded store object info file '%s', "
+			"version [%d]", StoreObjectInfoFile.c_str(), 
+			iVersion);
+
+		return true;
+	}
+	catch (...)
+	{
+		DeleteAllLocations();
+
+		aClientStoreMarker = 
+			BackupClientContext::ClientStoreMarker_NotKnown;
+		theLastSyncTime = 0;
+		theNextSyncTime = 0;
+
+		::syslog(LOG_WARNING, "Requested store object info file '%s' "
+			"does not exist, not accessible, or inconsistent. "
+			"Will re-cache from store.", 
+			StoreObjectInfoFile.c_str());
+	}
+
+	return false;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    BackupDaemon::DeleteStoreObjectInfo()
+//		Purpose: Deletes the serialised state file, to prevent us
+//			 from using it again if a backup is interrupted.
+//
+//		Created: 2006/02/12
+//
+// --------------------------------------------------------------------------
+
+bool BackupDaemon::DeleteStoreObjectInfo() const
+{
+	if(!GetConfiguration().KeyExists("StoreObjectInfoFile"))
+	{
+		return false;
+	}
+
+	std::string StoreObjectInfoFile = 
+		GetConfiguration().GetKeyValue("StoreObjectInfoFile");
+
+	if (::unlink(StoreObjectInfoFile.c_str()) != 0)
+	{
+		::syslog(LOG_ERR, "Failed to delete the old "
+			"store object info file '%s': %s",
+			StoreObjectInfoFile.c_str(), strerror(errno));
+		return false;
+	}
+
+	return true;
+}
diff --git a/bin/bbackupd/BackupDaemon.h b/bin/bbackupd/BackupDaemon.h
new file mode 100644
index 00000000..3b63ae3d
--- /dev/null
+++ b/bin/bbackupd/BackupDaemon.h
@@ -0,0 +1,227 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    BackupDaemon.h
+//		Purpose: Backup daemon
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+
+#ifndef BACKUPDAEMON__H
+#define BACKUPDAEMON__H
+
+#include <vector>
+#include <string>
+#include <memory>
+
+#include "BoxTime.h"
+#include "Daemon.h"
+#include "Socket.h"
+#include "SocketListen.h"
+#include "SocketStream.h"
+#ifdef WIN32
+	#include "WinNamedPipeStream.h"
+#endif
+
+class BackupClientDirectoryRecord;
+class BackupClientContext;
+class Configuration;
+class BackupClientInodeToIDMap;
+class ExcludeList;
+class IOStreamGetLine;
+class Archive;
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    BackupDaemon
+//		Purpose: Backup daemon
+//		Created: 2003/10/08
+//
+// --------------------------------------------------------------------------
+class BackupDaemon : public Daemon
+{
+public:
+	BackupDaemon();
+	~BackupDaemon();
+
+private:
+	// methods below do partial (specialized) serialization of client state only
+	void SerializeStoreObjectInfo(int64_t aClientStoreMarker, box_time_t theLastSyncTime, box_time_t theNextSyncTime) const;
+	bool DeserializeStoreObjectInfo(int64_t & aClientStoreMarker, box_time_t & theLastSyncTime, box_time_t & theNextSyncTime);
+	bool DeleteStoreObjectInfo() const;
+	BackupDaemon(const BackupDaemon &);
+public:
+
+	void Run();
+	virtual const char *DaemonName() const;
+	virtual const char *DaemonBanner() const;
+	const ConfigurationVerify *GetConfigVerify() const;
+
+	bool FindLocationPathName(const std::string &rLocationName, std::string &rPathOut) const;
+
+	enum
+	{
+		// Add stuff to this, make sure the textual equivalents in SetState() are changed too.
+		State_Initialising = -1,
+		State_Idle = 0,
+		State_Connected = 1,
+		State_Error = 2,
+		State_StorageLimitExceeded = 3
+	};
+
+	int GetState() {return mState;}
+
+	// Allow other classes to call this too
+	enum
+	{
+		NotifyEvent_StoreFull = 0,
+		NotifyEvent_ReadError = 1,
+		NotifyEvent__MAX = 1
+		// When adding notifications, remember to add strings to NotifySysadmin()
+	};
+	void NotifySysadmin(int Event);
+
+private:
+	void Run2();
+
+	void DeleteAllLocations();
+	void SetupLocations(BackupClientContext &rClientContext, const Configuration &rLocationsConf);
+
+	void DeleteIDMapVector(std::vector<BackupClientInodeToIDMap *> &rVector);
+	void DeleteAllIDMaps()
+	{
+		DeleteIDMapVector(mCurrentIDMaps);
+		DeleteIDMapVector(mNewIDMaps);
+	}
+	void FillIDMapVector(std::vector<BackupClientInodeToIDMap *> &rVector, bool NewMaps);
+	
+	void SetupIDMapsForSync();
+	void CommitIDMapsAfterSync();
+	void DeleteCorruptBerkelyDbFiles();
+	
+	void MakeMapBaseName(unsigned int MountNumber, std::string &rNameOut) const;
+
+	void SetState(int State);
+	
+	void WaitOnCommandSocket(box_time_t RequiredDelay, bool &DoSyncFlagOut, bool &SyncIsForcedOut);
+	void CloseCommandConnection();
+	void SendSyncStartOrFinish(bool SendStart);
+	
+	void TouchFileInWorkingDir(const char *Filename);
+
+	void DeleteUnusedRootDirEntries(BackupClientContext &rContext);
+
+#ifdef PLATFORM_CANNOT_FIND_PEER_UID_OF_UNIX_SOCKET
+	// For warning user about potential security hole
+	virtual void SetupInInitialProcess();
+#endif
+
+	int UseScriptToSeeIfSyncAllowed();
+
+private:
+	class Location
+	{
+	public:
+		Location();
+		~Location();
+
+		void Deserialize(Archive & rArchive);
+		void Serialize(Archive & rArchive) const;
+	private:
+		Location(const Location &);	// copy not allowed
+		Location &operator=(const Location &);
+	public:
+		std::string mName;
+		std::string mPath;
+		std::auto_ptr<BackupClientDirectoryRecord> mpDirectoryRecord;
+		int mIDMapIndex;
+		ExcludeList *mpExcludeFiles;
+		ExcludeList *mpExcludeDirs;
+	};
+
+	int mState;		// what the daemon is currently doing
+
+	std::vector<Location *> mLocations;
+	
+	std::vector<std::string> mIDMapMounts;
+	std::vector<BackupClientInodeToIDMap *> mCurrentIDMaps;
+	std::vector<BackupClientInodeToIDMap *> mNewIDMaps;
+	
+	// For the command socket
+	class CommandSocketInfo
+	{
+	public:
+		CommandSocketInfo();
+		~CommandSocketInfo();
+	private:
+		CommandSocketInfo(const CommandSocketInfo &);	// no copying
+		CommandSocketInfo &operator=(const CommandSocketInfo &);
+	public:
+#ifdef WIN32
+		WinNamedPipeStream mListeningSocket;
+#else
+		SocketListen<SocketStream, 1 /* listen backlog */> mListeningSocket;
+		std::auto_ptr<SocketStream> mpConnectedSocket;
+#endif
+		IOStreamGetLine *mpGetLine;
+	};
+	
+	// Using a socket?
+	CommandSocketInfo *mpCommandSocketInfo;
+	
+	// Stop notifications being repeated.
+	bool mNotificationsSent[NotifyEvent__MAX + 1];
+
+	// Unused entries in the root directory wait a while before being deleted
+	box_time_t mDeleteUnusedRootDirEntriesAfter;	// time to delete them
+	std::vector<std::pair<int64_t,std::string> > mUnusedRootDirEntries;
+
+#ifdef WIN32
+	public:
+	void RunHelperThread(void);
+
+	private:
+	bool mDoSyncFlagOut, mSyncIsForcedOut, mReceivedCommandConn;
+#endif
+};
+
+#endif // BACKUPDAEMON__H
diff --git a/bin/bbackupd/Win32BackupService.cpp b/bin/bbackupd/Win32BackupService.cpp
new file mode 100644
index 00000000..96f2b057
--- /dev/null
+++ b/bin/bbackupd/Win32BackupService.cpp
@@ -0,0 +1,89 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// Win32 service functions for Box Backup, by Nick Knight
+
+#ifdef WIN32
+
+#include "Box.h"
+#include "BackupDaemon.h"
+#include "MainHelper.h"
+#include "BoxPortsAndFiles.h"
+#include "BackupStoreException.h"
+
+#include "MemLeakFindOn.h"
+
+#include "Win32BackupService.h"
+
+Win32BackupService gDaemonService;
+extern HANDLE gStopServiceEvent;
+
+unsigned int WINAPI RunService(LPVOID lpParameter)
+{
+	DWORD retVal = gDaemonService.WinService();
+	SetEvent( gStopServiceEvent );
+	return retVal;
+}
+
+void TerminateService(void)
+{
+	gDaemonService.SetTerminateWanted();
+}
+
+DWORD Win32BackupService::WinService(void)
+{
+	int argc = 2;
+	//first off get the path name for the default 
+	char buf[MAX_PATH];
+	
+	GetModuleFileName(NULL, buf, sizeof(buf));
+	std::string buffer(buf);
+	std::string conf( "-c");
+	std::string cfile(buffer.substr(0,(buffer.find("bbackupd.exe"))) 
+			+ "bbackupd.conf");
+
+	const char *argv[] = {conf.c_str(), cfile.c_str()};
+
+	MAINHELPER_START
+
+	return this->Main(BOX_FILE_BBACKUPD_DEFAULT_CONFIG, argc, argv);
+
+	MAINHELPER_END
+}
+
+#endif // WIN32
diff --git a/bin/bbackupd/Win32BackupService.h b/bin/bbackupd/Win32BackupService.h
new file mode 100644
index 00000000..980e5d6c
--- /dev/null
+++ b/bin/bbackupd/Win32BackupService.h
@@ -0,0 +1,59 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// Box Backup service daemon implementation by Nick Knight
+
+#ifndef WIN32BACKUPSERVICE_H
+#define WIN32BACKUPSERVICE_H
+
+#ifdef WIN32
+
+class Configuration;
+class ConfigurationVerify;
+class BackupDaemon;
+
+class Win32BackupService : public BackupDaemon
+{
+public:
+	DWORD WinService(void);
+};
+
+#endif // WIN32
+
+#endif // WIN32BACKUPSERVICE_H
+
diff --git a/bin/bbackupd/Win32ServiceFunctions.cpp b/bin/bbackupd/Win32ServiceFunctions.cpp
new file mode 100644
index 00000000..07791af3
--- /dev/null
+++ b/bin/bbackupd/Win32ServiceFunctions.cpp
@@ -0,0 +1,313 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+//***************************************************************
+// From the book "Win32 System Services: The Heart of Windows 98
+// and Windows 2000"
+// by Marshall Brain
+// Published by Prentice Hall
+// Copyright 1995 Prentice Hall.
+//
+// This code implements the Windows API Service interface 
+// for the Box Backup for Windows native port.
+// Adapted for Box Backup by Nick Knight.
+//***************************************************************
+
+#ifdef WIN32
+
+#include "Box.h"
+
+#ifdef HAVE_UNISTD_H
+	#include <unistd.h>
+#endif
+#ifdef HAVE_PROCESS_H
+	#include <process.h>
+#endif
+
+extern void TerminateService(void);
+extern unsigned int WINAPI RunService(LPVOID lpParameter);
+
+// Global variables
+
+TCHAR* gServiceName = TEXT("Box Backup Service");
+SERVICE_STATUS gServiceStatus;
+SERVICE_STATUS_HANDLE gServiceStatusHandle = 0;
+HANDLE gStopServiceEvent = 0;
+
+#define SERVICE_NAME "boxbackup"
+
+void ShowMessage(char *s)
+{
+	MessageBox(0, s, "Box Backup Message", 
+		MB_OK | MB_SETFOREGROUND | MB_DEFAULT_DESKTOP_ONLY);
+}
+
+void ErrorHandler(char *s, DWORD err)
+{
+	char buf[256];
+	memset(buf, 0, sizeof(buf));
+	_snprintf(buf, sizeof(buf)-1, "%s (%d)", s, err);
+	::syslog(LOG_ERR, "%s", buf);
+	MessageBox(0, buf, "Error", 
+		MB_OK | MB_SETFOREGROUND | MB_DEFAULT_DESKTOP_ONLY);
+	ExitProcess(err);
+}
+
+void WINAPI ServiceControlHandler( DWORD controlCode )
+{
+	switch ( controlCode )
+	{
+		case SERVICE_CONTROL_INTERROGATE:
+			break;
+
+		case SERVICE_CONTROL_SHUTDOWN:
+		case SERVICE_CONTROL_STOP:
+			Beep(1000,100);
+			TerminateService();
+			gServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
+			SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
+
+			SetEvent(gStopServiceEvent);
+			return;
+
+		case SERVICE_CONTROL_PAUSE:
+			break;
+
+		case SERVICE_CONTROL_CONTINUE:
+			break;
+
+		default:
+			if ( controlCode >= 128 && controlCode <= 255 )
+				// user defined control code
+				break;
+			else
+				// unrecognised control code
+				break;
+	}
+
+	SetServiceStatus( gServiceStatusHandle, &gServiceStatus );
+}
+
+// ServiceMain is called when the SCM wants to
+// start the service. When it returns, the service
+// has stopped. It therefore waits on an event
+// just before the end of the function, and
+// that event gets set when it is time to stop. 
+// It also returns on any error because the
+// service cannot start if there is an eror.
+
+VOID ServiceMain(DWORD argc, LPTSTR *argv) 
+{
+    // initialise service status
+    gServiceStatus.dwServiceType = SERVICE_WIN32;
+    gServiceStatus.dwCurrentState = SERVICE_STOPPED;
+    gServiceStatus.dwControlsAccepted = 0;
+    gServiceStatus.dwWin32ExitCode = NO_ERROR;
+    gServiceStatus.dwServiceSpecificExitCode = NO_ERROR;
+    gServiceStatus.dwCheckPoint = 0;
+    gServiceStatus.dwWaitHint = 0;
+
+    gServiceStatusHandle = RegisterServiceCtrlHandler(gServiceName, 
+	ServiceControlHandler);
+
+    if (gServiceStatusHandle)
+    {
+        // service is starting
+        gServiceStatus.dwCurrentState = SERVICE_START_PENDING;
+        SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
+
+        // do initialisation here
+        gStopServiceEvent = CreateEvent( 0, TRUE, FALSE, 0 );
+		if (!gStopServiceEvent)
+		{
+			gServiceStatus.dwControlsAccepted &= 
+				~(SERVICE_ACCEPT_STOP | 
+				  SERVICE_ACCEPT_SHUTDOWN);
+			gServiceStatus.dwCurrentState = SERVICE_STOPPED;
+			SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
+			return;
+		}
+
+		HANDLE ourThread = (HANDLE)_beginthreadex(
+			NULL,
+			0,
+			RunService,
+			0,
+			CREATE_SUSPENDED,
+			NULL);
+
+		SetThreadPriority(ourThread, THREAD_PRIORITY_LOWEST);
+		ResumeThread(ourThread);
+
+		// we are now running so tell the SCM
+		gServiceStatus.dwControlsAccepted |= 
+		(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
+		gServiceStatus.dwCurrentState = SERVICE_RUNNING;
+		SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
+
+		// do cleanup here
+		WaitForSingleObject(gStopServiceEvent, INFINITE);
+		CloseHandle(gStopServiceEvent);
+		gStopServiceEvent = 0;
+
+		// service was stopped
+		gServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
+		SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
+
+		// service is now stopped
+		gServiceStatus.dwControlsAccepted &= 
+			~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);
+		gServiceStatus.dwCurrentState = SERVICE_STOPPED;
+		SetServiceStatus(gServiceStatusHandle, &gServiceStatus);
+    }
+}
+
+void OurService(void)
+{
+	SERVICE_TABLE_ENTRY serviceTable[] = 
+	{ 
+		{ SERVICE_NAME, (LPSERVICE_MAIN_FUNCTION) ServiceMain },
+		{ NULL, NULL }
+	};
+	BOOL success;
+
+	// Register with the SCM
+	success = StartServiceCtrlDispatcher(serviceTable);
+
+	if (!success)
+	{
+		ErrorHandler("Failed to start service. Did you start "
+			"Box Backup from the Service Control Manager? "
+			"(StartServiceCtrlDispatcher)", GetLastError());
+	}
+}
+
+void InstallService(void)
+{
+	SC_HANDLE newService, scm;
+
+	scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);
+
+	if (!scm) 
+	{
+		syslog(LOG_ERR, "Failed to open service control manager: "
+			"error %d", GetLastError());
+		return;
+	}
+
+	char cmd[MAX_PATH];
+	GetModuleFileName(NULL, cmd, sizeof(cmd)-1);
+	cmd[sizeof(cmd)-1] = 0;
+
+	char cmd_args[MAX_PATH];
+	_snprintf(cmd_args, sizeof(cmd_args)-1, "%s --service", cmd);
+	cmd_args[sizeof(cmd_args)-1] = 0;
+
+	newService = CreateService(
+		scm, 
+		SERVICE_NAME, 
+		"Box Backup", 
+		SERVICE_ALL_ACCESS, 
+		SERVICE_WIN32_OWN_PROCESS, 
+		SERVICE_AUTO_START, 
+		SERVICE_ERROR_NORMAL, 
+		cmd_args, 
+		0,0,0,0,0);
+
+	if (!newService) 
+	{
+		::syslog(LOG_ERR, "Failed to create Box Backup service: "
+			"error %d", GetLastError());
+		return;
+	}
+
+	::syslog(LOG_INFO, "Created Box Backup service");
+	
+	SERVICE_DESCRIPTION desc;
+	desc.lpDescription = "Backs up your data files over the Internet";
+	
+	if (!ChangeServiceConfig2(newService, SERVICE_CONFIG_DESCRIPTION,
+		&desc))
+	{
+		::syslog(LOG_WARNING, "Failed to set description for "
+			"Box Backup service: error %d", GetLastError());
+	}
+
+	CloseServiceHandle(newService);
+	CloseServiceHandle(scm);
+}
+
+void RemoveService(void)
+{
+	SC_HANDLE service, scm;
+	SERVICE_STATUS status;
+
+	scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);
+
+	if (!scm) 
+	{
+		syslog(LOG_ERR, "Failed to open service control manager: "
+			"error %d", GetLastError());
+		return;
+	}
+
+	service = OpenService(scm, SERVICE_NAME, SERVICE_ALL_ACCESS|DELETE);
+	ControlService(service, SERVICE_CONTROL_STOP, &status);
+
+	if (!service)
+	{
+		syslog(LOG_ERR, "Failed to open Box Backup service: "
+			"error %d", GetLastError());
+		return;
+	}
+
+	if (DeleteService(service))
+	{
+		syslog(LOG_INFO, "Box Backup service deleted");
+	}
+	else
+	{
+		syslog(LOG_ERR, "Failed to remove Box Backup service: "
+			"error %d", GetLastError());
+	}
+
+	CloseServiceHandle(service);
+	CloseServiceHandle(scm);
+}
+
+#endif // WIN32
diff --git a/bin/bbackupd/Win32ServiceFunctions.h b/bin/bbackupd/Win32ServiceFunctions.h
new file mode 100644
index 00000000..98856ca1
--- /dev/null
+++ b/bin/bbackupd/Win32ServiceFunctions.h
@@ -0,0 +1,57 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+//***************************************************************
+// From the book "Win32 System Services: The Heart of Windows 98
+// and Windows 2000"
+// by Marshall Brain
+// Published by Prentice Hall
+// Copyright 1995 Prentice Hall.
+//
+// This code implements the Windows API Service interface
+// for the Box Backup for Windows native port.
+//***************************************************************
+
+#ifndef WIN32SERVICEFUNCTIONS_H
+#define WIN32SERVICEFUNCTIONS_H
+
+void RemoveService(void);
+void InstallService(void);
+void OurService(void);
+
+#endif
diff --git a/bin/bbackupd/bbackupd-config b/bin/bbackupd/bbackupd-config
new file mode 100755
index 00000000..082a870f
--- /dev/null
+++ b/bin/bbackupd/bbackupd-config
@@ -0,0 +1,571 @@
+#!/usr/bin/perl
+# distribution boxbackup-0.10 (svn version: 494)
+#  
+# Copyright (c) 2003 - 2006
+#      Ben Summers and contributors.  All rights reserved.
+#  
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. All use of this software and associated advertising materials must 
+#    display the following acknowledgment:
+#        This product includes software developed by Ben Summers.
+# 4. The names of the Authors may not be used to endorse or promote
+#    products derived from this software without specific prior written
+#    permission.
+# 
+# [Where legally impermissible the Authors do not disclaim liability for 
+# direct physical injury or death caused solely by defects in the software 
+# unless it is modified by a third party.]
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#  
+#  
+#  
+use strict;
+
+# should be running as root
+if($> != 0)
+{
+	printf "\nWARNING: this should be run as root\n\n"
+}
+
+sub error_print_usage
+{
+	print <<__E;
+
+Setup bbackupd config utility.
+
+Bad command line parameters.
+Usage:
+	bbackupd-config config-dir backup-mode account-num server-hostname working-dir backup-dir [more backup directories]
+
+config-dir usually /etc/boxbackup
+backup-mode is lazy or snapshot
+    lazy mode runs continously, uploading files over a specified age
+    snapshot mode uploads a snapshot of the filesystem when instructed explicitly
+account-num (hexdecimal) and server-hostname as supplied from the server administrator
+working-dir usually /var/bbackupd
+backup-dir, list of directories to back up
+
+__E
+	print "=========\nERROR:\n",$_[0],"\n\n" if $_[0] ne '';
+	exit(1);
+}
+
+# check and get command line parameters
+if($#ARGV < 4)
+{
+	error_print_usage();
+}
+
+# check for OPENSSL_CONF environment var being set
+if(exists $ENV{'OPENSSL_CONF'})
+{
+	print <<__E;
+
+---------------------------------------
+
+WARNING:
+    You have the OPENSSL_CONF environment variable set.
+    Use of non-standard openssl configs may cause problems.
+
+---------------------------------------
+
+__E
+}
+
+# default locations
+my $default_config_location = '/etc/boxbackup/bbackupd.conf';
+
+# command line parameters
+my ($config_dir,$backup_mode,$account_num,$server,$working_dir,@tobackup) = @ARGV;
+
+# check backup mode is valid
+if($backup_mode ne 'lazy' && $backup_mode ne 'snapshot')
+{
+	error_print_usage("ERROR: backup mode must be 'lazy' or 'snapshot'");
+}
+
+# check server exists
+{
+	my @r = gethostbyname($server);
+	if($#r < 0)
+	{
+		error_print_usage("Backup server specified as '$server', but it could not found.\n(A test DNS lookup failed -- check arguments)");
+	}
+}
+
+if($working_dir !~ m~\A/~)
+{
+	error_print_usage("Working directory $working_dir is not specified as an absolute path");
+}
+
+# ssl stuff
+my $private_key = "$config_dir/bbackupd/$account_num-key.pem";
+my $certificate_request = "$config_dir/bbackupd/$account_num-csr.pem";
+my $certificate = "$config_dir/bbackupd/$account_num-cert.pem";
+my $ca_root_cert = "$config_dir/bbackupd/serverCA.pem";
+
+# encryption keys
+my $enc_key_file = "$config_dir/bbackupd/$account_num-FileEncKeys.raw";
+
+# other files
+my $config_file = "$config_dir/bbackupd.conf";
+my $notify_script = "$config_dir/bbackupd/NotifySysadmin.sh";
+
+# check that the directories are allowable
+for(@tobackup)
+{
+	if($_ eq '/')
+	{
+		die "It is not recommended that you backup the root directory of your disc";
+	}
+	if($_ !~ m/\A\//)
+	{
+		die "Directory $_ is not specified as an absolute path";
+	}
+	if(!-d $_)
+	{
+		die "$_ is not a directory";
+	}
+}
+
+# summarise configuration
+
+print <<__E;
+
+Setup bbackupd config utility.
+
+Configuration:
+   Writing configuration file: $config_file
+   Account: $account_num
+   Server hostname: $server
+   Directories to back up:
+__E
+print '      ',$_,"\n" for(@tobackup);
+print <<__E;
+
+Note: If other file systems are mounted inside these directories, then problems may occur
+with files on the store server being renamed incorrectly. This will cause efficiency
+problems, but not affect the integrity of the backups.
+
+WARNING: Directories not checked against mountpoints. Check mounted filesystems manually.
+
+__E
+
+# create directories
+if(!-d $config_dir)
+{
+	printf "Creating $config_dir...\n";
+	mkdir $config_dir,0755 or die "Can't create $config_dir";
+}
+
+if(!-d "$config_dir/bbackupd")
+{
+	printf "Creating $config_dir/bbackupd\n";
+	mkdir "$config_dir/bbackupd",0700 or die "Can't create $config_dir/bbackupd";
+}
+
+if(!-d "$working_dir")
+{
+	printf "Creating $working_dir\n";
+	if(!mkdir($working_dir,0700))
+	{
+		die "Couldn't create $working_dir -- create this manually and try again\n";
+	}
+}
+
+# generate the private key for the server
+if(!-f $private_key)
+{
+	print "Generating private key...\n";
+	if(system("openssl genrsa -out $private_key 2048") != 0)
+	{
+		die "Couldn't generate private key."
+	}
+}
+
+# generate a certificate request
+if(!-f $certificate_request)
+{
+	die "Couldn't run openssl for CSR generation" unless
+		open(CSR,"|openssl req -new -key $private_key -sha1 -out $certificate_request");
+	print CSR <<__E;
+.
+.
+.
+.
+.
+BACKUP-$account_num
+.
+.
+.
+
+__E
+	close CSR;
+	print "\n\n";
+	die "Certificate request wasn't created.\n" unless -f $certificate_request
+}
+
+# generate the key material for the file
+if(!-f $enc_key_file)
+{
+	print "Generating keys for file backup\n";
+	if(system("openssl rand -out $enc_key_file 1024") != 0)
+	{
+		die "Couldn't generate file backup keys."
+	}
+}
+
+# write the notify when store full script
+print "Writing notify script $notify_script\n";
+open NOTIFY,">$notify_script" or die "Can't open for writing";
+
+my $hostname = `hostname`; chomp $hostname;
+my $current_username = `whoami`; chomp $current_username;
+my $sendmail = `whereis sendmail`; chomp $sendmail;
+$sendmail =~ s/\n.\Z//s;
+# for Linux style whereis
+$sendmail = $1 if $sendmail =~ /^sendmail:\s+([\S]+)/;
+# last ditch guess
+$sendmail = 'sendmail' if $sendmail !~ m/\S/;
+
+print NOTIFY <<__EOS;
+#!/bin/sh
+
+SUBJECT="BACKUP PROBLEM on host $hostname"
+SENDTO="$current_username"
+
+if [ \$1 = store-full ]
+then
+$sendmail \$SENDTO <<EOM
+Subject: \$SUBJECT (store full)
+To: \$SENDTO
+
+
+The store account for $hostname is full.
+
+=============================
+FILES ARE NOT BEING BACKED UP
+=============================
+
+Please adjust the limits on account $account_num on server $server.
+
+EOM
+elif [ \$1 = read-error ]
+then
+$sendmail \$SENDTO <<EOM
+Subject: \$SUBJECT (read errors)
+To: \$SENDTO
+
+
+Errors occured reading some files or directories for backup on $hostname.
+
+===================================
+THESE FILES ARE NOT BEING BACKED UP
+===================================
+
+Check the logs on $hostname for the files and directories which caused
+these errors, and take appropraite action.
+
+Other files are being backed up.
+
+EOM
+else
+$sendmail \$SENDTO <<EOM
+Subject: \$SUBJECT (unknown)
+To: \$SENDTO
+
+
+The backup daemon on $hostname reported an unknown error.
+
+==========================
+FILES MAY NOT BE BACKED UP
+==========================
+
+Please check the logs on $hostname.
+
+EOM
+fi
+__EOS
+
+close NOTIFY;
+chmod 0700,$notify_script or die "Can't chmod $notify_script";
+
+
+# write the configuration file
+print "Writing configuration file $config_file\n";
+open CONFIG,">$config_file" or die "Can't open config file for writing";
+print CONFIG <<__E;
+
+StoreHostname = $server
+AccountNumber = 0x$account_num
+KeysFile = $enc_key_file
+
+CertificateFile = $certificate
+PrivateKeyFile = $private_key
+TrustedCAsFile = $ca_root_cert
+
+DataDirectory = $working_dir
+
+
+# This script is run whenever bbackupd encounters a problem which requires
+# the system administrator to assist:
+# 1) The store is full, and no more data can be uploaded.
+# 2) Some files or directories were not readable.
+# The default script emails the system administrator.
+
+NotifyScript = $notify_script
+
+__E
+
+if($backup_mode eq 'lazy')
+{
+	# lazy mode configuration
+	print CONFIG <<__E;
+
+# A scan of the local discs will be made once an hour (approximately).
+# To avoid cycles of load on the server, this time is randomly adjusted by a small
+# percentage as the daemon runs.
+
+UpdateStoreInterval = 3600
+
+
+# A file must have been modified at least 6 hours ago before it will be uploaded.
+
+MinimumFileAge = 21600
+
+
+# If a file is modified repeated, it won't be uploaded immediately in case it's modified again.
+# However, it should be uploaded eventually. This is how long we should wait after first noticing
+# a change. (1 day)
+
+MaxUploadWait = 86400
+
+__E
+}
+else
+{
+	# snapshot configuration
+	print CONFIG <<__E;
+
+# This configuration file is written for snapshot mode.
+# You will need to run bbackupctl to instruct the daemon to upload files.
+
+AutomaticBackup = no
+UpdateStoreInterval = 0
+MinimumFileAge = 0
+MaxUploadWait = 0
+
+__E
+}
+
+print CONFIG <<__E;
+
+# Files above this size (in bytes) are tracked, and if they are renamed they will simply be
+# renamed on the server, rather than being uploaded again. (64k - 1)
+
+FileTrackingSizeThreshold = 65535
+
+
+# The daemon does "changes only" uploads for files above this size (in bytes).
+# Files less than it are uploaded whole without this extra processing.
+
+DiffingUploadSizeThreshold = 8192
+
+
+# The limit on how much time is spent diffing files. Most files shouldn't take very long,
+# but if you have really big files you can use this to limit the time spent diffing them.
+# * Reduce if you are having problems with processor usage.
+# * Increase if you have large files, and think the upload of changes is too large and want
+#   to spend more time searching for unchanged blocks.
+
+MaximumDiffingTime = 20
+
+
+# Uncomment this line to see exactly what the daemon is going when it's connected to the server.
+
+# ExtendedLogging = yes
+
+
+# Use this to temporarily stop bbackupd from syncronising or connecting to the store.
+# This specifies a program or script script which is run just before each sync, and ideally
+# the full path to the interpreter. It will be run as the same user bbackupd is running as,
+# usually root.
+# The script prints either "now" or a number to STDOUT (and a terminating newline, no quotes).
+# If the result was "now", then the sync will happen. If it's a number, then the script will
+# be asked again in that number of seconds.
+# For example, you could use this on a laptop to only backup when on a specific network.
+
+# SyncAllowScript = /path/to/intepreter/or/exe script-name parameters etc
+
+
+# Where the command socket is created in the filesystem.
+
+CommandSocket = /var/run/bbackupd.sock
+
+# Uncomment the StoreObjectInfoFile to enable the experimental archiving
+# of the daemon's state (including client store marker and configuration)
+# between backup runs. This saves time and increases efficiency when
+# bbackupd is frequently stopped and started, since it removes the need
+# to rescan all directories on the remote server. However, it is new and
+# not yet heavily tested, so use with caution.
+
+# StoreObjectInfoFile = $working_dir/bbackupd.state
+
+Server
+{
+	PidFile = /var/run/bbackupd.pid
+}
+
+# 
+# BackupLocations specifies which locations on disc should be backed up. Each
+# directory is in the format
+# 
+# 	name
+# 	{
+# 		Path = /path/of/directory
+# 		(optional exclude directives)
+# 	}
+# 
+# 'name' is derived from the Path by the config script, but should merely be
+# unique.
+# 
+# The exclude directives are of the form
+# 
+# 	[Exclude|AlwaysInclude][File|Dir][|sRegex] = regex or full pathname
+# 
+# (The regex suffix is shown as 'sRegex' to make File or Dir plural)
+#
+# For example:
+# 
+# 	ExcludeDir = /home/guest-user
+# 	ExcludeFilesRegex = *.(mp3|MP3)\$
+# 	AlwaysIncludeFile = /home/username/veryimportant.mp3
+# 
+# This excludes the directory /home/guest-user from the backup along with all mp3
+# files, except one MP3 file in particular.
+# 
+# In general, Exclude excludes a file or directory, unless the directory is
+# explicitly mentioned in a AlwaysInclude directive.
+# 
+# If a directive ends in Regex, then it is a regular expression rather than a
+# explicit full pathname. See
+# 
+# 	man 7 re_format
+# 
+# for the regex syntax on your platform.
+# 
+
+BackupLocations
+{
+__E
+
+# write the dirs to backup
+for my $d (@tobackup)
+{
+	$d =~ m/\A.(.+)\Z/;
+	my $n = $1;
+	$n =~ tr`/`-`;
+	
+	my $excludekeys = '';
+	if(substr($enc_key_file, 0, length($d)+1) eq $d.'/')
+	{
+		$excludekeys = "\t\tExcludeFile = $enc_key_file\n";
+		print <<__E;
+
+NOTE: Keys file has been explicitly excluded from the backup.
+
+__E
+	}
+	
+	print CONFIG <<__E
+	$n
+	{
+		Path = $d
+$excludekeys	}
+__E
+}
+
+print CONFIG "}\n\n";
+close CONFIG;
+
+# explain to the user what they need to do next
+my $daemon_args = ($config_file eq $default_config_location)?'':" $config_file";
+my $ctl_daemon_args = ($config_file eq $default_config_location)?'':" -c $config_file";
+
+print <<__E;
+
+===================================================================
+
+bbackupd basic configuration complete.
+
+What you need to do now...
+
+1) Make a backup of $enc_key_file
+   This should be a secure offsite backup.
+   Without it, you cannot restore backups. Everything else can
+   be replaced. But this cannot.
+   KEEP IT IN A SAFE PLACE, OTHERWISE YOUR BACKUPS ARE USELESS.
+
+2) Send $certificate_request
+   to the administrator of the backup server, and ask for it to
+   be signed.
+
+3) The administrator will send you two files. Install them as
+      $certificate
+      $ca_root_cert
+   after checking their authenticity.
+
+4) You may wish to read the configuration file
+      $config_file
+   and adjust as appropraite.
+   
+   There are some notes in it on excluding files you do not
+   wish to be backed up.
+
+5) Review the script
+      $notify_script
+   and check that it will email the right person when the store
+   becomes full. This is important -- when the store is full, no
+   more files will be backed up. You want to know about this.
+
+6) Start the backup daemon with the command
+      /usr/local/bin/bbackupd$daemon_args
+   in /etc/rc.local, or your local equivalent.
+   Note that bbackupd must run as root.
+__E
+if($backup_mode eq 'snapshot')
+{
+	print <<__E;
+
+7) Set up a cron job to run whenever you want a snapshot of the
+   file system to be taken. Run the command
+      /usr/local/bin/bbackupctl -q$ctl_daemon_args sync
+__E
+}
+print <<__E;
+
+===================================================================
+
+Remember to make a secure, offsite backup of your backup keys,
+as described in step 1 above. If you do not, you have no backups.
+
+__E
+
diff --git a/bin/bbackupd/bbackupd.cpp b/bin/bbackupd/bbackupd.cpp
new file mode 100644
index 00000000..1ccfc7f8
--- /dev/null
+++ b/bin/bbackupd/bbackupd.cpp
@@ -0,0 +1,138 @@
+// distribution boxbackup-0.10 (svn version: 494)
+//  
+// Copyright (c) 2003 - 2006
+//      Ben Summers and contributors.  All rights reserved.
+//  
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 3. All use of this software and associated advertising materials must 
+//    display the following acknowledgment:
+//        This product includes software developed by Ben Summers.
+// 4. The names of the Authors may not be used to endorse or promote
+//    products derived from this software without specific prior written
+//    permission.
+// 
+// [Where legally impermissible the Authors do not disclaim liability for 
+// direct physical injury or death caused solely by defects in the software 
+// unless it is modified by a third party.]
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//  
+//  
+//  
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    bbackupd.cpp
+//		Purpose: main file for backup daemon
+//		Created: 2003/10/11
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+#include "BackupDaemon.h"
+#include "MainHelper.h"
+#include "BoxPortsAndFiles.h"
+#include "BackupStoreException.h"
+
+#include "MemLeakFindOn.h"
+
+#ifdef WIN32
+	#include "Win32ServiceFunctions.h"
+	#include "Win32BackupService.h"
+
+	extern Win32BackupService gDaemonService;
+#endif
+
+int main(int argc, const char *argv[])
+{
+	MAINHELPER_START
+
+#ifdef WIN32
+
+	::openlog("Box Backup (bbackupd)", 0, 0);
+
+	if(argc == 2 &&
+		(::strcmp(argv[1], "--help") == 0 ||
+		 ::strcmp(argv[1], "-h") == 0))
+	{
+		printf("-h help, -i install service, -r remove service,\n"
+			"-c <config file> start daemon now");
+		return 2;
+	}
+	if(argc == 2 && ::strcmp(argv[1], "-r") == 0)
+	{
+		RemoveService();
+		return 0;
+	}
+	if(argc == 2 && ::strcmp(argv[1], "-i") == 0)
+	{
+		InstallService();
+		return 0;
+	}
+
+	bool runAsWin32Service = false;
+	if (argc == 2 && ::strcmp(argv[1], "--service") == 0)
+	{
+		runAsWin32Service = true;
+	}
+	
+	// Under win32 we must initialise the Winsock library
+	// before using sockets
+		
+	WSADATA info;
+
+	if (WSAStartup(0x0101, &info) == SOCKET_ERROR) 
+	{
+		// box backup will not run without sockets
+		::syslog(LOG_ERR, "Failed to initialise Windows Sockets");
+		THROW_EXCEPTION(BackupStoreException, Internal)
+	}
+
+	EnableBackupRights();
+
+	int ExitCode = 0;
+
+	if (runAsWin32Service)
+	{
+		syslog(LOG_INFO,"Starting Box Backup Service");
+		OurService();
+	}
+	else
+	{
+		ExitCode = gDaemonService.Main(
+			BOX_FILE_BBACKUPD_DEFAULT_CONFIG, argc, argv);
+	}
+
+	// Clean up our sockets
+	WSACleanup();
+
+	::closelog();
+
+	return ExitCode;
+
+#else // !WIN32
+
+	BackupDaemon daemon;
+	return daemon.Main(BOX_FILE_BBACKUPD_DEFAULT_CONFIG, argc, argv);
+
+#endif // WIN32
+
+	MAINHELPER_END
+}
diff --git a/bin/bbackupd/win32/ReadMe.txt b/bin/bbackupd/win32/ReadMe.txt
new file mode 100644
index 00000000..3d260750
--- /dev/null
+++ b/bin/bbackupd/win32/ReadMe.txt
@@ -0,0 +1,24 @@
+Upgrade instructions
+
+Version 0.09g to 0.09h
+
+This version included patches to the server as well. The server for this 
+upgrade can be found at http://home.earthlink.net/~gniemcew/ but hopefully 
+will be merged into the core in the next release.
+
+New values in the bbackupd.conf can now be added:
+
+StoreObjectInfoFile = C:\Program Files\Box Backup\bbackupd\bbackupd.dat
+
+This stores the state when a backup daemon is shutdown.
+
+KeepAliveTime = 250
+
+This is imperative if MaximumDiffingTime is larger than 300, this stops the ssl 
+layer timing out when a diff is performed. It is wise to set MaximumDiffingTime 
+long enough for the largest file you may have. If you do not wish to upgrade your 
+server then make KeepAliveTime greater than MaximumDiffingTime.
+
+Have fun
+
+Nick
diff --git a/bin/bbackupd/win32/bbackupd.conf b/bin/bbackupd/win32/bbackupd.conf
new file mode 100644
index 00000000..85915520
--- /dev/null
+++ b/bin/bbackupd/win32/bbackupd.conf
@@ -0,0 +1,143 @@
+
+StoreHostname = yourhost
+AccountNumber = 0x1
+KeysFile = C:\Program Files\Box Backup\1-FileEncKeys.raw
+
+CertificateFile = C:\Program Files\Box Backup\1-cert.pem
+PrivateKeyFile = C:\Program Files\Box Backup\1-key.pem
+TrustedCAsFile = C:\Program Files\Box Backup\serverCA.pem
+
+DataDirectory = C:\Program Files\Box Backup\bbackupd
+
+# If you do not install it in the default location - also do not forget to 
+# change the pid file location (below)
+
+
+# This script is run whenever bbackupd encounters a problem which requires
+# the system administrator to assist:
+# 1) The store is full, and no more data can be uploaded.
+# 2) Some files or directories were not readable.
+# The default script emails the system administrator.
+
+# NotifyScript = NotifySysadmin.sh
+
+
+# A scan of the local discs will be made once an hour (approximately).
+# To avoid cycles of load on the server, this time is randomly adjusted by a small
+# percentage as the daemon runs.
+
+UpdateStoreInterval = 3600
+
+
+# A file must have been modified at least 6 hours ago before it will be uploaded.
+
+MinimumFileAge = 21600
+
+
+# If a file is modified repeated, it won't be uploaded immediately in case it's modified again.
+# However, it should be uploaded eventually. This is how long we should wait after first noticing
+# a change. (1 day)
+
+MaxUploadWait = 86400
+
+
+# Files above this size (in bytes) are tracked, and if they are renamed they will simply be
+# renamed on the server, rather than being uploaded again. (64k - 1)
+
+FileTrackingSizeThreshold = 65535
+
+
+# The daemon does "changes only" uploads for files above this size (in bytes).
+# Files less than it are uploaded whole without this extra processing.
+
+DiffingUploadSizeThreshold = 8192
+
+
+# The limit on how much time is spent diffing files. Most files shouldn't take very long,
+# but if you have really big files you can use this to limit the time spent diffing them.
+# * Reduce if you are having problems with processor usage.
+# * Increase if you have large files, and think the upload of changes is too large and want
+#   to spend more time searching for unchanged blocks.
+
+MaximumDiffingTime = 20
+
+# KeepAliveTime requires Gary's SSL KeepAlive patches
+# KeepAliveTime = 250
+
+# Uncomment this line to see exactly what the daemon is going when it's connected to the server.
+
+# ExtendedLogging = yes
+
+
+# Use this to temporarily stop bbackupd from syncronising or connecting to the store.
+# This specifies a program or script script which is run just before each sync, and ideally
+# the full path to the interpreter. It will be run as the same user bbackupd is running as,
+# usually root.
+# The script prints either "now" or a number to STDOUT (and a terminating newline, no quotes).
+# If the result was "now", then the sync will happen. If it's a number, then the script will
+# be asked again in that number of seconds.
+# For example, you could use this on a laptop to only backup when on a specific network.
+
+# SyncAllowScript = /path/to/intepreter/or/exe script-name parameters etc
+
+
+# Where the command socket is created in the filesystem.
+
+CommandSocket = pipe
+
+
+Server
+{
+	PidFile = C:\Program Files\Box Backup\bbackupd\bbackupd.pid
+}
+
+# StoreObjectInfoFile requires Gary's client marker serialisation patch
+# StoreObjectInfoFile = C:\Program Files\Box Backup\bbackupd\bbackupd.dat
+
+# 
+# BackupLocations specifies which locations on disc should be backed up. Each
+# directory is in the format
+# 
+# 	name
+# 	{
+# 		Path = /path/of/directory
+# 		(optional exclude directives)
+# 	}
+# 
+# 'name' is derived from the Path by the config script, but should merely be
+# unique.
+# 
+# The exclude directives are of the form
+# 
+# 	[Exclude|AlwaysInclude][File|Dir][|sRegex] = regex or full pathname
+# 
+# (The regex suffix is shown as 'sRegex' to make File or Dir plural)
+#
+# For example:
+# 
+# 	ExcludeDir = /home/guest-user
+# 	ExcludeFilesRegex = *.(mp3|MP3)$
+# 	AlwaysIncludeFile = /home/username/veryimportant.mp3
+# 
+# This excludes the directory /home/guest-user from the backup along with all mp3
+# files, except one MP3 file in particular.
+# 
+# In general, Exclude excludes a file or directory, unless the directory is
+# explicitly mentioned in a AlwaysInclude directive.
+# 
+# If a directive ends in Regex, then it is a regular expression rather than a
+# explicit full pathname. See
+# 
+# 	man 7 re_format
+# 
+# for the regex syntax on your platform.
+# 
+
+BackupLocations
+{
+      MyDocuments
+	{
+                Path = C:\Documents and Settings\
+	}
+}
+
diff --git a/bin/bbackupd/win32/installer.iss b/bin/bbackupd/win32/installer.iss
new file mode 100644
index 00000000..20e3addb
--- /dev/null
+++ b/bin/bbackupd/win32/installer.iss
@@ -0,0 +1,51 @@
+; Script to generate output file for Box Backup client for the Windows Platform

+;

+; Very important - this is the release process

+;

+; 1/ Upgrade BOX_VERSION in the file emu.h to the current version for example 0.09eWin32 - then perform a full rebuild

+;

+; 2/ Upgrade the AppVerName below to reflect the version

+;

+; 3/ Generate the output file, then rename it to the relevent filename to reflect the version

+

+[Setup]

+AppName=Box Backup

+AppVerName=BoxWin32 0.09h

+AppPublisher=Fluffy & Omniis

+AppPublisherURL=http://www.omniis.com

+AppSupportURL=http://www.omniis.com

+AppUpdatesURL=http://www.omniis.com

+DefaultDirName={pf}\Box Backup

+DefaultGroupName=Box Backup

+Compression=lzma

+SolidCompression=yes

+PrivilegesRequired=admin

+

+[Files]

+Source: "..\..\Release\bbackupd.exe"; DestDir: "{app}"; Flags: ignoreversion restartreplace

+Source: "..\..\Release\bbackupctl.exe"; DestDir: "{app}"; Flags: ignoreversion restartreplace

+Source: "..\..\Release\bbackupquery.exe"; DestDir: "{app}"; Flags: ignoreversion restartreplace

+Source: "..\..\ExceptionCodes.txt"; DestDir: "{app}"; Flags: ignoreversion restartreplace

+Source: "icon.ico"; DestDir: "{app}\"; Flags: ignoreversion restartreplace

+Source: "msvcr71.dll"; DestDir: "{app}\"; Flags: restartreplace

+Source: "bbackupd.conf"; DestDir: "{app}"; Flags: confirmoverwrite

+Source: "..\..\..\zlib\zlib1.dll"; DestDir: "{app}"; Flags: ignoreversion restartreplace

+Source: "..\..\..\openssl\bin\libeay32.dll"; DestDir: "{app}"; Flags: ignoreversion restartreplace

+Source: "..\..\..\openssl\bin\ssleay32.dll"; DestDir: "{app}"; Flags: ignoreversion restartreplace

+Source: "ReadMe.txt"; DestDir: "{app}"; Flags: ignoreversion restartreplace

+

+; NOTE: Don't use "Flags: ignoreversion" on any shared system files

+

+[Icons]

+Name: "{group}\Box Backup Query"; Filename: "{app}\bbackupquery.exe"; IconFilename: "{app}\icon.ico" ;Parameters: "-c bbackupd.conf"; WorkingDir: "{app}"

+Name: "{group}\Service\Install Service"; Filename: "{app}\bbackupd.exe"; IconFilename: "{app}\icon.ico" ;Parameters: "-i"; WorkingDir: "{app}"

+Name: "{group}\Service\Remove Service"; Filename: "{app}\bbackupd.exe"; IconFilename: "{app}\icon.ico" ;Parameters: "-r"; WorkingDir: "{app}"

+Name: "{group}\Initiate Backup Now"; Filename: "{app}\bbackupctl.exe"; IconFilename: "{app}\icon.ico" ;Parameters: "-c bbackupd.conf sync"; WorkingDir: "{app}"

+

+[Dirs]

+Name: "{app}\bbackupd"

+

+[Run]

+Filename: "{app}\bbackupd.exe"; Description: "Install Boxbackup as service"; Parameters: "-i"; Flags: postinstall

+Filename: "{app}\Readme.txt"; Description: "View upgrade notes"; Flags: postinstall shellexec skipifsilent

+