#include "pch.h"


typedef struct _FILE_PATH_LIST
{
	FILE_OBJECT_DESC des;
	DWORD dwCnt;
	//DWORD dwPathSize;

}FILE_PATH_LIST, * PFILE_PATH_LIST;


list<FILE_PATH_LIST> FileList;
list<FILE_OBJECT_DESC> obj_list;
static CRITICAL_SECTION s_objcs;


list<BS1FLT_SET_PROCESS_PATH> process_list;
static CRITICAL_SECTION s_prcs;



static BOOL IsStatus = FALSE;
static BOOL IsProcessStatus = FALSE;

VOID InitFileLst()
{
	InitializeCriticalSection(&s_objcs);

	obj_list.clear();
	FileList.clear();
	IsStatus = TRUE;
	return;
}

VOID CleanupFileLst()
{
	if (!IsStatus)
		return;

	EnterCriticalSection(&s_objcs);
	FileList.clear();
	obj_list.clear();
	LeaveCriticalSection(&s_objcs);
	DeleteCriticalSection(&s_objcs);
	IsStatus = FALSE;

	return;
}


VOID InitProcessLst()
{
	InitializeCriticalSection(&s_prcs);

	process_list.clear();
	IsProcessStatus = TRUE;
	return;
}

VOID CleanupProcessLst()
{
	if (!IsProcessStatus)
		return;

	EnterCriticalSection(&s_prcs);
	process_list.clear();
	LeaveCriticalSection(&s_prcs);
	DeleteCriticalSection(&s_prcs);
	IsProcessStatus = FALSE;

	return;
}


DWORD IsProcessList(LPWSTR lpwPath, DWORD dwPathSize, DWORD type)
{
	list <BS1FLT_SET_PROCESS_PATH>::iterator it;
	DWORD dwSize = dwPathSize;
	DWORD dwType = 0;

	if (!IsProcessStatus)
		return 0;

	if (process_list.empty())
		return 0;

	EnterCriticalSection(&s_prcs);
	it = process_list.begin();
	for (; it != process_list.end(); ++it)
	{
		DWORD len = 0;
		WCHAR* name = NULL;
		WCHAR* rname = wcsrchr(it->path, '\\');
		if (!rname)
		{
			name = wcsrchr(lpwPath, '\\');
			if (name)
			{
				++name;
				len = (DWORD)wcslen(name);
			}
			else
			{
				name = lpwPath;
				len = dwPathSize;
			}
		}
		else
		{
			name = lpwPath;
			len = dwSize;
		}

		if (len < it->size)
			continue;

		if (!_wcsnicmp(name, it->path, len))
		{
			BSONE_DEBUG(L"IsProcessList, it->ProcessPath(%s) name(%s)(%d) type(%d) cmp ok\n", it->path, name, len, type);
			if (type)
				it->type = type;

			dwType = it->type;
			break;
		}
	}

	LeaveCriticalSection(&s_prcs);
	return dwType;
}



BOOL SetProcessList(DWORD dwType, LPWSTR lpwPath, DWORD dwPathSize)
{
	BS1FLT_SET_PROCESS_PATH Path = { 0, };
	list <BS1FLT_SET_PROCESS_PATH>::iterator it;
	DWORD dwSize = dwPathSize;

	if (!IsProcessStatus)
		return FALSE;

	if (IsProcessList(lpwPath, dwSize, dwType))
		return FALSE;

	Path.type = dwType;
	StringCbCopyW(Path.path, sizeof(Path.path), lpwPath);
	Path.size = dwSize;

	EnterCriticalSection(&s_prcs);
	process_list.push_back(Path);
	LeaveCriticalSection(&s_prcs);
	//PB_DEBUGW(L"SetProcessList, dwType(%d)	ProcessPath(%s), dwSize(%d)\n", dwType, Path.ProcessPath, dwSize);

	return TRUE;

}



BOOL SetFilelist(PFILE_OBJECT_DESC pObj)
{
	FILE_PATH_LIST PathLst = { 0, };
	list <FILE_PATH_LIST>::iterator it;
	DWORD dwSize = pObj->size;

	it = FileList.begin();
	for (; it != FileList.end(); ++it)
	{

		if (it->des.size != dwSize)
			continue;

		if (0 == _wcsnicmp(it->des.path, pObj->path, dwSize))
		{
			++it->dwCnt;
			return FALSE;
		}
	}

	memcpy(&PathLst.des, pObj, sizeof(FILE_OBJECT_DESC));
	++PathLst.dwCnt;
	FileList.push_back(PathLst);

	BSONE_DEBUG(L"AddFilelist, path(%s)\n", pObj->path);
	return TRUE;
}



