marvell/services/cmcc_iot/sample/cis_sample_entry.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libubus.h>
#include <unistd.h>
#include <libubox/usock.h>
#include <pthread.h>
#include <sys/socket.h> 
#include <rilutil.h>

#include <telephony/ril.h>

#include "../ciscore/cis_def.h"
#include "../ciscore/cis_api.h"
#include "../ciscore/cis_if_sys.h"
#include "../ciscore/cis_api.h"
#include "../ciscore/cis_internals.h"
#include "cis_sample_entry.h"

#define LWM2M_INNER_CONN_SOCKET "/tmp/lwm2m_socket.sock"
#define RESULT_TO_RESPONSE(R)                                \
    ((R) == MIPLRS_205_CONTENT ? CIS_COAP_205_CONTENT :      \
    ((R) == MIPLRS_204_CHANGED ? CIS_COAP_204_CHANGED :      \
    ((R) == MIPLRS_400_BAD_REQUEST ? CIS_COAP_400_BAD_REQUEST :  \
    ((R) == MIPLRS_401_UNAUTHORIZED ? CIS_COAP_401_UNAUTHORIZED :        \
    ((R) == MIPLRS_404_NOT_FOUND ? CIS_COAP_404_NOT_FOUND : \
    ((R) == MIPLRS_405_METHOD_NOT_ALLOWED ? CIS_COAP_405_METHOD_NOT_ALLOWED :      \
    ((R) == MIPLRS_406_NOT_ACCEPTABLE ? CIS_COAP_406_NOT_ACCEPTABLE :      \
    CIS_COAP_503_SERVICE_UNAVAILABLE)))))))

static void* g_context = NULL;

struct ubus_context *lwm2m_ubus_ctx;
static const struct blobmsg_policy lwm2m_create_policy[] = {
	[0] = {.name = "total_size", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "context", .type = BLOBMSG_TYPE_STRING},
	[2] = {.name = "index", .type = BLOBMSG_TYPE_INT32},
	[3] = {.name = "current_size", .type = BLOBMSG_TYPE_INT32},
	[4] = {.name = "flag", .type = BLOBMSG_TYPE_INT32},
};

static const struct blobmsg_policy lwm2m_delete_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
};

static const struct blobmsg_policy lwm2m_addobj_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "objectId", .type = BLOBMSG_TYPE_INT32},
	[2] = {.name = "instanceCount", .type = BLOBMSG_TYPE_INT32},
	[3] = {.name = "instanceBitMap", .type = BLOBMSG_TYPE_STRING},
	[4] = {.name = "attributeCount", .type = BLOBMSG_TYPE_INT32},
	[5] = {.name = "actionCount", .type = BLOBMSG_TYPE_INT32},
};

static const struct blobmsg_policy lwm2m_delobj_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "objectId", .type = BLOBMSG_TYPE_INT32},
};

static const struct blobmsg_policy lwm2m_open_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "lifetime", .type = BLOBMSG_TYPE_INT32},
	[2] = {.name = "timeout", .type = BLOBMSG_TYPE_INT32},
};

static const struct blobmsg_policy lwm2m_update_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "lifetime", .type = BLOBMSG_TYPE_INT32},
	[2] = {.name = "objflag", .type = BLOBMSG_TYPE_INT32},
};

static const struct blobmsg_policy lwm2m_discoverresp_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "msgId", .type = BLOBMSG_TYPE_INT32},
	[2] = {.name = "result", .type = BLOBMSG_TYPE_INT32},
	[3] = {.name = "length", .type = BLOBMSG_TYPE_INT32},
	[4] = {.name = "context", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy lwm2m_readrsp_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "msgId", .type = BLOBMSG_TYPE_INT32},
	[2] = {.name = "result", .type = BLOBMSG_TYPE_INT32},
	[3] = {.name = "objectid", .type = BLOBMSG_TYPE_INT32},
	[4] = {.name = "instanceid", .type = BLOBMSG_TYPE_INT32},
	[5] = {.name = "resourceid", .type = BLOBMSG_TYPE_INT32},
	[6] = {.name = "valuetype", .type = BLOBMSG_TYPE_INT32},
	[7] = {.name = "len", .type = BLOBMSG_TYPE_INT32},
	[8] = {.name = "context", .type = BLOBMSG_TYPE_STRING},
	[9] = {.name = "index", .type = BLOBMSG_TYPE_INT32},
	[10] = {.name = "flag", .type = BLOBMSG_TYPE_INT32},
};


static const struct blobmsg_policy lwm2m_writersp_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "msgId", .type = BLOBMSG_TYPE_INT32},
	[2] = {.name = "result", .type = BLOBMSG_TYPE_INT32},
};


static const struct blobmsg_policy lwm2m_notify_policy[] = {
	[0] = {.name = "ref", .type = BLOBMSG_TYPE_INT32},
	[1] = {.name = "msgId", .type = BLOBMSG_TYPE_INT32},
	[2] = {.name = "objectid", .type = BLOBMSG_TYPE_INT32},
	[3] = {.name = "instanceid", .type = BLOBMSG_TYPE_INT32},
	[4] = {.name = "resourceid", .type = BLOBMSG_TYPE_INT32},
	[5] = {.name = "valuetype", .type = BLOBMSG_TYPE_INT32},
	[6] = {.name = "len", .type = BLOBMSG_TYPE_INT32},
	[7] = {.name = "context", .type = BLOBMSG_TYPE_STRING},
	[8] = {.name = "index", .type = BLOBMSG_TYPE_INT32},
	[9] = {.name = "flag", .type = BLOBMSG_TYPE_INT32},
	[10] = {.name = "ackid", .type = BLOBMSG_TYPE_INT32},
};

static int lwm2mgetversion_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mcreate_default_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mcreate_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mdelete_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2maddobj_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mdelobj_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mopen_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mupdate_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mclose_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mdiscoverresp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mreadrsp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mwritersp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mexcutersp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mparameterrsp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mobserverrsp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

static int lwm2mnotify_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg);

//static void lwm2m_subscribe_cb(struct ubus_context *ctx, struct ubus_object *obj);
int lwm2m_invoke_reply(struct ubus_context *ctx, const char *service,
                   const char *method, struct blob_attr *msg,int timeout);

void init_lwm2m_context();
cis_ret_t lwm2m_on_read(void* context,cis_uri_t* uri,cis_mid_t mid);
cis_ret_t lwm2m_on_discover(void* context,cis_uri_t* uri,cis_mid_t mid);
cis_ret_t lwm2m_on_write(void* context,cis_uri_t* uri,const cis_data_t* value,cis_attrcount_t attrcount,cis_mid_t mid);
cis_ret_t lwm2m_on_exec(void* context,cis_uri_t* uri,const uint8_t* value,uint32_t length,cis_mid_t mid);
cis_ret_t lwm2m_on_observe(void* context,cis_uri_t* uri,BOOL flag,cis_mid_t mid);
cis_ret_t lwm2m_on_params(void* context,cis_uri_t* uri,cis_observe_attr_t parameters,cis_mid_t mid);
cis_ret_t lwm2m_on_params(void* context,cis_uri_t* uri,cis_observe_attr_t parameters,cis_mid_t mid);
void lwm2m_on_event(void* context,cis_evt_t eid,void* param);
int32_t lwm2m_init();
void lwm2m_deinit();
int32_t parase_resource_from_value(char *value,int index);
int32_t get_resource_count_from_value(char *value);
void lwm2m_pump();
int lwm2m_ubus_init(void);
void lwm2m_get_imsi();
void lwm2m_get_imei();



