Marged chris/win32/merge/07-win32-fixes at r210 to trunk

4 files changed, 1765 insertions, 0 deletions

diff --git a/lib/win32/WinNamedPipeStream.cpp b/lib/win32/WinNamedPipeStream.cpp
new file mode 100755
index 00000000..17a2227b
--- /dev/null
+++ b/lib/win32/WinNamedPipeStream.cpp
@@ -0,0 +1,301 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    WinNamedPipeStream.cpp
+//		Purpose: I/O stream interface for Win32 named pipes
+//		Created: 2005/12/07
+//
+// --------------------------------------------------------------------------
+
+#include "Box.h"
+
+#ifdef WIN32
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <windows.h>
+
+#include "WinNamedPipeStream.h"
+#include "ServerException.h"
+#include "CommonException.h"
+#include "Socket.h"
+
+#include "MemLeakFindOn.h"
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::WinNamedPipeStream()
+//		Purpose: Constructor (create stream ready for Open() call)
+//		Created: 2005/12/07
+//
+// --------------------------------------------------------------------------
+WinNamedPipeStream::WinNamedPipeStream()
+	: mSocketHandle(NULL),
+	  mReadClosed(false),
+	  mWriteClosed(false),
+	  mIsServer(false),
+	  mIsConnected(false)
+{
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::~WinNamedPipeStream()
+//		Purpose: Destructor, closes stream if open
+//		Created: 2005/12/07
+//
+// --------------------------------------------------------------------------
+WinNamedPipeStream::~WinNamedPipeStream()
+{
+	if (mSocketHandle != NULL)
+	{
+		Close();
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::Accept(const char* Name)
+//		Purpose: Creates a new named pipe with the given name,
+//			and wait for a connection on it
+//		Created: 2005/12/07
+//
+// --------------------------------------------------------------------------
+void WinNamedPipeStream::Accept(const wchar_t* pName)
+{
+	if (mSocketHandle != NULL || mIsConnected) 
+	{
+		THROW_EXCEPTION(ServerException, SocketAlreadyOpen)
+	}
+
+	mSocketHandle = CreateNamedPipeW( 
+		pName,                     // pipe name 
+		PIPE_ACCESS_DUPLEX,        // read/write access 
+		PIPE_TYPE_MESSAGE |        // message type pipe 
+		PIPE_READMODE_MESSAGE |    // message-read mode 
+		PIPE_WAIT,                 // blocking mode 
+		1,                         // max. instances  
+		4096,                      // output buffer size 
+		4096,                      // input buffer size 
+		NMPWAIT_USE_DEFAULT_WAIT,  // client time-out 
+		NULL);                     // default security attribute 
+
+	if (mSocketHandle == NULL)
+	{
+		::syslog(LOG_ERR, "CreateNamedPipeW failed: %d", 
+			GetLastError());
+		THROW_EXCEPTION(ServerException, SocketOpenError)
+	}
+
+	bool connected = ConnectNamedPipe(mSocketHandle, (LPOVERLAPPED) NULL);
+
+	if (!connected)
+	{
+		::syslog(LOG_ERR, "ConnectNamedPipe failed: %d", 
+			GetLastError());
+		CloseHandle(mSocketHandle);
+		mSocketHandle = NULL;
+		THROW_EXCEPTION(ServerException, SocketOpenError)
+	}
+	
+	mReadClosed  = FALSE;
+	mWriteClosed = FALSE;
+	mIsServer    = TRUE; // must flush and disconnect before closing
+	mIsConnected = TRUE;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::Connect(const char* Name)
+//		Purpose: Opens a connection to a listening named pipe
+//		Created: 2005/12/07
+//
+// --------------------------------------------------------------------------
+void WinNamedPipeStream::Connect(const wchar_t* pName)
+{
+	if (mSocketHandle != NULL || mIsConnected) 
+	{
+		THROW_EXCEPTION(ServerException, SocketAlreadyOpen)
+	}
+	
+	mSocketHandle = CreateFileW( 
+		pName,          // pipe name 
+		GENERIC_READ |  // read and write access 
+		GENERIC_WRITE, 
+		0,              // no sharing 
+		NULL,           // default security attributes
+		OPEN_EXISTING,
+		0,              // default attributes 
+		NULL);          // no template file 
+
+	if (mSocketHandle == INVALID_HANDLE_VALUE)
+	{
+		::syslog(LOG_ERR, "Failed to connect to server's named pipe: "
+			"error %d", GetLastError());
+		THROW_EXCEPTION(ServerException, SocketOpenError)
+	}
+
+	mReadClosed  = FALSE;
+	mWriteClosed = FALSE;
+	mIsServer    = FALSE; // just close the socket
+	mIsConnected = TRUE;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::Read(void *pBuffer, int NBytes)
+//		Purpose: Reads data from stream. Maybe returns less than asked for.
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+int WinNamedPipeStream::Read(void *pBuffer, int NBytes, int Timeout)
+{
+	// TODO no support for timeouts yet
+	ASSERT(Timeout == IOStream::TimeOutInfinite)
+	
+	if (mSocketHandle == NULL || !mIsConnected) 
+	{
+		THROW_EXCEPTION(ServerException, BadSocketHandle)
+	}
+
+	DWORD NumBytesRead;
+	
+	bool Success = ReadFile( 
+		mSocketHandle, // pipe handle 
+		pBuffer,       // buffer to receive reply 
+		NBytes,        // size of buffer 
+		&NumBytesRead, // number of bytes read 
+		NULL);         // not overlapped 
+	
+	if (!Success)
+	{
+		THROW_EXCEPTION(ConnectionException, Conn_SocketReadError)
+	}
+	
+	// Closed for reading at EOF?
+	if (NumBytesRead == 0)
+	{
+		mReadClosed = true;
+	}
+	
+	return NumBytesRead;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::Write(void *pBuffer, int NBytes)
+//		Purpose: Writes data, blocking until it's all done.
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+void WinNamedPipeStream::Write(const void *pBuffer, int NBytes)
+{
+	if (mSocketHandle == NULL || !mIsConnected) 
+	{
+		THROW_EXCEPTION(ServerException, BadSocketHandle)
+	}
+	
+	// Buffer in byte sized type.
+	ASSERT(sizeof(char) == 1);
+	const char *pByteBuffer = (char *)pBuffer;
+	
+	int NumBytesWrittenTotal = 0;
+
+	while (NumBytesWrittenTotal < NBytes)
+	{
+		DWORD NumBytesWrittenThisTime = 0;
+
+		bool Success = WriteFile( 
+			mSocketHandle,    // pipe handle 
+			pByteBuffer + NumBytesWrittenTotal, // message 
+			NBytes      - NumBytesWrittenTotal, // message length 
+			&NumBytesWrittenThisTime, // bytes written this time
+			NULL);            // not overlapped 
+
+		if (!Success)
+		{
+			mWriteClosed = true;	// assume can't write again
+			THROW_EXCEPTION(ConnectionException, 
+				Conn_SocketWriteError)
+		}
+
+		NumBytesWrittenTotal += NumBytesWrittenThisTime;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::Close()
+//		Purpose: Closes connection to remote socket
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+void WinNamedPipeStream::Close()
+{
+	if (mSocketHandle == NULL || !mIsConnected) 
+	{
+		THROW_EXCEPTION(ServerException, BadSocketHandle)
+	}
+
+	if (mIsServer)
+	{	
+		if (!FlushFileBuffers(mSocketHandle))
+		{
+			::syslog(LOG_INFO, "FlushFileBuffers failed: %d", 
+				GetLastError());
+		}
+	
+		if (!DisconnectNamedPipe(mSocketHandle))
+		{
+			::syslog(LOG_ERR, "DisconnectNamedPipe failed: %d", 
+				GetLastError());
+		}
+
+		mIsServer = false;
+	}
+
+	if (!CloseHandle(mSocketHandle))
+	{
+		::syslog(LOG_ERR, "CloseHandle failed: %d", GetLastError());
+		THROW_EXCEPTION(ServerException, SocketCloseError)
+	}
+	
+	mSocketHandle = NULL;
+	mIsConnected = FALSE;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::StreamDataLeft()
+//		Purpose: Still capable of reading data?
+//		Created: 2003/08/02
+//
+// --------------------------------------------------------------------------
+bool WinNamedPipeStream::StreamDataLeft()
+{
+	return !mReadClosed;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    WinNamedPipeStream::StreamClosed()
+//		Purpose: Connection been closed?
+//		Created: 2003/08/02
+//
+// --------------------------------------------------------------------------
+bool WinNamedPipeStream::StreamClosed()
+{
+	return mWriteClosed;
+}
+
+#endif // WIN32
diff --git a/lib/win32/WinNamedPipeStream.h b/lib/win32/WinNamedPipeStream.h
new file mode 100755
index 00000000..5a800371
--- /dev/null
+++ b/lib/win32/WinNamedPipeStream.h
@@ -0,0 +1,60 @@
+// --------------------------------------------------------------------------
+//
+// File
+//		Name:    WinNamedPipeStream.h
+//		Purpose: I/O stream interface for Win32 named pipes
+//		Created: 2005/12/07
+//
+// --------------------------------------------------------------------------
+
+#if ! defined WINNAMEDPIPESTREAM__H && defined WIN32
+#define WINNAMEDPIPESTREAM__H
+
+#include "IOStream.h"
+
+// --------------------------------------------------------------------------
+//
+// Class
+//		Name:    WinNamedPipeStream
+//		Purpose: I/O stream interface for Win32 named pipes
+//		Created: 2003/07/31
+//
+// --------------------------------------------------------------------------
+class WinNamedPipeStream : public IOStream
+{
+public:
+	WinNamedPipeStream();
+	~WinNamedPipeStream();
+
+	// server side - create the named pipe and listen for connections
+	void Accept(const wchar_t* Name);
+
+	// client side - connect to a waiting server
+	void Connect(const wchar_t* Name);
+
+	// both sides
+	virtual int Read(void *pBuffer, int NBytes, 
+		int Timeout = IOStream::TimeOutInfinite);
+	virtual void Write(const void *pBuffer, int NBytes);
+	virtual void Close();
+	virtual bool StreamDataLeft();
+	virtual bool StreamClosed();
+	bool IsConnected() { return mIsConnected; }
+
+protected:
+	HANDLE GetSocketHandle();
+	void MarkAsReadClosed()  {mReadClosed  = true;}
+	void MarkAsWriteClosed() {mWriteClosed = true;}
+
+private:
+	WinNamedPipeStream(const WinNamedPipeStream &rToCopy) 
+		{ /* do not call */ }
+
+	HANDLE mSocketHandle;
+	bool mReadClosed;
+	bool mWriteClosed;
+	bool mIsServer;
+	bool mIsConnected;
+};
+
+#endif // WINNAMEDPIPESTREAM__H
diff --git a/lib/win32/emu.cpp b/lib/win32/emu.cpp
new file mode 100644
index 00000000..29200313
--- /dev/null
+++ b/lib/win32/emu.cpp
@@ -0,0 +1,978 @@
+// Box Backup Win32 native port by Nick Knight
+
+// Need at least 0x0500 to use GetFileSizeEx on Cygwin/MinGW
+#define WINVER 0x0500
+
+#include "Box.h"
+
+#ifdef WIN32
+
+// #include "emu.h"
+
+#include <windows.h>
+#include <fcntl.h>
+// #include <atlenc.h>
+#include <unistd.h>
+
+#include <string>
+#include <list>
+
+//our implimentation for a timer
+//based on a simple thread which sleeps for a
+//period of time
+static bool gFinishTimer;
+static CRITICAL_SECTION gLock;
+
+typedef struct 
+{
+	int countDown;
+	int interval;
+}
+tTimer;
+
+std::list<tTimer> gTimerList;
+static void (__cdecl *gTimerFunc) (int) = NULL;
+
+int setitimer(int type , struct itimerval *timeout, int)
+{
+	if ( SIGVTALRM == type || ITIMER_VIRTUAL == type )
+	{
+		EnterCriticalSection(&gLock);
+		// we only need seconds for the mo!
+		if (timeout->it_value.tv_sec  == 0 && 
+		    timeout->it_value.tv_usec == 0)
+		{
+			gTimerList.clear();
+		}
+		else
+		{
+			tTimer ourTimer;
+			ourTimer.countDown = timeout->it_value.tv_sec;
+			ourTimer.interval  = timeout->it_interval.tv_sec;
+			gTimerList.push_back(ourTimer);
+		}
+		LeaveCriticalSection(&gLock);
+	}
+	
+	// indicate success
+	return 0;
+}
+
+static unsigned int WINAPI RunTimer(LPVOID lpParameter)
+{
+	gFinishTimer = false;
+
+	while (!gFinishTimer)
+	{
+		std::list<tTimer>::iterator it;
+		EnterCriticalSection(&gLock);
+
+		for (it = gTimerList.begin(); it != gTimerList.end(); it++)
+		{
+			tTimer& rTimer(*it);
+
+			rTimer.countDown --;
+			if (rTimer.countDown == 0)
+			{
+				if (gTimerFunc != NULL)
+				{
+					gTimerFunc(0);
+				}
+				if (rTimer.interval)
+				{
+					rTimer.countDown = rTimer.interval;
+				}
+				else
+				{
+					// mark for deletion
+					rTimer.countDown = -1;
+				}
+			}
+		}
+
+		for (it = gTimerList.begin(); it != gTimerList.end(); it++)
+		{
+			tTimer& rTimer(*it);
+
+			if (rTimer.countDown == -1)
+			{
+				gTimerList.erase(it);
+				//if we don't do this the search is on a corrupt list
+				it = gTimerList.begin();
+			}
+		}
+
+		LeaveCriticalSection(&gLock);
+		// we only need to have a 1 second resolution
+		Sleep(1000);
+	}
+
+	return 0;
+}
+
+int SetTimerHandler(void (__cdecl *func ) (int))
+{
+	gTimerFunc = func;
+	return 0;
+}
+
+void InitTimer(void)
+{
+	InitializeCriticalSection(&gLock);
+
+	// create our thread
+	HANDLE ourThread = (HANDLE)_beginthreadex(NULL, 0, RunTimer, 0, 
+		CREATE_SUSPENDED, NULL);
+	SetThreadPriority(ourThread, THREAD_PRIORITY_LOWEST);
+	ResumeThread(ourThread);
+}
+
+void FiniTimer(void)
+{
+	gFinishTimer = true;
+	EnterCriticalSection(&gLock);
+	DeleteCriticalSection(&gLock);
+}
+
+//Our constants we need to keep track of
+//globals
+struct passwd gTempPasswd;
+
+bool EnableBackupRights( void )
+{
+	HANDLE hToken;
+	TOKEN_PRIVILEGES token_priv;
+
+	//open current process to adjust privileges
+	if( !OpenProcessToken( GetCurrentProcess( ), 
+		TOKEN_ADJUST_PRIVILEGES, 
+		&hToken ))
+	{
+		printf( "Cannot open process token - err = %d\n", GetLastError( ) );
+		return false;
+	}
+
+	//let's build the token privilege struct - 
+	//first, look up the LUID for the backup privilege
+
+	if( !LookupPrivilegeValue( NULL, //this system
+		SE_BACKUP_NAME, //the name of the privilege
+		&( token_priv.Privileges[0].Luid )) ) //result
+	{
+		printf( "Cannot lookup backup privilege - err = %d\n", GetLastError( ) );
+		return false;
+	}
+
+	token_priv.PrivilegeCount = 1;
+	token_priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+
+	// now set the privilege
+	// because we're going exit right after dumping the streams, there isn't 
+	// any need to save current state
+
+	if( !AdjustTokenPrivileges( hToken, //our process token
+		false,  //we're not disabling everything
+		&token_priv, //address of structure
+		sizeof( token_priv ), //size of structure
+		NULL, NULL )) //don't save current state
+	{
+		//this function is a little tricky - if we were adjusting
+		//more than one privilege, it could return success but not
+		//adjust them all - in the general case, you need to trap this
+		printf( "Could not enable backup privileges - err = %d\n", GetLastError( ) );
+		return false;
+
+	}
+	else
+	{
+		return true;
+	}
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    openfile
+//		Purpose: replacement for any open calls - handles unicode filenames - supplied in utf8
+//		Created: 25th October 2004
+//
+// --------------------------------------------------------------------------
+HANDLE openfile(const char *filename, int flags, int mode)
+{
+	try{
+
+		wchar_t *buffer;
+		std::string fileN(filename);
+
+		std::string tmpStr("\\\\?\\");
+		//is the path relative or otherwise
+		if ( fileN[1] != ':' )
+		{
+			//we need to get the current directory
+			char wd[PATH_MAX];
+			if(::getcwd(wd, PATH_MAX) == 0)
+			{
+				return NULL;
+			}
+			tmpStr += wd;
+			if (tmpStr[tmpStr.length()] != '\\')
+			{
+				tmpStr += '\\';
+			}
+		}
+		tmpStr += filename;
+
+		int strlen = MultiByteToWideChar(
+			CP_UTF8,               // code page
+			0,                     // character-type options
+			tmpStr.c_str(),        // string to map
+			(int)tmpStr.length(),       // number of bytes in string
+			NULL,                  // wide-character buffer
+			0                      // size of buffer - work out how much space we need
+			);
+
+		buffer = new wchar_t[strlen+1];
+		if ( buffer == NULL )
+		{
+			return NULL;
+		}
+
+		strlen = MultiByteToWideChar(
+			CP_UTF8,               // code page
+			0,                     // character-type options
+			tmpStr.c_str(),        // string to map
+			(int)tmpStr.length(),       // number of bytes in string
+			buffer,                // wide-character buffer
+			strlen                 // size of buffer
+			);
+
+		if ( strlen == 0 )
+		{
+			delete [] buffer;
+			return NULL;
+		}
+
+		buffer[strlen] = L'\0';
+
+		//flags could be O_WRONLY | O_CREAT | O_RDONLY
+		DWORD createDisposition = OPEN_EXISTING;
+		DWORD shareMode = FILE_SHARE_READ;
+		DWORD accessRights = FILE_READ_ATTRIBUTES | FILE_LIST_DIRECTORY | FILE_READ_EA;
+
+		if ( flags & O_WRONLY )
+		{
+			createDisposition = OPEN_EXISTING;
+			shareMode |= FILE_SHARE_READ ;//| FILE_SHARE_WRITE;
+		}
+		if ( flags & O_CREAT )
+		{
+			createDisposition = OPEN_ALWAYS;
+			shareMode |= FILE_SHARE_READ ;//| FILE_SHARE_WRITE;
+			accessRights |= FILE_WRITE_ATTRIBUTES | FILE_WRITE_DATA | FILE_WRITE_EA | FILE_ALL_ACCESS;
+		}
+		if ( flags & O_TRUNC )
+		{
+			createDisposition = OPEN_ALWAYS;
+		}
+
+		HANDLE hdir = CreateFileW(buffer, 
+			accessRights, 
+			shareMode, 
+			NULL, 
+			createDisposition, 
+			FILE_FLAG_BACKUP_SEMANTICS,
+			NULL);
+
+		if ( hdir == INVALID_HANDLE_VALUE )
+		{
+			// DWORD err = GetLastError();
+			// syslog(EVENTLOG_WARNING_TYPE, "Couldn't open file %s, err %i\n", filename, err);
+			delete [] buffer;
+			return NULL;
+		}
+
+		delete [] buffer;
+		return hdir;
+
+	}
+	catch(...)
+	{
+		printf("Caught openfile:%s\r\n", filename);
+	}
+	return NULL;
+
+}
+
+// MinGW provides a getopt implementation
+#ifndef __MINGW32__
+//works with getopt
+char *optarg;
+//optind looks like an index into the string - how far we have moved along
+int optind = 1;
+char nextchar = -1;
+#endif
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ourfstat
+//		Purpose: replacement for fstat supply a windows handle
+//		Created: 25th October 2004
+//
+// --------------------------------------------------------------------------
+int ourfstat(HANDLE hdir, struct stat * st)
+{
+	ULARGE_INTEGER conv;
+
+	if (hdir == INVALID_HANDLE_VALUE)
+	{
+		::syslog(LOG_ERR, "Error: invalid file handle in ourfstat()");
+		errno = EBADF;
+		return -1;
+	}
+
+	BY_HANDLE_FILE_INFORMATION fi;
+	if (!GetFileInformationByHandle(hdir, &fi))
+	{
+		::syslog(LOG_WARNING, "Failed to read file information: "
+			"error %d", GetLastError());
+		errno = EACCES;
+		return -1;
+	}
+
+	// This next example is how we get our INODE (equivalent) information
+	conv.HighPart = fi.nFileIndexHigh;
+	conv.LowPart = fi.nFileIndexLow;
+	st->st_ino = conv.QuadPart;
+
+	// get the time information
+	st->st_ctime = ConvertFileTimeToTime_t(&fi.ftCreationTime);
+	st->st_atime = ConvertFileTimeToTime_t(&fi.ftLastAccessTime);
+	st->st_mtime = ConvertFileTimeToTime_t(&fi.ftLastWriteTime);
+
+	// size of the file
+	LARGE_INTEGER st_size;
+	if (!GetFileSizeEx(hdir, &st_size))
+	{
+		::syslog(LOG_WARNING, "Failed to get file size: error %d",
+			GetLastError());
+		errno = EACCES;
+		return -1;
+	}
+
+	conv.HighPart = st_size.HighPart;
+	conv.LowPart = st_size.LowPart;
+	st->st_size = conv.QuadPart;
+
+	//the mode of the file
+	st->st_mode = 0;
+	//DWORD res = GetFileAttributes((LPCSTR)tmpStr.c_str());
+
+	if (INVALID_FILE_ATTRIBUTES != fi.dwFileAttributes)
+	{
+		if (fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		{
+			st->st_mode |= S_IFDIR;
+		}
+		else
+		{
+			st->st_mode |= S_IFREG;
+		}
+	}
+	else
+	{
+		::syslog(LOG_WARNING, "Failed to get file attributes: "
+			"error %d", GetLastError());
+		errno = EACCES;
+		return -1;
+	}
+
+	return 0;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    OpenFileByNameUtf8
+//		Purpose: Converts filename to Unicode and returns 
+//			a handle to it. In case of error, sets errno,
+//			logs the error and returns NULL.
+//		Created: 10th December 2004
+//
+// --------------------------------------------------------------------------
+HANDLE OpenFileByNameUtf8(const char* pName)
+{
+	//some string thing - required by ms to indicate long/unicode filename
+	std::string tmpStr("\\\\?\\");
+
+	// is the path relative or otherwise
+	std::string fileN(pName);
+	if (fileN[1] != ':')
+	{
+		// we need to get the current directory
+		char wd[PATH_MAX];
+		if(::getcwd(wd, PATH_MAX) == 0)
+		{
+			::syslog(LOG_WARNING, 
+				"Failed to open '%s': path too long", pName);
+			errno = ENAMETOOLONG;
+			return NULL;
+		}
+
+		tmpStr += wd;
+		if (tmpStr[tmpStr.length()] != '\\')
+		{
+			tmpStr += '\\';
+		}
+	}
+
+	tmpStr += fileN;
+
+	int strlen = MultiByteToWideChar(
+		CP_UTF8,               // code page
+		0,                     // character-type options
+		tmpStr.c_str(),        // string to map
+		(int)tmpStr.length(),  // number of bytes in string
+		NULL,                  // wide-character buffer
+		0                      // size of buffer - work out 
+		                       //   how much space we need
+		);
+
+	wchar_t* buffer = new wchar_t[strlen+1];
+
+	if (buffer == NULL)
+	{
+		::syslog(LOG_WARNING, 
+			"Failed to open '%s': out of memory", pName);
+		errno = ENOMEM;
+		return NULL;
+	}
+
+	strlen = MultiByteToWideChar(
+		CP_UTF8,               // code page
+		0,                     // character-type options
+		tmpStr.c_str(),        // string to map
+		(int)tmpStr.length(),  // number of bytes in string
+		buffer,                // wide-character buffer
+		strlen                 // size of buffer
+		);
+
+	if (strlen == 0)
+	{
+		::syslog(LOG_WARNING, 
+			"Failed to open '%s': could not convert "
+			"file name to Unicode", pName);
+		errno = EACCES;
+		delete [] buffer;
+		return NULL;
+	}
+
+	buffer[strlen] = L'\0';
+
+	HANDLE handle = CreateFileW(buffer, 
+		FILE_READ_ATTRIBUTES | FILE_LIST_DIRECTORY | FILE_READ_EA, 
+		FILE_SHARE_READ | FILE_SHARE_DELETE | FILE_SHARE_WRITE, 
+		NULL, 
+		OPEN_EXISTING, 
+		FILE_FLAG_BACKUP_SEMANTICS,
+		NULL);
+
+	if (handle == INVALID_HANDLE_VALUE)
+	{
+		// if our open fails we should always be able to 
+		// open in this mode - to get the inode information
+		// at least one process must have the file open - 
+		// in this case someone else does.
+		handle = CreateFileW(buffer, 
+			0, 
+			FILE_SHARE_READ, 
+			NULL, 
+			OPEN_EXISTING, 
+			FILE_FLAG_BACKUP_SEMANTICS,
+			NULL);
+	}
+
+	delete [] buffer;
+
+	if (handle == INVALID_HANDLE_VALUE)
+	{
+		DWORD err = GetLastError();
+
+		if (err == ERROR_FILE_NOT_FOUND)
+		{
+			::syslog(LOG_WARNING, 
+				"Failed to open '%s': file not found", pName);
+			errno = ENOENT;
+		}
+		else
+		{
+			::syslog(LOG_WARNING, 
+				"Failed to open '%s': error %d", pName);
+			errno = EACCES;
+		}
+
+		return NULL;
+	}
+
+	return handle;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    ourstat 
+//		Purpose: replacement for the lstat and stat functions, 
+//			works with unicode filenames supplied in utf8 format
+//		Created: 25th October 2004
+//
+// --------------------------------------------------------------------------
+int ourstat(const char * pName, struct stat * st)
+{
+	// at the mo
+	st->st_uid = 0;
+	st->st_gid = 0;
+	st->st_nlink = 1;
+
+	HANDLE handle = OpenFileByNameUtf8(pName);
+
+	if (handle == NULL)
+	{
+		// errno already set and error logged by OpenFileByNameUtf8()
+		return -1;
+	}
+
+	int retVal = ourfstat(handle, st);
+	if (retVal != 0)
+	{
+		// error logged, but without filename
+		::syslog(LOG_WARNING, "Failed to get file information "
+			"for '%s'", pName);
+	}
+
+	// close the handle
+	CloseHandle(handle);
+
+	return retVal;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    statfs
+//		Purpose: returns the mount point of where a file is located - 
+//			in this case the volume serial number
+//		Created: 25th October 2004
+//
+// --------------------------------------------------------------------------
+int statfs(const char * pName, struct statfs * s)
+{
+	HANDLE handle = OpenFileByNameUtf8(pName);
+
+	if (handle == NULL)
+	{
+		// errno already set and error logged by OpenFileByNameUtf8()
+		return -1;
+	}
+
+	BY_HANDLE_FILE_INFORMATION fi;
+	if (!GetFileInformationByHandle(handle, &fi))
+	{
+		::syslog(LOG_WARNING, "Failed to get file information "
+			"for '%s': error %d", pName, GetLastError());
+		CloseHandle(handle);
+		errno = EACCES;
+		return -1;
+	}
+
+	// convert volume serial number to a string
+	_ui64toa(fi.dwVolumeSerialNumber, s->f_mntonname + 1, 16);
+
+	// pseudo unix mount point
+	s->f_mntonname[0] = DIRECTORY_SEPARATOR_ASCHAR;
+
+	CloseHandle(handle);   // close the handle
+
+	return 0;
+}
+
+
+
+
+
+// MinGW provides opendir(), etc. via <dirent.h>
+// MSVC does not provide these, so emulation is needed
+
+#ifndef __MINGW32__
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    opendir
+//		Purpose: replacement for unix function, uses win32 findfirst routines
+//		Created: 25th October 2004
+//
+// --------------------------------------------------------------------------
+DIR *opendir(const char *name)
+{
+	try
+	{
+		DIR *dir = 0;
+		std::string dirName(name);
+
+		//append a '\' win32 findfirst is sensitive to this
+		if ( dirName[dirName.size()] != '\\' || dirName[dirName.size()] != '/' )
+		{
+			dirName += '\\';
+		}
+
+		//what is the search string? - everything
+		dirName += '*';
+
+		if(name && name[0])
+		{
+			if ( ( dir = new DIR ) != 0 )
+			{
+				//mbstowcs(dir->name, dirName.c_str(),100);
+				//wcscpy((wchar_t*)dir->name, (const wchar_t*)dirName.c_str());
+				//mbstowcs(dir->name, dirName.c_str(), dirName.size()+1);
+				//wchar_t *buffer;
+
+				int strlen = MultiByteToWideChar(
+					CP_UTF8,               // code page
+					0,                     // character-type options
+					dirName.c_str(),       // string to map
+					(int)dirName.length(), // number of bytes in string
+					NULL,                  // wide-character buffer
+					0                      // size of buffer - work out how much space we need
+					);
+
+				dir->name = new wchar_t[strlen+1];
+
+				if (dir->name == NULL)
+				{
+					delete dir;
+					dir   = 0;
+					errno = ENOMEM;
+					return NULL;
+				}
+
+				strlen = MultiByteToWideChar(
+					CP_UTF8,               // code page
+					0,                     // character-type options
+					dirName.c_str(),        // string to map
+					(int)dirName.length(),       // number of bytes in string
+					dir->name,                // wide-character buffer
+					strlen                 // size of buffer
+					);
+
+				if (strlen == 0)
+				{
+					delete dir->name;
+					delete dir;
+					dir   = 0;
+					errno = ENOMEM;
+					return NULL;
+				}
+
+				dir->name[strlen] = L'\0';
+
+				
+				dir->fd = _wfindfirst(
+					(const wchar_t*)dir->name,
+					&dir->info);
+
+				if (dir->fd != -1)
+				{
+					dir->result.d_name = 0;
+				}
+				else // go back
+				{
+					delete [] dir->name;
+					delete dir;
+					dir = 0;
+				}
+			}
+			else // backwards again
+			{
+				delete dir;
+				dir   = 0;
+				errno = ENOMEM;
+			}
+		}
+		else
+		{
+			errno = EINVAL;
+		}
+
+		return dir;
+
+	}
+	catch(...)
+	{
+		printf("Caught opendir");
+	}
+
+	return NULL;
+}
+
+//this kinda makes it not thread friendly!
+//but I don't think it needs to be.
+char tempbuff[MAX_PATH];
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    readdir
+//		Purpose: as function above
+//		Created: 25th October 2004
+//
+// --------------------------------------------------------------------------
+struct dirent *readdir(DIR *dp)
+{
+	try
+	{
+		struct dirent *den = NULL;
+
+		if (dp && dp->fd != -1)
+		{
+			if (!dp->result.d_name || 
+				_wfindnext(dp->fd, &dp->info) != -1)
+			{
+				den         = &dp->result;
+				std::wstring input(dp->info.name);
+				memset(tempbuff, 0, sizeof(tempbuff));
+				WideCharToMultiByte(CP_UTF8, 0, dp->info.name, 
+					-1, &tempbuff[0], sizeof (tempbuff), 
+					NULL, NULL);
+				//den->d_name = (char *)dp->info.name;
+				den->d_name = &tempbuff[0];
+			}
+		}
+		else
+		{
+			errno = EBADF;
+		}
+		return den;
+	}
+	catch (...)
+	{
+		printf("Caught readdir");
+	}
+	return NULL;
+}
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    closedir
+//		Purpose: as function above
+//		Created: 25th October 2004
+//
+// --------------------------------------------------------------------------
+int closedir(DIR *dp)
+{
+	try
+	{
+		int finres = -1;
+		if (dp)
+		{
+			if(dp->fd != -1)
+			{
+				finres = _findclose(dp->fd);
+			}
+
+			delete [] dp->name;
+			delete dp;
+		}
+
+		if (finres == -1) // errors go to EBADF 
+		{
+			errno = EBADF;
+		}
+
+		return finres;
+	}
+	catch (...)
+	{
+		printf("Caught closedir");
+	}
+	return -1;
+}
+#endif // !__MINGW32__
+
+// --------------------------------------------------------------------------
+//
+// Function
+//		Name:    poll
+//		Purpose: a weak implimentation (just enough for box) 
+//			of the unix poll for winsock2
+//		Created: 25th October 2004
+//
+// --------------------------------------------------------------------------
+int poll (struct pollfd *ufds, unsigned long nfds, int timeout)
+{
+	try
+	{
+		fd_set readfd;
+		fd_set writefd;
+
+		readfd.fd_count = 0;
+		writefd.fd_count = 0;
+
+		struct pollfd *ufdsTmp = ufds;
+
+		timeval timOut;
+		timeval *tmpptr; 
+
+		if (timeout == INFTIM)
+			tmpptr = NULL;
+		else
+			tmpptr = &timOut;
+
+		timOut.tv_sec  = timeout / 1000;
+		timOut.tv_usec = timeout * 1000;
+
+		if (ufds->events & POLLIN)
+		{
+			for (unsigned long i = 0; i < nfds; i++)
+			{
+				readfd.fd_array[i] = ufdsTmp->fd;
+				readfd.fd_count++;
+			}
+		}
+
+		if (ufds->events & POLLOUT)
+		{
+			for (unsigned long i = 0; i < nfds; i++)
+			{
+
+				writefd.fd_array[i]=ufdsTmp->fd;
+				writefd.fd_count++;
+			}
+		}	
+
+		int noffds = select(0, &readfd, &writefd, 0, tmpptr);
+
+		if (noffds == SOCKET_ERROR)
+		{
+			// int errval = WSAGetLastError();
+
+			ufdsTmp = ufds;
+			for (unsigned long i = 0; i < nfds; i++)
+			{
+				ufdsTmp->revents = POLLERR;
+				ufdsTmp++;
+			}
+			return (-1);
+		}
+
+		return noffds;
+	}
+	catch (...)
+	{
+		printf("Caught poll");
+	}
+
+	return -1;
+}
+
+HANDLE gSyslogH = 0;
+
+void syslog(int loglevel, const char *frmt, ...)
+{
+	DWORD errinfo;
+	char* buffer;
+	std::string sixfour(frmt);
+
+	switch (loglevel)
+	{
+	case LOG_INFO:
+		errinfo = EVENTLOG_INFORMATION_TYPE;
+		break;
+	case LOG_ERR:
+		errinfo = EVENTLOG_ERROR_TYPE;
+		break;
+	case LOG_WARNING:
+		errinfo = EVENTLOG_WARNING_TYPE;
+		break;
+	default:
+		errinfo = EVENTLOG_WARNING_TYPE;
+		break;
+	}
+
+
+	//taken from MSDN
+	try
+	{
+
+
+		int sixfourpos;
+		while ( ( sixfourpos = sixfour.find("%ll")) != -1 )
+		{
+			//maintain portability - change the 64 bit formater...
+			std::string temp = sixfour.substr(0,sixfourpos);
+			temp += "%I64";
+			temp += sixfour.substr(sixfourpos+3, sixfour.length());
+			sixfour = temp;
+		}
+
+		//printf("parsed string is:%s\r\n", sixfour.c_str());
+
+		va_list args;
+		va_start(args, frmt);
+
+#ifdef __MINGW32__
+		// no _vscprintf, use a fixed size buffer
+		buffer = new char[1024];
+		int len = 1023;
+#else
+		int len = _vscprintf( sixfour.c_str(), args );
+		ASSERT(len > 0)
+
+		len = len + 1;
+		char* buffer = new char[len];
+#endif
+
+		ASSERT(buffer)
+		memset(buffer, 0, len);
+
+		int len2 = vsnprintf(buffer, len, sixfour.c_str(), args);
+		ASSERT(len2 <= len);
+
+		va_end(args);
+	}
+	catch (...)
+	{
+		printf("Caught syslog: %s", sixfour.c_str());
+		return;
+	}
+
+	try
+	{
+
+		if (!ReportEvent(gSyslogH,    // event log handle 
+			errinfo,              // event type 
+			0,                    // category zero 
+			MSG_ERR_EXIST,	      // event identifier - 
+			                      // we will call them all the same
+			NULL,                 // no user security identifier 
+			1,                    // one substitution string 
+			0,                    // no data 
+			(LPCSTR*)&buffer,     // pointer to string array 
+			NULL))                // pointer to data 
+
+		{
+			DWORD err = GetLastError();
+			printf("Unable to send message to Event Log "
+				"(error %i):\r\n", err);
+		}
+
+		printf("%s\r\n", buffer);
+
+		if (buffer) delete [] buffer;
+	}
+	catch (...)
+	{
+		printf("Caught syslog ReportEvent");
+	}
+}
+
+#endif // WIN32
diff --git a/lib/win32/emu.h b/lib/win32/emu.h
new file mode 100644
index 00000000..5b506206
--- /dev/null
+++ b/lib/win32/emu.h
@@ -0,0 +1,426 @@
+// emulates unix syscalls to win32 functions
+
+#if ! defined EMU_INCLUDE && defined WIN32
+#define EMU_INCLUDE
+
+#define _STAT_DEFINED
+#define _INO_T_DEFINED
+
+#include <winsock2.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <direct.h>
+#include <errno.h>
+#include <io.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <time.h>
+//#include <winsock.h>
+//#include <sys/types.h>
+//#include <sys/stat.h>
+
+#include <string>
+
+#define gmtime_r( _clock, _result ) \
+	( *(_result) = *gmtime( (_clock) ), \
+	(_result) )
+
+
+//signal in unix SIGVTALRM does not exist in win32 - but looking at the 
+#define SIGVTALRM 254
+#define SIGALRM SIGVTALRM
+#define ITIMER_VIRTUAL 0
+
+int setitimer(int type , struct itimerval *timeout, int);
+void InitTimer(void);
+void FiniTimer(void);
+
+inline int geteuid(void)
+{
+	//lets pretend to be root!
+	return 0;
+}
+
+struct passwd {
+	char *pw_name;
+	char *pw_passwd;
+	uid_t pw_uid;
+	gid_t pw_gid;
+	time_t pw_change;
+	char *pw_class;
+	char *pw_gecos;
+	char *pw_dir;
+	char *pw_shell;
+	time_t pw_expire;
+};
+
+extern passwd gTempPasswd;
+inline struct passwd * getpwnam(const char * name)
+{
+	//for the mo pretend to be root
+	gTempPasswd.pw_uid = 0;
+	gTempPasswd.pw_gid = 0;
+
+	return &gTempPasswd;
+}
+
+#define S_IRWXG 1
+#define S_IRWXO 2
+#define S_ISUID 4
+#define S_ISGID 8
+#define S_ISVTX 16
+
+#ifndef __MINGW32__
+	//not sure if these are correct
+	//S_IWRITE -   writing permitted
+	//_S_IREAD -    reading permitted
+	//_S_IREAD | _S_IWRITE - 
+	#define S_IRUSR S_IWRITE
+	#define S_IWUSR S_IREAD
+	#define S_IRWXU (S_IREAD|S_IWRITE|S_IEXEC)
+
+	#define S_ISREG(x) (S_IFREG & x)
+	#define S_ISDIR(x) (S_IFDIR & x)
+#endif
+
+inline int utimes(const char * Filename, timeval[])
+{
+	//again I am guessing this is quite important to
+	//be functioning, as large restores would be a problem
+
+	//indicate success
+	return 0;
+}
+inline int chown(const char * Filename, u_int32_t uid, u_int32_t gid)
+{
+	//important - this needs implementing
+	//If a large restore is required then 
+	//it needs to restore files AND permissions
+	//reference AdjustTokenPrivileges
+	//GetAccountSid
+	//InitializeSecurityDescriptor
+	//SetSecurityDescriptorOwner
+	//The next function looks like the guy to use...
+	//SetFileSecurity
+
+	//indicate success
+	return 0;
+}
+
+inline int chmod(const char * Filename, int uid)
+{
+	//indicate sucsess
+	return 0;
+}
+
+//I do not perceive a need to change the user or group on a backup client
+//at any rate the owner of a service can be set in the service settings
+inline int setegid(int)
+{
+	return true;
+}
+inline int seteuid(int)
+{
+	return true;
+}
+inline int setgid(int)
+{
+	return true;
+}
+inline int setuid(int)
+{
+	return true;
+}
+inline int getgid(void)
+{
+	return 0;
+}
+inline int getuid(void)
+{
+	return 0;
+}
+
+#ifndef PATH_MAX
+#define PATH_MAX MAX_PATH
+#endif
+
+// MinGW provides a getopt implementation
+#ifndef __MINGW32__
+
+//this will need to be implimented if we see fit that command line
+//options are going to be used! (probably then:)
+//where the calling function looks for the parsed parameter
+extern char *optarg;
+//optind looks like an index into the string - how far we have moved along
+extern int optind;
+extern char nextchar;
+
+inline int getopt(int count, char * const * args, char * tolookfor)
+{
+	if ( optind >= count ) return -1;
+
+	std::string str((const char *)args[optind]);
+	std::string interestin(tolookfor);
+	int opttolookfor = 0;
+	int index = -1;
+	//just initialize the string - just in case it is used.
+	//optarg[0] = 0;
+	std::string opt;
+
+	if ( count == 0 ) return -1;
+
+	do 
+	{
+		if ( index != -1 )
+		{
+			str = str.substr(index+1, str.size());
+		}
+
+		index = str.find('-');
+
+		if ( index == -1 ) return -1;
+
+		opt = str[1];
+
+		optind ++;
+		str = args[optind];
+	}
+	while ( ( opttolookfor = interestin.find(opt)) == -1 );
+
+	if ( interestin[opttolookfor+1] == ':' ) 
+	{
+
+		//strcpy(optarg, str.c_str());
+		optarg = args[optind];
+		optind ++;
+	}
+
+	//indicate we have finished
+	return opt[0];
+}
+#endif // !__MINGW32__
+
+#define timespec timeval
+
+//not available in win32
+struct itimerval
+{
+	timeval 	it_interval;
+	timeval 	it_value;
+};
+
+//win32 deals in usec not nsec - so need to ensure this follows through
+#define tv_nsec tv_usec 
+
+#ifndef __MINGW32__
+	typedef unsigned __int64 u_int64_t;
+	typedef unsigned __int64 uint64_t;
+	typedef __int64 int64_t;
+	typedef unsigned __int32 uint32_t;
+	typedef unsigned __int32 u_int32_t;
+	typedef __int32 int32_t;
+	typedef unsigned __int16 uint16_t;
+	typedef __int16 int16_t;
+	typedef unsigned __int8 uint8_t;
+	typedef __int8 int8_t;
+
+	typedef int socklen_t;
+#endif
+
+// I (re-)defined here for the moment; has to be removed later !!! 
+#ifndef BOX_VERSION
+#define BOX_VERSION "0.09hWin32"
+#endif
+
+#define S_IRGRP S_IWRITE
+#define S_IWGRP S_IREAD
+#define S_IROTH S_IWRITE | S_IREAD
+#define S_IWOTH S_IREAD | S_IREAD
+
+//again need to verify these
+#define S_IFLNK 1
+
+#define S_ISLNK(x) ( false )
+
+// nasty implementation to get working - TODO get the win32 equiv
+#ifdef _DEBUG
+#define getpid() 1
+#endif
+
+#define vsnprintf _vsnprintf
+
+#ifndef __MINGW32__
+typedef unsigned int mode_t;
+#endif
+
+inline int mkdir(const char *pathname, mode_t mode)
+{
+	return mkdir(pathname);
+}
+
+#ifdef __MINGW32__
+	#include <dirent.h>
+#else
+	inline int strcasecmp(const char *s1, const char *s2)
+	{
+		return _stricmp(s1,s2);
+	}
+
+	struct dirent
+	{
+		char *d_name;
+	};
+
+	struct DIR
+	{
+		intptr_t		fd;	// filedescriptor
+		// struct _finddata_t	info;
+		struct _wfinddata_t	info;
+		// struct _finddata_t 	info;
+		struct dirent		result;	// d_name (first time null)
+		wchar_t			*name;	// null-terminated byte string
+	};
+
+	DIR *opendir(const char *name);
+	struct dirent *readdir(DIR *dp);
+	int closedir(DIR *dp);
+#endif
+
+HANDLE openfile(const char *filename, int flags, int mode);
+
+#define LOG_INFO 6
+#define LOG_WARNING 4
+#define LOG_ERR 3
+#define LOG_PID 0
+#define LOG_LOCAL6 0
+
+extern HANDLE gSyslogH;
+void MyReportEvent(LPCTSTR *szMsg, DWORD errinfo);
+inline void openlog(const char * daemonName, int, int)
+{
+	gSyslogH = RegisterEventSource(
+		NULL,  // uses local computer 
+		daemonName);    // source name
+	if (gSyslogH == NULL) 
+	{
+	}
+}
+
+inline void closelog(void)
+{
+	DeregisterEventSource(gSyslogH); 
+}
+
+void syslog(int loglevel, const char *fmt, ...);
+
+#ifndef __MINGW32__
+#define strtoll _strtoi64
+#endif
+
+inline unsigned int sleep(unsigned int secs)
+{
+	Sleep(secs*1000);
+	return(ERROR_SUCCESS);
+}
+
+#define INFTIM -1
+#define POLLIN 0x1
+#define POLLERR 0x8
+#define POLLOUT 0x4
+
+#define SHUT_RDWR SD_BOTH
+#define SHUT_RD SD_RECEIVE
+#define SHUT_WR SD_SEND
+
+struct pollfd
+{
+	SOCKET fd;
+	short int events;
+	short int revents;
+};
+
+inline int ioctl(SOCKET sock, int flag,  int * something)
+{
+	//indicate success
+	return 0;
+}
+
+inline int waitpid(pid_t pid, int *status, int)
+{
+	return 0;
+}
+
+//this shouldn't be needed.
+struct statfs
+{
+	TCHAR f_mntonname[MAX_PATH];
+};
+
+// I think this should get us going
+// Although there is a warning about 
+// mount points in win32 can now exists - which means inode number can be 
+// duplicated, so potential of a problem - perhaps this needs to be 
+// implemented with a little more thought... TODO
+
+struct stat {
+	//_dev_t st_dev;
+	u_int64_t st_ino;
+	DWORD st_mode;
+	short st_nlink;
+	short st_uid;
+	short st_gid;
+	//_dev_t st_rdev;
+	u_int64_t st_size;
+	time_t st_atime;
+	time_t st_mtime;
+	time_t st_ctime;
+};
+
+#ifndef __MINGW32__
+typedef u_int64_t _ino_t;
+#endif
+
+int ourstat(const char * name, struct stat * st);
+int ourfstat(HANDLE file, struct stat * st);
+int statfs(const char * name, struct statfs * s);
+
+//need this for converstions
+inline time_t ConvertFileTimeToTime_t(FILETIME *fileTime)
+{
+	SYSTEMTIME stUTC;
+	struct tm timeinfo;
+
+	// Convert the last-write time to local time.
+	FileTimeToSystemTime(fileTime, &stUTC);
+	// SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
+	
+	timeinfo.tm_sec = stUTC.wSecond;
+	timeinfo.tm_min = stUTC.wMinute;
+	timeinfo.tm_hour = stUTC.wHour;
+	timeinfo.tm_mday = stUTC.wDay;
+	timeinfo.tm_wday = stUTC.wDayOfWeek;
+	timeinfo.tm_mon = stUTC.wMonth - 1;
+	// timeinfo.tm_yday = ...;
+	timeinfo.tm_year = stUTC.wYear - 1900;
+
+	time_t retVal = mktime(&timeinfo);
+	return retVal;
+}
+
+#define stat(x,y) ourstat(x,y)
+#define fstat(x,y) ourfstat(x,y)
+#define lstat(x,y) ourstat(x,y)
+
+int poll (struct pollfd *ufds, unsigned long nfds, int timeout);
+bool EnableBackupRights( void );
+
+//
+// MessageId: MSG_ERR_EXIST
+// MessageText:
+//  Box Backup.
+//
+#define MSG_ERR_EXIST                         ((DWORD)0xC0000004L)
+
+#endif // !EMU_INCLUDE && WIN32