filebackup.h

实时文件备份

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

#if !defined(AFX_FILEBACKUP_H__31C56BDA_1D96_4AB3_96A0_38649ECD6FDE__INCLUDED_)
#define AFX_FILEBACKUP_H__31C56BDA_1D96_4AB3_96A0_38649ECD6FDE__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);


#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)

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;


inline TCHAR LOWER(TCHAR x) { return ((x) >= _T('A') && (x) <= _T('Z') ? (x) + (_T('a') - _T('A')) : (x)); }
inline TCHAR UPPER(TCHAR x) { return ((x) >= _T('a') && (x) <= _T('z') ? (x) - (_T('a') - _T('A')) : (x)); }

class CFileBackup
{
public:
	class CFilenameMaskListA
	{
	public:
		class CFilenameMaskA
		{
		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 CFilenameMaskA() : m_psMask(NULL), m_nMaskLen(0), m_nRequiredLen(0), m_enumType(SYNC_FILE_MASK_TYPE_OTHER) {}
			inline CFilenameMaskA(LPCSTR pcsMask) { *this = pcsMask; }
			inline CFilenameMaskA(LPCWSTR pcwsMask) { *this = pcwsMask; }

			inline ~CFilenameMaskA() { MaskStringEmpty(); }

			inline void MaskStringEmpty() { if ( m_psMask != NULL ) delete[] m_psMask; m_psMask = NULL; m_nMaskLen = 0; m_nRequiredLen = 0; }
			inline DWORD MaskStringGetLength() const { return m_nMaskLen; }
			inline void MaskStringMakeLower()
			{
				LPSTR ps = m_psMask;

				while ( *ps != NULL )
				{
					if ( *ps >= 'A' && *ps <= 'Z' )
						*ps = *ps + ('a' - 'A');
					ps++;
				}
			}
			inline void MaskStringMakeUpper()
			{
				LPSTR ps = m_psMask;

				while ( *ps != NULL )
				{
					if ( *ps >= 'a' && *ps <= 'z' )
						*ps = *ps - 'a' + 'A';
					ps++;
				}
			}
			inline BOOL MaskStringSetValue(LPCSTR psValue)
			{
				MaskStringEmpty();
				if ( psValue != NULL && *psValue != NULL )
				{
					m_nMaskLen = ::strlen(psValue);
					m_psMask = new char[m_nMaskLen + 1];
					::memcpy(m_psMask, psValue, m_nMaskLen + 1);
					return TRUE;
				}
				else
					return FALSE;
			}
			inline BOOL MaskStringSetValue(LPCWSTR pwsValue)
			{
				MaskStringEmpty();
				if ( pwsValue != NULL && *pwsValue != NULL )
				{
					int nLen;

					nLen = ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, pwsValue, -1, NULL, 0, NULL, NULL);
					if ( nLen == 0 )
						return FALSE;
					m_psMask = new char[nLen];
					m_nMaskLen = ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, pwsValue, -1, m_psMask, nLen, NULL, NULL);
					if ( m_nMaskLen == 0 )
					{
						delete[] m_psMask;
						m_psMask = NULL;
						return FALSE;
					}
					else
						return TRUE;
				}
				else
					return FALSE;
			}

			inline int MaskStringCompareNoCase(LPCSTR psStr) const
			{
				return ::stricmp(m_psMask, psStr);
			}
			inline int MaskStringCompareNoCase(LPCWSTR pwsStr) const
			{
				char sStr[MAX_PATH];

				if ( ::WideCharToMultiByte(CFileBackup::GetCodePage(), 0, pwsStr, -1, sStr, sizeof(sStr), NULL, NULL) == 0 )
					return 1;
				else
					return ::stricmp(m_psMask, sStr);
			}

			inline void Reset() { MaskStringEmpty(); m_enumType = SYNC_FILE_MASK_TYPE_OTHER; }

