mbtk/libmbtk_lib/coap/mbtk_coap.c

/*************************************************************
Description:
    C file for L620 coap.
Author:
    LuoJian
Date:
    2019/3/25 9:23:29
*************************************************************/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/in.h>
#include <unistd.h>

#include "mbtk_coap.h"
#include "mbtk_type.h"
#include "mbtk_log.h"
#include "mbtk_sock2.h"


/*************************************************************
    Variables:public
*************************************************************/


#define MBTK_ECOAP_TIMEOUT (15 * 1000)
#define MBTK_ECOAP_WAIT_CLOSE_TIMEOUT (5 * 60 * 1000)
#define MBTK_ECOAP_STACK_SIZE                (12 * 1024)        // task stack size

#define ECOAPVER 1
#define EOCAPTYPE 2
#define ECOAPCODE 3
#define ECOAPMSGID 4
#define ECOAPTOKEN 5


/*param--------------------*/
// Point the first item.
static mbtk_ecoap_package_s *mbtk_ecoap_head = NULL;
static mbtk_ecoap_package_ver mbth_ecoap_package_ver={1,0,1,1};


struct sockaddr_in serveraddr = {0};
int socket_id;
int addrlen;

static mbtk_init_info *coap_init_info = NULL;
static int coap_handle = -1;
static bool coap_sock_inited = FALSE;
static int coap_fd = -1;



// Point the last item.
static mbtk_ecoap_package_s *mbtk_ecoap_tail = NULL;
static mbtk_ecoap_net_s mbtk_ecoap_net;
static mbtk_ecoap_state_e mbtk_ecoap_state = MBTK_ECOAP_STATE_NON;

//static uint16 mbtk_ecoap_curr_coap_id = 0;
//static char mbtk_ecoap_host[MBTK_ECOAP_NEW_MAX+1] = {'\0'};

//static int mbtk_ecoap_port;
//static int mbtk_ecoap_is_dtls;
static mbtk_ecoap_opt_2 mbtk_ecoap_option_2;
static mbtk_ecoap_opt_3 mbtk_ecoap_option_3;
static int mbtk_ecoap_recv = -1;
//static int mbtk_ecoap_cur_time =0;

/*func------------------------*/
void mbtk_ecoap_option_add(mbtk_ecoap_option_s *option);
int mbtk_ecoap_list_del(uint16 message_id,int optDel);
int mbtk_ecoap_get_message_type(void);
void mbtk_ecoap_get_code(char *ptr);

#define HEXCHAR(x) ((x >= '0' && x <= '9') || (x >= 'a' && x <= 'f') || (x >= 'A' && x <= 'F'))


#if 1

#ifndef toupper
#define toupper(a)  ((((a) >= 'a') && ((a) <= 'z')) ? ((a) - 'a' + 'A') : (a))
#endif

void HexToStr(byte *pbDest, byte *pbSrc, int nLen)
{
	char   ddl,ddh;
	int i;

	for (i=0; i<nLen; i++)
	{
		ddh = 48 + pbSrc[i] / 16;
		ddl = 48 + pbSrc[i] % 16;
		if (ddh > 57)
		{
			ddh = ddh + 7;
		}
		if (ddl > 57)
		{
			ddl = ddl + 7;
		}
		pbDest[i*2] = ddh;
		pbDest[i*2+1] = ddl;
	}
	pbDest[nLen*2] = '\0';
}

uint8_t StrToHex(byte *pbDest, byte *pbSrc, int nLen)
{
	char h1,h2;
	byte s1,s2;
	uint8_t i;

	for (i=0; i<nLen; i++)
	{
		h1 = pbSrc[2*i];
		h2 = pbSrc[2*i+1];
		s1 = toupper(h1) - 0x30;
		if (s1 > 9)
		{
			s1 -= 7;
		}
		s2 = toupper(h2) - 0x30;
		if (s2 > 9)
		{
			s2 -= 7;
		}
		pbDest[i] = s1*16 + s2;
		//DS_MBTK_MSG1_HIGH("StrToHex:%.2X",pbDest[i]);
	}
	return i;
}

void coap_log(int is_ascii,const char* data,int len)
{
    if(len <= 0) {
        return;
    }

    if(is_ascii) { // Is ASCII
        int i = 0;
        int count = len / 100 + 1;

        // Has '\0'
        if(len != strlen(data)) {
            return;
        }

        while(i < count) {
            printf("%s\n",data + i * 100);
            i++;
        }
    } else { // Is hex
        int index = 0;
        int i = 0;
        char buf_temp[100];
        while(index % 16 == 0 && index < len) {
            memset(buf_temp,0,100);
            for(i = 0;i < 16 && index + i < len;i++) {
                snprintf(buf_temp + i * 3,100 - i,"%.2x ",((char*)data)[index + i]);
            }
            index += 16;
            printf("%s\n", buf_temp);
        }
    }
}



static void
mbtk_ecoap_show_error
(
    int rsp_errno
)
{
    char temp[50] = {0};
    memset(temp, 0, 50);
    snprintf(temp,50,"\r\n+MCOAPERROR:%d\r\n",rsp_errno);
    printf("%s\n",temp);
}

