myvtm/Other/USBKeyAPI/S4Time.cpp

#include "S4Time.h"
#include "logfile.h"
#pragma comment(lib, "Sense4ST.lib")
SENSE4_CONTEXT g_s4Ctx;
string m_strRootPIN;

static CLogFile* g_log = new CLogFile("C:\\RVC\\Ukey\\UsbKeyApiLog.log");

S4Time::S4Time(void)
{
	//memset(&g_s4Ctx, 0, sizeof(SENSE4_CONTEXT));
	//m_strRootPIN = "";	
}

S4Time::~S4Time(void)
{
}

DWORD S4Time::FindUsbKey(USBKEY_INFO* pKeyInfo, unsigned int* pCount)
{
	SENSE4_CONTEXT * s4CtxList =NULL ;
	DWORD			dwSize=0;

	//枚举系统连接了多少个设备,这一步不用判断返回值，第一个参数输入NULL
	DWORD dwRet = S4Enum(NULL,&dwSize);
	if (S4_SUCCESS != dwRet && S4_INSUFFICIENT_BUFFER != dwRet)
	{
		g_log->LOGERROR("S4Enum failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//如果得到的设备上下文内存数量为0或者不为sizeof(SENSE4_CONTEXT)的倍数，
	//说明没有找到设备或者列举设备出错。
	if ((0 == dwSize) || (dwSize % sizeof(SENSE4_CONTEXT))) 
	{
		g_log->LOGERROR("S4Enum no device! <dwSize = 0x%x>", dwSize);
		return S4_NO_LIST;
	}

	*pCount = dwSize / sizeof(SENSE4_CONTEXT);

	//根据返回的设备个数，分配空间给程序使用
	s4CtxList = (SENSE4_CONTEXT *)malloc(dwSize);

	//根据分配的空间，再次枚举设备，这次要判断函数返回值
	dwRet = S4Enum(s4CtxList,&dwSize);
	if(S4_SUCCESS == dwRet)
	{
		//g_s4Ctx.hLock = s4CtxList[0].hLock;
		g_s4Ctx.dwIndex = s4CtxList[0].dwIndex;
		g_s4Ctx.dwVersion = s4CtxList[0].dwVersion;
		g_s4Ctx.dwAtrLen = s4CtxList[0].dwAtrLen;
		memcpy(g_s4Ctx.bID, s4CtxList[0].bID, MAX_ID_LEN);
		memcpy(g_s4Ctx.bAtr, s4CtxList[0].bAtr, MAX_ATR_LEN);
		memcpy(g_s4Ctx.reserve, s4CtxList[0].reserve, RESERVE_NUM);
	}
	else
	{
		free(s4CtxList);
		s4CtxList = NULL;
		printf("Enum device failed.\n"); 
		g_log->LOGERROR("S4Enum failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	free(s4CtxList);
	s4CtxList = NULL;

	S4OPENINFO S4_OpenInfo;
	S4_OpenInfo.dwS4OpenInfoSize = sizeof(S4OPENINFO);
	S4_OpenInfo.dwShareMode = S4_EXCLUSIZE_MODE;

	dwRet = S4OpenEx(&g_s4Ctx, &S4_OpenInfo);
	if (S4_SUCCESS != dwRet)
	{		
		if (S4_DEVICE_BUSY == dwRet)
		{
			printf("device is busy, start to close, and then open.\n");
			g_log->LOGERROR("device is busy, start to close, and then open! <error code = 0x%x>", dwRet);
			dwRet = S4Close(&g_s4Ctx);
			if(S4_SUCCESS != dwRet)
			{
				free(s4CtxList);
				s4CtxList = NULL;
				printf("S4Close failure.\n");
				g_log->LOGERROR("S4Close  failed! <error code = 0x%x>", dwRet);
				return dwRet;
			}

			dwRet = S4OpenEx(&g_s4Ctx, &S4_OpenInfo);
			if(S4_SUCCESS != dwRet)
			{
				free(s4CtxList);
				s4CtxList = NULL;
				printf("S4OpenEx failure.\n");
				g_log->LOGERROR("S4OpenEx  failed! <error code = 0x%x>", dwRet);
				return dwRet;
			}

			g_log->LOGERROR("S4OpenEx  success");
		} 
		else
		{
			free(s4CtxList);
			s4CtxList = NULL;
			printf("S4OpenEx failure.\n");
			g_log->LOGERROR("S4OpenEx failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}		
	}		

	//获取设备序列号
	DWORD len = 0;
	char cSerialNumber[8] = {0};
	dwRet = S4Control(&g_s4Ctx, S4_GET_SERIAL_NUMBER, NULL, 0, (void*)cSerialNumber, 8, &len);
	if (S4_SUCCESS != dwRet)
	{
		printf("Get Serial number failed!<error code = %08x>\n", dwRet);
		g_log->LOGERROR("Get Serial number  failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}
	memcpy(pKeyInfo->m_HID, cSerialNumber, MAX_ID_LEN);
	memcpy(g_s4Ctx.bID, cSerialNumber, MAX_ID_LEN);

	/*dwRet = S4Close(&g_s4Ctx);
	if(S4_SUCCESS != dwRet)
	{
	printf("S4Close failure.\n");
	g_log->LOGERROR("S4Close  failed! <error code = 0x%x>", dwRet);
	return dwRet;
	}*/

	free(s4CtxList);
	s4CtxList = NULL;

	g_log->LOGERROR("Find S4 Time");

	return S4_SUCCESS;
}

DWORD S4Time::OpenUsbKey(USBKEY_HANDLE *pHandle,unsigned int Item)
{
	SENSE4_CONTEXT * s4CtxList =NULL ;
	DWORD			dwSize=0;
	DWORD			dwRet = S4_SUCCESS;

	if (((void*)(-1) != g_s4Ctx.hLock)
		&& (NULL != g_s4Ctx.hLock))
	{
		g_log->LOGERROR("S4 Time is openning");
	}
	else
	{
		g_log->LOGERROR("Open S4 Time");
		//枚举系统连接了多少个设备,这一步不用判断返回值，第一个参数输入NULL
		dwRet = S4Enum(NULL,&dwSize);
		if (S4_SUCCESS != dwRet && S4_INSUFFICIENT_BUFFER != dwRet)
		{
			return dwRet;
		}

		//如果得到的设备上下文内存数量为0或者不为sizeof(SENSE4_CONTEXT)的倍数，
		//说明没有找到设备或者列举设备出错。
		if ((0 == dwSize) || (dwSize % sizeof(SENSE4_CONTEXT))) 
		{
			return S4_NO_LIST;
		}

		//根据返回的设备个数，分配空间给程序使用
		s4CtxList = (SENSE4_CONTEXT *)malloc(dwSize);

		//根据分配的空间，再次枚举设备，这次要判断函数返回值
		dwRet = S4Enum(s4CtxList,&dwSize);
		if(S4_SUCCESS == dwRet)
		{
			g_s4Ctx.hLock = s4CtxList[0].hLock;
			g_s4Ctx.dwIndex = s4CtxList[0].dwIndex;
			g_s4Ctx.dwVersion = s4CtxList[0].dwVersion;
			g_s4Ctx.dwAtrLen = s4CtxList[0].dwAtrLen;
			memcpy(g_s4Ctx.bID, s4CtxList[0].bID, MAX_ID_LEN);
			memcpy(g_s4Ctx.bAtr, s4CtxList[0].bAtr, MAX_ATR_LEN);
			memcpy(g_s4Ctx.reserve, s4CtxList[0].reserve, RESERVE_NUM);
		}
		else
		{
			printf("Enum device failed.\n"); 
			g_log->LOGERROR("S4Enum failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}

		free(s4CtxList);
		s4CtxList = NULL;

		S4OPENINFO S4_OpenInfo;
		S4_OpenInfo.dwS4OpenInfoSize = sizeof(S4OPENINFO);
		S4_OpenInfo.dwShareMode = S4_EXCLUSIZE_MODE;

		dwRet = S4OpenEx(&g_s4Ctx, &S4_OpenInfo);
		if(S4_SUCCESS != dwRet)
		{
			printf("S4OpenEx failure.\n");
			g_log->LOGERROR("S4OpenEx  failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}		
	}

	*pHandle = g_s4Ctx.hLock;

	/*检查精锐IV 设备中是否存在根目录*/
	dwRet = S4ChangeDir(&g_s4Ctx, "\\");	
	if (S4_DEVICE_UNSUPPORTED == dwRet)
	{
		/*如果根目录不存在，创建新的根目录*/
		dwRet = S4CreateDir(&g_s4Ctx, "\\", 0, S4_CREATE_ROOT_DIR);
		if (dwRet != S4_SUCCESS)
		{
			printf("Create new root failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("Create new root  failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}
	}
	else if (dwRet != S4_SUCCESS)
	{
		printf("Change to root dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to root dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	return S4_SUCCESS;
}

DWORD S4Time::CloseUsbKey(USBKEY_HANDLE hHandle)
{
	g_log->LOGERROR("Close S4 Time");

	DWORD dwRet = S4_SUCCESS;

	if (((void*)(-1) != g_s4Ctx.hLock)
		&& (NULL != g_s4Ctx.hLock))
	{
		dwRet = S4Close(&g_s4Ctx);
		if(S4_SUCCESS != dwRet)
		{
			g_s4Ctx.hLock = NULL;
			printf("S4Close failure.\n");
			g_log->LOGERROR("S4Close failed! <error code = 0x%x>", dwRet);			
			return dwRet;
		}

		g_s4Ctx.hLock = NULL;
	}	

	return S4_SUCCESS;
}

DWORD S4Time::VerifyUserPIN(USBKEY_HANDLE hHandle, char* pPIN)
{
	//验证用户PIN码，默认值"123456789"，不修改
	DWORD dwRet = S4VerifyPin(&g_s4Ctx, (BYTE*)pPIN, 8, S4_USER_PIN);
	if (S4_SUCCESS != dwRet)
	{
		printf("Verify user PIN failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Verify user PIN failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	return S4_SUCCESS;
}

DWORD S4Time::VerifyAdminPIN(USBKEY_HANDLE hHandle, char* pPIN)
{
	char cNewDevPin[25] = {0};
	
	memcpy(cNewDevPin, pPIN, 8);
	memcpy(cNewDevPin+8, "1234567812345678", 16);	
	
	if (g_s4Ctx.hLock == NULL)
	{
		g_log->LOGERROR("g_s4Ctx.hLock is null");
	}

	DWORD dwRet = S4VerifyPin(&g_s4Ctx, (BYTE*)cNewDevPin, 24, S4_DEV_PIN);
	if (S4_SUCCESS != dwRet)
	{
		printf("verify dir admin PIN failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("verify dir admin PIN failed!<cNewDevPin = %s>, <error code = 0x%x>", cNewDevPin, dwRet);
		return dwRet;
	}

	g_log->LOGERROR("verify dir admin PIN success! <cNewDevPin = %s>", cNewDevPin);

	//保存根目录PIN码
	memcpy((void*)m_strRootPIN.c_str(), pPIN, 8);

	return S4_SUCCESS;
}

DWORD S4Time::VerifyLogDirAdminPIN(USBKEY_HANDLE hHandle, char* pPIN)
{
	char cNewDevPin[25] = {0};

	memcpy(cNewDevPin, pPIN, 8);
	memcpy(cNewDevPin+8, "1234567812345678", 16);

	g_log->LOGERROR("verify log dir admin PIN! <cNewDevPin = %s>", cNewDevPin);
	DWORD dwRet = S4VerifyPin(&g_s4Ctx, (BYTE*)cNewDevPin, 24, S4_DEV_PIN);
	if (S4_SUCCESS != dwRet)
	{
		printf("verify log dir admin PIN failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("verify log dir admin PIN failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	return S4_SUCCESS;
}

DWORD S4Time::ChangeAdminPIN(USBKEY_HANDLE hHandle,char* pOldPin, char* pNewPin)
{
	char cOldDevPin[25] = {0};
	char cNewDevPin[25] = {0};
	
	memcpy(cOldDevPin, pOldPin, 8);
	memcpy(cNewDevPin, pNewPin, 8);

	memcpy(cOldDevPin+8, "1234567812345678", 16);
	memcpy(cNewDevPin+8, "1234567812345678", 16);
	
	DWORD dwRet = S4ChangePin(&g_s4Ctx, (BYTE*)cOldDevPin, 24, (BYTE*)cNewDevPin, 24, S4_DEV_PIN);
	if (S4_SUCCESS != dwRet)
	{
		printf("change dir admin PIN failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("change dir admin PIN failed!  <cOldDevPin = %s>, <cNewDevPin = %s>,<error code = 0x%x>", cOldDevPin, cNewDevPin, dwRet);
		return dwRet;
	}

	g_log->LOGERROR("change dir admin PIN success! <cOldDevPin = %s>, <cNewDevPin = %s>", cOldDevPin, cNewDevPin);

	//保存根目录PIN码
	memcpy((void*)m_strRootPIN.c_str(), pNewPin, 8);

	return  S4_SUCCESS;
}

DWORD S4Time::GenUniqueKey(USBKEY_HANDLE hHandle,char* pAdminPin, char* pUserPin)
{
	return S4_SUCCESS;
}

DWORD S4Time::CreateDataFile(USBKEY_HANDLE hHandle, unsigned int nFileLength, unsigned int nFileID)
{
	return S4_SUCCESS;
}

DWORD S4Time::WriteDataFile(USBKEY_HANDLE hHandle, unsigned int nFileID, unsigned int wOffset, BYTE * pInData, unsigned int nDataLen, unsigned int nFileSize)
{
	g_log->LOGERROR("WriteDataFile, <nFileID = %d>", nFileID);

	DWORD dwRet = 0;
	DWORD dwBytesWritten = 0;
	string strInputID;
	string strFileID;
	string strFileLen;

	//写文件前，需先验证开发商PIN码
	dwRet = VerifyAdminPIN(hHandle, (char*)m_strRootPIN.c_str());
	if (S4_SUCCESS != dwRet)
	{
		return dwRet;
	}

	//取4位字节文件ID，比如0x0021中的0021
	_itoa_s(nFileID, (char*)strInputID.c_str(), 4,16);	
	int nIdLen = strlen(strInputID.c_str());	
	if (4 > nIdLen)
	{
		//补齐4位数文件ID
		for (int i=0;i<4-nIdLen;i++)
		{
			strFileID += "0";
		}
	}
	strFileID += strInputID.c_str();
	
	//加上4字节的文件头，用于表示文件长度
	_itoa_s(nDataLen, (char*)strFileLen.c_str(), 5, 10);
	int nLen = strlen(strFileLen.c_str());	
	if (4 > strlen(strFileLen.c_str()))
	{
		string strTemp;
		//补齐4字节
		for (int i=0;i<4-nLen;i++)
		{
			strTemp += "0";
		}
		strTemp += strFileLen.c_str();
		strFileLen = strTemp;
	}

	char* pFileData = new char[nDataLen+4];
	memset(pFileData, 0, nDataLen+4);
	memcpy(pFileData, strFileLen.c_str(), 4);
	memcpy(pFileData+4, pInData, nDataLen);

	//创建文件
	dwRet = S4WriteFile(
		&g_s4Ctx,
		strFileID.c_str(),
		wOffset, 
		pFileData,
		nDataLen+FILE_HEAD_LEN, /* Number of bytes to write. */
		nFileSize, /* New file size*/
		&dwBytesWritten,
		S4_CREATE_NEW, 
		S4_DATA_FILE);
	if (S4_FILE_EXIST == dwRet)
	{
		//文件已经存在，则覆盖写
		dwRet = S4WriteFile(
			&g_s4Ctx,
			strFileID.c_str(),
			wOffset, 
			pFileData,
			nDataLen+FILE_HEAD_LEN, /* Number of bytes to write. */
			0, /* New file size*/
			&dwBytesWritten,
			S4_UPDATE_FILE, 
			S4_DATA_FILE);
		if (S4_SUCCESS != dwRet)
		{
			/* Handle error here… */
			g_log->LOGERROR("write <fileID=%s> file failed! <error code = 0x%x>", strFileID.c_str(), dwRet);
			printf("write <%s> file failed! <error code = 0x%08x>\n", strFileID.c_str(), dwRet);
			if (NULL != pFileData)
			{
				delete pFileData;
				pFileData = NULL;
			}			
			return dwRet;
		}
	}
	else if (dwRet != S4_SUCCESS)
	{
		/* Handle error here… */
		g_log->LOGERROR("write <fileID=%s> file failed! <error code = 0x%x>", strFileID.c_str(), dwRet);
		printf("write <%s> file failed! <error code = 0x%08x>\n", strFileID.c_str(), dwRet);
		if (NULL != pFileData)
		{
			delete pFileData;
			pFileData = NULL;
		}	
		return dwRet;
	}

	if (NULL != pFileData)
	{
		delete pFileData;
		pFileData = NULL;
	}	

	//实际写入的数据长度和文件长度不一致，返回错误
	if (nDataLen+FILE_HEAD_LEN != dwBytesWritten)
	{
		g_log->LOGERROR("writted file len is not equle to real file len");
		return ERR_WRITE_DATA_LEN;
	}

	return S4_SUCCESS;
}

DWORD S4Time::ReadDataFile(USBKEY_HANDLE hHandle, unsigned int nFileID, unsigned int wOffset, BYTE * pOutData, unsigned int nDataLen)
{
	DWORD dwRet = 0;
	unsigned int nFileLen = 0;
	DWORD dwBytesRead = 0;
	string strFileID;
	string strInputID;

	//读文件前，需先验证用户PIN码，默认"12345678",不做修改
	dwRet = VerifyUserPIN(hHandle, DEFAULT_USER_PIN);
	if (S4_SUCCESS != dwRet)
	{
		return dwRet;
	}

	//取4位字节文件ID，比如0x0021中的0021
	_itoa_s(nFileID, (char*)strInputID.c_str(), 4, 16);	
	int nIdLen = strlen(strInputID.c_str());	
	if (4 > nIdLen)
	{
		//补齐4位数文件ID
		for (int i=0;i<4-nIdLen;i++)
		{
			strFileID += "0";
		}
	}
	strFileID += strInputID.c_str();	


	//如果待数据的数据长度大于274字节，分多次读写
	unsigned int nReadLen = nDataLen;
	unsigned int nOffset = 0;
	BOOL bFristRead = TRUE;
	while(nDataLen > MAX_READ_LEN)
	{
		//读274字节
		BYTE outBuffer[MAX_READ_LEN] = {0};
		ST_READ_DATAFILE stRead;
		memset(&stRead, 0, sizeof(stRead));

		if (bFristRead)
		{
			//第一次读文件，跳过文件头
			nOffset += FILE_HEAD_LEN;
			bFristRead = FALSE;
			printf("\n");
		}
		stRead.offset = nOffset;
		stRead.ucLen = MAX_READ_LEN;
		stRead.fid = nFileID;

		//执行读文件可执行文件
		dwRet = S4Execute(&g_s4Ctx,EXE_READ_DATA_FILE,&stRead,sizeof(ST_READ_DATAFILE),outBuffer,MAX_READ_LEN,&dwBytesRead);
		if (S4_SUCCESS != dwRet)
		{
			printf("执行0x0001 failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("执行0x0013 failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}	
		else
		{
			/*输出排序后的数据*/		
			for(int i=0;i<MAX_READ_LEN;i++)
			{
				printf("%c",outBuffer[i]);
			}
			
			if (MAX_READ_LEN != dwBytesRead)
			{
				g_log->LOGERROR("Read len is not equal to the len that want to read");
				return ERR_READ_DATA;
			}
		}

		memcpy(pOutData, outBuffer, MAX_READ_LEN);
		pOutData += MAX_READ_LEN;
		nOffset += MAX_READ_LEN;
		nDataLen -= MAX_READ_LEN;	
	}

	if (nDataLen > 0)
	{
		//读剩余字节
		BYTE outBuffer[MAX_READ_LEN] = {0};
		ST_READ_DATAFILE stRead;
		memset(&stRead, 0, sizeof(stRead));

		if (bFristRead && nDataLen != FILE_HEAD_LEN)
		{
			//第一次读文件且不是读取文件头是，跳过文件头
			nOffset += FILE_HEAD_LEN;
			bFristRead = FALSE;
		}
		stRead.offset = nOffset;
		stRead.ucLen = nDataLen;
		stRead.fid = nFileID;

		//执行读文件可执行文件
		dwRet = S4Execute(&g_s4Ctx,EXE_READ_DATA_FILE,&stRead,sizeof(ST_READ_DATAFILE),outBuffer,MAX_READ_LEN,&dwBytesRead);
		//dwRet = S4Execute(&m_s4Ctx,EXE_READ_DATA_FILE,(void*)"0021",4,outBuffer,nDataLen,&dwBytesRead);
		if (S4_SUCCESS != dwRet)
		{
			printf("执行0013 failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("执行0x0013 failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}	
		else
		{		
			for(unsigned int i=0;i<nDataLen;i++)
			{
				printf("%c",outBuffer[i]);
			}
			printf("\n");

			if (nDataLen != dwBytesRead)
			{
				g_log->LOGERROR("Read len is not equal to the len that want to read");
				return ERR_READ_DATA;
			}
		}

		memcpy(pOutData, outBuffer, nDataLen);
	}

	return S4_SUCCESS;
}

DWORD S4Time::DeleteDataFile(USBKEY_HANDLE hHandle, unsigned int nFileID)
{
	if (0)
	{
		DWORD dwRet = 0;
		string strFileID;
		string strInputID;

		//取4位字节文件ID，比如0x0021中的0021
		_itoa_s(nFileID, (char*)strInputID.c_str(), 4, 16);
		//_itoa(nFileID, (char*)strInputID.c_str(), 16);
		int nIdLen = strlen(strInputID.c_str());
		if (4 > nIdLen)
		{
			//补齐4位数文件ID
			for (int i=0;i<4-nIdLen;i++)
			{
				strFileID += "0";
			}
		}
		strFileID += strInputID.c_str();

		//切换目录
		dwRet = S4ChangeDir(&g_s4Ctx, strFileID.c_str());
		if (S4_SUCCESS != dwRet)
		{
			printf("Change to <%s> dir failed! <error code = 0x%08x>\n", strFileID.c_str(),dwRet);
			return dwRet;
		}

		//清空目录
		dwRet = S4EraseDir(&g_s4Ctx, NULL);
		if (S4_SUCCESS != dwRet)
		{
			printf("Delete <%s> dir failed! <error code = 0x%08x>\n", strFileID.c_str(), dwRet);
			return dwRet;
		}

		//修改PIN码
		dwRet = ChangeAdminPIN(hHandle, "12345678", (char*)m_strRootPIN.c_str());
		if (S4_SUCCESS != dwRet)
		{
			printf("change <%s> dir admin PIN failed! <error code = 0x%08x>\n", strFileID.c_str(), dwRet);
			return dwRet;
		}
	}
	
	return S4_SUCCESS;
}

DWORD S4Time::DeleteAllFile(USBKEY_HANDLE hHandle)
{
	g_log->LOGERROR("DeleteAllFile");

	//通过删除根目录来实现删除所有文件
	DWORD dwRet = 0;

	/*检查精锐IV 设备中是否存在根目录*/
	dwRet = S4ChangeDir(&g_s4Ctx, "\\");	
	if (S4_DEVICE_UNSUPPORTED == dwRet)
	{
		/*如果根目录不存在，创建新的根目录*/
		dwRet = S4CreateDir(&g_s4Ctx, "\\", 0, S4_CREATE_ROOT_DIR);
		if (dwRet != S4_SUCCESS)
		{
			printf("Create new root failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("Create new root  failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}
	}
	else if (dwRet != S4_SUCCESS)
	{
		printf("Change to root dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to root dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//清空根目录前，需先验证开发商PIN码
	dwRet = VerifyAdminPIN(hHandle, (char*)m_strRootPIN.c_str());
	if (S4_SUCCESS != dwRet)
	{
		return dwRet;
	}

	//清空根目录
	dwRet = S4EraseDir(&g_s4Ctx, NULL);
	if (S4_SUCCESS != dwRet)
	{
		printf("Delete root dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Delete root dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//创建新的根目录
	dwRet = S4CreateDir(&g_s4Ctx, "\\", 0, S4_CREATE_ROOT_DIR);
	if (S4_SUCCESS != dwRet)
	{
		printf("Create new root failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Create new root failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//修改开发商PIN码
	dwRet = ChangeAdminPIN(hHandle, DEFAULT_ADMIN_PIN, (char*)m_strRootPIN.c_str());
	if (S4_SUCCESS != dwRet)
	{
		printf("Change dev PIN failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change dev PIN failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	return S4_SUCCESS;
}

DWORD S4Time::GetFileLen(USBKEY_HANDLE hHandle, unsigned int nFileID, unsigned int* pFileLen)
{
	string strFileLen;

	DWORD dwRet = ReadDataFile(hHandle, nFileID, 0, (BYTE*)strFileLen.c_str(), 4);
	if (S4_SUCCESS != dwRet)
	{
		return dwRet;
	}

	*pFileLen = atoi(strFileLen.c_str());

	return S4_SUCCESS;
}

DWORD S4Time::WriteExeFile(USBKEY_HANDLE hHandle, unsigned int nFileID, BYTE * pInData, unsigned int nDataLen, unsigned int nFileSize)
{
	g_log->LOGERROR("WriteExeFile <nFileID = %d>", nFileID);

	DWORD dwRet = 0;
	DWORD dwBytesWritten = 0;
	string strInputID;
	string strFileID;
	string strFileLen;

	//读日志文件Exe文件因为为目录不同，需要切换目录
	if (READ_LOG_FILE_EXE_ID == nFileID)
	{
		//切换到日志目录
		dwRet = S4ChangeDir(&g_s4Ctx, LOG_DIR);	
		if (S4_DEVICE_UNSUPPORTED == dwRet
			|| S4_FILE_NOT_FOUND == dwRet)
		{
			//如果日志目录不存在，创建新的日志目录
			dwRet = S4CreateDir(&g_s4Ctx, LOG_DIR, MAX_LOG_DIR_SIZE, S4_CREATE_SUB_DIR);
			if (dwRet != S4_SUCCESS)
			{
				printf("Create d001 dir failed! <error code = 0x%08x>\n", dwRet);
				g_log->LOGERROR("Create d001 dir failed! <error code = 0x%x>", dwRet);
				return dwRet;
			}
		}
		else if (dwRet != S4_SUCCESS)
		{
			printf("Change to d001 dir failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("Change to d001 dir failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}

		dwRet = VerifyLogDirAdminPIN(hHandle, DEFAULT_ADMIN_PIN);
		if (S4_SUCCESS != dwRet)
		{
			return dwRet;
		}
	}
	else
	{
		//写文件前，需先验证开发商PIN码
		dwRet = VerifyAdminPIN(hHandle, (char*)m_strRootPIN.c_str());
		if (S4_SUCCESS != dwRet)
		{
			return dwRet;
		}
	}
	
	//取4位字节文件ID，比如0x0021中的0021
	_itoa_s(nFileID, (char*)strInputID.c_str(), 4, 16);	
	int nIdLen = strlen(strInputID.c_str());	
	if (4 > nIdLen)
	{
		//补齐4位数文件ID
		for (int i=0;i<4-nIdLen;i++)
		{
			strFileID += "0";
		}
	}
	strFileID += strInputID.c_str();

	//创建文件
	dwRet = S4WriteFile(
		&g_s4Ctx,
		strFileID.c_str(),
		0, 
		pInData,
		nDataLen, /* Number of bytes to write. */
		nFileSize, /* New file size*/
		&dwBytesWritten,
		S4_CREATE_NEW, 
		S4_EXE_FILE);
	if (dwRet != S4_SUCCESS)
	{
		/* Handle error here… */
		printf("write <fileID=%s> failed! <error code = 0x%08x>\n", strFileID.c_str(), dwRet);
		g_log->LOGERROR("write <fileID=%s> file failed! <error code = 0x%x>", strFileID.c_str(), dwRet);

		if (READ_LOG_FILE_EXE_ID == nFileID)
		{
			//切回根目录
			dwRet = S4ChangeDir(&g_s4Ctx, "\\");	
			if (dwRet != S4_SUCCESS)
			{
				printf("Change to root dir failed! <error code = 0x%08x>\n", dwRet);
				g_log->LOGERROR("Change to root dir failed! <error code = 0x%x>", dwRet);
				return dwRet;
			}
		}
		return dwRet;
	}

	//实际写入的数据长度和文件长度不一致，返回错误
	if (nDataLen != dwBytesWritten)
	{
		if (READ_LOG_FILE_EXE_ID == nFileID)
		{
			//切回根目录
			dwRet = S4ChangeDir(&g_s4Ctx, "\\");	
			if (dwRet != S4_SUCCESS)
			{
				printf("Change to root dir failed! <error code = 0x%08x>\n", dwRet);
				g_log->LOGERROR("Change to root dir failed! <error code = 0x%x>", dwRet);
				return dwRet;
			}
		}
		return ERR_WRITE_DATA_LEN;
	}

	if (READ_LOG_FILE_EXE_ID == nFileID)
	{
		//切回根目录
		dwRet = S4ChangeDir(&g_s4Ctx, "\\");	
		if (dwRet != S4_SUCCESS)
		{
			printf("Change to root dir failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("Change to root dir failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}
	}

	return S4_SUCCESS;
}

DWORD S4Time::ReadLogData(USBKEY_HANDLE hHandle, unsigned int wOffset, BYTE * pOutData, unsigned int nDataLen)
{
	DWORD dwRet = 0;
	unsigned int nFileLen = 0;
	DWORD dwBytesRead = 0;

	//读文件前，需先验证用户PIN码，默认"12345678",不做修改
	dwRet = VerifyUserPIN(hHandle, "12345678");
	if (S4_SUCCESS != dwRet)
	{
		return dwRet;
	}

	//读文件头,单独处理
	if (FILE_HEAD_LEN == nDataLen
		&& 0 == wOffset)
	{
		//读4字节文件头
		BYTE outBuffer[FILE_HEAD_LEN] = {0};
		ST_READ_DATAFILE stRead;
		memset(&stRead, 0, sizeof(stRead));

		stRead.offset = wOffset;
		stRead.ucLen = nDataLen;
		stRead.fid = LOG_FILE_ID;

		//执行读文件可执行文件
		dwRet = S4Execute(&g_s4Ctx,EXE_READ_LOG_FILE,(void*)&stRead,sizeof(ST_READ_DATAFILE),outBuffer,nDataLen,&dwBytesRead);
		if (S4_SUCCESS != dwRet)
		{
			printf("执行0x0014 failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("执行0x0014 failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}	
		else
		{
			if (nDataLen != dwBytesRead)
			{
				memcpy(&dwRet, outBuffer, 1);
				return dwRet;
			}
		}

		memcpy(pOutData, outBuffer, nDataLen);

		return S4_SUCCESS;
	}

	//如果待数据的数据长度大于274字节，分多次读写
	unsigned int nReadLen = nDataLen;
	unsigned int nOffset = 0;
	BOOL bFristRead = TRUE;
	while(nDataLen > MAX_READ_LEN)
	{
		//读274字节
		BYTE outBuffer[MAX_READ_LEN] = {0};
		ST_READ_DATAFILE stRead;
		memset(&stRead, 0, sizeof(stRead));

		if (bFristRead)
		{
			//第一次读文件，跳过文件头
			nOffset += FILE_HEAD_LEN;
			bFristRead = FALSE;
		}
		stRead.offset = nOffset;
		stRead.ucLen = MAX_READ_LEN;
		stRead.fid = LOG_FILE_ID;

		//执行读文件可执行文件
		dwRet = S4Execute(&g_s4Ctx,EXE_READ_LOG_FILE,(void*)&stRead,sizeof(ST_READ_DATAFILE),outBuffer,MAX_READ_LEN,&dwBytesRead);
		if (S4_SUCCESS != dwRet)
		{
			printf("执行0x0014 failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("执行0x0014 failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}	
		else
		{
			if (MAX_READ_LEN != dwBytesRead)
			{
				memcpy(&dwRet, outBuffer, 1);
				return dwRet;
			}
		}

		memcpy(pOutData, outBuffer, MAX_READ_LEN);
		pOutData += MAX_READ_LEN;
		nOffset += MAX_READ_LEN;
		nDataLen -= MAX_READ_LEN;	
	}

	if (nDataLen > 0)
	{
		//读剩余字节
		BYTE outBuffer[MAX_READ_LEN] = {0};
		ST_READ_DATAFILE stRead;
		memset(&stRead, 0, sizeof(stRead));

		if (bFristRead)
		{
			//第一次读文件，跳过文件头
			nOffset += FILE_HEAD_LEN;
			bFristRead = FALSE;
		}
		stRead.offset = nOffset;
		stRead.ucLen = nDataLen;
		stRead.fid = LOG_FILE_ID;

		//执行读文件可执行文件
		dwRet = S4Execute(&g_s4Ctx,EXE_READ_LOG_FILE,(void*)&stRead,sizeof(ST_READ_DATAFILE),outBuffer,nDataLen,&dwBytesRead);
		if (S4_SUCCESS != dwRet)
		{
			printf("执行0x0014 failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("执行0x0014 failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}	
		else
		{
			if (nDataLen != dwBytesRead)
			{
				memcpy(&dwRet, outBuffer, 1);
				return dwRet;
			}
		}

		memcpy(pOutData, outBuffer, nDataLen);
	}

	return S4_SUCCESS;
}

DWORD S4Time::WriteLogData(USBKEY_HANDLE hHandle, unsigned int wOffset, BYTE * pInData, unsigned int nDataLen)
{
	g_log->LOGERROR("WriteLogData");

	DWORD dwRet = 0;
	DWORD dwBytesWritten = 0;
	char* pFileData = NULL;
	string strFileLen;

	//写文件前，需先验证开发商PIN码
	dwRet = VerifyLogDirAdminPIN(hHandle, (char*)DEFAULT_ADMIN_PIN);
	if (S4_SUCCESS != dwRet)
	{
		return dwRet;
	}

	if (FILE_HEAD_LEN < nDataLen
		&& 0 == wOffset)
	{
		//如果不是写文件头，且是第一次写文件，则加上文件头
		//加上4字节的文件头，用于表示文件长度
		_itoa_s(nDataLen, (char*)strFileLen.c_str(), 5, 10);
		int nLen = strlen(strFileLen.c_str());	
		if (4 > strlen(strFileLen.c_str()))
		{
			string strTemp;
			//补齐4字节
			for (int i=0;i<4-nLen;i++)
			{
				strTemp += "0";
			}
			strTemp += strFileLen.c_str();
			strFileLen = strTemp;
		}

		pFileData = new char[nDataLen+FILE_HEAD_LEN];
		memset(pFileData, 0, nDataLen+FILE_HEAD_LEN);
		memcpy(pFileData, strFileLen.c_str(), FILE_HEAD_LEN);
		memcpy(pFileData+FILE_HEAD_LEN, pInData, nDataLen);
	}
	else
	{
		pFileData = new char[nDataLen];
		memset(pFileData, 0, nDataLen);
		memcpy(pFileData, pInData, nDataLen);
	}

	//创建文件
	dwRet = S4WriteFile(
		&g_s4Ctx,
		"0040",
		wOffset, 
		pFileData,
		nDataLen+FILE_HEAD_LEN, /* Number of bytes to write. */
		S4_MAX_LOG_SIZE, /* New file size*/
		&dwBytesWritten,
		S4_CREATE_NEW, 
		S4_DATA_FILE);
	if (S4_FILE_EXIST == dwRet)
	{
		//文件已经存在，则覆盖写
		unsigned int offset = 0;
		if (FILE_HEAD_LEN != nDataLen)
		{
			//如果不是写文件头，实际偏移量需要加上文件头长度
			offset = wOffset+FILE_HEAD_LEN;
		}
		else
		{
			offset = 0;
		}

		dwRet = S4WriteFile(
			&g_s4Ctx,
			"0040",
			offset, 
			pFileData,
			nDataLen, /* Number of bytes to write. */
			0, /* New file size*/
			&dwBytesWritten,
			S4_UPDATE_FILE, 
			S4_DATA_FILE);
		if (dwRet != S4_SUCCESS)
		{
			/* Handle error here… */
			printf("write log file failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("write log file failed! <error code = 0x%x>", dwRet);

			if (NULL != pFileData)
			{
				delete pFileData;
				pFileData = NULL;
			}			
			return dwRet;
		}

		if (NULL != pFileData)
		{
			delete pFileData;
			pFileData = NULL;
		}

		//实际写入的数据长度和文件长度不一致，返回错误
		if (nDataLen != dwBytesWritten)
		{
			return ERR_WRITE_DATA_LEN;
		}

		return S4_SUCCESS;
	}
	else if (dwRet != S4_SUCCESS)
	{
		/* Handle error here… */
		printf("write log file failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("write log file failed! <error code = 0x%x>", dwRet);

		if (NULL != pFileData)
		{
			delete pFileData;
			pFileData = NULL;
		}	
		return dwRet;
	}

	if (NULL != pFileData)
	{
		delete pFileData;
		pFileData = NULL;
	}	

	//实际写入的数据长度和文件长度不一致，返回错误
	if (nDataLen+FILE_HEAD_LEN != dwBytesWritten)
	{
		return ERR_WRITE_DATA_LEN;
	}	

	return S4_SUCCESS;
}

DWORD S4Time::GetLogFileLength(USBKEY_HANDLE hHandle, int* pFileLen)
{
	//切换到日志目录
	DWORD dwRet = S4ChangeDir(&g_s4Ctx, LOG_DIR);		
	if (dwRet != S4_SUCCESS)
	{
		printf("Change to d001 dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to d001 dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	BYTE strFileLen[MAX_LOG_END_POS_VALUE_NEEDLEN] = {0};
	dwRet = ReadLogData(hHandle, 0, strFileLen, 4);
	if(S4_SUCCESS != dwRet)
	{
		return dwRet;
	}

	*pFileLen = atoi((const char*)strFileLen);

	return S4_SUCCESS;
}

DWORD S4Time::ReadLogFile(USBKEY_HANDLE hHandle, BYTE* pOutData, int nDataLen)
{
	//切换到日志目录
	DWORD dwRet = S4ChangeDir(&g_s4Ctx, LOG_DIR);		
	if (dwRet != S4_SUCCESS)
	{
		printf("Change to d001 dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to d001 dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//读文件
	dwRet = ReadLogData(hHandle, 0, pOutData, nDataLen);
	if (dwRet != S4_SUCCESS)
	{
		return dwRet;
	}

	//切回根目录
	dwRet = S4ChangeDir(&g_s4Ctx, "\\");	
	if (dwRet != S4_SUCCESS)
	{
		printf("Change to root dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to root dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	return S4_SUCCESS;
}

DWORD S4Time::WriteLogFile(USBKEY_HANDLE hHandle, BYTE* pInData, int nDataLen)
{
	int nLogLen = 0;
	DWORD dwRet = 0;

	//切换到日志目录
	dwRet = S4ChangeDir(&g_s4Ctx, LOG_DIR);	
	if (S4_DEVICE_UNSUPPORTED == dwRet
		|| S4_FILE_NOT_FOUND == dwRet)
	{
		//如果日志目录不存在，创建新的日志目录
		dwRet = S4CreateDir(&g_s4Ctx, LOG_DIR, MAX_LOG_DIR_SIZE, S4_CREATE_SUB_DIR);
		if (dwRet != S4_SUCCESS)
		{
			printf("Create d001 dir failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("Create d001 dir failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}
	}
	else if (dwRet != S4_SUCCESS)
	{
		printf("Change to d001 dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to d001 dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//获取日志长度	
	dwRet = GetLogFileLength(hHandle, &nLogLen);
	if (SES_FILEID == dwRet)
	{
		//日志不存在,则创建新日志文件
		return WriteLogData(hHandle, 0, pInData, nDataLen);
	}
	else if (S4_SUCCESS != dwRet)
	{
		return dwRet;
	}

	//最大日志文件长度为4096字节，如果剩余空间不足以记录下一条日志，则返回错误
	int nNewEndPos = nLogLen + nDataLen;
	if (nNewEndPos > S4_MAX_LOG_SIZE)
	{
		return ERR_LOG_TOO_BIG;
	}

	//写入新日志内容
	dwRet = WriteLogData(hHandle, nLogLen, pInData, nDataLen);
	if (S4_SUCCESS == dwRet)
	{
		//更新文件头，即文件长度
		BYTE strNewEnPos[MAX_LOG_END_POS_VALUE_NEEDLEN+1] = {0};
		sprintf_s((char*)strNewEnPos, FILE_HEAD_LEN,"%d", nNewEndPos);
		dwRet = WriteLogData(hHandle, 0, strNewEnPos, FILE_HEAD_LEN);
		if (dwRet != S4_SUCCESS)
		{
			return dwRet;
		}	
	}
	else
	{
		return dwRet;
	}

	//切回根目录
	dwRet = S4ChangeDir(&g_s4Ctx, "\\");	
	if (dwRet != S4_SUCCESS)
	{
		printf("Change to root dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to root dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	return S4_SUCCESS;
}

DWORD S4Time::DeleteLogFile(USBKEY_HANDLE hHandle)
{
	g_log->LOGERROR("DeleteLogFile");

	//通过日志目录来实现删除日志文件
	DWORD dwRet = 0;

	//切换到日志目录
	dwRet = S4ChangeDir(&g_s4Ctx, LOG_DIR);	
	if (S4_DEVICE_UNSUPPORTED == dwRet)
	{
		//如果日志目录不存在，创建新的日志目录
		dwRet = S4CreateDir(&g_s4Ctx, LOG_DIR, MAX_LOG_DIR_SIZE, S4_CREATE_SUB_DIR);
		if (S4_SUCCESS != dwRet)
		{
			printf("Create d001 dir failed! <error code = 0x%08x>\n", dwRet);
			g_log->LOGERROR("Create d001 dir failed! <error code = 0x%x>", dwRet);
			return dwRet;
		}
	}
	else if (S4_SUCCESS != dwRet)
	{
		printf("Change to d001 dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to d001 dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//清空根目录前，需先验证开发商PIN码
	dwRet = VerifyLogDirAdminPIN(hHandle, (char*)DEFAULT_ADMIN_PIN);
	if (S4_SUCCESS != dwRet)
	{
		printf("VerifyLogDirAdminPIN failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("VerifyLogDirAdminPINfailed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//清空日志目录
	dwRet = S4EraseDir(&g_s4Ctx, NULL);
	if (S4_SUCCESS != dwRet)
	{
		printf("Delete d001 dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Delete d001 dir failed! <error code = 0x%x>", dwRet);
		return dwRet;
	}

	//切回根目录
	dwRet = S4ChangeDir(&g_s4Ctx, "\\");	
	if (S4_SUCCESS != dwRet)
	{
		printf("Change to root dir failed! <error code = 0x%08x>\n", dwRet);
		g_log->LOGERROR("Change to root dir failed!<error code = 0x%x>", dwRet);
		return dwRet;
	}

	return S4_SUCCESS;
}

DWORD S4Time::WritePrivateKey(USBKEY_HANDLE hHandle, BYTE * pInData, int nDataLen)
{
	DWORD dwRet = WriteDataFile(hHandle, PRIVATE_KEY_ID, 0, pInData, nDataLen, MAX_PRIVATE_KEY_SIZE);
	if (dwRet != S4_SUCCESS)
	{
		return dwRet;
	}

	return S4_SUCCESS;
}

DWORD S4Time::CreatePrivateKey(USBKEY_HANDLE hHandle, int nFileLen)
{
	return S4_SUCCESS;
}

DWORD S4Time::DeletePrivateKey(USBKEY_HANDLE hHandle)
{
	return S4_SUCCESS;
}

DWORD S4Time::ProtocolSwitch(USBKEY_HANDLE hHandle, int nFlag)
{
	return S4_SUCCESS;
}

DWORD S4Time::GetHIDFromUKey(char *strHID)
{	
	SENSE4_CONTEXT * s4CtxList =NULL ;
	DWORD dwSize=0;
	DWORD dwRet = 0;
	
	//枚举系统连接了多少个设备,这一步不用判断返回值，第一个参数输入NULL
	dwRet = S4Enum(NULL,&dwSize);
	if (S4_SUCCESS != dwRet && S4_INSUFFICIENT_BUFFER != dwRet)
	{
		printf("S4Enum failed!<error code = %08x>\n", dwRet);
		return dwRet;
	}
	
	//如果得到的设备上下文内存数量为0或者不为sizeof(SENSE4_CONTEXT)的倍数，
	//说明没有找到设备或者列举设备出错。
	if ((0 == dwSize) || (dwSize % sizeof(SENSE4_CONTEXT))) 
	{
		printf("S4Enum return size err!\n");
		return S4_NO_LIST;
	}
	
	int nCount = dwSize / sizeof(SENSE4_CONTEXT);
	
	//根据返回的设备个数，分配空间给程序使用
	s4CtxList = (SENSE4_CONTEXT *)malloc(dwSize);
	
	//根据分配的空间，再次枚举设备，这次要判断函数返回值
	dwRet = S4Enum(&g_s4Ctx,&dwSize);
	if(S4_SUCCESS != dwRet)
	{
		free(s4CtxList);
		s4CtxList = NULL;
		printf("Enum device failed.<error code = %08x>\n", dwRet); 
		return dwRet;
	}
	
	S4OPENINFO S4_OpenInfo;
	S4_OpenInfo.dwS4OpenInfoSize = sizeof(S4OPENINFO);
	S4_OpenInfo.dwShareMode = S4_EXCLUSIZE_MODE;
	
	dwRet = S4OpenEx(&g_s4Ctx, &S4_OpenInfo);
	if (S4_SUCCESS != dwRet)
	{		
		if (S4_DEVICE_BUSY == dwRet)
		{
			printf("device is busy, start to close, and then open.\n");
			dwRet = S4Close(&g_s4Ctx);
			if(S4_SUCCESS != dwRet)
			{
				free(s4CtxList);
				s4CtxList = NULL;
				printf("S4Close failure.<error code = %08x>\n", dwRet);
				return dwRet;
			}
	
			dwRet = S4OpenEx(&g_s4Ctx, &S4_OpenInfo);
			if(S4_SUCCESS != dwRet)
			{
				free(s4CtxList);
				s4CtxList = NULL;
				printf("S4OpenEx failure.<error code = %08x>\n", dwRet);
				return dwRet;
			}
		} 
		else
		{
			printf("S4OpenEx failure.<error code = %08x>\n", dwRet);
			return dwRet;
		}		
	}
	
	//获取设备序列号
	DWORD len = 0;
	unsigned char cSerialNumber[8] = {0};
	dwRet = S4Control(&g_s4Ctx, S4_GET_SERIAL_NUMBER, NULL, 0, (void*)cSerialNumber, 8, &len);
	if (S4_SUCCESS != dwRet)
	{
		/*free(s4CtxList);
		s4CtxList = NULL;*/
		printf("Get Serial number failed!<error code = %08x>\n", dwRet);
		return dwRet;
	}
	
	for (int i = 0; i < 8; i++)
	{
		sprintf(strHID+2*i, "%02X ", cSerialNumber[i]);
	}
	
	free(s4CtxList);
	s4CtxList = NULL;

	return S4_SUCCESS;
}