			inline CFilenameMaskA& operator =(LPCSTR pcsMask)
			{
				LPCSTR pStart;

				if ( IsAllMask(pcsMask) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_ALL;
					MaskStringEmpty();
				}
				else if ( IsExtMask(pcsMask, &pStart) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_EXT;
					MaskStringSetValue(pStart);
				}
				else
				{
					char sCleanMask[MAX_PATH];
					LPCSTR pMask;

					m_enumType = SYNC_FILE_MASK_TYPE_OTHER;
					MaskStringSetValue(CleanMask(pcsMask, sCleanMask));

					pMask = m_psMask;
					m_nRequiredLen = 0;
					while ( *pMask != NULL )
					{
						if ( *pMask != '*' && *pMask != '?' )
							m_nRequiredLen++;
						pMask++;
					}
				}
				MaskStringMakeLower();
				return *this;
			}
			inline CFilenameMaskA& operator =(LPCWSTR pcwsMask)
			{
				LPCWSTR pStart;

				if ( IsAllMask(pcwsMask) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_ALL;
					MaskStringEmpty();
				}
				else if ( IsExtMask(pcwsMask, &pStart) )
				{
					m_enumType = SYNC_FILE_MASK_TYPE_EXT;
					MaskStringSetValue(pStart);
				}
				else
				{
					WCHAR wsCleanMask[MAX_PATH];
					LPCSTR pMask;

					m_enumType = SYNC_FILE_MASK_TYPE_OTHER;
					MaskStringSetValue(CleanMask(pcwsMask, wsCleanMask));

					pMask = m_psMask;
					m_nRequiredLen = 0;
					while ( *pMask != NULL )
					{
						if ( *pMask != '*' && *pMask != '?' )
							m_nRequiredLen++;
						pMask++;
					}
				}
				MaskStringMakeLower();
				return *this;
			}