int ecoap_recv_buffer(char * dest,const char* data,int len)
{
    if( len <= 0) {
        return -1;
    }
    int buffer_len = 0;
    char Payload[MBTK_ECOAP_DATA_MAX*2+1] ={'\0'};
	int pud_lenth = mbtk_coap_get_pdu_Length();
	int type = mbtk_ecoap_get_message_type();
	char code[12];
    memset(code,0x00,sizeof(code));
	mbtk_ecoap_get_code(code);
	uint16_t mesageId = coapGetRecvMessageID();
	memset(Payload,0x00,MBTK_ECOAP_DATA_MAX*2+1);
	snprintf(dest,MBTK_ECOAP_DATA_MAX,
			"+COAPNMI:%d\r\nMessage Type:%d\r\nCode:\"%s\"\r\nMessage ID:%d\r\nPayload:",
			pud_lenth,
			type,
			code,
			mesageId);


    int i = 0;
	for(i = 0; i < len; i++)
	{
		if(data[i] == 0xFF && i> 3)   //BUG 46397
		{
			LOGE("data[i] == 0xFF\n");
			memcpy(Payload, data+i+1, len - i-1);
			Payload[len-i -1]='\0';
			break;
		}
	}

    LOGE("len:%d, i :%d\n",len,i);
	if(Payload[len-i -1] == '\0' )
	{
		LOGE("==\0-------------------\n");
	//	coap_log(-1,(char*)Payload,len - i-1);
	}else{
		LOGE("!=\0--------------------\n");
		Payload[0]='\0';
	}

    buffer_len = strlen(dest) + strlen(Payload);
    strcat(dest,Payload);
	LOGE("2---------buffer_len:%d,coap_recv_buffer_dest:%s,Payload:%s\n",buffer_len,dest,Payload);
    return buffer_len;
}

int mbtk_ecoap_get_message_type(void)
{
    switch(coapGetRecvType())
    {
        case COAP_CONFIRMABLE:
            return 0;
        break;

        case COAP_NON_CONFIRMABLE:
            return 1;
        break;

        case COAP_ACKNOWLEDGEMENT:
            return 2;
        break;

        case COAP_RESET:
            return 3;
        break;
    }
	return 0;
}

void mbtk_ecoap_get_code(char *ptr)
{
	switch(coapGetRecvCode()) {
		case COAP_EMPTY:
			memcpy(ptr,"0.00",4);
		break;
		case COAP_GET:
			memcpy(ptr,"0.01",4);
		break;
		case COAP_POST:
			memcpy(ptr,"0.02",4);
		break;
		case COAP_PUT:
			memcpy(ptr,"0.03",4);
		break;
		case COAP_DELETE:
			memcpy(ptr,"0.04",4);
		break;
		case COAP_CREATED:
			memcpy(ptr,"2.01",4);
		break;
		case COAP_DELETED:
			memcpy(ptr,"2.02",4);
		break;
		case COAP_VALID:
			memcpy(ptr,"2.03",4);
		break;
		case COAP_CHANGED:
			memcpy(ptr,"2.04",4);
		break;
		case COAP_CONTENT:
			memcpy(ptr,"2.05",4);
		break;
		case COAP_CONTINUE:
			memcpy(ptr,"2.31",4);
		break;
		case COAP_BAD_REQUEST:
			memcpy(ptr,"4.00",4);
		break;
		case COAP_UNAUTHORIZED:
			memcpy(ptr,"4.01",4);
		break;
		case COAP_BAD_OPTION:
			memcpy(ptr,"4.02",4);
		break;
		case COAP_FORBIDDEN:
			memcpy(ptr,"4.03",4);
		break;
		case COAP_NOT_FOUND:
			memcpy(ptr,"4.04",4);
		break;
		case COAP_METHOD_NOT_ALLOWED:
			memcpy(ptr,"4.05",4);
		break;
		case COAP_NOT_ACCEPTABLE:
			memcpy(ptr,"4.06",4);
		break;
		case COAP_PRECONDITION_FAILED:
			memcpy(ptr,"4.12",4);
		break;
		case COAP_REQUEST_ENTITY_TOO_LARGE:
			memcpy(ptr,"4.13",4);
		break;
		case COAP_UNSUPPORTED_CONTENT_FORMAT:
			memcpy(ptr,"4.15",4);
		break;
		case COAP_INTERNAL_SERVER_ERROR:
			memcpy(ptr,"5.00 ",4);
		break;
		case COAP_NOT_IMPLEMENTED:
			memcpy(ptr,"5.01",4);
		break;
		case COAP_BAD_GATEWAY:
			memcpy(ptr,"5.02",4);
		break;
		case COAP_SERVICE_UNAVAILABLE:
			memcpy(ptr,"5.03",4);
		break;
		case COAP_GATEWAY_TIMEOUT:
			memcpy(ptr,"5.04",4);
		break;
		case COAP_PROXYING_NOT_SUPPORTED:
			memcpy(ptr,"5.05",4);
		break;
		default:
			sprintf(ptr, "UndefCod%u",(unsigned)(coapGetRecvCode()));
	}
}

#if 0
static int
mbtk_ecoap_is_open()
{
    if(mbtk_ecoap_state >= MBTK_ECOAP_STATE_OPENED)
        return 0;

    return -1;
}


