filebackupe.h

实时文件备份

// FileBackup.h: interface for the CFileBackupE class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_FILEBACKUP_H__F916F369_A31D_4BF8_9575_6EA5C0792A4E__INCLUDED_)
#define AFX_FILEBACKUP_H__F916F369_A31D_4BF8_9575_6EA5C0792A4E__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <afxtempl.h>
#include "IoCtlCmd.h"

#define BASIC_ERROR(n)									(0x00 + (n))
#define CHANGESHANDLER_ERROR(n)							(0x40 + (n))
#define DATABASETHREAD_ERROR(n)							(0x80 + (n))
#define FILECOPYTHREAD_ERROR(n)							(0xC0 + (n))

#define LOAD_VXD_ERROR									BASIC_ERROR(1)
#define CHANGESHANDLER_MULTIBYTETOWIDECHAR_ERROR		CHANGESHANDLER_ERROR(1)
#define CHANGESHANDLER_WIDECHARTOMULTIBYTE_ERROR		CHANGESHANDLER_ERROR(2)
#define CHANGESHANDLER_GETLONGPATHNAME_ERROR			CHANGESHANDLER_ERROR(3)
#define CHANGESHANDLER_PATHNAMETOOLONG_ERROR			CHANGESHANDLER_ERROR(4)
#define CHANGESHANDLER_POSTFILECHANGES_ERROR			CHANGESHANDLER_ERROR(5)

typedef struct __tag_FileBackup_Callback_Param
{
	DWORD				m_dwCallbackType;
	LPCTSTR				m_pString;
	LPCTSTR				m_pString2;
	DWORD				m_dwPercentageOrErrorCode;	//	percentage or error code
	__int64				m_i64BytesAccessed;
} FILEBACKUP_CALLBACK_PARAM, *PFILEBACKUP_CALLBACK_PARAM;
typedef DWORD (WINAPI *LPFILEBACKUP_CALLBACK)(PFILEBACKUP_CALLBACK_PARAM lParam);

typedef struct __tag_FileBackup_FileChanges_Information
{
	struct __tag_FileBackup_FileChanges_Information*	m_pNext;
	time_t												m_tTime;
	BOOL												m_fNew;
	int													m_nBasePathLength;
	int													m_nPathnameLength;
	TCHAR												m_tsPathname[1];
} FILECHANGES_INFORMATION, *PFILECHANGES_INFORMATION;

#define	UWM_MYMESSAGE(n)				(WM_APP + 0x0040 + (n))
#define UWM_DESTROY_WORKERTHREAD		UWM_MYMESSAGE(1)
#define UWM_START_LOGGING_FILE_CHANGES	UWM_MYMESSAGE(2)
#define UWM_STOP_LOGGING_FILE_CHANGES	UWM_MYMESSAGE(3)
#define UWM_POST_FILE_CHANGES			UWM_MYMESSAGE(4)


inline char LOWER(char x) { return ((x) >= 'A' && (x) <= 'Z' ? (x) - 'A' + 'a' : (x)); }
inline WCHAR LOWER(WCHAR x) { return ((x) >= L'A' && (x) <= L'Z' ? (x) - L'A' + L'a' : (x)); }
//#define LOWER(x)		((x) >= _T('A') && (x) <= _T('Z') ? (x) - _T('A') + _T('a') : (x))


class CFileBackupE
{
public:	//	CMemoryException, CSimpleException
	class CVxDException : public ::CException
	{
//		DECLARE_DYNAMIC(CVxDException)
#ifdef _AFXDLL
		protected:
			static CRuntimeClass* PASCAL _GetBaseClass();
		public:
			static const AFX_DATA CRuntimeClass classCFileBackup_CVxDException;
			virtual CRuntimeClass* GetRuntimeClass() const;
#else
		public:
			static const AFX_DATA CRuntimeClass classCFileBackup_CVxDException;
			virtual CRuntimeClass* GetRuntimeClass() const;
#endif

	public:
		inline CVxDException() : CException(), m_dwErrorCode(0)
		{
			_tcscpy(m_tsMessage, _T("Failed in loading VxD driver to hook file system..."));
		}

		inline CVxDException(BOOL bAutoDelete) : CException(bAutoDelete), m_dwErrorCode(0)
		{
			_tcscpy(m_tsMessage, _T("Failed in loading VxD driver to hook file system..."));
		}

		inline CVxDException(BOOL bAutoDelete, DWORD dwErrorCode) : CException(bAutoDelete), m_dwErrorCode(dwErrorCode)
		{
			_stprintf(m_tsMessage, _T("Failed in loading VxD driver to hook file system: 0x%08X"), dwErrorCode);
		}

		inline CVxDException(BOOL bAutoDelete, LPCTSTR ptsFilename) : CException(bAutoDelete)
		{
			_stprintf(m_tsMessage, _T("Failed in loading VxD driver (%s) to hook file system..."), ptsFilename);
		}

