myvtm/Other/USBKeyAPI/USBKeyAPI.cpp

#include "USBKeyAPI.h"

DeviceBaseClass *pDevcieBase = NULL;
unsigned int g_DeviceType = NO_USBKEY;
USBKEY_INFO g_KeyInfo = {0};

DLL_EXPORT_API DWORD FindUsbKey(USBKEY_INFO* pKeyInfo, unsigned int* pCount)
{
	if (NULL == pKeyInfo
		|| NULL == pCount)
	{
		return USBKEY_INVALID_PARAMETER;
	}
	
	pDevcieBase = new RocArmTime();
	DWORD dwRet = pDevcieBase->FindUsbKey(pKeyInfo, pCount);
	if((DONGLE_SUCCESS != dwRet) || (*pCount == 0))
	{
		g_DeviceType = NO_USBKEY;
		delete pDevcieBase;
		pDevcieBase = NULL;
	}
	else
	{
		g_DeviceType = ROCEYARM_TIME_FEITAIN;
		pKeyInfo->m_USBKeyType = ROCEYARM_TIME_FEITAIN;
		printf("UKey Type:Feitian Rockey Arm Time\n");
		memcpy(&g_KeyInfo, pKeyInfo, sizeof(USBKEY_INFO));
		return USBKEY_SUCCESS;
	}

	if (NO_USBKEY == g_DeviceType)
	{
		pDevcieBase = new S4Time();
		dwRet = pDevcieBase->FindUsbKey(pKeyInfo, pCount);
		if((S4_SUCCESS != dwRet) || (*pCount == 0))
		{
			g_DeviceType = NO_USBKEY;
			delete pDevcieBase;
			pDevcieBase = NULL;
		}
		else
		{
			g_DeviceType = S4_TIME_SENSI;
			pKeyInfo->m_USBKeyType = S4_TIME_SENSI;
			memcpy(&g_KeyInfo, pKeyInfo, sizeof(USBKEY_INFO));
			printf("UKey Type:Sensi S4 Time\n");
			return USBKEY_SUCCESS;
		}
	}

	if (NO_USBKEY == g_DeviceType)
	{
		pDevcieBase = new GM3000();
		dwRet = pDevcieBase->FindUsbKey(pKeyInfo, pCount);
		if((S4_SUCCESS != dwRet) || (*pCount == 0))
		{
			g_DeviceType = NO_USBKEY;
			delete pDevcieBase;
			pDevcieBase = NULL;
		}
		else
		{
			g_DeviceType = GM3000_LONGMAI;
			pKeyInfo->m_USBKeyType = GM3000_LONGMAI;
			memcpy(&g_KeyInfo, pKeyInfo, sizeof(USBKEY_INFO));
			printf("UKey Type:Longmai GM3000\n");
			//g_log->LOGERROR("UKey Type:Longmai GM3000");
			return USBKEY_SUCCESS;
		}
	}

	//没有找到，则继续找其他厂商
	//此处可以添加处理新的设备


	if (NO_USBKEY == g_DeviceType)
	{
		return USBKEY_NOT_FOUND;
	}

	return USBKEY_SUCCESS;
}

DLL_EXPORT_API DWORD OpenUsbKey(USBKEY_HANDLE *pHandle,unsigned int Item)
{	
	if (NULL == pHandle || NULL == pDevcieBase)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->OpenUsbKey(pHandle, Item);
}

DLL_EXPORT_API DWORD CloseUsbKey(USBKEY_HANDLE hHandle)
{
	if (NULL == hHandle || NULL == pDevcieBase)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->CloseUsbKey(hHandle);
}

DLL_EXPORT_API DWORD VerifyAdminPIN(USBKEY_HANDLE hHandle, char* pPIN)
{
	if (NULL == hHandle || NULL == pDevcieBase)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	if (MAX_PIN_LEN != strlen(pPIN))
	{
		return USBKEY_INCORRECT_PIN_LEN;
	}

	return pDevcieBase->VerifyAdminPIN(hHandle, pPIN);
}

DLL_EXPORT_API DWORD ChangeAdminPIN(USBKEY_HANDLE hHandle,char* pOldPin, char* pNewPin)
{
	if ((MAX_PIN_LEN != strlen(pOldPin)) || (MAX_PIN_LEN != strlen(pNewPin)))
	{
		return USBKEY_INCORRECT_PIN_LEN;
	}

	return pDevcieBase->ChangeAdminPIN(hHandle, pOldPin, pNewPin);
}