static void mbtk_ecoap_reset()
{
    memset(&mbtk_ecoap_net,0x0,sizeof(mbtk_ecoap_net_s));
    mbtk_ecoap_net.message_id = 1;   //change mbtk_ecoap_net.message_id = 0;
    memset(&mbtk_ecoap_option_2, 0x0, sizeof(mbtk_ecoap_opt_2));
    memset(&mbth_ecoap_package_ver, 0x0,sizeof(mbtk_ecoap_package_ver));
    mbth_ecoap_package_ver.version = 1;
    mbth_ecoap_package_ver.type = 0;
    mbth_ecoap_package_ver.code = 1;
    mbth_ecoap_package_ver.message_id = 1;
    mbtk_ecoap_recv = -1;

    mbtk_ecoap_package_s *coap = mbtk_ecoap_head;
	mbtk_ecoap_package_s *coap_next = NULL;
	mbtk_ecoap_option_s * option_ptr = NULL;
	mbtk_ecoap_option_s * option_ptr_next = NULL;

    while(coap != NULL)
    {
		coap_next = coap->next;
		if(coap->payload != NULL)
			free(coap->payload);

		if(coap->options != NULL)
		{
			option_ptr = coap->options;
			while(option_ptr != NULL)
			{
				option_ptr_next = option_ptr->next;
				free(option_ptr);
				option_ptr = NULL;
				option_ptr = option_ptr_next;
			}

		}

		free(coap);
		coap = NULL;
		coap = coap_next;

    }

    mbtk_ecoap_head = mbtk_ecoap_tail = NULL;
}


static void mbtk_ecoap_close()
{

}
#endif




mbtk_ecoap_package_s *mbtk_ecoap_get_by_msg_id(uint16 message_id)
{
    if(mbtk_ecoap_head == NULL)
    {
    }
    else
    {
        mbtk_ecoap_package_s *coap_ptr = mbtk_ecoap_head;
        while(coap_ptr != NULL)
        {
            if(coap_ptr->message_id == message_id)
            {
                return coap_ptr;;
            }
            coap_ptr = coap_ptr->next;
        }
    }
    return NULL;
}

static void mbtk_ecoap_list_item_init(unsigned int  sig,mbtk_ecoap_package_s *coap,uint16 message_id)
{
    switch(sig)
    {
        case ECOAPVER:
            coap->version = message_id;
            break;
        case EOCAPTYPE:
            coap->type = message_id;
            break;
        case ECOAPCODE:
            coap->code = message_id;
            break;
        case ECOAPMSGID:
            coap->message_id = message_id;
            break;
        case ECOAPTOKEN:
            coap->token_len = message_id;
            break;
        default:
            break;
    }
    coap->next = NULL;  //change delete this code
}


mbtk_ecoap_package_s* mbtk_ecoap_list_add(uint16 message_id)
{
    LOGE("mbtk_ecoap_list_add-----memssage_id:%d\n",message_id);
    if(mbtk_ecoap_head == NULL)
    {
        mbtk_ecoap_head = (mbtk_ecoap_package_s*)malloc(sizeof(mbtk_ecoap_package_s));
        memset(mbtk_ecoap_head, 0,sizeof(mbtk_ecoap_package_s));
        mbtk_ecoap_list_item_init(ECOAPMSGID,mbtk_ecoap_head,message_id);
        mbtk_ecoap_tail = mbtk_ecoap_head;
        return mbtk_ecoap_head;
    }
    else
    {
        mbtk_ecoap_package_s *coap_ptr = mbtk_ecoap_head;
        while(coap_ptr != NULL)
        {
            if(coap_ptr->message_id == message_id)
            {
                printf("Coap %d exist.\n",message_id);
                return NULL;
            }
            coap_ptr = coap_ptr->next;
        }
        mbtk_ecoap_tail->next = (mbtk_ecoap_package_s*)malloc(sizeof(mbtk_ecoap_package_s));
        mbtk_ecoap_list_item_init(ECOAPMSGID,mbtk_ecoap_tail->next,message_id);
        mbtk_ecoap_tail = mbtk_ecoap_tail->next;
        return mbtk_ecoap_tail;
    }
}

static void mbtk_ecoap_free(mbtk_ecoap_package_s *coap)
{
    if(coap != NULL)
    {
        if(coap->payload != NULL)
            free(coap->payload);

        if(coap->options != NULL)
        {
            mbtk_ecoap_option_s *option_ptr = coap->options;
            while(option_ptr != NULL)
            {
                free(option_ptr);
                option_ptr = option_ptr->next;
            }
        }

        free(coap);
        coap = NULL;
    }
}

