return G_SOURCE_REMOVE;
}
-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)
+static void __zbl_service_from_network(zbl_req_cb_s *container, GVariant *parameters)
{
- zbl_req_cb_s *container = user_data;
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);
+ zb_form_network_cb cb = container->cb;
+ zb_nwk_addr panid;
+ g_variant_get(parameters, "(q)", &panid);
+ cb(panid, container->userdata);
- switch (container->cid) {
- /* Service */
- case ZBL_SERVICE_FORM_NETWORK: {
- zb_form_network_cb cb = container->cb;
- zb_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_STATUS_SUCCESS;
- g_variant_get(parameters, "(y)", &ret);
- cb(ret, container->userdata);
- }
- break;
- /* ZDO except Bind */
- case ZBL_ZDO_NWK_ADDR_REQ: {
- zb_zdo_addr_cb cb = container->cb;
+}
- int j = 0;
- zb_nwk_addr addr16;
- zb_ieee_addr addr64;
- unsigned char status;
- unsigned char num;
- unsigned char start_idx;
- unsigned char value;
- GVariantIter *mac_iter = NULL;
+static void __zbl_service_disable_network(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- g_variant_get(parameters, "(ya(y)qyy)", &status, &mac_iter, &addr16, &num, &start_idx);
- RETM_IF(NULL == mac_iter, "Invalid parameter !");
+ zb_disable_network_cb cb = container->cb;
+ unsigned char ret = ZB_ZDP_STATUS_SUCCESS;
+ g_variant_get(parameters, "(y)", &ret);
+ cb(ret, container->userdata);
- while (g_variant_iter_loop(mac_iter, "(y)", &value)) {
- addr64[j] = value;
- j++;
- }
- g_variant_iter_free(mac_iter);
+}
+
+static void __zbl_zdo_nwk_addr_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zdo_addr_cb cb = container->cb;
+
+ int j = 0;
+ zb_nwk_addr addr16;
+ zb_ieee_addr addr64;
+ unsigned char status;
+ unsigned char num;
+ unsigned char start_idx;
+ unsigned char value;
+ GVariantIter *mac_iter = NULL;
- cb(status, addr64, addr16, num, start_idx, NULL, container->userdata);
+ g_variant_get(parameters, "(ya(y)qyy)", &status, &mac_iter, &addr16, &num, &start_idx);
+ RETM_IF(NULL == mac_iter, "Invalid parameter !");
+
+ while (g_variant_iter_loop(mac_iter, "(y)", &value)) {
+ addr64[j] = value;
+ j++;
}
- break;
- case ZBL_ZDO_NWK_ADDR_EXT_REQ: {
- zb_zdo_addr_cb cb = container->cb;
+ g_variant_iter_free(mac_iter);
- int j = 0;
- zb_nwk_addr addr16;
- zb_ieee_addr addr64;
- unsigned char status;
- unsigned char num;
- unsigned char start_idx;
- unsigned char value;
- GVariantIter *mac_iter = NULL;
- GVariantIter *assoc_iter = NULL;
+ cb(status, addr64, addr16, num, start_idx, NULL, container->userdata);
- g_variant_get(parameters, "(ya(y)qyyaq)", &status, &mac_iter,
- &addr16, &num, &start_idx, &assoc_iter);
- RETM_IF(NULL == mac_iter, "Invalid parameter !");
+}
- while (g_variant_iter_loop(mac_iter, "(y)", &value)) {
- addr64[j] = value;
- j++;
- }
- g_variant_iter_free(mac_iter);
- if (NULL != assoc_iter)
- g_variant_iter_free(assoc_iter);
+static void __zbl_zdo_nwk_addr_ext_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zdo_addr_cb cb = container->cb;
+
+ int j = 0;
+ zb_nwk_addr addr16;
+ zb_ieee_addr addr64;
+ unsigned char status;
+ unsigned char num;
+ unsigned char start_idx;
+ unsigned char value;
+ GVariantIter *mac_iter = NULL;
+ GVariantIter *assoc_iter = NULL;
- cb(status, addr64, addr16, num, start_idx, NULL, container->userdata);
+ g_variant_get(parameters, "(ya(y)qyyaq)", &status, &mac_iter,
+ &addr16, &num, &start_idx, &assoc_iter);
+ RETM_IF(NULL == mac_iter, "Invalid parameter !");
+
+ while (g_variant_iter_loop(mac_iter, "(y)", &value)) {
+ addr64[j] = value;
+ j++;
}
- break;
- case ZBL_ZDO_ACTIVE_EP_REQ: {
- zb_zdo_active_ep_cb cb = container->cb;
+ g_variant_iter_free(mac_iter);
+ if (NULL != assoc_iter)
+ g_variant_iter_free(assoc_iter);
- int j = 0;
- zb_nwk_addr addr16;
- unsigned char status;
- unsigned char count;
- unsigned char value;
- GVariantIter *ep_iter = NULL;
- unsigned char *ep_list;
+ cb(status, addr64, addr16, num, start_idx, NULL, container->userdata);
+
+}
+
+static void __zbl_zdo_active_ep_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- g_variant_get(parameters, "(yqa(y)y)", &status, &addr16, &ep_iter, &count);
- RETM_IF(NULL == ep_iter, "Invalid parameter !");
+ zb_zdo_active_ep_cb cb = container->cb;
- ep_list = calloc(count+1, sizeof(unsigned char));
- RETM_IF(NULL == ep_list, "calloc() Fail(%d)", errno);
+ int j = 0;
+ zb_nwk_addr addr16;
+ unsigned char status;
+ unsigned char count;
+ unsigned char value;
+ GVariantIter *ep_iter = NULL;
+ unsigned char *ep_list;
- while (g_variant_iter_loop(ep_iter, "(y)", &value)) {
- ep_list[j] = value;
- j++;
- }
- g_variant_iter_free(ep_iter);
+ g_variant_get(parameters, "(yqa(y)y)", &status, &addr16, &ep_iter, &count);
+ RETM_IF(NULL == ep_iter, "Invalid parameter !");
- cb(status, addr16, count, ep_list, container->userdata);
+ ep_list = calloc(count+1, sizeof(unsigned char));
+ RETM_IF(NULL == ep_list, "calloc() Fail(%d)", errno);
- if (ep_list) {
- free(ep_list);
- ep_list = NULL;
- }
+ while (g_variant_iter_loop(ep_iter, "(y)", &value)) {
+ ep_list[j] = value;
+ j++;
}
- break;
- case ZBL_ZDO_SIMPLE_DESC_REQ: {
- zb_zdo_simple_desc_cb cb = container->cb;
+ g_variant_iter_free(ep_iter);
- int j = 0;
- int count;
- unsigned short addr16;
- unsigned short value;
- GVariantIter *in_iter = NULL;
- GVariantIter *out_iter = NULL;
- struct zb_zdo_simple_desc_s * records;
-
- records = calloc(1, sizeof(struct zb_zdo_simple_desc_s));
- RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
+ cb(status, addr16, count, ep_list, container->userdata);
- container->found = true;
+ if (ep_list) {
+ free(ep_list);
+ ep_list = NULL;
+ }
- g_variant_get(parameters, "(qiyyqqyyaqaq)", &addr16, &count,
- &records->device_ver,
- &records->ep, &records->profileid, &records->deviceid,
- &records->num_of_in_clusters, &records->num_of_out_clusters,
- &in_iter, &out_iter);
- if (NULL == in_iter || NULL == out_iter) {
- ERR("Invalid parameter !");
- free(records);
- return;
- }
+}
+
+static void __zbl_zdo_simple_desc_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zdo_simple_desc_cb cb = container->cb;
+
+ int j = 0;
+ int count;
+ unsigned short addr16;
+ unsigned short value;
+ GVariantIter *in_iter = NULL;
+ GVariantIter *out_iter = NULL;
+ struct zb_zdo_simple_desc_s * 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->profileid, &records->deviceid,
+ &records->num_of_in_clusters, &records->num_of_out_clusters,
+ &in_iter, &out_iter);
+ if (NULL == in_iter || NULL == out_iter) {
+ ERR("Invalid parameter !");
+ free(records);
+ return;
+ }
#if 0
- records->in_clusters = calloc(records->num_of_in_clusters, sizeof(unsigned short));
- if (NULL == records->in_clusters) {
- ERR("calloc() Fail(%d)", errno);
- g_variant_iter_free(in_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);
- g_variant_iter_free(in_iter);
- g_variant_iter_free(out_iter);
- return;
- }
-#endif
- while (g_variant_iter_loop(in_iter, "q", &value)) {
- records->in_clusters[j] = value;
- j++;
- }
+ records->in_clusters = calloc(records->num_of_in_clusters, sizeof(unsigned short));
+ if (NULL == records->in_clusters) {
+ ERR("calloc() Fail(%d)", errno);
g_variant_iter_free(in_iter);
-
- j = 0;
- while (g_variant_iter_loop(out_iter, "q", &value)) {
- records->out_clusters[j] = value;
- j++;
- }
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);
+ g_variant_iter_free(in_iter);
+ g_variant_iter_free(out_iter);
+ return;
+ }
+#endif
+ while (g_variant_iter_loop(in_iter, "q", &value)) {
+ records->in_clusters[j] = value;
+ j++;
+ }
+ g_variant_iter_free(in_iter);
- DBG("addr16=0x%x, count=%d, records->ep=%d, records->deviceid=0x%x",
- addr16, count, records->ep, records->deviceid);
- 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]);
+ j = 0;
+ while (g_variant_iter_loop(out_iter, "q", &value)) {
+ records->out_clusters[j] = value;
+ j++;
+ }
+ g_variant_iter_free(out_iter);
- cb(addr16, count, records, container->userdata);
+ DBG("addr16=0x%x, count=%d, records->ep=%d, records->deviceid=0x%x",
+ addr16, count, records->ep, records->deviceid);
+ 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 (records) {
- free(records);
- records = NULL;
- }
+ cb(addr16, count, records, container->userdata);
+
+ if (records) {
+ free(records);
+ records = NULL;
}
- break;
- case ZBL_ZDO_MATCHED_DESCRIPTOR_REQ: {
- zb_zdo_match_desc_cb cb = container->cb;
+}
- int j = 0;
- int match_len;
- zb_nwk_addr addr16;
- unsigned char value;
- unsigned char status;
- GVariantIter *ml_iter = NULL;
- unsigned char *match_list = NULL;
- g_variant_get(parameters, "(yqya(y))", &status, &addr16, &value, &ml_iter);
- match_len = value;
-
- RETM_IF(NULL == ml_iter, "Invalid parameter !");
-
- 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++;
- }
+static void __zbl_zdo_matched_descriptor_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zdo_match_desc_cb cb = container->cb;
+
+ int j = 0;
+ int match_len;
+ zb_nwk_addr addr16;
+ unsigned char value;
+ unsigned char status;
+ GVariantIter *ml_iter = NULL;
+ unsigned char *match_list = NULL;
+ g_variant_get(parameters, "(yqya(y))", &status, &addr16, &value, &ml_iter);
+ match_len = value;
+
+ RETM_IF(NULL == ml_iter, "Invalid parameter !");
+
+ 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++;
}
+ }
- DBG("Match count : [%d]", match_len);
- DBG("Match list : [%p]", match_list);
+ DBG("Match count : [%d]", match_len);
+ DBG("Match list : [%p]", match_list);
- cb(status, addr16, match_len, match_list, container->userdata);
+ cb(status, addr16, match_len, match_list, container->userdata);
- if (match_list) {
- free(match_list);
- match_list = NULL;
- }
+ if (match_list) {
+ free(match_list);
+ match_list = NULL;
}
- break;
- case ZBL_ZDO_NODE_DESC_REQ: {
- zb_zdo_node_desc_cb cb = container->cb;
+}
- zb_nwk_addr addr16;
- unsigned char status;
- struct zb_zdo_node_descriptor_s *desc;
+static void __zbl_zdo_node_desc_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zdo_node_desc_cb cb = container->cb;
- desc = calloc(1, sizeof(struct zb_zdo_node_descriptor_s));
- RETM_IF(NULL == desc, "calloc() Fail(%d)", errno);
+ zb_nwk_addr addr16;
+ unsigned char status;
+ struct zb_zdo_node_descriptor_s *desc;
- container->found = true;
+ desc = calloc(1, sizeof(struct zb_zdo_node_descriptor_s));
+ RETM_IF(NULL == desc, "calloc() Fail(%d)", errno);
- 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);
+ container->found = true;
- cb(status, addr16, desc, container->userdata);
+ 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 (desc) {
- free(desc);
- desc = NULL;
- }
+ cb(status, addr16, desc, container->userdata);
+ if (desc) {
+ free(desc);
+ desc = NULL;
}
- break;
- case ZBL_ZDO_POWER_DESC_REQ: {
- zb_zdo_power_desc_cb cb = container->cb;
+}
- zb_nwk_addr addr16;
- unsigned char status;
- struct zb_zdo_node_power_descriptor_s *desc;
+static void __zbl_zdo_power_desc_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- desc = calloc(1, sizeof(struct zb_zdo_node_power_descriptor_s));
- RETM_IF(NULL == desc, "calloc() Fail(%d)", errno);
+ zb_zdo_power_desc_cb cb = container->cb;
- g_variant_get(parameters, "(yqyyyy)", &status, &addr16,
- &desc->current_power_mode, &desc->available_power_sources,
- &desc->current_power_source, &desc->current_power_source_level);
+ zb_nwk_addr addr16;
+ unsigned char status;
+ struct zb_zdo_node_power_descriptor_s *desc;
- cb(status, addr16, desc, container->userdata);
+ desc = calloc(1, sizeof(struct zb_zdo_node_power_descriptor_s));
+ RETM_IF(NULL == desc, "calloc() Fail(%d)", errno);
- if (desc) {
- free(desc);
- desc = NULL;
- }
+ 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);
+
+ if (desc) {
+ free(desc);
+ desc = NULL;
}
- break;
- case ZBL_ZDO_COMPLEX_DESC_REQ: {
- zb_zdo_complex_desc_cb cb = container->cb;
+}
- int length;
- zb_nwk_addr addr16;
- unsigned char j = 0;
- unsigned char value;
- unsigned char status;
- GVariantIter *comp_iter = NULL;
- unsigned char *complex_desc = NULL;
+static void __zbl_zdo_complex_desc_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- g_variant_get(parameters, "(yqya(y))", &status, &addr16, &length, &comp_iter);
- RETM_IF(NULL == comp_iter, "Invalid parameter !");
+ zb_zdo_complex_desc_cb cb = container->cb;
- if (length > 0) {
- complex_desc = calloc(length, sizeof(char));
- if (NULL == complex_desc) {
- g_variant_iter_free(comp_iter);
- ERR("calloc() Fail(%d)", errno);
- return;
- }
+ int length;
+ zb_nwk_addr addr16;
+ unsigned char j = 0;
+ unsigned char value;
+ unsigned char status;
+ GVariantIter *comp_iter = NULL;
+ unsigned char *complex_desc = NULL;
- while (g_variant_iter_loop(comp_iter, "(y)", &value)) {
- complex_desc[j] = value;
- j++;
- }
+ g_variant_get(parameters, "(yqya(y))", &status, &addr16, &length, &comp_iter);
+ RETM_IF(NULL == comp_iter, "Invalid parameter !");
+
+ if (length > 0) {
+ complex_desc = calloc(length, sizeof(char));
+ if (NULL == complex_desc) {
g_variant_iter_free(comp_iter);
+ ERR("calloc() Fail(%d)", errno);
+ return;
}
- cb(status, addr16, length, complex_desc, container->userdata);
-
- if (complex_desc) {
- free(complex_desc);
- complex_desc = NULL;
+ while (g_variant_iter_loop(comp_iter, "(y)", &value)) {
+ complex_desc[j] = value;
+ j++;
}
+ g_variant_iter_free(comp_iter);
}
- break;
- case ZBL_ZDO_USER_DESC_REQ: {
- zb_zdo_user_desc_cb cb = container->cb;
- int length;
- zb_nwk_addr addr16;
- unsigned char j = 0;
- unsigned char value;
- unsigned char status;
- GVariantIter *comp_iter = NULL;
- unsigned char *complex_desc = NULL;
+ cb(status, addr16, length, complex_desc, container->userdata);
- g_variant_get(parameters, "(yqya(y))", &status, &addr16, &length, &comp_iter);
- RETM_IF(NULL == comp_iter, "Invalid parameter !");
+ if (complex_desc) {
+ free(complex_desc);
+ complex_desc = NULL;
+ }
+}
- if (length > 0) {
- complex_desc = calloc(length, sizeof(char));
- if (NULL == complex_desc) {
- g_variant_iter_free(comp_iter);
- ERR("calloc() Fail(%d)", errno);
- return;
- }
+static void __zbl_zdo_user_desc_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- while (g_variant_iter_loop(comp_iter, "(y)", &value)) {
- complex_desc[j] = value;
- j++;
- }
+ zb_zdo_user_desc_cb cb = container->cb;
+
+ int length;
+ zb_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, "(yqya(y))", &status, &addr16, &length, &comp_iter);
+ RETM_IF(NULL == comp_iter, "Invalid parameter !");
+
+ if (length > 0) {
+ complex_desc = calloc(length, sizeof(char));
+ if (NULL == complex_desc) {
g_variant_iter_free(comp_iter);
+ ERR("calloc() Fail(%d)", errno);
+ return;
}
- cb(status, addr16, length, complex_desc, container->userdata);
-
- if (complex_desc) {
- free(complex_desc);
- complex_desc = NULL;
+ while (g_variant_iter_loop(comp_iter, "(y)", &value)) {
+ complex_desc[j] = value;
+ j++;
}
- break;
- }
- case ZBL_ZDO_USER_DESC_SET_REQ: {
- zb_zdo_user_desc_conf_cb cb = container->cb;
- unsigned char status;
- g_variant_get(parameters, "(y)", &status);
- cb(status, container->userdata);
+ g_variant_iter_free(comp_iter);
}
- break;
- case ZBL_ZDO_MGMT_BIND_REQ: {
- zb_zdo_mgmt_bind_cb 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;
- unsigned short dst_addr16 = 0;
- unsigned char dst_ep = 0;
-
- GVariantIter *mac_iter = NULL;
- GVariantIter *rsp_iter = NULL;
- GVariantIter *destep_iter = NULL;
- struct zb_zdo_binding_table_s **records = NULL;
+ cb(status, addr16, length, complex_desc, container->userdata);
- g_variant_get(parameters, "(yyyya(ayyqyqayy))", &status,
- &binding_table_enteries, &start_index,
- &binding_table_list_count, &rsp_iter);
- RETM_IF(NULL == rsp_iter, "Invalid parameter !");
+ if (complex_desc) {
+ free(complex_desc);
+ complex_desc = NULL;
+ }
+}
- 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]) {
- g_variant_iter_free(rsp_iter);
- ERR("calloc() Fail(%d)", errno);
- goto MGMT_NWK_BIND_REQ_OUT;
- }
- }
- }
+static void __zbl_zdo_mgmt_bind_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zdo_mgmt_bind_cb 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;
+ unsigned short dst_addr16 = 0;
+ unsigned char dst_ep = 0;
+
+ GVariantIter *mac_iter = NULL;
+ GVariantIter *rsp_iter = NULL;
+ GVariantIter *destep_iter = NULL;
+ struct zb_zdo_binding_table_s **records = NULL;
+ g_variant_get(parameters, "(yyyya(ayyqyqayy))", &status,
+ &binding_table_enteries, &start_index,
+ &binding_table_list_count, &rsp_iter);
+ RETM_IF(NULL == rsp_iter, "Invalid parameter !");
+
+ 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++) {
- g_variant_iter_loop(rsp_iter, "(ayyqyqayy)", &mac_iter,
- &records[i]->src_ep, &records[i]->clusterid,
- &records[i]->dst_addr_mode, &dst_addr16,
- &destep_iter, &dst_ep);
- if (NULL == mac_iter) {
- ERR("Invalid parameter !");
- goto MGMT_NWK_BIND_REQ_OUT;
- }
- if (NULL == destep_iter) {
- ERR("Invalid parameter !");
+ records[i] = calloc(binding_table_list_count, sizeof(struct zb_zdo_binding_table_s));
+ if (NULL == records[i]) {
+ g_variant_iter_free(rsp_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, "(ayyqyqayy)", &mac_iter,
+ &records[i]->src_ep, &records[i]->clusterid,
+ &records[i]->dst_addr_mode, &dst_addr16,
+ &destep_iter, &dst_ep);
+ if (NULL == mac_iter) {
+ ERR("Invalid parameter !");
+ goto MGMT_NWK_BIND_REQ_OUT;
+ }
+ if (NULL == destep_iter) {
+ ERR("Invalid parameter !");
+ goto MGMT_NWK_BIND_REQ_OUT;
+ }
+ for (j = 0; j < 8; j++) {
+ g_variant_iter_loop(mac_iter, "y", &value);
+ records[i]->src_addr64[j] = value;
+ }
+ g_variant_iter_free(mac_iter);
+
+ if (0x03 == records[i]->dst_addr_mode) {
for (j = 0; j < 8; j++) {
- g_variant_iter_loop(mac_iter, "y", &value);
- records[i]->src_addr64[j] = value;
+ g_variant_iter_loop(destep_iter, "y", &value);
+ records[i]->dst_addr64[j] = value;
}
- g_variant_iter_free(mac_iter);
+ g_variant_iter_free(destep_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_free(destep_iter);
+ records[i]->dst_ep = dst_ep;
+ 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) {
+ records[i]->dst_addr16 = dst_addr16;
+ }
+ }
+ g_variant_iter_free(rsp_iter);
+
+ cb(status, binding_table_enteries, start_index, binding_table_list_count,
+ (void **)records, container->userdata);
+
+MGMT_NWK_BIND_REQ_OUT:
+ for (i = 0; i < binding_table_list_count; i++) {
+ if (records[i]) {
+ free(records[i]);
+ records[i] = NULL;
+ }
+ }
+ free(records);
+ records = NULL;
+}
+
+static void __zbl_zdo_mgmt_lqi_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zdo_mgmt_lqi_cb 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;
- records[i]->dst_ep = dst_ep;
- 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]);
+ GVariantIter *resp_iter = NULL;
+ GVariantIter *mac_iter = NULL;
+ GVariantIter *mac_iter1 = NULL;
+ struct zb_zdo_neighbor_table_desc_s **records = NULL;
+
+ g_variant_get(parameters, "(yyyya(ayayyqyyyyy))", &status, &neighbor_table_enteries,
+ &start_index, &neighbor_table_list_count, &resp_iter);
+ RETM_IF(NULL == resp_iter, "Invalid parameter !");
- } else if (0x01 == records[i]->dst_addr_mode) {
- records[i]->dst_addr16 = dst_addr16;
+ 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;
}
}
- g_variant_iter_free(rsp_iter);
+ }
+ 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);
+ if (NULL == mac_iter || NULL == mac_iter1) {
+ ERR("Invalid parameter !");
+ goto MGMT_LQI_REQ_OUT;
+ }
+
+ 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;
+ }
+ g_variant_iter_free(mac_iter);
+ g_variant_iter_free(mac_iter1);
- cb(status, binding_table_enteries, start_index, binding_table_list_count,
- (void **)records, container->userdata);
+ 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]);
-MGMT_NWK_BIND_REQ_OUT:
- for (i = 0; i < binding_table_list_count; i++) {
+ 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]);
+ }
+ g_variant_iter_free(resp_iter);
+
+ cb(status, neighbor_table_enteries, start_index, neighbor_table_list_count,
+ (void **)records, container->userdata);
+
+MGMT_LQI_REQ_OUT:
+ if (records) {
+ for (i = 0; i < neighbor_table_list_count; i++) {
if (records[i]) {
free(records[i]);
records[i] = NULL;
free(records);
records = NULL;
}
- break;
- case ZBL_ZDO_MGMT_LQI_REQ: {
- zb_zdo_mgmt_lqi_cb 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;
+static void __zbl_zdo_mgmt_rtg_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- GVariantIter *resp_iter = NULL;
- GVariantIter *mac_iter = NULL;
- GVariantIter *mac_iter1 = NULL;
- struct zb_zdo_neighbor_table_desc_s **records = NULL;
+ zb_zdo_mgmt_rtg_cb cb = container->cb;
- g_variant_get(parameters, "(yyyya(ayayyqyyyyy))", &status, &neighbor_table_enteries,
- &start_index, &neighbor_table_list_count, &resp_iter);
- RETM_IF(NULL == resp_iter, "Invalid parameter !");
+ int i;
+ unsigned char status;
+ unsigned char start_index;
+ unsigned char routing_table_enteries;
+ unsigned char routing_table_list_count;
- 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;
- }
+ GVariantIter *rsp_iter = NULL;
+ struct zb_zdo_routing_table_s **records = NULL;
+
+ g_variant_get(parameters, "(yyyya(qyyyyq))", &status, &routing_table_enteries,
+ &start_index, &routing_table_list_count, &rsp_iter);
+ RETM_IF(NULL == rsp_iter, "Invalid parameter !");
+
+ 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 < 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);
- if (NULL == mac_iter || NULL == mac_iter1) {
- ERR("Invalid parameter !");
- goto MGMT_LQI_REQ_OUT;
- }
+ }
- 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;
- }
- g_variant_iter_free(mac_iter);
- g_variant_iter_free(mac_iter1);
+ 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);
+ }
+ g_variant_iter_free(rsp_iter);
- 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]);
+ cb(status, routing_table_enteries, start_index, routing_table_list_count,
+ (void **)records, container->userdata);
- 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]);
+MGMT_NWK_RTG_REQ_OUT:
+ for (i = 0; i < routing_table_list_count; i++) {
+ if (records[i]) {
+ free(records[i]);
+ records[i] = NULL;
}
- g_variant_iter_free(resp_iter);
+ }
+ free(records);
+ records = NULL;
+}
- cb(status, neighbor_table_enteries, start_index, neighbor_table_list_count,
- (void **)records, container->userdata);
+static void __zbl_zdo_mgmt_nwk_disc_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
-MGMT_LQI_REQ_OUT:
- if (records) {
- for (i = 0; i < neighbor_table_list_count; i++) {
- if (records[i]) {
- free(records[i]);
- records[i] = NULL;
- }
- }
- free(records);
- records = NULL;
- }
- }
- break;
- case ZBL_ZDO_MGMT_RTG_REQ: {
- zb_zdo_mgmt_rtg_cb cb = container->cb;
+ zb_zdo_mgmt_nwk_disc_cb 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;
- int i;
- unsigned char status;
- unsigned char start_index;
- unsigned char routing_table_enteries;
- unsigned char routing_table_list_count;
+ GVariantIter *mac_iter = NULL;
+ GVariantIter *resp_iter = NULL;
- GVariantIter *rsp_iter = NULL;
- struct zb_zdo_routing_table_s **records = NULL;
+ DBG("_zbl_mgmt_nwk_disc_req_cb()");
- g_variant_get(parameters, "(yyyya(qyyyyq))", &status, &routing_table_enteries,
- &start_index, &routing_table_list_count, &rsp_iter);
- RETM_IF(NULL == rsp_iter, "Invalid parameter !");
+ g_variant_get(parameters, "(yyyya(ayyyyyyy))", &status, &nwk_count,
+ &start_index, &nwk_list_count, &resp_iter);
+ RETM_IF(NULL == resp_iter, "Invalid parameter !");
- if (routing_table_list_count > 0) {
- records = calloc(routing_table_list_count, sizeof(zb_zdo_routing_table_h));
+ struct zb_zdo_network_list_record_s **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 < routing_table_list_count; i++) {
- records[i] = calloc(1, sizeof(struct zb_zdo_routing_table_s));
+ 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_RTG_REQ_OUT;
+ goto MGMT_NWK_DISC_REQ_OUT;
}
}
}
+ for (i = 0; i < nwk_list_count; i++) {
+ g_variant_iter_loop(resp_iter, "(ayyyyyyy)",
+ &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);
+ if (NULL == mac_iter) {
+ ERR("Invalid parameter !");
+ goto MGMT_NWK_DISC_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);
+ for (j = 0; j < 8; j++) {
+ g_variant_iter_loop(mac_iter, "y", &value);
+ records[i]->extended_pan_id[j] = value;
+ }
+ g_variant_iter_free(mac_iter);
}
- g_variant_iter_free(rsp_iter);
+ g_variant_iter_free(resp_iter);
+ }
- cb(status, routing_table_enteries, start_index, routing_table_list_count,
- (void **)records, container->userdata);
+ cb(status, nwk_count, start_index, nwk_list_count,
+ (void **)records, container->userdata);
-MGMT_NWK_RTG_REQ_OUT:
- for (i = 0; i < routing_table_list_count; i++) {
+MGMT_NWK_DISC_REQ_OUT:
+ if (records) {
+ for (i = 0; i < nwk_list_count; i++) {
if (records[i]) {
free(records[i]);
records[i] = NULL;
free(records);
records = NULL;
}
- break;
- case ZBL_ZDO_MGMT_NWK_DISC_REQ: {
- zb_zdo_mgmt_nwk_disc_cb 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(ayyyyyyy))", &status, &nwk_count,
- &start_index, &nwk_list_count, &resp_iter);
- RETM_IF(NULL == resp_iter, "Invalid parameter !");
+static void __zbl_custom_aps_send_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- struct zb_zdo_network_list_record_s **records = NULL;
+ zb_aps_send_cb cb = container->cb;
- 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, "(ayyyyyyy)",
- &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);
- if (NULL == mac_iter) {
- ERR("Invalid parameter !");
- goto MGMT_NWK_DISC_REQ_OUT;
- }
+ unsigned short addr16;
+ unsigned char src_ep;
+ unsigned char dst_ep;
+ unsigned short clusterid;
+ unsigned short profileid;
+ unsigned short payload_len = 0;
+ unsigned char *payload = NULL;
- for (j = 0; j < 8; j++) {
- g_variant_iter_loop(mac_iter, "y", &value);
- records[i]->extended_pan_id[j] = value;
- }
- g_variant_iter_free(mac_iter);
- }
- g_variant_iter_free(resp_iter);
- }
+ unsigned char value;
+ GVariantIter *payload_iter = NULL;
+ int i = 0;
- cb(status, nwk_count, start_index, nwk_list_count,
- (void **)records, container->userdata);
+ g_variant_get(parameters, "(qyyqqqa(y))", &addr16, &src_ep, &dst_ep,
+ &clusterid, &profileid, &payload_len, &payload_iter);
+ RETM_IF(NULL == payload_iter, "Invalid parameter !");
-MGMT_NWK_DISC_REQ_OUT:
- if (records) {
- for (i = 0; i < nwk_list_count; i++) {
- if (records[i]) {
- free(records[i]);
- records[i] = NULL;
- }
- }
- free(records);
- records = NULL;
+ if (payload_len > 0) {
+ payload = calloc(payload_len+1, sizeof(unsigned char));
+ if (!payload) {
+ ERR("calloc() Fail(%d)", errno);
+ goto ZBL_CUSTOM_APS_SEND_REQ_OUT;
}
+ while (g_variant_iter_loop(payload_iter, "(y)", &value))
+ payload[i++] = value;
}
- break;
- case ZBL_ZDO_MGMT_PERMIT_JOIN_REQ: {
- zb_zdo_mgmt_permit_joining_cb 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_cb cb = container->cb;
- unsigned char status;
- g_variant_get(parameters, "(y)", &status);
- cb(status, container->userdata);
- }
- break;
- /* ZDO Bind */
- case ZBL_ZDO_BIND_REQ: {
- zb_zdo_bind_cb 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_cb cb = container->cb;
- unsigned char status;
- g_variant_get(parameters, "(y)", &status);
- cb(status, container->userdata);
+
+ cb(addr16, src_ep, dst_ep, clusterid, profileid, payload_len, payload,
+ container->userdata);
+ZBL_CUSTOM_APS_SEND_REQ_OUT:
+ g_variant_iter_free(payload_iter);
+ if (payload) {
+ free(payload);
+ payload = NULL;
}
- break;
- /* Custom */
- case ZBL_CUSTOM_APS_SEND_REQ: {
- zb_aps_send_cb cb = container->cb;
+}
- unsigned short addr16;
- unsigned char src_ep;
- unsigned char dst_ep;
- unsigned short clusterid;
- unsigned short profileid;
- unsigned short payload_len = 0;
- unsigned char *payload = NULL;
+static void __zbl_custom_zcl_send_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- unsigned char value;
- GVariantIter *payload_iter = NULL;
- int i = 0;
+ zb_zcl_send_cb cb = container->cb;
- g_variant_get(parameters, "(qyyqqqa(y))", &addr16, &src_ep, &dst_ep,
- &clusterid, &profileid, &payload_len, &payload_iter);
- RETM_IF(NULL == payload_iter, "Invalid parameter !");
+ unsigned short addr16;
+ unsigned char src_ep;
+ unsigned char dst_ep;
+ unsigned short clusterid;
+ unsigned short profileid;
+ unsigned short payload_len = 0;
+ unsigned char *payload = NULL;
- if (payload_len > 0) {
- payload = calloc(payload_len+1, sizeof(unsigned char));
- if (!payload) {
- ERR("calloc() Fail(%d)", errno);
- goto ZBL_CUSTOM_APS_SEND_REQ_OUT;
- }
- while (g_variant_iter_loop(payload_iter, "(y)", &value))
- payload[i++] = value;
- }
+ unsigned char value;
+ GVariantIter *payload_iter = NULL;
+ int i = 0;
- cb(addr16, src_ep, dst_ep, clusterid, profileid, payload_len, payload,
- container->userdata);
-ZBL_CUSTOM_APS_SEND_REQ_OUT:
- g_variant_iter_free(payload_iter);
- if (payload) {
- free(payload);
- payload = NULL;
+ g_variant_get(parameters, "(qyyqqqa(y))", &addr16, &src_ep, &dst_ep,
+ &clusterid, &profileid, &payload_len, &payload_iter);
+ RETM_IF(NULL == payload_iter, "Invalid parameter !");
+
+ if (payload_len > 0) {
+ payload = calloc(payload_len + 1, sizeof(unsigned char));
+ if (!payload) {
+ ERR("calloc() Fail(%d)", errno);
+ goto ZBL_CUSTOM_ZCL_SEND_REQ_OUT;
}
+ while (g_variant_iter_loop(payload_iter, "(y)", &value))
+ payload[i++] = value;
}
- break;
- case ZBL_CUSTOM_ZCL_SEND_REQ: {
- zb_zcl_send_cb cb = container->cb;
-
- unsigned short addr16;
- unsigned char src_ep;
- unsigned char dst_ep;
- unsigned short clusterid;
- unsigned short profileid;
- unsigned short payload_len = 0;
- unsigned char *payload = NULL;
- unsigned char value;
- GVariantIter *payload_iter = NULL;
- int i = 0;
+ cb(addr16, src_ep, dst_ep, clusterid, profileid, payload_len, payload,
+ container->userdata);
+ZBL_CUSTOM_ZCL_SEND_REQ_OUT:
+ g_variant_iter_free(payload_iter);
+ if (payload) {
+ free(payload);
+ payload = NULL;
+ }
+}
- g_variant_get(parameters, "(qyyqqqa(y))", &addr16, &src_ep, &dst_ep,
- &clusterid, &profileid, &payload_len, &payload_iter);
- RETM_IF(NULL == payload_iter, "Invalid parameter !");
+static void __zbl_custom_local_send_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- if (payload_len > 0) {
- payload = calloc(payload_len + 1, sizeof(unsigned char));
- if (!payload) {
- ERR("calloc() Fail(%d)", errno);
- goto ZBL_CUSTOM_ZCL_SEND_REQ_OUT;
- }
- while (g_variant_iter_loop(payload_iter, "(y)", &value))
- payload[i++] = value;
- }
+ zb_send_to_local_cb cb = container->cb;
- cb(addr16, src_ep, dst_ep, clusterid, profileid, payload_len, payload,
- container->userdata);
-ZBL_CUSTOM_ZCL_SEND_REQ_OUT:
- g_variant_iter_free(payload_iter);
- if (payload) {
- free(payload);
- payload = NULL;
+ unsigned char *data = NULL;
+ unsigned short length = 0;
+ unsigned char value;
+ GVariantIter *payload_iter = NULL;
+ int i = 0;
+
+ g_variant_get(parameters, "(qa(y))", &length, &payload_iter);
+ RETM_IF(NULL == payload_iter, "Invalid parameter !");
+
+ if (length > 0) {
+ data = calloc(length, sizeof(unsigned char));
+ if (!data) {
+ ERR("calloc() Fail(%d)", errno);
+ goto ZBL_CUSTOM_LOCAL_SEND_REQ_OUT;
}
+
+ while (g_variant_iter_loop(payload_iter, "(y)", &value))
+ data[i++] = value;
}
- break;
- case ZBL_CUSTOM_LOCAL_SEND_REQ: {
- zb_send_to_local_cb cb = container->cb;
- unsigned char *data = NULL;
- unsigned short length = 0;
- unsigned char value;
- GVariantIter *payload_iter = NULL;
- int i = 0;
+ cb(length, data, container->userdata);
+ZBL_CUSTOM_LOCAL_SEND_REQ_OUT:
+ g_variant_iter_free(payload_iter);
+ if (data) {
+ free(data);
+ data = NULL;
+ }
+}
- g_variant_get(parameters, "(qa(y))", &length, &payload_iter);
- RETM_IF(NULL == payload_iter, "Invalid parameter !");
+static void __zbl_zcl_global_read_attr_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- if (length > 0) {
- data = calloc(length, sizeof(unsigned char));
- if (!data) {
- ERR("calloc() Fail(%d)", errno);
- goto ZBL_CUSTOM_LOCAL_SEND_REQ_OUT;
- }
+ zb_zcl_global_attr_read_cb cb = container->cb;
- while (g_variant_iter_loop(payload_iter, "(y)", &value))
- data[i++] = value;
- }
+ int j = 0;
+ int isString;
+ unsigned char value;
- cb(length, data, container->userdata);
-ZBL_CUSTOM_LOCAL_SEND_REQ_OUT:
- g_variant_iter_free(payload_iter);
- if (data) {
- free(data);
- data = NULL;
+ zb_nwk_addr addr16;
+ unsigned char ep;
+ unsigned short attr_id;
+ unsigned short clusterid;
+ unsigned char status;
+ unsigned char type;
+ unsigned short count;
+ unsigned char attr_value[128];
+
+ GVariantIter *iter = NULL;
+ struct read_attribute_status_record_s *records = NULL;
+
+ g_variant_get(parameters, "(qya(y)qqyyqi)",
+ &addr16, &ep, &iter, &attr_id, &clusterid, &status, &type, &count, &isString);
+ RETM_IF(NULL == iter, "Invalid parameter !");
+
+ if (!isString) {
+ while (g_variant_iter_loop(iter, "(y)", &value)) {
+ attr_value[j] = value;
+ DBG("attr_value[%d] = 0x%02X", j, value);
+ j++;
+ }
+ g_variant_iter_free(iter);
+ } else {
+ while (g_variant_iter_loop(iter, "(y)", &value)) {
+ if (j == 0)
+ count = value;
+ attr_value[j] = value;
+ DBG("attr_value[%d] = 0x%02X", j, value);
+ j++;
}
+ g_variant_iter_free(iter);
}
- break;
- /* ZCL Global */
- case ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ: {
- zb_zcl_global_attr_read_cb cb = container->cb;
- int j = 0;
- int isString;
- unsigned char value;
+ records = calloc(1, sizeof(struct read_attribute_status_record_s));
- zb_nwk_addr addr16;
- unsigned char ep;
- unsigned short attr_id;
- unsigned short clusterid;
- unsigned char status;
- unsigned char type;
- unsigned short count;
- unsigned char attr_value[128];
+ if (!records) {
+ ERR("calloc() Fail(%d)", errno);
+ goto GLOBAL_READ_ATTRIBUTE_REQ_OUT;
+ }
- GVariantIter *iter = NULL;
- struct read_attribute_status_record_s *records = NULL;
+ records->id = attr_id;
+ records->status = status;
+ records->type = type;
+ records->value = attr_value;
- g_variant_get(parameters, "(qya(y)qqyyqi)",
- &addr16, &ep, &iter, &attr_id, &clusterid, &status, &type, &count, &isString);
- RETM_IF(NULL == iter, "Invalid parameter !");
+ cb(addr16, ep, clusterid, (void **)&records, count, container->userdata);
- if (!isString) {
- while (g_variant_iter_loop(iter, "(y)", &value)) {
- attr_value[j] = value;
- DBG("attr_value[%d] = 0x%02X", j, value);
- j++;
- }
- g_variant_iter_free(iter);
- } else {
- while (g_variant_iter_loop(iter, "(y)", &value)) {
- if (j == 0)
- count = value;
- attr_value[j] = value;
- DBG("attr_value[%d] = 0x%02X", j, value);
- j++;
- }
- g_variant_iter_free(iter);
- }
+GLOBAL_READ_ATTRIBUTE_REQ_OUT:
+ if (records) {
+ free(records);
+ records = NULL;
+ }
+}
- records = calloc(1, sizeof(struct read_attribute_status_record_s));
+static void __zbl_zcl_global_write_attr_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- if (!records) {
- ERR("calloc() Fail(%d)", errno);
- goto GLOBAL_READ_ATTRIBUTE_REQ_OUT;
- }
+ zb_zcl_global_attr_write_cb cb = container->cb;
- records->id = attr_id;
- records->status = status;
- records->type = type;
- records->value = attr_value;
+ int i = 0;
+ zb_nwk_addr addr16;
+ unsigned char ep;
+ unsigned short clusterid;
+ unsigned short attributeid;
+ int count;
+ unsigned char value;
- cb(addr16, ep, clusterid, (void **)&records, count, container->userdata);
+ GVariantIter *stat_iter = NULL;
+ GVariantIter *attr_iter = NULL;
+ struct write_attribute_status_record_s *records = NULL;
-GLOBAL_READ_ATTRIBUTE_REQ_OUT:
- if (records) {
- free(records);
- records = NULL;
- }
+ g_variant_get(parameters, "(qya(y)aqqi)",
+ &addr16, &ep, &stat_iter, &attr_iter, &clusterid, &count);
+ RETM_IF(NULL == stat_iter, "Invalid parameter !");
+ RETM_IF(NULL == attr_iter, "Invalid parameter !");
+ records = calloc(count,
+ sizeof(struct write_attribute_status_record_s));
+ if (!records) {
+ g_variant_iter_free(stat_iter);
+ g_variant_iter_free(attr_iter);
+ ERR("calloc() Fail(%d)", errno);
+ goto GLOBAL_WRITE_ATTRIBUTE_REQ_OUT;
}
- break;
- case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ: {
- zb_zcl_global_attr_write_cb cb = container->cb;
- int i = 0;
- zb_nwk_addr addr16;
- unsigned char ep;
- unsigned short clusterid;
- unsigned short attributeid;
- int count;
- unsigned char value;
+ while (g_variant_iter_loop(stat_iter, "(y)", &value)) {
+ records[i].status = value;
+ i++;
+ }
+ g_variant_iter_free(stat_iter);
- GVariantIter *stat_iter = NULL;
- GVariantIter *attr_iter = NULL;
- struct write_attribute_status_record_s *records = NULL;
+ i = 0;
+ while (g_variant_iter_loop(attr_iter, "q", &attributeid)) {
+ records[i].id = attributeid;
+ DBG("Attribute Id 0x%04X", attributeid);
+ i++;
+ }
+ g_variant_iter_free(attr_iter);
- g_variant_get(parameters, "(qya(y)aqqi)",
- &addr16, &ep, &stat_iter, &attr_iter, &clusterid, &count);
- RETM_IF(NULL == stat_iter, "Invalid parameter !");
- RETM_IF(NULL == attr_iter, "Invalid parameter !");
+ cb(addr16, ep, clusterid, (void **)&records, count, container->userdata);
+
+GLOBAL_WRITE_ATTRIBUTE_REQ_OUT:
+ if (records) {
+ free(records);
+ records = NULL;
+ }
+}
+
+static void __zbl_zcl_global_write_config_reporting_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ int j = 0;
+ int l = 0;
+ int k = 0;
+ int rec_len;
+
+ unsigned char ep;
+ unsigned short clusterid;
+ unsigned short attIdVal;
+ unsigned char value;
+
+ GVariantIter *stat_iter = NULL;
+ GVariantIter *attr_iter = NULL;
+ GVariantIter *dir_iter = NULL;
+
+ zb_nwk_addr addr16;
+ zb_zcl_global_config_report_write_cb cb = container->cb;
+ struct reporting_configuration_response_record_s *records = NULL;
+
+ g_variant_get(parameters, "(a(y)aqa(y)qiqy)",
+ &stat_iter, &attr_iter, &dir_iter, &clusterid, &rec_len, &addr16, &ep);
+ RETM_IF(NULL == stat_iter, "Invalid parameter !");
+ RETM_IF(NULL == attr_iter, "Invalid parameter !");
+ RETM_IF(NULL == dir_iter, "Invalid parameter !");
+
+ records = calloc(rec_len,
+ sizeof(struct reporting_configuration_response_record_s));
+ if (!records) {
+ g_variant_iter_free(stat_iter);
+ g_variant_iter_free(attr_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++;
+ }
+ g_variant_iter_free(stat_iter);
+
+ while (g_variant_iter_loop(attr_iter, "q", &attIdVal)) {
+ if (records[l].status != ZB_ZCL_STATUS_SUCCESS)
+ records[l].id = attIdVal;
+ l++;
+ }
+ g_variant_iter_free(attr_iter);
+
+ while (g_variant_iter_loop(dir_iter, "(y)", &value)) {
+ if (records[k].status != ZB_ZCL_STATUS_SUCCESS)
+ records[k].dir = value;
+ k++;
+ }
+ g_variant_iter_free(dir_iter);
+
+ cb(addr16, ep, clusterid, (void **)&records, rec_len, container->userdata);
+
+GLOBAL_CONFIGURE_REPORTING_REQ_OUT:
+ if (records) {
+ free(records);
+ records = NULL;
+ }
+}
+
+static void __zbl_zcl_global_discover_attr_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ int j = 0;
+ int l = 0;
+ int count;
+ unsigned short clusterid;
+ unsigned short attributeid;
+ unsigned char value;
+ int discovery_complete;
+
+ GVariantIter *stat_iter = NULL;
+ GVariantIter *attr_iter = NULL;
+
+ zb_nwk_addr addr16;
+ unsigned char ep;
+
+ zb_zcl_global_attr_discover_cb cb = container->cb;
+ struct discover_attribute_info_record_s **records = NULL;
+
+ g_variant_get(parameters, "(qya(y)aqqii)", &addr16, &ep, &stat_iter,
+ &attr_iter, &clusterid, &count, &discovery_complete);
+ RETM_IF(NULL == stat_iter, "Invalid parameter !");
+ RETM_IF(NULL == attr_iter, "Invalid parameter !");
+
+ records = calloc(count, sizeof(zb_zcl_discover_attr_info_record_h));
+ RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
+ for (j = 0; j < count; 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]);
+ records[l] = NULL;
+ }
+ free(records);
+ records = NULL;
- records = calloc(count,
- sizeof(struct write_attribute_status_record_s));
- if (!records) {
g_variant_iter_free(stat_iter);
g_variant_iter_free(attr_iter);
- ERR("calloc() Fail(%d)", errno);
- goto GLOBAL_WRITE_ATTRIBUTE_REQ_OUT;
+ return;
}
+ }
- while (g_variant_iter_loop(stat_iter, "(y)", &value)) {
- records[i].status = value;
- i++;
- }
- g_variant_iter_free(stat_iter);
+ j = 0;
+ while (g_variant_iter_loop(stat_iter, "(y)", &value)) {
+ records[j]->type = value;
+ DBG("Attribute Type 0x%02X", value);
+ j++;
+ }
+ g_variant_iter_free(stat_iter);
- i = 0;
- while (g_variant_iter_loop(attr_iter, "q", &attributeid)) {
- records[i].id = attributeid;
- DBG("Attribute Id 0x%04X", attributeid);
- i++;
+ while (g_variant_iter_loop(attr_iter, "q", &attributeid)) {
+ records[l]->id = attributeid;
+ DBG("Attribute Id 0x%04X", attributeid);
+ l++;
+ }
+ g_variant_iter_free(attr_iter);
+
+ cb(addr16, ep, clusterid, discovery_complete, (void *)records, count,
+ container->userdata);
+
+ for (j = 0; j < count; j++) {
+ if (records[j]) {
+ free(records[j]);
+ records[j] = NULL;
}
- g_variant_iter_free(attr_iter);
+ }
+ if (records) {
+ free(records);
+ records = NULL;
+ }
+}
- cb(addr16, ep, clusterid, (void **)&records, count, container->userdata);
+static void __zbl_zcl_global_discover_cmd_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
-GLOBAL_WRITE_ATTRIBUTE_REQ_OUT:
- if (records) {
+ int j = 0;
+ char value;
+ unsigned short clusterid;
+ unsigned short cmd_len;
+ unsigned char *cmd_data;
+ unsigned char discoveryComplete;
+
+ GVariantIter *cmd_iter = NULL;
+
+ unsigned char ep;
+ zb_nwk_addr addr16;
+ zb_zcl_global_discover_cmds_cb cb = container->cb;
+
+ g_variant_get(parameters, "(a(y)qqqyy)", &cmd_iter, &clusterid, &cmd_len,
+ &addr16, &ep, &discoveryComplete);
+ RETM_IF(NULL == cmd_iter, "Invalid parameter !");
+
+ cmd_data = calloc(cmd_len+1, sizeof(char));
+ if (NULL == cmd_data) {
+ ERR("calloc() Fail(%d)", errno);
+ 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++;
+ }
+ g_variant_iter_free(cmd_iter);
+
+ cb(addr16, ep, clusterid, discoveryComplete, cmd_data, cmd_len,
+ container->userdata);
+ if (cmd_data) {
+ free(cmd_data);
+ cmd_data = NULL;
+ }
+}
+
+static void __zbl_zcl_global_discover_attr_ex_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ int i = 0;
+ int j = 0;
+ unsigned short clusterid;
+ 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;
+
+ unsigned char ep;
+ zb_nwk_addr addr16;
+ struct extended_attribute_infomation_s **records = NULL;
+ zb_zcl_global_attr_extended_discover_cb cb = container->cb;
+
+ DBG("Will get the value now");
+
+ g_variant_get(parameters, "(aqa(y)a(y)qqqyy)", &attr_iter, &type_iter, &ac_iter,
+ &clusterid, &rec_len, &addr16, &ep, &discoveryComplete);
+ RETM_IF(NULL == attr_iter, "Invalid parameter !");
+ RETM_IF(NULL == type_iter, "Invalid parameter !");
+ RETM_IF(NULL == ac_iter, "Invalid parameter !");
+
+ DBG("records length 0x%04X", rec_len);
+
+ records = calloc(rec_len, sizeof(zb_zcl_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]);
+ records[i] = NULL;
+ }
free(records);
records = NULL;
+
+ g_variant_iter_free(attr_iter);
+ g_variant_iter_free(type_iter);
+ g_variant_iter_free(ac_iter);
+
+ ERR("calloc() Fail(%d)", errno);
+ return;
}
}
- break;
- case ZBL_ZCL_GLOBAL_WRITE_CONFIGURE_REPORTING_REQ: {
- int j = 0;
- int l = 0;
- int k = 0;
- int rec_len;
- unsigned char ep;
- unsigned short clusterid;
- unsigned short attIdVal;
- unsigned char value;
+ 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++;
+ }
+ g_variant_iter_free(attr_iter);
+ g_variant_iter_free(type_iter);
+ g_variant_iter_free(ac_iter);
- GVariantIter *stat_iter = NULL;
- GVariantIter *attr_iter = NULL;
- GVariantIter *dir_iter = NULL;
+ cb(addr16, ep, clusterid, discoveryComplete, (void *)records, rec_len,
+ container->userdata);
- zb_nwk_addr addr16;
- zb_zcl_global_config_report_write_cb cb = container->cb;
- struct reporting_configuration_response_record_s *records = NULL;
+ for (j = 0; j < rec_len; j++) {
+ if (records[j]) {
+ free(records[j]);
+ records[j] = NULL;
+ }
+ }
+ if (records) {
+ free(records);
+ records = NULL;
+ }
- g_variant_get(parameters, "(a(y)aqa(y)qiqy)",
- &stat_iter, &attr_iter, &dir_iter, &clusterid, &rec_len, &addr16, &ep);
- RETM_IF(NULL == stat_iter, "Invalid parameter !");
- RETM_IF(NULL == attr_iter, "Invalid parameter !");
- RETM_IF(NULL == dir_iter, "Invalid parameter !");
+}
- records = calloc(rec_len,
- sizeof(struct reporting_configuration_response_record_s));
- if (!records) {
- g_variant_iter_free(stat_iter);
- g_variant_iter_free(attr_iter);
- g_variant_iter_free(dir_iter);
+static void __zbl_zcl_global_read_config_reporting_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ 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;
+
+ zb_nwk_addr addr16;
+ unsigned char ep;
+ unsigned short clusterid;
+ zb_zcl_global_attr_read_cb cb = container->cb;
+
+ struct reporting_configuration_record_s **records = NULL;
+
+ g_variant_get(parameters, "(qyqqa(yyqyqqayq))",
+ &addr16, &ep, &clusterid, &record_length, &resp_iter);
+ RETM_IF(NULL == resp_iter, "Invalid parameter !");
+
+ records = calloc(record_length, sizeof(zb_zcl_reporting_config_record_h));
+ RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
+
+ 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_CONFIGURE_REPORTING_REQ_OUT;
+ goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT;
}
+ }
- while (g_variant_iter_loop(stat_iter, "(y)", &value)) {
- DBG("Value 0x%02X", value);
- records[j].status = value;
- j++;
+ 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 (NULL == data_iter) {
+ ERR("Invalid parameter !");
+ goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT;
}
- g_variant_iter_free(stat_iter);
- while (g_variant_iter_loop(attr_iter, "q", &attIdVal)) {
- if (records[l].status != ZB_ZCL_STATUS_SUCCESS)
- records[l].id = attIdVal;
- l++;
+ if (records[i]->dir != ZCL_REPORTING_DIRECTION_REPORTED &&
+ (zb_zcl_get_analog_or_discret(records[i]->type) == ZB_ZCL_DATA_TYPE_ANALOG)) {
+ data_size[i] = zb_zcl_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;
+ g_variant_iter_free(data_iter);
+ goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT;
+ }
+
+ while (g_variant_iter_loop(data_iter, "y", &value)) {
+ change[j] = value;
+ j++;
+ }
+ g_variant_iter_free(data_iter);
+ records[i]->change = change;
+ } else
+ records[i]->change = NULL;
+ } else
+ records[i]->change = NULL;
+ }
+ g_variant_iter_free(resp_iter);
+
+ cb(addr16, ep, clusterid, (void **)records, record_length, container->userdata);
+
+GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT:
+ if (data_size) {
+ free(data_size);
+ data_size = NULL;
+ }
+ if (status) {
+ free(status);
+ status = NULL;
+ }
+
+ for (i = 0; i < record_length; i++) {
+ if (records[i] && records[i]->change) {
+ free(records[i]->change);
+ records[i]->change = NULL;
}
- g_variant_iter_free(attr_iter);
+ if (records[i]) {
+ free(records[i]);
+ records[i] = NULL;
+ }
+ }
+ if (records) {
+ free(records);
+ records = NULL;
+ }
+}
+
+static void __zbl_zcl_group_view_group_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zcl_group_view_group_cb cb = container->cb;
- while (g_variant_iter_loop(dir_iter, "(y)", &value)) {
- if (records[k].status != ZB_ZCL_STATUS_SUCCESS)
- records[k].dir = value;
- k++;
+ int j = 0;
+ zb_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);
+ if (NULL == grpNameiter) {
+ ERR("Invalid grpNameiter");
+ goto GROUP_VIEW_GROUP_REQ_OUT;
+ }
+
+ 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) {
+ g_variant_iter_free(grpNameiter);
+ ERR("calloc() Fail(%d)", errno);
+ goto GROUP_VIEW_GROUP_REQ_OUT;
}
- g_variant_iter_free(dir_iter);
+ 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++;
+ }
+ g_variant_iter_free(grpNameiter);
+ } else {
+ group_name = calloc(2, sizeof(char));
+ if (NULL == group_name) {
+ g_variant_iter_free(grpNameiter);
+ ERR("calloc() Fail(%d)", errno);
+ goto GROUP_VIEW_GROUP_REQ_OUT;
+ }
+ group_name[j++] = value;
+ group_name[j++] = '\0';
+ }
- cb(addr16, ep, clusterid, (void **)&records, rec_len, container->userdata);
+ DBG("GroupName = %s", group_name);
+ cb(addr16, ep, status, group_id, group_name, container->userdata);
-GLOBAL_CONFIGURE_REPORTING_REQ_OUT:
- if (records) {
- free(records);
- records = NULL;
+GROUP_VIEW_GROUP_REQ_OUT:
+ if (group_name) {
+ free(group_name);
+ group_name = NULL;
+ }
+}
+
+static void __zbl_zcl_group_get_group_membership_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zcl_group_get_group_membership_cb cb = container->cb;
+
+ int j = 0;
+ zb_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);
+ RETM_IF(NULL == grpListiter, "Invalid parameter !");
+
+ if (group_count > 0) {
+ grouplist = calloc(group_count+1, sizeof(unsigned short));
+ if (NULL == grouplist) {
+ 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++;
}
+ g_variant_iter_free(grpListiter);
}
- break;
- case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ: {
- int j = 0;
- int l = 0;
- int count;
- unsigned short clusterid;
- unsigned short attributeid;
- unsigned char value;
- int discovery_complete;
+ cb(addr16, ep, capacity, group_count, grouplist, container->userdata);
- GVariantIter *stat_iter = NULL;
- GVariantIter *attr_iter = NULL;
+ if (grouplist) {
+ free(grouplist);
+ grouplist = NULL;
+ }
+}
- zb_nwk_addr addr16;
- unsigned char ep;
+static void __zbl_zcl_scene_view_scene_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
- zb_zcl_global_attr_discover_cb cb = container->cb;
- struct discover_attribute_info_record_s **records = NULL;
+ zb_zcl_scene_view_scene_cb cb = container->cb;
- g_variant_get(parameters, "(qya(y)aqqii)", &addr16, &ep, &stat_iter,
- &attr_iter, &clusterid, &count, &discovery_complete);
- RETM_IF(NULL == stat_iter, "Invalid parameter !");
- RETM_IF(NULL == attr_iter, "Invalid parameter !");
+ int j = 0;
+ int len;
+ zb_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;
- records = calloc(count, sizeof(zb_zcl_discover_attr_info_record_h));
- RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
- for (j = 0; j < count; 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]);
- records[l] = NULL;
- }
- free(records);
- records = NULL;
+ g_variant_get(parameters, "(qyyqyqa(y)ya(y))", &addr16, &ep, &status, &group_id, &scene_id,
+ &transition_time, &sceneNameIter, &ext_len, &extendedSetIter);
- g_variant_iter_free(stat_iter);
- g_variant_iter_free(attr_iter);
- return;
- }
- }
+ if (!g_variant_iter_loop(sceneNameIter, "(y)", &value)) {
+ ERR("There is no scene data");
+ return;
+ }
- j = 0;
- while (g_variant_iter_loop(stat_iter, "(y)", &value)) {
- records[j]->type = value;
- DBG("Attribute Type 0x%02X", 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++;
}
- g_variant_iter_free(stat_iter);
+ } 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;
+ }
- while (g_variant_iter_loop(attr_iter, "q", &attributeid)) {
- records[l]->id = attributeid;
- DBG("Attribute Id 0x%04X", attributeid);
- l++;
+ 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;
}
- g_variant_iter_free(attr_iter);
+ while (g_variant_iter_loop(extendedSetIter, "(y)", &value)) {
+ extendedFieldSets[j] = value;
+ j++;
+ }
+ }
- cb(addr16, ep, clusterid, discovery_complete, (void *)records, count,
- container->userdata);
+ cb(addr16, ep, status, group_id, scene_id, transition_time, scene_name,
+ extendedFieldSets, ext_len, container->userdata);
- for (j = 0; j < count; j++) {
- if (records[j]) {
- free(records[j]);
- records[j] = NULL;
- }
+SCENE_VIEW_SCENE_REQ_OUT:
+ if (scene_name) {
+ free(scene_name);
+ scene_name = NULL;
+ }
+
+ if (extendedFieldSets) {
+ free(extendedFieldSets);
+ extendedFieldSets = NULL;
+ }
+}
+
+static void __zbl_zcl_scene_get_scene_membership_req(zbl_req_cb_s *container, GVariant *parameters)
+{
+ RETM_IF(NULL == container, "container is null");
+ RETM_IF(NULL == container->cb, "cb is NULL");
+
+ zb_zcl_scene_get_scene_membership_cb cb = container->cb;
+
+ int j = 0;
+ zb_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, "(qyyyqya(y))", &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;
}
- if (records) {
- free(records);
- records = NULL;
+ 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:
+ if (scene_list) {
+ free(scene_list);
+ scene_list = NULL;
+ }
+
+}
+
+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;
+ 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);
+
+ switch (container->cid) {
+ /* Service */
+ case ZBL_SERVICE_FORM_NETWORK: {
+ __zbl_service_from_network(container, parameters);
+ }
+ break;
+ case ZBL_SERVICE_DISABLE_NETWORK: {
+ __zbl_service_disable_network(container, parameters);
+ }
+ break;
+ /* ZDO except Bind */
+ case ZBL_ZDO_NWK_ADDR_REQ: {
+ __zbl_zdo_nwk_addr_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_NWK_ADDR_EXT_REQ: {
+ __zbl_zdo_nwk_addr_ext_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_ACTIVE_EP_REQ: {
+ __zbl_zdo_active_ep_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_SIMPLE_DESC_REQ: {
+ __zbl_zdo_simple_desc_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_MATCHED_DESCRIPTOR_REQ: {
+ __zbl_zdo_matched_descriptor_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_NODE_DESC_REQ: {
+ __zbl_zdo_node_desc_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_POWER_DESC_REQ: {
+ __zbl_zdo_power_desc_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_COMPLEX_DESC_REQ: {
+ __zbl_zdo_complex_desc_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_USER_DESC_REQ: {
+ __zbl_zdo_user_desc_req(container, parameters);
+ break;
+ }
+ case ZBL_ZDO_USER_DESC_SET_REQ: {
+ zb_zdo_user_desc_conf_cb cb = container->cb;
+ unsigned char status;
+ g_variant_get(parameters, "(y)", &status);
+ cb(status, container->userdata);
+ }
+ break;
+ case ZBL_ZDO_MGMT_BIND_REQ: {
+ __zbl_zdo_mgmt_bind_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_MGMT_LQI_REQ: {
+ __zbl_zdo_mgmt_lqi_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_MGMT_RTG_REQ: {
+ __zbl_zdo_mgmt_rtg_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_MGMT_NWK_DISC_REQ: {
+ __zbl_zdo_mgmt_nwk_disc_req(container, parameters);
+ }
+ break;
+ case ZBL_ZDO_MGMT_PERMIT_JOIN_REQ: {
+ zb_zdo_mgmt_permit_joining_cb 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_cb cb = container->cb;
+ unsigned char status;
+ g_variant_get(parameters, "(y)", &status);
+ cb(status, container->userdata);
+ }
+ break;
+ /* ZDO Bind */
+ case ZBL_ZDO_BIND_REQ: {
+ zb_zdo_bind_cb 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_cb cb = container->cb;
+ unsigned char status;
+ g_variant_get(parameters, "(y)", &status);
+ cb(status, container->userdata);
+ }
+ break;
+ /* Custom */
+ case ZBL_CUSTOM_APS_SEND_REQ: {
+ __zbl_custom_aps_send_req(container, parameters);
+ }
+ break;
+ case ZBL_CUSTOM_ZCL_SEND_REQ: {
+ __zbl_custom_zcl_send_req(container, parameters);
+ }
+ break;
+ case ZBL_CUSTOM_LOCAL_SEND_REQ: {
+ __zbl_custom_local_send_req(container, parameters);
+ }
+ break;
+ /* ZCL Global */
+ case ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ: {
+ __zbl_zcl_global_read_attr_req(container, parameters);
+ }
+ break;
+ case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ: {
+ __zbl_zcl_global_write_attr_req(container, parameters);
+ }
+ break;
+ case ZBL_ZCL_GLOBAL_WRITE_CONFIGURE_REPORTING_REQ: {
+ __zbl_zcl_global_write_config_reporting_req(container, parameters);
+ }
+ break;
+ case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ: {
+ __zbl_zcl_global_discover_attr_req(container, parameters);
+ }
break;
case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_STRUCTURED_REQ: {
/* CAUTION: Currently we don't support this command */
/* GLOBAL_DISCOVER_COMMAND_RECEIVED and GLOBAL_DISCOVER_COMMAND_GENERATED should be handled as same way */
case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ:
case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ: {
-
- int j = 0;
- char value;
- unsigned short clusterid;
- unsigned short cmd_len;
- unsigned char *cmd_data;
- unsigned char discoveryComplete;
-
- GVariantIter *cmd_iter = NULL;
-
- unsigned char ep;
- zb_nwk_addr addr16;
- zb_zcl_global_discover_cmds_cb cb = container->cb;
-
- g_variant_get(parameters, "(a(y)qqqyy)", &cmd_iter, &clusterid, &cmd_len,
- &addr16, &ep, &discoveryComplete);
- RETM_IF(NULL == cmd_iter, "Invalid parameter !");
-
- cmd_data = calloc(cmd_len+1, sizeof(char));
- if (NULL == cmd_data) {
- ERR("calloc() Fail(%d)", errno);
- 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++;
- }
- g_variant_iter_free(cmd_iter);
-
- cb(addr16, ep, clusterid, discoveryComplete, cmd_data, cmd_len,
- container->userdata);
- if (cmd_data) {
- free(cmd_data);
- cmd_data = NULL;
- }
+ __zbl_zcl_global_discover_cmd_req(container, parameters);
}
break;
case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ: {
-
- int i = 0;
- int j = 0;
- unsigned short clusterid;
- 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;
-
- unsigned char ep;
- zb_nwk_addr addr16;
- struct extended_attribute_infomation_s **records = NULL;
- zb_zcl_global_attr_extended_discover_cb cb = container->cb;
-
- DBG("Will get the value now");
-
- g_variant_get(parameters, "(aqa(y)a(y)qqqyy)", &attr_iter, &type_iter, &ac_iter,
- &clusterid, &rec_len, &addr16, &ep, &discoveryComplete);
- RETM_IF(NULL == attr_iter, "Invalid parameter !");
- RETM_IF(NULL == type_iter, "Invalid parameter !");
- RETM_IF(NULL == ac_iter, "Invalid parameter !");
-
- DBG("records length 0x%04X", rec_len);
-
- records = calloc(rec_len, sizeof(zb_zcl_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]);
- records[i] = NULL;
- }
- free(records);
- records = NULL;
-
- g_variant_iter_free(attr_iter);
- g_variant_iter_free(type_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++;
- }
- g_variant_iter_free(attr_iter);
- g_variant_iter_free(type_iter);
- g_variant_iter_free(ac_iter);
-
- cb(addr16, ep, clusterid, discoveryComplete, (void *)records, rec_len,
- container->userdata);
-
- for (j = 0; j < rec_len; j++) {
- if (records[j]) {
- free(records[j]);
- records[j] = NULL;
- }
- }
- if (records) {
- free(records);
- records = NULL;
- }
+ __zbl_zcl_global_discover_attr_ex_req(container, parameters);
}
break;
case ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ: {
-
- 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;
-
- zb_nwk_addr addr16;
- unsigned char ep;
- unsigned short clusterid;
- zb_zcl_global_attr_read_cb cb = container->cb;
-
- struct reporting_configuration_record_s **records = NULL;
-
- g_variant_get(parameters, "(qyqqa(yyqyqqayq))",
- &addr16, &ep, &clusterid, &record_length, &resp_iter);
- RETM_IF(NULL == resp_iter, "Invalid parameter !");
-
- records = calloc(record_length, sizeof(zb_zcl_reporting_config_record_h));
- RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
-
- 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;
- }
- }
-
- 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 (NULL == data_iter) {
- ERR("Invalid parameter !");
- goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT;
- }
-
- if (records[i]->dir != ZCL_REPORTING_DIRECTION_REPORTED &&
- (zb_zcl_get_analog_or_discret(records[i]->type) == ZB_ZCL_DATA_TYPE_ANALOG)) {
- data_size[i] = zb_zcl_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;
- g_variant_iter_free(data_iter);
- goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT;
- }
-
- while (g_variant_iter_loop(data_iter, "y", &value)) {
- change[j] = value;
- j++;
- }
- g_variant_iter_free(data_iter);
- records[i]->change = change;
- } else
- records[i]->change = NULL;
- } else
- records[i]->change = NULL;
- }
- g_variant_iter_free(resp_iter);
-
- cb(addr16, ep, clusterid, (void **)records, record_length, container->userdata);
-
-GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT:
- if (data_size) {
- free(data_size);
- data_size = NULL;
- }
- if (status) {
- free(status);
- status = NULL;
- }
-
- for (i = 0; i < record_length; i++) {
- if (records[i] && records[i]->change) {
- free(records[i]->change);
- records[i]->change = NULL;
- }
- if (records[i]) {
- free(records[i]);
- records[i] = NULL;
- }
- }
- if (records) {
- free(records);
- records = NULL;
- }
+ __zbl_zcl_global_read_config_reporting_req(container, parameters);
}
break;
/* ZCL Alarm */
}
break;
case ZBL_ZCL_GROUP_VIEW_GROUP_REQ: {
- zb_zcl_group_view_group_cb cb = container->cb;
-
- int j = 0;
- zb_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);
- if (NULL == grpNameiter) {
- ERR("Invalid grpNameiter");
- goto GROUP_VIEW_GROUP_REQ_OUT;
- }
-
- 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) {
- 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++;
- }
- g_variant_iter_free(grpNameiter);
- } else {
- group_name = calloc(2, sizeof(char));
- if (NULL == group_name) {
- g_variant_iter_free(grpNameiter);
- ERR("calloc() Fail(%d)", errno);
- goto GROUP_VIEW_GROUP_REQ_OUT;
- }
- group_name[j++] = value;
- group_name[j++] = '\0';
- }
-
- DBG("GroupName = %s", group_name);
- cb(addr16, ep, status, group_id, group_name, container->userdata);
-
-GROUP_VIEW_GROUP_REQ_OUT:
- if (group_name) {
- free(group_name);
- group_name = NULL;
- }
+ __zbl_zcl_group_view_group_req(container, parameters);
}
break;
case ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ: {
- zb_zcl_group_get_group_membership_cb cb = container->cb;
-
- int j = 0;
- zb_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);
- RETM_IF(NULL == grpListiter, "Invalid parameter !");
-
- if (group_count > 0) {
- grouplist = calloc(group_count+1, sizeof(unsigned short));
- if (NULL == grouplist) {
- 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++;
- }
- g_variant_iter_free(grpListiter);
- }
-
- cb(addr16, ep, capacity, group_count, grouplist, container->userdata);
-
- if (grouplist) {
- free(grouplist);
- grouplist = NULL;
- }
+ __zbl_zcl_group_get_group_membership_req(container, parameters);
}
break;
case ZBL_ZCL_GROUP_REMOVE_GROUP_REQ: {
}
break;
case ZBL_ZCL_SCENE_VIEW_SCENE_REQ: {
- zb_zcl_scene_view_scene_cb cb = container->cb;
-
- int j = 0;
- int len;
- zb_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, "(qyyqyqa(y)ya(y))", &addr16, &ep, &status, &group_id, &scene_id,
- &transition_time, &sceneNameIter, &ext_len, &extendedSetIter);
-
- if (!g_variant_iter_loop(sceneNameIter, "(y)", &value)) {
- ERR("There is no scene data");
- return;
- }
-
- /** 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:
- if (scene_name) {
- free(scene_name);
- scene_name = NULL;
- }
-
- if (extendedFieldSets) {
- free(extendedFieldSets);
- extendedFieldSets = NULL;
- }
+ __zbl_zcl_scene_view_scene_req(container, parameters);
}
break;
case ZBL_ZCL_SCENE_REMOVE_SCENE_REQ: {
}
break;
case ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ: {
- zb_zcl_scene_get_scene_membership_cb cb = container->cb;
-
- int j = 0;
- zb_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, "(qyyyqya(y))", &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:
- if (scene_list) {
- free(scene_list);
- scene_list = NULL;
- }
+ __zbl_zcl_scene_get_scene_membership_req(container, parameters);
}
break;
/* ZCL Thermostat */
projects / platform / core / api / zigbee.git / commitdiff