xfile.cpp

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

//-----------------------------------------------------------
/*
	工程：		费尔个人防火墙
	网址：		http://www.xfilt.com
	电子邮件：	[e-mail]
	版权所有 (c) 2002 朱艳辉(费尔安全实验室)

	版权声明:
	---------------------------------------------------
		本电脑程序受著作权法的保护。未经授权，不能使用
	和修改本软件全部或部分源代码。凡擅自复制、盗用或散
	布此程序或部分程序或者有其它任何越权行为，将遭到民
	事赔偿及刑事的处罚，并将依法以最高刑罚进行追诉。
	
		凡通过合法途径购买此源程序者(仅限于本人)，默认
	授权允许阅读、编译、调试。调试且仅限于调试的需要才
	可以修改本代码，且修改后的代码也不可直接使用。未经
	授权，不允许将本产品的全部或部分代码用于其它产品，
	不允许转阅他人，不允许以任何方式复制或传播，不允许
	用于任何方式的商业行为。	

    ---------------------------------------------------	
*/
//-----------------------------------------------------------
//
// 控管规则操作类
//
//


#include "stdafx.h"
#include "XFile.h"

//============================================================================================
//Acl file operation
//initialize public function

CAclFile::CAclFile()
{
	m_AclFile.m_hFile 	= NULL;
	m_pMemFile			= NULL;
	m_pAclHeader		= NULL;
	m_hMemFile			= NULL;
	m_pCurrentPoint		= NULL;

	m_sPathName.Empty();

	InitializeCriticalSection(&gCriticalSectionFile);
}

CAclFile::~CAclFile()
{
	XF_SetFilterMode(FALSE);
	WaitRefence();
	CloseAcl();
	CloseMemFile();
}

//
// 等待所有使用控管规则数据的操作退出
//
void CAclFile::WaitRefence()
{
	if(m_pAclHeader == NULL)
		return;
	m_pAclHeader->wPv = PV_LOCKED;
	int TimeOut = 50; // 5 seconds
	while(m_pAclHeader->wRefenceCount > 0 && TimeOut-- > 0)
		Sleep(PV_LOCK_WAIT_TIME);
	m_pAclHeader->wRefenceCount = 0;
	m_pAclHeader->wPv = PV_UNLOCK;
}

//
// 释放内存
//
void CAclFile::CloseMemFile()
{
	//if(m_hMemFile != NULL && m_pMemFile != NULL)
	//{
	//	// 2002/08/20 add
	//	XF_UnmapViewOfFile(m_hMemFile
	//		, IOCTL_NDISHK_UNMAP_ACL_BUFFER
	//		, m_pMemFile
	//		);
	//	XF_UnmapViewOfFile(m_hMemFile
	//		, IOCTL_NDISHK_UNMAP_BUFFER_POINT
	//		, (const void*)TYPE_IOCTL_UNMAP_BUFFER_1
	//		);
	//	XF_UnmapViewOfFile(m_hMemFile
	//		, IOCTL_NDISHK_UNMAP_BUFFER_POINT
	//		, (const void*)TYPE_IOCTL_UNMAP_BUFFER_2
	//		);

	//	XF_UnmapViewOfFile(m_hMemFile
	//		, IOCTL_NDISHK_FREE_ACL_BUFFER/*2002/08/20 add*/
	//		, m_pMemFile
	//		);
	//	CloseHandle(m_hMemFile);
	//	m_pMemFile = NULL;
	//	m_hMemFile = NULL;
	//}
	m_pAclHeader = NULL;
	m_pCurrentPoint = NULL;
}

//
// 关闭控管规则文件
//
void CAclFile::CloseAcl()
{
	if(m_AclFile.m_hFile != NULL)
	{
		m_AclFile.Close();
		m_AclFile.m_hFile = NULL;
	}
}