int mbtk_ecoap_list_del(uint16 message_id,int optDel)
{
    LOGE("mbtk_ecoap_list_del:message_id:%d\n",message_id);
    if(mbtk_ecoap_head == NULL)
    {
    	printf("mbtk_ecoap_head == NULL\n");
	return -1;
    }

    mbtk_ecoap_recv = -1;
    if(optDel)
    {
        memset(&mbtk_ecoap_option_2, 0x0, sizeof(mbtk_ecoap_opt_2));
        memset(&mbtk_ecoap_option_3, 0x0, sizeof(mbtk_ecoap_opt_3));
        memset(&mbth_ecoap_package_ver,0x0,sizeof(mbth_ecoap_package_ver));
        mbth_ecoap_package_ver.version = 1;
        mbth_ecoap_package_ver.type = 0;
        mbth_ecoap_package_ver.code = 1;
        mbth_ecoap_package_ver.message_id = 1;
    }
    mbtk_ecoap_package_s *coap = mbtk_ecoap_head;
    if(mbtk_ecoap_head->message_id == message_id) // Is first item.
    {
        mbtk_ecoap_head = mbtk_ecoap_head->next;

        mbtk_ecoap_free(coap);
        return 0;
    }
    else     // Not first item.
    {
        while(coap->next != NULL)
        {
            if(message_id == coap->next->message_id)   // delete
            {
                mbtk_ecoap_package_s *coap_tmp = coap->next;
                if(mbtk_ecoap_tail == coap_tmp)
                {
                    mbtk_ecoap_tail = coap;
                }
                coap->next = coap_tmp->next;
                mbtk_ecoap_free(coap_tmp);
                return 0;;
            }
            coap = coap->next;
        }
        return -1;
    }
}

void mbtk_ecoap_option_add(mbtk_ecoap_option_s *option)
{
    if(option != NULL)
    {
        switch(option->type)
        {
            case COAP_OPTION_IF_MATCH:
            case COAP_OPTION_URI_HOST:
            case COAP_OPTION_ETAG:
            case COAP_OPTION_IF_NONE_MATCH:
            case COAP_OPTION_LOCATION_PATH:
            case COAP_OPTION_LOCATION_QUERY:
            case COAP_OPTION_PROXY_URI:
            case COAP_OPTION_PROXY_SCHEME:
            case COAP_OPTION_URI_PORT:
            case COAP_OPTION_ACCEPT:
            case COAP_OPTION_SIZE2:
            case COAP_OPTION_SIZE1:
            {
                break;
            }
            case COAP_OPTION_BLOCK2:
            case COAP_OPTION_BLOCK1:
            {
                LOGE("option->opt.opt_block.number = %d\n",option->opt.opt_block.number);
                if(option->opt.opt_block.number <= 0x0F)
                {
                    uint8_t temp[1];
                    temp[0] = (uint8_t)(((option->opt.opt_block.number << 4) & 0xF0)
                                        | ((option->opt.opt_block.more_flag << 3) & 0x08)
                                        | (option->opt.opt_block.size & 0x07));
                    coapAddOption(option->type,1,temp);
                }
                else if(option->opt.opt_block.number <= 0x0FFF)
                {
                    uint8_t temp[2];
                    temp[0] = (uint8_t)(option->opt.opt_block.number >> 4);
                    temp[1] = (uint8_t)(((option->opt.opt_block.number << 4) & 0xF0)
                                        | ((option->opt.opt_block.more_flag << 3) & 0x08)
                                        | (option->opt.opt_block.size & 0x07));
                    coapAddOption(option->type,2,temp);

                }
                else
                {
                    uint8_t temp[3];
                    temp[0] = (uint8_t)(option->opt.opt_block.number >> 12);
                    temp[1] = (uint8_t)(option->opt.opt_block.number >> 4);
                    temp[2] = (uint8_t)(((option->opt.opt_block.number << 4) & 0xF0)
                                        | ((option->opt.opt_block.more_flag << 3) & 0x08)
                                        | (option->opt.opt_block.size & 0x07));
                    coapAddOption(option->type,3,temp);

                }
                break;
            }
            case COAP_OPTION_MAX_AGE:
            {
                uint8_t temp[1];
                temp[0] = (uint8_t)option->opt.opt_int;
                coapAddOption(option->type,1,temp);
                break;
            }
            case COAP_OPTION_OBSERVE:
            {
                uint8_t temp[1];
                temp[0] = (uint8_t)option->opt.opt_int;
                coapAddOption(option->type,1,temp);
                break;
            }
            case COAP_OPTION_URI_QUERY:
            {
                coapAddURIQuery((char*)option->opt.opt_str);
                break;
            }
            case COAP_OPTION_URI_PATH:
            {
                coapSetURI((char*)option->opt.opt_str);
                break;
            }
            case COAP_OPTION_CONTENT_FORMAT:
            {
                coapSetContentFormat(option->opt.opt_content_format);
                break;
            }
            default:
                printf("No such type:%d\n",option->type);
                break;
        }
    }
}

