DriverPlatform-V3.1/CDI/HandleManager.cpp

#include "HandleManager.h"
#include "LocalConfig.h"
#include "PacketAnalizer.h"
#include "CDI.h"
#include "LogLocalHelper.h"       // 模块名接口声明（共用）
#include "Log4CPP.h"


HandleManager g_HandleManager;

HandleManager::HandleManager()
{
}


HandleManager::~HandleManager()
{
	Clear();
}

void HandleManager::Clear()
{
	//m_HandleMap.clear();
	Thread_Lock();
	m_CrcMap.clear();
	Thread_UnLock();
}

void HandleManager::ClearLocalDrvHandles(vector<UINT64> &ServerSysIFList)
{
	CcosTargetAddress DevID;
	vector<CcosDevFileHandle> HandleList;

	DevID[CCOS_PACK_TARGET_BUSID] = (const char*)getLocalEbusId();
	DevID[CCOS_PACK_TARGET_MACHINEID] = (const char*)getLocalMachineId();
	DevID[CCOS_PACK_TARGET_PROCID] = (UINT64)getpid();

	Thread_Lock();
	//kick all of dev's sysif 
	for (DWORD i = 0; i < ServerSysIFList.size(); i++)
	{
		DevID[CCOS_PACK_TARGET_ADDR] = ServerSysIFList[i];
//#ifdef _DEBUG
//		DevID.PrintOut();//for test
//#endif
		map<UINT64, CcosDevFileHandle>::iterator crc_iter = m_CrcMap.begin();
		while (crc_iter != m_CrcMap.end())
		{
//#ifdef _DEBUG
//			crc_iter->second.PrintOut();//for test
//#endif

			if (crc_iter->second.GetTarget(false) == DevID)
			{
				HandleList.push_back(crc_iter->second);

				//for test
				FERROR("ClearLocalDrvHandles Handle Id:{$}\n", (UINT64)(crc_iter->second[CCOS_PACKET_HANDLE_KEY]));

				crc_iter = m_CrcMap.erase(crc_iter);
				continue;
			}
			++crc_iter;
		}
	}
	Thread_UnLock();

	//notify close to owners
	for (DWORD i = 0; i < HandleList.size();i++)
	{
		ResDataObject Notify;
		PacketAnalizer::MakeCloseRequest(Notify, HandleList[i], PACKET_TYPE_NOTIFY);
		GetCommandDispathIF()->ReceivedFromDevice(Notify);
	}


}

void HandleManager::ClearRemoteHandles()
{
	vector<CcosDevFileHandle> HandleList;

	Thread_Lock();

	map<UINT64, CcosDevFileHandle>::iterator crc_iter = m_CrcMap.begin();
	while (crc_iter != m_CrcMap.end())
	{
		if ((int)(crc_iter->second[CCOS_PACK_HANDLE_ROUTE]) == (int)CCOS_PACKET_ROUTE_ETH)
		//if (crc_iter->second.m_Owner.m_MachineID.GetVal() != MachineId)
		{
			HandleList.push_back(crc_iter->second);

			//for test
			FERROR("ClearRemoteHandles Handle Id:{$}\n", (UINT64)(crc_iter->second[CCOS_PACKET_HANDLE_KEY]));

			crc_iter = m_CrcMap.erase(crc_iter);
			continue;
		}
		++crc_iter;
	}

	
	Thread_UnLock();

	//send notify here
	//send ...
	//notify close to owners
	for (DWORD i = 0; i < HandleList.size(); i++)
	{
		ResDataObject Notify;
		PacketAnalizer::MakeCloseRequest(Notify, HandleList[i], PACKET_TYPE_NOTIFY);
		GetCommandDispathIF()->ReceivedFromDevice(Notify);
	}



}