DLL_EXPORT_API DWORD GenUniqueKey(USBKEY_HANDLE hHandle,char* pAdminPin, char* pUserPin)
{
	if (NULL == hHandle 
		|| NULL == pDevcieBase 
		|| NULL == pAdminPin
		|| NULL == pUserPin)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->GenUniqueKey(hHandle, pAdminPin, pUserPin);
}

DWORD CreatePrivateKey(USBKEY_HANDLE hHandle, int nFileLen)
{
	return pDevcieBase->CreatePrivateKey(hHandle,nFileLen);
}

DLL_EXPORT_API DWORD WritePrivateKey(USBKEY_HANDLE hHandle, BYTE * pInData, int nDataLen)
{
	if (NULL == hHandle || NULL == pInData || nDataLen <= 0)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	DWORD dwRet = CreatePrivateKey(hHandle, nDataLen);
	if (DONGLE_FILE_EXIST == dwRet
		|| S4_FILE_EXIST == dwRet
		|| SAR_FILE_ALREADY_EXIST == dwRet)
	{
		dwRet = DeletePrivateKey(hHandle);
		if (USBKEY_SUCCESS != dwRet)
		{
			return dwRet;
		}

		dwRet = CreatePrivateKey(hHandle, nDataLen);
		if (USBKEY_SUCCESS != dwRet)
		{
			return dwRet;
		}

		return pDevcieBase->WritePrivateKey(hHandle, pInData, nDataLen);
	}
	else if (USBKEY_SUCCESS == dwRet)
	{
		return pDevcieBase->WritePrivateKey(hHandle, pInData, nDataLen);
	}	
	else
	{
		return dwRet;
	}
}

DLL_EXPORT_API DWORD DeletePrivateKey(USBKEY_HANDLE hHandle)
{
	return pDevcieBase->DeletePrivateKey(hHandle);
}

DLL_EXPORT_API DWORD WriteUserCertificate(USBKEY_HANDLE hHandle, BYTE* pInData, int nDataLen)
{
	if (NULL == hHandle || NULL == pInData || nDataLen <= 0)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->WriteDataFile(hHandle, USER_CERT_ID, 0, pInData, nDataLen, MAX_CERT_SIZE);
}

DLL_EXPORT_API DWORD ReadUserCertificate(USBKEY_HANDLE hHandle, BYTE* pOutData, int nDataLen)
{
	if (NULL == hHandle || NULL == pOutData || nDataLen <= 0)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->ReadDataFile(hHandle, USER_CERT_ID, 0, pOutData, nDataLen);
}

DLL_EXPORT_API DWORD GetUserCertificateLength(USBKEY_HANDLE hHandle, int* pFileLen)
{
	if (NULL == hHandle || NULL == pFileLen)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->GetFileLen(hHandle, USER_CERT_ID, (unsigned int*)pFileLen);
}

DLL_EXPORT_API DWORD DeleteUserCertificate(USBKEY_HANDLE hHandle)
{
	if (NULL == hHandle)
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->DeleteDataFile(hHandle, USER_CERT_ID);
}

DLL_EXPORT_API DWORD WriteRootCaCertificate(USBKEY_HANDLE hHandle, BYTE* pInData, int nDataLen)
{
	if (NULL == hHandle || NULL == pInData || nDataLen <= 0)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->WriteDataFile(hHandle, ROOT_CA_CERT_ID, 0, pInData, nDataLen, MAX_CERT_SIZE);
}

DLL_EXPORT_API DWORD ReadRootCaCertificate(USBKEY_HANDLE hHandle, BYTE* pOutData, int nDataLen)
{
	if (NULL == hHandle || NULL == pOutData || nDataLen <= 0)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->ReadDataFile(hHandle, ROOT_CA_CERT_ID, 0, pOutData, nDataLen);
}

DLL_EXPORT_API DWORD GetRootCaCertificateLength(USBKEY_HANDLE hHandle, int* pFileLen)
{
	if (NULL == hHandle || NULL == pFileLen)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->GetFileLen(hHandle, ROOT_CA_CERT_ID, (unsigned int*)pFileLen);
}

DLL_EXPORT_API DWORD DeleteRootCaCertificate(USBKEY_HANDLE hHandle)
{
	if (NULL == hHandle)
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->DeleteDataFile(hHandle, ROOT_CA_CERT_ID);
}

DLL_EXPORT_API DWORD WriteSubCaCertificate(USBKEY_HANDLE hHandle, BYTE * pInData, int nDataLen)
{
	if (NULL == hHandle || NULL == pInData || nDataLen <= 0)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->WriteDataFile(hHandle, SUB_CA_CERT_ID, 0, pInData, nDataLen, MAX_CERT_SIZE);
}