static const struct ubus_method lwm2m_methods[] = {	
		UBUS_METHOD_NOARG("version",			lwm2mgetversion_method),
		UBUS_METHOD_NOARG("createdefault",		lwm2mcreate_default_method),
		UBUS_METHOD("create",            		lwm2mcreate_method,				lwm2m_create_policy),
		UBUS_METHOD("delete", 					lwm2mdelete_method,				lwm2m_delete_policy),
		UBUS_METHOD("addobj", 					lwm2maddobj_method,				lwm2m_addobj_policy),
		UBUS_METHOD("delobj", 					lwm2mdelobj_method,				lwm2m_delobj_policy),
		UBUS_METHOD("open", 					lwm2mopen_method,				lwm2m_open_policy),
		UBUS_METHOD("update", 					lwm2mupdate_method,				lwm2m_update_policy),
		UBUS_METHOD("close", 					lwm2mclose_method,				lwm2m_delete_policy),
		UBUS_METHOD("discoverresp", 			lwm2mdiscoverresp_method,		lwm2m_discoverresp_policy),
		UBUS_METHOD("readrsp", 					lwm2mreadrsp_method,			lwm2m_readrsp_policy),
		UBUS_METHOD("writersp", 				lwm2mwritersp_method,			lwm2m_writersp_policy),
		UBUS_METHOD("excutersp", 				lwm2mexcutersp_method,			lwm2m_writersp_policy),
		UBUS_METHOD("parameterrsp", 			lwm2mparameterrsp_method,		lwm2m_writersp_policy),
		UBUS_METHOD("observerrsp", 				lwm2mobserverrsp_method,		lwm2m_writersp_policy),
		UBUS_METHOD("notify", 					lwm2mnotify_method,				lwm2m_notify_policy),

};
static struct ubus_object_type lwm2m_object_type = UBUS_OBJECT_TYPE("lwm2m", lwm2m_methods);

static struct ubus_object lwm2m_object = {
	.name = "lwm2m",
	.type = &lwm2m_object_type,
	.methods = lwm2m_methods,
	.n_methods = ARRAY_SIZE(lwm2m_methods),
};
//static struct ubus_subscriber lwm2m_ind_event;
static pthread_t s_tid_lwm2mMainTask;


static int lwm2m_client_fd=-1;


/*
static struct ubus_object_type lwm2m_notify_object_type;

static struct ubus_object lwm2m_notify_obj[1] =
{
    {.name = "lwm2m_ind",  .type = &lwm2m_notify_object_type, .subscribe_cb = lwm2m_subscribe_cb},
};
*/



static const uint8_t config_hex[] = {0x13,0x00,0x3b,
    0xf1,0x00,0x03,
    0xf2,0x00,0x29,0x05,0x00/*mtu*/,0x11/*Link&bind type*/,0x80/*BS ENABLED*/,0x00,0x00/*vpn*/,0x00,0x00/*username*/,0x00,0x00/*password*/,
    0x00,0x14/*host length*/,0x6e,0x62,0x69,0x6f,0x74,0x62,0x74,0x2e,0x68,0x65,0x63,0x6c,0x6f,0x75,0x64,0x73,0x2e,0x63,
    0x6f,0x6d,0x00,0x04,0x4e,0x55,0x4c,0x4c,0xf3,0x00,0x0c,0xea,0x04,0x00,0x00,0x04,0x4e,0x55,0x4c,0x4c};




struct miplContext lwm2m_context = {0};
static INT32 lwm2m_clear_register_flag();
extern void *lwm2m_recv_thread(void* argv);


/*
static void lwm2m_subscribe_cb(struct ubus_context *ctx, struct ubus_object *obj)
{
    UNUSED(ctx);
	lwm2m_printf("lwm2m Subscribers active: %d\n", obj->has_subscribers);
    //RIL_onNewConnect();

	
}
*/

int  utils_findDataType(cis_data_t * dataP)
{
    int res = dataP->type;
    LOGD("resource id is %d",dataP->id);
    switch(dataP->id){
    //boolean
    case digital_input_state:
    case digital_input_polarity:
    case increase_input_state:
    case decrease_input_state:
    case digital_state:
    case digital_output_state:
    case digital_output_polarity:
    case on_off:
        res = cis_data_type_bool;
        utils_opaqueToInt(dataP->asBuffer.buffer,dataP->asBuffer.length,&dataP->value.asInteger);
        break;
    //integer
    case digital_input_counter:
    case digital_input_debounce:
    case digital_input_edge_selection:
    case mode:
    case x_coordinate:
    case y_coordinate:
    case counter:
    case up_counter:
    case down_counter:
    case max_x_coordinate:
    case max_y_coordinate:
    case multi_state_input:
    case criticality_level:
    case duty_cycle:
    case dimmer:
    case on_time:
    case off_time:
    case busy_to_clear_delay:
    case clear_to_busy_delay:
    case bitmap_input:
        res = cis_data_type_integer;
        utils_opaqueToInt(dataP->asBuffer.buffer,dataP->asBuffer.length,&dataP->value.asInteger);
        break;
    //float
    case fractional_time:
    case min_x_value:
    case max_x_value:
    case min_y_value:
    case max_y_value:
    case min_z_value:
    case max_z_value:
    case min_limit:
    case max_limit:
    case delay_duration:
    case duration:
    case minimum_off_time:
    case contrast:
    case current_position:
    case transition_time:
    case remaining_time:
    case cumulative_time:
    case level:
    case analog_input_state:
    case min_measured_value:
    case max_measured_value:
    case min_range_value:
    case max_range_value:
    case analog_output_current_value:
    case sensor_value:
    case x_value:
    case y_value:
    case z_value:
    case compass_direction:
    case instantaneous_active_power:
    case min_measured_active_power:
    case max_measured_active_power:
    case min_range_active_power:
    case max_range_active_power:
    case cumulative_active_power:
    case active_power_calibration:
    case instantaneous_reactive_power:
    case min_measured_reactive_power:
    case max_measured_reactive_power:
    case min_range_reactive_power:
    case max_range_reactive_power:
    case cumulative_reactive_power:
    case reactive_power_calibration:
    case power_factor:
    case current_calibration:
    case start_time:
    case duration_in_min:
    case set_point_value:
        res = cis_data_type_float;
        utils_opaqueToFloat(dataP->asBuffer.buffer,dataP->asBuffer.length,&dataP->value.asFloat);
        break;
    //string
    case latitude:
    case longitude:
    case uncertainty:
    case text:
    case sensor_units:
    case colour:
    case application_type:
    case sensor_type:
    case event_identifier:
    case avg_load_adj_pct:
    case muti_state_output:
    case element_description:
    case uuid:
        res = cis_data_type_string;
        break;
    
        
    default:
        break;
    }

    return res;
}

void init_lwm2m_context()
{
    memset(&lwm2m_context,0,sizeof(struct miplContext));
}

cis_ret_t lwm2m_on_read		        (void* context,cis_uri_t* uri,cis_mid_t mid)
{
	UNUSED(context);
	int ref=0;
	int msgid=0;
	int objectid=0;
	int instanceid=0;
	int resourceid=0;
	int res;
    
    lwm2m_printf("lwm2m_on_read:(%d/%d/%d)\r\n",uri->objectId,uri->instanceId,uri->resourceId);
	if(CIS_URI_IS_SET_RESOURCE(uri)){
		ref = 0;
		msgid = mid;
		objectid = uri->objectId;
		instanceid = uri->instanceId;
		resourceid = uri->resourceId;
	}else if(!CIS_URI_IS_SET_RESOURCE(uri)&& CIS_URI_IS_SET_INSTANCE(uri)){
		ref = 0;
		msgid = mid;
		objectid = uri->objectId;
		instanceid = uri->instanceId;
		resourceid = -1;
	}else if(!CIS_URI_IS_SET_RESOURCE(uri)&& !CIS_URI_IS_SET_INSTANCE(uri)){
		ref = 0;
		msgid = mid;
		objectid = uri->objectId;
		instanceid = -1;
		resourceid = -1;
	}

	struct lwm2m_usock_head msg;
	msg.msgId = 0x2795;
	msg.msgData = (char *)malloc(256);
	memset(msg.msgData,0,256);
	res=snprintf(msg.msgData, 256, "+MIPLREAD: %d,%d,%d,%d,%d",
		ref,msgid,objectid,instanceid,resourceid);
	msg.msgLen = res;
	if(lwm2m_client_fd){
		write(lwm2m_client_fd, &msg, sizeof(struct lwm2m_usock_head));
		write(lwm2m_client_fd, msg.msgData, msg.msgLen);
	}
	
	free(msg.msgData);


	return CIS_CALLBACK_CONFORM;

}


