filebackupe.cpp

实时文件备份

													pThis->m_pCallback(&param);
												}
												CLargeBufferBlockBank::Free(pPostDataPage);
												pPostDataPage = NULL;
												break;
											}
											else
												pPostDataPage = NULL;
										}
									}
									if ( pPostDataPage == NULL )
									{
										pPostInfo = (PFILECHANGES_INFORMATION)(pPostDataPage = CLargeBufferBlockBank::Allocate());
										pPrevPostInfo = NULL;
									}
									pPostInfo->m_pNext = (PFILECHANGES_INFORMATION)((LPBYTE)pPostInfo + sizeof(*pPostInfo) + nPathnameLength * sizeof(TCHAR));
									pPostInfo->m_tTime = tCurrent;
									pPostInfo->m_fNew = pNotifyInfo->Action == FILE_ACTION_MODIFIED ? FALSE : TRUE;
									pPostInfo->m_nBasePathLength = pAccessoryItem->m_csPath.GetLength();
									pPostInfo->m_nPathnameLength = nPathnameLength;
									memcpy(pPostInfo->m_tsPathname, ptsTemp, (nPathnameLength + 1) * sizeof(TCHAR));
									pPrevPostInfo = pPostInfo;
									pPostInfo = pPostInfo->m_pNext;
								}
							}
						}
/*
						if ( n != 0 )
						{
							//	Get Long File Path
							pwsTemp = (PWCHAR)pTempStringBuffer;
							*pwsTemp++ = L'\\';
							*pwsTemp++ = L'\\';
							*pwsTemp++ = L'?';
							*pwsTemp++ = L'\\';
#ifdef UNICODE								
							lstrcpyW(pwsTemp, (LPCWSTR)pAccessoryItem->m_csPath);
							pwsTemp += pAccessoryItem->m_csPath.GetLength();
#else
							if ( (pwsTemp += MultiByteToWideChar(CP_THREAD_ACP, 0, (LPCSTR)pAccessoryItem->m_csPath, pAccessoryItem->m_csPath.GetLength() + 1, pwsTemp, CLargeBufferBlockBank::GetBlockSize() - 4 * sizeof(WCHAR))) == (PWCHAR)pTempStringBuffer + 4 )
							{
								if ( pThis->m_pCallback )
								{
									FILEBACKUP_CALLBACK_PARAM param = {CHANGESHANDLER_MULTIBYTETOWIDECHAR_ERROR, (LPCTSTR)pAccessoryItem->m_csPath, NULL, ::GetLastError(), 0};

									pThis->m_pCallback(&param);
								}
								goto NEXT_NOTIFY_INFO;
							}
#endif
							lstrcpynW(pwsTemp, pNotifyInfo->FileName, (pNotifyInfo->FileNameLength >> 1) + 1);
							if ( (nPathnameLength = GetLongPathNameW((PWCHAR)pTempStringBuffer, (PWCHAR)pTempStringBuffer, CLargeBufferBlockBank::GetBlockSize())) == 0 )
							{
								if ( pThis->m_pCallback )
								{
									FILEBACKUP_CALLBACK_PARAM param = {CHANGESHANDLER_GETLONGPATHNAME_ERROR, (LPCTSTR)pTempStringBuffer, NULL, ::GetLastError(), 0};

#ifndef UNICODE
									WideCharToMultiByte(CP_THREAD_ACP, 0, (LPCWSTR)pTempStringBuffer + 4, lstrlenW((LPCWSTR)pTempStringBuffer + 4), (LPSTR)pTempStringBuffer, CLargeBufferBlockBank::GetBlockSize(), NULL, NULL);
#endif
									pThis->m_pCallback(&param);
								}
								goto NEXT_NOTIFY_INFO;
							}
							//	Put into post buffer;
#ifdef UNICODE
							nPathnameLength -= 4;
							if ( sizeof(*pPostInfo) + nPathnameLength * sizeof(WCHAR) > CLargeBufferBlockBank::GetBlockSize() )
							{
								if ( pThis->m_pCallback )
								{
									FILEBACKUP_CALLBACK_PARAM param = {CHANGESHANDLER_PATHNAMETOOLONG_ERROR, (LPCTSTR)pTempStringBuffer + 4, NULL, ERROR_NOT_SUPPORTED, 0};

									pThis->m_pCallback(&param);
								}
								goto NEXT_NOTIFY_INFO;
							}
#else
							if ( (nPathnameLength = WideCharToMultiByte(CP_THREAD_ACP, 0, (LPCWSTR)pTempStringBuffer + 4, nPathnameLength - 4 + 1, (LPSTR)pTempStringBuffer, CLargeBufferBlockBank::GetBlockSize(), NULL, NULL)) == 0 )
							{
								if ( pThis->m_pCallback )
								{
									FILEBACKUP_CALLBACK_PARAM param = {CHANGESHANDLER_WIDECHARTOMULTIBYTE_ERROR, (LPCTSTR)pTempStringBuffer, NULL, ::GetLastError(), 0};

									pThis->m_pCallback(&param);
								}
								goto NEXT_NOTIFY_INFO;
							}
							nPathnameLength--;
#endif
							if ( pPostDataPage != NULL && (LPBYTE)pPostDataPage + CLargeBufferBlockBank::GetBlockSize() < (LPBYTE)pPostInfo + sizeof(*pPostInfo) + nPathnameLength * sizeof(TCHAR) )
							{
								pPostInfo->m_pNext = 0;
								if ( !pThis->m_pDatabassAccessThread->PostFileChanges(pPostDataPage) )
								{
									if ( pThis->m_pCallback )
									{
										FILEBACKUP_CALLBACK_PARAM param = {CHANGESHANDLER_POSTFILECHANGES_ERROR, NULL, NULL, ::GetLastError(), 0};

										pThis->m_pCallback(&param);
									}
									CLargeBufferBlockBank::Free(pPostDataPage);
									pPostDataPage = NULL;
									break;
								}
								else
									pPostDataPage = NULL;
							}
							if ( pPostDataPage == NULL )
								pPostInfo = (PFILECHANGES_INFORMATION)(pPostDataPage = CLargeBufferBlockBank::Allocate());
							pPostInfo->m_pNext = (PFILECHANGES_INFORMATION)((LPBYTE)pPostInfo + sizeof(*pPostInfo) + nPathnameLength * sizeof(TCHAR));
							pPostInfo->m_tTime = tCurrent;
							pPostInfo->m_nBasePathLength = pAccessoryItem->m_csPath.GetLength();
							pPostInfo->m_nPathnameLength = nPathnameLength;
#ifdef UNICODE
							memcpy(pPostInfo->m_tsPathname, (LPCWSTR)pTempStringBuffer + 4, (nPathnameLength + 1) * sizeof(WCHAR));
#else
							memcpy(pPostInfo->m_tsPathname, pTempStringBuffer, nPathnameLength + 1);
#endif
							pPostInfo = pPostInfo->m_pNext;
						}
						//	It's long file path already
						else
						{
						}
*/

