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);
236 /* Dispatch request */
237 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
238 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
239 ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ,
241 on_zdodev_control_matched_descriptor_req_resp, resp_cb_data);
248 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
250 /* Free response callback data */
251 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
253 /* Send failure response */
254 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
262 static void on_zdodev_control_ieee_addr_req_resp(ZigBeeServiceInterface *service_interface,
263 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
265 ZigbeeServiceInterfaceRespCbData_t *cb_data =
266 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
268 ZigbeeZdo_dev_control *dev_control_object;
269 GDBusMethodInvocation *invocation;
271 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
273 NOT_USED(service_interface);
274 NOT_USED(request_id);
276 if (NULL == resp_data || 0 == resp_data_len) {
277 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
282 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
283 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
285 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
286 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
288 zigbee_zdo_dev_control_complete_ieee_addr_req(dev_control_object,
289 invocation, payload->result);
294 static gboolean on_zdodev_control_ieee_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
295 GDBusMethodInvocation *invocation,
299 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
300 ZigbeeZdoDevControlIeeeAddrReq_t req;
301 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
305 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
307 /* Update request structure */
308 req.node_id = node_id;
310 /* Allocate response callback data */
312 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
313 invocation, NULL, 0);
314 if (NULL == resp_cb_data) {
315 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
317 /* Send failure response */
318 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
323 /* Dispatch request */
324 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
325 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
326 ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ,
328 on_zdodev_control_ieee_addr_req_resp, resp_cb_data);
330 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
332 /* Free response callback data */
333 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
335 /* Send failure response */
336 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
344 static void on_zdodev_control_active_ep_req_resp(ZigBeeServiceInterface *service_interface,
345 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
347 ZigbeeServiceInterfaceRespCbData_t *cb_data =
348 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
350 ZigbeeZdo_dev_control *dev_control_object;
351 GDBusMethodInvocation *invocation;
353 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
355 NOT_USED(service_interface);
356 NOT_USED(request_id);
358 if (NULL == resp_data || 0 == resp_data_len) {
359 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
364 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
365 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
367 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
368 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
370 zigbee_zdo_dev_control_complete_active_ep_req(dev_control_object,
371 invocation, payload->result);
376 static gboolean on_zdodev_control_active_ep_req(ZigbeeZdo_dev_control *zdodev_control_object,
377 GDBusMethodInvocation *invocation,
381 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
382 ZigbeeZdoDevControlActiveEpReq_t req;
383 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
387 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlActiveEpReq_t));
389 /* Update request structure */
390 req.node_id = node_id;
392 /* Allocate response callback data */
394 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
395 invocation, NULL, 0);
396 if (NULL == resp_cb_data) {
397 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
399 /* Send failure response */
400 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
405 /* Dispatch request */
406 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
407 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
408 ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ,
410 on_zdodev_control_active_ep_req_resp, resp_cb_data);
412 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
414 /* Free response callback data */
415 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
417 /* Send failure response */
418 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
426 static void on_zdodev_control_node_desc_req_resp(ZigBeeServiceInterface *service_interface,
427 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
429 ZigbeeServiceInterfaceRespCbData_t *cb_data =
430 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
432 ZigbeeZdo_dev_control *dev_control_object;
433 GDBusMethodInvocation *invocation;
435 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
437 NOT_USED(service_interface);
438 NOT_USED(request_id);
440 if (NULL == resp_data || 0 == resp_data_len) {
441 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
446 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
447 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
449 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
450 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
452 zigbee_zdo_dev_control_complete_node_desc_req(dev_control_object,
453 invocation, payload->result);
458 static gboolean on_zdodev_control_node_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
459 GDBusMethodInvocation *invocation,
463 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
464 ZigbeeZdoDevControlNodeDescriptorReq_t req;
465 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
469 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
471 /* Update request structure */
472 req.node_id = node_id;
474 /* Allocate response callback data */
476 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
477 invocation, NULL, 0);
478 if (NULL == resp_cb_data) {
479 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
481 /* Send failure response */
482 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
487 /* Dispatch request */
488 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
489 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
490 ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ,
492 on_zdodev_control_node_desc_req_resp, resp_cb_data);
494 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
496 /* Free response callback data */
497 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
499 /* Send failure response */
500 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
508 static void on_zdodev_control_power_desc_req_resp(ZigBeeServiceInterface *service_interface,
509 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
511 ZigbeeServiceInterfaceRespCbData_t *cb_data =
512 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
514 ZigbeeZdo_dev_control *dev_control_object;
515 GDBusMethodInvocation *invocation;
517 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
519 NOT_USED(service_interface);
520 NOT_USED(request_id);
522 if (NULL == resp_data || 0 == resp_data_len) {
523 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
528 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
529 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
531 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
532 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
534 zigbee_zdo_dev_control_complete_power_desc_req(dev_control_object,
535 invocation, payload->result);
540 static gboolean on_zdodev_control_power_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
541 GDBusMethodInvocation *invocation,
545 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
546 ZigbeeZdoDevControlPowerDescriptorReq_t req;
547 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
551 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
553 /* Update request structure */
554 req.node_id = node_id;
556 /* Allocate response callback data */
558 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
559 invocation, NULL, 0);
560 if (NULL == resp_cb_data) {
561 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
563 /* Send failure response */
564 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
569 /* Dispatch request */
570 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
571 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
572 ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ,
574 on_zdodev_control_power_desc_req_resp, resp_cb_data);
576 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
578 /* Free response callback data */
579 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
581 /* Send failure response */
582 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
590 static void on_zdodev_control_complex_desc_req_resp(ZigBeeServiceInterface *service_interface,
591 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
593 ZigbeeServiceInterfaceRespCbData_t *cb_data =
594 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
596 ZigbeeZdo_dev_control *dev_control_object;
597 GDBusMethodInvocation *invocation;
599 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
601 NOT_USED(service_interface);
602 NOT_USED(request_id);
604 if (NULL == resp_data || 0 == resp_data_len) {
605 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
610 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
611 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
613 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
614 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
616 zigbee_zdo_dev_control_complete_complex_desc_req(dev_control_object,
617 invocation, payload->result);
622 static gboolean on_zdodev_control_complex_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
623 GDBusMethodInvocation *invocation,
627 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
628 ZigbeeZdoDevControlComplexDescriptorReq_t req;
629 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
633 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
635 /* Update request structure */
636 req.node_id = node_id;
638 /* Allocate response callback data */
640 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
641 invocation, NULL, 0);
642 if (NULL == resp_cb_data) {
643 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
645 /* Send failure response */
646 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
651 /* Dispatch request */
652 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
653 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
654 ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ,
656 on_zdodev_control_complex_desc_req_resp, resp_cb_data);
658 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
660 /* Free response callback data */
661 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
663 /* Send failure response */
664 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
672 static void on_zdodev_control_user_desc_req_resp(ZigBeeServiceInterface *service_interface,
673 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
675 ZigbeeServiceInterfaceRespCbData_t *cb_data =
676 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
678 ZigbeeZdo_dev_control *dev_control_object;
679 GDBusMethodInvocation *invocation;
681 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
683 NOT_USED(service_interface);
684 NOT_USED(request_id);
686 if (NULL == resp_data || 0 == resp_data_len) {
687 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
692 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
693 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
695 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
696 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
698 zigbee_zdo_dev_control_complete_user_desc_req(dev_control_object,
699 invocation, payload->result);
704 static gboolean on_zdodev_control_user_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
705 GDBusMethodInvocation *invocation,
709 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
710 ZigbeeZdoDevControlUserDescriptorReq_t req;
711 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
715 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
717 /* Update request structure */
718 req.node_id = node_id;
720 /* Allocate response callback data */
722 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
723 invocation, NULL, 0);
724 if (NULL == resp_cb_data) {
725 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
727 /* Send failure response */
728 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
733 /* Dispatch request */
734 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
735 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
736 ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ,
738 on_zdodev_control_user_desc_req_resp, resp_cb_data);
740 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
742 /* Free response callback data */
743 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
745 /* Send failure response */
746 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
754 static void on_zdodev_control_user_desc_set_req_resp(ZigBeeServiceInterface *service_interface,
755 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
757 ZigbeeServiceInterfaceRespCbData_t *cb_data =
758 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
760 ZigbeeZdo_dev_control *dev_control_object;
761 GDBusMethodInvocation *invocation;
763 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
765 NOT_USED(service_interface);
766 NOT_USED(request_id);
768 if (NULL == resp_data || 0 == resp_data_len) {
769 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
774 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
775 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
777 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
778 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
780 zigbee_zdo_dev_control_complete_user_desc_set_req(dev_control_object,
781 invocation, payload->result);
786 static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdo_dev_control *zdodev_control_object,
787 GDBusMethodInvocation *invocation,
793 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
794 ZigbeeZdoDevControlUserDescriptorSetReq_t req;
795 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
797 GVariantIter *iter = NULL;
802 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
804 /* Update request structure */
805 req.node_id = node_id;
806 req.user_descriptor_len = length;
807 g_variant_get(user_desc, "a(y)", &iter);
808 while (g_variant_iter_loop(iter, "(y)", &(req.user_descriptor[i]))) {
810 if (i >= ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN)
814 /* Allocate response callback data */
816 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
817 invocation, NULL, 0);
818 if (NULL == resp_cb_data) {
819 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
821 /* Send failure response */
822 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
827 /* Dispatch request */
828 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
829 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
830 ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ,
832 on_zdodev_control_user_desc_set_req_resp, resp_cb_data);
834 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
836 /* Free response callback data */
837 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
839 /* Send failure response */
840 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
848 static void on_zdodev_control_device_announce_resp(ZigBeeServiceInterface *service_interface,
849 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
851 ZigbeeServiceInterfaceRespCbData_t *cb_data =
852 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
854 ZigbeeZdo_dev_control *dev_control_object;
855 GDBusMethodInvocation *invocation;
857 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
859 NOT_USED(service_interface);
860 NOT_USED(request_id);
862 if (NULL == resp_data || 0 == resp_data_len) {
863 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
868 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
869 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
871 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
872 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
874 zigbee_zdo_dev_control_complete_device_announce(dev_control_object,
875 invocation, payload->result);
880 static gboolean on_zdodev_control_device_announce(ZigbeeZdo_dev_control *zdodev_control_object,
881 GDBusMethodInvocation *invocation,
887 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
888 ZigbeeZdoDevControlDeviceAnnounce_t req;
889 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
891 GVariantIter *iter = NULL;
896 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
898 /* Update request structure */
899 req.node_id = node_id;
900 g_variant_get(mac_addr, "a(y)", &iter);
901 while (g_variant_iter_loop(iter, "(y)", &(req.mac_addr[i]))) {
903 if (i >= ZIGBEE_EUI64_SIZE)
906 req.capability = capability;
908 /* Allocate response callback data */
910 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
911 invocation, NULL, 0);
912 if (NULL == resp_cb_data) {
913 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
915 /* Send failure response */
916 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
921 /* Dispatch request */
922 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
923 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
924 ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE,
926 on_zdodev_control_device_announce_resp, resp_cb_data);
928 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
930 /* Free response callback data */
931 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
933 /* Send failure response */
934 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
942 static void on_zdodev_control_simple_desc_req_resp(ZigBeeServiceInterface *service_interface,
943 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
945 ZigbeeServiceInterfaceRespCbData_t *cb_data =
946 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
948 ZigbeeZdo_dev_control *dev_control_object;
949 GDBusMethodInvocation *invocation;
951 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
953 NOT_USED(service_interface);
954 NOT_USED(request_id);
956 if (NULL == resp_data || 0 == resp_data_len) {
957 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
962 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
963 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
965 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
966 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
968 zigbee_zdo_dev_control_complete_simple_desc_req(dev_control_object,
969 invocation, payload->result);
974 static gboolean on_zdodev_control_simple_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
975 GDBusMethodInvocation *invocation,
980 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
981 ZigbeeZdoDevControlSimpleDescriptorReq_t req;
982 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
986 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
988 /* Update request structure */
989 req.node_id = node_id;
990 req.endpoint = endpoint;
992 /* Allocate response callback data */
994 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
995 invocation, NULL, 0);
996 if (NULL == resp_cb_data) {
997 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
999 /* Send failure response */
1000 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1005 /* Dispatch request */
1006 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1007 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1008 ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ,
1010 on_zdodev_control_simple_desc_req_resp, resp_cb_data);
1012 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1014 /* Free response callback data */
1015 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1017 /* Send failure response */
1018 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1026 static void on_zdodev_control_mgmt_lqi_req_resp(ZigBeeServiceInterface *service_interface,
1027 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1029 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1030 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1032 ZigbeeZdo_dev_control *dev_control_object;
1033 GDBusMethodInvocation *invocation;
1035 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1037 NOT_USED(service_interface);
1038 NOT_USED(request_id);
1040 if (NULL == resp_data || 0 == resp_data_len) {
1041 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1046 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1047 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1049 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1050 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1052 zigbee_zdo_dev_control_complete_mgmt_lqi_req(dev_control_object,
1053 invocation, payload->result);
1058 static gboolean on_zdodev_control_mgmt_lqi_req(ZigbeeZdo_dev_control *zdodev_control_object,
1059 GDBusMethodInvocation *invocation,
1064 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1065 ZigbeeZdoDevControlMgmtLqiReq_t req;
1066 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1070 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
1072 /* Update request structure */
1073 req.node_id = node_id;
1074 req.start_index = start_idx;
1076 /* Allocate response callback data */
1078 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1079 invocation, NULL, 0);
1080 if (NULL == resp_cb_data) {
1081 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1083 /* Send failure response */
1084 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1089 /* Dispatch request */
1090 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1091 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1092 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ,
1094 on_zdodev_control_mgmt_lqi_req_resp, resp_cb_data);
1096 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1098 /* Free response callback data */
1099 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1101 /* Send failure response */
1102 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1110 static void on_zdodev_control_mgmt_rtg_req_resp(ZigBeeServiceInterface *service_interface,
1111 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1113 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1114 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1116 ZigbeeZdo_dev_control *dev_control_object;
1117 GDBusMethodInvocation *invocation;
1119 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1121 NOT_USED(service_interface);
1122 NOT_USED(request_id);
1124 if (NULL == resp_data || 0 == resp_data_len) {
1125 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1130 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1131 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1133 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1134 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1136 zigbee_zdo_dev_control_complete_mgmt_rtg_req(dev_control_object,
1137 invocation, payload->result);
1142 static gboolean on_zdodev_control_mgmt_rtg_req(ZigbeeZdo_dev_control *zdodev_control_object,
1143 GDBusMethodInvocation *invocation,
1148 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1149 ZigbeeZdoDevControlMgmtRtgReq_t req;
1150 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1154 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
1156 /* Update request structure */
1157 req.node_id = node_id;
1158 req.start_index = start_idx;
1160 /* Allocate response callback data */
1162 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1163 invocation, NULL, 0);
1164 if (NULL == resp_cb_data) {
1165 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1167 /* Send failure response */
1168 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1173 /* Dispatch request */
1174 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1175 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1176 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ,
1178 on_zdodev_control_mgmt_rtg_req_resp, resp_cb_data);
1180 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1182 /* Free response callback data */
1183 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1185 /* Send failure response */
1186 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1194 static void on_zdodev_control_mgmt_bind_req_resp(ZigBeeServiceInterface *service_interface,
1195 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1197 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1198 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1200 ZigbeeZdo_dev_control *dev_control_object;
1201 GDBusMethodInvocation *invocation;
1203 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1205 NOT_USED(service_interface);
1206 NOT_USED(request_id);
1208 if (NULL == resp_data || 0 == resp_data_len) {
1209 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1214 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1215 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1217 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1218 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1220 zigbee_zdo_dev_control_complete_mgmt_bind_req(dev_control_object,
1221 invocation, payload->result);
1226 static gboolean on_zdodev_control_mgmt_bind_req(ZigbeeZdo_dev_control *zdodev_control_object,
1227 GDBusMethodInvocation *invocation,
1232 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1233 ZigbeeZdoDevControlMgmtBindReq_t req;
1234 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1238 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
1240 /* Update request structure */
1241 req.node_id = node_id;
1242 req.start_index = start_idx;
1244 /* Allocate response callback data */
1246 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1247 invocation, NULL, 0);
1248 if (NULL == resp_cb_data) {
1249 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1251 /* Send failure response */
1252 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1257 /* Dispatch request */
1258 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1259 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1260 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ,
1262 on_zdodev_control_mgmt_bind_req_resp, resp_cb_data);
1264 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1266 /* Free response callback data */
1267 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1269 /* Send failure response */
1270 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1278 static void on_zdodev_control_mgmt_permit_join_req_resp(ZigBeeServiceInterface *service_interface,
1279 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1281 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1282 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1284 ZigbeeZdo_dev_control *dev_control_object;
1285 GDBusMethodInvocation *invocation;
1287 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1289 NOT_USED(service_interface);
1290 NOT_USED(request_id);
1292 if (NULL == resp_data || 0 == resp_data_len) {
1293 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1298 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1299 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1301 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1302 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1304 zigbee_zdo_dev_control_complete_mgmt_permit_join_req(dev_control_object,
1305 invocation, payload->result);
1310 static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zdodev_control_object,
1311 GDBusMethodInvocation *invocation,
1314 gchar tc_significance,
1317 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1318 ZigbeeZdoDevControlMgmtPermitJoinReq_t req;
1319 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1323 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
1325 /* Update request structure */
1326 req.node_id = node_id;
1327 req.duration = duration;
1328 req.tc_significance = tc_significance;
1330 /* Allocate response callback data */
1332 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1333 invocation, NULL, 0);
1334 if (NULL == resp_cb_data) {
1335 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1337 /* Send failure response */
1338 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1343 /* Dispatch request */
1344 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1345 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1346 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ,
1348 on_zdodev_control_mgmt_permit_join_req_resp, resp_cb_data);
1350 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1352 /* Free response callback data */
1353 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1355 /* Send failure response */
1356 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1364 static void on_zdodev_control_nwk_update_req_resp(ZigBeeServiceInterface *service_interface,
1365 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1367 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1368 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1370 ZigbeeZdo_dev_control *dev_control_object;
1371 GDBusMethodInvocation *invocation;
1373 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1375 NOT_USED(service_interface);
1376 NOT_USED(request_id);
1378 if (NULL == resp_data || 0 == resp_data_len) {
1379 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1384 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1385 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1387 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1388 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1390 zigbee_zdo_dev_control_complete_nwk_update_req(dev_control_object,
1391 invocation, payload->result);
1396 static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdo_dev_control *zdodev_control_object,
1397 GDBusMethodInvocation *invocation,
1400 gchar scan_duration,
1405 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1406 ZigbeeZdoDevControlNwkUpdateReq_t req;
1407 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1411 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
1413 /* Update request structure */
1414 req.node_id = node_id;
1415 req.scan_channel = scan_channel;
1416 req.scan_duration = scan_duration;
1417 req.scan_count = scan_count;
1418 req.network_update_id = nwk_update_id;
1420 /* Allocate response callback data */
1422 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1423 invocation, NULL, 0);
1424 if (NULL == resp_cb_data) {
1425 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1427 /* Send failure response */
1428 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1433 /* Dispatch request */
1434 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1435 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1436 ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ,
1438 on_zdodev_control_nwk_update_req_resp, resp_cb_data);
1440 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1442 /* Free response callback data */
1443 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1445 /* Send failure response */
1446 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1454 static void on_zdodev_control_nwk_disc_req_resp(ZigBeeServiceInterface *service_interface,
1455 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1457 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1458 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1460 ZigbeeZdo_dev_control *dev_control_object;
1461 GDBusMethodInvocation *invocation;
1463 ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1465 NOT_USED(service_interface);
1466 NOT_USED(request_id);
1468 if (NULL == resp_data || 0 == resp_data_len) {
1469 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1474 dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1475 zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1477 invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1478 zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1480 zigbee_zdo_dev_control_complete_nwk_disc_req(dev_control_object,
1481 invocation, payload->result);
1486 static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_control_object,
1487 GDBusMethodInvocation *invocation,
1490 gchar scan_duration,
1495 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1496 ZigbeeZdoDevControlNwkDiscoveryReq_t req;
1497 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1501 memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkDiscoveryReq_t));
1503 /* Update request structure */
1504 req.node_id = node_id;
1505 req.scan_channel = scan_channel;
1506 req.scan_duration = scan_duration;
1507 req.scan_count = scan_count;
1508 req.start_index = start_index;
1510 /* Allocate response callback data */
1512 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1513 invocation, NULL, 0);
1514 if (NULL == resp_cb_data) {
1515 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1517 /* Send failure response */
1518 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1523 /* Dispatch request */
1524 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1525 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1526 ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ,
1528 on_zdodev_control_nwk_disc_req_resp, resp_cb_data);
1530 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1532 /* Free response callback data */
1533 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1535 /* Send failure response */
1536 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1544 void zigbee_service_dbus_interface_zdo_dev_control_notification(ZigBeeServiceInterface *service_interface,
1545 guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
1547 ZigbeeZdo_dev_control *dev_control_object = NULL;
1549 zblib_check_null_ret("service_interface", service_interface);
1551 if (NULL == noti_data || 0 == noti_data_len) {
1552 Z_LOGE("noti_data is NULL");
1556 dev_control_object = _service_interface_ref_zigbee_zdo_dev_control(service_interface);
1557 zblib_check_null_ret("dev_control_object", dev_control_object);
1559 NOT_USED(noti_cb_data);
1562 case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_ADDR_RSP: {
1563 ZigbeeZdoDevControlNwkAddrResp_t *nwk_addr_t =
1564 (ZigbeeZdoDevControlNwkAddrResp_t*)noti_data;
1566 GVariant *v_eui64 = NULL;
1567 v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1568 nwk_addr_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
1569 if (NULL == v_eui64) {
1570 Z_LOGE("Failed to create variant!");
1572 Z_LOGD("nwk addr rsp : [0x%X]", nwk_addr_t->status);
1573 zigbee_zdo_dev_control_emit_nwk_addr_rsp(dev_control_object,
1574 nwk_addr_t->status, v_eui64, nwk_addr_t->node_id,
1575 nwk_addr_t->associated_count, nwk_addr_t->start_index);
1579 case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_ADDR_EXT_RSP: {
1580 ZigbeeZdoDevControlNwkAddrExtResp_t *nwk_addr_t =
1581 (ZigbeeZdoDevControlNwkAddrExtResp_t*)noti_data;
1583 GVariant *v_eui64 = NULL;
1584 GVariant *v_associated = NULL;
1585 v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1586 nwk_addr_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
1587 v_associated = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1588 nwk_addr_t->associated_addr_list,
1589 (sizeof(gushort) * nwk_addr_t->associated_count), TRUE, NULL, NULL);
1590 if (NULL == v_eui64 || NULL == v_associated) {
1591 Z_LOGE("Failed to create variant!");
1593 g_variant_unref(v_eui64);
1595 g_variant_unref(v_associated);
1597 Z_LOGD("nwk addr ext rsp : [0x%X]", nwk_addr_t->status);
1598 zigbee_zdo_dev_control_emit_nwk_addr_ext_rsp(dev_control_object,
1599 nwk_addr_t->status, v_eui64, nwk_addr_t->node_id,
1600 nwk_addr_t->associated_count, nwk_addr_t->start_index, v_associated);
1604 case ZBLIB_ZDO_DEV_CONTROL_NOTI_ACTIVE_EP_RSP: {
1605 ZigbeeZdoDevControlActiveEpResp_t *active_t =
1606 (ZigbeeZdoDevControlActiveEpResp_t *)noti_data;
1608 GVariant *v_ep_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1609 active_t->endpoint_list, active_t->endpoint_count, TRUE, NULL, NULL);
1610 if (NULL == v_ep_list) {
1611 Z_LOGE("Failed to create variant!");
1613 Z_LOGD("Active endpoint rsp : [0x%X]", active_t->status);
1614 zigbee_zdo_dev_control_emit_active_ep_rsp(dev_control_object,
1615 active_t->status, active_t->node_id,
1616 v_ep_list, active_t->endpoint_count);
1620 case ZBLIB_ZDO_DEV_CONTROL_NOTI_SIMPLE_DESC_RSP: {
1621 ZigbeeZdoDevControlSimpleDescriptorResp_t *desc_t =
1622 (ZigbeeZdoDevControlSimpleDescriptorResp_t *)noti_data;
1624 GVariant *v_in_cluster = NULL;
1625 GVariant *v_out_cluster = NULL;
1626 v_in_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1627 desc_t->in_cluster, (sizeof(gushort) * desc_t->in_cluster_count),
1629 v_out_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1630 desc_t->out_cluster, (sizeof(gushort) * desc_t->out_cluster_count),
1632 if (NULL == v_in_cluster || NULL == v_out_cluster) {
1633 Z_LOGE("Failed to create variant!");
1635 g_variant_unref(v_in_cluster);
1637 g_variant_unref(v_out_cluster);
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);
1648 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MATCHED_DESC_RSP: {
1649 ZigbeeZdoDevControlMatchedDescriptorResp_t *desc_t =
1650 (ZigbeeZdoDevControlMatchedDescriptorResp_t *)noti_data;
1652 GVariant *v_match_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1653 desc_t->match_list, desc_t->list_count, TRUE, NULL, NULL);
1654 if (NULL == v_match_list) {
1655 Z_LOGE("Failed to create variant!");
1657 Z_LOGD("matched descriptor rsp : [0x%X]", desc_t->status);
1658 zigbee_zdo_dev_control_emit_matched_descriptor_rsp(dev_control_object,
1659 desc_t->status, desc_t->node_id, desc_t->list_count, v_match_list);
1663 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_BIND_RSP: {
1664 ZigbeeZdoDevControlMgmtBindResp_t *desc_t =
1665 (ZigbeeZdoDevControlMgmtBindResp_t *)noti_data;
1669 GVariant *v_entries = NULL;
1670 GVariantBuilder *entry_builder =
1671 g_variant_builder_new (G_VARIANT_TYPE ("a(ayyqyqayy)"));
1672 if (NULL == entry_builder) {
1673 Z_LOGE("Failed to create variant builder!");
1677 for(i = 0; i < desc_t->table_list_count ; i++) {
1678 GVariantBuilder *eui64_builder =
1679 g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1680 GVariantBuilder *dest_eui64_builder =
1681 g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1683 if (NULL == eui64_builder || NULL == dest_eui64_builder) {
1684 Z_LOGE("Failed to create variant builder!");
1686 g_variant_builder_unref(eui64_builder);
1687 if (dest_eui64_builder)
1688 g_variant_builder_unref(dest_eui64_builder);
1689 g_variant_builder_unref(entry_builder);
1693 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1694 g_variant_builder_add (eui64_builder, "y",
1695 desc_t->table_list[i].eui64[v]);
1696 g_variant_builder_add (dest_eui64_builder, "y",
1697 desc_t->table_list[i].dest_eui64[v]);
1700 g_variant_builder_add (entry_builder, "(ayyqyqayy)",
1702 desc_t->table_list[i].source_endpoint,
1703 desc_t->table_list[i].cluster_id,
1704 desc_t->table_list[i].dest_addr_mode,
1705 desc_t->table_list[i].dest_addr,
1707 desc_t->table_list[i].dest_endpoint);
1709 g_variant_builder_unref(eui64_builder);
1710 g_variant_builder_unref(dest_eui64_builder);
1712 v_entries = g_variant_builder_end(entry_builder);
1714 Z_LOGD("management bind rsp : [0x%X]", desc_t->status);
1715 zigbee_zdo_dev_control_emit_mgmt_bind_rsp(dev_control_object,
1716 desc_t->status, desc_t->table_entries,
1717 desc_t->start_index, desc_t->table_list_count,
1721 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LQI_RSP: {
1722 ZigbeeZdoDevControlMgmtLqiResp_t *desc_t =
1723 (ZigbeeZdoDevControlMgmtLqiResp_t *)noti_data;
1727 GVariant *v_entries = NULL;
1728 GVariantBuilder *entry_builder =
1729 g_variant_builder_new (G_VARIANT_TYPE ("a(ayayyqyyyyy)"));
1730 if (NULL == entry_builder) {
1731 Z_LOGE("Failed to create variant builder!");
1735 for(i = 0; i < desc_t->table_list_count ; i++) {
1736 GVariantBuilder *ext_pan_builder =
1737 g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1738 GVariantBuilder *eui64_builder =
1739 g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1741 if (NULL == ext_pan_builder || NULL == eui64_builder) {
1742 Z_LOGE("Failed to create variant builder!");
1743 if (ext_pan_builder)
1744 g_variant_builder_unref(ext_pan_builder);
1746 g_variant_builder_unref(eui64_builder);
1747 g_variant_builder_unref(entry_builder);
1751 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1752 g_variant_builder_add (ext_pan_builder, "y",
1753 desc_t->table_list[i].extended_pan_id[v]);
1754 g_variant_builder_add (eui64_builder, "y",
1755 desc_t->table_list[i].eui64[v]);
1758 g_variant_builder_add (entry_builder, "(ayayyqyyyyy)",
1761 desc_t->table_list[i].node_id,
1762 desc_t->table_list[i].device_type,
1763 desc_t->table_list[i].rx_on_when_idle,
1764 desc_t->table_list[i].relationship,
1765 desc_t->table_list[i].permit_joining,
1766 desc_t->table_list[i].depth,
1767 desc_t->table_list[i].lqi);
1769 g_variant_builder_unref(ext_pan_builder);
1770 g_variant_builder_unref(eui64_builder);
1772 v_entries = g_variant_builder_end(entry_builder);
1774 Z_LOGD("management LQI rsp : [0x%X]", desc_t->status);
1775 zigbee_zdo_dev_control_emit_mgmt_lqi_rsp(dev_control_object,
1776 desc_t->status, desc_t->table_entries,
1777 desc_t->start_index, desc_t->table_list_count,
1781 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_RTG_RSP: {
1782 ZigbeeZdoDevControlMgmtRtgResp_t *desc_t =
1783 (ZigbeeZdoDevControlMgmtRtgResp_t *)noti_data;
1786 GVariant *v_entries = NULL;
1787 GVariantBuilder *entry_builder =
1788 g_variant_builder_new (G_VARIANT_TYPE ("a(qyyyyq)"));
1789 if (NULL == entry_builder) {
1790 Z_LOGE("Failed to create variant builder!");
1794 for(i = 0; i < desc_t->table_list_count ; i++) {
1795 g_variant_builder_add (entry_builder, "(qyyyyq)",
1796 desc_t->table_list[i].dest_addr,
1797 desc_t->table_list[i].status,
1798 desc_t->table_list[i].memory_constrained,
1799 desc_t->table_list[i].many_to_one,
1800 desc_t->table_list[i].route_record_required,
1801 desc_t->table_list[i].next_hop_addr);
1803 v_entries = g_variant_builder_end(entry_builder);
1805 Z_LOGD("management routing rsp : [0x%X]", desc_t->status);
1806 zigbee_zdo_dev_control_emit_mgmt_rtg_rsp(dev_control_object,
1807 desc_t->status, desc_t->table_entries,
1808 desc_t->start_index, desc_t->table_list_count,
1812 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_PERMIT_JOIN_RSP: {
1813 ZigbeeZdoDevControlMgmtPermitJoinResp_t *resp_t =
1814 (ZigbeeZdoDevControlMgmtPermitJoinResp_t *)noti_data;
1816 zigbee_zdo_dev_control_emit_mgmt_permit_join_rsp(dev_control_object,
1820 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LEFT_RSP: {
1821 ZigbeeZdoDevControlMgmtLeftResp_t *resp_t =
1822 (ZigbeeZdoDevControlMgmtLeftResp_t *)noti_data;
1824 zigbee_zdo_dev_control_emit_mgmt_left_rsp(dev_control_object,
1828 case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_DISC_RSP: {
1829 ZigbeeZdoDevControlNwkDiscoveryResp_t *nwk_disc_t =
1830 (ZigbeeZdoDevControlNwkDiscoveryResp_t *)noti_data;
1834 GVariant *v_entries = NULL;
1835 GVariantBuilder *entry_builder =
1836 g_variant_builder_new (G_VARIANT_TYPE ("a(ayyyyyyy)"));
1837 if (NULL == entry_builder) {
1838 Z_LOGE("Failed to create variant builder!");
1842 for(i = 0; i < nwk_disc_t->table_list_count ; i++) {
1843 GVariantBuilder *ext_pan_builder =
1844 g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1845 if (NULL == ext_pan_builder) {
1846 Z_LOGE("Failed to create variant builder!");
1847 g_variant_builder_unref(entry_builder);
1851 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1852 g_variant_builder_add (ext_pan_builder, "y",
1853 nwk_disc_t->table_list[i].extended_pan_id[v]);
1856 g_variant_builder_add (entry_builder, "(ayyyyyyy)",
1858 nwk_disc_t->table_list[i].logical_channel,
1859 nwk_disc_t->table_list[i].stack_profile,
1860 nwk_disc_t->table_list[i].zigbee_version,
1861 nwk_disc_t->table_list[i].beacon_order,
1862 nwk_disc_t->table_list[i].superframe_order,
1863 nwk_disc_t->table_list[i].permit_joining);
1865 g_variant_builder_unref(ext_pan_builder);
1867 v_entries = g_variant_builder_end(entry_builder);
1869 Z_LOGD("Network discovery rsp : [0x%X]", nwk_disc_t->status);
1870 zigbee_zdo_dev_control_emit_nwk_disc_rsp(dev_control_object,
1871 nwk_disc_t->status, nwk_disc_t->network_count,
1872 nwk_disc_t->start_index, nwk_disc_t->table_list_count,
1876 case ZBLIB_ZDO_DEV_CONTROL_NOTI_NODE_DESC_RSP: {
1877 ZigbeeZdoDevControlNodeDescriptorResp_t *desc_t =
1878 (ZigbeeZdoDevControlNodeDescriptorResp_t *)noti_data;
1880 zigbee_zdo_dev_control_emit_node_desc_rsp(dev_control_object,
1881 desc_t->status, desc_t->node_id, desc_t->logical_type,
1882 desc_t->complex_desciptor_available,
1883 desc_t->user_descriptor_available,
1884 desc_t->aps_flags, desc_t->frequency_band,
1885 desc_t->mac_capability_flags, desc_t->manufacturer_code,
1886 desc_t->max_buffer_size, desc_t->max_incoming_transfer_size,
1887 desc_t->server_mask, desc_t->max_outgoing_transfer_size,
1888 desc_t->descriptor_capability_field);
1891 case ZBLIB_ZDO_DEV_CONTROL_NOTI_POWER_DESC_RSP: {
1892 ZigbeeZdoDevControlPowerDescriptorResp_t *desc_t =
1893 (ZigbeeZdoDevControlPowerDescriptorResp_t *)noti_data;
1895 zigbee_zdo_dev_control_emit_power_desc_rsp(dev_control_object,
1896 desc_t->status, desc_t->node_id,
1897 desc_t->current_power_mode,
1898 desc_t->available_power_sources,
1899 desc_t->current_power_source,
1900 desc_t->current_power_source_level);
1903 case ZBLIB_ZDO_DEV_CONTROL_NOTI_COMPLEX_DESC_RSP: {
1904 ZigbeeZdoDevControlComplexDescriptorResp_t *desc_t =
1905 (ZigbeeZdoDevControlComplexDescriptorResp_t *)noti_data;
1907 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1908 desc_t->complex_descriptor_list, desc_t->list_count,
1910 if (NULL == v_desc_list) {
1911 Z_LOGE("Failed to create variant!");
1913 Z_LOGD("Complex descriptor rsp : [0x%X]", desc_t->status);
1914 zigbee_zdo_dev_control_emit_complex_desc_rsp(dev_control_object,
1915 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1919 case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_RSP: {
1920 ZigbeeZdoDevControlUserDescriptorResp_t *desc_t =
1921 (ZigbeeZdoDevControlUserDescriptorResp_t *)noti_data;
1923 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1924 desc_t->user_descriptor_list, desc_t->list_count,
1926 if (NULL == v_desc_list) {
1927 Z_LOGE("Failed to create variant!");
1929 Z_LOGD("User descriptor rsp : [0x%X]", desc_t->status);
1930 zigbee_zdo_dev_control_emit_user_desc_rsp(dev_control_object,
1931 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1935 case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_CONFIRM: {
1936 ZigbeeZdoDevControlUserDescriptorConfirm_t *resp_t =
1937 (ZigbeeZdoDevControlUserDescriptorConfirm_t *)noti_data;
1939 zigbee_zdo_dev_control_emit_user_desc_confirm(dev_control_object,
1944 Z_LOGE("Unexpected notification [%x]", noti_id);
1948 /* ZigbeeZdo_dev_control should be dereferenced */
1949 g_object_unref(dev_control_object);
1952 gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
1953 ZigbeeObjectSkeleton *zigbee_object)
1955 ZigbeeZdo_dev_control *zdodev_control_object;
1957 if (NULL == service_interface) {
1958 Z_LOGE("service_interface is NULL");
1962 zdodev_control_object = zigbee_zdo_dev_control_skeleton_new();
1963 zigbee_object_skeleton_set_zdo_dev_control(zigbee_object, zdodev_control_object);
1964 g_object_unref(zdodev_control_object);
1966 Z_LOGI("zdodev_control_object: [%p]", zdodev_control_object);
1969 * Register signal handlers for 'zdodev_control' interface
1971 g_signal_connect(zdodev_control_object,
1972 "handle-nwk-addr-req",
1973 G_CALLBACK(on_zdodev_control_nwk_addr_req), service_interface);
1975 g_signal_connect(zdodev_control_object,
1976 "handle-matched-descriptor-req",
1977 G_CALLBACK(on_zdodev_control_matched_descriptor_req), service_interface);
1979 g_signal_connect(zdodev_control_object,
1980 "handle-ieee-addr-req",
1981 G_CALLBACK(on_zdodev_control_ieee_addr_req), service_interface);
1983 g_signal_connect(zdodev_control_object,
1984 "handle-active-ep-req",
1985 G_CALLBACK(on_zdodev_control_active_ep_req), service_interface);
1987 g_signal_connect(zdodev_control_object,
1988 "handle-node-desc-req",
1989 G_CALLBACK(on_zdodev_control_node_desc_req), service_interface);
1991 g_signal_connect(zdodev_control_object,
1992 "handle-power-desc-req",
1993 G_CALLBACK(on_zdodev_control_power_desc_req), service_interface);
1995 g_signal_connect(zdodev_control_object,
1996 "handle-complex-desc-req",
1997 G_CALLBACK(on_zdodev_control_complex_desc_req), service_interface);
1999 g_signal_connect(zdodev_control_object,
2000 "handle-user-desc-req",
2001 G_CALLBACK(on_zdodev_control_user_desc_req), service_interface);
2003 g_signal_connect(zdodev_control_object,
2004 "handle-user-desc-set-req",
2005 G_CALLBACK(on_zdodev_control_user_desc_set_req), service_interface);
2007 g_signal_connect(zdodev_control_object,
2008 "handle-device-announce",
2009 G_CALLBACK(on_zdodev_control_device_announce), service_interface);
2011 g_signal_connect(zdodev_control_object,
2012 "handle-simple-desc-req",
2013 G_CALLBACK(on_zdodev_control_simple_desc_req), service_interface);
2015 g_signal_connect(zdodev_control_object,
2016 "handle-mgmt-lqi-req",
2017 G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service_interface);
2019 g_signal_connect(zdodev_control_object,
2020 "handle-mgmt-rtg-req",
2021 G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service_interface);
2023 g_signal_connect(zdodev_control_object,
2024 "handle-mgmt-bind-req",
2025 G_CALLBACK(on_zdodev_control_mgmt_bind_req), service_interface);
2027 g_signal_connect(zdodev_control_object,
2028 "handle-mgmt-permit-join-req",
2029 G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface);
2031 g_signal_connect(zdodev_control_object,
2032 "handle-nwk-update-req",
2033 G_CALLBACK(on_zdodev_control_nwk_update_req), service_interface);
2035 g_signal_connect(zdodev_control_object,
2036 "handle-nwk-disc-req",
2037 G_CALLBACK(on_zdodev_control_nwk_disc_req), service_interface);