xfile.cpp

这是一本学习 window编程的很好的参考教材

		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pNnb
			, ACL_NNB_LENTH
			, (DWORD*)&AclHeader.pNnb);
		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pIcmp
			, ACL_ICMP_LENTH
			, (DWORD*)&AclHeader.pIcmp);
		
		FileAcl.SeekToBegin();
		FileAcl.Write(&AclHeader, ACL_HEADER_LENTH);

		FileAcl.Close();
	}
	CATCH( CFileException, e )
	{
		if(FileAcl.m_hFile != NULL)	FileAcl.Close();
		return XERR_FILE_CREATE_FAILURE;
	}
	END_CATCH

	return XERR_SUCCESS;
}

//
// 增加一条控管规则记录
//
int	CAclFile::AddRecord(
	PXACL_RECORD pAdd, 
	PXACL_RECORD* ppFirst, 
	DWORD* pCount
)
{
	if(pAdd == NULL) return XERR_FILE_NOT_ENOUGH_MEMORY;

	if(!Lock()) return XERR_FILE_LOCK_ERROR;
	__try
	{
		pAdd->pNext = NULL;
		*pCount ++;

		PXACL_RECORD pRecord = *ppFirst;

		if(pRecord == NULL)
		{
			pAdd->dwId = 1;
			*ppFirst = pAdd;
			return XERR_SUCCESS;
		}

		while(pRecord != NULL) 
		{
			if(pRecord->pNext == NULL)
			{
				pAdd->dwId = pRecord->dwId + 1;
				pRecord->pNext = pAdd;
				break; 
			}
			pRecord = pRecord->pNext;
		}
		return XERR_SUCCESS;
	}
	__finally
	{
		Unlock();
	}

	return XERR_SUCCESS;
}

//
// 更新控管规则记录
//
int	CAclFile::UpdateRecord(PXACL_RECORD pUpdate, PXACL_RECORD pFirst, int nRecordLen)
{
	if(!Lock()) return XERR_FILE_LOCK_ERROR;
	__try
	{
		BYTE* pRecord = (BYTE*)FindRecord(pFirst, pUpdate->dwId);
		BYTE* pUpdateTemp = (BYTE*)pUpdate;
		int nRecordSize = sizeof(XACL_RECORD);
		if(pRecord != NULL)
		{
			memcpy(pRecord + nRecordSize, pUpdateTemp + nRecordSize, nRecordLen - nRecordSize);
			return XERR_SUCCESS;
		}
		return XERR_FILE_RECORD_CAN_NOT_FIND;
	}
	__finally
	{
		Unlock();
	}
	return XERR_FILE_RECORD_CAN_NOT_FIND;
}

//
// 删除控管规则记录
//
int CAclFile::DelRecord(PXACL_RECORD* ppEntry, DWORD dwId, DWORD* pCount)
{
	if(!Lock()) return XERR_FILE_LOCK_ERROR;
	__try
	{
		PXACL_RECORD pPrev = NULL;
		PXACL_RECORD pCurrent = *ppEntry;
		while(pCurrent != NULL)
		{
			if(pCurrent->dwId == dwId)
			{
				if(pPrev == NULL)
					*ppEntry = pCurrent->pNext;
				else
					pPrev->pNext = pCurrent->pNext;
				*pCount --;

				return XERR_SUCCESS;
			}
			pPrev = pCurrent;
			pCurrent = pCurrent->pNext;
		}
		return XERR_FILE_RECORD_CAN_NOT_FIND;
	}
	__finally
	{
		Unlock();
	}
	return	XERR_FILE_RECORD_CAN_NOT_FIND;
}

//
// 查找控管规则记录
//
PVOID CAclFile::FindRecord(PXACL_RECORD pFirst, DWORD dwId)
{
	PXACL_RECORD pCurrent = pFirst;
	while(pCurrent != NULL)
	{
		if(pCurrent->dwId == dwId)
		{
			break;
		}
		pCurrent = pCurrent->pNext;
	}
	return (PVOID)pCurrent;
}

