dirmon.c

这个是FileBackup的一个组件

		while ( *pPath )
		{
			if ( *pPath != '\\' )
				*pDest++ = *pPath++;
			else
			{
				*pBackSlash = pDest - pBackSlash - 1;
				pBackSlash = pDest++;
				pPath++;
			}
		}
		if ( (*pBackSlash = pDest - pBackSlash - 1) )
			*pDest = 0;

		Wait_Semaphore(g_semDirectoryItems, BLOCK_SVC_INTS);
		pTempDirectoryItem = g_pDirectoryItems;
		while ( pTempDirectoryItem )
		{
			pPath = pTempDirectoryItem->sShortPathName;
			pDest = pDirectoryItem->sShortPathName;
			while ( *pPath == *pDest && *pPath && strnicmp(pPath + 1, pDest + 1, *pPath) == 0 )
			{
				pPath += *pPath + 1;
				pDest += *pDest + 1;
			}
			if ( *pPath == *pDest && !*pPath )
			{
				pTempDirectoryItem->nRefCount++;
				dprintdirectoryitem("Insert monitor path", pTempDirectoryItem);
				Signal_Semaphore(g_semDirectoryItems);
				HeapFree(pDirectoryItem, 0);
				return pTempDirectoryItem;
			}
			pTempDirectoryItem = pTempDirectoryItem->pNext;
		}
		pDirectoryItem->nRefCount = 1;
		pDirectoryItem->pNext = g_pDirectoryItems;
		g_pDirectoryItems = pDirectoryItem;
		g_dwDirectoryItems++;
		dprintdirectoryitem("Insert monitor path", pDirectoryItem);
		Signal_Semaphore(g_semDirectoryItems);
	}
	return pDirectoryItem;
}

void FreeDirectoryItem(PDIRECTORYITEM pDirectoryItem)
{
	PDIRECTORYITEM pTempPrevDirectoryItem = NULL, pTempDirectoryItem;

	Wait_Semaphore(g_semDirectoryItems, BLOCK_SVC_INTS);
	pTempDirectoryItem = g_pDirectoryItems;
	while ( pTempDirectoryItem != pDirectoryItem && pTempDirectoryItem )
	{
		pTempPrevDirectoryItem = pTempDirectoryItem;
		pTempDirectoryItem = pTempDirectoryItem->pNext;
	}
	if ( pTempDirectoryItem != NULL )
	{
		if ( --pTempDirectoryItem->nRefCount == 0 )
		{
			if ( pTempPrevDirectoryItem == NULL )
				g_pDirectoryItems = pTempDirectoryItem->pNext;
			else
				pTempPrevDirectoryItem->pNext = pTempDirectoryItem->pNext;
			g_dwDirectoryItems--;
			Signal_Semaphore(g_semDirectoryItems);
			dprintdirectoryitem("Remove monitor path", pTempDirectoryItem);
			HeapFree(pTempDirectoryItem, 0);
			return;
		}
	}
	Signal_Semaphore(g_semDirectoryItems);
}

