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