DLL_EXPORT_API DWORD ReadSubCaCertificate(USBKEY_HANDLE hHandle, BYTE* pOutData, int nDataLen)
{
	if (NULL == hHandle || NULL == pOutData || nDataLen <= 0)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->ReadDataFile(hHandle, SUB_CA_CERT_ID, 0, pOutData, nDataLen);
}

DLL_EXPORT_API DWORD GetSubCaCertificateLength(USBKEY_HANDLE hHandle, int* pFileLen)
{
	if (NULL == hHandle || NULL == pFileLen)
	{
		return USBKEY_INVALID_PARAMETER;
	}

	return pDevcieBase->GetFileLen(hHandle, SUB_CA_CERT_ID, (unsigned int*)pFileLen);
}

DLL_EXPORT_API DWORD DeleteSubCaCertificate(USBKEY_HANDLE hHandle)
{
	if (NULL == hHandle)
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->DeleteDataFile(hHandle, SUB_CA_CERT_ID);
}

DLL_EXPORT_API DWORD SetAuthorizedDevices(USBKEY_HANDLE hHandle, char* pDeviceIDList)
{
	if ((NULL == hHandle) || (NULL == pDeviceIDList))
	{
		return INPUT_NULL_ERR;
	}

	string strInDevices = pDeviceIDList;

	//删除旧的授权设备列表
	DWORD dwRet = pDevcieBase->DeleteDataFile(hHandle, DEVICE_ID_LIST);
	if (DONGLE_FILE_NOT_FOUND == dwRet
		|| S4_FILE_NOT_FOUND == dwRet
		|| SAR_FILE_NOT_EXIST == dwRet)
	{
		//不存在时，直接下一步
	}
	else if (USBKEY_SUCCESS != dwRet)
	{
		return dwRet;
	}

	//写入新授权设备列表
	dwRet = pDevcieBase->WriteDataFile(hHandle, DEVICE_ID_LIST, 0, (BYTE*)strInDevices.c_str(), strInDevices.length(), MAX_AUTHOR_SIZE);
	if (USBKEY_SUCCESS != dwRet)
	{
		return dwRet;
	}

	return USBKEY_SUCCESS;
}

DLL_EXPORT_API DWORD SetAuthorizedDevicesAppend(USBKEY_HANDLE hHandle, char* pDeviceIDList)
{
	return DONGLE_SUCCESS;
}

DLL_EXPORT_API DWORD GetAuthorizedDevices(USBKEY_HANDLE hHandle, char* pDeviceIDList)
{
	if ((NULL == hHandle) || (NULL == pDeviceIDList))
	{
		return INPUT_NULL_ERR;
	}

	unsigned int nFileLen = 0;
	DWORD dwRet = pDevcieBase->GetFileLen(hHandle, DEVICE_ID_LIST, &nFileLen);
	if (dwRet != USBKEY_SUCCESS)
	{
		return dwRet;
	}

	return pDevcieBase->ReadDataFile(hHandle, DEVICE_ID_LIST, 0, (BYTE*)pDeviceIDList, nFileLen);
}

int FindSubStrPos(const char* source, const char* target)
{    
	unsigned int i,j;      

	if (strlen(source) < strlen(target))
	{
		return -1;
	}

	for (i = 0;i<=strlen(source)-strlen(target);i++)    
	{        
		if (source[i]==target[0])        
		{            
			for (j = 1;j<=strlen(target);j++)            
			{
				if (source[i+j]!=target[j])                    
					break;            
			}

			if ((j == strlen(target))
				|| (j == strlen(target)+1))//结束符匹配到则加1
			{                
				return i;                       
			} 

			j = 0;        
		}    
	}    

	return -1;
}