cis_ret_t lwm2m_on_discover	(void* context,cis_uri_t* uri,cis_mid_t mid)
{
	int res;
	UNUSED(context);
    if(CIS_URI_IS_SET_RESOURCE(uri)){
        lwm2m_printf("lwm2m_on_discover:(%d/%d/%d)\r\n",uri->objectId,uri->instanceId,uri->resourceId);
    }
    else if(CIS_URI_IS_SET_INSTANCE(uri)){
        lwm2m_printf("lwm2m_on_discover:(%d/%d)\r\n",uri->objectId,uri->instanceId);
    }
    else{
        lwm2m_printf("lwm2m_on_discover:(%d)\r\n",uri->objectId);
    }
    
	struct lwm2m_usock_head msg;
	msg.msgId = 0x2795;
	msg.msgData = (char *)malloc(256);
	memset(msg.msgData,0,256);
	res=snprintf(msg.msgData, 256, "+MIPLDISCOVER: %d,%d,%d", 
        0,mid,uri->objectId);
	msg.msgLen = res;

	if(lwm2m_client_fd){
		write(lwm2m_client_fd, &msg, sizeof(struct lwm2m_usock_head));
		write(lwm2m_client_fd, msg.msgData, msg.msgLen);
	}

	free(msg.msgData);

    return CIS_CALLBACK_CONFORM;
}


cis_ret_t lwm2m_on_write		        (void* context,cis_uri_t* uri,const cis_data_t* value,cis_attrcount_t attrcount,cis_mid_t mid)
{
	UNUSED(context);
    int i,j;
    const cis_data_t* temp_value = NULL;

	int ref=0;
	int msgid=0;
	int objectid=0;
	int instanceid=0;
	int resourceid=0;
	int valuetype=0;
	int index=0;
	int flag=0;
	int length=0;
	char buf[512] ={0};
	int res;


    if(CIS_URI_IS_SET_RESOURCE(uri)){
        lwm2m_printf("lwm2m_on_write:(%d/%d/%d)\r\n",uri->objectId,uri->instanceId,uri->resourceId);
    }
    else{
        lwm2m_printf("lwm2m_on_write:(%d/%d)\r\n",uri->objectId,uri->instanceId);
    }

    int temp_index = attrcount;
    lwm2m_printf("lwm2m_on_write: attrcount(%d)\r\n",attrcount);
    for(i = 0;i<attrcount;i++)
    { 
        temp_value = value+i;

        ref = 0;
        msgid = mid;
        objectid = uri->objectId;
        instanceid = uri->instanceId;
        resourceid = temp_value->id;
        valuetype = temp_value->type;
        index = temp_index-1;
        if(index==0){
            flag=0;
        }else if(i==0){
            flag=1;
        }else{
            flag=2;
        }
        lwm2m_printf("lwm2m_on_write: valuetype(%d)\r\n",valuetype);
        /*
        res = writeInd->valuetype;
        if(writeInd->valuetype == cis_data_type_opaque){
            lwm2m_printf("lwm2m_on_write: length(%d)\n",temp_value->asBuffer.length);
            LOG_BUF("buffer",temp_value->asBuffer.buffer,temp_value->asBuffer.length);
            res=utils_findDataType(temp_value);
        }
        lwm2m_printf("lwm2m_on_write: res(%d)\n",res);
        */
        if(temp_value->type == cis_data_type_string ){
            //lwm2m_printf("lwm2m_on_write: length(%d)\n",temp_value->asBuffer.length);
            length = temp_value->asBuffer.length;
            //lwm2m_printf("lwm2m_on_write: value(%s)\n",temp_value->asBuffer.buffer);
            //char *temp=value->value.asChildren.array[i].asBuffer.buffer;
            //LOG_BUF("buffer",temp,writeInd->length+1);
            cissys_memcpy(buf,temp_value->asBuffer.buffer,length);
        }else if(temp_value->type == cis_data_type_integer){
            int size;
            //temp_value->value.asInteger = 0;
            //cissys_memcpy(&temp_value->value.asInteger,temp_value->asBuffer.buffer,temp_value->asBuffer.length);
            size = snprintf(buf, 512, "%lld",temp_value->value.asInteger);
            length = size;
        }else if(temp_value->type == cis_data_type_float){
            int size;
            size = snprintf(buf, 512, "%f",temp_value->value.asFloat);
            length = size;
        }else if(temp_value->type == cis_data_type_bool){
            int size;
            lwm2m_printf("lwm2m_on_write: value(%lld)\r\n",temp_value->value.asInteger);
            size = snprintf(buf, 512, "%lld",temp_value->value.asInteger);
            length = size;
        }else if(temp_value->type == cis_data_type_opaque){
            
            lwm2m_printf("lwm2m_on_write: length(%d)\r\n",temp_value->asBuffer.length);
            length = temp_value->asBuffer.length;
            uint8_t *temp=temp_value->asBuffer.buffer;
            LOG_BUF("buffer",temp,length);
            for(j=0;j<length;j++)
        	{
        	    snprintf(buf+j,512,"%02d",*(temp+j));
        	}

        }
        
        if(valuetype != cis_data_type_undefine){
			
			struct lwm2m_usock_head msg;
			msg.msgId = 0x2795;
			msg.msgData = (char *)malloc(512);
			memset(msg.msgData,0,512);
			res=snprintf(msg.msgData, 512, "+MIPLWRITE: %d,%d,%d,%d,%d,%d,%d,%s,%d,%d", 
				ref,msgid,objectid,instanceid,resourceid,
		        valuetype,length,buf,flag,index);
			msg.msgLen = res;
			if(lwm2m_client_fd){
				write(lwm2m_client_fd, &msg, sizeof(struct lwm2m_usock_head));
				write(lwm2m_client_fd, msg.msgData, msg.msgLen);
			}
			free(msg.msgData);



        }
		
		temp_index --;
    }

    return CIS_CALLBACK_CONFORM;

}

cis_ret_t lwm2m_on_exec              (void* context,cis_uri_t* uri,const uint8_t* value,uint32_t length,cis_mid_t mid)
{
	UNUSED(context);
	int res;
    if(CIS_URI_IS_SET_RESOURCE(uri)){
        lwm2m_printf("lwm2m_on_exec:(%d/%d/%d)\r\n",uri->objectId,uri->instanceId,uri->resourceId);
    }
    else{
        return CIS_CALLBACK_METHOD_NOT_ALLOWED;
    }

    if(!CIS_URI_IS_SET_INSTANCE(uri))
    {
        return CIS_CALLBACK_BAD_REQUEST;
    }




	struct lwm2m_usock_head msg;
	msg.msgId = 0x2795;
	msg.msgData = (char *)malloc(256);
	memset(msg.msgData,0,256);

	if(length==0){
        res=snprintf(msg.msgData, 256, "+MIPLEXECUTE: %d,%d,%d,%d,%d", 
            0,mid,uri->objectId,uri->instanceId,uri->resourceId);

    }else{
        res=snprintf(msg.msgData, 256, "+MIPLEXECUTE: %d,%d,%d,%d,%d,%d,\"%s\"", 
            0,mid,uri->objectId,uri->instanceId,uri->resourceId,length,value);

    }
	msg.msgLen = res;

	if(lwm2m_client_fd){
		write(lwm2m_client_fd, &msg, sizeof(struct lwm2m_usock_head));
		write(lwm2m_client_fd, msg.msgData, msg.msgLen);
	}
	free(msg.msgData);



    return CIS_CALLBACK_CONFORM;

}



