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