ddns_client.c

UcLinux下对DDNS协议的实现源代码.

    /* send hangshake */
    memset((char *)&ddns_sodp, 0, sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = 0;
    ddns_sodp.Params[0] = DDNS_SEND_HANDSHAKE;
    n = send(sockd, (char *)&ddns_sodp, DATA_HEADER + ddns_sodp.ExtLen, 0);
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Send packet error!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* responsion handshake */
    memset(ddns_buf, 0, DDNS_BUFSIZE);
    n = recv(sockd, ddns_buf, DDNS_BUFSIZE, 0);
    if ((0 > n) ||(DDNS_BUFSIZE <= n))
    {
        ERROR("Recv handshake error.\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }
    
    memcpy((struct xSoDat *)&ddns_sodp, (struct xSoDat *)ddns_buf, n);
    if ((DDNS_ACK_CMD == (ddns_sodp.Command & 0xff)) && 
        (DDNS_SEND_HANDSHAKE == (ddns_sodp.Params[0] & 0xff)) && 
        (DDNS_RECV_HANDSHAKE_OK == (ddns_sodp.Params[4] & 0xff)))
    {
        #if DEBUG
        TRACE("Handshake success!\n\n");
        #endif
    }
    else
    {
        ERROR("Hangshake fail!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* send verify */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = 0;
    ddns_sodp.Params[0] = DDNS_SEND_VERIFY;
    ddns_sodp.Params[4] = DDNS_VERIFY_MODE;
    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER + ddns_sodp.ExtLen,0);
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Send error\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }
    
    /* recv verify */
    memset(ddns_buf,0,DDNS_BUFSIZE);
    n = recv(sockd,ddns_buf,DDNS_BUFSIZE,0);
    if ((0 > n) || (DDNS_BUFSIZE <= n))
    {
        ERROR("Recv verify error.\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }
    
    memcpy((struct xSoDat *)&ddns_sodp,(struct xSoDat *)ddns_buf,n);
    if ((DDNS_ACK_CMD == (ddns_sodp.Command & 0xff)) &&
        (DDNS_SEND_VERIFY == (ddns_sodp.Params[0] & 0xff)) &&
        (DDNS_RECV_HANDSHAKE_OK == (ddns_sodp.Params[4] & 0xff)))
    {
        #if DEBUG
        TRACE("Verify ok!\n\n");
        #endif
    }
    else
    {       
        ERROR("Verify fail!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* start send info */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = 0;
    ddns_sodp.Params[0] = DDNS_SEND_START;
    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER + ddns_sodp.ExtLen,0);
    
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Start info packet error!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* send ID / MAC */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = strlen(ddns_temp->hardwareId);
    ddns_sodp.Params[0] = DDNS_SEND_ID;
    memcpy((char *)&ddns_sodp.ExtDat,ddns_temp->hardwareId,ddns_sodp.ExtLen);
    #if DEBUG
    TRACE("mac = %s,len = %ld\n",ddns_sodp.ExtDat,ddns_sodp.ExtLen);
    #endif

    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER + ddns_sodp.ExtLen ,0);
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Send ID packet error!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* send HostName */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = strlen(ddns_temp->ddnsName);
    ddns_sodp.Params[0] = DDNS_SEND_HOSTNAME;
    memcpy((char *)&ddns_sodp.ExtDat,ddns_temp->ddnsName,ddns_sodp.ExtLen);
    #if DEBUG
    TRACE("HostName = %s,len = %ld\n",ddns_sodp.ExtDat,ddns_sodp.ExtLen);
    #endif
    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER + ddns_sodp.ExtLen,0);
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Send host name packet error!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* send TCPPort */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = sizeof(ddns_temp->TCPPort);
    ddns_sodp.Params[0] = DDNS_SEND_TCPPORT;
    
    ddns_sodp.ExtDat[1] = ((ddns_temp->TCPPort) & 0xff00) >> 8;
    ddns_sodp.ExtDat[0] = ((ddns_temp->TCPPort) & 0xff);
    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER + ddns_sodp.ExtLen,0);
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Send TCP port packet error!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* send WEBPort */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = sizeof(ddns_temp->HTTPPort);
    ddns_sodp.Params[0] = DDNS_SEND_HTTPPORT;
    
    ddns_sodp.ExtDat[1] = ((ddns_temp->HTTPPort) & 0xff00) >> 8;
    ddns_sodp.ExtDat[0] = ((ddns_temp->HTTPPort) & 0xff);
    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER + ddns_sodp.ExtLen,0);
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Send web port packet error!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* send finish symbol */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = 0;
    ddns_sodp.Params[0] = DDNS_SEND_FINISH;
    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER + ddns_sodp.ExtLen,0);
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Send finish symbol packet error!\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* recv data ack */
    memset(ddns_buf,0,DDNS_BUFSIZE);
    n =recv(sockd,ddns_buf,DDNS_BUFSIZE,0);
    if ((0 > n) || (n >= DDNS_BUFSIZE))
    {
        ERROR("Receive data ack error.\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }
    memcpy((struct xSoDat *)&ddns_sodp,(struct xSoDat *)ddns_buf,n);
    
    #if DEBUG
    for (i = 0; i < n; i++)
    {
        if (i % 6 == 0)
        {
            TRACE("\n");
        }
        TRACE("buf[%d] = %x",i,ddns_buf[i]);
    }
    #endif
    
    if ((DDNS_ACK_CMD == (ddns_sodp.Command & 0xff)) && 
        (DDNS_SEND_FINISH == (ddns_sodp.Params[0] & 0xff)) &&
        (DDNS_RECV_DATA_OK == (ddns_sodp.Params[4] & 0xff)))
    {
        #if DEBUG
        TRACE("Add DDNS node successed!\n\n");
        #endif
    }
    else 
    {
        if (DDNS_UNKNOWN_ERROR == (ddns_sodp.Params[4] & 0xff))
        {       
            ERROR("Unknown error!\n");
            close(sockd);
            return DDNS_ERR_NET_FAILUR;
        }
        else
        {
            ERROR("Add DDNS node failed!\n");
            close(sockd);
            return DDNS_ERR_NET_FAILUR;
        }
    }

    /* quit socket */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = 0;
    ddns_sodp.Params[0] = DDNS_SEND_QUIT;
    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER,0);
    if (DATA_HEADER != n)
    {
        ERROR("Send error\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    close(sockd);
    return DH_OK;
}

/*
 *functin :  keeplive info to DDNS server 
 *parameter: -
 *description: keeplive info to server
 *use fuction:DDNS_OpenNet,DDNS_GET_CFG,DDNS_Client_Register
 *success return DH_OK
 *fail return DDNS_ERR_NET_FAILUR
 *NO ID return DDNS_NO_ID
 */
ErrorCode_t DDNS_Client_KeepAlive()
{
    struct xSoDat ddns_sodp;
    
    int n = 0;
    int i = 0;
    int sockd = -1;

    /*
    获取配置信息直到成功为止
    */
    DDNS_GetCFG_UntilSuccess();
    
    /* connect DDNS server */
    for (i = 0; i < DDNS_CONN; i++)
    {
        sockd = DDNS_OpenNet(ddns_temp->serverIp,ddns_temp->serverPort);
        if (0 < sockd)
        {
            break;
        }
        sleep(DDNS_SLEEP_TIME); /*wait 5s & reconnect*/
    }
    
    if (i == DDNS_CONN)
    {
        return DDNS_ERR_NET_FAILUR;
    }
    /*  send active */
    memset((char *)&ddns_sodp,0,sizeof(ddns_sodp));
    ddns_sodp.Command = DDNS_REQ_CMD;
    ddns_sodp.ExtLen = strlen(ddns_temp->hardwareId);
    ddns_sodp.Params[0] = DDNS_SEND_ACTIVE;
    memcpy((char *)&ddns_sodp.ExtDat,ddns_temp->hardwareId,ddns_sodp.ExtLen);

    n = send(sockd,(char *)&ddns_sodp,DATA_HEADER + ddns_sodp.ExtLen,0);
    
    if (DATA_HEADER + ddns_sodp.ExtLen != n)
    {
        ERROR("Send keepActive packet error\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }

    /* recv ack */
    memset(ddns_buf,0,DDNS_BUFSIZE);
    n =recv(sockd,ddns_buf,DDNS_BUFSIZE,0);
    
    if ((0 > n) || (DDNS_BUFSIZE < n))
    {
        ERROR("Receive active ack error.\n");
        close(sockd);
        return DDNS_ERR_NET_FAILUR;
    }


    #if DEBUG
    for (i = 0; i < n; i++)
    {
        if (i % 6 == 0)
        TRACE("\n");
        TRACE("buf[%d] = %x",i,ddns_buf[i]);
    }
    #endif
    memcpy((struct xSoDat *)&ddns_sodp,(struct xSoDat *)ddns_buf,n);
    
    if ((DDNS_ACK_CMD == (ddns_sodp.Command & 0xff)) &&
        (DDNS_SEND_ACTIVE == (ddns_sodp.Params[0] & 0xff)) &&
        (DDNS_ACTIVE_OK == (ddns_sodp.Params[4] & 0xff)))
    {
        #if DEBUG
        TRACE("Add DDNS node successed!\n\n");
        #endif  
    }
    else
    {
        if (DDNS_NO_ID == (ddns_sodp.Params[4] & 0xff))
        {       
            ERROR("Unknown node ID!\n");
            close(sockd);

            /*
            在DDNS 服务器上进行注册直到成功为止
            */
            DDNS_ClientRegister_UntilSuccess();
            
            return DH_OK;
        }
        else
        {
            ERROR("Add DDNS node failed!\n");
            close(sockd);
            return DDNS_ERR_NET_FAILUR;
        }
    }
    
    close(sockd);
    return DH_OK;
}

/*
获取配置信息直到成功为止
*/
void DDNS_GetCFG_UntilSuccess(void)
{
    int iErrCode = DH_OK;
    
    /* 获取配置信息 */
    while (1)
    {
        iErrCode = DDNS_GET_CFG();
        if ( DH_OK != iErrCode )
        {
            printf("DDNS Client Get confige failed, status = %d\n", iErrCode);
            sleep(DDNS_SLEEP_TIME*DDNS_SLEEP_TIME);
        }
        else
        {
            printf("DDNS Client Get confige successed, status = %d\n", iErrCode);
            return;
        }
    }

    return;
}

/*
在DDNS 服务器上进行注册直到成功为止
*/
void DDNS_ClientRegister_UntilSuccess(void)
{
    int iErrCode = DH_OK;
    
    /* 在DDNS 服务器上进行注册 */
    while (1)
    {
        iErrCode = DDNS_Client_Register();
        if ( DH_OK != iErrCode )
        {
            printf("DDNS Client register failed, status = %d\n", iErrCode);
            sleep(DDNS_SLEEP_TIME);
        }
        else
        {
            printf("DDNS Client register successed, status = %d\n", iErrCode);
            return;
        }
    }

    return;
}

/*
在DDNS 服务器上进行保活，保活125s后如果还没保活退出，否则保活成功
*/
void DDNS_TimeKeephandle(void)
{
    int status = 0;
	int iCount = 0;
   
	while ( 1 )
	{
		status = DDNS_Client_KeepAlive();
	
		if (DH_OK != status)
		{
			printf("DDNS Client KeepAlive failed, status = %d\n", status);
			sleep(DDNS_SLEEP_TIME);
			iCount ++;
			if (DDNS_SLEEP_TIME*DDNS_SLEEP_TIME == iCount)
			{
				return;
			}
		}
		else
		{
			printf("DDNS Client KeepAlive successed, status = %d\n", status);
			return;
		}
	}
}