zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zdo_dev_control.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Contact: Suresh Kumar N (suresh.n@samsung.com)
   5  *
   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
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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.
  17  */
  18
  19 #include "zigbee_service_interface_common.h"
  20
  21 #include <zblib_driver_zdo_dev_control.h>
  22
  23 static void *_service_interface_ref_zigbee_zdo_dev_control(ZigBeeServiceInterface *service_interface)
  24 {
  25         ZigbeeObjectSkeleton *zigbee_object = NULL;
  26         ZigbeeCustomData_t *custom_data = NULL;
  27         ZigbeeZdo_dev_control *dev_control_object = NULL;
  28
  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!");
  32                 return NULL;
  33         }
  34
  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);
  39                 return NULL;
  40         }
  41
  42         dev_control_object = zigbee_object_get_zdo_dev_control(ZIGBEE_OBJECT(zigbee_object));
  43         return dev_control_object;
  44 }
  45
  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)
  48 {
  49         ZigbeeServiceInterfaceRespCbData_t *cb_data =
  50                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
  51
  52         ZigbeeZdo_dev_control *dev_control_object;
  53         GDBusMethodInvocation *invocation;
  54
  55         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
  56
  57         NOT_USED(service_interface);
  58         NOT_USED(request_id);
  59
  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);
  62                 g_free(cb_data);
  63                 return;
  64         }
  65
  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);
  68
  69         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
  70         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
  71
  72         zigbee_zdo_dev_control_complete_nwk_addr_req(dev_control_object, invocation,
  73                 payload->result);
  74
  75         g_free(cb_data);
  76 }
  77
  78 static gboolean on_zdodev_control_nwk_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
  79         GDBusMethodInvocation *invocation,
  80         GVariant *eui64,
  81         gchar request_type,
  82         gchar start_index,
  83         gpointer user_data)
  84 {
  85         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  86         ZigbeeZdoDevControlNwkAddrReq_t req;
  87         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  88
  89         GVariantIter *iter = NULL;
  90         guint i = 0;
  91
  92         gboolean ret;
  93
  94         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
  95
  96         /* Update request structure */
  97         g_variant_get(eui64, "a(y)", &iter);
  98         while (g_variant_iter_loop(iter, "(y)", &(req.eui64[i]))) {
  99                 i++;
 100                 if (i >= ZIGBEE_EUI64_SIZE)
 101                         break;
 102         }
 103         req.request_type = request_type;
 104         req.start_index = start_index;
 105
 106         /* Allocate response callback data */
 107         resp_cb_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!");
 112
 113                 /* Send failure response */
 114                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 115
 116                 return TRUE;
 117         }
 118
 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,
 123                 &req, sizeof(req),
 124                 on_zdodev_control_nwk_addr_req_resp, resp_cb_data);
 125         if (FALSE == ret) {
 126                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 127
 128                 /* Free response callback data */
 129                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 130
 131                 /* Send failure response */
 132                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 133
 134                 return TRUE;
 135         }
 136
 137         return TRUE;
 138 }
 139
 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)
 142 {
 143         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 144                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 145
 146         ZigbeeZdo_dev_control *dev_control_object;
 147         GDBusMethodInvocation *invocation;
 148
 149         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 150
 151         NOT_USED(service_interface);
 152         NOT_USED(request_id);
 153
 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);
 156                 g_free(cb_data);
 157                 return;
 158         }
 159
 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);
 162
 163         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 164         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 165
 166         zigbee_zdo_dev_control_complete_matched_descriptor_req(dev_control_object,
 167                 invocation, payload->result);
 168
 169         g_free(cb_data);
 170 }
 171
 172 static gboolean on_zdodev_control_matched_descriptor_req(ZigbeeZdo_dev_control *zdodev_control_object,
 173         GDBusMethodInvocation *invocation,
 174         gushort node_id,
 175         gushort profile_id,
 176         guchar num_in_cl,
 177         GVariant *in_cl,
 178         guchar num_out_cl,
 179         GVariant *out_cl,
 180         gpointer user_data)
 181 {
 182         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 183         ZigbeeZdoDevControlMatchedDescriptorReq_t req;
 184         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 185
 186         GVariantIter *iter = NULL;
 187         guint i = 0;
 188
 189         gboolean ret;
 190
 191         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
 192
 193         /* Update request structure */
 194         req.node_id = node_id;
 195         req.profile_id = profile_id;
 196         req.num_in_cl = num_in_cl;
 197         if (num_in_cl > 0) {
 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]))) {
 201                         i++;
 202                         if (i >= num_in_cl)
 203                                 break;
 204                 }
 205         } else {
 206                 req.in_cl = NULL;
 207         }
 208
 209         i = 0;
 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]))) {
 215                         i++;
 216                         if (i >= num_out_cl)
 217                                 break;
 218                 }
 219         } else {
 220                 req.out_cl = NULL;
 221         }
 222
 223         /* Allocate response callback data */
 224         resp_cb_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!");
 229
 230                 /* Send failure response */
 231                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 232
 233                 return TRUE;
 234         }
 235
 236         /* Dispatch request */
 237         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 238                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 239                 ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ,
 240                 &req, sizeof(req),
 241                 on_zdodev_control_matched_descriptor_req_resp, resp_cb_data);
 242
 243         /* Free resources */
 244         g_free(req.in_cl);
 245         g_free(req.out_cl);
 246
 247         if (FALSE == ret) {
 248                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 249
 250                 /* Free response callback data */
 251                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 252
 253                 /* Send failure response */
 254                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 255
 256                 return TRUE;
 257         }
 258
 259         return TRUE;
 260 }
 261
 262 static void on_zdodev_control_ieee_addr_req_resp(ZigBeeServiceInterface *service_interface,
 263         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 264 {
 265         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 266                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 267
 268         ZigbeeZdo_dev_control *dev_control_object;
 269         GDBusMethodInvocation *invocation;
 270
 271         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 272
 273         NOT_USED(service_interface);
 274         NOT_USED(request_id);
 275
 276         if (NULL == resp_data || 0 == resp_data_len) {
 277                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 278                 g_free(cb_data);
 279                 return;
 280         }
 281
 282         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 283         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 284
 285         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 286         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 287
 288         zigbee_zdo_dev_control_complete_ieee_addr_req(dev_control_object,
 289                 invocation, payload->result);
 290
 291         g_free(cb_data);
 292 }
 293
 294 static gboolean on_zdodev_control_ieee_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
 295         GDBusMethodInvocation *invocation,
 296         gshort node_id,
 297         gpointer user_data)
 298 {
 299         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 300         ZigbeeZdoDevControlIeeeAddrReq_t req;
 301         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 302
 303         gboolean ret;
 304
 305         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
 306
 307         /* Update request structure */
 308         req.node_id = node_id;
 309
 310         /* Allocate response callback data */
 311         resp_cb_data =
 312                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 313                         invocation, NULL, 0);
 314         if (NULL == resp_cb_data) {
 315                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 316
 317                 /* Send failure response */
 318                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 319
 320                 return TRUE;
 321         }
 322
 323         /* Dispatch request */
 324         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 325                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 326                 ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ,
 327                 &req, sizeof(req),
 328                 on_zdodev_control_ieee_addr_req_resp, resp_cb_data);
 329         if (FALSE == ret) {
 330                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 331
 332                 /* Free response callback data */
 333                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 334
 335                 /* Send failure response */
 336                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 337
 338                 return TRUE;
 339         }
 340
 341         return TRUE;
 342 }
 343
 344 static void on_zdodev_control_active_ep_req_resp(ZigBeeServiceInterface *service_interface,
 345         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 346 {
 347         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 348                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 349
 350         ZigbeeZdo_dev_control *dev_control_object;
 351         GDBusMethodInvocation *invocation;
 352
 353         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 354
 355         NOT_USED(service_interface);
 356         NOT_USED(request_id);
 357
 358         if (NULL == resp_data || 0 == resp_data_len) {
 359                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 360                 g_free(cb_data);
 361                 return;
 362         }
 363
 364         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 365         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 366
 367         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 368         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 369
 370         zigbee_zdo_dev_control_complete_active_ep_req(dev_control_object,
 371                 invocation, payload->result);
 372
 373         g_free(cb_data);
 374 }
 375
 376 static gboolean on_zdodev_control_active_ep_req(ZigbeeZdo_dev_control *zdodev_control_object,
 377         GDBusMethodInvocation *invocation,
 378         gshort node_id,
 379         gpointer user_data)
 380 {
 381         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 382         ZigbeeZdoDevControlActiveEpReq_t req;
 383         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 384
 385         gboolean ret;
 386
 387         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlActiveEpReq_t));
 388
 389         /* Update request structure */
 390         req.node_id = node_id;
 391
 392         /* Allocate response callback data */
 393         resp_cb_data =
 394                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 395                         invocation, NULL, 0);
 396         if (NULL == resp_cb_data) {
 397                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 398
 399                 /* Send failure response */
 400                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 401
 402                 return TRUE;
 403         }
 404
 405         /* Dispatch request */
 406         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 407                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 408                 ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ,
 409                 &req, sizeof(req),
 410                 on_zdodev_control_active_ep_req_resp, resp_cb_data);
 411         if (FALSE == ret) {
 412                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 413
 414                 /* Free response callback data */
 415                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 416
 417                 /* Send failure response */
 418                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 419
 420                 return TRUE;
 421         }
 422
 423         return TRUE;
 424 }
 425
 426 static void on_zdodev_control_node_desc_req_resp(ZigBeeServiceInterface *service_interface,
 427         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 428 {
 429         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 430                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 431
 432         ZigbeeZdo_dev_control *dev_control_object;
 433         GDBusMethodInvocation *invocation;
 434
 435         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 436
 437         NOT_USED(service_interface);
 438         NOT_USED(request_id);
 439
 440         if (NULL == resp_data || 0 == resp_data_len) {
 441                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 442                 g_free(cb_data);
 443                 return;
 444         }
 445
 446         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 447         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 448
 449         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 450         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 451
 452         zigbee_zdo_dev_control_complete_node_desc_req(dev_control_object,
 453                 invocation, payload->result);
 454
 455         g_free(cb_data);
 456 }
 457
 458 static gboolean on_zdodev_control_node_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 459         GDBusMethodInvocation *invocation,
 460         gshort node_id,
 461         gpointer user_data)
 462 {
 463         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 464         ZigbeeZdoDevControlNodeDescriptorReq_t req;
 465         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 466
 467         gboolean ret;
 468
 469         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
 470
 471         /* Update request structure */
 472         req.node_id = node_id;
 473
 474         /* Allocate response callback data */
 475         resp_cb_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!");
 480
 481                 /* Send failure response */
 482                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 483
 484                 return TRUE;
 485         }
 486
 487         /* Dispatch request */
 488         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 489                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 490                 ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ,
 491                 &req, sizeof(req),
 492                 on_zdodev_control_node_desc_req_resp, resp_cb_data);
 493         if (FALSE == ret) {
 494                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 495
 496                 /* Free response callback data */
 497                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 498
 499                 /* Send failure response */
 500                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 501
 502                 return TRUE;
 503         }
 504
 505         return TRUE;
 506 }
 507
 508 static void on_zdodev_control_power_desc_req_resp(ZigBeeServiceInterface *service_interface,
 509         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 510 {
 511         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 512                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 513
 514         ZigbeeZdo_dev_control *dev_control_object;
 515         GDBusMethodInvocation *invocation;
 516
 517         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 518
 519         NOT_USED(service_interface);
 520         NOT_USED(request_id);
 521
 522         if (NULL == resp_data || 0 == resp_data_len) {
 523                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 524                 g_free(cb_data);
 525                 return;
 526         }
 527
 528         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 529         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 530
 531         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 532         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 533
 534         zigbee_zdo_dev_control_complete_power_desc_req(dev_control_object,
 535                 invocation, payload->result);
 536
 537         g_free(cb_data);
 538 }
 539
 540 static gboolean on_zdodev_control_power_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 541         GDBusMethodInvocation *invocation,
 542         gshort node_id,
 543         gpointer user_data)
 544 {
 545         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 546         ZigbeeZdoDevControlPowerDescriptorReq_t req;
 547         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 548
 549         gboolean ret;
 550
 551         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
 552
 553         /* Update request structure */
 554         req.node_id = node_id;
 555
 556         /* Allocate response callback data */
 557         resp_cb_data =
 558                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 559                         invocation, NULL, 0);
 560         if (NULL == resp_cb_data) {
 561                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 562
 563                 /* Send failure response */
 564                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 565
 566                 return TRUE;
 567         }
 568
 569         /* Dispatch request */
 570         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 571                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 572                 ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ,
 573                 &req, sizeof(req),
 574                 on_zdodev_control_power_desc_req_resp, resp_cb_data);
 575         if (FALSE == ret) {
 576                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 577
 578                 /* Free response callback data */
 579                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 580
 581                 /* Send failure response */
 582                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 583
 584                 return TRUE;
 585         }
 586
 587         return TRUE;
 588 }
 589
 590 static void on_zdodev_control_complex_desc_req_resp(ZigBeeServiceInterface *service_interface,
 591         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 592 {
 593         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 594                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 595
 596         ZigbeeZdo_dev_control *dev_control_object;
 597         GDBusMethodInvocation *invocation;
 598
 599         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 600
 601         NOT_USED(service_interface);
 602         NOT_USED(request_id);
 603
 604         if (NULL == resp_data || 0 == resp_data_len) {
 605                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 606                 g_free(cb_data);
 607                 return;
 608         }
 609
 610         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 611         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 612
 613         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 614         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 615
 616         zigbee_zdo_dev_control_complete_complex_desc_req(dev_control_object,
 617                 invocation, payload->result);
 618
 619         g_free(cb_data);
 620 }
 621
 622 static gboolean on_zdodev_control_complex_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 623         GDBusMethodInvocation *invocation,
 624         gshort node_id,
 625         gpointer user_data)
 626 {
 627         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 628         ZigbeeZdoDevControlComplexDescriptorReq_t req;
 629         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 630
 631         gboolean ret;
 632
 633         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
 634
 635         /* Update request structure */
 636         req.node_id = node_id;
 637
 638         /* Allocate response callback data */
 639         resp_cb_data =
 640                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 641                         invocation, NULL, 0);
 642         if (NULL == resp_cb_data) {
 643                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 644
 645                 /* Send failure response */
 646                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 647
 648                 return TRUE;
 649         }
 650
 651         /* Dispatch request */
 652         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 653                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 654                 ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ,
 655                 &req, sizeof(req),
 656                 on_zdodev_control_complex_desc_req_resp, resp_cb_data);
 657         if (FALSE == ret) {
 658                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 659
 660                 /* Free response callback data */
 661                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 662
 663                 /* Send failure response */
 664                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 665
 666                 return TRUE;
 667         }
 668
 669         return TRUE;
 670 }
 671
 672 static void on_zdodev_control_user_desc_req_resp(ZigBeeServiceInterface *service_interface,
 673         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 674 {
 675         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 676                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 677
 678         ZigbeeZdo_dev_control *dev_control_object;
 679         GDBusMethodInvocation *invocation;
 680
 681         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 682
 683         NOT_USED(service_interface);
 684         NOT_USED(request_id);
 685
 686         if (NULL == resp_data || 0 == resp_data_len) {
 687                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 688                 g_free(cb_data);
 689                 return;
 690         }
 691
 692         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 693         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 694
 695         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 696         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 697
 698         zigbee_zdo_dev_control_complete_user_desc_req(dev_control_object,
 699                 invocation, payload->result);
 700
 701         g_free(cb_data);
 702 }
 703
 704 static gboolean on_zdodev_control_user_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 705         GDBusMethodInvocation *invocation,
 706         gshort node_id,
 707         gpointer user_data)
 708 {
 709         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 710         ZigbeeZdoDevControlUserDescriptorReq_t req;
 711         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 712
 713         gboolean ret;
 714
 715         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
 716
 717         /* Update request structure */
 718         req.node_id = node_id;
 719
 720         /* Allocate response callback data */
 721         resp_cb_data =
 722                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 723                         invocation, NULL, 0);
 724         if (NULL == resp_cb_data) {
 725                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 726
 727                 /* Send failure response */
 728                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 729
 730                 return TRUE;
 731         }
 732
 733         /* Dispatch request */
 734         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 735                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 736                 ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ,
 737                 &req, sizeof(req),
 738                 on_zdodev_control_user_desc_req_resp, resp_cb_data);
 739         if (FALSE == ret) {
 740                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 741
 742                 /* Free response callback data */
 743                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 744
 745                 /* Send failure response */
 746                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 747
 748                 return TRUE;
 749         }
 750
 751         return TRUE;
 752 }
 753
 754 static void on_zdodev_control_user_desc_set_req_resp(ZigBeeServiceInterface *service_interface,
 755         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 756 {
 757         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 758                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 759
 760         ZigbeeZdo_dev_control *dev_control_object;
 761         GDBusMethodInvocation *invocation;
 762
 763         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 764
 765         NOT_USED(service_interface);
 766         NOT_USED(request_id);
 767
 768         if (NULL == resp_data || 0 == resp_data_len) {
 769                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 770                 g_free(cb_data);
 771                 return;
 772         }
 773
 774         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 775         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 776
 777         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 778         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 779
 780         zigbee_zdo_dev_control_complete_user_desc_set_req(dev_control_object,
 781                 invocation, payload->result);
 782
 783         g_free(cb_data);
 784 }
 785
 786 static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdo_dev_control *zdodev_control_object,
 787         GDBusMethodInvocation *invocation,
 788         gshort node_id,
 789         gchar length,
 790         GVariant *user_desc,
 791         gpointer user_data)
 792 {
 793         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 794         ZigbeeZdoDevControlUserDescriptorSetReq_t req;
 795         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 796
 797         GVariantIter *iter = NULL;
 798         guint i = 0;
 799
 800         gboolean ret;
 801
 802         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
 803
 804         /* Update request structure */
 805         req.node_id = node_id;
 806         req.user_descriptor_len = length;
 807         g_variant_get(user_desc, "a(y)", &iter);
 808         while (g_variant_iter_loop(iter, "(y)", &(req.user_descriptor[i]))) {
 809                 i++;
 810                 if (i >= ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN)
 811                         break;
 812         }
 813
 814         /* Allocate response callback data */
 815         resp_cb_data =
 816                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 817                         invocation, NULL, 0);
 818         if (NULL == resp_cb_data) {
 819                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 820
 821                 /* Send failure response */
 822                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 823
 824                 return TRUE;
 825         }
 826
 827         /* Dispatch request */
 828         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 829                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 830                 ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ,
 831                 &req, sizeof(req),
 832                 on_zdodev_control_user_desc_set_req_resp, resp_cb_data);
 833         if (FALSE == ret) {
 834                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 835
 836                 /* Free response callback data */
 837                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 838
 839                 /* Send failure response */
 840                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 841
 842                 return TRUE;
 843         }
 844
 845         return TRUE;
 846 }
 847
 848 static void on_zdodev_control_device_announce_resp(ZigBeeServiceInterface *service_interface,
 849         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 850 {
 851         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 852                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 853
 854         ZigbeeZdo_dev_control *dev_control_object;
 855         GDBusMethodInvocation *invocation;
 856
 857         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 858
 859         NOT_USED(service_interface);
 860         NOT_USED(request_id);
 861
 862         if (NULL == resp_data || 0 == resp_data_len) {
 863                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 864                 g_free(cb_data);
 865                 return;
 866         }
 867
 868         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 869         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 870
 871         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 872         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 873
 874         zigbee_zdo_dev_control_complete_device_announce(dev_control_object,
 875                 invocation, payload->result);
 876
 877         g_free(cb_data);
 878 }
 879
 880 static gboolean on_zdodev_control_device_announce(ZigbeeZdo_dev_control *zdodev_control_object,
 881         GDBusMethodInvocation *invocation,
 882         gshort node_id,
 883         GVariant *mac_addr,
 884         gchar capability,
 885         gpointer user_data)
 886 {
 887         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 888         ZigbeeZdoDevControlDeviceAnnounce_t req;
 889         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 890
 891         GVariantIter *iter = NULL;
 892         guint i = 0;
 893
 894         gboolean ret;
 895
 896         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
 897
 898         /* Update request structure */
 899         req.node_id = node_id;
 900         g_variant_get(mac_addr, "a(y)", &iter);
 901         while (g_variant_iter_loop(iter, "(y)", &(req.mac_addr[i]))) {
 902                 i++;
 903                 if (i >= ZIGBEE_EUI64_SIZE)
 904                         break;
 905         }
 906         req.capability = capability;
 907
 908         /* Allocate response callback data */
 909         resp_cb_data =
 910                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 911                         invocation, NULL, 0);
 912         if (NULL == resp_cb_data) {
 913                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 914
 915                 /* Send failure response */
 916                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 917
 918                 return TRUE;
 919         }
 920
 921         /* Dispatch request */
 922         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 923                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 924                 ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE,
 925                 &req, sizeof(req),
 926                 on_zdodev_control_device_announce_resp, resp_cb_data);
 927         if (FALSE == ret) {
 928                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 929
 930                 /* Free response callback data */
 931                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 932
 933                 /* Send failure response */
 934                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 935
 936                 return TRUE;
 937         }
 938
 939         return TRUE;
 940 }
 941
 942 static void on_zdodev_control_simple_desc_req_resp(ZigBeeServiceInterface *service_interface,
 943         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 944 {
 945         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 946                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 947
 948         ZigbeeZdo_dev_control *dev_control_object;
 949         GDBusMethodInvocation *invocation;
 950
 951         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 952
 953         NOT_USED(service_interface);
 954         NOT_USED(request_id);
 955
 956         if (NULL == resp_data || 0 == resp_data_len) {
 957                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 958                 g_free(cb_data);
 959                 return;
 960         }
 961
 962         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 963         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
 964
 965         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 966         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 967
 968         zigbee_zdo_dev_control_complete_simple_desc_req(dev_control_object,
 969                 invocation, payload->result);
 970
 971         g_free(cb_data);
 972 }
 973
 974 static gboolean on_zdodev_control_simple_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 975         GDBusMethodInvocation *invocation,
 976         gshort node_id,
 977         gchar endpoint,
 978         gpointer user_data)
 979 {
 980         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 981         ZigbeeZdoDevControlSimpleDescriptorReq_t req;
 982         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 983
 984         gboolean ret;
 985
 986         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
 987
 988         /* Update request structure */
 989         req.node_id = node_id;
 990         req.endpoint = endpoint;
 991
 992         /* Allocate response callback data */
 993         resp_cb_data =
 994                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 995                         invocation, NULL, 0);
 996         if (NULL == resp_cb_data) {
 997                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 998
 999                 /* Send failure response */
1000                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1001
1002                 return TRUE;
1003         }
1004
1005         /* Dispatch request */
1006         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1007                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1008                 ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ,
1009                 &req, sizeof(req),
1010                 on_zdodev_control_simple_desc_req_resp, resp_cb_data);
1011         if (FALSE == ret) {
1012                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1013
1014                 /* Free response callback data */
1015                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1016
1017                 /* Send failure response */
1018                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1019
1020                 return TRUE;
1021         }
1022
1023         return TRUE;
1024 }
1025
1026 static void on_zdodev_control_mgmt_lqi_req_resp(ZigBeeServiceInterface *service_interface,
1027         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1028 {
1029         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1030                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1031
1032         ZigbeeZdo_dev_control *dev_control_object;
1033         GDBusMethodInvocation *invocation;
1034
1035         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1036
1037         NOT_USED(service_interface);
1038         NOT_USED(request_id);
1039
1040         if (NULL == resp_data || 0 == resp_data_len) {
1041                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1042                 g_free(cb_data);
1043                 return;
1044         }
1045
1046         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1047         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1048
1049         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1050         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1051
1052         zigbee_zdo_dev_control_complete_mgmt_lqi_req(dev_control_object,
1053                 invocation, payload->result);
1054
1055         g_free(cb_data);
1056 }
1057
1058 static gboolean on_zdodev_control_mgmt_lqi_req(ZigbeeZdo_dev_control *zdodev_control_object,
1059         GDBusMethodInvocation *invocation,
1060         gshort node_id,
1061         gchar start_idx,
1062         gpointer user_data)
1063 {
1064         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1065         ZigbeeZdoDevControlMgmtLqiReq_t req;
1066         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1067
1068         gboolean ret;
1069
1070         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
1071
1072         /* Update request structure */
1073         req.node_id = node_id;
1074         req.start_index = start_idx;
1075
1076         /* Allocate response callback data */
1077         resp_cb_data =
1078                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1079                         invocation, NULL, 0);
1080         if (NULL == resp_cb_data) {
1081                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1082
1083                 /* Send failure response */
1084                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1085
1086                 return TRUE;
1087         }
1088
1089         /* Dispatch request */
1090         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1091                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1092                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ,
1093                 &req, sizeof(req),
1094                 on_zdodev_control_mgmt_lqi_req_resp, resp_cb_data);
1095         if (FALSE == ret) {
1096                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1097
1098                 /* Free response callback data */
1099                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1100
1101                 /* Send failure response */
1102                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1103
1104                 return TRUE;
1105         }
1106
1107         return TRUE;
1108 }
1109
1110 static void on_zdodev_control_mgmt_rtg_req_resp(ZigBeeServiceInterface *service_interface,
1111         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1112 {
1113         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1114                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1115
1116         ZigbeeZdo_dev_control *dev_control_object;
1117         GDBusMethodInvocation *invocation;
1118
1119         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1120
1121         NOT_USED(service_interface);
1122         NOT_USED(request_id);
1123
1124         if (NULL == resp_data || 0 == resp_data_len) {
1125                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1126                 g_free(cb_data);
1127                 return;
1128         }
1129
1130         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1131         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1132
1133         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1134         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1135
1136         zigbee_zdo_dev_control_complete_mgmt_rtg_req(dev_control_object,
1137                 invocation, payload->result);
1138
1139         g_free(cb_data);
1140 }
1141
1142 static gboolean on_zdodev_control_mgmt_rtg_req(ZigbeeZdo_dev_control *zdodev_control_object,
1143         GDBusMethodInvocation *invocation,
1144         gshort node_id,
1145         gchar start_idx,
1146         gpointer user_data)
1147 {
1148         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1149         ZigbeeZdoDevControlMgmtRtgReq_t req;
1150         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1151
1152         gboolean ret;
1153
1154         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
1155
1156         /* Update request structure */
1157         req.node_id = node_id;
1158         req.start_index = start_idx;
1159
1160         /* Allocate response callback data */
1161         resp_cb_data =
1162                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1163                         invocation, NULL, 0);
1164         if (NULL == resp_cb_data) {
1165                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1166
1167                 /* Send failure response */
1168                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1169
1170                 return TRUE;
1171         }
1172
1173         /* Dispatch request */
1174         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1175                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1176                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ,
1177                 &req, sizeof(req),
1178                 on_zdodev_control_mgmt_rtg_req_resp, resp_cb_data);
1179         if (FALSE == ret) {
1180                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1181
1182                 /* Free response callback data */
1183                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1184
1185                 /* Send failure response */
1186                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1187
1188                 return TRUE;
1189         }
1190
1191         return TRUE;
1192 }
1193
1194 static void on_zdodev_control_mgmt_bind_req_resp(ZigBeeServiceInterface *service_interface,
1195         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1196 {
1197         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1198                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1199
1200         ZigbeeZdo_dev_control *dev_control_object;
1201         GDBusMethodInvocation *invocation;
1202
1203         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1204
1205         NOT_USED(service_interface);
1206         NOT_USED(request_id);
1207
1208         if (NULL == resp_data || 0 == resp_data_len) {
1209                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1210                 g_free(cb_data);
1211                 return;
1212         }
1213
1214         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1215         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1216
1217         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1218         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1219
1220         zigbee_zdo_dev_control_complete_mgmt_bind_req(dev_control_object,
1221                 invocation, payload->result);
1222
1223         g_free(cb_data);
1224 }
1225
1226 static gboolean on_zdodev_control_mgmt_bind_req(ZigbeeZdo_dev_control *zdodev_control_object,
1227         GDBusMethodInvocation *invocation,
1228         gshort node_id,
1229         gchar start_idx,
1230         gpointer user_data)
1231 {
1232         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1233         ZigbeeZdoDevControlMgmtBindReq_t req;
1234         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1235
1236         gboolean ret;
1237
1238         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
1239
1240         /* Update request structure */
1241         req.node_id = node_id;
1242         req.start_index = start_idx;
1243
1244         /* Allocate response callback data */
1245         resp_cb_data =
1246                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1247                         invocation, NULL, 0);
1248         if (NULL == resp_cb_data) {
1249                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1250
1251                 /* Send failure response */
1252                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1253
1254                 return TRUE;
1255         }
1256
1257         /* Dispatch request */
1258         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1259                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1260                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ,
1261                 &req, sizeof(req),
1262                 on_zdodev_control_mgmt_bind_req_resp, resp_cb_data);
1263         if (FALSE == ret) {
1264                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1265
1266                 /* Free response callback data */
1267                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1268
1269                 /* Send failure response */
1270                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1271
1272                 return TRUE;
1273         }
1274
1275         return TRUE;
1276 }
1277
1278 static void on_zdodev_control_mgmt_permit_join_req_resp(ZigBeeServiceInterface *service_interface,
1279         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1280 {
1281         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1282                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1283
1284         ZigbeeZdo_dev_control *dev_control_object;
1285         GDBusMethodInvocation *invocation;
1286
1287         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1288
1289         NOT_USED(service_interface);
1290         NOT_USED(request_id);
1291
1292         if (NULL == resp_data || 0 == resp_data_len) {
1293                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1294                 g_free(cb_data);
1295                 return;
1296         }
1297
1298         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1299         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1300
1301         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1302         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1303
1304         zigbee_zdo_dev_control_complete_mgmt_permit_join_req(dev_control_object,
1305                 invocation, payload->result);
1306
1307         g_free(cb_data);
1308 }
1309
1310 static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zdodev_control_object,
1311         GDBusMethodInvocation *invocation,
1312         gshort node_id,
1313         gchar duration,
1314         gchar tc_significance,
1315         gpointer user_data)
1316 {
1317         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1318         ZigbeeZdoDevControlMgmtPermitJoinReq_t req;
1319         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1320
1321         gboolean ret;
1322
1323         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
1324
1325         /* Update request structure */
1326         req.node_id = node_id;
1327         req.duration = duration;
1328         req.tc_significance = tc_significance;
1329
1330         /* Allocate response callback data */
1331         resp_cb_data =
1332                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1333                         invocation, NULL, 0);
1334         if (NULL == resp_cb_data) {
1335                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1336
1337                 /* Send failure response */
1338                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1339
1340                 return TRUE;
1341         }
1342
1343         /* Dispatch request */
1344         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1345                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1346                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ,
1347                 &req, sizeof(req),
1348                 on_zdodev_control_mgmt_permit_join_req_resp, resp_cb_data);
1349         if (FALSE == ret) {
1350                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1351
1352                 /* Free response callback data */
1353                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1354
1355                 /* Send failure response */
1356                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1357
1358                 return TRUE;
1359         }
1360
1361         return TRUE;
1362 }
1363
1364 static void on_zdodev_control_mgmt_nwk_update_req_resp(ZigBeeServiceInterface *service_interface,
1365         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1366 {
1367         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1368                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1369
1370         ZigbeeZdo_dev_control *dev_control_object;
1371         GDBusMethodInvocation *invocation;
1372
1373         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1374
1375         NOT_USED(service_interface);
1376         NOT_USED(request_id);
1377
1378         if (NULL == resp_data || 0 == resp_data_len) {
1379                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1380                 g_free(cb_data);
1381                 return;
1382         }
1383
1384         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1385         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1386
1387         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1388         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1389
1390         zigbee_zdo_dev_control_complete_mgmt_nwk_update_req(dev_control_object,
1391                 invocation, payload->result);
1392
1393         g_free(cb_data);
1394 }
1395
1396 static gboolean on_zdodev_control_mgmt_nwk_update_req(ZigbeeZdo_dev_control *zdodev_control_object,
1397         GDBusMethodInvocation *invocation,
1398         gshort node_id,
1399         guint scan_channel,
1400         gchar scan_duration,
1401         gchar scan_count,
1402         gint nwk_update_id,
1403         gpointer user_data)
1404 {
1405         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1406         ZigbeeZdoDevControlMgmtNwkUpdateReq_t req;
1407         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1408
1409         gboolean ret;
1410
1411         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtNwkUpdateReq_t));
1412
1413         /* Update request structure */
1414         req.node_id = node_id;
1415         req.scan_channel = scan_channel;
1416         req.scan_duration = scan_duration;
1417         req.scan_count = scan_count;
1418         req.network_update_id = nwk_update_id;
1419
1420         /* Allocate response callback data */
1421         resp_cb_data =
1422                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1423                         invocation, NULL, 0);
1424         if (NULL == resp_cb_data) {
1425                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1426
1427                 /* Send failure response */
1428                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1429
1430                 return TRUE;
1431         }
1432
1433         /* Dispatch request */
1434         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1435                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1436                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_UPDATE_REQ,
1437                 &req, sizeof(req),
1438                 on_zdodev_control_mgmt_nwk_update_req_resp, resp_cb_data);
1439         if (FALSE == ret) {
1440                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1441
1442                 /* Free response callback data */
1443                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1444
1445                 /* Send failure response */
1446                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1447
1448                 return TRUE;
1449         }
1450
1451         return TRUE;
1452 }
1453
1454 static void on_zdodev_control_mgmt_nwk_disc_req_resp(ZigBeeServiceInterface *service_interface,
1455         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1456 {
1457         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1458                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1459
1460         ZigbeeZdo_dev_control *dev_control_object;
1461         GDBusMethodInvocation *invocation;
1462
1463         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1464
1465         NOT_USED(service_interface);
1466         NOT_USED(request_id);
1467
1468         if (NULL == resp_data || 0 == resp_data_len) {
1469                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1470                 g_free(cb_data);
1471                 return;
1472         }
1473
1474         dev_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1475         zblib_check_null_free_and_ret("dev_control_object", dev_control_object, cb_data);
1476
1477         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1478         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1479
1480         zigbee_zdo_dev_control_complete_mgmt_nwk_disc_req(dev_control_object,
1481                 invocation, payload->result);
1482
1483         g_free(cb_data);
1484 }
1485
1486 static gboolean on_zdodev_control_mgmt_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_control_object,
1487         GDBusMethodInvocation *invocation,
1488         gshort node_id,
1489         guint scan_channel,
1490         gchar scan_duration,
1491         gshort scan_count,
1492         gchar start_index,
1493         gpointer user_data)
1494 {
1495         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1496         ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t req;
1497         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1498
1499         gboolean ret;
1500
1501         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtNwkDiscoveryReq_t));
1502
1503         /* Update request structure */
1504         req.node_id = node_id;
1505         req.scan_channel = scan_channel;
1506         req.scan_duration = scan_duration;
1507         req.scan_count = scan_count;
1508         req.start_index = start_index;
1509
1510         /* Allocate response callback data */
1511         resp_cb_data =
1512                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1513                         invocation, NULL, 0);
1514         if (NULL == resp_cb_data) {
1515                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1516
1517                 /* Send failure response */
1518                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1519
1520                 return TRUE;
1521         }
1522
1523         /* Dispatch request */
1524         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1525                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1526                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_NWK_DISC_REQ,
1527                 &req, sizeof(req),
1528                 on_zdodev_control_mgmt_nwk_disc_req_resp, resp_cb_data);
1529         if (FALSE == ret) {
1530                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1531
1532                 /* Free response callback data */
1533                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1534
1535                 /* Send failure response */
1536                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1537
1538                 return TRUE;
1539         }
1540
1541         return TRUE;
1542 }
1543
1544 void zigbee_service_dbus_interface_zdo_dev_control_notification(ZigBeeServiceInterface *service_interface,
1545         guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
1546 {
1547         ZigbeeZdo_dev_control *dev_control_object = NULL;
1548
1549         zblib_check_null_ret("service_interface", service_interface);
1550
1551         if (NULL == noti_data || 0 == noti_data_len) {
1552                 Z_LOGE("noti_data is NULL");
1553                 return;
1554         }
1555
1556         dev_control_object = _service_interface_ref_zigbee_zdo_dev_control(service_interface);
1557         zblib_check_null_ret("dev_control_object", dev_control_object);
1558
1559         NOT_USED(noti_cb_data);
1560
1561         switch(noti_id) {
1562         case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_ADDR_RSP: {
1563                 ZigbeeZdoDevControlNwkAddrResp_t *nwk_addr_t =
1564                         (ZigbeeZdoDevControlNwkAddrResp_t*)noti_data;
1565
1566                 GVariant *v_eui64 = NULL;
1567                 v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1568                         nwk_addr_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
1569                 if (NULL == v_eui64) {
1570                         Z_LOGE("Failed to create variant!");
1571                 } else {
1572                         Z_LOGD("nwk addr rsp : [0x%X]", nwk_addr_t->status);
1573                         zigbee_zdo_dev_control_emit_nwk_addr_rsp(dev_control_object,
1574                                 nwk_addr_t->status, v_eui64, nwk_addr_t->node_id,
1575                                 nwk_addr_t->associated_count, nwk_addr_t->start_index);
1576                 }
1577         break;
1578         }
1579         case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_ADDR_EXT_RSP: {
1580                 ZigbeeZdoDevControlNwkAddrExtResp_t *nwk_addr_t =
1581                         (ZigbeeZdoDevControlNwkAddrExtResp_t*)noti_data;
1582
1583                 GVariant *v_eui64 = NULL;
1584                 GVariant *v_associated = NULL;
1585                 v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1586                         nwk_addr_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
1587                 v_associated = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1588                         nwk_addr_t->associated_addr_list,
1589                         (sizeof(gushort) * nwk_addr_t->associated_count), TRUE, NULL, NULL);
1590                 if (NULL == v_eui64 || NULL == v_associated) {
1591                         Z_LOGE("Failed to create variant!");
1592                         if (v_eui64)
1593                                 g_variant_unref(v_eui64);
1594                         if (v_associated)
1595                                 g_variant_unref(v_associated);
1596                 } else {
1597                         Z_LOGD("nwk addr ext rsp : [0x%X]", nwk_addr_t->status);
1598                         zigbee_zdo_dev_control_emit_nwk_addr_ext_rsp(dev_control_object,
1599                                 nwk_addr_t->status, v_eui64, nwk_addr_t->node_id,
1600                                 nwk_addr_t->associated_count, nwk_addr_t->start_index, v_associated);
1601                 }
1602         break;
1603         }
1604         case ZBLIB_ZDO_DEV_CONTROL_NOTI_ACTIVE_EP_RSP: {
1605                 ZigbeeZdoDevControlActiveEpResp_t *active_t =
1606                         (ZigbeeZdoDevControlActiveEpResp_t *)noti_data;
1607
1608                 GVariant *v_ep_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1609                         active_t->endpoint_list, active_t->endpoint_count, TRUE, NULL, NULL);
1610                 if (NULL == v_ep_list) {
1611                         Z_LOGE("Failed to create variant!");
1612                 } else {
1613                         Z_LOGD("Active endpoint rsp : [0x%X]", active_t->status);
1614                         zigbee_zdo_dev_control_emit_active_ep_rsp(dev_control_object,
1615                                 active_t->status, active_t->node_id,
1616                                 v_ep_list, active_t->endpoint_count);
1617                 }
1618         break;
1619         }
1620         case ZBLIB_ZDO_DEV_CONTROL_NOTI_SIMPLE_DESC_RSP: {
1621                 ZigbeeZdoDevControlSimpleDescriptorResp_t *desc_t =
1622                         (ZigbeeZdoDevControlSimpleDescriptorResp_t *)noti_data;
1623
1624                 GVariant *v_in_cluster = NULL;
1625                 GVariant *v_out_cluster = NULL;
1626                 v_in_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1627                         desc_t->in_cluster, (sizeof(gushort) * desc_t->in_cluster_count),
1628                         TRUE, NULL, NULL);
1629                 v_out_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1630                         desc_t->out_cluster, (sizeof(gushort) * desc_t->out_cluster_count),
1631                         TRUE, NULL, NULL);
1632                 if (NULL == v_in_cluster || NULL == v_out_cluster) {
1633                         Z_LOGE("Failed to create variant!");
1634                         if (v_in_cluster)
1635                                 g_variant_unref(v_in_cluster);
1636                         if (v_out_cluster)
1637                                 g_variant_unref(v_out_cluster);
1638                 } else {
1639                         Z_LOGD("Simple descriptor rsp");
1640                         zigbee_zdo_dev_control_emit_simple_desc_rsp(dev_control_object,
1641                                 desc_t->node_id, desc_t->length, desc_t->device_version,
1642                                 desc_t->endpoint, desc_t->profile_id, desc_t->device_id,
1643                                 desc_t->in_cluster_count, desc_t->out_cluster_count,
1644                                 v_in_cluster, v_out_cluster);
1645                 }
1646         break;
1647         }
1648         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MATCHED_DESC_RSP: {
1649                 ZigbeeZdoDevControlMatchedDescriptorResp_t *desc_t =
1650                         (ZigbeeZdoDevControlMatchedDescriptorResp_t *)noti_data;
1651
1652                 GVariant *v_match_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1653                         desc_t->match_list, desc_t->list_count, TRUE, NULL, NULL);
1654                 if (NULL == v_match_list) {
1655                         Z_LOGE("Failed to create variant!");
1656                 } else {
1657                         Z_LOGD("matched descriptor rsp : [0x%X]", desc_t->status);
1658                         zigbee_zdo_dev_control_emit_matched_descriptor_rsp(dev_control_object,
1659                                 desc_t->status, desc_t->node_id, desc_t->list_count, v_match_list);
1660                 }
1661         break;
1662         }
1663         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_BIND_RSP: {
1664                 ZigbeeZdoDevControlMgmtBindResp_t *desc_t =
1665                         (ZigbeeZdoDevControlMgmtBindResp_t *)noti_data;
1666                 int i = 0;
1667                 int v = 0;
1668
1669                 GVariant *v_entries = NULL;
1670                 GVariantBuilder *entry_builder =
1671                                 g_variant_builder_new (G_VARIANT_TYPE ("a(ayyqyqayy)"));
1672                 if (NULL == entry_builder) {
1673                         Z_LOGE("Failed to create variant builder!");
1674                         break;
1675                 }
1676
1677                 for(i = 0; i < desc_t->table_list_count ; i++) {
1678                         GVariantBuilder *eui64_builder =
1679                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1680                         GVariantBuilder *dest_eui64_builder =
1681                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1682
1683                         if (NULL == eui64_builder || NULL == dest_eui64_builder) {
1684                                 Z_LOGE("Failed to create variant builder!");
1685                                 if (eui64_builder)
1686                                         g_variant_builder_unref(eui64_builder);
1687                                 if (dest_eui64_builder)
1688                                         g_variant_builder_unref(dest_eui64_builder);
1689                                 g_variant_builder_unref(entry_builder);
1690                                 break;
1691                         }
1692
1693                         for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1694                                 g_variant_builder_add (eui64_builder, "y",
1695                                         desc_t->table_list[i].eui64[v]);
1696                                 g_variant_builder_add (dest_eui64_builder, "y",
1697                                         desc_t->table_list[i].dest_eui64[v]);
1698                         }
1699
1700                         g_variant_builder_add (entry_builder, "(ayyqyqayy)",
1701                                 eui64_builder,
1702                                 desc_t->table_list[i].source_endpoint,
1703                                 desc_t->table_list[i].cluster_id,
1704                                 desc_t->table_list[i].dest_addr_mode,
1705                                 desc_t->table_list[i].dest_addr,
1706                                 dest_eui64_builder,
1707                                 desc_t->table_list[i].dest_endpoint);
1708
1709                         g_variant_builder_unref(eui64_builder);
1710                         g_variant_builder_unref(dest_eui64_builder);
1711                 }
1712                 v_entries = g_variant_builder_end(entry_builder);
1713
1714                 Z_LOGD("management bind rsp : [0x%X]", desc_t->status);
1715                 zigbee_zdo_dev_control_emit_mgmt_bind_rsp(dev_control_object,
1716                         desc_t->status, desc_t->table_entries,
1717                         desc_t->start_index, desc_t->table_list_count,
1718                         v_entries);
1719         break;
1720         }
1721         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LQI_RSP: {
1722                 ZigbeeZdoDevControlMgmtLqiResp_t *desc_t =
1723                         (ZigbeeZdoDevControlMgmtLqiResp_t *)noti_data;
1724                 int i = 0;
1725                 int v = 0;
1726
1727                 GVariant *v_entries = NULL;
1728                 GVariantBuilder *entry_builder =
1729                                 g_variant_builder_new (G_VARIANT_TYPE ("a(ayayyqyyyyy)"));
1730                 if (NULL == entry_builder) {
1731                         Z_LOGE("Failed to create variant builder!");
1732                         break;
1733                 }
1734
1735                 for(i = 0; i < desc_t->table_list_count ; i++) {
1736                         GVariantBuilder *ext_pan_builder =
1737                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1738                         GVariantBuilder *eui64_builder =
1739                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1740
1741                         if (NULL == ext_pan_builder || NULL == eui64_builder) {
1742                                 Z_LOGE("Failed to create variant builder!");
1743                                 if (ext_pan_builder)
1744                                         g_variant_builder_unref(ext_pan_builder);
1745                                 if (eui64_builder)
1746                                         g_variant_builder_unref(eui64_builder);
1747                                 g_variant_builder_unref(entry_builder);
1748                                 break;
1749                         }
1750
1751                         for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1752                                 g_variant_builder_add (ext_pan_builder, "y",
1753                                         desc_t->table_list[i].extended_pan_id[v]);
1754                                 g_variant_builder_add (eui64_builder, "y",
1755                                         desc_t->table_list[i].eui64[v]);
1756                         }
1757
1758                         g_variant_builder_add (entry_builder, "(ayayyqyyyyy)",
1759                                 ext_pan_builder,
1760                                 eui64_builder,
1761                                 desc_t->table_list[i].node_id,
1762                                 desc_t->table_list[i].device_type,
1763                                 desc_t->table_list[i].rx_on_when_idle,
1764                                 desc_t->table_list[i].relationship,
1765                                 desc_t->table_list[i].permit_joining,
1766                                 desc_t->table_list[i].depth,
1767                                 desc_t->table_list[i].lqi);
1768
1769                         g_variant_builder_unref(ext_pan_builder);
1770                         g_variant_builder_unref(eui64_builder);
1771                 }
1772                 v_entries = g_variant_builder_end(entry_builder);
1773
1774                 Z_LOGD("management LQI rsp : [0x%X]", desc_t->status);
1775                 zigbee_zdo_dev_control_emit_mgmt_lqi_rsp(dev_control_object,
1776                         desc_t->status, desc_t->table_entries,
1777                         desc_t->start_index, desc_t->table_list_count,
1778                         v_entries);
1779         break;
1780         }
1781         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_RTG_RSP: {
1782                 ZigbeeZdoDevControlMgmtRtgResp_t *desc_t =
1783                         (ZigbeeZdoDevControlMgmtRtgResp_t *)noti_data;
1784                 int i = 0;
1785
1786                 GVariant *v_entries = NULL;
1787                 GVariantBuilder *entry_builder =
1788                                 g_variant_builder_new (G_VARIANT_TYPE ("a(qyyyyq)"));
1789                 if (NULL == entry_builder) {
1790                         Z_LOGE("Failed to create variant builder!");
1791                         break;
1792                 }
1793
1794                 for(i = 0; i < desc_t->table_list_count ; i++) {
1795                         g_variant_builder_add (entry_builder, "(qyyyyq)",
1796                                 desc_t->table_list[i].dest_addr,
1797                                 desc_t->table_list[i].status,
1798                                 desc_t->table_list[i].memory_constrained,
1799                                 desc_t->table_list[i].many_to_one,
1800                                 desc_t->table_list[i].route_record_required,
1801                                 desc_t->table_list[i].next_hop_addr);
1802                 }
1803                 v_entries = g_variant_builder_end(entry_builder);
1804
1805                 Z_LOGD("management routing rsp : [0x%X]", desc_t->status);
1806                 zigbee_zdo_dev_control_emit_mgmt_rtg_rsp(dev_control_object,
1807                         desc_t->status, desc_t->table_entries,
1808                         desc_t->start_index, desc_t->table_list_count,
1809                         v_entries);
1810         break;
1811         }
1812         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_PERMIT_JOIN_RSP: {
1813                 ZigbeeZdoDevControlMgmtPermitJoinResp_t *resp_t =
1814                         (ZigbeeZdoDevControlMgmtPermitJoinResp_t *)noti_data;
1815
1816                 zigbee_zdo_dev_control_emit_mgmt_permit_join_rsp(dev_control_object,
1817                         resp_t->status);
1818         break;
1819         }
1820         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LEAVE_RSP: {
1821                 ZigbeeZdoDevControlMgmtLeftResp_t *resp_t =
1822                         (ZigbeeZdoDevControlMgmtLeftResp_t *)noti_data;
1823
1824                 zigbee_zdo_dev_control_emit_mgmt_leave_rsp(dev_control_object,
1825                         resp_t->status);
1826         break;
1827         }
1828         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_NWK_DISC_RSP: {
1829                 ZigbeeZdoDevControlMgmtNwkDiscoveryResp_t *nwk_disc_t =
1830                         (ZigbeeZdoDevControlMgmtNwkDiscoveryResp_t *)noti_data;
1831                 int i = 0;
1832                 int v = 0;
1833
1834                 GVariant *v_entries = NULL;
1835                 GVariantBuilder *entry_builder =
1836                                 g_variant_builder_new (G_VARIANT_TYPE ("a(ayyyyyyy)"));
1837                 if (NULL == entry_builder) {
1838                         Z_LOGE("Failed to create variant builder!");
1839                         break;
1840                 }
1841
1842                 for(i = 0; i < nwk_disc_t->table_list_count ; i++) {
1843                         GVariantBuilder *ext_pan_builder =
1844                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1845                         if (NULL == ext_pan_builder) {
1846                                 Z_LOGE("Failed to create variant builder!");
1847                                 g_variant_builder_unref(entry_builder);
1848                                 break;
1849                         }
1850
1851                         for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1852                                 g_variant_builder_add (ext_pan_builder, "y",
1853                                         nwk_disc_t->table_list[i].extended_pan_id[v]);
1854                         }
1855
1856                         g_variant_builder_add (entry_builder, "(ayyyyyyy)",
1857                                 ext_pan_builder,
1858                                 nwk_disc_t->table_list[i].logical_channel,
1859                                 nwk_disc_t->table_list[i].stack_profile,
1860                                 nwk_disc_t->table_list[i].zigbee_version,
1861                                 nwk_disc_t->table_list[i].beacon_order,
1862                                 nwk_disc_t->table_list[i].superframe_order,
1863                                 nwk_disc_t->table_list[i].permit_joining);
1864
1865                         g_variant_builder_unref(ext_pan_builder);
1866                 }
1867                 v_entries = g_variant_builder_end(entry_builder);
1868
1869                 Z_LOGD("Network discovery rsp : [0x%X]", nwk_disc_t->status);
1870                 zigbee_zdo_dev_control_emit_mgmt_nwk_disc_rsp(dev_control_object,
1871                         nwk_disc_t->status, nwk_disc_t->network_count,
1872                         nwk_disc_t->start_index, nwk_disc_t->table_list_count,
1873                         v_entries);
1874         break;
1875         }
1876         case ZBLIB_ZDO_DEV_CONTROL_NOTI_NODE_DESC_RSP: {
1877                 ZigbeeZdoDevControlNodeDescriptorResp_t *desc_t =
1878                         (ZigbeeZdoDevControlNodeDescriptorResp_t *)noti_data;
1879
1880                 zigbee_zdo_dev_control_emit_node_desc_rsp(dev_control_object,
1881                         desc_t->status, desc_t->node_id, desc_t->logical_type,
1882                         desc_t->complex_desciptor_available,
1883                         desc_t->user_descriptor_available,
1884                         desc_t->aps_flags, desc_t->frequency_band,
1885                         desc_t->mac_capability_flags, desc_t->manufacturer_code,
1886                         desc_t->max_buffer_size, desc_t->max_incoming_transfer_size,
1887                         desc_t->server_mask, desc_t->max_outgoing_transfer_size,
1888                         desc_t->descriptor_capability_field);
1889         break;
1890         }
1891         case ZBLIB_ZDO_DEV_CONTROL_NOTI_POWER_DESC_RSP: {
1892                 ZigbeeZdoDevControlPowerDescriptorResp_t *desc_t =
1893                         (ZigbeeZdoDevControlPowerDescriptorResp_t *)noti_data;
1894
1895                 zigbee_zdo_dev_control_emit_power_desc_rsp(dev_control_object,
1896                         desc_t->status, desc_t->node_id,
1897                         desc_t->current_power_mode,
1898                         desc_t->available_power_sources,
1899                         desc_t->current_power_source,
1900                         desc_t->current_power_source_level);
1901         break;
1902         }
1903         case ZBLIB_ZDO_DEV_CONTROL_NOTI_COMPLEX_DESC_RSP: {
1904                 ZigbeeZdoDevControlComplexDescriptorResp_t *desc_t =
1905                         (ZigbeeZdoDevControlComplexDescriptorResp_t *)noti_data;
1906
1907                 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1908                         desc_t->complex_descriptor_list, desc_t->list_count,
1909                         TRUE, NULL, NULL);
1910                 if (NULL == v_desc_list) {
1911                         Z_LOGE("Failed to create variant!");
1912                 } else {
1913                         Z_LOGD("Complex descriptor rsp : [0x%X]", desc_t->status);
1914                         zigbee_zdo_dev_control_emit_complex_desc_rsp(dev_control_object,
1915                                 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1916                 }
1917         break;
1918         }
1919         case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_RSP: {
1920                 ZigbeeZdoDevControlUserDescriptorResp_t *desc_t =
1921                         (ZigbeeZdoDevControlUserDescriptorResp_t *)noti_data;
1922
1923                 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1924                         desc_t->user_descriptor_list, desc_t->list_count,
1925                         TRUE, NULL, NULL);
1926                 if (NULL == v_desc_list) {
1927                         Z_LOGE("Failed to create variant!");
1928                 } else {
1929                         Z_LOGD("User descriptor rsp : [0x%X]", desc_t->status);
1930                         zigbee_zdo_dev_control_emit_user_desc_rsp(dev_control_object,
1931                                 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1932                 }
1933         break;
1934         }
1935         case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_CONFIRM: {
1936                 ZigbeeZdoDevControlUserDescriptorConfirm_t *resp_t =
1937                         (ZigbeeZdoDevControlUserDescriptorConfirm_t *)noti_data;
1938
1939                 zigbee_zdo_dev_control_emit_user_desc_confirm(dev_control_object,
1940                         resp_t->status);
1941         break;
1942         }
1943         default:
1944                 Z_LOGE("Unexpected notification [%x]", noti_id);
1945         break;
1946         }
1947
1948         /* ZigbeeZdo_dev_control should be dereferenced */
1949         g_object_unref(dev_control_object);
1950 }
1951
1952 gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
1953         ZigbeeObjectSkeleton *zigbee_object)
1954 {
1955         ZigbeeZdo_dev_control *zdodev_control_object;
1956
1957         if (NULL == service_interface) {
1958                 Z_LOGE("service_interface is NULL");
1959                 return FALSE;
1960         }
1961
1962         zdodev_control_object = zigbee_zdo_dev_control_skeleton_new();
1963         zigbee_object_skeleton_set_zdo_dev_control(zigbee_object, zdodev_control_object);
1964         g_object_unref(zdodev_control_object);
1965
1966         Z_LOGI("zdodev_control_object: [%p]", zdodev_control_object);
1967
1968         /*
1969          * Register signal handlers for 'zdodev_control' interface
1970          */
1971         g_signal_connect(zdodev_control_object,
1972                 "handle-nwk-addr-req",
1973                 G_CALLBACK(on_zdodev_control_nwk_addr_req), service_interface);
1974
1975         g_signal_connect(zdodev_control_object,
1976                 "handle-matched-descriptor-req",
1977                 G_CALLBACK(on_zdodev_control_matched_descriptor_req), service_interface);
1978
1979         g_signal_connect(zdodev_control_object,
1980                 "handle-ieee-addr-req",
1981                 G_CALLBACK(on_zdodev_control_ieee_addr_req), service_interface);
1982
1983         g_signal_connect(zdodev_control_object,
1984                 "handle-active-ep-req",
1985                 G_CALLBACK(on_zdodev_control_active_ep_req), service_interface);
1986
1987         g_signal_connect(zdodev_control_object,
1988                 "handle-node-desc-req",
1989                 G_CALLBACK(on_zdodev_control_node_desc_req), service_interface);
1990
1991         g_signal_connect(zdodev_control_object,
1992                 "handle-power-desc-req",
1993                 G_CALLBACK(on_zdodev_control_power_desc_req), service_interface);
1994
1995         g_signal_connect(zdodev_control_object,
1996                 "handle-complex-desc-req",
1997                 G_CALLBACK(on_zdodev_control_complex_desc_req), service_interface);
1998
1999         g_signal_connect(zdodev_control_object,
2000                 "handle-user-desc-req",
2001                 G_CALLBACK(on_zdodev_control_user_desc_req), service_interface);
2002
2003         g_signal_connect(zdodev_control_object,
2004                 "handle-user-desc-set-req",
2005                 G_CALLBACK(on_zdodev_control_user_desc_set_req), service_interface);
2006
2007         g_signal_connect(zdodev_control_object,
2008                 "handle-device-announce",
2009                 G_CALLBACK(on_zdodev_control_device_announce), service_interface);
2010
2011         g_signal_connect(zdodev_control_object,
2012                 "handle-simple-desc-req",
2013                 G_CALLBACK(on_zdodev_control_simple_desc_req), service_interface);
2014
2015         g_signal_connect(zdodev_control_object,
2016                 "handle-mgmt-lqi-req",
2017                 G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service_interface);
2018
2019         g_signal_connect(zdodev_control_object,
2020                 "handle-mgmt-rtg-req",
2021                 G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service_interface);
2022
2023         g_signal_connect(zdodev_control_object,
2024                 "handle-mgmt-bind-req",
2025                 G_CALLBACK(on_zdodev_control_mgmt_bind_req), service_interface);
2026
2027         g_signal_connect(zdodev_control_object,
2028                 "handle-mgmt-permit-join-req",
2029                 G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface);
2030
2031         g_signal_connect(zdodev_control_object,
2032                 "handle-mgmt-nwk-update-req",
2033                 G_CALLBACK(on_zdodev_control_mgmt_nwk_update_req), service_interface);
2034
2035         g_signal_connect(zdodev_control_object,
2036                 "handle-mgmt-nwk-disc-req",
2037                 G_CALLBACK(on_zdodev_control_mgmt_nwk_disc_req), service_interface);
2038
2039         return TRUE;
2040 }