2 * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
4 * Contact: Suresh Kumar N (suresh.n@samsung.com)
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
19 #include "zigbee_service_interface_common.h"
21 #include <zblib_driver_zdo_dev_control.h>
23 static void *_service_interface_ref_zigbee_zdo_dev_control(ZigBeeServiceInterface *service_interface)
25 ZigbeeObjectSkeleton *zigbee_object = NULL;
26 ZigbeeCustomData_t *custom_data = NULL;
27 ZigbeeZdo_dev_control *dev_control_object = NULL;
29 custom_data = (ZigbeeCustomData_t *)zblib_service_interface_ref_user_data(service_interface);
30 if (NULL == custom_data) {
31 Z_LOGE("D-BUS service interface custom_data is NULL!");
35 /* Get zigbee object */
36 zigbee_object = g_hash_table_lookup(custom_data->objects, ZIGBEE_SERVICE_PATH);
37 if (NULL == zigbee_object) {
38 Z_LOGW("Cannot find ZigBee D-BUS interface object!", zigbee_object);
42 dev_control_object = zigbee_object_get_zdo_dev_control(ZIGBEE_OBJECT(zigbee_object));
43 return dev_control_object;
46 static void on_zdodev_control_nwk_addr_req_resp(ZigBeeServiceInterface *service_interface,
47 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
49 ZigbeeServiceInterfaceRespCbData_t *cb_data =
50 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
52 ZigbeeZdo_dev_control *dev_control_object;
53 GDBusMethodInvocation *invocation;
55 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
57 NOT_USED(service_interface);
60 if (NULL == resp_data || 0 == resp_data_len) {
61 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
66 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
67 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
69 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
70 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
72 zigbee_zdo_dev_control_complete_nwk_addr_req(dev_control_object, invocation,
78 static gboolean on_zdodev_control_nwk_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
79 GDBusMethodInvocation *invocation,
85 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
86 ZigbeeZdoDevControlNwkAddrReq_t req;
87 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
89 GVariantIter *iter = NULL;
94 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
96 /* Update request structure */
97 g_variant_get(eui64, "a(y)", &iter);
98 while (g_variant_iter_loop(iter, "(y)", &(req.eui64[i]))) {
100 if (i >= ZIGBEE_EUI64_SIZE)
103 req.request_type = request_type;
104 req.start_index = start_index;
106 /* Allocate response callback data */
108 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
109 invocation, NULL, 0);
110 if (NULL == resp_cb_data) {
111 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
113 /* Send failure response */
114 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
119 /* Dispatch request */
120 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
121 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
122 ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ,
124 on_zdodev_control_nwk_addr_req_resp, resp_cb_data);
126 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
128 /* Free response callback data */
129 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
131 /* Send failure response */
132 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
140 static void on_zdodev_control_matched_descriptor_req_resp(ZigBeeServiceInterface *service_interface,
141 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
143 ZigbeeServiceInterfaceRespCbData_t *cb_data =
144 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
146 ZigbeeZdo_dev_control *dev_control_object;
147 GDBusMethodInvocation *invocation;
149 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
151 NOT_USED(service_interface);
152 NOT_USED(request_id);
154 if (NULL == resp_data || 0 == resp_data_len) {
155 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
160 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
161 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
163 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
164 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
166 zigbee_zdo_dev_control_complete_matched_descriptor_req(dev_control_object,
167 invocation, payload->result);
172 static gboolean on_zdodev_control_matched_descriptor_req(ZigbeeZdo_dev_control *zdodev_control_object,
173 GDBusMethodInvocation *invocation,
182 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
183 ZigbeeZdoDevControlMatchedDescriptorReq_t req;
184 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
186 GVariantIter *iter = NULL;
191 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
193 /* Update request structure */
194 req.node_id = node_id;
195 req.profile_id = profile_id;
196 req.num_in_cl = num_in_cl;
198 req.in_cl = g_malloc0_n(num_in_cl, sizeof(unsigned short));
199 g_variant_get(in_cl, "aq", &iter);
200 while (g_variant_iter_loop(iter, "q", &(req.in_cl[i]))) {
210 req.num_out_cl = num_out_cl;
211 if (num_out_cl > 0) {
212 req.out_cl = g_malloc0_n(num_out_cl, sizeof(unsigned short));
213 g_variant_get(out_cl, "aq", &iter);
214 while (g_variant_iter_loop(iter, "q", &(req.out_cl[i]))) {
223 /* Allocate response callback data */
225 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
226 invocation, NULL, 0);
227 if (NULL == resp_cb_data) {
228 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
230 /* Send failure response */
231 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
238 /* Dispatch request */
239 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
240 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
241 ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ,
243 on_zdodev_control_matched_descriptor_req_resp, resp_cb_data);
250 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
252 /* Free response callback data */
253 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
255 /* Send failure response */
256 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
264 static void on_zdodev_control_ieee_addr_req_resp(ZigBeeServiceInterface *service_interface,
265 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
267 ZigbeeServiceInterfaceRespCbData_t *cb_data =
268 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
270 ZigbeeZdo_dev_control *dev_control_object;
271 GDBusMethodInvocation *invocation;
273 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
275 NOT_USED(service_interface);
276 NOT_USED(request_id);
278 if (NULL == resp_data || 0 == resp_data_len) {
279 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
284 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
285 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
287 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
288 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
290 zigbee_zdo_dev_control_complete_ieee_addr_req(dev_control_object,
291 invocation, payload->result);
296 static gboolean on_zdodev_control_ieee_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
297 GDBusMethodInvocation *invocation,
301 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
302 ZigbeeZdoDevControlIeeeAddrReq_t req;
303 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
307 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
309 /* Update request structure */
310 req.node_id = node_id;
312 /* Allocate response callback data */
314 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
315 invocation, NULL, 0);
316 if (NULL == resp_cb_data) {
317 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
319 /* Send failure response */
320 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
325 /* Dispatch request */
326 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
327 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
328 ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ,
330 on_zdodev_control_ieee_addr_req_resp, resp_cb_data);
332 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
334 /* Free response callback data */
335 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
337 /* Send failure response */
338 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
346 static void on_zdodev_control_active_ep_req_resp(ZigBeeServiceInterface *service_interface,
347 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
349 ZigbeeServiceInterfaceRespCbData_t *cb_data =
350 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
352 ZigbeeZdo_dev_control *dev_control_object;
353 GDBusMethodInvocation *invocation;
355 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
357 NOT_USED(service_interface);
358 NOT_USED(request_id);
360 if (NULL == resp_data || 0 == resp_data_len) {
361 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
366 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
367 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
369 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
370 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
372 zigbee_zdo_dev_control_complete_active_ep_req(dev_control_object,
373 invocation, payload->result);
378 static gboolean on_zdodev_control_active_ep_req(ZigbeeZdo_dev_control *zdodev_control_object,
379 GDBusMethodInvocation *invocation,
383 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
384 ZigbeeZdoDevControlActiveEpReq_t req;
385 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
389 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlActiveEpReq_t));
391 /* Update request structure */
392 req.node_id = node_id;
394 /* Allocate response callback data */
396 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
397 invocation, NULL, 0);
398 if (NULL == resp_cb_data) {
399 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
401 /* Send failure response */
402 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
407 /* Dispatch request */
408 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
409 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
410 ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ,
412 on_zdodev_control_active_ep_req_resp, resp_cb_data);
414 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
416 /* Free response callback data */
417 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
419 /* Send failure response */
420 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
428 static void on_zdodev_control_node_desc_req_resp(ZigBeeServiceInterface *service_interface,
429 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
431 ZigbeeServiceInterfaceRespCbData_t *cb_data =
432 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
434 ZigbeeZdo_dev_control *dev_control_object;
435 GDBusMethodInvocation *invocation;
437 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
439 NOT_USED(service_interface);
440 NOT_USED(request_id);
442 if (NULL == resp_data || 0 == resp_data_len) {
443 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
448 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
449 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
451 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
452 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
454 zigbee_zdo_dev_control_complete_node_desc_req(dev_control_object,
455 invocation, payload->result);
460 static gboolean on_zdodev_control_node_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
461 GDBusMethodInvocation *invocation,
465 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
466 ZigbeeZdoDevControlNodeDescriptorReq_t req;
467 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
471 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
473 /* Update request structure */
474 req.node_id = node_id;
476 /* Allocate response callback data */
478 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
479 invocation, NULL, 0);
480 if (NULL == resp_cb_data) {
481 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
483 /* Send failure response */
484 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
489 /* Dispatch request */
490 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
491 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
492 ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ,
494 on_zdodev_control_node_desc_req_resp, resp_cb_data);
496 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
498 /* Free response callback data */
499 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
501 /* Send failure response */
502 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
510 static void on_zdodev_control_power_desc_req_resp(ZigBeeServiceInterface *service_interface,
511 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
513 ZigbeeServiceInterfaceRespCbData_t *cb_data =
514 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
516 ZigbeeZdo_dev_control *dev_control_object;
517 GDBusMethodInvocation *invocation;
519 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
521 NOT_USED(service_interface);
522 NOT_USED(request_id);
524 if (NULL == resp_data || 0 == resp_data_len) {
525 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
530 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
531 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
533 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
534 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
536 zigbee_zdo_dev_control_complete_power_desc_req(dev_control_object,
537 invocation, payload->result);
542 static gboolean on_zdodev_control_power_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
543 GDBusMethodInvocation *invocation,
547 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
548 ZigbeeZdoDevControlPowerDescriptorReq_t req;
549 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
553 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
555 /* Update request structure */
556 req.node_id = node_id;
558 /* Allocate response callback data */
560 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
561 invocation, NULL, 0);
562 if (NULL == resp_cb_data) {
563 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
565 /* Send failure response */
566 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
571 /* Dispatch request */
572 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
573 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
574 ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ,
576 on_zdodev_control_power_desc_req_resp, resp_cb_data);
578 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
580 /* Free response callback data */
581 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
583 /* Send failure response */
584 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
592 static void on_zdodev_control_complex_desc_req_resp(ZigBeeServiceInterface *service_interface,
593 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
595 ZigbeeServiceInterfaceRespCbData_t *cb_data =
596 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
598 ZigbeeZdo_dev_control *dev_control_object;
599 GDBusMethodInvocation *invocation;
601 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
603 NOT_USED(service_interface);
604 NOT_USED(request_id);
606 if (NULL == resp_data || 0 == resp_data_len) {
607 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
612 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
613 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
615 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
616 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
618 zigbee_zdo_dev_control_complete_complex_desc_req(dev_control_object,
619 invocation, payload->result);
624 static gboolean on_zdodev_control_complex_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
625 GDBusMethodInvocation *invocation,
629 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
630 ZigbeeZdoDevControlComplexDescriptorReq_t req;
631 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
635 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
637 /* Update request structure */
638 req.node_id = node_id;
640 /* Allocate response callback data */
642 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
643 invocation, NULL, 0);
644 if (NULL == resp_cb_data) {
645 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
647 /* Send failure response */
648 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
653 /* Dispatch request */
654 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
655 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
656 ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ,
658 on_zdodev_control_complex_desc_req_resp, resp_cb_data);
660 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
662 /* Free response callback data */
663 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
665 /* Send failure response */
666 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
674 static void on_zdodev_control_user_desc_req_resp(ZigBeeServiceInterface *service_interface,
675 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
677 ZigbeeServiceInterfaceRespCbData_t *cb_data =
678 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
680 ZigbeeZdo_dev_control *dev_control_object;
681 GDBusMethodInvocation *invocation;
683 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
685 NOT_USED(service_interface);
686 NOT_USED(request_id);
688 if (NULL == resp_data || 0 == resp_data_len) {
689 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
694 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
695 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
697 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
698 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
700 zigbee_zdo_dev_control_complete_user_desc_req(dev_control_object,
701 invocation, payload->result);
706 static gboolean on_zdodev_control_user_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
707 GDBusMethodInvocation *invocation,
711 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
712 ZigbeeZdoDevControlUserDescriptorReq_t req;
713 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
717 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
719 /* Update request structure */
720 req.node_id = node_id;
722 /* Allocate response callback data */
724 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
725 invocation, NULL, 0);
726 if (NULL == resp_cb_data) {
727 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
729 /* Send failure response */
730 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
735 /* Dispatch request */
736 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
737 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
738 ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ,
740 on_zdodev_control_user_desc_req_resp, resp_cb_data);
742 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
744 /* Free response callback data */
745 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
747 /* Send failure response */
748 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
756 static void on_zdodev_control_user_desc_set_req_resp(ZigBeeServiceInterface *service_interface,
757 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
759 ZigbeeServiceInterfaceRespCbData_t *cb_data =
760 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
762 ZigbeeZdo_dev_control *dev_control_object;
763 GDBusMethodInvocation *invocation;
765 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
767 NOT_USED(service_interface);
768 NOT_USED(request_id);
770 if (NULL == resp_data || 0 == resp_data_len) {
771 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
776 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
777 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
779 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
780 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
782 zigbee_zdo_dev_control_complete_user_desc_set_req(dev_control_object,
783 invocation, payload->result);
788 static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdo_dev_control *zdodev_control_object,
789 GDBusMethodInvocation *invocation,
795 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
796 ZigbeeZdoDevControlUserDescriptorSetReq_t req;
797 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
799 GVariantIter *iter = NULL;
804 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
806 /* Update request structure */
807 req.node_id = node_id;
808 req.user_descriptor_len = length;
809 g_variant_get(user_desc, "a(y)", &iter);
810 while (g_variant_iter_loop(iter, "(y)", &(req.user_descriptor[i]))) {
812 if (i >= ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN)
816 /* Allocate response callback data */
818 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
819 invocation, NULL, 0);
820 if (NULL == resp_cb_data) {
821 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
823 /* Send failure response */
824 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
829 /* Dispatch request */
830 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
831 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
832 ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ,
834 on_zdodev_control_user_desc_set_req_resp, resp_cb_data);
836 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
838 /* Free response callback data */
839 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
841 /* Send failure response */
842 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
850 static void on_zdodev_control_device_announce_resp(ZigBeeServiceInterface *service_interface,
851 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
853 ZigbeeServiceInterfaceRespCbData_t *cb_data =
854 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
856 ZigbeeZdo_dev_control *dev_control_object;
857 GDBusMethodInvocation *invocation;
859 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
861 NOT_USED(service_interface);
862 NOT_USED(request_id);
864 if (NULL == resp_data || 0 == resp_data_len) {
865 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
870 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
871 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
873 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
874 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
876 zigbee_zdo_dev_control_complete_device_announce(dev_control_object,
877 invocation, payload->result);
882 static gboolean on_zdodev_control_device_announce(ZigbeeZdo_dev_control *zdodev_control_object,
883 GDBusMethodInvocation *invocation,
889 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
890 ZigbeeZdoDevControlDeviceAnnounce_t req;
891 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
893 GVariantIter *iter = NULL;
898 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
900 /* Update request structure */
901 req.node_id = node_id;
902 g_variant_get(mac_addr, "a(y)", &iter);
903 while (g_variant_iter_loop(iter, "(y)", &(req.mac_addr[i]))) {
905 if (i >= ZIGBEE_EUI64_SIZE)
908 req.capability = capability;
910 /* Allocate response callback data */
912 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
913 invocation, NULL, 0);
914 if (NULL == resp_cb_data) {
915 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
917 /* Send failure response */
918 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
923 /* Dispatch request */
924 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
925 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
926 ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE,
928 on_zdodev_control_device_announce_resp, resp_cb_data);
930 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
932 /* Free response callback data */
933 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
935 /* Send failure response */
936 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
944 static void on_zdodev_control_simple_desc_req_resp(ZigBeeServiceInterface *service_interface,
945 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
947 ZigbeeServiceInterfaceRespCbData_t *cb_data =
948 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
950 ZigbeeZdo_dev_control *dev_control_object;
951 GDBusMethodInvocation *invocation;
953 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
955 NOT_USED(service_interface);
956 NOT_USED(request_id);
958 if (NULL == resp_data || 0 == resp_data_len) {
959 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
964 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
965 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
967 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
968 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
970 zigbee_zdo_dev_control_complete_simple_desc_req(dev_control_object,
971 invocation, payload->result);
976 static gboolean on_zdodev_control_simple_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
977 GDBusMethodInvocation *invocation,
982 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
983 ZigbeeZdoDevControlSimpleDescriptorReq_t req;
984 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
988 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
990 /* Update request structure */
991 req.node_id = node_id;
992 req.endpoint = endpoint;
994 /* Allocate response callback data */
996 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
997 invocation, NULL, 0);
998 if (NULL == resp_cb_data) {
999 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1001 /* Send failure response */
1002 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1007 /* Dispatch request */
1008 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1009 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1010 ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ,
1012 on_zdodev_control_simple_desc_req_resp, resp_cb_data);
1014 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1016 /* Free response callback data */
1017 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1019 /* Send failure response */
1020 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1028 static void on_zdodev_control_mgmt_lqi_req_resp(ZigBeeServiceInterface *service_interface,
1029 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1031 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1032 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1034 ZigbeeZdo_dev_control *dev_control_object;
1035 GDBusMethodInvocation *invocation;
1037 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1039 NOT_USED(service_interface);
1040 NOT_USED(request_id);
1042 if (NULL == resp_data || 0 == resp_data_len) {
1043 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1048 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1049 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1051 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1052 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1054 zigbee_zdo_dev_control_complete_mgmt_lqi_req(dev_control_object,
1055 invocation, payload->result);
1060 static gboolean on_zdodev_control_mgmt_lqi_req(ZigbeeZdo_dev_control *zdodev_control_object,
1061 GDBusMethodInvocation *invocation,
1066 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1067 ZigbeeZdoDevControlMgmtLqiReq_t req;
1068 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1072 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
1074 /* Update request structure */
1075 req.node_id = node_id;
1076 req.start_index = start_idx;
1078 /* Allocate response callback data */
1080 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1081 invocation, NULL, 0);
1082 if (NULL == resp_cb_data) {
1083 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1085 /* Send failure response */
1086 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1091 /* Dispatch request */
1092 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1093 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1094 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ,
1096 on_zdodev_control_mgmt_lqi_req_resp, resp_cb_data);
1098 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1100 /* Free response callback data */
1101 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1103 /* Send failure response */
1104 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1112 static void on_zdodev_control_mgmt_rtg_req_resp(ZigBeeServiceInterface *service_interface,
1113 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1115 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1116 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1118 ZigbeeZdo_dev_control *dev_control_object;
1119 GDBusMethodInvocation *invocation;
1121 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1123 NOT_USED(service_interface);
1124 NOT_USED(request_id);
1126 if (NULL == resp_data || 0 == resp_data_len) {
1127 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1132 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1133 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1135 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1136 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1138 zigbee_zdo_dev_control_complete_mgmt_rtg_req(dev_control_object,
1139 invocation, payload->result);
1144 static gboolean on_zdodev_control_mgmt_rtg_req(ZigbeeZdo_dev_control *zdodev_control_object,
1145 GDBusMethodInvocation *invocation,
1150 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1151 ZigbeeZdoDevControlMgmtRtgReq_t req;
1152 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1156 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
1158 /* Update request structure */
1159 req.node_id = node_id;
1160 req.start_index = start_idx;
1162 /* Allocate response callback data */
1164 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1165 invocation, NULL, 0);
1166 if (NULL == resp_cb_data) {
1167 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1169 /* Send failure response */
1170 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1175 /* Dispatch request */
1176 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1177 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1178 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ,
1180 on_zdodev_control_mgmt_rtg_req_resp, resp_cb_data);
1182 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1184 /* Free response callback data */
1185 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1187 /* Send failure response */
1188 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1196 static void on_zdodev_control_mgmt_bind_req_resp(ZigBeeServiceInterface *service_interface,
1197 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1199 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1200 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1202 ZigbeeZdo_dev_control *dev_control_object;
1203 GDBusMethodInvocation *invocation;
1205 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1207 NOT_USED(service_interface);
1208 NOT_USED(request_id);
1210 if (NULL == resp_data || 0 == resp_data_len) {
1211 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1216 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1217 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1219 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1220 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1222 zigbee_zdo_dev_control_complete_mgmt_bind_req(dev_control_object,
1223 invocation, payload->result);
1228 static gboolean on_zdodev_control_mgmt_bind_req(ZigbeeZdo_dev_control *zdodev_control_object,
1229 GDBusMethodInvocation *invocation,
1234 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1235 ZigbeeZdoDevControlMgmtBindReq_t req;
1236 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1240 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
1242 /* Update request structure */
1243 req.node_id = node_id;
1244 req.start_index = start_idx;
1246 /* Allocate response callback data */
1248 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1249 invocation, NULL, 0);
1250 if (NULL == resp_cb_data) {
1251 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1253 /* Send failure response */
1254 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1259 /* Dispatch request */
1260 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1261 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1262 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ,
1264 on_zdodev_control_mgmt_bind_req_resp, resp_cb_data);
1266 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1268 /* Free response callback data */
1269 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1271 /* Send failure response */
1272 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1280 static void on_zdodev_control_mgmt_permit_join_req_resp(ZigBeeServiceInterface *service_interface,
1281 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1283 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1284 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1286 ZigbeeZdo_dev_control *dev_control_object;
1287 GDBusMethodInvocation *invocation;
1289 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1291 NOT_USED(service_interface);
1292 NOT_USED(request_id);
1294 if (NULL == resp_data || 0 == resp_data_len) {
1295 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1300 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1301 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1303 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1304 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1306 zigbee_zdo_dev_control_complete_mgmt_permit_join_req(dev_control_object,
1307 invocation, payload->result);
1312 static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zdodev_control_object,
1313 GDBusMethodInvocation *invocation,
1316 gchar tc_significance,
1319 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1320 ZigbeeZdoDevControlMgmtPermitJoinReq_t req;
1321 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1325 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
1327 /* Update request structure */
1328 req.node_id = node_id;
1329 req.duration = duration;
1330 req.tc_significance = tc_significance;
1332 /* Allocate response callback data */
1334 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1335 invocation, NULL, 0);
1336 if (NULL == resp_cb_data) {
1337 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1339 /* Send failure response */
1340 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1345 /* Dispatch request */
1346 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1347 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1348 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ,
1350 on_zdodev_control_mgmt_permit_join_req_resp, resp_cb_data);
1352 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1354 /* Free response callback data */
1355 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1357 /* Send failure response */
1358 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1366 static void on_zdodev_control_mgmt_nwk_update_req_resp(ZigBeeServiceInterface *service_interface,
1367 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1369 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1370 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1372 ZigbeeZdo_dev_control *dev_control_object;
1373 GDBusMethodInvocation *invocation;
1375 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1377 NOT_USED(service_interface);
1378 NOT_USED(request_id);
1380 if (NULL == resp_data || 0 == resp_data_len) {
1381 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1386 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1387 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1389 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1390 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1392 zigbee_zdo_dev_control_complete_mgmt_nwk_update_req(dev_control_object,
1393 invocation, payload->result);
1398 static gboolean on_zdodev_control_mgmt_nwk_update_req(ZigbeeZdo_dev_control *zdodev_control_object,
1399 GDBusMethodInvocation *invocation,
1402 gchar scan_duration,
1407 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1408 ZigbeeZdoDevControlMgmtNwkUpdateReq_t req;
1409 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1413 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtNwkUpdateReq_t));
1415 /* Update request structure */
1416 req.node_id = node_id;
1417 req.scan_channel = scan_channel;
1418 req.scan_duration = scan_duration;
1419 req.scan_count = scan_count;
1420 req.network_update_id = nwk_update_id;
1422 /* Allocate response callback data */
1424 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1425 invocation, NULL, 0);
1426 if (NULL == resp_cb_data) {
1427 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1429 /* Send failure response */
1430 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1435 /* Dispatch request */
1436 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1437 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1438 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ,
1440 on_zdodev_control_mgmt_nwk_update_req_resp, resp_cb_data);
1442 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1444 /* Free response callback data */
1445 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1447 /* Send failure response */
1448 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1456 static void on_zdodev_control_mgmt_nwk_disc_req_resp(ZigBeeServiceInterface *service_interface,
1457 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1459 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1460 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1462 ZigbeeZdo_dev_control *dev_control_object;
1463 GDBusMethodInvocation *invocation;
1465 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1467 NOT_USED(service_interface);
1468 NOT_USED(request_id);
1470 if (NULL == resp_data || 0 == resp_data_len) {
1471 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1476 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1477 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1479 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1480 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1482 zigbee_zdo_dev_control_complete_mgmt_nwk_disc_req(dev_control_object,
1483 invocation, payload->result);
1488 static gboolean on_zdodev_control_mgmt_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_control_object,
1489 GDBusMethodInvocation *invocation,
1492 gchar scan_duration,
1497 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1498 ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t req;
1499 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1503 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t));
1505 /* Update request structure */
1506 req.node_id = node_id;
1507 req.scan_channel = scan_channel;
1508 req.scan_duration = scan_duration;
1509 req.scan_count = scan_count;
1510 req.start_index = start_index;
1512 /* Allocate response callback data */
1514 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1515 invocation, NULL, 0);
1516 if (NULL == resp_cb_data) {
1517 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1519 /* Send failure response */
1520 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1525 /* Dispatch request */
1526 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1527 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1528 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ,
1530 on_zdodev_control_mgmt_nwk_disc_req_resp, resp_cb_data);
1532 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1534 /* Free response callback data */
1535 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1537 /* Send failure response */
1538 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1546 void zigbee_service_dbus_interface_zdo_dev_control_notification(ZigBeeServiceInterface *service_interface,
1547 guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
1549 ZigbeeZdo_dev_control *dev_control_object = NULL;
1551 zblib_check_null_ret("service_interface", service_interface);
1553 if (NULL == noti_data || 0 == noti_data_len) {
1554 Z_LOGE("noti_data is NULL");
1558 dev_control_object = _service_interface_ref_zigbee_zdo_dev_control(service_interface);
1559 zblib_check_null_ret("dev_control_object", dev_control_object);
1561 NOT_USED(noti_cb_data);
1564 case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_ADDR_RSP: {
1565 ZigbeeZdoDevControlNwkAddrResp_t *nwk_addr_t =
1566 (ZigbeeZdoDevControlNwkAddrResp_t*)noti_data;
1568 GVariant *v_eui64 = NULL;
1569 v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1570 nwk_addr_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
1571 if (NULL == v_eui64) {
1572 Z_LOGE("Failed to create variant!");
1574 Z_LOGD("nwk addr rsp : [0x%X]", nwk_addr_t->status);
1575 zigbee_zdo_dev_control_emit_nwk_addr_rsp(dev_control_object,
1576 nwk_addr_t->status, v_eui64, nwk_addr_t->node_id,
1577 nwk_addr_t->associated_count, nwk_addr_t->start_index);
1581 case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_ADDR_EXT_RSP: {
1582 ZigbeeZdoDevControlNwkAddrExtResp_t *nwk_addr_t =
1583 (ZigbeeZdoDevControlNwkAddrExtResp_t*)noti_data;
1585 GVariant *v_eui64 = NULL;
1586 GVariant *v_associated = NULL;
1587 v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1588 nwk_addr_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
1589 v_associated = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1590 nwk_addr_t->associated_addr_list,
1591 (sizeof(gushort) * nwk_addr_t->associated_count), TRUE, NULL, NULL);
1592 if (NULL == v_eui64 || NULL == v_associated) {
1593 Z_LOGE("Failed to create variant!");
1595 Z_LOGD("nwk addr ext rsp : [0x%X]", nwk_addr_t->status);
1596 zigbee_zdo_dev_control_emit_nwk_addr_ext_rsp(dev_control_object,
1597 nwk_addr_t->status, v_eui64, nwk_addr_t->node_id,
1598 nwk_addr_t->associated_count, nwk_addr_t->start_index, v_associated);
1601 g_variant_unref(v_eui64);
1603 g_variant_unref(v_associated);
1606 case ZBLIB_ZDO_DEV_CONTROL_NOTI_ACTIVE_EP_RSP: {
1607 ZigbeeZdoDevControlActiveEpResp_t *active_t =
1608 (ZigbeeZdoDevControlActiveEpResp_t *)noti_data;
1610 GVariant *v_ep_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1611 active_t->endpoint_list, active_t->endpoint_count, TRUE, NULL, NULL);
1612 if (NULL == v_ep_list) {
1613 Z_LOGE("Failed to create variant!");
1615 Z_LOGD("Active endpoint rsp : [0x%X]", active_t->status);
1616 zigbee_zdo_dev_control_emit_active_ep_rsp(dev_control_object,
1617 active_t->status, active_t->node_id,
1618 v_ep_list, active_t->endpoint_count);
1621 g_variant_unref(v_ep_list);
1624 case ZBLIB_ZDO_DEV_CONTROL_NOTI_SIMPLE_DESC_RSP: {
1625 ZigbeeZdoDevControlSimpleDescriptorResp_t *desc_t =
1626 (ZigbeeZdoDevControlSimpleDescriptorResp_t *)noti_data;
1628 GVariant *v_in_cluster = NULL;
1629 GVariant *v_out_cluster = NULL;
1630 v_in_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1631 desc_t->in_cluster, (sizeof(gushort) * desc_t->in_cluster_count),
1633 v_out_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1634 desc_t->out_cluster, (sizeof(gushort) * desc_t->out_cluster_count),
1636 if (NULL == v_in_cluster || NULL == v_out_cluster) {
1637 Z_LOGE("Failed to create variant!");
1639 Z_LOGD("Simple descriptor rsp");
1640 zigbee_zdo_dev_control_emit_simple_desc_rsp(dev_control_object,
1641 desc_t->node_id, desc_t->length, desc_t->device_version,
1642 desc_t->endpoint, desc_t->profile_id, desc_t->device_id,
1643 desc_t->in_cluster_count, desc_t->out_cluster_count,
1644 v_in_cluster, v_out_cluster);
1647 g_variant_unref(v_in_cluster);
1649 g_variant_unref(v_out_cluster);
1652 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MATCHED_DESC_RSP: {
1653 ZigbeeZdoDevControlMatchedDescriptorResp_t *desc_t =
1654 (ZigbeeZdoDevControlMatchedDescriptorResp_t *)noti_data;
1656 GVariant *v_match_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1657 desc_t->match_list, desc_t->list_count, TRUE, NULL, NULL);
1658 if (NULL == v_match_list) {
1659 Z_LOGE("Failed to create variant!");
1661 Z_LOGD("matched descriptor rsp : [0x%X]", desc_t->status);
1662 zigbee_zdo_dev_control_emit_matched_descriptor_rsp(dev_control_object,
1663 desc_t->status, desc_t->node_id, desc_t->list_count, v_match_list);
1666 g_variant_unref(v_match_list);
1669 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_BIND_RSP: {
1670 ZigbeeZdoDevControlMgmtBindResp_t *desc_t =
1671 (ZigbeeZdoDevControlMgmtBindResp_t *)noti_data;
1675 GVariant *v_entries = NULL;
1676 GVariantBuilder *entry_builder =
1677 g_variant_builder_new(G_VARIANT_TYPE("a(ayyqyqayy)"));
1678 if (NULL == entry_builder) {
1679 Z_LOGE("Failed to create variant builder!");
1683 for (i = 0; i < desc_t->table_list_count ; i++) {
1684 GVariantBuilder *eui64_builder =
1685 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1686 GVariantBuilder *dest_eui64_builder =
1687 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1689 if (NULL == eui64_builder || NULL == dest_eui64_builder) {
1690 Z_LOGE("Failed to create variant builder!");
1692 g_variant_builder_unref(eui64_builder);
1693 if (dest_eui64_builder)
1694 g_variant_builder_unref(dest_eui64_builder);
1695 g_variant_builder_unref(entry_builder);
1699 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1700 g_variant_builder_add(eui64_builder, "y",
1701 desc_t->table_list[i].eui64[v]);
1702 g_variant_builder_add(dest_eui64_builder, "y",
1703 desc_t->table_list[i].dest_eui64[v]);
1706 g_variant_builder_add(entry_builder, "(ayyqyqayy)",
1708 desc_t->table_list[i].source_endpoint,
1709 desc_t->table_list[i].cluster_id,
1710 desc_t->table_list[i].dest_addr_mode,
1711 desc_t->table_list[i].dest_addr,
1713 desc_t->table_list[i].dest_endpoint);
1715 g_variant_builder_unref(eui64_builder);
1716 g_variant_builder_unref(dest_eui64_builder);
1718 v_entries = g_variant_builder_end(entry_builder);
1720 Z_LOGD("management bind rsp : [0x%X]", desc_t->status);
1721 zigbee_zdo_dev_control_emit_mgmt_bind_rsp(dev_control_object,
1722 desc_t->status, desc_t->table_entries,
1723 desc_t->start_index, desc_t->table_list_count,
1726 g_variant_unref(v_entries);
1729 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LQI_RSP: {
1730 ZigbeeZdoDevControlMgmtLqiResp_t *desc_t =
1731 (ZigbeeZdoDevControlMgmtLqiResp_t *)noti_data;
1735 GVariant *v_entries = NULL;
1736 GVariantBuilder *entry_builder =
1737 g_variant_builder_new(G_VARIANT_TYPE("a(ayayyqyyyyy)"));
1738 if (NULL == entry_builder) {
1739 Z_LOGE("Failed to create variant builder!");
1743 for (i = 0; i < desc_t->table_list_count ; i++) {
1744 GVariantBuilder *ext_pan_builder =
1745 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1746 GVariantBuilder *eui64_builder =
1747 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1749 if (NULL == ext_pan_builder || NULL == eui64_builder) {
1750 Z_LOGE("Failed to create variant builder!");
1751 if (ext_pan_builder)
1752 g_variant_builder_unref(ext_pan_builder);
1754 g_variant_builder_unref(eui64_builder);
1755 g_variant_builder_unref(entry_builder);
1759 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1760 g_variant_builder_add(ext_pan_builder, "y",
1761 desc_t->table_list[i].extended_pan_id[v]);
1762 g_variant_builder_add(eui64_builder, "y",
1763 desc_t->table_list[i].eui64[v]);
1766 g_variant_builder_add(entry_builder, "(ayayyqyyyyy)",
1769 desc_t->table_list[i].node_id,
1770 desc_t->table_list[i].device_type,
1771 desc_t->table_list[i].rx_on_when_idle,
1772 desc_t->table_list[i].relationship,
1773 desc_t->table_list[i].permit_joining,
1774 desc_t->table_list[i].depth,
1775 desc_t->table_list[i].lqi);
1777 g_variant_builder_unref(ext_pan_builder);
1778 g_variant_builder_unref(eui64_builder);
1780 v_entries = g_variant_builder_end(entry_builder);
1782 Z_LOGD("management LQI rsp : [0x%X]", desc_t->status);
1783 zigbee_zdo_dev_control_emit_mgmt_lqi_rsp(dev_control_object,
1784 desc_t->status, desc_t->table_entries,
1785 desc_t->start_index, desc_t->table_list_count,
1789 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_RTG_RSP: {
1790 ZigbeeZdoDevControlMgmtRtgResp_t *desc_t =
1791 (ZigbeeZdoDevControlMgmtRtgResp_t *)noti_data;
1794 GVariant *v_entries = NULL;
1795 GVariantBuilder *entry_builder =
1796 g_variant_builder_new(G_VARIANT_TYPE("a(qyyyyq)"));
1797 if (NULL == entry_builder) {
1798 Z_LOGE("Failed to create variant builder!");
1802 for (i = 0; i < desc_t->table_list_count ; i++) {
1803 g_variant_builder_add(entry_builder, "(qyyyyq)",
1804 desc_t->table_list[i].dest_addr,
1805 desc_t->table_list[i].status,
1806 desc_t->table_list[i].memory_constrained,
1807 desc_t->table_list[i].many_to_one,
1808 desc_t->table_list[i].route_record_required,
1809 desc_t->table_list[i].next_hop_addr);
1811 v_entries = g_variant_builder_end(entry_builder);
1813 Z_LOGD("management routing rsp : [0x%X]", desc_t->status);
1814 zigbee_zdo_dev_control_emit_mgmt_rtg_rsp(dev_control_object,
1815 desc_t->status, desc_t->table_entries,
1816 desc_t->start_index, desc_t->table_list_count,
1820 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_PERMIT_JOIN_RSP: {
1821 ZigbeeZdoDevControlMgmtPermitJoinResp_t *resp_t =
1822 (ZigbeeZdoDevControlMgmtPermitJoinResp_t *)noti_data;
1824 zigbee_zdo_dev_control_emit_mgmt_permit_join_rsp(dev_control_object,
1828 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LEAVE_RSP: {
1829 ZigbeeZdoDevControlMgmtLeftResp_t *resp_t =
1830 (ZigbeeZdoDevControlMgmtLeftResp_t *)noti_data;
1832 zigbee_zdo_dev_control_emit_mgmt_leave_rsp(dev_control_object,
1836 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_NWK_DISC_RSP: {
1837 ZigbeeZdoDevControlMgmtNwkDiscoveryResp_t *nwk_disc_t =
1838 (ZigbeeZdoDevControlMgmtNwkDiscoveryResp_t *)noti_data;
1842 GVariant *v_entries = NULL;
1843 GVariantBuilder *entry_builder =
1844 g_variant_builder_new(G_VARIANT_TYPE("a(ayyyyyyy)"));
1845 if (NULL == entry_builder) {
1846 Z_LOGE("Failed to create variant builder!");
1850 for (i = 0; i < nwk_disc_t->table_list_count ; i++) {
1851 GVariantBuilder *ext_pan_builder =
1852 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1853 if (NULL == ext_pan_builder) {
1854 Z_LOGE("Failed to create variant builder!");
1855 g_variant_builder_unref(entry_builder);
1859 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1860 g_variant_builder_add(ext_pan_builder, "y",
1861 nwk_disc_t->table_list[i].extended_pan_id[v]);
1864 g_variant_builder_add(entry_builder, "(ayyyyyyy)",
1866 nwk_disc_t->table_list[i].logical_channel,
1867 nwk_disc_t->table_list[i].stack_profile,
1868 nwk_disc_t->table_list[i].zigbee_version,
1869 nwk_disc_t->table_list[i].beacon_order,
1870 nwk_disc_t->table_list[i].superframe_order,
1871 nwk_disc_t->table_list[i].permit_joining);
1873 g_variant_builder_unref(ext_pan_builder);
1875 v_entries = g_variant_builder_end(entry_builder);
1877 Z_LOGD("Network discovery rsp : [0x%X]", nwk_disc_t->status);
1878 zigbee_zdo_dev_control_emit_mgmt_nwk_disc_rsp(dev_control_object,
1879 nwk_disc_t->status, nwk_disc_t->network_count,
1880 nwk_disc_t->start_index, nwk_disc_t->table_list_count,
1883 g_variant_unref(v_entries);
1886 case ZBLIB_ZDO_DEV_CONTROL_NOTI_NODE_DESC_RSP: {
1887 ZigbeeZdoDevControlNodeDescriptorResp_t *desc_t =
1888 (ZigbeeZdoDevControlNodeDescriptorResp_t *)noti_data;
1890 zigbee_zdo_dev_control_emit_node_desc_rsp(dev_control_object,
1891 desc_t->status, desc_t->node_id, desc_t->logical_type,
1892 desc_t->complex_desciptor_available,
1893 desc_t->user_descriptor_available,
1894 desc_t->aps_flags, desc_t->frequency_band,
1895 desc_t->mac_capability_flags, desc_t->manufacturer_code,
1896 desc_t->max_buffer_size, desc_t->max_incoming_transfer_size,
1897 desc_t->server_mask, desc_t->max_outgoing_transfer_size,
1898 desc_t->descriptor_capability_field);
1901 case ZBLIB_ZDO_DEV_CONTROL_NOTI_POWER_DESC_RSP: {
1902 ZigbeeZdoDevControlPowerDescriptorResp_t *desc_t =
1903 (ZigbeeZdoDevControlPowerDescriptorResp_t *)noti_data;
1905 zigbee_zdo_dev_control_emit_power_desc_rsp(dev_control_object,
1906 desc_t->status, desc_t->node_id,
1907 desc_t->current_power_mode,
1908 desc_t->available_power_sources,
1909 desc_t->current_power_source,
1910 desc_t->current_power_source_level);
1913 case ZBLIB_ZDO_DEV_CONTROL_NOTI_COMPLEX_DESC_RSP: {
1914 ZigbeeZdoDevControlComplexDescriptorResp_t *desc_t =
1915 (ZigbeeZdoDevControlComplexDescriptorResp_t *)noti_data;
1917 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1918 desc_t->complex_descriptor_list, desc_t->list_count,
1920 if (NULL == v_desc_list) {
1921 Z_LOGE("Failed to create variant!");
1923 Z_LOGD("Complex descriptor rsp : [0x%X]", desc_t->status);
1924 zigbee_zdo_dev_control_emit_complex_desc_rsp(dev_control_object,
1925 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1929 case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_RSP: {
1930 ZigbeeZdoDevControlUserDescriptorResp_t *desc_t =
1931 (ZigbeeZdoDevControlUserDescriptorResp_t *)noti_data;
1933 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1934 desc_t->user_descriptor_list, desc_t->list_count,
1936 if (NULL == v_desc_list) {
1937 Z_LOGE("Failed to create variant!");
1939 Z_LOGD("User descriptor rsp : [0x%X]", desc_t->status);
1940 zigbee_zdo_dev_control_emit_user_desc_rsp(dev_control_object,
1941 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1944 g_variant_unref(v_desc_list);
1947 case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_CONFIRM: {
1948 ZigbeeZdoDevControlUserDescriptorConfirm_t *resp_t =
1949 (ZigbeeZdoDevControlUserDescriptorConfirm_t *)noti_data;
1951 zigbee_zdo_dev_control_emit_user_desc_confirm(dev_control_object,
1956 Z_LOGE("Unexpected notification [%x]", noti_id);
1960 /* ZigbeeZdo_dev_control should be dereferenced */
1961 g_object_unref(dev_control_object);
1964 gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
1965 ZigbeeObjectSkeleton *zigbee_object)
1967 ZigbeeZdo_dev_control *zdodev_control_object;
1969 if (NULL == service_interface) {
1970 Z_LOGE("service_interface is NULL");
1974 zdodev_control_object = zigbee_zdo_dev_control_skeleton_new();
1975 zigbee_object_skeleton_set_zdo_dev_control(zigbee_object, zdodev_control_object);
1976 g_object_unref(zdodev_control_object);
1978 Z_LOGI("zdodev_control_object: [%p]", zdodev_control_object);
1981 * Register signal handlers for 'zdodev_control' interface
1983 g_signal_connect(zdodev_control_object,
1984 "handle-nwk-addr-req",
1985 G_CALLBACK(on_zdodev_control_nwk_addr_req), service_interface);
1987 g_signal_connect(zdodev_control_object,
1988 "handle-matched-descriptor-req",
1989 G_CALLBACK(on_zdodev_control_matched_descriptor_req), service_interface);
1991 g_signal_connect(zdodev_control_object,
1992 "handle-ieee-addr-req",
1993 G_CALLBACK(on_zdodev_control_ieee_addr_req), service_interface);
1995 g_signal_connect(zdodev_control_object,
1996 "handle-active-ep-req",
1997 G_CALLBACK(on_zdodev_control_active_ep_req), service_interface);
1999 g_signal_connect(zdodev_control_object,
2000 "handle-node-desc-req",
2001 G_CALLBACK(on_zdodev_control_node_desc_req), service_interface);
2003 g_signal_connect(zdodev_control_object,
2004 "handle-power-desc-req",
2005 G_CALLBACK(on_zdodev_control_power_desc_req), service_interface);
2007 g_signal_connect(zdodev_control_object,
2008 "handle-complex-desc-req",
2009 G_CALLBACK(on_zdodev_control_complex_desc_req), service_interface);
2011 g_signal_connect(zdodev_control_object,
2012 "handle-user-desc-req",
2013 G_CALLBACK(on_zdodev_control_user_desc_req), service_interface);
2015 g_signal_connect(zdodev_control_object,
2016 "handle-user-desc-set-req",
2017 G_CALLBACK(on_zdodev_control_user_desc_set_req), service_interface);
2019 g_signal_connect(zdodev_control_object,
2020 "handle-device-announce",
2021 G_CALLBACK(on_zdodev_control_device_announce), service_interface);
2023 g_signal_connect(zdodev_control_object,
2024 "handle-simple-desc-req",
2025 G_CALLBACK(on_zdodev_control_simple_desc_req), service_interface);
2027 g_signal_connect(zdodev_control_object,
2028 "handle-mgmt-lqi-req",
2029 G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service_interface);
2031 g_signal_connect(zdodev_control_object,
2032 "handle-mgmt-rtg-req",
2033 G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service_interface);
2035 g_signal_connect(zdodev_control_object,
2036 "handle-mgmt-bind-req",
2037 G_CALLBACK(on_zdodev_control_mgmt_bind_req), service_interface);
2039 g_signal_connect(zdodev_control_object,
2040 "handle-mgmt-permit-join-req",
2041 G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface);
2043 g_signal_connect(zdodev_control_object,
2044 "handle-mgmt-nwk-update-req",
2045 G_CALLBACK(on_zdodev_control_mgmt_nwk_update_req), service_interface);
2047 g_signal_connect(zdodev_control_object,
2048 "handle-mgmt-nwk-disc-req",
2049 G_CALLBACK(on_zdodev_control_mgmt_nwk_disc_req), service_interface);