Change 'enable' method to async operation

[platform/core/connectivity/zigbee-manager.git] / zigbee-daemon / zigbee-lib / src / zblib_request.c

diff --git a/zigbee-daemon/zigbee-lib/src/zblib_request.c b/zigbee-daemon/zigbee-lib/src/zblib_request.c
index 3bbc5cf..b3c314f 100644 (file)
--- a/zigbee-daemon/zigbee-lib/src/zblib_request.c
+++ b/zigbee-daemon/zigbee-lib/src/zblib_request.c
@@ -126,7 +126,7 @@ static ZigBeeRequest *__zblib_request_ref_request_by_request_id(ZigBeeService *s
 
        /* Look-up requets_id in request hash table */
        request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
-       if (NULL == request_table) {
+       if (NULL == request) {
                Z_LOGE("No request available for request_id: [%d]", request_id);
                return NULL;
        }
@@ -300,8 +300,10 @@ static gpointer __zblib_request_create_custom_request_data(guint request_type,
                        req->profile_id = in_req->profile_id;
                        req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
                        req->mfg_code = in_req->mfg_code;
+                       req->cmd_id = in_req->cmd_id;
+                       req->payload_len = in_req->payload_len;
                        memcpy(req->payload,
-                               in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
+                               in_req->payload, req->payload_len);
                }
 
                custom_request_data = (gpointer)req;
@@ -325,8 +327,9 @@ static gpointer __zblib_request_create_custom_request_data(guint request_type,
                        req->cluster_id = in_req->cluster_id;
                        req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
                        req->cmd_id = in_req->cmd_id;
+                       req->payload_len = in_req->payload_len;
                        memcpy(req->payload,
-                               in_req->payload, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
+                               in_req->payload, req->payload_len);
                }
 
                custom_request_data = (gpointer)req;
@@ -344,8 +347,9 @@ static gpointer __zblib_request_create_custom_request_data(guint request_type,
                                g_malloc0(sizeof(ZigbeeCustomSendToLocal_t));
 
                        /* Copy data */
+                       req->length = in_req->length;
                        memcpy(req->data,
-                               in_req->data, ZIGBEE_CUSTOM_SEND_PAYLOAD_LEN);
+                               in_req->data, req->length);
                }
 
                custom_request_data = (gpointer)req;
@@ -1133,16 +1137,6 @@ static gpointer __zblib_request_create_service_request_data(guint request_type,
        /* Fetch ops ID */
        ops_id = __zblib_request_get_ops_id(request_type);
        switch (ops_id) {
-       case ZBLIB_SERVICE_OPS_ENABLE: {
-               service_request_data = NULL;
-       }
-       break;
-
-       case ZBLIB_SERVICE_OPS_DISABLE: {
-               service_request_data = NULL;
-       }
-       break;
-
        case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
                service_request_data = NULL;
        }
@@ -1480,12 +1474,16 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
 
                in_req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request_data;
                if (NULL != in_req) {
+                       guint i;
                        /* Allocate memory */
                        req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)
                                g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
 
                        /* Copy data */
-                       req->attribute_id = g_strdup(in_req->attribute_id);
+                       for (i = 0; i < (in_req->attribute_id_len * sizeof(short)); i++)
+                               Z_LOGE("in_req->attribute_id[%d] = 0x%X", i, in_req->attribute_id[i]);
+                       req->attribute_id = g_memdup(in_req->attribute_id,
+                               in_req->attribute_id_len * sizeof(short));
                        req->attribute_id_len = in_req->attribute_id_len;
                        req->node_id = in_req->node_id;
                        req->cluster_id = in_req->cluster_id;
@@ -1508,7 +1506,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                                g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t));
 
                        /* Copy data */
-                       req->write_records = g_strdup(in_req->write_records);
+                       req->write_records = g_memdup(in_req->write_records, in_req->records_len);
                        req->records_len = in_req->records_len;
                        req->node_id = in_req->node_id;
                        req->cluster_id = in_req->cluster_id;
@@ -1532,7 +1530,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                                g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
 
                        /* Copy data */
-                       req->write_records = g_strdup(in_req->write_records);
+                       req->write_records = g_memdup(in_req->write_records, in_req->records_len);
                        req->records_len = in_req->records_len;
                        req->node_id = in_req->node_id;
                        req->cluster_id = in_req->cluster_id;
@@ -1556,7 +1554,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                                g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
 
                        /* Copy data */
-                       req->write_records = g_strdup(in_req->write_records);
+                       req->write_records = g_memdup(in_req->write_records, in_req->records_len);
                        req->records_len = in_req->records_len;
                        req->node_id = in_req->node_id;
                        req->cluster_id = in_req->cluster_id;
@@ -1580,7 +1578,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                                g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
 
                        /* Copy data */
-                       req->write_records = g_strdup(in_req->write_records);
+                       req->write_records = g_memdup(in_req->write_records, in_req->records_len);
                        req->records_len = in_req->records_len;
                        req->node_id = in_req->node_id;
                        req->cluster_id = in_req->cluster_id;