//获取任务中包含字段的个数
int GetTaskSubCnt(const char* pTask)
{
	int nSubCnt = 0;

	string strTask = pTask;
	int nPos = strTask.find_first_of("@");
	string firstTask = strTask.substr(0, nPos+1);
	int nfirstSubEndPos = firstTask.find_first_of(",");
	while (-1 != nfirstSubEndPos)
	{
		nSubCnt++;
		firstTask = firstTask.substr(nfirstSubEndPos+1, firstTask.length()-nfirstSubEndPos-1);
		nfirstSubEndPos = firstTask.find_first_of(",");
	}

	return nSubCnt;
}
//DLL_EXPORT_API DWORD ReduceAuthorizedDevice(USBKEY_HANDLE hHandle, char * pDeviceIDList)
//{
//	if ((NULL == hHandle) || (NULL == pDeviceIDList))
//	{
//		return INPUT_NULL_ERR;
//	}
//
//	unsigned int nInLen = strlen(pDeviceIDList);
//	/*if (DEVICES_ID_LEN > nInLen)
//	{
//		return INPUT_DEVICES_LIST_LEN_ERR;
//	}*/
//
//	//读出锁内设备列表
//	char data[MAX_DATAFILE_SIZE] = {0};
//	DWORD dwRet = GetAuthorizedDevices(hHandle, data);
//	if (DONGLE_FILE_NOT_FOUND == dwRet
//		|| S4_FILE_NOT_FOUND == dwRet
//		|| SAR_FILE_NOT_EXIST == dwRet)
//	{
//		return USBKEY_SUCCESS;
//	}
//	else if (USBKEY_SUCCESS != dwRet)
//	{
//		return dwRet;
//	}
//
//	//根据输入的设备列表，更新锁内设备列表
//	//更新逻辑：输入的设备列表中每个设备准入记录（ID+起始时间+结束时间），如果锁内设备列表中有找到相同的设备准入记录，则删除锁内设备列表中的该设备准入记录。
//	string strOldDevices = (char*)data;	
//	string strInDevices = pDeviceIDList;
//	
//	int nLastPos = strOldDevices.find_last_of("@");
//	if (-1 == nLastPos)
//	{
//		return USBKEY_SUCCESS;
//	}
//
//	string strNewDevices = strOldDevices.substr(0, nLastPos+1);
//
//	while(nInLen > 0)
//	{
//		int nPos = strInDevices.find_first_of("@");
//		if (-1 == nPos)
//		{
//			break;
//		}
//
//		string strId = strInDevices.substr(0, nPos+1);
//		int nIdPos = FindSubStrPos(strNewDevices.c_str(), strId.c_str());
//		if (-1 != nIdPos)
//		{
//			string strContent = strNewDevices;
//			int nContentLen = strContent.length();
//
//			string beforeRec = strContent.substr(0,nIdPos);
//			string afterRec = strContent.substr(nIdPos + strId.length(), nContentLen -strId.length() - nIdPos);
//			strNewDevices = beforeRec;
//			strNewDevices += afterRec;
//		}
//
//		strInDevices = strInDevices.substr(nPos+1, nInLen - nPos -1);
//		nInLen -= strId.length();
//	}
//
//	dwRet = pDevcieBase->DeleteDataFile(hHandle, DEVICE_ID_LIST);
//	if (USBKEY_SUCCESS != dwRet)
//	{
//		return dwRet;
//	}
//
//	if (ROCEYARM_TIME_FEITAIN ==g_DeviceType)
//	{
//		if (0 == strNewDevices.length())
//		{
//			//如果全部授权设备记录被删除，则直接返回，不重新写入
//			return USBKEY_SUCCESS;
//		}
//	}
//	
//	dwRet = SetAuthorizedDevices(hHandle, (char*)strNewDevices.c_str());
//	if (USBKEY_SUCCESS != dwRet)
//	{
//		return dwRet;
//	}
//
//	return USBKEY_SUCCESS;
//}

