X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=zigbee-daemon%2Fzigbee-interface%2Fsrc%2Fzigbee_service_dbus_interface_zdo_dev_control.c;h=15f3fa2aedfdb565d3395660707dc21b3eee8e3c;hb=691ff0189bb1cf9097978cf40e7459fe188f1306;hp=b54d3944e1291251c0d26694d4d6f761906dca9c;hpb=a991c099b7f05eaecc8005515d8cb1e58fe8aa8b;p=platform%2Fcore%2Fconnectivity%2Fzigbee-manager.git diff --git a/zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zdo_dev_control.c b/zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zdo_dev_control.c index b54d394..15f3fa2 100644 --- a/zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zdo_dev_control.c +++ b/zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zdo_dev_control.c @@ -20,17 +20,59 @@ #include +static void *_service_interface_ref_zigbee_zdo_dev_control(ZigBeeServiceInterface *service_interface) +{ + ZigbeeObjectSkeleton *zigbee_object = NULL; + ZigbeeCustomData_t *custom_data = NULL; + ZigbeeZdo_dev_control *dev_control_object = NULL; + + custom_data = (ZigbeeCustomData_t *)zblib_service_interface_ref_user_data(service_interface); + if (NULL == custom_data) { + Z_LOGE("D-BUS service interface custom_data is NULL!"); + return NULL; + } + + /* Get zigbee object */ + zigbee_object = g_hash_table_lookup(custom_data->objects, ZIGBEE_SERVICE_PATH); + if (NULL == zigbee_object) { + Z_LOGW("Cannot find ZigBee D-BUS interface object!", zigbee_object); + return NULL; + } + + dev_control_object = zigbee_object_get_zdo_dev_control(ZIGBEE_OBJECT(zigbee_object)); + return dev_control_object; +} + static void on_zdodev_control_nwk_addr_req_resp(ZigBeeServiceInterface *service_interface, guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data) { ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_nwk_addr_req(dev_control_object, invocation, + payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_nwk_addr_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -52,8 +94,8 @@ static gboolean on_zdodev_control_nwk_addr_req(ZigbeeZdo_dev_control *zdodev_con memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkAddrReq_t)); /* Update request structure */ - g_variant_get(eui64, "ay", &iter); - while (g_variant_iter_loop(iter, "y", req.eui64[i])) { + g_variant_get(eui64, "a(y)", &iter); + while (g_variant_iter_loop(iter, "(y)", &(req.eui64[i]))) { i++; if (i >= ZIGBEE_EUI64_SIZE) break; @@ -101,20 +143,39 @@ static void on_zdodev_control_matched_descriptor_req_resp(ZigBeeServiceInterface ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_matched_descriptor_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_matched_descriptor_req(ZigbeeZdo_dev_control *zdodev_control_object, GDBusMethodInvocation *invocation, - gshort node_id, - gshort profile_id, - gchar num_in_cl, + gushort node_id, + gushort profile_id, + guchar num_in_cl, GVariant *in_cl, - gchar num_out_cl, + guchar num_out_cl, GVariant *out_cl, gpointer user_data) { @@ -133,22 +194,30 @@ static gboolean on_zdodev_control_matched_descriptor_req(ZigbeeZdo_dev_control * req.node_id = node_id; req.profile_id = profile_id; req.num_in_cl = num_in_cl; - req.in_cl = g_malloc0(sizeof(num_in_cl)); - g_variant_get(in_cl, "ay", &iter); - while (g_variant_iter_loop(iter, "y", req.in_cl[i])) { - i++; - if (i >= num_in_cl) - break; + if (num_in_cl > 0) { + req.in_cl = g_malloc0_n(num_in_cl, sizeof(unsigned short)); + g_variant_get(in_cl, "aq", &iter); + while (g_variant_iter_loop(iter, "q", &(req.in_cl[i]))) { + i++; + if (i >= num_in_cl) + break; + } + } else { + req.in_cl = NULL; } i = 0; req.num_out_cl = num_out_cl; - req.out_cl = g_malloc0(sizeof(num_out_cl)); - g_variant_get(out_cl, "ay", &iter); - while (g_variant_iter_loop(iter, "y", req.out_cl[i])) { - i++; - if (i >= num_out_cl) - break; + if (num_out_cl > 0) { + req.out_cl = g_malloc0_n(num_out_cl, sizeof(unsigned short)); + g_variant_get(out_cl, "aq", &iter); + while (g_variant_iter_loop(iter, "q", &(req.out_cl[i]))) { + i++; + if (i >= num_out_cl) + break; + } + } else { + req.out_cl = NULL; } /* Allocate response callback data */ @@ -196,11 +265,30 @@ static void on_zdodev_control_ieee_addr_req_resp(ZigBeeServiceInterface *service ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_ieee_addr_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_ieee_addr_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -259,11 +347,30 @@ static void on_zdodev_control_active_ep_req_resp(ZigBeeServiceInterface *service ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_active_ep_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_active_ep_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -322,11 +429,30 @@ static void on_zdodev_control_node_desc_req_resp(ZigBeeServiceInterface *service ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_node_desc_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_node_desc_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -385,11 +511,30 @@ static void on_zdodev_control_power_desc_req_resp(ZigBeeServiceInterface *servic ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_power_desc_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_power_desc_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -448,11 +593,30 @@ static void on_zdodev_control_complex_desc_req_resp(ZigBeeServiceInterface *serv ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_complex_desc_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_complex_desc_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -511,11 +675,30 @@ static void on_zdodev_control_user_desc_req_resp(ZigBeeServiceInterface *service ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_user_desc_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_user_desc_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -574,11 +757,30 @@ static void on_zdodev_control_user_desc_set_req_resp(ZigBeeServiceInterface *ser ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_user_desc_set_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -602,8 +804,8 @@ static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdo_dev_control *zdode /* Update request structure */ req.node_id = node_id; req.user_descriptor_len = length; - g_variant_get(user_desc, "ay", &iter); - while (g_variant_iter_loop(iter, "y", req.user_descriptor[i])) { + g_variant_get(user_desc, "a(y)", &iter); + while (g_variant_iter_loop(iter, "(y)", &(req.user_descriptor[i]))) { i++; if (i >= ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN) break; @@ -649,11 +851,30 @@ static void on_zdodev_control_device_announce_resp(ZigBeeServiceInterface *servi ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_device_announce(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_device_announce(ZigbeeZdo_dev_control *zdodev_control_object, @@ -676,8 +897,8 @@ static gboolean on_zdodev_control_device_announce(ZigbeeZdo_dev_control *zdodev_ /* Update request structure */ req.node_id = node_id; - g_variant_get(mac_addr, "ay", &iter); - while (g_variant_iter_loop(iter, "y", req.mac_addr[i])) { + g_variant_get(mac_addr, "a(y)", &iter); + while (g_variant_iter_loop(iter, "(y)", &(req.mac_addr[i]))) { i++; if (i >= ZIGBEE_EUI64_SIZE) break; @@ -724,11 +945,30 @@ static void on_zdodev_control_simple_desc_req_resp(ZigBeeServiceInterface *servi ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_simple_desc_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_simple_desc_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -789,11 +1029,30 @@ static void on_zdodev_control_mgmt_lqi_req_resp(ZigBeeServiceInterface *service_ ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_mgmt_lqi_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_mgmt_lqi_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -854,11 +1113,30 @@ static void on_zdodev_control_mgmt_rtg_req_resp(ZigBeeServiceInterface *service_ ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_mgmt_rtg_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_mgmt_rtg_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -919,11 +1197,30 @@ static void on_zdodev_control_mgmt_bind_req_resp(ZigBeeServiceInterface *service ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_mgmt_bind_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_mgmt_bind_req(ZigbeeZdo_dev_control *zdodev_control_object, @@ -984,16 +1281,35 @@ static void on_zdodev_control_mgmt_permit_join_req_resp(ZigBeeServiceInterface * ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_mgmt_permit_join_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zdodev_control_object, GDBusMethodInvocation *invocation, - gshort addr16, + gshort node_id, gchar duration, gchar tc_significance, gpointer user_data) @@ -1007,7 +1323,7 @@ static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zd memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t)); /* Update request structure */ - req.addr = addr16; + req.node_id = node_id; req.duration = duration; req.tc_significance = tc_significance; @@ -1045,20 +1361,39 @@ static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zd return TRUE; } -static void on_zdodev_control_nwk_update_req_resp(ZigBeeServiceInterface *service_interface, +static void on_zdodev_control_mgmt_nwk_update_req_resp(ZigBeeServiceInterface *service_interface, guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data) { ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_mgmt_nwk_update_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } -static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdo_dev_control *zdodev_control_object, +static gboolean on_zdodev_control_mgmt_nwk_update_req(ZigbeeZdo_dev_control *zdodev_control_object, GDBusMethodInvocation *invocation, gshort node_id, guint scan_channel, @@ -1068,12 +1403,12 @@ static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdo_dev_control *zdodev_c gpointer user_data) { ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data; - ZigbeeZdoDevControlNwkUpdateReq_t req; + ZigbeeZdoDevControlMgmtNwkUpdateReq_t req; ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL; gboolean ret; - memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkUpdateReq_t)); + memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtNwkUpdateReq_t)); /* Update request structure */ req.node_id = node_id; @@ -1098,9 +1433,9 @@ static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdo_dev_control *zdodev_c /* Dispatch request */ ret = zigbee_service_dbus_interface_dispatch_request(service_interface, ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL, - ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ, + ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ, &req, sizeof(req), - on_zdodev_control_nwk_update_req_resp, resp_cb_data); + on_zdodev_control_mgmt_nwk_update_req_resp, resp_cb_data); if (FALSE == ret) { Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!"); @@ -1116,20 +1451,39 @@ static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdo_dev_control *zdodev_c return TRUE; } -static void on_zdodev_control_nwk_disc_req_resp(ZigBeeServiceInterface *service_interface, +static void on_zdodev_control_mgmt_nwk_disc_req_resp(ZigBeeServiceInterface *service_interface, guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data) { ZigbeeServiceInterfaceRespCbData_t *cb_data = (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data; - NOT_USED(cb_data); + ZigbeeZdo_dev_control *dev_control_object; + GDBusMethodInvocation *invocation; + + ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data; + NOT_USED(service_interface); NOT_USED(request_id); - NOT_USED(resp_data); - NOT_USED(resp_data_len); + + if (NULL == resp_data || 0 == resp_data_len) { + Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len); + g_free(cb_data); + return; + } + + dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data); + zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data); + + invocation = zigbee_service_dbus_interface_ref_invocation(cb_data); + zblib_check_null_free_and_ret("invocation", invocation, cb_data); + + zigbee_zdo_dev_control_complete_mgmt_nwk_disc_req(dev_control_object, + invocation, payload->result); + + g_free(cb_data); } -static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_control_object, +static gboolean on_zdodev_control_mgmt_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_control_object, GDBusMethodInvocation *invocation, gshort node_id, guint scan_channel, @@ -1139,12 +1493,12 @@ static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_con gpointer user_data) { ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data; - ZigbeeZdoDevControlNwkDescriptorReq_t req; + ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t req; ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL; gboolean ret; - memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t)); + memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t)); /* Update request structure */ req.node_id = node_id; @@ -1169,9 +1523,9 @@ static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_con /* Dispatch request */ ret = zigbee_service_dbus_interface_dispatch_request(service_interface, ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL, - ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ, + ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ, &req, sizeof(req), - on_zdodev_control_nwk_disc_req_resp, resp_cb_data); + on_zdodev_control_mgmt_nwk_disc_req_resp, resp_cb_data); if (FALSE == ret) { Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!"); @@ -1187,6 +1541,414 @@ static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_con return TRUE; } +void zigbee_service_dbus_interface_zdo_dev_control_notification(ZigBeeServiceInterface *service_interface, + guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data) +{ + ZigbeeZdo_dev_control *dev_control_object = NULL; + + zblib_check_null_ret("service_interface", service_interface); + + if (NULL == noti_data || 0 == noti_data_len) { + Z_LOGE("noti_data is NULL"); + return; + } + + dev_control_object = _service_interface_ref_zigbee_zdo_dev_control(service_interface); + zblib_check_null_ret("dev_control_object", dev_control_object); + + NOT_USED(noti_cb_data); + + switch (noti_id) { + case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_ADDR_RSP: { + ZigbeeZdoDevControlNwkAddrResp_t *nwk_addr_t = + (ZigbeeZdoDevControlNwkAddrResp_t*)noti_data; + + GVariant *v_eui64 = NULL; + v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"), + nwk_addr_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL); + if (NULL == v_eui64) { + Z_LOGE("Failed to create variant!"); + } else { + Z_LOGD("nwk addr rsp : [0x%X]", nwk_addr_t->status); + zigbee_zdo_dev_control_emit_nwk_addr_rsp(dev_control_object, + nwk_addr_t->status, v_eui64, nwk_addr_t->node_id, + nwk_addr_t->associated_count, nwk_addr_t->start_index); + } + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_ADDR_EXT_RSP: { + ZigbeeZdoDevControlNwkAddrExtResp_t *nwk_addr_t = + (ZigbeeZdoDevControlNwkAddrExtResp_t*)noti_data; + + GVariant *v_eui64 = NULL; + GVariant *v_associated = NULL; + v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"), + nwk_addr_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL); + v_associated = g_variant_new_from_data(G_VARIANT_TYPE("aq"), + nwk_addr_t->associated_addr_list, + (sizeof(gushort) * nwk_addr_t->associated_count), TRUE, NULL, NULL); + if (NULL == v_eui64 || NULL == v_associated) { + Z_LOGE("Failed to create variant!"); + if (v_eui64) + g_variant_unref(v_eui64); + if (v_associated) + g_variant_unref(v_associated); + } else { + Z_LOGD("nwk addr ext rsp : [0x%X]", nwk_addr_t->status); + zigbee_zdo_dev_control_emit_nwk_addr_ext_rsp(dev_control_object, + nwk_addr_t->status, v_eui64, nwk_addr_t->node_id, + nwk_addr_t->associated_count, nwk_addr_t->start_index, v_associated); + } + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_ACTIVE_EP_RSP: { + ZigbeeZdoDevControlActiveEpResp_t *active_t = + (ZigbeeZdoDevControlActiveEpResp_t *)noti_data; + + GVariant *v_ep_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"), + active_t->endpoint_list, active_t->endpoint_count, TRUE, NULL, NULL); + if (NULL == v_ep_list) { + Z_LOGE("Failed to create variant!"); + } else { + Z_LOGD("Active endpoint rsp : [0x%X]", active_t->status); + zigbee_zdo_dev_control_emit_active_ep_rsp(dev_control_object, + active_t->status, active_t->node_id, + v_ep_list, active_t->endpoint_count); + } + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_SIMPLE_DESC_RSP: { + ZigbeeZdoDevControlSimpleDescriptorResp_t *desc_t = + (ZigbeeZdoDevControlSimpleDescriptorResp_t *)noti_data; + + GVariant *v_in_cluster = NULL; + GVariant *v_out_cluster = NULL; + v_in_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"), + desc_t->in_cluster, (sizeof(gushort) * desc_t->in_cluster_count), + TRUE, NULL, NULL); + v_out_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"), + desc_t->out_cluster, (sizeof(gushort) * desc_t->out_cluster_count), + TRUE, NULL, NULL); + if (NULL == v_in_cluster || NULL == v_out_cluster) { + Z_LOGE("Failed to create variant!"); + if (v_in_cluster) + g_variant_unref(v_in_cluster); + if (v_out_cluster) + g_variant_unref(v_out_cluster); + } else { + Z_LOGD("Simple descriptor rsp"); + zigbee_zdo_dev_control_emit_simple_desc_rsp(dev_control_object, + desc_t->node_id, desc_t->length, desc_t->device_version, + desc_t->endpoint, desc_t->profile_id, desc_t->device_id, + desc_t->in_cluster_count, desc_t->out_cluster_count, + v_in_cluster, v_out_cluster); + } + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_MATCHED_DESC_RSP: { + ZigbeeZdoDevControlMatchedDescriptorResp_t *desc_t = + (ZigbeeZdoDevControlMatchedDescriptorResp_t *)noti_data; + + GVariant *v_match_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"), + desc_t->match_list, desc_t->list_count, TRUE, NULL, NULL); + if (NULL == v_match_list) { + Z_LOGE("Failed to create variant!"); + } else { + Z_LOGD("matched descriptor rsp : [0x%X]", desc_t->status); + zigbee_zdo_dev_control_emit_matched_descriptor_rsp(dev_control_object, + desc_t->status, desc_t->node_id, desc_t->list_count, v_match_list); + } + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_BIND_RSP: { + ZigbeeZdoDevControlMgmtBindResp_t *desc_t = + (ZigbeeZdoDevControlMgmtBindResp_t *)noti_data; + int i = 0; + int v = 0; + + GVariant *v_entries = NULL; + GVariantBuilder *entry_builder = + g_variant_builder_new(G_VARIANT_TYPE("a(ayyqyqayy)")); + if (NULL == entry_builder) { + Z_LOGE("Failed to create variant builder!"); + break; + } + + for (i = 0; i < desc_t->table_list_count ; i++) { + GVariantBuilder *eui64_builder = + g_variant_builder_new(G_VARIANT_TYPE("ay")); + GVariantBuilder *dest_eui64_builder = + g_variant_builder_new(G_VARIANT_TYPE("ay")); + + if (NULL == eui64_builder || NULL == dest_eui64_builder) { + Z_LOGE("Failed to create variant builder!"); + if (eui64_builder) + g_variant_builder_unref(eui64_builder); + if (dest_eui64_builder) + g_variant_builder_unref(dest_eui64_builder); + g_variant_builder_unref(entry_builder); + break; + } + + for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) { + g_variant_builder_add(eui64_builder, "y", + desc_t->table_list[i].eui64[v]); + g_variant_builder_add(dest_eui64_builder, "y", + desc_t->table_list[i].dest_eui64[v]); + } + + g_variant_builder_add(entry_builder, "(ayyqyqayy)", + eui64_builder, + desc_t->table_list[i].source_endpoint, + desc_t->table_list[i].cluster_id, + desc_t->table_list[i].dest_addr_mode, + desc_t->table_list[i].dest_addr, + dest_eui64_builder, + desc_t->table_list[i].dest_endpoint); + + g_variant_builder_unref(eui64_builder); + g_variant_builder_unref(dest_eui64_builder); + } + v_entries = g_variant_builder_end(entry_builder); + + Z_LOGD("management bind rsp : [0x%X]", desc_t->status); + zigbee_zdo_dev_control_emit_mgmt_bind_rsp(dev_control_object, + desc_t->status, desc_t->table_entries, + desc_t->start_index, desc_t->table_list_count, + v_entries); + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LQI_RSP: { + ZigbeeZdoDevControlMgmtLqiResp_t *desc_t = + (ZigbeeZdoDevControlMgmtLqiResp_t *)noti_data; + int i = 0; + int v = 0; + + GVariant *v_entries = NULL; + GVariantBuilder *entry_builder = + g_variant_builder_new(G_VARIANT_TYPE("a(ayayyqyyyyy)")); + if (NULL == entry_builder) { + Z_LOGE("Failed to create variant builder!"); + break; + } + + for (i = 0; i < desc_t->table_list_count ; i++) { + GVariantBuilder *ext_pan_builder = + g_variant_builder_new(G_VARIANT_TYPE("ay")); + GVariantBuilder *eui64_builder = + g_variant_builder_new(G_VARIANT_TYPE("ay")); + + if (NULL == ext_pan_builder || NULL == eui64_builder) { + Z_LOGE("Failed to create variant builder!"); + if (ext_pan_builder) + g_variant_builder_unref(ext_pan_builder); + if (eui64_builder) + g_variant_builder_unref(eui64_builder); + g_variant_builder_unref(entry_builder); + break; + } + + for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) { + g_variant_builder_add(ext_pan_builder, "y", + desc_t->table_list[i].extended_pan_id[v]); + g_variant_builder_add(eui64_builder, "y", + desc_t->table_list[i].eui64[v]); + } + + g_variant_builder_add(entry_builder, "(ayayyqyyyyy)", + ext_pan_builder, + eui64_builder, + desc_t->table_list[i].node_id, + desc_t->table_list[i].device_type, + desc_t->table_list[i].rx_on_when_idle, + desc_t->table_list[i].relationship, + desc_t->table_list[i].permit_joining, + desc_t->table_list[i].depth, + desc_t->table_list[i].lqi); + + g_variant_builder_unref(ext_pan_builder); + g_variant_builder_unref(eui64_builder); + } + v_entries = g_variant_builder_end(entry_builder); + + Z_LOGD("management LQI rsp : [0x%X]", desc_t->status); + zigbee_zdo_dev_control_emit_mgmt_lqi_rsp(dev_control_object, + desc_t->status, desc_t->table_entries, + desc_t->start_index, desc_t->table_list_count, + v_entries); + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_RTG_RSP: { + ZigbeeZdoDevControlMgmtRtgResp_t *desc_t = + (ZigbeeZdoDevControlMgmtRtgResp_t *)noti_data; + int i = 0; + + GVariant *v_entries = NULL; + GVariantBuilder *entry_builder = + g_variant_builder_new(G_VARIANT_TYPE("a(qyyyyq)")); + if (NULL == entry_builder) { + Z_LOGE("Failed to create variant builder!"); + break; + } + + for (i = 0; i < desc_t->table_list_count ; i++) { + g_variant_builder_add(entry_builder, "(qyyyyq)", + desc_t->table_list[i].dest_addr, + desc_t->table_list[i].status, + desc_t->table_list[i].memory_constrained, + desc_t->table_list[i].many_to_one, + desc_t->table_list[i].route_record_required, + desc_t->table_list[i].next_hop_addr); + } + v_entries = g_variant_builder_end(entry_builder); + + Z_LOGD("management routing rsp : [0x%X]", desc_t->status); + zigbee_zdo_dev_control_emit_mgmt_rtg_rsp(dev_control_object, + desc_t->status, desc_t->table_entries, + desc_t->start_index, desc_t->table_list_count, + v_entries); + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_PERMIT_JOIN_RSP: { + ZigbeeZdoDevControlMgmtPermitJoinResp_t *resp_t = + (ZigbeeZdoDevControlMgmtPermitJoinResp_t *)noti_data; + + zigbee_zdo_dev_control_emit_mgmt_permit_join_rsp(dev_control_object, + resp_t->status); + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LEAVE_RSP: { + ZigbeeZdoDevControlMgmtLeftResp_t *resp_t = + (ZigbeeZdoDevControlMgmtLeftResp_t *)noti_data; + + zigbee_zdo_dev_control_emit_mgmt_leave_rsp(dev_control_object, + resp_t->status); + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_NWK_DISC_RSP: { + ZigbeeZdoDevControlMgmtNwkDiscoveryResp_t *nwk_disc_t = + (ZigbeeZdoDevControlMgmtNwkDiscoveryResp_t *)noti_data; + int i = 0; + int v = 0; + + GVariant *v_entries = NULL; + GVariantBuilder *entry_builder = + g_variant_builder_new(G_VARIANT_TYPE("a(ayyyyyyy)")); + if (NULL == entry_builder) { + Z_LOGE("Failed to create variant builder!"); + break; + } + + for (i = 0; i < nwk_disc_t->table_list_count ; i++) { + GVariantBuilder *ext_pan_builder = + g_variant_builder_new(G_VARIANT_TYPE("ay")); + if (NULL == ext_pan_builder) { + Z_LOGE("Failed to create variant builder!"); + g_variant_builder_unref(entry_builder); + break; + } + + for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) { + g_variant_builder_add(ext_pan_builder, "y", + nwk_disc_t->table_list[i].extended_pan_id[v]); + } + + g_variant_builder_add(entry_builder, "(ayyyyyyy)", + ext_pan_builder, + nwk_disc_t->table_list[i].logical_channel, + nwk_disc_t->table_list[i].stack_profile, + nwk_disc_t->table_list[i].zigbee_version, + nwk_disc_t->table_list[i].beacon_order, + nwk_disc_t->table_list[i].superframe_order, + nwk_disc_t->table_list[i].permit_joining); + + g_variant_builder_unref(ext_pan_builder); + } + v_entries = g_variant_builder_end(entry_builder); + + Z_LOGD("Network discovery rsp : [0x%X]", nwk_disc_t->status); + zigbee_zdo_dev_control_emit_mgmt_nwk_disc_rsp(dev_control_object, + nwk_disc_t->status, nwk_disc_t->network_count, + nwk_disc_t->start_index, nwk_disc_t->table_list_count, + v_entries); + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_NODE_DESC_RSP: { + ZigbeeZdoDevControlNodeDescriptorResp_t *desc_t = + (ZigbeeZdoDevControlNodeDescriptorResp_t *)noti_data; + + zigbee_zdo_dev_control_emit_node_desc_rsp(dev_control_object, + desc_t->status, desc_t->node_id, desc_t->logical_type, + desc_t->complex_desciptor_available, + desc_t->user_descriptor_available, + desc_t->aps_flags, desc_t->frequency_band, + desc_t->mac_capability_flags, desc_t->manufacturer_code, + desc_t->max_buffer_size, desc_t->max_incoming_transfer_size, + desc_t->server_mask, desc_t->max_outgoing_transfer_size, + desc_t->descriptor_capability_field); + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_POWER_DESC_RSP: { + ZigbeeZdoDevControlPowerDescriptorResp_t *desc_t = + (ZigbeeZdoDevControlPowerDescriptorResp_t *)noti_data; + + zigbee_zdo_dev_control_emit_power_desc_rsp(dev_control_object, + desc_t->status, desc_t->node_id, + desc_t->current_power_mode, + desc_t->available_power_sources, + desc_t->current_power_source, + desc_t->current_power_source_level); + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_COMPLEX_DESC_RSP: { + ZigbeeZdoDevControlComplexDescriptorResp_t *desc_t = + (ZigbeeZdoDevControlComplexDescriptorResp_t *)noti_data; + + GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"), + desc_t->complex_descriptor_list, desc_t->list_count, + TRUE, NULL, NULL); + if (NULL == v_desc_list) { + Z_LOGE("Failed to create variant!"); + } else { + Z_LOGD("Complex descriptor rsp : [0x%X]", desc_t->status); + zigbee_zdo_dev_control_emit_complex_desc_rsp(dev_control_object, + desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list); + } + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_RSP: { + ZigbeeZdoDevControlUserDescriptorResp_t *desc_t = + (ZigbeeZdoDevControlUserDescriptorResp_t *)noti_data; + + GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"), + desc_t->user_descriptor_list, desc_t->list_count, + TRUE, NULL, NULL); + if (NULL == v_desc_list) { + Z_LOGE("Failed to create variant!"); + } else { + Z_LOGD("User descriptor rsp : [0x%X]", desc_t->status); + zigbee_zdo_dev_control_emit_user_desc_rsp(dev_control_object, + desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list); + } + break; + } + case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_CONFIRM: { + ZigbeeZdoDevControlUserDescriptorConfirm_t *resp_t = + (ZigbeeZdoDevControlUserDescriptorConfirm_t *)noti_data; + + zigbee_zdo_dev_control_emit_user_desc_confirm(dev_control_object, + resp_t->status); + break; + } + default: + Z_LOGE("Unexpected notification [%x]", noti_id); + break; + } + + /* ZigbeeZdo_dev_control should be dereferenced */ + g_object_unref(dev_control_object); +} + gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface, ZigbeeObjectSkeleton *zigbee_object) { @@ -1267,12 +2029,12 @@ gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterfa G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface); g_signal_connect(zdodev_control_object, - "handle-nwk-update-req", - G_CALLBACK(on_zdodev_control_nwk_update_req), service_interface); + "handle-mgmt-nwk-update-req", + G_CALLBACK(on_zdodev_control_mgmt_nwk_update_req), service_interface); g_signal_connect(zdodev_control_object, - "handle-nwk-disc-req", - G_CALLBACK(on_zdodev_control_nwk_disc_req), service_interface); + "handle-mgmt-nwk-disc-req", + G_CALLBACK(on_zdodev_control_mgmt_nwk_disc_req), service_interface); return TRUE; }