static void mbtk_ecoap_set_option(mbtk_ecoap_package_s *coap,
                                 mbtk_coap_option_type type,void *str,
                                 int int0,int int1,int int2)
{
    if(coap != NULL)
    {
/*        if(coap->options == NULL)
        {
            coap->options = (mbtk_ecoap_option_s*)malloc(sizeof(mbtk_ecoap_option_s));
            memset(coap->options,0x0,sizeof(mbtk_ecoap_option_s));
            coap->options->type = type;
            coap->options->next = NULL;
        }
*/
        mbtk_ecoap_option_s *option = coap->options;
        while(option != NULL)
        {
            LOGE("1option != NULL\n");
            if(option->type == type)
            {
                break;
            }
            option = option->next;
        }

        LOGE("----------------------\n");
        if(option == NULL) // Now option
        {
            LOGE("option == NULL\n");
            option = (mbtk_ecoap_option_s*)malloc(sizeof(mbtk_ecoap_option_s));
            memset(option,0x0,sizeof(mbtk_ecoap_option_s));
//            option->type = type;

            option->next = coap->options;
            coap->options = option;
            option->type = type;
        }
        else // Change option
        {
            // Do noting.
        }

        switch(type)
        {
            case COAP_OPTION_IF_MATCH:
            case COAP_OPTION_URI_HOST:
            case COAP_OPTION_ETAG:
            case COAP_OPTION_IF_NONE_MATCH:
            case COAP_OPTION_LOCATION_PATH:
            case COAP_OPTION_URI_QUERY:
            case COAP_OPTION_LOCATION_QUERY:
            case COAP_OPTION_PROXY_URI:
            case COAP_OPTION_PROXY_SCHEME:
            case COAP_OPTION_URI_PATH:
            {
                memset(option->opt.opt_str,0x0,128);
                memcpy(option->opt.opt_str,str,strlen((char*)str));
                break;
            }
            case COAP_OPTION_OBSERVE:
            case COAP_OPTION_MAX_AGE:
            case COAP_OPTION_URI_PORT:
            case COAP_OPTION_SIZE2:
            case COAP_OPTION_SIZE1:
            {
                option->opt.opt_int = (int)int0;
                break;
            }
            case COAP_OPTION_BLOCK2:
            case COAP_OPTION_BLOCK1:
            {
                option->opt.opt_block.size = (mbtk_ecoap_option_block_e)int0;
                option->opt.opt_block.number = (int)int1;
                option->opt.opt_block.more_flag = (uint8)int2;
                break;
            }
            case COAP_OPTION_CONTENT_FORMAT:
			{
                option->opt.opt_content_format = (mbtk_content_format_type)int0;
                break;
            }
            case COAP_OPTION_ACCEPT:
            {
                option->opt.opt_content_format = (mbtk_content_format_type)int0;
                break;
            }
            default:
                printf("No such type:%d\n",type);
                break;
        }
    }
}


static void mbtk_ecoap_send_ack(mbtk_coap_code_type code,
                               uint16_t message_id,uint8 token_len,uint8 *token)
{
    coapReset();
    coapSetVersion(1);
    coapSetType(COAP_ACKNOWLEDGEMENT);
    coapSetMessageID(message_id);

    if(code == COAP_POST || code == COAP_PUT)
        coapSetCode(COAP_CHANGED);
    else
        coapSetCode(COAP_EMPTY);

    if(token_len > 0)
    {
        coapSetToken(token, token_len);
    }

    uint8_t* pduPointer = coapGetPDUPointer();
    int pduLen = coapGetPDULength();
	int err;
	int res = mbtk_sock_write(coap_handle, coap_fd, pduPointer, pduLen, 300, &err);
    if(res != pduLen)
    {
        printf("Send ACK fail.[res:%d,pduLen:%d],err:%d\n",res,pduLen,err);
    }
    else
    {
        printf("Send ACK to server success.\n");
    }
}



static int mbtk_ecoap_handle_sock_init(char *ip_addr, int port, bool is_support_ssl, bool ingnore_cert)
{
    mbtk_sock_info *sock_info = NULL;
    int rc = 0;
    int errno;

    sock_info = (mbtk_sock_info *)malloc(sizeof(mbtk_sock_info));
    if(sock_info == NULL)
    {
        rc = -1;
        return rc;
    }
    memcpy(sock_info->address, ip_addr, strlen(ip_addr));
    sock_info->port = port;
    sock_info->is_support_ssl = is_support_ssl;
    sock_info->ingnore_cert = ingnore_cert;
	sock_info->type = MBTK_SOCK_UDP;

    printf("host %s\nport %d\nis_support_ssl %d\ningnore_cert %d\n",sock_info->address,sock_info->port,sock_info->is_support_ssl,sock_info->ingnore_cert);

	if(!coap_sock_inited)
	{
		coap_handle = mbtk_sock_init(coap_init_info);
	    if (coap_handle < 0 )
	    {
	        rc = -1;
	        return rc;
	    }
		coap_sock_inited = TRUE;
	}


    coap_fd  = mbtk_sock_open(coap_handle, sock_info, 3000, &errno);
    if(coap_fd < 0)
    {
    	printf("creat socket fail, errno:%d\n",errno);
        rc = -1;
        return rc;
    }
    mbtk_ecoap_state = MBTK_ECOAP_STATE_READY;
	return rc;
}