NEXT_NOTIFY_INFO:
						if ( pNotifyInfo->NextEntryOffset == 0 )
							break;
						pNotifyInfo = (PFILE_NOTIFY_INFORMATION)((LPBYTE)pNotifyInfo + pNotifyInfo->NextEntryOffset);
					}
					if ( pPostDataPage != NULL )
					{
						if ( pPrevPostInfo == NULL || (DWORD)pPostInfo == (DWORD)pPostDataPage )
							CLargeBufferBlockBank::Free(pPostDataPage);
						else
						{
							pPrevPostInfo->m_pNext = NULL;
							if ( !pThis->m_pDatabassAccessThread->PostFileChanges(pPostDataPage) )
							{
								if ( pThis->m_pCallback )
								{
									FILEBACKUP_CALLBACK_PARAM param = {CHANGESHANDLER_POSTFILECHANGES_ERROR, NULL, NULL, ::GetLastError(), 0};

									pThis->m_pCallback(&param);
								}
								CLargeBufferBlockBank::Free(pPostDataPage);
							}
						}
					}
					CLargeBufferBlockBank::Free(pTempStringBuffer);
					CLargeBufferBlockBank::Free(pTempStringBufferForDirectory);

					ResetEvent(pThis->m_arrayHandleBank[nIndex]);
					ReadDirectoryChangesW(pThis->m_arrayAccessoryBank[nIndex].m_hFile, pThis->m_arrayAccessoryBank[nIndex].m_pBuffer, CLargeBufferBlockBank::GetBlockSize(), TRUE, FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE, NULL, &pThis->m_arrayAccessoryBank[nIndex].m_objOverlapped, NULL);
				}
		}
	}

	pThis->ExitInstance();
	return 0;
}

BOOL CFileBackupE::CFileCopyThreadWrapper::InitInstance()
{
	CFileBackupE::m_objInitObject.DebugPrint(_T("CFileBackupE::CFileCopyThreadWrapper::InitInstance()\n"));
	return TRUE;
}

DWORD CFileBackupE::CFileCopyThreadWrapper::ExitInstance()
{
	m_pThread = NULL;
	CFileBackupE::m_objInitObject.DebugPrint(_T("CFileBackupE::CFileCopyThreadWrapper::ExitInstance()\n"));
	return ERROR_SUCCESS;
}

