zigbee-daemon/zigbee-interface/src/zigbee_service_dbus_interface_zcl_global_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_zcl_global_control.h>
  22
  23 static void *_service_interface_ref_zigbee_zcl_global_control(ZigBeeServiceInterface *service_interface)
  24 {
  25         ZigbeeObjectSkeleton *zigbee_object = NULL;
  26         ZigbeeCustomData_t *custom_data = NULL;
  27         ZigbeeZcl_global_control *global_control_object = NULL;
  28
  29         custom_data = (ZigbeeCustomData_t *)zblib_service_interface_ref_user_data(service_interface);
  30         if (NULL == custom_data) {
  31                 Z_LOGE("D-BUS service interface custom_data is NULL!");
  32                 return NULL;
  33         }
  34
  35         /* Get zigbee object */
  36         zigbee_object = g_hash_table_lookup(custom_data->objects, ZIGBEE_SERVICE_PATH);
  37         if (NULL == zigbee_object) {
  38                 Z_LOGW("Cannot find ZigBee D-BUS interface object!", zigbee_object);
  39                 return NULL;
  40         }
  41
  42         global_control_object = zigbee_object_get_zcl_global_control(ZIGBEE_OBJECT(zigbee_object));
  43         return global_control_object;
  44 }
  45
  46 static void on_zclglobal_control_read_attributes_req_resp(ZigBeeServiceInterface *service_interface,
  47         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
  48 {
  49         ZigbeeServiceInterfaceRespCbData_t *cb_data =
  50                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
  51
  52         ZigbeeZcl_global_control *global_control_object;
  53         GDBusMethodInvocation *invocation;
  54
  55         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
  56
  57         NOT_USED(service_interface);
  58         NOT_USED(request_id);
  59
  60         if (NULL == resp_data || 0 == resp_data_len) {
  61                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
  62                 g_free(cb_data);
  63                 return;
  64         }
  65
  66         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
  67         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
  68
  69         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
  70         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
  71
  72         zigbee_zcl_global_control_complete_read_attributes_req(global_control_object,
  73                 invocation, payload->result);
  74
  75         g_free(cb_data);
  76 }
  77
  78 static gboolean on_zclglobal_control_read_attributes_req(ZigbeeZcl_global_control *zclglobal_control_object,
  79         GDBusMethodInvocation *invocation,
  80         GVariant *attribute_id,
  81         gint attribute_ids_length,
  82         gshort node_id,
  83         gshort cluster_id,
  84         gchar zcl_frame_ctrl,
  85         gchar dest_ep,
  86         gpointer user_data)
  87 {
  88         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  89         ZigbeeZclGlobalControlReadAttributesRequest_t req;
  90         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  91
  92         GVariantIter *iter = NULL;
  93         guint i = 0;
  94
  95         gboolean ret;
  96
  97         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
  98
  99         req.attribute_id = g_try_malloc0_n(attribute_ids_length, sizeof(unsigned short));
 100         if (NULL == req.attribute_id) {
 101                 Z_LOGE("Failed to allocation !");
 102
 103                 /* Send failure response */
 104                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 105
 106                 return TRUE;
 107         }
 108
 109         /* Update request structure */
 110         g_variant_get(attribute_id, "a(y)", &iter);
 111         while (g_variant_iter_loop(iter, "(y)", &(req.attribute_id[i]))) {
 112                 i++;
 113                 if (i >= (attribute_ids_length * sizeof(unsigned short)))
 114                         break;
 115         }
 116         req.attribute_id_len = attribute_ids_length;
 117         req.node_id = node_id;
 118         req.cluster_id = cluster_id;
 119         req.zcl_frame_ctrl = zcl_frame_ctrl;
 120         req.dest_ep = dest_ep;
 121
 122         /* Allocate response callback data */
 123         resp_cb_data =
 124                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 125                         invocation, NULL, 0);
 126         if (NULL == resp_cb_data) {
 127                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 128
 129                 /* Send failure response */
 130                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 131
 132                 return TRUE;
 133         }
 134
 135         /* Dispatch request */
 136         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 137                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 138                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ,
 139                 &req, sizeof(req),
 140                 on_zclglobal_control_read_attributes_req_resp, resp_cb_data);
 141         if (FALSE == ret) {
 142                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 143
 144                 /* Free response callback data */
 145                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 146
 147                 /* Send failure response */
 148                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 149
 150                 return TRUE;
 151         }
 152
 153         return TRUE;
 154 }
 155
 156 static void on_zclglobal_control_write_attributes_req_resp(ZigBeeServiceInterface *service_interface,
 157         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 158 {
 159         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 160                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 161
 162         ZigbeeZcl_global_control *global_control_object;
 163         GDBusMethodInvocation *invocation;
 164
 165         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 166
 167         NOT_USED(service_interface);
 168         NOT_USED(request_id);
 169
 170         if (NULL == resp_data || 0 == resp_data_len) {
 171                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 172                 g_free(cb_data);
 173                 return;
 174         }
 175
 176         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 177         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
 178
 179         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 180         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 181
 182         zigbee_zcl_global_control_complete_write_attributes_req(global_control_object,
 183                 invocation, payload->result);
 184
 185         g_free(cb_data);
 186 }
 187
 188 static gboolean on_zclglobal_control_write_attributes_req(ZigbeeZcl_global_control *zclglobal_control_object,
 189         GDBusMethodInvocation *invocation,
 190         GVariant *write_attribute,
 191         gint records_length,
 192         gshort node_id,
 193         gshort cluster_id,
 194         gchar zcl_frame_ctrl,
 195         gchar src_ep,
 196         gchar dest_ep,
 197         gpointer user_data)
 198 {
 199         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 200         ZigbeeZclGlobalControlWriteAttributesRequest_t req;
 201         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 202
 203         GVariantIter *iter = NULL;
 204         gint i = 0;
 205
 206         gboolean ret;
 207
 208         Z_LOGI("DBus Service interface: [%p]", service_interface);
 209
 210         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t));
 211
 212         req.write_records = g_try_malloc0_n(records_length, sizeof(unsigned char));
 213         if (NULL == req.write_records) {
 214                 Z_LOGE("Failed to allocation !");
 215
 216                 /* Send failure response */
 217                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 218
 219                 g_free(req.write_records);
 220                 return TRUE;
 221         }
 222
 223         Z_LOGI("DBus Service interface: [%p]", service_interface);
 224
 225         /* Update request structure */
 226         g_variant_get(write_attribute, "a(y)", &iter);
 227         while (g_variant_iter_loop(iter, "(y)", &(req.write_records[i]))) {
 228                 i++;
 229                 if (i >= records_length)
 230                         break;
 231         }
 232         req.records_len = records_length;
 233         req.node_id = node_id;
 234         req.cluster_id = cluster_id;
 235         req.zcl_frame_ctrl = zcl_frame_ctrl;
 236         req.src_ep = src_ep;
 237         req.dest_ep = dest_ep;
 238
 239         /* Allocate response callback data */
 240         resp_cb_data =
 241                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 242                         invocation, NULL, 0);
 243         if (NULL == resp_cb_data) {
 244                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 245
 246                 /* Send failure response */
 247                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 248
 249                 g_free(req.write_records);
 250                 return TRUE;
 251         }
 252
 253         /* Dispatch request */
 254         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 255                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 256                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ,
 257                 &req, sizeof(req),
 258                 on_zclglobal_control_write_attributes_req_resp, resp_cb_data);
 259
 260         /* Free resource */
 261         g_free(req.write_records);
 262
 263         if (FALSE == ret) {
 264                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 265
 266                 /* Free response callback data */
 267                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 268
 269                 /* Send failure response */
 270                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 271
 272                 return TRUE;
 273         }
 274
 275         return TRUE;
 276 }
 277
 278 static void on_zclglobal_control_write_attributes_undivided_req_resp(ZigBeeServiceInterface *service_interface,
 279         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 280 {
 281         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 282                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 283
 284         ZigbeeZcl_global_control *global_control_object;
 285         GDBusMethodInvocation *invocation;
 286
 287         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 288
 289         NOT_USED(service_interface);
 290         NOT_USED(request_id);
 291
 292         if (NULL == resp_data || 0 == resp_data_len) {
 293                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 294                 g_free(cb_data);
 295                 return;
 296         }
 297
 298         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 299         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
 300
 301         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 302         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 303
 304         zigbee_zcl_global_control_complete_write_attributes_undivided_req(global_control_object,
 305                 invocation, payload->result);
 306
 307         g_free(cb_data);
 308 }
 309
 310 static gboolean on_zclglobal_control_write_attributes_undivided_req(ZigbeeZcl_global_control *zclglobal_control_object,
 311         GDBusMethodInvocation *invocation,
 312         GVariant *write_attribute,
 313         gint records_length,
 314         gshort node_id,
 315         gshort cluster_id,
 316         gchar zcl_frame_ctrl,
 317         gchar src_ep,
 318         gchar dest_ep,
 319         gpointer user_data)
 320 {
 321         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 322         ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t req;
 323         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 324
 325         GVariantIter *iter = NULL;
 326         gint i = 0;
 327
 328         gboolean ret;
 329
 330         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
 331
 332         req.write_records = g_try_malloc0_n(records_length, sizeof(unsigned char));
 333         if (NULL == req.write_records) {
 334                 Z_LOGE("Failed to allocation !");
 335
 336                 /* Send failure response */
 337                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 338
 339                 g_free(req.write_records);
 340                 return TRUE;
 341         }
 342
 343         /* Update request structure */
 344         g_variant_get(write_attribute, "a(y)", &iter);
 345         while (g_variant_iter_loop(iter, "(y)", &(req.write_records[i]))) {
 346                 i++;
 347                 if (i >= records_length)
 348                         break;
 349         }
 350         req.records_len = records_length;
 351         req.node_id = node_id;
 352         req.cluster_id = cluster_id;
 353         req.zcl_frame_ctrl = zcl_frame_ctrl;
 354         req.src_ep = src_ep;
 355         req.dest_ep = dest_ep;
 356
 357         /* Allocate response callback data */
 358         resp_cb_data =
 359                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 360                         invocation, NULL, 0);
 361         if (NULL == resp_cb_data) {
 362                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 363
 364                 /* Send failure response */
 365                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 366
 367                 g_free(req.write_records);
 368                 return TRUE;
 369         }
 370
 371         /* Dispatch request */
 372         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 373                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 374                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ,
 375                 &req, sizeof(req),
 376                 on_zclglobal_control_write_attributes_undivided_req_resp, resp_cb_data);
 377
 378         /* Free resource */
 379         g_free(req.write_records);
 380
 381         if (FALSE == ret) {
 382                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 383
 384                 /* Free response callback data */
 385                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 386
 387                 /* Send failure response */
 388                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 389
 390                 return TRUE;
 391         }
 392
 393         return TRUE;
 394 }
 395
 396 static void on_zclglobal_control_write_attributes_no_resp_resp(ZigBeeServiceInterface *service_interface,
 397         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 398 {
 399         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 400                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 401
 402         ZigbeeZcl_global_control *global_control_object;
 403         GDBusMethodInvocation *invocation;
 404
 405         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 406
 407         NOT_USED(service_interface);
 408         NOT_USED(request_id);
 409
 410         if (NULL == resp_data || 0 == resp_data_len) {
 411                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 412                 g_free(cb_data);
 413                 return;
 414         }
 415
 416         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 417         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
 418
 419         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 420         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 421
 422         zigbee_zcl_global_control_complete_write_attributes_no_resp(global_control_object,
 423                 invocation, payload->result);
 424
 425         g_free(cb_data);
 426 }
 427
 428 static gboolean on_zclglobal_control_write_attributes_no_resp(ZigbeeZcl_global_control *zclglobal_control_object,
 429         GDBusMethodInvocation *invocation,
 430         GVariant *write_attribute,
 431         gint records_length,
 432         gshort node_id,
 433         gshort cluster_id,
 434         gchar zcl_frame_ctrl,
 435         gchar src_ep,
 436         gchar dest_ep,
 437         gpointer user_data)
 438 {
 439         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 440         ZigbeeZclGlobalControlWriteAttributesNoResponse_t req;
 441         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 442
 443         GVariantIter *iter = NULL;
 444         gint i = 0;
 445
 446         gboolean ret;
 447
 448         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
 449
 450         req.write_records = g_try_malloc0_n(records_length, sizeof(unsigned char));
 451         if (NULL == req.write_records) {
 452                 Z_LOGE("Failed to allocation !");
 453
 454                 /* Send failure response */
 455                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 456
 457                 g_free(req.write_records);
 458                 return TRUE;
 459         }
 460
 461         /* Update request structure */
 462         g_variant_get(write_attribute, "a(y)", &iter);
 463         while (g_variant_iter_loop(iter, "(y)", &(req.write_records[i]))) {
 464                 i++;
 465                 if (i >= records_length)
 466                         break;
 467         }
 468         req.records_len = records_length;
 469         req.node_id = node_id;
 470         req.cluster_id = cluster_id;
 471         req.zcl_frame_ctrl = zcl_frame_ctrl;
 472         req.src_ep = src_ep;
 473         req.dest_ep = dest_ep;
 474
 475         /* Allocate response callback data */
 476         resp_cb_data =
 477                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 478                         invocation, NULL, 0);
 479         if (NULL == resp_cb_data) {
 480                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 481
 482                 /* Send failure response */
 483                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 484
 485                 g_free(req.write_records);
 486                 return TRUE;
 487         }
 488
 489         /* Dispatch request */
 490         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 491                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 492                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP,
 493                 &req, sizeof(req),
 494                 on_zclglobal_control_write_attributes_no_resp_resp, resp_cb_data);
 495
 496         /* Free resource */
 497         g_free(req.write_records);
 498
 499         if (FALSE == ret) {
 500                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 501
 502                 /* Free response callback data */
 503                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 504
 505                 /* Send failure response */
 506                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 507
 508                 return TRUE;
 509         }
 510
 511         return TRUE;
 512 }
 513
 514 static void on_zclglobal_control_write_attributes_structured_resp(ZigBeeServiceInterface *service_interface,
 515         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 516 {
 517         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 518                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 519
 520         ZigbeeZcl_global_control *global_control_object;
 521         GDBusMethodInvocation *invocation;
 522
 523         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 524
 525         NOT_USED(service_interface);
 526         NOT_USED(request_id);
 527
 528         if (NULL == resp_data || 0 == resp_data_len) {
 529                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 530                 g_free(cb_data);
 531                 return;
 532         }
 533
 534         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 535         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
 536
 537         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 538         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 539
 540         zigbee_zcl_global_control_complete_write_attributes_structured(global_control_object,
 541                 invocation, payload->result);
 542
 543         g_free(cb_data);
 544 }
 545
 546 static gboolean on_zclglobal_control_write_attributes_structured(ZigbeeZcl_global_control *zclglobal_control_object,
 547         GDBusMethodInvocation *invocation,
 548         GVariant *write_attribute,
 549         gint records_length,
 550         gshort node_id,
 551         gshort cluster_id,
 552         gchar zcl_frame_ctrl,
 553         gchar src_ep,
 554         gchar dest_ep,
 555         gpointer user_data)
 556 {
 557         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 558         ZigbeeZclGlobalControlWriteAttributesStructed_t req;
 559         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 560
 561         GVariantIter *iter = NULL;
 562         gint i = 0;
 563
 564         gboolean ret;
 565
 566         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
 567
 568         req.write_records = g_try_malloc0_n(records_length, sizeof(unsigned char));
 569         if (NULL == req.write_records) {
 570                 Z_LOGE("Failed to allocation !");
 571
 572                 /* Send failure response */
 573                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 574
 575                 g_free(req.write_records);
 576                 return TRUE;
 577         }
 578
 579         /* Update request structure */
 580         g_variant_get(write_attribute, "a(y)", &iter);
 581         while (g_variant_iter_loop(iter, "(y)", &(req.write_records[i]))) {
 582                 i++;
 583                 if (i >= records_length)
 584                         break;
 585         }
 586         req.records_len = records_length;
 587         req.node_id = node_id;
 588         req.cluster_id = cluster_id;
 589         req.zcl_frame_ctrl = zcl_frame_ctrl;
 590         req.src_ep = src_ep;
 591         req.dest_ep = dest_ep;
 592
 593         /* Allocate response callback data */
 594         resp_cb_data =
 595                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 596                         invocation, NULL, 0);
 597         if (NULL == resp_cb_data) {
 598                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 599
 600                 /* Send failure response */
 601                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 602
 603                 g_free(req.write_records);
 604                 return TRUE;
 605         }
 606
 607         /* Dispatch request */
 608         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 609                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 610                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED,
 611                 &req, sizeof(req),
 612                 on_zclglobal_control_write_attributes_structured_resp, resp_cb_data);
 613
 614         /* Free resource */
 615         g_free(req.write_records);
 616
 617         if (FALSE == ret) {
 618                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 619
 620                 /* Free response callback data */
 621                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 622
 623                 /* Send failure response */
 624                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 625
 626                 return TRUE;
 627         }
 628
 629         return TRUE;
 630 }
 631
 632 static void on_zclglobal_control_read_attributes_structured_resp(ZigBeeServiceInterface *service_interface,
 633         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 634 {
 635         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 636                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 637
 638         ZigbeeZcl_global_control *global_control_object;
 639         GDBusMethodInvocation *invocation;
 640
 641         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 642
 643         NOT_USED(service_interface);
 644         NOT_USED(request_id);
 645
 646         if (NULL == resp_data || 0 == resp_data_len) {
 647                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 648                 g_free(cb_data);
 649                 return;
 650         }
 651
 652         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 653         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
 654
 655         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 656         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 657
 658         zigbee_zcl_global_control_complete_read_attributes_structured(global_control_object,
 659                 invocation, payload->result);
 660
 661         g_free(cb_data);
 662 }
 663
 664 static gboolean on_zclglobal_control_read_attributes_structured(ZigbeeZcl_global_control *zclglobal_control_object,
 665         GDBusMethodInvocation *invocation,
 666         GVariant *read_attribute,
 667         gint records_length,
 668         gshort node_id,
 669         gshort cluster_id,
 670         gchar zcl_frame_ctrl,
 671         gchar src_ep,
 672         gchar dest_ep,
 673         gpointer user_data)
 674 {
 675         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 676         ZigbeeZclGlobalControlReadAttributesStructed_t req;
 677         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 678
 679         GVariantIter *iter = NULL;
 680         gint i = 0;
 681
 682         gboolean ret;
 683
 684         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
 685
 686         req.read_records = g_try_malloc0_n(records_length, sizeof(unsigned char));
 687         if (NULL == req.read_records) {
 688                 Z_LOGE("Failed to allocation !");
 689
 690                 /* Send failure response */
 691                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 692
 693                 g_free(req.read_records);
 694                 return TRUE;
 695         }
 696
 697         /* Update request structure */
 698         g_variant_get(read_attribute, "a(y)", &iter);
 699         while (g_variant_iter_loop(iter, "(y)", &(req.read_records[i]))) {
 700                 i++;
 701                 if (i >= records_length)
 702                         break;
 703         }
 704         req.records_len = records_length;
 705         req.node_id = node_id;
 706         req.cluster_id = cluster_id;
 707         req.zcl_frame_ctrl = zcl_frame_ctrl;
 708         req.src_ep = src_ep;
 709         req.dest_ep = dest_ep;
 710
 711         /* Allocate response callback data */
 712         resp_cb_data =
 713                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 714                         invocation, NULL, 0);
 715         if (NULL == resp_cb_data) {
 716                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 717
 718                 /* Send failure response */
 719                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 720
 721                 g_free(req.read_records);
 722                 return TRUE;
 723         }
 724
 725         /* Dispatch request */
 726         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 727                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 728                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED,
 729                 &req, sizeof(req),
 730                 on_zclglobal_control_read_attributes_structured_resp, resp_cb_data);
 731
 732         /* Free resource */
 733         g_free(req.read_records);
 734
 735         if (FALSE == ret) {
 736                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 737
 738                 /* Free response callback data */
 739                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 740
 741                 /* Send failure response */
 742                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 743
 744                 return TRUE;
 745         }
 746
 747         return TRUE;
 748 }
 749
 750 static void on_zclglobal_control_configure_reporting_req_resp(ZigBeeServiceInterface *service_interface,
 751         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 752 {
 753         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 754                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 755
 756         ZigbeeZcl_global_control *global_control_object;
 757         GDBusMethodInvocation *invocation;
 758
 759         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 760
 761         NOT_USED(service_interface);
 762         NOT_USED(request_id);
 763
 764         if (NULL == resp_data || 0 == resp_data_len) {
 765                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 766                 g_free(cb_data);
 767                 return;
 768         }
 769
 770         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 771         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
 772
 773         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 774         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 775
 776         zigbee_zcl_global_control_complete_configure_reporting_req(global_control_object,
 777                 invocation, payload->result);
 778
 779         g_free(cb_data);
 780 }
 781
 782 static gboolean on_zclglobal_control_configure_reporting_req(ZigbeeZcl_global_control *zclglobal_control_object,
 783         GDBusMethodInvocation *invocation,
 784         GVariant *read_attribute,
 785         gint records_length,
 786         gshort node_id,
 787         gshort cluster_id,
 788         gchar zcl_frame_ctrl,
 789         gchar src_ep,
 790         gchar dest_ep,
 791         gpointer user_data)
 792 {
 793         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 794         ZigbeeZclGlobalControlConfigureReportingReq_t req;
 795         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 796
 797         GVariantIter *iter = NULL;
 798         gint i = 0;
 799
 800         gboolean ret;
 801
 802         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
 803
 804         req.read_records = g_try_malloc0_n(records_length, sizeof(unsigned char));
 805         if (NULL == req.read_records) {
 806                 Z_LOGE("Failed to allocation !");
 807
 808                 /* Send failure response */
 809                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 810
 811                 g_free(req.read_records);
 812                 return TRUE;
 813         }
 814
 815         /* Update request structure */
 816         g_variant_get(read_attribute, "a(y)", &iter);
 817         while (g_variant_iter_loop(iter, "(y)", &(req.read_records[i]))) {
 818                 i++;
 819                 if (i >= records_length)
 820                         break;
 821         }
 822         req.records_len = records_length;
 823         req.node_id = node_id;
 824         req.cluster_id = cluster_id;
 825         req.zcl_frame_ctrl = zcl_frame_ctrl;
 826         req.src_ep = src_ep;
 827         req.dest_ep = dest_ep;
 828
 829         /* Allocate response callback data */
 830         resp_cb_data =
 831                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 832                         invocation, NULL, 0);
 833         if (NULL == resp_cb_data) {
 834                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 835
 836                 /* Send failure response */
 837                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 838
 839                 g_free(req.read_records);
 840                 return TRUE;
 841         }
 842
 843         /* Dispatch request */
 844         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 845                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 846                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ,
 847                 &req, sizeof(req),
 848                 on_zclglobal_control_configure_reporting_req_resp, resp_cb_data);
 849
 850         /* Free resource */
 851         g_free(req.read_records);
 852
 853         if (FALSE == ret) {
 854                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 855
 856                 /* Free response callback data */
 857                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 858
 859                 /* Send failure response */
 860                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 861
 862                 return TRUE;
 863         }
 864
 865         return TRUE;
 866 }
 867
 868 static void on_zclglobal_control_read_configure_reporting_resp(ZigBeeServiceInterface *service_interface,
 869         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 870 {
 871         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 872                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 873
 874         ZigbeeZcl_global_control *global_control_object;
 875         GDBusMethodInvocation *invocation;
 876
 877         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 878
 879         NOT_USED(service_interface);
 880         NOT_USED(request_id);
 881
 882         if (NULL == resp_data || 0 == resp_data_len) {
 883                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
 884                 g_free(cb_data);
 885                 return;
 886         }
 887
 888         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 889         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
 890
 891         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 892         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 893
 894         zigbee_zcl_global_control_complete_read_configure_reporting(global_control_object,
 895                 invocation, payload->result);
 896
 897         g_free(cb_data);
 898 }
 899
 900 static gboolean on_zclglobal_control_read_configure_reporting(ZigbeeZcl_global_control *zclglobal_control_object,
 901         GDBusMethodInvocation *invocation,
 902         GVariant *read_attribute,
 903         gint records_length,
 904         gshort node_id,
 905         gshort cluster_id,
 906         gchar zcl_frame_ctrl,
 907         gchar src_ep,
 908         gchar dest_ep,
 909         gpointer user_data)
 910 {
 911         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 912         ZigbeeZclGlobalControlReadConfigureReporting_t req;
 913         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 914
 915         GVariantIter *iter = NULL;
 916         gint i = 0;
 917
 918         gboolean ret;
 919
 920         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
 921
 922         req.read_records = g_try_malloc0_n(records_length, sizeof(unsigned char));
 923         if (NULL == req.read_records) {
 924                 Z_LOGE("Failed to allocation !");
 925
 926                 /* Send failure response */
 927                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 928
 929                 g_free(req.read_records);
 930                 return TRUE;
 931         }
 932
 933         /* Update request structure */
 934         g_variant_get(read_attribute, "a(y)", &iter);
 935         while (g_variant_iter_loop(iter, "(y)", &(req.read_records[i]))) {
 936                 i++;
 937                 if (i >= records_length)
 938                         break;
 939         }
 940         req.records_len = records_length;
 941         req.node_id = node_id;
 942         req.cluster_id = cluster_id;
 943         req.zcl_frame_ctrl = zcl_frame_ctrl;
 944         req.src_ep = src_ep;
 945         req.dest_ep = dest_ep;
 946
 947         /* Allocate response callback data */
 948         resp_cb_data =
 949                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_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                 g_free(req.read_records);
 958                 return TRUE;
 959         }
 960
 961         /* Dispatch request */
 962         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 963                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 964                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING,
 965                 &req, sizeof(req),
 966                 on_zclglobal_control_read_configure_reporting_resp, resp_cb_data);
 967
 968         /* Free resource */
 969         g_free(req.read_records);
 970
 971         if (FALSE == ret) {
 972                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 973
 974                 /* Free response callback data */
 975                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 976
 977                 /* Send failure response */
 978                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 979
 980                 return TRUE;
 981         }
 982
 983         return TRUE;
 984 }
 985
 986 static void on_zclglobal_control_discover_attributes_resp(ZigBeeServiceInterface *service_interface,
 987         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 988 {
 989         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 990                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 991
 992         ZigbeeZcl_global_control *global_control_object;
 993         GDBusMethodInvocation *invocation;
 994
 995         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 996
 997         NOT_USED(service_interface);
 998         NOT_USED(request_id);
 999
1000         if (NULL == resp_data || 0 == resp_data_len) {
1001                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1002                 g_free(cb_data);
1003                 return;
1004         }
1005
1006         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1007         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
1008
1009         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1010         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1011
1012         zigbee_zcl_global_control_complete_discover_attributes(global_control_object,
1013                 invocation, payload->result);
1014
1015         g_free(cb_data);
1016 }
1017
1018 static gboolean on_zclglobal_control_discover_attributes(ZigbeeZcl_global_control *zclglobal_control_object,
1019         GDBusMethodInvocation *invocation,
1020         gshort node_id,
1021         gchar dest_ep,
1022         gchar zcl_frame_ctrl,
1023         gshort cluster_id,
1024         gshort start_attr,
1025         gchar max_attribute_count,
1026         gpointer user_data)
1027 {
1028         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1029         ZigbeeZclGlobalControlDiscoverAttributes_t req;
1030         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1031
1032         gboolean ret;
1033
1034         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
1035
1036         /* Update request structure */
1037         req.node_id = node_id;
1038         req.dest_ep = dest_ep;
1039         req.zcl_frame_ctrl = zcl_frame_ctrl;
1040         req.cluster_id = cluster_id;
1041         req.start_attribute = start_attr;
1042         req.max_attribute_count = max_attribute_count;
1043
1044         /* Allocate response callback data */
1045         resp_cb_data =
1046                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
1047                         invocation, NULL, 0);
1048         if (NULL == resp_cb_data) {
1049                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1050
1051                 /* Send failure response */
1052                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1053
1054                 return TRUE;
1055         }
1056
1057         /* Dispatch request */
1058         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1059                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
1060                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES,
1061                 &req, sizeof(req),
1062                 on_zclglobal_control_discover_attributes_resp, resp_cb_data);
1063         if (FALSE == ret) {
1064                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1065
1066                 /* Free response callback data */
1067                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1068
1069                 /* Send failure response */
1070                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1071
1072                 return TRUE;
1073         }
1074
1075         return TRUE;
1076 }
1077
1078 static void on_zclglobal_control_discover_attributes_extended_resp(ZigBeeServiceInterface *service_interface,
1079         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1080 {
1081         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1082                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1083
1084         ZigbeeZcl_global_control *global_control_object;
1085         GDBusMethodInvocation *invocation;
1086
1087         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1088
1089         NOT_USED(service_interface);
1090         NOT_USED(request_id);
1091
1092         if (NULL == resp_data || 0 == resp_data_len) {
1093                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1094                 g_free(cb_data);
1095                 return;
1096         }
1097
1098         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1099         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
1100
1101         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1102         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1103
1104         zigbee_zcl_global_control_complete_discover_attributes_extended(global_control_object,
1105                 invocation, payload->result);
1106
1107         g_free(cb_data);
1108 }
1109
1110 static gboolean on_zclglobal_control_discover_attributes_extended(ZigbeeZcl_global_control *zclglobal_control_object,
1111         GDBusMethodInvocation *invocation,
1112         gshort node_id,
1113         gchar dest_ep,
1114         gchar zcl_frame_ctrl,
1115         gshort cluster_id,
1116         gshort start_attr,
1117         gchar max_attribute_count,
1118         gpointer user_data)
1119 {
1120         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1121         ZigbeeZclGlobalControlDiscoverAttributesExtended_t req;
1122         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1123
1124         gboolean ret;
1125
1126         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
1127
1128         /* Update request structure */
1129         req.node_id = node_id;
1130         req.dest_ep = dest_ep;
1131         req.zcl_frame_ctrl = zcl_frame_ctrl;
1132         req.cluster_id = cluster_id;
1133         req.start_attribute = start_attr;
1134         req.max_attribute_count = max_attribute_count;
1135
1136         /* Allocate response callback data */
1137         resp_cb_data =
1138                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
1139                         invocation, NULL, 0);
1140         if (NULL == resp_cb_data) {
1141                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1142
1143                 /* Send failure response */
1144                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1145
1146                 return TRUE;
1147         }
1148
1149         /* Dispatch request */
1150         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1151                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
1152                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED,
1153                 &req, sizeof(req),
1154                 on_zclglobal_control_discover_attributes_extended_resp, resp_cb_data);
1155         if (FALSE == ret) {
1156                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1157
1158                 /* Free response callback data */
1159                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1160
1161                 /* Send failure response */
1162                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1163
1164                 return TRUE;
1165         }
1166
1167         return TRUE;
1168 }
1169
1170 static void on_zclglobal_control_discover_commands_received_resp(ZigBeeServiceInterface *service_interface,
1171         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1172 {
1173         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1174                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1175
1176         ZigbeeZcl_global_control *global_control_object;
1177         GDBusMethodInvocation *invocation;
1178
1179         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1180
1181         NOT_USED(service_interface);
1182         NOT_USED(request_id);
1183
1184         if (NULL == resp_data || 0 == resp_data_len) {
1185                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1186                 g_free(cb_data);
1187                 return;
1188         }
1189
1190         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1191         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
1192
1193         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1194         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1195
1196         zigbee_zcl_global_control_complete_discover_commands_received(global_control_object,
1197                 invocation, payload->result);
1198
1199         g_free(cb_data);;
1200 }
1201
1202 static gboolean on_zclglobal_control_discover_commands_received(ZigbeeZcl_global_control *zclglobal_control_object,
1203         GDBusMethodInvocation *invocation,
1204         gshort node_id,
1205         gchar dest_ep,
1206         gchar zcl_frame_ctrl,
1207         gshort cluster_id,
1208         gshort start_command,
1209         gchar max_command_count,
1210         gpointer user_data)
1211 {
1212         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1213         ZigbeeZclGlobalControlDiscoverCommandsReceived_t req;
1214         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1215
1216         gboolean ret;
1217
1218         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
1219
1220         /* Update request structure */
1221         req.node_id = node_id;
1222         req.dest_ep = dest_ep;
1223         req.zcl_frame_ctrl = zcl_frame_ctrl;
1224         req.cluster_id = cluster_id;
1225         req.start_command = start_command;
1226         req.max_command_count = max_command_count;
1227
1228         /* Allocate response callback data */
1229         resp_cb_data =
1230                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
1231                         invocation, NULL, 0);
1232         if (NULL == resp_cb_data) {
1233                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1234
1235                 /* Send failure response */
1236                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1237
1238                 return TRUE;
1239         }
1240
1241         /* Dispatch request */
1242         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1243                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
1244                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED,
1245                 &req, sizeof(req),
1246                 on_zclglobal_control_discover_commands_received_resp, resp_cb_data);
1247         if (FALSE == ret) {
1248                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1249
1250                 /* Free response callback data */
1251                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1252
1253                 /* Send failure response */
1254                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1255
1256                 return TRUE;
1257         }
1258
1259         return TRUE;
1260 }
1261
1262 static void on_zclglobal_control_discover_commands_generated_resp(ZigBeeServiceInterface *service_interface,
1263         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1264 {
1265         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1266                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1267
1268         ZigbeeZcl_global_control *global_control_object;
1269         GDBusMethodInvocation *invocation;
1270
1271         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
1272
1273         NOT_USED(service_interface);
1274         NOT_USED(request_id);
1275
1276         if (NULL == resp_data || 0 == resp_data_len) {
1277                 Z_LOGE("resp_data=%p or resp_data_len=%d is null", resp_data, resp_data_len);
1278                 g_free(cb_data);
1279                 return;
1280         }
1281
1282         global_control_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1283         zblib_check_null_free_and_ret("global_control_object", global_control_object, cb_data);
1284
1285         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1286         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1287
1288         zigbee_zcl_global_control_complete_discover_commands_generated(global_control_object,
1289                 invocation, payload->result);
1290
1291         g_free(cb_data);
1292 }
1293
1294 static gboolean on_zclglobal_control_discover_commands_generated(ZigbeeZcl_global_control *zclglobal_control_object,
1295         GDBusMethodInvocation *invocation,
1296         gshort node_id,
1297         gchar dest_ep,
1298         gchar zcl_frame_ctrl,
1299         gshort cluster_id,
1300         gshort start_command,
1301         gchar max_command_count,
1302         gpointer user_data)
1303 {
1304         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1305         ZigbeeZclGlobalControlDiscoverCommandsGenerated_t req;
1306         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1307
1308         gboolean ret;
1309
1310         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
1311
1312         /* Update request structure */
1313         req.node_id = node_id;
1314         req.dest_ep = dest_ep;
1315         req.zcl_frame_ctrl = zcl_frame_ctrl;
1316         req.cluster_id = cluster_id;
1317         req.start_command = start_command;
1318         req.max_command_count = max_command_count;
1319
1320         /* Allocate response callback data */
1321         resp_cb_data =
1322                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
1323                         invocation, NULL, 0);
1324         if (NULL == resp_cb_data) {
1325                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1326
1327                 /* Send failure response */
1328                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1329
1330                 return TRUE;
1331         }
1332
1333         /* Dispatch request */
1334         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1335                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
1336                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED,
1337                 &req, sizeof(req),
1338                 on_zclglobal_control_discover_commands_generated_resp, resp_cb_data);
1339         if (FALSE == ret) {
1340                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1341
1342                 /* Free response callback data */
1343                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1344
1345                 /* Send failure response */
1346                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1347
1348                 return TRUE;
1349         }
1350
1351         return TRUE;
1352 }
1353
1354 void zigbee_service_dbus_interface_zcl_global_control_notification(ZigBeeServiceInterface *service_interface,
1355         guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
1356 {
1357         ZigbeeZcl_global_control *global_control_object = NULL;
1358
1359         zblib_check_null_ret("service_interface", service_interface);
1360
1361         if (NULL == noti_data || 0 == noti_data_len) {
1362                 Z_LOGE("noti_data is NULL");
1363                 return;
1364         }
1365
1366         global_control_object = _service_interface_ref_zigbee_zcl_global_control(service_interface);
1367         zblib_check_null_ret("global_control_object", global_control_object);
1368
1369         NOT_USED(noti_cb_data);
1370
1371         switch (noti_id) {
1372         case ZBLIB_ZCL_GLOBAL_NOTI_READ_ATTR_RSP: {
1373                 ZigbeeZclGlobalControlReadAttributesResp_t *attr_t =
1374                         (ZigbeeZclGlobalControlReadAttributesResp_t*)noti_data;
1375
1376                 GVariant *v_values = NULL;
1377                 v_values = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1378                         attr_t->values, attr_t->record_length, TRUE, NULL, NULL);
1379                 if (NULL == v_values) {
1380                         Z_LOGE("Failed to create variant!");
1381                 } else {
1382                         Z_LOGD("Read attributes resp");
1383                         zigbee_zcl_global_control_emit_read_attributes_rsp(global_control_object,
1384                                 attr_t->node_id, attr_t->src_ep, v_values, attr_t->attribute_id,
1385                                 attr_t->cluster_id, attr_t->status, attr_t->type,
1386                                 attr_t->record_length, attr_t->is_string);
1387                 }
1388         break;
1389         }
1390         case ZBLIB_ZCL_GLOBAL_NOTI_WRITE_ATTR_RSP: {
1391                 ZigbeeZclGlobalControlWriteAttributesResp_t *attr_t =
1392                         (ZigbeeZclGlobalControlWriteAttributesResp_t*)noti_data;
1393
1394                 GVariant *v_values = NULL;
1395                 GVariant *v_attrs = NULL;
1396                 v_values = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1397                         attr_t->values, attr_t->record_length, TRUE, NULL, NULL);
1398                 v_attrs = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1399                         attr_t->attribute_list, (sizeof(gushort) * attr_t->record_length),
1400                         TRUE, NULL, NULL);
1401                 if (NULL == v_values || NULL == v_attrs) {
1402                         Z_LOGE("Failed to create variant!");
1403                         if (v_values)
1404                                 g_variant_unref(v_values);
1405                         if (v_attrs)
1406                                 g_variant_unref(v_attrs);
1407                 } else {
1408                         Z_LOGD("Write attributes resp");
1409                         zigbee_zcl_global_control_emit_write_attributes_rsp(global_control_object,
1410                                 attr_t->node_id, attr_t->src_ep, v_values, v_attrs,
1411                                 attr_t->cluster_id, attr_t->record_length);
1412                 }
1413         break;
1414         }
1415         case ZBLIB_ZCL_GLOBAL_NOTI_CONFIG_REPORT_RSP: {
1416                 ZigbeeZclGlobalControlConfigReportResp_t *attr_t =
1417                         (ZigbeeZclGlobalControlConfigReportResp_t*)noti_data;
1418
1419                 GVariant *v_status = NULL;
1420                 GVariant *v_attrs = NULL;
1421                 GVariant *v_dirs = NULL;
1422                 v_status = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1423                         attr_t->status_list, attr_t->record_length, TRUE, NULL, NULL);
1424                 v_attrs = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1425                         attr_t->attribute_list, (sizeof(gushort) * attr_t->record_length),
1426                         TRUE, NULL, NULL);
1427                 v_dirs = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1428                         attr_t->dir_list, attr_t->record_length, TRUE, NULL, NULL);
1429                 if (NULL == v_status || NULL == v_attrs || NULL == v_dirs) {
1430                         Z_LOGE("Failed to create variant!");
1431                         if (v_status)
1432                                 g_variant_unref(v_status);
1433                         if (v_attrs)
1434                                 g_variant_unref(v_attrs);
1435                         if (v_dirs)
1436                                 g_variant_unref(v_dirs);
1437                 } else {
1438                         Z_LOGD("Configure reporting resp");
1439                         zigbee_zcl_global_control_emit_configure_reporting_rsp(global_control_object,
1440                                 v_status, v_attrs, v_dirs, attr_t->cluster_id,
1441                                 attr_t->record_length, attr_t->node_id, attr_t->src_ep);
1442                 }
1443         break;
1444         }
1445         case ZBLIB_ZCL_GLOBAL_NOTI_DISCOVER_ATTR_RSP: {
1446                 ZigbeeZclGlobalControlDiscoverAttributeResp_t *attr_t =
1447                         (ZigbeeZclGlobalControlDiscoverAttributeResp_t*)noti_data;
1448
1449                 GVariant *v_types = NULL;
1450                 GVariant *v_attrs = NULL;
1451                 v_types = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1452                         attr_t->type_list, attr_t->record_length, TRUE, NULL, NULL);
1453                 v_attrs = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1454                         attr_t->attribute_list, (sizeof(gushort) * attr_t->record_length),
1455                         TRUE, NULL, NULL);
1456                 if (NULL == v_types || NULL == v_attrs) {
1457                         Z_LOGE("Failed to create variant!");
1458                 } else {
1459                         Z_LOGD("Discover attribute resp");
1460                         zigbee_zcl_global_control_emit_discover_attribute_rsp(global_control_object,
1461                                 attr_t->node_id, attr_t->src_ep, v_types, v_attrs,
1462                                 attr_t->cluster_id, attr_t->record_length, attr_t->discovery_completed);
1463                 }
1464                 if (v_types)
1465                         g_variant_unref(v_types);
1466                 if (v_attrs)
1467                         g_variant_unref(v_attrs);
1468         break;
1469         }
1470         case ZBLIB_ZCL_GLOBAL_NOTI_WRITE_ATTR_STRUCTURED_RSP: {
1471                 ZigbeeZclGlobalControlWriteAttributeStructuredResp_t *attr_t =
1472                         (ZigbeeZclGlobalControlWriteAttributeStructuredResp_t*)noti_data;
1473
1474                 GVariant *v_status = NULL;
1475                 GVariant *v_attrs = NULL;
1476                 GVariant *v_indicator = NULL;
1477                 GVariantBuilder *index_builder = NULL;
1478                 GVariant *v_index = NULL;
1479                 int i = 0, j = 0;
1480
1481                 v_status = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1482                         attr_t->status_list, attr_t->record_length, TRUE, NULL, NULL);
1483                 v_attrs = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1484                         attr_t->attribute_list, (sizeof(gushort) * attr_t->record_length),
1485                         TRUE, NULL, NULL);
1486                 v_indicator = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1487                         attr_t->indicator_list, attr_t->record_length, TRUE, NULL, NULL);
1488
1489                 if (NULL == v_status || NULL == v_attrs || NULL == v_indicator) {
1490                         Z_LOGE("Failed to create variant!");
1491                         if (v_status)
1492                                 g_variant_unref(v_status);
1493                         if (v_attrs)
1494                                 g_variant_unref(v_attrs);
1495                         if (v_indicator)
1496                                 g_variant_unref(v_indicator);
1497                         break;
1498                 }
1499
1500                 index_builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
1501                 if (NULL == index_builder) {
1502                         Z_LOGE("Failed to create variant builder!");
1503                         g_variant_unref(v_status);
1504                         g_variant_unref(v_attrs);
1505                         g_variant_unref(v_indicator);
1506                         break;
1507                 }
1508                 for (i = 0; i < attr_t->record_length; i++) {
1509                         for (j = 0; j < attr_t->indicator_list[i]; j++)
1510                                 g_variant_builder_add(index_builder, "q", attr_t->index_list[i][j]);
1511                 }
1512                 v_index = g_variant_builder_end(index_builder);
1513                 g_variant_builder_unref(index_builder);
1514
1515                 Z_LOGD("Write attribute structured resp");
1516                 zigbee_zcl_global_control_emit_write_attribute_structured_rsp(
1517                         global_control_object,
1518                         v_status, v_attrs, v_indicator, v_index,
1519                         attr_t->cluster_id, attr_t->record_length,
1520                         attr_t->node_id, attr_t->src_ep);
1521                 if (v_status)
1522                         g_variant_unref(v_status);
1523                 if (v_attrs)
1524                         g_variant_unref(v_attrs);
1525                 if (v_indicator)
1526                         g_variant_unref(v_indicator);
1527         break;
1528         }
1529         case ZBLIB_ZCL_GLOBAL_NOTI_DISCOVER_CMDS_RECEIVED_RSP: {
1530                 ZigbeeZclGlobalControlDiscoverCommandsReceivedResp_t *attr_t =
1531                         (ZigbeeZclGlobalControlDiscoverCommandsReceivedResp_t*)noti_data;
1532
1533                 GVariant *v_commands = NULL;
1534                 v_commands = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1535                         attr_t->command_list, attr_t->list_count, TRUE, NULL, NULL);
1536                 if (NULL == v_commands) {
1537                         Z_LOGE("Failed to create variant!");
1538                 } else {
1539                         Z_LOGD("Discover commands received resp");
1540                         zigbee_zcl_global_control_emit_discover_commands_received_rsp(
1541                                 global_control_object,
1542                                 v_commands, attr_t->cluster_id, attr_t->list_count,
1543                                 attr_t->node_id, attr_t->src_ep, attr_t->discovery_completed);
1544                 }
1545                 if (v_commands)
1546                         g_variant_unref(v_commands);
1547         break;
1548         }
1549         case ZBLIB_ZCL_GLOBAL_NOTI_DISCOVER_CMDS_GENERATED_RSP: {
1550                 ZigbeeZclGlobalControlDiscoverCommandsGeneratedResp_t *attr_t =
1551                         (ZigbeeZclGlobalControlDiscoverCommandsGeneratedResp_t*)noti_data;
1552
1553                 GVariant *v_commands = NULL;
1554                 v_commands = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1555                         attr_t->command_list, attr_t->list_count, TRUE, NULL, NULL);
1556                 if (NULL == v_commands) {
1557                         Z_LOGE("Failed to create variant!");
1558                 } else {
1559                         Z_LOGD("Discover commands generated resp");
1560                         zigbee_zcl_global_control_emit_discover_commands_generated_rsp(
1561                                 global_control_object,
1562                                 v_commands, attr_t->cluster_id, attr_t->list_count,
1563                                 attr_t->node_id, attr_t->src_ep, attr_t->discovery_completed);
1564                 }
1565                 if (v_commands)
1566                         g_variant_unref(v_commands);
1567         break;
1568         }
1569         case ZBLIB_ZCL_GLOBAL_NOTI_DISCOVER_ATTR_EXT_RSP: {
1570                 ZigbeeZclGlobalControlDiscoverAttributesExtendedResp_t *attr_t =
1571                         (ZigbeeZclGlobalControlDiscoverAttributesExtendedResp_t*)noti_data;
1572
1573                 GVariant *v_attrs = NULL;
1574                 GVariant *v_attrs_type = NULL;
1575                 GVariant *v_access = NULL;
1576                 v_attrs = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1577                         attr_t->attribute_list, (sizeof(gushort) * attr_t->list_count),
1578                         TRUE, NULL, NULL);
1579                 v_attrs_type = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1580                         attr_t->attribute_type_list, attr_t->list_count, TRUE, NULL, NULL);
1581                 v_access = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1582                         attr_t->access_list, attr_t->list_count, TRUE, NULL, NULL);
1583                 if (NULL == v_attrs_type || NULL == v_attrs || NULL == v_access) {
1584                         Z_LOGE("Failed to create variant!");
1585                 } else {
1586                         Z_LOGD("Discover attributes extended resp");
1587                         zigbee_zcl_global_control_emit_discover_attributes_extended_rsp(
1588                                 global_control_object,
1589                                 v_attrs, v_attrs_type, v_access,
1590                                 attr_t->cluster_id, attr_t->list_count,
1591                                 attr_t->node_id, attr_t->src_ep, attr_t->discovery_completed);
1592                 }
1593                 if (v_attrs_type)
1594                         g_variant_unref(v_attrs_type);
1595                 if (v_attrs)
1596                         g_variant_unref(v_attrs);
1597                 if (v_access)
1598                         g_variant_unref(v_access);
1599         break;
1600         }
1601         case ZBLIB_ZCL_GLOBAL_NOTI_DEFAULT_RSP: {
1602                 ZigbeeZclGlobalControlDefaultResp_t *attr_t =
1603                         (ZigbeeZclGlobalControlDefaultResp_t*)noti_data;
1604
1605                 Z_LOGD("Global default resp");
1606                 zigbee_zcl_global_control_emit_zcl_global_default_response(
1607                         global_control_object,
1608                         attr_t->node_id, attr_t->src_ep, attr_t->cluster_id,
1609                         attr_t->command_id, attr_t->status);
1610         break;
1611         }
1612         case ZBLIB_ZCL_GLOBAL_NOTI_REPORT_ATTR_HANDLER_RSP: {
1613                 ZigbeeZclGlobalControlReportAttributeHandlerResp_t *attr_t =
1614                         (ZigbeeZclGlobalControlReportAttributeHandlerResp_t*)noti_data;
1615
1616                 GVariant *v_attrs = NULL;
1617                 GVariant *v_data_type = NULL;
1618                 GVariant *v_values = NULL;
1619                 GVariantBuilder *values_builder = NULL;
1620                 int i = 0, j = 0;
1621
1622                 v_attrs = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1623                         attr_t->attribute_list, (sizeof(gushort) * attr_t->list_count),
1624                         TRUE, NULL, NULL);
1625                 if (NULL == v_attrs) {
1626                         Z_LOGE("Failed to create variant!");
1627                         break;
1628                 }
1629                 v_data_type = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1630                         attr_t->data_type_list, attr_t->list_count, TRUE, NULL, NULL);
1631                 if (NULL == v_data_type) {
1632                         Z_LOGE("Failed to create variant!");
1633                         if (v_attrs)
1634                                 g_variant_unref(v_attrs);
1635                         break;
1636                 }
1637
1638                 values_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
1639                 if (NULL == values_builder) {
1640                         Z_LOGE("Failed to create variant builder!");
1641                         if (v_attrs)
1642                                 g_variant_unref(v_attrs);
1643                         if (v_data_type)
1644                                 g_variant_unref(v_data_type);
1645                         break;
1646                 }
1647                 for (i = 0; i < attr_t->list_count; i++) {
1648                         for (j = 0; j < attr_t->values_count[i]; j++)
1649                                 g_variant_builder_add(values_builder, "(y)", attr_t->values[i][j]);
1650                 }
1651                 v_values = g_variant_builder_end(values_builder);
1652                 g_variant_builder_unref(values_builder);
1653
1654                 Z_LOGD("Report attributes handler resp");
1655                 zigbee_zcl_global_control_emit_report_attr_handler_rsp(
1656                         global_control_object,
1657                         attr_t->node_id, attr_t->src_ep, attr_t->cluster_id,
1658                         v_attrs, v_data_type, v_values,
1659                         attr_t->list_count);
1660                 if (v_attrs)
1661                         g_variant_unref(v_attrs);
1662                 if (v_data_type)
1663                         g_variant_unref(v_data_type);
1664                 if (v_values)
1665                         g_variant_unref(v_values);
1666         break;
1667         }
1668         case ZBLIB_ZCL_GLOBAL_NOTI_READ_CONFIG_REPORT_RSP: {
1669                 ZigbeeZclGlobalControlReadConfigureReportingResp_t *resp_t =
1670                         (ZigbeeZclGlobalControlReadConfigureReportingResp_t *)noti_data;
1671                 int i = 0;
1672                 int v = 0;
1673
1674                 GVariant *v_entries = NULL;
1675                 GVariantBuilder *entry_builder =
1676                                 g_variant_builder_new(G_VARIANT_TYPE("a(yyqyqqayq)"));
1677                 if (NULL == entry_builder) {
1678                         Z_LOGE("Failed to create variant builder!");
1679                         break;
1680                 }
1681
1682                 for (i = 0; i < resp_t->record_count ; i++) {
1683                         GVariantBuilder *change_builder =
1684                                         g_variant_builder_new(G_VARIANT_TYPE("ay"));
1685                         if (NULL == change_builder) {
1686                                 Z_LOGE("Failed to create variant builder!");
1687                                 g_variant_builder_unref(entry_builder);
1688                                 break;
1689                         }
1690
1691                         for (v = 0; v < resp_t->entry_list[i].change_count; v++) {
1692                                 g_variant_builder_add(change_builder, "y",
1693                                         resp_t->entry_list[i].change[v]);
1694                         }
1695
1696                         g_variant_builder_add(entry_builder, "(yyqyqqayq)",
1697                                 resp_t->entry_list[i].status,
1698                                 resp_t->entry_list[i].dir,
1699                                 resp_t->entry_list[i].attribute_id,
1700                                 resp_t->entry_list[i].data_type,
1701                                 resp_t->entry_list[i].min_interval,
1702                                 resp_t->entry_list[i].max_interval,
1703                                 change_builder,
1704                                 resp_t->entry_list[i].change_count,
1705                                 resp_t->entry_list[i].timeout);
1706
1707                         g_variant_builder_unref(change_builder);
1708                 }
1709                 v_entries = g_variant_builder_end(entry_builder);
1710                 g_variant_builder_unref(entry_builder);
1711
1712                 Z_LOGD("Read configure reporting resp");
1713                 zigbee_zcl_global_control_emit_read_configure_reporting_rsp(
1714                         global_control_object, resp_t->node_id, resp_t->src_ep,
1715                         resp_t->cluster_id, resp_t->record_count, v_entries);
1716
1717                 if (v_entries)
1718                         g_variant_unref(v_entries);
1719         break;
1720         }
1721         default:
1722                 Z_LOGE("Unexpected notification [%x]", noti_id);
1723         break;
1724         }
1725
1726         /* ZigbeeZcl_global_control should be dereferenced */
1727         g_object_unref(global_control_object);
1728 }
1729
1730 gboolean zigbee_service_dbus_interface_zcl_global_control_init(ZigBeeServiceInterface *service_interface,
1731         ZigbeeObjectSkeleton *zigbee_object)
1732 {
1733         ZigbeeZcl_global_control *zclglobal_control_object;
1734
1735         if (NULL == service_interface) {
1736                 Z_LOGE("service_interface is NULL");
1737                 return FALSE;
1738         }
1739
1740         zclglobal_control_object = zigbee_zcl_global_control_skeleton_new();
1741         zigbee_object_skeleton_set_zcl_global_control(zigbee_object, zclglobal_control_object);
1742         g_object_unref(zclglobal_control_object);
1743
1744         Z_LOGI("zclglobal_control_object: [%p]", zclglobal_control_object);
1745
1746         /*
1747          * Register signal handlers for 'zclglobal_control' interface
1748          */
1749         g_signal_connect(zclglobal_control_object,
1750                 "handle-read-attributes-req",
1751                 G_CALLBACK(on_zclglobal_control_read_attributes_req), service_interface);
1752
1753         g_signal_connect(zclglobal_control_object,
1754                 "handle-write-attributes-req",
1755                 G_CALLBACK(on_zclglobal_control_write_attributes_req), service_interface);
1756
1757         g_signal_connect(zclglobal_control_object,
1758                 "handle-write-attributes-undivided-req",
1759                 G_CALLBACK(on_zclglobal_control_write_attributes_undivided_req), service_interface);
1760
1761         g_signal_connect(zclglobal_control_object,
1762                 "handle-write-attributes-no-resp",
1763                 G_CALLBACK(on_zclglobal_control_write_attributes_no_resp), service_interface);
1764
1765         g_signal_connect(zclglobal_control_object,
1766                 "handle-write-attributes-structured",
1767                 G_CALLBACK(on_zclglobal_control_write_attributes_structured), service_interface);
1768
1769         g_signal_connect(zclglobal_control_object,
1770                 "handle-read-attributes-structured",
1771                 G_CALLBACK(on_zclglobal_control_read_attributes_structured), service_interface);
1772
1773         g_signal_connect(zclglobal_control_object,
1774                 "handle-configure-reporting-req",
1775                 G_CALLBACK(on_zclglobal_control_configure_reporting_req), service_interface);
1776
1777         g_signal_connect(zclglobal_control_object,
1778                 "handle-read-configure-reporting",
1779                 G_CALLBACK(on_zclglobal_control_read_configure_reporting), service_interface);
1780
1781         g_signal_connect(zclglobal_control_object,
1782                 "handle-discover-attributes",
1783                 G_CALLBACK(on_zclglobal_control_discover_attributes), service_interface);
1784
1785         g_signal_connect(zclglobal_control_object,
1786                 "handle-discover-attributes-extended",
1787                 G_CALLBACK(on_zclglobal_control_discover_attributes_extended), service_interface);
1788
1789         g_signal_connect(zclglobal_control_object,
1790                 "handle-discover-commands-received",
1791                 G_CALLBACK(on_zclglobal_control_discover_commands_received), service_interface);
1792
1793         g_signal_connect(zclglobal_control_object,
1794                 "handle-discover-commands-generated",
1795                 G_CALLBACK(on_zclglobal_control_discover_commands_generated), service_interface);
1796
1797         return TRUE;
1798 }