int mbtk_ecoap_ecoap_send(mbtk_ecoap_package_s* coap)
{
    if(coap != NULL)
    {
        coapReset();
        coapSetVersion(coap->version);
        coapSetType(coap->type);
        coapSetCode(coap->code);
        coapSetMessageID(coap->message_id);

        if(coap->token_len > 0)
        {
            coapSetToken(coap->token, coap->token_len);
        }

        mbtk_ecoap_option_s *option = coap->options;
        while(option != NULL)
        {
            mbtk_ecoap_option_add(option);
            option = option->next;
        }

        if(coap->payload_len > 0)
        {
            coapSetPayload((uint8_t*)coap->payload, coap->payload_len);
        }

        uint8_t *pduPointer = coapGetPDUPointer();
        int pduLen = coapGetPDULength();
        uint8_t pduPointer2[MBTK_ECOAP_DATA_MAX*2];
		int err;
        memset ( pduPointer2,0x00,MBTK_ECOAP_DATA_MAX*2 );
        if((mbtk_ecoap_option_2.optlen + pduLen) > MBTK_ECOAP_DATA_MAX*2)
        {
            printf("This length is too long\n");
            return -1;
        }

        LOGE("pduLen:%d, optlen:%d\n",pduLen ,mbtk_ecoap_option_2.optlen);
   //     printf("pduPointer:\n");
   //     coap_log(-1,(char*)pduPointer,pduLen);
        int j=0,k=0;
        LOGE("pduPointer-----------end\n");
//        int optflag = 0;
        pduPointer2[0]= *pduPointer++;
        pduPointer2[1]= *pduPointer++;
        pduPointer2[2]= *pduPointer++;
        pduPointer2[3]= *pduPointer++;
        for(j = 0; j < mbtk_ecoap_option_2.optlen; j++)
        {
            pduPointer2[4+j] = mbtk_ecoap_option_2.optVal[j];
			LOGE("j:%d, %X",j, mbtk_ecoap_option_2.optVal[j]);
            k++;
        }
        int pduLen2 = 4;
        while(pduLen > pduLen2 )
        {
        	LOGE("\r\npduLen > pduLen2 \r\n");
            LOGE("pduLen:%d,pduPointer:%X,k:%d\n",pduLen2,*pduPointer,k);
            pduPointer2[pduLen2+k] = *pduPointer++;
            pduLen2++;
        }

        pduLen += mbtk_ecoap_option_2.optlen;

        printf("sendpdu:--------pduLen:%d\n",pduLen);
		coap_log(FALSE,(char*)pduPointer2,pduLen);
		int send_len = 0;

		if((send_len = mbtk_sock_write(coap_handle, coap_fd, pduPointer2, pduLen, 300, &err)) != pduLen)
//        if((send_len = sendto(socket_id, pduPointer2, pduLen, 0, (struct sockaddr*)&serveraddr, addrlen)) != pduLen)
        {
            printf("coap_udp_sendto complate.[%d/%d]\n",send_len,pduLen);

            coap->send_count++;
			return -1;
        }

        if(coap->type != COAP_CONFIRMABLE)
        {
            mbtk_ecoap_list_del(coap->message_id,0);
        }

    }
	return 0;
}

void mbtk_ecoap_recv_buffer(char * dest)
{
	int pud_lenth = mbtk_coap_get_pdu_Length();
	int type = mbtk_ecoap_get_message_type();
	char code[12];
    memset(code,0x00,sizeof(code));
	mbtk_ecoap_get_code(code);
	uint16_t mesageId = coapGetRecvMessageID();
	memset(dest,0x00,129);
	snprintf(dest,128,
			"+COAPNMI:%d\r\nMessage Type:%d\r\nCode:\"%s\"\r\nMessage ID:%d\r\nPayload:",
			pud_lenth,
			type,
			code,
			mesageId);
}


static void mbtk_ecoap_recv_resolve(const void *data,uint16 data_len)
{
    if(coapCreateRecv((uint8_t*)data, data_len) <= 0)
    {
        printf("coapCreateRecv fail.\n");
    }
    else
    {
        LOGE("coapCreateRecv() success.\n");

        uint8_t version = coapGetRecvVersion();
        mbtk_coap_type type = coapGetRecvType();
        mbtk_coap_code_type code = coapGetRecvCode();
        uint16_t message_id = coapGetRecvMessageID();
        int pud_lenth = mbtk_coap_get_pdu_Length();
        LOGE("version:%d;type:%d\n",version,type);
        LOGE("code:%d;message_id:%d,pud_lenth:%d\n",code,message_id,pud_lenth);

        uint8 token_len = coapGetRecvTokenLength();
        char token[9] = {0};
        memcpy(token,coapGetRecvTokenPointer(),token_len);
        LOGE("token[%d]:%s\n",token_len,token);

//        uint16 playload_len = coapGetRecvPayloadLength();
//        uint8 *playload = coapGetRecvPayloadPointer();
//        printf("----------------payload-----------------\n");
//        coap_log(0,(char*)playload,playload_len);
//        printf("--------------payload end----------------\n");


		char buff_data[MBTK_ECOAP_DATA_MAX*2+1];
		memset ( buff_data,0x00,MBTK_ECOAP_DATA_MAX*2+1 );
        int buffer_len = ecoap_recv_buffer(buff_data, data, data_len);
		printf("recv buff_len:%d\n",buffer_len);
        printf("buf:\n%s\r\n",buff_data);

        LOGE("type:%X\n",type);
        if(type == COAP_CONFIRMABLE) // Should ACK
        {
            mbtk_ecoap_send_ack(code,message_id,token_len,(uint8*)token);
        }
        else if(type == COAP_NON_CONFIRMABLE)
        {
            // Do nothing.
        }
        else if(type == COAP_ACKNOWLEDGEMENT)
        {
            mbtk_ecoap_package_s * coap_send = mbtk_ecoap_get_by_msg_id(message_id);
            if(coap_send != NULL)
            {
                uint32_t number;
                uint8_t more_flag;
                uint8_t size;
                LOGE("Get message(%d) ack.\n",message_id);
                if(coapGetRecvOptionBlock2(&number, &more_flag, &size))
                {
                    LOGE("Block2 (size:%d; more_flag:%d; number:%d)\n",size,more_flag,number);
                    if(more_flag) // Has data no read.
                    {
                        coap_send->message_id = ++mbtk_ecoap_net.message_id ;
                        mbtk_ecoap_set_option(coap_send, COAP_OPTION_BLOCK2, NULL,
                                             size,number + 1,0);

                        mbtk_ecoap_ecoap_send(coap_send);
                    }
                    else
                    {
                        mbtk_ecoap_list_del(message_id,0);
                    }
                }
                else
                {
                    printf("coapGetRecvOptionBlock2() fail.\n");
                    mbtk_ecoap_list_del(message_id,0);
                }
            }
            else
            {
                printf("Coap not match.\n");
            }
        }
        else     // COAP_RESET
        {
            printf("Coap type error.\n");
        }
    }
	coapDeleteRecv();

}