//
// 创建控管规则的内存映射文件
//
BOOL CAclFile::Create(LPCTSTR sMemFile, DWORD dwMaxSize)
{
	StopFilter();
	WaitRefence();
	CloseMemFile();

	m_hMemFile = XF_CreateFileMapping((HANDLE)INVALID_HANDLE_VALUE
		, GetSecurityAttributes()
		, PAGE_READWRITE
		, 0
		, dwMaxSize
		, sMemFile);
	if(m_hMemFile == NULL) return FALSE;

	m_pMemFile = (char*)XF_MapViewOfFile(m_hMemFile, FILE_MAP_WRITE, 0, 0, 0, 1);
	if(m_pMemFile == NULL)
	{
		CloseHandle(m_hMemFile);
		m_hMemFile = NULL;
		return FALSE;
	}
	return TRUE;
}

//
// 锁定内存
//
BOOL CAclFile::Lock()
{
	if(m_pAclHeader == NULL)
		return FALSE;
	while(m_pAclHeader->wPv != PV_UNLOCK)
		Sleep(PV_LOCK_WAIT_TIME);
	if(m_pAclHeader == NULL) return FALSE;
	ODS("Locked\n");
	m_pAclHeader->wPv = PV_LOCKED;
	int TimeOut = 50; // 5 seconds
	while(m_pAclHeader->wRefenceCount > 0 && TimeOut-- > 0)
		Sleep(PV_LOCK_WAIT_TIME);
	m_pAclHeader->wRefenceCount = 0;
	return TRUE;
}

//
// 解除锁定
//
void CAclFile::Unlock()
{
	if(m_pAclHeader == NULL)
		return;
	m_pAclHeader->wPv = PV_UNLOCK;
	ODS("Unlock\n");
}

//
// 通知PKF.DLL和nDisHK.SYS或者nDisHK.VXD停止过滤
//
BOOL CAclFile::StopFilter()
{
	if(m_pDllIoControl == NULL) return FALSE;
	PKF_IO_CONTROL IoControl;
	IoControl.Byte = TRUE;
	m_pDllIoControl(IO_CONTROL_SET_ACL_IS_REFRESH, &IoControl);
	XF_SetFilterMode(FALSE);
	return TRUE;
}

//
// 通知PKF.DLL和nDisHK.SYS或者nDisHK.VXD继续过滤
//
BOOL CAclFile::ContinueFilter()
{
	if(m_pDllIoControl == NULL) return FALSE;
	PKF_IO_CONTROL IoControl;
	IoControl.Byte = FALSE;
	m_pDllIoControl(IO_CONTROL_SET_ACL_IS_REFRESH, &IoControl);
	XF_SetFilterMode(TRUE);
	return TRUE;
}

//
// 通知PKF.DLL控管规则内存映射文件的句柄
//
BOOL CAclFile::SetDllAclMemoryHandle(HANDLE hFile)
{
	if(m_pDllIoControl == NULL) return FALSE;
	PKF_IO_CONTROL IoControl;
	IoControl.DWord = (DWORD)hFile;
	IoControl.Pointer = (BYTE*)m_dwMaxSize;
	IoControl.DWord2 = (DWORD)m_pAclHeader;
	m_pDllIoControl(IO_CONTROL_SET_ACL_MEMORY_FILE_HANDLE, &IoControl);
	return TRUE;
}


//============================================================================================
//private function

