From cab1145a0db2b0ff8e197892c84b58e64dfc13db Mon Sep 17 00:00:00 2001 From: saerome kim Date: Mon, 23 Jan 2017 22:35:52 +0900 Subject: [PATCH] Restore GDBus API from async to sync. - add result parameters to let app know the result of its calling Change-Id: I78f9adbea3b6394a137263796954f06d84a4529d Signed-off-by: saerome kim Signed-off-by: Jiwan Kim --- include/zigbee.h | 45 +- lib/zbl-dbus.c | 6163 +++++++++++++++++++++----------------------- lib/zbl-dbus.h | 3 +- lib/zbl.c | 13 +- test/main.c | 26 +- test/test-zigbee.c | 3 +- 6 files changed, 2958 insertions(+), 3295 deletions(-) diff --git a/include/zigbee.h b/include/zigbee.h index 9245ba5..856af35 100644 --- a/include/zigbee.h +++ b/include/zigbee.h @@ -80,45 +80,6 @@ int zb_create(zigbee_h *handle); */ void zb_destroy(zigbee_h handle); - -/** - * @brief response of enabling the zigbee service - * @details response of enabling the zigbee service - * - * @since_tizen 3.0 - * - * @param[out] status #ZB_ZDP_SUCCESS \n - * #ZB_ZDP_NOT_SUPPORTED \n - * @param[out] user_data user data - * - * @see zb_enable() - */ -typedef void (*zb_enable_cb)(unsigned char status, void *user_data); - -/** - * @brief enable the zigbee service. - * @details all this function to start zigbee service - * - * @since_tizen 3.0 - * - * @remarks You must free all resources of the zigbee by calling zb_destroy() - * if zigbee service is no longer needed. - * - * @param[in] handle The handle of zigbee - * @param[in] cb zb_enable_cb - * @param[in] user_data user data - * - * @return 0 on success, otherwise a negative error value. - * @retval #ZIGBEE_ERROR_NONE Successful - * @retval #ZIGBEE_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #ZIGBEE_ERROR_IO_ERROR Unexpected d-bus error - * - * @see zb_create() - * @see zb_destroy() - * - */ -int zb_enable(zigbee_h handle, zb_enable_cb cb, void *user_data); - /** * @brief Specifies the type of function passed to zb_set_event_handler() * @details This function can receive events from the devices in the network. @@ -160,8 +121,8 @@ typedef void (*zb_event_cb)(nwk_addr addr16, ieee_addr addr64, zb_event_e event_ zb_event_data_s lparam); /** - * @brief set event handler for the zigbee service. - * @details to set event handler to get events from the zigbee service + * @brief enable the zigbee service. + * @details all this function to start zigbee service * * @since_tizen 3.0 * @@ -180,7 +141,7 @@ typedef void (*zb_event_cb)(nwk_addr addr16, ieee_addr addr64, zb_event_e event_ * @see zb_destroy() * */ -int zb_set_event_cb(zigbee_h handle, zb_event_cb event_handler); +int zb_enable(zigbee_h handle, zb_event_cb event_handler); /** * @brief disable the zigbee service. diff --git a/lib/zbl-dbus.c b/lib/zbl-dbus.c index cbcf3b2..be36bea 100644 --- a/lib/zbl-dbus.c +++ b/lib/zbl-dbus.c @@ -55,6 +55,73 @@ static GDBusProxy *zdo_bind_proxy = NULL; static GDBusProxy *zcl_color_control_proxy = NULL; static GDBusProxy *custom_gproxy = NULL; +/* command id */ +typedef enum { + /* Service */ + ZBL_SERVICE_FORM_NETWORK = 0, + ZBL_SERVICE_DISABLE_NETWORK, + /* ZDP except Bind */ + ZBL_ZDO_NWK_ADDR_REQ, + ZBL_ZDO_NWK_ADDR_EXT_REQ, + ZBL_ZDO_ACTIVE_EP_REQ, + ZBL_ZDO_SIMPLE_DESC_REQ, + ZBL_ZDO_MATCHED_DESCRIPTOR_REQ, + ZBL_ZDO_COMPLEX_DESC_REQ, + ZBL_ZDO_MGMT_BIND_REQ, + ZBL_ZDO_MGMT_LQI_REQ, + ZBL_ZDO_MGMT_RTG_REQ, + ZBL_ZDO_MGMT_NWK_DISC_REQ, + ZBL_ZDO_MGMT_PERMIT_JOIN_REQ, + ZBL_ZDO_MGMT_LEAVE_REQ, + ZBL_ZDO_NODE_DESC_REQ, + ZBL_ZDO_POWER_DESC_REQ, + ZBL_ZDO_USER_DESC_REQ, + ZBL_ZDO_USER_DESC_SET_REQ, + /* ZDP Bind */ + ZBL_ZDO_BIND_REQ, + ZBL_ZDO_UNBIND_REQ, + /* ZCL Global */ + ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ, + ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ, + ZBL_ZCL_GLOBAL_CONFIGURE_REPORTING_REQ, + ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ, + ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_STRUCTURED_REQ, + ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ, + ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ, + ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ, + ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ, + /* Custom */ + ZBL_CUSTOM_APS_SEND_REQ, + ZBL_CUSTOM_ZCL_SEND_REQ, + ZBL_CUSTOM_LOCAL_SEND_REQ, + /* ZCL Alarm */ + ZBL_ZCL_ALARM_GET_ALARM_REQ, + /* ZCL Doorlock */ + ZBL_ZCL_DOORLOCK_LOCK_STATE, + /* ZCL Fanmode */ + ZBL_ZCL_FANMODE_FAN_MODE_STATE, + /* ZCL Group */ + ZBL_ZCL_GROUP_ADD_GROUP_REQ, + ZBL_ZCL_GROUP_VIEW_GROUP_REQ, + ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ, + ZBL_ZCL_GROUP_REMOVE_GROUP_REQ, + /* ZCL Identify */ + ZBL_ZCL_IDENTIFY_QUERY_REQ, + /* ZCL On/Off */ + ZBL_ZCL_ON_OFF_GET_ON_OFF_STATE, + /* ZCL Pollcontrol */ + ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ, + /* ZCL Scene */ + ZBL_ZCL_SCENE_ADD_SCENE_REQ, + ZBL_ZCL_SCENE_VIEW_SCENE_REQ, + ZBL_ZCL_SCENE_REMOVE_SCENE_REQ, + ZBL_ZCL_SCENE_STORE_SCENE_REQ, + ZBL_ZCL_SCENE_REMOVE_ALL_SCENE_REQ, + ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ, + /* ZCL Thermostat */ + ZBL_ZCL_THERMOSTAT_GET_LOCAL_TEMP, +} zbl_command_id_e; + typedef struct { bool found; void *cb; @@ -65,8 +132,12 @@ typedef struct { void *global_cmd; void *handle; #endif + zbl_command_id_e cid; } zbl_req_cb_s; +#define ZCL_REPORTING_DIRECTION_REPORTED 0x00 +#define ZCL_REPORTING_DIRECTION_RECEIVED 0x01 + static GDBusConnection *_zbl_get_connection(void) { GError *error = NULL; @@ -519,19 +590,24 @@ static void _zbl_signal_handler(GDBusConnection *connection, unsigned char value; int j = 0; - GVariantIter *iter1; - GVariantIter *iter2; + GVariantIter *iter1 = NULL; + GVariantIter *iter2 = NULL; g_variant_get(parameters, "(ayyayq)", &iter1, &count, &iter2, &addr16); while (g_variant_iter_loop(iter1, "y", &value)) { addr64[j] = value; j++; } + if (NULL != iter1) + g_variant_iter_free(iter1); + j = 0; while (g_variant_iter_loop(iter2, "y", &value)) { ep[j] = value; j++; } + if (NULL != iter2) + g_variant_iter_free(iter2); zb_event_data_s ev; ev.data.join = calloc(1, sizeof(zb_event_join_s)); @@ -546,13 +622,15 @@ static void _zbl_signal_handler(GDBusConnection *connection, unsigned char value; int j = 0; - GVariantIter *iter; + GVariantIter *iter = NULL; g_variant_get(parameters, "(ay)", &iter); while (g_variant_iter_loop(iter, "y", &value)) { addr64[j] = value; j++; } + if (NULL != iter) + g_variant_iter_free(iter); zb_event_data_s ev; memset(&ev, 0, sizeof(zb_event_data_s)); @@ -560,7 +638,7 @@ static void _zbl_signal_handler(GDBusConnection *connection, } else if (g_strcmp0(signal_name, "child_left") == 0) { int j = 0; ieee_addr addr64; - GVariantIter *iter; + GVariantIter *iter = NULL; unsigned char value, status; g_variant_get(parameters, "(ayy)", &iter, &status); @@ -568,6 +646,8 @@ static void _zbl_signal_handler(GDBusConnection *connection, addr64[j] = value; j++; } + if (NULL != iter) + g_variant_iter_free(iter); zb_event_data_s ev; ev.data.child_left = calloc(1, sizeof(zb_event_child_left_s)); @@ -631,7 +711,9 @@ static void _zbl_signal_handler(GDBusConnection *connection, int dsizeIndex = 0; char dSize[3] = {'\0', '\0'}; int i = 0, j = 0, records_len; - GVariantIter *attr_iter, *dataType_iter, *data_iter; + GVariantIter *attr_iter = NULL; + GVariantIter *dataType_iter = NULL; + GVariantIter *data_iter = NULL; attr_report_h *records = NULL; @@ -646,6 +728,13 @@ static void _zbl_signal_handler(GDBusConnection *connection, for (i = 0; i < j; i++) free(records[i]); free(records); + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + if (NULL != dataType_iter) + g_variant_iter_free(dataType_iter); + if (NULL != data_iter) + g_variant_iter_free(data_iter); + ERR("calloc() Fail(%d)", errno); return; } @@ -661,6 +750,11 @@ static void _zbl_signal_handler(GDBusConnection *connection, DBG("AttributeId 0x%04x", records[j]->id); j++; } + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + if (NULL != dataType_iter) + g_variant_iter_free(dataType_iter); + j = 0; while (j < records_len) { switch (records[j]->type) { @@ -684,8 +778,9 @@ static void _zbl_signal_handler(GDBusConnection *connection, for (i = dsizeIndex; i < data_size - 2; i++) { g_variant_iter_loop(data_iter, "y", &value); records[j]->value[i] = value; - } + if (NULL != data_iter) + g_variant_iter_free(data_iter); break; case ZB_ZCL_LONG_OCTAT_STRING: case ZB_ZCL_LONG_CHRACTER_STRING: @@ -714,6 +809,8 @@ static void _zbl_signal_handler(GDBusConnection *connection, g_variant_iter_loop(data_iter, "y", &value); records[j]->value[i] = value; } + if (NULL != data_iter) + g_variant_iter_free(data_iter); break; /* Array, set and bag */ case ZB_ZCL_ARRAY: @@ -742,6 +839,8 @@ static void _zbl_signal_handler(GDBusConnection *connection, DBG("value[%d] 0x%02X", i, records[j]->value[i]); } } + if (NULL != data_iter) + g_variant_iter_free(data_iter); } DBG("DataType = 0x%02X Data Size = %d", records[j]->type, data_size); j++; @@ -994,142 +1093,1891 @@ static void _zbl_request_cleanup(gpointer data) free(container); } -static gboolean _zbl_timeout_enable(gpointer p) +static gboolean _zbl_timeout_cb(gpointer p) { - zbl_req_cb_s *container = NULL; - zb_enable_cb cb = NULL; - - DBG("zb_enable_cb()"); + zbl_req_cb_s *container =(zbl_req_cb_s *)p; RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; + RETVM_IF(NULL == p, G_SOURCE_REMOVE, "container is NULL"); + RETVM_IF(NULL == container->cb, G_SOURCE_REMOVE, "cb is NULL"); + RETVM_IF(true == container->found, G_SOURCE_REMOVE, "cb was alreay handled"); + + switch (container->cid) { + /* Service */ + case ZBL_SERVICE_FORM_NETWORK: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + case ZBL_SERVICE_DISABLE_NETWORK: { + zb_disable_network_cb cb = container->cb; + cb(0x0000, container->userdata); + cb(ZB_ZDP_TIMEOUT, container->userdata); + } + break; + /* ZDP except Bind */ + case ZBL_ZDO_NWK_ADDR_REQ: { + zb_zdo_addr_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, NULL, 0, 0, 0, NULL, container->userdata); + } + break; + case ZBL_ZDO_NWK_ADDR_EXT_REQ: { + zb_zdo_addr_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, NULL, 0, 0, 0, NULL, container->userdata); + } + break; + case ZBL_ZDO_ACTIVE_EP_REQ: { + zb_zdo_active_ep_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata); + } + break; + case ZBL_ZDO_SIMPLE_DESC_REQ: { + zb_zdo_simple_desc_rsp cb = container->cb; + cb(0, 0, NULL, container->userdata); + } + break; + case ZBL_ZDO_MATCHED_DESCRIPTOR_REQ: { + zb_zdo_match_desc_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata); + } + break; + case ZBL_ZDO_COMPLEX_DESC_REQ: { + zb_zdo_complex_desc_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata); + } + break; + case ZBL_ZDO_MGMT_BIND_REQ: { + zb_zdo_mgmt_bind_rsp cb = container->cb; + zb_zdo_binding_table_h *records = NULL; + + records = calloc(1, sizeof(zb_zdo_binding_table_h)); + if (records) { + records[0] = calloc(1, sizeof(struct zb_zdo_binding_table_s)); + } - if (false == container->found && container->cb) - cb(ZB_ZDP_NOT_SUPPORTED, container->userdata); + cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata); - container->tid = 0; + free(records[0]); + free(records); + } + break; + case ZBL_ZDO_MGMT_LQI_REQ: { + zb_zdo_mgmt_lqi_rsp cb = container->cb; + zb_zdo_neighbor_table_desc_h *records = NULL; + + records = calloc(1, sizeof(zb_zdo_neighbor_table_desc_h)); + if (records) { + records[0] = calloc(1, sizeof(struct zb_zdo_neighbor_table_desc_s)); + } + cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata); + + free(records[0]); + free(records); + } + break; + case ZBL_ZDO_MGMT_RTG_REQ: { + zb_zdo_mgmt_rtg_rsp cb = container->cb; + zb_zdo_routing_table_h *records = NULL; + + records = calloc(1, sizeof(zb_zdo_routing_table_h)); + if (records) { + records[0] = calloc(1, sizeof(struct zb_zdo_routing_table_s)); + } + cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata); + + free(records[0]); + free(records); + } + break; + case ZBL_ZDO_MGMT_NWK_DISC_REQ: { + zb_zdo_mgmt_nwk_disc_rsp cb = container->cb; + zb_zdo_network_list_record_h *records = NULL; + records = calloc(1, sizeof(zb_zdo_network_list_record_h)); + if (records) { + records[0] = calloc(1, sizeof(struct zb_zdo_network_list_record_s)); + } + cb(0, 0, 0, 0, records, container->userdata); + free(records[0]); + free(records); + } + break; + case ZBL_ZDO_MGMT_PERMIT_JOIN_REQ: { + zb_zdo_mgmt_permit_joining_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, container->userdata); + } + break; + case ZBL_ZDO_MGMT_LEAVE_REQ: { + zb_zdo_mgmt_leave_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, container->userdata); + } + break; + case ZBL_ZDO_NODE_DESC_REQ: { + zb_zdo_node_desc_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, 0, NULL, container->userdata); + } + break; + case ZBL_ZDO_POWER_DESC_REQ: { + zb_zdo_power_desc_rsp cb = container->cb; + cb(0, 0, NULL, container->userdata); + } + break; + case ZBL_ZDO_USER_DESC_REQ: { + zb_zdo_user_desc_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata); + } + case ZBL_ZDO_USER_DESC_SET_REQ: { + zb_zdo_user_desc_conf cb = container->cb; + cb(ZB_ZDP_TIMEOUT, container->userdata); + } + break; + /* ZDP Bind */ + case ZBL_ZDO_BIND_REQ: { + zb_zdo_bind_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, container->userdata); + } + break; + case ZBL_ZDO_UNBIND_REQ: { + zb_zdo_unbind_rsp cb = container->cb; + cb(ZB_ZDP_TIMEOUT, container->userdata); + } + break; + /* Custom */ + case ZBL_CUSTOM_APS_SEND_REQ: { + zb_aps_send_rsp cb = container->cb; + cb(0, 0, 0, 0, 0, 0, NULL, container->userdata); + } break; + case ZBL_CUSTOM_ZCL_SEND_REQ: { + zb_zcl_send_rsp cb = container->cb; + cb(0, 0, 0, 0, 0, 0, NULL, container->userdata); + } + break; + case ZBL_CUSTOM_LOCAL_SEND_REQ: { + zb_send_to_local_rsp cb = container->cb; + cb(0, NULL, container->userdata); + } + break; + /* ZCL Global */ + case ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ: { + zb_zcl_global_rsp cb = container->cb; + cb(0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ: { + zb_zcl_global_rsp cb = container->cb; + cb(0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_CONFIGURE_REPORTING_REQ: { + zb_zcl_global_rsp cb = container->cb; + cb(0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ: { + zb_zcl_global_discover_attr_rsp cb = container->cb; + cb(0, 0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_STRUCTURED_REQ: { + zb_zcl_global_rsp cb = container->cb; + cb(0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ: { + zb_zcl_global_discover_cmds_rsp cb = container->cb; + cb(0, 0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ: { + zb_zcl_global_discover_cmds_rsp cb = container->cb; + cb(0, 0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ: { + zb_zcl_global_discover_attr_extended_rsp cb = container->cb; + cb(0, 0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ: { + zb_zcl_global_rsp cb = container->cb; + cb(0, 0, 0, NULL, 0, container->userdata); + } + break; + /* ZCL Alarm */ + case ZBL_ZCL_ALARM_GET_ALARM_REQ: { + zb_zcl_alarm_get_alarm_rsp cb = container->cb; + cb(ZB_ZCL_TIMEOUT, 0, ZB_ZCL_UNSUP_CLUSTER_COMMAND, 0, 0, 0, container->userdata); + } + break; + /* ZCL Doorlock */ + case ZBL_ZCL_DOORLOCK_LOCK_STATE: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + /* ZCL Fanmode */ + case ZBL_ZCL_FANMODE_FAN_MODE_STATE: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + /* ZCL Group */ + case ZBL_ZCL_GROUP_ADD_GROUP_REQ: { + zb_zcl_group_add_group_rsp cb = container->cb; + cb(0, 0, 0, 0, container->userdata); + } + break; + case ZBL_ZCL_GROUP_VIEW_GROUP_REQ: { + zb_zcl_group_view_group_rsp cb = container->cb; + cb(0, 0, 0, 0, NULL, container->userdata); + } + break; + case ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ: { + zb_zcl_group_get_group_membership_rsp cb = container->cb; + cb(0, 0, 0, 0, NULL, container->userdata); + } + break; + case ZBL_ZCL_GROUP_REMOVE_GROUP_REQ: { + zb_zcl_group_remove_group_rsp cb = container->cb; + cb(0, 0, 0, 0, container->userdata); + } + break; + /* ZCL Identify */ + case ZBL_ZCL_IDENTIFY_QUERY_REQ: { + zb_zcl_identify_query_cb cb = container->cb; + cb(0, 0, container->userdata); + } + break; + /* ZCL On/Off */ + case ZBL_ZCL_ON_OFF_GET_ON_OFF_STATE: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + /* ZCL Pollcontrol */ + case ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ: { + zb_zcl_pollctrl_check_in cb = container->cb; + cb(0, 0, container->userdata); + } + break; + /* ZCL Scene */ + case ZBL_ZCL_SCENE_ADD_SCENE_REQ: { + zb_zcl_scene_add_scene_rsp cb = container->cb; + cb(0, 0, 0, 0, 0, container->userdata); + } + break; + case ZBL_ZCL_SCENE_VIEW_SCENE_REQ: { + zb_zcl_scene_view_scene_rsp cb = container->cb; + cb(0, 0, 0, 0, 0, 0, NULL, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_SCENE_REMOVE_SCENE_REQ: { + zb_zcl_scene_remove_scene_rsp cb = container->cb; + cb(0, 0, 0, 0, 0, container->userdata); + } + break; + case ZBL_ZCL_SCENE_STORE_SCENE_REQ: { + zb_zcl_scene_store_scene_rsp cb = container->cb; + cb(0, 0, 0, 0, 0, container->userdata); + } + break; + case ZBL_ZCL_SCENE_REMOVE_ALL_SCENE_REQ: { + zb_zcl_scene_remove_all_scene_rsp cb = container->cb; + cb(0, 0, 0, 0, container->userdata); + } + break; + case ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ: { + zb_zcl_scene_get_scene_membership_rsp cb = container->cb; + cb(0, 0, 0, 0, 0, 0, NULL, container->userdata); + } + break; + /* ZCL Thermostat */ + case ZBL_ZCL_THERMOSTAT_GET_LOCAL_TEMP: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + default: + ERR("Unhandled cid = %d", container->cid); + } + container->tid = 0; g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); container->sid = 0; return G_SOURCE_REMOVE; } -static void _zbl_enable_cb(GDBusConnection *connection, +static void _zbl_response_cb(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data) { zbl_req_cb_s *container = user_data; - zb_enable_cb cb = container->cb; - - unsigned char ret = ZB_ZDP_SUCCESS; + RETM_IF(NULL == container, "container is null"); + RETM_IF(NULL == container->cb, "cb is NULL"); container->found = true; + g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("_zbl_enable_cb"); + switch (container->cid) { + /* Service */ + case ZBL_SERVICE_FORM_NETWORK: { + zb_form_network_cb cb = container->cb; + nwk_addr panid; + g_variant_get(parameters, "(q)", &panid); + cb(panid, container->userdata); + } + break; + case ZBL_SERVICE_DISABLE_NETWORK: { + zb_disable_network_cb cb = container->cb; + unsigned char ret = ZB_ZDP_SUCCESS; + g_variant_get(parameters, "(y)", &ret); + cb(ret, container->userdata); + } + break; + /* ZDP except Bind */ + case ZBL_ZDO_NWK_ADDR_REQ: { + zb_zdo_addr_rsp cb = container->cb; - g_variant_get(parameters, "(b)", &ret); + int j = 0; + nwk_addr addr16; + ieee_addr addr64; + unsigned char status; + unsigned char num; + unsigned char start_idx; + unsigned char value; + GVariantIter *mac_iter = NULL; - if (cb) - cb(ret, container->userdata); + g_variant_get(parameters, "(yayqyy)", &status, &mac_iter, &addr16, &num, &start_idx); + while (g_variant_iter_loop(mac_iter, "y", &value)) { + addr64[j] = value; + j++; + } - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} + cb(status, addr64, addr16, num, start_idx, NULL, container->userdata); + if (NULL != mac_iter) + g_variant_iter_free(mac_iter); + } + break; + case ZBL_ZDO_NWK_ADDR_EXT_REQ: { + zb_zdo_addr_rsp cb = container->cb; + int j = 0; + nwk_addr addr16; + ieee_addr addr64; + unsigned char status; + unsigned char num; + unsigned char start_idx; + unsigned char value; + GVariantIter *mac_iter = NULL; -int zbl_enable(zigbee_h handle, zb_enable_cb cb, void *user_data) -{ - int sub_id, to; - zbl_req_cb_s *container; + g_variant_get(parameters, "(yayqyy)", &status, &mac_iter, &addr16, &num, &start_idx); + while (g_variant_iter_loop(mac_iter, "y", &value)) { + addr64[j] = value; + j++; + } + if (NULL != mac_iter) + g_variant_iter_free(mac_iter); - RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); - RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); + cb(status, addr64, addr16, num, start_idx, NULL, container->userdata); + } + break; + case ZBL_ZDO_ACTIVE_EP_REQ: { + zb_zdo_active_ep_rsp cb = container->cb; - DBG("zbl_enable()"); + int j = 0; + nwk_addr addr16; + unsigned char status; + unsigned char count; + unsigned char value; + GVariantIter *ep_iter = NULL; + unsigned char *ep_list; - container = calloc(1, sizeof(zbl_req_cb_s)); - RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno); + g_variant_get(parameters, "(qyayy)", &addr16, &status, &ep_iter, &count); + ep_list = calloc(count+1, sizeof(unsigned char)); + RETM_IF(NULL == ep_list, "calloc() Fail(%d)", errno); - to = zbl_dbus_get_timeout(service_gproxy); - sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, - ZIGBEE_SERVICE_INTERFACE, "enabled", ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_enable_cb, container, _zbl_request_cleanup); + while (g_variant_iter_loop(ep_iter, "y", &value)) { + ep_list[j] = value; + j++; + } + if (NULL != ep_iter) + g_variant_iter_free(ep_iter); - if (0 == sub_id) { - ERR("g_dbus_connection_signal_subscribe() Fail"); - free(container); - return ZIGBEE_ERROR_IO_ERROR; + cb(status, addr16, count, ep_list, container->userdata); + free(ep_list); } + break; + case ZBL_ZDO_SIMPLE_DESC_REQ: { + zb_zdo_simple_desc_rsp cb = container->cb; - container->cb = cb; - container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_enable, container); - container->userdata = user_data; + int j = 0; + int count; + unsigned short addr16; + unsigned short value; + GVariantIter *in_iter = NULL; + GVariantIter *out_iter = NULL; + zb_zdo_simple_desc_h records; + + records = calloc(1, sizeof(struct zb_zdo_simple_desc_s)); + RETM_IF(NULL == records, "calloc() Fail(%d)", errno); - g_dbus_proxy_call(service_gproxy, "enable", NULL, G_DBUS_CALL_FLAGS_NONE, to, - NULL, NULL, container); + container->found = true; - return ZIGBEE_ERROR_NONE; -} + g_variant_get(parameters, "(qiyyqqyyaqaq)", &addr16, &count, + &records->device_ver, + &records->ep, &records->profile_id, &records->device_id, + &records->num_of_in_clusters, &records->num_of_out_clusters, + &in_iter, &out_iter); +#if 0 + records->in_clusters = calloc(records->num_of_in_clusters, sizeof(unsigned short)); + if (NULL == records->in_clusters) { + ERR("calloc() Fail(%d)", errno); + if (NULL != in_iter) + g_variant_iter_free(in_iter); + if (NULL != out_iter) + g_variant_iter_free(out_iter); + return; + } + records->out_clusters = calloc(records->num_of_out_clusters, sizeof(unsigned short)); + if (NULL == records->out_clusters) { + ERR("calloc() Fail(%d)", errno); + free(records->in_clusters); + if (NULL != in_iter) + g_variant_iter_free(in_iter); + if (NULL != out_iter) + g_variant_iter_free(out_iter); + return; + } +#endif + while (g_variant_iter_loop(in_iter, "q", &value)) { + records->in_clusters[j] = value; + j++; + } + if (NULL != in_iter) + g_variant_iter_free(in_iter); -int zbl_set_event_cb(zigbee_h handle, zb_event_cb event_handler) -{ - RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER); - handle->event_handler = event_handler; - return ZIGBEE_ERROR_NONE; -} + j = 0; + while (g_variant_iter_loop(out_iter, "q", &value)) { + records->out_clusters[j] = value; + j++; + } + if (NULL != out_iter) + g_variant_iter_free(out_iter); -int zbl_disable(void) -{ - DBG("zbl_disable()"); + DBG("addr16=0x%x, count=%d, records->ep=%d, records->device_id=0x%x", + addr16, count, records->ep, records->device_id); + for (j = 0; j < records->num_of_in_clusters; j++) + DBG("in_clusters[%d] = 0x%x", j, records->in_clusters[j]); + for (j = 0; j < records->num_of_out_clusters; j++) + DBG("out_clusters[%d] = 0x%x", j, records->out_clusters[j]); - if (0 >= zbl_ref_count) { - WARN("dbus does not initiaized\n"); - return ZIGBEE_ERROR_NO_DATA; + cb(addr16, count, records, container->userdata); +#if 0 + free(records->in_clusters); + free(records->out_clusters); +#endif + free(records); } + break; + case ZBL_ZDO_MATCHED_DESCRIPTOR_REQ: { + zb_zdo_match_desc_rsp cb = container->cb; - if (0 > --zbl_ref_count) { - DBG("all connections closed\n"); - return ZIGBEE_ERROR_NONE; + int j = 0; + int match_len; + nwk_addr addr16; + unsigned char value; + unsigned char status; + GVariantIter *ml_iter = NULL; + unsigned char *match_list = NULL; + g_variant_get(parameters, "(yqyay)", &status, &addr16, &match_len, &ml_iter); + + if (match_len > 0) { + match_list = calloc(match_len+1, sizeof(unsigned char)); + RETM_IF(NULL == match_list, "calloc() Fail(%d)", errno); + while (g_variant_iter_loop(ml_iter, "y", &value)) { + match_list[j] = value; + DBG("match_list[i]=%d", j, match_list[j]); + j++; + } + if (NULL != ml_iter) + g_variant_iter_free(ml_iter); + } + + cb(status, addr16, match_len, match_list, container->userdata); + + free(match_list); } + break; + case ZBL_ZDO_NODE_DESC_REQ: { + zb_zdo_node_desc_rsp cb = container->cb; - if (gdbus_conn) { + nwk_addr addr16; + unsigned char status; + zb_zdo_node_descriptor_h desc; - if (service_gproxy) { - g_dbus_proxy_call(service_gproxy, "disable", NULL, G_DBUS_CALL_FLAGS_NONE, - -1, NULL, NULL, NULL); + desc = calloc(1, sizeof(struct zb_zdo_node_descriptor_s)); + RETM_IF(NULL == desc, "calloc() Fail(%d)", errno); - g_object_unref(service_gproxy); - service_gproxy = NULL; - g_object_unref(on_off_gproxy); - on_off_gproxy = NULL; - g_object_unref(door_lock_gproxy); - door_lock_gproxy = NULL; - g_object_unref(level_control_gproxy); - level_control_gproxy = NULL; - g_object_unref(thermostat_gproxy); - thermostat_gproxy = NULL; - g_object_unref(alarm_gproxy); - alarm_gproxy = NULL; - g_object_unref(fan_control_gproxy); - fan_control_gproxy = NULL; + container->found = true; - g_object_unref(mfglib_gproxy); - mfglib_gproxy = NULL; - g_object_unref(zcl_global_proxy); - zcl_global_proxy = NULL; - g_object_unref(zcl_color_control_proxy); - zcl_color_control_proxy = NULL; - g_object_unref(custom_gproxy); - custom_gproxy = NULL; - } + g_variant_get(parameters, "(yqyyyyyyqyqqqy)", &status, &addr16, + &desc->logical_type, &desc->complex_desciptor_available, + &desc->user_descriptor_available, &desc->aps_flags, &desc->frequency_band, + &desc->mac_capability_flags, &desc->manufacturer_code, &desc->maximum_buffer_size, + &desc->maximum_incoming_transfer_size, &desc->server_mask, + &desc->maximum_outgoing_transfer_size, &desc->descriptor_capability_field); - g_object_unref(gdbus_conn); - gdbus_conn = NULL; + cb(status, addr16, desc, container->userdata); + free(desc); + } + break; + case ZBL_ZDO_POWER_DESC_REQ: { + zb_zdo_power_desc_rsp cb = container->cb; + + nwk_addr addr16; + unsigned char status; + zb_zdo_node_power_descriptor_h desc; + + desc = calloc(1, sizeof(struct zb_zdo_node_power_descriptor_s)); + RETM_IF(NULL == desc, "calloc() Fail(%d)", errno); + + g_variant_get(parameters, "(yqyyyy)", &status, &addr16, + &desc->current_power_mode, &desc->available_power_sources, + &desc->current_power_source, &desc->current_power_source_level); + + cb(status, addr16, desc, container->userdata); + free(desc); + } + break; + case ZBL_ZDO_COMPLEX_DESC_REQ: { + zb_zdo_complex_desc_rsp cb = container->cb; + + int length; + nwk_addr addr16; + unsigned char j = 0; + unsigned char value; + unsigned char status; + GVariantIter *comp_iter = NULL; + unsigned char *complex_desc = NULL; + + g_variant_get(parameters, "(yqyay)", &status, &addr16, &length, &comp_iter); + if (length > 0) { + complex_desc = calloc(length, sizeof(char)); + if (NULL == complex_desc) { + if (NULL != comp_iter) + g_variant_iter_free(comp_iter); + ERR("calloc() Fail(%d)", errno); + return; + } + + while (g_variant_iter_loop(comp_iter, "y", &value)) { + complex_desc[j] = value; + j++; + } + if (NULL != comp_iter) + g_variant_iter_free(comp_iter); + } + + cb(status, addr16, length, complex_desc, container->userdata); + free(complex_desc); + } + break; + case ZBL_ZDO_USER_DESC_REQ: { + zb_zdo_user_desc_rsp cb = container->cb; + + int length; + nwk_addr addr16; + unsigned char j = 0; + unsigned char value; + unsigned char status; + GVariantIter *comp_iter = NULL; + unsigned char *complex_desc = NULL; + + g_variant_get(parameters, "(yqyay)", &status, &addr16, &length, &comp_iter); + if (length > 0) { + complex_desc = calloc(length, sizeof(char)); + if (NULL == complex_desc) { + if (NULL != comp_iter) + g_variant_iter_free(comp_iter); + ERR("calloc() Fail(%d)", errno); + return; + } + while (g_variant_iter_loop(comp_iter, "y", &value)) { + complex_desc[j] = value; + j++; + } + if (NULL != comp_iter) + g_variant_iter_free(comp_iter); + } + + cb(status, addr16, length, complex_desc, container->userdata); + free(complex_desc); + } + case ZBL_ZDO_USER_DESC_SET_REQ: { + zb_zdo_user_desc_conf cb = container->cb; + unsigned char status; + g_variant_get(parameters, "(y)", &status); + cb(status, container->userdata); + } + break; + case ZBL_ZDO_MGMT_BIND_REQ: { + zb_zdo_mgmt_bind_rsp cb = NULL; + + unsigned char status; + unsigned char value; + + int i = 0; + int j = 0; + unsigned char binding_table_enteries; + unsigned char binding_table_list_count; + unsigned char start_index; + + GVariantIter *mac_iter = NULL; + GVariantIter *rsp_iter = NULL; + GVariantIter *destep_iter = NULL; + zb_zdo_binding_table_h *records = NULL; + + g_variant_get(parameters, "(yyyya(ayyqyay))", &status, &binding_table_enteries, + &start_index, &binding_table_list_count, &rsp_iter); + + if (binding_table_list_count > 0) { + records = calloc(binding_table_list_count, sizeof(zb_zdo_binding_table_h)); + RETM_IF(NULL == records, "calloc() Fail(%d)", errno); + for (i = 0; i < binding_table_list_count; i++) { + records[i] = calloc(binding_table_list_count, sizeof(struct zb_zdo_binding_table_s)); + if (NULL == records[i]) { + if (NULL != mac_iter) + g_variant_iter_free(mac_iter); + if (NULL != rsp_iter) + g_variant_iter_free(rsp_iter); + if (NULL != destep_iter) + g_variant_iter_free(destep_iter); + ERR("calloc() Fail(%d)", errno); + goto MGMT_NWK_BIND_REQ_OUT; + } + } + } + for (i = 0; i < binding_table_list_count; i++) { + g_variant_iter_loop(rsp_iter, "(ayyqyay)", &mac_iter, &records[i]->src_ep, + &records[i]->cluster_id, &records[i]->dst_addr_mode, &destep_iter); + for (j = 0; j < 8; j++) { + g_variant_iter_loop(mac_iter, "y", &value); + records[i]->src_addr64[j] = value; + } + if (NULL != mac_iter) + g_variant_iter_free(mac_iter); + + if (0x03 == records[i]->dst_addr_mode) { + for (j = 0; j < 8; j++) { + g_variant_iter_loop(destep_iter, "y", &value); + records[i]->dst_addr64[j] = value; + } + g_variant_iter_loop(destep_iter, "y", &value); + records[i]->dst_ep = value; + DBG("Destination MAC Addr : %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", + records[i]->dst_addr64[7], records[i]->dst_addr64[6], + records[i]->dst_addr64[5], records[i]->dst_addr64[4], + records[i]->dst_addr64[3], records[i]->dst_addr64[2], + records[i]->dst_addr64[1], records[i]->dst_addr64[0]); + + } else if (0x01 == records[i]->dst_addr_mode) { + g_variant_iter_loop(destep_iter, "y", &value); + records[i]->dst_addr16 = value; + g_variant_iter_loop(destep_iter, "y", &value); + records[i]->dst_addr16 += (value << 8); + } + if (NULL != destep_iter) + g_variant_iter_free(destep_iter); + } + if (NULL != rsp_iter) + g_variant_iter_free(rsp_iter); + + cb(status, binding_table_enteries, start_index, binding_table_list_count, + records, container->userdata); + +MGMT_NWK_BIND_REQ_OUT: + for (i = 0; i < binding_table_list_count; i++) { + if (records[i]) + free(records[i]); + } + free(records); + } + break; + case ZBL_ZDO_MGMT_LQI_REQ: { + zb_zdo_mgmt_lqi_rsp cb = container->cb; + + int i = 0; + int j = 0; + unsigned char value; + unsigned char status; + unsigned char start_index; + unsigned char neighbor_table_enteries; + unsigned char neighbor_table_list_count; + + GVariantIter *resp_iter = NULL; + GVariantIter *mac_iter = NULL; + GVariantIter *mac_iter1 = NULL; + zb_zdo_neighbor_table_desc_h *records = NULL; + + g_variant_get(parameters, "(yyyya(ayayyqyyyyy))", &status, &neighbor_table_enteries, + &start_index, &neighbor_table_list_count, &resp_iter); + + if (neighbor_table_list_count > 0) { + records = calloc(neighbor_table_list_count, sizeof(zb_zdo_neighbor_table_desc_h)); + RETM_IF(NULL == records, "calloc() Fail(%d)", errno); + for (i = 0; i < neighbor_table_list_count; i++) { + records[i] = calloc(1, sizeof(struct zb_zdo_neighbor_table_desc_s)); + if (NULL == records[i]) { + ERR("calloc() Fail(%d)", errno); + goto MGMT_LQI_REQ_OUT; + } + } + } + for (i = 0; i < neighbor_table_list_count; i++) { + g_variant_iter_loop(resp_iter, "(ayayyqyyyyy)", &mac_iter, &mac_iter1, + &records[i]->device_type, &records[i]->addr16, &records[i]->rx_on_when_idle, + &records[i]->relationship, &records[i]->permit_joining, &records[i]->depth, + &records[i]->lqi); + for (j = 0; j < 8; j++) { + g_variant_iter_loop(mac_iter, "y", &value); + records[i]->extended_pan_id[j] = value; + g_variant_iter_loop(mac_iter1, "y", &value); + records[i]->addr64[j] = value; + } + if (NULL != mac_iter) + g_variant_iter_free(mac_iter); + if (NULL != mac_iter1) + g_variant_iter_free(mac_iter1); + + DBG("ext PAN ID = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", + records[i]->extended_pan_id[0], records[i]->extended_pan_id[1], + records[i]->extended_pan_id[2], records[i]->extended_pan_id[3], + records[i]->extended_pan_id[4], records[i]->extended_pan_id[5], + records[i]->extended_pan_id[6], records[i]->extended_pan_id[7]); + + DBG("IEEE address = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", + records[i]->addr64[0], records[i]->addr64[1], records[i]->addr64[2], records[i]->addr64[3], + records[i]->addr64[4], records[i]->addr64[5], records[i]->addr64[6], records[i]->addr64[7]); + } + if (NULL != resp_iter) + g_variant_iter_free(resp_iter); + + cb(status, neighbor_table_enteries, start_index, neighbor_table_list_count, + records, container->userdata); + +MGMT_LQI_REQ_OUT: + for (i = 0; i < neighbor_table_list_count; i++) { + if (records[i]) + free(records[i]); + } + free(records); + } + break; + case ZBL_ZDO_MGMT_RTG_REQ: { + zb_zdo_mgmt_rtg_rsp cb = NULL; + + int i; + unsigned char status; + unsigned char start_index; + unsigned char routing_table_enteries; + unsigned char routing_table_list_count; + + GVariantIter *rsp_iter = NULL; + zb_zdo_routing_table_h *records = NULL; + + g_variant_get(parameters, "(yyyya(qyyyyq))", &status, &routing_table_enteries, + &start_index, &routing_table_list_count, &rsp_iter); + + if (routing_table_list_count > 0) { + records = calloc(routing_table_list_count, sizeof(zb_zdo_routing_table_h)); + RETM_IF(NULL == records, "calloc() Fail(%d)", errno); + for (i = 0; i < routing_table_list_count; i++) { + records[i] = calloc(1, sizeof(struct zb_zdo_routing_table_s)); + if (NULL == records[i]) { + ERR("calloc() Fail(%d)", errno); + goto MGMT_NWK_RTG_REQ_OUT; + } + } + } + + for (i = 0; i < routing_table_list_count; i++) { + g_variant_iter_loop(rsp_iter, "(qyyyyq)", &records[i]->dst_addr, &records[i]->status, + &records[i]->memory_constrained, &records[i]->route_record_required, + &records[i]->many_to_one, &records[i]->next_hop_addr); + } + if (NULL != rsp_iter) + g_variant_iter_free(rsp_iter); + + cb(status, routing_table_enteries, start_index, routing_table_list_count, + records, container->userdata); + +MGMT_NWK_RTG_REQ_OUT: + for (i = 0; i < routing_table_list_count; i++) { + if (records[i]) + free(records[i]); + } + free(records); + } + break; + case ZBL_ZDO_MGMT_NWK_DISC_REQ: { + zb_zdo_mgmt_nwk_disc_rsp cb = container->cb; + int i = 0; + int j = 0; + unsigned char value; + unsigned char status = 0; + unsigned char nwk_count = 0; + unsigned char start_index = 0; + unsigned char nwk_list_count = 0; + + GVariantIter *mac_iter = NULL; + GVariantIter *resp_iter = NULL; + + DBG("_zbl_mgmt_nwk_disc_req_cb()"); + + g_variant_get(parameters, "(yyyya(ayayyqyyyyy))", &status, &nwk_count, + &start_index, &nwk_list_count, &resp_iter); + + zb_zdo_network_list_record_h *records = NULL; + + if (!status) { + if (nwk_list_count > 0) { + records = calloc(nwk_list_count, sizeof(zb_zdo_network_list_record_h)); + RETM_IF(NULL == records, "calloc() Fail(%d)", errno); + for (i = 0; i < nwk_list_count; i++) { + records[i] = calloc(1, sizeof(struct zb_zdo_network_list_record_s)); + if (NULL == records[i]) { + ERR("calloc() Fail(%d)", errno); + goto MGMT_NWK_DISC_REQ_OUT; + } + } + } + for (i = 0; i < nwk_list_count; i++) { + g_variant_iter_loop(resp_iter, "(ayayyqyyyyy)", &mac_iter, &records[i]->logical_channel, + &records[i]->stack_profile, &records[i]->zigbee_version, &records[i]->beacon_order, + &records[i]->superframe_order, &records[i]->permit_joining); + for (j = 0; j < 8; j++) { + g_variant_iter_loop(mac_iter, "y", &value); + records[i]->extended_pan_id[j] = value; + } + if (NULL != mac_iter) + g_variant_iter_free(mac_iter); + } + if (NULL != resp_iter) + g_variant_iter_free(resp_iter); + } + + cb(status, nwk_count, start_index, nwk_list_count, records, container->userdata); + +MGMT_NWK_DISC_REQ_OUT: + for (i = 0; i < nwk_list_count; i++) { + if (records[i]) + free(records[i]); + } + free(records); + } + break; + case ZBL_ZDO_MGMT_PERMIT_JOIN_REQ: { + zb_zdo_mgmt_permit_joining_rsp cb = container->cb; + unsigned char status; + g_variant_get(parameters, "(y)", &status); + cb(status, container->userdata); + } + break; + case ZBL_ZDO_MGMT_LEAVE_REQ: { + zb_zdo_mgmt_leave_rsp cb = container->cb; + unsigned char status; + g_variant_get(parameters, "(y)", &status); + cb(status, container->userdata); + } + break; + /* ZDP Bind */ + case ZBL_ZDO_BIND_REQ: { + zb_zdo_bind_rsp cb = container->cb; + unsigned char status; + g_variant_get(parameters, "(y)", &status); + cb(status, container->userdata); + } + break; + case ZBL_ZDO_UNBIND_REQ: { + zb_zdo_unbind_rsp cb = container->cb; + unsigned char status; + g_variant_get(parameters, "(y)", &status); + cb(status, container->userdata); + } + break; + /* Custom */ + case ZBL_CUSTOM_APS_SEND_REQ: { + zb_aps_send_rsp cb = container->cb; + + unsigned short addr16; + unsigned char src_ep; + unsigned char dst_ep; + unsigned char cluster_id; + unsigned char profile_id; + unsigned char *payload = NULL; + unsigned short payload_len = 0; + unsigned char value; + GVariantIter *payload_iter = NULL; + int i = 0; + + g_variant_get(parameters, "(qyyqqayq)", &addr16, &src_ep, &dst_ep, + &cluster_id, &profile_id, &payload_iter, &payload_len); + + if (payload_len > 0) { + payload = calloc(payload_len, sizeof(unsigned char)); + while (g_variant_iter_loop(payload_iter, "y", &value)) { + payload[i++] = value; + } + if (NULL != payload_iter) + g_variant_iter_free(payload_iter); + } + + cb(addr16, src_ep, dst_ep, cluster_id, profile_id, payload_len, payload, + container->userdata); + + free(payload); + } + break; + case ZBL_CUSTOM_ZCL_SEND_REQ: { + zb_zcl_send_rsp cb = container->cb; + + unsigned short addr16; + unsigned char src_ep; + unsigned char dst_ep; + unsigned char cluster_id; + unsigned char profile_id; + unsigned char *payload = NULL; + unsigned short payload_len = 0; + unsigned char value; + GVariantIter *payload_iter = NULL; + int i = 0; + + g_variant_get(parameters, "(qyyqqayq)", &addr16, &src_ep, &dst_ep, + &cluster_id, &profile_id, &payload_iter, &payload_len); + + if (payload_len > 0) { + payload = calloc(payload_len, sizeof(unsigned char)); + while (g_variant_iter_loop(payload_iter, "y", &value)) { + payload[i++] = value; + } + if (NULL != payload_iter) + g_variant_iter_free(payload_iter); + } + + cb(addr16, src_ep, dst_ep, cluster_id, profile_id, payload_len, payload, + container->userdata); + + free(payload); + } + break; + case ZBL_CUSTOM_LOCAL_SEND_REQ: { + zb_send_to_local_rsp cb = container->cb; + + unsigned char *data = NULL; + unsigned short length = 0; + unsigned char value; + GVariantIter *payload_iter = NULL; + int i = 0; + + g_variant_get(parameters, "(ayq)", &payload_iter, &length); + + if (length > 0) { + data = calloc(length, sizeof(unsigned char)); + while (g_variant_iter_loop(payload_iter, "y", &value)) { + data[i++] = value; + } + if (NULL != payload_iter) + g_variant_iter_free(payload_iter); + } + + cb(length, data, container->userdata); + + free(data); + } + break; + /* ZCL Global */ + case ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ: { + zb_zcl_global_rsp cb = container->cb; + + int j = 0; + int isString; + unsigned char value; + + nwk_addr addr16; + unsigned char ep; + unsigned short attr_id; + unsigned short cluster_id; + unsigned char status; + unsigned char type; + unsigned short records_len; + unsigned char attr_value[128]; + + GVariantIter *iter = NULL; + read_attr_status_record_h records; + zb_global_record_data_s *data; + + data = calloc(1, sizeof(zb_global_record_data_s)); + records = calloc(1, sizeof(struct read_attribute_status_record_s)); + if (!records || !data) { + ERR("calloc() Fail(%d)", errno); + goto GLOBAL_READ_ATTRIBUTE_REQ_OUT; + } + + g_variant_get(parameters, "(qyayqqyyqi)", + &addr16, &ep, &iter, &attr_id, &cluster_id, &status, &type, &records_len, &isString); + if (!isString) { + while (g_variant_iter_loop(iter, "y", &value)) { + attr_value[j] = value; + DBG("attr_value[%d] = 0x%02X", j, value); + j++; + } + if (NULL != iter) + g_variant_iter_free(iter); + } else { + while (g_variant_iter_loop(iter, "y", &value)) { + if (j == 0) + records_len = value; + attr_value[j] = value; + DBG("attr_value[%d] = 0x%02X", j, value); + j++; + } + if (NULL != iter) + g_variant_iter_free(iter); + } + + records->id = attr_id; + records->status = status; + records->type = type; + records->value = attr_value; + data->type = ZB_GLOBAL_READ_ATTR; + data->record.read_attr = &records; + data->records_len = records_len; + + cb(addr16, ep, cluster_id, data, records_len, container->userdata); + +GLOBAL_READ_ATTRIBUTE_REQ_OUT: + if (records) + free(records); + if (data) + free(data); + } + break; + case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ: { + zb_zcl_global_rsp cb = container->cb; + + int i = 0; + nwk_addr addr16; + unsigned char ep; + unsigned short cluster_id; + unsigned short attribute_id; + int records_len; + unsigned char value; + + GVariantIter *stat_iter = NULL; + GVariantIter *attr_iter = NULL; + write_attr_status_record_h records; + zb_global_record_data_s *data; + + g_variant_get(parameters, "(qyayaqqi)", + &addr16, &ep, &stat_iter, &attr_iter, &cluster_id, &records_len); + + records = calloc(records_len, sizeof(struct write_attribute_status_record_s)); + data = calloc(1, sizeof(zb_global_record_data_s)); + if (!records || !data) { + if (NULL != stat_iter) + g_variant_iter_free(stat_iter); + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + ERR("calloc() Fail(%d)", errno); + goto GLOBAL_WRITE_ATTRIBUTE_REQ_OUT; + } + + while (g_variant_iter_loop(stat_iter, "y", &value)) { + records[i].status = value; + i++; + } + if (NULL != stat_iter) + g_variant_iter_free(stat_iter); + + i = 0; + while (g_variant_iter_loop(attr_iter, "q", &attribute_id)) { + records[i].id = attribute_id; + DBG("Attribute Id 0x%04X", attribute_id); + i++; + } + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + + data->type = ZB_GLOBAL_WRITE_ATTR; + data->record.write_attr = &records; + data->records_len = records_len; + + cb(addr16, ep, cluster_id, data, records_len, container->userdata); + +GLOBAL_WRITE_ATTRIBUTE_REQ_OUT: + free(records); + free(data); + } + break; + case ZBL_ZCL_GLOBAL_CONFIGURE_REPORTING_REQ: { + zb_zcl_global_rsp cb = container->cb; + nwk_addr addr16; + unsigned char ep; + unsigned short cluster_id; + unsigned short attIdVal; + unsigned char value; + int j = 0, l = 0, k = 0, rec_len; + GVariantIter *stat_iter = NULL; + GVariantIter *attr_iter = NULL; + GVariantIter *dir_iter = NULL; + report_config_response_record_h records; + zb_global_record_data_s *data; + + g_variant_get(parameters, "(ayaqayqiqy)", + &stat_iter, &attr_iter, &dir_iter, &cluster_id, &rec_len, &addr16, &ep); + + records = calloc(rec_len, sizeof(struct reporting_configuration_response_record_s)); + data = calloc(1, sizeof(zb_global_record_data_s)); + if (!data || !records) { + if (NULL != stat_iter) + g_variant_iter_free(stat_iter); + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + if (NULL != dir_iter) + g_variant_iter_free(dir_iter); + ERR("calloc() Fail(%d)", errno); + goto GLOBAL_CONFIGURE_REPORTING_REQ_OUT; + } + + while (g_variant_iter_loop(stat_iter, "y", &value)) { + DBG("Value 0x%02X", value); + records[j].status = value; + j++; + } + if (NULL != stat_iter) + g_variant_iter_free(stat_iter); + + while (g_variant_iter_loop(attr_iter, "q", &attIdVal)) { + if (records[l].status != ZB_ZCL_SUCCESS) + records[l].id = attIdVal; + l++; + } + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + + while (g_variant_iter_loop(dir_iter, "y", &value)) { + if (records[k].status != ZB_ZCL_SUCCESS) + records[k].dir = value; + k++; + } + if (NULL != dir_iter) + g_variant_iter_free(dir_iter); + + data->type = ZB_GLOBAL_CONFIG_REPORT; + data->record.report_config_rsp = &records; + data->records_len = rec_len; + + cb(addr16, ep, cluster_id, data, rec_len, container->userdata); + +GLOBAL_CONFIGURE_REPORTING_REQ_OUT: + free(records); + free(data); + } + break; + case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ: { + zb_zcl_global_discover_attr_rsp cb = container->cb; + nwk_addr addr16; + unsigned char ep; + discover_attr_info_record_h *records; + + int records_len; + unsigned short cluster_id; + unsigned short attribute_id; + unsigned char value; + int j = 0, l = 0; + int discovery_complete; + GVariantIter *stat_iter = NULL; + GVariantIter *attr_iter = NULL; + + g_variant_get(parameters, "(qyayaqqii)", &addr16, &ep, &stat_iter, + &attr_iter, &cluster_id, &records_len, &discovery_complete); + records = calloc(records_len, sizeof(discover_attr_info_record_h)); + RETM_IF(NULL == records, "calloc() Fail(%d)", errno); + for (j = 0; j < records_len; j++) { + records[j] = calloc(1, sizeof(struct discover_attribute_info_record_s)); + if (NULL == records[j]) { + ERR("calloc() Fail(%d)", errno); + for (l = 0; l < j; l++) + free(records[l]); + free(records); + if (NULL != stat_iter) + g_variant_iter_free(stat_iter); + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + return; + } + } + + j = 0; + while (g_variant_iter_loop(stat_iter, "y", &value)) { + records[j]->type = value; + DBG("Attribute Type 0x%02X", value); + j++; + } + if (NULL != stat_iter) + g_variant_iter_free(stat_iter); + + while (g_variant_iter_loop(attr_iter, "q", &attribute_id)) { + records[l]->id = attribute_id; + DBG("Attribute Id 0x%04X", attribute_id); + l++; + } + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + + cb(addr16, ep, cluster_id, discovery_complete, records, records_len, + container->userdata); + + for (j = 0; j < records_len; j++) + free(records[j]); + free(records); + } + break; + case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_STRUCTURED_REQ: { + zb_zcl_global_rsp cb = container->cb; + cb(0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ: { + zb_zcl_global_discover_cmds_rsp cb = container->cb; + + nwk_addr addr16; + unsigned char ep; + + int j = 0; + char value; + unsigned short cluster_id; + unsigned short cmd_len; + unsigned char *cmd_data; + unsigned char discoveryComplete; + GVariantIter *cmd_iter = NULL; + + g_variant_get(parameters, "(ayqqqyy)", &cmd_iter, &cluster_id, &cmd_len, + &addr16, &ep, &discoveryComplete); + + cmd_data = calloc(cmd_len+1, sizeof(char)); + if (NULL == cmd_data) { + ERR("calloc() Fail(%d)", errno); + if (NULL != cmd_iter) + g_variant_iter_free(cmd_iter); + return; + } + + while (g_variant_iter_loop(cmd_iter, "y", &value)) { + DBG("Value 0x%02X", value); + cmd_data[j] = value; + j++; + } + if (NULL != cmd_iter) + g_variant_iter_free(cmd_iter); + + cb(addr16, ep, cluster_id, discoveryComplete, cmd_data, cmd_len, container->userdata); + free(cmd_data); + } + break; + case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ: { + zb_zcl_global_discover_cmds_rsp cb = container->cb; + cb(0, 0, 0, 0, NULL, 0, container->userdata); + } + break; + case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ: { + zb_zcl_global_discover_attr_extended_rsp cb = container->cb; + nwk_addr addr16; + unsigned char ep; + + int i = 0; + int j = 0; + unsigned short cluster_id; + unsigned char t_value; + unsigned char ac_value; + + unsigned short rec_len; + unsigned short attr_data; + unsigned char discoveryComplete; + GVariantIter *attr_iter = NULL; + GVariantIter *type_iter = NULL; + GVariantIter *ac_iter = NULL; + extended_attr_info_h *records; + + DBG("Will get the value now"); + + g_variant_get(parameters, "(aqayayqqqyy)", &attr_iter, &type_iter, &ac_iter, + &cluster_id, &rec_len, &addr16, &ep, &discoveryComplete); + + DBG("records length 0x%04X", rec_len); + + records = calloc(rec_len, sizeof(extended_attr_info_h)); + RETM_IF(NULL == records, "calloc() Fail(%d)", errno); + for (j = 0; j < rec_len; j++) { + records[j] = calloc(1, sizeof(struct extended_attribute_infomation_s)); + if (NULL == records[j]) { + for (i = 0; i < j; i++) + free(records[i]); + free(records); + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + if (NULL != type_iter) + g_variant_iter_free(type_iter); + if (NULL != ac_iter) + g_variant_iter_free(ac_iter); + + ERR("calloc() Fail(%d)", errno); + return; + } + } + + j = 0; + while (g_variant_iter_loop(attr_iter, "q", &attr_data) + && g_variant_iter_loop(type_iter, "y", &t_value) + && g_variant_iter_loop(ac_iter, "y", &ac_value)) { + DBG("attrData 0x%04X", attr_data); + DBG("t_value 0x%02X", t_value); + DBG("ac_value 0x%02X", ac_value); + records[j]->id = attr_data; + records[j]->type = t_value; + records[j]->acl = ac_value; + j++; + } + if (NULL != attr_iter) + g_variant_iter_free(attr_iter); + if (NULL != type_iter) + g_variant_iter_free(type_iter); + if (NULL != ac_iter) + g_variant_iter_free(ac_iter); + + cb(addr16, ep, cluster_id, discoveryComplete, records, rec_len, container->userdata); + + for (j = 0; j < rec_len; j++) + free(records[j]); + free(records); + } + break; + case ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ: { + zb_zcl_global_rsp cb = container->cb; + nwk_addr addr16; + unsigned char ep; + unsigned short cluster_id; + + int i = 0; + int j = 0; + char value; + unsigned char *status = NULL; + unsigned char *data_size = NULL; + unsigned char *change = NULL; + unsigned short record_length; + GVariantIter *resp_iter = NULL; + GVariantIter *data_iter = NULL; + + report_config_record_h *records = NULL; + zb_global_record_data_s *data = NULL; + + g_variant_get(parameters, "(qyqqa(yyqyqqayq))", + &addr16, &ep, &cluster_id, &record_length, &resp_iter); + + records = calloc(record_length, sizeof(report_config_record_h)); + for (i = 0; i < record_length; i++) { + records[i] = calloc(1, sizeof(struct reporting_configuration_record_s)); + if (NULL == records[i]) { + ERR("calloc() Fail(%d)", errno); + goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT; + } + } + data = calloc(1, sizeof(zb_global_record_data_s)); + if (!data || !records) { + ERR("calloc() Fail(%d)", errno); + goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT; + } + + DBG("record_length %d", record_length); + status = calloc(record_length, sizeof(unsigned char)); + data_size = calloc(record_length, sizeof(unsigned char)); + if (!status || !data_size) { + ERR("Couldn't allocate the memory (%s)", errno); + goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT; + } + + for (i = 0; i < record_length; i++) { + g_variant_iter_loop(resp_iter, "(yyqyqqayq)", &status[i], &records[i]->dir, + &records[i]->id, &records[i]->type, &records[i]->max_i, &records[i]->min_i, + &data_iter, &records[i]->to); + if (records[i]->dir != ZCL_REPORTING_DIRECTION_REPORTED && + (zb_get_analog_or_discret(records[i]->type) == DATA_TYPE_ANALOG)) { + data_size[i] = zb_get_data_size(records[j]->type); + j = 0; + if (data_size[i] != 0xff) { + change = calloc(data_size[i]+1, sizeof(unsigned char)); + if (!change) { + ERR("calloc() Fail(%d)", errno); + records[i]->change = NULL; + if (NULL != data_iter) + g_variant_iter_free(data_iter); + continue; + } + while (g_variant_iter_loop(data_iter, "y", &value)) { + change[j] = value; + j++; + } + if (NULL != data_iter) + g_variant_iter_free(data_iter); + records[i]->change = change; + } else + records[i]->change = NULL; + } else + records[i]->change = NULL; + } + if (NULL != resp_iter) + g_variant_iter_free(resp_iter); + + data->type = ZB_GLOBAL_READ_REPORT_CONFIG; + data->record.report_config = records; + data->records_len = record_length; + + cb(addr16, ep, cluster_id, data, record_length, container->userdata); + +GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT: + free(data_size); + free(status); + for (i = 0; i < record_length; i++) + free(records[i]); + free(records); + free(data); + } + break; + /* ZCL Alarm */ + case ZBL_ZCL_ALARM_GET_ALARM_REQ: { + zb_zcl_alarm_get_alarm_rsp cb = container->cb; + + nwk_addr addr16 = 0; + unsigned char ep = 0; + unsigned char status = 0; + unsigned char alarm_code = 0; + unsigned short cluster_id = 0; + unsigned int time_stamp = 0; + + g_variant_get(parameters, "(qyyyqu)", &addr16, &ep, &status, &alarm_code, + &cluster_id, &time_stamp); + cb(addr16, ep, status, alarm_code, cluster_id, time_stamp, container->userdata); + } + break; + /* ZCL Doorlock */ + case ZBL_ZCL_DOORLOCK_LOCK_STATE: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + /* ZCL Fanmode */ + case ZBL_ZCL_FANMODE_FAN_MODE_STATE: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + /* ZCL Group */ + case ZBL_ZCL_GROUP_ADD_GROUP_REQ: { + zb_zcl_group_add_group_rsp cb = container->cb; + + nwk_addr addr16; + unsigned char ep; + unsigned char status; + unsigned short group_id; + + g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id); + cb(addr16, ep, status, group_id, container->userdata); + } + break; + case ZBL_ZCL_GROUP_VIEW_GROUP_REQ: { + zb_zcl_group_view_group_rsp cb = container->cb; + + int j = 0; + nwk_addr addr16; + unsigned char ep; + unsigned char value; + unsigned char status; + unsigned short group_id; + char *group_name = NULL; + GVariantIter *grpNameiter = NULL; + + g_variant_get(parameters, "(qyyqay)", &addr16, &ep, &status, &group_id, &grpNameiter); + g_variant_iter_loop(grpNameiter, "y", &value); + /* first byte indicates the length of the string */ + if ((value - '0') > 0) { + DBG("Value %d ", (value - '0')); + group_name = calloc((value - '0') + 1, sizeof(char)); + if (NULL == group_name) { + if (NULL != grpNameiter) + g_variant_iter_free(grpNameiter); + ERR("calloc() Fail(%d)", errno); + goto GROUP_VIEW_GROUP_REQ_OUT; + } + group_name[j] = value; + j++; + while (g_variant_iter_loop(grpNameiter, "y", &value) && (j <= (value - '0'))) { + group_name[j] = value; + DBG("Name %c", group_name[j]); + j++; + } + if (NULL != grpNameiter) + g_variant_iter_free(grpNameiter); + } else { + group_name = calloc(1, sizeof(char)); + if (NULL == group_name) { + if (NULL != grpNameiter) + g_variant_iter_free(grpNameiter); + ERR("calloc() Fail(%d)", errno); + goto GROUP_VIEW_GROUP_REQ_OUT; + } + group_name[j] = value; + j++; + group_name[j] = '\0'; + j++; + } + + DBG("GroupName = %s", group_name); + cb(addr16, ep, status, group_id, group_name, container->userdata); +GROUP_VIEW_GROUP_REQ_OUT: + free(group_name); + } + break; + case ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ: { + zb_zcl_group_get_group_membership_rsp cb = container->cb; + + int j = 0; + nwk_addr addr16; + unsigned char ep; + unsigned short gl_value; + unsigned char capacity; + unsigned char group_count; + unsigned short *grouplist = NULL; + GVariantIter *grpListiter = NULL; + + g_variant_get(parameters, "(qyyyaq)", &addr16, &ep, &capacity, &group_count, &grpListiter); + + if (group_count > 0) { + grouplist = calloc(group_count+1, sizeof(unsigned short)); + if (NULL == grouplist) { + if (NULL != grpListiter) + g_variant_iter_free(grpListiter); + ERR("calloc() Fail(%d)", errno); + return; + } + RETM_IF(NULL == grouplist, "calloc() Fail(%d)", errno); + + while (g_variant_iter_loop(grpListiter, "q", &gl_value)) { + grouplist[j] = gl_value; + j++; + } + if (NULL != grpListiter) + g_variant_iter_free(grpListiter); + } + + cb(addr16, ep, capacity, group_count, grouplist, container->userdata); + + free(grouplist); + } + break; + case ZBL_ZCL_GROUP_REMOVE_GROUP_REQ: { + zb_zcl_group_remove_group_rsp cb = container->cb; + + nwk_addr addr16; + unsigned char ep; + unsigned char status; + unsigned short group_id; + + g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id); + + cb(addr16, ep, status, group_id, container->userdata); + } + break; + /* ZCL Identify */ + case ZBL_ZCL_IDENTIFY_QUERY_REQ: { + zb_zcl_identify_query_cb cb = container->cb; + + nwk_addr addr16 = 0; + unsigned short identify_time = 0; + g_variant_get(parameters, "(qq)", &addr16, &identify_time); + + cb(addr16, identify_time, container->userdata); + } + break; + /* ZCL On/Off */ + case ZBL_ZCL_ON_OFF_GET_ON_OFF_STATE: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + /* ZCL Pollcontrol */ + case ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ: { + zb_zcl_pollctrl_check_in cb = container->cb; + + nwk_addr addr16 = 0; + unsigned char ep = 0; + + g_variant_get(parameters, "(qy)", &addr16, &ep); + cb(addr16, ep, container->userdata); + } + break; + /* ZCL Scene */ + case ZBL_ZCL_SCENE_ADD_SCENE_REQ: { + zb_zcl_scene_add_scene_rsp cb = container->cb; + + nwk_addr addr16 = 0; + unsigned char ep; + unsigned char status; + unsigned short group_id; + unsigned char scene_id; + + g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status, &group_id, &scene_id); + cb(addr16, ep, status, group_id, scene_id, container->userdata); + } + break; + case ZBL_ZCL_SCENE_VIEW_SCENE_REQ: { + zb_zcl_scene_view_scene_rsp cb = container->cb; + + int j = 0; + int len; + nwk_addr addr16 = 0; + unsigned char ep; + unsigned char status; + unsigned short group_id; + unsigned char scene_id; + unsigned short transition_time = 0; + unsigned char value; + unsigned short ext_len = 0; + char *scene_name = NULL; + char *extendedFieldSets = NULL; + GVariantIter *sceneNameIter = NULL; + GVariantIter *extendedSetIter = NULL; + + g_variant_get(parameters, "(qyyqyqayyay)", &addr16, &ep, &status, &group_id, &scene_id, + &transition_time, &sceneNameIter, &ext_len, &extendedSetIter); + + g_variant_iter_loop(sceneNameIter, "y", &value); + + /** first byte indicates the length of the string */ + len = value -'0'; + if (0 < len) { + scene_name = calloc(len + 1, sizeof(char)); + if (NULL == scene_name) { + ERR("calloc() Fail(%d)", errno); + goto SCENE_VIEW_SCENE_REQ_OUT; + } + scene_name[j] = value; + j++; + while (g_variant_iter_loop(sceneNameIter, "y", &value)) { + scene_name[j] = value; + j++; + } + } else { + scene_name = calloc(1 + 1, sizeof(char)); + if (NULL == scene_name) { + ERR("calloc() Fail(%d)", errno); + goto SCENE_VIEW_SCENE_REQ_OUT; + } + scene_name[j] = value; + } + + j = 0; + if (0 < ext_len) { + extendedFieldSets = calloc(ext_len + 1, sizeof(char)); + if (NULL == extendedFieldSets) { + ERR("calloc() Fail(%d)", errno); + goto SCENE_VIEW_SCENE_REQ_OUT; + } + while (g_variant_iter_loop(extendedSetIter, "y", &value)) { + extendedFieldSets[j] = value; + j++; + } + } + + cb(addr16, ep, status, group_id, scene_id, transition_time, scene_name, + extendedFieldSets, ext_len, container->userdata); + +SCENE_VIEW_SCENE_REQ_OUT: + free(scene_name); + free(extendedFieldSets); + } + break; + case ZBL_ZCL_SCENE_REMOVE_SCENE_REQ: { + zb_zcl_scene_remove_scene_rsp cb = container->cb; + + nwk_addr addr16 = 0; + unsigned char ep; + unsigned char status; + unsigned short group_id; + unsigned char scene_id; + + g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status, &group_id, &scene_id); + cb(addr16, ep, status, group_id, scene_id, container->userdata); + } + break; + case ZBL_ZCL_SCENE_STORE_SCENE_REQ: { + zb_zcl_scene_store_scene_rsp cb = container->cb; + + nwk_addr addr16 = 0; + unsigned char ep; + unsigned char status; + unsigned short group_id; + unsigned char scene_id; + + g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status, &group_id, &scene_id); + cb(addr16, ep, status, group_id, scene_id, container->userdata); + } + break; + case ZBL_ZCL_SCENE_REMOVE_ALL_SCENE_REQ: { + zb_zcl_scene_remove_all_scene_rsp cb = container->cb; + + nwk_addr addr16 = 0; + unsigned char ep; + unsigned char status; + unsigned short group_id; + + g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id); + cb(addr16, ep, status, group_id, container->userdata); + } + break; + case ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ: { + zb_zcl_scene_get_scene_membership_rsp cb = container->cb; + + int j = 0; + nwk_addr addr16 = 0; + unsigned char ep; + unsigned char status; + unsigned short group_id; + unsigned char capacity; + unsigned char value; + unsigned char scene_count = 0; + unsigned char *scene_list = NULL; + GVariantIter *sceneListIter = NULL; + + g_variant_get(parameters, "(qyyyqyay)", &addr16, &ep, &status, &capacity, &group_id, + &scene_count, &sceneListIter); + + if (0 < scene_count) { + scene_list = calloc(scene_count+1, sizeof(char)); + if (NULL == scene_list) { + ERR("calloc() Fail(%d)", errno); + goto SCENE_GET_SCENE_MEMBERSHIP_REQ_OUT; + } + while (g_variant_iter_loop(sceneListIter, "y", &value)) { + scene_list[j] = value; + DBG("Scene_List 0x%02X", scene_list[j]); + j++; + } + } + + cb(addr16, ep, status, capacity, group_id, scene_count, scene_list, container->userdata); +SCENE_GET_SCENE_MEMBERSHIP_REQ_OUT: + free(scene_list); + } + break; + /* ZCL Thermostat */ + case ZBL_ZCL_THERMOSTAT_GET_LOCAL_TEMP: { + zb_form_network_cb cb = container->cb; + cb(0x0000, container->userdata); + } + break; + default: + ERR("Unhandled cid = %d", container->cid); + } +} + + +int zbl_enable(zigbee_h handle, zb_event_cb event_handler) +{ + char enabled; + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); + RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); + RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER); + + handle->event_handler = event_handler; + + variant = g_dbus_proxy_call_sync(service_gproxy, "enable", NULL, + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(ib)", &result, &enabled); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get enable [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } + + return result; +} + +int zbl_disable(void) +{ + GVariant *variant = NULL; + GError *dbus_err = NULL; + int result = ZIGBEE_ERROR_NONE; + + DBG("zbl_disable()"); + + if (0 >= zbl_ref_count) { + WARN("dbus does not initiaized\n"); + return ZIGBEE_ERROR_NO_DATA; + } + + if (0 > --zbl_ref_count) { + DBG("all connections closed\n"); + return ZIGBEE_ERROR_NONE; + } + + if (gdbus_conn) { + + if (service_gproxy) { + variant = g_dbus_proxy_call_sync(service_gproxy, "disable", NULL, + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get disable [%s]", dbus_err->message); + g_error_free(dbus_err); + } + + g_object_unref(service_gproxy); + service_gproxy = NULL; + g_object_unref(on_off_gproxy); + on_off_gproxy = NULL; + g_object_unref(door_lock_gproxy); + door_lock_gproxy = NULL; + g_object_unref(level_control_gproxy); + level_control_gproxy = NULL; + g_object_unref(thermostat_gproxy); + thermostat_gproxy = NULL; + g_object_unref(alarm_gproxy); + alarm_gproxy = NULL; + g_object_unref(fan_control_gproxy); + fan_control_gproxy = NULL; + + g_object_unref(mfglib_gproxy); + mfglib_gproxy = NULL; + g_object_unref(zcl_global_proxy); + zcl_global_proxy = NULL; + g_object_unref(zcl_color_control_proxy); + zcl_color_control_proxy = NULL; + g_object_unref(custom_gproxy); + custom_gproxy = NULL; + } + + g_object_unref(gdbus_conn); + gdbus_conn = NULL; } return ZIGBEE_ERROR_NONE; @@ -1137,12 +2985,25 @@ int zbl_disable(void) int zbl_hw_reset(void) { - DBG("zbl_hw_reset()"); + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(service_gproxy, "zb_hw_reset", NULL, - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + variant = g_dbus_proxy_call_sync(service_gproxy, "zb_hw_reset", NULL, + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get zb_hw_reset [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } + return ZIGBEE_ERROR_NONE; } @@ -1150,8 +3011,9 @@ int zbl_get_network_info(ieee_addr addr64, nwk_addr *nodeid, nwk_addr *panid, unsigned char *channel, unsigned char *tx_power) { GVariant *variant = NULL; - GVariantIter *mac_iter = NULL; + GVariant *eui64 = NULL; GError *dbus_err = NULL; + int result = ZIGBEE_ERROR_NONE; nwk_addr _nodeid; nwk_addr _panid; @@ -1164,23 +3026,23 @@ int zbl_get_network_info(ieee_addr addr64, nwk_addr *nodeid, nwk_addr *panid, RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); - variant = g_dbus_proxy_call_sync(service_gproxy, "network_info", + variant = g_dbus_proxy_call_sync(service_gproxy, "get_network_info", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); if (variant) { - g_variant_get(variant, "(ayqqyy)", &mac_iter, + g_variant_get(variant, "(ia(y)qqyy)", &result, &eui64, &_nodeid, &_panid, &_radio_channel, &_radio_tx_power); /* Get EUI */ i = 0; - while (g_variant_iter_loop(mac_iter, "y", &value)) { + while (g_variant_iter_loop(eui64, "(y)", &value)) { addr64[i] = value; i++; } - DBG(" EUI : %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", - addr64[0], addr64[1], addr64[2], - addr64[3], addr64[4], addr64[5], - addr64[6], addr64[7]); + DBG(" Result: [%X]", result); + DBG(" EUI(%d) : %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", i, + addr64[0], addr64[1], addr64[2], addr64[3], + addr64[4], addr64[5], addr64[6], addr64[7]); DBG(" nodeID [0x%04X]", _nodeid); DBG(" PanID [0x%04X]", _panid); DBG(" Channel [%d] Tx Power [%d]", _radio_channel, _radio_tx_power); @@ -1194,29 +3056,34 @@ int zbl_get_network_info(ieee_addr addr64, nwk_addr *nodeid, nwk_addr *panid, if (tx_power) *tx_power = _radio_tx_power; + if (eui64) + g_variant_iter_free(eui64); g_variant_unref(variant); } else { - ERR("Failed to get network_info [%s]", dbus_err->message); + ERR("Failed to get_network_info [%s]", dbus_err->message); g_error_free(dbus_err); return ZIGBEE_ERROR_IO_ERROR; } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_get_controller_mac_address(ieee_addr addr64) { GVariant *variant = NULL; GVariantIter *iter = NULL; + GError *dbus_err = NULL; + char value; int j = 0; + int result = ZIGBEE_ERROR_NONE; DBG("zbl_get_controller_mac_address()"); RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); variant = g_dbus_proxy_call_sync(service_gproxy, "get_mac", - NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL); + NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); if (variant) { g_variant_get(variant, "(ay)", &iter); @@ -1224,10 +3091,18 @@ int zbl_get_controller_mac_address(ieee_addr addr64) addr64[j] = value; j++; } - DBG("IEEE ADDR 0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X", + DBG("IEEE ADDR 0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X, Ret=%d ", addr64[0], addr64[1], addr64[2], addr64[3], addr64[4], addr64[5], - addr64[6], addr64[7]); - return ZIGBEE_ERROR_NONE; + addr64[6], addr64[7], result); + + if (iter) + g_variant_iter_free(iter); + g_variant_unref(variant); + return result; + } + else { + ERR("Failed to get_mac [%s]", dbus_err->message); + g_error_free(dbus_err); } return ZIGBEE_ERROR_IO_ERROR; } @@ -1239,6 +3114,7 @@ int zbl_get_cluster_list(ieee_addr eui64, unsigned char endpoint, unsigned short GVariantBuilder *mac_builder = NULL; GVariant *mac_variant = NULL; GVariantIter *iter = NULL; + GError *dbus_err = NULL; unsigned short cluster; int i = 0; @@ -1255,10 +3131,11 @@ int zbl_get_cluster_list(ieee_addr eui64, unsigned char endpoint, unsigned short g_variant_builder_add(mac_builder, "y", eui64[1]); g_variant_builder_add(mac_builder, "y", eui64[0]); mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); variant = g_dbus_proxy_call_sync(service_gproxy, "cluster_list", g_variant_new("(@ayy)", mac_variant, endpoint), G_DBUS_CALL_FLAGS_NONE, - -1, NULL, NULL); + -1, NULL, &dbus_err); if (variant) { g_variant_get(variant, "(aq)", &iter); @@ -1270,10 +3147,12 @@ int zbl_get_cluster_list(ieee_addr eui64, unsigned char endpoint, unsigned short if (0 == i) ERR("No Clusters for Endpoint %0X", endpoint); - g_variant_iter_free(iter); + if (NULL != iter) + g_variant_iter_free(iter); g_variant_unref(variant); } else { - ERR("No Clusters for Endpoint %0X", endpoint); + ERR("No Clusters for Endpoint %0X [%s]", endpoint, dbus_err->message); + g_error_free(dbus_err); *count = 0; } @@ -1286,6 +3165,7 @@ int zbl_get_endpoint_list(ieee_addr eui64, unsigned char list[], unsigned char * GVariantBuilder *mac_builder = NULL; GVariant *mac_variant = NULL; GVariantIter *iter = NULL; + GError *dbus_err = NULL; unsigned char endpoint; int i = 0; @@ -1302,9 +3182,10 @@ int zbl_get_endpoint_list(ieee_addr eui64, unsigned char list[], unsigned char * g_variant_builder_add(mac_builder, "y", eui64[1]); g_variant_builder_add(mac_builder, "y", eui64[0]); mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); variant = g_dbus_proxy_call_sync(service_gproxy, "endpoint_list", - g_variant_new("(@ay)", mac_variant), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL); + g_variant_new("(@ay)", mac_variant), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); if (variant) { g_variant_get(variant, "(ay)", &iter); @@ -1319,23 +3200,27 @@ int zbl_get_endpoint_list(ieee_addr eui64, unsigned char list[], unsigned char * ERR("No Endpoints"); *count = 0; } - g_variant_iter_free(iter); + if (NULL != iter) + g_variant_iter_free(iter); g_variant_unref(variant); } else { ERR("NULL Variant"); ERR("No Endpoints"); + ERR("[%s]", dbus_err->message); + g_error_free(dbus_err); *count = 0; } return ZIGBEE_ERROR_NONE; } -int zb_api_get_node_type(ieee_addr eui64, unsigned char *node_type) +int zbl_api_get_node_type(ieee_addr eui64, unsigned char *node_type) { GVariant *variant = NULL; GVariantBuilder *mac_builder = NULL; GVariant *mac_variant = NULL; + GError *dbus_err = NULL; unsigned char n_type = 0; RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); @@ -1351,18 +3236,21 @@ int zb_api_get_node_type(ieee_addr eui64, unsigned char *node_type) g_variant_builder_add(mac_builder, "y", eui64[1]); g_variant_builder_add(mac_builder, "y", eui64[0]); mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); - variant = g_dbus_proxy_call_sync(service_gproxy, "node_type", - g_variant_new("(@ay)", mac_variant), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL); + variant = g_dbus_proxy_call_sync(service_gproxy, "node_type", g_variant_new("(@ay)", + mac_variant), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); if (variant) { g_variant_get(variant, "(y)", &n_type); *node_type = n_type; DBG("Node Type 0x%x", n_type); - + g_variant_unref(variant); } else { - ERR("NULL Variant"); + ERR("NULL Variant [%s]", dbus_err->message); + g_error_free(dbus_err); *node_type = 0; + return ZIGBEE_ERROR_IO_ERROR; } return ZIGBEE_ERROR_NONE; @@ -1378,6 +3266,7 @@ int zbl_get_all_device_info(zb_end_device_info_h **dev_list, unsigned char* num) GVariantIter *iter = NULL; GVariantIter *mac_iter = NULL; GVariantIter *endpoint_iter = NULL; + GError *dbus_err = NULL; unsigned short node_id; unsigned char node_type; unsigned char node_mac_address[8] = {0x00}; @@ -1390,7 +3279,7 @@ int zbl_get_all_device_info(zb_end_device_info_h **dev_list, unsigned char* num) /* check the format string when there are no input args */ variant = g_dbus_proxy_call_sync(service_gproxy, "device_info", - NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL); + NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); if (variant) { g_variant_get(variant, "(a(qyayyay))", &iter); @@ -1403,6 +3292,7 @@ int zbl_get_all_device_info(zb_end_device_info_h **dev_list, unsigned char* num) for (j = 0; j < i; j++) free(list[j]); free(list); + g_variant_unref(variant); return ZIGBEE_ERROR_OUT_OF_MEMORY; } } @@ -1446,13 +3336,14 @@ int zbl_get_all_device_info(zb_end_device_info_h **dev_list, unsigned char* num) *num = i; *dev_list = list; - g_variant_iter_free(iter); + if (NULL != iter) + g_variant_iter_free(iter); g_variant_unref(variant); } else { - ERR("NULL Variant"); + ERR("NULL Variant [%s]", dbus_err->message); ERR("No attached nodes"); + g_error_free(dbus_err); *num = 0; - } return ZIGBEE_ERROR_NONE; @@ -1460,51 +3351,54 @@ int zbl_get_all_device_info(zb_end_device_info_h **dev_list, unsigned char* num) int zbl_coex_start(unsigned char channel) { - DBG("zbl_coex_start()"); + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(service_gproxy, "coex_start", g_variant_new("(y)", channel), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + variant = g_dbus_proxy_call_sync(service_gproxy, "coex_start", g_variant_new("(y)", channel), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get coex_start [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } return ZIGBEE_ERROR_NONE; } int zbl_coex_stop(void) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + DBG("zbl_coex_stop()"); + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(service_gproxy, "coex_stop", NULL, G_DBUS_CALL_FLAGS_NONE, - -1, NULL, NULL, NULL); + variant = g_dbus_proxy_call_sync(service_gproxy, "coex_stop", NULL, + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get coex_stop [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } return ZIGBEE_ERROR_NONE; } -static void _zbl_form_network_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_form_network_cb cb = container->cb; - - nwk_addr panid; - - container->found = true; - - DBG("_zbl_form_network_cb()"); - - g_variant_get(parameters, "(q)", &panid); - - if (cb) - cb(panid, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - - int zbl_form_network(zigbee_h handle, zb_form_network_cb cb, void *user_data) { int sub_id, to; @@ -1513,15 +3407,13 @@ int zbl_form_network(zigbee_h handle, zb_form_network_cb cb, void *user_data) RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); - DBG("%s:%s", __func__, __LINE__); - container = calloc(1, sizeof(zbl_req_cb_s)); RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno); to = zbl_dbus_get_timeout(service_gproxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_SERVICE_INTERFACE, "form_network_done", ZIGBEE_SERVICE_OBJECT_PATH, NULL, 0, - _zbl_form_network_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -1531,7 +3423,8 @@ int zbl_form_network(zigbee_h handle, zb_form_network_cb cb, void *user_data) container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_enable, container); + container->cid = ZBL_SERVICE_FORM_NETWORK; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(service_gproxy, "form_network", NULL, G_DBUS_CALL_FLAGS_NONE, to, @@ -1540,29 +3433,6 @@ int zbl_form_network(zigbee_h handle, zb_form_network_cb cb, void *user_data) return ZIGBEE_ERROR_NONE; } -static void _zbl_disable_network_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_form_network_cb cb = container->cb; - - unsigned char ret = ZB_ZDP_SUCCESS; - - container->found = true; - - DBG("_zbl_disable_network_cb()"); - - g_variant_get(parameters, "(y)", &ret); - - if (cb) - cb(ret, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - - int zbl_disable_network(zigbee_h handle, zb_disable_network_cb cb, void *user_data) { int sub_id, to; @@ -1578,8 +3448,8 @@ int zbl_disable_network(zigbee_h handle, zb_disable_network_cb cb, void *user_da to = zbl_dbus_get_timeout(service_gproxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, - ZIGBEE_SERVICE_INTERFACE, "leave_network_done", ZIGBEE_SERVICE_OBJECT_PATH, NULL, 0, - _zbl_disable_network_cb, container, _zbl_request_cleanup); + ZIGBEE_SERVICE_INTERFACE, "disable_network_done", ZIGBEE_SERVICE_OBJECT_PATH, NULL, 0, + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -1589,7 +3459,8 @@ int zbl_disable_network(zigbee_h handle, zb_disable_network_cb cb, void *user_da container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_enable, container); + container->cid = ZBL_SERVICE_DISABLE_NETWORK; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(service_gproxy, "leave_network", NULL, G_DBUS_CALL_FLAGS_NONE, to, @@ -1600,6 +3471,10 @@ int zbl_disable_network(zigbee_h handle, zb_disable_network_cb cb, void *user_da int zbl_leave_device(ieee_addr addr64, bool remove_children, bool rejoin) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + GVariantBuilder *mac_builder = NULL; GVariant* mac_variant = NULL; unsigned char _remove_children = (remove_children) ? 1 : 0; @@ -1618,81 +3493,46 @@ int zbl_leave_device(ieee_addr addr64, bool remove_children, bool rejoin) g_variant_builder_add(mac_builder, "y", addr64[1]); g_variant_builder_add(mac_builder, "y", addr64[0]); mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); - g_dbus_proxy_call(service_gproxy, "leave_req", + variant = g_dbus_proxy_call_sync(service_gproxy, "leave_request", g_variant_new("(@ayyy)", mac_variant, _remove_children, _rejoin), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); - - return ZIGBEE_ERROR_NONE; -} - -int zbl_permit_join(unsigned char duration, bool broadcast) -{ - RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); - RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); - - g_dbus_proxy_call(service_gproxy, "permit_join", - g_variant_new("(ib)", duration, broadcast), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_addr_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_addr_rsp cb = NULL; - - DBG(" _zbl_timeout_addr_req()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, NULL, 0, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get leave_request [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return G_SOURCE_REMOVE; + return result; } -static void _zbl_addr_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) +int zbl_permit_join(unsigned char duration, bool broadcast) { - zbl_req_cb_s *container = user_data; - zb_zdo_addr_rsp cb = container->cb; - - int j = 0; - nwk_addr addr16; - ieee_addr addr64; - unsigned char status; - unsigned char num; - unsigned char start_idx; - unsigned char value; - GVariantIter *mac_iter; - - container->found = true; + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; - DBG("_zbl_addr_req_cb"); + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); + RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_variant_get(parameters, "(yayqyy)", &status, &mac_iter, &addr16, &num, &start_idx); - while (g_variant_iter_loop(mac_iter, "y", &value)) { - addr64[j] = value; - j++; + variant = g_dbus_proxy_call_sync(service_gproxy, "permit_join", + g_variant_new("(ib)", duration, broadcast), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get permit_join [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; } - if (cb) - cb(status, addr64, addr16, num, start_idx, NULL, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return result; } int zbl_nwk_addr_req(zigbee_h handle, ieee_addr addr64, unsigned char request_type, @@ -1714,7 +3554,7 @@ int zbl_nwk_addr_req(zigbee_h handle, ieee_addr addr64, unsigned char request_ty to = zbl_dbus_get_timeout(zdo_dev_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "nwk_addr_rsp", - ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_addr_req_cb, container, + ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -1725,7 +3565,8 @@ int zbl_nwk_addr_req(zigbee_h handle, ieee_addr addr64, unsigned char request_ty container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_addr_req, container); + container->cid = ZBL_ZDO_NWK_ADDR_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; mac_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -1738,6 +3579,7 @@ int zbl_nwk_addr_req(zigbee_h handle, ieee_addr addr64, unsigned char request_ty g_variant_builder_add(mac_builder, "y", addr64[1]); g_variant_builder_add(mac_builder, "y", addr64[0]); mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); g_dbus_proxy_call(zdo_dev_proxy, "nwk_addr_req", g_variant_new("(@ayyy)", mac_variant, request_type, start_idx), @@ -1764,7 +3606,7 @@ int zbl_ieee_addr_req(zigbee_h handle, nwk_addr addr16, zb_zdo_addr_rsp cb, sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "nwk_addr_rsp", ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_addr_req_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -1774,73 +3616,16 @@ int zbl_ieee_addr_req(zigbee_h handle, nwk_addr addr16, zb_zdo_addr_rsp cb, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_addr_req, container); + container->cid = ZBL_ZDO_NWK_ADDR_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; - g_dbus_proxy_call(zdo_dev_proxy, "ieee_addr_req", g_variant_new("(q)", addr16), + g_dbus_proxy_call(zdo_dev_proxy, "ieee_addr_req", g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_active_ep_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_active_ep_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_active_ep_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_active_ep_rsp cb = container->cb; - - int j = 0; - nwk_addr addr16; - unsigned char status; - unsigned char count; - unsigned char value; - GVariantIter *ep_iter; - unsigned char *ep_list; - - DBG("_zbl_active_ep_cb"); - - g_variant_get(parameters, "(qyayy)", &addr16, &status, &ep_iter, &count); - ep_list = calloc(count+1, sizeof(unsigned char)); - RETM_IF(NULL == ep_list, "calloc() Fail(%d)", errno); - - container->found = true; - - while (g_variant_iter_loop(ep_iter, "y", &value)) { - ep_list[j] = value; - j++; - } - - if (cb) - cb(status, addr16, count, ep_list, container->userdata); - - free(ep_list); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_active_ep(zigbee_h handle, nwk_addr addr16, zb_zdo_active_ep_rsp cb, void *user_data) { @@ -1859,7 +3644,7 @@ int zbl_active_ep(zigbee_h handle, nwk_addr addr16, zb_zdo_active_ep_rsp cb, sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "active_ep_rsp", ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_active_ep_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -1869,106 +3654,16 @@ int zbl_active_ep(zigbee_h handle, nwk_addr addr16, zb_zdo_active_ep_rsp cb, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_active_ep_req, container); + container->cid = ZBL_ZDO_ACTIVE_EP_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; - g_dbus_proxy_call(zdo_dev_proxy, "active_ep_req", g_variant_new("(q)", addr16), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); + g_dbus_proxy_call(zdo_dev_proxy, "active_ep_req", + g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_simple_desc_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_simple_desc_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_simple_desc_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zbl_simple_desc_req_cb()"); - zbl_req_cb_s *container = user_data; - zb_zdo_simple_desc_rsp cb = container->cb; - - int j = 0; - int count; - unsigned short addr16; - unsigned short value; - GVariantIter *in_iter; - GVariantIter *out_iter; - zb_zdo_simple_desc_h records; - - records = calloc(1, sizeof(struct zb_zdo_simple_desc_s)); - RETM_IF(NULL == records, "calloc() Fail(%d)", errno); - - container->found = true; - - g_variant_get(parameters, "(qiyyqqyyaqaq)", &addr16, &count, &records->device_ver, - &records->ep, &records->profile_id, &records->device_id, - &records->num_of_in_clusters, &records->num_of_out_clusters, &in_iter, - &out_iter); -#if 0 - records->in_clusters = calloc(sizeof(unsigned short), records->num_of_in_clusters); - if (NULL == records->in_clusters) { - ERR("calloc() Fail(%d)", errno); - free(records); - return; - } - records->out_clusters = calloc(sizeof(unsigned short), records->num_of_out_clusters); - if (NULL == records->out_clusters) { - ERR("calloc() Fail(%d)", errno); - free(records->in_clusters); - free(records); - return; - } -#endif - while (g_variant_iter_loop(in_iter, "q", &value)) { - records->in_clusters[j] = value; - j++; - } - - j = 0; - while (g_variant_iter_loop(out_iter, "q", &value)) { - records->out_clusters[j] = value; - j++; - } - - if (cb) { - cb(addr16, count, records, container->userdata); - DBG("addr16=0x%x, count=%d, records->ep=%d, records->device_id=0x%x", - addr16, count, records->ep, records->device_id); - for (j = 0; j < records->num_of_in_clusters; j++) - DBG("in_clusters[%d] = 0x%x", j, records->in_clusters[j]); - for (j = 0; j < records->num_of_out_clusters; j++) - DBG("out_clusters[%d] = 0x%x", j, records->out_clusters[j]); - } -#if 0 - free(records->in_clusters); - free(records->out_clusters); -#endif - free(records); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_simple_desc_req(zigbee_h handle, nwk_addr addr16, unsigned char ep, zb_zdo_simple_desc_rsp cb, void *user_data) { @@ -1987,7 +3682,7 @@ int zbl_simple_desc_req(zigbee_h handle, nwk_addr addr16, unsigned char ep, sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "simple_desc_rsp", ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_simple_desc_req_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -1997,11 +3692,12 @@ int zbl_simple_desc_req(zigbee_h handle, nwk_addr addr16, unsigned char ep, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_simple_desc_req, container); + container->cid = ZBL_ZDO_SIMPLE_DESC_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; - g_dbus_proxy_call(zdo_dev_proxy, "simple_desc_req", g_variant_new("(qy)", addr16, ep), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); + g_dbus_proxy_call(zdo_dev_proxy, "simple_desc_req", + g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } @@ -2014,65 +3710,6 @@ int zbl_extended_simple_desc_req(zigbee_h handle, nwk_addr addr16, } #endif /* ZB_SUPPORT_PRIORITY_5 */ -static gboolean _zbl_timeout_match_desc_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_match_desc_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata); - - container->tid = 0; - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_match_desc_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_match_desc_rsp cb = container->cb; - - int j = 0; - int match_len; - nwk_addr addr16; - unsigned char value; - unsigned char status; - GVariantIter *ml_iter; - unsigned char *match_list = NULL; - g_variant_get(parameters, "(yqyay)", &status, &addr16, &match_len, &ml_iter); - - DBG("match_len = %d", match_len); - - if (match_len > 0) { - match_list = calloc(match_len+1, sizeof(unsigned char)); - RETM_IF(NULL == match_list, "calloc() Fail(%d)", errno); - while (g_variant_iter_loop(ml_iter, "y", &value)) { - match_list[j] = value; - DBG("match_list[i]=%d", j, match_list[j]); - j++; - } - } - - if (cb) - cb(status, addr16, match_len, &match_list, container->userdata); - - if (match_list) - free(match_list); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - - int zbl_match_desc_req(zigbee_h handle, nwk_addr addr16, unsigned short profile_id, unsigned char num_in_clusters, unsigned short *in_clusters, unsigned char num_out_clusters, @@ -2099,7 +3736,7 @@ int zbl_match_desc_req(zigbee_h handle, nwk_addr addr16, sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "matched_descriptor_rsp", ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_match_desc_req_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -2109,178 +3746,32 @@ int zbl_match_desc_req(zigbee_h handle, nwk_addr addr16, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_match_desc_req, container); + container->cid = ZBL_ZDO_MATCHED_DESCRIPTOR_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; incl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq")); - for (i = 0; i < num_in_clusters; i++) - g_variant_builder_add(incl_builder, "q", in_clusters[i]); - - outcl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq")); - for (i = 0; i < num_out_clusters; i++) - g_variant_builder_add(outcl_builder, "q", out_clusters[i]); - - incl_variant = g_variant_builder_end(incl_builder); - outcl_variant = g_variant_builder_end(outcl_builder); - - g_dbus_proxy_call(zdo_dev_proxy, "matched_descriptor_req", - g_variant_new("(qqy@aqy@aq)", addr16, profile_id, num_in_clusters, - incl_variant, num_out_clusters, outcl_variant), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_node_desc_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_node_desc_rsp cb = NULL; - - DBG("_zbl_timeout_node_desc_req()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_node_desc_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_node_desc_rsp cb = container->cb; - - nwk_addr addr16; - unsigned char status; - zb_zdo_node_descriptor_h desc; - - DBG("_zbl_node_desc_req_cb"); - - desc = calloc(1, sizeof(struct zb_zdo_node_descriptor_s)); - RETM_IF(NULL == desc, "calloc() Fail(%d)", errno); - - container->found = true; - - g_variant_get(parameters, "(yqyyyyyyqyqqqy)", &status, &addr16, - &desc->logical_type, &desc->complex_desciptor_available, - &desc->user_descriptor_available, &desc->aps_flags, &desc->frequency_band, - &desc->mac_capability_flags, &desc->manufacturer_code, &desc->maximum_buffer_size, - &desc->maximum_incoming_transfer_size, &desc->server_mask, - &desc->maximum_outgoing_transfer_size, &desc->descriptor_capability_field); - - if (cb) - cb(status, addr16, desc, container->userdata); - - free(desc); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - -int zbl_node_desc_req(nwk_addr addr16, zb_zdo_node_desc_rsp cb, void *user_data) -{ - int sub_id, to; - zbl_req_cb_s *container; - - RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); - RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR); - - DBG("zbl_node_desc_req()"); - - container = calloc(1, sizeof(zbl_req_cb_s)); - RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno); - - to = zbl_dbus_get_timeout(zdo_dev_proxy); - sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, - ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "node_desc_rsp", - ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_node_desc_req_cb, container, _zbl_request_cleanup); - - if (0 == sub_id) { - ERR("g_dbus_connection_signal_subscribe() Fail"); - free(container); - return ZIGBEE_ERROR_IO_ERROR; - } - - container->cb = cb; - container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_node_desc_req, container); - container->userdata = user_data; - - g_dbus_proxy_call(zdo_dev_proxy, "node_desc_req", g_variant_new("(q)", addr16), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_power_desc_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_node_desc_rsp cb = NULL; - - DBG("_zbl_timeout_power_desc_req()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_power_desc_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_power_desc_rsp cb = container->cb; - - nwk_addr addr16; - unsigned char status; - zb_zdo_node_power_descriptor_h desc; - - DBG("_zbl_power_desc_req_cb"); - - desc = calloc(1, sizeof(struct zb_zdo_node_power_descriptor_s)); - RETM_IF(NULL == desc, "calloc() Fail(%d)", errno); - - container->found = true; + for (i = 0; i < num_in_clusters; i++) + g_variant_builder_add(incl_builder, "q", in_clusters[i]); - g_variant_get(parameters, "(yqyyyy)", &status, &addr16, - &desc->current_power_mode, &desc->available_power_sources, - &desc->current_power_source, &desc->current_power_source_level); + outcl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq")); + for (i = 0; i < num_out_clusters; i++) + g_variant_builder_add(outcl_builder, "q", out_clusters[i]); - if (cb) - cb(status, addr16, desc, container->userdata); + incl_variant = g_variant_builder_end(incl_builder); + outcl_variant = g_variant_builder_end(outcl_builder); + g_variant_builder_unref(incl_builder); + g_variant_builder_unref(outcl_builder); - free(desc); + g_dbus_proxy_call(zdo_dev_proxy, "matched_descriptor_req", + g_variant_new("(qqy@aqy@aq)", addr16, profile_id, num_in_clusters, + incl_variant, num_out_clusters, outcl_variant), + G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return ZIGBEE_ERROR_NONE; } -int zbl_power_desc_req(nwk_addr addr16, zb_zdo_power_desc_rsp cb, void *user_data) +int zbl_node_desc_req(nwk_addr addr16, zb_zdo_node_desc_rsp cb, void *user_data) { int sub_id, to; zbl_req_cb_s *container; @@ -2288,14 +3779,16 @@ int zbl_power_desc_req(nwk_addr addr16, zb_zdo_power_desc_rsp cb, void *user_dat RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR); + DBG("zbl_node_desc_req()"); + container = calloc(1, sizeof(zbl_req_cb_s)); RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno); to = zbl_dbus_get_timeout(zdo_dev_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, - ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "power_desc_rsp", + ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "node_desc_rsp", ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_power_desc_req_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -2305,75 +3798,49 @@ int zbl_power_desc_req(nwk_addr addr16, zb_zdo_power_desc_rsp cb, void *user_dat container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_power_desc_req, container); + container->cid = ZBL_ZDO_NODE_DESC_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; - g_dbus_proxy_call(zdo_dev_proxy, "power_desc_req", g_variant_new("(q)", addr16), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); + g_dbus_proxy_call(zdo_dev_proxy, "node_desc_req", + g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_complex_desc_req(gpointer p) +int zbl_power_desc_req(nwk_addr addr16, zb_zdo_power_desc_rsp cb, void *user_data) { - zbl_req_cb_s *container = NULL; - zb_zdo_complex_desc_rsp cb = NULL; - - DBG("_zbl_timeout_complex_desc_req()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} + int sub_id, to; + zbl_req_cb_s *container; -static void _zbl_complex_desc_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_complex_desc_rsp cb = container->cb; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); + RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR); - int length; - nwk_addr addr16; - unsigned char j = 0; - unsigned char value; - unsigned char status; - GVariantIter *comp_iter = NULL; - unsigned char *complex_desc = NULL; + container = calloc(1, sizeof(zbl_req_cb_s)); + RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno); - DBG("_zbl_complex_desc_req_cb"); + to = zbl_dbus_get_timeout(zdo_dev_proxy); + sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, + ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "power_desc_rsp", + ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, + _zbl_response_cb, container, _zbl_request_cleanup); - g_variant_get(parameters, "(yqyay)", &status, &addr16, &length, &comp_iter); - if (length > 0) { - complex_desc = calloc(length, sizeof(char)); - RETM_IF(NULL == complex_desc, "calloc() Fail(%d)", errno); - while (g_variant_iter_loop(comp_iter, "y", &value)) { - complex_desc[j] = value; - j++; - } + if (0 == sub_id) { + ERR("g_dbus_connection_signal_subscribe() Fail"); + free(container); + return ZIGBEE_ERROR_IO_ERROR; } - container->found = true; - - if (cb) - cb(status, addr16, length, complex_desc, container->userdata); + container->cb = cb; + container->sid = sub_id; + container->cid = ZBL_ZDO_POWER_DESC_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); + container->userdata = user_data; - free(complex_desc); + g_dbus_proxy_call(zdo_dev_proxy, "power_desc_req", + g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return ZIGBEE_ERROR_NONE; } int zbl_complex_desc_req(nwk_addr addr16, zb_zdo_complex_desc_rsp cb, void *user_data) @@ -2391,7 +3858,7 @@ int zbl_complex_desc_req(nwk_addr addr16, zb_zdo_complex_desc_rsp cb, void *user sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "complex_desc_rsp", ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_complex_desc_req_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -2401,77 +3868,16 @@ int zbl_complex_desc_req(nwk_addr addr16, zb_zdo_complex_desc_rsp cb, void *user container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_complex_desc_req, container); + container->cid = ZBL_ZDO_COMPLEX_DESC_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; - g_dbus_proxy_call(zdo_dev_proxy, "complex_desc_req", g_variant_new("(q)", addr16), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); + g_dbus_proxy_call(zdo_dev_proxy, "complex_desc_req", + g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_user_desc_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_complex_desc_rsp cb = NULL; - - DBG("_zbl_timeout_user_desc_req()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_user_desc_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_user_desc_rsp cb = container->cb; - - int length; - nwk_addr addr16; - unsigned char j = 0; - unsigned char value; - unsigned char status; - GVariantIter *comp_iter = NULL; - unsigned char *complex_desc = NULL; - - DBG("_zbl_user_desc_req_cb"); - - g_variant_get(parameters, "(yqyay)", &status, &addr16, &length, &comp_iter); - if (length > 0) { - complex_desc = calloc(length, sizeof(char)); - RETM_IF(NULL == complex_desc, "calloc() Fail(%d)", errno); - while (g_variant_iter_loop(comp_iter, "y", &value)) { - complex_desc[j] = value; - j++; - } - } - - container->found = true; - - if (cb) - cb(status, addr16, length, complex_desc, container->userdata); - - free(complex_desc); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_user_desc_req(nwk_addr addr16, zb_zdo_user_desc_rsp cb, void *user_data) { int sub_id, to; @@ -2487,7 +3893,7 @@ int zbl_user_desc_req(nwk_addr addr16, zb_zdo_user_desc_rsp cb, void *user_data) sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "user_desc_rsp", ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_user_desc_req_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -2497,61 +3903,16 @@ int zbl_user_desc_req(nwk_addr addr16, zb_zdo_user_desc_rsp cb, void *user_data) container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_user_desc_req, container); + container->cid = ZBL_ZDO_USER_DESC_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; - g_dbus_proxy_call(zdo_dev_proxy, "user_desc_req", g_variant_new("(q)", addr16), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); + g_dbus_proxy_call(zdo_dev_proxy, "user_desc_req", + g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_user_desc_set(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_user_desc_conf cb = NULL; - - DBG("_zbl_timeout_user_desc_req()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_user_desc_set_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_user_desc_conf cb = container->cb; - - unsigned char status; - - container->found = true; - - DBG("_zbl_user_desc_set_cb"); - - g_variant_get(parameters, "(y)", &status); - - if (cb) - cb(status, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - #define MAX_USER_DESC_SIZE 0x10 #define USER_DESC_COMMAND_SIZE 20 @@ -2577,7 +3938,7 @@ int zbl_user_desc_set(zigbee_h handle, nwk_addr addr16, unsigned char len, sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "user_desc_confirm", ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_user_desc_set_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -2587,7 +3948,8 @@ int zbl_user_desc_set(zigbee_h handle, nwk_addr addr16, unsigned char len, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_user_desc_set, container); + container->cid = ZBL_ZDO_USER_DESC_SET_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; user_desc_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -2595,9 +3957,11 @@ int zbl_user_desc_set(zigbee_h handle, nwk_addr addr16, unsigned char len, g_variant_builder_add(user_desc_builder, "y", user_desc[j]); user_desc_variant = g_variant_builder_end(user_desc_builder); + g_variant_builder_unref(user_desc_builder); - g_dbus_proxy_call(zdo_dev_proxy, "user_desc_set_req", g_variant_new("(qy@ay)", addr16, - len, user_desc_variant), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); + g_dbus_proxy_call(zdo_dev_proxy, "user_desc_set_req", + g_variant_new("(qy@ay)", addr16, len, user_desc_variant), + G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } @@ -2605,6 +3969,10 @@ int zbl_user_desc_set(zigbee_h handle, nwk_addr addr16, unsigned char len, int zbl_device_annce(zigbee_h handle, nwk_addr addr16, ieee_addr addr64, unsigned char capability) { + int result = ZIGBEE_ERROR_NONE; + GError *dbus_err = NULL; + GVariant *variant = NULL; + GVariantBuilder *mac_builder = NULL; GVariant* mac_variant = NULL; @@ -2621,56 +3989,22 @@ int zbl_device_annce(zigbee_h handle, nwk_addr addr16, ieee_addr addr64, g_variant_builder_add(mac_builder, "y", addr64[1]); g_variant_builder_add(mac_builder, "y", addr64[0]); mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); - g_dbus_proxy_call(zdo_dev_proxy, "device_annce", + variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "device_annce", g_variant_new("(q@ayy)", addr16, mac_variant, capability), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); - - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_bind_req_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_bind_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_bind_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_bind_rsp cb = container->cb; - - unsigned char status; - - container->found = true; - - DBG("_zbl_bind_req_cb"); - - g_variant_get(parameters, "(y)", &status); - - if (cb) - cb(status, container->userdata); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get device_annce [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return result; } int zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64, @@ -2695,8 +4029,8 @@ int zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64, to = zbl_dbus_get_timeout(zdo_bind_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, - ZIGBEE_ZDO_BIND_INTERFACE, "binding_rsp", ZIGBEE_ZDO_BIND_OBJECT_PATH, - NULL, 0, _zbl_bind_req_cb, container, _zbl_request_cleanup); + ZIGBEE_ZDO_BIND_INTERFACE, "bind_rsp", ZIGBEE_ZDO_BIND_OBJECT_PATH, + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); free(container); @@ -2705,7 +4039,8 @@ int zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_bind_req_req, container); + container->cid = ZBL_ZDO_BIND_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; src_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -2721,6 +4056,7 @@ int zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64, g_variant_builder_add(src_addr64_builder, "y", src_addr64[0]); } src_addr64_variant = g_variant_builder_end(src_addr64_builder); + g_variant_builder_unref(src_addr64_builder); dst_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); if (dst_addr64) { @@ -2734,6 +4070,7 @@ int zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64, g_variant_builder_add(dst_addr64_builder, "y", dst_addr64[0]); } dst_addr64_variant = g_variant_builder_end(dst_addr64_builder); + g_variant_builder_unref(dst_addr64_builder); g_dbus_proxy_call(zdo_bind_proxy, "bind_req", g_variant_new("(q@ayyq@ayyqy)", dst_addr16, src_addr64_variant, src_ep, @@ -2743,50 +4080,6 @@ int zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_unbind_req_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_unbind_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_unbind_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_bind_rsp cb = container->cb; - - unsigned char status; - - container->found = true; - - DBG("_zbl_unbind_req_cb"); - - g_variant_get(parameters, "(y)", &status); - - if (cb) - cb(status, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - - int zbl_unbind_req(nwk_addr dst_addr16, ieee_addr src_addr64, unsigned char src_ep, unsigned short cluster_id, ieee_addr dst_addr64, unsigned char type, nwk_addr group_addr, @@ -2809,8 +4102,8 @@ int zbl_unbind_req(nwk_addr dst_addr16, to = zbl_dbus_get_timeout(zdo_bind_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, - ZIGBEE_ZDO_BIND_INTERFACE, "unbindng_rsp", ZIGBEE_ZDO_BIND_OBJECT_PATH, - NULL, 0, _zbl_unbind_req_cb, container, _zbl_request_cleanup); + ZIGBEE_ZDO_BIND_INTERFACE, "unbind_rsp", ZIGBEE_ZDO_BIND_OBJECT_PATH, + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); free(container); @@ -2819,7 +4112,8 @@ int zbl_unbind_req(nwk_addr dst_addr16, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_unbind_req_req, container); + container->cid = ZBL_ZDO_UNBIND_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; src_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -2834,6 +4128,7 @@ int zbl_unbind_req(nwk_addr dst_addr16, g_variant_builder_add(src_addr64_builder, "y", src_addr64[0]); } src_addr64_variant = g_variant_builder_end(src_addr64_builder); + g_variant_builder_unref(src_addr64_builder); dst_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); if (dst_addr64) { @@ -2847,6 +4142,7 @@ int zbl_unbind_req(nwk_addr dst_addr16, g_variant_builder_add(dst_addr64_builder, "y", dst_addr64[0]); } dst_addr64_variant = g_variant_builder_end(dst_addr64_builder); + g_variant_builder_unref(dst_addr64_builder); g_dbus_proxy_call(zdo_bind_proxy, "unbind_req", g_variant_new("(q@ayyq@ayyqy)", dst_addr16, src_addr64_variant, src_ep, @@ -2856,103 +4152,11 @@ int zbl_unbind_req(nwk_addr dst_addr16, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_mgmt_nwk_disc_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_mgmt_nwk_disc_rsp cb = NULL; - zb_zdo_network_list_record_h *records = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - records = calloc(1, sizeof(zb_zdo_network_list_record_h)); - if (records) { - records[0] = calloc(1, sizeof(struct zb_zdo_network_list_record_s)); - } - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, records, container->userdata); - - if (records[0]) - free(records[0]); - if (records) - free(records); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_mgmt_nwk_disc_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zdo_mgmt_nwk_disc_rsp cb = container->cb; - - int i = 0; - int j = 0; - unsigned char value; - unsigned char status = 0; - unsigned char nwk_count = 0; - unsigned char start_index = 0; - unsigned char nwk_list_count = 0; - - GVariantIter *mac_iter; - GVariantIter *resp_iter; - - DBG("_zbl_mgmt_nwk_disc_req_cb()"); - - g_variant_get(parameters, "(yyyya(ayayyqyyyyy))", &status, &nwk_count, - &start_index, &nwk_list_count, &resp_iter); - - zb_zdo_network_list_record_h *records = NULL; - - if (!status) { - if (nwk_list_count > 0) { - records = calloc(nwk_list_count, sizeof(zb_zdo_network_list_record_h)); - RETM_IF(NULL == records, "calloc() Fail(%d)", errno); - for (i = 0; i < nwk_list_count; i++) { - records[i] = calloc(1, sizeof(struct zb_zdo_network_list_record_s)); - if (NULL == records[i]) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - } - } - for (i = 0; i < nwk_list_count; i++) { - g_variant_iter_loop(resp_iter, "(ayayyqyyyyy)", &mac_iter, &records[i]->logical_channel, - &records[i]->stack_profile, &records[i]->zigbee_version, &records[i]->beacon_order, - &records[i]->superframe_order, &records[i]->permit_joining); - for (j = 0; j < 8; j++) { - g_variant_iter_loop(mac_iter, "y", &value); - records[i]->extended_pan_id[j] = value; - } - } - } - - if (cb) - cb(status, nwk_count, start_index, nwk_list_count, records, container->userdata); - -OUT: - for (i = 0; i < nwk_list_count; i++) - if (records[i]) - free(records[i]); - free(records); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_mgmt_nwk_disc_req(nwk_addr addr16, unsigned int scan_channels, unsigned char scan_duration, unsigned char scan_count, unsigned char start_idx, zb_zdo_mgmt_nwk_disc_rsp cb, void *user_data) { + int sub_id, to; zbl_req_cb_s *container; @@ -2967,7 +4171,7 @@ int zbl_mgmt_nwk_disc_req(nwk_addr addr16, unsigned int scan_channels, to = zbl_dbus_get_timeout(zdo_dev_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "nwk_disc_rsp", - ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_mgmt_nwk_disc_req_cb, + ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -2978,7 +4182,8 @@ int zbl_mgmt_nwk_disc_req(nwk_addr addr16, unsigned int scan_channels, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_mgmt_nwk_disc_req, container); + container->cid = ZBL_ZDO_MGMT_NWK_DISC_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zdo_dev_proxy, "nwk_disc_req", @@ -2991,120 +4196,29 @@ int zbl_mgmt_nwk_disc_req(nwk_addr addr16, unsigned int scan_channels, int zbl_mgmt_nwk_update_req(unsigned int scan_channels, unsigned char scan_duration, unsigned char scan_count, unsigned char nwk_update_id, nwk_addr nwk_manager_addr) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_mgmt_nwk_update_req()"); - g_dbus_proxy_call(zdo_dev_proxy, "nwk_update_req", + variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "nwk_update_req", g_variant_new("(quyyy)", nwk_manager_addr, scan_channels, scan_duration, - scan_count, nwk_update_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_mgmt_lqi_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_mgmt_lqi_rsp cb = NULL; - zb_zdo_neighbor_table_desc_h *records = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - records = calloc(1, sizeof(zb_zdo_neighbor_table_desc_h)); - if (records) { - records[0] = calloc(1, sizeof(struct zb_zdo_neighbor_table_desc_s)); - } - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata); - - if (records[0]) - free(records[0]); - if (records) - free(records); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_mgmt_lqi_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zbl_mgmt_lqi_req_cb()"); - zbl_req_cb_s *container = user_data; - zb_zdo_mgmt_lqi_rsp cb = container->cb; - - int i = 0; - int j = 0; - unsigned char value; - unsigned char status; - unsigned char start_index; - unsigned char neighbor_table_enteries; - unsigned char neighbor_table_list_count; - - GVariantIter *resp_iter; - GVariantIter *mac_iter; - GVariantIter *mac_iter1; - zb_zdo_neighbor_table_desc_h *records = NULL; - - g_variant_get(parameters, "(yyyya(ayayyqyyyyy))", &status, &neighbor_table_enteries, - &start_index, &neighbor_table_list_count, &resp_iter); - - if (neighbor_table_list_count > 0) { - records = calloc(neighbor_table_list_count, sizeof(zb_zdo_neighbor_table_desc_h)); - RETM_IF(NULL == records, "calloc() Fail(%d)", errno); - for (i = 0; i < neighbor_table_list_count; i++) { - records[i] = calloc(1, sizeof(struct zb_zdo_neighbor_table_desc_s)); - if (NULL == records[i]) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - } - } - for (i = 0; i < neighbor_table_list_count; i++) { - g_variant_iter_loop(resp_iter, "(ayayyqyyyyy)", &mac_iter, &mac_iter1, - &records[i]->device_type, &records[i]->addr16, &records[i]->rx_on_when_idle, - &records[i]->relationship, &records[i]->permit_joining, &records[i]->depth, - &records[i]->lqi); - for (j = 0; j < 8; j++) { - g_variant_iter_loop(mac_iter, "y", &value); - records[i]->extended_pan_id[j] = value; - g_variant_iter_loop(mac_iter1, "y", &value); - records[i]->addr64[j] = value; - } - - DBG("ext PAN ID = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02", - records[i]->extended_pan_id[0], records[i]->extended_pan_id[1], - records[i]->extended_pan_id[2], records[i]->extended_pan_id[3], - records[i]->extended_pan_id[4], records[i]->extended_pan_id[5], - records[i]->extended_pan_id[6], records[i]->extended_pan_id[7]); - - DBG("IEEE address = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02", - records[i]->addr64[0], records[i]->addr64[1], records[i]->addr64[2], records[i]->addr64[3], - records[i]->addr64[4], records[i]->addr64[5], records[i]->addr64[6], records[i]->addr64[7]); - } - - if (cb) { - cb(status, neighbor_table_enteries, start_index, neighbor_table_list_count, - records, container->userdata); + scan_count, nwk_update_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get nwk_update_req [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; } -OUT: - for (i = 0; i < neighbor_table_list_count; i++) - if (records[i]) - free(records[i]); - free(records); - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return result; } int zbl_mgmt_lqi_req(nwk_addr addr16, unsigned char start_idx, @@ -3124,7 +4238,7 @@ int zbl_mgmt_lqi_req(nwk_addr addr16, unsigned char start_idx, to = zbl_dbus_get_timeout(zdo_dev_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "mgmt_lqi_rsp", - ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_mgmt_lqi_req_cb, container, + ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -3135,100 +4249,17 @@ int zbl_mgmt_lqi_req(nwk_addr addr16, unsigned char start_idx, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_mgmt_lqi_req, container); + container->cid = ZBL_ZDO_MGMT_LQI_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zdo_dev_proxy, "mgmt_lqi_req", - g_variant_new("(qy)", addr16, start_idx), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, - container); + g_variant_new("(qy)", addr16, start_idx), + G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_mgmt_rtg_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_mgmt_rtg_rsp cb = NULL; - zb_zdo_routing_table_h *records = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - records = calloc(1, sizeof(zb_zdo_routing_table_h)); - if (records) { - records[0] = calloc(1, sizeof(struct zb_zdo_routing_table_s)); - } - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata); - - if (records[0]) - free(records[0]); - if (records) - free(records); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_mgmt_rtg_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zbl_mgmt_rtg_req_cb()"); - zbl_req_cb_s *container = user_data; - zb_zdo_mgmt_rtg_rsp cb = container->cb; - - int i; - unsigned char status; - unsigned char start_index; - unsigned char routing_table_enteries; - unsigned char routing_table_list_count; - - GVariantIter *rsp_iter; - zb_zdo_routing_table_h *records = NULL; - - g_variant_get(parameters, "(yyyya(qyyyyq))", &status, &routing_table_enteries, - &start_index, &routing_table_list_count, &rsp_iter); - - if (routing_table_list_count > 0) { - records = calloc(routing_table_list_count, sizeof(zb_zdo_routing_table_h)); - RETM_IF(NULL == records, "calloc() Fail(%d)", errno); - for (i = 0; i < routing_table_list_count; i++) { - records[i] = calloc(1, sizeof(struct zb_zdo_routing_table_s)); - if (NULL == records[i]) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - } - } - - for (i = 0; i < routing_table_list_count; i++) { - g_variant_iter_loop(rsp_iter, "(qyyyyq)", &records[i]->dst_addr, &records[i]->status, - &records[i]->memory_constrained, &records[i]->route_record_required, - &records[i]->many_to_one, &records[i]->next_hop_addr); - } - - if (cb) { - cb(status, routing_table_enteries, start_index, routing_table_list_count, - records, container->userdata); - } -OUT: - for (i = 0; i < routing_table_list_count; i++) - if (records[i]) - free(records[i]); - free(records); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_mgmt_rtg_req(nwk_addr addr16, unsigned char start_idx, zb_zdo_mgmt_rtg_rsp cb, void *user_data) { @@ -3246,7 +4277,7 @@ int zbl_mgmt_rtg_req(nwk_addr addr16, unsigned char start_idx, to = zbl_dbus_get_timeout(zdo_dev_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "mgmt_rtg_rsp", - ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_mgmt_rtg_req_cb, container, + ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -3257,125 +4288,17 @@ int zbl_mgmt_rtg_req(nwk_addr addr16, unsigned char start_idx, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_mgmt_rtg_req, container); + container->cid = ZBL_ZDO_MGMT_RTG_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zdo_dev_proxy, "mgmt_rtg_req", - g_variant_new("(qy)", addr16, start_idx), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, - container); + g_variant_new("(qy)", addr16, start_idx), + G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_mgmt_bind_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_mgmt_bind_rsp cb = NULL; - zb_zdo_binding_table_h *records = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - records = calloc(1, sizeof(zb_zdo_binding_table_h)); - if (records) { - records[0] = calloc(1, sizeof(struct zb_zdo_binding_table_s)); - } - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata); - - if (records[0]) - free(records[0]); - if (records) - free(records); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_mgmt_bind_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zbl_mgmt_bind_req_cb()"); - zbl_req_cb_s *container = user_data; - zb_zdo_mgmt_bind_rsp cb = container->cb; - - unsigned char status; - unsigned char value; - - int i = 0; - int j = 0; - unsigned char binding_table_enteries; - unsigned char binding_table_list_count; - unsigned char start_index; - - GVariantIter *mac_iter, *rsp_iter, *destep_iter; - zb_zdo_binding_table_h *records = NULL; - - g_variant_get(parameters, "(yyyya(ayyqyay))", &status, &binding_table_enteries, - &start_index, &binding_table_list_count, &rsp_iter); - - if (binding_table_list_count > 0) { - records = calloc(binding_table_list_count, sizeof(zb_zdo_binding_table_h)); - RETM_IF(NULL == records, "calloc() Fail(%d)", errno); - for (i = 0; i < binding_table_list_count; i++) { - records[i] = calloc(binding_table_list_count, sizeof(struct zb_zdo_binding_table_s)); - if (NULL == records[i]) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - } - } - for (i = 0; i < binding_table_list_count; i++) { - g_variant_iter_loop(rsp_iter, "(ayyqyay)", &mac_iter, &records[i]->src_ep, - &records[i]->cluster_id, &records[i]->dst_addr_mode, &destep_iter); - for (j = 0; j < 8; j++) { - g_variant_iter_loop(mac_iter, "y", &value); - records[i]->src_addr64[j] = value; - } - if (0x03 == records[i]->dst_addr_mode) { - for (j = 0; j < 8; j++) { - g_variant_iter_loop(destep_iter, "y", &value); - records[i]->dst_addr64[j] = value; - } - g_variant_iter_loop(destep_iter, "y", &value); - records[i]->dst_ep = value; - DBG("Destination MAC Addr : %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", - records[i]->dst_addr64[7], records[i]->dst_addr64[6], - records[i]->dst_addr64[5], records[i]->dst_addr64[4], - records[i]->dst_addr64[3], records[i]->dst_addr64[2], - records[i]->dst_addr64[1], records[i]->dst_addr64[0]); - - } else if (0x01 == records[i]->dst_addr_mode) { - g_variant_iter_loop(destep_iter, "y", &value); - records[i]->dst_addr16 = value; - g_variant_iter_loop(destep_iter, "y", &value); - records[i]->dst_addr16 += (value << 8); - } - } - - if (cb) { - cb(status, binding_table_enteries, start_index, binding_table_list_count, - records, container->userdata); - } - -OUT: - for (i = 0; i < binding_table_list_count; i++) - if (records[i]) - free(records[i]); - free(records); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_mgmt_bind_req(nwk_addr addr16, unsigned char start_idx, zb_zdo_mgmt_bind_rsp cb, void *user_data) { @@ -3393,7 +4316,7 @@ int zbl_mgmt_bind_req(nwk_addr addr16, unsigned char start_idx, to = zbl_dbus_get_timeout(zdo_dev_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "mgmt_bind_rsp", - ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_mgmt_bind_req_cb, container, + ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -3404,54 +4327,17 @@ int zbl_mgmt_bind_req(nwk_addr addr16, unsigned char start_idx, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_mgmt_bind_req, container); + container->cid = ZBL_ZDO_MGMT_BIND_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; - g_dbus_proxy_call(zdo_dev_proxy, "mgmt_bind_req", g_variant_new("(qy)", addr16, - start_idx), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); + g_dbus_proxy_call(zdo_dev_proxy, "mgmt_bind_req", + g_variant_new("(qy)", addr16, start_idx), + G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_mgmt_leave_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_mgmt_leave_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_mgmt_leave_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zbl_mgmt_leave_req_cb()"); - zbl_req_cb_s *container = user_data; - zb_zdo_mgmt_leave_rsp cb = container->cb; - unsigned char status; - - g_variant_get(parameters, "(y)", &status); - - if (cb) - cb(status, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children, unsigned rejoin, zb_zdo_mgmt_leave_rsp cb, void *user_data) { @@ -3469,8 +4355,8 @@ int zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children, to = zbl_dbus_get_timeout(zdo_dev_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, - ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "mgmt_left_rsp", - ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_mgmt_leave_req_cb, container, + ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "mgmt_leave_rsp", + ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -3481,7 +4367,8 @@ int zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_mgmt_leave_req, container); + container->cid = ZBL_ZDO_MGMT_LEAVE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; mac_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -3494,6 +4381,7 @@ int zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children, g_variant_builder_add(mac_builder, "y", addr64[1]); g_variant_builder_add(mac_builder, "y", addr64[0]); mac_variant = g_variant_builder_end(mac_builder); + g_variant_builder_unref(mac_builder); g_dbus_proxy_call(service_gproxy, "leave_req", g_variant_new("(@ayyy)", mac_variant, remove_children, rejoin), @@ -3502,45 +4390,6 @@ int zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_mgmt_permit_joining_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zdo_mgmt_permit_joining_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZDP_TIMEOUT, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_mgmt_permit_joining_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zbl_mgmt_permit_joining_req_cb()"); - zbl_req_cb_s *container = user_data; - zb_zdo_mgmt_permit_joining_rsp cb = container->cb; - unsigned char status; - - g_variant_get(parameters, "(y)", &status); - - if (cb) - cb(status, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_mgmt_permit_joining_req(nwk_addr addr16, unsigned char duration, unsigned char tc_significance, zb_zdo_mgmt_permit_joining_rsp cb, void *user_data) { @@ -3550,94 +4399,32 @@ int zbl_mgmt_permit_joining_req(nwk_addr addr16, unsigned char duration, RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR); - container = calloc(1, sizeof(zbl_req_cb_s)); - RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno); - - to = zbl_dbus_get_timeout(zdo_dev_proxy); - sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, - ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "mgmt_permit_join_rsp", - ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_mgmt_permit_joining_req_cb, - container, _zbl_request_cleanup); - - if (0 == sub_id) { - ERR("g_dbus_connection_signal_subscribe() Fail"); - free(container); - return ZIGBEE_ERROR_IO_ERROR; - } - - container->cb = cb; - container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_mgmt_permit_joining_req, container); - container->userdata = user_data; - - g_dbus_proxy_call(zdo_dev_proxy, "mgmt_permit_join_req", - g_variant_new("(qyy)", addr16, duration, tc_significance), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_aps_send(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_aps_send_rsp cb = NULL; - - DBG("_zb_timeout_aps_send()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_aps_send_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zb_aps_send_cb()"); - zbl_req_cb_s *container = user_data; - zb_aps_send_rsp cb = container->cb; - unsigned short addr16; - unsigned char src_ep; - unsigned char dst_ep; - unsigned char cluster_id; - unsigned char profile_id; - unsigned char *payload = NULL; - unsigned short payload_len = 0; - unsigned char value; - GVariantIter *payload_iter; - int i = 0; + container = calloc(1, sizeof(zbl_req_cb_s)); + RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno); - g_variant_get(parameters, "(qyyqqayq)", &addr16, &src_ep, &dst_ep, - &cluster_id, &profile_id, &payload_iter, &payload_len); + to = zbl_dbus_get_timeout(zdo_dev_proxy); + sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, + ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, "mgmt_permit_join_rsp", + ZIGBEE_ZDO_DEV_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, + container, _zbl_request_cleanup); - if (payload_len > 0) { - payload = calloc(payload_len, sizeof(unsigned char)); - while (g_variant_iter_loop(payload_iter, "y", &value)) { - payload[i++] = value; - } + if (0 == sub_id) { + ERR("g_dbus_connection_signal_subscribe() Fail"); + free(container); + return ZIGBEE_ERROR_IO_ERROR; } - if (cb) - cb(addr16, src_ep, dst_ep, cluster_id, profile_id, - payload_len, payload, container->userdata); + container->cb = cb; + container->sid = sub_id; + container->cid = ZBL_ZDO_MGMT_PERMIT_JOIN_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); + container->userdata = user_data; - if (payload) - free(payload); + g_dbus_proxy_call(zdo_dev_proxy, "mgmt_permit_join_req", + g_variant_new("(qyy)", addr16, duration, tc_significance), + G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return ZIGBEE_ERROR_NONE; } int zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, @@ -3662,7 +4449,7 @@ int zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, to = zbl_dbus_get_timeout(custom_gproxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_CUSTOM_INTERFACE, "aps_send_rsp", ZIGBEE_CUSTOM_OBJECT_PATH, NULL, 0, - _zbl_aps_send_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -3672,7 +4459,8 @@ int zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_aps_send, container); + container->cid = ZBL_CUSTOM_APS_SEND_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; payload_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -3682,6 +4470,7 @@ int zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, } } payload_variant = g_variant_builder_end(payload_builder); + g_variant_builder_unref(payload_builder); g_dbus_proxy_call(custom_gproxy, "aps_send", g_variant_new("(qyyyqqyq@ay)", addr16, aps_frame_ctl, src_ep, dst_ep, cluster_id, @@ -3691,69 +4480,6 @@ int zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_zcl_send(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_send_rsp cb = NULL; - - DBG("_zb_timeout_zcl_send()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_zcl_send_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zbl_zcl_send_cb()"); - zbl_req_cb_s *container = user_data; - zb_zcl_send_rsp cb = container->cb; - unsigned short addr16; - unsigned char src_ep; - unsigned char dst_ep; - unsigned char cluster_id; - unsigned char profile_id; - unsigned char *payload = NULL; - unsigned short payload_len = 0; - unsigned char value; - GVariantIter *payload_iter; - int i = 0; - - g_variant_get(parameters, "(qyyqqayq)", &addr16, &src_ep, &dst_ep, - &cluster_id, &profile_id, &payload_iter, &payload_len); - - if (payload_len > 0) { - payload = calloc(payload_len, sizeof(unsigned char)); - while (g_variant_iter_loop(payload_iter, "y", &value)) { - payload[i++] = value; - } - } - - if (cb) - cb(addr16, src_ep, dst_ep, cluster_id, profile_id, - payload_len, payload, container->userdata); - - if (payload) - free(payload); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, unsigned short cluster_id, unsigned char zcl_frame_ctl, unsigned char cmd, unsigned short payload_len, unsigned char *payload, @@ -3774,7 +4500,7 @@ int zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, to = zbl_dbus_get_timeout(custom_gproxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_CUSTOM_INTERFACE, "zcl_send_rsp", ZIGBEE_CUSTOM_OBJECT_PATH, NULL, 0, - _zbl_zcl_send_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -3784,7 +4510,8 @@ int zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_zcl_send, container); + container->cid = ZBL_CUSTOM_ZCL_SEND_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; payload_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -3794,6 +4521,7 @@ int zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, } } payload_variant = g_variant_builder_end(payload_builder); + g_variant_builder_unref(payload_builder); g_dbus_proxy_call(custom_gproxy, "zcl_send", g_variant_new("(qyyqyy@ay)", addr16, src_ep, dst_ep, cluster_id, zcl_frame_ctl, @@ -3802,62 +4530,6 @@ int zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_send_to_local(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_send_to_local_rsp cb = NULL; - - DBG("_zb_timeout_send_to_local()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_send_to_local_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zb_send_to_local_cb()"); - zbl_req_cb_s *container = user_data; - zb_send_to_local_rsp cb = container->cb; - unsigned char *data = NULL; - unsigned short length = 0; - unsigned char value; - GVariantIter *payload_iter; - int i = 0; - - g_variant_get(parameters, "(ayq)", &payload_iter, &length); - - if (length > 0) { - data = calloc(length, sizeof(unsigned char)); - while (g_variant_iter_loop(payload_iter, "y", &value)) { - data[i++] = value; - } - } - - if (cb) - cb(length, data, container->userdata); - - if (data) - free(data); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_send_to_local(unsigned short length, unsigned char *data, zb_send_to_local_rsp cb, void *user_data) { @@ -3876,7 +4548,7 @@ int zbl_send_to_local(unsigned short length, unsigned char *data, to = zbl_dbus_get_timeout(custom_gproxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_CUSTOM_INTERFACE, "send_to_local_rsp", ZIGBEE_CUSTOM_OBJECT_PATH, NULL, 0, - _zbl_send_to_local_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -3886,7 +4558,8 @@ int zbl_send_to_local(unsigned short length, unsigned char *data, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_send_to_local, container); + container->cid = ZBL_CUSTOM_LOCAL_SEND_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; payload_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -3896,6 +4569,7 @@ int zbl_send_to_local(unsigned short length, unsigned char *data, } } payload_variant = g_variant_builder_end(payload_builder); + g_variant_builder_unref(payload_builder); g_dbus_proxy_call(custom_gproxy, "send_to_local", g_variant_new("(@ay)", payload_variant), @@ -3904,104 +4578,6 @@ int zbl_send_to_local(unsigned short length, unsigned char *data, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_read_attributes_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_global_rsp cb = NULL; - - DBG("_zbl_timeout_read_attributes_req()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, NULL, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_read_attributes_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_global_rsp cb = container->cb; - - int j = 0; - int isString; - unsigned char value; - - nwk_addr addr16; - unsigned char ep; - unsigned short attr_id; - unsigned short cluster_id; - unsigned char status; - unsigned char type; - unsigned short records_len; - unsigned char attr_value[128]; - - GVariantIter *iter; - read_attr_status_record_h records; - zb_global_record_data_s *data; - - DBG("_zbl_read_attributes_req_cb"); - - data = calloc(1, sizeof(zb_global_record_data_s)); - records = calloc(1, sizeof(struct read_attribute_status_record_s)); - if (!records || !data) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - - container->found = true; - - g_variant_get(parameters, "(qyayqqyyqi)", - &addr16, &ep, &iter, &attr_id, &cluster_id, &status, &type, &records_len, &isString); - if (!isString) { - while (g_variant_iter_loop(iter, "y", &value)) { - attr_value[j] = value; - DBG("attr_value[%d] = 0x%02X", j, value); - j++; - } - } else { - while (g_variant_iter_loop(iter, "y", &value)) { - if (j == 0) - records_len = value; - attr_value[j] = value; - DBG("attr_value[%d] = 0x%02X", j, value); - j++; - } - } - - records->id = attr_id; - records->status = status; - records->type = type; - records->value = attr_value; - data->type = ZB_GLOBAL_READ_ATTR; - data->record.read_attr = &records; - data->records_len = records_len; - - if (cb) - cb(addr16, ep, cluster_id, data, records_len, container->userdata); - -OUT: - if (records) - free(records); - if (data) - free(data); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_read_attr_req(zigbee_h handle, unsigned short addr16, unsigned char dest_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned short *attribute_ids, int attribute_ids_len, zb_zcl_global_rsp cb, void *user_data) @@ -4028,7 +4604,7 @@ int zbl_read_attr_req(zigbee_h handle, unsigned short addr16, unsigned char dest to = zbl_dbus_get_timeout(zcl_global_proxy); sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "read_attributes_rsp", - ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_read_attributes_req_cb, + ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -4039,7 +4615,8 @@ int zbl_read_attr_req(zigbee_h handle, unsigned short addr16, unsigned char dest container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_read_attributes_req, container); + container->cid = ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -4067,94 +4644,16 @@ int zbl_read_attr_req(zigbee_h handle, unsigned short addr16, unsigned char dest for (i = 0; i < attribute_ids_len*sizeof(unsigned short); i++) g_variant_builder_add(attr_builder, "y", t[i]); attr_variant = g_variant_builder_end(attr_builder); + g_variant_builder_unref(attr_builder); - g_dbus_proxy_call(zcl_global_proxy, "read_attributes_req", g_variant_new("(@ayiqqyy)", - attr_variant, attribute_ids_len, addr16, cluster_id, zcl_frame_ctl, dest_ep), + g_dbus_proxy_call(zcl_global_proxy, "read_attributes_req", + g_variant_new("(@ayiqqyy)", attr_variant, attribute_ids_len, addr16, cluster_id, + zcl_frame_ctl, dest_ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_write_attributes_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_global_rsp cb = NULL; - - DBG("_zbl_timeout_write_attributes_req()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, NULL, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_write_attributes_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_global_rsp cb = container->cb; - - int i = 0; - nwk_addr addr16; - unsigned char ep; - unsigned short cluster_id; - unsigned short attribute_id; - int records_len; - unsigned char value; - - GVariantIter *stat_iter, *attr_iter; - write_attr_status_record_h records; - zb_global_record_data_s *data; - - g_variant_get(parameters, "(qyayaqqi)", - &addr16, &ep, &stat_iter , &attr_iter, &cluster_id, &records_len); - - records = calloc(records_len, sizeof(struct write_attribute_status_record_s)); - data = calloc(1, sizeof(zb_global_record_data_s)); - if (!records || !data) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - - while (g_variant_iter_loop(stat_iter, "y", &value)) { - records[i].status = value; - i++; - } - i = 0; - while (g_variant_iter_loop(attr_iter, "q", &attribute_id)) { - records[i].id = attribute_id; - DBG("Attribute Id 0x%04X", attribute_id); - i++; - } - data->type = ZB_GLOBAL_WRITE_ATTR; - data->record.write_attr = &records; - data->records_len = records_len; - - if (cb) - cb(addr16, ep, cluster_id, data, records_len, container->userdata); - -OUT: - if (records) - free(records); - if (data) - free(data); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_write_attr_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, write_attr_record_h *records, int records_len, zb_zcl_global_rsp cb, void *user_data) @@ -4252,6 +4751,7 @@ int zbl_write_attr_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, u } rec_variant = g_variant_builder_end(rec_builder); + g_variant_builder_unref(rec_builder); container = calloc(1, sizeof(zbl_req_cb_s)); if (NULL == container) { @@ -4265,7 +4765,7 @@ int zbl_write_attr_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, u to = zbl_dbus_get_timeout(zcl_global_proxy); sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "write_attributes_rsp", - ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_write_attributes_req_cb, + ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -4279,7 +4779,8 @@ int zbl_write_attr_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, u container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_write_attributes_req, container); + container->cid = ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -4415,6 +4916,7 @@ int zbl_wattr_undivided_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ } rec_variant = g_variant_builder_end(rec_builder); + g_variant_builder_unref(rec_builder); container = calloc(1, sizeof(zbl_req_cb_s)); if (NULL == container) { @@ -4428,7 +4930,7 @@ int zbl_wattr_undivided_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ to = zbl_dbus_get_timeout(zcl_global_proxy); sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "write_attributes_rsp", - ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_write_attributes_req_cb, + ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -4442,7 +4944,8 @@ int zbl_wattr_undivided_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_write_attributes_req, container); + container->cid = ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -4468,7 +4971,7 @@ int zbl_wattr_undivided_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ _zbl_register_global_req(handle, container); #endif - g_dbus_proxy_call(zcl_global_proxy, "write_attributes_undivided_req", + g_dbus_proxy_call(zcl_global_proxy, "write_attributes_undivided_req", g_variant_new("(@ayiqqyyy)", rec_variant, writeAttributeIndex, addr16, cluster_id, zcl_frame_ctl, src_ep, dst_ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); @@ -4484,6 +4987,10 @@ int zbl_wattr_req_no_rsp(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, write_attr_record_h *records, int records_len) { + int result = ZIGBEE_ERROR_NONE; + GError *dbus_err = NULL; + GVariant *variant = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR); @@ -4535,142 +5042,68 @@ int zbl_wattr_req_no_rsp(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, dataSize[j] = dSize[1]; dataSize[j] = (dataSize[j] << 8) | dSize[0]; size_of_allo = size_of_allo + (dataSize[j] + 3 + 2); - } - } else - ERR("Data is not present"); - } - j++; - } - DBG("size_of_allo Length %d", size_of_allo); - - writeAttribute = calloc(size_of_allo + 1, sizeof(unsigned char)); - if (NULL == writeAttribute) { - ERR("Couldn't Allocate Memory"); - free(isString); - free(dataSize); - return ZIGBEE_ERROR_OUT_OF_MEMORY; - } - - j = 0; - while (j < records_len && writeAttributeIndex < size_of_allo) { - writeAttribute[writeAttributeIndex++] = ((*records)[j].id) & 0xff; - writeAttribute[writeAttributeIndex++] = (((*records)[j].id) >> 8) & 0xff; - writeAttribute[writeAttributeIndex++] = (*records)[j].type; - for (i = 0; i < (dataSize[j] + isString[j]); i++) { - writeAttribute[writeAttributeIndex++] = (*records)[j].value[i]; - DBG("0x%02X", (*records)[j].value[i]); - } - j++; - } - - rec_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); - DBG(" "); - for (i = 0; i < writeAttributeIndex ; i++) { - DBG("0x%02X", writeAttribute[i]); - g_variant_builder_add(rec_builder, "y", writeAttribute[i]); - } - - rec_variant = g_variant_builder_end(rec_builder); - - g_dbus_proxy_call(zcl_global_proxy, "write_attributes_no_rep", - g_variant_new("(@ayiqqyyy)", rec_variant, writeAttributeIndex, addr16, - cluster_id, zcl_frame_ctl, src_ep, dst_ep), G_DBUS_CALL_FLAGS_NONE, - -1, NULL, NULL, NULL); - - free(isString); - free(dataSize); - free(writeAttribute); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_configure_reporting(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_global_rsp cb = NULL; - - DBG("_zbl_timeout_configure_reporting()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, NULL, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_configure_reporting_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_global_rsp cb = container->cb; - - nwk_addr addr16; - unsigned char ep; - unsigned short cluster_id; - unsigned short attIdVal; - unsigned char value; - int j = 0, l = 0, k = 0, rec_len; - GVariantIter *stat_iter, *attr_iter, *dir_iter; - report_config_response_record_h records; - zb_global_record_data_s *data; - - DBG("_zbl_configure_reporting_cb"); - - g_variant_get(parameters, "(ayaqayqiqy)", - &stat_iter, &attr_iter, &dir_iter, &cluster_id, &rec_len, &addr16, &ep); - - records = calloc(rec_len, sizeof(struct reporting_configuration_response_record_s)); - data = calloc(1, sizeof(zb_global_record_data_s)); - if (!data || !records) { - ERR("calloc() Fail(%d)", errno); - goto OUT; + } + } else + ERR("Data is not present"); + } + j++; } + DBG("size_of_allo Length %d", size_of_allo); - while (g_variant_iter_loop(stat_iter, "y", &value)) { - DBG("Value 0x%02X", value); - records[j].status = value; - j++; + writeAttribute = calloc(size_of_allo + 1, sizeof(unsigned char)); + if (NULL == writeAttribute) { + ERR("Couldn't Allocate Memory"); + free(isString); + free(dataSize); + return ZIGBEE_ERROR_OUT_OF_MEMORY; } - while (g_variant_iter_loop(attr_iter, "q", &attIdVal)) { - if (records[l].status != ZB_ZCL_SUCCESS) - records[l].id = attIdVal; - l++; + j = 0; + while (j < records_len && writeAttributeIndex < size_of_allo) { + writeAttribute[writeAttributeIndex++] = ((*records)[j].id) & 0xff; + writeAttribute[writeAttributeIndex++] = (((*records)[j].id) >> 8) & 0xff; + writeAttribute[writeAttributeIndex++] = (*records)[j].type; + for (i = 0; i < (dataSize[j] + isString[j]); i++) { + writeAttribute[writeAttributeIndex++] = (*records)[j].value[i]; + DBG("0x%02X", (*records)[j].value[i]); + } + j++; } - while (g_variant_iter_loop(dir_iter, "y", &value)) { - if (records[k].status != ZB_ZCL_SUCCESS) - records[k].dir = value; - k++; + rec_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); + DBG(" "); + for (i = 0; i < writeAttributeIndex ; i++) { + DBG("0x%02X", writeAttribute[i]); + g_variant_builder_add(rec_builder, "y", writeAttribute[i]); } - data->type = ZB_GLOBAL_CONFIG_REPORT; - data->record.report_config_rsp = &records; - data->records_len = rec_len; - container->found = true; + rec_variant = g_variant_builder_end(rec_builder); + g_variant_builder_unref(rec_builder); - if (cb) - cb(addr16, ep, cluster_id, data, rec_len, container->userdata); + variant = g_dbus_proxy_call_sync(zcl_global_proxy, "write_attributes_no_rep", + g_variant_new("(@ayiqqyyy)", rec_variant, writeAttributeIndex, addr16, + cluster_id, zcl_frame_ctl, src_ep, dst_ep), G_DBUS_CALL_FLAGS_NONE, + -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get write_attributes_no_rep [%s]", dbus_err->message); + g_error_free(dbus_err); -OUT: - if (records) - free(records); - if (data) - free(data); + free(isString); + free(dataSize); + free(writeAttribute); - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return ZIGBEE_ERROR_IO_ERROR; + } + + free(isString); + free(dataSize); + free(writeAttribute); + + return result; } int zbl_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, @@ -4703,7 +5136,7 @@ int zbl_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char src_ to = zbl_dbus_get_timeout(zcl_global_proxy); sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "configure_reporting_rsp", - ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_configure_reporting_cb, + ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -4714,7 +5147,8 @@ int zbl_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char src_ container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_configure_reporting, container); + container->cid = ZBL_ZCL_GLOBAL_CONFIGURE_REPORTING_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -4770,6 +5204,7 @@ int zbl_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char src_ } rec_variant = g_variant_builder_end(rec_builder); + g_variant_builder_unref(rec_builder); g_dbus_proxy_call(zcl_global_proxy, "configure_reporting_req", g_variant_new("(@ayqqqyyy)", rec_variant, count, addr16, cluster_id, @@ -4778,136 +5213,6 @@ int zbl_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char src_ return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_read_configure_reporting(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_global_rsp cb = NULL; - - DBG("_zbl_timeout_read_configure_reporting()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, NULL, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -#define ZCL_REPORTING_DIRECTION_REPORTED 0x00 -#define ZCL_REPORTING_DIRECTION_RECEIVED 0x01 - -static void _zbl_read_configure_reporting_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_global_rsp cb = container->cb; - - nwk_addr addr16; - unsigned char ep; - unsigned short cluster_id; - - int i = 0; - int j = 0; - char value; - unsigned char *status = NULL; - unsigned char *data_size = NULL; - unsigned char *change = NULL; - unsigned short record_length; - GVariantIter *resp_iter; - GVariantIter *data_iter; - - DBG("_zbl_read_configure_reporting_cb"); - - report_config_record_h *records = NULL; - zb_global_record_data_s *data = NULL; - - g_variant_get(parameters, "(qyqqa(yyqyqqayq))", - &addr16, &ep, &cluster_id, &record_length, &resp_iter); - - records = calloc(record_length, sizeof(report_config_record_h)); - for (i = 0; i < record_length; i++) { - records[i] = calloc(1, sizeof(struct reporting_configuration_record_s)); - if (NULL == records[i]) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - } - data = calloc(1, sizeof(zb_global_record_data_s)); - if (!data || !records) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - - DBG("record_length %d", record_length); - status = calloc(record_length, sizeof(unsigned char)); - data_size = calloc(record_length, sizeof(unsigned char)); - if (!status || !data_size) { - ERR("Couldn't allocate the memory (%s)", errno); - goto OUT; - } - - for (i = 0; i < record_length; i++) { - g_variant_iter_loop(resp_iter, "(yyqyqqayq)", &status[i], &records[i]->dir, - &records[i]->id, &records[i]->type, &records[i]->max_i, &records[i]->min_i, - &data_iter, &records[i]->to); - if (records[i]->dir != ZCL_REPORTING_DIRECTION_REPORTED && - (zb_get_analog_or_discret(records[i]->type) == DATA_TYPE_ANALOG)) { - data_size[i] = zb_get_data_size(records[j]->type); - j = 0; - if (data_size[i] != 0xff) { - change = calloc(data_size[i]+1, sizeof(unsigned char)); - if (!change) { - ERR("calloc() Fail(%d)", errno); - records[i]->change = NULL; - continue; - } - while (g_variant_iter_loop(data_iter, "y", &value)) { - change[j] = value; - j++; - } - records[i]->change = change; - } else - records[i]->change = NULL; - } else - records[i]->change = NULL; - } - - data->type = ZB_GLOBAL_READ_REPORT_CONFIG; - data->record.report_config = records; - data->records_len = record_length; - - container->found = true; - - if (cb) - cb(addr16, ep, cluster_id, data, record_length, container->userdata); -OUT: - if (data_size) - free(data_size); - if (status) - free(status); - if (records) { - for (i = 0; i < record_length; i++) - if (records[i]) - free(records[i]); - free(records); - } - free(data); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - - int zbl_read_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, read_report_config_record_h *records, int records_len, @@ -4938,7 +5243,7 @@ int zbl_read_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char to = zbl_dbus_get_timeout(zcl_global_proxy); sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "read_configure_reporting_rsp", - ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_read_configure_reporting_cb, + ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -4949,7 +5254,8 @@ int zbl_read_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_read_configure_reporting, container); + container->cid = ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -5011,6 +5317,7 @@ int zbl_read_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char } rec_variant = g_variant_builder_end(rec_builder); + g_variant_builder_unref(rec_builder); g_dbus_proxy_call(zcl_global_proxy, "read_configure_reporting", g_variant_new("(@ayqqqyyy)", rec_variant, idx, addr16, cluster_id, zcl_frame_ctl, @@ -5021,89 +5328,6 @@ int zbl_read_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_discover_attributes_req(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_global_discover_attr_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL)"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, NULL, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_discover_attributes_req_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_global_discover_attr_rsp cb = container->cb; - - nwk_addr addr16; - unsigned char ep; - discover_attr_info_record_h *records; - - int records_len; - unsigned short cluster_id; - unsigned short attribute_id; - unsigned char value; - int j = 0, l = 0; - int discovery_complete; - GVariantIter *stat_iter, *attr_iter; - - DBG("_zbl_discover_attributes_req_cb"); - - g_variant_get(parameters, "(qyayaqqii)", &addr16, &ep, &stat_iter, - &attr_iter, &cluster_id, &records_len, &discovery_complete); - records = calloc(records_len, sizeof(discover_attr_info_record_h)); - RETM_IF(NULL == records, "calloc() Fail(%d)", errno); - for (j = 0; j < records_len; j++) { - records[j] = calloc(1, sizeof(struct discover_attribute_info_record_s)); - if (NULL == records[j]) { - ERR("calloc() Fail(%d)", errno); - for (l = 0; l < j; l++) - free(records[l]); - free(records); - return; - } - } - - j = 0; - while (g_variant_iter_loop(stat_iter, "y", &value)) { - records[j]->type = value; - DBG("Attribute Type 0x%02X", value); - j++; - } - while (g_variant_iter_loop(attr_iter, "q", &attribute_id)) { - records[l]->id = attribute_id; - DBG("Attribute Id 0x%04X", attribute_id); - l++; - } - - container->found = true; - - if (cb) - cb(addr16, ep, cluster_id, discovery_complete, records, records_len, - container->userdata); - - for (j = 0; j < records_len; j++) - free(records[j]); - free(records); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_discover_attr_req(zigbee_h handle, unsigned short addr16, unsigned char src_ep, unsigned char dest_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned short start_id, unsigned char max_attribute_ids, @@ -5111,8 +5335,7 @@ int zbl_discover_attr_req(zigbee_h handle, unsigned short addr16, unsigned char { int sub_id, to; zbl_req_cb_s *container; - unsigned char status = ZIGBEE_ERROR_NONE; - GVariant *variant = NULL; + #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC zb_event_global_default_rsp_s *global_req = NULL; #endif @@ -5129,7 +5352,7 @@ int zbl_discover_attr_req(zigbee_h handle, unsigned short addr16, unsigned char sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "discover_attribute_rsp", ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_discover_attributes_req_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -5139,7 +5362,8 @@ int zbl_discover_attr_req(zigbee_h handle, unsigned short addr16, unsigned char container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_discover_attributes_req, container); + container->cid = ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -5166,75 +5390,7 @@ int zbl_discover_attr_req(zigbee_h handle, unsigned short addr16, unsigned char addr16, dest_ep, zcl_frame_ctl, cluster_id, start_id, max_attribute_ids), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - if (variant) { - g_variant_get(variant, "(y)", &status); - DBG("zbl_discover_attr_req Status = 0x%02X", status); - } - - return status; -} - -static gboolean _zbl_timeout_discover_cmds(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_global_discover_cmds_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, NULL, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_discover_cmds_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - DBG("_zbl_discover_cmds_cb"); - zbl_req_cb_s *container = user_data; - RETM_IF(NULL == container, "cb_container is NULL"); - - zb_zcl_global_discover_cmds_rsp cb = container->cb; - nwk_addr addr16; - unsigned char ep; - - int j = 0; - char value; - unsigned short cluster_id; - unsigned short cmd_len; - unsigned char *cmd_data; - unsigned char discoveryComplete; - GVariantIter *cmd_iter; - - g_variant_get(parameters, "(ayqqqyy)", &cmd_iter, &cluster_id, &cmd_len, - &addr16, &ep, &discoveryComplete); - - cmd_data = calloc(cmd_len+1, sizeof(char)); - RETM_IF(NULL == cmd_data, "calloc() Fail(%d)", errno); - - while (g_variant_iter_loop(cmd_iter, "y", &value)) { - DBG("Value 0x%02X", value); - cmd_data[j] = value; - j++; - } - - container->found = true; - if (cb) - cb(addr16, ep, cluster_id, discoveryComplete, cmd_data, cmd_len, container->userdata); - - free(cmd_data); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return ZIGBEE_ERROR_NONE; } int zbl_discover_cmds_gen(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, @@ -5258,7 +5414,7 @@ int zbl_discover_cmds_gen(zigbee_h handle, nwk_addr addr16, unsigned char src_ep to = zbl_dbus_get_timeout(zcl_global_proxy); sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "discover_commands_received_rsp", - ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_discover_cmds_cb, container, + ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -5269,7 +5425,8 @@ int zbl_discover_cmds_gen(zigbee_h handle, nwk_addr addr16, unsigned char src_ep container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_discover_cmds, container); + container->cid = ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -5303,6 +5460,10 @@ int zbl_discover_cmds_recv(zigbee_h handle, nwk_addr addr16, unsigned char src_e unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id, unsigned char max_command_ids, zb_zcl_global_discover_cmds_rsp cb, void *user_data) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + int sub_id, to; zbl_req_cb_s *container; @@ -5321,7 +5482,7 @@ int zbl_discover_cmds_recv(zigbee_h handle, nwk_addr addr16, unsigned char src_e to = zbl_dbus_get_timeout(zcl_global_proxy); sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "discover_commands_received_rsp", - ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_discover_cmds_cb, container, + ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -5332,7 +5493,8 @@ int zbl_discover_cmds_recv(zigbee_h handle, nwk_addr addr16, unsigned char src_e container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_discover_cmds, container); + container->cid = ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -5355,106 +5517,26 @@ int zbl_discover_cmds_recv(zigbee_h handle, nwk_addr addr16, unsigned char src_e _zbl_register_global_req(handle, container); #endif - g_dbus_proxy_call(zcl_global_proxy, "discover_commands_received", + variant = g_dbus_proxy_call_sync(zcl_global_proxy, "discover_commands_received", g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl, cluster_id, - start_command_id, max_command_ids), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_discover_attr_ext(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_global_discover_attr_extended_rsp cb = NULL; - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, NULL, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_discover_attr_ext_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - RETM_IF(NULL == container, "cb_container is NULL"); - - zb_zcl_global_discover_attr_extended_rsp cb = container->cb; - nwk_addr addr16; - unsigned char ep; - - int i = 0; - int j = 0; - unsigned short cluster_id; - unsigned char t_value; - unsigned char ac_value; - - unsigned short rec_len; - unsigned short attr_data; - unsigned char discoveryComplete; - GVariantIter *attr_iter, *type_itr, *ac_itr; - extended_attr_info_h *records; - - DBG("Will get the value now"); - - g_variant_get(parameters, "(aqayayqqqyy)", &attr_iter, &type_itr, &ac_itr, - &cluster_id, &rec_len, &addr16, &ep, &discoveryComplete); - - DBG("records length 0x%04X", rec_len); - - records = calloc(rec_len, sizeof(extended_attr_info_h)); - RETM_IF(NULL == records, "calloc() Fail(%d)", errno); - for (j = 0; j < rec_len; j++) { - records[j] = calloc(1, sizeof(struct extended_attribute_infomation_s)); - if (NULL == records[j]) { - ERR("calloc() Fail(%d)", errno); - for (i = 0; i < j; i++) - free(records[i]); - free(records); - return; - } - } - - j = 0; - while (g_variant_iter_loop(attr_iter, "q", &attr_data) - && g_variant_iter_loop(type_itr, "y", &t_value) - && g_variant_iter_loop(ac_itr, "y", &ac_value)) { - DBG("attrData 0x%04X", attr_data); - DBG("t_value 0x%02X", t_value); - DBG("ac_value 0x%02X", ac_value); - records[j]->id = attr_data; - records[j]->type = t_value; - records[j]->acl = ac_value; - j++; + start_command_id, max_command_ids), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get discover_commands_received [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; } - container->found = true; - if (cb) - cb(addr16, ep, cluster_id, discoveryComplete, records, rec_len, container->userdata); - - for (j = 0; j < rec_len; j++) - free(records[j]); - free(records); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return result; } -int zbl_discover_attr_ext(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep, - unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned short start_id, - unsigned char max_attribute_ids, zb_zcl_global_discover_attr_extended_rsp cb, - void *user_data) +int zbl_discover_attr_ext(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, + unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id, + unsigned short start_id, unsigned char max_attribute_ids, + zb_zcl_global_discover_attr_extended_rsp cb, void *user_data) { int sub_id, to; zbl_req_cb_s *container; @@ -5474,7 +5556,7 @@ int zbl_discover_attr_ext(zigbee_h handle, nwk_addr addr16, unsigned char src_ep to = zbl_dbus_get_timeout(zcl_global_proxy); sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "discover_attributes_extended_rsp", - ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_discover_attr_ext_cb, container, + ZIGBEE_ZCL_GLOBAL_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -5485,7 +5567,8 @@ int zbl_discover_attr_ext(zigbee_h handle, nwk_addr addr16, unsigned char src_ep container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_discover_attr_ext, container); + container->cid = ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC global_req = calloc(1, sizeof(zb_event_global_default_rsp_s)); @@ -5518,78 +5601,51 @@ int zbl_discover_attr_ext(zigbee_h handle, nwk_addr addr16, unsigned char src_ep int zbl_reset_alarm(nwk_addr addr16, unsigned char ep, unsigned char alarm_code, unsigned short cluster_id) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == alarm_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(alarm_gproxy, "reset_alarm", + variant = g_dbus_proxy_call_sync(alarm_gproxy, "reset_alarm", g_variant_new("(qyyq)", addr16, ep, alarm_code, cluster_id), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get reset_alarm [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_reset_all_alarm(nwk_addr addr16, unsigned char ep) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == alarm_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(alarm_gproxy, "reset_all_alarm", g_variant_new("(qy)", addr16, ep), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_get_alarm(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_alarm_get_alarm_rsp cb = NULL; - - DBG("_zbl_timeout_get_alarm()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(ZB_ZCL_TIMEOUT, 0, ZB_ZCL_UNSUP_CLUSTER_COMMAND, 0, 0, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_get_alarm_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_alarm_get_alarm_rsp cb = container->cb; - - nwk_addr addr16 = 0; - unsigned char ep = 0; - unsigned char status = 0; - unsigned char alarm_code = 0; - unsigned short cluster_id = 0; - unsigned int time_stamp = 0; - - container->found = true; - - DBG("_zbl_get_alarm_cb"); - - g_variant_get(parameters, "(qyyyqu)", &addr16, &ep, &status, &alarm_code, - &cluster_id, &time_stamp); - - if (cb) - cb(addr16, ep, status, alarm_code, cluster_id, time_stamp, container->userdata); + variant = g_dbus_proxy_call_sync(alarm_gproxy, "reset_all_alarm", + g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get reset_all_alarm [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return result; } int zbl_get_alarm(nwk_addr addr16, unsigned char ep, zb_zcl_alarm_get_alarm_rsp cb, @@ -5609,7 +5665,7 @@ int zbl_get_alarm(nwk_addr addr16, unsigned char ep, zb_zcl_alarm_get_alarm_rsp to = zbl_dbus_get_timeout(alarm_gproxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_ALARM_INTERFACE, "get_alarm_rsp", ZIGBEE_ZCL_ALARM_OBJECT_PATH, - NULL, 0, _zbl_get_alarm_cb, container, _zbl_request_cleanup); + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -5619,246 +5675,381 @@ int zbl_get_alarm(nwk_addr addr16, unsigned char ep, zb_zcl_alarm_get_alarm_rsp container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_get_alarm, container); + container->cid = ZBL_ZCL_ALARM_GET_ALARM_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; - g_dbus_proxy_call(alarm_gproxy, "get_alarm", g_variant_new("(qy)", addr16, ep), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); + g_dbus_proxy_call(alarm_gproxy, "get_alarm", + g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); return ZIGBEE_ERROR_NONE; } int zbl_reset_all_alarm_log(nwk_addr addr16, unsigned char ep) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == alarm_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(alarm_gproxy, "reset_all_alarm_log", - g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + variant = g_dbus_proxy_call_sync(alarm_gproxy, "reset_all_alarm_log", + g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get reset_all_alarm_log [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_move_to_hue(nwk_addr addr16, unsigned char ep, unsigned char hue, unsigned char direction, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "move_to_hue", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_to_hue", g_variant_new("(qyyyq)", addr16, ep, hue, direction, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_to_hue [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_move_hue(nwk_addr addr16, unsigned char ep, unsigned char move_mode, unsigned char rate) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "move_hue", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_hue", g_variant_new("(qyyy)", addr16, ep, move_mode, rate), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_hue [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_step_hue(nwk_addr addr16, unsigned char ep, unsigned char step_mode, unsigned char step_size, unsigned char transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "step_hue", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "step_hue", g_variant_new("(qyyyy)", addr16, ep, step_mode, step_size, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get step_hue [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_move_to_saturation(nwk_addr addr16, unsigned char ep, unsigned char saturation, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "move_to_saturation", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_to_saturation", g_variant_new("(qyyq)", addr16, ep, saturation, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_to_saturation [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_move_saturation(nwk_addr addr16, unsigned char ep, unsigned char move_mode, unsigned char rate) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "move_saturation", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_saturation", g_variant_new("(qyyy)", addr16, ep, move_mode, rate), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_saturation [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_step_saturation(nwk_addr addr16, unsigned char ep, unsigned char step_mode, unsigned char step_size, unsigned char transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "step_saturation", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "step_saturation", g_variant_new("(qyyyy)", addr16, ep, step_mode, step_size, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get step_saturation [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_move_to_hue_and_saturation(nwk_addr addr16, unsigned char ep, unsigned char hue, unsigned char saturation, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "move_to_hue_and_saturation", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_to_hue_and_saturation", g_variant_new("(qyyyq)", addr16, ep, hue, saturation, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_to_hue_and_saturation [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_move_to_color(nwk_addr addr16, unsigned char ep, unsigned short color_x, unsigned short color_y, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "move_to_color", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_to_color", g_variant_new("(qyqqq)", addr16, ep, color_x, color_y, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_to_color [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_move_color(nwk_addr addr16, unsigned char ep, unsigned short rate_x, unsigned short rate_y) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "move_color", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_color", g_variant_new("(qyqq)", addr16, ep, rate_x, rate_y), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_color [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_step_color(nwk_addr addr16, unsigned char ep, unsigned short step_x, unsigned short step_y, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "step_color", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "step_color", g_variant_new("(qyqqq)", addr16, ep, step_x, step_y, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get step_color [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_ccontrol_move_to_color_temperature(nwk_addr addr16, unsigned char ep, unsigned short color_temperature, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_color_control_proxy, "move_color_temperature", + variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_color_temperature", g_variant_new("(qyqq)", addr16, ep, color_temperature, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_color_temperature [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_reset_factory_default(nwk_addr addr16, unsigned char ep) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_basic_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_basic_proxy, "rest_factory_default", - g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + variant = g_dbus_proxy_call_sync(zcl_basic_proxy, "reset_factory_default", + g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get reset_factory_default [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_identify(nwk_addr addr16, unsigned char dst_ep, unsigned short identify_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_identify_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_identify_proxy, "identify", + variant = g_dbus_proxy_call_sync(zcl_identify_proxy, "identify", g_variant_new("(qyq)", addr16, dst_ep, identify_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_identify_query(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_identify_query_cb cb = NULL; - - DBG("_zbl_timeout_identity_query()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_identify_query_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_identify_query_cb cb = container->cb; - - nwk_addr addr16 = 0; - unsigned short identify_time = 0; - - container->found = true; - - DBG("_zbl_identity_query_cb"); - - g_variant_get(parameters, "(qq)", &addr16, &identify_time); - - if (cb) - cb(addr16, identify_time, container->userdata); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get identify [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return result; } int zbl_identify_query(nwk_addr addr16, unsigned char dst_ep, @@ -5878,72 +6069,25 @@ int zbl_identify_query(nwk_addr addr16, unsigned char dst_ep, to = zbl_dbus_get_timeout(zcl_identify_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_IDENTIFY_INTERFACE, "query_rsp", ZIGBEE_ZCL_IDENTIFY_OBJECT_PATH, - NULL, 0, _zbl_identify_query_cb, container, _zbl_request_cleanup); + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); - free(container); - return ZIGBEE_ERROR_IO_ERROR; - } - - container->cb = cb; - container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_identify_query, container); - container->userdata = user_data; - - g_dbus_proxy_call(zcl_identify_proxy, "query", g_variant_new("(qy)", addr16, dst_ep), - G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_add_group(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_group_add_group_rsp cb = NULL; - - DBG("_zbl_timeout_add_group()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_add_group_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_group_add_group_rsp cb = container->cb; - - nwk_addr addr16; - unsigned char ep; - unsigned char status; - unsigned short group_id; - - container->found = true; - - DBG("_zbl_add_group_cb"); + free(container); + return ZIGBEE_ERROR_IO_ERROR; + } - g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id); + container->cb = cb; + container->sid = sub_id; + container->cid = ZBL_ZCL_IDENTIFY_QUERY_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); + container->userdata = user_data; - if (cb) - cb(addr16, ep, status, group_id, container->userdata); + g_dbus_proxy_call(zcl_identify_proxy, "query", + g_variant_new("(qy)", addr16, dst_ep), + G_DBUS_CALL_FLAGS_NONE, to, NULL, NULL, container); - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return ZIGBEE_ERROR_NONE; } int zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, @@ -5967,7 +6111,7 @@ int zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, to = zbl_dbus_get_timeout(zcl_group_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_GROUP_INTERFACE, "add_group_rsp", ZIGBEE_ZCL_GROUP_OBJECT_PATH, - NULL, 0, _zbl_add_group_cb, container, _zbl_request_cleanup); + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -5977,7 +6121,8 @@ int zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_add_group, container); + container->cid = ZBL_ZCL_GROUP_ADD_GROUP_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; @@ -5987,6 +6132,7 @@ int zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, j++; } groupname_variant = g_variant_builder_end(groupname_builder); + g_variant_builder_unref(groupname_builder); g_dbus_proxy_call(zcl_group_proxy, "add_group", g_variant_new("(qyq@ay)", addr16, ep, group_id, groupname_variant), @@ -5995,91 +6141,6 @@ int zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_view_group(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_group_view_group_rsp cb = NULL; - - DBG("_zbl_timeout_view_group()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_view_group_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_group_view_group_rsp cb = container->cb; - - int j = 0; - nwk_addr addr16; - unsigned char ep; - unsigned char value; - unsigned char status; - unsigned short group_id; - char *group_name = NULL; - GVariantIter *grpNameiter; - - DBG("_zbl_view_group_cb"); - - g_variant_get(parameters, "(qyyqay)", &addr16, &ep, &status, &group_id, &grpNameiter); - g_variant_iter_loop(grpNameiter, "y", &value); - /* first byte indicates the length of the string */ - if ((value - '0') > 0) { - DBG("Value %d ", (value - '0')); - group_name = calloc((value - '0') + 1, sizeof(char)); - if (NULL == group_name) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - group_name[j] = value; - j++; - while (g_variant_iter_loop(grpNameiter, "y", &value) && (j <= (value - '0'))) { - group_name[j] = value; - DBG("Name %c", group_name[j]); - j++; - } - } else { - group_name = calloc(1, sizeof(char)); - if (NULL == group_name) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - group_name[j] = value; - j++; - group_name[j] = '\0'; - j++; - } - - DBG("GroupName = %s", group_name); - - container->found = true; - - if (cb) - cb(addr16, ep, status, group_id, group_name, container->userdata); -OUT: - if (group_name) - free(group_name); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_view_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, zb_zcl_group_view_group_rsp cb, void *user_data) { @@ -6097,7 +6158,7 @@ int zbl_view_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, to = zbl_dbus_get_timeout(zcl_group_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_GROUP_INTERFACE, "view_group_rsp", ZIGBEE_ZCL_GROUP_OBJECT_PATH, - NULL, 0, _zbl_view_group_cb, container, _zbl_request_cleanup); + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -6107,7 +6168,8 @@ int zbl_view_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_view_group, container); + container->cid = ZBL_ZCL_GROUP_VIEW_GROUP_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_group_proxy, "view_group", @@ -6117,71 +6179,6 @@ int zbl_view_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_get_group_membership(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_group_get_group_membership_rsp cb = NULL; - - DBG("_zbl_timeout_get_group_membership()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_group_get_group_membership_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_group_get_group_membership_rsp cb = container->cb; - - int j = 0; - nwk_addr addr16; - unsigned char ep; - unsigned short gl_value; - unsigned char capacity; - unsigned char group_count; - unsigned short *grouplist = NULL; - GVariantIter *grpListiter; - - DBG("_zbl_group_get_group_membership_cb"); - - - g_variant_get(parameters, "(qyyyaq)", &addr16, &ep, &capacity, &group_count, &grpListiter); - - if (group_count > 0) { - grouplist = calloc(group_count+1, sizeof(unsigned short)); - RETM_IF(NULL == grouplist, "calloc() Fail(%d)", errno); - while (g_variant_iter_loop(grpListiter, "q", &gl_value)) { - grouplist[j] = gl_value; - j++; - } - } - - container->found = true; - - if (cb) - cb(addr16, ep, capacity, group_count, grouplist, container->userdata); - - free(grouplist); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep, unsigned char group_count, unsigned short *group_list, zb_zcl_group_get_group_membership_rsp cb, void *user_data) @@ -6204,7 +6201,7 @@ int zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep, to = zbl_dbus_get_timeout(zcl_group_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_GROUP_INTERFACE, "get_group_membership_rsp", - ZIGBEE_ZCL_GROUP_OBJECT_PATH, NULL, 0, _zbl_group_get_group_membership_cb, + ZIGBEE_ZCL_GROUP_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -6215,7 +6212,8 @@ int zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_get_group_membership, container); + container->cid = ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; grouplist_builder = g_variant_builder_new(G_VARIANT_TYPE("aq")); @@ -6224,6 +6222,7 @@ int zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep, j++; } grouplist_variant = g_variant_builder_end(grouplist_builder); + g_variant_builder_unref(grouplist_builder); g_dbus_proxy_call(zcl_group_proxy, "get_group_membership", g_variant_new("(qyy@aq)", addr16, ep, group_count, grouplist_variant), @@ -6232,55 +6231,6 @@ int zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_remove_group(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_group_remove_group_rsp cb = NULL; - - DBG("_zbl_timeout_remove_group()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_remove_group_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_group_remove_group_rsp cb = container->cb; - - nwk_addr addr16; - unsigned char ep; - unsigned char status; - unsigned short group_id; - - container->found = true; - - DBG("_zbl_remove_group_cb"); - - g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id); - - if (cb) - cb(addr16, ep, status, group_id, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_remove_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, zb_zcl_group_remove_group_rsp cb, void *user_data) { @@ -6298,7 +6248,7 @@ int zbl_remove_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, to = zbl_dbus_get_timeout(zcl_group_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_GROUP_INTERFACE, "remove_group_rsp", ZIGBEE_ZCL_GROUP_OBJECT_PATH, - NULL, 0, _zbl_remove_group_cb, container, _zbl_request_cleanup); + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -6308,7 +6258,8 @@ int zbl_remove_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_remove_group, container); + container->cid = ZBL_ZCL_GROUP_REMOVE_GROUP_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_group_proxy, "remove_group", g_variant_new("(qyq)", @@ -6319,20 +6270,37 @@ int zbl_remove_group(nwk_addr addr16, unsigned char ep, unsigned short group_id, int zbl_remove_all_group(nwk_addr addr16, unsigned char ep) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_group_proxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_group_remove_all_group()"); - g_dbus_proxy_call(zcl_group_proxy, "remove_all_group", g_variant_new("(qy)", addr16, ep), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + variant = g_dbus_proxy_call_sync(zcl_group_proxy, "remove_all_group", + g_variant_new("(qy)", addr16, ep),G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get remove_all_group [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_add_group_if_identifying(nwk_addr addr16, unsigned char ep, unsigned short group_id, const char *group_name) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + int j = 0; GVariant *groupname_variant = NULL; GVariantBuilder *groupname_builder = NULL; @@ -6346,214 +6314,319 @@ int zbl_add_group_if_identifying(nwk_addr addr16, unsigned char ep, j++; } groupname_variant = g_variant_builder_end(groupname_builder); + g_variant_builder_unref(groupname_builder); - g_dbus_proxy_call(zcl_group_proxy, "add_group_if_identifying", + variant = g_dbus_proxy_call_sync(zcl_group_proxy, "add_group_if_identifying", g_variant_new("(qyq@ay)", addr16, ep, group_id, groupname_variant), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get add_group_if_identifying [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_level_control_move_to_level(nwk_addr addr16, unsigned char ep, unsigned char level, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_level_control_move_to_level()"); - g_dbus_proxy_call(level_control_gproxy, "move_to_level", + variant = g_dbus_proxy_call_sync(level_control_gproxy, "move_to_level", g_variant_new("(qyyq)", addr16, ep, level, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_to_level [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_level_control_move(nwk_addr addr16, unsigned char ep, unsigned char move_mode, unsigned char rate) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_level_control_move()"); - g_dbus_proxy_call(level_control_gproxy, "move", + variant = g_dbus_proxy_call_sync(level_control_gproxy, "move", g_variant_new("(qyyy)", addr16, ep, move_mode, rate), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_level_control_step(nwk_addr addr16, unsigned char ep, unsigned char step_mode, unsigned char step_size, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_level_control_step()"); - g_dbus_proxy_call(level_control_gproxy, "step", + variant = g_dbus_proxy_call_sync(level_control_gproxy, "step", g_variant_new("(qyyyq)", addr16, ep, step_mode, step_size, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get step [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_level_control_stop(nwk_addr addr16, unsigned char ep) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_level_control_stop()"); - g_dbus_proxy_call(level_control_gproxy, "stop", - g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + variant = g_dbus_proxy_call_sync(level_control_gproxy, "stop", + g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get stop [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_level_control_move_to_level_with_on_off(nwk_addr addr16, unsigned char ep, unsigned char level, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_level_control_move_to_level_with_on_off()"); - g_dbus_proxy_call(level_control_gproxy, "move_to_level_with_on_off", + variant = g_dbus_proxy_call_sync(level_control_gproxy, "move_to_level_with_on_off", g_variant_new("(qyyq)", addr16, ep, level, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_to_level_with_on_off [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_level_control_move_with_on_off(nwk_addr addr16, unsigned char ep, unsigned char move_mode, unsigned char rate) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_level_control_move_with_on_off()"); - g_dbus_proxy_call(level_control_gproxy, "move_with_on_off", + variant = g_dbus_proxy_call_sync(level_control_gproxy, "move_with_on_off", g_variant_new("(qyyy)", addr16, ep, move_mode, rate), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get move_with_on_off [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_level_control_step_with_on_off(nwk_addr addr16, unsigned char ep, unsigned char step_mode, unsigned char step_size, unsigned short transition_time) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR); DBG("zbl_level_control_step_with_on_off()"); - g_dbus_proxy_call(level_control_gproxy, "step_with_on_off", + variant = g_dbus_proxy_call_sync(level_control_gproxy, "step_with_on_off", g_variant_new("(qyyyq)", addr16, ep, step_mode, step_size, transition_time), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get step_with_on_off [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_onoff_set(nwk_addr addr16, unsigned char ep, unsigned char on_off_type) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == on_off_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(on_off_gproxy, "set_on_off", + variant = g_dbus_proxy_call_sync(on_off_gproxy, "set_on_off", g_variant_new("(qyy)", addr16, ep, on_off_type), G_DBUS_CALL_FLAGS_NONE, - -1, NULL, NULL, NULL); + -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get set_on_off [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_zone_enroll_response(nwk_addr addr16, unsigned char dst_ep, unsigned char enroll_response_code, unsigned char zone_id) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_ias_zone_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_ias_zone_proxy, "enroll_response", + variant = g_dbus_proxy_call_sync(zcl_ias_zone_proxy, "enroll_response", g_variant_new("(qyyy)", addr16, dst_ep, enroll_response_code, zone_id), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get enroll_response [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_pollcontrol_check_in_response(nwk_addr addr16, unsigned char ep, unsigned char start_fast_polling, unsigned short fast_poll_timeout) { - RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); - RETV_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR); - - g_dbus_proxy_call(zcl_poll_control_proxy, "check_in_response", - g_variant_new("(qyyq)", addr16, ep, start_fast_polling, fast_poll_timeout), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); - - return ZIGBEE_ERROR_NONE; -} - -int zbl_pollcontrol_fast_poll_stop(nwk_addr addr16, unsigned char ep) -{ - RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); - RETV_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR); - - g_dbus_proxy_call(zcl_poll_control_proxy, "fast_poll_stop", - g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_set_long_poll_interval(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_pollctrl_check_in cb = NULL; - - DBG("_zbl_timeout_set_long_poll_interval()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, container->userdata); + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; - container->tid = 0; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); + RETV_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; + variant = g_dbus_proxy_call_sync(zcl_poll_control_proxy, "check_in_response", + g_variant_new("(qyyq)", addr16, ep, start_fast_polling, fast_poll_timeout), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get check_in_response [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return G_SOURCE_REMOVE; + return result; } -static void _zbl_set_long_poll_interval_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) +int zbl_pollcontrol_fast_poll_stop(nwk_addr addr16, unsigned char ep) { - zbl_req_cb_s *container = user_data; - zb_zcl_pollctrl_check_in cb = container->cb; - - nwk_addr addr16 = 0; - unsigned char ep = 0; - - container->found = true; - - DBG("_zbl_set_long_poll_interval_cb"); + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; - g_variant_get(parameters, "(qy)", &addr16, &ep); + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); + RETV_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR); - if (cb) - cb(addr16, ep, container->userdata); + variant = g_dbus_proxy_call_sync(zcl_poll_control_proxy, "fast_poll_stop", + g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get fast_poll_stop [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return result; } int zbl_pollcontrol_set_long_poll_interval(nwk_addr addr16, unsigned char ep, @@ -6574,7 +6647,7 @@ int zbl_pollcontrol_set_long_poll_interval(nwk_addr addr16, unsigned char ep, sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_POLL_CONTROL_INTERFACE, "checkin_response", ZIGBEE_ZCL_POLL_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_set_long_poll_interval_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -6584,7 +6657,8 @@ int zbl_pollcontrol_set_long_poll_interval(nwk_addr addr16, unsigned char ep, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_set_long_poll_interval, container); + container->cid = ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_poll_control_proxy, "set_long_poll_interval", @@ -6612,7 +6686,7 @@ int zbl_pollcontrol_set_short_poll_interval(nwk_addr addr16, unsigned char ep, sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_POLL_CONTROL_INTERFACE, "checkin_response", ZIGBEE_ZCL_POLL_CONTROL_OBJECT_PATH, NULL, 0, - _zbl_set_long_poll_interval_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -6622,7 +6696,8 @@ int zbl_pollcontrol_set_short_poll_interval(nwk_addr addr16, unsigned char ep, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_set_long_poll_interval, container); + container->cid = ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_poll_control_proxy, "set_short_poll_interval", @@ -6632,56 +6707,6 @@ int zbl_pollcontrol_set_short_poll_interval(nwk_addr addr16, unsigned char ep, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_add_scene(gpointer p) -{ - zbl_req_cb_s *container = p; - zb_zcl_scene_add_scene_rsp cb = container->cb; - - DBG("_zbl_timeout_add_scene()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_add_scene_cb(GDBusConnection *connection, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_scene_add_scene_rsp cb = container->cb; - - nwk_addr addr16 = 0; - unsigned char ep; - unsigned char status; - unsigned short group_id; - unsigned char scene_id; - - container->found = true; - - DBG("_zbl_add_scene_cb"); - - g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status, &group_id, &scene_id); - - if (cb) - cb(addr16, ep, status, group_id, scene_id, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id, unsigned short transition_time, const char *scene_name, unsigned short ext_field_len, const char *extension_field_sets, @@ -6708,7 +6733,7 @@ int zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, to = zbl_dbus_get_timeout(zcl_scene_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_SCENE_INTERFACE, "add_scene_rsp", ZIGBEE_ZCL_SCENE_OBJECT_PATH, NULL, 0, - _zbl_add_scene_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -6718,7 +6743,8 @@ int zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_add_scene, container); + container->cid = ZBL_ZCL_SCENE_ADD_SCENE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; scenename_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); @@ -6727,6 +6753,8 @@ int zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, j++; } scenename_variant = g_variant_builder_end(scenename_builder); + g_variant_builder_unref(scenename_builder); + extensionfieldSet_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); while (index < ext_field_len) { @@ -6735,6 +6763,7 @@ int zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, index++; } extensionfieldSet_variant = g_variant_builder_end(extensionfieldSet_builder); + g_variant_builder_unref(extensionfieldSet_builder); g_dbus_proxy_call(zcl_scene_proxy, "add_scene", g_variant_new("(qyqyqq@ay@ay)", addr16, ep, group_id, scene_id, transition_time, @@ -6744,112 +6773,6 @@ int zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_view_scene(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_scene_view_scene_rsp cb = NULL; - - DBG("_zbl_timeout_view_scene()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, 0, 0, NULL, NULL, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_view_scene_cb(GDBusConnection *connection, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_scene_view_scene_rsp cb = container->cb; - - int j = 0; - int len; - nwk_addr addr16 = 0; - unsigned char ep; - unsigned char status; - unsigned short group_id; - unsigned char scene_id; - unsigned short transition_time = 0; - unsigned char value; - unsigned short ext_len = 0; - char *scene_name = NULL; - char *extendedFieldSets = NULL; - GVariantIter *sceneNameIter = NULL; - GVariantIter *extendedSetIter = NULL; - - DBG("_zbl_view_scene_cb"); - - g_variant_get(parameters, "(qyyqyqayyay)", &addr16, &ep, &status, &group_id, &scene_id, - &transition_time, &sceneNameIter, &ext_len, &extendedSetIter); - - g_variant_iter_loop(sceneNameIter, "y", &value); - - /** first byte indicates the length of the string */ - len = value -'0'; - if (0 < len) { - scene_name = calloc(len + 1, sizeof(char)); - if (NULL == scene_name) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - scene_name[j] = value; - j++; - while (g_variant_iter_loop(sceneNameIter, "y", &value)) { - scene_name[j] = value; - j++; - } - } else { - scene_name = calloc(1 + 1, sizeof(char)); - if (NULL == scene_name) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - scene_name[j] = value; - } - - j = 0; - if (0 < ext_len) { - extendedFieldSets = calloc(ext_len + 1, sizeof(char)); - if (NULL == extendedFieldSets) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - while (g_variant_iter_loop(extendedSetIter, "y", &value)) { - extendedFieldSets[j] = value; - j++; - } - } - - container->found = true; - - if (cb) - cb(addr16, ep, status, group_id, scene_id, transition_time, scene_name, - extendedFieldSets, ext_len, container->userdata); - -OUT: - if (scene_name) - free(scene_name); - - if (extendedFieldSets) - free(extendedFieldSets); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_view_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id, zb_zcl_scene_view_scene_rsp cb, void *user_data) { @@ -6867,7 +6790,7 @@ int zbl_view_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, to = zbl_dbus_get_timeout(zcl_scene_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_SCENE_INTERFACE, "view_scene_rsp", ZIGBEE_ZCL_SCENE_OBJECT_PATH, NULL, 0, - _zbl_view_scene_cb, container, _zbl_request_cleanup); + _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -6877,7 +6800,8 @@ int zbl_view_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_view_scene, container); + container->cid = ZBL_ZCL_SCENE_VIEW_SCENE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_scene_proxy, "view_scene", @@ -6887,56 +6811,6 @@ int zbl_view_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_remove_scene(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_scene_remove_scene_rsp cb = NULL; - - DBG("_zbl_timeout_remove_scene()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_remove_scene_cb(GDBusConnection *connection, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_scene_remove_scene_rsp cb = container->cb; - - nwk_addr addr16 = 0; - unsigned char ep; - unsigned char status; - unsigned short group_id; - unsigned char scene_id; - - container->found = true; - - DBG("_zbl_remove_scene_cb"); - - g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status, &group_id, &scene_id); - - if (cb) - cb(addr16, ep, status, group_id, scene_id, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_remove_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id, zb_zcl_scene_remove_scene_rsp cb, void *user_data) @@ -6955,7 +6829,7 @@ int zbl_remove_scene(nwk_addr addr16, unsigned char ep, to = zbl_dbus_get_timeout(zcl_scene_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_SCENE_INTERFACE, "remove_scene_rsp", ZIGBEE_ZCL_SCENE_OBJECT_PATH, - NULL, 0, _zbl_remove_scene_cb, container, _zbl_request_cleanup); + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -6965,7 +6839,8 @@ int zbl_remove_scene(nwk_addr addr16, unsigned char ep, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_remove_scene, container); + container->cid = ZBL_ZCL_SCENE_REMOVE_SCENE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_scene_proxy, "remove_scene", @@ -6975,55 +6850,6 @@ int zbl_remove_scene(nwk_addr addr16, unsigned char ep, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_remove_all_scene(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_scene_remove_all_scene_rsp cb = NULL; - - DBG("_zbl_timeout_remove_all_scene()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_remove_all_scene_cb(GDBusConnection *connection, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_scene_remove_all_scene_rsp cb = container->cb; - - nwk_addr addr16 = 0; - unsigned char ep; - unsigned char status; - unsigned short group_id; - - container->found = true; - - DBG("_zbl_remove_all_scene_cb"); - - g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id); - - if (cb) - cb(addr16, ep, status, group_id, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_remove_all_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, zb_zcl_scene_remove_all_scene_rsp cb, void *user_data) { @@ -7041,7 +6867,7 @@ int zbl_remove_all_scene(nwk_addr addr16, unsigned char ep, to = zbl_dbus_get_timeout(zcl_scene_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_SCENE_INTERFACE, "remove_all_scene_rsp", - ZIGBEE_ZCL_SCENE_OBJECT_PATH, NULL, 0, _zbl_remove_all_scene_cb, container, + ZIGBEE_ZCL_SCENE_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -7052,7 +6878,8 @@ int zbl_remove_all_scene(nwk_addr addr16, unsigned char ep, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_remove_all_scene, container); + container->cid = ZBL_ZCL_SCENE_REMOVE_ALL_SCENE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_scene_proxy, "remove_all_scene", @@ -7062,59 +6889,12 @@ int zbl_remove_all_scene(nwk_addr addr16, unsigned char ep, return ZIGBEE_ERROR_NONE; } -static gboolean _zbl_timeout_scene_store_scene(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_scene_store_scene_rsp cb = NULL; - - DBG("_zbl_timeout_scene_store_scene()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, 0, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_scene_store_scene_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_scene_store_scene_rsp cb = container->cb; - - nwk_addr addr16 = 0; - unsigned char ep; - unsigned char status; - unsigned short group_id; - unsigned char scene_id; - - container->found = true; - - DBG("_zbl_scene_store_scene_cb"); - - g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status, &group_id, &scene_id); - - if (cb) - cb(addr16, ep, status, group_id, scene_id, container->userdata); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); -} - int zbl_store_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id, zb_zcl_scene_store_scene_rsp cb, void *user_data) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + int sub_id, to; zbl_req_cb_s *container; @@ -7129,7 +6909,7 @@ int zbl_store_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, to = zbl_dbus_get_timeout(zcl_scene_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_SCENE_INTERFACE, "store_scene_rsp", ZIGBEE_ZCL_SCENE_OBJECT_PATH, - NULL, 0, _zbl_scene_store_scene_cb, container, _zbl_request_cleanup); + NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { ERR("g_dbus_connection_signal_subscribe() Fail"); @@ -7139,7 +6919,8 @@ int zbl_store_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_scene_store_scene, container); + container->cid = ZBL_ZCL_SCENE_STORE_SCENE_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_scene_proxy, "store_scene", @@ -7152,87 +6933,27 @@ int zbl_store_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, int zbl_recall_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id, unsigned char scene_id) { + int result = ZIGBEE_ERROR_NONE; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(zcl_scene_proxy, "recall_scene", + variant = g_dbus_proxy_call_sync(zcl_scene_proxy, "recall_scene", g_variant_new("(qyqy)", addr16, ep, group_id, scene_id), G_DBUS_CALL_FLAGS_NONE, - -1, NULL, NULL, NULL); - - return ZIGBEE_ERROR_NONE; -} - -static gboolean _zbl_timeout_get_scene_membership(gpointer p) -{ - zbl_req_cb_s *container = NULL; - zb_zcl_scene_get_scene_membership_rsp cb = NULL; - - DBG("_zbl_timeout_get_scene_membership()"); - - RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL"); - container = p; - RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL"); - cb = container->cb; - - if (false == container->found && container->cb) - cb(0, 0, 0, 0, 0, 0, NULL, container->userdata); - - container->tid = 0; - - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); - DBG("container->sid=%d unsubscribed"); - container->sid = 0; - - return G_SOURCE_REMOVE; -} - -static void _zbl_get_scene_membership_cb(GDBusConnection *connection, - const gchar *sender_name, const gchar *object_path, const gchar *interface_name, - const gchar *signal_name, GVariant *parameters, gpointer user_data) -{ - zbl_req_cb_s *container = user_data; - zb_zcl_scene_get_scene_membership_rsp cb = container->cb; - - int j = 0; - nwk_addr addr16 = 0; - unsigned char ep; - unsigned char status; - unsigned short group_id; - unsigned char capacity; - unsigned char value; - unsigned char scene_count = 0; - unsigned char *scene_list = NULL; - GVariantIter *sceneListIter = NULL; - - DBG("_zbl_get_scene_membership_cb"); - - g_variant_get(parameters, "(qyyyqyay)", &addr16, &ep, &status, &capacity, &group_id, - &scene_count, &sceneListIter); - - if (0 < scene_count) { - scene_list = calloc(scene_count+1, sizeof(char)); - if (NULL == scene_list) { - ERR("calloc() Fail(%d)", errno); - goto OUT; - } - while (g_variant_iter_loop(sceneListIter, "y", &value)) { - scene_list[j] = value; - DBG("Scene_List 0x%02X", scene_list[j]); - j++; - } + -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get recall_scene [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; } - container->found = true; - - if (cb) - cb(addr16, ep, status, capacity, group_id, scene_count, scene_list, container->userdata); - -OUT: - if (scene_list) - free(scene_list); - - if (container->sid) - g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid); + return result; } int zbl_get_scene_membership(nwk_addr addr16, unsigned char ep, @@ -7252,7 +6973,7 @@ int zbl_get_scene_membership(nwk_addr addr16, unsigned char ep, to = zbl_dbus_get_timeout(zcl_scene_proxy); sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL, ZIGBEE_ZCL_SCENE_INTERFACE, "get_scene_membership_rsp", - ZIGBEE_ZCL_SCENE_OBJECT_PATH, NULL, 0, _zbl_get_scene_membership_cb, container, + ZIGBEE_ZCL_SCENE_OBJECT_PATH, NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup); if (0 == sub_id) { @@ -7263,7 +6984,8 @@ int zbl_get_scene_membership(nwk_addr addr16, unsigned char ep, container->cb = cb; container->sid = sub_id; - container->tid = g_timeout_add_seconds(to, _zbl_timeout_get_scene_membership, container); + container->cid = ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ; + container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container); container->userdata = user_data; g_dbus_proxy_call(zcl_scene_proxy, "get_scene_membership", @@ -7276,14 +6998,27 @@ int zbl_get_scene_membership(nwk_addr addr16, unsigned char ep, int zbl_thermostat_adjust_setpoint(nwk_addr addr16, unsigned char ep, unsigned char mode, unsigned char amount) { + int result = ZIGBEE_ERROR_IO_ERROR; + GVariant *variant = NULL; + GError *dbus_err = NULL; + RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR); RETV_IF(NULL == thermostat_gproxy, ZIGBEE_ERROR_IO_ERROR); - g_dbus_proxy_call(thermostat_gproxy, "setpoint_raise_lower", + variant = g_dbus_proxy_call_sync(thermostat_gproxy, "setpoint_raise_lower", g_variant_new("(qyyy)", addr16, ep, mode, amount), - G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL); + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err); + if (variant) { + g_variant_get(variant, "(i)", &result); + DBG("ret = [0x%x]", result); + g_variant_unref(variant); + } else { + ERR("Failed to get setpoint_raise_lower [%s]", dbus_err->message); + g_error_free(dbus_err); + return ZIGBEE_ERROR_IO_ERROR; + } - return ZIGBEE_ERROR_NONE; + return result; } int zbl_dbus_start(zigbee_h handle) diff --git a/lib/zbl-dbus.h b/lib/zbl-dbus.h index 7c8b945..9184420 100644 --- a/lib/zbl-dbus.h +++ b/lib/zbl-dbus.h @@ -26,8 +26,7 @@ int zbl_dbus_start(zigbee_h handle); void zbl_dbus_stop(void); GDBusConnection* zbl_dbus_get_object(void); int zbl_dbus_get_timeout(GDBusProxy *proxy); -int zbl_enable(zigbee_h handle, zb_enable_cb cb, void *user_data); -int zbl_set_event_cb(zigbee_h handle, zb_event_cb event_handler); +int zbl_enable(zigbee_h handle, zb_event_cb event_handler); int zbl_disable(void); int zbl_hw_reset(void); int zbl_coex_start(unsigned char channel); diff --git a/lib/zbl.c b/lib/zbl.c index e056467..b9b0f8a 100644 --- a/lib/zbl.c +++ b/lib/zbl.c @@ -51,24 +51,15 @@ API void zb_destroy(zigbee_h handle) zbl_dbus_stop(); } -API int zb_enable(zigbee_h handle, zb_enable_cb cb, void *user_data) +API int zb_enable(zigbee_h handle, zb_event_cb event_handler) { int ret = ZIGBEE_ERROR_NONE; RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER); - ret = zbl_enable(handle, cb, user_data); + ret = zbl_enable(handle, event_handler); DBG("zbl_enable()=0x%X", ret); return ret; } -API int zb_set_event_cb(zigbee_h handle, zb_event_cb event_handler) -{ - int ret = ZIGBEE_ERROR_NONE; - RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER); - ret = zbl_set_event_cb(handle, event_handler); - DBG("zb_set_event_cb()=0x%X", ret); - return ret; -} - API int zb_disable(zigbee_h handle) { int ret = ZIGBEE_ERROR_NONE; diff --git a/test/main.c b/test/main.c index efd0b52..3a4b147 100644 --- a/test/main.c +++ b/test/main.c @@ -240,11 +240,6 @@ static void _init_endpoints() huebulb_ep1.out_clusters[0] = ZB_ZCL_OTA_BOOTLOAD_CLUSTER_ID; } -static void zigbee_enable_cb(unsigned char ret, void *user_data) -{ - msgp("enable result received = 0x%02X\n", ret); -} - static void zigbee_form_network_done_cb(nwk_addr panid, void *user_data) { msgp("form_network_done received PANID = 0x%04X\n", panid); @@ -493,18 +488,12 @@ static int run_enable(MManager *mm, struct menu_data *menu) /* Register event callback */ int ret = ZIGBEE_ERROR_NONE; - ret = zb_enable(handle, zigbee_enable_cb, NULL); + ret = zb_enable(handle, zigbee_event_cb); if (ZIGBEE_ERROR_NONE != ret) { msg("zb_enable(0x%X) - FAILED!!!", ret); return RET_FAILURE; } - ret = zb_set_event_cb(handle, zigbee_event_cb); - if (ZIGBEE_ERROR_NONE != ret) { - msg("zb_set_event_cb(0x%X) - FAILED!!!", ret); - return RET_FAILURE; - } - msg(" - zb_enable() ret: [0x%X]", ret); return RET_SUCCESS; @@ -910,7 +899,7 @@ static int __select_handle_register_event(MManager *mm, struct menu_data *menu) msg("zb_create(%d) - SUCCESS!!!. handle [%p]", ret, handle); } - ret = zb_enable(&handle, zigbee_event_cb, NULL); + ret = zb_enable(&handle, zigbee_event_cb); if (ZIGBEE_ERROR_NONE != ret) { msg("zb_enable(%d) - FAILED!!!.", ret); return RET_FAILURE; @@ -918,17 +907,6 @@ static int __select_handle_register_event(MManager *mm, struct menu_data *menu) msg("zb_enable(%d) - SUCCESS!!!. handle [%p]", ret, handle); } - msg("zigbee_disable_network_done_cb = %x", zigbee_disable_network_done_cb); - - - /* Register event callback */ - ret = zb_set_event_cb(handle, zigbee_event_cb); - if (ZIGBEE_ERROR_NONE != ret) { - msg("zb_set_event_cb(0x%X) - FAILED!!!", ret); - return RET_FAILURE; - } - msg("zb_set_event_cb(%d) - SUCCESS!!!. handle [%p]", ret, handle); - menu_manager_set_user_data(mm, handle); return RET_SUCCESS; diff --git a/test/test-zigbee.c b/test/test-zigbee.c index a76ca24..675b0cc 100644 --- a/test/test-zigbee.c +++ b/test/test-zigbee.c @@ -1572,8 +1572,7 @@ void process_input(const char *input, gpointer user_data) printf("zb_create ret=[0x%x]\n", (int)handle); break; case CMD_ENABLE: - ret = zb_enable(handle, zigbee_enable_cb, NULL); - ret = zb_set_event_cb(handle, zigbee_event_cb); + ret = zb_enable(handle, zigbee_event_cb); printf("zb_enable ret=[0x%x]\n", ret); break; case CMD_GET_NETWORK_INFO: -- 2.34.1