		inline CVxDException(BOOL bAutoDelete, DWORD dwErrorCode, LPCTSTR ptsFilename) : CException(bAutoDelete), m_dwErrorCode(dwErrorCode)
		{
			_stprintf(m_tsMessage, _T("Failed in loading VxD driver (%s) to hook file system: 0x%08X"), ptsFilename, dwErrorCode);
		}

		virtual ~CVxDException()
		{
		}

		virtual BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, PUINT pnHelpContext = NULL)
		{
			ASSERT(lpszError != NULL && AfxIsValidString(lpszError, nMaxError));

			if ( pnHelpContext != NULL )
				*pnHelpContext = 0;

			lstrcpyn(lpszError, m_tsMessage, nMaxError);

			return TRUE;
		}

	protected:
		TCHAR m_tsMessage[128 + MAX_PATH];
		DWORD m_dwErrorCode;
	};

	class CGlobalInit
	{
	public:
		inline CGlobalInit()
		{
			m_dwVersion = GetVersion();

#ifdef _DEBUG
			InitializeCriticalSection(&m_objDebugOutputCriticalSection);
#endif
		}

		inline ~CGlobalInit()
		{
#ifdef _DEBUG
			DeleteCriticalSection(&m_objDebugOutputCriticalSection);
#endif
		}

		inline BOOL IsNT() { return m_dwVersion < 0x80000000; }

#ifdef _DEBUG
		inline void DebugPrint(LPCTSTR lpszFormat, ...)
		{
			va_list argList;
			CString csMessage;

			va_start(argList, lpszFormat);
			csMessage.FormatV(lpszFormat, argList);

			if ( !csMessage.IsEmpty() && csMessage.GetLength() > 0 )
			{
				EnterCriticalSection(&m_objDebugOutputCriticalSection);
				_tprintf((LPCTSTR)csMessage);
				LeaveCriticalSection(&m_objDebugOutputCriticalSection);
			}

			va_end(argList);
		}
#endif

	protected:
		DWORD						m_dwVersion;

#ifdef _DEBUG
		CRITICAL_SECTION			m_objDebugOutputCriticalSection;
#endif
	};

	class CFilenameMaskList
	{
	public:
		class CFilenameMask
		{
		public:
			typedef enum
			{
				SYNC_FILE_MASK_TYPE_OTHER				= 0,
				SYNC_FILE_MASK_TYPE_ALL					= 1,
				SYNC_FILE_MASK_TYPE_EXT					= 2,
			} FILE_MASK_TYPE;

			inline CFilenameMask() : m_enumType(SYNC_FILE_MASK_TYPE_OTHER), m_nMaskLen(0), m_nRequiredLen(0) {}
			inline CFilenameMask(LPCTSTR pcstrMask) { *this = pcstrMask; }

			inline void Reset() { m_csMask.Empty(); m_enumType = SYNC_FILE_MASK_TYPE_OTHER; m_nMaskLen = m_nRequiredLen = 0; }

			inline CFilenameMask& operator =(LPCTSTR pcstrMask)
			{
				LPCTSTR pStart;

				if ( IsAllMask(pcstrMask) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_ALL;
					m_csMask.Empty();
				}
				else if ( IsExtMask(pcstrMask, &pStart) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_EXT;
					m_csMask = pStart;
				}
				else
				{
					LPCTSTR pMask;

					m_enumType = SYNC_FILE_MASK_TYPE_OTHER;
					m_csMask = CleanMask(pcstrMask);

					pMask = m_csMask;
					m_nRequiredLen = 0;
					while ( *pMask != NULL )
					{
						if ( *pMask != _T('*') && *pMask != _T('?') )
							m_nRequiredLen++;
						pMask++;
					}
				}
				m_nMaskLen = m_csMask.GetLength();
				m_csMask.MakeLower();
				return *this;
			}

			inline BOOL operator ==(LPCTSTR pcstrMask) const
			{
				LPCTSTR pStart;

				if ( IsAllMask(pcstrMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL;
				else if ( IsExtMask(pcstrMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT && m_csMask.CompareNoCase(pStart) == 0;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER && m_csMask.CompareNoCase(CleanMask(pcstrMask)) == 0;
			}

			inline BOOL operator ==(const CFilenameMask& mask) const
			{
				return m_enumType == mask.m_enumType && m_csMask.Compare(mask.m_csMask) == 0;
			}

			inline BOOL operator !=(const CFilenameMask& mask) const
			{
				return !(*this == mask);
			}

			inline int Compare(LPCTSTR pcstrMask) const
			{
				LPCTSTR pStart;

				if ( IsAllMask(pcstrMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL ? 0 : 1;
				else if ( IsExtMask(pcstrMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT ? m_csMask.CompareNoCase(pStart) : m_enumType == SYNC_FILE_MASK_TYPE_ALL ? -1 : 1;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER ? m_csMask.CompareNoCase(CleanMask(pcstrMask)) : -1;
			}

			inline static BOOL IsAllMask(LPCTSTR pcstrMask)
			{
				BOOL fCharLimit;

				if ( pcstrMask == NULL || *pcstrMask == NULL )
					return TRUE;

				fCharLimit = TRUE;
				while ( *pcstrMask != NULL )
				{
					if ( *pcstrMask == _T('*') )
						fCharLimit = FALSE;
					else if ( *pcstrMask == _T('.') )
					{
						if ( fCharLimit )
							return FALSE;
						else
							fCharLimit = TRUE;
					}
					else if ( *pcstrMask != _T('?') )
						return FALSE;
					pcstrMask++;
				}
				return !fCharLimit;
			}

			inline static BOOL IsExtMask(LPCTSTR pcstrMask, LPCTSTR* ppStart = NULL)
			{
				BOOL fCharLimit;

				if ( pcstrMask == NULL || *pcstrMask == NULL )
					return FALSE;

				fCharLimit = TRUE;
				while ( *pcstrMask != NULL )
				{
					if ( *pcstrMask == _T('*') )
						fCharLimit = FALSE;
					else if ( *pcstrMask == _T('.') )
					{
						if ( fCharLimit )
							return FALSE;
						else
						{
							if ( *++pcstrMask == NULL )
								return FALSE;
							if ( ppStart != NULL )
								*ppStart = pcstrMask;
							do
							{
								if ( *pcstrMask == _T('*') || *pcstrMask == _T('?') || *pcstrMask == _T('.') )
									return FALSE;
							} while ( *++pcstrMask != NULL );
							return TRUE;
						}
					}
					else if ( *pcstrMask != _T('?') )
						return FALSE;
					pcstrMask++;
				}
				return FALSE;
			}

			inline static CString CleanMask(LPCTSTR pcstrMask)
			{
				CString csNewMask;
				int nOrgMaskLen = _tcslen(pcstrMask);
				LPCTSTR pOrgMask = pcstrMask;
				LPTSTR pNewMask = csNewMask.GetBuffer(nOrgMaskLen + 1);
				int nQuestionMarkLen = 0;

				while ( *pOrgMask != NULL )
				{
					if ( *pOrgMask == _T('*') )
					{
						*pNewMask++ = _T('*');
						nQuestionMarkLen = 0;
						while ( *pOrgMask == _T('*') || *pOrgMask == _T('?') )
							pOrgMask++;
						continue;
					}
					else if ( *pOrgMask == _T('?') )
						nQuestionMarkLen++;
					else
					{
						while ( nQuestionMarkLen > 0 )
						{
							*pNewMask++ = _T('?');
							nQuestionMarkLen--;
						}
						*pNewMask++ = *pOrgMask;
					}
					pOrgMask++;
				}

				*pNewMask = NULL;
				csNewMask.ReleaseBuffer();
				return csNewMask;
			}

			static BOOL IsSubNameMatch(LPCTSTR pcstrMask, LPCTSTR pcstrName);
			static BOOL IsSubNameMatchWithoutDot(LPCTSTR pcstrMask, LPCTSTR pcstrName);

			inline BOOL IsNameMatch(LPCTSTR pcstrName) const
			{
				if ( pcstrName == NULL )
					return FALSE;

				if ( m_enumType == SYNC_FILE_MASK_TYPE_ALL )
					return TRUE;

				if ( m_enumType == SYNC_FILE_MASK_TYPE_EXT )
				{
					int nNameLen = _tcslen(pcstrName);
					LPCTSTR pName;

					if ( m_nMaskLen >= nNameLen )
						return FALSE;
					pName = pcstrName + nNameLen - m_nMaskLen;
					return *(pName - 1) == _T('.') && m_csMask.CompareNoCase(pName) == 0;
				}

				{
					LPCTSTR pMask = m_csMask;
					LPCTSTR pOrgName = pcstrName;
					TCHAR tsNameDuplicate[MAX_PATH];
					LPTSTR pName = tsNameDuplicate;
					int nDotCount = 0;

					while ( *pOrgName != NULL )
						if ( *pOrgName >= _T('A') && *pOrgName <= _T('Z') )
							*pName++ = *pOrgName++ + _T('a') - _T('A');
						else if ( *pOrgName == _T('.') )
						{
							*pName++ = _T('.');
							pOrgName++;
							nDotCount++;
						}
						else
							*pName++ = *pOrgName++;
					*pName = NULL;
					while ( pName > tsNameDuplicate && *(pName - 1) == _T('.') )
					{
							*--pName = NULL;
							nDotCount--;
					}
					if ( pName == tsNameDuplicate )
						return FALSE;
					pName = tsNameDuplicate;
					if ( nDotCount != 0 )
					{
						while ( *pMask != NULL )
						{
							if ( *pMask == _T('*') || *pMask == _T('?') )
								return IsSubNameMatch(pMask, pName);
							else if ( *pMask != *pName )
								return FALSE;
							pName++;
							pMask++;
						}
						return *pName == NULL;	//	*pMask == NULL
					}
					else
					{
						while ( *pMask != NULL )
						{
							if ( *pMask == _T('*') || *pMask == _T('?') )