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

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Contact: Suresh Kumar N (suresh.n@samsung.com)
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include "zigbee_service_interface_common.h"
  20
  21 #include <zblib_driver_zdo_dev_control.h>
  22
  23 static void on_zdodev_control_nwk_addr_req_resp(ZigBeeServiceInterface *service_interface,
  24         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
  25 {
  26         ZigbeeServiceInterfaceRespCbData_t *cb_data =
  27                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
  28
  29         NOT_USED(cb_data);
  30         NOT_USED(service_interface);
  31         NOT_USED(request_id);
  32         NOT_USED(resp_data);
  33         NOT_USED(resp_data_len);
  34 }
  35
  36 static gboolean on_zdodev_control_nwk_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
  37         GDBusMethodInvocation *invocation,
  38         GVariant *eui64,
  39         gchar request_type,
  40         gchar start_index,
  41         gpointer user_data)
  42 {
  43         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  44         ZigbeeZdoDevControlNwkAddrReq_t req;
  45         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  46
  47         GVariantIter *iter = NULL;
  48         guint i = 0;
  49
  50         gboolean ret;
  51
  52         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
  53
  54         /* Update request structure */
  55         g_variant_get(eui64, "ay", &iter);
  56         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
  57                 i++;
  58                 if (i >= ZIGBEE_EUI64_SIZE)
  59                         break;
  60         }
  61         req.request_type = request_type;
  62         req.start_index = start_index;
  63
  64         /* Allocate response callback data */
  65         resp_cb_data =
  66                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
  67                         invocation, NULL, 0);
  68         if (NULL == resp_cb_data) {
  69                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
  70
  71                 /* Send failure response */
  72                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
  73
  74                 return TRUE;
  75         }
  76
  77         /* Dispatch request */
  78         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
  79                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
  80                 ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ,
  81                 &req, sizeof(req),
  82                 on_zdodev_control_nwk_addr_req_resp, resp_cb_data);
  83         if (FALSE == ret) {
  84                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
  85
  86                 /* Free response callback data */
  87                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
  88
  89                 /* Send failure response */
  90                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
  91
  92                 return TRUE;
  93         }
  94
  95         return TRUE;
  96 }
  97
  98 static void on_zdodev_control_matched_descriptor_req_resp(ZigBeeServiceInterface *service_interface,
  99         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 100 {
 101         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 102                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 103
 104         NOT_USED(cb_data);
 105         NOT_USED(service_interface);
 106         NOT_USED(request_id);
 107         NOT_USED(resp_data);
 108         NOT_USED(resp_data_len);
 109 }
 110
 111 static gboolean on_zdodev_control_matched_descriptor_req(ZigbeeZdo_dev_control *zdodev_control_object,
 112         GDBusMethodInvocation *invocation,
 113         gshort node_id,
 114         gshort profile_id,
 115         gchar num_in_cl,
 116         GVariant *in_cl,
 117         gchar num_out_cl,
 118         GVariant *out_cl,
 119         gpointer user_data)
 120 {
 121         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 122         ZigbeeZdoDevControlMatchedDescriptorReq_t req;
 123         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 124
 125         GVariantIter *iter = NULL;
 126         guint i = 0;
 127
 128         gboolean ret;
 129
 130         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
 131
 132         /* Update request structure */
 133         req.node_id = node_id;
 134         req.profile_id = profile_id;
 135         req.num_in_cl = num_in_cl;
 136         req.in_cl = g_malloc0(sizeof(num_in_cl));
 137         g_variant_get(in_cl, "ay", &iter);
 138         while (g_variant_iter_loop(iter, "y", req.in_cl[i])) {
 139                 i++;
 140                 if (i >= num_in_cl)
 141                         break;
 142         }
 143
 144         i = 0;
 145         req.num_out_cl = num_out_cl;
 146         req.out_cl = g_malloc0(sizeof(num_out_cl));
 147         g_variant_get(out_cl, "ay", &iter);
 148         while (g_variant_iter_loop(iter, "y", req.out_cl[i])) {
 149                 i++;
 150                 if (i >= num_out_cl)
 151                         break;
 152         }
 153
 154         /* Allocate response callback data */
 155         resp_cb_data =
 156                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 157                         invocation, NULL, 0);
 158         if (NULL == resp_cb_data) {
 159                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 160
 161                 /* Send failure response */
 162                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 163
 164                 return TRUE;
 165         }
 166
 167         /* Dispatch request */
 168         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 169                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 170                 ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ,
 171                 &req, sizeof(req),
 172                 on_zdodev_control_matched_descriptor_req_resp, resp_cb_data);
 173
 174         /* Free resources */
 175         g_free(req.in_cl);
 176         g_free(req.out_cl);
 177
 178         if (FALSE == ret) {
 179                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 180
 181                 /* Free response callback data */
 182                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 183
 184                 /* Send failure response */
 185                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 186
 187                 return TRUE;
 188         }
 189
 190         return TRUE;
 191 }
 192
 193 static void on_zdodev_control_ieee_addr_req_resp(ZigBeeServiceInterface *service_interface,
 194         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 195 {
 196         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 197                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 198
 199         NOT_USED(cb_data);
 200         NOT_USED(service_interface);
 201         NOT_USED(request_id);
 202         NOT_USED(resp_data);
 203         NOT_USED(resp_data_len);
 204 }
 205
 206 static gboolean on_zdodev_control_ieee_addr_req(ZigbeeZdo_dev_control *zdodev_control_object,
 207         GDBusMethodInvocation *invocation,
 208         gshort node_id,
 209         gpointer user_data)
 210 {
 211         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 212         ZigbeeZdoDevControlIeeeAddrReq_t req;
 213         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 214
 215         gboolean ret;
 216
 217         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
 218
 219         /* Update request structure */
 220         req.node_id = node_id;
 221
 222         /* Allocate response callback data */
 223         resp_cb_data =
 224                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 225                         invocation, NULL, 0);
 226         if (NULL == resp_cb_data) {
 227                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 228
 229                 /* Send failure response */
 230                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 231
 232                 return TRUE;
 233         }
 234
 235         /* Dispatch request */
 236         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 237                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 238                 ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ,
 239                 &req, sizeof(req),
 240                 on_zdodev_control_ieee_addr_req_resp, resp_cb_data);
 241         if (FALSE == ret) {
 242                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 243
 244                 /* Free response callback data */
 245                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 246
 247                 /* Send failure response */
 248                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 249
 250                 return TRUE;
 251         }
 252
 253         return TRUE;
 254 }
 255
 256 static void on_zdodev_control_active_ep_req_resp(ZigBeeServiceInterface *service_interface,
 257         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 258 {
 259         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 260                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 261
 262         NOT_USED(cb_data);
 263         NOT_USED(service_interface);
 264         NOT_USED(request_id);
 265         NOT_USED(resp_data);
 266         NOT_USED(resp_data_len);
 267 }
 268
 269 static gboolean on_zdodev_control_active_ep_req(ZigbeeZdo_dev_control *zdodev_control_object,
 270         GDBusMethodInvocation *invocation,
 271         gshort node_id,
 272         gpointer user_data)
 273 {
 274         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 275         ZigbeeZdoDevControlActiveEpReq_t req;
 276         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 277
 278         gboolean ret;
 279
 280         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlActiveEpReq_t));
 281
 282         /* Update request structure */
 283         req.node_id = node_id;
 284
 285         /* Allocate response callback data */
 286         resp_cb_data =
 287                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 288                         invocation, NULL, 0);
 289         if (NULL == resp_cb_data) {
 290                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 291
 292                 /* Send failure response */
 293                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 294
 295                 return TRUE;
 296         }
 297
 298         /* Dispatch request */
 299         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 300                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 301                 ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ,
 302                 &req, sizeof(req),
 303                 on_zdodev_control_active_ep_req_resp, resp_cb_data);
 304         if (FALSE == ret) {
 305                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 306
 307                 /* Free response callback data */
 308                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 309
 310                 /* Send failure response */
 311                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 312
 313                 return TRUE;
 314         }
 315
 316         return TRUE;
 317 }
 318
 319 static void on_zdodev_control_node_desc_req_resp(ZigBeeServiceInterface *service_interface,
 320         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 321 {
 322         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 323                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 324
 325         NOT_USED(cb_data);
 326         NOT_USED(service_interface);
 327         NOT_USED(request_id);
 328         NOT_USED(resp_data);
 329         NOT_USED(resp_data_len);
 330 }
 331
 332 static gboolean on_zdodev_control_node_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 333         GDBusMethodInvocation *invocation,
 334         gshort node_id,
 335         gpointer user_data)
 336 {
 337         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 338         ZigbeeZdoDevControlNodeDescriptorReq_t req;
 339         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 340
 341         gboolean ret;
 342
 343         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
 344
 345         /* Update request structure */
 346         req.node_id = node_id;
 347
 348         /* Allocate response callback data */
 349         resp_cb_data =
 350                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 351                         invocation, NULL, 0);
 352         if (NULL == resp_cb_data) {
 353                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 354
 355                 /* Send failure response */
 356                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 357
 358                 return TRUE;
 359         }
 360
 361         /* Dispatch request */
 362         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 363                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 364                 ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ,
 365                 &req, sizeof(req),
 366                 on_zdodev_control_node_desc_req_resp, resp_cb_data);
 367         if (FALSE == ret) {
 368                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 369
 370                 /* Free response callback data */
 371                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 372
 373                 /* Send failure response */
 374                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 375
 376                 return TRUE;
 377         }
 378
 379         return TRUE;
 380 }
 381
 382 static void on_zdodev_control_power_desc_req_resp(ZigBeeServiceInterface *service_interface,
 383         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 384 {
 385         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 386                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 387
 388         NOT_USED(cb_data);
 389         NOT_USED(service_interface);
 390         NOT_USED(request_id);
 391         NOT_USED(resp_data);
 392         NOT_USED(resp_data_len);
 393 }
 394
 395 static gboolean on_zdodev_control_power_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 396         GDBusMethodInvocation *invocation,
 397         gshort node_id,
 398         gpointer user_data)
 399 {
 400         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 401         ZigbeeZdoDevControlPowerDescriptorReq_t req;
 402         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 403
 404         gboolean ret;
 405
 406         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
 407
 408         /* Update request structure */
 409         req.node_id = node_id;
 410
 411         /* Allocate response callback data */
 412         resp_cb_data =
 413                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 414                         invocation, NULL, 0);
 415         if (NULL == resp_cb_data) {
 416                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 417
 418                 /* Send failure response */
 419                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 420
 421                 return TRUE;
 422         }
 423
 424         /* Dispatch request */
 425         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 426                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 427                 ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ,
 428                 &req, sizeof(req),
 429                 on_zdodev_control_power_desc_req_resp, resp_cb_data);
 430         if (FALSE == ret) {
 431                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 432
 433                 /* Free response callback data */
 434                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 435
 436                 /* Send failure response */
 437                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 438
 439                 return TRUE;
 440         }
 441
 442         return TRUE;
 443 }
 444
 445 static void on_zdodev_control_complex_desc_req_resp(ZigBeeServiceInterface *service_interface,
 446         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 447 {
 448         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 449                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 450
 451         NOT_USED(cb_data);
 452         NOT_USED(service_interface);
 453         NOT_USED(request_id);
 454         NOT_USED(resp_data);
 455         NOT_USED(resp_data_len);
 456 }
 457
 458 static gboolean on_zdodev_control_complex_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 459         GDBusMethodInvocation *invocation,
 460         gshort node_id,
 461         gpointer user_data)
 462 {
 463         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 464         ZigbeeZdoDevControlComplexDescriptorReq_t req;
 465         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 466
 467         gboolean ret;
 468
 469         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
 470
 471         /* Update request structure */
 472         req.node_id = node_id;
 473
 474         /* Allocate response callback data */
 475         resp_cb_data =
 476                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 477                         invocation, NULL, 0);
 478         if (NULL == resp_cb_data) {
 479                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 480
 481                 /* Send failure response */
 482                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 483
 484                 return TRUE;
 485         }
 486
 487         /* Dispatch request */
 488         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 489                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 490                 ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ,
 491                 &req, sizeof(req),
 492                 on_zdodev_control_complex_desc_req_resp, resp_cb_data);
 493         if (FALSE == ret) {
 494                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 495
 496                 /* Free response callback data */
 497                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 498
 499                 /* Send failure response */
 500                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 501
 502                 return TRUE;
 503         }
 504
 505         return TRUE;
 506 }
 507
 508 static void on_zdodev_control_user_desc_req_resp(ZigBeeServiceInterface *service_interface,
 509         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 510 {
 511         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 512                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 513
 514         NOT_USED(cb_data);
 515         NOT_USED(service_interface);
 516         NOT_USED(request_id);
 517         NOT_USED(resp_data);
 518         NOT_USED(resp_data_len);
 519 }
 520
 521 static gboolean on_zdodev_control_user_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 522         GDBusMethodInvocation *invocation,
 523         gshort node_id,
 524         gpointer user_data)
 525 {
 526         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 527         ZigbeeZdoDevControlUserDescriptorReq_t req;
 528         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 529
 530         gboolean ret;
 531
 532         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
 533
 534         /* Update request structure */
 535         req.node_id = node_id;
 536
 537         /* Allocate response callback data */
 538         resp_cb_data =
 539                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 540                         invocation, NULL, 0);
 541         if (NULL == resp_cb_data) {
 542                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 543
 544                 /* Send failure response */
 545                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 546
 547                 return TRUE;
 548         }
 549
 550         /* Dispatch request */
 551         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 552                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 553                 ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ,
 554                 &req, sizeof(req),
 555                 on_zdodev_control_user_desc_req_resp, resp_cb_data);
 556         if (FALSE == ret) {
 557                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 558
 559                 /* Free response callback data */
 560                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 561
 562                 /* Send failure response */
 563                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 564
 565                 return TRUE;
 566         }
 567
 568         return TRUE;
 569 }
 570
 571 static void on_zdodev_control_user_desc_set_req_resp(ZigBeeServiceInterface *service_interface,
 572         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 573 {
 574         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 575                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 576
 577         NOT_USED(cb_data);
 578         NOT_USED(service_interface);
 579         NOT_USED(request_id);
 580         NOT_USED(resp_data);
 581         NOT_USED(resp_data_len);
 582 }
 583
 584 static gboolean on_zdodev_control_user_desc_set_req(ZigbeeZdo_dev_control *zdodev_control_object,
 585         GDBusMethodInvocation *invocation,
 586         gshort node_id,
 587         gchar length,
 588         GVariant *user_desc,
 589         gpointer user_data)
 590 {
 591         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 592         ZigbeeZdoDevControlUserDescriptorSetReq_t req;
 593         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 594
 595         GVariantIter *iter = NULL;
 596         guint i = 0;
 597
 598         gboolean ret;
 599
 600         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
 601
 602         /* Update request structure */
 603         req.node_id = node_id;
 604         req.user_descriptor_len = length;
 605         g_variant_get(user_desc, "ay", &iter);
 606         while (g_variant_iter_loop(iter, "y", req.user_descriptor[i])) {
 607                 i++;
 608                 if (i >= ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN)
 609                         break;
 610         }
 611
 612         /* Allocate response callback data */
 613         resp_cb_data =
 614                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 615                         invocation, NULL, 0);
 616         if (NULL == resp_cb_data) {
 617                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 618
 619                 /* Send failure response */
 620                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 621
 622                 return TRUE;
 623         }
 624
 625         /* Dispatch request */
 626         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 627                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 628                 ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ,
 629                 &req, sizeof(req),
 630                 on_zdodev_control_user_desc_set_req_resp, resp_cb_data);
 631         if (FALSE == ret) {
 632                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 633
 634                 /* Free response callback data */
 635                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 636
 637                 /* Send failure response */
 638                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 639
 640                 return TRUE;
 641         }
 642
 643         return TRUE;
 644 }
 645
 646 static void on_zdodev_control_device_announce_resp(ZigBeeServiceInterface *service_interface,
 647         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 648 {
 649         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 650                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 651
 652         NOT_USED(cb_data);
 653         NOT_USED(service_interface);
 654         NOT_USED(request_id);
 655         NOT_USED(resp_data);
 656         NOT_USED(resp_data_len);
 657 }
 658
 659 static gboolean on_zdodev_control_device_announce(ZigbeeZdo_dev_control *zdodev_control_object,
 660         GDBusMethodInvocation *invocation,
 661         gshort node_id,
 662         GVariant *mac_addr,
 663         gchar capability,
 664         gpointer user_data)
 665 {
 666         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 667         ZigbeeZdoDevControlDeviceAnnounce_t req;
 668         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 669
 670         GVariantIter *iter = NULL;
 671         guint i = 0;
 672
 673         gboolean ret;
 674
 675         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
 676
 677         /* Update request structure */
 678         req.node_id = node_id;
 679         g_variant_get(mac_addr, "ay", &iter);
 680         while (g_variant_iter_loop(iter, "y", req.mac_addr[i])) {
 681                 i++;
 682                 if (i >= ZIGBEE_EUI64_SIZE)
 683                         break;
 684         }
 685         req.capability = capability;
 686
 687         /* Allocate response callback data */
 688         resp_cb_data =
 689                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 690                         invocation, NULL, 0);
 691         if (NULL == resp_cb_data) {
 692                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 693
 694                 /* Send failure response */
 695                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 696
 697                 return TRUE;
 698         }
 699
 700         /* Dispatch request */
 701         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 702                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 703                 ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE,
 704                 &req, sizeof(req),
 705                 on_zdodev_control_device_announce_resp, resp_cb_data);
 706         if (FALSE == ret) {
 707                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 708
 709                 /* Free response callback data */
 710                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 711
 712                 /* Send failure response */
 713                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 714
 715                 return TRUE;
 716         }
 717
 718         return TRUE;
 719 }
 720
 721 static void on_zdodev_control_simple_desc_req_resp(ZigBeeServiceInterface *service_interface,
 722         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 723 {
 724         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 725                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 726
 727         NOT_USED(cb_data);
 728         NOT_USED(service_interface);
 729         NOT_USED(request_id);
 730         NOT_USED(resp_data);
 731         NOT_USED(resp_data_len);
 732 }
 733
 734 static gboolean on_zdodev_control_simple_desc_req(ZigbeeZdo_dev_control *zdodev_control_object,
 735         GDBusMethodInvocation *invocation,
 736         gshort node_id,
 737         gchar endpoint,
 738         gpointer user_data)
 739 {
 740         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 741         ZigbeeZdoDevControlSimpleDescriptorReq_t req;
 742         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 743
 744         gboolean ret;
 745
 746         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
 747
 748         /* Update request structure */
 749         req.node_id = node_id;
 750         req.endpoint = endpoint;
 751
 752         /* Allocate response callback data */
 753         resp_cb_data =
 754                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 755                         invocation, NULL, 0);
 756         if (NULL == resp_cb_data) {
 757                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 758
 759                 /* Send failure response */
 760                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 761
 762                 return TRUE;
 763         }
 764
 765         /* Dispatch request */
 766         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 767                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 768                 ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ,
 769                 &req, sizeof(req),
 770                 on_zdodev_control_simple_desc_req_resp, resp_cb_data);
 771         if (FALSE == ret) {
 772                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 773
 774                 /* Free response callback data */
 775                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 776
 777                 /* Send failure response */
 778                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 779
 780                 return TRUE;
 781         }
 782
 783         return TRUE;
 784 }
 785
 786 static void on_zdodev_control_mgmt_lqi_req_resp(ZigBeeServiceInterface *service_interface,
 787         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 788 {
 789         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 790                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 791
 792         NOT_USED(cb_data);
 793         NOT_USED(service_interface);
 794         NOT_USED(request_id);
 795         NOT_USED(resp_data);
 796         NOT_USED(resp_data_len);
 797 }
 798
 799 static gboolean on_zdodev_control_mgmt_lqi_req(ZigbeeZdo_dev_control *zdodev_control_object,
 800         GDBusMethodInvocation *invocation,
 801         gshort node_id,
 802         gchar start_idx,
 803         gpointer user_data)
 804 {
 805         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 806         ZigbeeZdoDevControlMgmtLqiReq_t req;
 807         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 808
 809         gboolean ret;
 810
 811         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
 812
 813         /* Update request structure */
 814         req.node_id = node_id;
 815         req.start_index = start_idx;
 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_MGMT_LQI_REQ,
 834                 &req, sizeof(req),
 835                 on_zdodev_control_mgmt_lqi_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_mgmt_rtg_req_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         NOT_USED(cb_data);
 858         NOT_USED(service_interface);
 859         NOT_USED(request_id);
 860         NOT_USED(resp_data);
 861         NOT_USED(resp_data_len);
 862 }
 863
 864 static gboolean on_zdodev_control_mgmt_rtg_req(ZigbeeZdo_dev_control *zdodev_control_object,
 865         GDBusMethodInvocation *invocation,
 866         gshort node_id,
 867         gchar start_idx,
 868         gpointer user_data)
 869 {
 870         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 871         ZigbeeZdoDevControlMgmtRtgReq_t req;
 872         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 873
 874         gboolean ret;
 875
 876         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
 877
 878         /* Update request structure */
 879         req.node_id = node_id;
 880         req.start_index = start_idx;
 881
 882         /* Allocate response callback data */
 883         resp_cb_data =
 884                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 885                         invocation, NULL, 0);
 886         if (NULL == resp_cb_data) {
 887                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 888
 889                 /* Send failure response */
 890                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 891
 892                 return TRUE;
 893         }
 894
 895         /* Dispatch request */
 896         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 897                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 898                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ,
 899                 &req, sizeof(req),
 900                 on_zdodev_control_mgmt_rtg_req_resp, resp_cb_data);
 901         if (FALSE == ret) {
 902                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 903
 904                 /* Free response callback data */
 905                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 906
 907                 /* Send failure response */
 908                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 909
 910                 return TRUE;
 911         }
 912
 913         return TRUE;
 914 }
 915
 916 static void on_zdodev_control_mgmt_bind_req_resp(ZigBeeServiceInterface *service_interface,
 917         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 918 {
 919         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 920                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 921
 922         NOT_USED(cb_data);
 923         NOT_USED(service_interface);
 924         NOT_USED(request_id);
 925         NOT_USED(resp_data);
 926         NOT_USED(resp_data_len);
 927 }
 928
 929 static gboolean on_zdodev_control_mgmt_bind_req(ZigbeeZdo_dev_control *zdodev_control_object,
 930         GDBusMethodInvocation *invocation,
 931         gshort node_id,
 932         gchar start_idx,
 933         gpointer user_data)
 934 {
 935         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 936         ZigbeeZdoDevControlMgmtBindReq_t req;
 937         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 938
 939         gboolean ret;
 940
 941         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
 942
 943         /* Update request structure */
 944         req.node_id = node_id;
 945         req.start_index = start_idx;
 946
 947         /* Allocate response callback data */
 948         resp_cb_data =
 949                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
 950                         invocation, NULL, 0);
 951         if (NULL == resp_cb_data) {
 952                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 953
 954                 /* Send failure response */
 955                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 956
 957                 return TRUE;
 958         }
 959
 960         /* Dispatch request */
 961         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 962                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
 963                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ,
 964                 &req, sizeof(req),
 965                 on_zdodev_control_mgmt_bind_req_resp, resp_cb_data);
 966         if (FALSE == ret) {
 967                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 968
 969                 /* Free response callback data */
 970                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 971
 972                 /* Send failure response */
 973                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 974
 975                 return TRUE;
 976         }
 977
 978         return TRUE;
 979 }
 980
 981 static void on_zdodev_control_mgmt_permit_join_req_resp(ZigBeeServiceInterface *service_interface,
 982         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 983 {
 984         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 985                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 986
 987         NOT_USED(cb_data);
 988         NOT_USED(service_interface);
 989         NOT_USED(request_id);
 990         NOT_USED(resp_data);
 991         NOT_USED(resp_data_len);
 992 }
 993
 994 static gboolean on_zdodev_control_mgmt_permit_join_req(ZigbeeZdo_dev_control *zdodev_control_object,
 995         GDBusMethodInvocation *invocation,
 996         gshort addr16,
 997         gchar duration,
 998         gchar tc_significance,
 999         gpointer user_data)
1000 {
1001         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1002         ZigbeeZdoDevControlMgmtPermitJoinReq_t req;
1003         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1004
1005         gboolean ret;
1006
1007         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
1008
1009         /* Update request structure */
1010         req.addr = addr16;
1011         req.duration = duration;
1012         req.tc_significance = tc_significance;
1013
1014         /* Allocate response callback data */
1015         resp_cb_data =
1016                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1017                         invocation, NULL, 0);
1018         if (NULL == resp_cb_data) {
1019                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1020
1021                 /* Send failure response */
1022                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1023
1024                 return TRUE;
1025         }
1026
1027         /* Dispatch request */
1028         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1029                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1030                 ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ,
1031                 &req, sizeof(req),
1032                 on_zdodev_control_mgmt_permit_join_req_resp, resp_cb_data);
1033         if (FALSE == ret) {
1034                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1035
1036                 /* Free response callback data */
1037                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1038
1039                 /* Send failure response */
1040                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1041
1042                 return TRUE;
1043         }
1044
1045         return TRUE;
1046 }
1047
1048 static void on_zdodev_control_nwk_update_req_resp(ZigBeeServiceInterface *service_interface,
1049         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1050 {
1051         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1052                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1053
1054         NOT_USED(cb_data);
1055         NOT_USED(service_interface);
1056         NOT_USED(request_id);
1057         NOT_USED(resp_data);
1058         NOT_USED(resp_data_len);
1059 }
1060
1061 static gboolean on_zdodev_control_nwk_update_req(ZigbeeZdo_dev_control *zdodev_control_object,
1062         GDBusMethodInvocation *invocation,
1063         gshort node_id,
1064         guint scan_channel,
1065         gchar scan_duration,
1066         gchar scan_count,
1067         gint nwk_update_id,
1068         gpointer user_data)
1069 {
1070         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1071         ZigbeeZdoDevControlNwkUpdateReq_t req;
1072         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1073
1074         gboolean ret;
1075
1076         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
1077
1078         /* Update request structure */
1079         req.node_id = node_id;
1080         req.scan_channel = scan_channel;
1081         req.scan_duration = scan_duration;
1082         req.scan_count = scan_count;
1083         req.network_update_id = nwk_update_id;
1084
1085         /* Allocate response callback data */
1086         resp_cb_data =
1087                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1088                         invocation, NULL, 0);
1089         if (NULL == resp_cb_data) {
1090                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1091
1092                 /* Send failure response */
1093                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1094
1095                 return TRUE;
1096         }
1097
1098         /* Dispatch request */
1099         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1100                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1101                 ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ,
1102                 &req, sizeof(req),
1103                 on_zdodev_control_nwk_update_req_resp, resp_cb_data);
1104         if (FALSE == ret) {
1105                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1106
1107                 /* Free response callback data */
1108                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1109
1110                 /* Send failure response */
1111                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1112
1113                 return TRUE;
1114         }
1115
1116         return TRUE;
1117 }
1118
1119 static void on_zdodev_control_nwk_disc_req_resp(ZigBeeServiceInterface *service_interface,
1120         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1121 {
1122         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1123                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1124
1125         NOT_USED(cb_data);
1126         NOT_USED(service_interface);
1127         NOT_USED(request_id);
1128         NOT_USED(resp_data);
1129         NOT_USED(resp_data_len);
1130 }
1131
1132 static gboolean on_zdodev_control_nwk_disc_req(ZigbeeZdo_dev_control *zdodev_control_object,
1133         GDBusMethodInvocation *invocation,
1134         gshort node_id,
1135         guint scan_channel,
1136         gchar scan_duration,
1137         gshort scan_count,
1138         gchar start_index,
1139         gpointer user_data)
1140 {
1141         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1142         ZigbeeZdoDevControlNwkDescriptorReq_t req;
1143         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1144
1145         gboolean ret;
1146
1147         memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t));
1148
1149         /* Update request structure */
1150         req.node_id = node_id;
1151         req.scan_channel = scan_channel;
1152         req.scan_duration = scan_duration;
1153         req.scan_count = scan_count;
1154         req.start_index = start_index;
1155
1156         /* Allocate response callback data */
1157         resp_cb_data =
1158                 zigbee_service_dbus_interface_create_resp_cb_data(zdodev_control_object,
1159                         invocation, NULL, 0);
1160         if (NULL == resp_cb_data) {
1161                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1162
1163                 /* Send failure response */
1164                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1165
1166                 return TRUE;
1167         }
1168
1169         /* Dispatch request */
1170         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1171                 ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
1172                 ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ,
1173                 &req, sizeof(req),
1174                 on_zdodev_control_nwk_disc_req_resp, resp_cb_data);
1175         if (FALSE == ret) {
1176                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1177
1178                 /* Free response callback data */
1179                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1180
1181                 /* Send failure response */
1182                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1183
1184                 return TRUE;
1185         }
1186
1187         return TRUE;
1188 }
1189
1190 gboolean zigbee_service_dbus_interface_zdo_dev_control_init(ZigBeeServiceInterface *service_interface,
1191         ZigbeeObjectSkeleton *zigbee_object)
1192 {
1193         ZigbeeZdo_dev_control *zdodev_control_object;
1194
1195         if (NULL == service_interface) {
1196                 Z_LOGE("service_interface is NULL");
1197                 return FALSE;
1198         }
1199
1200         zdodev_control_object = zigbee_zdo_dev_control_skeleton_new();
1201         zigbee_object_skeleton_set_zdo_dev_control(zigbee_object, zdodev_control_object);
1202         g_object_unref(zdodev_control_object);
1203
1204         Z_LOGI("zdodev_control_object: [%p]", zdodev_control_object);
1205
1206         /*
1207          * Register signal handlers for 'zdodev_control' interface
1208          */
1209         g_signal_connect(zdodev_control_object,
1210                 "handle-nwk-addr-req",
1211                 G_CALLBACK(on_zdodev_control_nwk_addr_req), service_interface);
1212
1213         g_signal_connect(zdodev_control_object,
1214                 "handle-matched-descriptor-req",
1215                 G_CALLBACK(on_zdodev_control_matched_descriptor_req), service_interface);
1216
1217         g_signal_connect(zdodev_control_object,
1218                 "handle-ieee-addr-req",
1219                 G_CALLBACK(on_zdodev_control_ieee_addr_req), service_interface);
1220
1221         g_signal_connect(zdodev_control_object,
1222                 "handle-active-ep-req",
1223                 G_CALLBACK(on_zdodev_control_active_ep_req), service_interface);
1224
1225         g_signal_connect(zdodev_control_object,
1226                 "handle-node-desc-req",
1227                 G_CALLBACK(on_zdodev_control_node_desc_req), service_interface);
1228
1229         g_signal_connect(zdodev_control_object,
1230                 "handle-power-desc-req",
1231                 G_CALLBACK(on_zdodev_control_power_desc_req), service_interface);
1232
1233         g_signal_connect(zdodev_control_object,
1234                 "handle-complex-desc-req",
1235                 G_CALLBACK(on_zdodev_control_complex_desc_req), service_interface);
1236
1237         g_signal_connect(zdodev_control_object,
1238                 "handle-user-desc-req",
1239                 G_CALLBACK(on_zdodev_control_user_desc_req), service_interface);
1240
1241         g_signal_connect(zdodev_control_object,
1242                 "handle-user-desc-set-req",
1243                 G_CALLBACK(on_zdodev_control_user_desc_set_req), service_interface);
1244
1245         g_signal_connect(zdodev_control_object,
1246                 "handle-device-announce",
1247                 G_CALLBACK(on_zdodev_control_device_announce), service_interface);
1248
1249         g_signal_connect(zdodev_control_object,
1250                 "handle-simple-desc-req",
1251                 G_CALLBACK(on_zdodev_control_simple_desc_req), service_interface);
1252
1253         g_signal_connect(zdodev_control_object,
1254                 "handle-mgmt-lqi-req",
1255                 G_CALLBACK(on_zdodev_control_mgmt_lqi_req), service_interface);
1256
1257         g_signal_connect(zdodev_control_object,
1258                 "handle-mgmt-rtg-req",
1259                 G_CALLBACK(on_zdodev_control_mgmt_rtg_req), service_interface);
1260
1261         g_signal_connect(zdodev_control_object,
1262                 "handle-mgmt-bind-req",
1263                 G_CALLBACK(on_zdodev_control_mgmt_bind_req), service_interface);
1264
1265         g_signal_connect(zdodev_control_object,
1266                 "handle-mgmt-permit-join-req",
1267                 G_CALLBACK(on_zdodev_control_mgmt_permit_join_req), service_interface);
1268
1269         g_signal_connect(zdodev_control_object,
1270                 "handle-nwk-update-req",
1271                 G_CALLBACK(on_zdodev_control_nwk_update_req), service_interface);
1272
1273         g_signal_connect(zdodev_control_object,
1274                 "handle-nwk-disc-req",
1275                 G_CALLBACK(on_zdodev_control_nwk_disc_req), service_interface);
1276
1277         return TRUE;
1278 }