int AllocateAndAppendDirectoryItems(PCHAR pPaths, DWORD*pdwDirectoryItem)
{
	PDIRECTORYITEM pDirectoryItem, pFirstDirectoryItem = NULL, pLastDirectoryItem = NULL, pTempDirectoryItem;
	int nItemCount = 0, nNewDirectoryItemCount = 0;

	while ( *pPaths )
	{
		if ( (pDirectoryItem = HeapAllocate(sizeof(*pDirectoryItem), 0)) )
		{
			PCHAR pDest, pBackSlash;
			PCHAR pChar;

			pBackSlash = pDirectoryItem->sPathName;
			pDest = pBackSlash + 1;
			while ( *pPaths )
			{
				if ( *pPaths != '\\' )
					*pDest++ = *pPaths++;
				else
				{
					*pBackSlash = pDest - pBackSlash - 1;
					pBackSlash = pDest++;
					pPaths++;
				}
			}
			if ( (*pBackSlash = pDest - pBackSlash - 1) )
				*pDest = 0;
			pPaths++;
			pBackSlash = pDirectoryItem->sShortPathName;
			pDest = pBackSlash + 1;
			while ( *pPaths )
			{
				if ( *pPaths != '\\' )
					*pDest++ = *pPaths++;
				else
				{
					*pBackSlash = pDest - pBackSlash - 1;
					pBackSlash = pDest++;
					pPaths++;
				}
			}
			if ( (*pBackSlash = pDest - pBackSlash - 1) )
				*pDest = 0;
			pPaths++;

			pTempDirectoryItem = pFirstDirectoryItem;
			while ( pTempDirectoryItem )
			{
				pChar = pTempDirectoryItem->sShortPathName;
				pDest = pDirectoryItem->sShortPathName;
				while ( *pChar == *pDest && *pChar && strnicmp(pChar + 1, pDest + 1, *pChar) == 0 )
				{
					pChar += *pChar + 1;
					pDest += *pDest + 1;
				}
				if ( *pChar == *pDest && !*pChar )
				{
					pTempDirectoryItem->nRefCount++;
					HeapFree(pDirectoryItem, 0);
					*pdwDirectoryItem++ = (DWORD)pTempDirectoryItem;
					nItemCount++;
					dprintdirectoryitem("Insert monitor path", pTempDirectoryItem);
					break;
				}
				pTempDirectoryItem = pTempDirectoryItem->pNext;
			}
			pDirectoryItem->nRefCount = 1;
			pDirectoryItem->pNext = pFirstDirectoryItem;
			pFirstDirectoryItem = pDirectoryItem;
			if ( pLastDirectoryItem == NULL )
				pLastDirectoryItem = pDirectoryItem;
			nNewDirectoryItemCount++;
			*pdwDirectoryItem++ = (DWORD)pDirectoryItem;
			nItemCount++;
			dprintdirectoryitem("Insert monitor path", pDirectoryItem);
		}
	}
	if ( pFirstDirectoryItem )
	{
		Wait_Semaphore(g_semDirectoryItems, BLOCK_SVC_INTS);
		pLastDirectoryItem->pNext = g_pDirectoryItems;
		g_pDirectoryItems = pFirstDirectoryItem;
		g_dwDirectoryItems += nNewDirectoryItemCount;
		Signal_Semaphore(g_semDirectoryItems);
	}
	*pdwDirectoryItem++ = 0;
	return nItemCount;
}

void FreeAllDirectoryItems()
{
	PDIRECTORYITEM pTempPrevDirectoryItem = NULL, pTempDirectoryItem;

	Wait_Semaphore(g_semDirectoryItems, BLOCK_SVC_INTS);
	pTempDirectoryItem = g_pDirectoryItems;
	g_pDirectoryItems = NULL;
	Signal_Semaphore(g_semDirectoryItems);
	while ( pTempDirectoryItem != NULL )
	{
		pTempPrevDirectoryItem = pTempDirectoryItem;
		pTempDirectoryItem = pTempDirectoryItem->pNext;
		dprintdirectoryitem("Remove moinitor path", pTempPrevDirectoryItem);
		HeapFree(pTempPrevDirectoryItem, 0);
	}
}

void InitFileItemsHashTable()
{
	g_semFileItemHashTable = Create_Semaphore(0);
	memset(g_pFileItemHashTable, 0, sizeof(g_pFileItemHashTable));
	Signal_Semaphore(g_semFileItemHashTable);
}