@@ -1604,7 +1602,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                                g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
 
                        /* Copy data */
-                       req->read_records = g_strdup(in_req->read_records);
+                       req->read_records = g_memdup(in_req->read_records, in_req->records_len);
                        req->records_len = in_req->records_len;
                        req->node_id = in_req->node_id;
                        req->cluster_id = in_req->cluster_id;
@@ -1628,7 +1626,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                                g_malloc0(sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
 
                        /* Copy data */
-                       req->read_records = g_strdup(in_req->read_records);
+                       req->read_records = g_memdup(in_req->read_records, in_req->records_len);
                        req->records_len = in_req->records_len;
                        req->node_id = in_req->node_id;
                        req->cluster_id = in_req->cluster_id;
@@ -1652,7 +1650,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                                g_malloc0(sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
 
                        /* Copy data */
-                       req->read_records = g_strdup(in_req->read_records);
+                       req->read_records = g_memdup(in_req->read_records, in_req->records_len);
                        req->records_len = in_req->records_len;
                        req->node_id = in_req->node_id;
                        req->cluster_id = in_req->cluster_id;
@@ -1681,7 +1679,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                        req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
                        req->cluster_id = in_req->cluster_id;
                        req->start_attribute = in_req->start_attribute;
-                       req->max = in_req->max;
+                       req->max_attribute_count = in_req->max_attribute_count;
                }
 
                zclglobal_control_request_data = (gpointer)req;
@@ -1704,7 +1702,7 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                        req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
                        req->cluster_id = in_req->cluster_id;
                        req->start_attribute = in_req->start_attribute;
-                       req->max = in_req->max;
+                       req->max_attribute_count = in_req->max_attribute_count;
                }
 
                zclglobal_control_request_data = (gpointer)req;
@@ -1726,8 +1724,8 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                        req->dest_ep = in_req->dest_ep;
                        req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
                        req->cluster_id = in_req->cluster_id;
-                       req->start_attribute = in_req->start_attribute;
-                       req->max = in_req->max;
+                       req->start_command = in_req->start_command;
+                       req->max_command_count = in_req->max_command_count;
                }
 
                zclglobal_control_request_data = (gpointer)req;
@@ -1749,8 +1747,8 @@ static gpointer __zblib_request_create_zcl_global_control_request_data(guint req
                        req->dest_ep = in_req->dest_ep;
                        req->zcl_frame_ctrl = in_req->zcl_frame_ctrl;
                        req->cluster_id = in_req->cluster_id;
-                       req->start_attribute = in_req->start_attribute;
-                       req->max = in_req->max;
+                       req->start_command = in_req->start_command;
+                       req->max_command_count = in_req->max_command_count;
                }
 
                zclglobal_control_request_data = (gpointer)req;
@@ -2160,6 +2158,7 @@ static gpointer __zblib_request_create_zcl_group_request_data(guint request_type
                        /* Copy data */
                        req->node_id = in_req->node_id;
                        req->dest_ep = in_req->dest_ep;
+                       req->group_id = in_req->group_id;
                }
 
                zcl_group_request_data = (gpointer)req;
@@ -2180,8 +2179,8 @@ static gpointer __zblib_request_create_zcl_group_request_data(guint request_type
                        req->node_id = in_req->node_id;
                        req->dest_ep = in_req->dest_ep;
                        req->group_count = in_req->group_count;
-                       req->group_list = (gshort *)g_memdup(in_req->group_list,
-                               in_req->group_count);
+                       req->group_list = (gushort *)g_memdup(in_req->group_list,
+                               sizeof(gushort) * in_req->group_count);
                }
 
                zcl_group_request_data = (gpointer)req;
@@ -2384,7 +2383,7 @@ static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type
                        g_strlcpy(req->scene_name,
                                in_req->scene_name, ZIGBEE_ZCL_SCENE_NAME_MAX_LEN + 1);
                        req->ext_field_set_len = in_req->ext_field_set_len;
-                       req->ext_field_set = (gshort *)g_memdup(in_req->ext_field_set,
+                       req->ext_field_set = (guchar *)g_memdup(in_req->ext_field_set,
                                in_req->ext_field_set_len);
                }
 
@@ -2568,9 +2567,17 @@ static gpointer __zblib_request_create_zdo_dev_control_request_data(guint reques
                        req->node_id = in_req->node_id;
                        req->profile_id = in_req->profile_id;
                        req->num_in_cl = in_req->num_in_cl;
-                       req->in_cl = g_strdup(in_req->in_cl);
+                       if (in_req->num_in_cl > 0) {
+                               req->in_cl = g_malloc0_n(in_req->num_in_cl, sizeof(unsigned short));
+                               memcpy(req->in_cl, in_req->in_cl,
+                                       in_req->num_in_cl * sizeof(unsigned short));
+                       }
                        req->num_out_cl = in_req->num_out_cl;
-                       req->out_cl = g_strdup(in_req->out_cl);
+                       if (in_req->num_out_cl > 0) {
+                               req->out_cl = g_malloc0_n(in_req->num_out_cl, sizeof(unsigned short));
+                               memcpy(req->out_cl, in_req->out_cl,
+                                       in_req->num_out_cl * sizeof(unsigned short));
+                       }
                }
 
                zdodev_control_request_data = (gpointer)req;