cis_ret_t lwm2m_on_observe         (void* context,cis_uri_t* uri,BOOL flag,cis_mid_t mid)
{
	UNUSED(context);
	int flag_value;
	int resourceid;
	int instanceid;
	int res;

    if(flag){
        LOGD("cis_on_observe set: %d/%d/%d\n",
            uri->objectId,
            CIS_URI_IS_SET_INSTANCE(uri)?uri->instanceId:-1,
            CIS_URI_IS_SET_RESOURCE(uri)?uri->resourceId:-1);
        
    }else{
        LOGD("cis_on_observe cancel: %d/%d/%d\n",
            uri->objectId,
            CIS_URI_IS_SET_INSTANCE(uri)?uri->instanceId:-1,
            CIS_URI_IS_SET_RESOURCE(uri)?uri->resourceId:-1);
    }

    if(flag){
        flag_value = 1;
    }else{
        flag_value = 0;
    }
     LOGD("cis_on_observe mid: %d objectid: %d\n",mid,uri->objectId);

    if(CIS_URI_IS_SET_RESOURCE(uri)){
        resourceid = uri->resourceId;
    }else{
        resourceid =-1;
    }
    if(CIS_URI_IS_SET_INSTANCE(uri)){
        instanceid = uri->instanceId;
    }else{
        instanceid =-1;
    }




	struct lwm2m_usock_head msg;
	msg.msgId = 0x2795;
	msg.msgData = (char *)malloc(256);
	memset(msg.msgData,0,256);
    res=snprintf(msg.msgData, 256, "+MIPLOBSERVE: %d,%d,%d,%d,%d,%d", 
        0,mid,flag_value,uri->objectId,instanceid,resourceid);
	msg.msgLen = res;

	
	if(lwm2m_client_fd){
		write(lwm2m_client_fd, &msg, sizeof(struct lwm2m_usock_head));
		write(lwm2m_client_fd, msg.msgData, msg.msgLen);
	}
	free(msg.msgData);


    return CIS_CALLBACK_CONFORM;

}


cis_ret_t lwm2m_on_params         (void* context,cis_uri_t* uri,cis_observe_attr_t parameters,cis_mid_t mid)
{
	UNUSED(context);
	char value[128]={0};
	int res;


    if(CIS_URI_IS_SET_RESOURCE(uri)){
        lwm2m_printf("cis_on_params:(%d/%d/%d)\r\n",uri->objectId,uri->instanceId,uri->resourceId);
    }
    else{
        return CIS_CALLBACK_METHOD_NOT_ALLOWED;
    }

    if(!CIS_URI_IS_SET_INSTANCE(uri))
    {
        return CIS_CALLBACK_BAD_REQUEST;
    }


	int size;

    size = snprintf(value, 512, "pmin=%d;pmax=%d;lt=%f;gt=%f;stp=%f", 
        parameters.minPeriod, parameters.maxPeriod,parameters.lessThan,parameters.greaterThan,parameters.step);
	

	struct lwm2m_usock_head msg;
	msg.msgId = 0x2795;
	msg.msgData = (char *)malloc(256);
	memset(msg.msgData,0,256);
    res=snprintf(msg.msgData, 256, "+MIPLPARAMETER: %d,%d,%d,%d,%d,%d,\"%s\"", 
        0,mid,uri->objectId,uri->instanceId,uri->resourceId,size,value);	
	msg.msgLen = res;
	if(lwm2m_client_fd){
		write(lwm2m_client_fd, &msg, sizeof(struct lwm2m_usock_head));
		write(lwm2m_client_fd, msg.msgData, msg.msgLen);
	}
	free(msg.msgData);



    return CIS_CALLBACK_CONFORM;
}



void lwm2m_on_event             (void* context,cis_evt_t eid,void* param)
{
	int value;
	int res;
    lwm2m_printf("cis_on_event(%d):%s\r\n",eid,STR_EVENT_CODE(eid));
    switch(eid)
    {
        case CIS_EVENT_RESPONSE_FAILED:
            lwm2m_printf("cis_on_event response failed mid:%d\r\n",(int32_t)param);
            break;
        case CIS_EVENT_NOTIFY_FAILED:
            lwm2m_printf("cis_on_event notify failed mid:%d\r\n",(int32_t)param);
            break;
        case CIS_EVENT_UPDATE_NEED:
            lwm2m_printf("cis_on_event need to update,reserve time:%ds\r\n",(int32_t)param);
            cis_update_reg(context,LIFETIME_INVALID,false);
            break;
        case CIS_EVENT_REG_SUCCESS:
            {
            /*
                struct st_observe_info* delnode;
                while(g_observeList != NULL){
                    g_observeList =(st_observe_info *)CIS_LIST_RM((cis_list_t *)g_observeList,g_observeList->mid,(cis_list_t **)&delnode);
                    free(delnode);
                }
            */
            }
            break;
        case CIS_EVENT_UNREG_DONE:
            lwm2m_printf("cis_on_event close done\r\n");
            lwm2m_clear_register_flag();
            break;
        default:
            break;
    }  


	struct lwm2m_usock_head msg;
	msg.msgId = 0x2795;
	msg.msgData = (char *)malloc(256);
	memset(msg.msgData,0,256);
	value = (int)param;
	if(param){
        res=snprintf(msg.msgData, 256, "+MIPLEVENT: %d,%d,%d", 
            0,eid,value);

    }else{
        res=snprintf(msg.msgData, 256, "+MIPLEVENT: %d,%d", 
            0,eid);

    }	
	msg.msgLen = res;
	if(lwm2m_client_fd){
		write(lwm2m_client_fd, &msg, sizeof(struct lwm2m_usock_head));
		write(lwm2m_client_fd, msg.msgData, msg.msgLen);
	}
	free(msg.msgData);


}


int32_t lwm2m_init()
{
    cis_version_t ver;
    lwm2m_context.g_lifetime = 20;
    
    /*init sample data*/
    //prv_make_sample_data();
    cis_version(&ver);
    lwm2m_printf("CIS SDK Version:%u.%u.%u\r\n",ver.major,ver.minor,ver.micro);

    if(cis_init(&g_context,lwm2m_context.config,lwm2m_context.config_size,NULL,NULL) != CIS_RET_OK){
        lwm2m_printf("%s init failed.\r\n",__func__);
        return LWM2MRC_FAIL;
    }

    return LWM2MRC_SUCCESS;


}

void lwm2m_deinit()
{
    cis_deinit(&g_context);

}



static int32_t lwm2m_clear_register_flag()
{
    lwm2m_context.register_flag = 0;

    return LWM2MRC_SUCCESS;

}


static int lwm2m_get_boolean(const char * value)
{
	if (value) {
		if (!strcmp(value, "true")) {
			return 1;
		} else if (!strcmp(value, "on")) {
			return 1;
		} else if (!strcmp(value, "1")) {
			return 1;
		} else if (!strcmp(value, "yes")) {
			return 1;
		}
	}
	return 0;
}

int32_t parase_resource_from_value(char *value,int index)
{
    int i,len;
    char *p=NULL;
    char *q=NULL;
    char *t=NULL;
    if(value==NULL){
        return -1;
    }
   
    len=strlen(value);
    if(len<=0){
        return -1;
    }
    q=(char *)malloc(len+10);
    t=q;
    memset(q,0,len+10);
    memcpy(q,value,len);
    int res=-1;
    for(i=0;i<index;i++){
        p= strstr(q,";");
        if(p==NULL && (i+1)==index){
            res = atoi(q);
            goto out;
        }else if(p!=NULL && (i+1)==index){
            *p = 0;
            res = atoi(q);
            goto out;
        }else if(p!=NULL && (i+1)!=index){
            q=p+1;
        }
    }
out:
    free(t);
    return res;

}

int32_t get_resource_count_from_value(char *value)
{
    int i,len;
    int count=1;
    if(value==NULL){
        return 0;
    }
   
    len=strlen(value);
    if(len<=0){
        return 0;
    }
    for(i=0;i<len;i++){
        if(*(value+i)==';'){
            count++;
        }
    }

    return count;

}

/*
static BOOL lwm2m_getInstId(uint8_t* inst_bitmap,uint8_t index,cis_iid_t* iid)
{
    if (inst_bitmap == NULL)
    {
        return 0;
    }

    uint8_t bytes = index / 8;
    uint8_t bits = index % 8;

    if ((*(inst_bitmap + bytes) >> (7 - bits)) & 0x01) {
        if(iid != NULL)*iid = index;
        return true;
    }
    return false;
}
*/


void lwm2m_pump()
{
    //int i = 0;
    
    /*pump function*/
    cis_pump(g_context);

    /*update lifetime*/
    /*
    uint32_t nowtime = cissys_gettime();
    if(nowtime - g_lifetime_last > ((g_lifetime-5) * 1000)){
        g_lifetime_last = cissys_gettime();
        cis_update_reg(g_context,LIFETIME_INVALID,false);
    }
    
    if(g_callback.flag!=0){
        if((nowtime - g_callback.time)*200 > 10){
            prv_reset_callback_info();

        }

    }
    */

}