//
// 修正链表的指针
//
void CAclFile::RepairPoint(PXACL_RECORD* pAclRecord, DWORD dwBaseAddress)
{
	if(*pAclRecord == NULL) return;
	DWORD tmp = (DWORD)(*pAclRecord);
	*pAclRecord = (PXACL_RECORD)(dwBaseAddress + (DWORD)(*pAclRecord));
	PXACL_RECORD pTempAclRecord = *pAclRecord;
	while(pTempAclRecord != NULL && pTempAclRecord->pNext != NULL)
	{
		pTempAclRecord->pNext = (PXACL_RECORD)(dwBaseAddress + (DWORD)pTempAclRecord->pNext);
		pTempAclRecord = pTempAclRecord->pNext;
	}
}

//
// 创建一条记录
//
char* CAclFile::CreateRecord(PVOID pRecord, int nLenth)
{
	if(!Lock()) return NULL;
	__try
	{
		if(m_dwMaxOffset < (DWORD)m_pCurrentPoint + nLenth)
		{
			if(SaveAcl() != XERR_SUCCESS
				|| ReadAcl() != XERR_SUCCESS)
				return NULL;
		}

		char* pBuf = m_pCurrentPoint;
		memcpy(pBuf, pRecord, nLenth);
		m_pCurrentPoint += nLenth;
		return pBuf;
	}
	__finally
	{
		Unlock();
	}
	return NULL;
}

//============================================================================================
//Export function

//
// 更新文件
//
BOOL CAclFile::UpdateFile(DWORD nPosition, PVOID pBuf, int nLenth)
{
	if(m_sPathName.IsEmpty() || m_AclFile.m_hFile != NULL
		|| _taccess(m_sPathName + ACL_FILE_NAME, 0) == -1)
		return FALSE;

	TRY										
	{
		m_AclFile.Open(	m_sPathName + ACL_FILE_NAME,
						CFile::modeWrite		|
						CFile::typeBinary		| 
						CFile::shareExclusive
						);
		m_AclFile.Seek(nPosition, CFile::begin);
		m_AclFile.Write(pBuf, nLenth);
		CloseAcl();
	}
	CATCH( CFileException, e )
	{
		return FALSE;
	}
	END_CATCH

	return TRUE;
}

//
// 从文件中读取控管规则
//
int CAclFile::ReadAcl(BOOL IsDLL, HINSTANCE instance)	//main function
{
	int	iRet = XERR_SUCCESS;

	if(IsDLL)
		m_sPathName = CAclFile::GetAppPath(IsDLL, instance);
	else
		m_sPathName = CAclFile::GetAppPath();

	if(m_AclFile.m_hFile == NULL && (iRet = OpenAcl()) != XERR_SUCCESS)
		return iRet;

	TRY
	{
		CFileStatus	m_FileStatus;
		if(!m_AclFile.GetStatus(m_FileStatus))
			return XERR_FILE_GET_STATUS_ERROR;
		if(m_FileStatus.m_size < ACL_HEADER_LENTH)
			return XERR_FILE_INVALID_SIGNATURE;

		m_dwMaxSize = m_FileStatus.m_size + MAX_MEMORY_FILE_SIZE;
		if(!Create(PKF_MEMORY_ACL_FILE, m_dwMaxSize))
			return XERR_FILE_CREATE_MEMORY_ERROR;
		m_pCurrentPoint = m_pMemFile + m_FileStatus.m_size;
		m_dwMaxOffset = (DWORD)m_pMemFile + m_dwMaxSize;

		m_AclFile.SeekToBegin();
		m_AclFile.Read(m_pMemFile,m_FileStatus.m_size);	//read the header
		m_pAclHeader = (PXACL_HEADER)m_pMemFile;

		if(_tcscmp(m_pAclHeader->sSignature , ACL_HEADER_SIGNATURE) != 0)
		{
			CloseAcl();
			return XERR_FILE_INVALID_SIGNATURE;
		}
		//
		// 2002/12/20 modify for v2.1.0
		//
		if(	m_pAclHeader->ulVersion < COMP_ACL_VERSION_START 
			|| m_pAclHeader->ulVersion > COMP_ACL_VERSION_END
			|| m_pAclHeader->bMajor < COMP_ACL_MAJOR_START
			|| m_pAclHeader->bMajor > COMP_ACL_MAJOR_END
			)
		{
			CloseAcl();
			return XERR_FILE_INVALID_VERSION;
		}

		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pTime, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pAllIp, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pIntranetIp, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pDistrustIp, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pTrustIp, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pCustomIp, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pAcl, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pWeb, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pNnb, (DWORD)m_pAclHeader);
		RepairPoint((PXACL_RECORD*)&m_pAclHeader->pIcmp, (DWORD)m_pAclHeader);
		
		CloseAcl();

		if(!SetDllAclMemoryHandle(m_hMemFile)) 
			return XERR_FILE_SET_DLL_FILE_HANDLE_ERROR;

		ContinueFilter();
	}
	CATCH( CFileException, e )
	{
		CloseAcl();
		return XERR_FILE_READ_ERROR;
	}
	END_CATCH

	return iRet;
}