void DestroyFileItemsHashTable()
{
	PFILEITEM pPrevFileItem, pFileItem;
	PPATHLINKITEM pPrevPathLinkItem, pPathLinkItem;
	int i;

	Wait_Semaphore(g_semFileItemHashTable, BLOCK_SVC_INTS);
	for ( i = 0; i < HASH_NUMBER; i++ )
	{
		pFileItem = g_pFileItemHashTable[i];
		while ( pFileItem )
		{
			pPrevFileItem = pFileItem;
			pFileItem = pFileItem->pNext;
			pPathLinkItem = pPrevFileItem->pBasePaths;
			while ( pPathLinkItem )
			{
				pPrevPathLinkItem = pPathLinkItem;
				pPathLinkItem = pPathLinkItem->pNext;
				HeapFree(pPrevPathLinkItem, 0);
			}
			HeapFree(pPrevFileItem, 0);
		}
	}
	Destroy_Semaphore(g_semFileItemHashTable);
}

void InsertFileItemIntoHashTable(PFILEITEM pFileItem)
{
	PFILEITEM* ppFileItem;

	Wait_Semaphore(g_semFileItemHashTable, BLOCK_SVC_INTS);
	ppFileItem = g_pFileItemHashTable + (pFileItem->nFileNumber & HASH_BITS_MASK);
	pFileItem->pNext = *ppFileItem;
	*ppFileItem = pFileItem;
	Signal_Semaphore(g_semFileItemHashTable);
}

PFILEITEM RemoveFileItemFromHashTable(sfn_t nFileNumber)
{
	PFILEITEM pPrevFileItem = NULL, pFileItem;
	PFILEITEM* ppFileItem;
	
	Wait_Semaphore(g_semFileItemHashTable, BLOCK_SVC_INTS);
	ppFileItem = g_pFileItemHashTable + (nFileNumber & HASH_BITS_MASK);
	pFileItem = *ppFileItem;
	while ( pFileItem )
	{
		if ( pFileItem->nFileNumber == nFileNumber )
		{
			if ( pPrevFileItem == NULL )
				*ppFileItem = pFileItem->pNext;
			else
				pPrevFileItem->pNext = pFileItem->pNext;
			Signal_Semaphore(g_semFileItemHashTable);
			return pFileItem;
		}
		pPrevFileItem = pFileItem;
		pFileItem = pFileItem->pNext;
	}
	Signal_Semaphore(g_semFileItemHashTable);
	return NULL;
}

PFILEITEM GetFileItemFromHashTable(sfn_t nFileNumber)
{
	PFILEITEM pFileItem;

	Wait_Semaphore(g_semFileItemHashTable, BLOCK_SVC_INTS);
	pFileItem = g_pFileItemHashTable[nFileNumber & HASH_BITS_MASK];
	while ( pFileItem && pFileItem->nFileNumber != nFileNumber )
		pFileItem = pFileItem->pNext;
	Signal_Semaphore(g_semFileItemHashTable);
	return pFileItem;
}

void InitFreeFileItemsList()
{
	g_semFreeFileItems = Create_Semaphore(0);
	g_pFreeFileItems = NULL;
	Signal_Semaphore(g_semFreeFileItems);
}

void DestroyFreeFileItemsList()
{
	PFILEITEM pPrevFileItem, pFileItem;

	Wait_Semaphore(g_semFreeFileItems, BLOCK_SVC_INTS);
	pFileItem = g_pFreeFileItems;
	while ( pFileItem )
	{
		pPrevFileItem = pFileItem;
		pFileItem = pFileItem->pNext;
		HeapFree(pFileItem, 0);
	}
	Destroy_Semaphore(g_semFreeFileItems);
}

PFILEITEM AllocateFileItem()
{
	PFILEITEM pFileItem;

	Wait_Semaphore(g_semFreeFileItems, BLOCK_SVC_INTS);
	if ( (pFileItem = g_pFreeFileItems) )
	{
		g_pFreeFileItems = g_pFreeFileItems->pNext;
		Signal_Semaphore(g_semFreeFileItems);
	}
	else
	{
		Signal_Semaphore(g_semFreeFileItems);
		if ( !(pFileItem = HeapAllocate(sizeof(*pFileItem), 0)) )
			return NULL;
	}
	memset(pFileItem, 0, sizeof(*pFileItem));
	return pFileItem;
}