DLL_EXPORT_API DWORD ReduceAuthorizedDevice(USBKEY_HANDLE hHandle, char * pDeviceIDList)
{
	if ((NULL == hHandle) || (NULL == pDeviceIDList))
	{
		return INPUT_NULL_ERR;
	}

	unsigned int nInLen = strlen(pDeviceIDList);
	/*if (DEVICES_ID_LEN > nInLen)
	{
		return INPUT_DEVICES_LIST_LEN_ERR;
	}*/

	//读出锁内设备列表
	char data[MAX_DATAFILE_SIZE] = {0};
	DWORD dwRet = GetAuthorizedDevices(hHandle, data);
	if (DONGLE_FILE_NOT_FOUND == dwRet
		|| S4_FILE_NOT_FOUND == dwRet
		|| SAR_FILE_NOT_EXIST == dwRet)
	{
		return USBKEY_SUCCESS;
	}
	else if (USBKEY_SUCCESS != dwRet)
	{
		return dwRet;
	}

	//根据输入的设备列表，更新锁内设备列表
	//更新逻辑：输入的设备列表中每个设备准入记录（ID+起始时间+结束时间），如果锁内设备列表中有找到相同的设备准入记录，则删除锁内设备列表中的该设备准入记录。
	string strOldDevices = (char*)data;	
	string strInDevices = pDeviceIDList;
	
	int nLastPos = strOldDevices.find_last_of("@");
	if (-1 == nLastPos)
	{
		return USBKEY_SUCCESS;
	}

	string strNewDevices = strOldDevices.substr(0, nLastPos+1);

	//判断电子钥匙中的任务和输入参数中的任务是否带任务ID，3个字段标识包含任务ID
	int nSubCntInKey = GetTaskSubCnt(strNewDevices.c_str());
	int nSubCntInput = GetTaskSubCnt(strInDevices.c_str());

	while(nInLen > 0)
	{
		int nPos = strInDevices.find_first_of("@");
		if (-1 == nPos)
		{
			break;
		}

		//兼容带任务ID和不带任务ID两种情况
		string strId;
		int nfirstSubEndPos = 0;
		switch (nSubCntInput)
		{
		case 3://任务包含TaskID
			if (2 == nSubCntInKey)
			{
				strId = strInDevices.substr(0, nPos+1);
				nfirstSubEndPos = strId.find_first_of(",");
				strId = strId.substr(nfirstSubEndPos+1, strId.length()-nfirstSubEndPos-1);
			}
			else
			{
				strId = strInDevices.substr(0, nPos+1);
			}
			break;

		case 2://任务不包含TaskID
			strId = strInDevices.substr(0, nPos+1);
			break;

		default://异常
			break;
		}

		int nIdPos = FindSubStrPos(strNewDevices.c_str(), strId.c_str());
		if (-1 != nIdPos)
		{
			string strContent = strNewDevices;
			int nContentLen = strContent.length();

			string beforeRec = strContent.substr(0,nIdPos);
			string afterRec = strContent.substr(nIdPos + strId.length(), nContentLen -strId.length() - nIdPos);
			strNewDevices = beforeRec;
			strNewDevices += afterRec;
		}

		strInDevices = strInDevices.substr(nPos+1, nInLen - nPos -1);
		nInLen -= strId.length();
	}

	dwRet = pDevcieBase->DeleteDataFile(hHandle, DEVICE_ID_LIST);
	if (USBKEY_SUCCESS != dwRet)
	{
		return dwRet;
	}

	if (ROCEYARM_TIME_FEITAIN ==g_DeviceType)
	{
		if (0 == strNewDevices.length())
		{
			//如果全部授权设备记录被删除，则直接返回，不重新写入
			return USBKEY_SUCCESS;
		}
	}
	
	dwRet = SetAuthorizedDevices(hHandle, (char*)strNewDevices.c_str());
	if (USBKEY_SUCCESS != dwRet)
	{
		return dwRet;
	}

	return USBKEY_SUCCESS;
}

DLL_EXPORT_API DWORD WriteLogFile(USBKEY_HANDLE hHandle, BYTE* pInData, int nDataLen)
{
	if ((NULL == hHandle) || (NULL == pInData))
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->WriteLogFile(hHandle, pInData, nDataLen);
}

DLL_EXPORT_API DWORD ReadLogFile(USBKEY_HANDLE hHandle, BYTE* pOutData, int nDataLen)
{
	if ((NULL == hHandle) || (NULL == pOutData))
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->ReadLogFile(hHandle, pOutData, nDataLen);
}

DLL_EXPORT_API DWORD UpdateLogRecord(USBKEY_HANDLE hHandle, BYTE * pNewRecord, int nNewRecordLen)
{
	string strNewRecord = (char*)pNewRecord;
	int nRecLen = strNewRecord.length();
	int nPos = strNewRecord.find_first_of("@");
	string strNew = strNewRecord.substr(nPos + 1, nRecLen - nPos - 1);
	nPos = strNew.find_first_of("@");
	string strWarningID = strNew.substr(0,nPos);

	int nLogFileLen = 0;
	DWORD dwRet = GetLogFileLength(hHandle, &nLogFileLen);
	if (DONGLE_FILE_NOT_FOUND == dwRet
		|| S4_FILE_NOT_FOUND == dwRet
		|| SAR_FILE_NOT_EXIST == dwRet)
	{	
		//没有找到日志文件，这创建日志文件，并写入当前记录
		return WriteLogFile(hHandle, pNewRecord, nNewRecordLen);		
	}
	else if (USBKEY_SUCCESS != dwRet)
	{
		return dwRet;
	}

	BYTE* logContent = new BYTE[nLogFileLen+1];
	memset(logContent, 0, nLogFileLen+1);
	dwRet = ReadLogFile(hHandle, logContent, nLogFileLen);
	if (USBKEY_SUCCESS != dwRet)
	{
		return dwRet;
	}

	//查找WarningID匹配的记录
	string strLogContent = (char*)logContent;
	nPos = strLogContent.find_first_of(strWarningID);
	if (nPos < 0)
	{
		//没有找到匹配记录，则当新记录写入
		dwRet = WriteLogFile(hHandle, pNewRecord, nNewRecordLen);
		if (USBKEY_SUCCESS != dwRet)
		{
			return  dwRet;
		}

		return USBKEY_SUCCESS;
	}

	string str = strLogContent;
	int len = str.length();

	//替换匹配记录
	while (len > 0)
	{
		int newLen = str.length();
		if (newLen <= 0)
		{
			break;
		}

		nPos = str.find_first_of(";");
		if (nPos < 0)
		{
			break;
		}			

		string strRecord = str.substr(0, nPos+1);
		int nRecordLen = strRecord.length();
		int nTerminalNoPos = strRecord.find_first_of("@");			
		string strNewRec = strRecord.substr(nTerminalNoPos+1, nRecordLen - nTerminalNoPos -1);

		int nWariningIdPos = strNewRec.find_first_of("@");
		string WarningId = strNewRec.substr(0, nWariningIdPos);

		if (0 == strcmp(WarningId.c_str(), strWarningID.c_str()))
		{
			string strContent = strLogContent;
			int logContentLen = strContent.length();

			int recPos = FindSubStrPos(strContent.c_str(),strRecord.c_str());

			string beforeRec = strContent.substr(0,recPos);
			string afterRec = strContent.substr(recPos + nRecordLen, logContentLen - nRecordLen - recPos);
			string newLogContent = beforeRec;
			newLogContent += strNewRecord;
			newLogContent += afterRec;

			dwRet = DeleteLogFile(hHandle);
			if (USBKEY_SUCCESS != dwRet)
			{
				return  dwRet;
			}		

			dwRet = WriteLogFile(hHandle, (BYTE*)newLogContent.c_str(), newLogContent.length());
			if (USBKEY_SUCCESS != dwRet)
			{
				return  dwRet;
			}

			break;
		}

		str = str.substr(nPos+1, newLen - nPos -1);
		len = len - nPos - 1;		
	}

	return USBKEY_SUCCESS;
}

