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         gshort node_id,
 175         gshort profile_id,
 176         gchar num_in_cl,
 177         GVariant *in_cl,
 178         gchar 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_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_nwk_update_req(dev_control_object,
1391                 invocation, payload->result);
1392
1393         g_free(cb_data);
1394 }
1395
1396 static gboolean on_zdodev_control_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         ZigbeeZdoDevControlNwkUpdateReq_t req;
1407         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1408
1409         gboolean ret;
1410
1411         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkUpdateReq_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_NWK_UPDATE_REQ,
1437                 &req, sizeof(req),
1438                 on_zdodev_control_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_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_nwk_disc_req(dev_control_object,
1481                 invocation, payload->result);
1482
1483         g_free(cb_data);
1484 }
1485
1486 static gboolean on_zdodev_control_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         ZigbeeZdoDevControlNwkDiscoveryReq_t req;
1497         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1498
1499         gboolean ret;
1500
1501         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkDiscoveryReq_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_NWK_DISC_REQ,
1527                 &req, sizeof(req),
1528                 on_zdodev_control_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, nwk_addr_t->associated_count, TRUE, NULL, NULL);
1589                 if (NULL == v_eui64 || NULL == v_associated) {
1590                         Z_LOGE("Failed to create variant!");
1591                         if (v_eui64)
1592                                 g_variant_unref(v_eui64);
1593                         if (v_associated)
1594                                 g_variant_unref(v_associated);
1595                 } else {
1596                         Z_LOGD("nwk addr ext rsp : [0x%X]", nwk_addr_t->status);
1597                         zigbee_zdo_dev_control_emit_nwk_addr_ext_rsp(dev_control_object,
1598                                 nwk_addr_t->status, v_eui64, nwk_addr_t->node_id,
1599                                 nwk_addr_t->associated_count, nwk_addr_t->start_index, v_associated);
1600                 }
1601         break;
1602         }
1603         case ZBLIB_ZDO_DEV_CONTROL_NOTI_ACTIVE_EP_RSP: {
1604                 ZigbeeZdoDevControlActiveEpResp_t *active_t =
1605                         (ZigbeeZdoDevControlActiveEpResp_t *)noti_data;
1606
1607                 GVariant *v_ep_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1608                         active_t->endpoint_list, active_t->endpoint_count, TRUE, NULL, NULL);
1609                 if (NULL == v_ep_list) {
1610                         Z_LOGE("Failed to create variant!");
1611                 } else {
1612                         Z_LOGD("Active endpoint rsp : [0x%X]", active_t->status);
1613                         zigbee_zdo_dev_control_emit_active_ep_rsp(dev_control_object,
1614                                 active_t->status, active_t->node_id,
1615                                 v_ep_list, active_t->endpoint_count);
1616                 }
1617         break;
1618         }
1619         case ZBLIB_ZDO_DEV_CONTROL_NOTI_SIMPLE_DESC_RSP: {
1620                 ZigbeeZdoDevControlSimpleDescriptorResp_t *desc_t =
1621                         (ZigbeeZdoDevControlSimpleDescriptorResp_t *)noti_data;
1622
1623                 GVariant *v_in_cluster = NULL;
1624                 GVariant *v_out_cluster = NULL;
1625                 v_in_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1626                         desc_t->in_cluster, (sizeof(gushort) * desc_t->in_cluster_count),
1627                         TRUE, NULL, NULL);
1628                 v_out_cluster = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1629                         desc_t->out_cluster, (sizeof(gushort) * desc_t->out_cluster_count),
1630                         TRUE, NULL, NULL);
1631                 if (NULL == v_in_cluster || NULL == v_out_cluster) {
1632                         Z_LOGE("Failed to create variant!");
1633                         if (v_in_cluster)
1634                                 g_variant_unref(v_in_cluster);
1635                         if (v_out_cluster)
1636                                 g_variant_unref(v_out_cluster);
1637                 } else {
1638                         Z_LOGD("Simple descriptor rsp");
1639                         zigbee_zdo_dev_control_emit_simple_desc_rsp(dev_control_object,
1640                                 desc_t->node_id, desc_t->length, desc_t->device_version,
1641                                 desc_t->endpoint, desc_t->profile_id, desc_t->device_id,
1642                                 desc_t->in_cluster_count, desc_t->out_cluster_count,
1643                                 v_in_cluster, v_out_cluster);
1644                 }
1645         break;
1646         }
1647         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MATCHED_DESC_RSP: {
1648                 ZigbeeZdoDevControlMatchedDescriptorResp_t *desc_t =
1649                         (ZigbeeZdoDevControlMatchedDescriptorResp_t *)noti_data;
1650
1651                 GVariant *v_match_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1652                         desc_t->match_list, desc_t->list_count, TRUE, NULL, NULL);
1653                 if (NULL == v_match_list) {
1654                         Z_LOGE("Failed to create variant!");
1655                 } else {
1656                         Z_LOGD("matched descriptor rsp : [0x%X]", desc_t->status);
1657                         zigbee_zdo_dev_control_emit_matched_descriptor_rsp(dev_control_object,
1658                                 desc_t->status, desc_t->node_id, desc_t->list_count, v_match_list);
1659                 }
1660         break;
1661         }
1662         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_BIND_RSP: {
1663                 ZigbeeZdoDevControlMgmtBindResp_t *desc_t =
1664                         (ZigbeeZdoDevControlMgmtBindResp_t *)noti_data;
1665                 int i = 0;
1666                 int v = 0;
1667
1668                 GVariant *v_entries = NULL;
1669                 GVariantBuilder *entry_builder =
1670                                 g_variant_builder_new (G_VARIANT_TYPE ("a(ayyqyqayy)"));
1671                 if (NULL == entry_builder) {
1672                         Z_LOGE("Failed to create variant builder!");
1673                         break;
1674                 }
1675
1676                 for(i = 0; i < desc_t->table_list_count ; i++) {
1677                         GVariantBuilder *eui64_builder =
1678                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1679                         GVariantBuilder *dest_eui64_builder =
1680                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1681
1682                         if (NULL == eui64_builder || NULL == dest_eui64_builder) {
1683                                 Z_LOGE("Failed to create variant builder!");
1684                                 if (eui64_builder)
1685                                         g_variant_builder_unref(eui64_builder);
1686                                 if (dest_eui64_builder)
1687                                         g_variant_builder_unref(dest_eui64_builder);
1688                                 g_variant_builder_unref(entry_builder);
1689                                 break;
1690                         }
1691
1692                         for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1693                                 g_variant_builder_add (eui64_builder, "y",
1694                                         desc_t->table_list[i].eui64[v]);
1695                                 g_variant_builder_add (dest_eui64_builder, "y",
1696                                         desc_t->table_list[i].dest_eui64[v]);
1697                         }
1698
1699                         g_variant_builder_add (entry_builder, "(ayyqyqayy)",
1700                                 eui64_builder,
1701                                 desc_t->table_list[i].source_endpoint,
1702                                 desc_t->table_list[i].cluster_id,
1703                                 desc_t->table_list[i].dest_addr_mode,
1704                                 desc_t->table_list[i].dest_addr,
1705                                 dest_eui64_builder,
1706                                 desc_t->table_list[i].dest_endpoint);
1707
1708                         g_variant_builder_unref(eui64_builder);
1709                         g_variant_builder_unref(dest_eui64_builder);
1710                 }
1711                 v_entries = g_variant_builder_end(entry_builder);
1712
1713                 Z_LOGD("management bind rsp : [0x%X]", desc_t->status);
1714                 zigbee_zdo_dev_control_emit_mgmt_bind_rsp(dev_control_object,
1715                         desc_t->status, desc_t->table_entries,
1716                         desc_t->start_index, desc_t->table_list_count,
1717                         v_entries);
1718         break;
1719         }
1720         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LQI_RSP: {
1721                 ZigbeeZdoDevControlMgmtLqiResp_t *desc_t =
1722                         (ZigbeeZdoDevControlMgmtLqiResp_t *)noti_data;
1723                 int i = 0;
1724                 int v = 0;
1725
1726                 GVariant *v_entries = NULL;
1727                 GVariantBuilder *entry_builder =
1728                                 g_variant_builder_new (G_VARIANT_TYPE ("a(ayayyqyyyyy)"));
1729                 if (NULL == entry_builder) {
1730                         Z_LOGE("Failed to create variant builder!");
1731                         break;
1732                 }
1733
1734                 for(i = 0; i < desc_t->table_list_count ; i++) {
1735                         GVariantBuilder *ext_pan_builder =
1736                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1737                         GVariantBuilder *eui64_builder =
1738                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1739
1740                         if (NULL == ext_pan_builder || NULL == eui64_builder) {
1741                                 Z_LOGE("Failed to create variant builder!");
1742                                 if (ext_pan_builder)
1743                                         g_variant_builder_unref(ext_pan_builder);
1744                                 if (eui64_builder)
1745                                         g_variant_builder_unref(eui64_builder);
1746                                 g_variant_builder_unref(entry_builder);
1747                                 break;
1748                         }
1749
1750                         for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1751                                 g_variant_builder_add (ext_pan_builder, "y",
1752                                         desc_t->table_list[i].extended_pan_id[v]);
1753                                 g_variant_builder_add (eui64_builder, "y",
1754                                         desc_t->table_list[i].eui64[v]);
1755                         }
1756
1757                         g_variant_builder_add (entry_builder, "(ayayyqyyyyy)",
1758                                 ext_pan_builder,
1759                                 eui64_builder,
1760                                 desc_t->table_list[i].node_id,
1761                                 desc_t->table_list[i].device_type,
1762                                 desc_t->table_list[i].rx_on_when_idle,
1763                                 desc_t->table_list[i].relationship,
1764                                 desc_t->table_list[i].permit_joining,
1765                                 desc_t->table_list[i].depth,
1766                                 desc_t->table_list[i].lqi);
1767
1768                         g_variant_builder_unref(ext_pan_builder);
1769                         g_variant_builder_unref(eui64_builder);
1770                 }
1771                 v_entries = g_variant_builder_end(entry_builder);
1772
1773                 Z_LOGD("management LQI rsp : [0x%X]", desc_t->status);
1774                 zigbee_zdo_dev_control_emit_mgmt_lqi_rsp(dev_control_object,
1775                         desc_t->status, desc_t->table_entries,
1776                         desc_t->start_index, desc_t->table_list_count,
1777                         v_entries);
1778         break;
1779         }
1780         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_RTG_RSP: {
1781                 ZigbeeZdoDevControlMgmtRtgResp_t *desc_t =
1782                         (ZigbeeZdoDevControlMgmtRtgResp_t *)noti_data;
1783                 int i = 0;
1784
1785                 GVariant *v_entries = NULL;
1786                 GVariantBuilder *entry_builder =
1787                                 g_variant_builder_new (G_VARIANT_TYPE ("a(qyyyyq)"));
1788                 if (NULL == entry_builder) {
1789                         Z_LOGE("Failed to create variant builder!");
1790                         break;
1791                 }
1792
1793                 for(i = 0; i < desc_t->table_list_count ; i++) {
1794                         g_variant_builder_add (entry_builder, "(qyyyyq)",
1795                                 desc_t->table_list[i].dest_addr,
1796                                 desc_t->table_list[i].status,
1797                                 desc_t->table_list[i].memory_constrained,
1798                                 desc_t->table_list[i].many_to_one,
1799                                 desc_t->table_list[i].route_record_required,
1800                                 desc_t->table_list[i].next_hop_addr);
1801                 }
1802                 v_entries = g_variant_builder_end(entry_builder);
1803
1804                 Z_LOGD("management routing rsp : [0x%X]", desc_t->status);
1805                 zigbee_zdo_dev_control_emit_mgmt_rtg_rsp(dev_control_object,
1806                         desc_t->status, desc_t->table_entries,
1807                         desc_t->start_index, desc_t->table_list_count,
1808                         v_entries);
1809         break;
1810         }
1811         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_PERMIT_JOIN_RSP: {
1812                 ZigbeeZdoDevControlMgmtPermitJoinResp_t *resp_t =
1813                         (ZigbeeZdoDevControlMgmtPermitJoinResp_t *)noti_data;
1814
1815                 zigbee_zdo_dev_control_emit_mgmt_permit_join_rsp(dev_control_object,
1816                         resp_t->status);
1817         break;
1818         }
1819         case ZBLIB_ZDO_DEV_CONTROL_NOTI_MGMT_LEFT_RSP: {
1820                 ZigbeeZdoDevControlMgmtLeftResp_t *resp_t =
1821                         (ZigbeeZdoDevControlMgmtLeftResp_t *)noti_data;
1822
1823                 zigbee_zdo_dev_control_emit_mgmt_left_rsp(dev_control_object,
1824                         resp_t->status);
1825         break;
1826         }
1827         case ZBLIB_ZDO_DEV_CONTROL_NOTI_NWK_DISC_RSP: {
1828                 ZigbeeZdoDevControlNwkDiscoveryResp_t *nwk_disc_t =
1829                         (ZigbeeZdoDevControlNwkDiscoveryResp_t *)noti_data;
1830                 int i = 0;
1831                 int v = 0;
1832
1833                 GVariant *v_entries = NULL;
1834                 GVariantBuilder *entry_builder =
1835                                 g_variant_builder_new (G_VARIANT_TYPE ("a(ayyyyyyy)"));
1836                 if (NULL == entry_builder) {
1837                         Z_LOGE("Failed to create variant builder!");
1838                         break;
1839                 }
1840
1841                 for(i = 0; i < nwk_disc_t->table_list_count ; i++) {
1842                         GVariantBuilder *ext_pan_builder =
1843                                         g_variant_builder_new (G_VARIANT_TYPE ("ay"));
1844                         if (NULL == ext_pan_builder) {
1845                                 Z_LOGE("Failed to create variant builder!");
1846                                 g_variant_builder_unref(entry_builder);
1847                                 break;
1848                         }
1849
1850                         for (v = 0; v < ZIGBEE_EUI64_SIZE; v++) {
1851                                 g_variant_builder_add (ext_pan_builder, "y",
1852                                         nwk_disc_t->table_list[i].extended_pan_id[v]);
1853                         }
1854
1855                         g_variant_builder_add (entry_builder, "(ayyyyyyy)",
1856                                 ext_pan_builder,
1857                                 nwk_disc_t->table_list[i].logical_channel,
1858                                 nwk_disc_t->table_list[i].stack_profile,
1859                                 nwk_disc_t->table_list[i].zigbee_version,
1860                                 nwk_disc_t->table_list[i].beacon_order,
1861                                 nwk_disc_t->table_list[i].superframe_order,
1862                                 nwk_disc_t->table_list[i].permit_joining);
1863
1864                         g_variant_builder_unref(ext_pan_builder);
1865                 }
1866                 v_entries = g_variant_builder_end(entry_builder);
1867
1868                 Z_LOGD("Network discovery rsp : [0x%X]", nwk_disc_t->status);
1869                 zigbee_zdo_dev_control_emit_nwk_disc_rsp(dev_control_object,
1870                         nwk_disc_t->status, nwk_disc_t->network_count,
1871                         nwk_disc_t->start_index, nwk_disc_t->table_list_count,
1872                         v_entries);
1873         break;
1874         }
1875         case ZBLIB_ZDO_DEV_CONTROL_NOTI_NODE_DESC_RSP: {
1876                 ZigbeeZdoDevControlNodeDescriptorResp_t *desc_t =
1877                         (ZigbeeZdoDevControlNodeDescriptorResp_t *)noti_data;
1878
1879                 zigbee_zdo_dev_control_emit_node_desc_rsp(dev_control_object,
1880                         desc_t->status, desc_t->node_id, desc_t->logical_type,
1881                         desc_t->complex_desciptor_available,
1882                         desc_t->user_descriptor_available,
1883                         desc_t->aps_flags, desc_t->frequency_band,
1884                         desc_t->mac_capability_flags, desc_t->manufacturer_code,
1885                         desc_t->max_buffer_size, desc_t->max_incoming_transfer_size,
1886                         desc_t->server_mask, desc_t->max_outgoing_transfer_size,
1887                         desc_t->descriptor_capability_field);
1888         break;
1889         }
1890         case ZBLIB_ZDO_DEV_CONTROL_NOTI_POWER_DESC_RSP: {
1891                 ZigbeeZdoDevControlPowerDescriptorResp_t *desc_t =
1892                         (ZigbeeZdoDevControlPowerDescriptorResp_t *)noti_data;
1893
1894                 zigbee_zdo_dev_control_emit_power_desc_rsp(dev_control_object,
1895                         desc_t->status, desc_t->node_id,
1896                         desc_t->current_power_mode,
1897                         desc_t->available_power_sources,
1898                         desc_t->current_power_source,
1899                         desc_t->current_power_source_level);
1900         break;
1901         }
1902         case ZBLIB_ZDO_DEV_CONTROL_NOTI_COMPLEX_DESC_RSP: {
1903                 ZigbeeZdoDevControlComplexDescriptorResp_t *desc_t =
1904                         (ZigbeeZdoDevControlComplexDescriptorResp_t *)noti_data;
1905
1906                 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1907                         desc_t->complex_descriptor_list, desc_t->list_count,
1908                         TRUE, NULL, NULL);
1909                 if (NULL == v_desc_list) {
1910                         Z_LOGE("Failed to create variant!");
1911                 } else {
1912                         Z_LOGD("Complex descriptor rsp : [0x%X]", desc_t->status);
1913                         zigbee_zdo_dev_control_emit_complex_desc_rsp(dev_control_object,
1914                                 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1915                 }
1916         break;
1917         }
1918         case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_RSP: {
1919                 ZigbeeZdoDevControlUserDescriptorResp_t *desc_t =
1920                         (ZigbeeZdoDevControlUserDescriptorResp_t *)noti_data;
1921
1922                 GVariant *v_desc_list = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1923                         desc_t->user_descriptor_list, desc_t->list_count,
1924                         TRUE, NULL, NULL);
1925                 if (NULL == v_desc_list) {
1926                         Z_LOGE("Failed to create variant!");
1927                 } else {
1928                         Z_LOGD("User descriptor rsp : [0x%X]", desc_t->status);
1929                         zigbee_zdo_dev_control_emit_user_desc_rsp(dev_control_object,
1930                                 desc_t->status, desc_t->node_id, desc_t->list_count, v_desc_list);
1931                 }
1932         break;
1933         }
1934         case ZBLIB_ZDO_DEV_CONTROL_NOTI_USER_DESC_CONFIRM: {
1935                 ZigbeeZdoDevControlUserDescriptorConfirm_t *resp_t =
1936                         (ZigbeeZdoDevControlUserDescriptorConfirm_t *)noti_data;
1937
1938                 zigbee_zdo_dev_control_emit_user_desc_confirm(dev_control_object,
1939                         resp_t->status);
1940         break;
1941         }
1942         default:
1943                 Z_LOGE("Unexpected notification [%x]", noti_id);
1944         break;
1945         }
1946
1947         /* ZigbeeZdo_dev_control should be dereferenced */
1948         g_object_unref(dev_control_object);
1949 }
1950
1951 gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
1952         ZigbeeObjectSkeleton *zigbee_object)
1953 {
1954         ZigbeeZdo_dev_control *zdodev_control_object;
1955
1956         if (NULL == service_interface) {
1957                 Z_LOGE("service_interface is NULL");
1958                 return FALSE;
1959         }
1960
1961         zdodev_control_object = zigbee_zdo_dev_control_skeleton_new();
1962         zigbee_object_skeleton_set_zdo_dev_control(zigbee_object, zdodev_control_object);
1963         g_object_unref(zdodev_control_object);
1964
1965         Z_LOGI("zdodev_control_object: [%p]", zdodev_control_object);
1966
1967         /*
1968          * Register signal handlers for 'zdodev_control' interface
1969          */
1970         g_signal_connect(zdodev_control_object,
1971                 "handle-nwk-addr-req",
1972                 G_CALLBACK(on_zdodev_control_nwk_addr_req), service_interface);
1973
1974         g_signal_connect(zdodev_control_object,
1975                 "handle-matched-descriptor-req",
1976                 G_CALLBACK(on_zdodev_control_matched_descriptor_req), service_interface);
1977
1978         g_signal_connect(zdodev_control_object,
1979                 "handle-ieee-addr-req",
1980                 G_CALLBACK(on_zdodev_control_ieee_addr_req), service_interface);
1981
1982         g_signal_connect(zdodev_control_object,
1983                 "handle-active-ep-req",
1984                 G_CALLBACK(on_zdodev_control_active_ep_req), service_interface);
1985
1986         g_signal_connect(zdodev_control_object,
1987                 "handle-node-desc-req",
1988                 G_CALLBACK(on_zdodev_control_node_desc_req), service_interface);
1989
1990         g_signal_connect(zdodev_control_object,
1991                 "handle-power-desc-req",
1992                 G_CALLBACK(on_zdodev_control_power_desc_req), service_interface);
1993
1994         g_signal_connect(zdodev_control_object,
1995                 "handle-complex-desc-req",
1996                 G_CALLBACK(on_zdodev_control_complex_desc_req), service_interface);
1997
1998         g_signal_connect(zdodev_control_object,
1999                 "handle-user-desc-req",
2000                 G_CALLBACK(on_zdodev_control_user_desc_req), service_interface);
2001
2002         g_signal_connect(zdodev_control_object,
2003                 "handle-user-desc-set-req",
2004                 G_CALLBACK(on_zdodev_control_user_desc_set_req), service_interface);
2005
2006         g_signal_connect(zdodev_control_object,
2007                 "handle-device-announce",
2008                 G_CALLBACK(on_zdodev_control_device_announce), service_interface);
2009
2010         g_signal_connect(zdodev_control_object,
2011                 "handle-simple-desc-req",
2012                 G_CALLBACK(on_zdodev_control_simple_desc_req), service_interface);
2013
2014         g_signal_connect(zdodev_control_object,
2015                 "handle-mgmt-lqi-req",
2016                 G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service_interface);
2017
2018         g_signal_connect(zdodev_control_object,
2019                 "handle-mgmt-rtg-req",
2020                 G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service_interface);
2021
2022         g_signal_connect(zdodev_control_object,
2023                 "handle-mgmt-bind-req",
2024                 G_CALLBACK(on_zdodev_control_mgmt_bind_req), service_interface);
2025
2026         g_signal_connect(zdodev_control_object,
2027                 "handle-mgmt-permit-join-req",
2028                 G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface);
2029
2030         g_signal_connect(zdodev_control_object,
2031                 "handle-nwk-update-req",
2032                 G_CALLBACK(on_zdodev_control_nwk_update_req), service_interface);
2033
2034         g_signal_connect(zdodev_control_object,
2035                 "handle-nwk-disc-req",
2036                 G_CALLBACK(on_zdodev_control_nwk_disc_req), service_interface);
2037
2038         return TRUE;
2039 }