PFILEITEM AllocateFileItemForActionRenamed()
{
	PFILEITEM pFileItem1, pFileItem2;

	Wait_Semaphore(g_semFreeFileItems, BLOCK_SVC_INTS);
	if ( g_pFreeFileItems && g_pFreeFileItems->pNext )
	{
		pFileItem1 = g_pFreeFileItems;
		pFileItem2 = g_pFreeFileItems->pNext;
		g_pFreeFileItems = (pFileItem2)->pNext;
		Signal_Semaphore(g_semFreeFileItems);
	}
	else
	{
		Signal_Semaphore(g_semFreeFileItems);
		if ( !(pFileItem1 = HeapAllocate(sizeof(*pFileItem1), 0)) )
			return NULL;
		if ( !(pFileItem2 = HeapAllocate(sizeof(*pFileItem2), 0)) )
		{
			HeapFree(pFileItem1, 0);
			return NULL;
		}
	}
	memset(pFileItem1, 0, sizeof(*pFileItem1));
	memset(pFileItem2, 0, sizeof(*pFileItem2));
	pFileItem1->pNext = pFileItem2;
	pFileItem1->wAction = DIRMON_ACTION_RENAMED_OLD_NAME;
	return pFileItem1;
}

void FreeFileItem(PFILEITEM pFileItem)
{
	PPATHLINKITEM pPathLinkItem;
	DWORD dwFreePathLinkItems = 1;

	if ( pFileItem->pBasePaths )
	{
		pPathLinkItem = pFileItem->pBasePaths;
		while ( pPathLinkItem->pNext )
		{
			pPathLinkItem = pPathLinkItem->pNext;
			dwFreePathLinkItems++;
		}
		Wait_Semaphore(g_semFreePathLinkItems, BLOCK_SVC_INTS);
		pPathLinkItem->pNext = g_pFreePathLinkItems;
		g_pFreePathLinkItems = pFileItem->pBasePaths;
		g_dwFreePathLinkItems += dwFreePathLinkItems;
		Signal_Semaphore(g_semFreePathLinkItems);
	}

	Wait_Semaphore(g_semFreeFileItems, BLOCK_SVC_INTS);
	pFileItem->pNext = g_pFreeFileItems;
	g_pFreeFileItems = pFileItem;
	Signal_Semaphore(g_semFreeFileItems);
}

void FreeFileItemForActionRenamed(PFILEITEM pFileItem)
{
	PFILEITEM pFileItem2 = pFileItem->pNext;
	PPATHLINKITEM pPathLinkItem;
	DWORD dwFreePathLinkItems = 1;

	if ( pFileItem->pBasePaths )
	{
		pPathLinkItem = pFileItem->pBasePaths;
		while ( pPathLinkItem->pNext )
		{
			pPathLinkItem = pPathLinkItem->pNext;
			dwFreePathLinkItems++;
		}
		pPathLinkItem->pNext = pFileItem2->pBasePaths;
		while ( pPathLinkItem->pNext )
		{
			pPathLinkItem = pPathLinkItem->pNext;
			dwFreePathLinkItems++;
		}
		Wait_Semaphore(g_semFreePathLinkItems, BLOCK_SVC_INTS);
		pPathLinkItem->pNext = g_pFreePathLinkItems;
		g_pFreePathLinkItems = pFileItem->pBasePaths;
		g_dwFreePathLinkItems += dwFreePathLinkItems;
		Signal_Semaphore(g_semFreePathLinkItems);
	}

	Wait_Semaphore(g_semFreeFileItems, BLOCK_SVC_INTS);
	pFileItem2->pNext = g_pFreeFileItems;
	g_pFreeFileItems = pFileItem;
	Signal_Semaphore(g_semFreeFileItems);
}

void InitFreePathLinkItemsList()
{
	g_semFreePathLinkItems = Create_Semaphore(0);
	g_pFreePathLinkItems = NULL;
	g_dwFreePathLinkItems = 0;
	Signal_Semaphore(g_semFreePathLinkItems);
}

void DestroyFreePathLinkItemsList()
{