BOOL SetFileObj(DWORD dwType, DWORD dwPid, WCHAR* pPath, DWORD dwPathSize)
{
	FILE_OBJECT_DESC obj = { 0, };
	DWORD dwSize = dwPathSize / sizeof(WCHAR);


	obj.size = dwSize;
	obj.pid = dwPid;
	obj.type = dwType;
	StringCbCopyW(obj.path, sizeof(obj.path), pPath);

	EnterCriticalSection(&s_objcs);
	obj_list.push_back(obj);

	SetFilelist(&obj);
	LeaveCriticalSection(&s_objcs);

	BSONE_DEBUG(L"AddFileObj, pPath(%s),	dwSize(%d)\n", pPath, dwSize);
	return TRUE;
}

BOOL RemoveFileLst(DWORD dwType, WCHAR* pPath, DWORD dwPathSize)
{
	FILE_PATH_LIST PathLst = { 0, };
	list <FILE_PATH_LIST>::iterator it;
	DWORD dwSize = dwPathSize;
	BOOL bIs = FALSE;

	if (FileList.empty())
		return FALSE;


	EnterCriticalSection(&s_objcs);

	it = FileList.begin();
	for (; it != FileList.end(); ++it)
	{
		if (it->des.size != dwSize)
			continue;

		if (!_wcsnicmp(it->des.path, pPath, dwSize))
		{
			--it->dwCnt;
			if (it->dwCnt == 0)
			{
				FileList.erase(it);
				bIs = TRUE;
			}

			break;
		}

	}

	LeaveCriticalSection(&s_objcs);
	return bIs;
}


BOOL GetFileList(DWORD dwPid, list<FILE_OBJECT_DESC>& fileobj)
{
	FILE_OBJECT_DESC obj = { 0, };
	list <FILE_OBJECT_DESC>::iterator it;
	BOOL bIs = FALSE;
	DWORD i = 0;

	if (obj_list.empty())
		return FALSE;

	EnterCriticalSection(&s_objcs);

	it = obj_list.begin();
	while (it != obj_list.end())
	{
		if (it->pid != dwPid)
		{
			++it;
			continue;
		}

		//PB_DEBUGW(L"GetFileList, enum[%d] %d		%s\n", obj_list.size(), it->ulPid, it->path);
		fileobj.push_back((FILE_OBJECT_DESC)*it);
		it = obj_list.erase(it);
		bIs = TRUE;
	}

	LeaveCriticalSection(&s_objcs);
	return bIs;
}

vector<ULONG> vexit_pid;
static CRITICAL_SECTION s_exitpidcs;
BOOL IsExitPidStatus = FALSE;

VOID InitExitPid()
{
	InitializeCriticalSection(&s_exitpidcs);

	vexit_pid.clear();
	IsExitPidStatus = TRUE;
	return;
}

VOID SetExitPid(ULONG ulPid)
{
	if (!IsExitPidStatus)
		return;

	EnterCriticalSection(&s_exitpidcs);
	vexit_pid.push_back(ulPid);
	BSONE_DEBUG(L"SetExitPid,	Pid(%d)\n", ulPid);
	LeaveCriticalSection(&s_exitpidcs);
}

DWORD GetExitPid(PEXIT_PID pExitPid, ULONG ulSize)
{
	if (!IsExitPidStatus)
		return 0;

	EnterCriticalSection(&s_exitpidcs);

	BSONE_DEBUG(L"GetExitPid,	ulCnt(%d)\n", __FUNCTIONW__, pExitPid->ulCnt);
	pExitPid->ulCnt = (DWORD)vexit_pid.size();
	memcpy(pExitPid->ulPid, &vexit_pid[0], sizeof(ULONG) * pExitPid->ulCnt);
	vexit_pid.clear();
	LeaveCriticalSection(&s_exitpidcs);

	return pExitPid->ulCnt * sizeof(ULONG);
}

VOID CleanupExitPid()
{
	if (!IsExitPidStatus)
		return;

	EnterCriticalSection(&s_exitpidcs);
	vexit_pid.clear();
	LeaveCriticalSection(&s_exitpidcs);
	DeleteCriticalSection(&s_exitpidcs);
}