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 on_zdodev_control_nwk_addr_req_resp(ZigBeeServiceInterface *service_interface,
24 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
26 ZigbeeServiceInterfaceRespCbData_t *cb_data =
27 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
30 NOT_USED(service_interface);
33 NOT_USED(resp_data_len);
36 static gboolean on_zdodev_control_nwk_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
37 GDBusMethodInvocation *invocation,
43 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
44 ZigbeeZdodevControlNwkAddrReq_t req;
45 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
47 GVariantIter *iter = NULL;
52 memset(&req, 0x0, sizeof(ZigbeeZdodevControlNwkAddrReq_t));
54 /* Update request structure */
55 g_variant_get(eui64, "ay", &iter);
56 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
58 if (i >= ZIGBEE_EUI64_SIZE)
61 req.request_type = request_type;
62 req.start_index = start_index;
64 /* Allocate response callback data */
66 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
68 if (NULL == resp_cb_data) {
69 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
71 /* Send failure response */
72 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
77 /* Dispatch request */
78 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
79 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
80 ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ,
82 on_zdodev_control_nwk_addr_req_resp, resp_cb_data);
84 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
86 /* Free response callback data */
87 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
89 /* Send failure response */
90 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
98 static void on_zdodev_control_matched_descriptor_req_resp(ZigBeeServiceInterface *service_interface,
99 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
101 ZigbeeServiceInterfaceRespCbData_t *cb_data =
102 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
105 NOT_USED(service_interface);
106 NOT_USED(request_id);
108 NOT_USED(resp_data_len);
111 static gboolean on_zdodev_control_matched_descriptor_req(ZigbeeZdo_dev_control *zdodev_control_object,
112 GDBusMethodInvocation *invocation,
121 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
122 ZigbeeZdodevControlMatchedDescriptorReq_t req;
123 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
125 GVariantIter *iter = NULL;
130 memset(&req, 0x0, sizeof(ZigbeeZdodevControlMatchedDescriptorReq_t));
132 /* Update request structure */
133 req.node_id = node_id;
134 req.profile_id = profile_id;
135 req.num_in_cl = num_in_cl;
136 req.in_cl = g_malloc0(sizeof(num_in_cl));
137 g_variant_get(in_cl, "ay", &iter);
138 while (g_variant_iter_loop(iter, "y", req.in_cl[i])) {
145 req.num_out_cl = num_out_cl;
146 req.out_cl = g_malloc0(sizeof(num_out_cl));
147 g_variant_get(out_cl, "ay", &iter);
148 while (g_variant_iter_loop(iter, "y", req.out_cl[i])) {
154 /* Allocate response callback data */
156 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
157 invocation, NULL, 0);
158 if (NULL == resp_cb_data) {
159 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
161 /* Send failure response */
162 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
167 /* Dispatch request */
168 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
169 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
170 ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ,
172 on_zdodev_control_matched_descriptor_req_resp, resp_cb_data);
179 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
181 /* Free response callback data */
182 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
184 /* Send failure response */
185 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
193 static void on_zdodev_control_ieee_addr_req_resp(ZigBeeServiceInterface *service_interface,
194 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
196 ZigbeeServiceInterfaceRespCbData_t *cb_data =
197 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
200 NOT_USED(service_interface);
201 NOT_USED(request_id);
203 NOT_USED(resp_data_len);
206 static gboolean on_zdodev_control_ieee_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
207 GDBusMethodInvocation *invocation,
211 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
212 ZigbeeZdodevControlIeeeAddrReq_t req;
213 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
217 memset(&req, 0x0, sizeof(ZigbeeZdodevControlIeeeAddrReq_t));
219 /* Update request structure */
220 req.node_id = node_id;
222 /* Allocate response callback data */
224 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
225 invocation, NULL, 0);
226 if (NULL == resp_cb_data) {
227 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
229 /* Send failure response */
230 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
235 /* Dispatch request */
236 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
237 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
238 ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ,
240 on_zdodev_control_ieee_addr_req_resp, resp_cb_data);
242 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
244 /* Free response callback data */
245 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
247 /* Send failure response */
248 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
256 static void on_zdodev_control_active_ep_req_resp(ZigBeeServiceInterface *service_interface,
257 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
259 ZigbeeServiceInterfaceRespCbData_t *cb_data =
260 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
263 NOT_USED(service_interface);
264 NOT_USED(request_id);
266 NOT_USED(resp_data_len);
269 static gboolean on_zdodev_control_active_ep_req(ZigbeeZdo_dev_control *zdodev_control_object,
270 GDBusMethodInvocation *invocation,
274 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
275 ZigbeeZdodevControlActiveEpReq_t req;
276 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
280 memset(&req, 0x0, sizeof(ZigbeeZdodevControlActiveEpReq_t));
282 /* Update request structure */
283 req.node_id = node_id;
285 /* Allocate response callback data */
287 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
288 invocation, NULL, 0);
289 if (NULL == resp_cb_data) {
290 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
292 /* Send failure response */
293 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
298 /* Dispatch request */
299 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
300 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
301 ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ,
303 on_zdodev_control_active_ep_req_resp, resp_cb_data);
305 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
307 /* Free response callback data */
308 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
310 /* Send failure response */
311 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
319 static void on_zdodev_control_node_desc_req_resp(ZigBeeServiceInterface *service_interface,
320 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
322 ZigbeeServiceInterfaceRespCbData_t *cb_data =
323 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
326 NOT_USED(service_interface);
327 NOT_USED(request_id);
329 NOT_USED(resp_data_len);
332 static gboolean on_zdodev_control_node_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
333 GDBusMethodInvocation *invocation,
337 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
338 ZigbeeZdodevControlNodeDescriptorReq_t req;
339 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
343 memset(&req, 0x0, sizeof(ZigbeeZdodevControlNodeDescriptorReq_t));
345 /* Update request structure */
346 req.node_id = node_id;
348 /* Allocate response callback data */
350 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
351 invocation, NULL, 0);
352 if (NULL == resp_cb_data) {
353 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
355 /* Send failure response */
356 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
361 /* Dispatch request */
362 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
363 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
364 ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ,
366 on_zdodev_control_node_desc_req_resp, resp_cb_data);
368 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
370 /* Free response callback data */
371 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
373 /* Send failure response */
374 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
382 static void on_zdodev_control_power_desc_req_resp(ZigBeeServiceInterface *service_interface,
383 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
385 ZigbeeServiceInterfaceRespCbData_t *cb_data =
386 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
389 NOT_USED(service_interface);
390 NOT_USED(request_id);
392 NOT_USED(resp_data_len);
395 static gboolean on_zdodev_control_power_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
396 GDBusMethodInvocation *invocation,
400 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
401 ZigbeeZdodevControlPowerDescriptorReq_t req;
402 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
406 memset(&req, 0x0, sizeof(ZigbeeZdodevControlPowerDescriptorReq_t));
408 /* Update request structure */
409 req.node_id = node_id;
411 /* Allocate response callback data */
413 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
414 invocation, NULL, 0);
415 if (NULL == resp_cb_data) {
416 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
418 /* Send failure response */
419 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
424 /* Dispatch request */
425 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
426 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
427 ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ,
429 on_zdodev_control_power_desc_req_resp, resp_cb_data);
431 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
433 /* Free response callback data */
434 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
436 /* Send failure response */
437 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
445 static void on_zdodev_control_complex_desc_req_resp(ZigBeeServiceInterface *service_interface,
446 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
448 ZigbeeServiceInterfaceRespCbData_t *cb_data =
449 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
452 NOT_USED(service_interface);
453 NOT_USED(request_id);
455 NOT_USED(resp_data_len);
458 static gboolean on_zdodev_control_complex_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
459 GDBusMethodInvocation *invocation,
463 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
464 ZigbeeZdodevControlComplexDescriptorReq_t req;
465 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
469 memset(&req, 0x0, sizeof(ZigbeeZdodevControlComplexDescriptorReq_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_ZDODEV_CONTROL,
490 ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ,
492 on_zdodev_control_complex_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_user_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;
515 NOT_USED(service_interface);
516 NOT_USED(request_id);
518 NOT_USED(resp_data_len);
521 static gboolean on_zdodev_control_user_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
522 GDBusMethodInvocation *invocation,
526 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
527 ZigbeeZdodevControlUserDescriptorReq_t req;
528 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
532 memset(&req, 0x0, sizeof(ZigbeeZdodevControlUserDescriptorReq_t));
534 /* Update request structure */
535 req.node_id = node_id;
537 /* Allocate response callback data */
539 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
540 invocation, NULL, 0);
541 if (NULL == resp_cb_data) {
542 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
544 /* Send failure response */
545 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
550 /* Dispatch request */
551 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
552 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
553 ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ,
555 on_zdodev_control_user_desc_req_resp, resp_cb_data);
557 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
559 /* Free response callback data */
560 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
562 /* Send failure response */
563 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
571 static void on_zdodev_control_user_desc_set_req_resp(ZigBeeServiceInterface *service_interface,
572 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
574 ZigbeeServiceInterfaceRespCbData_t *cb_data =
575 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
578 NOT_USED(service_interface);
579 NOT_USED(request_id);
581 NOT_USED(resp_data_len);
584 static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdo_dev_control *zdodev_control_object,
585 GDBusMethodInvocation *invocation,
591 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
592 ZigbeeZdodevControlUserDescriptorSetReq_t req;
593 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
595 GVariantIter *iter = NULL;
600 memset(&req, 0x0, sizeof(ZigbeeZdodevControlUserDescriptorSetReq_t));
602 /* Update request structure */
603 req.node_id = node_id;
604 req.user_descriptor_len = length;
605 g_variant_get(user_desc, "ay", &iter);
606 while (g_variant_iter_loop(iter, "y", req.user_descriptor[i])) {
608 if (i >= ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN)
612 /* Allocate response callback data */
614 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
615 invocation, NULL, 0);
616 if (NULL == resp_cb_data) {
617 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
619 /* Send failure response */
620 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
625 /* Dispatch request */
626 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
627 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
628 ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ,
630 on_zdodev_control_user_desc_set_req_resp, resp_cb_data);
632 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
634 /* Free response callback data */
635 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
637 /* Send failure response */
638 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
646 static void on_zdodev_control_device_announce_resp(ZigBeeServiceInterface *service_interface,
647 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
649 ZigbeeServiceInterfaceRespCbData_t *cb_data =
650 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
653 NOT_USED(service_interface);
654 NOT_USED(request_id);
656 NOT_USED(resp_data_len);
659 static gboolean on_zdodev_control_device_announce(ZigbeeZdo_dev_control *zdodev_control_object,
660 GDBusMethodInvocation *invocation,
666 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
667 ZigbeeZdodevControlDeviceAnnounce_t req;
668 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
670 GVariantIter *iter = NULL;
675 memset(&req, 0x0, sizeof(ZigbeeZdodevControlDeviceAnnounce_t));
677 /* Update request structure */
678 req.node_id = node_id;
679 g_variant_get(mac_addr, "ay", &iter);
680 while (g_variant_iter_loop(iter, "y", req.mac_addr[i])) {
682 if (i >= ZIGBEE_EUI64_SIZE)
685 req.capability = capability;
687 /* Allocate response callback data */
689 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
690 invocation, NULL, 0);
691 if (NULL == resp_cb_data) {
692 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
694 /* Send failure response */
695 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
700 /* Dispatch request */
701 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
702 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
703 ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE,
705 on_zdodev_control_device_announce_resp, resp_cb_data);
707 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
709 /* Free response callback data */
710 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
712 /* Send failure response */
713 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
721 static void on_zdodev_control_simple_desc_req_resp(ZigBeeServiceInterface *service_interface,
722 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
724 ZigbeeServiceInterfaceRespCbData_t *cb_data =
725 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
728 NOT_USED(service_interface);
729 NOT_USED(request_id);
731 NOT_USED(resp_data_len);
734 static gboolean on_zdodev_control_simple_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
735 GDBusMethodInvocation *invocation,
740 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
741 ZigbeeZdodevControlSimpleDescriptorReq_t req;
742 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
746 memset(&req, 0x0, sizeof(ZigbeeZdodevControlSimpleDescriptorReq_t));
748 /* Update request structure */
749 req.node_id = node_id;
750 req.endpoint = endpoint;
752 /* Allocate response callback data */
754 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
755 invocation, NULL, 0);
756 if (NULL == resp_cb_data) {
757 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
759 /* Send failure response */
760 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
765 /* Dispatch request */
766 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
767 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
768 ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ,
770 on_zdodev_control_simple_desc_req_resp, resp_cb_data);
772 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
774 /* Free response callback data */
775 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
777 /* Send failure response */
778 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
786 static void on_zdodev_control_mgmt_lqi_req_resp(ZigBeeServiceInterface *service_interface,
787 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
789 ZigbeeServiceInterfaceRespCbData_t *cb_data =
790 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
793 NOT_USED(service_interface);
794 NOT_USED(request_id);
796 NOT_USED(resp_data_len);
799 static gboolean on_zdodev_control_mgmt_lqi_req(ZigbeeZdo_dev_control *zdodev_control_object,
800 GDBusMethodInvocation *invocation,
805 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
806 ZigbeeZdodevControlMgmtLqiReq_t req;
807 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
811 memset(&req, 0x0, sizeof(ZigbeeZdodevControlMgmtLqiReq_t));
813 /* Update request structure */
814 req.node_id = node_id;
815 req.start_index = start_idx;
817 /* Allocate response callback data */
819 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
820 invocation, NULL, 0);
821 if (NULL == resp_cb_data) {
822 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
824 /* Send failure response */
825 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
830 /* Dispatch request */
831 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
832 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
833 ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ,
835 on_zdodev_control_mgmt_lqi_req_resp, resp_cb_data);
837 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
839 /* Free response callback data */
840 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
842 /* Send failure response */
843 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
851 static void on_zdodev_control_mgmt_rtg_req_resp(ZigBeeServiceInterface *service_interface,
852 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
854 ZigbeeServiceInterfaceRespCbData_t *cb_data =
855 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
858 NOT_USED(service_interface);
859 NOT_USED(request_id);
861 NOT_USED(resp_data_len);
864 static gboolean on_zdodev_control_mgmt_rtg_req(ZigbeeZdo_dev_control *zdodev_control_object,
865 GDBusMethodInvocation *invocation,
870 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
871 ZigbeeZdodevControlMgmtRtgReq_t req;
872 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
876 memset(&req, 0x0, sizeof(ZigbeeZdodevControlMgmtRtgReq_t));
878 /* Update request structure */
879 req.node_id = node_id;
880 req.start_index = start_idx;
882 /* Allocate response callback data */
884 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
885 invocation, NULL, 0);
886 if (NULL == resp_cb_data) {
887 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
889 /* Send failure response */
890 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
895 /* Dispatch request */
896 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
897 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
898 ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ,
900 on_zdodev_control_mgmt_rtg_req_resp, resp_cb_data);
902 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
904 /* Free response callback data */
905 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
907 /* Send failure response */
908 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
916 static void on_zdodev_control_mgmt_bind_req_resp(ZigBeeServiceInterface *service_interface,
917 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
919 ZigbeeServiceInterfaceRespCbData_t *cb_data =
920 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
923 NOT_USED(service_interface);
924 NOT_USED(request_id);
926 NOT_USED(resp_data_len);
929 static gboolean on_zdodev_control_mgmt_bind_req(ZigbeeZdo_dev_control *zdodev_control_object,
930 GDBusMethodInvocation *invocation,
935 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
936 ZigbeeZdodevControlMgmtBindReq_t req;
937 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
941 memset(&req, 0x0, sizeof(ZigbeeZdodevControlMgmtBindReq_t));
943 /* Update request structure */
944 req.node_id = node_id;
945 req.start_index = start_idx;
947 /* Allocate response callback data */
949 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
950 invocation, NULL, 0);
951 if (NULL == resp_cb_data) {
952 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
954 /* Send failure response */
955 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
960 /* Dispatch request */
961 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
962 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
963 ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ,
965 on_zdodev_control_mgmt_bind_req_resp, resp_cb_data);
967 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
969 /* Free response callback data */
970 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
972 /* Send failure response */
973 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
981 static void on_zdodev_control_mgmt_permit_join_req_resp(ZigBeeServiceInterface *service_interface,
982 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
984 ZigbeeServiceInterfaceRespCbData_t *cb_data =
985 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
988 NOT_USED(service_interface);
989 NOT_USED(request_id);
991 NOT_USED(resp_data_len);
994 static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zdodev_control_object,
995 GDBusMethodInvocation *invocation,
998 gchar tc_significance,
1001 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1002 ZigbeeZdodevControlMgmtPermitJoinReq_t req;
1003 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1007 memset(&req, 0x0, sizeof(ZigbeeZdodevControlMgmtPermitJoinReq_t));
1009 /* Update request structure */
1011 req.duration = duration;
1012 req.tc_significance = tc_significance;
1014 /* Allocate response callback data */
1016 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1017 invocation, NULL, 0);
1018 if (NULL == resp_cb_data) {
1019 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1021 /* Send failure response */
1022 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1027 /* Dispatch request */
1028 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1029 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
1030 ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ,
1032 on_zdodev_control_mgmt_permit_join_req_resp, resp_cb_data);
1034 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1036 /* Free response callback data */
1037 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1039 /* Send failure response */
1040 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1048 static void on_zdodev_control_nwk_update_req_resp(ZigBeeServiceInterface *service_interface,
1049 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1051 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1052 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1055 NOT_USED(service_interface);
1056 NOT_USED(request_id);
1057 NOT_USED(resp_data);
1058 NOT_USED(resp_data_len);
1061 static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdo_dev_control *zdodev_control_object,
1062 GDBusMethodInvocation *invocation,
1065 gchar scan_duration,
1070 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1071 ZigbeeZdodevControlNwkUpdateReq_t req;
1072 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1076 memset(&req, 0x0, sizeof(ZigbeeZdodevControlNwkUpdateReq_t));
1078 /* Update request structure */
1079 req.node_id = node_id;
1080 req.scan_channel = scan_channel;
1081 req.scan_duration = scan_duration;
1082 req.scan_count = scan_count;
1083 req.network_update_id = nwk_update_id;
1085 /* Allocate response callback data */
1087 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1088 invocation, NULL, 0);
1089 if (NULL == resp_cb_data) {
1090 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1092 /* Send failure response */
1093 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1098 /* Dispatch request */
1099 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1100 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
1101 ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ,
1103 on_zdodev_control_nwk_update_req_resp, resp_cb_data);
1105 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1107 /* Free response callback data */
1108 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1110 /* Send failure response */
1111 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1119 static void on_zdodev_control_nwk_disc_req_resp(ZigBeeServiceInterface *service_interface,
1120 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1122 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1123 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1126 NOT_USED(service_interface);
1127 NOT_USED(request_id);
1128 NOT_USED(resp_data);
1129 NOT_USED(resp_data_len);
1132 static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_control_object,
1133 GDBusMethodInvocation *invocation,
1136 gchar scan_duration,
1141 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1142 ZigbeeZdodevControlNwkDescriptorReq_t req;
1143 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1147 memset(&req, 0x0, sizeof(ZigbeeZdodevControlNwkDescriptorReq_t));
1149 /* Update request structure */
1150 req.node_id = node_id;
1151 req.scan_channel = scan_channel;
1152 req.scan_duration = scan_duration;
1153 req.scan_count = scan_count;
1154 req.start_index = start_index;
1156 /* Allocate response callback data */
1158 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1159 invocation, NULL, 0);
1160 if (NULL == resp_cb_data) {
1161 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1163 /* Send failure response */
1164 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1169 /* Dispatch request */
1170 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1171 ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
1172 ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ,
1174 on_zdodev_control_nwk_disc_req_resp, resp_cb_data);
1176 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1178 /* Free response callback data */
1179 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1181 /* Send failure response */
1182 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1190 gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
1191 ZigbeeObjectSkeleton *zigbee_object)
1193 ZigbeeZdo_dev_control *zdodev_control_object;
1195 if (NULL == service_interface) {
1196 Z_LOGE("service_interface is NULL");
1200 zdodev_control_object = zigbee_zdo_dev_control_skeleton_new();
1201 zigbee_object_skeleton_set_zdo_dev_control(zigbee_object, zdodev_control_object);
1202 g_object_unref(zdodev_control_object);
1204 Z_LOGI("zdodev_control_object: [%p]", zdodev_control_object);
1207 * Register signal handlers for 'zdodev_control' interface
1209 g_signal_connect(zdodev_control_object,
1210 "handle-nwk-addr-req",
1211 G_CALLBACK(on_zdodev_control_nwk_addr_req), service_interface);
1213 g_signal_connect(zdodev_control_object,
1214 "handle-matched-descriptor-req",
1215 G_CALLBACK(on_zdodev_control_matched_descriptor_req), service_interface);
1217 g_signal_connect(zdodev_control_object,
1218 "handle-ieee-addr-req",
1219 G_CALLBACK(on_zdodev_control_ieee_addr_req), service_interface);
1221 g_signal_connect(zdodev_control_object,
1222 "handle-active-ep-req",
1223 G_CALLBACK(on_zdodev_control_active_ep_req), service_interface);
1225 g_signal_connect(zdodev_control_object,
1226 "handle-node-desc-req",
1227 G_CALLBACK(on_zdodev_control_node_desc_req), service_interface);
1229 g_signal_connect(zdodev_control_object,
1230 "handle-power-desc-req",
1231 G_CALLBACK(on_zdodev_control_power_desc_req), service_interface);
1233 g_signal_connect(zdodev_control_object,
1234 "handle-complex-desc-req",
1235 G_CALLBACK(on_zdodev_control_complex_desc_req), service_interface);
1237 g_signal_connect(zdodev_control_object,
1238 "handle-user-desc-req",
1239 G_CALLBACK(on_zdodev_control_user_desc_req), service_interface);
1241 g_signal_connect(zdodev_control_object,
1242 "handle-user-desc-set-req",
1243 G_CALLBACK(on_zdodev_control_user_desc_set_req), service_interface);
1245 g_signal_connect(zdodev_control_object,
1246 "handle-device-announce",
1247 G_CALLBACK(on_zdodev_control_device_announce), service_interface);
1249 g_signal_connect(zdodev_control_object,
1250 "handle-simple-desc-req",
1251 G_CALLBACK(on_zdodev_control_simple_desc_req), service_interface);
1253 g_signal_connect(zdodev_control_object,
1254 "handle-mgmt-lqi-req",
1255 G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service_interface);
1257 g_signal_connect(zdodev_control_object,
1258 "handle-mgmt-rtg-req",
1259 G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service_interface);
1261 g_signal_connect(zdodev_control_object,
1262 "handle-mgmt-bind-req",
1263 G_CALLBACK(on_zdodev_control_mgmt_bind_req), service_interface);
1265 g_signal_connect(zdodev_control_object,
1266 "handle-mgmt-permit-join-req",
1267 G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface);
1269 g_signal_connect(zdodev_control_object,
1270 "handle-nwk-update-req",
1271 G_CALLBACK(on_zdodev_control_nwk_update_req), service_interface);
1273 g_signal_connect(zdodev_control_object,
1274 "handle-nwk-disc-req",
1275 G_CALLBACK(on_zdodev_control_nwk_disc_req), service_interface);