static int ecoap_sig_recv_handle(void)
{
    LOGE("coap_sig_recv_handle----------start\n");

    uint8_t buffer[MBTK_ECOAP_DATA_MAX*2+1];
    memset ( buffer,0x00,MBTK_ECOAP_DATA_MAX*2+1 );
    int ret=-1;
	int err = -1;
	while(TRUE)
	{
		ret = mbtk_sock_read(coap_handle, coap_fd, buffer, MBTK_ECOAP_DATA_MAX*2, 1000*10, &err);
		if(ret <= 0)
		{
            printf("read fail, err:%d",err);
			break;
		}
        printf("recv_from ret:%d\n",ret);
        coap_log(FALSE,(char*)buffer,ret);
        mbtk_ecoap_recv_resolve(buffer,ret);
	}

    return ret;
}

static int ecoap_sig_send_complete_handle(void )
{
    int ret=-1;
    mbtk_ecoap_package_s *coap = mbtk_ecoap_get_by_msg_id(mbtk_ecoap_net.message_id);
    if(coap == NULL)
    {
        mbtk_ecoap_show_error(MBTK_ECOAP_ERR_MSG_ID);
        return -1;
    }

    ret = mbtk_ecoap_ecoap_send(coap);

    return ret;

}

//static int mbtk_ecoap_open(int open);



#endif


/*************************************************************
    Public Function Definitions
*************************************************************/

/*************************************************************
	ip_addr: url
	port

*************************************************************/
int mbtk_coap_ecoapnew_exec_cmd
(
    char *ip_addr,
    int port,
    bool is_support_ssl,
    bool ingnore_cert
)
{
    printf("mbtk_coap_ecoapnew_exec_cmd()------start1\n");
	int ret = 0;
	if( !ip_addr)
	{
	    mbtk_ecoap_show_error(MBTK_ECOAP_ERR_NO_READY);
	    return -1;
	}

	ret = mbtk_ecoap_handle_sock_init(ip_addr, port, is_support_ssl, ingnore_cert);

    return ret;
}

int mbtk_coap_ecoaprxmod_exec_cmd
(
	int mode
)
{
    int result = 0;
//	int rx_mod = mode;

    return result;
}

int mbtk_coap_ecoappr_exec_cmd
(
	int format
)
{
    int result = 0;
//	uint16 ecoappr = format;
    return result;
}

int mbtk_coap_ecoaprxget_exec_cmd
(
    int len
)
{
    int result = 0;
//	int get_len = len;

    return result;

}

int mbtk_coap_ecoapver_exec_cmd
(
    int version
)
{
    int result = 0;
	mbth_ecoap_package_ver.version = version;
    return result;

}

int mbtk_coap_ecoaptype_exec_cmd
(
    mbtk_coap_type type
)
{
    int result = 0;
	mbth_ecoap_package_ver.type = type;

    return result;

}


int mbtk_coap_ecoapcode_exec_cmd
(
    mbtk_coap_code_type code
)
{
    int  result = 0;
	mbth_ecoap_package_ver.code = code;
        LOGE("ver:%d,type:%d,code:%d,msg:%d\n",
            mbth_ecoap_package_ver.version,
            mbth_ecoap_package_ver.type,
            mbth_ecoap_package_ver.code,
            mbth_ecoap_package_ver.message_id);
    return result;

}

int mbtk_coap_ecoaptoken_exec_cmd
(
    char *token_buf, int len
)
{
    int result = 0;
	uint16 token_length = len;
	char * token = token_buf;
	if(strlen(token) != token_length)
	{
		return -1;
	}

	mbth_ecoap_package_ver.token_len = token_length;
	memcpy(mbth_ecoap_package_ver.token, token, strlen(token));

	return result;
}

int mbtk_coap_ecoapmsgid_exec_cmd
(
    int msg_id
)
{
    int result = 0;
	 mbth_ecoap_package_ver.message_id = msg_id;

	return result;
}