@@ -2813,7 +2820,7 @@ static gpointer __zblib_request_create_zdo_dev_control_request_data(guint reques
                                g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
 
                        /* Copy data */
-                       req->addr = in_req->addr;
+                       req->node_id = in_req->node_id;
                        req->duration = in_req->duration;
                        req->tc_significance = in_req->tc_significance;
                }
@@ -2822,15 +2829,15 @@ static gpointer __zblib_request_create_zdo_dev_control_request_data(guint reques
        }
        break;
 
-       case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
-               ZigbeeZdoDevControlNwkUpdateReq_t *in_req;
-               ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
+       case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ: {
+               ZigbeeZdoDevControlMgmtNwkUpdateReq_t *in_req;
+               ZigbeeZdoDevControlMgmtNwkUpdateReq_t *req = NULL;
 
-               in_req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request_data;
+               in_req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)request_data;
                if (NULL != in_req) {
                        /* Allocate memory */
-                       req = (ZigbeeZdoDevControlNwkUpdateReq_t *)
-                               g_malloc0(sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
+                       req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)
+                               g_malloc0(sizeof(ZigbeeZdoDevControlMgmtNwkUpdateReq_t));
 
                        /* Copy data */
                        req->node_id = in_req->node_id;
@@ -2844,15 +2851,15 @@ static gpointer __zblib_request_create_zdo_dev_control_request_data(guint reques
        }
        break;
 
-       case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
-               ZigbeeZdoDevControlNwkDescriptorReq_t *in_req;
-               ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
+       case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ: {
+               ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *in_req;
+               ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *req = NULL;
 
-               in_req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request_data;
+               in_req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)request_data;
                if (NULL != in_req) {
                        /* Allocate memory */
-                       req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)
-                               g_malloc0(sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t));
+                       req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)
+                               g_malloc0(sizeof(ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t));
 
                        /* Copy data */
                        req->node_id = in_req->node_id;
@@ -2896,12 +2903,10 @@ static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
 
                        /* Copy data */
                        req->node_id = in_req->node_id;
-                       g_strlcpy(req->src_addr,
-                               in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
+                       memcpy(req->src_addr, in_req->src_addr, ZIGBEE_EUI64_SIZE);
                        req->src_ep = in_req->src_ep;
                        req->cluster_id = in_req->cluster_id;
-                       g_strlcpy(req->dst_addr,
-                               in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
+                       memcpy(req->dst_addr, in_req->dst_addr, ZIGBEE_EUI64_SIZE);
                        req->bind_type = in_req->bind_type;
                        req->group_addr = in_req->group_addr;
                        req->dst_ep = in_req->dst_ep;
@@ -2923,12 +2928,10 @@ static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
 
                        /* Copy data */
                        req->node_id = in_req->node_id;
-                       g_strlcpy(req->src_addr,
-                               in_req->src_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
+                       memcpy(req->src_addr, in_req->src_addr, ZIGBEE_EUI64_SIZE);
                        req->src_ep = in_req->src_ep;
                        req->cluster_id = in_req->cluster_id;
-                       g_strlcpy(req->dst_addr,
-                               in_req->dst_addr, ZIGBEE_ZDO_BIND_ADDRESS_MAX_LEN + 1);
+                       memcpy(req->dst_addr, in_req->dst_addr, ZIGBEE_EUI64_SIZE);
                        req->bind_type = in_req->bind_type;
                        req->group_addr = in_req->group_addr;
                        req->dst_ep = in_req->dst_ep;
@@ -3602,14 +3605,6 @@ static void __zblib_request_free_service_request_data(ZigBeeRequest *request,
        /* Fetch ops ID */
        ops_id = __zblib_request_get_ops_id(request_type);
        switch (ops_id) {
-       case ZBLIB_SERVICE_OPS_ENABLE: {
-       }
-       break;
-
-       case ZBLIB_SERVICE_OPS_DISABLE: {
-       }
-       break;
-
        case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
        }
        break;
@@ -4484,20 +4479,20 @@ static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *req
        }
        break;
 
-       case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
-               ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
+       case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ: {
+               ZigbeeZdoDevControlMgmtNwkUpdateReq_t *req = NULL;
 
-               req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request->request_data;
+               req = (ZigbeeZdoDevControlMgmtNwkUpdateReq_t *)request->request_data;
                if (NULL != req) {
                        g_free(req);
                }
        }
        break;
 
-       case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
-               ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
+       case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ: {
+               ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *req = NULL;
 
-               req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request->request_data;
+               req = (ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t *)request->request_data;
                if (NULL != req) {
                        g_free(req);
                }