DLL_EXPORT_API DWORD DeleteLogFile(USBKEY_HANDLE hHandle)
{
	if (NULL == hHandle)
	{
		return INPUT_NULL_ERR;
	}

	DWORD  dwRet = pDevcieBase->DeleteLogFile(hHandle);
	if (USBKEY_SUCCESS != dwRet)
	{
		printf("DeleteLogFile  failed! <error code = 0x%08x>\n", dwRet);
		return dwRet;
	}

	//S4只能通过删除文件目录实现文件删除，但删除目录会把同目录下的Exe文件删除，故清空目录后必须重新下载该目录下的Exe文件
	if (S4_TIME_SENSI == g_DeviceType)
	{
		//重新下载exe
		FILE* fp = NULL;
		int nFileLen = 0;
		BYTE* pReadDataBuf = NULL;

		errno_t tErrno = fopen_s(&fp, READ_LOG_EXE_PATH, "rb");
		if(NULL == fp)
		{
			printf("fopen_s C:\\RVC\\UKey\\S4_readLogFile.bin  failed! <error code = 0x%08x>\n", tErrno);
			return OPEN_EXE_FILE_ERR;
		}

		fseek(fp, 0, SEEK_END);
		nFileLen = ftell(fp);
		pReadDataBuf = new BYTE[nFileLen];
		if (NULL == pReadDataBuf)
		{
			return NEW_MEM_ERR;
		}
		memset(pReadDataBuf, 0, nFileLen);
		fseek(fp, 0, SEEK_SET);
		fread(pReadDataBuf,1,nFileLen,fp);
		fclose(fp);

		dwRet = pDevcieBase->WriteExeFile(hHandle, READ_LOG_FILE_EXE_ID, pReadDataBuf, nFileLen, nFileLen);
		if (S4_SUCCESS != dwRet)
		{
			delete pReadDataBuf;
			pReadDataBuf = NULL;
			printf("WriteExeFile 0014  failed! <error code = 0x%08x>\n", dwRet);
			return dwRet;
		}

		delete pReadDataBuf;
		pReadDataBuf = NULL;
	}

	return USBKEY_SUCCESS;
}

DLL_EXPORT_API DWORD GetLogFileLength(USBKEY_HANDLE hHandle, int* pFileLen)
{
	if ((NULL == hHandle) || (NULL == pFileLen))
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->GetLogFileLength(hHandle, pFileLen);
}