//
// 保存控管规则到文件
//
int	CAclFile::SaveAcl()
{
	int		iRet;

	if((iRet = WriteAcl(m_sPathName + ACL_TEMP_FILE_NAME)) != XERR_SUCCESS)
		return iRet;

	TRY
	{
		CFile::Remove(m_sPathName + ACL_FILE_NAME);
		CFile::Rename(m_sPathName + ACL_TEMP_FILE_NAME, m_sPathName + ACL_FILE_NAME);
	}
	CATCH( CFileException, e )
	{
		return XERR_FILE_SAVE_ERROR;
	}
	END_CATCH

	return XERR_SUCCESS;
}

//
// 增加控管规则
//
int	CAclFile::AddAcl(void *pAddAcl, int AclType)
{
	if(pAddAcl == NULL) return XERR_FILE_INVALID_PARAMETER;

	PXACL_RECORD pAddRecord = NULL;

	switch(AclType)
	{
	case ACL_TYPE_ACL:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_ACL_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pAcl
			, &m_pAclHeader->ulAclCount);

	case ACL_TYPE_DISTRUST_IP:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_IP_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pDistrustIp
			, &m_pAclHeader->ulDistrustIPCount);

	case ACL_TYPE_TRUST_IP:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_IP_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pTrustIp
			, &m_pAclHeader->ulTrustIPCount);

	case ACL_TYPE_CUSTOM_IP:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_IP_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pCustomIp
			, &m_pAclHeader->ulCustomIPCount);

	case ACL_TYPE_INTRANET_IP:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_IP_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pIntranetIp
			, &m_pAclHeader->ulIntranetIPCount);

	case ACL_TYPE_WEB:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_WEB_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pWeb
			, &m_pAclHeader->dwWebCount);

	case ACL_TYPE_NNB:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_NNB_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pNnb
			, &m_pAclHeader->dwNnbCount);

	case ACL_TYPE_ICMP:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_ICMP_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pIcmp
			, &m_pAclHeader->dwIcmpCount);

	case ACL_TYPE_TIME:
		pAddRecord = (PXACL_RECORD)CreateRecord(pAddAcl, ACL_TIME_LENTH);
		return AddRecord(pAddRecord
			, (PXACL_RECORD*)&m_pAclHeader->pTime
			, &m_pAclHeader->ulTimeCount);

	default:
		return XERR_FILE_INVALID_PARAMETER;
	}

	return XERR_SUCCESS;
}

//
// 更新控管规则
//
int	CAclFile::UpdateAcl(void *pAcl, int AclType)
{
	switch(AclType)
	{
	case ACL_TYPE_ACL:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pAcl, ACL_ACL_LENTH);
	case ACL_TYPE_DISTRUST_IP:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pDistrustIp, ACL_IP_LENTH);
	case ACL_TYPE_TRUST_IP:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pTrustIp, ACL_IP_LENTH);
	case ACL_TYPE_CUSTOM_IP:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pCustomIp, ACL_IP_LENTH);
	case ACL_TYPE_INTRANET_IP:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pIntranetIp, ACL_IP_LENTH);
	case ACL_TYPE_WEB:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pWeb, ACL_WEB_LENTH);
	case ACL_TYPE_NNB:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pNnb, ACL_NNB_LENTH);
	case ACL_TYPE_ICMP:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pIcmp, ACL_ICMP_LENTH);
	case ACL_TYPE_TIME:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pTime, ACL_TIME_LENTH);
	case ACL_TYPE_ALL_IP:
		return UpdateRecord((PXACL_RECORD)pAcl, (PXACL_RECORD)m_pAclHeader->pAllIp, ACL_IP_LENTH);
	default:
		return XERR_FILE_INVALID_PARAMETER;
	}
}

//
// 删除控管规则
//
int	CAclFile::DelAcl(DWORD dwId, int AclType)
{