static void * lwm2m_main(void * param)
{
	UNUSED(param);
	struct timespec abstimeout;
	int ret;
    uint32_t pumpRet;
        /*update lifetime*/
    struct timeval nowtime ;
	uint32_t count;
	
    while(1){
        
		pthread_mutex_lock(&lwm2m_context.mutex);
        if(lwm2m_context.register_flag){        
            /*pump function*/
            pumpRet = cis_pump(g_context);
            if(pumpRet == PUMP_RET_NOSLEEP)
            {
                lwm2m_printf("%s,pump no sleep\r\n",__func__);
                //memset(&apiMsg,0,sizeof(struct miApiMsg));
                pthread_mutex_unlock(&lwm2m_context.mutex);
                continue;
            }else if(pumpRet == PUMP_RET_TRANSSLEEP){
            	gettimeofday(&nowtime, NULL);
				lwm2m_printf("%s,[%d]nowtime.tv_sec[%ld]\r\n",__func__,
					lwm2m_context.register_flag, 
					nowtime.tv_sec);
                //timeout = 200;
				abstimeout.tv_sec=nowtime.tv_sec+1;
				abstimeout.tv_nsec = nowtime.tv_usec * 1000;
            }else{
				gettimeofday(&nowtime, NULL);
				count=(uint32_t)(nowtime.tv_sec - lwm2m_context.g_lifetime_last.tv_sec);
                if(count >= (lwm2m_context.g_lifetime-5)){
                    //lwm2m_context.g_lifetime_last = cissys_gettime();
					gettimeofday(&lwm2m_context.g_lifetime_last, NULL);
                    cis_update_reg(g_context,LIFETIME_INVALID,false);
					//abstimeout.tv_sec = nowtime.tv_sec+5;
					//abstimeout.tv_nsec = nowtime.tv_usec * 1000;
                    //timeout=(lwm2m_context.g_lifetime -5)*200;
                    //memset(&apiMsg,0,sizeof(struct miApiMsg));
                    pthread_mutex_unlock(&lwm2m_context.mutex);
                    continue;
                }else{
                	abstimeout.tv_sec=nowtime.tv_sec+((lwm2m_context.g_lifetime_last.tv_sec+lwm2m_context.g_lifetime-5) - nowtime.tv_sec);
					abstimeout.tv_nsec = nowtime.tv_usec * 1000;
                    //timeout= (lwm2m_context.g_lifetime-5) * 1000 - (nowtime - lwm2m_context.g_lifetime_last);
                    //if(timeout/5){
                    //    timeout = timeout/5;
                    //}else{
                    //    timeout = 1;
                    //}
                }

            }

        }
		
		if (lwm2m_context.register_flag){

			lwm2m_printf("%s,[%d]abstimeout.tv_sec[%ld]\r\n",__func__,
					lwm2m_context.register_flag, 
					abstimeout.tv_sec);
			ret = pthread_cond_timedwait(&lwm2m_context.cond, &lwm2m_context.mutex, &abstimeout);
			if (ret == ETIMEDOUT) {
				lwm2m_printf("%s,pthread_cond_timedwait timeout\r\n",__func__);
			}

		}else{
			pthread_cond_wait(&lwm2m_context.cond, &lwm2m_context.mutex);
		}
		
		pthread_mutex_unlock(&lwm2m_context.mutex);
        
    }

    return NULL;
}




static int lwm2mgetversion_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;
	char version[64]={0};
/*	
	int ret;
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_string(&b, "event", "test");
	ret=ubus_notify(lwm2m_ubus_ctx, &lwm2m_object_type, "lwm2m", b.head, -1);
	if (ret)
		lwm2m_printf("%s: ubus notify error: ret=%d\n", __FUNCTION__, ret);


	ubus_notify_async

	blobmsg_buf_init(&wifi_buf);
	blobmsg_add_u32(&wifi_buf, "id", SSID_CHANGE_NOTIFY_ID);
	blobmsg_add_string(&wifi_buf, "new_ssid", new_ssid);
	if (ubus_notify_async(ctx, &wifi_service_object, "ssid_change", wifi_buf.head, &nreq))
		return 0;
	blob_buf_free(&wifi_buf);
	nreq.complete_cb = (void *)&ssid_change_notify_complete_cb;
	ubus_complete_request(ctx, &nreq.req, 100);

*/
    cis_version_t ver;
    cis_version(&ver);
    snprintf(version,64,"%u.%u.%u",ver.major,ver.minor,ver.micro);

	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_string(&b, "version", version);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}

static int lwm2mcreate_default_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);
	int len;
	static struct blob_buf b;
	unsigned long result;
	int retry=5;
	
	len=sizeof(config_hex)+1;
	lwm2m_context.config = (CHAR *)malloc(len);
	memset(lwm2m_context.config,0,len);
	memcpy(lwm2m_context.config,config_hex,sizeof(config_hex));
	lwm2m_context.config_size = sizeof(config_hex);
	result = lwm2m_init();
	
	if(result!=LWM2MRC_SUCCESS){
		lwm2m_printf("lwm2m_init failed\r\n"); 
	}else{

	start:
		if(lwm2m_client_fd<0){
			lwm2m_client_fd = usock(USOCK_UNIX, LWM2M_INNER_CONN_SOCKET, NULL);
			if (lwm2m_client_fd < 0) {
				if(retry){
					sleep(1);
					retry--;
					goto start;
				}
				lwm2m_printf("%s,Failed to connect to server\r\n",__FUNCTION__);
				result = LWM2MRC_FAIL;
			}
		}


	}

	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mcreate_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[5];
	int total_size=0;
	char * context=NULL;
	int index=0;
	int current_size=0;
	int flag=0;

    int result;
	int ref=0;

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_create_policy, 5, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }

    total_size = 	blobmsg_get_u32(tb[0]);
	context = 		blobmsg_get_string(tb[1]);
	index = 		blobmsg_get_u32(tb[2]);
	current_size = 	blobmsg_get_u32(tb[3]);
	flag = 			blobmsg_get_u32(tb[4]);
	lwm2m_printf("lwm2mcreate_method total_size[%d] index[%d] current_size[%d] flag[%d]\r\n",
				total_size,
				index,
				current_size,
				flag); 

    if(flag == 1){
        if(lwm2m_context.config){
            free(lwm2m_context.config);
            lwm2m_context.config =NULL;
        }
        lwm2m_context.config = (CHAR *)malloc(total_size + 10);
        memset(lwm2m_context.config,0,total_size +10);
        if(current_size > total_size) lwm2m_assert(0);
        memcpy(lwm2m_context.config,context,current_size);
        lwm2m_context.config_size = current_size;
    }else{
        if(lwm2m_context.config==NULL)lwm2m_assert(0);
        if((lwm2m_context.config_size + current_size) > total_size)lwm2m_assert(0);
        memcpy(lwm2m_context.config+lwm2m_context.config_size,context,current_size);
        lwm2m_context.config_size +=current_size;
    }

    result = LWM2MRC_SUCCESS;
    lwm2m_context.config_flag = flag;
    ref = 1;
    
    if(flag==0){ 
        result=lwm2m_init();
        if(result == LWM2MRC_SUCCESS){
            ref = 0;
        }
    }
 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);
	blobmsg_add_u32(&b, "ref", ref);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mdelete_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[1];

    int result;
	int ref;

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_delete_policy, 1, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }

    ref = blobmsg_get_u32(tb[0]);
	
	if(lwm2m_context.config && lwm2m_context.ref == ref){
		free(lwm2m_context.config);
		lwm2m_context.config =NULL;
		lwm2m_deinit();
		result = LWM2MRC_SUCCESS;
	}else{
		result = LWM2MRC_FAIL;
	}
	
 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}