//
// 初始化 Acl Header
//
void CAclFile::InitDefaultValue()
{
	if(m_pMemFile != NULL) delete[] m_pMemFile;
	DWORD dwFileLen = ACL_HEADER_LENTH + ACL_TIME_TOTAL_LENTH + ACL_IP_LENTH * 2;
	m_pMemFile = new CHAR[dwFileLen];
	memset(m_pMemFile, 0, dwFileLen);

	m_pAclHeader = (PXACL_HEADER)m_pMemFile;

	// Initalize header default value
	_tcscpy(m_pAclHeader->sSignature, ACL_HEADER_SIGNATURE);
	m_pAclHeader->bMajor	= ACL_HEADER_MAJOR;
	m_pAclHeader->bMinor	= ACL_HEADER_MINOR;
	m_pAclHeader->uiSerial	= ACL_HEADER_SERIAL;
	m_pAclHeader->ulVersion	= ACL_HEADER_VERSION;
	m_pAclHeader->uiLogSize	= ACL_HEADER_LOG_SIZE;
	m_pAclHeader->bUpdateInterval = ACL_HEADER_UPDATE_INTERVAL;
	_tcscpy(m_pAclHeader->sUserName, ACL_HEADER_USER_NAME);
	_tcscpy(m_pAclHeader->sACode, ACL_HEADER_ACODE);
	_tcscpy(m_pAclHeader->sWebURL, ACL_HEADER_WEB_URL);
	_stprintf(m_pAclHeader->sCommandURL, ACL_HEADER_COMMAND_URL
		, GUI_LANGUAGE, ACL_HEADER_VERSION, ACL_HEADER_MAJOR, ACL_HEADER_MINOR);
	_tcscpy(m_pAclHeader->sUserRegisterURL, ACL_HEADER_REGISTER_URL);
	_tcscpy(m_pAclHeader->sEmail, ACL_HEADER_EMAIL);
	m_pAclHeader->ulHeaderLenth	= ACL_HEADER_LENTH;

	m_pAclHeader->bWriteLog = ACL_WRITE_LOG;
	m_pAclHeader->bAutoStart = ACL_AUTO_START;
	m_pAclHeader->bAudioAlert = ACL_AUDIO_ALERT;
	m_pAclHeader->bSplashAlert = ACL_SPLASH_ALERT;
	m_pAclHeader->bShowWelcome = ACL_SHOW_WELCOME;
	m_pAclHeader->bCheckTorjan = ACL_CHECK_TORJAN;
	m_pAclHeader->bCheckFile = ACL_CHECK_FILE;

	m_pAclHeader->bAppSet = ACL_APP_SET;
	m_pAclHeader->bAppQueryEx = ACL_QUERY_QUERY;
	m_pAclHeader->bWebSet = ACL_WEB_SET;
	m_pAclHeader->bWebQueryEx = ACL_QUERY_QUERY;
	m_pAclHeader->bNnbSet = ACL_NNB_SET;
	m_pAclHeader->bNnbQueryEx = ACL_QUERY_QUERY;
	m_pAclHeader->bIcmpSet = ACL_ICMP_SET;
	m_pAclHeader->bIcmpQueryEx = ACL_QUERY_QUERY;
	m_pAclHeader->bSecurity = ACL_SECURITY;
	m_pAclHeader->bWorkMode = ACL_WORK_MODE;

	//
	// Initalize intranet IP aria default value
	//
	m_pAclHeader->pAllIp 
		= (PXACL_IP)(ACL_HEADER_LENTH + ACL_TIME_TOTAL_LENTH + (DWORD)m_pMemFile);
	m_pAclHeader->dwAllIpCount	= 1;
	m_pAclHeader->pAllIp->dwId	= 1;
	m_pAclHeader->pAllIp->bNotAllowEdit = 1;

	m_pAclHeader->pIntranetIp 
		= (PXACL_IP)(ACL_HEADER_LENTH  + ACL_TIME_TOTAL_LENTH + ACL_IP_LENTH + (DWORD)m_pMemFile);
	m_pAclHeader->ulIntranetIPCount	= ACL_HEADER_INTRANET_IP_COUNT;

	m_pAclHeader->pIntranetIp->dwId		= 1;
	m_pAclHeader->pIntranetIp->ulStartIP= ACL_INTRANET_START_IP;
	m_pAclHeader->pIntranetIp->ulEndIP	= ACL_INTRANET_END_IP;
	m_pAclHeader->pIntranetIp->pNext	= NULL;

	//
	// Initalize time aria default value
	//
	m_pAclHeader->pTime	= (PXACL_TIME)(ACL_HEADER_LENTH + (DWORD)m_pMemFile);
	m_pAclHeader->ulTimeCount = ACL_HEADER_TIME_COUNT;
	for(DWORD i = 0; i < m_pAclHeader->ulTimeCount; i++)
	{
		(m_pAclHeader->pTime + i)->dwId = (DWORD)(i + 1);
		(m_pAclHeader->pTime + i)->bWeekDay	= ACL_WEEK[i];
		(m_pAclHeader->pTime + i)->tStartTime = ACL_TIME_START[i];
		(m_pAclHeader->pTime + i)->tEndTime	= ACL_TIME_END[i];

		if(i == m_pAclHeader->ulTimeCount - 1)
			(m_pAclHeader->pTime + i)->pNext = NULL;
		else
			(m_pAclHeader->pTime + i)->pNext = m_pAclHeader->pTime + i + 1;
	}
	m_pAclHeader->pTime->bNotAllowEdit = 1;
}

