dirmon.bak.c

这个是FileBackup的一个组件

	while ( pItem )
	{
		pItemNext = pItem->pNext;
		if ( pItem < FREEFILEITEMSSTART || pItem >= FREEFILEITEMSEND )
			HeapFree(pItem, 0);
		pItem = pItemNext;
	}
	g_pFreeFileItems = NULL;
	Destroy_Semaphore(g_semFreeFileItems);
}

BOOL AllocateFileItem(PFILEITEM* ppFileItem)
{
	Wait_Semaphore(g_semFreeFileItems, BLOCK_SVC_INTS);
	if ( (*ppFileItem = g_pFreeFileItems) != NULL )
	{
		g_pFreeFileItems = g_pFreeFileItems->pNext;
		Signal_Semaphore(g_semFreeFileItems);
	}
	else
	{
		Signal_Semaphore(g_semFreeFileItems);
		if ( (*ppFileItem = HeapAllocate(sizeof(**ppFileItem), 0)) == NULL )
			return FALSE;
	}
	memset(*ppFileItem, 0, sizeof(**ppFileItem));
	return TRUE;
}

void FreeFileItem(PFILEITEM pFileItem)
{
	Wait_Semaphore(g_semFreeFileItems, BLOCK_SVC_INTS);
	pFileItem->pNext = g_pFreeFileItems;
	g_pFreeFileItems = pFileItem;
	Signal_Semaphore(g_semFreeFileItems);
}

void ParsedPath2PathName(path_t pParsedPath, int nDrive, int nCodePage, CHAR psPathName[MAX_PATH])
{
	int nStartPos = 0;
	_QWORD qdResult;

	if ( nDrive != 0xFF )
	{
		psPathName[0] = nDrive - 1 + 'A';
		psPathName[1] = ':';
		nStartPos = 2;
	}
	UniToBCSPath(psPathName + nStartPos, pParsedPath->pp_elements, MAX_PATH - 1, nCodePage == BCS_OEM ? BCS_OEM : BCS_WANSI, &qdResult);
}

#if PARSE_FILENAME_FROM_FILENUMBER
BOOL SFN2PathName(sfn_t nFileNumber, int nDrive, int nResType, int nCodePage, pioreq pIOreq, CHAR psPathName[MAX_PATH])
{
	ifsreq objIFSreq;
	CHAR cBuf[MAX_PATH * sizeof(unsigned short) + 2 * sizeof(unsigned short)];
	path_t pParsedPath = (path_t)cBuf;

//	DEBUG_FUNCTION_NAME("SFN2PathName");

	memcpy(&objIFSreq, pIOreq, sizeof(objIFSreq));
	objIFSreq.ifsir.ir_flags = ENUMH_GETFILENAME;
	objIFSreq.ifsir.ir_ppath = pParsedPath;
	if ( (*g_pPrevIFSHookProc)(objIFSreq.ifs_hndl->hf_misc->hm_func[HM_ENUMHANDLE], IFSFN_ENUMHANDLE, nDrive, nResType, nCodePage, (pioreq)&objIFSreq) == ERROR_SUCCESS )
	{
		ParsedPath2PathName(pParsedPath, nDrive, nCodePage, psPathName);
		return TRUE;
	}
	else
		return FALSE;
}
#endif
/*
BOOL IsMonitored(CHAR psPathName[MAX_PATH])
{
	if ( g_pDirectoryItems != NULL )
	{
		PDIRECTORYITEM pItem;
		int nCompare;
	
		Wait_Semaphore(g_semDirectoryItems, BLOCK_SVC_INTS);
		pItem = g_pDirectoryItems;
		while ( pItem )
			if ( psPathName[pItem->nLen] == '\\' )
			{
				nCompare = strnicmp(psPathName, pItem->sDirectory, pItem->nLen);
				if ( nCompare == 0 )
				{
					Signal_Semaphore(g_semDirectoryItems);
					return TRUE;
				}
				else if ( nCompare < 0 )
					break;
				pItem = pItem->pNext;
			}
		Signal_Semaphore(g_semDirectoryItems);
	}
	return FALSE;
}
*/
BOOL IsMonitoredEx(PFILEITEM pFileItem)
{
	
	if ( g_pDirectoryItems != NULL )
	{
		BOOL fRet = FALSE;
		PDIRECTORYITEM pItem;
		PCHAR psPathName;
		PCHAR psDir, psShortDir;
	
		Wait_Semaphore(g_semDirectoryItems, BLOCK_SVC_INTS);
		pItem = g_pDirectoryItems;
/*
		while ( pItem )
			if ( psPathName[pItem->nLen] == '\\' )
			{
				nCompare = strnicmp(psPathName, pItem->sDirectory, pItem->nLen);
				if ( nCompare == 0 )
				{
					pFileItem->pDirectoryItem = pItem;
					pFileItem->pRelativePath = psPathName + pItem->nLen + 1;
					Signal_Semaphore(g_semDirectoryItems);
					return TRUE;
				}
				else if ( nCompare < 0 )
					break;
				pItem = pItem->pNext;
			}
*/
		while ( pItem )
		{
			psPathName = pFileItem->sFilePathName;
			psDir = pItem->sDirectory;
			psShortDir = pItem->sShortDirectory;
			while ( *psDir )
			{
				if ( (psPathName[*psDir] != '\\' || strnicmp(psDir + 1, psPathName, *psDir) != 0)
					&& (psPathName[*psShortDir] != '\\' || strnicmp(psShortDir + 1, psPathName, *psShortDir) != 0) )
					break;
				psDir += *psDir + 1;
				psShortDir += *psShortDir + 1;
			}
			if ( !*psDir )
				fRet = TRUE;
			pItem = pItem->pNext;
		}
		Signal_Semaphore(g_semDirectoryItems);
		return fRet;
	}
	else
		return FALSE;
}