static int lwm2maddobj_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[6];
	int ref;
	int objectId;
	int instanceCount;
	char * instanceBitMap;
	int attributeCount;
	int actionCount;

    int result;
	
    cis_ret_t ret;
    cis_res_count_t rescount;
    cis_inst_bitmap_t bitmap;

    uint16_t instCount,instBytes;
    const char* instAsciiPtr;
    uint8_t * instPtr;
    cis_oid_t oid;
    uint16_t i;
	lwm2m_printf("entry lwm2maddobj_method\r\n");

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_addobj_policy, 6, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }

    ref = 				blobmsg_get_u32(tb[0]);
	objectId = 			blobmsg_get_u32(tb[1]);
	instanceCount = 	blobmsg_get_u32(tb[2]);
	instanceBitMap = 	blobmsg_get_string(tb[3]);
	attributeCount = 	blobmsg_get_u32(tb[4]);
	actionCount = 		blobmsg_get_u32(tb[5]);
	

	if(lwm2m_context.config==NULL || lwm2m_context.ref != ref){
		result = LWM2MRC_FAIL;
		goto out;
	}

    oid = objectId;
    //instCount = strlen(instanceBitMap);
    instCount = instanceCount;
    instBytes = (instCount - 1) / 8 + 1;
    instAsciiPtr = instanceBitMap;
    lwm2m_printf("instCount[%d],instBytes[%d]\r\n",instCount,instBytes);

    instPtr = (uint8_t*)cis_malloc(instBytes);
    memset(instPtr,0,instBytes);
    
    for (i = 0;i < instCount;i++)
    {
        uint8_t instBytePos = i / 8;
        uint8_t instByteOffset = 7 - (i % 8);
        if(instAsciiPtr[i] == '1'){
            instPtr[instBytePos] += 0x01 << instByteOffset;
        }
    }

    rescount.attrCount = attributeCount;
    //resconfig.actionCount = addobj_req->instancecount;
    rescount.actCount = actionCount;
    bitmap.instanceCount = instCount;
    bitmap.instanceBitmap = instPtr;
    bitmap.instanceBytes = instBytes;

    lwm2m_printf("attrCount[%d],actCount[%d],instanceCount[%d],instanceBytes[%d]\r\n",
        rescount.attrCount,rescount.actCount,bitmap.instanceCount,bitmap.instanceBytes);

    ret = cis_addobject(g_context,oid,&bitmap,&rescount);
    cis_free(instPtr);
    if(ret == CIS_RET_NO_ERROR){
        result = LWM2MRC_SUCCESS;
    }else{
        result = LWM2MRC_FAIL;
    }
 	lwm2m_printf("lwm2maddobj_method finish\r\n");
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mdelobj_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[2];
	int ref;
	int objectId;


    int result;
	cis_ret_t ret;
	

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_delobj_policy, 2, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }

    ref = 		blobmsg_get_u32(tb[0]);
	objectId = 	blobmsg_get_u32(tb[1]);

	

	if(lwm2m_context.config==NULL || lwm2m_context.ref != ref){
		result = LWM2MRC_FAIL;
		goto out;
	}
    

    ret = cis_delobject(g_context,objectId);
    if(ret == CIS_RET_NO_ERROR){
        return LWM2MRC_SUCCESS;
    }else{
        return LWM2MRC_FAIL;
    }

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}

static int lwm2mopen_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[3];
	int ref;
	int lifetime;
	int timeout;


    int result;
	cis_ret_t ret;
	
	lwm2m_printf("%s\r\n",__func__);

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_open_policy, 3, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }

    ref = 		blobmsg_get_u32(tb[0]);
	lifetime = 	blobmsg_get_u32(tb[1]);
	timeout = 	blobmsg_get_u32(tb[2]);
	UNUSED(timeout);

    if(lwm2m_context.config==NULL 
        || lwm2m_context.ref != ref
        || lwm2m_context.config_flag!=0){
        result = LWM2MRC_FAIL;
		goto out;
    }

	cis_callback_t callback;
	callback.onRead = (cis_read_callback_t)lwm2m_on_read;
	callback.onWrite = (cis_write_callback_t)lwm2m_on_write;
	callback.onExec = (cis_exec_callback_t)lwm2m_on_exec;
    callback.onObserve = (cis_observe_callback_t)lwm2m_on_observe;
    callback.onSetParams = (cis_set_params_callback_t)lwm2m_on_params;
    callback.onEvent = (cis_event_callback_t)lwm2m_on_event;
    callback.onDiscover = (cis_discover_callback_t)lwm2m_on_discover;


    //lwm2m_context.g_lifetime_last = cissys_gettime();
	gettimeofday(&lwm2m_context.g_lifetime_last, NULL);
    ret = cis_register(g_context,lifetime,&callback);
    if(ret!=CIS_RET_OK){
        lwm2m_printf("%s register failed.\r\n",__func__);
        result = LWM2MRC_FAIL;
		goto out;
    }

    lwm2m_context.register_flag = 1;
	result = LWM2MRC_SUCCESS;
	
	lwm2m_printf("%s,register_flag success\r\n",__func__);
	
	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}

static int lwm2mupdate_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[3];
	int ref;
	int lifetime;
	int objflag;


    int result;
	cis_ret_t ret;
	

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_update_policy, 3, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
    ref = 		blobmsg_get_u32(tb[0]);
	lifetime = 	blobmsg_get_u32(tb[1]);
	objflag = 	blobmsg_get_u32(tb[2]);

	if(lwm2m_context.config==NULL 
		|| lwm2m_context.ref != ref){
		result = LWM2MRC_FAIL;
		goto out;
	}
	
    ret=cis_update_reg(g_context,lifetime,objflag);
    if(ret!=COAP_NO_ERROR){
       	result = LWM2MRC_FAIL;
        goto out;
    }
	result = LWM2MRC_SUCCESS;

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mclose_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[1];
	int ref;
    int result;
	

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_delete_policy, 1, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
	
    ref = blobmsg_get_u32(tb[0]);


	if(lwm2m_context.config==NULL 
		|| lwm2m_context.ref != ref){
		result = LWM2MRC_FAIL;
		goto out;
	}

	cis_unregister(g_context);

	result = LWM2MRC_SUCCESS;
	lwm2m_context.register_flag = 0;

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mdiscoverresp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[5];
	int ref=0;
	int msgId=0;
	int res=0;
	int length=0;
	char *buf=NULL;


    int result=0;
	int count=0;
	int i;
	cis_uri_t temp_uri;

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_discoverresp_policy, 5, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
	
	ref = 		blobmsg_get_u32(tb[0]);
	msgId = 	blobmsg_get_u32(tb[1]);
	res = 		blobmsg_get_u32(tb[2]);
	length = 	blobmsg_get_u32(tb[3]);
	buf = 		blobmsg_get_string(tb[4]);
	UNUSED(length);

    if(lwm2m_context.config==NULL 
        || lwm2m_context.ref != ref){
        result = LWM2MRC_FAIL;
		goto out;
    }
		
	lwm2m_printf("lwm2m_discover_rsp: ref(%d),msgid(%d),result(%d)\r\n",ref,msgId,res);
	if(res!=MIPLRS_205_CONTENT){
		result=RESULT_TO_RESPONSE(res);
		cis_response(g_context,NULL,NULL,msgId,result);
	
	}else{
		count=get_resource_count_from_value(buf);
		lwm2m_printf("lwm2m_discover_rsp: get count(%d)\r\n",count);
		for(i=0;i<count;i++){
			memset(&temp_uri,0,sizeof(cis_uri_t)); 
			temp_uri.objectId = URI_INVALID;
			temp_uri.instanceId = URI_INVALID;
			temp_uri.resourceId = parase_resource_from_value(buf,i+1);
			cis_uri_update(&temp_uri);
			cis_response(g_context,&temp_uri,NULL,msgId,CIS_RESPONSE_CONTINUE);
		}
		cis_response(g_context,NULL,NULL,msgId,CIS_RESPONSE_DISCOVER);
		
	}

	result = LWM2MRC_SUCCESS;

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}