int mbtk_coap_ecoapopt_exec_cmd
(
    char *value_buf, int buf_len
)
{
    int result = 0;
	int opt = buf_len;
    char* value = value_buf;

    if(value == NULL)
    {
        return -1;
    }
    if(opt != strlen(value))
    {
        return -1;
    }

    memset(&mbtk_ecoap_option_2, 0x0, sizeof(mbtk_ecoap_opt_2));
    memset(&mbtk_ecoap_option_3, 0x0, sizeof(mbtk_ecoap_opt_3));

    mbtk_ecoap_option_3.optlen = opt;
    mbtk_ecoap_option_2.optlen = opt / 2;

    if(mbtk_ecoap_option_2.optlen > 0)
    {
        memcpy(mbtk_ecoap_option_3.optVal, value, opt);
        mbtk_ecoap_option_3.optVal[opt] = '\0';
        StrToHex((byte*)mbtk_ecoap_option_2.optVal, (byte*)value, strlen(value));
//		printf("\r\nopt2---------option_len,option_data");
//		coap_log(FALSE,(char*)mbtk_ecoap_option_2.optVal,mbtk_ecoap_option_2.optlen);
    }
    return result;

}

int mbtk_coap_ecoapsend_exec_cmd
(
    int message_id, int Data_len, char *data
)
{
    int data_len = Data_len;
    char * send_data = NULL;
	int err = -1;
    if(data_len != 0 )
    {
        send_data = data;
    }
    int coap_id = message_id;

	LOGE("send---------coap_id:%d,data_len:%d\n",coap_id,data_len);

     if(mbtk_ecoap_state <= MBTK_ECOAP_STATE_CLOSING )
    {
        mbtk_ecoap_show_error(MBTK_ECOAP_ERR_NO_OPEN);
        return -1;
    }

    if(coap_id != mbth_ecoap_package_ver.message_id)
    {
        mbtk_ecoap_show_error(MBTK_ECOAP_ERR_MSG_ID);
        return -1;
    }

    if(coap_id != mbtk_ecoap_net.message_id)
    {
        printf("send_cmd del message_id:%d\n",mbtk_ecoap_net.message_id);
        mbtk_ecoap_list_del(mbtk_ecoap_net.message_id,-1);
    }

    if(send_data)
    {
        if(data_len != strlen(send_data) || data_len > 1024)
        {
            mbtk_ecoap_show_error(MBTK_ECOAP_ERR_PAYLOAD_LENGTH);
            return -1;
        }
    }

    mbtk_ecoap_package_s *coap = mbtk_ecoap_get_by_msg_id(coap_id);
    if( !coap)
    {
        mbtk_ecoap_net.message_id = mbth_ecoap_package_ver.message_id;
        coap = mbtk_ecoap_list_add(mbtk_ecoap_net.message_id);
        if(coap != NULL)
        {
            mbtk_ecoap_list_item_init(ECOAPVER,coap,mbth_ecoap_package_ver.version);
            mbtk_ecoap_list_item_init(EOCAPTYPE,coap,mbth_ecoap_package_ver.type);
            mbtk_ecoap_list_item_init(ECOAPCODE,coap,mbth_ecoap_package_ver.code);
            if(mbth_ecoap_package_ver.token_len > 0)
            {
                coap->token_len = mbth_ecoap_package_ver.token_len;
                memcpy(coap->token, mbth_ecoap_package_ver.token, strlen((char *)mbth_ecoap_package_ver.token));
            }

            if(data_len > 0)
            {
                coap->payload_len = data_len;
                if(coap->payload != NULL)
                {
                    free(coap->payload);
                    coap->payload = NULL;
                }
                coap->payload = (uint8*)malloc(data_len + 1);
                memset(coap->payload,0x00,data_len + 1);
                memcpy(coap->payload,send_data,data_len);
            }

        }
        else{
            printf("coap new error\n");
        }

    }
    else
    {
		printf("coap is NULL\n");
    }

    mbtk_ecoap_recv = 0;
	if(mbtk_ecoap_state < MBTK_ECOAP_STATE_READY)
	{
	    printf("State[%d] error,not ready...\n",mbtk_ecoap_state);
	    return -1;
	}

	if( !ecoap_sig_send_complete_handle() )
	{
		ecoap_sig_recv_handle();
	}

	if(mbtk_sock_close(coap_handle, coap_fd,1000, &err)) {
        return -1;
    }

    coap_fd = -1;
    return 0;

}

int mbtk_coap_ecoapdel_exec_cmd( int del_id )
{

    int result = 0;
	LOGE("del---------del_id:%d\n",del_id);
	if(del_id != 1)
	{
		return -1;
	}

	 if(mbtk_ecoap_state <= MBTK_ECOAP_STATE_CLOSING )
	{
		mbtk_ecoap_show_error(MBTK_ECOAP_ERR_NO_OPEN);
		return -1;
	}

	LOGE("del---------del_id:%d\n",del_id);

    return result;

}

int mbtk_coap_ecoapclose_exec_cmd( void )
{
    int result = 0;
	if(!coap_sock_inited) {
        LOGE("HTTP not inited.");
        return -1;
    }

    int err = mbtk_sock_deinit(coap_handle);
    if(err != MBTK_SOCK_SUCCESS) {
        LOGE("mbtk_sock_deinit() fail.");
        return -1;
    }

    coap_handle = -1;
    coap_sock_inited = FALSE;
    return 0;

    return result;
}

void mbtk_coap_lib_info_print()
{
    MBTK_SOURCE_INFO_PRINT("mbtk_coap_lib");
}