自学教程：C++ GAgent_Printf函数代码示例

/****************************************************************        Function        :   Cloud_InitSocket        Description     :   init socket connect to server.        iSocketId       :   socketid.        p_szServerIPAddr:   server ip address like "192.168.1.1"        port            :   server socket port.        flag            :   =0 init socket in no block.                            =1 init socket in block.        return          :   >0 the cloud socket id                             <=0 fail.****************************************************************/int32 Cloud_InitSocket( int32 iSocketId,int8 *p_szServerIPAddr,int32 port,int8 flag ){    int32 ret=0;    ret = strlen( p_szServerIPAddr );        if( ret<=0 || ret> 17 )        return RET_FAILED;    GAgent_Printf(GAGENT_DEBUG,"socket connect cloud ip:%s .",p_szServerIPAddr);    if( iSocketId > 0 )    {        GAgent_Printf(GAGENT_DEBUG, "Cloud socket need to close SocketID:[%d]", iSocketId );        close( iSocketId );        iSocketId = INVALID_SOCKET;    }    if( (iSocketId = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))<=0)    {        GAgent_Printf(GAGENT_ERROR," Cloud socket init fail");        return RET_FAILED;    }    GAgent_Printf(GAGENT_DEBUG, "New cloud socketID [%d]",iSocketId);    ret = GAgent_connect( iSocketId, port, p_szServerIPAddr,flag );    if ( RET_SUCCESS!=ret )    {        close(iSocketId);        iSocketId=INVALID_SOCKET;        GAgent_Printf(GAGENT_ERROR, "Cloud socket connect fail with:%d", ret);        return -3;    }    return iSocketId;}

int GAgent_GetHostByName(char *domain, char *IPAddress){    unsigned char Err;    ip_addr_t ip_addr;    char str[32];    memset(str, 0x0, sizeof(str));    switch (dns_gethostbyname(domain, &ip_addr, Gagent_ServerFound, NULL)) {        case ERR_OK:			memcpy((unsigned char*)IPAddress, (unsigned char*)inet_ntoa(ip_addr.addr), strlen(inet_ntoa(ip_addr.addr)) + 1);        	GAgent_Printf(GAGENT_LOG, "ok Server name %s, first address: %s",                 domain, inet_ntoa(domain_ipaddr.addr));			return 0;        case ERR_INPROGRESS:            GAgent_Printf(GAGENT_LOG, "dns_gethostbyname called back success./n/r");			/* Waiting for connect success */		    OSSemPend(pdomainSem, 1000, &Err);				    if (domain_flag == 1) {		        memcpy((unsigned char*)IPAddress, (unsigned char*)inet_ntoa(domain_ipaddr.addr), strlen(inet_ntoa(domain_ipaddr.addr)) + 1);		        GAgent_Printf(GAGENT_LOG, "call back Server name %s, first address: %s", 		                domain, inet_ntoa(domain_ipaddr.addr));				return 0;		    } else {		        return -1;		    }            break;        default:            GAgent_Printf(GAGENT_LOG, "dns_gethostbyname called back error./n/r");            return -1;    }}

int Socket_CreateUDPServer(int udp_port){    struct sockaddr_in addr;    if (g_UDPServerFd == -1)     {        g_UDPServerFd = socket(AF_INET, SOCK_DGRAM, 0);        if (g_UDPServerFd < 1)        {            GAgent_Printf(GAGENT_DEBUG, "UDPServer socket create error,errno:%d", errno);            g_UDPServerFd = -1;            return -1;        }        memset(&addr, 0x0, sizeof(addr));        addr.sin_family = AF_INET;        addr.sin_port = htons(udp_port);        addr.sin_addr.s_addr = INADDR_ANY;        if (bind(g_UDPServerFd, (struct sockaddr *)&addr, sizeof(addr)) != 0)        {            GAgent_Printf(GAGENT_DEBUG, "UDPServer socket bind error,errno:%d", errno);            close(g_UDPServerFd);            g_UDPServerFd = -1;            return -1;        }    }    GAgent_Printf(GAGENT_DEBUG, "UDP Server socketid:%d on port:%d", g_UDPServerFd, udp_port);    return 0;}