#pragma optimize("", off)
int _cdecl DirMonHookProc(pIFSFunc pfn, int fn, int Drive, int ResType,
                          int CodePage, pioreq pir)
{
	int nRetCode;
	ioreq objOriginalRequest = *pir;

	nRetCode = (*g_pPrevIFSHookProc)(pfn, fn, Drive, ResType, CodePage, pir);

	if ( nRetCode == ERROR_SUCCESS )
	{
		PFILEITEM pFileItem;
		DWORD dwUpdateDosTime, dwUpdateDosMillisecond;

		dwUpdateDosTime = IFSMgr_Get_DOSTime(&dwUpdateDosMillisecond);
		switch ( fn )
		{
		case IFSFN_OPEN:
#if PARSE_FILENAME_FROM_FILENUMBER
			if ( AllocateFileItem(&pFileItem) )
			{
				pFileItem->nFileNumber = pir->ir_sfn;
				if ( (objOriginalRequest.ir_options & (ACTION_CREATENEW | ACTION_REPLACEEXISTING)
						|| objOriginalRequest.ir_flags & (ACCESS_WRITEONLY | ACCESS_READWRITE)) )
				{
					if ( objOriginalRequest.ir_options & (ACTION_CREATENEW | ACTION_REPLACEEXISTING) )
						pFileItem->dwUpdateDosTime = dwUpdateDosTime;
					ParsedPath2PathName(pir->ir_ppath, Drive, CodePage, pFileItem->sFilePathName);
					if ( IsMonitoredEx(pFileItem) )
						dprintf("Insert file item into hash table (Open): %s\n", pFileItem->sFilePathName);
					else
						dprintf("Insert (not monitored) file item into hash table (Open): %s\n", pFileItem->sFilePathName);
				}
				else
					dprintf("Insert (not monitored) file item into hash table (Open): %d\n", pFileItem->nFileNumber);
				InsertFileItemIntoHashTable(pFileItem);
			}
#else
			if ( (objOriginalRequest.ir_options & (ACTION_CREATENEW | ACTION_REPLACEEXISTING)
					|| objOriginalRequest.ir_flags & (ACCESS_WRITEONLY | ACCESS_READWRITE))
					&& AllocateFileItem(&pFileItem) )
			{
				if ( objOriginalRequest.ir_options & (ACTION_CREATENEW | ACTION_REPLACEEXISTING) )
					pFileItem->dwUpdateDosTime = dwUpdateDosTime;
				ParsedPath2PathName(pir->ir_ppath, Drive, CodePage, pFileItem->sFilePathName);
				if ( IsMonitoredEx(pFileItem) )
				{
					pFileItem->nFileNumber = pir->ir_sfn;
					InsertFileItemIntoHashTable(pFileItem);
					dprintf("Insert file item into hash table (Open): %s\n", pFileItem->sFilePathName);
				}
				else
					FreeFileItem(pFileItem);
			}
#endif
			break;
		case IFSFN_CLOSE:
			if ( objOriginalRequest.ir_flags == CLOSE_FINAL && (pFileItem = RemoveFileItemFromHashTable(objOriginalRequest.ir_sfn)) )
			{
#if PARSE_FILENAME_FROM_FILENUMBER
				if ( pFileItem->pDirectoryItem && pFileItem->dwUpdateDosTime )
#else
				if ( pFileItem->dwUpdateDosTime )
#endif
				{
					BOOL fAppended = AppendFileItemToDirectory(pFileItem);
					dprintf("Append file item to directory (%s): %s -> %s\n", fAppended ? "OK" : "Fail", pFileItem->pRelativePath, pFileItem->pDirectoryItem->sDirectory);
				}
				else
					FreeFileItem(pFileItem);
			}
			break;
		case IFSFN_WRITE:
#if PARSE_FILENAME_FROM_FILENUMBER
			if ( (pFileItem = GetFileItemFromHashTable(pir->ir_sfn)) )
			{
				if ( pFileItem->pDirectoryItem )
					pFileItem->dwUpdateDosTime = dwUpdateDosTime;
			}
			else if ( AllocateFileItem(&pFileItem) )
			{
				pFileItem->dwUpdateDosTime = dwUpdateDosTime;
				if ( SFN2PathName(pir->ir_sfn, Drive, ResType, CodePage, pir, pFileItem->sFilePathName) && IsMonitoredEx(pFileItem) )
				{
					pFileItem->nFileNumber = pir->ir_sfn;
					InsertFileItemIntoHashTable(pFileItem);
					dprintf("Insert file item into hash table (Write): %s\n", pFileItem->sFilePathName);
				}
				else
					FreeFileItem(pFileItem);
			}
			else
				dprintf("Unattended file write...\n");
#else
			if ( (pFileItem = GetFileItemFromHashTable(pir->ir_sfn)) )
				pFileItem->dwUpdateDosTime = dwUpdateDosTime;
#endif
			break;
		case IFSFN_FILEATTRIB:
			if ( (objOriginalRequest.ir_flags == SET_ATTRIBUTES || objOriginalRequest.ir_flags == SET_ATTRIB_MODIFY_DATETIME) && AllocateFileItem(&pFileItem) )
			{
				pFileItem->dwUpdateDosTime = dwUpdateDosTime;
				ParsedPath2PathName(pir->ir_ppath, Drive, CodePage, pFileItem->sFilePathName);
				if ( IsMonitoredEx(pFileItem) )
				{
					BOOL fAppended = AppendFileItemToDirectory(pFileItem);
					dprintf("Append file item to directory (%s): %s -> %s\n", fAppended ? "OK" : "Fail", pFileItem->pRelativePath, pFileItem->pDirectoryItem->sDirectory);
	    		}
	    		else
	    			FreeFileItem(pFileItem);
			}
			break;
		case IFSFN_FILETIMES:
			if ( pir->ir_flags == SET_MODIFY_DATETIME )
			{
#if PARSE_FILENAME_FROM_FILENUMBER
				if ( (pFileItem = GetFileItemFromHashTable(pir->ir_sfn)) )
				{
					if ( pFileItem->pDirectoryItem )
						pFileItem->dwUpdateDosTime = dwUpdateDosTime;
				}
				else if ( AllocateFileItem(&pFileItem) )
				{
					pFileItem->dwUpdateDosTime = dwUpdateDosTime;
					if ( SFN2PathName(pir->ir_sfn, Drive, ResType, CodePage, pir, pFileItem->sFilePathName) && IsMonitoredEx(pFileItem) )
					{
						pFileItem->nFileNumber = pir->ir_sfn;
						InsertFileItemIntoHashTable(pFileItem);
						dprintf("Insert file item into hash table (Times): %s\n", pFileItem->sFilePathName);
					}
					else
						FreeFileItem(pFileItem);
				}
#else
				if ( (pFileItem = GetFileItemFromHashTable(pir->ir_sfn)) )
					pFileItem->dwUpdateDosTime = dwUpdateDosTime;
#endif
			}
			break;
		case IFSFN_DELETE:
			if ( (pFileItem = RemoveFileItemFromHashTable(pir->ir_sfn)) )
			{
				BOOL fAppended;

				pFileItem->dwUpdateDosTime = dwUpdateDosTime;
				fAppended = AppendFileItemToDirectory(pFileItem);
				dprintf("Append file item to directory (%s): %s -> %s\n", fAppended ? "OK" : "Fail", pFileItem->pRelativePath, pFileItem->pDirectoryItem->sDirectory);
			}
			else if ( AllocateFileItem(&pFileItem) )
			{
				pFileItem->dwUpdateDosTime = dwUpdateDosTime;
				ParsedPath2PathName(pir->ir_ppath, Drive, CodePage, pFileItem->sFilePathName);
				if ( IsMonitoredEx(pFileItem) )
	    		{
	    			BOOL fAppended = AppendFileItemToDirectory(pFileItem);
					dprintf("Append file item to directory (%s): %s -> %s\n", fAppended ? "OK" : "Fail", pFileItem->pRelativePath, pFileItem->pDirectoryItem->sDirectory);
	    		}
	    		else
	    			FreeFileItem(pFileItem);
			}
			else
				dprintf("Unattened file delete...\n");
			break;
		case IFSFN_RENAME:
			if ( AllocateFileItem(&pFileItem) )
			{
				pFileItem->dwUpdateDosTime = dwUpdateDosTime;
				ParsedPath2PathName(pir->ir_ppath, Drive, CodePage, pFileItem->sFilePathName);
				if ( IsMonitoredEx(pFileItem) )
				{
					PDIRECTORYITEM pDirectoryItem = pFileItem->pDirectoryItem;
					int nPathNameLen = pFileItem->pRelativePath - pFileItem->sFilePathName;
					BOOL fAppended = AppendFileItemToDirectory(pFileItem);
					dprintf("Append file item to directory (%s): %s -> %s\n", fAppended ? "OK" : "Fail", pFileItem->pRelativePath, pFileItem->pDirectoryItem->sDirectory);
					if ( AllocateFileItem(&pFileItem) )
					{
						pFileItem->dwUpdateDosTime = dwUpdateDosTime;
						ParsedPath2PathName(pir->ir_ppath2, Drive, CodePage, pFileItem->sFilePathName);
						pFileItem->pDirectoryItem = pDirectoryItem;
						pFileItem->pRelativePath = pFileItem->sFilePathName + nPathNameLen;
						fAppended = AppendFileItemToDirectory(pFileItem);
						dprintf("Append file item to directory (%s): %s -> %s\n", fAppended ? "OK" : "Fail", pFileItem->pRelativePath, pFileItem->pDirectoryItem->sDirectory);
					}
				}
				else
					FreeFileItem(pFileItem);
			}
			break;
		case IFSFN_IOCTL16DRIVE:
			break;
	
	    case IFSFN_DIR:
	    	if ( (pir->ir_flags == CREATE_DIR || pir->ir_flags == DELETE_DIR) && AllocateFileItem(&pFileItem) )
	    	{
	    		pFileItem->dwUpdateDosTime = dwUpdateDosTime;
	    		ParsedPath2PathName(pir->ir_ppath, Drive, CodePage, pFileItem->sFilePathName);
	    		if ( IsMonitoredEx(pFileItem) )
	    		{
	    			BOOL fAppended = AppendFileItemToDirectory(pFileItem);
					dprintf("Append file item to directory (%s): %s -> %s\n", fAppended ? "OK" : "Fail", pFileItem->pRelativePath, pFileItem->pDirectoryItem->sDirectory);
	    		}
	    		else
	    			FreeFileItem(pFileItem);
	    	}
	    	break;
/*
//		case IFSFN_FINDOPEN:
//		case IFSFN_FINDNEXT:
//	    case IFSFN_FINDCLOSE:
	    case IFSFN_READ:
	    case IFSFN_FCNNEXT:
	    case IFSFN_SEEK:
	    case IFSFN_QUERY:
	    case IFSFN_GETDISKINFO:
//	    case IFSFN_ENUMHANDLE:
	    	break;
	    default:
	    	dprintf("Unattended request: %d\n", fn);
	    	break;
*/		}
	}

	return nRetCode;
}
#pragma optimize("", on)

