From 0a38403313b5c510c886b46cec36358689d5ff3f Mon Sep 17 00:00:00 2001 From: itolfh Date: Fri, 13 Jan 2017 19:56:28 +0800 Subject: [PATCH 01/22] update --- include/wilddog.h | 23 +- project/linux/env.mk | 2 +- src/Makefile | 6 - src/networking/coap/Makefile | 7 + src/networking/coap/wilddog_conn_coap.c | 1005 --------- src/networking/coap/wilddog_conn_coap.h | 19 - src/networking/coap/wilddog_protocol_coap.c | 441 ++++ src/networking/coap/wilddog_protocol_coap.h | 42 + src/secure/nosec/wilddog_nosec.c | 49 +- src/wilddog_conn.c | 1587 +++---------- src/wilddog_conn.h | 96 +- src/wilddog_conn_manage.c | 2223 ------------------- src/wilddog_conn_manage.h | 189 -- src/wilddog_ct.c | 9 +- src/wilddog_event.c | 8 +- src/wilddog_protocol.h | 65 + src/wilddog_sec.h | 19 +- src/wilddog_sec_host.c | 17 +- src/wilddog_sec_host.h | 35 - src/wilddog_store.c | 10 +- src/wilddog_store.h | 2 +- src/wilddog_url_parser.c | 43 +- src/wilddog_url_parser.h | 1 + 23 files changed, 1058 insertions(+), 4840 deletions(-) delete mode 100644 src/networking/coap/wilddog_conn_coap.c delete mode 100644 src/networking/coap/wilddog_conn_coap.h create mode 100644 src/networking/coap/wilddog_protocol_coap.c create mode 100644 src/networking/coap/wilddog_protocol_coap.h delete mode 100644 src/wilddog_conn_manage.c delete mode 100644 src/wilddog_conn_manage.h create mode 100644 src/wilddog_protocol.h delete mode 100644 src/wilddog_sec_host.h diff --git a/include/wilddog.h b/include/wilddog.h index a026396..c461845 100644 --- a/include/wilddog.h +++ b/include/wilddog.h @@ -30,11 +30,11 @@ extern "C" /* if do not need debug log, undefine it to cost down ROM space. */ #define WILDDOG_DEBUG -#define WD_DEBUG_ALL 0 -#define WD_DEBUG_LOG 1 -#define WD_DEBUG_WARN 2 -#define WD_DEBUG_ERROR 3 -#define WD_DEBUG_NODBG 4 +#define WD_DEBUG_ALL (0) +#define WD_DEBUG_LOG (1) +#define WD_DEBUG_WARN (2) +#define WD_DEBUG_ERROR (3) +#define WD_DEBUG_DEBUG (4) #ifdef WILDDOG_PORT_TYPE_ESP #include "wilddog_espressif.h" @@ -78,11 +78,19 @@ typedef signed long s32 ; #ifdef WILDDOG_DEBUG #define DEBUG_LEVEL WD_DEBUG_ERROR +STATIC const char *s_debug[] = { + "[ALL]", + "[LOG]", + "[WARN]", + "[ERROR]", + "[DEBUG]" +}; + #define wilddog_debug_level(level, format,...) do{if(level >= DEBUG_LEVEL){ \ - printf("func:%s LINE: %d: "format"\r\n", __func__, __LINE__, ##__VA_ARGS__); \ + printf("func:%s LINE: %d: %s"format"\r\n", __func__, __LINE__, s_debug[level],##__VA_ARGS__); \ }}while(0) -#define wilddog_debug(format,...) wilddog_debug_level(WD_DEBUG_NODBG, \ +#define wilddog_debug(format,...) wilddog_debug_level(WD_DEBUG_DEBUG, \ format,##__VA_ARGS__) #else @@ -155,6 +163,7 @@ typedef enum WILDDOG_RETURN_T WILDDOG_HTTP_OK = 200, WILDDOG_HTTP_CREATED = 201, WILDDOG_HTTP_NO_CONTENT = 204, + WILDDOG_HTTP_PARTICAL_CONTENT = 206, WILDDOG_HTTP_NOT_MODIFIED = 304, diff --git a/project/linux/env.mk b/project/linux/env.mk index a135e01..a8b10f9 100644 --- a/project/linux/env.mk +++ b/project/linux/env.mk @@ -15,7 +15,7 @@ else QUIET = @ MAKE += --no-print-directory endif -CFLAGS+=-Wall -O2 +CFLAGS+=-Wall -g ifeq ($(APP_SEC_TYPE), tinydtls) CFLAGS += -pthread diff --git a/src/Makefile b/src/Makefile index a1a9c9c..10fdc56 100644 --- a/src/Makefile +++ b/src/Makefile @@ -9,12 +9,6 @@ LIB_PATH = $(TOPDIR)/lib CFLAGS = $(INCLUDE_PATH) -ifneq ($(APP_SEC_TYPE), nosec) -CFLAGS+= -DWILDDOG_PORT=5684 -else -CFLAGS+= -DWILDDOG_PORT=5683 -endif - LDFLAGS = include $(TOPDIR)/project/$(PORT_TYPE)/env.mk diff --git a/src/networking/coap/Makefile b/src/networking/coap/Makefile index ec89a75..94bad0e 100644 --- a/src/networking/coap/Makefile +++ b/src/networking/coap/Makefile @@ -3,6 +3,13 @@ INCLUDE_PATH=-I$(TOPDIR)/include -I$(TOPDIR)/src LIB_PATH = $(TOPDIR)/lib CFLAGS = $(INCLUDE_PATH) + +ifneq ($(APP_SEC_TYPE), nosec) +CFLAGS+= -DWILDDOG_PORT=5684 +else +CFLAGS+= -DWILDDOG_PORT=5683 +endif + LDFLAGS = ifeq ($(PORT_TYPE), espressif) INCLUDE_PATH+= -I ../../include -I $(TOPDIR)platform/espressif diff --git a/src/networking/coap/wilddog_conn_coap.c b/src/networking/coap/wilddog_conn_coap.c deleted file mode 100644 index 76d4860..0000000 --- a/src/networking/coap/wilddog_conn_coap.c +++ /dev/null @@ -1,1005 +0,0 @@ -/* - * Copyright (C) 2014-2016 Wilddog Technologies. All Rights Reserved. - * - * FileName: wilddog_conn.c - * - * Description: connection functions. - * - * History: - * Version Author Date Description - * - * 0.4.0 lxs 2015-05-15 Create file. - * 0.5.0 lxs 2015-12-22 modify interface. - */ - -#ifndef WILDDOG_PORT_TYPE_ESP -#include -#endif -#include -#include -#include "option.h" -#include "wilddog_payload.h" - -#include "utlist.h" -#include "wilddog_config.h" -#include "wilddog.h" -#include "wilddog_endian.h" -#include "wilddog_conn_coap.h" -#include "wilddog_debug.h" -#include "wilddog_common.h" -#include "wilddog_sec.h" -#include "test_lib.h" - -#include "wilddog_conn.h" -#include "wilddog_conn_manage.h" -#include "wilddog_conn_coap.h" - -#define _COAP_PATH_SLASH '/' -#define AUTHR_LEN (4) - -#define _GET_COAP_CODE(code) ((code >> 5) * 100 + (code & 0x1F)) - -Wilddog_Func_T _wilddog_coap_findRespondNode = NULL ; - -typedef struct _WILDDOG_RECV_STRUCT -{ - u8 data[WILDDOG_PROTO_MAXSIZE]; - u8 isused; -}_wilddog_Recv_T; - - - - -STATIC _wilddog_Recv_T l_recvData; - -extern int _byte2bytestr(u8 *p_dst,u8 *p_src,u8 len); - - -/*LOCK and UNLOCK used for multi thread*/ -STATIC INLINE int WD_SYSTEM _wilddog_coap_recvBufLock(int timeout) -{ - return 0; -} -STATIC INLINE void WD_SYSTEM _wilddog_coap_recvBufUnlock(void) -{ - return; -} -#if 0 -STATIC void WD_SYSTEM _wilddog_coap_initRecvBuffer(void) -{ - _wilddog_coap_recvBufLock(0); - memset(&l_recvData, 0, sizeof(l_recvData)); - _wilddog_coap_recvBufUnlock(); - return; -} -#endif -/* - * Function: _sys_coap_ntol - * Description: Convert the byte order - * Input: src: The pointer of the source byte - * len: The length of the source byte - * Output: dst: The pointer of the destination byte - * Return: N/A -*/ -STATIC INLINE void WD_SYSTEM _sys_coap_ntol - ( - u8 *dst, - const u8 *src, - const u8 len - ) -{ - u8 i; - for(i=0;ip_r_path); - p_recvArg->p_r_path = NULL; - _wilddog_coap_freeRecvBuffer( p_recvArg->p_recvData ); -} - -/* - * Function: _wilddog_coap_code2Http - * Description: Convert the coap code to http return code - * Input: rec_code: The coap code - * Output: N/A - * Return: The http return code -*/ -unsigned int WD_SYSTEM _wilddog_coap_code2Http(unsigned int rec_code) -{ - switch(rec_code) - { - case 201: return WILDDOG_HTTP_CREATED; - case 202: return WILDDOG_HTTP_NO_CONTENT; - case 203: return WILDDOG_HTTP_NOT_MODIFIED; - case 204: return WILDDOG_HTTP_NO_CONTENT; - case 205: return WILDDOG_HTTP_OK; - - } - return rec_code; -} - -/* - * Function: _wilddog_coap_cmd2Typecode - * Description: Convert cmd to coap type and code field - * Input: cmd: The conn command - * Output: p_type: The pointer of the coap type - * p_code: The pointer of the coap code field - * pp_observe: The pointer of the observe flag - * Return: If success, return 0; else return WILDDOG_ERR_INVALID -*/ -STATIC int WD_SYSTEM _wilddog_coap_cmd2Typecode - ( - u8 cmd, - u8 *p_type, - u8 *p_code - ) -{ - int res = 0; - switch(cmd) - { - case WILDDOG_CONN_CMD_AUTH: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_POST; - break; - case WILDDOG_CONN_CMD_GET: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_GET; - break; - - case WILDDOG_CONN_CMD_SET: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_PUT; - break; - case WILDDOG_CONN_CMD_PUSH: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_POST; - break; - case WILDDOG_CONN_CMD_REMOVE: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_DELETE; - break; - case WILDDOG_CONN_CMD_ON: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_GET; - break; - case WILDDOG_CONN_CMD_OFF: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_GET; - break; -#if 1 - case WILDDOG_CM_SYS_CMD_SHORTPING: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_GET; - break; - case WILDDOG_CM_SYS_CMD_LONGPING: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_POST; - break; -#endif - case WILDDOG_CONN_CMD_ONDISSET: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_PUT; - break; - case WILDDOG_CONN_CMD_ONDISPUSH: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_POST; - break; - case WILDDOG_CONN_CMD_ONDISREMOVE: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_DELETE; - break; - case WILDDOG_CONN_CMD_CANCELDIS: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_DELETE; - break; - case WILDDOG_CONN_CMD_OFFLINE: - *p_type = COAP_MESSAGE_CON; - *p_code = COAP_REQUEST_GET; - break; - default: - res = WILDDOG_ERR_INVALID; - break; - } - return res; -} -/* - * Function: _wilddog_coap_findChar - * Description: Find the number of char 'c' exist in the string buffer. - * Input: c: The char. - * p_buf: The pointer of the string buffer. - * Output: N/A - * Return: The number. -*/ -STATIC int WD_SYSTEM _wilddog_coap_findChar - ( - const char c, - const unsigned char *p_buf - ) -{ - int res = 0 ; - u32 i; - for(i=0;p_buf[i] != 0;i++) - { - if(p_buf[i] == c) - res++; - } - return res; -} -/* - * Function: _wilddog_coap_countPacktSize. - * Description: Count the conn packet size. - * Count method: - * host : 4+ host len - * path : n*(4+ subpath) - * query: 4+2+query len - * Input: p_cp_pkt: The pointer of conn packet - * Output: N/A - * Return: The number of the conn packet size -*/ -STATIC int WD_SYSTEM _wilddog_coap_countPacktSize - ( - Protocol_Arg_CountSize_T *p_arg - ) -{ - int len = 0,n=0; - wilddog_assert(p_arg,0); - - /*option*/ - if(p_arg->p_host) - len = 4 + strlen((const char *)p_arg->p_host); - - if(p_arg->p_query) - len += 6 + strlen((const char *)p_arg->p_query); - if(p_arg->p_path) - { - n = _wilddog_coap_findChar('/',p_arg->p_path); - len += 4 * (n+1)+strlen((const char *)p_arg->p_path); - } - else - len += 5; - - /* payload add */ - len += (p_arg->d_payloadLen + 4 ); - - /* + had + token + observer*/ - len += 8 + 14 + 8; - - return len; -} - -/* - * 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,"coap:: tcreat coap pakge :%p :",p_pdu); - return ( size_t )p_pdu; -} -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,"coap:: destory coap pakge :%p :",p_coap); - coap_delete_pdu((coap_pdu_t*)p_coap); - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_coap_addHost - * Description: add host to coap packages. - * Input: p_arg: p_coap/p_options. - * Output: N/A - * Return: WILDDOG_ERR_NOERR or WILDDOG_ERR_NULL. -*/ - -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_addHost - ( - Protocol_Arg_Option_T *p_arg, - int flag - ) -{ - if( p_arg == NULL || - p_arg->p_pkg == NULL || - p_arg->p_options == NULL) - return WILDDOG_ERR_NULL; - - coap_add_option((coap_pdu_t*)p_arg->p_pkg, \ - COAP_OPTION_URI_HOST, \ - strlen((const char*)p_arg->p_options), \ - p_arg->p_options); - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_coap_addPath - * Description: add host to coap packages. - * Input: p_arg: p_coap/p_options. - * Output: N/A - * Return: WILDDOG_ERR_NOERR or WILDDOG_ERR_NULL. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_addPath - ( - Protocol_Arg_Option_T *p_arg, - int flag - ) -{ - u8 *p_subpath_h = NULL; - u8 *p_subpath_end = NULL; - - if( p_arg == NULL || - p_arg->p_pkg == NULL || - p_arg->p_options == NULL) - return WILDDOG_ERR_NULL; - - /* @add path */ - for(p_subpath_h= p_arg->p_options;p_subpath_h;) - { - p_subpath_h = (u8*)_wilddog_strchar(( char *)p_subpath_h,'/'); - if(!p_subpath_h) - break; - p_subpath_h++; - p_subpath_end = (u8*)_wilddog_strchar((char *)p_subpath_h,'/'); - if( !p_subpath_end ) - { - coap_add_option((coap_pdu_t*) p_arg->p_pkg, \ - COAP_OPTION_URI_PATH, \ - strlen((const char *)p_subpath_h), \ - p_subpath_h); - break; - } - else - coap_add_option((coap_pdu_t*) p_arg->p_pkg, \ - COAP_OPTION_URI_PATH, \ - p_subpath_end - p_subpath_h, \ - p_subpath_h); - - } - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_coap_addQuery - * Description: add query. - * Input: p_arg: p_coap/p_options. - * Output: N/A - * Return: WILDDOG_ERR_NOERR or WILDDOG_ERR_NULL. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_addQuery - ( - Protocol_Arg_Option_T *p_arg, - int flag - ) -{ - if( p_arg == NULL || - p_arg->p_pkg == NULL || - p_arg->p_options == NULL) - return WILDDOG_ERR_NULL; - - coap_add_option((coap_pdu_t*)p_arg->p_pkg, \ - COAP_OPTION_URI_QUERY, \ - strlen((const char *)p_arg->p_options), \ - p_arg->p_options); - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_coap_addData - * Description: add data. - * Input: p_arg: p_coap/p_payload/d_payloadLen. - * Output: N/A - * Return: WILDDOG_ERR_NOERR or WILDDOG_ERR_NULL. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_addData - ( - Protocol_Arg_Payload_T *p_arg, - int flag - ) -{ - int ret; - if( p_arg == NULL || - p_arg->p_pkg == NULL || - p_arg->p_payload == NULL) - return WILDDOG_ERR_NULL; - ret = coap_add_data((coap_pdu_t*)p_arg->p_pkg,\ - p_arg->d_payloadLen, \ - p_arg->p_payload); - - if(0 == ret) - return WILDDOG_ERR_NULL; - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_coap_addObserver - * Description: add query. - * Input: p_arg: p_coap/p_options. - * Output: N/A - * Return: WILDDOG_ERR_NOERR or WILDDOG_ERR_NULL. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_addObserver - ( - Protocol_Arg_Option_T *p_arg, - int flag - ) -{ - if( p_arg == NULL || - p_arg->p_pkg == NULL || - p_arg->p_options == NULL) - { - return WILDDOG_ERR_NULL; - } - - coap_add_option((coap_pdu_t*)p_arg->p_pkg,\ - COAP_OPTION_OBSERVE, \ - 1, \ - p_arg->p_options); - - return WILDDOG_ERR_NOERR; -} - -/* - * Function: _wilddog_coap_authUpdate - * Description:Update the coap auth - * Input: p_arg->p_auth: The pointer of the auth data - * p_arg->p_coap: The pointer of the coap pdu - * Output: N/A - * Return: If success, return WILDDOG_ERR_NOERR -*/ -STATIC int WD_SYSTEM _wilddog_conn_coap_auth_update - ( - Protocol_Arg_Auth_T *p_arg, - int flag - ) -{ - coap_opt_iterator_t d_oi; - coap_opt_t *p_op = NULL; - u8 *p_opvalue = NULL; - - if( p_arg == NULL ||\ - p_arg->p_pkg == NULL || \ - p_arg->p_newAuth == NULL) - return WILDDOG_ERR_INVALID; - /* seek option*/ - p_op = coap_check_option(p_arg->p_pkg,COAP_OPTION_URI_QUERY,&d_oi); - if(p_op == NULL) - return WILDDOG_ERR_NOERR; - /* pointer to option value*/ - p_opvalue = coap_opt_value(p_op); - if(p_opvalue == NULL) - return WILDDOG_ERR_INVALID; - - if(memcmp(p_opvalue,_CM_AUTHR_QURES,strlen(_CM_AUTHR_QURES)) != 0) - return WILDDOG_ERR_INVALID; - - memcpy(p_opvalue,p_arg->p_newAuth,p_arg->d_newAuthLen); - - return WILDDOG_ERR_NOERR; -} - -/* - * Function: _wilddog_coap_send. - * Description: send out and coap package. - * - * Input: p_coap : point to an coap package. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -Wilddog_Return_T WD_SYSTEM _wilddog_coap_send(void *p_arg,int flag) -{ - coap_pdu_t *p_coap = (coap_pdu_t*)p_arg; - - if( p_coap == NULL) - return WILDDOG_ERR_INVALID; - -#ifdef DEBUG_LEVEL - if(DEBUG_LEVEL <= WD_DEBUG_LOG ) - coap_show_pdu(p_coap); -#endif - return _wilddog_sec_send(p_coap->hdr, p_coap->length); -} - -Wilddog_Return_T WD_SYSTEM _wilddog_coap_midTokenModify(void *p_arg,int flag) -{ - Wilddog_CM_Send_Ping_Arg_T *ping_pkg = (Wilddog_CM_Send_Ping_Arg_T*)p_arg; - coap_pdu_t *p_coap = (coap_pdu_t*)(ping_pkg->p_pkg); - coap_hdr_t *p_hdr = p_coap->hdr; - - if(NULL == ping_pkg || NULL == p_coap || NULL == p_hdr) - return WILDDOG_ERR_INVALID; - - p_hdr->id = ping_pkg->d_mid; - - memcpy(p_hdr->token, (u8*)(&(ping_pkg->d_token)), p_hdr->token_length);\ - - return WILDDOG_ERR_NOERR; -} - -/* - * Function: _wilddog_recvCoap - * Description: Verify the receive the coap - * Input: p_buf: The pointer of the buffer - * buflen: The length of the buffer - * Output: N/A - * Return: If there's coap packet, return the pointer of the coap pdu, - * else return NULL -*/ -STATIC coap_pdu_t * WD_SYSTEM _wilddog_recvCoap - ( - u8 *p_buf, - u32 buflen - ) -{ - coap_pdu_t* p_resp = NULL; - - p_resp = coap_new_pdu(); - if(!p_resp) - return NULL; - - /* is coap packet */ - if( coap_pdu_parse(p_buf,buflen, p_resp) && - (p_resp->hdr->version == COAP_DEFAULT_VERSION)) - return p_resp; - else - { - coap_delete_pdu(p_resp); - return NULL; - } -} -/* - * 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; -} - - -u8* WD_SYSTEM _wilddog_recv_path_alloc - (const coap_pdu_t *pdu) -{ - coap_opt_iterator_t opt_iter; - coap_opt_t *option; - u16 pdu_hd_option_len = 0,i=0; - u8 *p_path_buf = NULL; - - if(pdu->data) /* path len < pdu head + total option */ - pdu_hd_option_len = pdu->data -(unsigned char *)pdu->hdr; - else - pdu_hd_option_len = pdu->length; - /*list all option */ - coap_option_iterator_init((coap_pdu_t *)pdu, &opt_iter, COAP_OPT_ALL); - while ((option = coap_option_next(&opt_iter))) - { - - if ( opt_iter.type == COAP_OPTION_URI_PATH ) - { - u16 d_optionlen = coap_opt_length(option); - u8 *p_optionvalue = coap_opt_value(option); - - if(p_path_buf == NULL){ - p_path_buf = wmalloc(pdu_hd_option_len); - - if( p_path_buf == NULL ) - return NULL; - memset(p_path_buf,0,pdu_hd_option_len); - p_path_buf[i] = _COAP_PATH_SLASH; - i++; - } - - if( d_optionlen == 0) - continue; - /* just in cast, unexpect error : option prase faile */ - if( (pdu_hd_option_len - i ) < d_optionlen ) - { - wfree(p_path_buf); - return NULL; - } - if( i != 1 ){ - - p_path_buf[i] = _COAP_PATH_SLASH; - i++; - } - memcpy((u8*)&p_path_buf[i],p_optionvalue,d_optionlen); - i += d_optionlen; - } - } - - - return p_path_buf; -} - - -/* - * 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:: receive coap return code : %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:: receive return code %ld",p_cm_recvArg->err); - - /* get token option.*/ - if(p_recvPdu->hdr->token_length != COAP_TOKENLEN) - return WILDDOG_ERR_INVALID; - - memcpy((char*)&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:: receive package observer index : %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)); - - /* get path */ - /* path must be free !! */ - p_cm_recvArg->p_r_path = _wilddog_recv_path_alloc(p_recvPdu); - - wilddog_debug_level(WD_DEBUG_LOG,"coap:: package path %s ",p_cm_recvArg->p_r_path); - wilddog_debug_level(WD_DEBUG_LOG, \ - "coap:: receive package 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:: receive payload :%s", \ - p_cm_recvArg->p_recvData); - - return WILDDOG_ERR_NOERR; - -} -/* - * 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; - -} - -/* 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 coap package:\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_recvArg_free( &recvArg); - - return WILDDOG_ERR_NOERR; - -_COAPRECV_ERR: - _wilddog_coap_recvArg_free( &recvArg ); - return WILDDOG_ERR_NULL; -} -/* - * Function: _wilddog_coap_init. - * Description: init coap port. - * - * Input: p_arg->p_host : DNS server name . - * p_arg->d_port : connect udp port. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -Wilddog_Return_T WD_SYSTEM _wilddog_coap_init - ( - Protocol_Arg_Init_T *p_arg, - int flag - ) -{ - if( p_arg == NULL || - p_arg->p_host == NULL) - return WILDDOG_ERR_INVALID; - - _wilddog_coap_findRespondNode = p_arg->f_handleRespond; - - return _wilddog_sec_init(p_arg->p_host,p_arg->d_port); -} -/* - * Function: _wilddog_coap_deInit. - * Description: destory coap packet port. - * - * Input: N/A. - * Output: N/A. - * Return: Wilddog_Return_T type . -*/ -Wilddog_Return_T _wilddog_coap_deInit(void *p_arg,int flag) -{ - _wilddog_coap_findRespondNode = NULL; - return _wilddog_sec_deinit(); -} -/* protocol :: coap interface */ -Wilddog_Func_T _wilddog_protocolPackage_funcTable[_PROTOCOL_CMD_MAX + 1] = -{ - (Wilddog_Func_T) _wilddog_coap_init, - (Wilddog_Func_T) _wilddog_coap_deInit, - - (Wilddog_Func_T) _wilddog_coap_countPacktSize, - (Wilddog_Func_T) _wilddog_coap_creat, - (Wilddog_Func_T) _wilddog_coap_destory, - (Wilddog_Func_T) _wilddog_coap_addHost, - (Wilddog_Func_T) _wilddog_coap_addPath, - (Wilddog_Func_T) _wilddog_coap_addQuery, - (Wilddog_Func_T) _wilddog_coap_addObserver, - (Wilddog_Func_T) _wilddog_coap_addData, - - (Wilddog_Func_T) _wilddog_conn_coap_auth_update, - (Wilddog_Func_T) _wilddog_coap_send, - (Wilddog_Func_T) _wilddog_coap_receive, - (Wilddog_Func_T) _wilddog_coap_midTokenModify, - NULL -}; - -/* - * Function: _wilddog_protocol_ioctl - * Description: the ioctl function of protocol - * Input: cmd: command - * arg: the arg - * flags: the flag, not used - * Output: N/A - * Return: if success, return WILDDOG_ERR_NOERR -*/ -size_t WD_SYSTEM _wilddog_protocol_ioctl - ( - Protocol_cmd_t cmd, - void *p_args, - int flags - ) -{ - if( cmd >= _PROTOCOL_CMD_MAX || - cmd < 0) - return WILDDOG_ERR_INVALID; - - return (size_t)(_wilddog_protocolPackage_funcTable[cmd])(p_args,flags); -} diff --git a/src/networking/coap/wilddog_conn_coap.h b/src/networking/coap/wilddog_conn_coap.h deleted file mode 100644 index 2d6dd12..0000000 --- a/src/networking/coap/wilddog_conn_coap.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Wilddog.h - * - * Created on: 2015-12-12 - * Author: x - */ - -#ifndef __WILDDOG_CONN_COAP_H_ -#define __WILDDOG_CONN_COAP_H_ - -#include "pdu.h" -#include "wilddog.h" -#include "wilddog_url_parser.h" -#include "wilddog_conn.h" - -#define COAP_TOKENLEN 4 - -#endif /* __WILDDOG_CONN_COAP_H_ */ - diff --git a/src/networking/coap/wilddog_protocol_coap.c b/src/networking/coap/wilddog_protocol_coap.c new file mode 100644 index 0000000..396478b --- /dev/null +++ b/src/networking/coap/wilddog_protocol_coap.c @@ -0,0 +1,441 @@ +/* + * Copyright (C) 2014-2016 Wilddog Technologies. All Rights Reserved. + * + * FileName: wilddog_protocol_coap.c + * + * Description: coap special protocol functions. + * + * History: + * Version Author Date Description + * + * 1.1.1 jimmy 2017-01-11 Create file. + */ + +#ifndef WILDDOG_PORT_TYPE_ESP +#include +#endif +#include +#include +#include "option.h" +#include "wilddog_payload.h" + +#include "utlist.h" +#include "wilddog_config.h" +#include "wilddog.h" +#include "wilddog_endian.h" +#include "wilddog_protocol.h" +#include "wilddog_protocol_coap.h" +#include "wilddog_debug.h" +#include "wilddog_common.h" +#include "wilddog_sec.h" +#include "test_lib.h" + +#include "wilddog_conn.h" + +/* + * Function: _wilddog_conn_mallocRecvBuffer + * Description: conn layer malloc the buffer which used for recv + * + * Input: N/A + * Output: N/A + * Return: the buffer's pointer +*/ +STATIC u8* WD_SYSTEM _wilddog_coap_mallocRecvBuffer(Wilddog_Protocol_T *proto) +{ + int i = 0; + u8* buffer = NULL; + + wilddog_assert(proto, NULL); + + for(i = 0; i < WILDDOG_PROTO_RECV_BUF_NUM; i++){ + if(proto->recv_buf[i].isused == FALSE) + { + buffer = proto->recv_buf[i].data; + proto->recv_buf[i].isused = TRUE; + memset(buffer, 0, WILDDOG_PROTO_MAXSIZE); + } + } + + return buffer; +} + +/* + * Function: _wilddog_conn_freeRecvBuffer + * Description: conn layer free the buffer which used for recv + * + * Input: ptr: the buffer's pointer + * Output: N/A + * Return: N/A +*/ +STATIC void WD_SYSTEM _wilddog_coap_freeRecvBuffer(Wilddog_Protocol_T *proto,u8* ptr) +{ + int i; + + if(!ptr || !proto) + return; + + for(i = 0; i < WILDDOG_PROTO_RECV_BUF_NUM; i++){ + if(proto->recv_buf[i].data == ptr && TRUE == proto->recv_buf[i].isused){ + proto->recv_buf[i].isused = FALSE; + } + } + + return; +} + + +/* + * Function: _wilddog_coap_random + * Description: Get a rand number + * Input: N/A + * Output: N/A + * Return: A rand number +*/ +STATIC INLINE u32 WD_SYSTEM _wilddog_coap_random(void) +{ + srand(_wilddog_getTime()); + return (u32)rand(); +} +//not thread safe +STATIC INLINE u16 WD_SYSTEM _wilddog_coap_getMid(void) +{ + STATIC u16 mid = 1; + return mid++; +} +/* + * Function: _wilddog_coap_getToken + * Description: get index, not thread safe + * Input: N/A + * Output: N/A + * Return: A rand number +*/ +STATIC u32 WD_SYSTEM _wilddog_coap_getToken(u16 mid) +{ + u32 token = _wilddog_coap_random(); + return (u32)(((token & (~0xff)) | (mid & 0xff)) & 0xffffffff); +} +/* + * Function: _wilddog_coap_countChar + * Description: count the number of char 'c' exist in the string buffer. + * Input: c: The char. + * p_buf: The pointer of the string buffer. + * Output: N/A + * Return: The number. +*/ +STATIC int WD_SYSTEM _wilddog_coap_countChar(const char c,const char *p_buf) +{ + int res = 0 ; + u32 i; + for(i=0;p_buf[i] != 0;i++) + { + if(p_buf[i] == c) + res++; + } + return res; +} + +/* +coap header. + | 0 | 1 | 2 | 3 | + |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |Ver| T | TKL | Code | Message ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Token (if any, TKL bytes) ... + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Options (if any) ... + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + |1 1 1 1 1 1 1 1| Payload (if any) ... + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + +option max header will be 5 bytes. + 7 6 5 4 3 2 1 0 ++---------------+---------------+ +| Option Delta | Option Length | 1 byte ++---------------+---------------+ +/ Option Delta / 0-2 bytes +\ (extended) \ ++-------------------------------+ +/ Option Length / 0-2 bytes +\ (extended) \ ++-------------------------------+ +/ Option Value / 0 or more bytes ++-------------------------------+ +*/ +//Try to count this coap packet's size, so we can malloc less buffer. +STATIC int WD_SYSTEM _wilddog_coap_countSize(Wilddog_Coap_Pkt_T pkt){ + int size = 0; + + wilddog_assert(pkt.url, -1); + + // 4 bytes header and token + size += 4 + pkt.token_length; + + //host option, option max head length is 5 + if(pkt.url->p_url_host){ + size += 5 + strlen((const char*)pkt.url->p_url_host) + 1; + } + //path option + if(pkt.url->p_url_path){ + // path will be separated into some options by '/', it may be more than 1 option + int num = 0; + num = _wilddog_coap_countChar('/', (const char *)pkt.url->p_url_path); + // max option number is "number of /" + 1 + num++; + size += num * 5 + strlen((const char*)pkt.url->p_url_path) + 1; + } + else{ + //a null path, also will be in coap, but no data + size += 5; + } + + //query option + if(pkt.url->p_url_query){ + //query will be separated into some options by '&', it may be more than 1 option + int num = 0; + num = _wilddog_coap_countChar('&', (const char *)pkt.url->p_url_query); + // max option number is "number of &" + 1 + num++; + size += num * 5 + strlen((const char*)pkt.url->p_url_query) + 1; + } + //may be observe option, observe 0 + if(WILDDOG_COAP_CMD_ON == pkt.command){ + size += 5 + 1; + } + + //payload, with 0xff ahead. + size += pkt.data_len + 1; + return size; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Coap_Pkt_T pkt; + u32 token; + Wilddog_Str_T* oldPath = NULL; + Wilddog_Str_T* tmp = NULL; + int finalPathLen = 0; + coap_pdu_t * pdu = NULL; + + wilddog_assert(data, WILDDOG_ERR_NULL); + wilddog_assert(!arg->p_url->p_url_path, WILDDOG_ERR_NULL); + + //add information for coap header + pkt.command = WILDDOG_COAP_CMD_INIT; + pkt.type = COAP_MESSAGE_CON; + pkt.code = COAP_REQUEST_POST; + pkt.version = COAP_DEFAULT_VERSION; + pkt.mid = _wilddog_coap_getMid(); + + //get coap token, donot use hdr.token, use pkt.token instead + pkt.token_length = WILDDOG_COAP_TOKEN_LEN; + token = _wilddog_coap_getToken(pkt.mid); + memcpy(pkt.token,(u8*)&token,WILDDOG_COAP_TOKEN_LEN); + + //in our coap, token is message id and more than mid, tell up layer the message id + *(arg->p_message_id) = token; + + //get user auth token as data. + pkt.data = arg->p_data; + pkt.data_len = arg->d_data_len; + + pkt.url = arg->p_url; + + //merge session init path with path .cs, assert pkt.url->p_url_path is null + finalPathLen = strlen(WILDDOG_COAP_SESSION_PATH) + 1; + tmp = (Wilddog_Str_T*)wmalloc(finalPathLen); + wilddog_assert(tmp, WILDDOG_ERR_NULL); + if(NULL == tmp){ + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); + return WILDDOG_ERR_NULL; + } + //store old path + oldPath = pkt.url->p_url_path; + pkt.url->p_url_path = tmp; + snprintf((char*)pkt.url->p_url_path, finalPathLen, "%s", WILDDOG_COAP_SESSION_PATH); + //count pkt size. + pkt.size = _wilddog_coap_countSize(pkt); + + //make a coap packet + pdu = coap_pdu_init(pkt.type, pkt.code, pkt.mid, pkt.size); + if(NULL == pdu){ + wfree(pkt.url->p_url_path); + pkt.url->p_url_path = oldPath; + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); + return WILDDOG_ERR_NULL; + } + //add token + coap_add_token(pdu, pkt.token_length, pkt.token); + //add host + coap_add_option(pdu,COAP_OPTION_URI_HOST,strlen((const char*)pkt.url->p_url_host),pkt.url->p_url_host); + + //add path + coap_add_option(pdu,COAP_OPTION_URI_PATH, strlen((const char*)pkt.url->p_url_path),pkt.url->p_url_path); + + //add data + coap_add_data(pdu,pkt.data_len, pkt.data); + + if(_wilddog_sec_send(arg->protocol, pdu->hdr, pdu->length) < 0){ + coap_delete_pdu(pdu); + wfree(pkt.url->p_url_path); + return WILDDOG_ERR_SENDERR; + } + wfree(pkt.url->p_url_path); + pkt.url->p_url_path = oldPath; + *(u8**)(arg->p_out_data) = (u8*)pdu; + *(arg->p_out_data_len) = (u32)pdu->length; + + return WILDDOG_ERR_NOERR; +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_freePkt(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + + wilddog_assert(data, WILDDOG_ERR_NULL); + + if(arg->p_out_data){ + wfree(arg->p_out_data); + } + return WILDDOG_ERR_NOERR; +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_getPkt(void* data, int flag){ + u8* recv_data = NULL; + int res = 0; + coap_pdu_t * pdu; + + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + + wilddog_assert(data, WILDDOG_ERR_NULL); + //1. recv from socket + recv_data = _wilddog_coap_mallocRecvBuffer(arg->protocol); + wilddog_assert(recv_data, WILDDOG_ERR_NULL); + res = _wilddog_sec_recv(arg->protocol,(void*)recv_data,(s32)WILDDOG_PROTO_MAXSIZE); + if(res < 0 || res > WILDDOG_PROTO_MAXSIZE){ + _wilddog_coap_freeRecvBuffer(arg->protocol,recv_data); + wilddog_debug_level(WD_DEBUG_ERROR, "Receive failed, error = %d",res); + return WILDDOG_ERR_INVALID; + } + + //2. malloc coap buffer, handle coap, get token + pdu = coap_new_pdu(); + if(NULL == pdu){ + _wilddog_coap_freeRecvBuffer(arg->protocol,recv_data); + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc pdu failed!"); + return WILDDOG_ERR_NULL; + } + if(0 == coap_pdu_parse(recv_data, res,pdu)){ + coap_delete_pdu(pdu); + _wilddog_coap_freeRecvBuffer(arg->protocol,recv_data); + wilddog_debug_level(WD_DEBUG_ERROR, "Parse pdu failed!"); + return WILDDOG_ERR_INVALID; + } + if(pdu->hdr->version != COAP_DEFAULT_VERSION){ + coap_delete_pdu(pdu); + _wilddog_coap_freeRecvBuffer(arg->protocol,recv_data); + wilddog_debug_level(WD_DEBUG_ERROR, "Parse pdu failed!"); + return WILDDOG_ERR_INVALID; + } + //3. send pkt to upper + *(arg->p_message_id) = *(u32*)(pdu->hdr->token); + *(arg->p_out_data) = (u8*)pdu; + *(arg->p_out_data_len) = pdu->length; + return WILDDOG_ERR_NOERR; +} + +/* protocol :: coap interface */ +Wilddog_Func_T _wilddog_protocol_funcTable[WD_PROTO_CMD_MAX + 1] = +{ + (Wilddog_Func_T) _wilddog_coap_initSession,//init + (Wilddog_Func_T)NULL,//ping + (Wilddog_Func_T)NULL,//get + (Wilddog_Func_T)NULL,//set + (Wilddog_Func_T)NULL,//push + (Wilddog_Func_T)NULL,//remove + (Wilddog_Func_T)NULL,//on + (Wilddog_Func_T)NULL,//off + (Wilddog_Func_T)NULL,//dis set + (Wilddog_Func_T)NULL,//dis push + (Wilddog_Func_T)NULL,//dis remove + (Wilddog_Func_T)NULL,//dis cancel + (Wilddog_Func_T)NULL,//online + (Wilddog_Func_T)NULL,//offline + (Wilddog_Func_T)_wilddog_coap_recv_getPkt,//get pkt + (Wilddog_Func_T)_wilddog_coap_recv_freePkt//free pkt + NULL +}; + +/* + * Function: _wilddog_protocol_ioctl + * Description: the ioctl function of protocol + * Input: cmd: command + * arg: the arg + * flags: the flag, not used + * Output: N/A + * Return: if success, return WILDDOG_ERR_NOERR +*/ +size_t WD_SYSTEM _wilddog_protocol_ioctl + ( + Wilddog_Proto_Cmd_T cmd, + void *p_args, + int flags + ) +{ + if( cmd >= WD_PROTO_CMD_MAX || + cmd < 0) + return WILDDOG_ERR_INVALID; + + return (size_t)(_wilddog_protocol_funcTable[cmd])(p_args,flags); +} + +/* + * Function: _wilddog_protocol_init. + * Description: init protocol. + * + * Input: p_conn : connect layer pointer. + * + * Output: N/A. + * Return: Wilddog_Protocol_T type. +*/ +Wilddog_Protocol_T * WD_SYSTEM _wilddog_protocol_init(void *data) +{ + Wilddog_Protocol_T *protocol; + Wilddog_Conn_T* p_conn = data; + + wilddog_assert(p_conn, NULL); + + protocol = (Wilddog_Protocol_T*)wmalloc(sizeof(Wilddog_Protocol_T)); + + wilddog_assert(protocol, NULL); + + protocol->socketFd = -1; + protocol->host = p_conn->p_conn_repo->p_rp_url->p_url_host; + protocol->addr.port = WILDDOG_PORT; + protocol->callback = _wilddog_protocol_ioctl; + + //init socket and ip + if(WILDDOG_ERR_NOERR != _wilddog_sec_init(protocol)){ + wfree(protocol); + wilddog_debug_level(WD_DEBUG_ERROR, "Init secure failed!"); + return NULL; + } + + return protocol; +} + +/* + * Function: _wilddog_protocol_deInit. + * Description: DeInit protocol. + * + * Input: N/A. + * Output: N/A. + * Return: Wilddog_Return_T type . +*/ +Wilddog_Return_T WD_SYSTEM _wilddog_protocol_deInit(void *data) +{ + Wilddog_Conn_T *p_conn = (Wilddog_Conn_T*)data; + _wilddog_sec_deinit(p_conn->p_protocol); + + wfree(p_conn->p_protocol); + return WILDDOG_ERR_NOERR; +} + diff --git a/src/networking/coap/wilddog_protocol_coap.h b/src/networking/coap/wilddog_protocol_coap.h new file mode 100644 index 0000000..d0331a5 --- /dev/null +++ b/src/networking/coap/wilddog_protocol_coap.h @@ -0,0 +1,42 @@ +/* + * Wilddog.h + * + * Created on: 2015-12-12 + * Author: x + */ + +#ifndef __WILDDOG_CONN_COAP_H_ +#define __WILDDOG_CONN_COAP_H_ + +#include "pdu.h" +#include "wilddog.h" +#include "wilddog_url_parser.h" +#include "wilddog_conn.h" + +#define WILDDOG_COAP_TOKEN_LEN 4 +#define WILDDOG_COAP_SESSION_PATH ".cs" + +#define WILDDOG_COAP_CMD_INIT 0 +#define WILDDOG_COAP_CMD_GET 1 +#define WILDDOG_COAP_CMD_SET 2 +#define WILDDOG_COAP_CMD_PSH 3 +#define WILDDOG_COAP_CMD_RMV 4 +#define WILDDOG_COAP_CMD_ON 5 +#define WILDDOG_COAP_CMD_OFF 5 + +typedef struct WILDDOG_COAP_PKT_T{ + size_t size; + u8 command; + u8 version; /* protocol version */ + u8 type; /* type flag */ + u8 code; /* request method (value 1--10) or response code (value 40-255) */ + u16 token_length; /* length of Token */ + u16 mid; /* message id */ + u8 token[WILDDOG_COAP_TOKEN_LEN]; + Wilddog_Url_T * url; + u8 *data; + u16 data_len; +}Wilddog_Coap_Pkt_T; + +#endif /* __WILDDOG_CONN_COAP_H_ */ + diff --git a/src/secure/nosec/wilddog_nosec.c b/src/secure/nosec/wilddog_nosec.c index c34ad79..c23fe1a 100644 --- a/src/secure/nosec/wilddog_nosec.c +++ b/src/secure/nosec/wilddog_nosec.c @@ -2,10 +2,8 @@ #include "wilddog.h" #include "wilddog_config.h" #include "wilddog_port.h" -#include "wilddog_sec_host.h" - -STATIC Wilddog_Address_T l_addr_in; -STATIC int l_fd; +#include "wilddog_sec.h" +#include "wilddog_protocol.h" /* * Function: _wilddog_sec_send @@ -19,17 +17,18 @@ STATIC int l_fd; */ Wilddog_Return_T WD_SYSTEM _wilddog_sec_send ( + Wilddog_Protocol_T *protocol, void* p_data, s32 len ) { int res; - res = wilddog_send(l_fd,&l_addr_in, p_data, len); + res = wilddog_send(protocol->socketFd,&protocol->addr, p_data, len); if(res < 0) { - if(l_fd) - wilddog_closeSocket(l_fd); - wilddog_openSocket(&l_fd); + if(protocol->socketFd) + wilddog_closeSocket(protocol->socketFd); + wilddog_openSocket(&protocol->socketFd); } return res; } @@ -45,11 +44,12 @@ Wilddog_Return_T WD_SYSTEM _wilddog_sec_send */ int WD_SYSTEM _wilddog_sec_recv ( + Wilddog_Protocol_T *protocol, void* p_data, s32 len ) { - return wilddog_receive(l_fd, &l_addr_in, p_data, len, \ + return wilddog_receive(protocol->socketFd, &protocol->addr, p_data, len, \ WILDDOG_RECEIVE_TIMEOUT); } @@ -62,16 +62,17 @@ int WD_SYSTEM _wilddog_sec_recv * Return: Success: 0 */ Wilddog_Return_T WD_SYSTEM _wilddog_sec_init - ( - Wilddog_Str_T *p_host, - u16 d_port + ( + Wilddog_Protocol_T *protocol ) -{ - int res; - wilddog_openSocket(&l_fd); - res = _wilddog_sec_getHost(&l_addr_in,p_host,d_port); +{ + wilddog_assert(protocol, WILDDOG_ERR_NULL); - return res; + if(0 != wilddog_openSocket(&protocol->socketFd)){ + return WILDDOG_ERR_INVALID; + } + + return _wilddog_sec_getHost(&protocol->addr, protocol->host); } /* @@ -82,10 +83,11 @@ Wilddog_Return_T WD_SYSTEM _wilddog_sec_init * Output: N/A * Return: Success: 0 */ -Wilddog_Return_T WD_SYSTEM _wilddog_sec_deinit(void) +Wilddog_Return_T WD_SYSTEM _wilddog_sec_deinit(Wilddog_Protocol_T *protocol) { - if(l_fd) - wilddog_closeSocket(l_fd); + if(protocol->socketFd) + wilddog_closeSocket(protocol->socketFd); + protocol->socketFd = -1; return WILDDOG_ERR_NOERR; } /* @@ -99,8 +101,7 @@ Wilddog_Return_T WD_SYSTEM _wilddog_sec_deinit(void) */ Wilddog_Return_T _wilddog_sec_reconnect ( - Wilddog_Str_T *p_host, - u16 d_port, + Wilddog_Protocol_T *protocol, int retryNum ) { @@ -108,8 +109,8 @@ Wilddog_Return_T _wilddog_sec_reconnect Wilddog_Return_T ret = WILDDOG_ERR_INVALID; for(i = 0; i < retryNum; i++) { - _wilddog_sec_deinit(); - ret = _wilddog_sec_init(p_host, d_port); + _wilddog_sec_deinit(protocol); + ret = _wilddog_sec_init(protocol); if(WILDDOG_ERR_NOERR == ret) return ret; } diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index e56783c..445205c 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -28,1325 +28,276 @@ #include "wilddog_common.h" #include "wilddog_conn.h" -#include "wilddog_conn_manage.h" #include "wilddog_port.h" #include "wilddog_url_parser.h" #include "wilddog_payload.h" #include "wilddog_api.h" #include "test_lib.h" +#include "wilddog_protocol.h" -extern Wilddog_Return_T WD_SYSTEM _wilddog_node_setKey - ( - Wilddog_Node_T *node, - Wilddog_Str_T *key - ); +#define WILDDOG_RETRANSMIT_DEFAULT_INTERVAL (2*1000)//默认的重传间隔 +#define WILDDOG_DEFALUT_PING_INTERVAL (19*1000) //初始化的ping间隔 +#define WILDDOG_DEFAULT_PING_DELTA (10*1000) //ping的初始化步进间隔 -/* - * Function: _wilddog_conn_cb_set - * Description: conn layer set callback function . - * - * Input: p_cm_recv: recv packet. - * Output: N/A - * Return: N/A -*/ -STATIC void WD_SYSTEM _wilddog_conn_cb_set - ( - Wilddog_CM_Recv_T *p_cm_recv, - int flag - ) -{ - if( p_cm_recv->f_user_callback ) - p_cm_recv->f_user_callback(p_cm_recv->p_user_cb_arg,p_cm_recv->err); +STATIC INLINE u32 WD_SYSTEM _wilddog_conn_getNextSendTime(int count){ + return (_wilddog_getTime() + count * WILDDOG_RETRANSMIT_DEFAULT_INTERVAL); } -/* - * Function: _wilddog_conn_cb_push. - * Description: conn layer push callback function. - * - * Input: p_cm_recv: recv packet. - * Output: N/A. - * Return: N/A. -*/ -STATIC void WD_SYSTEM _wilddog_conn_cb_push - ( - Wilddog_CM_Recv_T *p_cm_recv, - int flag - ) -{ - if( p_cm_recv->f_user_callback ) - { - p_cm_recv->f_user_callback(p_cm_recv->p_recvData->p_dt_data,\ - p_cm_recv->p_user_cb_arg, \ - p_cm_recv->err); - } +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth_callback(){ + return 0; } -/* - * Function: _wilddog_conn_cb_get - * Description: serialize cbor to node type and call user call backet. - * - * Input: p_cm_recv: recv packet. - * Output: N/A - * Return: N/A -*/ -STATIC void WD_SYSTEM _wilddog_conn_cb_get - ( - Wilddog_CM_Recv_T *p_cm_recv, - int flag - ) -{ - Wilddog_Node_T* p_snapshot = NULL; - Wilddog_Str_T *p_path = NULL; - - if( p_cm_recv->p_recvData && \ - p_cm_recv->p_recvData->d_dt_len > 0 ) - { -#ifdef WILDDOG_SELFTEST - ramtest_skipLastmalloc(); -#endif - - p_snapshot = _wilddog_payload2Node(p_cm_recv->p_recvData ); - p_path = _wilddog_url_getKey(p_cm_recv->p_url_path); - - if( p_path ) - _wilddog_node_setKey(p_snapshot, p_path); - -#ifdef WILDDOG_SELFTEST - ramtest_caculate_nodeRam(); -#endif - } - -#ifdef WILDDOG_SELFTEST - ramtest_caculate_peakRam(); -#endif +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_pkt_data_free(Wilddog_Conn_Pkt_Data_T * p_data){ + Wilddog_Conn_Pkt_Data_T *curr, *tmp; + wilddog_assert(p_data, WILDDOG_ERR_NULL); - if(p_cm_recv->f_user_callback) - { - p_cm_recv->f_user_callback(p_snapshot, - p_cm_recv->p_user_cb_arg, - p_cm_recv->err); + LL_FOREACH_SAFE(p_data,curr,tmp){ + if(curr){ + LL_DELETE(p_data,curr); + wfree(curr->data); + wfree(curr); + } } - - if(p_snapshot) - wilddog_node_delete(p_snapshot); - - return; + return WILDDOG_ERR_NOERR; } -/* - * Function: _wilddog_conn_addUrl. - * Description: add host and path option. - * - * Input: p_url: url option. - * p_pkg: protocol package. - * Output: N/A - * Return: N/A -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_addUrl - ( - Wilddog_Url_T * p_url, - void *p_pkg - ) -{ - Protocol_Arg_Option_T pkg_option; - - if( p_url== NULL || - p_pkg == NULL) - return WILDDOG_ERR_INVALID; +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_deInit(Wilddog_Conn_Pkt_T * pkt){ + wilddog_assert(pkt, WILDDOG_ERR_NULL); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - /* add host.*/ - pkg_option.p_pkg = p_pkg; - pkg_option.p_options = p_url->p_url_host; - if( _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_HOST,&pkg_option,0) != \ - WILDDOG_ERR_NOERR ) - { - return WILDDOG_ERR_NULL; + if(pkt->p_proto_data){ + wfree(pkt->p_proto_data); + pkt->p_proto_data = NULL; } - - /* add path.*/ - pkg_option.p_pkg = p_pkg; - pkg_option.p_options = p_url->p_url_path; - if( _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_PATH,&pkg_option,0) != \ - WILDDOG_ERR_NOERR ) - { - return WILDDOG_ERR_NULL; + if(pkt->p_data){ + _wilddog_conn_pkt_data_free(pkt->p_data); + pkt->p_data = NULL; } - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_conn_getCborPayload. - * Description: node transition to cbor payload. - * Input: p_node: node data. - * p_pkg: protocol package. - * Output: N/A - * Return: N/A -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_getCborPayload - ( - Protocol_Arg_Payload_T *p_cbor_hd, - Wilddog_Node_T *p_snode - ) -{ - Wilddog_Payload_T *p_nodeData = NULL; - - wilddog_assert(p_cbor_hd,WILDDOG_ERR_INVALID); - wilddog_assert(p_snode,WILDDOG_ERR_INVALID); - - p_nodeData = _wilddog_node2Payload(p_snode); - - if( p_nodeData ) - { - p_cbor_hd->p_payload = p_nodeData->p_dt_data; - p_cbor_hd->d_payloadLen = p_nodeData->d_dt_len; - wfree(p_nodeData); - - return WILDDOG_ERR_NOERR; + if(pkt->p_url){ + _wilddog_url_freeParsedUrl(pkt->p_url); + pkt->p_url = NULL; } - else - return WILDDOG_ERR_NULL; -} - -STATIC int WD_SYSTEM _wilddog_conn_send - ( - Wilddog_Conn_Cmd_T cmd, - void *p_pkg, - u32 token, - Wilddog_ConnCmd_Arg_T *p_arg - ) -{ - Wilddog_CM_UserArg_T sendArg; - - memset(&sendArg,0,sizeof(Wilddog_CM_UserArg_T)); - /* todo send to */ - sendArg.cmd = cmd; - sendArg.p_cm_l = p_arg->p_repo->p_rp_conn->p_cm_l; - sendArg.p_pkg = (void*)p_pkg; - sendArg.f_userCB = p_arg->p_complete; - sendArg.f_userCB_arg = p_arg->p_completeArg; - sendArg.d_token = token; - return _wilddog_cm_ioctl( CM_CMD_USERSEND,&sendArg,0); - -} -/* count protocol sizeof*/ -STATIC int WD_SYSTEM _wilddog_conn_countPakgeSize - ( - Wilddog_ConnCmd_Arg_T *p_arg, - u32 s_payloadLen, - u32 s_externLen - ) -{ - Protocol_Arg_CountSize_T pkg_sizeCount; - - memset(&pkg_sizeCount,0,sizeof(Protocol_Arg_CountSize_T)); - - /*count package size.*/ - if(p_arg->p_url) - { - pkg_sizeCount.p_host = p_arg->p_url->p_url_host; - pkg_sizeCount.p_path = p_arg->p_url->p_url_path; - } - pkg_sizeCount.p_query = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, - p_arg->p_repo->p_rp_conn->p_cm_l,0); - - pkg_sizeCount.d_extendLen = s_externLen; - pkg_sizeCount.d_payloadLen = s_payloadLen; - - return (int)_wilddog_protocol_ioctl(_PROTOCOL_CMD_COUNTSIZE,&pkg_sizeCount,0); -} -STATIC int WD_SYSTEM _wilddog_conn_get - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = NULL; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_GET; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - - pkg_arg.d_token = (u32)_wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*count pakage size*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg,0,0); - /* creat coap package.*/ - p_pkg_index = (void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) - return WILDDOG_ERR_NULL; - - /* add host.*/ - /* add path.*/ - if(_wilddog_conn_addUrl(p_arg->p_url,p_pkg_index) != WILDDOG_ERR_NOERR) - goto _CONN_GET_ERR; - /* add query - auth.*/ - pkg_option.p_pkg = p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_GET_ERR; - - /* send to */ - res = _wilddog_conn_send(WILDDOG_CONN_CMD_GET, - p_pkg_index, - pkg_arg.d_token, - p_arg); - if(res < 0) - goto _CONN_GET_ERR; - - return res; - -_CONN_GET_ERR: - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,p_pkg_index,0); - return res; -} - -STATIC int WD_SYSTEM _wilddog_conn_set(Wilddog_ConnCmd_Arg_T *p_arg,int flags) -{ - void* p_pkg_index = 0; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Protocol_Arg_Payload_T pkg_cborPayload; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_data,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - memset(&pkg_cborPayload,0,sizeof(Protocol_Arg_Payload_T)); - - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_SET; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*get payload len.*/ - if( _wilddog_conn_getCborPayload(&pkg_cborPayload,p_arg->p_data) < 0 ) - return WILDDOG_ERR_INVALID; - - /*get package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg, \ - pkg_cborPayload.d_payloadLen, \ - 0); - - /* creat coap package.*/ - p_pkg_index = (void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) - return WILDDOG_ERR_NULL; - - /* add host.*/ - /* add path.*/ - if(_wilddog_conn_addUrl(p_arg->p_url,p_pkg_index) != WILDDOG_ERR_NOERR) - goto _CONN_SET_ERR; - /* add query - token.*/ - pkg_option.p_pkg = p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if(res != WILDDOG_ERR_NOERR) - goto _CONN_SET_ERR; - - /*add payload*/ - pkg_cborPayload.p_pkg = p_pkg_index; - - res = (int)_wilddog_protocol_ioctl(_PROTOCOL_CMD_ADD_DATA, \ - &pkg_cborPayload, \ - 0); - if( res < 0) - goto _CONN_SET_ERR; - - - /* todo send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - if(res < 0) - goto _CONN_SET_ERR; - - wfree(pkg_cborPayload.p_payload); - - return res; - -_CONN_SET_ERR: - - wfree(pkg_cborPayload.p_payload); - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; - -} - -STATIC int WD_SYSTEM _wilddog_conn_push - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Protocol_Arg_Payload_T pkg_cborPayload; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_data,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - memset(&pkg_cborPayload,0,sizeof(Protocol_Arg_Payload_T)); - - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_PUSH; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*get payload len.*/ - if(_wilddog_conn_getCborPayload(&pkg_cborPayload,p_arg->p_data) < 0 ) - return WILDDOG_ERR_INVALID; - /*get package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg, \ - pkg_cborPayload.d_payloadLen, \ - 0); - - /* creat coap package.*/ - p_pkg_index =(void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) - return WILDDOG_ERR_NULL; - - /* add host.*/ - /* add path.*/ - if(_wilddog_conn_addUrl(p_arg->p_url,(void*)p_pkg_index) != WILDDOG_ERR_NOERR) - goto _CONN_PUSH_ERR; - /* add query - auth.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_PUSH_ERR; - /*add payload*/ - pkg_cborPayload.p_pkg = p_pkg_index; - - res = (int)_wilddog_protocol_ioctl(_PROTOCOL_CMD_ADD_DATA, \ - &pkg_cborPayload, \ - 0); - - if( res < 0) - goto _CONN_PUSH_ERR; - - - /* send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - - if( res < 0) - goto _CONN_PUSH_ERR; - - wfree(pkg_cborPayload.p_payload); - - return res; - -_CONN_PUSH_ERR: - - wfree(pkg_cborPayload.p_payload); - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; + return WILDDOG_ERR_NOERR; } -STATIC int WD_SYSTEM _wilddog_conn_remove - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_REMOVE; - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - - pkg_arg.d_token = (u32)_wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - /*count package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg,0,0); +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_init(Wilddog_Conn_Pkt_T * pkt,Wilddog_Conn_T *p_conn){ + wilddog_assert(pkt&&p_conn, WILDDOG_ERR_NULL); - /* creat coap package.*/ - p_pkg_index = (void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) + pkt->p_url = (Wilddog_Url_T*)wmalloc(sizeof(Wilddog_Url_T)); + if(NULL == pkt->p_url){ + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); return WILDDOG_ERR_NULL; - - /* add host.*/ - /* add path.*/ - if(_wilddog_conn_addUrl(p_arg->p_url,(void*)p_pkg_index) != WILDDOG_ERR_NOERR) - goto _CONN_REMOVE_ERR; - /* add query - token.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_REMOVE_ERR; - /* send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - - if( res < 0 ) - goto _CONN_REMOVE_ERR; - - return res; - -_CONN_REMOVE_ERR: - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; - -} - -STATIC int WD_SYSTEM _wilddog_conn_on - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - u8 observerValue = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Wilddog_CM_UserArg_T sendArg; - //Wilddog_CM_FindNode_Arg_T nodeFind_arg; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - /*if the path have been observer aleady,Ignore the request* - if( p_arg->p_repo->p_rp_conn->p_cm_l && - p_arg->p_repo->p_rp_conn->p_cm_l->p_cm_n_hd - ) - { - nodeFind_arg.path = p_arg->p_url->p_url_path; - nodeFind_arg.p_node_hd = p_arg->p_repo->p_rp_conn->p_cm_l->p_cm_n_hd; - if(_wilddog_cm_ioctl(CM_CMD_OBSERVER_ALEADY,&nodeFind_arg,0)) - return WILDDOG_ERR_NOERR; - } - */ - //wilddog_debug("observer path %s", p_arg->p_url->p_url_path); - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - memset(&sendArg,0,sizeof(Wilddog_CM_UserArg_T)); - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_ON; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*count package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg,0,0); - - /* creat coap package.*/ - p_pkg_index =(void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) - return WILDDOG_ERR_NULL; - - /* add host.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = p_arg->p_url->p_url_host; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_HOST,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_ON_ERR; - /* add query - observer.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)&observerValue; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_OBSERVER,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_ON_ERR; - /* add path.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = p_arg->p_url->p_url_path; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_PATH,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_ON_ERR; - - /* add token.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_ON_ERR; - - /* todo send to */ - sendArg.cmd = WILDDOG_CONN_CMD_ON; - sendArg.d_token = pkg_arg.d_token; - sendArg.p_cm_l = p_arg->p_repo->p_rp_conn->p_cm_l; - sendArg.p_pkg = (void*)p_pkg_index; - sendArg.f_userCB = p_arg->p_complete; - sendArg.f_userCB_arg = p_arg->p_completeArg; - sendArg.p_path = p_arg->p_url->p_url_path; - - if( (res = _wilddog_cm_ioctl( CM_CMD_USERSEND,&sendArg,0))< 0) - goto _CONN_ON_ERR; - - return res; - -_CONN_ON_ERR: - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; + } -} -STATIC int WD_SYSTEM _wilddog_conn_off - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - int res = 0; - void* p_pkg_index = 0; - u8 observerValue = 1; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Wilddog_CM_OffArg_T deleNodeArg; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_OFF; - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*count package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg,0,0); - - /* creat coap package.*/ - p_pkg_index = (void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) + if(WILDDOG_ERR_NOERR != _wilddog_url_copy(p_conn->p_conn_repo->p_rp_url, pkt->p_url)){ + wfree(pkt->p_url); + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); return WILDDOG_ERR_NULL; - - /* add host.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = p_arg->p_url->p_url_host; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_HOST,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_OFF_ERR; - /* add query - observer.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)&observerValue; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_OBSERVER,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_OFF_ERR; - /* add path.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = p_arg->p_url->p_url_path; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_PATH,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_OFF_ERR; - - /* add query - token.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_OFF_ERR; - - /*delete on node */ - deleNodeArg.p_cm_l = p_arg->p_repo->p_rp_conn->p_cm_l; - deleNodeArg.p_path = p_arg->p_url->p_url_path; - - res = _wilddog_cm_ioctl( CM_CMD_DELENODE_BYPATH,&deleNodeArg,0); - if( res < 0 ) - goto _CONN_OFF_ERR; - /* todo send to */ - - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index,pkg_arg.d_token, \ - p_arg); - if( res < 0 ) - goto _CONN_OFF_ERR; - - return res; - -_CONN_OFF_ERR: - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; - -} - -STATIC int WD_SYSTEM _wilddog_conn_auth - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - u8 *p_buf = NULL; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Protocol_Arg_Payload_T authData; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - memset(&authData,0,sizeof(Protocol_Arg_Payload_T)); - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_AUTH; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, - 0); - - /* get auth data and payload size*/ - authData.d_payloadLen = p_arg->p_repo->p_rp_store->p_se_callback( - p_arg->p_repo->p_rp_store,\ - WILDDOG_STORE_CMD_GETAUTH, \ - &p_buf, \ - 0); - - authData.p_payload = p_buf; - /* count pakge size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg, \ - authData.d_payloadLen, \ - 0); - /* creat coap package.*/ - p_pkg_index = (void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) + } + pkt->p_data = (Wilddog_Conn_Pkt_Data_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_Data_T)); + if(NULL == pkt->p_data){ + _wilddog_url_freeParsedUrl(pkt->p_url); + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); return WILDDOG_ERR_NULL; - - /* add host.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = p_arg->p_url->p_url_host; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_HOST,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_AUTH_ERR; - - /* add path.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = _CM_AUTHR_PATH; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_PATH,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_AUTH_ERR; - - /*add payload.*/ - authData.p_pkg = (void*)p_pkg_index; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_DATA,&authData,0); - if(res < 0) - goto _CONN_AUTH_ERR; - /*20160711 skyli : delete all auth node to guarantee user auth send alone*/ - _wilddog_cm_ioctl( CM_CMD_AUTH_DELETE,p_arg->p_repo->p_rp_conn->p_cm_l,0); - /* send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - if( res < 0) - goto _CONN_AUTH_ERR; - - return res; - -_CONN_AUTH_ERR: - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; + } + pkt->p_complete = NULL; + pkt->d_count = 0; + pkt->d_next_send_time = 0; + pkt->d_message_id = 0; + pkt->next = NULL; + return WILDDOG_ERR_NOERR; } - -STATIC int WD_SYSTEM _wilddog_conn_onDisSet - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Protocol_Arg_Payload_T pkg_cborPayload; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - memset(&pkg_cborPayload,0,sizeof(Protocol_Arg_Payload_T)); - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_ONDISSET; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*get payload len.*/ - if( _wilddog_conn_getCborPayload(&pkg_cborPayload,p_arg->p_data) < 0 ) - return WILDDOG_ERR_INVALID; - - /*count package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg, - pkg_cborPayload.d_payloadLen, - (strlen(_CM_ONDIS)+PROTOCOL_QUERY_HEADLEN)); - - /* creat coap package.*/ - p_pkg_index = (void*) _wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) - return WILDDOG_ERR_NULL; - - /* add host.*/ - /* add path.*/ - res = _wilddog_conn_addUrl(p_arg->p_url,(void*)p_pkg_index); - if( res != WILDDOG_ERR_NOERR) - goto _CONN_DISSET_ERR; - /* add query - token.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_DISSET_ERR; - /* add query -.dis.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_CM_ONDIS; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_DISSET_ERR; - - /*add payload*/ - pkg_cborPayload.p_pkg = p_pkg_index; - - res =(int)_wilddog_protocol_ioctl(_PROTOCOL_CMD_ADD_DATA,&pkg_cborPayload,0); - if( res < 0) - goto _CONN_DISSET_ERR; - - - /* send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - if( res < 0) - goto _CONN_DISSET_ERR; - - wfree(pkg_cborPayload.p_payload); - return res; - -_CONN_DISSET_ERR: - - wfree(pkg_cborPayload.p_payload); - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; +STATIC BOOL WD_SYSTEM _wilddog_conn_midCmp(u32 s_mid,u32 d_mid){ + if((s_mid & 0xffffffff) == (d_mid & 0xffffffff)){ + return TRUE; + } + return FALSE; } -STATIC int WD_SYSTEM _wilddog_conn_onDisPush - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Protocol_Arg_Payload_T pkg_cborPayload; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - memset(&pkg_cborPayload,0,sizeof(Protocol_Arg_Payload_T)); - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_ONDISPUSH; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*get payload len.*/ - if( _wilddog_conn_getCborPayload(&pkg_cborPayload,p_arg->p_data) < 0 ) - return WILDDOG_ERR_INVALID; - - /*count package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg, - pkg_cborPayload.d_payloadLen, - (strlen(_CM_ONDIS)+PROTOCOL_QUERY_HEADLEN)); - - /* creat coap package.*/ - p_pkg_index = (void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) - return WILDDOG_ERR_NULL; - - /* add host.*/ - /* add path.*/ - - res = _wilddog_conn_addUrl(p_arg->p_url,(void*)p_pkg_index); - if( res != WILDDOG_ERR_NOERR) - goto _CONN_DISPUSH_ERR; - /* add query - token.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_DISPUSH_ERR; - /* add query -.dis.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_CM_ONDIS; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_DISPUSH_ERR; - - /*add payload*/ - pkg_cborPayload.p_pkg = p_pkg_index; - - res=(int)_wilddog_protocol_ioctl(_PROTOCOL_CMD_ADD_DATA,&pkg_cborPayload,0); - if( res < 0) - goto _CONN_DISPUSH_ERR; - - - /* send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - if( res < 0) - goto _CONN_DISPUSH_ERR; - - wfree(pkg_cborPayload.p_payload); - return res; - -_CONN_DISPUSH_ERR: - - wfree(pkg_cborPayload.p_payload); - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; - +/* + * find the send packet matched with received packet +*/ +STATIC Wilddog_Conn_Pkt_T * WD_SYSTEM _wilddog_conn_recv_sendPktFind(Wilddog_Conn_T *p_conn,u32 mid){ + wilddog_assert(p_conn NULL); + + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + if(TRUE == _wilddog_conn_midCmp(mid,p_conn->d_conn_sys->p_ping->d_message_id)){ + return p_conn->d_conn_sys.p_ping; + } + else{ + Wilddog_Conn_Pkt_T *curr, *tmp; + //observe list check + LL_FOREACH_SAFE(p_conn->d_conn_user->p_observer_list,curr,tmp){ + if(TRUE == _wilddog_conn_midCmp(mid,curr->d_message_id)){ + return curr; + } + } + //rest list check + LL_FOREACH_SAFE(p_conn->d_conn_user->p_rest_list,curr,tmp){ + if(TRUE == _wilddog_conn_midCmp(mid,curr->d_message_id)){ + return curr; + } + } + //others, also include auth pkt, do not match them. + } + }else if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHING){ + if(TRUE == _wilddog_conn_midCmp(mid, p_conn->d_conn_sys.p_auth->d_message_id)){ + //match, is the auth callback! + return p_conn->d_conn_sys.p_auth; + } + else{ + //bye bye, we don't care who you are. + return NULL; + } + }else{ + wilddog_debug_level(WD_DEBUG_WARN, "Receive packet, but client was not registered yet."); + return NULL; + } + return NULL; } +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionInit(Wilddog_Conn_T *p_conn){ + Wilddog_Session_T *p_session; + Wilddog_Conn_Pkt_T *pkt; + Wilddog_Proto_Cmd_Arg_T command; -STATIC int WD_SYSTEM _wilddog_conn_onDisRemove - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + wilddog_assert(p_conn->p_conn_repo->p_rp_store, WILDDOG_ERR_NULL); - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_ONDISREMOVE; + p_session = &p_conn->d_session; + memset(p_session, 0, sizeof(Wilddog_Session_T)); - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*count package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg, \ - 0, \ - (strlen(_CM_ONDIS)+PROTOCOL_QUERY_HEADLEN)); - /* creat coap package.*/ - p_pkg_index =(void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + if(NULL == pkt){ return WILDDOG_ERR_NULL; - - /* add host.*/ - /* add path.*/ - res = _wilddog_conn_addUrl(p_arg->p_url,(void*)p_pkg_index); - if( res != WILDDOG_ERR_NOERR) - goto _CONN_DISREMOVE_ERR; - /* add query - token.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, - p_arg->p_repo->p_rp_conn->p_cm_l,0); + } - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_DISREMOVE_ERR; - /* add query -.dis.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_CM_ONDIS; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_DISREMOVE_ERR; - - /* send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - if( res < 0 ) - goto _CONN_DISREMOVE_ERR; - - return res; - -_CONN_DISREMOVE_ERR: - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; - -} - -STATIC int WD_SYSTEM _wilddog_conn_cancelDis - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - wilddog_assert(p_arg->p_url,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_CANCELDIS; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - - /*count package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg, \ - 0, \ - (strlen(_CM_DISCANCEL)+PROTOCOL_QUERY_HEADLEN)); - /* creat coap package.*/ - p_pkg_index =(void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if(p_pkg_index == 0) + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); return WILDDOG_ERR_NULL; - - /* add host.*/ - /* add path.*/ - res = _wilddog_conn_addUrl(p_arg->p_url,(void*)p_pkg_index); - if( res != WILDDOG_ERR_NOERR) - goto _CONN_CANCELDIS_ERR; - /* add query - token.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN,\ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_CANCELDIS_ERR; - /* add query -.dis.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_CM_DISCANCEL; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_CANCELDIS_ERR; - - /* send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - if( res < 0) - goto _CONN_CANCELDIS_ERR; - - return res; - -_CONN_CANCELDIS_ERR: - - _wilddog_protocol_ioctl( _PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; + } + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_auth_callback; + //add to auth queue + if(p_conn->d_conn_sys.p_auth){ + _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_auth); + } + p_conn->d_conn_sys.p_auth = pkt; + + //send to server + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = &(p_conn->d_conn_sys.p_auth->p_data->data); + command.p_out_data_len = &(p_conn->d_conn_sys.p_auth->p_data->len); + //get user auth token + if(p_conn->p_conn_repo->p_rp_store->p_se_callback){ + command.d_data_len = (p_conn->p_conn_repo->p_rp_store->p_se_callback)( + p_conn->p_conn_repo->p_rp_store, + WILDDOG_STORE_CMD_GETAUTH,&command.p_data,0); + } + if(p_conn->p_protocol->callback){ + if(WILDDOG_ERR_NOERR == \ + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SESSION_INIT, &command, 0)){ + //change status to authing + p_session->d_session_status = WILDDOG_SESSION_AUTHING; + } + } + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + return WILDDOG_ERR_NOERR; } +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_trySync(void* data,int flag){ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + u32 message_id = 0; + Wilddog_Conn_T *p_conn; + u8* recvPkt = NULL; + u32 recvPkt_len = 0; + Wilddog_Conn_Pkt_T * sendPkt = NULL; + + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + command.protocol = p_conn->p_protocol; + + wilddog_assert(p_conn && command.protocol,WILDDOG_ERR_NULL); + + command.p_out_data = &recvPkt; + command.p_out_data_len = &recvPkt_len; + command.d_data_len = 0; + command.p_url = arg->p_url; + command.p_message_id = &message_id; + //1. receive packet + if(p_conn->p_protocol->callback){ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_GETPKT, &command, 0); + } + if(WILDDOG_ERR_NOERR != ret){ + return ret; + } -STATIC int WD_SYSTEM _wilddog_conn_offLine - ( - Wilddog_ConnCmd_Arg_T *p_arg, \ - int flags - ) -{ - void* p_pkg_index = 0; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_OFFLINE; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_ioctl(CM_CMD_GET_INDEX,NULL,0); - pkg_arg.d_token = _wilddog_cm_ioctl(CM_CMD_GET_TOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - /*count package size.*/ - pkg_arg.d_packageLen = _wilddog_conn_countPakgeSize(p_arg, - 0, - (strlen(_CM_OFFLINE_PATH)+PROTOCOL_PATH_HEADLEN)); - - /* creat coap package.*/ - p_pkg_index =(void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == 0) - return WILDDOG_ERR_NULL; - - /* add host.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = p_arg->p_repo->p_rp_url->p_url_host; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_HOST,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_OFFLINE_ERR; - - /* add path.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = _CM_OFFLINE_PATH; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_PATH,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_OFFLINE_ERR; - - /* add query - token.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = (void*)_wilddog_cm_ioctl(CM_CMD_SHORTTOKEN, \ - p_arg->p_repo->p_rp_conn->p_cm_l, \ - 0); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CONN_OFFLINE_ERR; - - /* send to */ - res = (int)_wilddog_conn_send(pkg_arg.cmd, \ - (void*)p_pkg_index, \ - pkg_arg.d_token, \ - p_arg); - if( res < 0) - goto _CONN_OFFLINE_ERR; - - /* todo set system offline .*/ - return _wilddog_cm_ioctl(CM_CMD_OFFLINE,p_arg->p_repo->p_rp_conn->p_cm_l,0); - - _CONN_OFFLINE_ERR: - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; -} - -STATIC int WD_SYSTEM _wilddog_conn_onLine - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - wilddog_assert(p_arg,WILDDOG_ERR_INVALID); - - /*set online.*/ - return _wilddog_cm_ioctl(CM_CMD_ONLINE,p_arg->p_repo->p_rp_conn->p_cm_l,0); -} - -/* - * Function: _wilddog_conn_trySync - * Description: conn layer try sync function - * - * Input: p_repo: the pointer of the repo struct - * Output: N/A - * Return: the result -*/ -STATIC int WD_SYSTEM _wilddog_conn_trysync - ( - Wilddog_ConnCmd_Arg_T *p_arg, - int flags - ) -{ - if( !p_arg || !p_arg->p_repo ||\ - !p_arg->p_repo->p_rp_conn||\ - !p_arg->p_repo->p_rp_conn->p_cm_l) - return WILDDOG_ERR_INVALID; + //2. try to find the send pkt which has same message id, + //but if we are not authed, only accept auth pkt. + sendPkt == _wilddog_conn_recv_sendPktFind(p_conn,message_id); + if(NULL == sendPkt){ + //delete the recvPkt. + if(p_conn->p_protocol->callback){ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_FREEPKT, &command, 0); + } + wilddog_debug_level(WD_DEBUG_WARN, "Received an unmatched packet, mid = 0x%x!",message_id); + return ret; + } + //3. handle packet + command.p_data = sendPkt->p_data; + command.p_proto_data = sendPkt->p_proto_data; + if(p_conn->p_protocol->callback){ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_HANDLEPKT, &command, 0); + } + //4. state machine - return _wilddog_cm_ioctl(CM_CMD_TRYSYNC,p_arg->p_repo->p_rp_conn->p_cm_l,0); -} -/* call back interface */ -Wilddog_Func_T _wilddog_connCallBack_funcTable[WILDDOG_CONN_CBCMD_MAX + 1] = -{ - (Wilddog_Func_T)_wilddog_conn_cb_get, //WILDDOG_CONN_CBCMD_GET - (Wilddog_Func_T)_wilddog_conn_cb_set, //WILDDOG_CONN_CBCMD_SET - (Wilddog_Func_T)_wilddog_conn_cb_push,//WILDDOG_CONN_CBCMD_PUSH - (Wilddog_Func_T)_wilddog_conn_cb_set, //_wilddog_conn_cb_remove, - (Wilddog_Func_T)_wilddog_conn_cb_get, //wilddog_conn_cb_on, - (Wilddog_Func_T)_wilddog_conn_cb_set, //lddog_conn_cb_off, - (Wilddog_Func_T)_wilddog_conn_cb_set, //lddog_conn_cb_auth, - - (Wilddog_Func_T)_wilddog_conn_cb_set, //WILDDOG_CONN_CBCMD_ONDISSET, - (Wilddog_Func_T)_wilddog_conn_cb_set, //WILDDOG_CONN_CBCMD_ONDISPUSH, - (Wilddog_Func_T)_wilddog_conn_cb_set, //WILDDOG_CONN_CBCMD_ONDISREMOVE, - - (Wilddog_Func_T)_wilddog_conn_cb_set, //WILDDOG_CONN_CBCMD_CANCELDIS, - (Wilddog_Func_T)_wilddog_conn_cb_set, //WILDDOG_CONN_CBCMD_ONLINE - (Wilddog_Func_T)_wilddog_conn_cb_set, //WILDDOG_CONN_CBCMD_OFFLINE, - NULL -}; -STATIC int WD_SYSTEM _wilddog_conn_cb_ioctl - ( - Wilddog_Conn_CBCmd_T cmd, - void *p_args, - int flags - ) -{ - if( cmd > WILDDOG_CONN_CBCMD_MAX || \ - cmd < 0) - return WILDDOG_ERR_INVALID; - - return (_wilddog_connCallBack_funcTable[cmd])(p_args,flags); + //5. if has retransmit packet, send + return ret; } - /* send interface */ Wilddog_Func_T _wilddog_conn_funcTable[WILDDOG_CONN_CMD_MAX + 1] = { - - - (Wilddog_Func_T)_wilddog_conn_get, - (Wilddog_Func_T)_wilddog_conn_set, - (Wilddog_Func_T)_wilddog_conn_push, - (Wilddog_Func_T)_wilddog_conn_remove, - (Wilddog_Func_T)_wilddog_conn_on, - (Wilddog_Func_T)_wilddog_conn_off, - (Wilddog_Func_T)_wilddog_conn_auth, - - (Wilddog_Func_T)_wilddog_conn_onDisSet, - (Wilddog_Func_T)_wilddog_conn_onDisPush, - (Wilddog_Func_T)_wilddog_conn_onDisRemove, - - (Wilddog_Func_T)_wilddog_conn_cancelDis, - - (Wilddog_Func_T)_wilddog_conn_offLine, - (Wilddog_Func_T)_wilddog_conn_onLine, - (Wilddog_Func_T)_wilddog_conn_trysync, - - (Wilddog_Func_T)_wilddog_conn_init, - (Wilddog_Func_T)_wilddog_conn_deinit, - - NULL + (Wilddog_Func_T)NULL,//get + (Wilddog_Func_T)NULL,//set + (Wilddog_Func_T)NULL,//push + (Wilddog_Func_T)NULL,//remove + (Wilddog_Func_T)NULL,//on + (Wilddog_Func_T)NULL,//off + (Wilddog_Func_T)NULL,//auth + (Wilddog_Func_T)NULL,//ondisset + (Wilddog_Func_T)NULL,//ondispush + (Wilddog_Func_T)NULL,//ondisremove + (Wilddog_Func_T)NULL,//ondiscancel + (Wilddog_Func_T)NULL,//offline + (Wilddog_Func_T)NULL,//online + (Wilddog_Func_T)_wilddog_conn_trySync,//trysync + (Wilddog_Func_T)NULL }; -STATIC int WD_SYSTEM _wilddog_conn_ioctl - ( +STATIC int WD_SYSTEM _wilddog_conn_ioctl( Wilddog_Conn_Cmd_T cmd, void *p_args, int flags ) { - if( cmd > WILDDOG_CONN_CMD_MAX || - cmd < 0) + if( cmd >= WILDDOG_CONN_CMD_MAX ) return WILDDOG_ERR_INVALID; - - return (_wilddog_conn_funcTable[cmd])(p_args,flags); + + if(_wilddog_conn_funcTable[cmd]){ + return (_wilddog_conn_funcTable[cmd])(p_args,flags); + } + else{ + wilddog_debug_level(WD_DEBUG_ERROR, "Cannot find function %d!",cmd); + return WILDDOG_ERR_NULL; + } } - - /* * Function: _wilddog_conn_init * Description: creat session and register send and trysync function. @@ -1355,55 +306,97 @@ STATIC int WD_SYSTEM _wilddog_conn_ioctl * Output: N/A * Return: the result */ -Wilddog_Conn_T * WD_SYSTEM _wilddog_conn_init(Wilddog_Repo_T* p_repo) +Wilddog_Conn_T * WD_SYSTEM _wilddog_conn_init(Wilddog_Repo_T *p_repo) { - Wilddog_CM_InitArg_T cm_initArg; - Wilddog_Conn_T* p_repo_conn = NULL; + Wilddog_Conn_T* p_conn = NULL; - if(!p_repo) - return NULL; + wilddog_assert(p_repo, NULL); - p_repo_conn = (Wilddog_Conn_T*)wmalloc(sizeof(Wilddog_Conn_T)); - if( NULL ==p_repo_conn) - return NULL; - - p_repo_conn->p_conn_repo = p_repo; - p_repo->p_rp_conn = p_repo_conn; - p_repo_conn->f_conn_ioctl = (Wilddog_Func_T)_wilddog_conn_ioctl; + p_conn = (Wilddog_Conn_T*)wmalloc(sizeof(Wilddog_Conn_T)); - cm_initArg.p_repo= p_repo; - cm_initArg.f_conn_cb = (Wilddog_Func_T)_wilddog_conn_cb_ioctl; + wilddog_assert(p_conn, NULL); - p_repo_conn->p_cm_l = (void*)_wilddog_cm_ioctl( CM_CMD_INIT,&cm_initArg,0); - if( p_repo_conn->p_cm_l == NULL ) - { - wfree(p_repo_conn); - p_repo_conn = NULL; + p_conn->p_conn_repo = p_repo; + p_conn->f_conn_ioctl = (Wilddog_Func_T)_wilddog_conn_ioctl; + p_conn->d_conn_sys.d_curr_ping_interval = WILDDOG_DEFALUT_PING_INTERVAL; + p_conn->d_conn_sys.d_ping_delta = WILDDOG_DEFAULT_PING_DELTA; + + //Init protocol layer. + p_conn->p_protocol = _wilddog_protocol_init(p_conn); + if(NULL == p_conn->p_protocol){ + wfree(p_conn); + wilddog_debug_level(WD_DEBUG_ERROR, "Init protocol failed!"); + return NULL; + } + + //Init session. + if(WILDDOG_ERR_NOERR != _wilddog_conn_sessionInit(p_conn)){ + _wilddog_protocol_deInit(p_conn); + wfree(p_conn); + wilddog_debug_level(WD_DEBUG_ERROR, "Init session failed!"); + return NULL; } - return p_repo_conn; + return p_conn; } - /* * Function: _wilddog_conn_deinit * Description: conn layer deinit function * * Input: p_repo: the pointer of the repo struct * Output: N/A - * Return: the pointer of the conn struct + * Return: 0 or errorcode */ -Wilddog_Conn_T* WD_SYSTEM _wilddog_conn_deinit(Wilddog_Repo_T*p_repo) +Wilddog_Return_T WD_SYSTEM _wilddog_conn_deinit(Wilddog_Repo_T *p_repo) { - if( !p_repo || !p_repo->p_rp_conn ) - return NULL; + Wilddog_Conn_T* p_conn = NULL; + + wilddog_assert(p_repo, WILDDOG_ERR_NULL); + + p_conn = p_repo->p_rp_conn; - /* destory list.*/ - _wilddog_cm_ioctl(CM_CMD_DEINIT,p_repo->p_rp_conn->p_cm_l,0); + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + //TODO: Deinit pkts + if(p_conn->d_conn_sys.p_auth){ + _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_auth); + wfree(p_conn->d_conn_sys.p_auth); + p_conn->d_conn_sys.p_auth = NULL; + } + if(p_conn->d_conn_sys.p_ping){ + _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_ping); + wfree(p_conn->d_conn_sys.p_ping); + p_conn->d_conn_sys.p_ping = NULL; + } + if(p_conn->d_conn_user.p_observer_list){ + Wilddog_Conn_Pkt_T *curr, *p_tmp; + LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,p_tmp){ + if(curr){ + LL_DELETE(p_conn->d_conn_user.p_observer_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + } + } + } + p_conn->d_conn_user.p_observer_list = NULL; + + if(p_conn->d_conn_user.p_rest_list){ + Wilddog_Conn_Pkt_T *curr, *p_tmp; + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,p_tmp){ + if(curr){ + LL_DELETE(p_conn->d_conn_user.p_rest_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + } + } + } + p_conn->d_conn_user.p_rest_list = NULL; + //TODO: Deinit session. - wfree( p_repo->p_rp_conn); + //TODO: Deinit protocol layer. + _wilddog_protocol_deInit(p_conn); + wfree(p_conn); p_repo->p_rp_conn = NULL; - - return NULL; -} + return WILDDOG_ERR_NOERR; +} diff --git a/src/wilddog_conn.h b/src/wilddog_conn.h index 803363e..d3b01f9 100644 --- a/src/wilddog_conn.h +++ b/src/wilddog_conn.h @@ -20,10 +20,10 @@ extern "C" { #endif -#include "wilddog_conn_manage.h" #include "wilddog_config.h" #include "wilddog_ct.h" - +#include "wilddog_protocol.h" +#if 0 /* protocol package len .*/ #define PROTOCOL_QUERY_HEADLEN (8) #define PROTOCOL_PATH_HEADLEN (8) @@ -177,10 +177,100 @@ extern size_t WD_SYSTEM _wilddog_protocol_ioctl void *p_args, int flags ); +#else +#define WILDDOG_CONN_SESSION_SHORT_LEN 4 +#define WILDDOG_CONN_SESSION_LONG_LEN 32 + +typedef enum WILDDOG_SESSION_STATE{ + WILDDOG_SESSION_NOTAUTHED = 0, + WILDDOG_SESSION_AUTHING, + WILDDOG_SESSION_AUTHED +}Wilddog_Session_State; + +typedef enum WILDDOG_CONN_CMD_TYPE +{ + WILDDOG_CONN_CMD_GET, + WILDDOG_CONN_CMD_SET, + WILDDOG_CONN_CMD_PUSH, + WILDDOG_CONN_CMD_REMOVE, + WILDDOG_CONN_CMD_ON, + WILDDOG_CONN_CMD_OFF, + WILDDOG_CONN_CMD_AUTH, + + WILDDOG_CONN_CMD_ONDISSET, + WILDDOG_CONN_CMD_ONDISPUSH, + WILDDOG_CONN_CMD_ONDISREMOVE, + + WILDDOG_CONN_CMD_CANCELDIS, + + WILDDOG_CONN_CMD_OFFLINE, + WILDDOG_CONN_CMD_ONLINE, + WILDDOG_CONN_CMD_TRYSYNC, + + WILDDOG_CONN_CMD_MAX +}Wilddog_Conn_Cmd_T; +typedef struct WILDDOG_CONN_CMD_ARG +{ + Wilddog_Repo_T *p_repo; + Wilddog_Url_T * p_url; + Wilddog_Node_T * p_data; + Wilddog_Func_T p_complete; + void* p_completeArg; +}Wilddog_ConnCmd_Arg_T; +typedef struct WILDDOG_CONN_PKT_DATA_T{ + struct WILDDOG_CONN_PKT_DATA_T *next; + u8* data; + //int seq;//sequence number + u32 len; +}Wilddog_Conn_Pkt_Data_T; +typedef struct WILDDOG_CONN_PKT_T{ + struct WILDDOG_CONN_PKT_T *next; + int d_count; + u32 d_message_id; + u32 d_next_send_time; + Wilddog_Url_T *p_url; + Wilddog_Func_T p_complete;//pkt matched function + Wilddog_Func_T p_user_callback; + void *p_user_arg; + Wilddog_Conn_Pkt_Data_T *p_data; //packet data serialized and packeted by protocol. + u8 *p_proto_data; +}Wilddog_Conn_Pkt_T; + +typedef struct WILDDOG_CONN_SYS_T{ + struct WILDDOG_CONN_T *p_conn; + int d_curr_ping_interval; + int d_ping_delta; + Wilddog_Conn_Pkt_T *p_ping; + Wilddog_Conn_Pkt_T *p_auth; +}Wilddog_Conn_Sys_T; + +typedef struct WILDDOG_CONN_USER_T{ + struct WILDDOG_CONN_T *p_conn; + Wilddog_Conn_Pkt_T *p_observer_list; + Wilddog_Conn_Pkt_T *p_rest_list; +}Wilddog_Conn_User_T; + +typedef struct WILDDOG_SESSION_T{ + Wilddog_Session_State d_session_status; + char short_sid[WILDDOG_CONN_SESSION_SHORT_LEN]; + char long_sid[WILDDOG_CONN_SESSION_LONG_LEN]; +}Wilddog_Session_T; + +typedef struct WILDDOG_CONN_T +{ + Wilddog_Repo_T *p_conn_repo; + Wilddog_Session_T d_session; + Wilddog_Conn_Sys_T d_conn_sys; + Wilddog_Conn_User_T d_conn_user; + Wilddog_Protocol_T *p_protocol; + Wilddog_Func_T f_conn_ioctl; +}Wilddog_Conn_T; + +#endif /*implemented interface.*/ extern Wilddog_Conn_T* _wilddog_conn_init(Wilddog_Repo_T* p_repo); -extern Wilddog_Conn_T* _wilddog_conn_deinit(Wilddog_Repo_T*p_repo); +extern Wilddog_Return_T _wilddog_conn_deinit(Wilddog_Repo_T*p_repo); #endif /*_WILDDOG_CONN_H_*/ diff --git a/src/wilddog_conn_manage.c b/src/wilddog_conn_manage.c deleted file mode 100644 index 38602f2..0000000 --- a/src/wilddog_conn_manage.c +++ /dev/null @@ -1,2223 +0,0 @@ -/* - * Copyright (C) 2014-2016 Wilddog Technologies. All Rights Reserved. - * - * FileName: wilddog_conn.c - * - * Description: connection functions. - * - * History: - * Version Author Date Description - * - * 0.4.0 lxs 2015-05-15 Create file. - * 0.8.0 lxs 2015-12-23 only manage list and system state. - * - */ - -#ifndef WILDDOG_PORT_TYPE_ESP -#include -#endif -#include -#include -#include - -#include "utlist.h" -#include "wilddog_config.h" -#include "wilddog_common.h" -#include "wilddog_url_parser.h" -#include "wilddog_ct.h" -#include "wilddog.h" -#include "wilddog_store.h" -#include "wilddog_debug.h" -#include "wilddog_payload.h" - -#include "wilddog_conn.h" -#include "wilddog_conn_manage.h" -#include "wilddog_sec.h" - -#include "test_lib.h" - -/*link config */ -#define TEST_LINK_LOG_EN (0) - -#define _CM_TOKEN_SHORT 's' -#define _CM_TOKEN_LONG 'l' -#define _CM_TOKEN_SHORT_LEN ( strlen( _CM_AUTHR_QURES ) + 8) -#define _CM_TOKEN_LONG_LEN ( 32 + 1) - -#define _GETBYTE_H(b) ((b>>4)&0x0f) -#define _GETBYTE_L(b) (b&0x0f) -#define DIFF(a,b) ((a>b)?(a-b):(b-a)) -#define _CM_MS (1000) - -#define PONG_QURES "seq=" -#define PONG_NUMBERMAX (98) -#define PONG_NUMBERLEN (2) -#define PONG_REQUESINTERVAL (12*60*1000) - -/* auth timeout need to pong immediately*/ -#define PONG_REQUEST_IMMEDIATELY (1000) -#define _CM_RECV_SERVER_ERROR(err) ( err >= 400) - -/* retransmit cover (FIRSTRTRANSMIT_INV**n) */ -#define _PAKGE_RETRANSMIT_TIME (2000) -#define WILDDOG_PING_INTERVAL 60000 -#define _CM_MAXAGE_TIME ( 360*60) - -#define _CM_NEXTSENDTIME_SET(ctime,cnt) (ctime+(_PAKGE_RETRANSMIT_TIME<<(cnt++))) - -#define _CM_SYS_PING_SHORTTOKEN_PATH "/.ping" -#define _CM_SYS_PING_LONGTOKEN_PATH "/.rst" -#define _CM_SYS_RECONNECT_TIME (2) - -#define _CM_SYS_STEP_SEC ( 9 ) -#define _CM_SYS_INTERVALINIT_SEC (20 ) -#define _CM_SYS_KEEPOFFLINE (3) -#define _CM_SYS_PINGRETRACETIME_SEC (10) -#define _CM_SYS_OFFLINE_PINGTM_SEC (3*60) -#define _CM_SYS_SERVER_KEEPSESSION_SEC (168) -#define _CM_SYS_PING_INTERVAL_MIN_SEC (10) -#define _CM_SYS_PING_INTERVAL_MAX_SEC ((_CM_SYS_SERVER_KEEPSESSION_SEC) - \ - (WILDDOG_RETRANSMITE_TIME/(_CM_MS))) - - -typedef enum CM_NODE_TYPE{ - CM_NODE_TYPE_OBSERVER = 1, - CM_NODE_TYPE_MAX -}CM_Node_Type; -typedef enum _CM_EVENT_TYPE{ - _CM_EVENT_TYPE_NULL, - _CM_EVENT_TYPE_REONLINE, - _CM_EVENT_TYPE_MAX -}_CM_Event_Type; - -typedef enum _CM_SYS_PING_TYPE_T{ - _CM_SYS_PINGTYPE_SHORT, - _CM_SYS_PINGTYPE_LONG -}_CM_SYS_PING_TYPE_T; - -typedef struct _CM_SYS_NODE_T{ - struct _CM_SYS_NODE_T *next; - void *p_ping_pkg; - _CM_SYS_PING_TYPE_T d_pingType; - - u32 d_token; - u32 d_ping_sendTm; - u32 d_ping_registerTm; - Wilddog_Cm_List_T *p_cm_l; - - u8 d_userOffLine; - u8 d_sendCnt; - u8 d_intervalTm; - u8 d_stepTm; - u8 d_offLineCnt; - u8 d_onlineState; - BOOL d_disableLink; -#if TEST_LINK_LOG_EN - u8 d_long_pingCont; -#endif -}_CM_SYS_Node_T; - -typedef struct CM_CONTROL_T -{ - Wilddog_Cm_List_T *p_cm_l_hd; - _CM_SYS_Node_T *p_cmsys_n_hd; - Wilddog_Func_T f_cn_callBackHandle; - - int d_messageId; - u8 d_list_cnt; - u8 d_cm_onlineEvent; -}CM_Control_T; - -STATIC u16 d_user_node_num = 0; - -CM_Control_T *p_l_cmControl = NULL; - -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_node_destory - ( - Wilddog_CM_Node_T **pp_dele - ); - -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_session_maintain - ( - Wilddog_Cm_List_T *p_cm_l - ); -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_session_saveToken - ( - Wilddog_Payload_T *p_recvData, - Wilddog_Cm_List_T *p_cm_l - ); - -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_node_updataSendTime - ( - Wilddog_Cm_List_T *p_cm_l, - Wilddog_CM_Node_T *p_cm_n, - u32 nextSendTm - ); -STATIC BOOL WD_SYSTEM _wilddog_cm_sys_findNode - ( - Protocol_recvArg_T *p_recv - ); -STATIC int WD_SYSTEM _wilddog_cm_sys_keeplink(void); -STATIC void* WD_SYSTEM _wilddog_cm_sys_creatPing - ( - Wilddog_Cm_List_T *p_cm_l, - _CM_SYS_PING_TYPE_T pingType, - u32 *p_pkg_token - ); -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_trafficRunOut - ( - Wilddog_Cm_List_T *p_cm_l - ); -STATIC int WD_SYSTEM _wilddog_cm_sys_disablePingLink - ( - Wilddog_Cm_List_T *p_cm_l, - BOOL newstate - ); -STATIC _CM_SYS_Node_T *WD_SYSTEM _wilddog_cm_sys_findSysnodeBycml - ( - Wilddog_Cm_List_T *p_cm_l - ); -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_timeInit - ( - _CM_SYS_Node_T *p_cmsys_n - ); -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_setOnLineState - ( - Wilddog_Cm_List_T *p_cm_l, - u32 s - ); -STATIC u8 WD_SYSTEM _wilddog_cm_sys_getOnlineState - ( - Wilddog_Cm_List_T *p_cm_l - ); -STATIC int WD_SYSTEM _wilddog_cm_cmd_getIndex(void *p_arg,int flag); -STATIC u32 WD_SYSTEM _wilddog_cm_cmd_getToken(void *p_arg,int flag); -STATIC Wilddog_CM_Node_T* WD_SYSTEM _wilddog_cm_findObserverNode_byPath - ( - Wilddog_CM_Node_T *p_node_hd, - u8 *p_s_path - ); - -/* - * Function: _wilddog_cm_rand_get - * Description: Get a rand number - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC INLINE int WD_SYSTEM _wilddog_cm_rand_get(void) -{ - srand(_wilddog_getTime()); - return rand(); -} - -/* - * Function: _wilddog_cm_node_creat. - * Description: malloc node . - * Input: p_arg : arg - * Output: N/A. - * Return: pointer to the allocation address. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_node_creat - ( - Wilddog_CM_UserArg_T *p_arg, - Wilddog_CM_Node_T **p_cm_node - ) -{ - Wilddog_CM_Node_T *p_newNode = NULL; - - /* 20160712:skylli:: add max queue node judge*/ - if( d_user_node_num > WILDDOG_REQ_QUEUE_NUM ) - return WILDDOG_ERR_QUEUEFULL; - p_newNode = (Wilddog_CM_Node_T*)wmalloc(sizeof(Wilddog_CM_Node_T)); - if(p_newNode == NULL) - return WILDDOG_ERR_NULL; - - memset(p_newNode,0,sizeof(Wilddog_CM_Node_T)); - - p_newNode->cmd = p_arg->cmd; - p_newNode->d_token = (0xffffffff) & p_arg->d_token; - p_newNode->p_pkg = p_arg->p_pkg; - p_newNode->f_userCB = p_arg->f_userCB; - p_newNode->p_userCB_arg = p_arg->f_userCB_arg; - - p_newNode->d_retransmit_cnt = 0; - p_newNode->d_registerTm = _wilddog_getTime(); - p_newNode->d_sendTm = _wilddog_getTime(); - - if( p_arg->p_path ) - { - int tmpLen = strlen((const char*)p_arg->p_path) +1; - p_newNode->p_path = wmalloc(tmpLen); - if(p_newNode->p_path == NULL) - { - wfree(p_newNode); - return WILDDOG_ERR_NULL; - } - memset(p_newNode->p_path,0,tmpLen); - memcpy(p_newNode->p_path,p_arg->p_path,(tmpLen-1)); - } - /* node type subscription.*/ - if( p_arg->cmd == WILDDOG_CONN_CBCMD_ON) - { - p_newNode->d_nodeType = CM_NODE_TYPE_OBSERVER; - - p_newNode->reObserver_flg = FALSE; - p_newNode->d_subscibe_index = 0; - } - - wilddog_debug_level(WD_DEBUG_LOG,"conn_manage:: creat cm node : %p \n",p_newNode); - /* add */ - d_user_node_num++; - *p_cm_node = p_newNode; - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_node_destory - * Description: free node. - * Input: pp_dele:address of delete pointer. - * Output: N/A - * Return: Wilddog_Return_T type -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_node_destory - ( - Wilddog_CM_Node_T **pp_dele - ) -{ - Wilddog_CM_Node_T *p_dele = NULL; - if( pp_dele == NULL || *pp_dele == NULL) - return 0; - - p_dele = *pp_dele; - wilddog_debug_level(WD_DEBUG_LOG,"conn_manage:: destory node :%p",p_dele); - - if(p_dele->p_pkg) - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_dele->p_pkg,0); - p_dele->p_pkg = NULL; - - if(p_dele->p_path) - wfree(p_dele->p_path); - p_dele->p_path = NULL; - - wfree(p_dele); - *pp_dele = NULL; - d_user_node_num = ( d_user_node_num == 0 )?0:(d_user_node_num-1); - return 0; -} -/* - * Function: _wilddog_cm_ndoe_isNotify - * Description: judge if node was an observer and have receive and ack. - * Input: p_cm_n: cm node - * Output: N/A - * Return: BOOL type . -*/ -STATIC BOOL WD_SYSTEM _wilddog_cm_ndoe_isNotify - ( - Wilddog_CM_Node_T *p_cm_n - ) -{ - if( p_cm_n->d_nodeType == CM_NODE_TYPE_OBSERVER && \ - p_cm_n->d_subscibe_index > 0) - return TRUE; - else - return FALSE; -} -/* - * Function: _wilddog_cm_node_updataSendTime - * Description: updata node send time. - * Input: p_cm_n: cm node. - * p_cm_l : list pointer. - * nextSendTm: send time in milisecond. - * Output: N/A - * Return: Wilddog_Return_T type . -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_node_updataSendTime - ( - Wilddog_Cm_List_T *p_cm_l, - Wilddog_CM_Node_T *p_cm_n, - u32 nextSendTm - ) -{ - /* set time.*/ - p_cm_n->d_sendTm = nextSendTm;// - return WILDDOG_ERR_NOERR; -} - -/* - * Function: _wilddog_cm_list_destory - * Description: free list that belong some repo. - * Input: - * p_cm_l : list pointer. - * Output: N/A - * Return: Wilddog_Return_T type . -*/ -STATIC int WD_SYSTEM _wilddog_cm_list_destory - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - if(p_cm_l == NULL) - return WILDDOG_ERR_INVALID; - /* destory cm node hang on this list.*/ - wilddog_debug_level(WD_DEBUG_LOG,"conn_manage:: destory repo linked list : %p",p_cm_l); - if(p_cm_l->p_cm_n_hd) - { - Wilddog_CM_Node_T *curr = NULL,*tmp = NULL; - LL_FOREACH_SAFE(p_cm_l->p_cm_n_hd,curr,tmp) - { - - LL_DELETE(p_cm_l->p_cm_n_hd,curr); - _wilddog_cm_node_destory(&curr); - } - p_cm_l->p_cm_n_hd = NULL; - } - - wfree(p_cm_l->p_short_token); - p_cm_l->p_short_token = NULL; - wfree(p_cm_l->p_long_token); - p_cm_l->p_long_token = NULL; - - wfree(p_cm_l); - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_sendWithToken - * Description: updata token then send out. - * Input: p_cm_l:list pointer - * p_send :send out node. - * Output: N/A - * Return: Wilddog_Return_T type -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sendWithToken - ( - Wilddog_Cm_List_T *p_cm_l, - Wilddog_CM_Node_T *p_send - ) -{ - /* updata token.*/ - int res =0; - Protocol_Arg_Auth_T authArg = {NULL,NULL,0}; - authArg.p_pkg = p_send->p_pkg; - authArg.p_newAuth = p_cm_l->p_short_token; - authArg.d_newAuthLen = strlen((char*)p_cm_l->p_short_token); - _wilddog_protocol_ioctl(_PROTOCOL_CMD_AUTHUPDATA,&authArg,0); - res = _wilddog_protocol_ioctl(_PROTOCOL_CMD_SEND,p_send->p_pkg,0); - _wilddog_cm_node_updataSendTime(p_cm_l,p_send, - _CM_NEXTSENDTIME_SET(_wilddog_getTime(),p_send->d_retransmit_cnt)); - return res; -} -/* - * Function: _wilddog_cm_authSend - * Description: put off that package while unauth,if authed,send out immediately. - * Input: p_cm_l:list pointer - * p_send :send out node. - * Output: N/A - * Return: Wilddog_Return_T type -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_authSend - ( - Wilddog_Cm_List_T *p_cm_l, - Wilddog_CM_Node_T *p_send - ) -{ - int res = 0; - switch( p_cm_l->d_authStatus ) - { - case CM_SESSION_DOAUTH: - case CM_SESSION_AUTHING: - /*all application request put off*/ - _wilddog_cm_node_updataSendTime(p_cm_l, \ - p_send, \ - _CM_NEXTSENDTIME_SET(_wilddog_getTime(), - p_send->d_retransmit_cnt)); - break; - case CM_SESSION_UNAUTH: - case CM_SESSION_AUTHED: - res = _wilddog_cm_sendWithToken(p_cm_l,p_send); - _wilddog_cm_node_updataSendTime(p_cm_l, - p_send, - _CM_NEXTSENDTIME_SET(_wilddog_getTime(), - p_send->d_retransmit_cnt)); - break; - } - - return res; -} -/* - * Function: _wilddog_cm_onlineSend. - * Description:according to it's online statue to send out. - * Input: p_cm_l : list head. - * p_cm_n : cm node. - * Output: N/A. - * Return: pointer to the allocation address. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_onlineSend - ( - Wilddog_Cm_List_T *p_cm_l, - Wilddog_CM_Node_T *p_cm_n - ) -{ - if( CM_OFFLINE == _wilddog_cm_sys_getOnlineState(p_cm_l)) - { - /* on event hold in list until system reonline.*/ - if( p_cm_n->cmd == WILDDOG_CONN_CMD_ON) - { - _wilddog_cm_node_updataSendTime(p_cm_l, \ - p_cm_n, \ - (_wilddog_getTime()+_CM_MAXAGE_TIME)); - } - else - { - _wilddog_cm_node_updataSendTime(p_cm_l, \ - p_cm_n, \ - _CM_NEXTSENDTIME_SET(_wilddog_getTime(),p_cm_n->d_retransmit_cnt)); - } - return WILDDOG_ERR_NOERR; - } - else /* online*/ - { - return _wilddog_cm_authSend(p_cm_l,p_cm_n); - } -} -/* - * Function: _wilddog_cm_cmd_authe_delete. - * Description: clean all autho node . - * Input: Wilddog_Cm_List_T *p_cm_l node list. - * flag : N/A. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_cmd_authe_delete - ( - Wilddog_Cm_List_T *p_cm_l, - int flag - ) -{ - if(p_cm_l == NULL) - return WILDDOG_ERR_INVALID; - /* destory cm node hang on this list.*/ - if(p_cm_l->p_cm_n_hd) - { - Wilddog_CM_Node_T *curr = NULL,*tmp = NULL; - LL_FOREACH_SAFE(p_cm_l->p_cm_n_hd,curr,tmp) - { - if( curr->cmd != WILDDOG_CONN_CMD_AUTH ) - continue; - LL_DELETE(p_cm_l->p_cm_n_hd,curr); - _wilddog_cm_node_destory(&curr); - } - } - - return WILDDOG_ERR_NOERR; -} - - -/* - * Function: _wilddog_cm_cmd_userSend. - * Description: hang application pakage in to list and send out. - * Input: p_arg: input arg. - * flag : N/A. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_cmd_userSend - ( - Wilddog_CM_UserArg_T *p_arg, - int flag - ) -{ - int res = 0; - /* creat node.*/ - Wilddog_CM_Node_T *p_newNode = NULL; - res = _wilddog_cm_node_creat(p_arg,&p_newNode); - - if( res != WILDDOG_ERR_NOERR) - return res; - /* add to list's head.*/ - LL_PREPEND(p_arg->p_cm_l->p_cm_n_hd,p_newNode); - - if( p_arg->cmd == WILDDOG_CONN_CMD_AUTH) - { - /*auth send.*/ - res = _wilddog_protocol_ioctl(_PROTOCOL_CMD_SEND,p_arg->p_pkg,0); - _wilddog_cm_node_updataSendTime(p_arg->p_cm_l, \ - p_newNode, \ - _CM_NEXTSENDTIME_SET(_wilddog_getTime(),p_newNode->d_retransmit_cnt)); - }else/*application send.*/ - res = _wilddog_cm_onlineSend(p_arg->p_cm_l,p_newNode); - /* set auth state*/ - if( p_arg->cmd == WILDDOG_CONN_CMD_AUTH && res >= 0){ - p_arg->p_cm_l->d_authStatus = CM_SESSION_AUTHING; - } - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_recv_errorHandle - * Description: handle receive error code. - * error code = 401, unauthoried then request new session. - * error code = 412, flow run out then cancel all observer event. - * no error then put off ping send time and reOnline the system. - * Input: - * p_recv : receive package. - * p_cm_l : reponde list. - * Output: N/A - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_recv_errorHandle - ( - Protocol_recvArg_T *p_recv, - Wilddog_Cm_List_T *p_cm_l - ) -{ - /* server error.*/ - if( _CM_RECV_SERVER_ERROR(p_recv->err)) - { - wilddog_debug_level(WD_DEBUG_LOG,"conn_manage:: receive return code: %ld",p_recv->err); - /* unauth need to send auth request.*/ - if(p_recv->err == WILDDOG_HTTP_UNAUTHORIZED) - { - /* session init in next execution cycle.*/ - p_cm_l->d_authStatus = CM_SESSION_DOAUTH; - } - else - if(p_recv->err == WILDDOG_HTTP_PRECONDITION_FAIL) - { - /*traffic runout. */ - p_cm_l->d_serverEvent = CM_SERVER_EVENT_PRECONDITION_FAIL; - } - } - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_findObserverNode_byPath. - * Description: list head and return node who's path == p_s_path - * Input: p_node_hd: list head. - * p_recv_path : socurce path. - * p_recv : receive notify. - - * Output: N/A. - * Return: Wilddog_CM_Node_T node. -*/ -STATIC Wilddog_CM_Node_T* WD_SYSTEM _wilddog_cm_findObserverNode_byPath - ( - Wilddog_CM_Node_T *p_node_hd, - u8 *p_s_path - ) -{ - u32 len = 0; - Wilddog_CM_Node_T *curr_cm = NULL,*temp_cm = NULL; - LL_FOREACH_SAFE(p_node_hd,curr_cm,temp_cm) - { - if(curr_cm->p_path == 0 ) - continue; - len = (strlen((const char*)curr_cm->p_path) >= strlen((const char*)p_s_path))? \ - strlen((const char*)p_s_path) : strlen((const char*)curr_cm->p_path); - if(memcmp(p_s_path,curr_cm->p_path,len) == 0 ) - return curr_cm; - } - return NULL; -} -STATIC Wilddog_CM_Node_T* WD_SYSTEM _wilddog_cm_findObserverNode - ( Wilddog_CM_FindNode_Arg_T *p_arg,int flag) -{ - return _wilddog_cm_findObserverNode_byPath(p_arg->p_node_hd,p_arg->path); -} -/* - * Function: _wilddog_cm_recv_handle_on. - * Description: handle notify: - * if notify index larger then update node index and notify user. - * if notify index less then ignore it. - * if error code > 300 then delete it. - * Input: p_cm_l: list pointer. - * p_cm_n : cm node. - * p_recv : receive notify. - * p_cm_recvArg : receive arg. - * flag : N/A. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_recv_handle_on - ( - Wilddog_Cm_List_T *p_cm_l, - Wilddog_CM_Node_T *p_cm_n, - Protocol_recvArg_T *p_recv, - Wilddog_CM_Recv_T *p_cm_recvArg - ) -{ - u32 nextSendTm = 0; - - if(_CM_RECV_SERVER_ERROR(p_recv->err)) - { - /*have beed observer,ignore it*/ -//20161020 node must be remove since receive error. -#if 0 - if( _wilddog_cm_ndoe_isNotify(p_cm_n) && \ - p_recv->err != WILDDOG_HTTP_PRECONDITION_FAIL) - { - return WILDDOG_ERR_NOERR; - } -#endif - /* call user call back.*/ - if(p_l_cmControl->f_cn_callBackHandle) - { - p_l_cmControl->f_cn_callBackHandle(p_cm_recvArg->cmd, \ - p_cm_recvArg, \ - 0); - } - /* delete it.*/ - LL_DELETE(p_cm_l->p_cm_n_hd,p_cm_n); - _wilddog_cm_node_destory(&p_cm_n); - } - else - { - if( p_cm_n->d_nodeType == CM_NODE_TYPE_OBSERVER && \ - p_recv->d_isObserver == TRUE && \ - p_recv->d_observerIndx > p_cm_n->d_subscibe_index) - { - /*reobserver call back */ - if(p_cm_n->reObserver_flg == TRUE) - { - p_cm_n->reObserver_flg = FALSE; - p_cm_recvArg->err = WILDDOG_ERR_RECONNECT; - } - /* call user call back.*/ - if(p_l_cmControl->f_cn_callBackHandle) - { - p_l_cmControl->f_cn_callBackHandle(p_cm_recvArg->cmd,\ - p_cm_recvArg, \ - 0); - } - /* get observer index.*/ - p_cm_n->d_subscibe_index = p_recv->d_observerIndx; - /* get maxage.*/ - p_cm_n->d_maxAge = p_recv->d_maxAge * 60 ; - /* updata next send time.*/ - nextSendTm = _wilddog_getTime() + p_recv->d_maxAge; - - /*adjust sending list.*/ - _wilddog_cm_node_updataSendTime(p_cm_l,p_cm_n,nextSendTm); - } - } - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_recv_handle. - * Description: handle all receive package. - * Input: p_cm_l : list pointer. - * p_cm_n : response node. - * p_recv : store parsed receive package. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC int WD_SYSTEM _wilddog_cm_recv_handle - ( - Protocol_recvArg_T *p_recv, - Wilddog_CM_Node_T *p_cm_n, - Wilddog_Cm_List_T *p_cm_l - ) -{ - /* handle error.*/ - Wilddog_Payload_T payload; - Wilddog_CM_Recv_T cm_recv; - int res = 0 ; - memset(&payload,0,sizeof(Wilddog_Payload_T)); - memset(&cm_recv,0,sizeof(Wilddog_CM_Recv_T)); - - if( p_recv == NULL || - p_cm_n == NULL || - p_cm_l == NULL - ) - return WILDDOG_ERR_INVALID; - - payload.p_dt_data = p_recv->p_recvData; - payload.d_dt_len = p_recv->d_recvDataLen; - payload.d_dt_pos = 0; - - cm_recv.cmd = p_cm_n->cmd; - cm_recv.err = p_recv->err; - cm_recv.p_recvData = &payload; - cm_recv.p_url_path = p_cm_n->p_path; - cm_recv.f_user_callback = p_cm_n->f_userCB; - cm_recv.p_user_cb_arg = p_cm_n->p_userCB_arg; - /* handle error.*/ - _wilddog_cm_recv_errorHandle(p_recv,p_cm_l); - switch(p_cm_n->cmd) - { - case WILDDOG_CONN_CBCMD_AUTH: - -#ifdef WILDDOG_SELFTEST - performtest_getHandleSessionResponTime(); -#endif - _wilddog_cm_session_saveToken(&payload,p_cm_l); - if(p_l_cmControl->f_cn_callBackHandle) - { - p_l_cmControl->f_cn_callBackHandle(cm_recv.cmd,&cm_recv,0); - } - LL_DELETE(p_cm_l->p_cm_n_hd,p_cm_n); - _wilddog_cm_node_destory(&p_cm_n); - break; - case WILDDOG_CONN_CBCMD_ON: - res = _wilddog_cm_recv_handle_on(p_cm_l,p_cm_n,p_recv,&cm_recv); - break; - default: - if(p_l_cmControl->f_cn_callBackHandle) - { - p_l_cmControl->f_cn_callBackHandle(cm_recv.cmd,&cm_recv,0); - } - LL_DELETE(p_cm_l->p_cm_n_hd,p_cm_n); - _wilddog_cm_node_destory(&p_cm_n); - break; - } - if( !_CM_RECV_SERVER_ERROR(p_recv->err)) - { - /* set online*/ - if(CM_OFFLINE == _wilddog_cm_sys_getOnlineState(p_cm_l)) - { - /*set reonline flag.*/ - p_l_cmControl->d_cm_onlineEvent = _CM_EVENT_TYPE_REONLINE; - /* set online.*/ - _wilddog_cm_sys_setOnLineState(p_cm_l,CM_ONLINE); - } - /* normal responds.*/ - /* 20160627 : disable,while notify frequently , server need ping package to keep session.*/ - //_wilddog_cm_sys_timeSkip(p_cm_l); - } - return res; -} -/* - * Function: _wilddog_cm_recv_findContext. - * Description: find respond context according to it's token. - * Input: p_recv: receive package. - * flag : N/A. - * Output: N/A. - * Return: BOOL type. -*/ -STATIC BOOL WD_SYSTEM _wilddog_cm_recv_findContext - ( - Protocol_recvArg_T *p_recv, - int flag - ) -{ - Wilddog_Repo_T *curr_repo = NULL,*temp_repo = NULL; - Wilddog_CM_Node_T *p_find = NULL; - Wilddog_Cm_List_T *p_cm_l = NULL; - Wilddog_Repo_T **pp_repo = _wilddog_ct_getRepoHead(); - if( pp_repo == NULL ) - return WILDDOG_ERR_INVALID; - LL_FOREACH_SAFE(*pp_repo,curr_repo,temp_repo) - { - if(curr_repo->p_rp_conn == NULL) - continue ; - if( curr_repo->p_rp_conn->p_cm_l) - { - Wilddog_CM_Node_T *curr_cm = NULL,*temp_cm = NULL; - LL_FOREACH_SAFE(curr_repo->p_rp_conn->p_cm_l->p_cm_n_hd,\ - curr_cm,temp_cm) - { - if( (curr_cm->d_token & 0xffffffff) == (p_recv->d_token & 0xffffffff)) - { - p_find = curr_cm; - p_cm_l = curr_repo->p_rp_conn->p_cm_l; - - break; - } - } - } - } - - if( p_find ) - { - /* Observer then find node by path.*/ - if( p_recv->p_r_path && - p_find->d_nodeType == CM_NODE_TYPE_OBSERVER) - p_find = _wilddog_cm_findObserverNode_byPath(p_cm_l->p_cm_n_hd, p_recv->p_r_path); - - _wilddog_cm_recv_handle(p_recv,p_find,p_cm_l); - return TRUE; - } - else/* system node responds.*/ - return _wilddog_cm_sys_findNode(p_recv); -} -STATIC int WD_SYSTEM _wilddog_cm_recv(void) -{ - wilddog_assert(p_l_cmControl,WILDDOG_ERR_INVALID); - - return _wilddog_protocol_ioctl(_PROTOCOL_CMD_RECV,NULL,0); -} -/* - * Function: _wilddog_cm_trafficRunOut. - * Description: trffic over runs and touch all observer user call back . - * Input: p_cm_l: list pointer. - * Output: N/A. - * Return: BOOL type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_trafficRunOut - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - - if(p_cm_l->d_serverEvent == CM_SERVER_EVENT_PRECONDITION_FAIL) - { - Wilddog_CM_Node_T *curr = NULL,*tmp = NULL; - Protocol_recvArg_T trfficRunOut; - - memset(&trfficRunOut,0,sizeof(Protocol_recvArg_T)); - trfficRunOut.err = WILDDOG_HTTP_PRECONDITION_FAIL; - - LL_FOREACH_SAFE(p_cm_l->p_cm_n_hd,curr,tmp) - { - /* all node touch call back,and destory.*/ - _wilddog_cm_recv_handle(&trfficRunOut,curr,p_cm_l); - } - } - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_transmitTimeOut. - * Description: retransmit time out and return -10 to user. - * Input: p_cm_l: list. - * p_cm_n : cm node poniter. - * Output: N/A. - * Return: BOOL type. -*/ -STATIC BOOL WD_SYSTEM _wilddog_cm_transmitTimeOut - ( - Wilddog_CM_Node_T *p_cm_n, - Wilddog_Cm_List_T *p_cm_l - ) -{ - if(DIFF(p_cm_n->d_registerTm,_wilddog_getTime())> WILDDOG_RETRANSMITE_TIME) - { - Protocol_recvArg_T timeOutArg; - memset(&timeOutArg,0,sizeof(Protocol_recvArg_T)); - timeOutArg.err = WILDDOG_ERR_RECVTIMEOUT; - _wilddog_cm_recv_handle(&timeOutArg,p_cm_n,p_cm_l); - return TRUE; - } - - return FALSE; -} -/* - * Function: _wilddog_cm_retransmit. - * Description: retransmit user request. - * Input: p_cm_l: retransmit list. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_retransmit - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - Wilddog_CM_Node_T *curr = NULL,*tmp = NULL; - u32 currTm = _wilddog_getTime(); - - if(p_cm_l == NULL) - return WILDDOG_ERR_INVALID; - - LL_FOREACH_SAFE(p_cm_l->p_cm_n_hd,curr,tmp) - { - /*successfully observer node not need to retransmit.*/ - if(_wilddog_cm_ndoe_isNotify(curr) == TRUE) - continue; - - /* send out while touch send time.*/ - /* time out node will be dele and not need to retransmit.*/ - if(_wilddog_cm_transmitTimeOut(curr,p_cm_l) == FALSE) - { - /* send out while touch send time.*/ - //wilddog_debug("currTm >curr->d_sendTm %ld currTm = %ld",curr->d_sendTm,currTm); - if( currTm >curr->d_sendTm && \ - DIFF(currTm,curr->d_sendTm) < (0xffff)){ - if(curr->cmd == WILDDOG_CONN_CMD_AUTH) - { - /*auth send.*/ - _wilddog_protocol_ioctl(_PROTOCOL_CMD_SEND,curr->p_pkg,0); - _wilddog_cm_node_updataSendTime(p_cm_l, \ - curr, \ - _CM_NEXTSENDTIME_SET(_wilddog_getTime(), \ - curr->d_retransmit_cnt)); - } - else - { - _wilddog_cm_onlineSend(p_cm_l,curr); - /* put to queue tial.*/ - } - } - - } - } - - return WILDDOG_ERR_NOERR; -} - -/* - * Function: _wilddog_cm_reonline_send. - * Description: send observer. - * Input: N/A. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_reonline_send - ( - Wilddog_Cm_List_T *p_cm_l, - Wilddog_CM_Node_T *p_send - ) -{ - Wilddog_CM_Send_Ping_Arg_T ping_pkg; - ping_pkg.p_pkg = p_send->p_pkg; - ping_pkg.d_mid = (u16)_wilddog_cm_cmd_getIndex(NULL, 0); - ping_pkg.d_token = (u32) _wilddog_cm_cmd_getToken(NULL, 0); - p_send->d_token = ping_pkg.d_token; - - - _wilddog_protocol_ioctl( _PROTOCOL_CMD_MODIFY_MIDTOKEN, &ping_pkg, 0); - - return _wilddog_cm_authSend(p_cm_l,p_send); -} -/* - * Function: _wilddog_cm_reOnline. - * Description: system reonline, retransmit observer request. - * Input: N/A. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_reOnline(void) -{ - wilddog_assert(p_l_cmControl,WILDDOG_ERR_INVALID); - - if(p_l_cmControl->d_cm_onlineEvent == _CM_EVENT_TYPE_REONLINE) - { - /* resend all reobserver node.*/ - Wilddog_Repo_T *head_repo = NULL,*curr_repo = NULL,*tmp_repo = NULL; - Wilddog_Repo_T **pp_head_repo = _wilddog_ct_getRepoHead(); - if( pp_head_repo == NULL || \ - *pp_head_repo == NULL) - { - return WILDDOG_ERR_NOERR; - } - head_repo = *pp_head_repo; - LL_FOREACH_SAFE(head_repo,curr_repo,tmp_repo) - { - Wilddog_CM_Node_T *head_n=NULL,*curr_n = NULL,*tmp_n = NULL; - if( curr_repo->p_rp_conn == NULL || \ - curr_repo->p_rp_conn->p_cm_l == NULL || \ - curr_repo->p_rp_conn->p_cm_l->p_cm_n_hd == NULL) - { - continue ; - } - head_n = curr_repo->p_rp_conn->p_cm_l->p_cm_n_hd; - /* reObserver.*/ - LL_FOREACH_SAFE(head_n,curr_n,tmp_n) - { - if(curr_n->d_nodeType == CM_NODE_TYPE_OBSERVER) - { - /* have been notify..*/ - if(curr_n->d_subscibe_index) - curr_n->reObserver_flg = TRUE; - - /*reset observer index.*/ - curr_n->d_subscibe_index = 0; - /* 20160627 UPDATE REGISTER TIME */ - curr_n->d_registerTm = _wilddog_getTime(); - _wilddog_cm_reonline_send(curr_repo->p_rp_conn->p_cm_l,curr_n); - //_wilddog_cm_authSend(curr_repo->p_rp_conn->p_cm_l,curr_n); - } - } - } - p_l_cmControl->d_cm_onlineEvent = _CM_EVENT_TYPE_NULL; - } - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_sessionInit. - * Description: auth request and set auth state = authing. - * Input: N/A. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sessionInit - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - void* p_pkg_index = NULL; - u8 *pbuf = NULL; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Protocol_Arg_Payload_T authData; - Wilddog_CM_UserArg_T sendArg; - Protocol_Arg_CountSize_T pkg_sizeCount; - - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - wilddog_assert(p_cm_l->p_repo,WILDDOG_ERR_INVALID); - - memset(&pkg_sizeCount,0,sizeof(Protocol_Arg_CountSize_T)); - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - memset(&authData,0,sizeof(Protocol_Arg_Payload_T)); - memset(&sendArg,0,sizeof(Wilddog_CM_UserArg_T)); - /* malloc long and short token .*/ - if( p_cm_l->p_short_token == NULL) - { - p_cm_l->p_short_token = (u8*)wmalloc(_CM_TOKEN_SHORT_LEN+1); - if(p_cm_l->p_short_token == NULL) - return WILDDOG_ERR_NULL; - } - if(p_cm_l->p_long_token == NULL) - { - p_cm_l->p_long_token = (u8*)wmalloc(_CM_TOKEN_LONG_LEN+1); - if(p_cm_l->p_long_token == NULL) - { - wfree(p_cm_l->p_short_token); - return WILDDOG_ERR_NULL; - } - } - /* init session token.*/ - memset(p_cm_l->p_short_token,'0',_CM_TOKEN_SHORT_LEN); - memset(p_cm_l->p_long_token,'0',_CM_TOKEN_LONG_LEN); - p_cm_l->p_long_token[_CM_TOKEN_LONG_LEN] = 0; - p_cm_l->p_short_token[_CM_TOKEN_SHORT_LEN] = 0; - - memcpy(p_cm_l->p_short_token,_CM_AUTHR_QURES,strlen(_CM_AUTHR_QURES)); - /* init protocol package.*/ - pkg_arg.cmd = WILDDOG_CONN_CMD_AUTH; - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_cmd_getIndex(NULL,0); - pkg_arg.d_token = (u32) _wilddog_cm_cmd_getToken(NULL,0); - - /* get local auth len */ - authData.d_payloadLen = p_cm_l->p_repo->p_rp_store->p_se_callback( - p_cm_l->p_repo->p_rp_store, - WILDDOG_STORE_CMD_GETAUTH,&pbuf,0); - authData.p_payload = pbuf; - - /*count package size.*/ - pkg_sizeCount.p_host = p_cm_l->p_repo->p_rp_url->p_url_host; - pkg_sizeCount.p_path = (u8*)_CM_AUTHR_PATH; - pkg_sizeCount.d_payloadLen = authData.d_payloadLen; - pkg_arg.d_packageLen = (int)_wilddog_protocol_ioctl( - _PROTOCOL_CMD_COUNTSIZE,&pkg_sizeCount,0); - - /* creat coap package.*/ - p_pkg_index =(void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == NULL) - return WILDDOG_ERR_NULL; - - /* add host.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = p_cm_l->p_repo->p_rp_url->p_url_host; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_HOST,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CM_AUTH_ERR; - - /* add path.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = _CM_AUTHR_PATH; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_PATH,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CM_AUTH_ERR; - - /*add payload.*/ - authData.p_pkg = (void*)p_pkg_index; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_DATA,&authData,0); - if(res < 0) - goto _CM_AUTH_ERR; - - /* add list and send out.*/ - sendArg.cmd = WILDDOG_CONN_CMD_AUTH; - sendArg.p_cm_l = p_cm_l; - sendArg.d_token = pkg_arg.d_token; - sendArg.p_pkg = (void*)p_pkg_index; - if((res = _wilddog_cm_cmd_userSend(&sendArg,0))< 0 ) - goto _CM_AUTH_ERR; - - return res; - -_CM_AUTH_ERR: - wfree( p_cm_l->p_short_token); - p_cm_l->p_short_token = NULL; - wfree( p_cm_l->p_long_token); - p_cm_l->p_long_token = NULL; - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return res; - -} -/* - * Function: _wilddog_cm_session_maintain. - * Description: set session state == doauth then send auth request in nex cycle. - * Input: p_cm_l : cm list. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_session_maintain - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - if( p_cm_l && - p_cm_l->d_authStatus == CM_SESSION_DOAUTH) - { - p_l_cmControl->d_cm_onlineEvent = _CM_EVENT_TYPE_REONLINE; - return _wilddog_cm_sessionInit(p_cm_l); - } - else - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_session_saveToken. - * Description: updata token. - * Input: p_cm_l : cm list. - * p_recvData : receive package ,new token in it's payload. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_session_saveToken - ( - Wilddog_Payload_T *p_recvData, - Wilddog_Cm_List_T *p_cm_l - ) -{ - Wilddog_Str_T *p_short_token = NULL, *p_long_token = NULL; - Wilddog_Node_T *p_snapshot = NULL; - - if( p_recvData == NULL || \ - p_recvData->p_dt_data == NULL || \ - p_recvData->d_dt_len == 0) - return WILDDOG_ERR_INVALID; - - p_snapshot = _wilddog_payload2Node(p_recvData); -#ifdef DEBUG_LEVEL - if(DEBUG_LEVEL <= WD_DEBUG_LOG ) - wilddog_debug_printnode(p_snapshot); -#endif - /* get token. */ - if(p_snapshot) - { - Wilddog_Node_T *p_child_node = p_snapshot->p_wn_child ; - Wilddog_Node_T *p_next_node = p_child_node->p_wn_next; - - if( p_child_node && \ - *(p_child_node->p_wn_key) == _CM_TOKEN_SHORT) - { - p_short_token = p_child_node->p_wn_value; - } - if( p_child_node && \ - *(p_child_node->p_wn_key) == _CM_TOKEN_LONG) - { - p_long_token = p_child_node->p_wn_value; - } - - if( p_next_node && \ - *(p_next_node->p_wn_key) == _CM_TOKEN_SHORT) - { - p_short_token = p_next_node->p_wn_value; - } - if( p_next_node && \ - *(p_next_node->p_wn_key) == _CM_TOKEN_LONG) - { - p_long_token = p_next_node->p_wn_value; - } - - if( p_long_token && p_short_token) - { - memset( p_cm_l->p_long_token ,0,_CM_TOKEN_LONG_LEN); - sprintf((char*)p_cm_l->p_long_token,"%s",p_long_token); - - memset( p_cm_l->p_short_token ,0,_CM_TOKEN_SHORT_LEN); - sprintf((char*)p_cm_l->p_short_token,"%s%s",_CM_AUTHR_QURES,p_short_token); - - wilddog_node_delete(p_snapshot); - } - else - { - wilddog_node_delete(p_snapshot); - goto _SET_UNAUTH; - } - p_cm_l->d_authStatus = CM_SESSION_AUTHED; - return WILDDOG_ERR_NOERR; - } - -_SET_UNAUTH: - - p_cm_l->d_authStatus = CM_SESSION_UNAUTH; - return WILDDOG_ERR_INVALID; -} -/* - * Function: _wilddog_cm_sys_setOnLineState. - * Description: all repo was offline then system was offline,otherwise online. - * Input: p_cm_l : cm list. - * s : new state. - * note: in mutilple host,system was define online or offline while one - * host was online another offline ?? while all host was out of - * line then the system was define offline otherwise online. - * Output: N/A. - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_setOnLineState - ( - Wilddog_Cm_List_T *p_cm_l, - u32 s - ) -{ - _CM_SYS_Node_T *p_cmsys_n = NULL; - /*set host to new state.*/ - p_cmsys_n = _wilddog_cm_sys_findSysnodeBycml(p_cm_l); - if( p_cmsys_n == NULL) - return WILDDOG_ERR_NULL; - /*set new state.*/ - p_cmsys_n->d_onlineState = s; - if(_wilddog_ct_getOnlineStatus() == s){ - return WILDDOG_ERR_NOERR; - } - /*deal with offline while system online.*/ - if( _wilddog_ct_getOnlineStatus() == CM_ONLINE ) - { - if(s == CM_OFFLINE) - { - u8 changeFlag = 1; - _CM_SYS_Node_T *curr = NULL,*tmp=NULL; - LL_FOREACH_SAFE(p_l_cmControl->p_cmsys_n_hd,curr,tmp) - { - if(curr->d_onlineState == CM_ONLINE) - { - changeFlag = 0; - break; - } - } - if(changeFlag) - _wilddog_ct_setOnlineStatus(CM_OFFLINE); - } - } - else - _wilddog_ct_setOnlineStatus(s); - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_sys_getOnlineState. - * Description: updata token. - * Input: p_cm_l : cm list. - * Output: N/A. - * Return: u8 type. -*/ -STATIC u8 WD_SYSTEM _wilddog_cm_sys_getOnlineState - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - _CM_SYS_Node_T *p_cmsys_n = NULL; - /*set host to new state.*/ - p_cmsys_n = _wilddog_cm_sys_findSysnodeBycml(p_cm_l); - if(p_cmsys_n == NULL) - return CM_OFFLINE; - return p_cmsys_n->d_onlineState; -} -/* - * Function: _wilddog_cm_sys_timeInit - * Description: init sys the time of node. - * Input: p_cmsys_n: system node poniter. - * Output: N/A - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_timeInit - ( - _CM_SYS_Node_T *p_cmsys_n - ) -{ - p_cmsys_n->d_intervalTm = _CM_SYS_INTERVALINIT_SEC; - p_cmsys_n->d_stepTm = _CM_SYS_STEP_SEC; - if( p_cmsys_n->d_pingType != _CM_SYS_PINGTYPE_SHORT) - { - if(p_cmsys_n->p_ping_pkg) - { - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY, \ - (void*)p_cmsys_n->p_ping_pkg, \ - 0); - } - p_cmsys_n->p_ping_pkg = NULL; - } - - p_cmsys_n->d_pingType = _CM_SYS_PINGTYPE_SHORT; - p_cmsys_n->d_disableLink = FALSE; - - p_cmsys_n->d_offLineCnt = 0; - p_cmsys_n->d_ping_sendTm = _wilddog_getTime() + \ - p_cmsys_n->d_intervalTm * _CM_MS; - p_cmsys_n->d_ping_registerTm = p_cmsys_n->d_ping_sendTm; - - return WILDDOG_ERR_NOERR; -} -STATIC _CM_SYS_Node_T *WD_SYSTEM _wilddog_cm_sys_findSysnodeBycml - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - _CM_SYS_Node_T *curr = NULL,*tmp=NULL; - - wilddog_assert(p_cm_l,NULL); - - LL_FOREACH_SAFE(p_l_cmControl->p_cmsys_n_hd,curr,tmp) - { - if(curr->p_cm_l == p_cm_l) - return curr; - } - return NULL ; -} - -/* - * Function: _wilddog_cm_sys_setPingControlFlag - * Description: enable or disable ping controlFlag. - * Input: p_recv : receive data. - * Output: N/A - * Return: Wilddog_Return_T type. -*/ -STATIC int WD_SYSTEM _wilddog_cm_sys_disablePingLink - ( - Wilddog_Cm_List_T *p_cm_l, - BOOL newstate - ) -{ - int res = WILDDOG_ERR_NULL; - _CM_SYS_Node_T *p_find = NULL; - - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - - - p_find = _wilddog_cm_sys_findSysnodeBycml( p_cm_l ); - if(p_find) - { - p_find->d_disableLink= newstate; - res = WILDDOG_ERR_NOERR; - } - return res ; -} - -/* - * Function: _wilddog_cm_sys_timeStepIncrease - * Description: increase sys node step by step. - * Input: p_cmsys_n: system node poniter. - * Output: N/A - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_timeStepIncrease - ( - _CM_SYS_Node_T *p_cmsys_n - ) -{ - if( p_cmsys_n->d_pingType != _CM_SYS_PINGTYPE_SHORT) - { - if(p_cmsys_n->p_ping_pkg) - { - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY, \ - (void*)p_cmsys_n->p_ping_pkg, \ - 0); - - p_cmsys_n->p_ping_pkg = NULL; - - if(p_cmsys_n->d_stepTm) - { - /*not convergence.*/ - p_cmsys_n->d_intervalTm -= p_cmsys_n->d_stepTm; - if(p_cmsys_n->d_stepTm == 1) - { - p_cmsys_n->d_stepTm = 0; - /* internvaltime retrace retrace.*/ - if(p_cmsys_n->d_intervalTm > _CM_SYS_PINGRETRACETIME_SEC) - p_cmsys_n->d_intervalTm -= _CM_SYS_PINGRETRACETIME_SEC; - - } - else - p_cmsys_n->d_stepTm = p_cmsys_n->d_stepTm /2; - } - else - { - /*convergence and nat change*/ - p_cmsys_n->d_stepTm = _CM_SYS_STEP_SEC; - p_cmsys_n->d_intervalTm -= p_cmsys_n->d_stepTm; - } - } - } - else - { - p_cmsys_n->d_intervalTm += p_cmsys_n->d_stepTm; - } - - p_cmsys_n->d_pingType = _CM_SYS_PINGTYPE_SHORT; - /* step increase.*/ - if(p_cmsys_n->d_intervalTm >= _CM_SYS_PING_INTERVAL_MAX_SEC) - { - p_cmsys_n->d_stepTm = 0; - p_cmsys_n->d_intervalTm = _CM_SYS_PING_INTERVAL_MAX_SEC; - } - else - /* mini interval time.*/ - if( p_cmsys_n->d_intervalTm < _CM_SYS_PING_INTERVAL_MIN_SEC) - p_cmsys_n->d_intervalTm = _CM_SYS_PING_INTERVAL_MIN_SEC; - - p_cmsys_n->d_ping_registerTm = _wilddog_getTime() + \ - p_cmsys_n->d_intervalTm * _CM_MS; - - p_cmsys_n->d_ping_sendTm = p_cmsys_n->d_ping_registerTm; - p_cmsys_n->d_sendCnt = 0; - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_sys_timeSkip - * Description: recv user respond and set sys node send time to next cycle. - * Input: p_cm_l: responds list. - * Output: N/A - * Return: Wilddog_Return_T type. -*/ -/* 20160627 : disable,while notify frequently , server need ping package to keep session.*/ -#if 0 -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_timeSkip - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - _CM_SYS_Node_T *p_find = NULL; - - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - - p_find = _wilddog_cm_sys_findSysnodeBycml(p_cm_l); - if(p_find) - { - p_find->d_ping_registerTm = _wilddog_getTime() + \ - p_find->d_intervalTm * _CM_MS; - - p_find->d_ping_sendTm = p_find->d_ping_registerTm; - - p_find->d_sendCnt = 0; - return WILDDOG_ERR_NOERR; - } - else - return WILDDOG_ERR_NULL; -} -#endif -/* - * Function: _wilddog_cm_sys_timeReset - * Description: ping request lost or server haven't support. - * Input: p_cmsys_n: ping node pointer. - * Output: N/A - * Return: Wilddog_Return_T type. -*/ - -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_timeReset - ( - _CM_SYS_Node_T *p_cmsys_n - ) -{ - if( p_cmsys_n->d_pingType != _CM_SYS_PINGTYPE_LONG) - { - if(p_cmsys_n->p_ping_pkg) - { - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY, \ - (void*)p_cmsys_n->p_ping_pkg, \ - 0); - - p_cmsys_n->p_ping_pkg = NULL; - } - } - p_cmsys_n->d_pingType = _CM_SYS_PINGTYPE_LONG; -#if TEST_LINK_LOG_EN - ++(p_cmsys_n->d_long_pingCont); -#endif - - if( p_cmsys_n->d_offLineCnt < _CM_SYS_KEEPOFFLINE) - { - p_cmsys_n->d_ping_registerTm = _wilddog_getTime(); - p_cmsys_n->d_ping_sendTm = _wilddog_getTime(); - p_cmsys_n->d_sendCnt = 0; - } - else - { - p_cmsys_n->d_ping_registerTm = _CM_SYS_OFFLINE_PINGTM_SEC*_CM_MS + \ - _wilddog_getTime(); - - p_cmsys_n->d_ping_sendTm = p_cmsys_n->d_ping_registerTm; - - p_cmsys_n->d_sendCnt = 0; - p_cmsys_n->d_intervalTm = _CM_SYS_INTERVALINIT_SEC; - p_cmsys_n->d_stepTm = _CM_SYS_STEP_SEC; - /* set offline.*/ - - _wilddog_cm_sys_setOnLineState(p_cmsys_n->p_cm_l,CM_OFFLINE); - } - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_sys_recvHandle - * Description: handle ping responds. - * Input: p_cmsys_n: ping node pointer. - * p_recv : receive data. - * Output: N/A - * Return: Wilddog_Return_T type. -*/ -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_recvHandle - ( - Protocol_recvArg_T *p_recv, - _CM_SYS_Node_T *p_cmsys_n - ) -{ - if( _CM_RECV_SERVER_ERROR(p_recv->err)) - { - if( p_recv->err == WILDDOG_ERR_RECVTIMEOUT) - p_cmsys_n->d_offLineCnt++; - else if(p_recv->err == WILDDOG_HTTP_PRECONDITION_FAIL) - p_cmsys_n->p_cm_l->d_serverEvent = CM_SERVER_EVENT_PRECONDITION_FAIL; - else if( p_recv->err == WILDDOG_HTTP_BAD_REQUEST && - p_cmsys_n->d_pingType == _CM_SYS_PINGTYPE_LONG) - { - /* server have been release session resource.*/ - p_cmsys_n->p_cm_l->d_authStatus = CM_SESSION_DOAUTH; - /* reset ping time.*/ - _wilddog_cm_sys_timeInit(p_cmsys_n); - return WILDDOG_ERR_NOERR; - } - /* package lost ,init session.*/ - if(p_recv->err == WILDDOG_ERR_RECVTIMEOUT) - { -#if TEST_LINK_LOG_EN - - wilddog_debug("\t re_connect session\n"); -#endif - _wilddog_sec_reconnect( p_cmsys_n->p_cm_l->p_host, \ - WILDDOG_PORT, \ - _CM_SYS_RECONNECT_TIME); - } - /* err responds.*/ - _wilddog_cm_sys_timeReset(p_cmsys_n); - } - else - { - /* if already off line then reOnline.*/ - if(CM_OFFLINE == _wilddog_cm_sys_getOnlineState(p_cmsys_n->p_cm_l)) - { - p_l_cmControl->d_cm_onlineEvent = _CM_EVENT_TYPE_REONLINE; - _wilddog_cm_sys_setOnLineState(p_cmsys_n->p_cm_l,CM_ONLINE); - } - /*reset offline flag.*/ - p_cmsys_n->d_offLineCnt = 0; - /* normal responds.*/ - _wilddog_cm_sys_timeStepIncrease(p_cmsys_n); - } -#if TEST_LINK_LOG_EN - wilddog_debug("\t<><>\ttry long ping time : %d",p_cmsys_n->d_long_pingCont); - wilddog_debug("\t<><>\tinterval time :%d ",p_cmsys_n->d_intervalTm); - wilddog_debug("\t<><>\tstep time :%d ",p_cmsys_n->d_stepTm); -#endif - - return WILDDOG_ERR_NOERR; -} -/* - * Function: _wilddog_cm_sys_findNode - * Description: find ping node according to the token. - * Input: p_recv : receive data. - * Output: N/A - * Return: Wilddog_Return_T type. -*/ -STATIC BOOL WD_SYSTEM _wilddog_cm_sys_findNode - ( - Protocol_recvArg_T *p_recv - ) -{ - BOOL res = FALSE; - _CM_SYS_Node_T *curr = NULL,*tmp=NULL; - - wilddog_assert(p_recv,WILDDOG_ERR_INVALID); - - LL_FOREACH_SAFE(p_l_cmControl->p_cmsys_n_hd,curr,tmp) - { - if((curr->d_token & 0xffffffff) == (p_recv->d_token & 0xffffffff)) - { - _wilddog_cm_sys_recvHandle(p_recv,curr); - res = TRUE; - break; - } - } - - return res ; -} - -STATIC int WD_SYSTEM _wilddog_cm_sys_pingSend - ( - _CM_SYS_Node_T *p_cmsys_n - ) -{ - int res = 0; - Wilddog_CM_Send_Ping_Arg_T ping_pkg; - if(p_cmsys_n->p_ping_pkg == NULL) - { - p_cmsys_n->p_ping_pkg = _wilddog_cm_sys_creatPing(p_cmsys_n->p_cm_l, \ - p_cmsys_n->d_pingType, \ - &(p_cmsys_n->d_token)); - - if(p_cmsys_n->p_ping_pkg == NULL) - return WILDDOG_ERR_NULL; - } - - if(NULL == p_cmsys_n->p_ping_pkg) - return -1; - - ping_pkg.p_pkg = p_cmsys_n->p_ping_pkg; - ping_pkg.d_mid = (u16)_wilddog_cm_cmd_getIndex(NULL, 0); - ping_pkg.d_token = (u32) _wilddog_cm_cmd_getToken(NULL, 0); - p_cmsys_n->d_token = ping_pkg.d_token; - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_MODIFY_MIDTOKEN, &ping_pkg, 0); - res = _wilddog_protocol_ioctl(_PROTOCOL_CMD_SEND,p_cmsys_n->p_ping_pkg,0); - p_cmsys_n->d_ping_sendTm = _CM_NEXTSENDTIME_SET(_wilddog_getTime(), \ - p_cmsys_n->d_sendCnt); - - return res; -} - -STATIC int WD_SYSTEM _wilddog_cm_sys_keeplink(void) -{ - _CM_SYS_Node_T *curr = NULL,*tmp = NULL; - u32 currTm = _wilddog_getTime(); - - wilddog_assert(p_l_cmControl,WILDDOG_ERR_INVALID); - - LL_FOREACH_SAFE(p_l_cmControl->p_cmsys_n_hd,curr,tmp) - { - if( currTm >curr->d_ping_sendTm&& \ - DIFF(currTm,curr->d_ping_sendTm) < (0xffff)) - { - if(curr->d_disableLink == TRUE) - continue; - - if( DIFF(curr->d_ping_registerTm,currTm) > WILDDOG_RETRANSMITE_TIME ) - { - /* time out.*/ - Protocol_recvArg_T timeOutArg; - memset(&timeOutArg,0,sizeof(Protocol_recvArg_T)); - timeOutArg.err = WILDDOG_ERR_RECVTIMEOUT; - _wilddog_cm_sys_recvHandle(&timeOutArg,curr); - } - else /*send out.*/ - _wilddog_cm_sys_pingSend(curr); - } - } - return WILDDOG_ERR_NOERR; -} -STATIC int WD_SYSTEM _wilddog_cm_sys_nodeAdd( Wilddog_Cm_List_T *p_cm_l) -{ - _CM_SYS_Node_T *p_cmSys_n = NULL; - - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - - p_cmSys_n = (_CM_SYS_Node_T*)wmalloc(sizeof(_CM_SYS_Node_T)); - if( p_cmSys_n == NULL) - return WILDDOG_ERR_NULL; - - memset(p_cmSys_n,0,sizeof(_CM_SYS_Node_T)); - - p_cmSys_n->p_cm_l = p_cm_l; - - wilddog_debug_level(WD_DEBUG_LOG,"conn_manage:: Add system node : %p",p_cmSys_n); - - /*add to list.*/ - LL_APPEND(p_l_cmControl->p_cmsys_n_hd,p_cmSys_n); - - _wilddog_cm_sys_timeInit(p_cmSys_n); - - return WILDDOG_ERR_NOERR; -} -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_nodeRemove - ( - _CM_SYS_Node_T **pp_cmsys_n - ) -{ - _CM_SYS_Node_T *p_cmsys_n = NULL; - - wilddog_assert(pp_cmsys_n,WILDDOG_ERR_INVALID); - wilddog_assert(*pp_cmsys_n,WILDDOG_ERR_INVALID); - - p_cmsys_n = *pp_cmsys_n; - - wilddog_debug_level(WD_DEBUG_LOG,"conn_manage:: remove system node : %p",p_cmsys_n); - if(p_cmsys_n->p_ping_pkg) - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_cmsys_n->p_ping_pkg,0); - - /* remove from list*/ - LL_DELETE(p_l_cmControl->p_cmsys_n_hd,p_cmsys_n); - /*free it.*/ - wfree(p_cmsys_n); - - *pp_cmsys_n = NULL; - - return WILDDOG_ERR_NOERR; -} -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_cm_sys_releaseRepoResource - ( - Wilddog_Cm_List_T *p_cm_l - ) -{ - _CM_SYS_Node_T *p_find = NULL; - - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - p_find = _wilddog_cm_sys_findSysnodeBycml(p_cm_l); - if(p_find) - { - _wilddog_cm_sys_nodeRemove(&p_find); - } - return WILDDOG_ERR_NOERR; -} - -STATIC int WD_SYSTEM _wilddog_cm_sys_listDestory(void) -{ - _CM_SYS_Node_T *curr = NULL,*tmp=NULL; - LL_FOREACH_SAFE(p_l_cmControl->p_cmsys_n_hd,curr,tmp) - { - _wilddog_cm_sys_nodeRemove(&curr); - } - - return WILDDOG_ERR_NOERR; -} -/* system ping creat.*/ -STATIC void* WD_SYSTEM _wilddog_cm_sys_creatPing - ( - Wilddog_Cm_List_T *p_cm_l, - _CM_SYS_PING_TYPE_T pingType, - u32 *p_pkg_token - ) -{ - void* p_pkg_index = NULL; - int res = 0; - Protocol_Arg_Creat_T pkg_arg; - Protocol_Arg_Option_T pkg_option; - Protocol_Arg_CountSize_T pkg_payload; - Wilddog_CM_UserArg_T sendArg; - - memset(&pkg_arg,0,sizeof(Protocol_Arg_Creat_T)); - memset(&pkg_option,0,sizeof(Protocol_Arg_Option_T)); - memset(&pkg_payload,0,sizeof(Protocol_Arg_CountSize_T)); - memset(&sendArg,0,sizeof(Wilddog_CM_UserArg_T)); - - /* init protocol package.*/ - if( pingType == _CM_SYS_PINGTYPE_SHORT) - { - pkg_arg.cmd = WILDDOG_CM_SYS_CMD_SHORTPING; - pkg_payload.p_path =(u8*)_CM_SYS_PING_SHORTTOKEN_PATH; - pkg_payload.p_query = p_cm_l->p_short_token; - } - else - { - pkg_arg.cmd = WILDDOG_CM_SYS_CMD_LONGPING; - pkg_payload.p_path =(u8*)_CM_SYS_PING_LONGTOKEN_PATH; - pkg_payload.d_payloadLen = strlen((char*)p_cm_l->p_long_token)+1; - } - pkg_payload.p_host = p_cm_l->p_host; - pkg_arg.d_packageLen=(int)_wilddog_protocol_ioctl(_PROTOCOL_CMD_COUNTSIZE, \ - &pkg_payload, - 0); - - /* get messageid */ - pkg_arg.d_index = (u16)_wilddog_cm_cmd_getIndex(NULL,0); - pkg_arg.d_token = (u32) _wilddog_cm_cmd_getToken(NULL,0); - - - /* creat coap package.*/ - p_pkg_index =(void*)_wilddog_protocol_ioctl(_PROTOCOL_CMD_CREAT,&pkg_arg,0); - if( p_pkg_index == NULL) - return NULL; - - /* add host.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = p_cm_l->p_repo->p_rp_url->p_url_host; - - res = _wilddog_protocol_ioctl(_PROTOCOL_CMD_ADD_HOST,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CM_CREATPING_ERR; - - /* add token*/ - if( pingType == _CM_SYS_PINGTYPE_SHORT) - { - /* add ping path.*/ - pkg_option.p_pkg = (void*)p_pkg_index; - //p_cm_l->p_repo->p_rp_url->p_url_path - pkg_option.p_options = _CM_SYS_PING_SHORTTOKEN_PATH; - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_PATH,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CM_CREATPING_ERR; - /* add query.*/ - pkg_option.p_options = p_cm_l->p_short_token; - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_QUERY,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CM_CREATPING_ERR; - } - else - { - /* add ping path.*/ - Protocol_Arg_Payload_T payloadArg; - pkg_option.p_pkg = (void*)p_pkg_index; - pkg_option.p_options = _CM_SYS_PING_LONGTOKEN_PATH; - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_PATH,&pkg_option,0); - if( res != WILDDOG_ERR_NOERR ) - goto _CM_CREATPING_ERR; - - /* add ping token.*/ - payloadArg.p_pkg = (void*)p_pkg_index; - payloadArg.p_payload = (void*)p_cm_l->p_long_token; - payloadArg.d_payloadLen = strlen((char*)p_cm_l->p_long_token); - - res = _wilddog_protocol_ioctl( _PROTOCOL_CMD_ADD_DATA,&payloadArg,0); - if(res < 0) - goto _CM_CREATPING_ERR; - - } - /* add to system list and send out.*/ - *p_pkg_token = 0xffffffff & pkg_arg.d_token; - - return p_pkg_index; - -_CM_CREATPING_ERR: - - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DESTORY,(void*)p_pkg_index,0); - return NULL; -} - -/* - * Function: _wilddog_get_index - * Description: get index - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC int WD_SYSTEM _wilddog_cm_cmd_getIndex(void *p_arg,int flag) -{ - int res = 0xffff; - p_l_cmControl->d_messageId++; - - res = res & p_l_cmControl->d_messageId; - return res; -} -/* - * Function: _wilddog_get_index - * Description: get index - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC u32 WD_SYSTEM _wilddog_cm_cmd_getToken(void *p_arg,int flag) -{ - u32 temtoken = 0; - temtoken = _wilddog_cm_rand_get(); - return (u32)(0x0 |((temtoken<<8) | (p_l_cmControl->d_messageId & 0xff))); -} -/* - * Function: wilddog_cm_shortToken - * Description: get - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC INLINE void* WD_SYSTEM _wilddog_cm_cmd_shortToken - ( - Wilddog_Cm_List_T *p_cm_l, - int flag - ) -{ - return (void*)p_cm_l->p_short_token; -} -/* - * Function: wilddog_cm_shortToken - * Description: get - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC INLINE void* WD_SYSTEM _wilddog_cm_cmd_authQuery - ( - Wilddog_Cm_List_T *p_cm_l, - int flag - ) -{ - return (void*)(p_cm_l->p_short_token); -} - -/* - * Function: wilddog_cm_shortToken - * Description: get - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC int WD_SYSTEM _wilddog_cm_cmd_deleNodeByPath - ( - Wilddog_CM_OffArg_T *p_arg, - int flag - ) -{ - Wilddog_CM_Node_T *curr = NULL, *tmp = NULL; - - if( p_arg->p_cm_l == NULL) - return WILDDOG_ERR_INVALID; - - LL_FOREACH_SAFE(p_arg->p_cm_l->p_cm_n_hd,curr,tmp) - { - if( curr->d_nodeType == CM_NODE_TYPE_OBSERVER && - strcmp((const char*)curr->p_path,(const char*)p_arg->p_path) == 0) - { - LL_DELETE(p_arg->p_cm_l->p_cm_n_hd,curr); - _wilddog_cm_node_destory(&curr); - } - } - - return WILDDOG_ERR_NOERR; -} - -/* - * Function: wilddog_cm_offLine - * Description: get - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC int WD_SYSTEM _wilddog_cm_cmd_offLine - ( - Wilddog_Cm_List_T *p_cm_l, - int flag - ) -{ - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - /*all host offLine cmd already sended out then we define system offline.*/ - //p_cm_l->d_authStatus = CM_SESSION_UNAUTH; - _wilddog_cm_sys_setOnLineState(p_cm_l,CM_OFFLINE); - return _wilddog_cm_sys_disablePingLink(p_cm_l,TRUE); -} -/* - * Function: wilddog_cm_onLine - * Description: get - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC int WD_SYSTEM _wilddog_cm_cmd_onLine - ( - Wilddog_Cm_List_T *p_cm_l, - int flag - ) -{ - _CM_SYS_Node_T *p_cmsys_n = NULL; - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - //p_cm_l->d_authStatus = CM_SESSION_DOAUTH; - p_cmsys_n = _wilddog_cm_sys_findSysnodeBycml(p_cm_l); - if(p_cmsys_n) - { - p_cmsys_n->p_cm_l->d_authStatus = CM_SESSION_DOAUTH; - /* reset ping time.*/ - _wilddog_cm_sys_timeInit(p_cmsys_n); - - return WILDDOG_ERR_NOERR; - } - else - return WILDDOG_ERR_NULL; -} -/* - * Function: wilddog_cm_onLine - * Description: get - * Input: N/A - * Output: N/A - * Return: A rand number -*/ -STATIC int WD_SYSTEM _wilddog_cm_cmd_trySync - ( - Wilddog_Cm_List_T *p_cm_l, - int flag - ) -{ - int res = 0; - res = _wilddog_cm_retransmit(p_cm_l); - res = _wilddog_cm_session_maintain(p_cm_l); - res = _wilddog_cm_recv(); - res = _wilddog_cm_reOnline(); - res = _wilddog_cm_trafficRunOut(p_cm_l); - res = _wilddog_cm_sys_keeplink(); - return res; -} - -/* - * Function: _wilddog_cm_cmd_init - * Description: init session. - * - * Input: p_host: The pointer of the host - * d_port: The port number. - * f_cn_callBack : conn call back. - * Output: N/A - * Return: N/A -*/ -Wilddog_Cm_List_T* WD_SYSTEM _wilddog_cm_cmd_init - ( - Wilddog_CM_InitArg_T *p_arg, - int flag - ) -{ - int res = 0; - Protocol_Arg_Init_T d_pkginitArg; - Wilddog_Cm_List_T *p_cm_l = NULL ; - - memset(&d_pkginitArg,0,sizeof(Protocol_Arg_Init_T)); - - d_pkginitArg.d_port = WILDDOG_PORT; - d_pkginitArg.p_host = p_arg->p_repo->p_rp_url->p_url_host; - d_pkginitArg.f_handleRespond = (Wilddog_Func_T)_wilddog_cm_recv_findContext; - - /*creat list head.*/ - p_cm_l = wmalloc(sizeof(Wilddog_Cm_List_T)); - if( p_cm_l== NULL) - return NULL; - - memset(p_cm_l,0,sizeof(Wilddog_Cm_List_T)); - p_cm_l->p_repo = p_arg->p_repo; - /* Auth request.*/ - /* coap init.*/ - if(p_l_cmControl == NULL) - { - p_l_cmControl = (CM_Control_T*)wmalloc(sizeof(CM_Control_T)); - if( p_l_cmControl == NULL) - { - wfree(p_cm_l); - return NULL; - } - memset(p_l_cmControl,0,sizeof(CM_Control_T)); - - p_l_cmControl->p_cm_l_hd = p_cm_l; - p_l_cmControl->d_messageId = _wilddog_cm_rand_get(); - p_l_cmControl->f_cn_callBackHandle = p_arg->f_conn_cb; - _wilddog_protocol_ioctl(_PROTOCOL_CMD_INIT,&d_pkginitArg,0); - } - -#ifdef WILDDOG_SELFTEST - performtest_getDtlsHskTime(); - performtest_timeReset(); -#endif - - p_cm_l->p_host = p_arg->p_repo->p_rp_url->p_url_host; - /* auth reques and send out.*/ - if((res = _wilddog_cm_sessionInit(p_cm_l))< 0 ) - goto CM_INIT_ERROR; - -#ifdef WILDDOG_SELFTEST - ramtest_skipLastmalloc(); - - performtest_getSessionQueryTime(); - performtest_timeReset(); -#endif - - res =_wilddog_cm_sys_nodeAdd(p_cm_l); - if( res < 0 ) - goto CM_INIT_ERROR; - - p_l_cmControl->d_list_cnt++; - wilddog_debug_level(WD_DEBUG_LOG,"conn_manage:: creat repo linked list : %p",p_cm_l); - return p_cm_l; -CM_INIT_ERROR: - - wfree(p_cm_l); - if( p_l_cmControl->d_list_cnt == 0) - { - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DEINIT,NULL,0); - wfree(p_l_cmControl); - } - return NULL; -} -/* - * Function: _wilddog_cm_cmd_init - * Description: init session. - * - * Input: p_host: The pointer of the host - * d_port: The port number. - * Output: N/A - * Return: N/A -*/ -Wilddog_Return_T WD_SYSTEM _wilddog_cm_cmd_deInit - ( - Wilddog_Cm_List_T *p_cm_l, - int flags - ) -{ - if( p_l_cmControl == NULL) - return WILDDOG_ERR_NULL; - - wilddog_assert(p_cm_l,WILDDOG_ERR_INVALID); - /* destory list.*/ - - _wilddog_cm_sys_releaseRepoResource(p_cm_l); - _wilddog_cm_list_destory(p_cm_l); - p_l_cmControl->d_list_cnt--; - - /* pakg deinit.*/ - if(p_l_cmControl->d_list_cnt == 0) - { - _wilddog_cm_sys_listDestory(); - _wilddog_protocol_ioctl(_PROTOCOL_CMD_DEINIT,NULL,0); - wfree(p_l_cmControl); - p_l_cmControl = NULL; - } - - return WILDDOG_ERR_NOERR; -} - -/* protocol :: coap interface */ -Wilddog_Func_T _wilddog_cm_funcTable[CM_CMD_MAX + 1] = -{ - (Wilddog_Func_T) _wilddog_cm_cmd_init, - (Wilddog_Func_T) _wilddog_cm_cmd_deInit, - - (Wilddog_Func_T) _wilddog_cm_cmd_getIndex, - (Wilddog_Func_T) _wilddog_cm_cmd_getToken, - - (Wilddog_Func_T) _wilddog_cm_cmd_shortToken, - (Wilddog_Func_T) _wilddog_cm_cmd_authQuery, - - (Wilddog_Func_T) _wilddog_cm_cmd_userSend, - (Wilddog_Func_T) _wilddog_cm_cmd_deleNodeByPath, - - (Wilddog_Func_T) _wilddog_cm_cmd_offLine, - (Wilddog_Func_T) _wilddog_cm_cmd_onLine, - - (Wilddog_Func_T) _wilddog_cm_cmd_trySync, - (Wilddog_Func_T) _wilddog_cm_findObserverNode, - (Wilddog_Func_T) _wilddog_cm_cmd_authe_delete, - NULL -}; -/* - * Function: _wilddog_protocol_ioctl - * Description: the ioctl function of protocol - * Input: cmd: command - * arg: the arg - * flags: the flag, not used - * Output: N/A - * Return: if success, return WILDDOG_ERR_NOERR -*/ -size_t WD_SYSTEM _wilddog_cm_ioctl - ( - u8 cmd, - void *p_args, - int flags - ) -{ - if( cmd >= _PROTOCOL_CMD_MAX || - cmd < 0) - return WILDDOG_ERR_INVALID; - - return (size_t)(_wilddog_cm_funcTable[cmd])(p_args,flags); -} - diff --git a/src/wilddog_conn_manage.h b/src/wilddog_conn_manage.h deleted file mode 100644 index 10f8d76..0000000 --- a/src/wilddog_conn_manage.h +++ /dev/null @@ -1,189 +0,0 @@ -/* - * Copyright (C) 2014-2016 Wilddog Technologies. All Rights Reserved. - * - * FileName: wilddog_manage.h - * - * Description: connection management. - * - * History: - * Version Author Date Description - * - * 0.4.0 lxs 2015-05-15 Create file. - * - */ - -#ifndef _WILDDOG_CONN_MANAGE_H_ -#define _WILDDOG_CONN_MANAGE_H_ - -#ifdef __cplusplus -extern "C" -{ -#endif - -#include "wilddog.h" -#include "wilddog_ct.h" -#include "wilddog_url_parser.h" - - -#define _CM_AUTHR_PATH "/.cs" -#define _CM_AUTHR_QURES ".cs=" -#define _CM_ONDIS ".dis=add" -#define _CM_DISCANCEL ".dis=rm" -#define _CM_OFFLINE_PATH "/.off" -#define _CM_ONLINE ".on" - - -#define AUTHR_LEN (4) -#define AUTHR_LENINBYTE (2*AUTHR_LEN) - - -typedef enum CM_CMD_T{ - CM_CMD_INIT, - CM_CMD_DEINIT, - - CM_CMD_GET_INDEX, - CM_CMD_GET_TOKEN, - - CM_CMD_SHORTTOKEN, - CM_CMD_AUTHQUERY, - - CM_CMD_USERSEND, - CM_CMD_DELENODE_BYPATH, - - CM_CMD_OFFLINE, - CM_CMD_ONLINE, - CM_CMD_TRYSYNC, - - - CM_CMD_OBSERVER_ALEADY, - CM_CMD_AUTH_DELETE, - - CM_CMD_MAX -}CM_Cmd_T; -typedef enum CM_ONLINE_STATUS{ - CM_OFFLINE, - CM_ONLINE -}CM_Online_Status; -typedef enum CM_SESSION_STATE{ - CM_SESSION_UNAUTH, - CM_SESSION_DOAUTH, - CM_SESSION_AUTHING, - CM_SESSION_AUTHED -}CM_Session_State; - -typedef enum CM_SERVER_EVENT_T{ - CM_SERVER_EVENT_NOMAL, - CM_SERVER_EVENT_PRECONDITION_FAIL, - CM_SERVER_EVENT_MAX - -}CM_Server_Event_T; - -typedef enum WILDDOG_CMSYS_CMD_TYPE -{ - WILDDOG_CM_SYS_CMD_SHORTPING = 0XA0, - WILDDOG_CM_SYS_CMD_LONGPING = 0XA1, - - WILDDOG_CM_SYS_CMD_MAX -}Wilddog_Cmsys_Cmd_Type; - -typedef struct WILDDOG_CM_NODE_T{ - - u32 cmd; - u32 d_registerTm; - u32 d_sendTm; - u32 d_token; - void *p_pkg; - void* p_userCB_arg; - Wilddog_Func_T f_userCB; - - u32 d_subscibe_index; - u32 d_maxAge; - u8 *p_path; - - struct WILDDOG_CM_NODE_T *next; - - - u8 reObserver_flg; - u8 d_nodeType; - u8 d_retransmit_cnt; - u8 _reserve; -}Wilddog_CM_Node_T; - -typedef struct WILDDOG_CM_LIST_T -{ - Wilddog_CM_Node_T *p_cm_n_hd; - u8 *p_long_token; - u8 *p_short_token; - Wilddog_Str_T *p_host; - Wilddog_Repo_T *p_repo; - - CM_Session_State d_authStatus; - CM_Server_Event_T d_serverEvent; -}Wilddog_Cm_List_T; - -typedef struct WILDDOG_CM_INITARG_T{ - - Wilddog_Func_T f_conn_cb; - Wilddog_Repo_T *p_repo; -}Wilddog_CM_InitArg_T; - -typedef struct WILDDOG_CM_OFFARG_T{ - - u8 *p_path; - Wilddog_Cm_List_T *p_cm_l; - -}Wilddog_CM_OffArg_T; - - -typedef struct WILDDOG_CM_USERARG_T{ - - u32 cmd; - u32 d_token; - void *p_pkg; - - void* f_userCB_arg; - u8 *p_path; - Wilddog_Func_T f_userCB; - Wilddog_Cm_List_T *p_cm_l; - -}Wilddog_CM_UserArg_T; - -typedef struct WILDDOG_CM_RECV_T -{ - Wilddog_Payload_T *p_recvData; - Wilddog_Func_T f_user_callback; - Wilddog_Str_T *p_url_path; - void* p_user_cb_arg; - u32 err; - u8 cmd; -}Wilddog_CM_Recv_T; - -typedef struct PROTOCOL_RECVARG_T{ - - u32 d_observerIndx; - u32 d_maxAge; - u32 d_token; - u32 err; - - u32 d_recvDataLen; - - u8 d_isObserver; - u8 d_blockIdx; - u8 d_blockNum; - u8 reserve; - - u8 *p_r_path; - u8 *p_recvData; - -}Protocol_recvArg_T; - -typedef struct WILDDOG_CM_SEND_PING_ARG_T -{ - void* p_pkg; - u16 d_mid; - u32 d_token; -}Wilddog_CM_Send_Ping_Arg_T; -extern size_t WD_SYSTEM _wilddog_cm_ioctl(u8 cmd,void *p_args,int flags); - -#endif /* _WILDDOG_CONN_MANAGE_H_ */ - diff --git a/src/wilddog_ct.c b/src/wilddog_ct.c index 2150872..f87c935 100644 --- a/src/wilddog_ct.c +++ b/src/wilddog_ct.c @@ -562,9 +562,12 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_ct_destoryRepo wilddog_assert(p_repo, WILDDOG_ERR_NULL); p_repoHead = _wilddog_ct_getRepoHead(); - p_repo->p_rp_store = _wilddog_store_deinit(p_repo); - p_repo->p_rp_conn = _wilddog_conn_deinit(p_repo); - + _wilddog_store_deinit(p_repo); + _wilddog_conn_deinit(p_repo); + + p_repo->p_rp_store = NULL; + p_repo->p_rp_conn = NULL; + _wilddog_url_freeParsedUrl(p_repo->p_rp_url); p_repo->p_rp_url = NULL; LL_DELETE((*p_repoHead), p_repo); diff --git a/src/wilddog_event.c b/src/wilddog_event.c index 4f91481..feea747 100644 --- a/src/wilddog_event.c +++ b/src/wilddog_event.c @@ -260,7 +260,7 @@ void WD_SYSTEM _wilddog_event_trigger enode = repo->p_rp_store->p_se_event->p_head; - /*TODO: use the type to check which event can be triggered */ + /* Event bubbling, trigger all relative events. */ while(enode) { u8 pathContainResult = 0; @@ -420,6 +420,7 @@ Wilddog_Return_T WD_SYSTEM _wilddog_event_nodeAdd } else if( ((cmpResult == 0) && (slen == dlen)) ) { + /*oh no, find a node already exists.*/ tmp_node->p_onData = arg->p_complete; tmp_node->p_dataArg = arg->p_completeArg; _wilddog_event_nodeFree(node); @@ -597,6 +598,7 @@ Wilddog_Return_T WD_SYSTEM _wilddog_event_nodeDelete if(node->flag == ON_FLAG) { + if(p_conn && p_conn->f_conn_ioctl) { err = p_conn->f_conn_ioctl(WILDDOG_CONN_CMD_OFF, arg, 0); @@ -605,6 +607,9 @@ Wilddog_Return_T WD_SYSTEM _wilddog_event_nodeDelete wilddog_debug_level(WD_DEBUG_LOG, "nodedelete off node path:%s\n", \ arg->p_url->p_url_path); + /*if this node is to be closed, but it's son or grandson want's on, then + *on them. + */ prev_node = node; node = node->next; while(node) @@ -738,7 +743,6 @@ Wilddog_Event_T* WD_SYSTEM _wilddog_event_init(Wilddog_Store_T *p_store) if(p_event == NULL) { wilddog_debug_level( WD_DEBUG_ERROR, "cannot wmalloc Wilddog_Event_T"); - return NULL; } diff --git a/src/wilddog_protocol.h b/src/wilddog_protocol.h new file mode 100644 index 0000000..692eaf4 --- /dev/null +++ b/src/wilddog_protocol.h @@ -0,0 +1,65 @@ + +#ifndef _WILDDOG_PROTOCOL_H_ +#define _WILDDOG_PROTOCOL_H_ +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "wilddog.h" +#include "wilddog_ct.h" +#include "wilddog_url_parser.h" + +#define WILDDOG_PROTO_RECV_BUF_NUM 1 + +typedef struct _WILDDOG_PROTO_RECV_STRUCT +{ + u8 data[WILDDOG_PROTO_MAXSIZE]; + u8 isused; +}_wilddog_Proto_Recv_T; + +typedef struct WILDDOG_PROTOCOL_T{ + Wilddog_Str_T *host; + int socketFd; + Wilddog_Address_T addr; + Wilddog_Func_T callback; + _wilddog_Proto_Recv_T recv_buf[WILDDOG_PROTO_RECV_BUF_NUM]; +}Wilddog_Protocol_T; +typedef struct WILDDOG_PROTO_CMD_ARG_T{ + Wilddog_Protocol_T* protocol; + u8 *p_data;//input + u32 d_data_len; + Wilddog_Url_T * p_url; + u32 * p_message_id; + u8 **p_out_data;//output + u32 *p_out_data_len; + u8 **p_proto_data;//proto special, in/out +}Wilddog_Proto_Cmd_Arg_T; +typedef enum WILDDOG_PROTO_CMD_T{ + WD_PROTO_CMD_SEND_SESSION_INIT = 0, + WD_PROTO_CMD_SEND_SESSION_PING, + WD_PROTO_CMD_SEND_GET, + WD_PROTO_CMD_SEND_SET, + WD_PROTO_CMD_SEND_PUSH, + WD_PROTO_CMD_SEND_REMOVE, + WD_PROTO_CMD_SEND_ON, + WD_PROTO_CMD_SEND_OFF, + WD_PROTO_CMD_SEND_DIS_SET, + WD_PROTO_CMD_SEND_DIS_PUSH, + WD_PROTO_CMD_SEND_DIS_REMOVE, + WD_PROTO_CMD_SEND_DIS_CANCEL, + WD_PROTO_CMD_SEND_ONLINE, + WD_PROTO_CMD_SEND_OFFLINE, + WD_PROTO_CMD_RECV_GETPKT, + WD_PROTO_CMD_RECV_FREEPKT, + WD_PROTO_CMD_RECV_HANDLEPKT, + WD_PROTO_CMD_MAX +}Wilddog_Proto_Cmd_T; +extern Wilddog_Protocol_T * _wilddog_protocol_init(void *p_conn); +extern Wilddog_Return_T _wilddog_protocol_deInit(void *p_conn); +#ifdef __cplusplus +} +#endif + +#endif /*_WILDDOG_PROTOCOL_H_*/ + diff --git a/src/wilddog_sec.h b/src/wilddog_sec.h index 01f9778..d0abaec 100644 --- a/src/wilddog_sec.h +++ b/src/wilddog_sec.h @@ -6,26 +6,29 @@ extern "C" { #endif +#include "wilddog_protocol.h" +extern int WD_SYSTEM _wilddog_sec_getHost + ( + Wilddog_Address_T *p_remoteAddr, + Wilddog_Str_T *p_host + ); extern Wilddog_Return_T _wilddog_sec_send ( + Wilddog_Protocol_T *protocol, void* p_data, s32 len ); extern int _wilddog_sec_recv ( + Wilddog_Protocol_T *protocol, void* p_data, s32 len ); -extern Wilddog_Return_T _wilddog_sec_init - ( - Wilddog_Str_T *p_host, - u16 d_port - ); -extern Wilddog_Return_T _wilddog_sec_deinit(void); +extern Wilddog_Return_T _wilddog_sec_init(Wilddog_Protocol_T *protocol); +extern Wilddog_Return_T _wilddog_sec_deinit(Wilddog_Protocol_T *protocol); extern Wilddog_Return_T _wilddog_sec_reconnect ( - Wilddog_Str_T *p_host, - u16 d_port, + Wilddog_Protocol_T *protocol, int retryNum ); #ifdef __cplusplus diff --git a/src/wilddog_sec_host.c b/src/wilddog_sec_host.c index de50256..e47753a 100644 --- a/src/wilddog_sec_host.c +++ b/src/wilddog_sec_host.c @@ -74,6 +74,9 @@ STATIC int WD_SYSTEM _wilddog_sec_getDefaultIpIndex int index; STATIC int count = 0; int totalNum = sizeof(l_defaultAddr_t)/sizeof(Wilddog_Address_T); + + wilddog_assert(p_host, 0); + index = _wilddog_sec_hashIndex(p_host, totalNum); index = (index + count) % totalNum; @@ -86,18 +89,17 @@ STATIC int WD_SYSTEM _wilddog_sec_getDefaultIpIndex * Function: _wilddog_sec_getHost * Description: sec layer get host ip by the name * - * Input: p_host: the pointer of the host - * d_port: the port + * Input: p_host: the pointer of the host + * * Output: p_remoteAddr: the pointer of the ip address * Return: the gethostbyname result */ int WD_SYSTEM _wilddog_sec_getHost ( Wilddog_Address_T *p_remoteAddr, - Wilddog_Str_T *p_host, - u16 d_port + Wilddog_Str_T *p_host ) -{ +{ int res = -1; int i; #define WILDDOG_COAP_LOCAL_HOST "s-dal5-coap-1.wilddogio.com" @@ -109,10 +111,10 @@ int WD_SYSTEM _wilddog_sec_getHost res = wilddog_gethostbyname(p_remoteAddr,WILDDOG_COAP_LOCAL_HOST); #ifdef WILDDOG_SELFTEST - ramtest_gethostbyname(); + ramtest_gethostbyname(); #endif #ifdef WILDDOG_SELFTEST - performtest_timeReset(); + performtest_timeReset(); #endif if(-1 == res) @@ -122,7 +124,6 @@ int WD_SYSTEM _wilddog_sec_getHost memcpy(p_remoteAddr->ip, l_defaultAddr_t[i].ip,l_defaultAddr_t[i].len); res = 0; } - p_remoteAddr->port = d_port; #undef WILDDOG_COAP_LOCAL_HOST return res; diff --git a/src/wilddog_sec_host.h b/src/wilddog_sec_host.h deleted file mode 100644 index 7766a83..0000000 --- a/src/wilddog_sec_host.h +++ /dev/null @@ -1,35 +0,0 @@ - -#ifndef _WILDDOG_SEC_H_ -#define _WILDDOG_SEC_H_ - -#ifdef __cplusplus -extern "C" { -#endif -extern int _wilddog_sec_getHost - ( - Wilddog_Address_T *p_remoteAddr, - Wilddog_Str_T *p_host, - u16 d_port - ); -extern Wilddog_Return_T _wilddog_sec_send - ( - void* p_data, - s32 len - ); -extern int _wilddog_sec_recv - ( - void* p_data, - s32 len - ); -extern Wilddog_Return_T _wilddog_sec_init - ( - Wilddog_Str_T *p_host, - u16 d_port - ); -extern Wilddog_Return_T _wilddog_sec_deinit(void); - -#ifdef __cplusplus -} -#endif - -#endif/*_WILDDOG_SEC_H_*/ \ No newline at end of file diff --git a/src/wilddog_store.c b/src/wilddog_store.c index d79738f..d55946d 100644 --- a/src/wilddog_store.c +++ b/src/wilddog_store.c @@ -116,24 +116,24 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_store_setAuth * Description: Deinit the store structure. * Input: p_repo: The pointer of the repo structure. * Output: N/A - * Return: return NULL. + * Return: return 0 or error code. */ -Wilddog_Store_T* WD_SYSTEM _wilddog_store_deinit(Wilddog_Repo_T* p_repo) +Wilddog_Return_T WD_SYSTEM _wilddog_store_deinit(Wilddog_Repo_T* p_repo) { Wilddog_Store_T *p_store = NULL; - wilddog_assert(p_repo, NULL); + wilddog_assert(p_repo, WILDDOG_ERR_NULL); p_store = p_repo->p_rp_store; if(NULL == p_store) - return NULL; + return WILDDOG_ERR_NULL; p_store->p_se_head = NULL; p_store->p_se_event = _wilddog_event_deinit(p_store); if(p_store->p_se_auth) wfree(p_store->p_se_auth); p_store->p_se_auth = NULL; wfree(p_store); - return NULL; + return WILDDOG_ERR_NOERR; } /* diff --git a/src/wilddog_store.h b/src/wilddog_store.h index d9c6325..bec3bca 100644 --- a/src/wilddog_store.h +++ b/src/wilddog_store.h @@ -61,7 +61,7 @@ typedef struct WILDDOG_STORE_T extern Wilddog_Store_T *_wilddog_store_init(Wilddog_Repo_T* p_repo); -extern Wilddog_Store_T *_wilddog_store_deinit(Wilddog_Repo_T* p_repo); +extern Wilddog_Return_T _wilddog_store_deinit(Wilddog_Repo_T* p_repo); #ifdef __cplusplus } diff --git a/src/wilddog_url_parser.c b/src/wilddog_url_parser.c index e71f747..e1091a1 100644 --- a/src/wilddog_url_parser.c +++ b/src/wilddog_url_parser.c @@ -374,8 +374,7 @@ void WD_SYSTEM parsed_url_free(struct parsed_url *purl) * Output: N/A * Return: success return 0, failed return nagative number. */ - -int WD_SYSTEM _wilddogurl_checkPath(Wilddog_Str_T *p_path) +int WD_SYSTEM _wilddog_url_checkPath(Wilddog_Str_T *p_path) { int len , i; u8 data; @@ -408,6 +407,42 @@ int WD_SYSTEM _wilddogurl_checkPath(Wilddog_Str_T *p_path) return WILDDOG_ERR_NOERR; } +Wilddog_Return_T WD_SYSTEM _wilddog_url_copy(Wilddog_Url_T* src, Wilddog_Url_T* dst){ + wilddog_assert(src && dst, WILDDOG_ERR_NULL); + + if(src->p_url_host){ + dst->p_url_host = (Wilddog_Str_T*)wmalloc(strlen((const char*)src->p_url_host) + 1); + if(NULL == dst->p_url_host){ + wilddog_debug_level(WD_DEBUG_ERROR, "malloc dst->p_url_host failed!"); + return WILDDOG_ERR_NULL; + } + strcpy((char*)dst->p_url_host,(char*)src->p_url_host); + } + if(src->p_url_path){ + dst->p_url_path = (Wilddog_Str_T*)wmalloc(strlen((const char*)src->p_url_path) + 1); + if(NULL == dst->p_url_path){ + wilddog_debug_level(WD_DEBUG_ERROR, "malloc dst->p_url_host failed!"); + wfree(dst->p_url_host); + dst->p_url_host = NULL; + return WILDDOG_ERR_NULL; + } + strcpy((char*)dst->p_url_path,(char*)src->p_url_path); + } + if(src->p_url_query){ + dst->p_url_query = (Wilddog_Str_T*)wmalloc(strlen((const char*)src->p_url_query) + 1); + if(NULL == dst->p_url_query){ + wilddog_debug_level(WD_DEBUG_ERROR, "malloc dst->p_url_host failed!"); + wfree(dst->p_url_host); + wfree(dst->p_url_path); + dst->p_url_host = NULL; + dst->p_url_path = NULL; + return WILDDOG_ERR_NULL; + } + strcpy((char*)dst->p_url_query,(char*)src->p_url_query); + } + return WILDDOG_ERR_NOERR; +} + /* * Function: _wilddog_url_parseUrl * Description: parse url using wilddog format. @@ -468,7 +503,7 @@ Wilddog_Url_T * WD_SYSTEM _wilddog_url_parseUrl(Wilddog_Str_T * url) len += strlen((const char*)p_paresd_url->path); if(WILDDOG_ERR_NOERR != \ - _wilddogurl_checkPath((Wilddog_Str_T*)p_paresd_url->path) + _wilddog_url_checkPath((Wilddog_Str_T*)p_paresd_url->path) ) { #ifdef WILDDOG_ADD_ONLINESTAT @@ -710,7 +745,7 @@ STATIC Wilddog_Str_T * WD_SYSTEM _wilddog_url_getChildStr return NULL; } - if(WILDDOG_ERR_NOERR != _wilddogurl_checkPath(childName)) + if(WILDDOG_ERR_NOERR != _wilddog_url_checkPath(childName)) { wilddog_debug_level(WD_DEBUG_ERROR, "check path error!"); return NULL; diff --git a/src/wilddog_url_parser.h b/src/wilddog_url_parser.h index db18c82..377c21f 100644 --- a/src/wilddog_url_parser.h +++ b/src/wilddog_url_parser.h @@ -48,6 +48,7 @@ extern Wilddog_Return_T _wilddog_url_getPath Wilddog_Str_T** pp_dstPath ); extern Wilddog_Str_T *_wilddog_url_getKey(Wilddog_Str_T * p_path); +extern Wilddog_Return_T _wilddog_url_copy(Wilddog_Url_T* src, Wilddog_Url_T* dst); #ifdef __cplusplus } #endif From 66d1baa85084a239fd5cc8ded0f650c8ebeb6178 Mon Sep 17 00:00:00 2001 From: itolfh Date: Tue, 17 Jan 2017 17:20:19 +0800 Subject: [PATCH 02/22] update --- include/wilddog.h | 5 +- platform/linux/wilddog_posix.c | 4 +- src/networking/coap/pdu.c | 16 +- src/networking/coap/wilddog_protocol_coap.c | 249 +++++++++++++++++- src/serialize/cbor/wilddog_cbor.c | 1 - src/wilddog_conn.c | 271 ++++++++++++++++++-- src/wilddog_conn.h | 4 +- src/wilddog_protocol.h | 2 +- 8 files changed, 499 insertions(+), 53 deletions(-) diff --git a/include/wilddog.h b/include/wilddog.h index c461845..5658c58 100644 --- a/include/wilddog.h +++ b/include/wilddog.h @@ -76,7 +76,7 @@ typedef signed long s32 ; #endif #ifdef WILDDOG_DEBUG -#define DEBUG_LEVEL WD_DEBUG_ERROR +#define DEBUG_LEVEL WD_DEBUG_ALL STATIC const char *s_debug[] = { "[ALL]", @@ -87,7 +87,7 @@ STATIC const char *s_debug[] = { }; #define wilddog_debug_level(level, format,...) do{if(level >= DEBUG_LEVEL){ \ - printf("func:%s LINE: %d: %s"format"\r\n", __func__, __LINE__, s_debug[level],##__VA_ARGS__); \ + printf("%s:func:%s LINE: %d: "format"\r\n",s_debug[level],__func__, __LINE__, ##__VA_ARGS__); \ }}while(0) #define wilddog_debug(format,...) wilddog_debug_level(WD_DEBUG_DEBUG, \ @@ -154,6 +154,7 @@ typedef enum WILDDOG_RETURN_T WILDDOG_ERR_RECVNOMATCH = -11, WILDDOG_ERR_CLIENTOFFLINE = -12, WILDDOG_ERR_RECONNECT = -13, + WILDDOG_ERR_IGNORE = -14, /* * Using auto detect udp session tech, sdk maybe trigger reconnect event in * first serval minutes, and the snapshot in callback maybe newer than local diff --git a/platform/linux/wilddog_posix.c b/platform/linux/wilddog_posix.c index b2a1179..0a0472a 100644 --- a/platform/linux/wilddog_posix.c +++ b/platform/linux/wilddog_posix.c @@ -119,7 +119,7 @@ int wilddog_send #endif wilddog_debug_level(WD_DEBUG_LOG, \ - "addr_in->port = %d, ip = %u.%u.%u.%u\n", \ + "addr_in->port = %d, ip = %u.%u.%u.%u", \ addr_in->port, addr_in->ip[0], \ addr_in->ip[1], addr_in->ip[2], \ addr_in->ip[3]); @@ -177,7 +177,7 @@ int wilddog_receive } else { - wilddog_debug_level(WD_DEBUG_LOG, "received %d packet",recvlen); + wilddog_debug_level(WD_DEBUG_LOG, "received %d bytes",recvlen); } #if WILDDOG_SELFTEST { diff --git a/src/networking/coap/pdu.c b/src/networking/coap/pdu.c index b60aa37..3ce94aa 100644 --- a/src/networking/coap/pdu.c +++ b/src/networking/coap/pdu.c @@ -276,13 +276,13 @@ int WD_SYSTEM coap_pdu_parse if (pdu->max_size < length) { wilddog_debug_level(WD_DEBUG_ERROR, \ - "pdu:: insufficient space to store parsed PDU\n"); + "pdu:: insufficient space to store parsed PDU"); return 0; } if (length < sizeof(coap_hdr_t)) { - wilddog_debug_level(WD_DEBUG_ERROR, "pdu:: discarded invalid PDU\n"); + wilddog_debug_level(WD_DEBUG_ERROR, "pdu:: discarded invalid PDU"); } pdu->hdr->version = data[0] >> 6; @@ -296,7 +296,7 @@ int WD_SYSTEM coap_pdu_parse if (length != sizeof(coap_hdr_t) || pdu->hdr->token_length) { wilddog_debug_level(WD_DEBUG_ERROR, \ - "pdu:: empty message is not empty\n"); + "pdu:: empty message is not empty"); goto discard; } } @@ -304,7 +304,7 @@ int WD_SYSTEM coap_pdu_parse if (length < sizeof(coap_hdr_t) + pdu->hdr->token_length || pdu->hdr->token_length > 8) { - wilddog_debug_level(WD_DEBUG_ERROR, "pdu:: coap_pdu_parse: invalid Token\n"); + wilddog_debug_level(WD_DEBUG_ERROR, "pdu:: coap_pdu_parse: invalid Token"); goto discard; } @@ -328,7 +328,7 @@ int WD_SYSTEM coap_pdu_parse if (!next_option_safe(&opt, (size_t *)&length)) { - wilddog_debug_level(WD_DEBUG_ERROR, "pdu:: coap_pdu_parse: drop\n"); + wilddog_debug_level(WD_DEBUG_ERROR, "pdu:: coap_pdu_parse: drop"); goto discard; } } @@ -342,13 +342,9 @@ int WD_SYSTEM coap_pdu_parse if (!length) { wilddog_debug_level(WD_DEBUG_ERROR, \ - "pdu:: message ending in payload start marker\n"); + "pdu:: message ending in payload start marker"); goto discard; } - - wilddog_debug_level(WD_DEBUG_LOG, \ - "pdu:: set data to %p (pdu ends at %p)\n", (unsigned char *)opt, - (unsigned char *)pdu->hdr + pdu->length); pdu->data = (unsigned char *)opt; } diff --git a/src/networking/coap/wilddog_protocol_coap.c b/src/networking/coap/wilddog_protocol_coap.c index 396478b..e8f8d7a 100644 --- a/src/networking/coap/wilddog_protocol_coap.c +++ b/src/networking/coap/wilddog_protocol_coap.c @@ -32,6 +32,14 @@ #include "wilddog_conn.h" +#define COAP_CODE_GET(code) ((code >> 5) * 100 + (code & 0x1F)) + +typedef struct _WILDDOG_COAP_OBSERVE_DATA{ + u32 last_index; + u32 last_recv_time; + u32 maxage; +}_Wilddog_Coap_Observe_Data_T; + /* * Function: _wilddog_conn_mallocRecvBuffer * Description: conn layer malloc the buffer which used for recv @@ -83,6 +91,31 @@ STATIC void WD_SYSTEM _wilddog_coap_freeRecvBuffer(Wilddog_Protocol_T *proto,u8* return; } +/* + * Function: _wilddog_coap_ntoh + * Description: Convert the byte order + * Input: src: The pointer of the source byte + * len: The length of the source byte + * Output: dst: The pointer of the destination byte + * Return: N/A +*/ +STATIC INLINE void WD_SYSTEM _wilddog_coap_ntoh + ( + u8 *dst, + const u8 *src, + const u8 len + ) +{ + u8 i; + + for(i=0;ihdr->code); + + switch(rec_code) + { + case 201: return WILDDOG_HTTP_CREATED; + case 202: return WILDDOG_HTTP_NO_CONTENT; + case 203: return WILDDOG_HTTP_NOT_MODIFIED; + case 204: return WILDDOG_HTTP_NO_CONTENT; + case 205: return WILDDOG_HTTP_OK; + } + return rec_code; +} + +/*notice, observe_index may not be continually, and may be fallback to + little index. +/* from RFC 7641: https://tools.ietf.org/html/rfc7641#section-3.4 + V1 is last index, V2 is recv index, T1 is last recv time + T2 is now recv time. Condition 3 we do not care , only care 1 and 2 + + (V1 < V2 and V2 - V1 < 2^23) or + (V1 > V2 and V1 - V2 > 2^23) or + (T2 > T1 + 128 seconds) +*/ +STATIC BOOL WD_SYSTEM _wilddog_coap_isObserveNew(u32 old_index, u32 new_index){ + if(((old_index < new_index) && (new_index - old_index < (1<<23))) || \ + ((old_index > new_index) && (old_index - new_index > (1<<23)))) + return TRUE; + + return FALSE; +} +/* ++-----+---+---+---+---+---------+--------+--------+---------+ +| No. | C | U | N | R | Name | Format | Length | Default | ++-----+---+---+---+---+---------+--------+--------+---------+ +| 6 | | x | - | | Observe | uint | 0-3 B | (none) | ++-----+---+---+---+---+---------+--------+--------+---------+ +*/ +STATIC u32 WD_SYSTEM _wilddog_coap_getRecvObserveIndex(coap_pdu_t * pdu) +{ + u32 observe = 0; + u16 len; + coap_opt_t *p_op =NULL; + coap_opt_iterator_t d_oi; + u8 *option_value = NULL; + + wilddog_assert(pdu, WILDDOG_ERR_NULL); + + p_op = coap_check_option(pdu,COAP_OPTION_OBSERVE,&d_oi); + + if(p_op){ + len = coap_opt_length(p_op); + // max observe data is 3 bytes. + if(len == 0 || len > 3){ + wilddog_debug_level(WD_DEBUG_ERROR, "Get an maxage option but length is %ld!",len); + return 0; + } + option_value = coap_opt_value(p_op); + if(NULL == option_value){ + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Get an option length is %ld but no value!",len); + + return 0; + } + //observe option is in big endian. + _wilddog_coap_ntoh((u8*)&observe,option_value,len); + } + return observe; +} + +/* ++-----+---+---+---+---+----------------+--------+--------+----------+ +| No. | C | U | N | R | Name | Format | Length | Default | ++-----+---+---+---+---+----------------+--------+--------+----------+ +| 14 | | x | - | | Max-Age | uint | 0-4 | 60 | ++-----+---+---+---+---+----------------+--------+--------+----------+ +*/ +STATIC u32 WD_SYSTEM _wilddog_coap_getRecvMaxage(coap_pdu_t * pdu) +{ + u32 maxage = 0; + u16 len; + coap_opt_t *p_op =NULL; + coap_opt_iterator_t d_oi; + u8 *option_value = NULL; + + wilddog_assert(pdu, WILDDOG_ERR_NULL); + + p_op = coap_check_option(pdu,COAP_OPTION_MAXAGE,&d_oi); + + if(p_op){ + len = coap_opt_length(p_op); + // max maxage data is 4 bytes. + if(len == 0 || len > 4){ + wilddog_debug_level(WD_DEBUG_ERROR, "Get an maxage option but length is %ld!",len); + return 0; + } + option_value = coap_opt_value(p_op); + if(NULL == option_value){ + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Get an option length is %ld but no value!",len); + + return 0; + } + //maxage option is in big endian. + _wilddog_coap_ntoh((u8*)&maxage,option_value,len); + } + return maxage; +} + /* * Function: _wilddog_coap_countChar * Description: count the number of char 'c' exist in the string buffer. @@ -272,7 +426,8 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag coap_add_option(pdu,COAP_OPTION_URI_PATH, strlen((const char*)pkt.url->p_url_path),pkt.url->p_url_path); //add data - coap_add_data(pdu,pkt.data_len, pkt.data); + if(pkt.data) + coap_add_data(pdu,pkt.data_len, pkt.data); if(_wilddog_sec_send(arg->protocol, pdu->hdr, pdu->length) < 0){ coap_delete_pdu(pdu); @@ -281,19 +436,88 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag } wfree(pkt.url->p_url_path); pkt.url->p_url_path = oldPath; + + //store the packet to connect layer *(u8**)(arg->p_out_data) = (u8*)pdu; *(arg->p_out_data_len) = (u32)pdu->length; - return WILDDOG_ERR_NOERR; } + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_handlePkt(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + u32 error_code = WILDDOG_ERR_NOTAUTH; + u32 maxage = 0; + u32 observe_index = 0; + coap_pdu_t * pdu; + u32 payload_len = 0; + u8 *payload = NULL; + _Wilddog_Coap_Observe_Data_T *observe_data; + + wilddog_assert(data, WILDDOG_ERR_NULL); + + /* we may get the following: + * 1. error code, + * 2. token(already got in getPkt), + * 3. maxage + * 4. observe index(the 3&4 were used by observer), + * 5. path, + * 6. blockNum(used by block), + * 7. payload + */ + + //pdu stored in p_data + pdu = (coap_pdu_t *)arg->p_data; + + wilddog_assert(pdu, WILDDOG_ERR_NULL); + + //1. get error code + error_code = _wilddog_coap_getRecvCode(pdu); + + //2. get token, we already got it, pass. + //3. get maxage + maxage = _wilddog_coap_getRecvMaxage(pdu); + //4. get observe index + observe_index = _wilddog_coap_getRecvObserveIndex(pdu); + //5. get path, only observer may be use path to find the root path, we assume + // when root firstly sended, do not send child, when child firstly sended, + // send root again, and remove child observe. + //6. get block number, fixme: we do not support block [rfc7959] + //7. get payload + coap_get_data(pdu,&payload_len,&payload); + + //from observe index, check if the pkt is new or not. + if(observe_index){ + observe_data = *(_Wilddog_Coap_Observe_Data_T**)arg->p_proto_data; + + wilddog_assert(observe_data, WILDDOG_ERR_NULL); + + if(TRUE == _wilddog_coap_isObserveNew(observe_data->last_index,observe_index)){ + //get new observe, handle it. + observe_data->last_index = observe_index; + if(maxage) + observe_data->maxage = maxage; + observe_data->last_recv_time = _wilddog_getTime(); + }else{ + //get old observe, ignore it. + error_code = WILDDOG_ERR_IGNORE; + } + } + //error code and payload must tell connect layer + //send payload to connect layer. + *(arg->p_out_data) = (u8*)payload; + *(arg->p_out_data_len) = payload_len; + return error_code; +} + STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_freePkt(void* data, int flag){ Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; wilddog_assert(data, WILDDOG_ERR_NULL); - if(arg->p_out_data){ - wfree(arg->p_out_data); + //we only free p_data!!! + if(arg->p_data){ + wfree(arg->p_data); } return WILDDOG_ERR_NOERR; } @@ -302,7 +526,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_getPkt(void* data, int flag u8* recv_data = NULL; int res = 0; coap_pdu_t * pdu; - + int len; Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; wilddog_assert(data, WILDDOG_ERR_NULL); @@ -312,7 +536,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_getPkt(void* data, int flag res = _wilddog_sec_recv(arg->protocol,(void*)recv_data,(s32)WILDDOG_PROTO_MAXSIZE); if(res < 0 || res > WILDDOG_PROTO_MAXSIZE){ _wilddog_coap_freeRecvBuffer(arg->protocol,recv_data); - wilddog_debug_level(WD_DEBUG_ERROR, "Receive failed, error = %d",res); + //wilddog_debug_level(WD_DEBUG_ERROR, "Receive failed, error = %d",res); return WILDDOG_ERR_INVALID; } @@ -335,8 +559,14 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_getPkt(void* data, int flag wilddog_debug_level(WD_DEBUG_ERROR, "Parse pdu failed!"); return WILDDOG_ERR_INVALID; } - //3. send pkt to upper - *(arg->p_message_id) = *(u32*)(pdu->hdr->token); + //3. send pkt to connect layer. + //!!!Notice, we assume token is WILDDOG_COAP_TOKEN_LEN bytes! + //more than WILDDOG_COAP_TOKEN_LEN bytes will be ignored! + len = pdu->hdr->token_length > WILDDOG_COAP_TOKEN_LEN? \ + (WILDDOG_COAP_TOKEN_LEN):(pdu->hdr->token_length); + memcpy((u8*)arg->p_message_id,pdu->hdr->token, len); + _wilddog_coap_freeRecvBuffer(arg->protocol,recv_data); + //send pdu to connect layer to store. *(arg->p_out_data) = (u8*)pdu; *(arg->p_out_data_len) = pdu->length; return WILDDOG_ERR_NOERR; @@ -360,7 +590,8 @@ Wilddog_Func_T _wilddog_protocol_funcTable[WD_PROTO_CMD_MAX + 1] = (Wilddog_Func_T)NULL,//online (Wilddog_Func_T)NULL,//offline (Wilddog_Func_T)_wilddog_coap_recv_getPkt,//get pkt - (Wilddog_Func_T)_wilddog_coap_recv_freePkt//free pkt + (Wilddog_Func_T)_wilddog_coap_recv_freePkt,//free pkt + (Wilddog_Func_T)_wilddog_coap_recv_handlePkt,//handle pkt NULL }; diff --git a/src/serialize/cbor/wilddog_cbor.c b/src/serialize/cbor/wilddog_cbor.c index 9f72404..7cf954e 100644 --- a/src/serialize/cbor/wilddog_cbor.c +++ b/src/serialize/cbor/wilddog_cbor.c @@ -428,7 +428,6 @@ STATIC Wilddog_Node_T * WD_SYSTEM _wilddog_c2n_parseMap if(currNum == WILDDOG_CBOR_FOLLOW_UNKNOW_LEN) { /* waiting break*/ - wilddog_debug_level(WD_DEBUG_WARN, "do not know the length"); var = TRUE; currNum = WILDDOG_CBOR_FOLLOW_UNKNOW_DEFLEN; } diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index 445205c..476b037 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -39,12 +39,141 @@ #define WILDDOG_DEFALUT_PING_INTERVAL (19*1000) //初始化的ping间隔 #define WILDDOG_DEFAULT_PING_DELTA (10*1000) //ping的初始化步进间隔 +#define WILDDOG_AUTH_SHORT_TKN_KEY "s" +#define WILDDOG_AUTH_LONG_TKN_KEY "l" + + STATIC INLINE u32 WD_SYSTEM _wilddog_conn_getNextSendTime(int count){ return (_wilddog_getTime() + count * WILDDOG_RETRANSMIT_DEFAULT_INTERVAL); } -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth_callback(){ - return 0; +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG,"Receive auth packet, return code is %d",error_code); + if(error_code == WILDDOG_HTTP_OK){ + //1. store short token and long token + //2. change auth status to authed + //3. trigger user callback + Wilddog_Payload_T node_payload; + Wilddog_Node_T *p_node = NULL; + wilddog_assert(payload, WILDDOG_ERR_IGNORE); + + node_payload.p_dt_data = payload; + node_payload.d_dt_len = payload_len; + node_payload.d_dt_pos = 0; + + //malloced a p_node + p_node = _wilddog_payload2Node(&node_payload); + + wilddog_assert(p_node, WILDDOG_ERR_IGNORE); + if(!p_node->p_wn_child || !p_node->p_wn_child->p_wn_next){ + wilddog_debug_level(WD_DEBUG_ERROR,"Node's child is null!"); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + //p_node contain a 's' and 'l' node, which are short and long token. + if(WILDDOG_NODE_TYPE_UTF8STRING != p_node->p_wn_child->d_wn_type || + WILDDOG_NODE_TYPE_UTF8STRING != p_node->p_wn_child->p_wn_next->d_wn_type){ + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Node type is %d and %d,not string!", + p_node->p_wn_child->d_wn_type, + p_node->p_wn_child->p_wn_next->d_wn_type); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + if(!p_node->p_wn_child->p_wn_key|| \ + !p_node->p_wn_child->p_wn_value|| \ + !p_node->p_wn_child->p_wn_next->p_wn_key|| \ + !p_node->p_wn_child->p_wn_next->p_wn_value){ + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Node child: key[%s]value[%s],next:key[%s]value[%s] is NULL!", \ + p_node->p_wn_child->p_wn_key, + p_node->p_wn_child->p_wn_value, + p_node->p_wn_child->p_wn_next->p_wn_key, + p_node->p_wn_child->p_wn_next->p_wn_value); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + if(!strcmp((const char*)p_node->p_wn_child->p_wn_key,WILDDOG_AUTH_SHORT_TKN_KEY)){ + if(strcmp((const char*)p_node->p_wn_child->p_wn_next->p_wn_key,WILDDOG_AUTH_LONG_TKN_KEY)){ + //short match, but long not find + wilddog_debug_level(WD_DEBUG_ERROR, "long token not find!"); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + //short token, store it. + strncpy((char*)p_conn->d_session.short_sid, \ + (char*)p_node->p_wn_child->p_wn_value, \ + WILDDOG_CONN_SESSION_SHORT_LEN - 1); + //long token, store it. + strncpy((char*)p_conn->d_session.long_sid, \ + (char*)p_node->p_wn_child->p_wn_next->p_wn_value,\ + WILDDOG_CONN_SESSION_LONG_LEN - 1); + }else if(!strcmp((const char*)p_node->p_wn_child->p_wn_key,WILDDOG_AUTH_LONG_TKN_KEY)){ + if(strcmp((const char*)p_node->p_wn_child->p_wn_next->p_wn_key,WILDDOG_AUTH_SHORT_TKN_KEY)){ + //long match, but short not find + wilddog_debug_level(WD_DEBUG_ERROR, "short token not find!"); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + //short token, store it. + strncpy((char*)p_conn->d_session.short_sid, \ + (char*)p_node->p_wn_child->p_wn_next->p_wn_value, \ + WILDDOG_CONN_SESSION_SHORT_LEN - 1); + //long token, store it. + strncpy((char*)p_conn->d_session.long_sid, \ + (char*)p_node->p_wn_child->p_wn_value, \ + WILDDOG_CONN_SESSION_LONG_LEN - 1); + }else{ + //short and long not find + wilddog_debug_level(WD_DEBUG_ERROR, "short and long token not find!"); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + p_conn->d_session.d_session_status = WILDDOG_SESSION_AUTHED; + wilddog_debug_level(WD_DEBUG_LOG, \ + "Auth success!Short token is %s, long token is %s", \ + p_conn->d_session.short_sid, + p_conn->d_session.long_sid); + + //free p_node + wilddog_node_delete(p_node); + ret = WILDDOG_ERR_NOERR; + }else if(WILDDOG_HTTP_BAD_REQUEST == error_code){ + //cannot find this repo, stop to send auth data. + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Can not find host %s", p_conn->p_conn_repo->p_rp_url->p_url_host); + + ret = WILDDOG_ERR_INVALID; + }else if(WILDDOG_HTTP_INTERNAL_SERVER_ERR == error_code){ + //cantinue to send auth data. + wilddog_debug_level(WD_DEBUG_ERROR, "Receive server internal error"); + ret = WILDDOG_ERR_IGNORE; + }else{ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + wilddog_debug_level(WD_DEBUG_ERROR, "Receive unknown error %d",error_code); + ret = WILDDOG_ERR_INVALID; + } + + //user callback + if(pkt->p_user_callback){ + wilddog_debug_level(WD_DEBUG_LOG, "trigger auth callback"); + (pkt->p_user_callback)(pkt->p_user_arg,error_code); + } + + return ret; } STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_pkt_data_free(Wilddog_Conn_Pkt_Data_T * p_data){ @@ -116,22 +245,22 @@ STATIC BOOL WD_SYSTEM _wilddog_conn_midCmp(u32 s_mid,u32 d_mid){ * find the send packet matched with received packet */ STATIC Wilddog_Conn_Pkt_T * WD_SYSTEM _wilddog_conn_recv_sendPktFind(Wilddog_Conn_T *p_conn,u32 mid){ - wilddog_assert(p_conn NULL); + wilddog_assert(p_conn,NULL); if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ - if(TRUE == _wilddog_conn_midCmp(mid,p_conn->d_conn_sys->p_ping->d_message_id)){ + if(TRUE == _wilddog_conn_midCmp(mid,p_conn->d_conn_sys.p_ping->d_message_id)){ return p_conn->d_conn_sys.p_ping; } else{ Wilddog_Conn_Pkt_T *curr, *tmp; //observe list check - LL_FOREACH_SAFE(p_conn->d_conn_user->p_observer_list,curr,tmp){ + LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,tmp){ if(TRUE == _wilddog_conn_midCmp(mid,curr->d_message_id)){ return curr; } } //rest list check - LL_FOREACH_SAFE(p_conn->d_conn_user->p_rest_list,curr,tmp){ + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ if(TRUE == _wilddog_conn_midCmp(mid,curr->d_message_id)){ return curr; } @@ -161,25 +290,75 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionInit(Wilddog_Conn_T *p_co wilddog_assert(p_conn, WILDDOG_ERR_NULL); wilddog_assert(p_conn->p_conn_repo->p_rp_store, WILDDOG_ERR_NULL); + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_auth_callback; + //add to auth queue + if(p_conn->d_conn_sys.p_auth){ + _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_auth); + wfree(p_conn->d_conn_sys.p_auth); + p_conn->d_conn_sys.p_auth = NULL; + } + p_conn->d_conn_sys.p_auth = pkt; + p_session = &p_conn->d_session; memset(p_session, 0, sizeof(Wilddog_Session_T)); + p_session->d_session_status = WILDDOG_SESSION_AUTHING; - pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); - if(NULL == pkt){ - return WILDDOG_ERR_NULL; + //send to server + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = &(p_conn->d_conn_sys.p_auth->p_data->data); + command.p_out_data_len = &(p_conn->d_conn_sys.p_auth->p_data->len); + + if(p_conn->p_protocol->callback){ + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SESSION_INIT, &command, 0)); } + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + return WILDDOG_ERR_NOERR; +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth(void* data,int flag){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Session_T *p_session; + Wilddog_Conn_Pkt_T *pkt; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn)){ wfree(pkt); wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); return WILDDOG_ERR_NULL; } pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_auth_callback; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; //add to auth queue if(p_conn->d_conn_sys.p_auth){ _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_auth); + wfree(p_conn->d_conn_sys.p_auth); + p_conn->d_conn_sys.p_auth = NULL; } p_conn->d_conn_sys.p_auth = pkt; + + p_session = &p_conn->d_session; + memset(p_session, 0, sizeof(Wilddog_Session_T)); + p_session->d_session_status = WILDDOG_SESSION_AUTHING; //send to server command.p_message_id= &pkt->d_message_id; @@ -190,29 +369,53 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionInit(Wilddog_Conn_T *p_co //get user auth token if(p_conn->p_conn_repo->p_rp_store->p_se_callback){ command.d_data_len = (p_conn->p_conn_repo->p_rp_store->p_se_callback)( - p_conn->p_conn_repo->p_rp_store, - WILDDOG_STORE_CMD_GETAUTH,&command.p_data,0); + p_conn->p_conn_repo->p_rp_store, + WILDDOG_STORE_CMD_GETAUTH,&command.p_data,0); } - + if(p_conn->p_protocol->callback){ - if(WILDDOG_ERR_NOERR == \ - (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SESSION_INIT, &command, 0)){ - //change status to authing - p_session->d_session_status = WILDDOG_SESSION_AUTHING; - } + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SESSION_INIT, &command, 0)); } ++pkt->d_count; pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); return WILDDOG_ERR_NOERR; } +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_get(void* data,int flag){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Conn_Pkt_T *pkt; + + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_get_callback; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; + + //add to rest queue + LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); + + +} + STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_trySync(void* data,int flag){ Wilddog_Return_T ret = WILDDOG_ERR_INVALID; Wilddog_Proto_Cmd_Arg_T command; Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; u32 message_id = 0; Wilddog_Conn_T *p_conn; - u8* recvPkt = NULL; - u32 recvPkt_len = 0; + u8* recvPkt = NULL, *payload = NULL; + u32 recvPkt_len = 0, payload_len = 0; Wilddog_Conn_Pkt_T * sendPkt = NULL; wilddog_assert(data, WILDDOG_ERR_NULL); @@ -227,6 +430,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_trySync(void* data,int flag){ command.p_out_data = &recvPkt; command.p_out_data_len = &recvPkt_len; + command.p_data = NULL; command.d_data_len = 0; command.p_url = arg->p_url; command.p_message_id = &message_id; @@ -237,12 +441,14 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_trySync(void* data,int flag){ if(WILDDOG_ERR_NOERR != ret){ return ret; } - + + command.p_data = recvPkt; + command.d_data_len = recvPkt_len; //2. try to find the send pkt which has same message id, //but if we are not authed, only accept auth pkt. - sendPkt == _wilddog_conn_recv_sendPktFind(p_conn,message_id); + sendPkt = _wilddog_conn_recv_sendPktFind(p_conn,message_id); if(NULL == sendPkt){ - //delete the recvPkt. + //delete the recvPkt. Remember the recv pkt is in p_data. if(p_conn->p_protocol->callback){ ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_FREEPKT, &command, 0); } @@ -250,11 +456,24 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_trySync(void* data,int flag){ return ret; } //3. handle packet - command.p_data = sendPkt->p_data; - command.p_proto_data = sendPkt->p_proto_data; + command.p_out_data = &payload; + command.p_out_data_len = &payload_len; + command.p_proto_data = &sendPkt->p_proto_data; if(p_conn->p_protocol->callback){ ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_HANDLEPKT, &command, 0); } + if(ret > WILDDOG_ERR_NOERR){ + //callback the p_complete + if(sendPkt->p_complete){ + (sendPkt->p_complete)(p_conn, sendPkt, payload, payload_len, ret); + } + } + //Free recvPkt.Remember the recv pkt is in p_data. + if(p_conn->p_protocol->callback){ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_FREEPKT, &command, 0); + } + recvPkt = NULL; + recvPkt_len = 0; //4. state machine //5. if has retransmit packet, send @@ -263,13 +482,13 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_trySync(void* data,int flag){ /* send interface */ Wilddog_Func_T _wilddog_conn_funcTable[WILDDOG_CONN_CMD_MAX + 1] = { - (Wilddog_Func_T)NULL,//get + (Wilddog_Func_T)_wilddog_conn_get,//get (Wilddog_Func_T)NULL,//set (Wilddog_Func_T)NULL,//push (Wilddog_Func_T)NULL,//remove (Wilddog_Func_T)NULL,//on (Wilddog_Func_T)NULL,//off - (Wilddog_Func_T)NULL,//auth + (Wilddog_Func_T)_wilddog_conn_auth,//auth (Wilddog_Func_T)NULL,//ondisset (Wilddog_Func_T)NULL,//ondispush (Wilddog_Func_T)NULL,//ondisremove diff --git a/src/wilddog_conn.h b/src/wilddog_conn.h index d3b01f9..838cce6 100644 --- a/src/wilddog_conn.h +++ b/src/wilddog_conn.h @@ -178,8 +178,8 @@ extern size_t WD_SYSTEM _wilddog_protocol_ioctl int flags ); #else -#define WILDDOG_CONN_SESSION_SHORT_LEN 4 -#define WILDDOG_CONN_SESSION_LONG_LEN 32 +#define WILDDOG_CONN_SESSION_SHORT_LEN (8 + 1) +#define WILDDOG_CONN_SESSION_LONG_LEN (32 + 1) typedef enum WILDDOG_SESSION_STATE{ WILDDOG_SESSION_NOTAUTHED = 0, diff --git a/src/wilddog_protocol.h b/src/wilddog_protocol.h index 692eaf4..cba10e8 100644 --- a/src/wilddog_protocol.h +++ b/src/wilddog_protocol.h @@ -30,7 +30,7 @@ typedef struct WILDDOG_PROTO_CMD_ARG_T{ u8 *p_data;//input u32 d_data_len; Wilddog_Url_T * p_url; - u32 * p_message_id; + u32 * p_message_id;//we assume message id in u32 u8 **p_out_data;//output u32 *p_out_data_len; u8 **p_proto_data;//proto special, in/out From 38f24b5599ffb3990283c9444b836e1674fb045f Mon Sep 17 00:00:00 2001 From: itolfh Date: Tue, 7 Feb 2017 13:45:52 +0800 Subject: [PATCH 03/22] add tinydtls and mbedtls support --- include/wilddog.h | 8 +- platform/linux/wilddog_posix.c | 2 +- src/networking/coap/pdu.c | 4 +- src/networking/coap/wilddog_protocol_coap.c | 905 +++++++- src/networking/coap/wilddog_protocol_coap.h | 31 +- src/performtest.c | 9 +- src/ramtest.c | 7 + src/secure/mbedtls/lib/net.c | 10 +- .../{wilddog_dtls.c => wilddog_sec_mbedtls.c} | 221 +- src/secure/nosec/wilddog_nosec.c | 1 + src/secure/tinydtls/crypto.c | 1 + src/secure/tinydtls/dtls.c | 5 +- src/secure/tinydtls/dtls_time.c | 3 + src/secure/tinydtls/ecc.c | 2 + src/secure/tinydtls/hmac.c | 2 +- src/secure/tinydtls/netq.c | 5 +- src/secure/tinydtls/peer.c | 1 + src/secure/tinydtls/session.c | 2 + src/secure/tinydtls/sha2.c | 6 + src/secure/tinydtls/tiny_ccm.c | 1 + src/secure/tinydtls/tiny_debug.c | 1 + ...conn_sec_dtls.c => wilddog_sec_tinydtls.c} | 230 +- src/wilddog_api.c | 2 + src/wilddog_common.c | 9 +- src/wilddog_conn.c | 1878 +++++++++++++++-- src/wilddog_conn.h | 203 +- src/wilddog_ct.c | 16 + src/wilddog_event.c | 5 +- src/wilddog_protocol.h | 37 +- src/wilddog_sec_host.c | 1 + src/wilddog_store.c | 13 +- src/wilddog_url_parser.c | 2 +- tests/linux/test_limit.c | 70 +- tests/linux/test_multipleHost.c | 3 + tests/linux/test_stab_cycle.c | 4 +- tests/linux/test_step.c | 6 +- 36 files changed, 2945 insertions(+), 761 deletions(-) rename src/secure/mbedtls/lib/{wilddog_dtls.c => wilddog_sec_mbedtls.c} (68%) rename src/secure/tinydtls/{wilddog_conn_sec_dtls.c => wilddog_sec_tinydtls.c} (68%) diff --git a/include/wilddog.h b/include/wilddog.h index 5658c58..de97699 100644 --- a/include/wilddog.h +++ b/include/wilddog.h @@ -76,12 +76,12 @@ typedef signed long s32 ; #endif #ifdef WILDDOG_DEBUG -#define DEBUG_LEVEL WD_DEBUG_ALL +#define DEBUG_LEVEL WD_DEBUG_LOG STATIC const char *s_debug[] = { - "[ALL]", - "[LOG]", - "[WARN]", + "[ ALL ]", + "[ LOG ]", + "[WARN ]", "[ERROR]", "[DEBUG]" }; diff --git a/platform/linux/wilddog_posix.c b/platform/linux/wilddog_posix.c index 0a0472a..c064cc2 100644 --- a/platform/linux/wilddog_posix.c +++ b/platform/linux/wilddog_posix.c @@ -172,7 +172,7 @@ int wilddog_receive if(memcmp(addr->ip, &remaddr.sin_addr.s_addr, addr->len) || \ wilddog_ntohs(remaddr.sin_port) != addr->port) { - wilddog_debug("ip or port not match!"); + wilddog_debug_level(WD_DEBUG_WARN,"ip or port not match!"); return -1; } else diff --git a/src/networking/coap/pdu.c b/src/networking/coap/pdu.c index 3ce94aa..c16c1de 100644 --- a/src/networking/coap/pdu.c +++ b/src/networking/coap/pdu.c @@ -49,9 +49,9 @@ coap_pdu_t * WD_SYSTEM coap_pdu_init if (size < sizeof(coap_hdr_t) || size > COAP_MAX_PDU_SIZE) return NULL; - pdu = wmalloc(sizeof(coap_pdu_t) + size); + pdu = (coap_pdu_t *)wmalloc(sizeof(coap_pdu_t) + size); - if (pdu) + if (pdu) { coap_pdu_clear(pdu, size); pdu->hdr->id = id; diff --git a/src/networking/coap/wilddog_protocol_coap.c b/src/networking/coap/wilddog_protocol_coap.c index e8f8d7a..04d3f45 100644 --- a/src/networking/coap/wilddog_protocol_coap.c +++ b/src/networking/coap/wilddog_protocol_coap.c @@ -33,6 +33,7 @@ #include "wilddog_conn.h" #define COAP_CODE_GET(code) ((code >> 5) * 100 + (code & 0x1F)) +#define WILDDOG_RECONNECT_TIMES (3) //reconnect retry time typedef struct _WILDDOG_COAP_OBSERVE_DATA{ u32 last_index; @@ -132,6 +133,8 @@ STATIC INLINE u32 WD_SYSTEM _wilddog_coap_random(void) //not thread safe STATIC INLINE u16 WD_SYSTEM _wilddog_coap_getMid(void) { + //Do not need to care about endian, because we send what, will receive the same. + //Only we need is to make sure it will not conflict in short time. STATIC u16 mid = 1; return mid++; } @@ -144,9 +147,21 @@ STATIC INLINE u16 WD_SYSTEM _wilddog_coap_getMid(void) */ STATIC u32 WD_SYSTEM _wilddog_coap_getToken(u16 mid) { + //Do not need to care about endian, because we send what, will receive the same. + //Only we need is to sure it is randomable. u32 token = _wilddog_coap_random(); return (u32)(((token & (~0xff)) | (mid & 0xff)) & 0xffffffff); } +STATIC coap_opt_t* WD_SYSTEM _wilddog_coap_getSendSessionOption(coap_pdu_t * pdu){ + //FIXME: We used a simple method, we assume .cs query is the head, + // so coap_check_option's return is .cs query option. + //But we have more than 1 query, such as disconnect , so fix it!!! + coap_opt_iterator_t d_oi; + + wilddog_assert(pdu, NULL); + + return coap_check_option(pdu,COAP_OPTION_URI_QUERY,&d_oi); +} /* * Function: _wilddog_coap_getRecvCode * Description: Convert the coap code to http return code @@ -172,10 +187,98 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_getRecvCode(coap_pdu_t * pdu) } return rec_code; } +/* + * Function: _wilddog_coap_addPath + * Description: add path to coap packages. + * Input: pdu: coap pdu. + * path: path string. + * Output: N/A + * Return: WILDDOG_ERR_NOERR or WILDDOG_ERR_NULL. + * Other: path can be : 1. "/" 2. "/a" 3. "/a/b" 4. "/a/b/(maybe)" + * 5. "a" (maybe) 6. "a/b" (maybe) +*/ +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_addPath(coap_pdu_t *pdu,char *path) +{ + char *p_subpath_start = NULL; + char *p_subpath_end = NULL; + unsigned int total_len = 0; + + wilddog_assert(pdu, WILDDOG_ERR_NULL); + + if(NULL == path){ + coap_add_option(pdu, COAP_OPTION_URI_PATH,0, NULL); + return WILDDOG_ERR_NOERR; + } + total_len = strlen((const char*)path); + if('/' == path[0] && 1 == total_len){ + // handle condition 1 + //coap_add_option(pdu,COAP_OPTION_URI_PATH,total_len, (u8*)path); + coap_add_option(pdu, COAP_OPTION_URI_PATH,0, NULL); + return WILDDOG_ERR_NOERR; + } + + p_subpath_start = path; + //change condition 2/3/4 to 5 or 6 + if('/' == p_subpath_start[0]) + p_subpath_start++; + + //now we only need handle condition 5/6 + while(p_subpath_start){ + p_subpath_end = _wilddog_strchar(p_subpath_start, '/'); + if(!p_subpath_end){ + // path has no / anymore, maybe condition 5 or condition 6's step 2 + coap_add_option(pdu,COAP_OPTION_URI_PATH,strlen(p_subpath_start),(u8*)p_subpath_start); + return WILDDOG_ERR_NOERR; + } + // now we find /, such as "a" in "a/b", length is end - start. + coap_add_option(pdu,COAP_OPTION_URI_PATH,p_subpath_end - p_subpath_start,(u8*)p_subpath_start); + //jump "/" + p_subpath_start = p_subpath_end + 1; + } + return WILDDOG_ERR_NOERR; +} +/* + * Function: _wilddog_coap_addQuery + * Description: add query to coap packages. + * Input: pdu: coap pdu. + * query: query string. + * Output: N/A + * Return: WILDDOG_ERR_NOERR or WILDDOG_ERR_NULL. + * Other: path can be : 1. "a" 2. "a&b" +*/ +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_addQuery(coap_pdu_t *pdu,char *query) +{ + char *p_subquery_start = NULL; + char *p_subquery_end = NULL; + + wilddog_assert(pdu, WILDDOG_ERR_NULL); + + if(NULL == query){ + coap_add_option(pdu, COAP_OPTION_URI_QUERY,0, NULL); + return WILDDOG_ERR_NOERR; + } + + p_subquery_start = query; + + while(p_subquery_start){ + p_subquery_end = _wilddog_strchar(p_subquery_start, '&'); + if(!p_subquery_end){ + // query has no & anymore, maybe condition 1 or condition 2's step 2 + coap_add_option(pdu,COAP_OPTION_URI_QUERY,strlen(p_subquery_start),(u8*)p_subquery_start); + return WILDDOG_ERR_NOERR; + } + // now we find &, such as "a" in "a&b", length is end - start. + coap_add_option(pdu,COAP_OPTION_URI_QUERY,p_subquery_end - p_subquery_start,(u8*)p_subquery_start); + //jump "&" + p_subquery_start = p_subquery_end + 1; + } + return WILDDOG_ERR_NOERR; +} + /*notice, observe_index may not be continually, and may be fallback to little index. -/* from RFC 7641: https://tools.ietf.org/html/rfc7641#section-3.4 + from RFC 7641: https://tools.ietf.org/html/rfc7641#section-3.4 V1 is last index, V2 is recv index, T1 is last recv time T2 is now recv time. Condition 3 we do not care , only care 1 and 2 @@ -213,13 +316,13 @@ STATIC u32 WD_SYSTEM _wilddog_coap_getRecvObserveIndex(coap_pdu_t * pdu) len = coap_opt_length(p_op); // max observe data is 3 bytes. if(len == 0 || len > 3){ - wilddog_debug_level(WD_DEBUG_ERROR, "Get an maxage option but length is %ld!",len); + wilddog_debug_level(WD_DEBUG_ERROR, "Get an maxage option but length is %d!",len); return 0; } option_value = coap_opt_value(p_op); if(NULL == option_value){ wilddog_debug_level(WD_DEBUG_ERROR, \ - "Get an option length is %ld but no value!",len); + "Get an option length is %d but no value!",len); return 0; } @@ -252,13 +355,13 @@ STATIC u32 WD_SYSTEM _wilddog_coap_getRecvMaxage(coap_pdu_t * pdu) len = coap_opt_length(p_op); // max maxage data is 4 bytes. if(len == 0 || len > 4){ - wilddog_debug_level(WD_DEBUG_ERROR, "Get an maxage option but length is %ld!",len); + wilddog_debug_level(WD_DEBUG_ERROR, "Get an maxage option but length is %d!",len); return 0; } option_value = coap_opt_value(p_op); if(NULL == option_value){ wilddog_debug_level(WD_DEBUG_ERROR, \ - "Get an option length is %ld but no value!",len); + "Get an option length is %d but no value!",len); return 0; } @@ -342,7 +445,6 @@ STATIC int WD_SYSTEM _wilddog_coap_countSize(Wilddog_Coap_Pkt_T pkt){ //a null path, also will be in coap, but no data size += 5; } - //query option if(pkt.url->p_url_query){ //query will be separated into some options by '&', it may be more than 1 option @@ -353,30 +455,28 @@ STATIC int WD_SYSTEM _wilddog_coap_countSize(Wilddog_Coap_Pkt_T pkt){ size += num * 5 + strlen((const char*)pkt.url->p_url_query) + 1; } //may be observe option, observe 0 - if(WILDDOG_COAP_CMD_ON == pkt.command){ - size += 5 + 1; - } - + size += 5 + 1; + //payload, with 0xff ahead. size += pkt.data_len + 1; return size; } -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag){ - Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; +//now we only care one packet, do not thinking about partition. +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_sendPkt(Wilddog_Coap_Sendpkt_Arg_T arg,BOOL isNeedCs, Wilddog_Coap_Observe_Stat_T observeStat) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; Wilddog_Coap_Pkt_T pkt; - u32 token; - Wilddog_Str_T* oldPath = NULL; - Wilddog_Str_T* tmp = NULL; - int finalPathLen = 0; - coap_pdu_t * pdu = NULL; + u32 token = 0; + coap_pdu_t *pdu = NULL; + Wilddog_Str_T *new_query = NULL; + int query_len = 0; + Wilddog_Str_T *tmp = NULL; - wilddog_assert(data, WILDDOG_ERR_NULL); - wilddog_assert(!arg->p_url->p_url_path, WILDDOG_ERR_NULL); + wilddog_assert(arg.protocol&&arg.url&&arg.token&&arg.send_pkt, WILDDOG_ERR_NULL); //add information for coap header - pkt.command = WILDDOG_COAP_CMD_INIT; pkt.type = COAP_MESSAGE_CON; - pkt.code = COAP_REQUEST_POST; + pkt.code = arg.code; pkt.version = COAP_DEFAULT_VERSION; pkt.mid = _wilddog_coap_getMid(); @@ -385,64 +485,682 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag token = _wilddog_coap_getToken(pkt.mid); memcpy(pkt.token,(u8*)&token,WILDDOG_COAP_TOKEN_LEN); - //in our coap, token is message id and more than mid, tell up layer the message id - *(arg->p_message_id) = token; - - //get user auth token as data. - pkt.data = arg->p_data; - pkt.data_len = arg->d_data_len; + *arg.token = token; - pkt.url = arg->p_url; + //get user data. + pkt.data = arg.data; + pkt.data_len = arg.data_len; - //merge session init path with path .cs, assert pkt.url->p_url_path is null - finalPathLen = strlen(WILDDOG_COAP_SESSION_PATH) + 1; - tmp = (Wilddog_Str_T*)wmalloc(finalPathLen); - wilddog_assert(tmp, WILDDOG_ERR_NULL); - if(NULL == tmp){ - wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); - return WILDDOG_ERR_NULL; + pkt.url = arg.url; + + if(TRUE == isNeedCs){ + //combine the short token with .cs query option, ".cs=", etc. + if(NULL != arg.url->p_url_query){ + //query string length = + //(pkt.url->p_url_query) + (&) + (.cs) + (=) + (short token length) + '\0' + query_len = strlen((const char*)arg.url->p_url_query) + 1 + strlen(WILDDOG_COAP_SESSION_QUERY) + 1 + arg.d_session_len + 1; + }else{ + //query string length = (.cs) + (=) + (short token length) + '\0' + query_len = strlen(WILDDOG_COAP_SESSION_QUERY) + 1 + arg.d_session_len + 1; + } + new_query = (Wilddog_Str_T*)wmalloc(query_len); + wilddog_assert(new_query, WILDDOG_ERR_NULL); + if(NULL != arg.url->p_url_query){ + sprintf((char*)new_query, "%s&%s=%s",(const char*)arg.url->p_url_query,WILDDOG_COAP_SESSION_PATH,(const char*)arg.p_session_info); + }else{ + sprintf((char*)new_query, "%s=%s",WILDDOG_COAP_SESSION_PATH,(const char*)arg.p_session_info); + } + //store old query + tmp = arg.url->p_url_query; + arg.url->p_url_query = new_query; } - //store old path - oldPath = pkt.url->p_url_path; - pkt.url->p_url_path = tmp; - snprintf((char*)pkt.url->p_url_path, finalPathLen, "%s", WILDDOG_COAP_SESSION_PATH); + //count pkt size. pkt.size = _wilddog_coap_countSize(pkt); //make a coap packet pdu = coap_pdu_init(pkt.type, pkt.code, pkt.mid, pkt.size); if(NULL == pdu){ - wfree(pkt.url->p_url_path); - pkt.url->p_url_path = oldPath; + //restore query wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); - return WILDDOG_ERR_NULL; + ret = WILDDOG_ERR_NULL; + goto END; } + //add token coap_add_token(pdu, pkt.token_length, pkt.token); //add host coap_add_option(pdu,COAP_OPTION_URI_HOST,strlen((const char*)pkt.url->p_url_host),pkt.url->p_url_host); - + if(WILDDOG_COAP_OBSERVE_NOOBSERVE != observeStat){ + u8 observe_value = (WILDDOG_COAP_OBSERVE_ON == observeStat)?0:1; + coap_add_option(pdu,COAP_OPTION_OBSERVE,sizeof(observe_value),&observe_value); + } //add path - coap_add_option(pdu,COAP_OPTION_URI_PATH, strlen((const char*)pkt.url->p_url_path),pkt.url->p_url_path); - + _wilddog_coap_addPath(pdu,(char*)pkt.url->p_url_path); + //add query + if(pkt.url->p_url_query) + _wilddog_coap_addQuery(pdu, (char*)pkt.url->p_url_query); //add data if(pkt.data) coap_add_data(pdu,pkt.data_len, pkt.data); + + ret = WILDDOG_ERR_NOERR; + if(TRUE == arg.isSend){ + ret = _wilddog_sec_send(arg.protocol, pdu->hdr, pdu->length); + if(ret < 0){ + coap_delete_pdu(pdu); + pdu = NULL; + wilddog_debug_level(WD_DEBUG_ERROR, "Send Packet %x failed.",(unsigned int)token); + ret = WILDDOG_ERR_SENDERR; + }else{ + ret = WILDDOG_ERR_NOERR; + } + } + if(pdu){ + Wilddog_Conn_Pkt_Data_T *out_pkt = *arg.send_pkt; + out_pkt->next = NULL; + out_pkt->data = (u8*)pdu; + out_pkt->len = (u32)(pdu->length&0xffff); + } +END: + if(isNeedCs){ + //resume old query + arg.url->p_url_query = tmp; + if(new_query) + wfree(new_query); + } + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Str_T* tmp = NULL; + Wilddog_Str_T* new_path = NULL; + int finalPathLen = 0; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + //now we only care one packet, do not thinking about partition. + wilddog_assert(data&&arg->protocol&&arg->p_url&&arg->p_out_data, WILDDOG_ERR_NULL); - if(_wilddog_sec_send(arg->protocol, pdu->hdr, pdu->length) < 0){ - coap_delete_pdu(pdu); - wfree(pkt.url->p_url_path); - return WILDDOG_ERR_SENDERR; + //merge session init path with path .cs, assert pkt.url->p_url_path is null + finalPathLen = strlen(WILDDOG_COAP_SESSION_PATH) + 1; + new_path = (Wilddog_Str_T*)wmalloc(finalPathLen); + wilddog_assert(new_path, WILDDOG_ERR_NULL); + if(NULL == new_path){ + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); + return WILDDOG_ERR_NULL; } - wfree(pkt.url->p_url_path); - pkt.url->p_url_path = oldPath; + sprintf((char*)new_path, "%s", WILDDOG_COAP_SESSION_PATH); + //store old path + tmp = arg->p_url->p_url_path; + arg->p_url->p_url_path = new_path; + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_POST; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = TRUE; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; - //store the packet to connect layer - *(u8**)(arg->p_out_data) = (u8*)pdu; - *(arg->p_out_data_len) = (u32)pdu->length; - return WILDDOG_ERR_NOERR; + ret = _wilddog_coap_send_sendPkt(send_arg, FALSE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + //resume old path + arg->p_url->p_url_path = tmp; + if(new_path) + wfree(new_path); + + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_reconnect(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + wilddog_assert(arg->protocol, WILDDOG_ERR_NULL); + //retry WILDDOG_RECONNECT_TIMES times + return _wilddog_sec_reconnect(arg->protocol, WILDDOG_RECONNECT_TIMES); } +/* + Ping policy: + 1. Short: Send GET coap://.wilddogio.com/.ping?.cs= + 2. Long: Send POST coap://.wilddogio.com/.rst, payload is long token +*/ +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_ping(void* data, int flag){ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Str_T *new_query = NULL, *new_path = NULL; + Wilddog_Str_T *tmp_query = NULL, *tmp_path = NULL; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + wilddog_assert(data&&arg->protocol&&arg->p_url&&arg->p_message_id&&arg->p_session_info&&arg->p_out_data, WILDDOG_ERR_NULL); + + //change url and data + if(FALSE == flag){ + //coap://.wilddogio.com/.ping?.cs= + int query_len = 0; + //query = ".cs" + "=" + "" + query_len = strlen(WILDDOG_COAP_SESSION_QUERY) + 1 + arg->d_session_len + 1; + new_query = (Wilddog_Str_T*)wmalloc(query_len); + if(NULL == new_query){ + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed"); + return WILDDOG_ERR_NULL; + } + sprintf((char*)new_query, "%s=%s",WILDDOG_COAP_SESSION_QUERY,(const char*)arg->p_session_info); + new_path = (Wilddog_Str_T*)wmalloc(strlen((const char*)WILDDOG_COAP_SESSION_PING_PATH) + 1); + if(NULL == new_path){ + wfree(new_query); + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed"); + return WILDDOG_ERR_NULL; + } + sprintf((char*)new_path, "%s",WILDDOG_COAP_SESSION_PING_PATH); + send_arg.data = NULL; + send_arg.data_len = 0; + }else{ + //coap://.wilddogio.com/.rst payload = + new_path = (Wilddog_Str_T*)wmalloc(strlen((const char*)WILDDOG_COAP_SESSION_RST_PATH) + 1); + if(NULL == new_path){ + wfree(new_query); + wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed"); + return WILDDOG_ERR_NULL; + } + sprintf((char*)new_path, "%s",WILDDOG_COAP_SESSION_RST_PATH); + send_arg.data = arg->p_session_info; + send_arg.data_len = arg->d_session_len; + } + + //store old query + tmp_query = arg->p_url->p_url_query; + arg->p_url->p_url_query = new_query; + tmp_path = arg->p_url->p_url_path; + arg->p_url->p_url_path = new_path; + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = (FALSE == flag) ? (COAP_REQUEST_GET):(COAP_REQUEST_POST); + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.isSend = TRUE; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + + ret = _wilddog_coap_send_sendPkt(send_arg, FALSE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + //resume old query + arg->p_url->p_url_query = tmp_query; + if(new_query){ + wfree(new_query); + } + arg->p_url->p_url_path = tmp_path; + if(new_path){ + wfree(new_path); + } + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_retransmit(void* data, int flag){ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + coap_pdu_t *pdu = NULL; + coap_opt_t *opt = NULL; + + wilddog_assert(arg&&arg->p_data&&arg->protocol, WILDDOG_ERR_NULL); + + pdu = (coap_pdu_t *)arg->p_data; + if(arg->d_session_len == WILDDOG_CONN_SESSION_SHORT_LEN - 1){ + //we must change short session key + //find .cs query, change the value to newer + opt = _wilddog_coap_getSendSessionOption(pdu); + if(opt){ + //reflash session data + //data = ".cs" + "=" + "" + int query_len; + query_len = strlen(WILDDOG_COAP_SESSION_QUERY) + 1 + arg->d_session_len; + if(query_len != coap_opt_length(opt)){ + //not match! + wilddog_debug_level(WD_DEBUG_WARN,"Session not match!!!, real is %d, want %d", + coap_opt_length(opt),query_len); + }else{ + //matched, change old short token to new + u8* value = coap_opt_value(opt); + wilddog_assert(value, WILDDOG_ERR_NULL); + //check again, because _wilddog_coap_getSendSessionOption maybe fail now. + if(0 == strncmp((const char*)value, WILDDOG_COAP_SESSION_QUERY, strlen(WILDDOG_COAP_SESSION_QUERY))){ + //ignore ".cs=", so value add 4, copy new sort token to query. + memcpy((char*)(value + 4),arg->p_session_info, arg->d_session_len); + } + } + } + //observe special operation + if(arg->p_proto_data){ + _Wilddog_Coap_Observe_Data_T * observe_data = (_Wilddog_Coap_Observe_Data_T*)arg->p_proto_data; + observe_data->last_index = 0; + observe_data->last_recv_time = 0; + observe_data->maxage = 0; + } + }else if(arg->d_session_len == WILDDOG_CONN_SESSION_LONG_LEN - 1){ + //change long session key + //FIXME: now we do not need to change long token, let it go. + //If send old token, we only need to reauth. + wilddog_debug_level(WD_DEBUG_WARN, "Can not be here!"); + } + ret = _wilddog_sec_send(arg->protocol, pdu->hdr, pdu->length); + return (ret < 0) ? (WILDDOG_ERR_SENDERR):(WILDDOG_ERR_NOERR); +} + +/* + coap get packet like coap:// a.b.cn / path ? query=1&query=2 + [scheme] [host] [path] [ query ] +*/ +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_getValue(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data, WILDDOG_ERR_NULL); + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_GET; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = NULL; + send_arg.data_len = 0; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + return ret; +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_setValue(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data && \ + arg->p_data&&arg->d_data_len, WILDDOG_ERR_NULL); + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_PUT; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_push(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data && \ + arg->p_data&&arg->d_data_len, WILDDOG_ERR_NULL); + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_POST; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_remove(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data, WILDDOG_ERR_NULL); + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_DELETE; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_addObserver(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + _Wilddog_Coap_Observe_Data_T *observe_data = NULL; + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data, WILDDOG_ERR_NULL); + + observe_data = (_Wilddog_Coap_Observe_Data_T*)wmalloc(sizeof(_Wilddog_Coap_Observe_Data_T)); + wilddog_assert(observe_data, WILDDOG_ERR_NULL); + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_GET; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = NULL; + send_arg.data_len = 0; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_ON); + + //add proto_data + if(WILDDOG_ERR_NOERR == ret){ + *arg->p_proto_data = (u8*)observe_data; + }else{ + wfree(observe_data); + } + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_removeObserver(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data, WILDDOG_ERR_NULL); + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_GET; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = NULL; + send_arg.data_len = 0; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_OFF); + + return ret; +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_disSetValue(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + Wilddog_Str_T *new_query = NULL; + int query_len = 0; + Wilddog_Str_T *tmp = NULL; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data && \ + arg->p_data&&arg->d_data_len, WILDDOG_ERR_NULL); + + //add disconnect function with query .dis=add + if(NULL != arg->p_url->p_url_query){ + //query string length = + //(pkt.url->p_url_query) + (&) + (.dis=add) + '\0' + query_len = strlen((const char*)arg->p_url->p_url_query) + 1 + strlen(WILDDOG_COAP_ADD_DIS_QUERY) + 1; + }else{ + //query string length = (.dis=add) + '\0' + query_len = strlen(WILDDOG_COAP_ADD_DIS_QUERY) + 1; + } + new_query = (Wilddog_Str_T*)wmalloc(query_len); + wilddog_assert(new_query, WILDDOG_ERR_NULL); + + if(NULL != arg->p_url->p_url_query){ + sprintf((char*)new_query, "%s&%s",(const char*)arg->p_url->p_url_query,WILDDOG_COAP_ADD_DIS_QUERY); + }else{ + sprintf((char*)new_query, "%s",WILDDOG_COAP_ADD_DIS_QUERY); + } + //store old query + tmp = arg->p_url->p_url_query; + arg->p_url->p_url_query = new_query; + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_PUT; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + //resume old query + arg->p_url->p_url_query = tmp; + if(new_query) + wfree(new_query); + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_disPush(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + Wilddog_Str_T *new_query = NULL; + int query_len = 0; + Wilddog_Str_T *tmp = NULL; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data && \ + arg->p_data&&arg->d_data_len, WILDDOG_ERR_NULL); + + //add disconnect function with query .dis=add + if(NULL != arg->p_url->p_url_query){ + //query string length = + //(pkt.url->p_url_query) + (&) + (.dis=add) + '\0' + query_len = strlen((const char*)arg->p_url->p_url_query) + 1 + strlen(WILDDOG_COAP_ADD_DIS_QUERY) + 1; + }else{ + //query string length = (.dis=add) + '\0' + query_len = strlen(WILDDOG_COAP_ADD_DIS_QUERY) + 1; + } + new_query = (Wilddog_Str_T*)wmalloc(query_len); + wilddog_assert(new_query, WILDDOG_ERR_NULL); + + if(NULL != arg->p_url->p_url_query){ + sprintf((char*)new_query, "%s&%s",(const char*)arg->p_url->p_url_query,WILDDOG_COAP_ADD_DIS_QUERY); + }else{ + sprintf((char*)new_query, "%s",WILDDOG_COAP_ADD_DIS_QUERY); + } + //store old query + tmp = arg->p_url->p_url_query; + arg->p_url->p_url_query = new_query; + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_POST; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + //resume old query + arg->p_url->p_url_query = tmp; + if(new_query) + wfree(new_query); + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_disRemove(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + Wilddog_Str_T *new_query = NULL; + int query_len = 0; + Wilddog_Str_T *tmp = NULL; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data, WILDDOG_ERR_NULL); + //add disconnect function with query .dis=add + if(NULL != arg->p_url->p_url_query){ + //query string length = + //(pkt.url->p_url_query) + (&) + (.dis=add) + '\0' + query_len = strlen((const char*)arg->p_url->p_url_query) + 1 + strlen(WILDDOG_COAP_ADD_DIS_QUERY) + 1; + }else{ + //query string length = (.dis=add) + '\0' + query_len = strlen(WILDDOG_COAP_ADD_DIS_QUERY) + 1; + } + new_query = (Wilddog_Str_T*)wmalloc(query_len); + wilddog_assert(new_query, WILDDOG_ERR_NULL); + + if(NULL != arg->p_url->p_url_query){ + sprintf((char*)new_query, "%s&%s",(const char*)arg->p_url->p_url_query,WILDDOG_COAP_ADD_DIS_QUERY); + }else{ + sprintf((char*)new_query, "%s",WILDDOG_COAP_ADD_DIS_QUERY); + } + //store old query + tmp = arg->p_url->p_url_query; + arg->p_url->p_url_query = new_query; + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_DELETE; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + //resume old query + arg->p_url->p_url_query = tmp; + if(new_query) + wfree(new_query); + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_disCancel(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + Wilddog_Str_T *new_query = NULL; + int query_len = 0; + Wilddog_Str_T *tmp = NULL; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data, WILDDOG_ERR_NULL); + //add disconnect function with query .dis=add + if(NULL != arg->p_url->p_url_query){ + //query string length = + //(pkt.url->p_url_query) + (&) + (.dis=rm) + '\0' + query_len = strlen((const char*)arg->p_url->p_url_query) + 1 + strlen(WILDDOG_COAP_CANCEL_DIS_QUERY) + 1; + }else{ + //query string length = (.dis=add) + '\0' + query_len = strlen(WILDDOG_COAP_CANCEL_DIS_QUERY) + 1; + } + new_query = (Wilddog_Str_T*)wmalloc(query_len); + wilddog_assert(new_query, WILDDOG_ERR_NULL); + + if(NULL != arg->p_url->p_url_query){ + sprintf((char*)new_query, "%s&%s",(const char*)arg->p_url->p_url_query,WILDDOG_COAP_CANCEL_DIS_QUERY); + }else{ + sprintf((char*)new_query, "%s",WILDDOG_COAP_CANCEL_DIS_QUERY); + } + //store old query + tmp = arg->p_url->p_url_query; + arg->p_url->p_url_query = new_query; + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_DELETE; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + //resume old query + arg->p_url->p_url_query = tmp; + if(new_query) + wfree(new_query); + + return ret; +} +//send GET coap://.wilddogio.com/.off +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_offline(void* data, int flag){ + Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Coap_Sendpkt_Arg_T send_arg; + Wilddog_Str_T *new_path = NULL; + int path_len = 0; + Wilddog_Str_T *tmp = NULL; + + wilddog_assert(data&&arg->protocol&& \ + arg->p_url&&arg->p_session_info&& \ + arg->d_session_len&&arg->p_out_data, WILDDOG_ERR_NULL); + //add disconnect function with query .dis=add + if(NULL != arg->p_url->p_url_path){ + //path string length = + //(pkt.url->p_url_path) + (/) + (.off) + '\0' + path_len = strlen((const char*)arg->p_url->p_url_path) + 1 + strlen(WILDDOG_COAP_OFFLINE_PATH) + 1; + }else{ + //query string length = (.off) + '\0' + path_len = strlen(WILDDOG_COAP_OFFLINE_PATH) + 1; + } + new_path = (Wilddog_Str_T*)wmalloc(path_len); + wilddog_assert(new_path, WILDDOG_ERR_NULL); + + if(NULL != arg->p_url->p_url_path){ + sprintf((char*)new_path, "%s&%s",(const char*)arg->p_url->p_url_path,WILDDOG_COAP_OFFLINE_PATH); + }else{ + sprintf((char*)new_path, "%s",WILDDOG_COAP_OFFLINE_PATH); + } + //store old path + tmp = arg->p_url->p_url_path; + arg->p_url->p_url_path = new_path; + + send_arg.protocol = arg->protocol; + send_arg.url = arg->p_url; + send_arg.code = COAP_REQUEST_GET; + send_arg.p_session_info = arg->p_session_info; + send_arg.d_session_len = arg->d_session_len; + send_arg.data = arg->p_data; + send_arg.data_len = arg->d_data_len; + send_arg.isSend = flag; + send_arg.token = arg->p_message_id; + send_arg.send_pkt = (Wilddog_Conn_Pkt_Data_T**)arg->p_out_data; + ret = _wilddog_coap_send_sendPkt(send_arg, TRUE, WILDDOG_COAP_OBSERVE_NOOBSERVE); + + //resume old query + arg->p_url->p_url_path = tmp; + if(new_path) + wfree(new_path); + + return ret; +} STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_handlePkt(void* data, int flag){ Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; @@ -482,7 +1200,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_handlePkt(void* data, int f //5. get path, only observer may be use path to find the root path, we assume // when root firstly sended, do not send child, when child firstly sended, // send root again, and remove child observe. - //6. get block number, fixme: we do not support block [rfc7959] + //6. get block number, FIXME: we do not support block [rfc7959] //7. get payload coap_get_data(pdu,&payload_len,&payload); @@ -495,6 +1213,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_handlePkt(void* data, int f if(TRUE == _wilddog_coap_isObserveNew(observe_data->last_index,observe_index)){ //get new observe, handle it. observe_data->last_index = observe_index; + //FIXME: we do not use maxage to flash observe packet, only store. if(maxage) observe_data->maxage = maxage; observe_data->last_recv_time = _wilddog_getTime(); @@ -512,13 +1231,28 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_handlePkt(void* data, int f STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_freePkt(void* data, int flag){ Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; + coap_pdu_t* pdu = (coap_pdu_t*)arg->p_data; + coap_pdu_t *toSend = NULL; + u8 type = flag?(COAP_MESSAGE_ACK):(COAP_MESSAGE_RST); + wilddog_assert(data && pdu, WILDDOG_ERR_NULL); - wilddog_assert(data, WILDDOG_ERR_NULL); - - //we only free p_data!!! - if(arg->p_data){ - wfree(arg->p_data); + //1. if need, send ack to the src of recvPkt + //2. release recvPkt + + //if is con, match send ack ,other send rst + if(COAP_MESSAGE_CON == pdu->hdr->type){ + toSend = coap_pdu_init(type,0,pdu->hdr->id,WILDDOG_PROTO_MAXSIZE); + if(toSend){ + coap_add_token(toSend,pdu->hdr->token_length,pdu->hdr->token); + //we don't care send success or not + _wilddog_sec_send(arg->protocol,toSend->hdr,toSend->length); + coap_delete_pdu(toSend); + } } + + //we free recvPkt + coap_delete_pdu(pdu); + return WILDDOG_ERR_NOERR; } @@ -534,12 +1268,11 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_getPkt(void* data, int flag recv_data = _wilddog_coap_mallocRecvBuffer(arg->protocol); wilddog_assert(recv_data, WILDDOG_ERR_NULL); res = _wilddog_sec_recv(arg->protocol,(void*)recv_data,(s32)WILDDOG_PROTO_MAXSIZE); - if(res < 0 || res > WILDDOG_PROTO_MAXSIZE){ + if(res <= 0 || res > WILDDOG_PROTO_MAXSIZE){ _wilddog_coap_freeRecvBuffer(arg->protocol,recv_data); - //wilddog_debug_level(WD_DEBUG_ERROR, "Receive failed, error = %d",res); - return WILDDOG_ERR_INVALID; + //wilddog_debug_level(WD_DEBUG_LOG, "Receive failed, error = %d",res); + return WILDDOG_ERR_RECVTIMEOUT; } - //2. malloc coap buffer, handle coap, get token pdu = coap_new_pdu(); if(NULL == pdu){ @@ -575,20 +1308,22 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_getPkt(void* data, int flag /* protocol :: coap interface */ Wilddog_Func_T _wilddog_protocol_funcTable[WD_PROTO_CMD_MAX + 1] = { - (Wilddog_Func_T) _wilddog_coap_initSession,//init - (Wilddog_Func_T)NULL,//ping - (Wilddog_Func_T)NULL,//get - (Wilddog_Func_T)NULL,//set - (Wilddog_Func_T)NULL,//push - (Wilddog_Func_T)NULL,//remove - (Wilddog_Func_T)NULL,//on - (Wilddog_Func_T)NULL,//off - (Wilddog_Func_T)NULL,//dis set - (Wilddog_Func_T)NULL,//dis push - (Wilddog_Func_T)NULL,//dis remove - (Wilddog_Func_T)NULL,//dis cancel - (Wilddog_Func_T)NULL,//online - (Wilddog_Func_T)NULL,//offline + (Wilddog_Func_T) _wilddog_coap_initSession,//init + (Wilddog_Func_T)_wilddog_coap_reconnect, + (Wilddog_Func_T)_wilddog_coap_send_ping,//ping + (Wilddog_Func_T)_wilddog_coap_send_retransmit,//retransmit + (Wilddog_Func_T)_wilddog_coap_send_getValue,//get + (Wilddog_Func_T)_wilddog_coap_send_setValue,//set + (Wilddog_Func_T)_wilddog_coap_send_push,//push + (Wilddog_Func_T)_wilddog_coap_send_remove,//remove + (Wilddog_Func_T)_wilddog_coap_send_addObserver,//on + (Wilddog_Func_T)_wilddog_coap_send_removeObserver,//off + (Wilddog_Func_T)_wilddog_coap_send_disSetValue,//dis set + (Wilddog_Func_T)_wilddog_coap_send_disPush,//dis push + (Wilddog_Func_T)_wilddog_coap_send_disRemove,//dis remove + (Wilddog_Func_T)_wilddog_coap_send_disCancel,//dis cancel + (Wilddog_Func_T)NULL,//online, the same as init + (Wilddog_Func_T)_wilddog_coap_send_offline,//offline (Wilddog_Func_T)_wilddog_coap_recv_getPkt,//get pkt (Wilddog_Func_T)_wilddog_coap_recv_freePkt,//free pkt (Wilddog_Func_T)_wilddog_coap_recv_handlePkt,//handle pkt @@ -615,7 +1350,13 @@ size_t WD_SYSTEM _wilddog_protocol_ioctl cmd < 0) return WILDDOG_ERR_INVALID; - return (size_t)(_wilddog_protocol_funcTable[cmd])(p_args,flags); + if(_wilddog_protocol_funcTable[cmd]){ + return (_wilddog_protocol_funcTable[cmd])(p_args,flags); + } + else{ + wilddog_debug_level(WD_DEBUG_ERROR, "Cannot find function %d!",cmd); + return WILDDOG_ERR_NULL; + } } /* @@ -665,7 +1406,9 @@ Wilddog_Return_T WD_SYSTEM _wilddog_protocol_deInit(void *data) { Wilddog_Conn_T *p_conn = (Wilddog_Conn_T*)data; _wilddog_sec_deinit(p_conn->p_protocol); - + p_conn->p_protocol->host = NULL; + p_conn->p_protocol->user_data = NULL; + wfree(p_conn->p_protocol); return WILDDOG_ERR_NOERR; } diff --git a/src/networking/coap/wilddog_protocol_coap.h b/src/networking/coap/wilddog_protocol_coap.h index d0331a5..9e2a053 100644 --- a/src/networking/coap/wilddog_protocol_coap.h +++ b/src/networking/coap/wilddog_protocol_coap.h @@ -15,18 +15,21 @@ #define WILDDOG_COAP_TOKEN_LEN 4 #define WILDDOG_COAP_SESSION_PATH ".cs" +#define WILDDOG_COAP_SESSION_QUERY WILDDOG_COAP_SESSION_PATH +#define WILDDOG_COAP_SESSION_RST_PATH ".rst" +#define WILDDOG_COAP_SESSION_PING_PATH ".ping" +#define WILDDOG_COAP_ADD_DIS_QUERY ".dis=add" +#define WILDDOG_COAP_CANCEL_DIS_QUERY ".dis=rm" +#define WILDDOG_COAP_OFFLINE_PATH ".off" -#define WILDDOG_COAP_CMD_INIT 0 -#define WILDDOG_COAP_CMD_GET 1 -#define WILDDOG_COAP_CMD_SET 2 -#define WILDDOG_COAP_CMD_PSH 3 -#define WILDDOG_COAP_CMD_RMV 4 -#define WILDDOG_COAP_CMD_ON 5 -#define WILDDOG_COAP_CMD_OFF 5 +typedef enum{ + WILDDOG_COAP_OBSERVE_NOOBSERVE = 0, + WILDDOG_COAP_OBSERVE_ON, + WILDDOG_COAP_OBSERVE_OFF +}Wilddog_Coap_Observe_Stat_T; typedef struct WILDDOG_COAP_PKT_T{ size_t size; - u8 command; u8 version; /* protocol version */ u8 type; /* type flag */ u8 code; /* request method (value 1--10) or response code (value 40-255) */ @@ -38,5 +41,17 @@ typedef struct WILDDOG_COAP_PKT_T{ u16 data_len; }Wilddog_Coap_Pkt_T; +typedef struct WILDDOG_COAP_SENDPKT_ARG_T{ + Wilddog_Protocol_T * protocol; + Wilddog_Url_T* url; + u8 code; + u8* p_session_info; + u32 d_session_len; + u8* data; + int data_len; + int isSend; + u32 *token; + Wilddog_Conn_Pkt_Data_T** send_pkt; +}Wilddog_Coap_Sendpkt_Arg_T; #endif /* __WILDDOG_CONN_COAP_H_ */ diff --git a/src/performtest.c b/src/performtest.c index 43a2cec..3785e8f 100644 --- a/src/performtest.c +++ b/src/performtest.c @@ -290,6 +290,7 @@ void WD_SYSTEM performtest_getHandleRecvTime(void) void WD_SYSTEM performtest_init( u32 delay_tm,u32 tree_num, u8 request_num) { memset(&g_performtest,0,sizeof(g_performtest)); + wilddog_debug_level(WD_DEBUG_LOG, "perform test start!"); g_performtest.tree_num = tree_num; g_performtest.request_num = request_num; g_performtest.d_tm_trysync_delay = delay_tm; @@ -510,11 +511,8 @@ void WD_SYSTEM performtest_handle return; } perform_count = 0; - wilddog_debug(); performtest_setSysState(SYS_AUTHRECV); - wilddog_debug(); performtest_timeReset(); - wilddog_debug(); os_timer_disarm(&test_timer2); os_timer_setfn(&test_timer2, (os_timer_func_t *)perform_sync, NULL); @@ -523,6 +521,11 @@ void WD_SYSTEM performtest_handle return; } #endif +#else +void WD_SYSTEM performtest_init(void) +{ + wilddog_debug_level(WD_DEBUG_LOG, "perform test cannot start, define WILDDOG_SELFTEST!"); +} #endif diff --git a/src/ramtest.c b/src/ramtest.c index ce247ba..bcc21a7 100644 --- a/src/ramtest.c +++ b/src/ramtest.c @@ -56,6 +56,8 @@ int ramtest_getSysRamusage(Ramtest_T *p,u32 *p_uage); void WD_SYSTEM ramtest_init(u32 tree_num,u32 request_num) { Ramtest_T *p = &d_ramtest; + + wilddog_debug_level(WD_DEBUG_LOG,"Ram test start!"); memset(p,0,sizeof(Ramtest_T)); p->d_mallocblks_init = ramtest_getLastMallocSize(p); p->d_stackblks_init = ramtest_getLastStackSize(p); @@ -342,5 +344,10 @@ int WD_SYSTEM ramtest_handle( const u8 *p_url,u32 tree_num, u8 request_num) } #endif +#else +void WD_SYSTEM ramtest_init(void) +{ + wilddog_debug_level(WD_DEBUG_LOG, "ram test cannot start, define WILDDOG_SELFTEST!"); +} #endif diff --git a/src/secure/mbedtls/lib/net.c b/src/secure/mbedtls/lib/net.c index 43e2019..4acb1ae 100644 --- a/src/secure/mbedtls/lib/net.c +++ b/src/secure/mbedtls/lib/net.c @@ -531,9 +531,10 @@ int mbedtls_net_send( void *ctx, const unsigned char *buf, size_t len ) int ret; int fd = ((mbedtls_net_context *) ctx)->fd; - if( fd < 0 ) + if( fd < 0 ){ + wilddog_debug_level(WD_DEBUG_ERROR, "Invalid context."); return( MBEDTLS_ERR_NET_INVALID_CONTEXT ); - + } ret = (int) write( fd, buf, len ); if( ret < 0 ) @@ -564,13 +565,14 @@ int mbedtls_net_send( void *ctx, const unsigned char *buf, size_t len ) */ void mbedtls_net_free( mbedtls_net_context *ctx ) { - if( ctx->fd == -1 ) + if( ctx->fd == -1 ){ return; - + } shutdown( ctx->fd, 2 ); close( ctx->fd ); ctx->fd = -1; } +#else #endif /* MBEDTLS_NET_C */ diff --git a/src/secure/mbedtls/lib/wilddog_dtls.c b/src/secure/mbedtls/lib/wilddog_sec_mbedtls.c similarity index 68% rename from src/secure/mbedtls/lib/wilddog_dtls.c rename to src/secure/mbedtls/lib/wilddog_sec_mbedtls.c index 955196e..f47ced5 100644 --- a/src/secure/mbedtls/lib/wilddog_dtls.c +++ b/src/secure/mbedtls/lib/wilddog_sec_mbedtls.c @@ -4,7 +4,7 @@ #include "wilddog.h" #include "wilddog_debug.h" #include "wilddog_config.h" -#include "wilddog_sec_host.h" +#include "wilddog_sec.h" #include "wilddog_port.h" #include "mbedtls/net.h" @@ -20,30 +20,18 @@ #include "test_lib.h" #define SERVER_NAME "Li" -STATIC Wilddog_Address_T l_addr_in; -STATIC int l_fd; - -extern int mbedtls_debug_get_threshold(void); -typedef struct _ctx -{ +typedef struct WILDDOG_SEC_MBEDTLS_T{ + Wilddog_Address_T addr; int fd; - Wilddog_Address_T * addr_in; -}CTX; + mbedtls_entropy_context entropy; + mbedtls_ctr_drbg_context ctr_drbg; + mbedtls_ssl_context ssl; + mbedtls_ssl_config conf; + mbedtls_x509_crt cacert; + mbedtls_timing_delay_context timer; +}Wilddog_Sec_Mbedtls_T; -CTX ctx; - -//ssl_context ssl; -//entropy_context entropy; -//ctr_drbg_context ctr_drbg; -//x509_crt cacert; - -//mbedtls_net_context server_fd; -mbedtls_entropy_context entropy; -mbedtls_ctr_drbg_context ctr_drbg; -mbedtls_ssl_context ssl; -mbedtls_ssl_config conf; -mbedtls_x509_crt cacert; -mbedtls_timing_delay_context timer; +extern int mbedtls_debug_get_threshold(void); /* * Function: _wilddog_dtls_debug @@ -69,18 +57,6 @@ STATIC void _wilddog_dtls_debug fflush( stdout ); } -/* - * Function: wilddog_getssl - * Description: get ssl context struct - * Input: N/A - * Output: N/A - * Return: ssl context struct -*/ -STATIC mbedtls_ssl_context *wilddog_getssl(void) -{ - return &ssl; -} - /* * Function: _net_send * Description: The net send function without timeout @@ -91,13 +67,10 @@ STATIC mbedtls_ssl_context *wilddog_getssl(void) */ int _net_send( void *ctx, const unsigned char *buf, size_t len ) { - int fd; - Wilddog_Address_T * addr_in; - CTX content; - content = *((CTX *)ctx); - fd = content.fd; - addr_in = content.addr_in; - return wilddog_send(fd, addr_in, (void*)buf, (s32)len); + Wilddog_Protocol_T *protocol = (Wilddog_Protocol_T *)ctx; + + wilddog_assert(protocol, WILDDOG_ERR_NULL); + return wilddog_send(protocol->socketFd, &protocol->addr, (void*)buf, (s32)len); } @@ -111,17 +84,12 @@ int _net_send( void *ctx, const unsigned char *buf, size_t len ) */ int _net_recv( void *ctx, unsigned char *buf, size_t len ) { - int fd; - Wilddog_Address_T * addr_in; - CTX content; - - content = *((CTX *)ctx); - fd = content.fd; - addr_in = content.addr_in; - - return wilddog_receive(fd, addr_in, (void*)buf, (s32)len, \ - WILDDOG_RECEIVE_TIMEOUT); + Wilddog_Protocol_T *protocol = (Wilddog_Protocol_T *)ctx; + + wilddog_assert(protocol, WILDDOG_ERR_NULL); + return wilddog_receive(protocol->socketFd, &protocol->addr, (void*)buf, (s32)len, \ + WILDDOG_RECEIVE_TIMEOUT); } /* @@ -141,15 +109,11 @@ int _net_recv_timeout uint32_t timeout ) { - int fd; - Wilddog_Address_T * addr_in; - CTX content; - - content = *((CTX *)ctx); - fd = content.fd; - addr_in = content.addr_in; - - return wilddog_receive(fd, addr_in, (void*)buf, (s32)len, timeout); + Wilddog_Protocol_T *protocol = (Wilddog_Protocol_T *)ctx; + + wilddog_assert(protocol, WILDDOG_ERR_NULL); + + return wilddog_receive(protocol->socketFd, &protocol->addr, (void*)buf, (s32)len, timeout); } /* @@ -162,13 +126,15 @@ int _net_recv_timeout */ Wilddog_Return_T _wilddog_sec_send ( + Wilddog_Protocol_T *protocol, void* p_data, s32 len ) { int ret; - - do ret = mbedtls_ssl_write( wilddog_getssl(),(unsigned char *) p_data, len); + Wilddog_Sec_Mbedtls_T * mbed = (Wilddog_Sec_Mbedtls_T*)protocol->user_data; + wilddog_assert(protocol&&mbed, WILDDOG_ERR_NULL); + do ret = mbedtls_ssl_write(&mbed->ssl,(unsigned char *) p_data, len); while( ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE ); @@ -184,20 +150,23 @@ Wilddog_Return_T _wilddog_sec_send */ int _wilddog_sec_recv ( + Wilddog_Protocol_T *protocol, void* p_data, s32 len ) { int ret; + Wilddog_Sec_Mbedtls_T * mbed = (Wilddog_Sec_Mbedtls_T*)protocol->user_data; + wilddog_assert(protocol&&mbed, WILDDOG_ERR_NULL); do { - ret = mbedtls_ssl_read( wilddog_getssl(),(unsigned char *)p_data, len ); + ret = mbedtls_ssl_read(&mbed->ssl,(unsigned char *)p_data, len ); } while( ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE ); - return wilddog_getssl()->in_left ; + return mbed->ssl.in_left ; } /* @@ -208,21 +177,31 @@ int _wilddog_sec_recv * Output: N/A * Return: Success: 0 Faied: <0 */ -Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) +Wilddog_Return_T _wilddog_sec_init(Wilddog_Protocol_T *protocol) { int ret; uint32_t flags; const char *pers = "dtls_client"; + + Wilddog_Sec_Mbedtls_T * mbed = NULL; + + wilddog_assert(protocol, WILDDOG_ERR_NULL); /* open socket ** get host by name */ - wilddog_openSocket(&l_fd); - if( (ret = _wilddog_sec_getHost(&l_addr_in,p_host,d_port)) <0 ) + wilddog_openSocket(&protocol->socketFd); + ret = _wilddog_sec_getHost(&protocol->addr,protocol->host); + if(ret < 0) return ret; - - ctx.fd = l_fd; - ctx.addr_in = &l_addr_in; + + protocol->user_data = wmalloc(sizeof(Wilddog_Sec_Mbedtls_T)); + if(!protocol->user_data){ + wilddog_debug_level(WD_DEBUG_ERROR,"Malloc failed!"); + return WILDDOG_ERR_NULL; + } + + mbed = (Wilddog_Sec_Mbedtls_T*)protocol->user_data; mbedtls_debug_set_threshold( 0 ); wilddog_debug_level(WD_DEBUG_LOG, "debug_threshold: %d\n", \ @@ -231,19 +210,19 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) * 0. Initialize the RNG and the session data */ // mbedtls_net_init( &server_fd ); - mbedtls_ssl_init( &ssl ); - mbedtls_ssl_config_init( &conf ); - mbedtls_x509_crt_init( &cacert ); - mbedtls_ctr_drbg_init( &ctr_drbg ); + mbedtls_ssl_init( &mbed->ssl ); + mbedtls_ssl_config_init( &mbed->conf); + mbedtls_x509_crt_init( &mbed->cacert); + mbedtls_ctr_drbg_init( &mbed->ctr_drbg ); wilddog_debug_level(WD_DEBUG_LOG, \ "\n . Seeding the random number generator..." ); fflush( stdout ); - mbedtls_entropy_init( &entropy ); - ret = mbedtls_ctr_drbg_seed(&ctr_drbg, \ + mbedtls_entropy_init( &mbed->entropy ); + ret = mbedtls_ctr_drbg_seed(&mbed->ctr_drbg, \ mbedtls_entropy_func, \ - &entropy, \ + &mbed->entropy, \ (const unsigned char *) pers, \ strlen( pers )); if( ret != 0 ) @@ -254,9 +233,7 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) return WILDDOG_ERR_INVALID; } - - wilddog_debug_level(WD_DEBUG_LOG, " ok\n" ); - + /* * 0. Initialize certificates */ @@ -268,7 +245,7 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) ramtest_skipLastmalloc(); #endif - ret = mbedtls_x509_crt_parse(&cacert, \ + ret = mbedtls_x509_crt_parse(&mbed->cacert, \ (const unsigned char *) mbedtls_test_cas_pem, \ mbedtls_test_cas_pem_len ); @@ -278,10 +255,10 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) wilddog_debug_level(WD_DEBUG_LOG, \ "cacert version:%d\n", \ - cacert.version); + mbed->cacert.version); wilddog_debug_level(WD_DEBUG_LOG, \ "cacert next version:%d\n", \ - cacert.next->version); + mbed->cacert.next->version); if( ret < 0 ) { @@ -292,15 +269,13 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) return WILDDOG_ERR_INVALID; } - wilddog_debug_level(WD_DEBUG_LOG, " ok (%d skipped)\n", ret ); - /* * 2. Setup stuff */ wilddog_debug_level(WD_DEBUG_LOG, " . Setting up the DTLS structure..." ); fflush( stdout ); - ret = mbedtls_ssl_config_defaults(&conf, + ret = mbedtls_ssl_config_defaults(&mbed->conf, MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_PRESET_DEFAULT ); @@ -314,17 +289,15 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) return WILDDOG_ERR_INVALID; } - wilddog_debug_level(WD_DEBUG_LOG, " ok\n" ); - /* OPTIONAL is usually a bad choice for security, but makes interop easier * in this simplified example, in which the ca chain is hardcoded. * Production code should set a proper ca chain and use REQUIRED. */ - mbedtls_ssl_conf_authmode( &conf, MBEDTLS_SSL_VERIFY_REQUIRED ); - mbedtls_ssl_conf_ca_chain( &conf, &cacert, NULL ); - mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg ); - mbedtls_ssl_conf_dbg( &conf, _wilddog_dtls_debug, stdout ); + mbedtls_ssl_conf_authmode( &mbed->conf, MBEDTLS_SSL_VERIFY_REQUIRED ); + mbedtls_ssl_conf_ca_chain( &mbed->conf, &mbed->cacert, NULL ); + mbedtls_ssl_conf_rng( &mbed->conf, mbedtls_ctr_drbg_random, &mbed->ctr_drbg ); + mbedtls_ssl_conf_dbg( &mbed->conf, _wilddog_dtls_debug, stdout ); - if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 ) + if( ( ret = mbedtls_ssl_setup( &mbed->ssl, &mbed->conf ) ) != 0 ) { wilddog_debug_level(WD_DEBUG_ERROR, " failed\n ! mbedtls_ssl_setup returned %d\n\n", @@ -333,7 +306,7 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) return WILDDOG_ERR_INVALID; } - if( ( ret = mbedtls_ssl_set_hostname( &ssl, SERVER_NAME ) ) != 0 ) + if( ( ret = mbedtls_ssl_set_hostname( &mbed->ssl, SERVER_NAME ) ) != 0 ) { wilddog_debug_level(WD_DEBUG_ERROR, " failed\n ! mbedtls_ssl_set_hostname returned %d\n\n", @@ -342,28 +315,26 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) return WILDDOG_ERR_INVALID; } - mbedtls_ssl_set_bio(&ssl, - &ctx, + mbedtls_ssl_set_bio(&mbed->ssl, + protocol, _net_send, _net_recv, _net_recv_timeout ); - mbedtls_ssl_conf_read_timeout(&conf, WILDDOG_RECEIVE_TIMEOUT); + mbedtls_ssl_conf_read_timeout(&mbed->conf, WILDDOG_RECEIVE_TIMEOUT); - mbedtls_ssl_set_timer_cb(&ssl, - &timer, + mbedtls_ssl_set_timer_cb(&mbed->ssl, + &mbed->timer, mbedtls_timing_set_delay, mbedtls_timing_get_delay ); - - wilddog_debug_level(WD_DEBUG_LOG, " ok\n" ); - + /* * 4. Handshake */ wilddog_debug_level(WD_DEBUG_LOG," . Performing the SSL/TLS handshake..."); fflush( stdout ); - do ret = mbedtls_ssl_handshake( &ssl ); + do ret = mbedtls_ssl_handshake( &mbed->ssl ); while( ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE ); @@ -376,8 +347,6 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) return WILDDOG_ERR_INVALID; } - wilddog_debug_level(WD_DEBUG_LOG, " ok\n" ); - /* * 5. Verify the server certificate */ @@ -387,7 +356,7 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) * handshake would not succeed if the peer's cert is bad. Even if we used * SSL_VERIFY_OPTIONAL, we would bail out here if ret != 0 */ - if( ( flags = mbedtls_ssl_get_verify_result( &ssl ) ) != 0 ) + if( ( flags = mbedtls_ssl_get_verify_result( &mbed->ssl ) ) != 0 ) { char vrfy_buf[512]; @@ -413,32 +382,37 @@ Wilddog_Return_T _wilddog_sec_init( Wilddog_Str_T *p_host,u16 d_port) * Output: N/A * Return: Success: 0 */ -Wilddog_Return_T _wilddog_sec_deinit(void) +Wilddog_Return_T _wilddog_sec_deinit(Wilddog_Protocol_T *protocol) { int ret; + Wilddog_Sec_Mbedtls_T * mbed = (Wilddog_Sec_Mbedtls_T*)protocol->user_data; /* * 8. Done, cleanly close the connection */ - + wilddog_assert(protocol&&mbed, WILDDOG_ERR_NULL); + wilddog_debug_level(WD_DEBUG_LOG, " . Closing the connection..." ); /* No error checking, the connection might be closed already */ - do ret = mbedtls_ssl_close_notify( wilddog_getssl() ); + do ret = mbedtls_ssl_close_notify(&mbed->ssl); while( ret == MBEDTLS_ERR_SSL_WANT_WRITE ); ret = 0; wilddog_debug_level(WD_DEBUG_LOG, " done\n" ); - if( l_fd != -1 ) - wilddog_closeSocket( l_fd ); -// mbedtls_net_free( &server_fd ); + if(protocol->socketFd != -1) + wilddog_closeSocket(protocol->socketFd); + protocol->socketFd = -1; + memset(&protocol->addr,0,sizeof(protocol->addr)); - mbedtls_x509_crt_free( &cacert ); - mbedtls_ssl_free( &ssl ); - mbedtls_ssl_config_free( &conf ); - mbedtls_ctr_drbg_free( &ctr_drbg ); - mbedtls_entropy_free( &entropy ); + mbedtls_x509_crt_free( &mbed->cacert ); + mbedtls_ssl_free( &mbed->ssl ); + mbedtls_ssl_config_free( &mbed->conf ); + mbedtls_ctr_drbg_free( &mbed->ctr_drbg ); + mbedtls_entropy_free( &mbed->entropy ); + wfree(mbed); + protocol->user_data = NULL; return WILDDOG_ERR_NOERR; } /* @@ -450,19 +424,14 @@ Wilddog_Return_T _wilddog_sec_deinit(void) * Output: N/A * Return: Success: 0 Faied: < 0 */ -Wilddog_Return_T _wilddog_sec_reconnect - ( - Wilddog_Str_T *p_host, - u16 d_port, - int retryNum - ) +Wilddog_Return_T _wilddog_sec_reconnect(Wilddog_Protocol_T *protocol,int retryNum) { int i; Wilddog_Return_T ret = WILDDOG_ERR_INVALID; for(i = 0; i < retryNum; i++) { - _wilddog_sec_deinit(); - ret = _wilddog_sec_init(p_host, d_port); + _wilddog_sec_deinit(protocol); + ret = _wilddog_sec_init(protocol); if(WILDDOG_ERR_NOERR == ret) return ret; } diff --git a/src/secure/nosec/wilddog_nosec.c b/src/secure/nosec/wilddog_nosec.c index c23fe1a..9f55208 100644 --- a/src/secure/nosec/wilddog_nosec.c +++ b/src/secure/nosec/wilddog_nosec.c @@ -69,6 +69,7 @@ Wilddog_Return_T WD_SYSTEM _wilddog_sec_init wilddog_assert(protocol, WILDDOG_ERR_NULL); if(0 != wilddog_openSocket(&protocol->socketFd)){ + wilddog_debug_level(WD_DEBUG_ERROR, "Can not open socket!"); return WILDDOG_ERR_INVALID; } diff --git a/src/secure/tinydtls/crypto.c b/src/secure/tinydtls/crypto.c index c428f10..17f4573 100644 --- a/src/secure/tinydtls/crypto.c +++ b/src/secure/tinydtls/crypto.c @@ -561,6 +561,7 @@ dtls_decrypt(const unsigned char *src, size_t length, if (ret < 0) { /* cleanup everything in case the key has the wrong size */ dtls_warn("cannot set rijndael key\n"); + wilddog_debug_level(WD_DEBUG_WARN,"Cannot set rijndael key."); goto error; } diff --git a/src/secure/tinydtls/dtls.c b/src/secure/tinydtls/dtls.c index 1ffddf3..061e60d 100644 --- a/src/secure/tinydtls/dtls.c +++ b/src/secure/tinydtls/dtls.c @@ -1432,9 +1432,10 @@ dtls_send_multi(dtls_context_t *ctx, dtls_peer_t *peer, res = dtls_prepare_record(peer, security, type, buf_array, buf_len_array, buf_array_len, sendbuf, &len); - if (res < 0) + if (res < 0){ + wilddog_debug_level(WD_DEBUG_ERROR,"Prepare record failed"); return res; - + } /* if (peer && MUST_HASH(peer, type, buf, buflen)) */ /* update_hs_hash(peer, buf, buflen); */ diff --git a/src/secure/tinydtls/dtls_time.c b/src/secure/tinydtls/dtls_time.c index d9dbb9a..b8fe589 100644 --- a/src/secure/tinydtls/dtls_time.c +++ b/src/secure/tinydtls/dtls_time.c @@ -73,6 +73,9 @@ dtls_clock_init(void) { # endif dtls_clock_offset = 0; #endif + return; + //just avoid warning. + wilddog_debug_level(WD_DEBUG_ALL, "Dtls clock init."); } #ifdef WILDDOG_PORT_TYPE_WICED diff --git a/src/secure/tinydtls/ecc.c b/src/secure/tinydtls/ecc.c index dbdc318..ae2ebcb 100644 --- a/src/secure/tinydtls/ecc.c +++ b/src/secure/tinydtls/ecc.c @@ -639,6 +639,8 @@ int ecc_ecdsa_validate(const uint32_t *x, const uint32_t *y, const uint32_t *e, int ecc_is_valid_key(const uint32_t * priv_key) { return isGreater(ecc_order_m, priv_key, arrayLength) == 1; + //just avoid warning. + wilddog_debug_level(WD_DEBUG_LOG, "ecc is valid_key?"); } /* diff --git a/src/secure/tinydtls/hmac.c b/src/secure/tinydtls/hmac.c index 0a9b8f7..17f4463 100644 --- a/src/secure/tinydtls/hmac.c +++ b/src/secure/tinydtls/hmac.c @@ -138,7 +138,7 @@ dtls_hmac_finalize(dtls_hmac_context_t *ctx, unsigned char *result) { dtls_hash_update(&ctx->data, buf, len); len = dtls_hash_finalize(result, &ctx->data); - + wilddog_debug_level(WD_DEBUG_ALL, "hmac finalized."); return len; } diff --git a/src/secure/tinydtls/netq.c b/src/secure/tinydtls/netq.c index 0a10a50..a474cbb 100644 --- a/src/secure/tinydtls/netq.c +++ b/src/secure/tinydtls/netq.c @@ -94,9 +94,10 @@ netq_next(netq_t *p) { void netq_remove(list_t queue, netq_t *p) { - if (!queue || !p) + if (!queue || !p){ + wilddog_debug_level(WD_DEBUG_ERROR, "netq remove failed with empty."); return; - + } list_remove(queue, p); } diff --git a/src/secure/tinydtls/peer.c b/src/secure/tinydtls/peer.c index 8f2876c..afbcdae 100644 --- a/src/secure/tinydtls/peer.c +++ b/src/secure/tinydtls/peer.c @@ -80,6 +80,7 @@ dtls_new_peer(const session_t *session) { if (!peer->security_params[0]) { dtls_free_peer(peer); + wilddog_debug_level(WD_DEBUG_ERROR,"New dtls peer failed."); return NULL; } diff --git a/src/secure/tinydtls/session.c b/src/secure/tinydtls/session.c index 78880c3..ad55c7a 100644 --- a/src/secure/tinydtls/session.c +++ b/src/secure/tinydtls/session.c @@ -91,4 +91,6 @@ int dtls_session_equals(const session_t *a, const session_t *b) { assert(a); assert(b); return _dtls_address_equals_impl(a, b); + //just avoid warning. + wilddog_debug_level(WD_DEBUG_ALL,"Session equal complete."); } diff --git a/src/secure/tinydtls/sha2.c b/src/secure/tinydtls/sha2.c index d7e1e39..ebc92e4 100644 --- a/src/secure/tinydtls/sha2.c +++ b/src/secure/tinydtls/sha2.c @@ -725,6 +725,8 @@ char *SHA256_End(TINY_SHA256_CTX* context, char buffer[]) { } MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH); return buffer; + //just avoid warning. + wilddog_debug_level(WD_DEBUG_ALL, "sha512 ended."); } char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) { @@ -1055,6 +1057,8 @@ char *SHA512_End(SHA512_CTX* context, char buffer[]) { } MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH); return buffer; + //just avoid warning. + wilddog_debug_level(WD_DEBUG_ALL, "sha512 ended."); } char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) { @@ -1131,6 +1135,8 @@ char *SHA384_End(SHA384_CTX* context, char buffer[]) { } MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH); return buffer; + //just avoid warning. + wilddog_debug_level(WD_DEBUG_ALL, "sha512 ended."); } char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) { diff --git a/src/secure/tinydtls/tiny_ccm.c b/src/secure/tinydtls/tiny_ccm.c index abbb49e..61222fc 100644 --- a/src/secure/tinydtls/tiny_ccm.c +++ b/src/secure/tinydtls/tiny_ccm.c @@ -307,5 +307,6 @@ dtls_ccm_decrypt_message(rijndael_ctx *ctx, size_t M, size_t L, return len - M; error: + wilddog_debug_level(WD_DEBUG_ERROR,"Error in decrypt."); return -1; } diff --git a/src/secure/tinydtls/tiny_debug.c b/src/secure/tinydtls/tiny_debug.c index 05898e3..ab869b8 100644 --- a/src/secure/tinydtls/tiny_debug.c +++ b/src/secure/tinydtls/tiny_debug.c @@ -75,6 +75,7 @@ tiny_dtls_get_log_level() { void tiny_dtls_set_log_level(log_t level) { maxlog = level; + wilddog_debug_level(WD_DEBUG_LOG, "Dtls log level is %d.",level); } /* this array has the same order as the type log_t */ diff --git a/src/secure/tinydtls/wilddog_conn_sec_dtls.c b/src/secure/tinydtls/wilddog_sec_tinydtls.c similarity index 68% rename from src/secure/tinydtls/wilddog_conn_sec_dtls.c rename to src/secure/tinydtls/wilddog_sec_tinydtls.c index 04397ad..3090364 100644 --- a/src/secure/tinydtls/wilddog_conn_sec_dtls.c +++ b/src/secure/tinydtls/wilddog_sec_tinydtls.c @@ -44,7 +44,7 @@ #include "wilddog.h" #include "wilddog_port.h" -#include "wilddog_sec_host.h" +#include "wilddog_sec.h" #ifdef __GNUC__ #define UNUSED_PARAM __attribute__((unused)) @@ -57,9 +57,8 @@ typedef enum _TINYDTLS_STATE_S{ _TINYDTLS_STATE_ERROR = 2, _TINYDTLS_STATE_CONNECT = 3 }TinyDtls_State_S; -typedef struct WILDDOG_CONN_SEC_T{ +typedef struct WILDDOG_SEC_TINYDTLS_T{ dtls_context_t *dtls_context; - size_t d_fd; session_t dst; unsigned short d_dtlstState; u8 *p_recvbuf; @@ -68,11 +67,7 @@ typedef struct WILDDOG_CONN_SEC_T{ u8 reserved1; u8 reserved2; u8 reserved3; -}Wilddog_Conn_Sec_T; - -STATIC Wilddog_Conn_Sec_T d_conn_sec_dtls; -STATIC Wilddog_Address_T l_tinyaddr_in; -STATIC int l_tinyfd; +}Wilddog_Sec_Tinydtls_T; /*publick key*/ STATIC const unsigned char server_pub_key_x[] = @@ -145,6 +140,8 @@ ssize_t read_from_file(char *arg, unsigned char *buf, size_t max_buf_len) #endif /* The PSK information for DTLS */ +//jimmy: Useful or not??? Only get_psk_info used them, but their value never changed. +// so we cannot retrieve key. #define PSK_ID_MAXLEN 256 #define PSK_MAXLEN 256 static unsigned char psk_id[PSK_ID_MAXLEN]; @@ -264,16 +261,24 @@ STATIC int read_from_peer ) { size_t i,readlen; + Wilddog_Protocol_T *protocol = NULL; + Wilddog_Sec_Tinydtls_T * sec_session = NULL; + + protocol = (Wilddog_Protocol_T *)dtls_get_app_data(ctx); + wilddog_assert(protocol, -1); - if(d_conn_sec_dtls.p_recvbuf == NULL) + sec_session = (Wilddog_Sec_Tinydtls_T*)protocol->user_data; + wilddog_assert(sec_session, -1); + + if(sec_session->p_recvbuf == NULL) return 0; - d_conn_sec_dtls.d_recvFig = 1; - readlen = (d_conn_sec_dtls.d_recvlen > len)?len:d_conn_sec_dtls.d_recvlen; + sec_session->d_recvFig = 1; + readlen = (sec_session->d_recvlen > len)?len:sec_session->d_recvlen; for (i = 0; i < len; i++) { - d_conn_sec_dtls.p_recvbuf[i] = data[i]; + sec_session->p_recvbuf[i] = data[i]; } - d_conn_sec_dtls.d_recvlen = readlen; + sec_session->d_recvlen = readlen; return 0; } @@ -286,10 +291,14 @@ STATIC int send_to_peer size_t len ) { - int fd = *(int *)dtls_get_app_data(ctx); + Wilddog_Protocol_T *protocol; + int res = 0; Wilddog_Address_T addr_inSend; + protocol = (Wilddog_Protocol_T *)dtls_get_app_data(ctx); + wilddog_assert(protocol, -1); + addr_inSend.len = session->size; #if defined(WILDDOG_PORT_TYPE_WICED) || \ defined(WILDDOG_PORT_TYPE_QUCETEL) || \ @@ -302,49 +311,35 @@ STATIC int send_to_peer addr_inSend.port = session->addr.sin.sin_port; memcpy(addr_inSend.ip,&session->addr.sin.sin_addr,session->size); #endif - res = wilddog_send(fd,&addr_inSend,data,len); + res = wilddog_send(protocol->socketFd,&addr_inSend,data,len); return res; } STATIC int dtls_handle_read(struct dtls_context_t *ctx) { - int fd; - session_t *p_session = &d_conn_sec_dtls.dst; - Wilddog_Address_T addr_in; + Wilddog_Protocol_T *protocol = NULL; + Wilddog_Sec_Tinydtls_T * session = NULL; #define MAX_READ_BUF 2000 static uint8 buf[MAX_READ_BUF]; int len; - fd = *(int *)dtls_get_app_data(ctx); - if (!fd) - return -1; -#if defined(WILDDOG_PORT_TYPE_WICED) || \ - defined(WILDDOG_PORT_TYPE_QUCETEL) || \ - defined(WILDDOG_PORT_TYPE_MXCHIP) + protocol = (Wilddog_Protocol_T *)dtls_get_app_data(ctx); + wilddog_assert(protocol, -1); - addr_in.len = d_conn_sec_dtls.dst.addr.len; - addr_in.port = d_conn_sec_dtls.dst.addr.port; - memcpy(addr_in.ip,&d_conn_sec_dtls.dst.addr.ip,d_conn_sec_dtls.dst.addr.len); -#else - addr_in.len = d_conn_sec_dtls.dst.size; - addr_in.port = d_conn_sec_dtls.dst.addr.sin.sin_port; - memcpy(addr_in.ip, \ - &d_conn_sec_dtls.dst.addr.sin.sin_addr, \ - d_conn_sec_dtls.dst.size); -#endif - + session = (Wilddog_Sec_Tinydtls_T*)protocol->user_data; + wilddog_assert(session, -1); memset(buf, 0, MAX_READ_BUF); - len = wilddog_receive(fd,&addr_in,buf,MAX_READ_BUF,WILDDOG_RECEIVE_TIMEOUT); + len = wilddog_receive(protocol->socketFd,&protocol->addr,buf,MAX_READ_BUF,WILDDOG_RECEIVE_TIMEOUT); if (len < 0) { return 0;// return -1; } else if(len > 0) { - dtls_dsrv_log_addr(DTLS_LOG_DEBUG, "peer", p_session); + dtls_dsrv_log_addr(DTLS_LOG_DEBUG, "peer", &session->dst); dtls_debug_dump("bytes from peer", buf, len); - return dtls_handle_message(ctx, p_session, buf, len); + return dtls_handle_message(ctx, &session->dst, buf, len); } return 0; } @@ -357,10 +352,19 @@ int handle_dtls_event unsigned short code ) { - d_conn_sec_dtls.d_dtlstState = level; - if( code == DTLS_EVENT_CONNECTED) - d_conn_sec_dtls.d_dtlstState = _TINYDTLS_STATE_CONNECT; + Wilddog_Protocol_T *protocol = NULL; + Wilddog_Sec_Tinydtls_T * sec_session = NULL; + + protocol = (Wilddog_Protocol_T *)dtls_get_app_data(ctx); + wilddog_assert(protocol, -1); + sec_session = (Wilddog_Sec_Tinydtls_T*)protocol->user_data; + wilddog_assert(sec_session, -1); + + sec_session->d_dtlstState = level; + if( code == DTLS_EVENT_CONNECTED) + sec_session->d_dtlstState = _TINYDTLS_STATE_CONNECT; + return 0; } @@ -385,7 +389,7 @@ STATIC dtls_handler_t cb = STATIC int _wilddog_sec_reconnectInner ( - Wilddog_Conn_Sec_T *wd_sec, + Wilddog_Sec_Tinydtls_T *wd_sec, int timeout, int reconnectNum ) @@ -419,47 +423,45 @@ STATIC int _wilddog_sec_reconnectInner return -1; } -Wilddog_Return_T _wilddog_sec_reconnect - ( - Wilddog_Str_T *p_host, - u16 d_port, - int retryNum - ) +Wilddog_Return_T _wilddog_sec_reconnect(Wilddog_Protocol_T *protocol,int retryNum) { int res = 0; + Wilddog_Sec_Tinydtls_T *session = (Wilddog_Sec_Tinydtls_T*)protocol->user_data; - res = _wilddog_sec_reconnectInner(&d_conn_sec_dtls, - WILDDOG_RETRANSMITE_TIME,retryNum); + wilddog_assert(protocol&&session, -1); + + res = _wilddog_sec_reconnectInner(session,WILDDOG_RETRANSMITE_TIME,retryNum); if(res >= 0) return res; - _wilddog_sec_deinit(); - res = _wilddog_sec_init(p_host, d_port); + _wilddog_sec_deinit(protocol); + res = _wilddog_sec_init(protocol); return res; } /* do not malloc session*/ STATIC int _wilddog_sec_setSession ( - int fd, - Wilddog_Address_T * addr_in + Wilddog_Protocol_T *protocol ) { - d_conn_sec_dtls.d_fd = fd; + Wilddog_Sec_Tinydtls_T *session = (Wilddog_Sec_Tinydtls_T*)protocol->user_data; + + wilddog_assert(protocol&&session, -1); + #if defined(WILDDOG_PORT_TYPE_WICED) || \ defined(WILDDOG_PORT_TYPE_QUCETEL) || \ defined(WILDDOG_PORT_TYPE_MXCHIP) - memcpy(&d_conn_sec_dtls.dst.addr.ip,addr_in->ip,addr_in->len); - d_conn_sec_dtls.dst.size = addr_in->len; - d_conn_sec_dtls.dst.addr.len = addr_in->len; - d_conn_sec_dtls.dst.addr.port = addr_in->port; + memcpy(&session->dst.addr.ip,protocol->addr.ip,protocol->addr.len); + session->dst.size = protocol->addr.len; + session->dst.addr.len = protocol->addr.len; + session->dst.addr.port = protocol->addr.port; #else - d_conn_sec_dtls.dst.addr.sin.sin_family = 2;/*AF_INET ipv4*/ - memcpy(&d_conn_sec_dtls.dst.addr.sin.sin_addr,addr_in->ip,addr_in->len); - d_conn_sec_dtls.dst.size = addr_in->len; - - d_conn_sec_dtls.dst.addr.sin.sin_port = addr_in->port; + session->dst.addr.sin.sin_family = 2;/*AF_INET ipv4*/ + memcpy(&session->dst.addr.sin.sin_addr,protocol->addr.ip,protocol->addr.len); + session->dst.size = protocol->addr.len; + session->dst.addr.sin.sin_port = protocol->addr.port; #endif return 0; } @@ -473,6 +475,7 @@ STATIC int _wilddog_sec_setSession */ Wilddog_Return_T _wilddog_sec_send ( + Wilddog_Protocol_T *protocol, void* p_data, s32 len ) @@ -480,15 +483,18 @@ Wilddog_Return_T _wilddog_sec_send uint8 *p_buf = p_data; s32 sendLen = 0; int res = 0; + Wilddog_Sec_Tinydtls_T * session = (Wilddog_Sec_Tinydtls_T*)protocol->user_data; - _wilddog_sec_setSession(l_tinyfd,&l_tinyaddr_in); + wilddog_assert(protocol&&session, -1); + + _wilddog_sec_setSession(protocol); - if(d_conn_sec_dtls.d_dtlstState != _TINYDTLS_STATE_CONNECT) + if(session->d_dtlstState != _TINYDTLS_STATE_CONNECT) return WILDDOG_ERR_SENDERR; while(sendLen < len) { - res = dtls_write(d_conn_sec_dtls.dtls_context, &d_conn_sec_dtls.dst, \ + res = dtls_write(session->dtls_context, &session->dst, \ (uint8 *)(p_buf + sendLen), len - sendLen); if (res >= 0 ) { @@ -513,20 +519,26 @@ Wilddog_Return_T _wilddog_sec_send int _wilddog_sec_recv ( + Wilddog_Protocol_T *protocol, void* p_data, s32 len ) { int res = 0; - _wilddog_sec_setSession(l_tinyfd,&l_tinyaddr_in); - d_conn_sec_dtls.p_recvbuf = p_data; - d_conn_sec_dtls.d_recvlen = len; - d_conn_sec_dtls.d_recvFig = 0; + Wilddog_Sec_Tinydtls_T * session = (Wilddog_Sec_Tinydtls_T*)protocol->user_data; + + wilddog_assert(protocol&&session, -1); + + _wilddog_sec_setSession(protocol); + + session->p_recvbuf = p_data; + session->d_recvlen = len; + session->d_recvFig = 0; /* decode recv */ - res = dtls_handle_read(d_conn_sec_dtls.dtls_context); - if( d_conn_sec_dtls.d_recvFig ) - res = d_conn_sec_dtls.d_recvlen; + res = dtls_handle_read(session->dtls_context); + if(session->d_recvFig) + res = session->d_recvlen; return res; } @@ -540,57 +552,64 @@ int _wilddog_sec_recv * Output: N/A * Return: Success: 0 else init failure */ -Wilddog_Return_T _wilddog_sec_init - ( - Wilddog_Str_T *p_host, - u16 d_port - ) +Wilddog_Return_T _wilddog_sec_init(Wilddog_Protocol_T *protocol) { int res = 0; int sec_int_cnt = 0; - memset(&d_conn_sec_dtls, 0, sizeof(Wilddog_Conn_Sec_T)); + Wilddog_Sec_Tinydtls_T * session = NULL; + + wilddog_assert(protocol, WILDDOG_ERR_NULL); - wilddog_openSocket(&l_tinyfd); - res = _wilddog_sec_getHost(&l_tinyaddr_in,p_host,d_port); - if(res <0 ) + wilddog_openSocket(&protocol->socketFd); + res = _wilddog_sec_getHost(&protocol->addr,protocol->host); + if(res < 0) return res; - _wilddog_sec_setSession(l_tinyfd,&l_tinyaddr_in); + if(protocol->user_data){ + wfree(protocol->user_data); + protocol->user_data = NULL; + } + protocol->user_data = wmalloc(sizeof(Wilddog_Sec_Tinydtls_T)); + if(!protocol->user_data){ + wilddog_debug_level(WD_DEBUG_ERROR,"Malloc failed!"); + return WILDDOG_ERR_NULL; + } + + session = (Wilddog_Sec_Tinydtls_T*)protocol->user_data; + + _wilddog_sec_setSession(protocol); dtls_init(); #ifndef WILDDOG_PORT_TYPE_WICED tiny_dtls_set_log_level(WD_DEBUG_DTLS); #endif - d_conn_sec_dtls.dtls_context = dtls_new_context(&d_conn_sec_dtls.d_fd); + session->dtls_context = dtls_new_context(protocol); - if(d_conn_sec_dtls.dtls_context == NULL) + if(session->dtls_context == NULL){ return -1; + } /*@ register dtls cb*/ - dtls_set_handler(d_conn_sec_dtls.dtls_context, &cb); + dtls_set_handler(session->dtls_context, &cb); /*@ Establishes a DTLS channel with the specified remote peer dst. **@ start client Hello */ - res = dtls_connect(d_conn_sec_dtls.dtls_context, &d_conn_sec_dtls.dst); + res = dtls_connect(session->dtls_context, &session->dst); while(sec_int_cnt++ < 100) { - if(d_conn_sec_dtls.d_dtlstState == _TINYDTLS_STATE_CONNECT) + if(session->d_dtlstState == _TINYDTLS_STATE_CONNECT) return 0; /*dtls error */ - if( d_conn_sec_dtls.d_dtlstState == _TINYDTLS_STATE_ERROR) + if(session->d_dtlstState == _TINYDTLS_STATE_ERROR) break; - res = dtls_handle_read(d_conn_sec_dtls.dtls_context); + res = dtls_handle_read(session->dtls_context); if(res < 0) break; } -/* res = _wilddog_sec_reconnectInner(d_conn_sec_dtls.dtls_context, - &d_conn_sec_dtls.dst, - WILDDOG_RETRANSMITE_TIME, - 3);*/ return res; } @@ -601,16 +620,21 @@ Wilddog_Return_T _wilddog_sec_init * Output: N/A * Return: Success: 0 */ -Wilddog_Return_T _wilddog_sec_deinit(void) +Wilddog_Return_T _wilddog_sec_deinit(Wilddog_Protocol_T *protocol) { - /* send terminate alert*/ - dtls_free_context(d_conn_sec_dtls.dtls_context); - if(l_tinyfd) - wilddog_closeSocket(l_tinyfd); + Wilddog_Sec_Tinydtls_T * session = (Wilddog_Sec_Tinydtls_T *)protocol->user_data; + + wilddog_assert(protocol&&session, WILDDOG_ERR_NULL); + + /* send terminate alert*/ + dtls_free_context(session->dtls_context); + if(protocol->socketFd != -1) + wilddog_closeSocket(protocol->socketFd); - l_tinyfd = 0; - memset(&l_tinyaddr_in,0,sizeof(l_tinyaddr_in)); - memset(&d_conn_sec_dtls, 0, sizeof(Wilddog_Conn_Sec_T)); + protocol->socketFd = -1; + memset(&protocol->addr,0,sizeof(protocol->addr)); + wfree(session); + protocol->user_data = NULL; return WILDDOG_ERR_NOERR; } diff --git a/src/wilddog_api.c b/src/wilddog_api.c index 07baf76..289a694 100644 --- a/src/wilddog_api.c +++ b/src/wilddog_api.c @@ -578,6 +578,7 @@ Wilddog_Return_T wilddog_cancelDisconnectOperations */ Wilddog_Return_T wilddog_goOffline(void) { + wilddog_debug_level(WD_DEBUG_LOG, "Go offline has been called!"); return (Wilddog_Return_T)_wilddog_ct_ioctl(WILDDOG_APICMD_GOOFFLINE, NULL,0); } /* @@ -590,5 +591,6 @@ Wilddog_Return_T wilddog_goOffline(void) */ Wilddog_Return_T wilddog_goOnline(void) { + wilddog_debug_level(WD_DEBUG_LOG, "Go online has been called!"); return (Wilddog_Return_T)_wilddog_ct_ioctl(WILDDOG_APICMD_GOONLINE, NULL,0); } \ No newline at end of file diff --git a/src/wilddog_common.c b/src/wilddog_common.c index e921532..400b064 100644 --- a/src/wilddog_common.c +++ b/src/wilddog_common.c @@ -172,16 +172,9 @@ u32 WD_SYSTEM _wilddog_getTime(void) */ void WD_SYSTEM _wilddog_syncTime(void) { -// static u32 recentTime = 0; u32 currTime = _wilddog_getTime() + WILDDOG_RECEIVE_TIMEOUT; - - /*every repo will receive WILDDOG_RECEIVE_TIMEOUT ms*/ -// u32 calTime = recentTime + WILDDOG_RECEIVE_TIMEOUT; - -// currTime = (currTime != recentTime ? (currTime):(calTime)); - + wilddog_debug_level(WD_DEBUG_ALL,"Sync time, current time is %ld",currTime); _wilddog_setTime(currTime); -// recentTime = currTime; return; } diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index 476b037..28d1189 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -11,6 +11,7 @@ * 0.4.0 lxs 2015-05-15 Create file. * 0.5.0 lxs 2015-10-09 cut down some function. * 0.7.5 lxs 2015-12-02 one cmd one functions. + * 1.2.0 jimmy 2017-01-09 Rewrite connect layer logic. */ #ifndef WILDDOG_PORT_TYPE_ESP @@ -35,16 +36,620 @@ #include "test_lib.h" #include "wilddog_protocol.h" -#define WILDDOG_RETRANSMIT_DEFAULT_INTERVAL (2*1000)//默认的重传间隔 -#define WILDDOG_DEFALUT_PING_INTERVAL (19*1000) //初始化的ping间隔 -#define WILDDOG_DEFAULT_PING_DELTA (10*1000) //ping的初始化步进间隔 +#define WILDDOG_RETRANSMIT_DEFAULT_INTERVAL (1)//默认的数据包重传间隔,s +#define WILDDOG_SESSION_OFFLINE_TIMES (3)//session 建立失败多少次后，认为离线 +#define WILDDOG_SESSION_MAX_RETRY_TIME_INTERVAL (150)//session max retry time interval +#define WILDDOG_SMART_PING + +#ifdef WILDDOG_SMART_PING +#define WILDDOG_DEFAULT_PING_INTERVAL (19) //初始化的ping间隔,s +#define WILDDOG_DEFAULT_PING_DELTA (8) //ping的初始化步进间隔,s +//180s is server session keepalive time, so ping interval cannot more than it, +//and we must consider the transmit timeout. +#else +#define WILDDOG_DEFAULT_PING_INTERVAL (25) //默认ping间隔,s +#define WILDDOG_DEFAULT_PING_DELTA (0) //ping的步进间隔,s +#define WILDDOG_FORCE_FALLBACK_TIME (2)// if ping failed, force fallback +#endif +#define WILDDOG_MAX_PING_INTERVAL (175 - (WILDDOG_RETRANSMITE_TIME/1000))//最大ping间隔,s #define WILDDOG_AUTH_SHORT_TKN_KEY "s" #define WILDDOG_AUTH_LONG_TKN_KEY "l" +extern Wilddog_Return_T WD_SYSTEM _wilddog_node_setKey + ( + Wilddog_Node_T *node, + Wilddog_Str_T *key + ); +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_deInit(Wilddog_Conn_Pkt_T * pkt); +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_init(Wilddog_Conn_Pkt_T * pkt,Wilddog_Url_T *s_url); + +STATIC INLINE u32 WD_SYSTEM _wilddog_conn_getNextSendTime(int count){ + return (_wilddog_getTime() + (WILDDOG_RETRANSMIT_DEFAULT_INTERVAL << count) * 1000); +} +/* + Ping policy: When authed: + 1. ping interval = WILDDOG_DEFAULT_PING_INTERVAL, delta = WILDDOG_DEFAULT_PING_DELTA, + 2. Send GET coap://.wilddogio.com/.ping?.cs= + 3.1 if recv 200 OK, interval += delta, interval max is 165. continue 2 + 3.2 else if recv 401 UNAUTHED, interval -= delta, delta /= 2, goto 4 + 4. Send POST coap://.wilddogio.com/.rst, payload is long token + 5.1 if recv 200 OK, interval += delta, continue 2 + 5.2 else if recv 400 BADREQUEST, reset interval and delta, set to unauth. +*/ +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_ping_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive ping packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + + switch(error_code){ + case WILDDOG_HTTP_OK: + { + //interval += delta, send short token next time + if(WILDDOG_MAX_PING_INTERVAL <= p_conn->d_conn_sys.d_curr_ping_interval){ + p_conn->d_conn_sys.d_ping_delta = 0; + p_conn->d_conn_sys.d_curr_ping_interval = WILDDOG_MAX_PING_INTERVAL; + }else + p_conn->d_conn_sys.d_curr_ping_interval += p_conn->d_conn_sys.d_ping_delta; + p_conn->d_conn_sys.d_ping_next_send_time = _wilddog_getTime() + \ + p_conn->d_conn_sys.d_curr_ping_interval * 1000; + p_conn->d_conn_sys.d_ping_type = WILDDOG_PING_TYPE_SHORT; + ret = WILDDOG_ERR_NOERR; + break; + } + case WILDDOG_HTTP_BAD_REQUEST: + { + //reset interval and delta + p_conn->d_conn_sys.d_curr_ping_interval = WILDDOG_DEFAULT_PING_INTERVAL; + p_conn->d_conn_sys.d_ping_delta = WILDDOG_DEFAULT_PING_DELTA; + p_conn->d_conn_sys.d_ping_type = WILDDOG_PING_TYPE_SHORT; + p_conn->d_conn_sys.d_ping_next_send_time = 0; + //if status is init, means appid is not exist, so keep the status. + if(WILDDOG_SESSION_INIT != p_conn->d_session.d_session_status){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + } + ret = WILDDOG_ERR_NOERR; + break; + } + case WILDDOG_HTTP_UNAUTHORIZED: + { + //interval -= delta, delta /= 2, send long token right now. + p_conn->d_conn_sys.d_curr_ping_interval -= p_conn->d_conn_sys.d_ping_delta; + p_conn->d_conn_sys.d_ping_delta /= 2; + p_conn->d_conn_sys.d_ping_type = WILDDOG_PING_TYPE_LONG; + p_conn->d_conn_sys.d_ping_next_send_time = _wilddog_getTime(); + ret = WILDDOG_ERR_NOERR; + break; + } + default: + { + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + } + } + + //the pkt was handled, free pkt + if(p_conn->d_conn_sys.p_ping){ + _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_ping); + wfree(p_conn->d_conn_sys.p_ping); + p_conn->d_conn_sys.p_ping = NULL; + } + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_get_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Node_T *p_node = NULL; + Wilddog_Conn_Pkt_T *curr,*tmp; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive get packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + + if(WILDDOG_HTTP_OK == error_code){ + //handle the payload + Wilddog_Payload_T node_payload; + Wilddog_Str_T *p_path = NULL; + + p_path = _wilddog_url_getKey(pkt->p_url->p_url_path); + + if(NULL == payload){ + p_node = wilddog_node_createNull(NULL); + wilddog_assert(p_node, WILDDOG_ERR_NULL); + }else{ + node_payload.p_dt_data = payload; + node_payload.d_dt_len = payload_len; + node_payload.d_dt_pos = 0; + + //malloced a p_node + p_node = _wilddog_payload2Node(&node_payload); + wilddog_assert(p_node, WILDDOG_ERR_NULL); + //sepecial: data {} change to null + if(WILDDOG_NODE_TYPE_OBJECT == p_node->d_wn_type && \ + NULL == p_node->p_wn_child) + { + wilddog_node_delete(p_node); + p_node = wilddog_node_createNull(NULL); + wilddog_assert(p_node, WILDDOG_ERR_NULL); + } + } + if(p_path){ + _wilddog_node_setKey(p_node, p_path); + } + ret = WILDDOG_ERR_NOERR; + + }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + }else{ + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + } + + //user callback + if(pkt->p_user_callback){ + wilddog_debug_level(WD_DEBUG_LOG, "Tigger getValue callback."); + (pkt->p_user_callback)(p_node,pkt->p_user_arg,error_code); + } + + if(p_node) + wilddog_node_delete(p_node); + + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr == pkt){ + //match, remove it + LL_DELETE(p_conn->d_conn_user.p_rest_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + p_conn->d_conn_user.d_count--; + break; + } + } + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_set_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Conn_Pkt_T *curr,*tmp; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive set packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + + if(WILDDOG_HTTP_OK == error_code){ + ret = WILDDOG_ERR_NOERR; + }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + }else{ + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + } + + //user callback + if(pkt->p_user_callback){ + wilddog_debug_level(WD_DEBUG_LOG, "Tigger setValue callback."); + (pkt->p_user_callback)(pkt->p_user_arg,error_code); + } + + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr == pkt){ + //match, remove it + LL_DELETE(p_conn->d_conn_user.p_rest_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + p_conn->d_conn_user.d_count--; + break; + } + } + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_push_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Conn_Pkt_T *curr,*tmp; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive push packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + + if(WILDDOG_HTTP_OK == error_code){ + ret = WILDDOG_ERR_NOERR; + }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + }else{ + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + } + + //user callback + if(pkt->p_user_callback){ + wilddog_debug_level(WD_DEBUG_LOG, "Tigger push callback."); + (pkt->p_user_callback)(payload,pkt->p_user_arg,error_code); + } + + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr == pkt){ + //match, remove it + LL_DELETE(p_conn->d_conn_user.p_rest_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + p_conn->d_conn_user.d_count--; + break; + } + } + return ret; +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_remove_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Conn_Pkt_T *curr,*tmp; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive remove packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + + switch(error_code){ + case WILDDOG_HTTP_OK: + { + ret = WILDDOG_ERR_NOERR; + break; + } + case WILDDOG_HTTP_UNAUTHORIZED: + { + //need reauth, this happened only when server lost our session. + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + break; + } + case WILDDOG_HTTP_INTERNAL_SERVER_ERR: + { + wilddog_debug_level(WD_DEBUG_ERROR, "Receive server internal error"); + //ret = WILDDOG_ERR_IGNORE;//do not ignore, just handle it normally. + break; + } + case WILDDOG_HTTP_PRECONDITION_FAIL: + { + wilddog_debug_level(WD_DEBUG_WARN, "Precondition failed ! May be the pay package is overflow."); + break; + } + case WILDDOG_ERR_RECVTIMEOUT: + { + wilddog_debug_level(WD_DEBUG_WARN,"Receive timeout."); + break; + } + default: + { + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + break; + } + } + + //user callback + if(pkt->p_user_callback){ + wilddog_debug_level(WD_DEBUG_LOG, "Tigger removeValue callback."); + (pkt->p_user_callback)(pkt->p_user_arg,error_code); + } + + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr == pkt){ + //match, remove it + LL_DELETE(p_conn->d_conn_user.p_rest_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + p_conn->d_conn_user.d_count--; + break; + } + } + return ret; + +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_addObserver_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Node_T *p_node = NULL; + Wilddog_Conn_Pkt_T *curr,*tmp; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive addObserver packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + + if(WILDDOG_HTTP_OK == error_code){ + //handle the payload + Wilddog_Payload_T node_payload; + Wilddog_Str_T *p_path = NULL; + + p_path = _wilddog_url_getKey(pkt->p_url->p_url_path); + + if(NULL == payload){ + p_node = wilddog_node_createNull(NULL); + wilddog_assert(p_node, WILDDOG_ERR_NULL); + }else{ + node_payload.p_dt_data = payload; + node_payload.d_dt_len = payload_len; + node_payload.d_dt_pos = 0; + + //malloced a p_node + p_node = _wilddog_payload2Node(&node_payload); + wilddog_assert(p_node, WILDDOG_ERR_NULL); + //sepecial: data {} change to null + if(WILDDOG_NODE_TYPE_OBJECT == p_node->d_wn_type && \ + NULL == p_node->p_wn_child) + { + wilddog_node_delete(p_node); + p_node = wilddog_node_createNull(NULL); + wilddog_assert(p_node, WILDDOG_ERR_NULL); + } + } + if(p_path){ + _wilddog_node_setKey(p_node, p_path); + } + //change pkt to never timeout, next send time to maximum. + pkt->d_flag |= WILDDOG_CONN_PKT_FLAG_NEVERTIMEOUT; + pkt->d_next_send_time = 0xfffffff; + ret = WILDDOG_ERR_NOERR; + + }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + }else{ + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + } + + //user callback + if(pkt->p_user_callback){ + wilddog_debug_level(WD_DEBUG_LOG, "Tigger addObserver callback."); + (pkt->p_user_callback)(p_node,pkt->p_user_arg,error_code); + } + + if(p_node) + wilddog_node_delete(p_node); + //if received error, remove it + //if reconnect, do not remove. + if(WILDDOG_HTTP_OK != error_code){ + LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,tmp){ + if(curr == pkt){ + //match, remove it + LL_DELETE(p_conn->d_conn_user.p_observer_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + p_conn->d_conn_user.d_count--; + break; + } + } + } + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_removeObserver_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Conn_Pkt_T *curr,*tmp; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive removeObserver packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + + if(WILDDOG_HTTP_OK == error_code){ + ret = WILDDOG_ERR_NOERR; + }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + }else{ + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + } + + //user callback + if(pkt->p_user_callback){ + wilddog_debug_level(WD_DEBUG_LOG, "Tigger removeObserver callback."); + (pkt->p_user_callback)(pkt->p_user_arg,error_code); + } + + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr == pkt){ + //match, remove it + LL_DELETE(p_conn->d_conn_user.p_rest_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + p_conn->d_conn_user.d_count--; + break; + } + } + return ret; +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disCommon_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Conn_Pkt_T *curr,*tmp; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + if(WILDDOG_HTTP_OK == error_code){ + ret = WILDDOG_ERR_NOERR; + }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + }else{ + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + } + + //user callback + if(pkt->p_user_callback){ + (pkt->p_user_callback)(pkt->p_user_arg,error_code); + } + + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr == pkt){ + //match, remove it + LL_DELETE(p_conn->d_conn_user.p_rest_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + p_conn->d_conn_user.d_count--; + break; + } + } + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disSet_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive dis set packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + return _wilddog_conn_disCommon_callback(p_conn,pkt,payload,payload_len,error_code); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disPush_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive dis push packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + return _wilddog_conn_disCommon_callback(p_conn,pkt,payload,payload_len,error_code); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disRemove_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive dis remove packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + return _wilddog_conn_disCommon_callback(p_conn,pkt,payload,payload_len,error_code); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disCancel_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive dis cancel packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + return _wilddog_conn_disCommon_callback(p_conn,pkt,payload,payload_len,error_code); +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_offline_callback + ( + Wilddog_Conn_T *p_conn, + Wilddog_Conn_Pkt_T *pkt, + u8* payload, + u32 payload_len, + Wilddog_Return_T error_code + ) +{ + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Conn_Pkt_T *curr,*tmp; + + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive offline packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + + if(WILDDOG_HTTP_OK == error_code){ + ret = WILDDOG_ERR_NOERR; + }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + }else{ + wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); + } + + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr == pkt){ + //match, remove it + LL_DELETE(p_conn->d_conn_user.p_rest_list, curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + p_conn->d_conn_user.d_count--; + break; + } + } + return ret; -STATIC INLINE u32 WD_SYSTEM _wilddog_conn_getNextSendTime(int count){ - return (_wilddog_getTime() + count * WILDDOG_RETRANSMIT_DEFAULT_INTERVAL); } STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth_callback @@ -57,122 +662,170 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth_callback ) { Wilddog_Return_T ret = WILDDOG_ERR_INVALID; - + Wilddog_Conn_Pkt_T *curr,*tmp; wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + wilddog_assert(p_conn->d_conn_sys.p_auth == pkt, WILDDOG_ERR_INVALID); - wilddog_debug_level(WD_DEBUG_LOG,"Receive auth packet, return code is %d",error_code); - if(error_code == WILDDOG_HTTP_OK){ - //1. store short token and long token - //2. change auth status to authed - //3. trigger user callback - Wilddog_Payload_T node_payload; - Wilddog_Node_T *p_node = NULL; - wilddog_assert(payload, WILDDOG_ERR_IGNORE); - - node_payload.p_dt_data = payload; - node_payload.d_dt_len = payload_len; - node_payload.d_dt_pos = 0; - - //malloced a p_node - p_node = _wilddog_payload2Node(&node_payload); - - wilddog_assert(p_node, WILDDOG_ERR_IGNORE); - if(!p_node->p_wn_child || !p_node->p_wn_child->p_wn_next){ - wilddog_debug_level(WD_DEBUG_ERROR,"Node's child is null!"); - wilddog_node_delete(p_node); - return WILDDOG_ERR_IGNORE; - } - //p_node contain a 's' and 'l' node, which are short and long token. - if(WILDDOG_NODE_TYPE_UTF8STRING != p_node->p_wn_child->d_wn_type || - WILDDOG_NODE_TYPE_UTF8STRING != p_node->p_wn_child->p_wn_next->d_wn_type){ - wilddog_debug_level(WD_DEBUG_ERROR, \ - "Node type is %d and %d,not string!", - p_node->p_wn_child->d_wn_type, - p_node->p_wn_child->p_wn_next->d_wn_type); - wilddog_node_delete(p_node); - return WILDDOG_ERR_IGNORE; - } - if(!p_node->p_wn_child->p_wn_key|| \ - !p_node->p_wn_child->p_wn_value|| \ - !p_node->p_wn_child->p_wn_next->p_wn_key|| \ - !p_node->p_wn_child->p_wn_next->p_wn_value){ - wilddog_debug_level(WD_DEBUG_ERROR, \ - "Node child: key[%s]value[%s],next:key[%s]value[%s] is NULL!", \ - p_node->p_wn_child->p_wn_key, - p_node->p_wn_child->p_wn_value, - p_node->p_wn_child->p_wn_next->p_wn_key, - p_node->p_wn_child->p_wn_next->p_wn_value); - wilddog_node_delete(p_node); - return WILDDOG_ERR_IGNORE; - } - if(!strcmp((const char*)p_node->p_wn_child->p_wn_key,WILDDOG_AUTH_SHORT_TKN_KEY)){ - if(strcmp((const char*)p_node->p_wn_child->p_wn_next->p_wn_key,WILDDOG_AUTH_LONG_TKN_KEY)){ - //short match, but long not find - wilddog_debug_level(WD_DEBUG_ERROR, "long token not find!"); + wilddog_debug_level(WD_DEBUG_LOG, \ + "Receive auth packet [0x%x], return code is [%d]", \ + (unsigned int)pkt->d_message_id,error_code); + switch(error_code){ + case WILDDOG_HTTP_OK: + { + //1. store short token and long token + //2. change auth status to authed + //3. trigger user callback + //4. if ok, free pkt. + Wilddog_Payload_T node_payload; + Wilddog_Node_T *p_node = NULL; + wilddog_assert(payload, WILDDOG_ERR_IGNORE); + + node_payload.p_dt_data = payload; + node_payload.d_dt_len = payload_len; + node_payload.d_dt_pos = 0; + + //malloced a p_node + p_node = _wilddog_payload2Node(&node_payload); + + wilddog_assert(p_node, WILDDOG_ERR_IGNORE); + if(!p_node->p_wn_child || !p_node->p_wn_child->p_wn_next){ + wilddog_debug_level(WD_DEBUG_ERROR,"Node's child is null!"); wilddog_node_delete(p_node); return WILDDOG_ERR_IGNORE; } - //short token, store it. - strncpy((char*)p_conn->d_session.short_sid, \ - (char*)p_node->p_wn_child->p_wn_value, \ - WILDDOG_CONN_SESSION_SHORT_LEN - 1); - //long token, store it. - strncpy((char*)p_conn->d_session.long_sid, \ - (char*)p_node->p_wn_child->p_wn_next->p_wn_value,\ - WILDDOG_CONN_SESSION_LONG_LEN - 1); - }else if(!strcmp((const char*)p_node->p_wn_child->p_wn_key,WILDDOG_AUTH_LONG_TKN_KEY)){ - if(strcmp((const char*)p_node->p_wn_child->p_wn_next->p_wn_key,WILDDOG_AUTH_SHORT_TKN_KEY)){ - //long match, but short not find - wilddog_debug_level(WD_DEBUG_ERROR, "short token not find!"); + //p_node contain a 's' and 'l' node, which are short and long token. + if(WILDDOG_NODE_TYPE_UTF8STRING != p_node->p_wn_child->d_wn_type || + WILDDOG_NODE_TYPE_UTF8STRING != p_node->p_wn_child->p_wn_next->d_wn_type){ + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Node type is %d and %d,not string!", + p_node->p_wn_child->d_wn_type, + p_node->p_wn_child->p_wn_next->d_wn_type); wilddog_node_delete(p_node); return WILDDOG_ERR_IGNORE; } - //short token, store it. - strncpy((char*)p_conn->d_session.short_sid, \ - (char*)p_node->p_wn_child->p_wn_next->p_wn_value, \ - WILDDOG_CONN_SESSION_SHORT_LEN - 1); - //long token, store it. - strncpy((char*)p_conn->d_session.long_sid, \ - (char*)p_node->p_wn_child->p_wn_value, \ - WILDDOG_CONN_SESSION_LONG_LEN - 1); - }else{ - //short and long not find - wilddog_debug_level(WD_DEBUG_ERROR, "short and long token not find!"); + if(!p_node->p_wn_child->p_wn_key|| \ + !p_node->p_wn_child->p_wn_value|| \ + !p_node->p_wn_child->p_wn_next->p_wn_key|| \ + !p_node->p_wn_child->p_wn_next->p_wn_value){ + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Node child: key[%s]value[%s],next:key[%s]value[%s] is NULL!", \ + p_node->p_wn_child->p_wn_key, + p_node->p_wn_child->p_wn_value, + p_node->p_wn_child->p_wn_next->p_wn_key, + p_node->p_wn_child->p_wn_next->p_wn_value); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + if(!strcmp((const char*)p_node->p_wn_child->p_wn_key,WILDDOG_AUTH_SHORT_TKN_KEY)){ + if(strcmp((const char*)p_node->p_wn_child->p_wn_next->p_wn_key,WILDDOG_AUTH_LONG_TKN_KEY)){ + //short match, but long not find + wilddog_debug_level(WD_DEBUG_ERROR, "long token not find!"); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + memset(p_conn->d_session.short_sid, 0,WILDDOG_CONN_SESSION_SHORT_LEN); + memset(p_conn->d_session.long_sid, 0,WILDDOG_CONN_SESSION_LONG_LEN); + //short token, store it. + strncpy((char*)p_conn->d_session.short_sid, \ + (char*)p_node->p_wn_child->p_wn_value, \ + WILDDOG_CONN_SESSION_SHORT_LEN - 1); + //long token, store it. + strncpy((char*)p_conn->d_session.long_sid, \ + (char*)p_node->p_wn_child->p_wn_next->p_wn_value,\ + WILDDOG_CONN_SESSION_LONG_LEN - 1); + }else if(!strcmp((const char*)p_node->p_wn_child->p_wn_key,WILDDOG_AUTH_LONG_TKN_KEY)){ + if(strcmp((const char*)p_node->p_wn_child->p_wn_next->p_wn_key,WILDDOG_AUTH_SHORT_TKN_KEY)){ + //long match, but short not find + wilddog_debug_level(WD_DEBUG_ERROR, "short token not find!"); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + memset(p_conn->d_session.short_sid, 0,WILDDOG_CONN_SESSION_SHORT_LEN); + memset(p_conn->d_session.long_sid, 0,WILDDOG_CONN_SESSION_LONG_LEN); + //short token, store it. + strncpy((char*)p_conn->d_session.short_sid, \ + (char*)p_node->p_wn_child->p_wn_next->p_wn_value, \ + WILDDOG_CONN_SESSION_SHORT_LEN - 1); + //long token, store it. + strncpy((char*)p_conn->d_session.long_sid, \ + (char*)p_node->p_wn_child->p_wn_value, \ + WILDDOG_CONN_SESSION_LONG_LEN - 1); + }else{ + //short and long not find + wilddog_debug_level(WD_DEBUG_ERROR, "short and long token not find!"); + wilddog_node_delete(p_node); + return WILDDOG_ERR_IGNORE; + } + p_conn->d_session.d_session_status = WILDDOG_SESSION_AUTHED; + wilddog_debug_level(WD_DEBUG_LOG, \ + "Auth success!Short token is %s, long token is %s", \ + p_conn->d_session.short_sid, + p_conn->d_session.long_sid); + + //free p_node wilddog_node_delete(p_node); + ret = WILDDOG_ERR_NOERR; + //change observe/rest stored packets' send time to now. + LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,tmp){ + if(curr){ + curr->d_flag &= ~WILDDOG_CONN_PKT_FLAG_NEVERTIMEOUT; + curr->d_count = 0; + curr->d_next_send_time = _wilddog_getTime(); + } + } + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr){ + curr->d_next_send_time = _wilddog_getTime(); + } + } + //online, change status + p_conn->d_conn_sys.d_auth_fail_count = 0; + p_conn->d_conn_sys.d_offline_time = 0; + p_conn->d_conn_sys.d_online_retry_count = 0; + break; + } + case WILDDOG_HTTP_BAD_REQUEST: + { + //cannot find this repo, stop to send auth data. + p_conn->d_session.d_session_status = WILDDOG_SESSION_INIT; + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Can not find host %s", p_conn->p_conn_repo->p_rp_url->p_url_host); + ret = WILDDOG_ERR_INVALID; + break; + } + case WILDDOG_HTTP_INTERNAL_SERVER_ERR: + { + //Oh, server down! Wait time to resend this packet. + wilddog_debug_level(WD_DEBUG_ERROR, "Receive server internal error"); return WILDDOG_ERR_IGNORE; } - p_conn->d_session.d_session_status = WILDDOG_SESSION_AUTHED; - wilddog_debug_level(WD_DEBUG_LOG, \ - "Auth success!Short token is %s, long token is %s", \ - p_conn->d_session.short_sid, - p_conn->d_session.long_sid); - - //free p_node - wilddog_node_delete(p_node); - ret = WILDDOG_ERR_NOERR; - }else if(WILDDOG_HTTP_BAD_REQUEST == error_code){ - //cannot find this repo, stop to send auth data. - p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; - wilddog_debug_level(WD_DEBUG_ERROR, \ - "Can not find host %s", p_conn->p_conn_repo->p_rp_url->p_url_host); - - ret = WILDDOG_ERR_INVALID; - }else if(WILDDOG_HTTP_INTERNAL_SERVER_ERR == error_code){ - //cantinue to send auth data. - wilddog_debug_level(WD_DEBUG_ERROR, "Receive server internal error"); - ret = WILDDOG_ERR_IGNORE; - }else{ - p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; - wilddog_debug_level(WD_DEBUG_ERROR, "Receive unknown error %d",error_code); - ret = WILDDOG_ERR_INVALID; + case WILDDOG_ERR_RECVTIMEOUT: + { + wilddog_debug_level(WD_DEBUG_WARN, "Receive timeout."); + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + break; + } + default: + { + //WTF! We don't recognize this error code, can do nothing but reauth. + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + wilddog_debug_level(WD_DEBUG_ERROR, "Receive unknown error %d",error_code); + ret = WILDDOG_ERR_INVALID; + break; + } } //user callback if(pkt->p_user_callback){ - wilddog_debug_level(WD_DEBUG_LOG, "trigger auth callback"); + wilddog_debug_level(WD_DEBUG_LOG, "Trigger auth callback"); (pkt->p_user_callback)(pkt->p_user_arg,error_code); } - + //the pkt was handled, free pkt + if(p_conn->d_conn_sys.p_auth){ + _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_auth); + wfree(p_conn->d_conn_sys.p_auth); + p_conn->d_conn_sys.p_auth = NULL; + } return ret; } @@ -207,8 +860,8 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_deInit(Wilddog_Conn_Pkt_T return WILDDOG_ERR_NOERR; } -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_init(Wilddog_Conn_Pkt_T * pkt,Wilddog_Conn_T *p_conn){ - wilddog_assert(pkt&&p_conn, WILDDOG_ERR_NULL); +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_init(Wilddog_Conn_Pkt_T * pkt,Wilddog_Url_T *s_url){ + wilddog_assert(pkt&&s_url, WILDDOG_ERR_NULL); pkt->p_url = (Wilddog_Url_T*)wmalloc(sizeof(Wilddog_Url_T)); if(NULL == pkt->p_url){ @@ -216,7 +869,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_init(Wilddog_Conn_Pkt_T * return WILDDOG_ERR_NULL; } - if(WILDDOG_ERR_NOERR != _wilddog_url_copy(p_conn->p_conn_repo->p_rp_url, pkt->p_url)){ + if(WILDDOG_ERR_NOERR != _wilddog_url_copy(s_url, pkt->p_url)){ wfree(pkt->p_url); wilddog_debug_level(WD_DEBUG_ERROR, "Malloc failed!"); return WILDDOG_ERR_NULL; @@ -232,56 +885,542 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_packet_init(Wilddog_Conn_Pkt_T * pkt->d_next_send_time = 0; pkt->d_message_id = 0; pkt->next = NULL; - + pkt->d_register_time = _wilddog_getTime(); return WILDDOG_ERR_NOERR; } STATIC BOOL WD_SYSTEM _wilddog_conn_midCmp(u32 s_mid,u32 d_mid){ if((s_mid & 0xffffffff) == (d_mid & 0xffffffff)){ return TRUE; } - return FALSE; -} -/* - * find the send packet matched with received packet -*/ -STATIC Wilddog_Conn_Pkt_T * WD_SYSTEM _wilddog_conn_recv_sendPktFind(Wilddog_Conn_T *p_conn,u32 mid){ - wilddog_assert(p_conn,NULL); + return FALSE; +} + +/* + * find the send packet matched with received packet +*/ +STATIC Wilddog_Conn_Pkt_T * WD_SYSTEM _wilddog_conn_recv_sendPktFind(Wilddog_Conn_T *p_conn,u32 mid){ + Wilddog_Conn_Pkt_T *curr, *tmp; + + wilddog_assert(p_conn,NULL); + + if(p_conn->d_conn_sys.p_auth){ + if(TRUE == _wilddog_conn_midCmp(mid, p_conn->d_conn_sys.p_auth->d_message_id)){ + //match, is the auth callback! + return p_conn->d_conn_sys.p_auth; + } + } + if(p_conn->d_conn_sys.p_ping){ + if(TRUE == _wilddog_conn_midCmp(mid,p_conn->d_conn_sys.p_ping->d_message_id)){ + return p_conn->d_conn_sys.p_ping; + } + } + //observe list check + LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,tmp){ + if(TRUE == _wilddog_conn_midCmp(mid,curr->d_message_id)){ + return curr; + } + } + //rest list check + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(TRUE == _wilddog_conn_midCmp(mid,curr->d_message_id)){ + return curr; + } + } + return NULL; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_reconnect(Wilddog_Conn_T *p_conn){ + //reconnect socket + Wilddog_Proto_Cmd_Arg_T command; + + wilddog_assert(p_conn&&p_conn->p_protocol, WILDDOG_ERR_NULL); + + //send + command.p_data = NULL; + command.d_data_len = 0; + command.p_message_id= NULL; + command.p_url = NULL; + command.protocol = p_conn->p_protocol; + command.p_out_data = NULL; + command.p_out_data_len = NULL; + command.p_proto_data = NULL; + //send pkt must need session info, exclude auth pkt. + command.p_session_info = NULL; + command.d_session_len = 0; + if(p_conn->p_protocol->callback){ + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_RECONNECT, &command, 0); + } + return WILDDOG_ERR_NOERR; +} +STATIC BOOL WD_SYSTEM _wilddog_conn_isTimeout(u32 src, u32 dst, u32 timeout){ + if(src >= dst){ + if(src - dst > timeout) + return TRUE; + return FALSE; + }else{ + //fallback + if(src + (0xffffffff - dst) > timeout) + return TRUE; + return FALSE; + } +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_retransmitPkt(Wilddog_Conn_T *p_conn,Wilddog_Conn_Pkt_T *pkt){ + Wilddog_Proto_Cmd_Arg_T command; + wilddog_assert(p_conn&&pkt, WILDDOG_ERR_NULL); + + //send to server, get method has no p_data + command.p_data = (u8*)pkt->p_data->data; + command.d_data_len = pkt->p_data->len; + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = NULL; + command.p_out_data_len = NULL; + command.p_proto_data = NULL; + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + + if(_wilddog_conn_isTimeout(_wilddog_getTime(),pkt->d_register_time,WILDDOG_RETRANSMITE_TIME) && \ + 0 == (WILDDOG_CONN_PKT_FLAG_NEVERTIMEOUT & pkt->d_flag)){ + //timeout, trigger callback + if(pkt->p_complete){ + Wilddog_Return_T ret; + if(WILDDOG_SESSION_INIT == p_conn->d_session.d_session_status){ + //observe/ping/rest recv timeout and status is init,means + //auth received bad request. + ret = WILDDOG_HTTP_BAD_REQUEST; + }else{ + ret = WILDDOG_ERR_RECVTIMEOUT; + } + (pkt->p_complete)(p_conn,pkt,NULL,0, ret); + } + p_conn->d_timeout_count++; + return WILDDOG_ERR_RECVTIMEOUT; + }else if(_wilddog_getTime() >= pkt->d_next_send_time){ + //if authed, we can handle retransmit. + if(WILDDOG_SESSION_AUTHED == p_conn->d_session.d_session_status){ + pkt->d_count++; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + if(p_conn->p_protocol->callback){ + wilddog_debug_level(WD_DEBUG_LOG, "Retransmit pkt 0x%x",(unsigned int)pkt->d_message_id); + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_RETRANSMIT, &command, 0); + } + }else{ + //not authed +// wilddog_debug_level(WD_DEBUG_WARN, "Not authed, do not retransmit packet 0x%x.",(unsigned int)pkt->d_message_id); + //pkt->d_count++; + //pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + } + return WILDDOG_ERR_NOERR; +} +/* + Ping policy: When authed: + 1. ping interval = WILDDOG_DEFAULT_PING_INTERVAL, delta = WILDDOG_DEFAULT_PING_DELTA, + 2. Send GET coap://.wilddogio.com/.ping?.cs= + 3.1 if recv 200 OK, interval += delta, continue 2 + 3.2 else if recv 401 UNAUTHED, interval -= delta, delta /= 2, goto 4 + 4. Send POST coap://.wilddogio.com/.rst, payload is long token + 5.1 if recv 200 OK, interval += delta, continue 2 + 5.2 else if recv 400 BADREQUEST, reset interval and delta, set to unauth. +*/ +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_pingHandler(Wilddog_Conn_T* p_conn){ + Wilddog_Conn_Pkt_T *pkt = p_conn->d_conn_sys.p_ping; + + wilddog_assert(p_conn&&p_conn->p_protocol, WILDDOG_ERR_NULL); + //already handled ping retransmit and timeout, now we handle send + if(WILDDOG_SESSION_AUTHED == p_conn->d_session.d_session_status){ + Wilddog_Proto_Cmd_Arg_T command; + command.p_data = NULL; + command.d_data_len = 0; + command.p_message_id= NULL; + command.p_url = NULL; + command.protocol = p_conn->p_protocol; + command.p_out_data = NULL; + command.p_out_data_len = NULL; + command.p_proto_data = NULL; + if(0 == p_conn->d_conn_sys.d_ping_next_send_time || p_conn->d_conn_sys.d_ping_next_send_time < _wilddog_getTime()){ + //have not initialized + if(0 == p_conn->d_conn_sys.d_ping_next_send_time){ + p_conn->d_conn_sys.d_curr_ping_interval = WILDDOG_DEFAULT_PING_INTERVAL; + p_conn->d_conn_sys.d_ping_delta = WILDDOG_DEFAULT_PING_DELTA; + p_conn->d_conn_sys.d_ping_next_send_time = _wilddog_getTime() + p_conn->d_conn_sys.d_curr_ping_interval * 1000; + p_conn->d_conn_sys.d_ping_type = WILDDOG_PING_TYPE_SHORT; + } + //send to server + if(pkt){ + _wilddog_conn_packet_deInit(pkt); + wfree(pkt); + p_conn->d_conn_sys.p_ping = NULL; + } + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn->p_conn_repo->p_rp_url)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_ping_callback; + //add to ping queue + p_conn->d_conn_sys.p_ping = pkt; + + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + //send pkt must need session info, exclude auth pkt. + if(WILDDOG_PING_TYPE_SHORT == p_conn->d_conn_sys.d_ping_type){ + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + command.p_out_data = (u8**)&(pkt->p_data); + command.p_out_data_len = NULL; + if(p_conn->p_protocol->callback){ + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_PING, &command,FALSE); + wilddog_debug_level(WD_DEBUG_LOG, "Send short ping pkt 0x%x at %ld ms, interval is %d", \ + (unsigned int)pkt->d_message_id, _wilddog_getTime(),p_conn->d_conn_sys.d_curr_ping_interval); + } + }else{ + command.p_session_info = p_conn->d_session.long_sid; + command.d_session_len = WILDDOG_CONN_SESSION_LONG_LEN - 1; + command.p_out_data = (u8**)&(pkt->p_data); + command.p_out_data_len = NULL; + if(p_conn->p_protocol->callback){ + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_PING, &command,TRUE); + wilddog_debug_level(WD_DEBUG_LOG, "Send long ping pkt 0x%x at %ld ms, interval is %d", \ + (unsigned int)pkt->d_message_id,_wilddog_getTime(),p_conn->d_conn_sys.d_curr_ping_interval); + } + } + pkt->d_count++; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + } + return WILDDOG_ERR_NOERR; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_retransmitHandler(Wilddog_Conn_T *p_conn){ + u32 last_timeout_count = 0; + Wilddog_Conn_Pkt_T *pkt = NULL; + Wilddog_Conn_Pkt_T *curr, *tmp; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + last_timeout_count = p_conn->d_timeout_count; + //1. timeout handle + //2. retransmit handle + //if authed we can handle retransmit event + pkt = p_conn->d_conn_sys.p_auth; + if(pkt){ + if(WILDDOG_SESSION_AUTHED == p_conn->d_session.d_session_status){ + //WTF, we already authed, do not need this pkt + _wilddog_conn_packet_deInit(pkt); + wfree(pkt); + p_conn->d_conn_sys.p_auth = NULL; + }else{ + //check timeout and retransmit + if(_wilddog_conn_isTimeout(_wilddog_getTime(),pkt->d_register_time,WILDDOG_RETRANSMITE_TIME)){ + //timeout: + //1.trigger callback + //2.set status to unauth, and add timeout count + //3.delete it. + //4.add auth fail count, + // if more than WILDDOG_SESSION_OFFLINE_TIMES times, offline. + //callback + if(pkt->p_complete){ + (pkt->p_complete)(p_conn,pkt,NULL,0, WILDDOG_ERR_RECVTIMEOUT); + } + p_conn->d_timeout_count++; + + if(p_conn->d_conn_sys.p_auth){ + _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_auth); + wfree(p_conn->d_conn_sys.p_auth); + p_conn->d_conn_sys.p_auth = NULL; + } + //auth fail handle + p_conn->d_conn_sys.d_auth_fail_count++; + if(WILDDOG_SESSION_OFFLINE_TIMES <= p_conn->d_conn_sys.d_auth_fail_count && \ + 0 == p_conn->d_conn_sys.d_offline_time){ + //first offline + p_conn->d_conn_sys.d_offline_time = _wilddog_getTime(); + p_conn->d_conn_sys.d_online_retry_count = 0; + } + }else if(_wilddog_getTime() >= pkt->d_next_send_time){ + //retransmit + Wilddog_Proto_Cmd_Arg_T command; + //send to server + command.p_data = (u8*)pkt->p_data->data; + command.d_data_len = pkt->p_data->len; + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = NULL; + command.p_out_data_len = NULL; + command.p_proto_data = NULL; + //send pkt must need session info, exclude auth pkt. + command.p_session_info = NULL; + command.d_session_len = 0; + pkt->d_count++; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + if(p_conn->p_protocol->callback){ + wilddog_debug_level(WD_DEBUG_LOG, "Retransmit auth pkt 0x%x",(unsigned int)pkt->d_message_id); + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_RETRANSMIT, &command, 0); + } + } + } + } + pkt = p_conn->d_conn_sys.p_ping; + if(pkt){ + _wilddog_conn_retransmitPkt(p_conn,pkt); + } + //observe list + LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,tmp){ + if(curr){ + //flash observe's regster time, never timeout + _wilddog_conn_retransmitPkt(p_conn,curr); + } + } + //rest list + LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ + if(curr){ + _wilddog_conn_retransmitPkt(p_conn,curr); + } + } + + if(last_timeout_count < p_conn->d_timeout_count){ + _wilddog_conn_reconnect(p_conn); + if(p_conn->d_timeout_count > 3){ + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + } + } + return WILDDOG_ERR_NOERR; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_commonSet(void* data,int flag, Wilddog_Func_T func,BOOL isDis){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Conn_Pkt_T *pkt; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Payload_T *payload = NULL; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + if(p_conn->d_conn_user.d_count > WILDDOG_REQ_QUEUE_NUM){ + wilddog_debug_level(WD_DEBUG_WARN, "Too many requests! Max is %d",WILDDOG_REQ_QUEUE_NUM); + return WILDDOG_ERR_QUEUEFULL; + } + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)func; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; + + //add to rest queue + LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); + p_conn->d_conn_user.d_count++; + + if(arg->p_data){ +#if (DEBUG_LEVEL)<=(WD_DEBUG_LOG) + if(arg->p_url->p_url_path) + wilddog_debug_level(WD_DEBUG_LOG,"Print data want set: \npath %s", \ + arg->p_url->p_url_path); + wilddog_debug_printnode(arg->p_data); + printf("\n"); +#endif + payload = _wilddog_node2Payload(arg->p_data); +#if (DEBUG_LEVEL)<=(WD_DEBUG_LOG) + { + int i; + wilddog_debug_level(WD_DEBUG_LOG,"Send data is:\n"); + for(i = 0; i < payload->d_dt_len;i++){ + printf("%02x ", *(u8*)(payload->p_dt_data + i)); + } + printf("\n"); + } +#endif + } + //send to server + command.p_data = NULL; + command.d_data_len = 0; + if(payload){ + command.p_data = payload->p_dt_data; + command.d_data_len = payload->d_dt_len; + } + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + + if(p_conn->p_protocol->callback){ + BOOL isSend = FALSE;//send to server or not + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + isSend = TRUE; + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + if(TRUE == isDis){ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_DIS_SET, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send dis setValue pkt 0x%x",(unsigned int)pkt->d_message_id); + }else{ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SET, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send setValue pkt 0x%x",(unsigned int)pkt->d_message_id); + } + } + + if(payload){ + if(payload->p_dt_data) + wfree(payload->p_dt_data); + wfree(payload); + } + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_commonPush(void* data,int flag, Wilddog_Func_T func, BOOL isDis){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Conn_Pkt_T *pkt; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Payload_T *payload = NULL; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + if(p_conn->d_conn_user.d_count > WILDDOG_REQ_QUEUE_NUM){ + wilddog_debug_level(WD_DEBUG_WARN, "Too many requests! Max is %d",WILDDOG_REQ_QUEUE_NUM); + return WILDDOG_ERR_QUEUEFULL; + } + + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)func; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; + + //add to rest queue + LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); + p_conn->d_conn_user.d_count++; + + if(arg->p_data) + payload = _wilddog_node2Payload(arg->p_data); + //send to server + command.p_data = NULL; + command.d_data_len = 0; + if(payload){ + command.p_data = payload->p_dt_data; + command.d_data_len = payload->d_dt_len; + } + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + + if(p_conn->p_protocol->callback){ + BOOL isSend = FALSE;//send to server or not + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + isSend = TRUE; + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + if(TRUE == isDis){ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_DIS_PUSH, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send dis setValue pkt 0x%x",(unsigned int)pkt->d_message_id); + }else{ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_PUSH, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send setValue pkt 0x%x",(unsigned int)pkt->d_message_id); + } + + } + + if(payload){ + if(payload->p_dt_data) + wfree(payload->p_dt_data); + wfree(payload); + } + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_commonRemove(void* data,int flag, Wilddog_Func_T func, BOOL isDis){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Conn_Pkt_T *pkt; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + if(p_conn->d_conn_user.d_count > WILDDOG_REQ_QUEUE_NUM){ + wilddog_debug_level(WD_DEBUG_WARN, "Too many requests! Max is %d",WILDDOG_REQ_QUEUE_NUM); + return WILDDOG_ERR_QUEUEFULL; + } + + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)func; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; - if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ - if(TRUE == _wilddog_conn_midCmp(mid,p_conn->d_conn_sys.p_ping->d_message_id)){ - return p_conn->d_conn_sys.p_ping; - } - else{ - Wilddog_Conn_Pkt_T *curr, *tmp; - //observe list check - LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,tmp){ - if(TRUE == _wilddog_conn_midCmp(mid,curr->d_message_id)){ - return curr; - } - } - //rest list check - LL_FOREACH_SAFE(p_conn->d_conn_user.p_rest_list,curr,tmp){ - if(TRUE == _wilddog_conn_midCmp(mid,curr->d_message_id)){ - return curr; - } - } - //others, also include auth pkt, do not match them. - } - }else if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHING){ - if(TRUE == _wilddog_conn_midCmp(mid, p_conn->d_conn_sys.p_auth->d_message_id)){ - //match, is the auth callback! - return p_conn->d_conn_sys.p_auth; + //add to rest queue + LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); + p_conn->d_conn_user.d_count++; + + //send to server, delete method has no p_data + command.p_data = NULL; + command.d_data_len = 0; + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + + if(p_conn->p_protocol->callback){ + BOOL isSend = FALSE;//send to server or not + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + isSend = TRUE; + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); } - else{ - //bye bye, we don't care who you are. - return NULL; + if(TRUE == isDis){ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_DIS_REMOVE, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send dis removeValue pkt 0x%x",(unsigned int)pkt->d_message_id); + }else{ + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_REMOVE, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send removeValue pkt 0x%x",(unsigned int)pkt->d_message_id); } - }else{ - wilddog_debug_level(WD_DEBUG_WARN, "Receive packet, but client was not registered yet."); - return NULL; + } - return NULL; + return ret; } + STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionInit(Wilddog_Conn_T *p_conn){ Wilddog_Session_T *p_session; Wilddog_Conn_Pkt_T *pkt; @@ -292,8 +1431,9 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionInit(Wilddog_Conn_T *p_co pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); wilddog_assert(pkt, WILDDOG_ERR_NULL); - - if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn)){ + //All requests want to send out need a pkt structure.We use this structure to + //find out the response. + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn->p_conn_repo->p_rp_url)){ wfree(pkt); wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); return WILDDOG_ERR_NULL; @@ -308,23 +1448,242 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionInit(Wilddog_Conn_T *p_co p_conn->d_conn_sys.p_auth = pkt; p_session = &p_conn->d_session; - memset(p_session, 0, sizeof(Wilddog_Session_T)); p_session->d_session_status = WILDDOG_SESSION_AUTHING; //send to server + command.p_data = NULL; + command.d_data_len = 0; command.p_message_id= &pkt->d_message_id; command.p_url = pkt->p_url; command.protocol = p_conn->p_protocol; - command.p_out_data = &(p_conn->d_conn_sys.p_auth->p_data->data); - command.p_out_data_len = &(p_conn->d_conn_sys.p_auth->p_data->len); - + command.p_out_data = (u8**)&(pkt->p_data); + command.p_out_data_len = NULL; + //send pkt must need session info, exclude auth pkt. + command.p_session_info = NULL; + command.d_session_len = 0; + if(p_conn->p_protocol->callback){ - (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SESSION_INIT, &command, 0)); + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SESSION_INIT, &command, 0); + wilddog_debug_level(WD_DEBUG_LOG, "Send init pkt 0x%x",(unsigned int)pkt->d_message_id); } ++pkt->d_count; pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); return WILDDOG_ERR_NOERR; } +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionRetry(Wilddog_Conn_T *p_conn){ + wilddog_assert(p_conn,WILDDOG_ERR_NULL); + + if(p_conn->d_conn_sys.d_offline_time != 0){ + //we are now offline, so we need control retry interval. + u32 sended_time = (1 << p_conn->d_conn_sys.d_online_retry_count); + sended_time = (sended_time > WILDDOG_SESSION_MAX_RETRY_TIME_INTERVAL)? \ + (WILDDOG_SESSION_MAX_RETRY_TIME_INTERVAL):(sended_time); + sended_time = sended_time * 1000; + //left maybe neg value, but it is unsigned, also bigger than offline time, so it works. + //and + if(_wilddog_getTime() - sended_time < p_conn->d_conn_sys.d_offline_time){ + //is not time to send + return WILDDOG_ERR_NOERR; + }else{ + wilddog_debug_level(WD_DEBUG_LOG, "Retry [%d] times to establish session.",p_conn->d_conn_sys.d_online_retry_count); + p_conn->d_conn_sys.d_online_retry_count++; + p_conn->d_conn_sys.d_offline_time = _wilddog_getTime(); + } + } + return _wilddog_conn_sessionInit(p_conn); +} + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_get(void* data,int flag){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Conn_Pkt_T *pkt; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + if(p_conn->d_conn_user.d_count > WILDDOG_REQ_QUEUE_NUM){ + wilddog_debug_level(WD_DEBUG_WARN, "Too many requests! Max is %d",WILDDOG_REQ_QUEUE_NUM); + return WILDDOG_ERR_QUEUEFULL; + } + + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_get_callback; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; + + //add to rest queue + LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); + p_conn->d_conn_user.d_count++; + + //send to server, get method has no p_data + command.p_data = NULL; + command.d_data_len = 0; + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + if(p_conn->p_protocol->callback){ + BOOL isSend = FALSE;//send to server or not + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + isSend = TRUE; + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_GET, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send getValue pkt 0x%x",(unsigned int)pkt->d_message_id); + } + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_set(void* data,int flag){ + return _wilddog_conn_commonSet(data, flag, (Wilddog_Func_T)_wilddog_conn_set_callback,FALSE); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_push(void* data,int flag){ + return _wilddog_conn_commonPush(data,flag,(Wilddog_Func_T)_wilddog_conn_push_callback,FALSE); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_remove(void* data,int flag){ + return _wilddog_conn_commonRemove(data, flag, (Wilddog_Func_T)_wilddog_conn_remove_callback,FALSE); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_addObserver(void* data,int flag){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Conn_Pkt_T *pkt; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + if(p_conn->d_conn_user.d_count > WILDDOG_REQ_QUEUE_NUM){ + wilddog_debug_level(WD_DEBUG_WARN, "Too many requests! Max is %d",WILDDOG_REQ_QUEUE_NUM); + return WILDDOG_ERR_QUEUEFULL; + } + + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_addObserver_callback; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; + + //add to rest queue + LL_APPEND(p_conn->d_conn_user.p_observer_list,pkt); + p_conn->d_conn_user.d_count++; + + //send to server + command.p_data = NULL; + command.d_data_len = 0; + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + command.p_proto_data = &(pkt->p_proto_data); + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + + if(p_conn->p_protocol->callback){ + BOOL isSend = FALSE;//send to server or not + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + isSend = TRUE; + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_ON, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send addObserver pkt 0x%x",(unsigned int)pkt->d_message_id); + } + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_removeObserver(void* data,int flag){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Conn_Pkt_T *pkt; + Wilddog_Conn_Pkt_T *curr,*tmp; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + if(p_conn->d_conn_user.d_count > WILDDOG_REQ_QUEUE_NUM){ + wilddog_debug_level(WD_DEBUG_WARN, "Too many requests! Max is %d",WILDDOG_REQ_QUEUE_NUM); + return WILDDOG_ERR_QUEUEFULL; + } + + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_removeObserver_callback; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; + + //add to rest queue + LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); + p_conn->d_conn_user.d_count++; + + //send to server, get method has no p_data + command.p_data = NULL; + command.d_data_len = 0; + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + command.p_proto_data = NULL; + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + + if(p_conn->p_protocol->callback){ + BOOL isSend = FALSE;//send to server or not + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + isSend = TRUE; + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_OFF, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send removeObserver pkt 0x%x",(unsigned int)pkt->d_message_id); + } + //remove observer + LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,tmp){ + if(curr){ + if(TRUE == _wilddog_url_diff(curr->p_url, arg->p_url)){ + //diff + LL_DELETE(p_conn->d_conn_user.p_observer_list,curr); + _wilddog_conn_packet_deInit(curr); + wfree(curr); + break; + } + } + } + return ret; +} STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth(void* data,int flag){ Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; @@ -340,7 +1699,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth(void* data,int flag){ pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); wilddog_assert(pkt, WILDDOG_ERR_NULL); - if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn)){ + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ wfree(pkt); wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); return WILDDOG_ERR_NULL; @@ -357,15 +1716,21 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth(void* data,int flag){ p_conn->d_conn_sys.p_auth = pkt; p_session = &p_conn->d_session; - memset(p_session, 0, sizeof(Wilddog_Session_T)); + //memset(p_session, 0, sizeof(Wilddog_Session_T)); p_session->d_session_status = WILDDOG_SESSION_AUTHING; //send to server + command.p_data = NULL; + command.d_data_len = 0; command.p_message_id= &pkt->d_message_id; command.p_url = pkt->p_url; command.protocol = p_conn->p_protocol; - command.p_out_data = &(p_conn->d_conn_sys.p_auth->p_data->data); - command.p_out_data_len = &(p_conn->d_conn_sys.p_auth->p_data->len); + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + //send pkt must need session info, exclude auth pkt. + command.p_session_info = NULL; + command.d_session_len = 0; + //get user auth token if(p_conn->p_conn_repo->p_rp_store->p_se_callback){ command.d_data_len = (p_conn->p_conn_repo->p_rp_store->p_se_callback)( @@ -374,42 +1739,153 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth(void* data,int flag){ } if(p_conn->p_protocol->callback){ - (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SESSION_INIT, &command, 0)); + (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_SESSION_INIT, &command, 0); + wilddog_debug_level(WD_DEBUG_LOG, "Send auth pkt 0x%x",(unsigned int)pkt->d_message_id); } ++pkt->d_count; pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); return WILDDOG_ERR_NOERR; } -STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_get(void* data,int flag){ + +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disSet(void* data,int flag){ + return _wilddog_conn_commonSet(data, flag,(Wilddog_Func_T)_wilddog_conn_disSet_callback,TRUE); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disPush(void* data,int flag){ + return _wilddog_conn_commonPush(data,flag,(Wilddog_Func_T)_wilddog_conn_disPush_callback,TRUE); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disRemove(void* data,int flag){ + return _wilddog_conn_commonRemove(data, flag, (Wilddog_Func_T)_wilddog_conn_disRemove_callback,TRUE); +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disCancel(void* data,int flag){ Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; Wilddog_Conn_T *p_conn; Wilddog_Proto_Cmd_Arg_T command; Wilddog_Conn_Pkt_T *pkt; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + if(p_conn->d_conn_user.d_count > WILDDOG_REQ_QUEUE_NUM){ + wilddog_debug_level(WD_DEBUG_WARN, "Too many requests! Max is %d",WILDDOG_REQ_QUEUE_NUM); + return WILDDOG_ERR_QUEUEFULL; + } + + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); + wilddog_assert(pkt, WILDDOG_ERR_NULL); + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ + wfree(pkt); + wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); + return WILDDOG_ERR_NULL; + } + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_disCancel_callback; + pkt->p_user_callback = arg->p_complete; + pkt->p_user_arg = arg->p_completeArg; + + //add to rest queue + LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); + p_conn->d_conn_user.d_count++; + command.p_data = NULL; + command.d_data_len = 0; + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + + if(p_conn->p_protocol->callback){ + BOOL isSend = FALSE;//send to server or not + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + isSend = TRUE; + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_DIS_CANCEL, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send dis cancel pkt 0x%x",(unsigned int)pkt->d_message_id); + } + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_offline(void* data,int flag){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + Wilddog_Proto_Cmd_Arg_T command; + Wilddog_Conn_Pkt_T *pkt; + Wilddog_Return_T ret = WILDDOG_ERR_INVALID; wilddog_assert(data, WILDDOG_ERR_NULL); p_conn = arg->p_repo->p_rp_conn; wilddog_assert(p_conn, WILDDOG_ERR_NULL); + if(p_conn->d_conn_user.d_count > WILDDOG_REQ_QUEUE_NUM){ + wilddog_debug_level(WD_DEBUG_WARN, "Too many requests! Max is %d",WILDDOG_REQ_QUEUE_NUM); + return WILDDOG_ERR_QUEUEFULL; + } + pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); wilddog_assert(pkt, WILDDOG_ERR_NULL); - if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, p_conn)){ + if(WILDDOG_ERR_NOERR != _wilddog_conn_packet_init(pkt, arg->p_url)){ wfree(pkt); wilddog_debug_level(WD_DEBUG_ERROR, "Connect layer packet init failed!"); return WILDDOG_ERR_NULL; } - pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_get_callback; + pkt->p_complete = (Wilddog_Func_T)_wilddog_conn_offline_callback; pkt->p_user_callback = arg->p_complete; pkt->p_user_arg = arg->p_completeArg; //add to rest queue LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); + p_conn->d_conn_user.d_count++; + + command.p_data = NULL; + command.d_data_len = 0; + command.p_message_id= &pkt->d_message_id; + command.p_url = pkt->p_url; + command.protocol = p_conn->p_protocol; + command.p_out_data = (u8**)&pkt->p_data; + command.p_out_data_len = NULL; + + //send pkt must need session info, exclude auth pkt. + command.p_session_info = p_conn->d_session.short_sid; + command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; + + if(p_conn->p_protocol->callback){ + BOOL isSend = FALSE;//send to server or not + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_AUTHED){ + isSend = TRUE; + ++pkt->d_count; + pkt->d_next_send_time = _wilddog_conn_getNextSendTime(pkt->d_count); + } + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_SEND_OFFLINE, &command, isSend); + wilddog_debug_level(WD_DEBUG_LOG, "Send offline pkt 0x%x",(unsigned int)pkt->d_message_id); + } + + return ret; +} +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_online(void* data,int flag){ + Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; + Wilddog_Conn_T *p_conn; + wilddog_assert(data, WILDDOG_ERR_NULL); + + p_conn = arg->p_repo->p_rp_conn; + + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + return _wilddog_conn_auth(data, flag); } STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_trySync(void* data,int flag){ Wilddog_Return_T ret = WILDDOG_ERR_INVALID; + Wilddog_Return_T error_code = WILDDOG_ERR_INVALID; Wilddog_Proto_Cmd_Arg_T command; Wilddog_ConnCmd_Arg_T *arg = (Wilddog_ConnCmd_Arg_T*)data; u32 message_id = 0; @@ -439,62 +1915,82 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_trySync(void* data,int flag){ ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_GETPKT, &command, 0); } if(WILDDOG_ERR_NOERR != ret){ - return ret; + if(WILDDOG_ERR_RECVTIMEOUT == ret){ + goto next; + } + else{ + wilddog_debug_level(WD_DEBUG_WARN,"Received error [%d]",ret); + return ret; + } } + //We have received packet, reset timeout count + p_conn->d_timeout_count = 0; command.p_data = recvPkt; command.d_data_len = recvPkt_len; - //2. try to find the send pkt which has same message id, - //but if we are not authed, only accept auth pkt. + //2. try to find the send pkt which has same message id sendPkt = _wilddog_conn_recv_sendPktFind(p_conn,message_id); if(NULL == sendPkt){ //delete the recvPkt. Remember the recv pkt is in p_data. if(p_conn->p_protocol->callback){ - ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_FREEPKT, &command, 0); + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_FREEPKT, &command, FALSE); } - wilddog_debug_level(WD_DEBUG_WARN, "Received an unmatched packet, mid = 0x%x!",message_id); + wilddog_debug_level(WD_DEBUG_WARN, "Received an unmatched packet, mid = 0x%x!",(unsigned int)message_id); return ret; } + //3. handle packet command.p_out_data = &payload; command.p_out_data_len = &payload_len; command.p_proto_data = &sendPkt->p_proto_data; if(p_conn->p_protocol->callback){ - ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_HANDLEPKT, &command, 0); + error_code = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_HANDLEPKT, &command, 0); } - if(ret > WILDDOG_ERR_NOERR){ + + //if sendPkt want to be freed, it must be freed in callback, because + //we cannot operate the linklist which sendPkt belonged to. + if(error_code >= WILDDOG_ERR_NOERR){ //callback the p_complete if(sendPkt->p_complete){ - (sendPkt->p_complete)(p_conn, sendPkt, payload, payload_len, ret); + ret = (sendPkt->p_complete)(p_conn, sendPkt, payload, payload_len, error_code); } } + sendPkt = NULL; + //Free recvPkt.Remember the recv pkt is in p_data. if(p_conn->p_protocol->callback){ - ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_FREEPKT, &command, 0); + ret = (p_conn->p_protocol->callback)(WD_PROTO_CMD_RECV_FREEPKT, &command, TRUE); } recvPkt = NULL; recvPkt_len = 0; - //4. state machine - - //5. if has retransmit packet, send +next: + //4. retransmit or timeout logic + _wilddog_conn_retransmitHandler(p_conn); + //5. session maintain + if(p_conn->d_session.d_session_status == WILDDOG_SESSION_NOTAUTHED){ + //retry + _wilddog_conn_sessionRetry(p_conn); + } + //ping status + _wilddog_conn_pingHandler(p_conn); return ret; } /* send interface */ Wilddog_Func_T _wilddog_conn_funcTable[WILDDOG_CONN_CMD_MAX + 1] = { (Wilddog_Func_T)_wilddog_conn_get,//get - (Wilddog_Func_T)NULL,//set - (Wilddog_Func_T)NULL,//push - (Wilddog_Func_T)NULL,//remove - (Wilddog_Func_T)NULL,//on - (Wilddog_Func_T)NULL,//off + (Wilddog_Func_T)_wilddog_conn_set,//set + (Wilddog_Func_T)_wilddog_conn_push,//push + (Wilddog_Func_T)_wilddog_conn_remove,//remove + (Wilddog_Func_T)_wilddog_conn_addObserver,//on + (Wilddog_Func_T)_wilddog_conn_removeObserver,//off (Wilddog_Func_T)_wilddog_conn_auth,//auth - (Wilddog_Func_T)NULL,//ondisset - (Wilddog_Func_T)NULL,//ondispush - (Wilddog_Func_T)NULL,//ondisremove - (Wilddog_Func_T)NULL,//ondiscancel - (Wilddog_Func_T)NULL,//offline - (Wilddog_Func_T)NULL,//online + (Wilddog_Func_T)_wilddog_conn_disSet,//ondisset + (Wilddog_Func_T)_wilddog_conn_disPush,//ondispush + (Wilddog_Func_T)_wilddog_conn_disRemove,//ondisremove + (Wilddog_Func_T)_wilddog_conn_disCancel,//ondiscancel + (Wilddog_Func_T)_wilddog_conn_offline,//offline + (Wilddog_Func_T)_wilddog_conn_online,//online (Wilddog_Func_T)_wilddog_conn_trySync,//trysync (Wilddog_Func_T)NULL }; @@ -537,9 +2033,11 @@ Wilddog_Conn_T * WD_SYSTEM _wilddog_conn_init(Wilddog_Repo_T *p_repo) p_conn->p_conn_repo = p_repo; p_conn->f_conn_ioctl = (Wilddog_Func_T)_wilddog_conn_ioctl; - p_conn->d_conn_sys.d_curr_ping_interval = WILDDOG_DEFALUT_PING_INTERVAL; + p_conn->d_conn_sys.d_curr_ping_interval = WILDDOG_DEFAULT_PING_INTERVAL; p_conn->d_conn_sys.d_ping_delta = WILDDOG_DEFAULT_PING_DELTA; - + p_conn->d_session.d_session_status = WILDDOG_SESSION_INIT; + sprintf((char*)p_conn->d_session.short_sid, "00000000"); + sprintf((char*)p_conn->d_session.long_sid, "00000000000000000000000000000000"); //Init protocol layer. p_conn->p_protocol = _wilddog_protocol_init(p_conn); if(NULL == p_conn->p_protocol){ @@ -547,7 +2045,6 @@ Wilddog_Conn_T * WD_SYSTEM _wilddog_conn_init(Wilddog_Repo_T *p_repo) wilddog_debug_level(WD_DEBUG_ERROR, "Init protocol failed!"); return NULL; } - //Init session. if(WILDDOG_ERR_NOERR != _wilddog_conn_sessionInit(p_conn)){ _wilddog_protocol_deInit(p_conn); @@ -555,7 +2052,6 @@ Wilddog_Conn_T * WD_SYSTEM _wilddog_conn_init(Wilddog_Repo_T *p_repo) wilddog_debug_level(WD_DEBUG_ERROR, "Init session failed!"); return NULL; } - return p_conn; } /* @@ -575,7 +2071,7 @@ Wilddog_Return_T WD_SYSTEM _wilddog_conn_deinit(Wilddog_Repo_T *p_repo) p_conn = p_repo->p_rp_conn; wilddog_assert(p_conn, WILDDOG_ERR_NULL); - //TODO: Deinit pkts + //Deinit pkts if(p_conn->d_conn_sys.p_auth){ _wilddog_conn_packet_deInit(p_conn->d_conn_sys.p_auth); wfree(p_conn->d_conn_sys.p_auth); @@ -609,9 +2105,9 @@ Wilddog_Return_T WD_SYSTEM _wilddog_conn_deinit(Wilddog_Repo_T *p_repo) } } p_conn->d_conn_user.p_rest_list = NULL; - //TODO: Deinit session. + //TODO: Deinit session.We don't need deinit, let it timeout.--jimmy - //TODO: Deinit protocol layer. + //Deinit protocol layer. _wilddog_protocol_deInit(p_conn); wfree(p_conn); p_repo->p_rp_conn = NULL; diff --git a/src/wilddog_conn.h b/src/wilddog_conn.h index 838cce6..51c6f69 100644 --- a/src/wilddog_conn.h +++ b/src/wilddog_conn.h @@ -23,166 +23,41 @@ extern "C" #include "wilddog_config.h" #include "wilddog_ct.h" #include "wilddog_protocol.h" -#if 0 -/* protocol package len .*/ -#define PROTOCOL_QUERY_HEADLEN (8) -#define PROTOCOL_PATH_HEADLEN (8) - -typedef enum WILDDOG_CONN_CMD_TYPE -{ - WILDDOG_CONN_CMD_GET, - WILDDOG_CONN_CMD_SET, - WILDDOG_CONN_CMD_PUSH, - WILDDOG_CONN_CMD_REMOVE, - WILDDOG_CONN_CMD_ON, - WILDDOG_CONN_CMD_OFF, - WILDDOG_CONN_CMD_AUTH, - - WILDDOG_CONN_CMD_ONDISSET, - WILDDOG_CONN_CMD_ONDISPUSH, - WILDDOG_CONN_CMD_ONDISREMOVE, - - WILDDOG_CONN_CMD_CANCELDIS, - - WILDDOG_CONN_CMD_OFFLINE, - WILDDOG_CONN_CMD_ONLINE, - WILDDOG_CONN_CMD_TRYSYNC, - - WILDDOG_CONN_CMD_INIT, - WILDDOG_CONN_CMD_DEINIT, - - WILDDOG_CONN_CMD_MAX -}Wilddog_Conn_Cmd_T; -typedef enum WILDDOG_CONN_CBCMD_TYPE -{ - WILDDOG_CONN_CBCMD_GET, - WILDDOG_CONN_CBCMD_SET, - WILDDOG_CONN_CBCMD_PUSH, - WILDDOG_CONN_CBCMD_REMOVE, - WILDDOG_CONN_CBCMD_ON, - WILDDOG_CONN_CBCMD_OFF, - WILDDOG_CONN_CBCMD_AUTH, - - WILDDOG_CONN_CBCMD_ONDISSET, - WILDDOG_CONN_CBCMD_ONDISPUSH, - WILDDOG_CONN_CBCMD_ONDISREMOVE, - - WILDDOG_CONN_CBCMD_CANCELDIS, - WILDDOG_CONN_CBCMD_ONLINE, - WILDDOG_CONN_CBCMD_OFFLINE, - - WILDDOG_CONN_CBCMD_MAX -}Wilddog_Conn_CBCmd_T; - -typedef struct WILDDOG_CONN_T -{ - Wilddog_Repo_T *p_conn_repo; - Wilddog_Cm_List_T *p_cm_l; - Wilddog_Func_T f_conn_ioctl; -}Wilddog_Conn_T; - - -typedef struct WILDDOG_CONN_CMD_ARG -{ - - Wilddog_Repo_T *p_repo; - Wilddog_Url_T * p_url; - Wilddog_Node_T * p_data; - Wilddog_Func_T p_complete; - void* p_completeArg; -}Wilddog_ConnCmd_Arg_T; - -/* protocol peripheral interface.*/ -typedef enum PROTOCOL_CMD_T{ - _PROTOCOL_CMD_INIT, - _PROTOCOL_CMD_DEINIT, - - _PROTOCOL_CMD_COUNTSIZE, - _PROTOCOL_CMD_CREAT, - _PROTOCOL_CMD_DESTORY, - _PROTOCOL_CMD_ADD_HOST, - _PROTOCOL_CMD_ADD_PATH, - _PROTOCOL_CMD_ADD_QUERY, - _PROTOCOL_CMD_ADD_OBSERVER, - _PROTOCOL_CMD_ADD_DATA, - - _PROTOCOL_CMD_AUTHUPDATA, - _PROTOCOL_CMD_SEND, - _PROTOCOL_CMD_RECV, - _PROTOCOL_CMD_MODIFY_MIDTOKEN, - _PROTOCOL_CMD_MAX -}Protocol_cmd_t; -typedef struct PROTOCOL_ARG_INIT_T{ - Wilddog_Str_T *p_host; - Wilddog_Func_T f_handleRespond; - u16 d_port; -}Protocol_Arg_Init_T; - -typedef struct PROTOCOL_ARG_CREAT_T{ - u8 cmd; - u16 d_index; - u16 d_packageLen; - u32 d_token; -}Protocol_Arg_Creat_T; - -typedef struct PROTOCOL_ARG_OPTION_T{ - void *p_pkg; - void *p_options; -}Protocol_Arg_Option_T; - -typedef struct PROTOCOL_ARG_PAYLOADA_T{ - void *p_pkg; - void *p_payload; - u32 d_payloadLen; -}Protocol_Arg_Payload_T; - -typedef struct PROTOCOL_ARG_COUNTSIZE_T{ - u8 *p_host; - u8 *p_path; - u8 *p_query; - - u32 d_payloadLen; - u32 d_extendLen; -}Protocol_Arg_CountSize_T; - -typedef struct PROTOCOL_ARG_SEND_T{ - u8 cmd; - Wilddog_Url_T *p_url; - - u32 d_token; - u32 d_payloadlen; - u8 *p_payload; - void *p_user_arg; - - u16 d_messageid; -}Protocol_Arg_Send_T; - - -typedef struct PROTOCOL_ARG_AUTHARG_T{ - void *p_pkg; - u8 *p_newAuth; - int d_newAuthLen; -}Protocol_Arg_Auth_T; -typedef struct WILDDOG_CM_FINDNODE_ARG_T -{ - Wilddog_CM_Node_T *p_node_hd; - u8 *path; -}Wilddog_CM_FindNode_Arg_T; - -/* protocol application function */ -extern size_t WD_SYSTEM _wilddog_protocol_ioctl - ( - Protocol_cmd_t cmd, - void *p_args, - int flags - ); -#else #define WILDDOG_CONN_SESSION_SHORT_LEN (8 + 1) #define WILDDOG_CONN_SESSION_LONG_LEN (32 + 1) + +#define WILDDOG_CONN_PKT_FLAG_NEVERTIMEOUT (0x01)//this flag mean packet never timeout. + +/* + Session State machine: + + ----bad request----- ------------------retry---------------- + | | | | + \|/ | \|/ | + ------ --------- ----------- + |Init|----init---->|Authing|-----timeout/unknown err---->|NotAuthed| + ------ --------- ----------- + /|\ | /|\ /|\ + | | | | + | 200 OK Auth | + | | | | + | \|/ | | + | -------- | + ---goOffline-----|Authed|------------unauthed err------------ + -------- + Policy: + 1. Init/NotAuthed/Authing: only can send auth packet,other packets must + be stored but do not send out.During this time, ping pacet will not be + generated. When stored packets time out, trigger timeout function. + 2. Authed: Can send any type of packets, and will generate ping packet. + 3. Authing->Authed: All stored packets will be send right now. + 4. Authed->Authing/NotAuthed: the same as 1. +*/ typedef enum WILDDOG_SESSION_STATE{ - WILDDOG_SESSION_NOTAUTHED = 0, + WILDDOG_SESSION_INIT = 0, + WILDDOG_SESSION_NOTAUTHED, WILDDOG_SESSION_AUTHING, WILDDOG_SESSION_AUTHED }Wilddog_Session_State; @@ -209,6 +84,10 @@ typedef enum WILDDOG_CONN_CMD_TYPE WILDDOG_CONN_CMD_MAX }Wilddog_Conn_Cmd_T; +typedef enum{ + WILDDOG_PING_TYPE_SHORT = 0, + WILDDOG_PING_TYPE_LONG +}Wilddog_Ping_Type_T; typedef struct WILDDOG_CONN_CMD_ARG { @@ -229,6 +108,8 @@ typedef struct WILDDOG_CONN_PKT_T{ int d_count; u32 d_message_id; u32 d_next_send_time; + u32 d_register_time; + u32 d_flag; Wilddog_Url_T *p_url; Wilddog_Func_T p_complete;//pkt matched function Wilddog_Func_T p_user_callback; @@ -241,25 +122,32 @@ typedef struct WILDDOG_CONN_SYS_T{ struct WILDDOG_CONN_T *p_conn; int d_curr_ping_interval; int d_ping_delta; + int d_auth_fail_count; + u32 d_offline_time; + int d_online_retry_count; + Wilddog_Ping_Type_T d_ping_type; + u32 d_ping_next_send_time; Wilddog_Conn_Pkt_T *p_ping; Wilddog_Conn_Pkt_T *p_auth; }Wilddog_Conn_Sys_T; typedef struct WILDDOG_CONN_USER_T{ struct WILDDOG_CONN_T *p_conn; + int d_count; Wilddog_Conn_Pkt_T *p_observer_list; Wilddog_Conn_Pkt_T *p_rest_list; }Wilddog_Conn_User_T; typedef struct WILDDOG_SESSION_T{ Wilddog_Session_State d_session_status; - char short_sid[WILDDOG_CONN_SESSION_SHORT_LEN]; - char long_sid[WILDDOG_CONN_SESSION_LONG_LEN]; + u8 short_sid[WILDDOG_CONN_SESSION_SHORT_LEN]; + u8 long_sid[WILDDOG_CONN_SESSION_LONG_LEN]; }Wilddog_Session_T; typedef struct WILDDOG_CONN_T { Wilddog_Repo_T *p_conn_repo; + u32 d_timeout_count; Wilddog_Session_T d_session; Wilddog_Conn_Sys_T d_conn_sys; Wilddog_Conn_User_T d_conn_user; @@ -267,7 +155,6 @@ typedef struct WILDDOG_CONN_T Wilddog_Func_T f_conn_ioctl; }Wilddog_Conn_T; -#endif /*implemented interface.*/ extern Wilddog_Conn_T* _wilddog_conn_init(Wilddog_Repo_T* p_repo); extern Wilddog_Return_T _wilddog_conn_deinit(Wilddog_Repo_T*p_repo); diff --git a/src/wilddog_ct.c b/src/wilddog_ct.c index f87c935..d923661 100644 --- a/src/wilddog_ct.c +++ b/src/wilddog_ct.c @@ -1258,6 +1258,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_ct_conn_sync Wilddog_Repo_T** p_head = _wilddog_ct_getRepoHead(); Wilddog_Repo_T* p_curr, *p_tmp; Wilddog_Conn_T * p_conn; + int total=0,offline=0; #ifdef WILDDOG_FORCE_OFFLINE if(TRUE == _wilddog_ct_getOfflineForced()){ return WILDDOG_ERR_CLIENTOFFLINE; @@ -1277,6 +1278,21 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_ct_conn_sync cmd.p_repo = p_curr; (p_conn->f_conn_ioctl)(WILDDOG_CONN_CMD_TRYSYNC, &cmd, 0); _wilddog_syncTime(); + total++; + if(0 != p_conn->d_conn_sys.d_offline_time){ + offline++; + } + } + } + if(total == offline){ + //all repo offline, then we offline + if(TRUE == _wilddog_ct_getOnlineStatus()){ + _wilddog_ct_setOnlineStatus(FALSE); + } + }else{ + //online + if(FALSE == _wilddog_ct_getOnlineStatus()){ + _wilddog_ct_setOnlineStatus(TRUE); } } return WILDDOG_ERR_NOERR; diff --git a/src/wilddog_event.c b/src/wilddog_event.c index feea747..db04a36 100644 --- a/src/wilddog_event.c +++ b/src/wilddog_event.c @@ -74,6 +74,7 @@ STATIC void WD_SYSTEM _wilddog_event_nodeFree Wilddog_EventNode_T *node ) { + wilddog_debug_level(WD_DEBUG_LOG,"_wilddog_event_nodeFree %s",node->p_url->p_url_path); _wilddog_url_freeParsedUrl(node->p_url); wfree(node); } @@ -604,8 +605,8 @@ Wilddog_Return_T WD_SYSTEM _wilddog_event_nodeDelete err = p_conn->f_conn_ioctl(WILDDOG_CONN_CMD_OFF, arg, 0); } - wilddog_debug_level(WD_DEBUG_LOG, "nodedelete off node path:%s\n", \ - arg->p_url->p_url_path); + wilddog_debug_level(WD_DEBUG_LOG, "Remove observer node path:%s, error code [%d]", \ + arg->p_url->p_url_path,err); /*if this node is to be closed, but it's son or grandson want's on, then *on them. diff --git a/src/wilddog_protocol.h b/src/wilddog_protocol.h index cba10e8..08d5d64 100644 --- a/src/wilddog_protocol.h +++ b/src/wilddog_protocol.h @@ -22,6 +22,7 @@ typedef struct WILDDOG_PROTOCOL_T{ Wilddog_Str_T *host; int socketFd; Wilddog_Address_T addr; + void *user_data; Wilddog_Func_T callback; _wilddog_Proto_Recv_T recv_buf[WILDDOG_PROTO_RECV_BUF_NUM]; }Wilddog_Protocol_T; @@ -29,6 +30,8 @@ typedef struct WILDDOG_PROTO_CMD_ARG_T{ Wilddog_Protocol_T* protocol; u8 *p_data;//input u32 d_data_len; + u8* p_session_info; + u32 d_session_len; Wilddog_Url_T * p_url; u32 * p_message_id;//we assume message id in u32 u8 **p_out_data;//output @@ -37,22 +40,24 @@ typedef struct WILDDOG_PROTO_CMD_ARG_T{ }Wilddog_Proto_Cmd_Arg_T; typedef enum WILDDOG_PROTO_CMD_T{ WD_PROTO_CMD_SEND_SESSION_INIT = 0, - WD_PROTO_CMD_SEND_SESSION_PING, - WD_PROTO_CMD_SEND_GET, - WD_PROTO_CMD_SEND_SET, - WD_PROTO_CMD_SEND_PUSH, - WD_PROTO_CMD_SEND_REMOVE, - WD_PROTO_CMD_SEND_ON, - WD_PROTO_CMD_SEND_OFF, - WD_PROTO_CMD_SEND_DIS_SET, - WD_PROTO_CMD_SEND_DIS_PUSH, - WD_PROTO_CMD_SEND_DIS_REMOVE, - WD_PROTO_CMD_SEND_DIS_CANCEL, - WD_PROTO_CMD_SEND_ONLINE, - WD_PROTO_CMD_SEND_OFFLINE, - WD_PROTO_CMD_RECV_GETPKT, - WD_PROTO_CMD_RECV_FREEPKT, - WD_PROTO_CMD_RECV_HANDLEPKT, + WD_PROTO_CMD_SEND_RECONNECT,// 1 + WD_PROTO_CMD_SEND_PING,// 2 + WD_PROTO_CMD_SEND_RETRANSMIT,// 3 + WD_PROTO_CMD_SEND_GET, // 4 + WD_PROTO_CMD_SEND_SET,// 5 + WD_PROTO_CMD_SEND_PUSH,// 6 + WD_PROTO_CMD_SEND_REMOVE,// 7 + WD_PROTO_CMD_SEND_ON,// 8 + WD_PROTO_CMD_SEND_OFF,// 9 + WD_PROTO_CMD_SEND_DIS_SET, // 10 + WD_PROTO_CMD_SEND_DIS_PUSH,// 11 + WD_PROTO_CMD_SEND_DIS_REMOVE,// 12 + WD_PROTO_CMD_SEND_DIS_CANCEL,// 13 + WD_PROTO_CMD_SEND_ONLINE,// 14 + WD_PROTO_CMD_SEND_OFFLINE,// 15 + WD_PROTO_CMD_RECV_GETPKT,// 16 + WD_PROTO_CMD_RECV_FREEPKT,// 17 + WD_PROTO_CMD_RECV_HANDLEPKT,// 18 WD_PROTO_CMD_MAX }Wilddog_Proto_Cmd_T; extern Wilddog_Protocol_T * _wilddog_protocol_init(void *p_conn); diff --git a/src/wilddog_sec_host.c b/src/wilddog_sec_host.c index e47753a..5174895 100644 --- a/src/wilddog_sec_host.c +++ b/src/wilddog_sec_host.c @@ -123,6 +123,7 @@ int WD_SYSTEM _wilddog_sec_getHost p_remoteAddr->len = l_defaultAddr_t[i].len; memcpy(p_remoteAddr->ip, l_defaultAddr_t[i].ip,l_defaultAddr_t[i].len); res = 0; + wilddog_debug_level(WD_DEBUG_WARN, "Cannot get DNS, use default IP."); } #undef WILDDOG_COAP_LOCAL_HOST diff --git a/src/wilddog_store.c b/src/wilddog_store.c index d55946d..908e518 100644 --- a/src/wilddog_store.c +++ b/src/wilddog_store.c @@ -45,10 +45,8 @@ Wilddog_Store_T * WD_SYSTEM _wilddog_store_init(Wilddog_Repo_T* p_repo) wilddog_assert(p_repo, NULL); p_store = (Wilddog_Store_T *)wmalloc(sizeof(Wilddog_Store_T)); - if(NULL == p_store) - { - return NULL; - } + wilddog_assert(p_store, NULL); + p_store->p_se_auth = (Wilddog_Store_Auth_T *)wmalloc( \ sizeof(Wilddog_Store_Auth_T)); if(NULL == p_store->p_se_auth) @@ -83,9 +81,12 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_store_setAuth Wilddog_Conn_T *p_conn = p_store->p_se_repo->p_rp_conn; Wilddog_ConnCmd_Arg_T connCmd; - if(p_authArg->d_len > WILDDOG_AUTH_LEN) + if(p_authArg->d_len > WILDDOG_AUTH_LEN){ + wilddog_debug_level(WD_DEBUG_ERROR, \ + "Auth data length is %d, more than Max size %d",p_authArg->d_len,WILDDOG_AUTH_LEN); + return WILDDOG_ERR_INVALID; - + } memset(p_store->p_se_auth->p_auth, 0, WILDDOG_AUTH_LEN); if(!p_authArg->p_data) diff --git a/src/wilddog_url_parser.c b/src/wilddog_url_parser.c index e1091a1..d94da68 100644 --- a/src/wilddog_url_parser.c +++ b/src/wilddog_url_parser.c @@ -580,7 +580,7 @@ void WD_SYSTEM _wilddog_url_freeParsedUrl(Wilddog_Url_T * p_url) * Input: p_src: Source url. * p_dst: Destination url. * Output: N/A - * Return: Same return TRUE, others return FALSE. + * Return: diff return TRUE, others return FALSE. */ BOOL WD_SYSTEM _wilddog_url_diff ( diff --git a/tests/linux/test_limit.c b/tests/linux/test_limit.c index 12bd277..ff584ba 100644 --- a/tests/linux/test_limit.c +++ b/tests/linux/test_limit.c @@ -1635,41 +1635,41 @@ int test_node_find() struct test_reult_t test_results[] = { - {"wilddog_initWithUrl", test_new, 0}, - {"wilddog_destroy", test_destroy, 0}, - {"wilddog_auth", test_auth, 0}, - {"wilddog_getParent", test_getParent, 0}, - {"wilddog_getRoot", test_getRoot, 0}, - {"wilddog_getChild", test_getChild, 0}, - {"wilddog_getKey", test_getKey, 0}, - {"wilddog_getHost", test_getHost, 0}, - {"wilddog_getPath", test_getPath, 0}, - {"wilddog_goOnline", test_goOnline, 0}, - {"wilddog_goOffline", test_goOffline, 0}, - {"wilddog_getValue", test_query, 0}, - {"wilddog_setValue", test_set, 0}, - {"wilddog_push", test_push, 0}, - {"wilddog_removeValue", test_remove, 0}, - {"wilddog_addObserver", test_on, 0}, - {"wilddog_removeObserver", test_off, 0}, - {"wilddog_onDisconnectSetValue", test_disconn_set, 0}, - {"wilddog_onDisconnectPush", test_disconn_push, 0}, - {"wilddog_onDisconnectRemoveValue", test_disconn_rmv, 0}, - {"wilddog_cancelDisconnectOperations", test_disconn_cancel, 0}, - {"wilddog_node_createObject", test_node_createObj, 0}, - {"wilddog_node_createUString", test_node_createUstr, 0}, - {"wilddog_node_createBString", test_node_createBstr, 0}, - {"wilddog_node_createFloat", test_node_createFloat, 0}, - {"wilddog_node_createNum", test_node_createNum, 0}, - {"wilddog_node_createNull", test_node_createNull, 0}, - {"wilddog_node_createTrue", test_node_createTrue, 0}, - {"wilddog_node_createFalse", test_node_createFalse, 0}, - {"wilddog_node_getValue", test_node_getValue, 0}, - {"wilddog_node_setValue", test_node_setValue, 0}, - {"wilddog_node_addChild", test_node_addChild, 0}, - {"wilddog_node_delete", test_node_delete, 0}, - {"wilddog_node_clone", test_node_clone, 0}, - {"wilddog_node_find", test_node_find, 0}, + {"wilddog_initWithUrl", (Wilddog_Func_T)test_new, 0}, + {"wilddog_destroy", (Wilddog_Func_T)test_destroy, 0}, + {"wilddog_auth", (Wilddog_Func_T)test_auth, 0}, + {"wilddog_getParent", (Wilddog_Func_T)test_getParent, 0}, + {"wilddog_getRoot", (Wilddog_Func_T)test_getRoot, 0}, + {"wilddog_getChild", (Wilddog_Func_T)test_getChild, 0}, + {"wilddog_getKey", (Wilddog_Func_T)test_getKey, 0}, + {"wilddog_getHost", (Wilddog_Func_T)test_getHost, 0}, + {"wilddog_getPath", (Wilddog_Func_T)test_getPath, 0}, + {"wilddog_goOnline", (Wilddog_Func_T)test_goOnline, 0}, + {"wilddog_goOffline", (Wilddog_Func_T)test_goOffline, 0}, + {"wilddog_getValue", (Wilddog_Func_T)test_query, 0}, + {"wilddog_setValue", (Wilddog_Func_T)test_set, 0}, + {"wilddog_push", (Wilddog_Func_T)test_push, 0}, + {"wilddog_removeValue", (Wilddog_Func_T)test_remove, 0}, + {"wilddog_addObserver", (Wilddog_Func_T)test_on, 0}, + {"wilddog_removeObserver", (Wilddog_Func_T)test_off, 0}, + {"wilddog_onDisconnectSetValue", (Wilddog_Func_T)test_disconn_set, 0}, + {"wilddog_onDisconnectPush", (Wilddog_Func_T)test_disconn_push, 0}, + {"wilddog_onDisconnectRemoveValue", (Wilddog_Func_T)test_disconn_rmv, 0}, + {"wilddog_cancelDisconnectOperations", (Wilddog_Func_T)test_disconn_cancel, 0}, + {"wilddog_node_createObject", (Wilddog_Func_T)test_node_createObj, 0}, + {"wilddog_node_createUString", (Wilddog_Func_T)test_node_createUstr, 0}, + {"wilddog_node_createBString", (Wilddog_Func_T)test_node_createBstr, 0}, + {"wilddog_node_createFloat", (Wilddog_Func_T)test_node_createFloat, 0}, + {"wilddog_node_createNum", (Wilddog_Func_T)test_node_createNum, 0}, + {"wilddog_node_createNull", (Wilddog_Func_T)test_node_createNull, 0}, + {"wilddog_node_createTrue", (Wilddog_Func_T)test_node_createTrue, 0}, + {"wilddog_node_createFalse", (Wilddog_Func_T)test_node_createFalse, 0}, + {"wilddog_node_getValue", (Wilddog_Func_T)test_node_getValue, 0}, + {"wilddog_node_setValue", (Wilddog_Func_T)test_node_setValue, 0}, + {"wilddog_node_addChild", (Wilddog_Func_T)test_node_addChild, 0}, + {"wilddog_node_delete", (Wilddog_Func_T)test_node_delete, 0}, + {"wilddog_node_clone", (Wilddog_Func_T)test_node_clone, 0}, + {"wilddog_node_find", (Wilddog_Func_T)test_node_find, 0}, {NULL, NULL, -1}, }; diff --git a/tests/linux/test_multipleHost.c b/tests/linux/test_multipleHost.c index c5f63ea..aa82caa 100644 --- a/tests/linux/test_multipleHost.c +++ b/tests/linux/test_multipleHost.c @@ -329,6 +329,9 @@ int main(void) multipletest_request(MULTIPLETEST_CMD_ON,client2,&multipleClient[1]); multipletest_request(MULTIPLETEST_CMD_ON,client3,&multipleClient[2]); multiple_trysync(); + wilddog_removeObserver(client1,WD_ET_VALUECHANGE); + wilddog_removeObserver(client2,WD_ET_VALUECHANGE); + wilddog_removeObserver(client3,WD_ET_VALUECHANGE); /*PUSH */ printf("\ntest push \n"); diff --git a/tests/linux/test_stab_cycle.c b/tests/linux/test_stab_cycle.c index 8acdf71..4b4f011 100644 --- a/tests/linux/test_stab_cycle.c +++ b/tests/linux/test_stab_cycle.c @@ -339,9 +339,9 @@ void stab_test_cycle(void) int main(void) { - stab_test_cycle(); - return 0; + return 0; + wilddog_debug();//just avoid warning. } #endif /* WILDDOG_SELFTEST*/ diff --git a/tests/linux/test_step.c b/tests/linux/test_step.c index 087cb0c..2bc7124 100644 --- a/tests/linux/test_step.c +++ b/tests/linux/test_step.c @@ -62,7 +62,6 @@ STATIC void test_step_deleteFunc(void* arg, Wilddog_Return_T err) STATIC void test_step_setFunc(void* arg, Wilddog_Return_T err) { - *(BOOL*)arg = TRUE; printf("\t set err =%d \n",err); l_step.res_setValueSuccess = TRUE; @@ -74,7 +73,6 @@ STATIC void test_step_getFunc( void* arg, Wilddog_Return_T err) { - *(BOOL*)arg = TRUE; printf("\t get err =%d \n",err); l_step.res_getValueSuccess = TRUE; @@ -86,7 +84,6 @@ STATIC void test_step_getObserverFunc( void* arg, Wilddog_Return_T err) { - *(BOOL*)arg = TRUE; printf("\t res_addObserverSuccess err =%d \n",err); l_step.res_addObserverSuccess = TRUE; @@ -177,7 +174,6 @@ int main(void) Wilddog_Node_T *L4c1 = NULL,*L4c2 = NULL, *L4c3 = NULL,*L4c4 = NULL,*L4c5 = NULL; - memset(host,0,sizeof(host)); test_gethost(host,TEST_URL); printf(" \t host %s \n",host); @@ -323,7 +319,6 @@ int main(void) wilddog_trySync(); } - isFinished = FALSE; wilddog_addObserver(wilddog, WD_ET_VALUECHANGE, test_step_getObserverFunc, \ (void*)&isFinished); @@ -344,5 +339,6 @@ int main(void) test_step_printf(); return test_step_res(); + wilddog_debug("");//just avoid warning } From 6445940ac54df324a8822a15b10d1f20adaf7699 Mon Sep 17 00:00:00 2001 From: itolfh Date: Tue, 7 Feb 2017 15:52:30 +0800 Subject: [PATCH 04/22] change gcc from -g to -O2 --- project/linux/env.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/project/linux/env.mk b/project/linux/env.mk index a8b10f9..a135e01 100644 --- a/project/linux/env.mk +++ b/project/linux/env.mk @@ -15,7 +15,7 @@ else QUIET = @ MAKE += --no-print-directory endif -CFLAGS+=-Wall -g +CFLAGS+=-Wall -O2 ifeq ($(APP_SEC_TYPE), tinydtls) CFLAGS += -pthread From 1608adc2ab39559184eb711de9475288519940e6 Mon Sep 17 00:00:00 2001 From: itolfh Date: Wed, 8 Feb 2017 10:21:29 +0800 Subject: [PATCH 05/22] end with new line --- src/wilddog_api.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/wilddog_api.c b/src/wilddog_api.c index 289a694..fc71d21 100644 --- a/src/wilddog_api.c +++ b/src/wilddog_api.c @@ -593,4 +593,4 @@ Wilddog_Return_T wilddog_goOnline(void) { wilddog_debug_level(WD_DEBUG_LOG, "Go online has been called!"); return (Wilddog_Return_T)_wilddog_ct_ioctl(WILDDOG_APICMD_GOONLINE, NULL,0); -} \ No newline at end of file +} From 915196d62feb6aed57f1ee2599aa8b034d529c9f Mon Sep 17 00:00:00 2001 From: itolfh Date: Wed, 8 Feb 2017 16:38:42 +0800 Subject: [PATCH 06/22] update changelog --- CHANGELOG | 7 +++++++ src/wilddog_conn.h | 4 ++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 2a18567..54d8cdb 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,10 @@ +1.1.2 鏈彂甯 +浼樺寲锛 +浼樺寲浠ｇ爜閫昏緫锛岄噸鏋勮繛鎺ュ眰浠ｇ爜銆 + +宸茬煡闂锛 +鍙拡瀵筶inux骞冲彴娴嬭瘯锛屾湭娴嬭瘯鍏朵粬骞冲彴銆 + 1.1.1 2016.12.31 淇锛 淇鍐嶆鍦ㄧ嚎鍚庯紝鍘熷厛宸茶闃呮垚鍔熺殑浜嬩欢琚垹闄ょ殑bug銆 diff --git a/src/wilddog_conn.h b/src/wilddog_conn.h index 51c6f69..773aa46 100644 --- a/src/wilddog_conn.h +++ b/src/wilddog_conn.h @@ -49,9 +49,9 @@ extern "C" -------- Policy: 1. Init/NotAuthed/Authing: only can send auth packet,other packets must - be stored but do not send out.During this time, ping pacet will not be + be stored but do not send out.During this time, ping packet will not be generated. When stored packets time out, trigger timeout function. - 2. Authed: Can send any type of packets, and will generate ping packet. + 2. Authed: We can send any type of packets, and will generate ping packet. 3. Authing->Authed: All stored packets will be send right now. 4. Authed->Authing/NotAuthed: the same as 1. */ From cb5ff08e46ab0da909acd34ab7a0dd8bbb3c35a3 Mon Sep 17 00:00:00 2001 From: itolfh Date: Wed, 8 Feb 2017 17:37:08 +0800 Subject: [PATCH 07/22] fix removeObserver bug --- src/wilddog_event.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/wilddog_event.c b/src/wilddog_event.c index db04a36..b59b009 100644 --- a/src/wilddog_event.c +++ b/src/wilddog_event.c @@ -242,6 +242,7 @@ void WD_SYSTEM _wilddog_event_trigger ) { Wilddog_EventNode_T *enode = NULL; + Wilddog_EventNode_T *enode_next = NULL; Wilddog_Repo_T *repo; Wilddog_Node_T *obj_node = NULL, *obj_node_prev = NULL; Wilddog_Node_T *obj_node_next = NULL; @@ -265,6 +266,7 @@ void WD_SYSTEM _wilddog_event_trigger while(enode) { u8 pathContainResult = 0; + enode_next = enode->next; flag = 0; p_str = NULL; pathContainResult = _wilddog_event_pathContain( \ @@ -317,7 +319,7 @@ void WD_SYSTEM _wilddog_event_trigger wilddog_node_delete(obj_node); } - enode = enode->next; + enode = enode_next; } /*delete observer node.while receive error */ From 54914ea5a1e0d63e3cb12dc35272b80efb17499a Mon Sep 17 00:00:00 2001 From: itolfh Date: Tue, 14 Feb 2017 15:36:12 +0800 Subject: [PATCH 08/22] fix event assert fail bug, add tests --- include/wilddog.h | 2 +- src/wilddog_conn.c | 47 ++++++-- src/wilddog_event.c | 15 ++- tests/linux/test_disEvent.c | 16 ++- tests/linux/test_reobserver.c | 217 +++++++++++++++------------------- 5 files changed, 157 insertions(+), 140 deletions(-) diff --git a/include/wilddog.h b/include/wilddog.h index de97699..d2f3483 100644 --- a/include/wilddog.h +++ b/include/wilddog.h @@ -76,7 +76,7 @@ typedef signed long s32 ; #endif #ifdef WILDDOG_DEBUG -#define DEBUG_LEVEL WD_DEBUG_LOG +#define DEBUG_LEVEL WD_DEBUG_ERROR STATIC const char *s_debug[] = { "[ ALL ]", diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index 28d1189..9410497 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -38,7 +38,7 @@ #define WILDDOG_RETRANSMIT_DEFAULT_INTERVAL (1)//默认的数据包重传间隔,s #define WILDDOG_SESSION_OFFLINE_TIMES (3)//session 建立失败多少次后，认为离线 -#define WILDDOG_SESSION_MAX_RETRY_TIME_INTERVAL (150)//session max retry time interval +#define WILDDOG_SESSION_MAX_RETRY_TIME_INTERVAL (150)//最大离线重试间隔 #define WILDDOG_SMART_PING #ifdef WILDDOG_SMART_PING @@ -125,9 +125,16 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_ping_callback } case WILDDOG_HTTP_UNAUTHORIZED: { - //interval -= delta, delta /= 2, send long token right now. - p_conn->d_conn_sys.d_curr_ping_interval -= p_conn->d_conn_sys.d_ping_delta; - p_conn->d_conn_sys.d_ping_delta /= 2; + //delta = 0,means it was stable, but now env changed. + if(0 == p_conn->d_conn_sys.d_ping_delta){ + p_conn->d_conn_sys.d_ping_delta = WILDDOG_DEFAULT_PING_DELTA; + p_conn->d_conn_sys.d_curr_ping_interval = WILDDOG_DEFAULT_PING_INTERVAL; + } + else{ + //interval -= delta, delta /= 2, send long token right now. + p_conn->d_conn_sys.d_curr_ping_interval -= p_conn->d_conn_sys.d_ping_delta; + p_conn->d_conn_sys.d_ping_delta /= 2; + } p_conn->d_conn_sys.d_ping_type = WILDDOG_PING_TYPE_LONG; p_conn->d_conn_sys.d_ping_next_send_time = _wilddog_getTime(); ret = WILDDOG_ERR_NOERR; @@ -200,6 +207,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_get_callback }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + return WILDDOG_ERR_IGNORE; }else{ wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); } @@ -247,6 +255,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_set_callback ret = WILDDOG_ERR_NOERR; }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + return WILDDOG_ERR_IGNORE; }else{ wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); } @@ -291,6 +300,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_push_callback ret = WILDDOG_ERR_NOERR; }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + return WILDDOG_ERR_IGNORE; }else{ wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); } @@ -342,7 +352,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_remove_callback { //need reauth, this happened only when server lost our session. p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; - break; + return WILDDOG_ERR_IGNORE; } case WILDDOG_HTTP_INTERNAL_SERVER_ERR: { @@ -442,6 +452,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_addObserver_callback }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + return WILDDOG_ERR_IGNORE; }else{ wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); } @@ -493,6 +504,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_removeObserver_callback ret = WILDDOG_ERR_NOERR; }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + return WILDDOG_ERR_IGNORE; }else{ wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); } @@ -534,6 +546,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_disCommon_callback ret = WILDDOG_ERR_NOERR; }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + return WILDDOG_ERR_IGNORE; }else{ wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); } @@ -634,6 +647,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_offline_callback ret = WILDDOG_ERR_NOERR; }else if(WILDDOG_HTTP_UNAUTHORIZED == error_code){ p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + return WILDDOG_ERR_IGNORE; }else{ wilddog_debug_level(WD_DEBUG_WARN, "Get an error [%d].",(int)error_code); } @@ -1233,7 +1247,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_commonSet(void* data,int flag, W #if (DEBUG_LEVEL)<=(WD_DEBUG_LOG) { int i; - wilddog_debug_level(WD_DEBUG_LOG,"Send data is:\n"); + wilddog_debug_level(WD_DEBUG_LOG,"Send data is:"); for(i = 0; i < payload->d_dt_len;i++){ printf("%02x ", *(u8*)(payload->p_dt_data + i)); } @@ -1314,8 +1328,27 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_commonPush(void* data,int flag, LL_APPEND(p_conn->d_conn_user.p_rest_list,pkt); p_conn->d_conn_user.d_count++; - if(arg->p_data) + if(arg->p_data){ +#if (DEBUG_LEVEL)<=(WD_DEBUG_LOG) + if(arg->p_url->p_url_path) + wilddog_debug_level(WD_DEBUG_LOG,"Print data want push: \npath %s", \ + arg->p_url->p_url_path); + wilddog_debug_printnode(arg->p_data); + printf("\n"); +#endif payload = _wilddog_node2Payload(arg->p_data); +#if (DEBUG_LEVEL)<=(WD_DEBUG_LOG) + { + int i; + wilddog_debug_level(WD_DEBUG_LOG,"Send data is:"); + for(i = 0; i < payload->d_dt_len;i++){ + printf("%02x ", *(u8*)(payload->p_dt_data + i)); + } + printf("\n"); + } +#endif + } + //send to server command.p_data = NULL; command.d_data_len = 0; diff --git a/src/wilddog_event.c b/src/wilddog_event.c index b59b009..d6d12c6 100644 --- a/src/wilddog_event.c +++ b/src/wilddog_event.c @@ -277,7 +277,6 @@ void WD_SYSTEM _wilddog_event_trigger (pathContainResult == WD_EVENT_PATHCONTAIN_SED)) { /* if could not find the node, new a null node.*/ - p_str = (Wilddog_Str_T *)_wilddog_event_pathRelative( \ (char*)((Wilddog_Url_T *)arg)->p_url_path, \ (char *)enode->p_url->p_url_path); @@ -291,7 +290,6 @@ void WD_SYSTEM _wilddog_event_trigger obj_node = wilddog_node_createNull(NULL); } /* store the prev and next, make the temp node as the head*/ - if(obj_node->p_wn_prev != NULL) { obj_node_prev = obj_node->p_wn_prev; @@ -322,8 +320,8 @@ void WD_SYSTEM _wilddog_event_trigger enode = enode_next; } /*delete observer node.while receive error */ - - _wilddog_event_errHandle(&repo->p_rp_store->p_se_event->p_head); + if(repo->p_rp_store->p_se_event->p_head) + _wilddog_event_errHandle(&repo->p_rp_store->p_se_event->p_head); } @@ -397,7 +395,7 @@ Wilddog_Return_T WD_SYSTEM _wilddog_event_nodeAdd return WILDDOG_ERR_NULL; } - wilddog_debug_level(WD_DEBUG_LOG, "event node path:%s\n", \ + wilddog_debug_level(WD_DEBUG_LOG, "event node path:%s", \ node->p_url->p_url_path); node->p_onData = arg->p_complete; @@ -432,8 +430,11 @@ Wilddog_Return_T WD_SYSTEM _wilddog_event_nodeAdd tmp_node->p_url->p_url_host, \ tmp_node->p_url->p_url_path); /*resend it.*/ - if(tmp_node->state == EVENT_STATE_OFF) + if(tmp_node->state == EVENT_STATE_OFF){ + tmp_node->flag = OFF_FLAG; + wilddog_debug_level(WD_DEBUG_WARN,"Node's current state is off, resend."); break; + } return WILDDOG_ERR_NOERR; } else @@ -443,7 +444,6 @@ Wilddog_Return_T WD_SYSTEM _wilddog_event_nodeAdd } if(node) { - /* */ if(prev_node == tmp_node) { @@ -465,7 +465,6 @@ Wilddog_Return_T WD_SYSTEM _wilddog_event_nodeAdd u8 pathContainResult = _wilddog_event_pathContain(\ (char*)head->p_url->p_url_path, \ (char*)arg->p_url->p_url_path); - if(pathContainResult == WD_EVENT_PATHCONTAIN_SCD) { if(head->flag == ON_FLAG) diff --git a/tests/linux/test_disEvent.c b/tests/linux/test_disEvent.c index b2cd070..7f4954a 100644 --- a/tests/linux/test_disEvent.c +++ b/tests/linux/test_disEvent.c @@ -53,7 +53,6 @@ File name : test_disOffLineOnline.c #include #include #include "wilddog.h" -#include "test_config.h" #define TEST_URL_LEN (128) #define TEST_DIS_PATH "/dis" @@ -181,7 +180,7 @@ STATIC void dis_getCallBack return; } -int main(void) +int main(int argc, char **argv) { int offtime=0; int argSet =_DIS_CMD_SET,argPush=_DIS_CMD_PUSH,argRm=_DIS_CMD_RM,argCnc = _DIS_CMD_CNC; @@ -198,12 +197,21 @@ int main(void) memset(p_rmUrl,0,TEST_URL_LEN); memset(p_cncUrl,0,TEST_URL_LEN); - +#ifndef TEST_URL + if(argc < 5){ + printf("Input : \t ./test_disEvent url1 url2 url3 url4 \n"); + exit(0); + } + sprintf((char*)p_setUrl,"%s%s",(Wilddog_Str_T*)argv[1],TEST_DIS_PATH); + sprintf((char*)p_pushUrl,"%s%s",(Wilddog_Str_T*)argv[2],TEST_DIS_PATH); + sprintf((char*)p_rmUrl,"%s%s",(Wilddog_Str_T*)argv[3],TEST_DIS_PATH); + sprintf((char*)p_cncUrl,"%s%s",(Wilddog_Str_T*)argv[4],TEST_DIS_PATH); +#else sprintf((char*)p_setUrl,"%s%s",TEST_URL,TEST_DIS_PATH); sprintf((char*)p_pushUrl,"%s%s",TEST_URL2,TEST_DIS_PATH); sprintf((char*)p_rmUrl,"%s%s",TEST_URL3,TEST_DIS_PATH); sprintf((char*)p_cncUrl,"%s%s",TEST_URL4,TEST_DIS_PATH); - +#endif printf("\n\tStart dis_event\\Offline\\Online test:\n\n"); printf("\tdis set url %s \n",p_setUrl); printf("\tdis push url %s\n",p_pushUrl); diff --git a/tests/linux/test_reobserver.c b/tests/linux/test_reobserver.c index 7dbd64f..ad20a1f 100644 --- a/tests/linux/test_reobserver.c +++ b/tests/linux/test_reobserver.c @@ -1,10 +1,8 @@ /* -* 娴嬭瘯鐩殑锛 鏂綉鎯呭喌涓嬶紝observer 鎺ユ敹鍒-10 鍐嶆璋冪敤observer 鏄惁姝ｅ父鍙戦佸嚭 observer 鐢宠銆 -* 娴嬭瘯椤癸細 1銆乷bserver 鎺ユ敹鍒伴敊璇槸鍚﹀畬鍏ㄩ噴鏀 observer銆 -* 2銆侀噴鏀惧悗缁х画璁㈤槄瀛愯妭鐐癸紝涔嬪墠璁㈤槄鐨勭埗鑺傜偣涔熶笉鑳芥敹鍒版帹閫侊紝楠岃瘉鍐嶆璁㈤槄鏄惁鍙楀墠涓娆¤闃呯殑褰卞搷銆 +* 娴嬭瘯椤癸細 1銆佽闃/a锛岀劧鍚庤璇ヨ闃呰秴鏃讹紝鍦ㄨ秴鏃跺洖璋冧腑閲嶆柊璁㈤槄锛岃兘閲嶆柊璁㈤槄锛堟敞鎰忥細鏈夊彲鑳借Е鍙慹rror鍥炶皟锛夈 +* 2銆佹柇绾块噸杩炴祴璇曪紝璁㈤槄鑺傜偣鍚庯紝鏂嚎搴旈噸鏂板彂閫乷bserve銆 * -* 娴嬭瘯姝ラ锛 1銆佹柇缃戯細 sudo ifconfig eth0 down -* 2銆佽繍琛屾祴璇 +* 娴嬭瘯姝ラ锛 杩愯娴嬭瘯 * */ #include @@ -13,174 +11,153 @@ #include #include #include "wilddog.h" -#include "test_config.h" #define _TEST_FAIL (-1) #define _TEST_SUCCESSFUL (1) #define _TEST_SUB_KEY_A "aa" #define _TEST_SUB_KEY_B "bb" - -Wilddog_T wilddog = 0,wilddog_a,wilddog_b; - -static int observer_root=0, observer_cb =0, observer_main = 0; -typedef enum TEST_RSULT{ - RESULT_NO_REOBSERVER, - RESULT_MAIN_REOBSERVER, - RESULT_REOBSERVER, - RESULT_MAX -}TEST_RSULT_T; - - -static int test_result[RESULT_MAX]; -static int test_count[RESULT_MAX]; - -STATIC void observer_cb_root +static int test_result = 1; +static BOOL isExit = FALSE; +STATIC void set_cb ( - const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err ) { - if(observer_root ) - { - test_result[RESULT_NO_REOBSERVER] = _TEST_FAIL; - - } - - test_count[RESULT_NO_REOBSERVER] = 1; + if(arg) + *(BOOL*)arg = TRUE; if((err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED ) && err != WILDDOG_ERR_RECONNECT) { - wilddog_debug("addObserver error code = %d",err); - observer_root = 1; + wilddog_debug_level(WD_DEBUG_LOG,"set error code = %d",err); return; } - - wilddog_debug("receive notify"); return; } - - -STATIC void observer_cb_a +STATIC void observer_cb_2 ( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err ) { - if(observer_main == 2 ) - { - test_result[RESULT_MAIN_REOBSERVER] = _TEST_SUCCESSFUL; - test_count[RESULT_MAIN_REOBSERVER] = 1; - - } - + isExit = TRUE; if((err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED ) && err != WILDDOG_ERR_RECONNECT) { - wilddog_debug("addObserver error code = %d",err); - - if(observer_main <1 ) - observer_main = 1; + wilddog_debug_level(WD_DEBUG_DEBUG,"addObserver error code = %d",err); return; } - - wilddog_debug("receive notify"); + test_result = 0; +// wilddog_debug("Second"); return; } -STATIC void observer_cb_b +STATIC void observer_cb_1 ( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err ) { - if(observer_cb ) - { - test_result[RESULT_REOBSERVER] = _TEST_SUCCESSFUL; - test_count[RESULT_REOBSERVER] = 1; - + Wilddog_T wilddog = (Wilddog_T)arg; + if(0 == wilddog){ + wilddog_debug_level(WD_DEBUG_LOG,"Reobserve callback triggered"); + test_result = 0; + isExit = TRUE; } - if((err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED ) && err != WILDDOG_ERR_RECONNECT) { - wilddog_debug("addObserver error code = %d",err); - wilddog_debug("reobserver new"); - wilddog_addObserver(wilddog_b,WD_ET_VALUECHANGE,observer_cb_b,NULL); - observer_cb = 1; + wilddog_debug_level(WD_DEBUG_LOG,"addObserver error code = %d",err); + if(wilddog){ + wilddog_debug_level(WD_DEBUG_LOG,"Reobserve"); + wilddog_addObserver(wilddog,WD_ET_VALUECHANGE,observer_cb_1,NULL); + } return; } - - wilddog_debug("receive notify"); return; } -STATIC int test_finish(void) -{ - int i; - for(i=0;i<(RESULT_MAX);i++){ - if(test_count[i] == 0){ - return 0; - } - - } - return 1; -} -STATIC int test_restult_printf(void) -{ - int i,res=0; - printf("\n\toffline result :\t"); - for(i=0;i Date: Fri, 17 Feb 2017 14:04:26 +0800 Subject: [PATCH 09/22] add test module --- tests/linux/test_module.c | 67 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 tests/linux/test_module.c diff --git a/tests/linux/test_module.c b/tests/linux/test_module.c new file mode 100644 index 0000000..3cf27c9 --- /dev/null +++ b/tests/linux/test_module.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include +#include +#include "wilddog.h" +#include + +BOOL isExit = FALSE; + +static void catch_function(int signal) { + puts("Interactive attention signal caught."); + isExit = TRUE; +} + +STATIC void addObserver_callback + ( + const Wilddog_Node_T* p_snapshot, + void* arg, + Wilddog_Return_T err + ) +{ + if((err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED ) && + err != WILDDOG_ERR_RECONNECT) + { + wilddog_debug("addObserver failed! error code = %d",err); + return; + } + wilddog_debug("Observe new data!"); + wilddog_debug_printnode(p_snapshot); + printf("\n"); + return; +} + +int main(int argc, char **argv) +{ + Wilddog_T wilddog = 0; + +#ifndef TEST_URL + if(argc < 2){ + printf("Input : \t ./test_reobserver url\n"); + exit(0); + } + url = (Wilddog_Str_T *)argv[1]; +#else + url = (Wilddog_Str_T *)TEST_URL; +#endif + signal(SIGINT, catch_function); + wilddog = wilddog_initWithUrl((Wilddog_Str_T*)url); + wilddog_addObserver(wilddog,WD_ET_VALUECHANGE,addObserver_callback,(void*)wilddog); + + while(1) + { + /* + * Handle the event and callback function, it must be called in a + * special frequency + */ + wilddog_trySync(); + if(isExit) + break; + } + /*Destroy the wilddog clent and release the memory*/ + wilddog_destroy(&wilddog); + + return 0; +} + From 80f40175560337949fc3cdd4d84e42b00f8f71ae Mon Sep 17 00:00:00 2001 From: itolfh Date: Thu, 2 Mar 2017 16:30:43 +0800 Subject: [PATCH 10/22] fix bigendian --- src/networking/coap/wilddog_protocol_coap.c | 29 ++++++++++++++------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/src/networking/coap/wilddog_protocol_coap.c b/src/networking/coap/wilddog_protocol_coap.c index 04d3f45..df8993d 100644 --- a/src/networking/coap/wilddog_protocol_coap.c +++ b/src/networking/coap/wilddog_protocol_coap.c @@ -96,26 +96,35 @@ STATIC void WD_SYSTEM _wilddog_coap_freeRecvBuffer(Wilddog_Protocol_T *proto,u8* * Function: _wilddog_coap_ntoh * Description: Convert the byte order * Input: src: The pointer of the source byte - * len: The length of the source byte + * srcLen: src max bytes + * dstLen: The length of the source byte * Output: dst: The pointer of the destination byte * Return: N/A */ STATIC INLINE void WD_SYSTEM _wilddog_coap_ntoh ( u8 *dst, + const u16 dstLen, const u8 *src, - const u8 len + const u16 srcLen ) { - u8 i; - - for(i=0;i dstLen ? dstLen:srcLen; + // if srcLen > dstLen, copy lsb #if WILDDOG_LITTLE_ENDIAN == 1 - dst[i] = src[len - i - 1 ]; + // lsb is from head + for(i = 0; i < len; i++){ + dst[i] = src[srcLen - i]; + } #else - dst[i] = src[i]; -#endif + //lsb is from tail + for(i = 0; i < len; i++){ + if(dstLen - srcLen + i < 0) + continue; + dst[dstLen - srcLen + i] = src[i]; } +#endif } /* @@ -327,7 +336,7 @@ STATIC u32 WD_SYSTEM _wilddog_coap_getRecvObserveIndex(coap_pdu_t * pdu) return 0; } //observe option is in big endian. - _wilddog_coap_ntoh((u8*)&observe,option_value,len); + _wilddog_coap_ntoh((u8*)&observe,sizeof(observe),option_value,len); } return observe; } @@ -366,7 +375,7 @@ STATIC u32 WD_SYSTEM _wilddog_coap_getRecvMaxage(coap_pdu_t * pdu) return 0; } //maxage option is in big endian. - _wilddog_coap_ntoh((u8*)&maxage,option_value,len); + _wilddog_coap_ntoh((u8*)&maxage,sizeof(maxage),option_value,len); } return maxage; } From 7a45719115dbe147679965dfab7e3acbacc98f76 Mon Sep 17 00:00:00 2001 From: itolfh Date: Tue, 14 Mar 2017 18:16:58 +0800 Subject: [PATCH 11/22] add auth2.0, change token len to 512, add clearauth function --- src/networking/coap/wilddog_protocol_coap.c | 43 +++++++++++++++++++-- src/networking/coap/wilddog_protocol_coap.h | 4 ++ src/wilddog_conn.c | 15 +++++++ src/wilddog_conn.h | 3 +- src/wilddog_store.c | 26 +++++++++++++ src/wilddog_store.h | 3 +- tests/linux/test_module.c | 2 +- 7 files changed, 89 insertions(+), 7 deletions(-) diff --git a/src/networking/coap/wilddog_protocol_coap.c b/src/networking/coap/wilddog_protocol_coap.c index df8993d..231a065 100644 --- a/src/networking/coap/wilddog_protocol_coap.c +++ b/src/networking/coap/wilddog_protocol_coap.c @@ -583,8 +583,14 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_sendPkt(Wilddog_Coap_Sendpk STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag){ Wilddog_Proto_Cmd_Arg_T * arg = (Wilddog_Proto_Cmd_Arg_T*)data; Wilddog_Return_T ret = WILDDOG_ERR_INVALID; - Wilddog_Str_T* tmp = NULL; + Wilddog_Str_T* tmp_path = NULL; Wilddog_Str_T* new_path = NULL; +#ifdef WILDDOG_AUTH_2_0 + Wilddog_Str_T* tmp_query = NULL; + Wilddog_Str_T* new_query = NULL; + int query_len = 0; +#endif + int finalPathLen = 0; Wilddog_Coap_Sendpkt_Arg_T send_arg; //now we only care one packet, do not thinking about partition. @@ -600,8 +606,32 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag } sprintf((char*)new_path, "%s", WILDDOG_COAP_SESSION_PATH); //store old path - tmp = arg->p_url->p_url_path; + tmp_path = arg->p_url->p_url_path; arg->p_url->p_url_path = new_path; + +#ifdef WILDDOG_AUTH_2_0 + //auth 2.0, url is like coap://1.wilddogio.com/.cs?v=2 + if(NULL != arg->p_url->p_url_query){ + //query string length = (pkt.url->p_url_query) + (&) + (v=2) + '\0' + query_len = strlen((const char*)arg->p_url->p_url_query) + 1 + strlen(WILDDOG_COAP_SESSION_AUTH_QUERY_2_0) + 1; + }else{ + //query string length = (v=2) + '\0' + query_len = strlen(WILDDOG_COAP_SESSION_AUTH_QUERY_2_0) + 1; + } + new_query = (Wilddog_Str_T*)wmalloc(query_len); + if(NULL == new_query){ + wfree(new_path); + return WILDDOG_ERR_NULL; + } + if(NULL != arg->p_url->p_url_query){ + sprintf((char*)new_query, "%s&%s",(const char*)arg->p_url->p_url_query,WILDDOG_COAP_SESSION_AUTH_QUERY_2_0); + }else{ + sprintf((char*)new_query, "%s",WILDDOG_COAP_SESSION_AUTH_QUERY_2_0); + } + //store old query + tmp_query = arg->p_url->p_url_query; + arg->p_url->p_url_query = new_query; +#endif send_arg.protocol = arg->protocol; send_arg.url = arg->p_url; @@ -616,10 +646,15 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_initSession(void* data, int flag ret = _wilddog_coap_send_sendPkt(send_arg, FALSE, WILDDOG_COAP_OBSERVE_NOOBSERVE); //resume old path - arg->p_url->p_url_path = tmp; + arg->p_url->p_url_path = tmp_path; if(new_path) wfree(new_path); - +#ifdef WILDDOG_AUTH_2_0 + //resume old query + arg->p_url->p_url_query = tmp_query; + if(new_query) + wfree(new_query); +#endif return ret; } diff --git a/src/networking/coap/wilddog_protocol_coap.h b/src/networking/coap/wilddog_protocol_coap.h index 9e2a053..36af964 100644 --- a/src/networking/coap/wilddog_protocol_coap.h +++ b/src/networking/coap/wilddog_protocol_coap.h @@ -22,6 +22,10 @@ #define WILDDOG_COAP_CANCEL_DIS_QUERY ".dis=rm" #define WILDDOG_COAP_OFFLINE_PATH ".off" +#ifdef WILDDOG_AUTH_2_0 +#define WILDDOG_COAP_SESSION_AUTH_QUERY_2_0 "v=2" +#endif + typedef enum{ WILDDOG_COAP_OBSERVE_NOOBSERVE = 0, WILDDOG_COAP_OBSERVE_ON, diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index 9410497..6f4e066 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -819,6 +819,21 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth_callback p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; break; } +#ifdef WILDDOG_AUTH_2_0 + case WILDDOG_HTTP_UNAUTHORIZED: + { + wilddog_debug_level(WD_DEBUG_WARN, "Auth failed, clear auth data."); + p_conn->d_session.d_session_status = WILDDOG_SESSION_NOTAUTHED; + + //clear user auth token + if(p_conn->p_conn_repo->p_rp_store->p_se_callback){ + (p_conn->p_conn_repo->p_rp_store->p_se_callback)( + p_conn->p_conn_repo->p_rp_store, + WILDDOG_STORE_CMD_CLEARAUTH,NULL,0); + } + break; + } +#endif default: { //WTF! We don't recognize this error code, can do nothing but reauth. diff --git a/src/wilddog_conn.h b/src/wilddog_conn.h index 773aa46..1823d00 100644 --- a/src/wilddog_conn.h +++ b/src/wilddog_conn.h @@ -24,10 +24,11 @@ extern "C" #include "wilddog_ct.h" #include "wilddog_protocol.h" +#define WILDDOG_AUTH_2_0 + #define WILDDOG_CONN_SESSION_SHORT_LEN (8 + 1) #define WILDDOG_CONN_SESSION_LONG_LEN (32 + 1) - #define WILDDOG_CONN_PKT_FLAG_NEVERTIMEOUT (0x01)//this flag mean packet never timeout. /* diff --git a/src/wilddog_store.c b/src/wilddog_store.c index 908e518..b95b0c8 100644 --- a/src/wilddog_store.c +++ b/src/wilddog_store.c @@ -60,6 +60,30 @@ Wilddog_Store_T * WD_SYSTEM _wilddog_store_init(Wilddog_Repo_T* p_repo) p_store->p_se_callback = (Wilddog_Func_T)_wilddog_store_ioctl; return p_store; } +/* + * Function: _wilddog_store_clearAuth + * Description: Clear the auth data. + * Input: p_store: The pointer of the store structure. + * arg: args. + * flag: unused. + * Output: N/A + * Return: If success return 0. +*/ +STATIC Wilddog_Return_T WD_SYSTEM _wilddog_store_clearAuth + ( + Wilddog_Store_T *p_store, + void* arg, + int flag + ){ + Wilddog_Conn_T *p_conn = p_store->p_se_repo->p_rp_conn; + + wilddog_assert(p_conn, WILDDOG_ERR_NULL); + + memset(p_store->p_se_auth->p_auth, 0, WILDDOG_AUTH_LEN); + p_store->p_se_auth->d_len = 0; + + return WILDDOG_ERR_NOERR; +} /* * Function: _wilddog_store_setAuth @@ -183,6 +207,8 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_store_ioctl return _wilddog_store_getAuth(p_store, arg); case WILDDOG_STORE_CMD_GETNODE: return WILDDOG_ERR_INVALID; + case WILDDOG_STORE_CMD_CLEARAUTH: + return _wilddog_store_clearAuth(p_store, arg, flags); case WILDDOG_STORE_CMD_SETAUTH: return _wilddog_store_setAuth(p_store, arg, flags); case WILDDOG_STORE_CMD_SENDGET: diff --git a/src/wilddog_store.h b/src/wilddog_store.h index bec3bca..4cf0b2d 100644 --- a/src/wilddog_store.h +++ b/src/wilddog_store.h @@ -10,12 +10,13 @@ extern "C" #include "wilddog_conn.h" -#define WILDDOG_AUTH_LEN 256 +#define WILDDOG_AUTH_LEN 512 typedef enum WILDDOG_STORE_CMD_T { WILDDOG_STORE_CMD_GETAUTH = 0, WILDDOG_STORE_CMD_GETNODE, + WILDDOG_STORE_CMD_CLEARAUTH, WILDDOG_STORE_CMD_SETAUTH, WILDDOG_STORE_CMD_SENDGET, WILDDOG_STORE_CMD_SENDSET, diff --git a/tests/linux/test_module.c b/tests/linux/test_module.c index 3cf27c9..b767114 100644 --- a/tests/linux/test_module.c +++ b/tests/linux/test_module.c @@ -35,7 +35,7 @@ STATIC void addObserver_callback int main(int argc, char **argv) { Wilddog_T wilddog = 0; - + Wilddog_Str_T* url = NULL; #ifndef TEST_URL if(argc < 2){ printf("Input : \t ./test_reobserver url\n"); From 84f5d5f39b31a891da2f09291431b7947229956a Mon Sep 17 00:00:00 2001 From: itolfh Date: Thu, 16 Mar 2017 16:21:16 +0800 Subject: [PATCH 12/22] update conn --- include/wilddog.h | 3 ++- src/wilddog_conn.c | 11 ++++++++--- src/wilddog_conn.h | 2 +- 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/include/wilddog.h b/include/wilddog.h index d2f3483..028946f 100644 --- a/include/wilddog.h +++ b/include/wilddog.h @@ -76,8 +76,9 @@ typedef signed long s32 ; #endif #ifdef WILDDOG_DEBUG +#ifndef DEBUG_LEVEL #define DEBUG_LEVEL WD_DEBUG_ERROR - +#endif STATIC const char *s_debug[] = { "[ ALL ]", "[ LOG ]", diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index 6f4e066..8889e43 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -124,6 +124,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_ping_callback break; } case WILDDOG_HTTP_UNAUTHORIZED: + case WILDDOG_HTTP_NOT_ACCEPTABLE: { //delta = 0,means it was stable, but now env changed. if(0 == p_conn->d_conn_sys.d_ping_delta){ @@ -1058,7 +1059,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_pingHandler(Wilddog_Conn_T* p_co wilddog_assert(p_conn&&p_conn->p_protocol, WILDDOG_ERR_NULL); //already handled ping retransmit and timeout, now we handle send - if(WILDDOG_SESSION_AUTHED == p_conn->d_session.d_session_status){ + if(WILDDOG_SESSION_AUTHED == p_conn->d_session.d_session_status && NULL == p_conn->d_conn_sys.p_ping){ Wilddog_Proto_Cmd_Arg_T command; command.p_data = NULL; command.d_data_len = 0; @@ -1077,11 +1078,11 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_pingHandler(Wilddog_Conn_T* p_co p_conn->d_conn_sys.d_ping_type = WILDDOG_PING_TYPE_SHORT; } //send to server - if(pkt){ +/* if(pkt){ _wilddog_conn_packet_deInit(pkt); wfree(pkt); p_conn->d_conn_sys.p_ping = NULL; - } + }*/ pkt = (Wilddog_Conn_Pkt_T*)wmalloc(sizeof(Wilddog_Conn_Pkt_T)); wilddog_assert(pkt, WILDDOG_ERR_NULL); @@ -1521,6 +1522,10 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionInit(Wilddog_Conn_T *p_co STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_sessionRetry(Wilddog_Conn_T *p_conn){ wilddog_assert(p_conn,WILDDOG_ERR_NULL); + if(NULL != p_conn->d_conn_sys.p_auth){ + wilddog_debug_level(WD_DEBUG_WARN, "Session is establishing..."); + return WILDDOG_ERR_NOERR; + } if(p_conn->d_conn_sys.d_offline_time != 0){ //we are now offline, so we need control retry interval. u32 sended_time = (1 << p_conn->d_conn_sys.d_online_retry_count); diff --git a/src/wilddog_conn.h b/src/wilddog_conn.h index 1823d00..7fe54c8 100644 --- a/src/wilddog_conn.h +++ b/src/wilddog_conn.h @@ -24,7 +24,7 @@ extern "C" #include "wilddog_ct.h" #include "wilddog_protocol.h" -#define WILDDOG_AUTH_2_0 +//#define WILDDOG_AUTH_2_0 #define WILDDOG_CONN_SESSION_SHORT_LEN (8 + 1) #define WILDDOG_CONN_SESSION_LONG_LEN (32 + 1) From 16306a5a13c1735d25fda3a50656d50c1af0cd33 Mon Sep 17 00:00:00 2001 From: itolfh Date: Thu, 16 Mar 2017 16:21:41 +0800 Subject: [PATCH 13/22] update conn --- src/wilddog_conn.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/wilddog_conn.h b/src/wilddog_conn.h index 7fe54c8..1823d00 100644 --- a/src/wilddog_conn.h +++ b/src/wilddog_conn.h @@ -24,7 +24,7 @@ extern "C" #include "wilddog_ct.h" #include "wilddog_protocol.h" -//#define WILDDOG_AUTH_2_0 +#define WILDDOG_AUTH_2_0 #define WILDDOG_CONN_SESSION_SHORT_LEN (8 + 1) #define WILDDOG_CONN_SESSION_LONG_LEN (32 + 1) From 3edd1f845c780474afe4d5528531bdb4e9e30c81 Mon Sep 17 00:00:00 2001 From: itolfh Date: Thu, 16 Mar 2017 16:41:33 +0800 Subject: [PATCH 14/22] fix little endian ntoh bug --- src/networking/coap/wilddog_protocol_coap.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/networking/coap/wilddog_protocol_coap.c b/src/networking/coap/wilddog_protocol_coap.c index 231a065..94ab1d0 100644 --- a/src/networking/coap/wilddog_protocol_coap.c +++ b/src/networking/coap/wilddog_protocol_coap.c @@ -115,7 +115,7 @@ STATIC INLINE void WD_SYSTEM _wilddog_coap_ntoh #if WILDDOG_LITTLE_ENDIAN == 1 // lsb is from head for(i = 0; i < len; i++){ - dst[i] = src[srcLen - i]; + dst[i] = src[srcLen - i - 1]; } #else //lsb is from tail From 167f798cacca0c13ca36d0a48e7718990aa80737 Mon Sep 17 00:00:00 2001 From: skylli Date: Thu, 16 Mar 2017 16:57:00 +0800 Subject: [PATCH 15/22] update wice makefile --- project/wiced/wiced.mk | 3 +-- tests/wiced/wiced.mk | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/project/wiced/wiced.mk b/project/wiced/wiced.mk index 7db968f..5a4c01c 100644 --- a/project/wiced/wiced.mk +++ b/project/wiced/wiced.mk @@ -28,7 +28,7 @@ ifeq ($(APP_PROTO_TYPE),coap) #COAP_C:=$(wildcard $(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/*.c) $(NAME)_SOURCES += $(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/option.c \ $(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/pdu.c \ -$(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/wilddog_conn_coap.c +$(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/wilddog_protocol_coap.c $(NAME)_INCLUDES += $(WILDDOG_TOP_DIR)/src/networking/coap/ endif @@ -125,7 +125,6 @@ $(WILDDOG_TOP_DIR)/src/ramtest.c \ $(WILDDOG_TOP_DIR)/src/wilddog_api.c \ $(WILDDOG_TOP_DIR)/src/wilddog_common.c \ $(WILDDOG_TOP_DIR)/src/wilddog_conn.c \ -$(WILDDOG_TOP_DIR)/src/wilddog_conn_manage.c \ $(WILDDOG_TOP_DIR)/src/wilddog_ct.c \ $(WILDDOG_TOP_DIR)/src/wilddog_debug.c \ $(WILDDOG_TOP_DIR)/src/wilddog_event.c \ diff --git a/tests/wiced/wiced.mk b/tests/wiced/wiced.mk index 164674f..6e25186 100644 --- a/tests/wiced/wiced.mk +++ b/tests/wiced/wiced.mk @@ -32,7 +32,7 @@ ifeq ($(APP_PROTO_TYPE),coap) #COAP_C:=$(wildcard $(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/*.c) $(NAME)_SOURCES += $(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/option.c \ $(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/pdu.c \ -$(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/wilddog_conn_coap.c +$(WILDDOG_TOP_DIR)/src/networking/$(APP_PROTO_TYPE)/wilddog_protocol_coap.c $(NAME)_INCLUDES += $(WILDDOG_TOP_DIR)/src/networking/coap/ endif @@ -135,7 +135,6 @@ $(WILDDOG_TOP_DIR)/src/ramtest.c \ $(WILDDOG_TOP_DIR)/src/wilddog_api.c \ $(WILDDOG_TOP_DIR)/src/wilddog_common.c \ $(WILDDOG_TOP_DIR)/src/wilddog_conn.c \ -$(WILDDOG_TOP_DIR)/src/wilddog_conn_manage.c \ $(WILDDOG_TOP_DIR)/src/wilddog_ct.c \ $(WILDDOG_TOP_DIR)/src/wilddog_debug.c \ $(WILDDOG_TOP_DIR)/src/wilddog_event.c \ From 5ae7563a22e6d5cca1f8e038c9dcf938029233e2 Mon Sep 17 00:00:00 2001 From: skylli Date: Fri, 17 Mar 2017 15:11:26 +0800 Subject: [PATCH 16/22] updata wiced --- project/wiced/wiced.mk | 4 ++-- tests/wiced/wiced.mk | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/project/wiced/wiced.mk b/project/wiced/wiced.mk index 5a4c01c..ddf8287 100644 --- a/project/wiced/wiced.mk +++ b/project/wiced/wiced.mk @@ -83,7 +83,7 @@ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/ssl_cli.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/ssl_srv.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/ssl_tls.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/timing.c \ -$(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/wilddog_dtls.c \ +$(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/wilddog_sec_mbedtls.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/x509.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/x509_crt.c @@ -106,7 +106,7 @@ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/peer.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/rijndael.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/session.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/sha2.c \ -$(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/wilddog_conn_sec_dtls.c +$(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/wilddog_sec_tinydtls.c $(NAME)_INCLUDES += $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/ endif diff --git a/tests/wiced/wiced.mk b/tests/wiced/wiced.mk index 6e25186..0cd7851 100644 --- a/tests/wiced/wiced.mk +++ b/tests/wiced/wiced.mk @@ -87,7 +87,7 @@ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/ssl_cli.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/ssl_srv.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/ssl_tls.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/timing.c \ -$(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/wilddog_dtls.c \ +$(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/wilddog_sec_mbedtls.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/x509.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/x509_crt.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/lib/sha512.c \ @@ -116,7 +116,7 @@ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/peer.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/rijndael.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/session.c \ $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/sha2.c \ -$(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/wilddog_conn_sec_dtls.c +$(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/wilddog_sec_tinydtls.c $(NAME)_INCLUDES += $(WILDDOG_TOP_DIR)/src/secure/$(APP_SEC_TYPE)/ endif From 514240c47bbdc2abe046d588a6cea5e92ce4ea76 Mon Sep 17 00:00:00 2001 From: itolfh Date: Fri, 17 Mar 2017 17:16:44 +0800 Subject: [PATCH 17/22] reinit connect layer after connect init fail, fix after re auth, observe timeout quickly bug. --- src/networking/coap/wilddog_protocol_coap.c | 5 ++--- src/secure/mbedtls/lib/wilddog_sec_mbedtls.c | 5 +++-- src/wilddog_conn.c | 5 +++++ src/wilddog_ct.c | 6 ++++++ src/wilddog_store.c | 5 +++++ 5 files changed, 21 insertions(+), 5 deletions(-) diff --git a/src/networking/coap/wilddog_protocol_coap.c b/src/networking/coap/wilddog_protocol_coap.c index 94ab1d0..f9f9bbf 100644 --- a/src/networking/coap/wilddog_protocol_coap.c +++ b/src/networking/coap/wilddog_protocol_coap.c @@ -557,8 +557,8 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_sendPkt(Wilddog_Coap_Sendpk if(TRUE == arg.isSend){ ret = _wilddog_sec_send(arg.protocol, pdu->hdr, pdu->length); if(ret < 0){ - coap_delete_pdu(pdu); - pdu = NULL; + //coap_delete_pdu(pdu); + //pdu = NULL; wilddog_debug_level(WD_DEBUG_ERROR, "Send Packet %x failed.",(unsigned int)token); ret = WILDDOG_ERR_SENDERR; }else{ @@ -1427,7 +1427,6 @@ Wilddog_Protocol_T * WD_SYSTEM _wilddog_protocol_init(void *data) protocol->host = p_conn->p_conn_repo->p_rp_url->p_url_host; protocol->addr.port = WILDDOG_PORT; protocol->callback = _wilddog_protocol_ioctl; - //init socket and ip if(WILDDOG_ERR_NOERR != _wilddog_sec_init(protocol)){ wfree(protocol); diff --git a/src/secure/mbedtls/lib/wilddog_sec_mbedtls.c b/src/secure/mbedtls/lib/wilddog_sec_mbedtls.c index f47ced5..61d60fb 100644 --- a/src/secure/mbedtls/lib/wilddog_sec_mbedtls.c +++ b/src/secure/mbedtls/lib/wilddog_sec_mbedtls.c @@ -192,9 +192,10 @@ Wilddog_Return_T _wilddog_sec_init(Wilddog_Protocol_T *protocol) */ wilddog_openSocket(&protocol->socketFd); ret = _wilddog_sec_getHost(&protocol->addr,protocol->host); - if(ret < 0) + if(ret < 0){ + wilddog_debug_level(WD_DEBUG_ERROR,"Get host failed!"); return ret; - + } protocol->user_data = wmalloc(sizeof(Wilddog_Sec_Mbedtls_T)); if(!protocol->user_data){ wilddog_debug_level(WD_DEBUG_ERROR,"Malloc failed!"); diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index 8889e43..3612d32 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -783,6 +783,11 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth_callback //change observe/rest stored packets' send time to now. LL_FOREACH_SAFE(p_conn->d_conn_user.p_observer_list,curr,tmp){ if(curr){ + if((WILDDOG_CONN_PKT_FLAG_NEVERTIMEOUT & curr->d_flag) == 0x1){ + //first observe response packet received before, + //now re auth, so need register again. + curr->d_register_time = _wilddog_getTime(); + } curr->d_flag &= ~WILDDOG_CONN_PKT_FLAG_NEVERTIMEOUT; curr->d_count = 0; curr->d_next_send_time = _wilddog_getTime(); diff --git a/src/wilddog_ct.c b/src/wilddog_ct.c index d923661..c02020e 100644 --- a/src/wilddog_ct.c +++ b/src/wilddog_ct.c @@ -1206,6 +1206,8 @@ Wilddog_Return_T _wilddog_ct_conn_goOffline() cmd.p_repo = p_curr; cmd.p_url = p_curr->p_rp_url; (p_conn->f_conn_ioctl)(WILDDOG_CONN_CMD_OFFLINE, &cmd, 0); + }else if(!p_conn){ + p_curr->p_rp_conn = _wilddog_conn_init(p_curr); } } return WILDDOG_ERR_NOERR; @@ -1236,6 +1238,8 @@ Wilddog_Return_T _wilddog_ct_conn_goOnline() cmd.p_repo = p_curr; cmd.p_url = p_curr->p_rp_url; (p_conn->f_conn_ioctl)(WILDDOG_CONN_CMD_ONLINE, &cmd, 0); + }else if(!p_conn){ + p_curr->p_rp_conn = _wilddog_conn_init(p_curr); } } return WILDDOG_ERR_NOERR; @@ -1282,6 +1286,8 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_ct_conn_sync if(0 != p_conn->d_conn_sys.d_offline_time){ offline++; } + }else if(!p_conn){ + p_curr->p_rp_conn = _wilddog_conn_init(p_curr); } } if(total == offline){ diff --git a/src/wilddog_store.c b/src/wilddog_store.c index b95b0c8..b3765ec 100644 --- a/src/wilddog_store.c +++ b/src/wilddog_store.c @@ -201,6 +201,11 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_store_ioctl { Wilddog_Conn_T *p_conn = p_store->p_se_repo->p_rp_conn; Wilddog_Event_T *p_rp_event = p_store->p_se_event; + if(!p_conn){ + wilddog_debug("reinit connect layer"); + p_store->p_se_repo->p_rp_conn = _wilddog_conn_init(p_store->p_se_repo); + p_conn = p_store->p_se_repo->p_rp_conn; + } switch(cmd) { case WILDDOG_STORE_CMD_GETAUTH: From fdd76a97ff0fdaf708eaa8fc91900ff0121ffe2b Mon Sep 17 00:00:00 2001 From: itolfh Date: Fri, 17 Mar 2017 17:41:19 +0800 Subject: [PATCH 18/22] fix re observe fail bug --- src/networking/coap/wilddog_protocol_coap.c | 5 +++-- src/wilddog_conn.c | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/networking/coap/wilddog_protocol_coap.c b/src/networking/coap/wilddog_protocol_coap.c index f9f9bbf..22fe4df 100644 --- a/src/networking/coap/wilddog_protocol_coap.c +++ b/src/networking/coap/wilddog_protocol_coap.c @@ -775,8 +775,8 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_send_retransmit(void* data, int } } //observe special operation - if(arg->p_proto_data){ - _Wilddog_Coap_Observe_Data_T * observe_data = (_Wilddog_Coap_Observe_Data_T*)arg->p_proto_data; + if(arg->p_proto_data && *(arg->p_proto_data)){ + _Wilddog_Coap_Observe_Data_T * observe_data = *(_Wilddog_Coap_Observe_Data_T**)arg->p_proto_data; observe_data->last_index = 0; observe_data->last_recv_time = 0; observe_data->maxage = 0; @@ -1263,6 +1263,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_coap_recv_handlePkt(void* data, int f observe_data->last_recv_time = _wilddog_getTime(); }else{ //get old observe, ignore it. + wilddog_debug_level(WD_DEBUG_WARN,"Received old observe index: last index is %ld, current index is %ld",observe_data->last_index,observe_index); error_code = WILDDOG_ERR_IGNORE; } } diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index 3612d32..6c84502 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -1010,7 +1010,7 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_retransmitPkt(Wilddog_Conn_T *p_ command.protocol = p_conn->p_protocol; command.p_out_data = NULL; command.p_out_data_len = NULL; - command.p_proto_data = NULL; + command.p_proto_data = &(pkt->p_proto_data); //send pkt must need session info, exclude auth pkt. command.p_session_info = p_conn->d_session.short_sid; command.d_session_len = WILDDOG_CONN_SESSION_SHORT_LEN - 1; From 3f8fca50c59cce831296e485832e9051b056032d Mon Sep 17 00:00:00 2001 From: itolfh Date: Fri, 24 Mar 2017 16:13:52 +0800 Subject: [PATCH 19/22] add test docs --- docs/Wilddog-SDK-Test-User-Manual.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/Wilddog-SDK-Test-User-Manual.md b/docs/Wilddog-SDK-Test-User-Manual.md index 6470e30..3c8e30e 100644 --- a/docs/Wilddog-SDK-Test-User-Manual.md +++ b/docs/Wilddog-SDK-Test-User-Manual.md @@ -1,3 +1,10 @@ #娴嬭瘯浣跨敤鎸囧崡 娴嬭瘯鐨勬簮鏂囦欢浣嶄簬tests鏂囦欢澶逛腑锛屾牴鎹钩鍙板垎鎴愬嚑涓瓙鐩綍锛屽叿浣撴楠ゅ弬鐪嬪搴旂洰褰曚笅鐨凴EADME銆 + +#娴嬭瘯鏂规硶 + +1. 璁㈤槄鑺傜偣锛岃繛鎺ヤ笂鍚庢柇缃戯紝淇敼host锛屾寚鍚戝叾浠栨湇鍔″櫒ip銆1鍒嗛挓鍚庨噸鏂拌繛鎺ョ綉缁滐紝瑙傚療鏄惁鑳芥敹鍒拌闃咃紝鑷冲皯淇敼2娆℃暟鎹 +2. 璁㈤槄鑺傜偣锛岃繛鎺ヤ笂鍚庢柇缃戯紝淇敼host锛屾寚鍚戝綋鍓嶆湇鍔″櫒ip銆4鍒嗛挓鍚庨噸鏂拌繛鎺ョ綉缁滐紝瑙傚療鏄惁鑳芥敹鍒拌闃咃紝鑷冲皯淇敼2娆℃暟鎹 +3. 璁㈤槄鑺傜偣锛岃繛鎺ヤ笂鍚庢柇缃戯紝淇敼host锛屾寚鍚戝叾浠栨湇鍔″櫒ip銆4鍒嗛挓鍚庨噸鏂拌繛鎺ョ綉缁滐紝瑙傚療鏄惁鑳芥敹鍒拌闃咃紝鑷冲皯淇敼2娆℃暟鎹 +4. 杩愯tools涓嬮潰鐨勮嚜鍔ㄥ寲娴嬭瘯鑴氭湰銆 From 2d3f74e288da6ad7b19db97ae865387fb919a503 Mon Sep 17 00:00:00 2001 From: itolfh Date: Mon, 27 Mar 2017 10:59:48 +0800 Subject: [PATCH 20/22] update readme --- README.md | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index 34f9327..9bd56b1 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -#WildDog SDK璇存槑 +# WildDog SDK璇存槑 WildDog C/宓屽叆寮廠DK鏄疻ildDog鍦–/宓屽叆寮忓満鏅笅鐨勫鎴风锛屼娇鐢ㄨ呰皟鐢╝pi鎺ュ彛鍗冲彲瀹炵幇鍜屼簯绔殑閫氫俊銆佹秷鎭闃呭姛鑳姐傚鏈変粈涔堟剰瑙併佸缓璁垨鍚堜綔鎰忓悜锛屽彲璁块棶`www.wilddog.com`銆 WildDog C/宓屽叆寮忕殑SDK 浣跨敤鐨勬槸CoAP UDP + DTLS + CBOR鎶鏈 @@ -11,7 +11,7 @@ CoAP鏄敮涓鐨勫浗闄呯墿鑱旂綉搴旂敤灞傛爣鍑嗭紝鎴戜滑瀵归夋嫨浣曠鍗忚骞 鎴戜滑鍦↙inux骞冲彴涓嬮噰鐢–/宓屽叆寮廠DK瀹炵幇浜嗕竴涓繙绋嬭皟鐢╯hell鑴氭湰鐨勫伐鍏凤紝娆㈣繋澶у浣跨敤锛岃矾寰勶細`https://github.com/WildDogTeam/liveshell` -##1. 鐩綍缁撴瀯 +## 1. 鐩綍缁撴瀯 鈹溾攢鈹 docs 鈹溾攢鈹 examples @@ -22,13 +22,13 @@ CoAP鏄敮涓鐨勫浗闄呯墿鑱旂綉搴旂敤灞傛爣鍑嗭紝鎴戜滑瀵归夋嫨浣曠鍗忚骞 鈹溾攢鈹 tests 鈹斺攢鈹 tools -####docs +#### docs SDK鏂囨。銆 -####examples +#### examples 鍚勪釜骞冲彴涓嬬殑demo渚嬪瓙銆 -####include +#### include 鐩綍涓悇涓枃浠跺唴瀹瑰涓嬶細 * wilddog.h : 鍩烘湰鏁版嵁缁撴瀯鍜屽畯瀹氫箟 @@ -37,15 +37,15 @@ SDK鏂囨。銆 * wilddog_port.h : 骞冲彴鐩稿叧鎺ュ彛鍑芥暟 * widdog_debug.h : debug鐩稿叧鍑芥暟澹版槑 -####platform +#### platform 璇ョ洰褰曟牴鎹笉鍚屽钩鍙板垎涓轰笉鍚屽瓙鐩綍锛屽垎鍒负linux鍜寃iced绛夈 -####project +#### project demo渚嬪瓙鐨勫伐绋嬬洰褰曘 -####src +#### src 骞冲彴鏃犲叧鐩綍銆 @@ -53,12 +53,12 @@ demo渚嬪瓙鐨勫伐绋嬬洰褰曘 娴嬭瘯鏂囦欢銆 -####tools +#### tools 鍚勪釜骞冲彴浣跨敤鐨勪竴浜涘伐鍏枫 ---- -##2. 蹇熷叆闂 +## 2. 蹇熷叆闂 缂栬瘧SDK锛岀紪璇戝悗鐨勫簱鏂囦欢鍦╨ib鐩綍涓 @@ -81,17 +81,14 @@ demo渚嬪瓙鐨勫伐绋嬬洰褰曘 ---- -##3. 绉绘璇存槑 +## 3. 绉绘璇存槑 -SDK宸茬粡鍦╓ICED銆丒SP8266銆佸簡绉慚ICO銆佹爲鑾撴淳銆丄rduino Yun銆丱penWRT涓垚鍔熺Щ妞嶏紝鍙弬鑰僤ocs鐩綍銆 +SDK宸茬粡鍦╓ICED銆佹爲鑾撴淳銆丄rduino Yun銆丱penWRT涓垚鍔熺Щ妞嶏紝鍙弬鑰 docs 鐩綍銆 ---- -##4. 鍏朵粬鍙傝 +## 4. 鍏朵粬鍙傝 SDK 鏂囨。: https://z.wilddog.com/ WICED 鏂囨。鍜宻dk鑾峰彇:http://www.broadcom.com/products/wiced/wifi/ -Espressif sdk鑾峰彇: http://espressif.com/zh-hans/%E6%9C%80%E6%96%B0sdk%E5%8F%91%E5%B8%83/ - -搴嗙 SDK鑾峰彇锛歨ttp://mico.io/wiki/doku.php From c7e8b90905bc9241db89085654e1ac6d66087342 Mon Sep 17 00:00:00 2001 From: itolfh Date: Mon, 27 Mar 2017 11:00:21 +0800 Subject: [PATCH 21/22] update readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9bd56b1..d8d4561 100644 --- a/README.md +++ b/README.md @@ -49,7 +49,7 @@ demo渚嬪瓙鐨勫伐绋嬬洰褰曘 骞冲彴鏃犲叧鐩綍銆 -####tests +#### tests 娴嬭瘯鏂囦欢銆 From 3e695badf460adba56afc5ff12f14474ed9c5152 Mon Sep 17 00:00:00 2001 From: itolfh Date: Wed, 12 Apr 2017 17:51:19 +0800 Subject: [PATCH 22/22] fix 412 bug --- CHANGELOG | 4 ++++ src/wilddog_conn.c | 5 +++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index e202f16..77a2337 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,7 @@ +2.0.1 2017.04.12 +淇锛 +淇璧勬簮瓒呴檺鎴 appId 涓嶅瓨鍦ㄦ椂棰戠箒璇锋眰鐨 bug銆 + 2.0.0 2017.03.27 鏂板锛 Auth 鎺ュ彛鍗囩骇鍒 Auth 2.0 鐗堟湰锛堜笉鍐嶆敮鎸 Auth 1.0 锛夈 diff --git a/src/wilddog_conn.c b/src/wilddog_conn.c index 6c84502..b008b55 100644 --- a/src/wilddog_conn.c +++ b/src/wilddog_conn.c @@ -804,12 +804,13 @@ STATIC Wilddog_Return_T WD_SYSTEM _wilddog_conn_auth_callback p_conn->d_conn_sys.d_online_retry_count = 0; break; } - case WILDDOG_HTTP_BAD_REQUEST: + case WILDDOG_HTTP_BAD_REQUEST:/*fall down*/ + case WILDDOG_HTTP_PRECONDITION_FAIL: { //cannot find this repo, stop to send auth data. p_conn->d_session.d_session_status = WILDDOG_SESSION_INIT; wilddog_debug_level(WD_DEBUG_ERROR, \ - "Can not find host %s", p_conn->p_conn_repo->p_rp_url->p_url_host); + "Can not find host %s or resource overrun!", p_conn->p_conn_repo->p_rp_url->p_url_host); ret = WILDDOG_ERR_INVALID; break; }