DLL_EXPORT_API DWORD DownLoadExeFile(USBKEY_HANDLE hHandle, const char* pFolderPath)
{
	if ((NULL == hHandle) || (NULL == pFolderPath))
	{
		return INPUT_NULL_ERR;
	}

	FILE* fp = NULL;
	int nFileLen = 0;
	BYTE* pReadDataBuf = NULL;

	//写数据文件Exe
	string strReadDataFilePath(pFolderPath);
	string strWriteDataFilePath(pFolderPath);
	string strWriteTDESKeytPath(pFolderPath);
	string strReadLogFilePath(pFolderPath);
	
	switch (g_DeviceType)
	{
	case ROCEYARM_TIME_FEITAIN:
		strReadDataFilePath += ROCARM_READ_DATAFILE_EXE;
		strWriteDataFilePath += ROCARM_WRITE_DATAFILE_EXE;
		strWriteTDESKeytPath += ROCARM_WRITE_TDESKEY_EXE;
		//return USBKEY_SUCCESS;
		break;

	case S4_TIME_SENSI:
		strReadDataFilePath += S4_READ_DATAFILE_EXE;
		strReadLogFilePath += S4_READ_LOGFILE_EXE;
		break;

	case GM3000_LONGMAI:
		return USBKEY_SUCCESS;
		break;

	default:
		return USB_KEY_TYPE_ERR;
		break;
	}

	errno_t tErrno = fopen_s(&fp, strReadDataFilePath.c_str(), "rb");
	if(NULL == fp)
	{
		return OPEN_EXE_FILE_ERR;
	}
	fseek(fp, 0, SEEK_END);
	nFileLen = ftell(fp);
	pReadDataBuf = new BYTE[nFileLen];
	if (NULL == pReadDataBuf)
	{
		return NEW_MEM_ERR;
	}
	memset(pReadDataBuf, 0, nFileLen);
	fseek(fp, 0, SEEK_SET);
	fread(pReadDataBuf,1,nFileLen,fp);
	fclose(fp);

	DWORD dwRet = pDevcieBase->WriteExeFile(hHandle, READ_DATA_FILE_EXE_ID, pReadDataBuf, nFileLen, nFileLen);
	if (USBKEY_SUCCESS != dwRet)
	{
		delete pReadDataBuf;
		pReadDataBuf = NULL;
		return dwRet;
	}

	delete pReadDataBuf;
	pReadDataBuf = NULL;

	//S4还需要下载读Log文件可执行程序
	if (S4_TIME_SENSI == g_DeviceType)
	{
		errno_t tErrno = fopen_s(&fp, strReadLogFilePath.c_str(), "rb");
		if(NULL == fp)
		{
			return OPEN_EXE_FILE_ERR;
		}

		fseek(fp, 0, SEEK_END);
		nFileLen = ftell(fp);
		pReadDataBuf = new BYTE[nFileLen];
		if (NULL == pReadDataBuf)
		{
			return NEW_MEM_ERR;
		}
		memset(pReadDataBuf, 0, nFileLen);
		fseek(fp, 0, SEEK_SET);
		fread(pReadDataBuf,1,nFileLen,fp);
		fclose(fp);

		DWORD dwRet = pDevcieBase->WriteExeFile(hHandle, READ_LOG_FILE_EXE_ID, pReadDataBuf, nFileLen, nFileLen);
		if (USBKEY_SUCCESS != dwRet)
		{
			delete pReadDataBuf;
			pReadDataBuf = NULL;
			return dwRet;
		}

		delete pReadDataBuf;
		pReadDataBuf = NULL;
	}
	
	return USBKEY_SUCCESS;
}

DLL_EXPORT_API DWORD DeleteAllFile(USBKEY_HANDLE hHandle)
{
	if (NULL == hHandle)
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->DeleteAllFile(hHandle);
}

void itoh(UINT64 n,char *s)
{
	char base[16] = {'0','1','2','3',
		'4','5','6','7',
		'8','9','A','B',
		'C','D','E','F'};
	UINT64 a = n;
	int i = 0;
	while(a != 0)
	{
		i++;
		s[16-i] = base[a%16];
		a/=16;
	}

	if (0 == a && 16 != i)
	{
		while (i<16)
		{
			i++;
			s[16-i] = '0';
		}
	}
}