UINT CFileBackupE::CFileCopyThreadWrapper::Win9xFileCopyThreadProc(CFileCopyThreadWrapper* pThis)
{
	DWORD dwWaitResult;
//	int nIndex;
	UINT nMsg;
	WPARAM wParam;
	LPARAM lParam;

	while ( 1 )
	{
		dwWaitResult = ::WaitForSingleObject(pThis->GetSemaphore(), INFINITE);
		if ( dwWaitResult == WAIT_OBJECT_0 )
		{
			//	Got message
			if ( pThis->GetFirstMessage(nMsg, wParam, lParam) )
			{
				switch ( nMsg )
				{
				case UWM_DESTROY_WORKERTHREAD:
					if ( wParam )
					{
//						((MESSAGE_RESULT*)wParam)->m_dwResult = pThis->ExitInstance();
						((MESSAGE_RESULT*)wParam)->m_dwResult = ERROR_SUCCESS;
						SetEvent(((MESSAGE_RESULT*)wParam)->m_hFinishedEvent);
					}
					else
					{
					}
					return ERROR_SUCCESS;
				}
			}
		}
		else
		{
			//	Something wrong with the message queue
			break;
		}
	}

	return ERROR_SUCCESS;
}

UINT CFileBackupE::CFileCopyThreadWrapper::WinNTFileCopyThreadProc(CFileCopyThreadWrapper* pThis)
{
	DWORD dwWaitResult;
//	int nIndex;
	UINT nMsg;
	WPARAM wParam;
	LPARAM lParam;

	while ( 1 )
	{
		dwWaitResult = ::WaitForSingleObject(pThis->GetSemaphore(), INFINITE);
		if ( dwWaitResult == WAIT_OBJECT_0 )
		{
			//	Got message
			if ( pThis->GetFirstMessage(nMsg, wParam, lParam) )
			{
				switch ( nMsg )
				{
				case UWM_DESTROY_WORKERTHREAD:
					if ( wParam )
					{
//						((MESSAGE_RESULT*)wParam)->m_dwResult = pThis->ExitInstance();
						((MESSAGE_RESULT*)wParam)->m_dwResult = ERROR_SUCCESS;
						SetEvent(((MESSAGE_RESULT*)wParam)->m_hFinishedEvent);
					}
					else
					{
					}
					return ERROR_SUCCESS;
				}
			}
		}
		else
		{
			//	Something wrong with the message queue
			break;
		}
	}

	return ERROR_SUCCESS;
}

BOOL CFileBackupE::CDatabaseAccessThread::InitInstance()
{
	if ( !m_objFileChangesHandler.IsThreadAvailable() && !m_objFileChangesHandler.CreateThread() )
		return FALSE;
	if ( !m_objFileCopyThreadWrapper.IsThreadAvailable() && !m_objFileCopyThreadWrapper.CreateThread() )
	{
		Sleep(10);
		m_objFileChangesHandler.TerminateThread();
		return FALSE;
	}
	return TRUE;
}

BOOL CFileBackupE::CDatabaseAccessThread::ExitInstance()
{
	DWORD dwRet1 = ERROR_SUCCESS, dwRet2 = ERROR_SUCCESS;

	if ( m_objFileChangesHandler.IsThreadAvailable() )
		dwRet1 = m_objFileChangesHandler.TerminateThread();
	if ( m_objFileCopyThreadWrapper.IsThreadAvailable() )
		dwRet2 = m_objFileCopyThreadWrapper.TerminateThread();
	if ( dwRet1 != ERROR_SUCCESS ) 
	{
		::SetLastError(dwRet1);
		return FALSE;
	}
	else if ( dwRet2 != ERROR_SUCCESS )
	{
		::SetLastError(dwRet2);
		return FALSE;
	}
	else
		return TRUE;
}