			inline BOOL operator ==(LPCSTR pcsMask) const
			{
				LPCSTR pStart;
				char sCleanMask[MAX_PATH];

				if ( IsAllMask(pcsMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL;
				else if ( IsExtMask(pcsMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT && MaskStringCompareNoCase(pStart) == 0;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER && MaskStringCompareNoCase(CleanMask(pcsMask, sCleanMask)) == 0;
			}
			inline BOOL operator ==(LPCWSTR pcwsMask) const
			{
				LPCWSTR pStart;
				WCHAR wsCleanMask[MAX_PATH];

				if ( IsAllMask(pcwsMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL;
				else if ( IsExtMask(pcwsMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT && MaskStringCompareNoCase(pStart) == 0;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER && MaskStringCompareNoCase(CleanMask(pcwsMask, wsCleanMask)) == 0;
			}

			inline BOOL operator ==(const CFilenameMaskA& mask) const
			{
				return m_enumType == mask.m_enumType && m_nMaskLen == mask.m_nMaskLen && m_nRequiredLen == mask.m_nRequiredLen && MaskStringCompareNoCase(mask.m_psMask) == 0;
			}

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

			inline int Compare(LPCSTR pcsMask) const
			{
				LPCSTR pStart;
				char sCleanMask[MAX_PATH];

				if ( IsAllMask(pcsMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL ? 0 : 1;
				else if ( IsExtMask(pcsMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT ? MaskStringCompareNoCase(pStart) : m_enumType == SYNC_FILE_MASK_TYPE_ALL ? -1 : 1;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER ? MaskStringCompareNoCase(CleanMask(pcsMask, sCleanMask)) : -1;
			}
			inline int Compare(LPCWSTR pcwsMask) const
			{
				LPCWSTR pStart;
				WCHAR wsCleanMask[MAX_PATH];

				if ( IsAllMask(pcwsMask) )
					return m_enumType == SYNC_FILE_MASK_TYPE_ALL ? 0 : 1;
				else if ( IsExtMask(pcwsMask, &pStart) )
					return m_enumType == SYNC_FILE_MASK_TYPE_EXT ? MaskStringCompareNoCase(pStart) : m_enumType == SYNC_FILE_MASK_TYPE_ALL ? -1 : 1;
				else
					return m_enumType == SYNC_FILE_MASK_TYPE_OTHER ? MaskStringCompareNoCase(CleanMask(pcwsMask, wsCleanMask)) : -1;
			}

			inline static BOOL IsAllMask(LPCSTR pcsMask)
			{
				BOOL fCharLimit;

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

				fCharLimit = TRUE;
				while ( *pcsMask != NULL )
				{
					if ( *pcsMask == '*' )
						fCharLimit = FALSE;
					else if ( *pcsMask == '.' )
					{
						if ( fCharLimit )
							return FALSE;
						else
							fCharLimit = TRUE;
					}
					else if ( *pcsMask != '?' )
						return FALSE;
					pcsMask++;
				}
				return !fCharLimit;
			}
			inline static BOOL IsAllMask(LPCWSTR pcwsMask)
			{
				BOOL fCharLimit;

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

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

			inline static BOOL IsExtMask(LPCSTR pcsMask, LPCSTR* ppStart = NULL)
			{
				BOOL fCharLimit;

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

				fCharLimit = TRUE;
				while ( *pcsMask != NULL )
				{
					if ( *pcsMask == '*' )
						fCharLimit = FALSE;
					else if ( *pcsMask == '.' )
					{
						if ( fCharLimit )
							return FALSE;
						else
						{
							if ( *++pcsMask == NULL )
								return FALSE;
							if ( ppStart != NULL )
								*ppStart = pcsMask;
							do
							{
								if ( *pcsMask == '*' || *pcsMask == '?' || *pcsMask == '.' )
									return FALSE;
							} while ( *++pcsMask != NULL );
							return TRUE;
						}
					}
					else if ( *pcsMask != '?' )
						return FALSE;
					pcsMask++;
				}
				return FALSE;
			}
			inline static BOOL IsExtMask(LPCWSTR pcwsMask, LPCWSTR* ppStart = NULL)
			{
				BOOL fCharLimit;

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

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

			inline static LPCSTR CleanMask(LPCSTR pcsMask, LPSTR pcsNewMask)
			{
				LPSTR pNewMask = pcsNewMask;
				int nQuestionMarkLen = 0;

				while ( *pcsMask != NULL )
				{
					if ( *pcsMask == '*' )
					{
						*pNewMask++ = '*';
						nQuestionMarkLen = 0;
						while ( *pcsMask == '*' || *pcsMask == '?' )
							pcsMask++;
						continue;
					}
					else if ( *pcsMask == '?' )
						nQuestionMarkLen++;
					else
					{
						while ( nQuestionMarkLen > 0 )
						{
							*pNewMask++ = '?';
							nQuestionMarkLen--;
						}
						*pNewMask++ = *pcsMask;
					}
					pcsMask++;
				}
				*pNewMask = NULL;
				return pcsNewMask;
			}
			inline static LPCWSTR CleanMask(LPCWSTR pcwsMask, LPWSTR pcwsNewMask)
			{
				LPWSTR pNewMask = pcwsNewMask;
				int nQuestionMarkLen = 0;

				while ( *pcwsMask != NULL )
				{
					if ( *pcwsMask == L'*' )
					{
						*pNewMask++ = L'*';
						nQuestionMarkLen = 0;
						while ( *pcwsMask == L'*' || *pcwsMask == L'?' )
							pcwsMask++;
						continue;
					}
					else if ( *pcwsMask == L'?' )
						nQuestionMarkLen++;
					else
					{
						while ( nQuestionMarkLen > 0 )
						{
							*pNewMask++ = L'?';
							nQuestionMarkLen--;
						}
						*pNewMask++ = *pcwsMask;
					}
					pcwsMask++;
				}
				*pNewMask = NULL;
				return pcwsNewMask;
			}
/*			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('?') )