DLL_EXPORT_API DWORD EncPin(BYTE * pPin, BYTE * pEncPin)
{
	//与HID做异或
	if ((NULL == pPin) ||
		(NULL == pEncPin))
	{
		return INPUT_NULL_ERR;
	}

	//获取锁的PID，并转换成16进制数
	/*USBKEY_INFO UkeyInfo;
	DWORD dwRet = 0;
	unsigned int count = 0;
	dwRet = FindUsbKey(&UkeyInfo, &count);
	if (DONGLE_SUCCESS != dwRet)
	{
	return dwRet;
	}*/

	//UINT64 lPID = 0x0806220716210A13;
	UINT64 lPID = 0;
	int nAscall = 0;
	string strPID = "";
	char cAscall[3] = {0};
	for (int i = 0; i < 8; i++)
	{
		nAscall = g_KeyInfo.m_HID[i];

		memset(cAscall, 0, 3);
		_itoa_s(nAscall, cAscall, 16);
		if (1 == strlen(cAscall))
		{
			string zero = "0";
			zero += cAscall;

			strPID += zero;
		}
		else
		{
			strPID += cAscall;
		}

	}

	//字符转64位16进制数
	sscanf_s(strPID.c_str() , "%I64x" , &lPID);

	char cPin[17] = {0};
	memcpy(cPin, pPin, 8);

	UINT64 nPinLen = strlen((const char*)pPin);
	if (PIN_LEN != nPinLen)
	{
		//PIN长度必须为8
		return DONGLE_INCORRECT_PIN;
	}

	//拼接8个F，组成实际PIN码
	memcpy(cPin+8, "FFFFFFFF", 8);

	//转16进制整数
	UINT64 lPin = 0;
	sscanf_s(cPin , "%I64x" , &lPin);
	UINT64 lEncPin = lPin ^ lPID;

	itoh(lEncPin, (char*)pEncPin);

	return DONGLE_SUCCESS;
}

DLL_EXPORT_API DWORD DecPin(BYTE * pEncPin, BYTE * pPin)
{
	//与HID做异或
	if ((NULL == pPin) ||
		(NULL == pEncPin))
	{
		return INPUT_NULL_ERR;
	}

	string strPIN = (char*)pEncPin;

	UINT64 nPinLen = strlen((const char*)pEncPin);
	if (16 != nPinLen)
	{
		//加密后的PIN长度必须为16
		return DONGLE_INCORRECT_PIN;
	}

	//获取锁的PID，并转换成16进制数
	/*USBKEY_INFO UkeyInfo;
	DWORD dwRet = 0;
	unsigned  int count = 0;
	dwRet = FindUsbKey(&UkeyInfo, &count);
	if (DONGLE_SUCCESS != dwRet)
	{
		return dwRet;
	}*/

	//UINT64 lPID = 0x0806220716210A13;
	UINT64 lPID = 0;
	int nAscall = 0;
	string strPID = "";
	char cAscall[3] = {0};
	for (int i = 0; i < 8; i++)
	{
		nAscall = g_KeyInfo.m_HID[i];

		memset(cAscall, 0, 3);
		_itoa_s(nAscall, cAscall, 16);
		if (1 == strlen(cAscall))
		{
			string zero = "0";
			zero += cAscall;

			strPID += zero;
		}
		else
		{
			strPID += cAscall;
		}

	}

	sscanf_s(strPID.c_str() , "%I64x" , &lPID);

	//转16进制整数
	UINT64 lEncPin = 0;
	sscanf_s((const char*)pEncPin , "%I64x" , &lEncPin );

	UINT64 lPin = lEncPin ^ lPID;

	BYTE pDecPin[17] = {0};
	itoh(lPin, (char*)pDecPin);

	memcpy(pPin, pDecPin, 8);
	return DONGLE_SUCCESS;
}

DLL_EXPORT_API DWORD GenSignedInfo(USBKEY_HANDLE hHandle, const char* pcInData, char* pcOutData)
{
	if (NULL == hHandle || NULL == pcInData)
	{
		return INPUT_NULL_ERR;
	}

	DWORD dwRet = 0;	
	int  nInDataLen = 0;
	int  nOutDataLen = 0;
	BYTE inBuf[128] = {0};
	BYTE outBuf[128] = {0};


	nInDataLen = strlen(pcInData);
	if (nInDataLen > 117)
	{
		//加密数据长度不能大于私钥长度/8 - 11
		return -1;
	}

	memcpy(inBuf, pcInData, nInDataLen);

	//RSA私钥加密
	nOutDataLen = 128;
	dwRet = Dongle_RsaPri(hHandle, PRIVATE_KEY_ID, FLAG_ENCODE, inBuf, nInDataLen, outBuf, &nOutDataLen);
	if (DONGLE_SUCCESS != dwRet)
	{
		return dwRet;
		printf("RSA private key encode. Return: 0x%08X\n", dwRet);
	}

	memcpy(pcOutData, outBuf, nOutDataLen);

	return DONGLE_SUCCESS;
}

DLL_EXPORT_API DWORD ProtocolSwitch(USBKEY_HANDLE hHandle, int nFlag)
{
	if (NULL == hHandle)
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->ProtocolSwitch(hHandle, nFlag);
}

DLL_EXPORT_API DWORD GetHIDFromUKey(char *strHID)
{
	if (NULL == strHID)
	{
		return INPUT_NULL_ERR;
	}

	return pDevcieBase->GetHIDFromUKey(strHID);
}