/*************************************************
* Function: PCT_HandleOtaFileChunkMsg
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_HandleOtaFileChunkMsg(PTC_ProtocolCon *pstruContoller, MSG_Buffer *pstruBuffer)
{
ZC_MessageHead *pstruMsg;
ZC_OtaFileChunkReq *pstruOta;
u32 u32FileLen;
u32 u32RetVal;
u32 u32RecvOffset;
ZC_Printf("Ota File Chunk\n");
pstruMsg = (ZC_MessageHead*)pstruBuffer->u8MsgBuffer;
pstruOta = (ZC_OtaFileChunkReq *)(pstruMsg + 1);
u32FileLen = ZC_HTONS(pstruMsg->Payloadlen) - sizeof(ZC_OtaFileChunkReq);
u32RecvOffset = ZC_HTONL(pstruOta->u32Offset);
/*check para*/
if ((u32RecvOffset != pstruContoller->struOtaInfo.u32RecvOffset)
|| ((u32RecvOffset + u32FileLen) > pstruContoller->struOtaInfo.u32TotalLen)
|| (u32FileLen > ZC_OTA_MAX_CHUNK_LEN))
{
ZC_Printf("recv error %d,%d,%d,%d,\n", u32RecvOffset,
pstruContoller->struOtaInfo.u32RecvOffset,
pstruContoller->struOtaInfo.u32TotalLen,
u32FileLen);
PCT_SendErrorMsg(pstruMsg->MsgId, NULL, 0);
return;
}
u32RetVal = pstruContoller->pstruMoudleFun->pfunUpdate((u8*)(pstruOta + 1), u32RecvOffset, u32FileLen);
//u32RetVal = ZC_RET_OK;
ZC_Printf("offset = %d, len = %d\n", u32RecvOffset, u32FileLen);
if (ZC_RET_ERROR == u32RetVal)
{
ZC_Printf("OTA Fail\n");
PCT_SendErrorMsg(pstruMsg->MsgId, NULL, 0);
return;
}
/*update file offset*/
pstruContoller->struOtaInfo.u32RecvOffset = pstruContoller->struOtaInfo.u32RecvOffset + u32FileLen;
PCT_SendAckToCloud(pstruMsg->MsgId);
}
/*************************************************
* Function: ZC_ConfigPara
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void ZC_ConfigPara(u8 *pu8Data)
{
ZC_Configuration *pstruConfig;
pstruConfig = (ZC_Configuration*)pu8Data;
g_struZcConfigDb.struSwitchInfo.u32SecSwitch = ZC_HTONL(pstruConfig->u32SecSwitch);
g_struZcConfigDb.struSwitchInfo.u32TraceSwitch = ZC_HTONL(pstruConfig->u32TraceSwitch);
g_struZcConfigDb.struSwitchInfo.u32WifiConfig = ZC_HTONL(pstruConfig->u32WifiConfig);
g_struZcConfigDb.struSwitchInfo.u32ServerAddrConfig = ZC_HTONL(pstruConfig->u32ServerAddrConfig);
g_struZcConfigDb.struSwitchInfo.u32ServerIp = ZC_HTONL(pstruConfig->u32IpAddr);
g_struZcConfigDb.struSwitchInfo.u16ServerPort = ZC_HTONS(pstruConfig->u16Port);
memcpy(g_struZcConfigDb.struSwitchInfo.u8Password, pstruConfig->u8Password, ZC_PASSWORD_MAX_LEN);
memcpy(g_struZcConfigDb.struSwitchInfo.u8Ssid, pstruConfig->u8Ssid, ZC_SSID_MAX_LEN);
memcpy(g_struZcConfigDb.struCloudInfo.u8CloudAddr, pstruConfig->u8CloudAddr, ZC_CLOUD_ADDR_MAX_LEN);
memcpy(g_struZcConfigDb.struCloudInfo.u8CloudKey, pstruConfig->u8CloudKey, ZC_CLOUD_KEY_MAX_LEN);
g_struProtocolController.pstruMoudleFun->pfunWriteFlash((u8*)&g_struZcConfigDb, sizeof(ZC_ConfigDB));
}
/*************************************************
* Function: PCT_SendHeartMsg
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_SendUnbindMsg()
{
ZC_MessageHead struUnbind;
ZC_SecHead struSecHead;
u16 u16Len = 0;
u32 u32Timer = 0;
EVENT_BuildMsg(ZC_CODE_UNBIND, 0, (u8*)&struUnbind, &u16Len,
NULL, 0);
/*build sec head*/
struSecHead.u8SecType = ZC_SEC_ALG_AES;
struSecHead.u16TotalMsg = ZC_HTONS(u16Len);
(void)PCT_SendMsgToCloud(&struSecHead, (u8*)&struUnbind);
ZC_Printf("Send Unbind msg ok\n");
u32Timer = rand();
u32Timer = (PCT_TIMER_INTERVAL_SENDUBIND) * (u32Timer % 10 + 1);
g_struProtocolController.pstruMoudleFun->pfunSetTimer(PCT_TIMER_SENDUBIND,
u32Timer, &g_struProtocolController.u8SendUnbindTimer);
}
/*************************************************
* Function: PCT_HandleMoudleEvent
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_HandleMoudleEvent(u8 *pu8Msg, u16 u16DataLen)
{
MSG_Buffer *pstruBuffer;
ZC_SecHead struHead;
if (PCT_TIMER_INVAILD != g_struProtocolController.u8SendMoudleTimer)
{
TIMER_StopTimer(g_struProtocolController.u8SendMoudleTimer);
pstruBuffer = (MSG_Buffer *)g_struProtocolController.pu8SendMoudleBuffer;
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
g_struProtocolController.u8SendMoudleTimer = PCT_TIMER_INVAILD;
g_struProtocolController.u8ReSendMoudleNum = 0;
}
struHead.u8SecType = ZC_SEC_ALG_AES;
struHead.u16TotalMsg = ZC_HTONS(u16DataLen);
(void)PCT_SendMsgToCloud(&struHead, pu8Msg);
return;
}
/*************************************************
* Function: PCT_SetLicense
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_SetLicense(PTC_ProtocolCon *pstruContoller, MSG_Buffer *pstruBuffer)
{
s32 ret = 0;
ZC_MessageHead *pstruMsg;
u8 *pu8License;
pstruMsg = (ZC_MessageHead*)pstruBuffer->u8MsgBuffer;
pu8License = (u8 *)(pstruMsg + 1);
ret = ZC_ConfigLicense(pu8License, ZC_HTONS(pstruMsg->Payloadlen));
if (ZC_RET_OK == ret)
{
PCT_SendAckToCloud(pstruMsg->MsgId);
}
else
{
PCT_SendErrorMsg(pstruMsg->MsgId, NULL, 0);
}
pstruContoller->pstruMoudleFun->pfunSetTimer(PCT_TIMER_REBOOT,
PCT_TIMER_INTERVAL_REBOOT, &pstruContoller->u8RebootTimer);
return;
}
/*************************************************
* Function: PCT_HandleMoudleEvent
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_HandleMoudleEvent(u8 *pu8Msg, u16 u16DataLen)
{
MSG_Buffer *pstruBuffer;
ZC_SecHead struHead;
ZC_MessageHead *pstruMsg = (ZC_MessageHead *)pu8Msg;
if ((PCT_TIMER_INVAILD != g_struProtocolController.u8SendMoudleTimer) &&
(pstruMsg->MsgCode < 200))
{
TIMER_StopTimer(g_struProtocolController.u8SendMoudleTimer);
pstruBuffer = (MSG_Buffer *)g_struProtocolController.pu8SendMoudleBuffer;
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
g_struProtocolController.u8SendMoudleTimer = PCT_TIMER_INVAILD;
g_struProtocolController.u8ReSendMoudleNum = 0;
PCT_SendEmptyMsg(((ZC_MessageHead *)pu8Msg)->MsgId, ZC_SEC_ALG_AES);
}
struHead.u8SecType = ZC_SEC_ALG_AES;
struHead.u16TotalMsg = ZC_HTONS(u16DataLen);
(void)PCT_SendMsgToCloud(&struHead, pu8Msg);
return;
}
/*************************************************
* Function: PCT_SendMsgToCloud
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
u32 PCT_SendMsgToCloud(ZC_SecHead *pstruSecHead, u8 *pu8PlainData)
{
//u32 u32Index;
u32 u32RetVal;
u16 u16Len;
u16 u16PaddingLen;
ZC_SendParam struParam;
u32RetVal = SEC_PaddingCheck(pstruSecHead->u8SecType, ZC_HTONS(pstruSecHead->u16TotalMsg), &u16PaddingLen);
if (ZC_RET_ERROR == u32RetVal)
{
return ZC_RET_ERROR;
}
u16Len = ZC_HTONS(pstruSecHead->u16TotalMsg) + sizeof(ZC_SecHead) + u16PaddingLen;
if (u16Len > MSG_BUFFER_MAXLEN)
{
return ZC_RET_ERROR;
}
#if 1
if (MSG_BUFFER_IDLE == g_struSendBuffer[0].u8Status)
{
u16Len = ZC_HTONS(pstruSecHead->u16TotalMsg) + u16PaddingLen;
/*first check padding,then Encrypt, final copy sechead*/
u32RetVal = SEC_Encrypt(pstruSecHead, g_struSendBuffer[0].u8MsgBuffer + sizeof(ZC_SecHead), pu8PlainData, &u16Len);
if (ZC_RET_ERROR == u32RetVal)
{
return ZC_RET_ERROR;
}
pstruSecHead->u16TotalMsg = ZC_HTONS(u16Len);
/*copy sechead*/
memcpy(g_struSendBuffer[0].u8MsgBuffer, (u8*)pstruSecHead, sizeof(ZC_SecHead));
g_struSendBuffer[0].u32Len = u16Len + sizeof(ZC_SecHead);
g_struSendBuffer[0].u8Status = MSG_BUFFER_FULL;
//MSG_PushMsg(&g_struSendQueue, (u8*)&g_struSendBuffer[0]);
/* ·¢ËÍ */
struParam.u8NeedPoll = 0;
g_struProtocolController.pstruMoudleFun->pfunSendTcpData(g_struProtocolController.struCloudConnection.u32Socket,
g_struSendBuffer[0].u8MsgBuffer,
g_struSendBuffer[0].u32Len,
&struParam);
//ZC_Printf("send data len = %d\n", u16DataLen);
g_struSendBuffer[0].u8Status = MSG_BUFFER_IDLE;
g_struSendBuffer[0].u32Len = 0;
return ZC_RET_OK;
}
#else
for (u32Index = 0; u32Index < MSG_BUFFER_SEND_MAX_NUM; u32Index++)
{
if (MSG_BUFFER_IDLE == g_struSendBuffer[u32Index].u8Status)
{
u16Len = ZC_HTONS(pstruSecHead->u16TotalMsg) + u16PaddingLen;
/*first check padding,then Encrypt, final copy sechead*/
u32RetVal = SEC_Encrypt(pstruSecHead, g_struSendBuffer[u32Index].u8MsgBuffer + sizeof(ZC_SecHead), pu8PlainData, &u16Len);
if (ZC_RET_ERROR == u32RetVal)
{
return ZC_RET_ERROR;
}
pstruSecHead->u16TotalMsg = ZC_HTONS(u16Len);
/*copy sechead*/
memcpy(g_struSendBuffer[u32Index].u8MsgBuffer, (u8*)pstruSecHead, sizeof(ZC_SecHead));
g_struSendBuffer[u32Index].u32Len = u16Len + sizeof(ZC_SecHead);
g_struSendBuffer[u32Index].u8Status = MSG_BUFFER_FULL;
MSG_PushMsg(&g_struSendQueue, (u8*)&g_struSendBuffer[u32Index]);
return ZC_RET_OK;
}
}
#endif
return ZC_RET_ERROR;
}
/*************************************************
* Function: PCT_HandleEvent
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_HandleEvent(PTC_ProtocolCon *pstruContoller)
{
MSG_Buffer *pstruBuffer;
ZC_MessageHead *pstruMsg;
//u32 u32i;
if (ZC_MAGIC_FLAG == g_struZcConfigDb.struDeviceInfo.u32UnBindFlag)
{
g_struProtocolController.u8MainState = PCT_STATE_WAIT_UNBIND;
if (PCT_TIMER_INVAILD != pstruContoller->u8SendUnbindTimer)
{
TIMER_StopTimer(pstruContoller->u8SendUnbindTimer);
}
PCT_SendUnbindMsg();
return;
}
pstruBuffer = (MSG_Buffer *)MSG_PopMsg(&g_struRecvQueue);
if (NULL == pstruBuffer)
{
return;
}
pstruMsg = (ZC_MessageHead*)pstruBuffer->u8MsgBuffer;
ZC_Printf("event %d recv len =%d\n", pstruMsg->MsgId, ZC_HTONS(pstruMsg->Payloadlen) + sizeof(ZC_MessageHead));
#if 0
for (u32i = 0; u32i < ZC_HTONS(pstruMsg->Payloadlen) + sizeof(ZC_MessageHead); u32i++)
ZC_Printf("data[%d] = 0x%02x\n", u32i, pstruBuffer->u8MsgBuffer[u32i]);
#endif
ZC_TraceData((u8*)pstruMsg, ZC_HTONS(pstruMsg->Payloadlen) + sizeof(ZC_MessageHead));
if (ZC_RET_ERROR == PCT_CheckCrc(pstruMsg->TotalMsgCrc, (u8*)(pstruMsg + 1), ZC_HTONS(pstruMsg->Payloadlen)))
{
PCT_SendEmptyMsg(pstruMsg->MsgId, ZC_SEC_ALG_AES);
PCT_SendErrorMsg(pstruMsg->MsgId, NULL, 0);
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
return;
}
/*when do OTA, does not send empty*/
switch (pstruMsg->MsgCode)
{
case ZC_CODE_ZOTA_BEGIN:
PCT_HandleOtaBeginMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_ZOTA_FILE_BEGIN:
PCT_HandleOtaFileBeginMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_ZOTA_FILE_CHUNK:
PCT_HandleOtaFileChunkMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_ZOTA_FILE_END:
PCT_HandleOtaFileEndMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_ZOTA_END:
PCT_HandleOtaEndMsg(pstruContoller, pstruBuffer);
break;
#if 0
case ZC_CODE_OTA_BEGIN:
case ZC_CODE_OTA_FILE_BEGIN:
case ZC_CODE_OTA_FILE_CHUNK:
case ZC_CODE_OTA_FILE_END:
case ZC_CODE_OTA_END:
case ZC_CODE_OTA_CONFIRM:
PCT_HandleMoudleMsg(pstruContoller, pstruBuffer);
break;
#endif
case ZC_CODE_TOKEN_SET:
PCT_SetTokenKey(pstruContoller, pstruBuffer);
break;
case ZC_CODE_RESET_NETWORK:
PCT_ResetNetWork(pstruContoller, pstruBuffer);
break;
case ZC_CODE_UNBIND:
break;
default:
PCT_HandleMoudleMsg(pstruContoller, pstruBuffer);
break;
}
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
return;
}
/*************************************************
* Function: PCT_HandleEvent
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_HandleEvent(PTC_ProtocolCon *pstruContoller)
{
MSG_Buffer *pstruBuffer;
ZC_MessageHead *pstruMsg;
if (PCT_TIMER_INVAILD != pstruContoller->u8SendMoudleTimer)
{
return;
}
pstruBuffer = (MSG_Buffer *)MSG_PopMsg(&g_struRecvQueue);
if (NULL == pstruBuffer)
{
return;
}
pstruMsg = (ZC_MessageHead*)pstruBuffer->u8MsgBuffer;
ZC_Printf("event %d recv len =%d\n", pstruMsg->MsgId, ZC_HTONS(pstruMsg->Payloadlen) + sizeof(ZC_MessageHead));
ZC_TraceData((u8*)pstruMsg, ZC_HTONS(pstruMsg->Payloadlen) + sizeof(ZC_MessageHead));
if (ZC_RET_ERROR == PCT_CheckCrc(pstruMsg->TotalMsgCrc, (u8*)(pstruMsg + 1), ZC_HTONS(pstruMsg->Payloadlen)))
{
PCT_SendEmptyMsg(pstruMsg->MsgId, ZC_SEC_ALG_AES);
PCT_SendErrorMsg(pstruMsg->MsgId, NULL, 0);
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
return;
}
/*when do OTA, does not send empty*/
switch (pstruMsg->MsgCode)
{
case ZC_CODE_ZOTA_BEGIN:
PCT_HandleOtaBeginMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_ZOTA_FILE_BEGIN:
PCT_HandleOtaFileBeginMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_ZOTA_FILE_CHUNK:
PCT_HandleOtaFileChunkMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_ZOTA_FILE_END:
PCT_HandleOtaFileEndMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_ZOTA_END:
PCT_HandleOtaEndMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_OTA_BEGIN:
case ZC_CODE_OTA_FILE_BEGIN:
case ZC_CODE_OTA_FILE_CHUNK:
case ZC_CODE_OTA_FILE_END:
case ZC_CODE_OTA_END:
PCT_HandleMoudleMsg(pstruContoller, pstruBuffer);
break;
case ZC_CODE_TOKEN_SET:
PCT_SetTokenKey(pstruContoller, pstruBuffer);
break;
default:
PCT_HandleMoudleMsg(pstruContoller, pstruBuffer);
PCT_SendEmptyMsg(pstruMsg->MsgId, ZC_SEC_ALG_AES);
break;
}
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
return;
}
/*************************************************
* Function: MSG_RecvDataFromCloud
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
u32 ICACHE_FLASH_ATTR
MSG_RecvData(MSG_Buffer *pstruRecvBuffer, u8 *pu8Data, u32 u32DataLen)
{
ZC_SecHead *pstruMsg;
u32 u32MsgLen;
if (MSG_BUFFER_FULL == pstruRecvBuffer->u8Status)
{
return ZC_RET_ERROR;
}
if (MSG_BUFFER_IDLE == pstruRecvBuffer->u8Status)
{
if (u32DataLen < sizeof(ZC_SecHead))
{
memcpy(pstruRecvBuffer->u8MsgBuffer, pu8Data, u32DataLen);
pstruRecvBuffer->u8Status = MSG_BUFFER_SEGMENT_NOHEAD;
pstruRecvBuffer->u32Len = u32DataLen;
}
else
{
pstruMsg = (ZC_SecHead *)(pu8Data);
u32MsgLen = ZC_HTONS(pstruMsg->u16TotalMsg) + sizeof(ZC_SecHead);
if (u32MsgLen > MSG_BUFFER_MAXLEN)
{
pstruRecvBuffer->u8Status = MSG_BUFFER_IDLE;
pstruRecvBuffer->u32Len = 0;
return ZC_RET_ERROR;
}
if (u32MsgLen <= u32DataLen)
{
memcpy(pstruRecvBuffer->u8MsgBuffer, pu8Data, u32MsgLen);
pstruRecvBuffer->u8Status = MSG_BUFFER_FULL;
pstruRecvBuffer->u32Len = u32MsgLen;
}
else
{
memcpy(pstruRecvBuffer->u8MsgBuffer, pu8Data, u32DataLen);
pstruRecvBuffer->u8Status = MSG_BUFFER_SEGMENT_HEAD;
pstruRecvBuffer->u32Len = u32DataLen;
}
}
return ZC_RET_OK;
}
if (MSG_BUFFER_SEGMENT_HEAD == pstruRecvBuffer->u8Status)
{
pstruMsg = (ZC_SecHead *)(pstruRecvBuffer->u8MsgBuffer);
u32MsgLen = ZC_HTONS(pstruMsg->u16TotalMsg) + sizeof(ZC_SecHead);
if (u32MsgLen <= u32DataLen + pstruRecvBuffer->u32Len)
{
memcpy((pstruRecvBuffer->u8MsgBuffer + pstruRecvBuffer->u32Len),
pu8Data,
(u32MsgLen - pstruRecvBuffer->u32Len));
pstruRecvBuffer->u8Status = MSG_BUFFER_FULL;
pstruRecvBuffer->u32Len = u32MsgLen;
}
else
{
memcpy((pstruRecvBuffer->u8MsgBuffer + pstruRecvBuffer->u32Len),
pu8Data,
u32DataLen);
pstruRecvBuffer->u32Len += u32DataLen;
pstruRecvBuffer->u8Status = MSG_BUFFER_SEGMENT_HEAD;
}
return ZC_RET_OK;
}
if (MSG_BUFFER_SEGMENT_NOHEAD == pstruRecvBuffer->u8Status)
{
if ((pstruRecvBuffer->u32Len + u32DataLen) < sizeof(ZC_SecHead))
{
memcpy((pstruRecvBuffer->u8MsgBuffer + pstruRecvBuffer->u32Len),
pu8Data,
u32DataLen);
pstruRecvBuffer->u32Len += u32DataLen;
pstruRecvBuffer->u8Status = MSG_BUFFER_SEGMENT_NOHEAD;
}
else
{
memcpy((pstruRecvBuffer->u8MsgBuffer + pstruRecvBuffer->u32Len),
pu8Data,
(sizeof(ZC_SecHead) - pstruRecvBuffer->u32Len));
pstruMsg = (ZC_SecHead *)(pstruRecvBuffer->u8MsgBuffer);
u32MsgLen = ZC_HTONS(pstruMsg->u16TotalMsg) + sizeof(ZC_SecHead);
if (u32MsgLen > MSG_BUFFER_MAXLEN)
{
pstruRecvBuffer->u8Status = MSG_BUFFER_IDLE;
pstruRecvBuffer->u32Len = 0;
return ZC_RET_ERROR;
}
if (u32MsgLen <= u32DataLen + pstruRecvBuffer->u32Len)
{
memcpy((pstruRecvBuffer->u8MsgBuffer + pstruRecvBuffer->u32Len),
pu8Data,
u32MsgLen - pstruRecvBuffer->u32Len);
pstruRecvBuffer->u8Status = MSG_BUFFER_FULL;
pstruRecvBuffer->u32Len = u32MsgLen;
}
else
{
memcpy((pstruRecvBuffer->u8MsgBuffer + pstruRecvBuffer->u32Len),
pu8Data,
u32DataLen);
pstruRecvBuffer->u8Status = MSG_BUFFER_SEGMENT_HEAD;
pstruRecvBuffer->u32Len += u32DataLen;
}
}
return ZC_RET_OK;
}
return ZC_RET_ERROR;
}
/*************************************************
* Function: ZC_RecvDataFromClient
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void ZC_RecvDataFromClient(u32 ClientId, u8 *pu8Data, u32 u32DataLen)
{
u32 u32RetVal;
ZC_MessageHead *pstruMsg;
ZC_MessageOptHead struOpt;
ZC_SsessionInfo struSessionMsg;
ZC_SecHead *pstruHead;
u16 u16Len;
u32 u32CiperLen;
u8 *pu8Key;
ZC_SendParam struParam;
u8 u8Iv[ZC_HS_SESSION_KEY_LEN];
u16 crc;
/*can hanle it,get aes key*/
ZC_GetStoreInfor(ZC_GET_TYPE_TOKENKEY, &pu8Key);
u32RetVal = ZC_CheckClientIdle(ClientId);
if (ZC_RET_ERROR == u32RetVal)
{
pstruHead = (ZC_SecHead*)(g_u8MsgBuildBuffer);
EVENT_BuildMsg(ZC_CODE_ERR, 0, g_u8MsgBuildBuffer + sizeof(ZC_SecHead), &u16Len,
NULL, 0);
memcpy(u8Iv, pu8Key, ZC_HS_SESSION_KEY_LEN);
AES_CBC_Encrypt(g_u8MsgBuildBuffer + sizeof(ZC_SecHead), u16Len,
pu8Key, ZC_HS_SESSION_KEY_LEN,
u8Iv, ZC_HS_SESSION_KEY_LEN,
g_u8MsgBuildBuffer + sizeof(ZC_SecHead), &u32CiperLen);
pstruHead->u8SecType = ZC_SEC_ALG_AES;
pstruHead->u16TotalMsg = ZC_HTONS((u16)u32CiperLen);
struParam.u8NeedPoll = 0;
g_struProtocolController.pstruMoudleFun->pfunSendTcpData(ClientId, g_u8MsgBuildBuffer,
u32CiperLen + sizeof(ZC_SecHead), &struParam);
return;
}
/*set client busy*/
ZC_SetClientBusy(ClientId);
u32RetVal = MSG_RecvData(&g_struClientBuffer, pu8Data, u32DataLen);
if ((MSG_BUFFER_FULL == g_struClientBuffer.u8Status)&&(ZC_RET_OK == u32RetVal))
{
do
{
pstruHead = (ZC_SecHead *)g_struClientBuffer.u8MsgBuffer;
if (ZC_HTONS(pstruHead->u16TotalMsg) >= MSG_BULID_BUFFER_MAXLEN)
{
break;
}
memcpy(u8Iv, pu8Key, ZC_HS_SESSION_KEY_LEN);
AES_CBC_Decrypt(g_struClientBuffer.u8MsgBuffer + sizeof(ZC_SecHead), ZC_HTONS(pstruHead->u16TotalMsg),
pu8Key, ZC_HS_SESSION_KEY_LEN,
u8Iv, ZC_HS_SESSION_KEY_LEN,
g_u8MsgBuildBuffer, &u32CiperLen);
pstruMsg = (ZC_MessageHead*)(g_u8MsgBuildBuffer);
if(ZC_RET_ERROR == PCT_CheckCrc(pstruMsg->TotalMsgCrc, (u8 *)(pstruMsg + 1), ZC_HTONS(pstruMsg->Payloadlen)))
{
break;
}
pstruMsg->Payloadlen = ZC_HTONS(ZC_HTONS(pstruMsg->Payloadlen) + sizeof(ZC_MessageOptHead) + sizeof(ZC_SsessionInfo));
if (ZC_HTONS(pstruMsg->Payloadlen) > MSG_BULID_BUFFER_MAXLEN)
{
break;
}
pstruMsg->OptNum = pstruMsg->OptNum + 1;
struOpt.OptCode = ZC_HTONS(ZC_OPT_SSESSION);
struOpt.OptLen = ZC_HTONS(sizeof(ZC_SsessionInfo));
struSessionMsg.u32SsessionId = ZC_HTONL(ClientId);
u16Len = 0;
memcpy(g_struClientBuffer.u8MsgBuffer + u16Len, pstruMsg, sizeof(ZC_MessageHead));
/*insert opt*/
u16Len += sizeof(ZC_MessageHead);
memcpy(g_struClientBuffer.u8MsgBuffer + u16Len,
&struOpt, sizeof(ZC_MessageOptHead));
u16Len += sizeof(ZC_MessageOptHead);
memcpy(g_struClientBuffer.u8MsgBuffer + u16Len,
&struSessionMsg, sizeof(struSessionMsg));
/*copy message*/
u16Len += sizeof(struSessionMsg);
memcpy(g_struClientBuffer.u8MsgBuffer + u16Len,
(u8*)(pstruMsg+1), ZC_HTONS(pstruMsg->Payloadlen) - (sizeof(ZC_MessageOptHead) + sizeof(struSessionMsg)));
u16Len += ZC_HTONS(pstruMsg->Payloadlen) - (sizeof(ZC_MessageOptHead) + sizeof(struSessionMsg));
g_struClientBuffer.u32Len = u16Len;
crc = crc16_ccitt(g_struClientBuffer.u8MsgBuffer+sizeof(ZC_MessageHead),u16Len - sizeof(ZC_MessageHead));
pstruMsg = (ZC_MessageHead*)(g_struClientBuffer.u8MsgBuffer);
pstruMsg->TotalMsgCrc[0]=(crc&0xff00)>>8;
pstruMsg->TotalMsgCrc[1]=(crc&0xff);
ZC_TraceData(g_struClientBuffer.u8MsgBuffer, g_struClientBuffer.u32Len);
/*send to moudle*/
g_struProtocolController.pstruMoudleFun->pfunSendToMoudle(g_struClientBuffer.u8MsgBuffer, g_struClientBuffer.u32Len);
}while(0);
g_struClientBuffer.u8Status = MSG_BUFFER_IDLE;
g_struClientBuffer.u32Len = 0;
ZC_SetClientFree(ClientId);
}
return;
}
