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 g_variant_unref(v_eui64);
1597 g_variant_unref(v_associated);
1599 Z_LOGD("nwk addr ext rsp : [0x%X]", nwk_addr_t->status);
1600 zigbee_zdo_dev_control_emit_nwk_addr_ext_rsp(dev_control_object,
1601 nwk_addr_t->status, v_eui64, nwk_addr_t->node_id,
1602 nwk_addr_t->associated_count, nwk_addr_t->start_index, 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);
1622 case ZBLIB_ZDO_DEV_CONTROL_NOTI_SIMPLE_DESC_RSP: {
1623 ZigbeeZdoDevControlSimpleDescriptorResp_t *desc_t =
1624 (ZigbeeZdoDevControlSimpleDescriptorResp_t *)noti_data;
1626 GVariant *v_in_cluster = NULL;
1627 GVariant *v_out_cluster = NULL;
1628 v_in_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1629 desc_t->in_cluster, (sizeof(gushort) * desc_t->in_cluster_count),
1631 v_out_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1632 desc_t->out_cluster, (sizeof(gushort) * desc_t->out_cluster_count),
1634 if (NULL == v_in_cluster || NULL == v_out_cluster) {
1635 Z_LOGE("Failed to create variant!");
1637 g_variant_unref(v_in_cluster);
1639 g_variant_unref(v_out_cluster);
1641 Z_LOGD("Simple descriptor rsp");
1642 zigbee_zdo_dev_control_emit_simple_desc_rsp(dev_control_object,
1643 desc_t->node_id, desc_t->length, desc_t->device_version,
1644 desc_t->endpoint, desc_t->profile_id, desc_t->device_id,
1645 desc_t->in_cluster_count, desc_t->out_cluster_count,
1646 v_in_cluster, v_out_cluster);
1650 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MATCHED_DESC_RSP: {
1651 ZigbeeZdoDevControlMatchedDescriptorResp_t *desc_t =
1652 (ZigbeeZdoDevControlMatchedDescriptorResp_t *)noti_data;
1654 GVariant *v_match_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1655 desc_t->match_list, desc_t->list_count, TRUE, NULL, NULL);
1656 if (NULL == v_match_list) {
1657 Z_LOGE("Failed to create variant!");
1659 Z_LOGD("matched descriptor rsp : [0x%X]", desc_t->status);
1660 zigbee_zdo_dev_control_emit_matched_descriptor_rsp(dev_control_object,
1661 desc_t->status, desc_t->node_id, desc_t->list_count, v_match_list);
1665 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_BIND_RSP: {
1666 ZigbeeZdoDevControlMgmtBindResp_t *desc_t =
1667 (ZigbeeZdoDevControlMgmtBindResp_t *)noti_data;
1671 GVariant *v_entries = NULL;
1672 GVariantBuilder *entry_builder =
1673 g_variant_builder_new(G_VARIANT_TYPE("a(ayyqyqayy)"));
1674 if (NULL == entry_builder) {
1675 Z_LOGE("Failed to create variant builder!");
1679 for (i = 0; i < desc_t->table_list_count ; i++) {
1680 GVariantBuilder *eui64_builder =
1681 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1682 GVariantBuilder *dest_eui64_builder =
1683 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1685 if (NULL == eui64_builder || NULL == dest_eui64_builder) {
1686 Z_LOGE("Failed to create variant builder!");
1688 g_variant_builder_unref(eui64_builder);
1689 if (dest_eui64_builder)
1690 g_variant_builder_unref(dest_eui64_builder);
1691 g_variant_builder_unref(entry_builder);
1695 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1696 g_variant_builder_add(eui64_builder, "y",
1697 desc_t->table_list[i].eui64[v]);
1698 g_variant_builder_add(dest_eui64_builder, "y",
1699 desc_t->table_list[i].dest_eui64[v]);
1702 g_variant_builder_add(entry_builder, "(ayyqyqayy)",
1704 desc_t->table_list[i].source_endpoint,
1705 desc_t->table_list[i].cluster_id,
1706 desc_t->table_list[i].dest_addr_mode,
1707 desc_t->table_list[i].dest_addr,
1709 desc_t->table_list[i].dest_endpoint);
1711 g_variant_builder_unref(eui64_builder);
1712 g_variant_builder_unref(dest_eui64_builder);
1714 v_entries = g_variant_builder_end(entry_builder);
1716 Z_LOGD("management bind rsp : [0x%X]", desc_t->status);
1717 zigbee_zdo_dev_control_emit_mgmt_bind_rsp(dev_control_object,
1718 desc_t->status, desc_t->table_entries,
1719 desc_t->start_index, desc_t->table_list_count,
1723 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LQI_RSP: {
1724 ZigbeeZdoDevControlMgmtLqiResp_t *desc_t =
1725 (ZigbeeZdoDevControlMgmtLqiResp_t *)noti_data;
1729 GVariant *v_entries = NULL;
1730 GVariantBuilder *entry_builder =
1731 g_variant_builder_new(G_VARIANT_TYPE("a(ayayyqyyyyy)"));
1732 if (NULL == entry_builder) {
1733 Z_LOGE("Failed to create variant builder!");
1737 for (i = 0; i < desc_t->table_list_count ; i++) {
1738 GVariantBuilder *ext_pan_builder =
1739 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1740 GVariantBuilder *eui64_builder =
1741 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1743 if (NULL == ext_pan_builder || NULL == eui64_builder) {
1744 Z_LOGE("Failed to create variant builder!");
1745 if (ext_pan_builder)
1746 g_variant_builder_unref(ext_pan_builder);
1748 g_variant_builder_unref(eui64_builder);
1749 g_variant_builder_unref(entry_builder);
1753 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1754 g_variant_builder_add(ext_pan_builder, "y",
1755 desc_t->table_list[i].extended_pan_id[v]);
1756 g_variant_builder_add(eui64_builder, "y",
1757 desc_t->table_list[i].eui64[v]);
1760 g_variant_builder_add(entry_builder, "(ayayyqyyyyy)",
1763 desc_t->table_list[i].node_id,
1764 desc_t->table_list[i].device_type,
1765 desc_t->table_list[i].rx_on_when_idle,
1766 desc_t->table_list[i].relationship,
1767 desc_t->table_list[i].permit_joining,
1768 desc_t->table_list[i].depth,
1769 desc_t->table_list[i].lqi);
1771 g_variant_builder_unref(ext_pan_builder);
1772 g_variant_builder_unref(eui64_builder);
1774 v_entries = g_variant_builder_end(entry_builder);
1776 Z_LOGD("management LQI rsp : [0x%X]", desc_t->status);
1777 zigbee_zdo_dev_control_emit_mgmt_lqi_rsp(dev_control_object,
1778 desc_t->status, desc_t->table_entries,
1779 desc_t->start_index, desc_t->table_list_count,
1783 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_RTG_RSP: {
1784 ZigbeeZdoDevControlMgmtRtgResp_t *desc_t =
1785 (ZigbeeZdoDevControlMgmtRtgResp_t *)noti_data;
1788 GVariant *v_entries = NULL;
1789 GVariantBuilder *entry_builder =
1790 g_variant_builder_new(G_VARIANT_TYPE("a(qyyyyq)"));
1791 if (NULL == entry_builder) {
1792 Z_LOGE("Failed to create variant builder!");
1796 for (i = 0; i < desc_t->table_list_count ; i++) {
1797 g_variant_builder_add(entry_builder, "(qyyyyq)",
1798 desc_t->table_list[i].dest_addr,
1799 desc_t->table_list[i].status,
1800 desc_t->table_list[i].memory_constrained,
1801 desc_t->table_list[i].many_to_one,
1802 desc_t->table_list[i].route_record_required,
1803 desc_t->table_list[i].next_hop_addr);
1805 v_entries = g_variant_builder_end(entry_builder);
1807 Z_LOGD("management routing rsp : [0x%X]", desc_t->status);
1808 zigbee_zdo_dev_control_emit_mgmt_rtg_rsp(dev_control_object,
1809 desc_t->status, desc_t->table_entries,
1810 desc_t->start_index, desc_t->table_list_count,
1814 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_PERMIT_JOIN_RSP: {
1815 ZigbeeZdoDevControlMgmtPermitJoinResp_t *resp_t =
1816 (ZigbeeZdoDevControlMgmtPermitJoinResp_t *)noti_data;
1818 zigbee_zdo_dev_control_emit_mgmt_permit_join_rsp(dev_control_object,
1822 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LEAVE_RSP: {
1823 ZigbeeZdoDevControlMgmtLeftResp_t *resp_t =
1824 (ZigbeeZdoDevControlMgmtLeftResp_t *)noti_data;
1826 zigbee_zdo_dev_control_emit_mgmt_leave_rsp(dev_control_object,
1830 case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_NWK_DISC_RSP: {
1831 ZigbeeZdoDevControlMgmtNwkDiscoveryResp_t *nwk_disc_t =
1832 (ZigbeeZdoDevControlMgmtNwkDiscoveryResp_t *)noti_data;
1836 GVariant *v_entries = NULL;
1837 GVariantBuilder *entry_builder =
1838 g_variant_builder_new(G_VARIANT_TYPE("a(ayyyyyyy)"));
1839 if (NULL == entry_builder) {
1840 Z_LOGE("Failed to create variant builder!");
1844 for (i = 0; i < nwk_disc_t->table_list_count ; i++) {
1845 GVariantBuilder *ext_pan_builder =
1846 g_variant_builder_new(G_VARIANT_TYPE("ay"));
1847 if (NULL == ext_pan_builder) {
1848 Z_LOGE("Failed to create variant builder!");
1849 g_variant_builder_unref(entry_builder);
1853 for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1854 g_variant_builder_add(ext_pan_builder, "y",
1855 nwk_disc_t->table_list[i].extended_pan_id[v]);
1858 g_variant_builder_add(entry_builder, "(ayyyyyyy)",
1860 nwk_disc_t->table_list[i].logical_channel,
1861 nwk_disc_t->table_list[i].stack_profile,
1862 nwk_disc_t->table_list[i].zigbee_version,
1863 nwk_disc_t->table_list[i].beacon_order,
1864 nwk_disc_t->table_list[i].superframe_order,
1865 nwk_disc_t->table_list[i].permit_joining);
1867 g_variant_builder_unref(ext_pan_builder);
1869 v_entries = g_variant_builder_end(entry_builder);
1871 Z_LOGD("Network discovery rsp : [0x%X]", nwk_disc_t->status);
1872 zigbee_zdo_dev_control_emit_mgmt_nwk_disc_rsp(dev_control_object,
1873 nwk_disc_t->status, nwk_disc_t->network_count,
1874 nwk_disc_t->start_index, nwk_disc_t->table_list_count,
1878 case ZBLIB_ZDO_DEV_CONTROL_NOTI_NODE_DESC_RSP: {
1879 ZigbeeZdoDevControlNodeDescriptorResp_t *desc_t =
1880 (ZigbeeZdoDevControlNodeDescriptorResp_t *)noti_data;
1882 zigbee_zdo_dev_control_emit_node_desc_rsp(dev_control_object,
1883 desc_t->status, desc_t->node_id, desc_t->logical_type,
1884 desc_t->complex_desciptor_available,
1885 desc_t->user_descriptor_available,
1886 desc_t->aps_flags, desc_t->frequency_band,
1887 desc_t->mac_capability_flags, desc_t->manufacturer_code,
1888 desc_t->max_buffer_size, desc_t->max_incoming_transfer_size,
1889 desc_t->server_mask, desc_t->max_outgoing_transfer_size,
1890 desc_t->descriptor_capability_field);
1893 case ZBLIB_ZDO_DEV_CONTROL_NOTI_POWER_DESC_RSP: {
1894 ZigbeeZdoDevControlPowerDescriptorResp_t *desc_t =
1895 (ZigbeeZdoDevControlPowerDescriptorResp_t *)noti_data;
1897 zigbee_zdo_dev_control_emit_power_desc_rsp(dev_control_object,
1898 desc_t->status, desc_t->node_id,
1899 desc_t->current_power_mode,
1900 desc_t->available_power_sources,
1901 desc_t->current_power_source,
1902 desc_t->current_power_source_level);
1905 case ZBLIB_ZDO_DEV_CONTROL_NOTI_COMPLEX_DESC_RSP: {
1906 ZigbeeZdoDevControlComplexDescriptorResp_t *desc_t =
1907 (ZigbeeZdoDevControlComplexDescriptorResp_t *)noti_data;
1909 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1910 desc_t->complex_descriptor_list, desc_t->list_count,
1912 if (NULL == v_desc_list) {
1913 Z_LOGE("Failed to create variant!");
1915 Z_LOGD("Complex descriptor rsp : [0x%X]", desc_t->status);
1916 zigbee_zdo_dev_control_emit_complex_desc_rsp(dev_control_object,
1917 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1921 case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_RSP: {
1922 ZigbeeZdoDevControlUserDescriptorResp_t *desc_t =
1923 (ZigbeeZdoDevControlUserDescriptorResp_t *)noti_data;
1925 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1926 desc_t->user_descriptor_list, desc_t->list_count,
1928 if (NULL == v_desc_list) {
1929 Z_LOGE("Failed to create variant!");
1931 Z_LOGD("User descriptor rsp : [0x%X]", desc_t->status);
1932 zigbee_zdo_dev_control_emit_user_desc_rsp(dev_control_object,
1933 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1937 case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_CONFIRM: {
1938 ZigbeeZdoDevControlUserDescriptorConfirm_t *resp_t =
1939 (ZigbeeZdoDevControlUserDescriptorConfirm_t *)noti_data;
1941 zigbee_zdo_dev_control_emit_user_desc_confirm(dev_control_object,
1946 Z_LOGE("Unexpected notification [%x]", noti_id);
1950 /* ZigbeeZdo_dev_control should be dereferenced */
1951 g_object_unref(dev_control_object);
1954 gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
1955 ZigbeeObjectSkeleton *zigbee_object)
1957 ZigbeeZdo_dev_control *zdodev_control_object;
1959 if (NULL == service_interface) {
1960 Z_LOGE("service_interface is NULL");
1964 zdodev_control_object = zigbee_zdo_dev_control_skeleton_new();
1965 zigbee_object_skeleton_set_zdo_dev_control(zigbee_object, zdodev_control_object);
1966 g_object_unref(zdodev_control_object);
1968 Z_LOGI("zdodev_control_object: [%p]", zdodev_control_object);
1971 * Register signal handlers for 'zdodev_control' interface
1973 g_signal_connect(zdodev_control_object,
1974 "handle-nwk-addr-req",
1975 G_CALLBACK(on_zdodev_control_nwk_addr_req), service_interface);
1977 g_signal_connect(zdodev_control_object,
1978 "handle-matched-descriptor-req",
1979 G_CALLBACK(on_zdodev_control_matched_descriptor_req), service_interface);
1981 g_signal_connect(zdodev_control_object,
1982 "handle-ieee-addr-req",
1983 G_CALLBACK(on_zdodev_control_ieee_addr_req), service_interface);
1985 g_signal_connect(zdodev_control_object,
1986 "handle-active-ep-req",
1987 G_CALLBACK(on_zdodev_control_active_ep_req), service_interface);
1989 g_signal_connect(zdodev_control_object,
1990 "handle-node-desc-req",
1991 G_CALLBACK(on_zdodev_control_node_desc_req), service_interface);
1993 g_signal_connect(zdodev_control_object,
1994 "handle-power-desc-req",
1995 G_CALLBACK(on_zdodev_control_power_desc_req), service_interface);
1997 g_signal_connect(zdodev_control_object,
1998 "handle-complex-desc-req",
1999 G_CALLBACK(on_zdodev_control_complex_desc_req), service_interface);
2001 g_signal_connect(zdodev_control_object,
2002 "handle-user-desc-req",
2003 G_CALLBACK(on_zdodev_control_user_desc_req), service_interface);
2005 g_signal_connect(zdodev_control_object,
2006 "handle-user-desc-set-req",
2007 G_CALLBACK(on_zdodev_control_user_desc_set_req), service_interface);
2009 g_signal_connect(zdodev_control_object,
2010 "handle-device-announce",
2011 G_CALLBACK(on_zdodev_control_device_announce), service_interface);
2013 g_signal_connect(zdodev_control_object,
2014 "handle-simple-desc-req",
2015 G_CALLBACK(on_zdodev_control_simple_desc_req), service_interface);
2017 g_signal_connect(zdodev_control_object,
2018 "handle-mgmt-lqi-req",
2019 G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service_interface);
2021 g_signal_connect(zdodev_control_object,
2022 "handle-mgmt-rtg-req",
2023 G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service_interface);
2025 g_signal_connect(zdodev_control_object,
2026 "handle-mgmt-bind-req",
2027 G_CALLBACK(on_zdodev_control_mgmt_bind_req), service_interface);
2029 g_signal_connect(zdodev_control_object,
2030 "handle-mgmt-permit-join-req",
2031 G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface);
2033 g_signal_connect(zdodev_control_object,
2034 "handle-mgmt-nwk-update-req",
2035 G_CALLBACK(on_zdodev_control_mgmt_nwk_update_req), service_interface);
2037 g_signal_connect(zdodev_control_object,
2038 "handle-mgmt-nwk-disc-req",
2039 G_CALLBACK(on_zdodev_control_mgmt_nwk_disc_req), service_interface);