/* * Function: _wilddog_recv_dispatch. * Description: recv coap packet and handle it. * * Input: p_recvPdu : point to the recv coap packet. * p_cm_recvArg: recv arg that will transmit to cm port. * Output: N/A. * Return: N/A. */ Wilddog_Return_T WD_SYSTEM _wilddog_recv_dispatch ( coap_pdu_t *p_recvPdu, Protocol_recvArg_T *p_cm_recvArg ) { size_t playloadLen =0; u8 *p_payload = NULL; /* get err*/ wilddog_debug_level(WD_DEBUG_LOG," coap err : %d",p_recvPdu->hdr->code); p_cm_recvArg->err = _wilddog_coap_code2Http( \ (unsigned int)_GET_COAP_CODE(p_recvPdu->hdr->code)); wilddog_debug_level(WD_DEBUG_LOG,"coap http error %ld",p_cm_recvArg->err); /* get token option.*/ if(p_recvPdu->hdr->token_length != COAP_TOKENLEN) return WILDDOG_ERR_INVALID; memcpy(&p_cm_recvArg->d_token,p_recvPdu->hdr->token,COAP_TOKENLEN); /* get observer index.*/ p_cm_recvArg->d_isObserver = _wilddog_recv_getOptionValue(p_recvPdu, COAP_OPTION_OBSERVE, (u8*)&p_cm_recvArg->d_observerIndx, sizeof(p_cm_recvArg->d_observerIndx)); wilddog_debug_level(WD_DEBUG_LOG, \ "coap get observerIndex : %lu ", \ p_cm_recvArg->d_observerIndx); /* get maxage.*/ _wilddog_recv_getOptionValue(p_recvPdu, COAP_OPTION_MAXAGE, \ (u8*)&(p_cm_recvArg->d_maxAge), \ sizeof( p_cm_recvArg->d_maxAge)); wilddog_debug_level(WD_DEBUG_LOG, \ "coap get max-age : %lu ", \ p_cm_recvArg->d_maxAge); /* get blockNum.*/ /*get payload data */ coap_get_data(p_recvPdu,&playloadLen,&p_payload); /* clean buf .*/ memset(p_cm_recvArg->p_recvData,0,(size_t)p_cm_recvArg->d_recvDataLen); if( playloadLen > p_cm_recvArg->d_recvDataLen ) return WILDDOG_ERR_INVALID; memcpy( p_cm_recvArg->p_recvData,p_payload,playloadLen); p_cm_recvArg->d_recvDataLen = playloadLen; wilddog_debug_level(WD_DEBUG_LOG, \ "coap recv data :%s", \ p_cm_recvArg->p_recvData); return WILDDOG_ERR_NOERR; }
/* * Function: wilddog_send * Description: wilddog send function, it use the interface in wiced platform. * Input: socketId: The socket id. * addr_in: The pointer of Wilddog_Address_T * tosend: The pointer of the send buffer * tosendLength: The length of the send buffer. * Output: N/A * Return: If success, return the number of characters sent.; else return -1. */ int wilddog_send ( int socketId, Wilddog_Address_T* addr_in, void* tosend, s32 tosendLength ) { wiced_udp_socket_t* socket = (wiced_udp_socket_t*) socketId; wiced_ip_address_t ipaddr; ipaddr.version = WICED_IPV4; ipaddr.ip.v4 = WILDDOG_MAKE_IPV4(addr_in->ip[0], addr_in->ip[1], \ addr_in->ip[2], addr_in->ip[3]); wiced_packet_t* packet; uint8_t* data; uint16_t aval; if ( wiced_packet_create_udp( socket, 0, &packet, &data, &aval ) != \ WICED_SUCCESS ) { wilddog_debug_level(WD_DEBUG_ERROR, "error create packet ...\r\n"); return -1; } if ( aval < tosendLength ) { /* Delete packet, since the send failed */ wiced_packet_delete( packet ); wilddog_debug_level(WD_DEBUG_ERROR, \ "too large length to translate! should be %d, want send %ld\n", \ aval, tosendLength); return -1; } memcpy( data, tosend, tosendLength ); #if WILDDOG_SELFTEST performtest_getDtlsSendTime(); #endif wiced_packet_set_data_end( packet, (uint8_t*) ( data + tosendLength ) ); wilddog_debug_level(WD_DEBUG_LOG, "socketId = %d, port = %d\n", \ socketId, addr_in->port); if ( wiced_udp_send( socket, &ipaddr, addr_in->port, packet ) != \ WICED_SUCCESS ) { wilddog_debug_level(WD_DEBUG_ERROR, "UDP packet send failed\r\n"); wiced_packet_delete( packet ); } else { wilddog_debug_level(WD_DEBUG_LOG, "send packet success!\n"); return tosendLength; } return -1; }
/* * Function: _wilddog_coap_ackSend. * Description: response an ack . * Input: recv_type: recv type conn or non-con . * ack_type : respond an ack or reset. * mid : recv coap's message id. * tokenLen: recv coap's token len. * recv_token: recv coap's token. * Output: N/A. * Return: N/A. */ STATIC int WD_SYSTEM _wilddog_coap_ackSend ( u32 recv_type, u32 ack_type, u32 mid, u32 tokenLen, u32 recv_token ) { int returnCode= 0; unsigned int id = mid; size_t tkl = tokenLen; unsigned char* p_tk = (unsigned char*)&recv_token; coap_pdu_t *toSend = NULL; /* only con request need tobe respond.*/ if(recv_type != COAP_MESSAGE_CON) return WILDDOG_ERR_NOERR; toSend = coap_pdu_init(ack_type, 0, id,WILDDOG_PROTO_MAXSIZE); coap_add_token(toSend,tkl,p_tk); if (toSend == NULL) { wilddog_debug_level(WD_DEBUG_ERROR,"coap_addToken error"); return WILDDOG_ERR_NULL; } returnCode = _wilddog_sec_send(toSend->hdr,toSend->length); coap_delete_pdu(toSend); return returnCode; }
STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_destory ( void *p_coap, int flag ) { if(p_coap == 0) return WILDDOG_ERR_INVALID; wilddog_debug_level(WD_DEBUG_LOG,"\tcc\tdestory coap pakge :%p :",p_coap); coap_delete_pdu((coap_pdu_t*)p_coap); return WILDDOG_ERR_NOERR; }
/* * Function: _wilddog_url_getChildStr * Description: Create the child path of the source path. * Input: p_src_path: The source path. * childName: child's name or path * Output: N/A * Return: Pointer to the child's path. */ STATIC Wilddog_Str_T * WD_SYSTEM _wilddog_url_getChildStr ( Wilddog_Str_T*p_srcPath, Wilddog_Str_T* childName ) { Wilddog_Str_T *p_path = NULL; int len = 0; int srcLen = 0, childLen = 0; int dstPathLen = 0; if(!childName || !p_srcPath) return NULL; srcLen = strlen((const char*)p_srcPath); childLen = strlen((const char*)childName); if(childLen == 0 || \ (childLen == 1 && childName[0] == '/')) { return NULL; } if(WILDDOG_ERR_NOERR != _wilddogurl_checkPath(childName)) { wilddog_debug_level(WD_DEBUG_ERROR, "check path error!"); return NULL; } len = srcLen + childLen + 3; p_path = (Wilddog_Str_T*)wmalloc(len + 1); if(NULL == p_path) { return NULL; } if(srcLen == 1 && p_srcPath[0] == '/') { snprintf((char*)p_path, len , "/%s", (char*)childName); } else { snprintf((char*)p_path, len , "%s/%s", (char*)p_srcPath, \ (char*)childName); } dstPathLen= strlen((const char *)p_path); p_path[dstPathLen]= 0; return p_path; }
/* * Function: _wilddog_recv_getOptionValue. * Description: parse coap option and get it's value. * * Input: p_recvPdu : point to recv coap packet. * optionCode : option code. * p_dst : buffer that will store the option value. * d_dstSize : p_dst sizeof. * Output: N/A. * Return: N/A. */ BOOL WD_SYSTEM _wilddog_recv_getOptionValue ( coap_pdu_t *p_recvPdu, u32 optionCode, u8 *p_dst, u8 d_dstSize ) { coap_opt_t *p_op =NULL; u8 *p_optionvalue = NULL; u8 d_optionlen = 0; coap_opt_iterator_t d_oi; p_op = coap_check_option(p_recvPdu,optionCode,&d_oi); if(p_op) { d_optionlen = coap_opt_length(p_op); if(d_optionlen && d_optionlen <= d_dstSize) { p_optionvalue = coap_opt_value(p_op); #if WILDDOG_LITTLE_ENDIAN == 1 _sys_coap_ntol((u8*)p_dst,p_optionvalue,d_optionlen); #else memcpy((u8*)p_dst,p_optionvalue,d_optionlen); #endif #if 0 wilddog_debug_level( WD_DEBUG_WARN, \ "option value address = %p ,option len = %d \n",\ p_dst,d_optionlen); #endif return TRUE; } } return FALSE; }
/* * Function: _wilddog_coap_creat * Description: creat an coap package with no option and payload. * Input: p_arg: cmd/message/token/package len. * Output: N/A * Return: coap pointer. */ STATIC size_t WD_SYSTEM _wilddog_coap_creat ( Protocol_Arg_Creat_T *p_arg, int flag ) { coap_pdu_t *p_pdu = NULL; u8 type=0,code = 0; if(p_arg == NULL) return 0; /* get coap type and code.*/ if(_wilddog_coap_cmd2Typecode(p_arg->cmd,&type,&code) < 0) return 0; /*creat an coap package.*/ p_pdu = coap_pdu_init(type,code,p_arg->d_index,p_arg->d_packageLen); if(p_pdu == NULL) return 0; /* add token option.*/ coap_add_token(p_pdu, COAP_TOKENLEN, (u8*)&(p_arg->d_token)); wilddog_debug_level(WD_DEBUG_LOG,"\tcc\tcreat coap pakge :%p :",p_pdu); return ( size_t )p_pdu; }
/* * Function: _wilddog_url_parseUrl * Description: parse url using wilddog format. * Input: url: Input url. * Output: N/A * Return: Pointer to the url structure. */ Wilddog_Url_T * WD_SYSTEM _wilddog_url_parseUrl(Wilddog_Str_T * url) { struct parsed_url * p_paresd_url = NULL; Wilddog_Url_T * p_wd_url = NULL; int len = 2; wilddog_assert(url, NULL); p_paresd_url = parse_url((char*)url); if(NULL == p_paresd_url) return NULL; p_wd_url = (Wilddog_Url_T *)wmalloc(sizeof(Wilddog_Url_T)); if(NULL == p_wd_url) { wilddog_debug_level(WD_DEBUG_ERROR, "cannot malloc p_wd_url!\n"); parsed_url_free(p_paresd_url); return NULL; } if(NULL != p_paresd_url->host) { p_wd_url->p_url_host = (Wilddog_Str_T *)wmalloc( \ strlen(p_paresd_url->host) + 1); if(NULL == p_wd_url->p_url_host) { wilddog_debug_level(WD_DEBUG_ERROR, "cannot malloc p_url_host!\n"); _wilddog_url_freeParsedUrl(p_wd_url); parsed_url_free(p_paresd_url); return NULL; } strncpy((char*)p_wd_url->p_url_host, (char*)p_paresd_url->host, \ strlen((const char*)p_paresd_url->host)); } else return NULL; if(NULL == p_paresd_url->path) { p_wd_url->p_url_path = (Wilddog_Str_T *)wmalloc(len); if(NULL == p_wd_url->p_url_path) { _wilddog_url_freeParsedUrl(p_wd_url); parsed_url_free(p_paresd_url); return NULL; } p_wd_url->p_url_path[0] = '/'; } else { len += strlen((const char*)p_paresd_url->path); if(WILDDOG_ERR_NOERR != \ _wilddogurl_checkPath((Wilddog_Str_T*)p_paresd_url->path) ) { _wilddog_url_freeParsedUrl(p_wd_url); parsed_url_free(p_paresd_url); return NULL; } p_wd_url->p_url_path = (Wilddog_Str_T *)wmalloc(len + 1); if(NULL == p_wd_url->p_url_path) { _wilddog_url_freeParsedUrl(p_wd_url); parsed_url_free(p_paresd_url); return NULL; } snprintf((char*)p_wd_url->p_url_path, len, "/%s", \ p_paresd_url->path); len = strlen((const char*)p_wd_url->p_url_path); if(len > 1 && p_wd_url->p_url_path[len - 1] == '/') { p_wd_url->p_url_path[len - 1] = 0; } } if(NULL != p_paresd_url->query) { p_wd_url->p_url_query = (Wilddog_Str_T *)wmalloc( \ strlen((const char*)p_paresd_url->query) + 1); if(NULL == p_wd_url->p_url_query) { _wilddog_url_freeParsedUrl(p_wd_url); parsed_url_free(p_paresd_url); return NULL; } strncpy((char*)p_wd_url->p_url_query, (char*)p_paresd_url->query, \ strlen((const char*)p_paresd_url->query)); } parsed_url_free(p_paresd_url); return p_wd_url; }
/* * Function: wilddog_receive * Description: wilddog receive function, it use the interface in wiced platform. * Input: socketId: The socket id. * addr: The pointer of Wilddog_Address_T * buf: The pointer of the send buffer * bufLen: The length of the send buffer. * timeout: The max timeout in recv process. * Output: N/A * Return: If success, return the number of bytes received; else return -1. */ int wilddog_receive ( int socketId, Wilddog_Address_T* addr_in, void* buf, s32 bufLen, s32 timeout ) { wiced_udp_socket_t* socket = (wiced_udp_socket_t*) socketId; wiced_packet_t* receive = NULL; u16 totalLeft = 0; u16 total = 0; uint16_t pos = 0; uint8_t* rxData; uint16_t fragLeft = 0; wiced_ip_address_t recieve_ip_addr; uint16_t receive_port; wiced_result_t result; result = wiced_udp_receive( socket, &receive, timeout ); if ( result == WICED_SUCCESS ) { if(NULL == receive) { wilddog_debug_level(WD_DEBUG_ERROR, "receive is NULL!"); return -1; } wiced_udp_packet_get_info( receive, &recieve_ip_addr, &receive_port ); if ( !recieve_ip_addr.ip.v4 == MAKE_IPV4_ADDRESS(addr_in->ip[0], \ addr_in->ip[1], addr_in->ip[2], addr_in->ip[3]) ) { wilddog_debug_level(WD_DEBUG_ERROR, "addr error!\n" ); wiced_packet_delete( receive ); return -1; } do { if ( wiced_packet_get_data( receive, 0, (uint8_t**) &rxData, \ &fragLeft, &totalLeft ) != WICED_SUCCESS ) { wilddog_debug_level(WD_DEBUG_ERROR, \ "get data from packet error \r\n" ); wiced_packet_delete( receive ); return -1; } else { if ( pos + fragLeft > bufLen ) { /* too large, drop*/ wiced_packet_delete( receive ); wilddog_debug_level(WD_DEBUG_ERROR, \ "too large receive end , get %d bytes\n", pos ); return 0; } if ( total == 0 ) { /*only get first data, next fragment's total is wrong*/ total = totalLeft; } memcpy( (uint8_t *) ( buf + pos ), rxData, fragLeft ); pos += fragLeft; fragLeft = 0; } if ( pos == total ) { /*end*/ #if WILDDOG_SELFTEST { performtest_getWaitSessionQueryTime(); performtest_getWaitRecvTime(); } #endif wilddog_debug_level(WD_DEBUG_LOG, "received %d data!", pos); wiced_packet_delete( receive ); return pos; } else if ( pos < total ) { /*get next fragment*/ wilddog_debug_level(WD_DEBUG_LOG, "more than one packet!"); if ( WICED_SUCCESS != _packet_get_next_fragment( receive, \ &receive ) ) { wilddog_debug_level(WD_DEBUG_ERROR, \ "get next fragment err! %d lost!", total); if(receive) wiced_packet_delete( receive ); return -1; } if ( NULL == receive ) { wilddog_debug_level(WD_DEBUG_ERROR, \ "get next fragment err! %d lost!", total); return -1; } } else { wiced_packet_delete( receive ); return -1; } } while ( pos < total ); } else { wilddog_debug_level(WD_DEBUG_LOG, "result = %d",result); } /*if(receive) wiced_packet_delete( receive );*/ return 0; }
int test(char *uid) { char url[1024]; char en_key = 0; BOOL isFinished = FALSE; Wilddog_T wilddog; Wilddog_Handle_T s_handle; Wilddog_Node_T *p_head = NULL, *p_node = NULL/*, *p_snapshot = NULL*/; u8 value1[5] = {246,12,0,0,6}; /*u8 value2[4] = {23,67,98,1};*/ wFloat f = 2.3; Wilddog_Node_T *root; Wilddog_Node_T *L1c1,*L1c2; Wilddog_Node_T *L2c1,*L2c2,*L2c3; Wilddog_Node_T *L3c1,*L3c2,*L3c3,*L3c4,*L3c5; Wilddog_Node_T *L4c1,*L4c2,*L4c3,*L4c4,*L4c5; int count = 0; sprintf(url,"%s%s%s",TEST_URL_HEAD,uid,TEST_URL_END); memset(&s_handle, 0, sizeof(s_handle)); s_handle.isFinished = FALSE; printf("*******************************************\n"); printf("First Step: Build the data tree \n"); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif root = wilddog_node_createNum((Wilddog_Str_T *)"root",9999); L1c1 = wilddog_node_createFalse((Wilddog_Str_T *)"L1c1"); L1c2 = wilddog_node_createTrue((Wilddog_Str_T *)"L1c2"); L2c1 = wilddog_node_createNum((Wilddog_Str_T *)"L2c1",-10000); L2c2 = wilddog_node_createFloat((Wilddog_Str_T *)"L2c2",f); L2c3 = wilddog_node_createTrue((Wilddog_Str_T *)"L2c3"); //true L3c1 = wilddog_node_createBString((Wilddog_Str_T *)"L3c1",value1,sizeof(value1)/sizeof(u8)); //BString L3c2 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c2"); L3c3 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c3"); L3c4 = wilddog_node_createNull((Wilddog_Str_T *)"L3c4"); //NULL L3c5 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c5"); L4c1 = wilddog_node_createNum((Wilddog_Str_T *)"L4c1",875);// +Num L4c2 = wilddog_node_createNum((Wilddog_Str_T *)"L4c2",-5693); // -Num L4c3 = wilddog_node_createFloat((Wilddog_Str_T *)"L4c3",f); //float L4c4 = wilddog_node_createFalse((Wilddog_Str_T *)"L4c4"); //false L4c5 = wilddog_node_createUString((Wilddog_Str_T *)"L4c5",(Wilddog_Str_T *)"string"); //UString if(WILDDOG_ERR_NOERR != wilddog_node_addChild(root,L1c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(root,L1c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c1,L2c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c1,L2c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c2,L2c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c1,L3c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c1,L3c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c4)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c5)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c2,L4c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c3,L4c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c3,L4c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c5,L4c4)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c5,L4c5)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } printf("*******************************************\n"); printf("The data is built as below:\n"); wilddog_debug_printnode(root); printf("\n"); printf("*******************************************\n"); printf("\n\n"); /* printf("*******************************************\n"); printf("Second Step: Use the Node API to change the data tree\n"); printf("Change the L1c1 node's key from \"L1c1\" to \"L1c1New\" \n"); wilddog_node_setKey(L1c1,(Wilddog_Str_T *)"L1c1New"); printf("Change the L3c1 node's value from Bytestring \"{0xf6,0x0c,0x00,0x00,0x06}\" to Bytestring \"{0x17,0x43,0x62,0x01}\"\n "); wilddog_node_setValue(L3c1,value2,sizeof(value2)/sizeof(u8)); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif printf("*******************************************\n"); printf("The data tree had changed as below:\n"); wilddog_debug_printnode(root); printf("\n"); printf("*******************************************\n"); printf("\n\n"); */ /* printf("*******************************************\n"); printf("Clone the data tree from L2c2 node\n"); printf("Print the L2c2 data tree\n"); p_snapshot = wilddog_node_clone(L2c2); wilddog_debug_printnode(p_snapshot); wilddog_node_delete(p_snapshot); printf("\n"); printf("*******************************************\n"); printf("\n\n"); */ /*************************************************************/ wilddog = wilddog_initWithUrl((Wilddog_Str_T *)url); printf("*******************************************\n"); printf("Third step: Remove the %s's data\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_removeValue(wilddog, test_onDeleteFunc, (void*)&isFinished); while(1) { if(TRUE == isFinished) { wilddog_debug("remove success!"); break; } wilddog_trySync(); } isFinished = FALSE; /*************************************************************/ printf("*******************************************\n"); printf("It has removed all data in %s!\n",uid); printf("Please check the data on %s page\n",url); printf("*******************************************\n"); printf("\n\n"); printf("*******************************************\n"); printf("Fourth step: Set the root node to the %s's data tree\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_setValue(wilddog,root,test_onSetFunc,(void*)&isFinished); wilddog_node_delete(root); while(1) { if(TRUE == isFinished) { wilddog_debug("set success!"); break; } wilddog_trySync(); } isFinished = FALSE; printf("*******************************************\n"); printf("It has set the data in %s!\n",uid); printf("Please check the data tree on %s page\n",url); printf("*******************************************\n"); printf("\n\n"); /*****************************************************************/ printf("*******************************************\n"); printf("Fifth step: Get the %s's data\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif s_handle.p_node = NULL; wilddog_getValue(wilddog, test_onQueryFunc, (void*)(&s_handle)); while(1) { if(s_handle.isFinished) { if(s_handle.p_node) { wilddog_debug("print node:"); wilddog_debug_printnode(s_handle.p_node); wilddog_node_delete(s_handle.p_node); s_handle.p_node= NULL; printf("\n"); break; } } wilddog_trySync(); } isFinished = FALSE; printf("*******************************************\n"); printf("It has get the data in %s!\n",uid); printf("Please check the data tree!\n"); printf("*******************************************\n"); printf("\n\n"); /*****************************************************************/ p_head = wilddog_node_createObject((Wilddog_Str_T *)"3"); p_node = wilddog_node_createNum((Wilddog_Str_T *)"2",1234); wilddog_node_addChild(p_head, p_node); printf("*******************************************\n"); printf("Sixth step: Build a node as \"{\"2\":1234}\"\n"); printf("Push the new node to the %s's data tree's root node\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_push(wilddog, p_head, test_onPushFunc, (void *)&isFinished); wilddog_node_delete(p_head); while(1) { if(isFinished) { wilddog_debug("push success!"); break; } wilddog_trySync(); } printf("*******************************************\n"); printf("It has pushed the data in %s!\n",uid); printf("Please check the data tree on %s page\n",url); printf("\{\"2\":1234}\" will have a parent which have a long number\n");
int main(void) { int i, j; Wilddog_T p_repo1_ref1 = 0, p_repo1_ref2 =0; Wilddog_T p_repo2_ref1 = 0, p_repo2_ref2 = 0,p_repo2_ref1_cpy = 0; Wilddog_T p_ref[6]; Wilddog_T p_parent = 0, p_root = 0, p_child = 0; for(j = 0; j < FUNC_NUM; j++) { memset(&test_results[j], 0, sizeof(struct test_reult_t)); } test_results[0].name = "wilddog_getParent"; test_results[1].name = "wilddog_getRoot"; test_results[2].name = "wilddog_getChild"; /* * test the url format */ for( i = 0; i < sizeof(test_url)/sizeof(char *); i++) { p_ref[i] = wilddog_initWithUrl((Wilddog_Str_T *)test_url[i]); if(p_ref[i]) { wilddog_debug_level(WD_DEBUG_LOG, "p_ref-- [%d] \n\n", i); wilddog_debug_printUrl(p_ref[i]); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } else { wilddog_debug_level(WD_DEBUG_LOG, "------------------------\n"); wilddog_debug_level(WD_DEBUG_LOG, "%s could not init\n\n", test_url[i]); wilddog_debug_level(WD_DEBUG_LOG, "------------------------\n"); TEST_RESULT_PRINTF("test_all:wilddog_initWithUrl error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } } wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy the test url before\n\n"); for( i = 0; i < sizeof(test_url)/sizeof(char *); i++) { wilddog_debug_level(WD_DEBUG_LOG, "destroy %d test url %lu\n", i, (long unsigned int)p_ref[i]); if(p_ref[i]) wilddog_destroy(&(p_ref[i])); } wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy the test url after\n\n"); /* * test the multi repo and multi ref * test getparent getchild getroot */ p_repo1_ref1 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid1.wilddogio.com/a1"); p_repo1_ref2 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid1.wilddogio.com/a1/b2"); p_repo2_ref1 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3"); p_repo2_ref1_cpy = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3"); p_repo2_ref2 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3/d4/e5"); if(p_repo1_ref1) { wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref1\n\n"); wilddog_debug_printUrl(p_repo1_ref1); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } if(p_repo1_ref2) { wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2\n\n"); wilddog_debug_printUrl(p_repo1_ref2); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } if(p_repo2_ref1) { wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref1\n\n"); wilddog_debug_printUrl(p_repo2_ref1); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } if(p_repo2_ref1 != p_repo2_ref1_cpy) { TEST_RESULT_PRINTF( "test_all: new same url error ",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } if(p_repo2_ref2) { wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref2\n\n"); wilddog_debug_printUrl(p_repo2_ref2); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } p_parent = wilddog_getParent(p_repo1_ref2); if(p_parent == p_repo1_ref1) { wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2--parent\n\n"); wilddog_debug_printUrl(p_parent); test_results[0].result = TRUE; wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); } else { wilddog_debug_level(WD_DEBUG_LOG, "could not get repo1_ref2's parent\n\n"); TEST_RESULT_PRINTF("test_all:get parent error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } p_root = wilddog_getRoot(p_repo1_ref2); if(p_root) { wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2--root\n\n"); wilddog_debug_printUrl(p_root); test_results[1].result = TRUE; wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); wilddog_destroy(&p_root); } else { wilddog_debug_level(WD_DEBUG_LOG, "could not get repo1_ref2's root\n\n"); TEST_RESULT_PRINTF("test_all:get root error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } wilddog_debug_level(WD_DEBUG_LOG, "p_repo1_ref1 = %u",( unsigned int)p_repo1_ref1); wilddog_debug_printUrl(p_repo1_ref1); p_child = wilddog_getChild(p_repo2_ref2, (Wilddog_Str_T *)"c3/d4"); wilddog_debug_level(WD_DEBUG_LOG, "p_child = %u", ( unsigned int)p_child); if(p_child) { wilddog_debug_level(WD_DEBUG_LOG, "p_repo2_ref2--child\n\n"); wilddog_debug_printUrl(p_child); test_results[2].result = TRUE; wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); wilddog_destroy(&p_child); } else { wilddog_debug_level(WD_DEBUG_LOG, "could not get p_repo2_ref2's child /c3/d4\n\n"); TEST_RESULT_PRINTF("test_all:get chile error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR); return ABORT_ERR; } p_parent = wilddog_getParent(p_repo2_ref2); if(p_parent) { wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref2--parent\n\n"); wilddog_debug_printUrl(p_parent); wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n"); wilddog_destroy(&p_parent); } else { wilddog_debug_level(WD_DEBUG_LOG, "could not get repo2_ref2's parent\n\n"); } wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy all ref\n\n"); wilddog_destroy(&p_repo1_ref1); wilddog_destroy(&p_repo1_ref2); wilddog_destroy(&p_repo2_ref1); wilddog_destroy(&p_repo2_ref2); for(j = 0 ; j < FUNC_NUM; j++) { if(test_results[j].name) { printf("%-32s\t%s\n", test_results[j].name, (test_results[j].result == TRUE?("PASS"):("FAIL"))); if(test_results[j].result != TRUE) return -1; } } return 0; }
/* to do * Function: _wilddog_coap_receive. * Description: recv coap packet and handle it. * * Input: N/A. * Output: N/A. * Return: Wilddog_Return_T type */ Wilddog_Return_T WD_SYSTEM _wilddog_coap_receive(void *p_arg,int flag) { int res =0; u32 recv_type = 0; u32 ack_type = COAP_MESSAGE_ACK; u32 tmp_tokenLen = 0; u32 tmp_token = 0; u32 tmp_mid = 0; Protocol_recvArg_T recvArg; coap_pdu_t *p_pdu = NULL; memset(&recvArg,0,sizeof(Protocol_recvArg_T)); recvArg.p_recvData = _wilddog_coap_mallocRecvBuffer(); if( recvArg.p_recvData == NULL) { wilddog_debug_level(WD_DEBUG_ERROR, "malloc failed!"); return WILDDOG_ERR_NULL; } res = _wilddog_sec_recv((void*)recvArg.p_recvData,(s32)WILDDOG_PROTO_MAXSIZE); /*@ NO enougth space */ if( res <= 0 || res > WILDDOG_PROTO_MAXSIZE ) goto _COAPRECV_ERR; recvArg.d_recvDataLen = res; /* distinguish recv an coap packet. */ p_pdu = _wilddog_recvCoap(recvArg.p_recvData,recvArg.d_recvDataLen); if(p_pdu == NULL) goto _COAPRECV_ERR; #ifdef WILDDOG_SELFTEST ramtest_caculate_peakRam(); performtest_getHandleRecvDtlsTime(); #endif #ifdef WILDDOG_DEBUG #if DEBUG_LEVEL <= WD_DEBUG_LOG printf("recv:\n"); coap_show_pdu(p_pdu); #endif #endif /* dispatch .*/ recvArg.d_recvDataLen = WILDDOG_PROTO_MAXSIZE; if( _wilddog_recv_dispatch(p_pdu,&recvArg) < 0) { coap_delete_pdu(p_pdu); goto _COAPRECV_ERR; } tmp_mid = p_pdu->hdr->id; recv_type = p_pdu->hdr->type; tmp_tokenLen = p_pdu->hdr->token_length; memcpy(&tmp_token,p_pdu->hdr->token,p_pdu->hdr->token_length); coap_delete_pdu(p_pdu); /* call back.*/ if( _wilddog_coap_findRespondNode(&recvArg) != TRUE) ack_type = COAP_MESSAGE_RST; /* ack */ _wilddog_coap_ackSend(recv_type,ack_type,tmp_mid,tmp_tokenLen,tmp_token); _wilddog_coap_freeRecvBuffer( recvArg.p_recvData ); return WILDDOG_ERR_NOERR; _COAPRECV_ERR: _wilddog_coap_freeRecvBuffer( recvArg.p_recvData ); return WILDDOG_ERR_NULL; }