int32 Http_POST( int32 socketid, const int8 *host,const int8 *passcode,const int8 *mac,const uint8 *product_key ){    int32 ret=0;    uint8 *postBuf=NULL;    int8 *url = "/dev/devices";     int8 Content[100]={0};    int32 ContentLen=0;    int32 totalLen=0;    //int8 *contentType="application/x-www-form-urlencoded";        postBuf = (uint8*)malloc(400);    if (postBuf==NULL) return 1;    //g_globalvar.http_sockettype =HTTP_GET_DID;//http_sockettype=1 :http_post type.    sprintf(Content,"passcode=%s&mac=%s&product_key=%s",passcode,mac,product_key);    ContentLen=strlen(Content);    snprintf( postBuf,400,"%s %s %s%s%s %s%s%s %d%s%s%s%s%s",              "POST" ,url,"HTTP/1.1",kCRLFNewLine,              "Host:",host,kCRLFNewLine,              "Content-Length:",ContentLen,kCRLFNewLine,              "Content-Type: application/x-www-form-urlencoded",kCRLFNewLine,              kCRLFNewLine,              Content        );    totalLen = strlen( postBuf );    GAgent_Printf(GAGENT_DEBUG,"http_post:%s %d",postBuf,totalLen);        ret = send( socketid,postBuf,totalLen,0 );    GAgent_Printf(GAGENT_DEBUG,"http_post ret: %d",ret);        free( postBuf );    return 0;}

int Socket_CreateUDPBroadCastServer( int udp_port ){    int udpbufsize = 2;    if ( g_UDPBroadcastServerFd == -1 )    {        g_UDPBroadcastServerFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);        if (g_UDPBroadcastServerFd < 0)        {            GAgent_Printf(GAGENT_DEBUG, "UDP BC socket create error, errno:%d", errno);            g_UDPBroadcastServerFd = -1;            return -1;        }        g_stUDPBroadcastAddr.sin_family = AF_INET;        g_stUDPBroadcastAddr.sin_port = htons(udp_port);        g_stUDPBroadcastAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);        if (setsockopt(g_UDPBroadcastServerFd, SOL_SOCKET, SO_BROADCAST, &udpbufsize, sizeof(int)) != 0)        {            GAgent_Printf(GAGENT_DEBUG, "UDP BC Server setsockopt error,errno:%d", errno);            //return;        }        if (bind(g_UDPBroadcastServerFd, (struct sockaddr *)&g_stUDPBroadcastAddr, sizeof(g_stUDPBroadcastAddr)) != 0)        {            GAgent_Printf(GAGENT_DEBUG, "UDP BC Server bind error,errno:%d", errno);            close(g_UDPBroadcastServerFd);            g_UDPBroadcastServerFd = -1;            return -1;        }    }    GAgent_Printf(GAGENT_DEBUG, "UDP BC Server socketid:%d on port:%d", g_UDPBroadcastServerFd, udp_port);    return 0;}

int GAgent_Socket_DispatchUDPRecvData( u8 *pData, int varlen, int messagelen, struct sockaddr_t addr, socklen_t addrLen){    int ret;    u8 Udp_ReDiscover[200] =  {0};    char Udp_ReOnBoarding[8] = {0x00,0x00,0x00,0x03,0x03,0x00,0x00,0x02};    if( pData[7]==0x01 )//OnBoarding    {        GAgent_Printf(GAGENT_INFO,"OnBoarding");        Udp_Onboarding(pData,messagelen);        GAgent_Socket_sendto(g_GAgent_UDPServerFd, Udp_ReOnBoarding, 8, &addr, sizeof(struct sockaddr_t));        DRV_GAgent_Reset();        return 0;    }    if( pData[7]==0x03 ) //Ondiscover    {        GAgent_Printf(GAGENT_INFO,"Ondiscover");        GAgent_Build_BroadCastPacket( 0, Udp_ReDiscover );        ret = GAgent_Socket_sendto(g_GAgent_UDPServerFd, Udp_ReDiscover,Udp_ReDiscover[4]+5, &addr, sizeof(struct sockaddr_t));        if(ret != Udp_ReDiscover[4]+5)        {            GAgent_Printf(GAGENT_ERROR,"send discover response fail.ret:0x%x", ret);        }        return 0;    }    GAgent_Printf(GAGENT_WARNING,"invalid udp packet [%d]", pData[7]);    return -1;}

/************************************************* * *		Function : check mqtt witch qos 1 *		packet_bufferBUF: MQTT receive data *		packet_length :	the packet length  *   add by Ale lin  2014-04-03 *		 ***************************************************/int check_mqttpushqos1( uint8_t *packet_bufferBUF,int packet_length, uint16_t msg_id ){    uint16_t msg_id_rcv;    uint8_t *packet_buffer=NULL;    packet_buffer = ( uint8_t* )malloc(packet_length);    memset( packet_buffer,0,packet_length);    memcpy( packet_buffer,packet_bufferBUF,packet_length);    if(packet_length < 0)    {        GAgent_Printf(GAGENT_INFO,"Error on read packet!");	        free(packet_buffer);        return -1;    }    if(MQTTParseMessageType(packet_buffer) != MQTT_MSG_PUBACK)    {        GAgent_Printf(GAGENT_INFO,"PUBACK expected!");        free(packet_buffer);        return -1;						    }    msg_id_rcv = mqtt_parse_msg_id(packet_buffer);    if(msg_id != msg_id_rcv)    {        GAgent_Printf(GAGENT_INFO," message id was expected, but message id was found!");        free(packet_buffer);        return -1;    }			    free(packet_buffer);						    GAgent_Printf(GAGENT_INFO,"check_mqttpushqos1 OK");        return 1;														}

/*********************************************************** * *   return :    0 success ,1 error * *************************************************************/int32 Mqtt_SendConnetPacket( mqtt_broker_handle_t *pstBroketHandle, int32 socketid,const int8* username,const int8* password ){           int32 ret;        if( (username==NULL) || (password==NULL) )// 匿名登录 GAgent V4 will not runing this code.    {        return 1;    }    else // 用户登录    {        mqtt_init( pstBroketHandle,username );        mqtt_init_auth(pstBroketHandle,username,password );    }    mqtt_set_alive(pstBroketHandle, CLOUD_MQTT_SET_ALIVE);    pstBroketHandle->socketid = socketid;    pstBroketHandle->mqttsend = send_packet;    ret = mqtt_connect(pstBroketHandle);    if (ret != 0)        {            GAgent_Printf(GAGENT_WARNING,"mqtt send connect packet is failed with:%d", ret);             return 1;        }    GAgent_Printf(GAGENT_INFO, "Mqtt_SendConnetPacket OK, write:%d", ret);     return 0;}

/****************************************************** * *   FUNCTION       :   get the uuid by productkey in HTTP GET *      productkey  :   productkey *      host        :   host *      return      :   0-OK 1-fail *   Add by Alex lin  --2014-11-10 * ********************************************************/int32 Http_JD_Get_uuid_req( const int8 *host,const int8 *product_key ){    int8 *getBuf=NULL;    int32 totalLen=0;    int32 ret=0;    int8 *url = "/dev/jd/product/";        if( strlen(product_key)<=0 )    {           GAgent_Printf(GAGENT_ERROR,"need a productkey to get uuid! ");        return 1;    }    getBuf = (int8*)malloc(500);    if (getBuf==NULL)  return 1;    memset( getBuf,0,500 );     //g_globalvar.http_sockettype =HTTP_GET_JD_UUID;//http get product_uuid for JD.    sprintf( getBuf,"%s %s%s%s%s%s%s%s%s%s",             "GET",url,product_key," HTTP/1.1",kCRLFNewLine,             "Host: ",host,kCRLFNewLine,             "Cache-Control: no-cache",kCRLFLineEnding );    totalLen =strlen( getBuf );    GAgent_Printf(GAGENT_DEBUG,"totalLen=%d/r/n",totalLen);    GAgent_Printf(GAGENT_DEBUG,"Sent Http to get JD uuid./n");    GAgent_Printf(GAGENT_DUMP,"%s",getBuf );    free(getBuf);       if(ret>0) return 0;     else    return 1;}

int32 Mqtt_Login2Server(  int32 socketid,const uint8 *username,const uint8 *password ){    if( Mqtt_SendConnetPacket( &g_stMQTTBroker,socketid,(const int8*)username,(const int8*)password ) == 0)    {            GAgent_Printf(GAGENT_INFO," Mqtt_SendConnetPacket OK!");        return 0;    }       GAgent_Printf(GAGENT_INFO," Mqtt_SendConnetPacket NO!");            return 1;}

void debugpacket(ppacket pp){    if(pp->pend < pp->ppayload)    {        GAgent_Printf(GAGENT_DEBUG, "Wrong packet to dump");        return;    }    GAgent_Printf(GAGENT_DEBUG, "Packet info: len = %x, head len = %x, payload len = %x",                  pp->pend - pp->phead, pp->ppayload - pp->phead, pp->pend - pp->ppayload);    GAgent_DebugPacket(pp->phead, pp->pend - pp->phead);}

/****************************************************************FunctionName    :   GAgent_LocalSendDataDescription     :   send data to local io.return          :   NULLAdd by Alex.lin     --2015-04-07****************************************************************/uint32 Local_SendData( int32 fd,uint8 *pData, int32 bufferMaxLen ){    int32 i=0;    if( PF_SendData2MCU!=NULL )    {        GAgent_Printf( GAGENT_DUMP,"local send len = %d:/r/n",bufferMaxLen );        for( i=0;i<bufferMaxLen;i++ )            GAgent_Printf( GAGENT_DUMP," %02x",pData[i]);        GAgent_Printf( GAGENT_DUMP,"/r/n");        PF_SendData2MCU( fd,pData,bufferMaxLen );    }    return 0;}

int GAgent_Socket_CheckNewTCPClient(void){    fd_set readfds, exceptfds;    int ret;    int newClientfd;    int i;    struct sockaddr_t addr;	struct timeval_t t;    int addrlen= sizeof(addr);    t.tv_sec = 0;//秒    t.tv_usec = 0;//微秒    /*Check status on erery sockets */    FD_ZERO(&readfds);    FD_SET(g_GAgent_TCPServerFd, &readfds);    ret = select((g_GAgent_TCPServerFd+1), &readfds, NULL, &exceptfds, &t);    if (ret > 0)    {        newClientfd = GAgent_Socket_accept(g_GAgent_TCPServerFd, &addr, &addrlen);        GAgent_Printf(GAGENT_DEBUG, "detected new client as %d", newClientfd);        if (newClientfd > 0)        {            if(g_GAgent_TCPSocketMaxClientFd<newClientfd)            {                g_GAgent_TCPSocketMaxClientFd=(newClientfd+1); /*Select接口要求+1*/            }            for(i=0;i<SOCKET_MAXTCPCLENT;i++)             {                if (g_GAgent_stTCPSocketClients[i].SocketFD == -1)                 {                    memcpy(&g_GAgent_stTCPSocketClients[i].TCPClientAddr, &addr, sizeof(addr));                    g_GAgent_stTCPSocketClients[i].SocketFD = newClientfd;                    g_GAgent_stTCPSocketClients[i].TimeOut = LAN_CLIENT_MAXLIVETIME;                    GAgent_Printf(GAGENT_INFO, "new tcp client, clientid:%d[%d] [time:%08x second: %08x MS]",                         newClientfd, i, DRV_GAgent_GetTime_S(), DRV_GAgent_GetTime_MS() );                                        return newClientfd; //返回连接ID                }            }            /*此时连接个数大于系统定义的最大个数,应该关闭释放掉对应的socket资源*/                       close( newClientfd );        }        else        {            GAgent_Printf(GAGENT_DEBUG, "Failed to accept client");        }    }    return -1;}

void Gagent_ServerFound(const char *name, ip_addr_t *ipaddr, void *arg){    if ((ipaddr) && (ipaddr->addr)) {        memcpy(&domain_ipaddr, ipaddr, sizeof(ip_addr_t));        domain_flag = 1;        GAgent_Printf(GAGENT_LOG, "Get DNS server ip success./n/r");    } else {        domain_flag = 0;        GAgent_Printf(GAGENT_LOG, "Get DNS server ip error./n/r");        }    OSSemPost(pdomainSem);}

/****************************************************************FunctionName    :   GAgent_Local_ExtractOnePacketDescription     :   extract one packet from local cycle buf, and                     put data into buf.Will change pos_startbuf             :   dest bufreturn          :   >0 the local packet data length.                    <0 don't have one whole packet data****************************************************************/int32 GAgent_Local_ExtractOnePacket(uint8 *buf){    int32 ret;    uint32 i;    uint16 packetLen;    if(NULL == buf)    {        GAgent_Printf(GAGENT_WARNING,"%s,%d,Input buf is NULL", __FUNCTION__, __LINE__);        return RET_FAILED;    }    /* find one packet data form position pos_start of local driver buf */    ret = find_packet_forward(pos_start, &packetLen);    if(ret >= 0)    {        /* a whole packet */        pos_start = ret;        for(i = 0; i < packetLen; i++)        {            buf[i] = __halbuf_read(pos_start + i);        }        pos_start += packetLen;                return packetLen;    }    return RET_FAILED;}

int32 MQTT_readPacket( int32 socketid,ppacket pbuf,int32 bufferLen ){    int32 bytes_rcvd;    uint8_t *pData;    int32 messageLen;    int32 varLen;    int32 packet_length;    memset(pbuf->phead, 0, bufferLen);    pData = pbuf->phead;    bytes_rcvd = recv(socketid, pData , bufferLen, 0);    if((bytes_rcvd) <= 0)    {        MQTTclose_socket( &g_stMQTTBroker );        return -1;    }    //pData = packetBuffer + 0;    pbuf->pend=pbuf->phead+bytes_rcvd;        messageLen = mqtt_parse_rem_len(pData);    varLen = mqtt_num_rem_len_bytes(pData);    if(varLen<1 || varLen>4)    {         return -3;    }    packet_length = varLen + messageLen + 1;    if (bytes_rcvd < packet_length)    {        GAgent_Printf(GAGENT_INFO, " packet length too long %s:%d ", __FUNCTION__, __LINE__);        return -3;    }       return bytes_rcvd;}

void GAgent_Socket_ClientTimeoutTimer(void){    int i,j;    for (i = 0; i < SOCKET_MAXTCPCLENT; i++)    {        if (g_GAgent_stTCPSocketClients[i].TimeOut > 0)        {            g_GAgent_stTCPSocketClients[i].TimeOut --;                        if (g_GAgent_stTCPSocketClients[i].TimeOut ==0)            {                GAgent_Printf(GAGENT_DEBUG,                     "Close socket(%d) now[time:%08x second: %08x MS] ",                 g_GAgent_stTCPSocketClients[i].SocketFD, DRV_GAgent_GetTime_S(),                 DRV_GAgent_GetTime_MS());                close(g_GAgent_stTCPSocketClients[i].SocketFD);								for( j=0;j<8;j++ )								{										if(g_SocketLogin[j]==g_GAgent_stTCPSocketClients[i].SocketFD)											g_SocketLogin[j]=0;								}                g_GAgent_stTCPSocketClients[i].SocketFD = -1;								            }        }    }    return;}

/****************************************************************FunctionName    :   GAgent_Clean_ConfigDescription     :   GAgent clean the device config                  pgc             :   global staruc return          :   NULLAdd by Frank Liu     --2015-05-08****************************************************************/void GAgent_Clean_Config( pgcontext pgc ){    memset( pgc->gc.old_did,0,DID_LEN);    memset( pgc->gc.old_wifipasscode,0,PASSCODE_MAXLEN + 1);      memcpy( pgc->gc.old_did,pgc->gc.DID,DID_LEN );    memcpy( pgc->gc.old_wifipasscode,pgc->gc.wifipasscode,PASSCODE_MAXLEN + 1 );    GAgent_Printf(GAGENT_INFO,"Reset GAgent and goto Disable Device !");      Cloud_ReqDisable( pgc );    GAgent_SetCloudConfigStatus( pgc,CLOUD_RES_DISABLE_DID );    memset( pgc->gc.wifipasscode,0,PASSCODE_MAXLEN + 1);    memset( pgc->gc.wifi_ssid,0,SSID_LEN_MAX + 1 );    memset( pgc->gc.wifi_key,0, WIFIKEY_LEN_MAX + 1 );    memset( pgc->gc.DID,0,DID_LEN);        memset( (uint8*)&(pgc->gc.cloud3info),0,sizeof( GAgent3Cloud ) );        memset( pgc->gc.GServer_ip,0,IP_LEN_MAX + 1);    memset( pgc->gc.m2m_ip,0,IP_LEN_MAX + 1);    make_rand(pgc->gc.wifipasscode);    pgc->gc.flag &=~XPG_CFG_FLAG_CONNECTED;    GAgent_DevSaveConfigData( &(pgc->gc) );}

/****************************************************************        FunctionName        :   GAgent_LocalSendGAgentstatus.        Description         :   check Gagent's status whether it is update.        Add by Nik.chen     --2015-04-18****************************************************************/void GAgent_LocalSendGAgentstatus(pgcontext pgc,uint32 dTime_s ){    uint16 GAgentStatus = 0;     uint16 LastGAgentStatus = 0;     resetPacket( pgc->rtinfo.Rxbuf );    if( (pgc->rtinfo.GAgentStatus) != (pgc->rtinfo.lastGAgentStatus) )    {          GAgentStatus = pgc->rtinfo.GAgentStatus&LOCAL_GAGENTSTATUS_MASK;          LastGAgentStatus = pgc->rtinfo.lastGAgentStatus&LOCAL_GAGENTSTATUS_MASK;          GAgent_Printf( GAGENT_INFO,"GAgentStatus change, lastGAgentStatus=0x%04x, newGAgentStatus=0x%04x", LastGAgentStatus, GAgentStatus);          pgc->rtinfo.lastGAgentStatus = pgc->rtinfo.GAgentStatus&LOCAL_GAGENTSTATUS_MASK;          GAgentStatus = htons(GAgentStatus);          memcpy((pgc->rtinfo.Rxbuf->ppayload), (uint8 *)&GAgentStatus, 2);          pgc->rtinfo.Rxbuf->pend =  (pgc->rtinfo.Rxbuf->ppayload)+2;          pgc->rtinfo.updatestatusinterval =  0;           //GAgent_Printf(GAGENT_CRITICAL,"updateGagentstatusLast time=%d", (pgc->rtinfo.send2LocalLastTime));         GAgent_LocalDataWriteP0( pgc,pgc->rtinfo.local.uart_fd, (pgc->rtinfo.Rxbuf), WIFI_STATUS2MCU );    }     pgc->rtinfo.updatestatusinterval+= dTime_s;    if( (pgc->rtinfo.updatestatusinterval)  > LOCAL_GAGENTSTATUS_INTERVAL)    {        pgc->rtinfo.updatestatusinterval = 0;        GAgentStatus = pgc->rtinfo.GAgentStatus&LOCAL_GAGENTSTATUS_MASK;        GAgentStatus = htons(GAgentStatus);        memcpy((pgc->rtinfo.Rxbuf->ppayload), (uint8 *)&GAgentStatus, 2);        pgc->rtinfo.Rxbuf->pend =  (pgc->rtinfo.Rxbuf->ppayload)+2;        GAgent_LocalDataWriteP0( pgc,pgc->rtinfo.local.uart_fd, (pgc->rtinfo.Rxbuf), WIFI_STATUS2MCU );    }}

int send_packet(int socketid, const void* buf, unsigned int count){    int ret;    ret = send(socketid, buf, count, 0);    GAgent_Printf(GAGENT_INFO,"MQTT Send packet length=%d",ret );    return ret;}

/*****************************************************************       FunctionName    :   send_broadCastPacket*       Description     :   Send BroadCast data.*       Add by Frank Liu   --2015-04-14****************************************************************/void send_broadCastPacket(pgcontext pgc,uint8* ptxBuf,uint16 cmdWord){    int32 ret = 0;    int32 len = 0;    struct sockaddr_t addr;    memset(&addr,0,sizeof(addr));        resetPacket(pgc->rtinfo.Rxbuf);    addr = pgc->ls.addr;    if(NULL == ptxBuf)    {        return;    }    ret = combination_broadcast_packet(pgc,ptxBuf,cmdWord);    if((RET_SUCCESS == ret) && (INVALID_SOCKET != pgc->ls.udpBroadCastServerFd))    {        len = ptxBuf[4] + LAN_PROTOCOL_HEAD_LEN + 1;        ret = Socket_sendto(pgc->ls.udpBroadCastServerFd,ptxBuf,len,&addr,sizeof(addr));        GAgent_Printf( GAGENT_INFO,"Send BroadCast datalen=%d cmd=%04X ret :%d",len,cmdWord,ret );    }    return ;}

void GAgent_Timer(){    int i;    for (i = 0; i < GAGENT_MAXTIMER; i++)    {        if (g_stCoreGAgentTimer[i].flag != 0)        {            g_stCoreGAgentTimer[i].nextSeconds --;            if (g_stCoreGAgentTimer[i].nextSeconds == 0)            {                g_stCoreGAgentTimer[i].pfFunc();                if (GAGENT_TIMER_CLOCK == g_stCoreGAgentTimer[i].flag)                {                    GAgent_Printf(GAGENT_DEBUG,"delete timerid:%d , flag:%d, second:%d",                             i, g_stCoreGAgentTimer[i].flag, g_stCoreGAgentTimer[i].initSecods);                    g_stCoreGAgentTimer[i].flag = 0;                     g_stCoreGAgentTimer[i].initSecods = 0;                }                else                {                    g_stCoreGAgentTimer[i].nextSeconds = g_stCoreGAgentTimer[i].initSecods;                    }            }        }    }    return;}

// Use?int check_mqttconnect( uint8_t *packet_buffer,int packet_length ){    if(packet_length < 0)    {        GAgent_Printf(GAGENT_INFO,"Error on read packet!");	        return 1;    }    if(packet_buffer[3] != 0x00)    {        GAgent_Printf(GAGENT_INFO,"check_mqttconnect CONNACK failed![%d]", packet_buffer[3]);							        return 3;    }    return 0;}

int32 Http_GET( const int8 *host,const int8 *did,int32 socketid ){    static int8 *getBuf=NULL;    int32 totalLen=0;    int32 ret=0;    int8 *url = "/dev/devices/";    getBuf = (int8*)malloc( 200 );    if(getBuf == NULL)    {        return 1;    }    memset( getBuf,0,200 );    //g_globalvar.http_sockettype =HTTP_PROVISION;//http get type.    snprintf( getBuf,200,"%s %s%s %s%s%s %s%s%s%s%s",              "GET",url,did,"HTTP/1.1",kCRLFNewLine,              "Host:",host,kCRLFNewLine              "Cache-Control: no-cache",kCRLFNewLine,              "Content-Type: application/x-www-form-urlencoded",kCRLFLineEnding);    totalLen =strlen( getBuf );    ret = send( socketid, getBuf,totalLen,0 );    GAgent_Printf(GAGENT_DEBUG,"Sent provision:/n %s/n", getBuf);    free(getBuf);    getBuf = NULL;    if(ret<=0 )     {        return 1;    }    else    {        return 0;    }    }

int GAgent_CreateTimer(int flag, unsigned long ms, void (*pTimerHandler)(void)) {    int seconds = (ms+900)/1000;    int i;    if ((flag != GAGENT_TIMER_PERIOD) && (flag != GAGENT_TIMER_CLOCK))    {        return -1;    }    for (i = 0; i < GAGENT_MAXTIMER; i++)    {        if (g_stCoreGAgentTimer[i].flag == 0)        {            g_stCoreGAgentTimer[i].flag = flag;            g_stCoreGAgentTimer[i].nextSeconds = seconds;            g_stCoreGAgentTimer[i].initSecods = seconds;            g_stCoreGAgentTimer[i].pfFunc = pTimerHandler;            GAgent_Printf(GAGENT_DEBUG,"create timerid:%d , flag:%d, second:%d", i, flag, seconds);            return i;        }    }    return -1;}

/****************************************************************        FunctionName        :   GAgent_CloudTick.        Description         :   GAgent Send cloud heartbeat to cloud                                when mqttstatus is MQTT_STATUS_RUNNING        Add by Alex.lin     --2015-03-10****************************************************************/void GAgent_CloudTick( pgcontext pgc ){    uint32 cTime=0,dTime=0;    if( pgc->rtinfo.waninfo.mqttstatus != MQTT_STATUS_RUNNING )        return;        cTime = GAgent_GetDevTime_MS();    dTime = abs(cTime - pgc->rtinfo.waninfo.send2MqttLastTime );        if( dTime < CLOUD_HEARTBEAT )        return ;        if(pgc->rtinfo.waninfo.cloudPingTime > 2 )    {        ERRORCODE        pgc->rtinfo.waninfo.cloudPingTime=0;        GAgent_SetCloudServerStatus( pgc,MQTT_STATUS_START );        GAgent_SetWiFiStatus( pgc,WIFI_CLOUD_STATUS,1 );    }    else    {        MQTT_HeartbeatTime();        pgc->rtinfo.waninfo.cloudPingTime++;        GAgent_Printf(GAGENT_INFO,"GAgent MQTT Ping ...");    }    pgc->rtinfo.waninfo.send2MqttLastTime = GAgent_GetDevTime_MS();}

int8 dealPacket( pgcontext pgc, ppacket pTxBuf ){    GAgent_Printf(GAGENT_DEBUG,"/r/n");    GAgent_Printf(GAGENT_DEBUG,"IN %s packet type : %04x",__FUNCTION__ ,pTxBuf->type );    if( ((pTxBuf->type)&(LOCAL_DATA_OUT)) == LOCAL_DATA_OUT )    {        GAgent_Printf( GAGENT_DEBUG,"packet Type : LOCAL_DATA_OUT ");        GAgent_LocalDataWriteP0( pgc,pgc->rtinfo.local.uart_fd, pTxBuf,MCU_CTRL_CMD );        GAgent_Printf( GAGENT_DEBUG,"ReSetpacket Type : LOCAL_DATA_OUT ");        pTxBuf->type = SetPacketType(pTxBuf->type, LOCAL_DATA_OUT, 0);    }    if( ((pTxBuf->type)&(CLOUD_DATA_OUT)) == CLOUD_DATA_OUT )    {        if( ((pgc->rtinfo.GAgentStatus)&WIFI_CLOUD_CONNECTED)  == WIFI_CLOUD_CONNECTED )        {            GAgent_Printf( GAGENT_DEBUG,"packet Type : CLOUD_DATA_OUT ");            GAgent_Cloud_SendData(  pgc,pTxBuf,(pTxBuf->pend)-(pTxBuf->ppayload) );            GAgent_Printf( GAGENT_DEBUG,"ReSetpacket Type : CLOUD_DATA_OUT ");        }        pTxBuf->type = SetPacketType(pTxBuf->type, CLOUD_DATA_OUT, 0);    }    if( ((pTxBuf->type)&(LAN_TCP_DATA_OUT)) == LAN_TCP_DATA_OUT )    {        GAgent_Lan_SendTcpData(pgc, pTxBuf);        pTxBuf->type = SetPacketType(pTxBuf->type, LAN_TCP_DATA_OUT, 0);    }    GAgent_Printf( GAGENT_DEBUG,"OUT packet type : %04X/r/n",pTxBuf->type );    return 0;}

void GAgent_DebugV4Packet(int flag, unsigned char *packet, int packetLen){    if (flag == GAGENT_DEBUG_PACKET_SEND2MCU)    {        GAgent_Printf(GAGENT_DEBUG_PACKET,                "Send to MCU Packet, SN:%d, CMD:%d, Len:%d",                packet[MCU_SN_POS], packet[MCU_CMD_POS], packetLen);    }}

/****************************************************************        FunctionName        :   GAgent_LANInit.        Description         :   init clients socket and create tcp/udp server.        Add by Will.zhou     --2015-03-10****************************************************************/void GAgent_LANInit(pgcontext pgc){    LAN_tcpClientInit(pgc);    LAN_InitSocket(pgc);      GAgent_SetWiFiStatus( pgc,WIFI_MODE_BINDING,1 );  //enable Bind    pgc->ls.broResourceNum = 0;//enable public broadcast resource    GAgent_SetWiFiStatus( pgc,WIFI_CLIENT_ON,0 );        GAgent_Printf( GAGENT_DEBUG,"file:%s function:%s line:%d ",__FILE__,__FUNCTION__,__LINE__ );}

/****************************************************************        Function    :   Cloud_ResConnect        Description :   handle packet form mqtt req connect         buf         :   data form mqtt.        return      :   0: req connect ok                        other req connect fail.        Add by Alex.lin     --2015-03-09****************************************************************/uint32 Cloud_ResConnect( uint8* buf ){    int32 i=0;    if( buf[3] == 0x00 )    {        if( (buf[0]!=0) && (buf[1] !=0) )        {        return 0;        }        else        {            GAgent_Printf( GAGENT_ERROR,"%s %s %d",__FILE__,__FUNCTION__,__LINE__ );            GAgent_Printf( GAGENT_ERROR,"MQTT Connect res  fail ret =%d!!",buf[3] );            return 1;        }    }    GAgent_Printf( GAGENT_ERROR,"res connect fail with %d ",buf[3] );        return buf[3];}