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