BOOL OnSysDynamicDeviceInit()
{
	DEBUG_FUNCTION_NAME("OnSysDynamicDeviceInit");

	//	Initialize lists and hash table
	InitDirectoryItemList();
	InitFileItemHashTable();
	InitFreeFileItemList();

	//	Hook IFS functions
	g_pPrevIFSHookProc = IFSMgr_InstallFileSystemApiHook(DirMonHookProc);
	return TRUE;
}

BOOL OnSysDynamicDeviceExit()
{
	DEBUG_FUNCTION_NAME("OnSysDynamicDeviceExit");

	//	Unhook IFS functions.
	IFSMgr_RemoveFileSystemApiHook(DirMonHookProc);

	//	Destroy lists and hash table
	dprintf("DestroyFreeFileItemList...\n");
	DestroyFreeFileItemList();
	dprintf("DestroyFileItemHashTable...\n");
	DestroyFileItemHashTable();
	dprintf("DestroyDirectoryItemList...\n");
	DestroyDirectoryItemList();
	dprintf("return TRUE...\n");

	return TRUE;
}

DWORD OnW32Deviceiocontrol(PIOCTLPARAMS p)
{
	PDIRECTORYITEM pItem;

	DEBUG_FUNCTION_NAME("OnW32Deviceiocontrol");

	switch ( p->dioc_IOCtlCode )
	{
	case DIOC_OPEN:
		dprintf("  DIOC_OPEN\n");
		return 0;
	case DIOC_CLOSEHANDLE:
		dprintf("  DIOC_CLOSEHANDLE\n");
		return 0;
	case DIRMON_AddMonitorPath:
		dprintf("  DIRMON_AddMonitorPath\n");
		return AllocateDirectoryItem(p->dioc_InBuf, &pItem) ? 0 : 1;
	default:
		dprintf("  default\n");
		return 0;
	}
}