/**************************************************************** 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_LocalSendData Description : send data to local io. return : NULL Add 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_ExtractOnePacket Description : extract one packet from local cycle buf, and put data into buf.Will change pos_start buf : dest buf return : >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_Config Description : GAgent clean the device config pgc : global staruc return : NULL Add 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]; }