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;
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;
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));
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));
} 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);
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));
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;
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;
}
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) {
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:
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:
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++;
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;
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;
}
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;
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);
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);
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;
}
GVariantBuilder *mac_builder = NULL;
GVariant *mac_variant = NULL;
GVariantIter *iter = NULL;
+ GError *dbus_err = NULL;
unsigned short cluster;
int i = 0;
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);
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;
}
GVariantBuilder *mac_builder = NULL;
GVariant *mac_variant = NULL;
GVariantIter *iter = NULL;
+ GError *dbus_err = NULL;
unsigned char endpoint;
int i = 0;
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);
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);
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;
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};
/* 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);
for (j = 0; j < i; j++)
free(list[j]);
free(list);
+ g_variant_unref(variant);
return ZIGBEE_ERROR_OUT_OF_MEMORY;
}
}
*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;
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;
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");
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,
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;
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");
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,
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;
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,
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) {
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"));
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),
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");
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)
{
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");
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)
{
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");
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;
}
}
#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,
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");
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;
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");
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)
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");
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;
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");
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
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");
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"));
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;
}
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;
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,
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);
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"));
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) {
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,
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,
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);
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"));
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) {
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,
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;
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) {
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",
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,
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) {
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)
{
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) {
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)
{
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) {
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)
{
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) {
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"));
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),
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)
{
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,
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");
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"));
}
}
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,
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,
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");
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"));
}
}
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,
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)
{
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");
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"));
}
}
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),
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)
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) {
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));
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)
}
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) {
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) {
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));
}
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) {
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) {
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));
_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);
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);
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,
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) {
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));
}
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,
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,
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) {
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));
}
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,
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,
{
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
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");
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));
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,
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) {
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));
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;
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) {
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));
_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;
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) {
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));
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,
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");
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,
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,
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");
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;
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),
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)
{
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");
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",
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)
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) {
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"));
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),
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)
{
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");
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)",
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;
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,
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");
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",
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");
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",
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,
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");
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"));
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) {
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,
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)
{
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");
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",
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)
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");
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",
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)
{
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) {
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",
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;
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");
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",
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,
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) {
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",
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)
projects / platform / core / api / zigbee.git / commitdiff