static int lwm2mreadrsp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[11];
	int ref;
	int msgId;
	int res;
	int objectid;
	int instanceid;
	int resourceid;
	int valuetype;
	int len;
	char *buf;
	int index;
	int flag;


    int result;
	st_context_t *context = (st_context_t*)g_context;
    cis_uri_t uri={0};
    cis_data_t tmpdata={0};

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_readrsp_policy, 11, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
	
	ref = 			blobmsg_get_u32(tb[0]);
	msgId = 		blobmsg_get_u32(tb[1]);
	res = 			blobmsg_get_u32(tb[2]);
	objectid = 		blobmsg_get_u32(tb[3]);
	instanceid = 	blobmsg_get_u32(tb[4]);
	resourceid = 	blobmsg_get_u32(tb[5]);
	valuetype = 	blobmsg_get_u32(tb[6]);
	len = 			blobmsg_get_u32(tb[7]);
	buf = 			blobmsg_get_string(tb[8]);
	index = 		blobmsg_get_u32(tb[9]);
	flag = 			blobmsg_get_u32(tb[10]);



    if(lwm2m_context.config==NULL 
        || lwm2m_context.ref != ref){
        result = LWM2MRC_FAIL;
		goto out;
    }
	

    lwm2m_printf("lwm2m_read_rsp: ref(%d),msgid(%d),result(%d)\r\n",ref,msgId,res);
    if(res!=MIPLRS_205_CONTENT){
        if(index!=0){
            cis_response(context,NULL,NULL,msgId,CIS_RESPONSE_READ);
        }else{
            result=RESULT_TO_RESPONSE(res);
            cis_response(context,NULL,NULL,msgId,result);
        }
    }else{
        uri.objectId = objectid;
        uri.instanceId = instanceid;
        uri.resourceId = resourceid;

        if(valuetype == cis_data_type_bool){
            tmpdata.type = cis_data_type_bool;
            tmpdata.value.asBoolean = lwm2m_get_boolean(buf);
        }else if(valuetype == cis_data_type_integer){
            tmpdata.type = cis_data_type_integer;
            tmpdata.value.asInteger = atoi(buf);
        }else if(valuetype == cis_data_type_float){
            tmpdata.type = cis_data_type_float;
            tmpdata.value.asFloat = atof(buf);
        }else if(valuetype == cis_data_type_string){
            tmpdata.type = cis_data_type_string;
            tmpdata.asBuffer.length = len;
            tmpdata.asBuffer.buffer = (uint8_t*)strdup(buf);
        }else{
            //need check value type
        }
        if(index==0&& flag==0){

            cis_uri_update(&uri);
            cis_response(context,&uri,&tmpdata,msgId,CIS_RESPONSE_READ);
        }else{
            cis_uri_update(&uri);
            cis_response(context,&uri,&tmpdata,msgId,CIS_RESPONSE_CONTINUE);
        }

    }

	result = LWM2MRC_SUCCESS;

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mwritersp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[3];
	int ref;
	int msgId;
	int res;


    int result;

	

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_writersp_policy, 3, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
    ref 	= blobmsg_get_u32(tb[0]);
	msgId 	= blobmsg_get_u32(tb[1]);
	res 	= blobmsg_get_u32(tb[2]);

	if(lwm2m_context.config==NULL 
		|| lwm2m_context.ref != ref){
		result = LWM2MRC_FAIL;
		goto out;
	}
	
    st_context_t *context = (st_context_t*)g_context;
    lwm2m_printf("lwm2m_write_rsp: ref(%d),msgid(%d),result(%d)\r\n",ref,msgId,res);
    if(res!=MIPLRS_204_CHANGED){
        result=RESULT_TO_RESPONSE(res);
        cis_response(context,NULL,NULL,msgId,result);
    }else{
        cis_response(context,NULL,NULL,msgId,CIS_RESPONSE_WRITE);
    }


	result = LWM2MRC_SUCCESS;

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}

static int lwm2mexcutersp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[3];
	int ref;
	int msgId;
	int res;


    int result;
	

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_writersp_policy, 3, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
    ref 	= blobmsg_get_u32(tb[0]);
	msgId 	= blobmsg_get_u32(tb[1]);
	res 	= blobmsg_get_u32(tb[2]);

	if(lwm2m_context.config==NULL 
		|| lwm2m_context.ref != ref){
		result = LWM2MRC_FAIL;
		goto out;
	}


    st_context_t *context = (st_context_t*)g_context;
    lwm2m_printf("lwm2m_execute_rsp: ref(%d),msgid(%d),result(%d)\r\n",ref,msgId,res);
    if(res!=MIPLRS_204_CHANGED){
        result=RESULT_TO_RESPONSE(res);
        cis_response(context,NULL,NULL,msgId,result);
    }else{
        cis_response(context,NULL,NULL,msgId,CIS_RESPONSE_EXECUTE);
    }

	result = LWM2MRC_SUCCESS;

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mparameterrsp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[3];
	int ref;
	int msgId;
	int res;


    int result;
	

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_writersp_policy, 3, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
    ref 	= blobmsg_get_u32(tb[0]);
	msgId 	= blobmsg_get_u32(tb[1]);
	res 	= blobmsg_get_u32(tb[2]);

	if(lwm2m_context.config==NULL 
		|| lwm2m_context.ref != ref){
		result = LWM2MRC_FAIL;
		goto out;
	}
	
	st_context_t *context = (st_context_t*)g_context;
	lwm2m_printf("lwm2m_param_rsp: ref(%d),msgid(%d),result(%d)\r\n",ref,msgId,res);
	if(res!=MIPLRS_205_CONTENT){
		result=RESULT_TO_RESPONSE(res);
		cis_response(context,NULL,NULL,msgId,result);
	}else{
		cis_response(context,NULL,NULL,msgId,CIS_RESPONSE_OBSERVE_PARAMS);
	}

	result = LWM2MRC_SUCCESS;

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mobserverrsp_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[3];
	int ref;
	int msgId;
	int res;


    int result;	

    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_writersp_policy, 3, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
    ref 	= blobmsg_get_u32(tb[0]);
	msgId 	= blobmsg_get_u32(tb[1]);
	res 	= blobmsg_get_u32(tb[2]);

	if(lwm2m_context.config==NULL 
		|| lwm2m_context.ref != ref){
		result = LWM2MRC_FAIL;
		goto out;
	}
	

	st_context_t *context = (st_context_t*)g_context;
	lwm2m_printf("lwm2m_observe_rsp: ref(%d),msgid(%d),result(%d)\r\n",ref,msgId,res);
	if(res!=MIPLRS_205_CONTENT){
		result=RESULT_TO_RESPONSE(res);
		cis_response(context,NULL,NULL,msgId,result);
	}else{
		cis_response(g_context,NULL,NULL,msgId,CIS_RESPONSE_OBSERVE);
	}

	result = LWM2MRC_SUCCESS;

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:	
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static int lwm2mnotify_method(struct ubus_context *ctx, struct ubus_object *obj,
			       struct ubus_request_data *req, const char *method, struct blob_attr *msg)
{
	UNUSED(obj);
	UNUSED(msg);
	UNUSED(method);

	static struct blob_buf b;

    struct blob_attr *tb[11];
	int ref;
	int msgId;

	int objectid;
	int instanceid;
	int resourceid;
	int valuetype;
	int len;
	char *buf;
	int index;
	int flag;
	int ackid;


    int result;
    cis_uri_t uri={0};
    cis_data_t dataP;


    /*parsing blob to be accessed easily with tb array - parse "1" argument*/
    result = blobmsg_parse(lwm2m_notify_policy, 11, tb, blob_data(msg), blob_len(msg));
    if (result < 0) {
		result = LWM2MRC_FAIL;
        goto out;
    }
	
	ref = 			blobmsg_get_u32(tb[0]);
	msgId = 		blobmsg_get_u32(tb[1]);

	objectid = 		blobmsg_get_u32(tb[2]);
	instanceid = 	blobmsg_get_u32(tb[3]);
	resourceid = 	blobmsg_get_u32(tb[4]);
	valuetype = 	blobmsg_get_u32(tb[5]);
	len = 			blobmsg_get_u32(tb[6]);
	buf = 			blobmsg_get_string(tb[7]);
	index = 		blobmsg_get_u32(tb[8]);
	flag = 			blobmsg_get_u32(tb[9]);
	ackid = 		blobmsg_get_u32(tb[10]);

	UNUSED(flag);


    if(lwm2m_context.config==NULL 
        || lwm2m_context.ref != ref){
        result = LWM2MRC_FAIL;
		goto out;
    }
	



    
    uri.objectId = objectid;
    uri.instanceId = instanceid;
    uri.resourceId = resourceid;
    uri.flag = 0;
    memset(&dataP, 0, sizeof(cis_data_t));