bool HandleManager::Registhandle(CcosDevFileHandle &Handle)
{
	Thread_Lock();
	map<UINT64, CcosDevFileHandle>::iterator crc_iter = m_CrcMap.find((UINT64)Handle[CCOS_PACKET_HANDLE_KEY]);
	if (crc_iter != m_CrcMap.end())
	{
		Thread_UnLock();
		return false;
	}

	//if (RegistHandle(Handle.m_Dev.m_ProcID, Handle.m_Dev.m_Addr, Handle.m_Owner, Handle.m_Flags))
	//{
	//	m_CrcMap[Handle.m_HandleId] = Handle;
	//}

	m_CrcMap[(UINT64)Handle[CCOS_PACKET_HANDLE_KEY]] = Handle;

#ifdef _DEBUG
	//for test
	FERROR("Registed Handle Count:{$}\n", m_CrcMap.size());
	crc_iter = m_CrcMap.begin();
	while (crc_iter != m_CrcMap.end())
	{
		FERROR("Registed Handle Id:{$}\n", (UINT64)(crc_iter->second[CCOS_PACKET_HANDLE_KEY]));
		++crc_iter;
	}
#endif

	Thread_UnLock();
	return true;
}

bool HandleManager::UnRegistHandle(UINT64 CrcCode)
{
	Thread_Lock();

	//for test
	FERROR("Before UnRegistHandle,Map Count:{$},Req Handle Id:{$}\n", m_CrcMap.size(), CrcCode);


	map<UINT64, CcosDevFileHandle>::iterator crc_iter = m_CrcMap.find(CrcCode);
	if (crc_iter != m_CrcMap.end())
	{
		//for test
		FERROR("UnRegistHandle Handle Id:{$}\n", (UINT64)(crc_iter->second[CCOS_PACKET_HANDLE_KEY]));

		m_CrcMap.erase(crc_iter);
		Thread_UnLock();

		return true;


	}

	//for test
#ifdef _DEBUG
	FERROR("Left Handle Count:{$}\n", m_CrcMap.size());
	crc_iter = m_CrcMap.begin();
	while (crc_iter != m_CrcMap.end())
	{
		FERROR("LeftHandle Id:{$}\n", (UINT64)(crc_iter->second[CCOS_PACKET_HANDLE_KEY]));
		++crc_iter;
	}
#endif
	Thread_UnLock();
	return false;
}


bool HandleManager::GetHandle(UINT64 CrcCode, CcosDevFileHandle& filehandle)
{
	Thread_Lock();
	map<UINT64, CcosDevFileHandle>::iterator crc_iter = m_CrcMap.find(CrcCode);
	if (crc_iter != m_CrcMap.end())
	{
		filehandle = crc_iter->second;
		Thread_UnLock();
		return true;
	}

	Thread_UnLock();
	return false;
}

bool HandleManager::GetFileFlag(UINT64 CrcCode,UINT64 DevAddr, DWORD &fileFlag)
{
	bool ret = false;
	Thread_Lock();
	map<UINT64, CcosDevFileHandle>::iterator crc_iter = m_CrcMap.find(CrcCode);
	if (crc_iter != m_CrcMap.end())
	{
		if ((UINT64)crc_iter->second.GetTarget(false)[CCOS_PACK_TARGET_ADDR] == DevAddr)
		{
			fileFlag = crc_iter->second[CCOS_PACK_HANDLE_FLAGS];
			ret = true;
		}
		else
		{
			FERROR("Dev Addr not exist.Crc:{$}", DevAddr);
		}
	}
	else
	{
		FERROR("Dev Crc not exist.Crc:{$}", CrcCode);
	}

	Thread_UnLock();
	return ret;
}

void HandleManager::DeviceDetached(UINT64 ProcId, UINT64 Addr)
{
	//NOT FINISHED YET
	//it didn't send the close notify
	Thread_Lock();
	map<UINT64, CcosDevFileHandle>::iterator crc_iter = m_CrcMap.begin();
	while (crc_iter != m_CrcMap.end())
	{
		if ((UINT64)crc_iter->second.GetTarget(false)[CCOS_PACK_TARGET_ADDR] == Addr && (UINT64)crc_iter->second.GetTarget(false)[CCOS_PACK_TARGET_PROCID] == ProcId)
		{
			//send notify here
			//send ...

			//for test
			FERROR("DeviceDetached Handle Id:{$}\n", (UINT64)(crc_iter->second[CCOS_PACKET_HANDLE_KEY]));

			crc_iter = m_CrcMap.erase(crc_iter);
			continue;
		}
		++crc_iter;
	}

	Thread_UnLock();

}