//
// 创建控管规则文件
//
int CAclFile::CreateAcl(const TCHAR *sPathName)
{
	InitDefaultValue();
	return WriteAcl(sPathName);
}

//
// 打开控管规则文件
//
int CAclFile::OpenAcl()
{
	int		iRet;

	if(_taccess(m_sPathName + ACL_FILE_NAME, 0) == -1
		&& (iRet = CreateAcl(m_sPathName + ACL_FILE_NAME)) != XERR_SUCCESS)	
		return iRet;

	TRY										
	{
		m_AclFile.Open(	m_sPathName + ACL_FILE_NAME,
						CFile::modeRead			|
						CFile::typeBinary		| 
						CFile::shareDenyWrite
						);
	}
	CATCH( CFileException, e )
	{
		return XERR_FILE_CAN_NOT_OPEN;
	}
	END_CATCH

	return XERR_SUCCESS;
}

//
// 保存控管规则记录到控管规则文件
//
int CAclFile::WriteRecord(CFile *File, DWORD* pRecord, DWORD dwRecordLen, DWORD* FilePosition)
{
	if(pRecord == NULL)	return XERR_SUCCESS;

	TRY
	{
		*FilePosition = File->GetPosition();

		DWORD dwTempLen = dwRecordLen - sizeof(DWORD);
		DWORD dwNext = 0;
		DWORD* pTempRecord = pRecord;
		while(pTempRecord != NULL)
		{
			if(*pTempRecord != NULL)
			{
				dwNext = File->GetPosition() + dwRecordLen;
				File->Write(&dwNext, sizeof(DWORD));
				File->Write(pTempRecord + 1, dwTempLen);
				pTempRecord = (DWORD*)*pTempRecord;
			}
			else
			{
				File->Write(pTempRecord, dwRecordLen);
				break;
			}
		}
	}
	CATCH( CFileException, e )
	{
		return XERR_FILE_SAVE_ERROR;
	}
	END_CATCH

	return XERR_SUCCESS;
}

//
// 保存整个控管规则文件
//
int CAclFile::WriteAcl(const TCHAR *sPathName)
{
	CFile	FileAcl;

	TRY
	{
		FileAcl.Open(	sPathName,
						CFile::modeCreate	| 
						CFile::modeWrite	| 
						CFile::typeBinary	| 
						CFile::shareExclusive
						);

		XACL_HEADER AclHeader = *m_pAclHeader;

		FileAcl.Seek(ACL_HEADER_LENTH, CFile::begin);

		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pTime
			, ACL_TIME_LENTH
			, (DWORD*)&AclHeader.pTime);
		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pAllIp
			, ACL_IP_LENTH
			, (DWORD*)&AclHeader.pAllIp);
		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pIntranetIp
			, ACL_IP_LENTH
			, (DWORD*)&AclHeader.pIntranetIp);
		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pDistrustIp
			, ACL_IP_LENTH
			, (DWORD*)&AclHeader.pDistrustIp);
		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pTrustIp
			, ACL_IP_LENTH
			, (DWORD*)&AclHeader.pTrustIp);
		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pCustomIp
			, ACL_IP_LENTH
			, (DWORD*)&AclHeader.pCustomIp);
		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pAcl
			, ACL_ACL_LENTH
			, (DWORD*)&AclHeader.pAcl);
		WriteRecord(&FileAcl
			, (DWORD*)m_pAclHeader->pWeb
			, ACL_WEB_LENTH
			, (DWORD*)&AclHeader.pWeb);