/*************************************************
* Function: PCT_RecvAccessMsg2
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_RecvAccessMsg2(PTC_ProtocolCon *pstruContoller)
{
MSG_Buffer *pstruBuffer;
ZC_MessageHead *pstruMsg;
ZC_HandShakeMsg2 *pstruMsg2;
ZC_AccessPoint *pstruAccessPoint;
u32 u32Addr;
u16 u16Port;
pstruBuffer = (MSG_Buffer *)MSG_PopMsg(&g_struRecvQueue);
if (NULL == pstruBuffer)
{
return;
}
pstruMsg = (ZC_MessageHead*)pstruBuffer->u8MsgBuffer;
pstruMsg2 = (ZC_HandShakeMsg2*)(pstruMsg + 1);
if ((ZC_CODE_HANDSHAKE_2 == pstruMsg->MsgCode)||(ZC_CODE_ACCESS_POINT_RSP == pstruMsg->MsgCode))
{
if (ZC_RET_ERROR == PCT_CheckCrc(pstruMsg->TotalMsgCrc, (u8*)pstruMsg2, ZC_HTONS(pstruMsg->Payloadlen)))
{
PCT_DisConnectCloud(pstruContoller);
}
else
{
TIMER_StopTimer(pstruContoller->u8AccessTimer);
if (0 == memcmp(pstruMsg2->RandMsg, pstruContoller->RandMsg, ZC_HS_MSG_LEN))
{
if (ZC_CODE_HANDSHAKE_2 == pstruMsg->MsgCode)
{
memcpy(pstruContoller->u8SessionKey, pstruMsg2->SessionKey, ZC_HS_SESSION_KEY_LEN);
memcpy(pstruContoller->IvRecv, pstruMsg2->SessionKey, ZC_HS_SESSION_KEY_LEN);
memcpy(pstruContoller->IvSend, pstruMsg2->SessionKey, ZC_HS_SESSION_KEY_LEN);
PCT_SendCloudAccessMsg3(pstruContoller);
ZC_Printf("Recv Msg2 ok\n");
}
else
{
pstruAccessPoint=(ZC_AccessPoint*)(pstruMsg + 1);
u32Addr = ZC_HTONL(pstruAccessPoint->u32ServerAddr);
u16Port = ZC_HTONS(pstruAccessPoint->u16ServerPort);
ZC_StoreAccessInfo((u8 *)&u32Addr,(u8 *)&u16Port);
PCT_DisConnectCloud(pstruContoller);
ZC_Printf("Recv Access Point ok,Cloud Addr=%x,port=%x!\n",u32Addr,u16Port);
}
}
else
{
PCT_DisConnectCloud(pstruContoller);
ZC_Printf("Recv Msg2 rand error \n");
}
}
}
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
}
/*************************************************
* Function: PCT_RecvAccessMsg4
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_RecvAccessMsg4(PTC_ProtocolCon *pstruContoller)
{
MSG_Buffer *pstruBuffer;
ZC_MessageHead *pstruMsg;
ZC_HandShakeMsg4 *pstruMsg4;
pstruBuffer = (MSG_Buffer *)MSG_PopMsg(&g_struRecvQueue);
if (NULL == pstruBuffer)
{
return;
}
pstruMsg = (ZC_MessageHead*)pstruBuffer->u8MsgBuffer;
pstruMsg4 = (ZC_HandShakeMsg4 *)(pstruMsg + 1);
if (ZC_CODE_HANDSHAKE_4 == pstruMsg->MsgCode)
{
if (ZC_RET_ERROR == PCT_CheckCrc(pstruMsg->TotalMsgCrc, (u8*)pstruMsg4, ZC_HTONS(pstruMsg->Payloadlen)))
{
PCT_DisConnectCloud(pstruContoller);
}
else
{
TIMER_StopTimer(pstruContoller->u8AccessTimer);
if (0 == memcmp(pstruMsg4->RandMsg, pstruContoller->RandMsg, ZC_HS_MSG_LEN))
{
pstruContoller->u8MainState = PCT_STATE_CONNECT_CLOUD;
ZC_Printf("recv msg4 ok\n");
PCT_SendNotifyMsg(ZC_CODE_CLOUD_CONNECTED);
}
else
{
PCT_DisConnectCloud(pstruContoller);
ZC_Printf("Recv msg4 rand error \n");
}
}
}
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
if (PCT_TIMER_INVAILD != pstruContoller->u8HeartTimer)
{
TIMER_StopTimer(pstruContoller->u8HeartTimer);
}
pstruContoller->pstruMoudleFun->pfunSetTimer(PCT_TIMER_SENDHEART,
PCT_TIMER_INTERVAL_HEART, &pstruContoller->u8HeartTimer);
}
/*************************************************
* Function: PCT_RecvAccessMsg2
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_RecvAccessMsg2(PTC_ProtocolCon *pstruContoller)
{
MSG_Buffer *pstruBuffer;
ZC_MessageHead *pstruMsg;
ZC_HandShakeMsg2 *pstruMsg2;
pstruBuffer = (MSG_Buffer *)MSG_PopMsg(&g_struRecvQueue);
if (NULL == pstruBuffer)
{
return;
}
pstruMsg = (ZC_MessageHead*)pstruBuffer->u8MsgBuffer;
pstruMsg2 = (ZC_HandShakeMsg2*)(pstruMsg + 1);
if (ZC_CODE_HANDSHAKE_2 == pstruMsg->MsgCode)
{
if (ZC_RET_ERROR == PCT_CheckCrc(pstruMsg->TotalMsgCrc, (u8*)pstruMsg2, ZC_HTONS(pstruMsg->Payloadlen)))
{
PCT_DisConnectCloud(pstruContoller);
}
else
{
TIMER_StopTimer(pstruContoller->u8AccessTimer);
if (0 == memcmp(pstruMsg2->RandMsg, pstruContoller->RandMsg, ZC_HS_MSG_LEN))
{
memcpy(pstruContoller->u8SessionKey, pstruMsg2->SessionKey, ZC_HS_SESSION_KEY_LEN);
memcpy(pstruContoller->IvRecv, pstruMsg2->SessionKey, ZC_HS_SESSION_KEY_LEN);
memcpy(pstruContoller->IvSend, pstruMsg2->SessionKey, ZC_HS_SESSION_KEY_LEN);
PCT_SendCloudAccessMsg3(pstruContoller);
ZC_Printf("Recv Msg2 ok\n");
}
else
{
PCT_DisConnectCloud(pstruContoller);
ZC_Printf("Recv Msg2 rand error \n");
}
}
}
pstruBuffer->u32Len = 0;
pstruBuffer->u8Status = MSG_BUFFER_IDLE;
}
/*************************************************
* Function: PCT_ResetNetWork
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_ResetNetWork(PTC_ProtocolCon *pstruContoller, MSG_Buffer *pstruBuffer)
{
ZC_MessageHead *pstruMsg;
pstruMsg = (ZC_MessageHead*)pstruBuffer->u8MsgBuffer;
ZC_ConfigInitPara();
PCT_DisConnectCloud(pstruContoller);
PCT_SendEmptyMsg(pstruMsg->MsgId, ZC_SEC_ALG_AES);
PCT_SendAckToCloud(pstruMsg->MsgId);
return;
}
/*************************************************
* Function: PCT_SendCloudAccessMsg1
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void PCT_SendCloudAccessMsg1(PTC_ProtocolCon *pstruContoller)
{
u16 u16Len;
ZC_SecHead struSechead;
ZC_HandShakeMsg1 *pstruMsg1 = (ZC_HandShakeMsg1 *)g_u8MsgBuildBuffer;
u8 *pu8DeviceId;
u8 *pu8Domain;
u32 u32RetVal;
u8 u8DeviceIdLen;
/*stop reconnection timer*/
if (PCT_TIMER_INVAILD != pstruContoller->u8ReconnectTimer)
{
ZC_Printf("msg1 stop u8ReconnectTimer\n");
TIMER_StopTimer(pstruContoller->u8ReconnectTimer);
pstruContoller->u8ReconnectTimer = PCT_TIMER_INVAILD;
}
ZC_GetStoreInfor(ZC_GET_TYPE_DEVICEID, &pu8DeviceId);
ZC_GetStoreInfor(ZC_GET_TYPE_DOMAIN, &pu8Domain);
u8DeviceIdLen = strlen((const char *)pu8DeviceId);
memcpy(pstruMsg1->RandMsg, pstruContoller->RandMsg, ZC_HS_MSG_LEN);
memcpy(pstruMsg1->DeviceId, pu8DeviceId, u8DeviceIdLen);
memcpy(pstruMsg1->u8Domain, pu8Domain, ZC_DOMAIN_LEN);
EVENT_BuildMsg(ZC_CODE_HANDSHAKE_1, 1, g_u8MsgBuildBuffer, &u16Len,
(u8*)pstruMsg1, sizeof(ZC_HandShakeMsg1)+u8DeviceIdLen);
struSechead.u8SecType = ZC_SEC_ALG_RSA;
struSechead.u16TotalMsg = ZC_HTONS(u16Len);
struSechead.u8Resver = 0x5A;
u32RetVal = PCT_SendMsgToCloud(&struSechead, g_u8MsgBuildBuffer);
if (ZC_RET_ERROR == u32RetVal)
{
ZC_Printf("Send Msg1 fail disconnect\n");
PCT_DisConnectCloud(pstruContoller);
return;
}
ZC_Printf("Send Msg1 \n");
pstruContoller->u8MainState = PCT_STATE_WAIT_ACCESSRSP;
pstruContoller->pstruMoudleFun->pfunSetTimer(PCT_TIMER_REACCESS,
PCT_TIMER_INTERVAL_RECONNECT * 120, &pstruContoller->u8AccessTimer);
}
/*************************************************
* Function: MX_Init
* Description:
* Author: cxy
* Returns:
* Parameter:
* History:
*************************************************/
void MX_CloudRecvfunc(void *inContext)
{
s32 s32RecvLen=0;
fd_set fdread;
u32 u32Index;
u32 u32Len=0;
u32 u32ActiveFlag = 0;
struct sockaddr_t cliaddr;
int connfd;
extern u8 g_u8ClientStart;
u32 u32MaxFd = 0;
struct timeval_t timeout;
struct sockaddr_t addr;
int tmp=1;
s8 s8ret = 0;
ZC_StartClientListen();
u32ActiveFlag = 0;
timeout.tv_sec= 0;
timeout.tv_usec= 1000;
FD_ZERO(&fdread);
FD_SET(g_Bcfd, &fdread);
u32MaxFd = u32MaxFd > g_Bcfd ? u32MaxFd : g_Bcfd;
if (PCT_INVAILD_SOCKET != g_struProtocolController.struClientConnection.u32Socket)
{
FD_SET(g_struProtocolController.struClientConnection.u32Socket, &fdread);
u32MaxFd = u32MaxFd > g_struProtocolController.struClientConnection.u32Socket ? u32MaxFd : g_struProtocolController.struClientConnection.u32Socket;
u32ActiveFlag = 1;
}
if ((g_struProtocolController.u8MainState >= PCT_STATE_WAIT_ACCESSRSP)
&& (g_struProtocolController.u8MainState < PCT_STATE_DISCONNECT_CLOUD))
{
FD_SET(g_struProtocolController.struCloudConnection.u32Socket, &fdread);
u32MaxFd = u32MaxFd > g_struProtocolController.struCloudConnection.u32Socket ? u32MaxFd : g_struProtocolController.struCloudConnection.u32Socket;
u32ActiveFlag = 1;
}
for (u32Index = 0; u32Index < ZC_MAX_CLIENT_NUM; u32Index++)
{
if (0 == g_struClientInfo.u32ClientVaildFlag[u32Index])
{
FD_SET(g_struClientInfo.u32ClientFd[u32Index], &fdread);
u32MaxFd = u32MaxFd > g_struClientInfo.u32ClientFd[u32Index] ? u32MaxFd : g_struClientInfo.u32ClientFd[u32Index];
u32ActiveFlag = 1;
}
}
if (0 == u32ActiveFlag)
{
return;
}
s8ret = select(u32MaxFd + 1, &fdread, NULL, NULL, &timeout);
if(s8ret<=0)
{
return ;
}
if ((g_struProtocolController.u8MainState >= PCT_STATE_WAIT_ACCESSRSP)
&& (g_struProtocolController.u8MainState < PCT_STATE_DISCONNECT_CLOUD))
{
if (FD_ISSET(g_struProtocolController.struCloudConnection.u32Socket, &fdread))
{
s32RecvLen = recv(g_struProtocolController.struCloudConnection.u32Socket, g_u8recvbuffer, MX_MAX_SOCKET_LEN, 0);
if(s32RecvLen > 0)
{
ZC_Printf("recv data len = %d\n", s32RecvLen);
MSG_RecvDataFromCloud(g_u8recvbuffer, s32RecvLen);
}
else
{
ZC_Printf("recv error, len = %d\n",s32RecvLen);
PCT_DisConnectCloud(&g_struProtocolController);
}
}
}
for (u32Index = 0; u32Index < ZC_MAX_CLIENT_NUM; u32Index++)
{
if (0 == g_struClientInfo.u32ClientVaildFlag[u32Index])
{
if (FD_ISSET(g_struClientInfo.u32ClientFd[u32Index], &fdread))
{
s32RecvLen = recv(g_struClientInfo.u32ClientFd[u32Index], g_u8recvbuffer, MX_MAX_SOCKET_LEN, 0);
if (s32RecvLen > 0)
{
ZC_RecvDataFromClient(g_struClientInfo.u32ClientFd[u32Index], g_u8recvbuffer, s32RecvLen);
}
else
{
ZC_ClientDisconnect(g_struClientInfo.u32ClientFd[u32Index]);
close(g_struClientInfo.u32ClientFd[u32Index]);
}
}
}
}
if (PCT_INVAILD_SOCKET != g_struProtocolController.struClientConnection.u32Socket)
{
if (FD_ISSET(g_struProtocolController.struClientConnection.u32Socket, &fdread))
{
connfd = accept(g_struProtocolController.struClientConnection.u32Socket,(struct sockaddr_t *)&cliaddr,(socklen_t *)&u32Len);
if (ZC_RET_ERROR == ZC_ClientConnect((u32)connfd))
{
close(connfd);
}
else
{
ZC_Printf("accept client = %d\n", connfd);
}
}
}
if (FD_ISSET(g_Bcfd, &fdread))
{
tmp = sizeof(addr);
s32RecvLen = recvfrom(g_Bcfd, g_u8MsgBuildBuffer, 100, 0, (struct sockaddr_t *)&addr, (socklen_t*)&tmp);
if(s32RecvLen > 0)
{
ZC_SendClientQueryReq(g_u8MsgBuildBuffer, (u16)s32RecvLen);
}
}
}