bool HandleManager::CheckNotifyPacketAccessValidity(ResDataObject &packet, DWORD Flags)
{
	bool ret = true;
	//CMD
	PACKET_CMD cmd = PacketAnalizer::GetPacketCmd(&packet);
	switch (cmd)
	{
	case PACKET_CMD_EXE:
		if ((Flags & NOTIFY_ACTION) == 0)
		{
			ret = false;
		}
		break;
	case PACKET_CMD_DATA:
		if ((Flags & NOTIFY_DATA) == 0)
		{
			ret = false;
		}

		break;
	case PACKET_CMD_MSG:
		if ((Flags & NOTIFY_MSG) == 0)
		{
			ret = false;
		}
		break;
	case PACKET_CMD_PART_UPDATE:
	case PACKET_CMD_UPDATE:
	case PACKET_CMD_ADD:
	case PACKET_CMD_DEL:
		if ((Flags & NOTIFY_UPDATE) == 0)
		{
			ret = false;
		}
		break;
	}

	return ret;


}

bool HandleManager::CheckNormalPacketAccessValidity(ResDataObject &packet,DWORD Flags)
{
	bool ret = true;
	//CMD
	PACKET_CMD cmd = PacketAnalizer::GetPacketCmd(&packet);
	switch (cmd)
	{
	case PACKET_CMD_EXE:
		if ((Flags & ACTION) == 0)
		{
			ret = false;
		}
		break;
	case PACKET_CMD_DATA:
	case PACKET_CMD_MSG:
	case PACKET_CMD_UPDATE:
	case PACKET_CMD_ADD:
	case PACKET_CMD_DEL:
			ret = false;
		break;
	}

	return ret;


}

CMD_ECHO HandleManager::CheckReqPacketValidity(ResDataObject &packet, UINT64 &Addr)
{
	CMD_ECHO ret = CMD_ECHO_IGNORE;//ignore
	UINT64 Crc;
	DWORD Flag;
	bool status = true;
	status &= PacketAnalizer::GetPacketHandleCrc(&packet, Crc);
	status &= PacketAnalizer::GetPacketHandleAddr(&packet, Addr, true);

	if (status)
	{
		if (GetFileFlag(Crc, Addr, Flag))
		{
			//REQ & RES
			status = CheckNormalPacketAccessValidity(packet, Flag);
			if (status)
			{
				ret = CMD_ECHO_OK;//ok
			}
			else
			{
				FERROR("Dev AccessValidity not Match.AccessFlag: {$} packet {$}", Flag, packet.encode());
				ret = CMD_ECHO_NG;//failed
			}
		}
		else
		{
			FERROR("fileFlag not right {$} ", packet.encode());
			ret = CMD_ECHO_NOTARGET;//no target
		}
	}
	
	return ret;
}

bool HandleManager::GetNotifyOwners(ResDataObject &packet, vector<CcosDevFileHandle> &OwnerList)
{
	bool ret = true;
	//get device proc&address
	UINT64 Proc, Addr;
	ret &= PacketAnalizer::GetPacketHandleProcId(&packet, Proc, true);
	ret &= PacketAnalizer::GetPacketHandleAddr(&packet, Addr, true);

	if (ret == false)
	{
		return false;
	}

	OwnerList.clear();

	Thread_Lock();
	map<UINT64, CcosDevFileHandle>::iterator crc_iter = m_CrcMap.begin();
	while (crc_iter != m_CrcMap.end())
	{
		if (((UINT64)crc_iter->second.GetTarget(false)[CCOS_PACK_TARGET_ADDR] == Addr) 
			&& ((UINT64)crc_iter->second.GetTarget(false)[CCOS_PACK_TARGET_PROCID] == Proc))
		{
			//
			if (CheckNotifyPacketAccessValidity(packet, crc_iter->second[CCOS_PACK_HANDLE_FLAGS]))
			{
				//match one
				OwnerList.push_back(crc_iter->second);
			}
		}
		++crc_iter;
	}
	Thread_UnLock();

	return (OwnerList.size() > 0);
}