    dataP.id = resourceid;
    if(valuetype == cis_data_type_bool){
        dataP.type = cis_data_type_bool;
        dataP.value.asBoolean = lwm2m_get_boolean(buf);
    }else if(valuetype == cis_data_type_integer){
        dataP.type = cis_data_type_integer;
        dataP.value.asInteger = atoi(buf);
    }else if(valuetype == cis_data_type_float){
        dataP.type = cis_data_type_float;
        dataP.value.asFloat = atof(buf);
    }else if(valuetype == cis_data_type_string){
        dataP.type = cis_data_type_string;
        dataP.asBuffer.length = len;
        dataP.asBuffer.buffer = (uint8_t*)strdup(buf);
    }else{
        //need check value type
    }

    if(index==0&& ackid==0){
        cis_uri_update(&uri);
        result=cis_notify(g_context,&uri,&dataP,msgId,CIS_NOTIFY_CONTENT,false);
    }else{
        cis_uri_update(&uri);
        result=cis_notify(g_context,&uri,&dataP,msgId,CIS_NOTIFY_CONTINUE,false);

    }

    if(result != CIS_RET_OK){
        lwm2m_printf("%s failed:(%d)\r\n",__func__,result);
        result = LWM2MRC_FAIL;
    }else{
        result = LWM2MRC_SUCCESS;
    }

	pthread_mutex_lock(&lwm2m_context.mutex);
	pthread_cond_signal(&lwm2m_context.cond);
	pthread_mutex_unlock(&lwm2m_context.mutex);

 
out:
	memset(&b, 0, sizeof(b));
	blob_buf_init(&b, 0);
	blobmsg_add_u32(&b, "result", result);

	ubus_send_reply(ctx, req, b.head);
	return 0;
}


static void lwm2m_get_imei_cb(struct ubus_request *req, int type, struct blob_attr *msg)
{
	UNUSED(req);
	UNUSED(type);
	unsigned int requestid;
	unsigned int rilerrno;
	char *response_data = NULL;
	int response_len = 0;

	if (rilutil_parseResponse(msg, &requestid, &rilerrno, (void *)&response_data, &response_len)) {
		lwm2m_printf("%s,Parse failed\r\n",__func__);
		return;
	}
	if (response_data && (response_len > 0)) {

		if (rilerrno != RIL_E_SUCCESS) {
			lwm2m_printf("%s,Ril error %d\r\n",__func__, rilerrno);
			rilutil_freeResponseData(requestid, response_data, response_len);
			return;
		}

		if (requestid == RIL_REQUEST_GET_IMEI) {
			lwm2m_printf("%s,len[%d],get IMEI=%s\n",__func__,response_len,response_data);
			if(response_len<20){
				memset(lwm2m_context.IMEI,0,20);
				memcpy(lwm2m_context.IMEI,response_data,response_len);
			}else{
				lwm2m_printf("%s,get IMEI abnormal\n",__func__);
			}
			
			
		}else{
			lwm2m_printf("%s,get requestid=%d\r\n",__func__,requestid);
		}
		rilutil_freeResponseData(requestid, response_data, response_len);
	} else {
		if (response_data) {
			rilutil_freeResponseData(requestid, response_data, response_len);
		}
		lwm2m_printf("%s,no response data,rilerror code %d\n", __func__,rilerrno);
	}


}




void lwm2m_get_imei()
{
	int ret;
	static struct blob_buf b;
	unsigned int ril_id=0;
	if(ubus_lookup_id(lwm2m_ubus_ctx,"ril",&ril_id)){
		lwm2m_printf("%s,ubus_lookup_id RIL failed\r\n",__func__);
		return;
	}

	memset(&b, 0, sizeof(b));
	blob_buf_init(&b,0);
	rilutil_makeRequestBlob(&b, RIL_REQUEST_GET_IMEI, NULL, 0);
	ret =ubus_invoke(lwm2m_ubus_ctx, ril_id, "ril_request", b.head, lwm2m_get_imei_cb, 0,0);
	if(ret != 0){
		lwm2m_printf("lwm2m_get_imei,ubus_invoke Failed %s\r\n", ubus_strerror(ret));
	}
	return;

}


static void lwm2m_get_imsi_cb(struct ubus_request *req, int type, struct blob_attr *msg)
{
	UNUSED(req);
	UNUSED(type);
	unsigned int requestid;
	unsigned int rilerrno;
	char *response_data = NULL;
	int response_len = 0;

	if (rilutil_parseResponse(msg, &requestid, &rilerrno, (void *)&response_data, &response_len)) {
		lwm2m_printf("%s,Parse failed\r\n",__func__);
		return;
	}
	if (response_data && (response_len > 0)) {

		if (rilerrno != RIL_E_SUCCESS) {
			lwm2m_printf("%s,Ril error %d\r\n",__func__, rilerrno);
			rilutil_freeResponseData(requestid, response_data, response_len);
			return;
		}
		if (requestid == RIL_REQUEST_GET_IMSI) {
			lwm2m_printf("%s,len[%d],get IMSI=%s\n",__func__,response_len,response_data);
			if(response_len<20){
				memset(lwm2m_context.IMSI,0,20);
				memcpy(lwm2m_context.IMSI,response_data,response_len);
			}else{
				lwm2m_printf("%s,get IMSI abnormal\n",__func__);
					
			}
			
		}else{
			lwm2m_printf("%s,get requestid=%d\r\n",__func__,requestid);
		}
		rilutil_freeResponseData(requestid, response_data, response_len);
	} else {
		if (response_data) {
			rilutil_freeResponseData(requestid, response_data, response_len);
		}
		lwm2m_printf("%s,no response data,rilerror code %d\n", __func__,rilerrno);
	}


}

void lwm2m_get_imsi()
{
	int ret;
	static struct blob_buf b;

	unsigned int ril_id=0;
	if(ubus_lookup_id(lwm2m_ubus_ctx,"ril",&ril_id)){
		lwm2m_printf("%s,ubus_lookup_id RIL failed\r\n",__func__);
		return;
	}

	memset(&b, 0, sizeof(b));
	blob_buf_init(&b,0);
	rilutil_makeRequestBlob(&b, RIL_REQUEST_GET_IMSI, NULL, 0);
	ret =ubus_invoke(lwm2m_ubus_ctx, ril_id, "ril_request", b.head, lwm2m_get_imsi_cb, 0,0);
	if(ret != 0){
		lwm2m_printf("lwm2m_get_imei,ubus_invoke Failed %s\r\n", ubus_strerror(ret));
	}
	return;
}


int lwm2m_ubus_init(void)
{

	int ret = 0;
	
	ret = ubus_add_object(lwm2m_ubus_ctx, &lwm2m_object);
	if (ret){
		lwm2m_printf("lwm2m_main,Failed to add object: %s\r\n", ubus_strerror(ret));
		return -1;
	}


	ret = pthread_cond_init(&lwm2m_context.cond, NULL);
	if (ret != 0)
		return ret;

	ret = pthread_mutex_init(&lwm2m_context.mutex, NULL);
	if (ret != 0) {
		pthread_cond_destroy(&lwm2m_context.cond);
		return ret;
	}

	ret = pthread_create(&s_tid_lwm2mMainTask, NULL, lwm2m_main, NULL);
	if(ret < 0){
		lwm2m_printf("Failed to create lwm2m main thread, ret:%d\r\n",ret);
		return -1;
	}

	lwm2m_get_imei();
	lwm2m_get_imsi();

	return 0;
}

int main(int argc,char **argv)
{
	UNUSED(argc);
	UNUSED(argv);
	const char *ubus_socket = NULL;
	
    Lwm2mMutexCreate();
	init_lwm2m_context();
	uloop_init();
	
	lwm2m_ubus_ctx = ubus_connect(ubus_socket);
	if(!lwm2m_ubus_ctx) {
		lwm2m_printf("%s: Failed to connect to ubus\r\n",__FUNCTION__);
		goto out;
	}

	ubus_add_uloop(lwm2m_ubus_ctx);
	
	int res=lwm2m_ubus_init();
	if(res){
		lwm2m_printf("%s: embms_main error!\r\n",__FUNCTION__);
		goto fail;
	}
	uloop_run();
fail:
	ubus_free(lwm2m_ubus_ctx);
out:
	uloop_done();
	return 0;

}