DWORD WINAPI FileBackupCallbackE(PFILEBACKUP_CALLBACK_PARAM lParam);
int TryCompileE(int argc, TCHAR* argv[])
{
/*
//	CFileBackupE objFileBackup;
	CFileBackupE::CFileFilter objFileFilter;
	struct
	{
		TCHAR*	tsFileFilter;
		TCHAR*	tsFilenameMask;
		BOOL	fIncludeFilenameMask;
		DWORD	dwFileAttributesMask;
		DWORD*	pdwFileAttributesMask;
		BOOL	fIncludeFileAttributesMask;
	}
	arrayIncludeFileFilters[] = {
//		{_T(""), _T(""), TRUE, 0, !NULL, TRUE},
		{_T("E:\\Working\\Test\\SyncTest\\Copy of Test1"), _T("*.rar;*.txt;*.gif"), TRUE, 0, NULL, TRUE},
		{_T("E:\\Working\\Test\\SyncTest\\Copy of Test2"), _T("*.gif"), FALSE, 0, NULL, TRUE},
	};
	struct
	{
		TCHAR*	tsFileFilter;
	}
	arrayExcludeFileFilters[] = {
//		{_T("")},
		{_T("E:\\Working\\Test\\SyncTest\\Copy of Test2\\DriverStudio 2.7.rar")},
		{_T("E:\\Working\\Test\\SyncTest\\Copy of Test2\\TestFolder")},
	};
	TCHAR* tsFilePathname[] = {
//		_T(""),
		_T("E:\\Working\\Test\\SyncTest\\temp"),
		_T("E:\\Working\\Test\\SyncTest\\Copy of Test1\\cnsf\\avatars\\016.gif"),
		_T("E:\\Working\\Test\\SyncTest\\Copy of Test1\\cnsf\\avatars\\index.html"),
		_T("E:\\Working\\Test\\SyncTest\\Copy of Test2\\cnsf\\avatars\\index.html"),
		_T("E:\\Working\\Test\\SyncTest\\Copy of Test2\\cnsf\\avatars\\016.gif"),
		_T("E:\\Working\\Test\\SyncTest\\Copy of Test2\\DriverStudio 2.7.rar"),
		_T("E:\\Working\\Test\\SyncTest\\Copy of Test2\\TestFolder\\Sample2.txt"),
	};
	int i;

	for ( i = 0; i < sizeof(arrayIncludeFileFilters) / sizeof(*arrayIncludeFileFilters); i++ )
		if ( arrayIncludeFileFilters[i].pdwFileAttributesMask )
			arrayIncludeFileFilters[i].pdwFileAttributesMask = &arrayIncludeFileFilters[i].dwFileAttributesMask;

	for ( i = 0; i < sizeof(arrayIncludeFileFilters) / sizeof(*arrayIncludeFileFilters); i++ )
	{
		if ( !objFileFilter.AddIncludePath(arrayIncludeFileFilters[i].tsFileFilter, arrayIncludeFileFilters[i].tsFilenameMask, arrayIncludeFileFilters[i].fIncludeFilenameMask, arrayIncludeFileFilters[i].pdwFileAttributesMask, arrayIncludeFileFilters[i].fIncludeFileAttributesMask) )
			std::cout << _T("Failed in add include path: ") << arrayIncludeFileFilters[i].tsFileFilter << std::endl;
	}
	for ( i = 0; i < sizeof(arrayExcludeFileFilters) / sizeof(*arrayExcludeFileFilters); i++ )
	{
		if ( !objFileFilter.AddExcludePath(arrayExcludeFileFilters[i].tsFileFilter) )
			std::cout << _T("Failed in add exclude path: ") << arrayExcludeFileFilters[i].tsFileFilter << std::endl;
	}
	for ( i = 0; i < sizeof(tsFilePathname) / sizeof(*tsFilePathname); i++ )
	{
		if ( objFileFilter.MatchFilePathname(tsFilePathname[i]) )
			std::cout << _T("  Succeed: ") << tsFilePathname[i] << std::endl;
		else
			std::cout << _T("  Fail: ") << tsFilePathname[i] << std::endl;
	}
	{
		CString csBasePath;
		CFileBackupE::CFileFilter::CParsedPathItem* pItem;

		if ( !objFileFilter.GetDriveBasePath(_T('E'), csBasePath, pItem) )
			std::cout << _T("Failed in GetDriveBasePath...") << std::endl;
		else
		{
			std::cout << _T("Get base path: ") << (LPCTSTR)csBasePath << std::endl;
			for ( i = 0; i < sizeof(tsFilePathname) / sizeof(*tsFilePathname); i++ )
			{
				if ( pItem->MatchFilePathname(tsFilePathname[i] + csBasePath.GetLength() + 1) )
					std::cout << _T("  Succeed: ") << tsFilePathname[i] << std::endl;
				else
					std::cout << _T("  Fail: ") << tsFilePathname[i] << std::endl;
			}
		}
	}
	return 0;
*/
	CFileBackupE::CDatabaseAccessThread  objDatabase(FileBackupCallbackE, FALSE);

	if ( objDatabase.CreateThread(THREAD_PRIORITY_ABOVE_NORMAL) )
	{
		Sleep(1000);
		objDatabase.TerminateThread();
	}
	else
		CFileBackupE::m_objInitObject.DebugPrint(_T("Failed in creating thread: 0x%08X\n"), GetLastError());

	return 0;
}

DWORD WINAPI FileBackupCallbackE(PFILEBACKUP_CALLBACK_PARAM lParam)
{
	switch ( lParam->m_dwCallbackType )
	{
	case LOAD_VXD_ERROR:
		CFileBackupE::m_objInitObject.DebugPrint(_T("Failed in loading VxD driver (%s) to hook file system: 0x%08X\n"), lParam->m_pString, lParam->m_dwPercentageOrErrorCode);
	}
	return PROGRESS_CONTINUE;
}