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 on_zclglobal_control_read_attributes_req_resp(ZigBeeServiceInterface *service_interface,
  24         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
  25 {
  26         ZigbeeServiceInterfaceRespCbData_t *cb_data =
  27                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
  28
  29         NOT_USED(cb_data);
  30         NOT_USED(service_interface);
  31         NOT_USED(request_id);
  32         NOT_USED(resp_data);
  33         NOT_USED(resp_data_len);
  34 }
  35
  36 static gboolean on_zclglobal_control_read_attributes_req(ZigbeeZcl_global_control *zclglobal_control_object,
  37         GDBusMethodInvocation *invocation,
  38         GVariant *attribute_id,
  39         gint attribute_ids_length,
  40         gshort node_id,
  41         gshort cluster_id,
  42         gchar zcl_frame_ctrl,
  43         gchar dest_ep,
  44         gpointer user_data)
  45 {
  46         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  47         ZigbeeZclGlobalControlReadAttributesRequest_t req;
  48         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  49
  50         GVariantIter *iter = NULL;
  51         gint i = 0;
  52
  53         gboolean ret;
  54
  55         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
  56
  57         /* Update request structure */
  58         g_variant_get(attribute_id, "ay", &iter);
  59         while (g_variant_iter_loop(iter, "y", req.attribute_id[i])) {
  60                 i++;
  61                 if (i >= attribute_ids_length)
  62                         break;
  63         }
  64         req.attribute_id_len = attribute_ids_length;
  65         req.node_id = node_id;
  66         req.cluster_id = cluster_id;
  67         req.zcl_frame_ctrl = zcl_frame_ctrl;
  68         req.dest_ep = dest_ep;
  69
  70         /* Allocate response callback data */
  71         resp_cb_data =
  72                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
  73                         invocation, NULL, 0);
  74         if (NULL == resp_cb_data) {
  75                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
  76
  77                 /* Send failure response */
  78                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
  79
  80                 return TRUE;
  81         }
  82
  83         /* Dispatch request */
  84         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
  85                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
  86                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ,
  87                 &req, sizeof(req),
  88                 on_zclglobal_control_read_attributes_req_resp, resp_cb_data);
  89         if (FALSE == ret) {
  90                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
  91
  92                 /* Free response callback data */
  93                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
  94
  95                 /* Send failure response */
  96                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
  97
  98                 return TRUE;
  99         }
 100
 101         return TRUE;
 102 }
 103
 104 static void on_zclglobal_control_write_attributes_req_resp(ZigBeeServiceInterface *service_interface,
 105         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 106 {
 107         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 108                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 109
 110         NOT_USED(cb_data);
 111         NOT_USED(service_interface);
 112         NOT_USED(request_id);
 113         NOT_USED(resp_data);
 114         NOT_USED(resp_data_len);
 115 }
 116
 117 static gboolean on_zclglobal_control_write_attributes_req(ZigbeeZcl_global_control *zclglobal_control_object,
 118         GDBusMethodInvocation *invocation,
 119         GVariant *write_attribute,
 120         gint records_length,
 121         gshort node_id,
 122         gshort cluster_id,
 123         gchar zcl_frame_ctrl,
 124         gchar dest_ep,
 125         gpointer user_data)
 126 {
 127         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 128         ZigbeeZclGlobalControlWriteAttributesRequest_t req;
 129         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 130
 131         GVariantIter *iter = NULL;
 132         gint i = 0;
 133
 134         gboolean ret;
 135
 136         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
 137
 138         /* Update request structure */
 139         g_variant_get(write_attribute, "ay", &iter);
 140         while (g_variant_iter_loop(iter, "y", req.write_records[i])) {
 141                 i++;
 142                 if (i >= records_length)
 143                         break;
 144         }
 145         req.records_len = records_length;
 146         req.node_id = node_id;
 147         req.cluster_id = cluster_id;
 148         req.zcl_frame_ctrl = zcl_frame_ctrl;
 149         req.dest_ep = dest_ep;
 150
 151         /* Allocate response callback data */
 152         resp_cb_data =
 153                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 154                         invocation, NULL, 0);
 155         if (NULL == resp_cb_data) {
 156                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 157
 158                 /* Send failure response */
 159                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 160
 161                 return TRUE;
 162         }
 163
 164         /* Dispatch request */
 165         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 166                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 167                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ,
 168                 &req, sizeof(req),
 169                 on_zclglobal_control_write_attributes_req_resp, resp_cb_data);
 170         if (FALSE == ret) {
 171                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 172
 173                 /* Free response callback data */
 174                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 175
 176                 /* Send failure response */
 177                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 178
 179                 return TRUE;
 180         }
 181
 182         return TRUE;
 183 }
 184
 185 static void on_zclglobal_control_write_attributes_undivided_req_resp(ZigBeeServiceInterface *service_interface,
 186         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 187 {
 188         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 189                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 190
 191         NOT_USED(cb_data);
 192         NOT_USED(service_interface);
 193         NOT_USED(request_id);
 194         NOT_USED(resp_data);
 195         NOT_USED(resp_data_len);
 196 }
 197
 198 static gboolean on_zclglobal_control_write_attributes_undivided_req(ZigbeeZcl_global_control *zclglobal_control_object,
 199         GDBusMethodInvocation *invocation,
 200         GVariant *write_attribute,
 201         gint records_length,
 202         gshort node_id,
 203         gshort cluster_id,
 204         gchar zcl_frame_ctrl,
 205         gchar src_ep,
 206         gchar dest_ep,
 207         gpointer user_data)
 208 {
 209         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 210         ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t req;
 211         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 212
 213         GVariantIter *iter = NULL;
 214         gint i = 0;
 215
 216         gboolean ret;
 217
 218         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
 219
 220         /* Update request structure */
 221         g_variant_get(write_attribute, "ay", &iter);
 222         while (g_variant_iter_loop(iter, "y", req.write_records[i])) {
 223                 i++;
 224                 if (i >= records_length)
 225                         break;
 226         }
 227         req.records_len = records_length;
 228         req.node_id = node_id;
 229         req.cluster_id = cluster_id;
 230         req.zcl_frame_ctrl = zcl_frame_ctrl;
 231         req.src_ep = src_ep;
 232         req.dest_ep = dest_ep;
 233
 234         /* Allocate response callback data */
 235         resp_cb_data =
 236                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 237                         invocation, NULL, 0);
 238         if (NULL == resp_cb_data) {
 239                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 240
 241                 /* Send failure response */
 242                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 243
 244                 return TRUE;
 245         }
 246
 247         /* Dispatch request */
 248         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 249                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 250                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ,
 251                 &req, sizeof(req),
 252                 on_zclglobal_control_write_attributes_undivided_req_resp, resp_cb_data);
 253         if (FALSE == ret) {
 254                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 255
 256                 /* Free response callback data */
 257                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 258
 259                 /* Send failure response */
 260                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 261
 262                 return TRUE;
 263         }
 264
 265         return TRUE;
 266 }
 267
 268 static void on_zclglobal_control_write_attributes_no_resp_resp(ZigBeeServiceInterface *service_interface,
 269         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 270 {
 271         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 272                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 273
 274         NOT_USED(cb_data);
 275         NOT_USED(service_interface);
 276         NOT_USED(request_id);
 277         NOT_USED(resp_data);
 278         NOT_USED(resp_data_len);
 279 }
 280
 281 static gboolean on_zclglobal_control_write_attributes_no_resp(ZigbeeZcl_global_control *zclglobal_control_object,
 282         GDBusMethodInvocation *invocation,
 283         GVariant *write_attribute,
 284         gint records_length,
 285         gshort node_id,
 286         gshort cluster_id,
 287         gchar zcl_frame_ctrl,
 288         gchar src_ep,
 289         gchar dest_ep,
 290         gpointer user_data)
 291 {
 292         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 293         ZigbeeZclGlobalControlWriteAttributesNoResponse_t req;
 294         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 295
 296         GVariantIter *iter = NULL;
 297         gint i = 0;
 298
 299         gboolean ret;
 300
 301         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
 302
 303         /* Update request structure */
 304         g_variant_get(write_attribute, "ay", &iter);
 305         while (g_variant_iter_loop(iter, "y", req.write_records[i])) {
 306                 i++;
 307                 if (i >= records_length)
 308                         break;
 309         }
 310         req.records_len = records_length;
 311         req.node_id = node_id;
 312         req.cluster_id = cluster_id;
 313         req.zcl_frame_ctrl = zcl_frame_ctrl;
 314         req.src_ep = src_ep;
 315         req.dest_ep = dest_ep;
 316
 317         /* Allocate response callback data */
 318         resp_cb_data =
 319                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 320                         invocation, NULL, 0);
 321         if (NULL == resp_cb_data) {
 322                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 323
 324                 /* Send failure response */
 325                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 326
 327                 return TRUE;
 328         }
 329
 330         /* Dispatch request */
 331         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 332                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 333                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP,
 334                 &req, sizeof(req),
 335                 on_zclglobal_control_write_attributes_no_resp_resp, resp_cb_data);
 336         if (FALSE == ret) {
 337                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 338
 339                 /* Free response callback data */
 340                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 341
 342                 /* Send failure response */
 343                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 344
 345                 return TRUE;
 346         }
 347
 348         return TRUE;
 349 }
 350
 351 static void on_zclglobal_control_write_attributes_structured_resp(ZigBeeServiceInterface *service_interface,
 352         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 353 {
 354         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 355                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 356
 357         NOT_USED(cb_data);
 358         NOT_USED(service_interface);
 359         NOT_USED(request_id);
 360         NOT_USED(resp_data);
 361         NOT_USED(resp_data_len);
 362 }
 363
 364 static gboolean on_zclglobal_control_write_attributes_structured(ZigbeeZcl_global_control *zclglobal_control_object,
 365         GDBusMethodInvocation *invocation,
 366         GVariant *write_attribute,
 367         gint records_length,
 368         gshort node_id,
 369         gshort cluster_id,
 370         gchar zcl_frame_ctrl,
 371         gchar src_ep,
 372         gchar dest_ep,
 373         gpointer user_data)
 374 {
 375         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 376         ZigbeeZclGlobalControlWriteAttributesStructed_t req;
 377         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 378
 379         GVariantIter *iter = NULL;
 380         gint i = 0;
 381
 382         gboolean ret;
 383
 384         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
 385
 386         /* Update request structure */
 387         g_variant_get(write_attribute, "ay", &iter);
 388         while (g_variant_iter_loop(iter, "y", req.write_records[i])) {
 389                 i++;
 390                 if (i >= records_length)
 391                         break;
 392         }
 393         req.records_len = records_length;
 394         req.node_id = node_id;
 395         req.cluster_id = cluster_id;
 396         req.zcl_frame_ctrl = zcl_frame_ctrl;
 397         req.src_ep = src_ep;
 398         req.dest_ep = dest_ep;
 399
 400         /* Allocate response callback data */
 401         resp_cb_data =
 402                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 403                         invocation, NULL, 0);
 404         if (NULL == resp_cb_data) {
 405                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 406
 407                 /* Send failure response */
 408                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 409
 410                 return TRUE;
 411         }
 412
 413         /* Dispatch request */
 414         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 415                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 416                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED,
 417                 &req, sizeof(req),
 418                 on_zclglobal_control_write_attributes_structured_resp, resp_cb_data);
 419         if (FALSE == ret) {
 420                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 421
 422                 /* Free response callback data */
 423                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 424
 425                 /* Send failure response */
 426                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 427
 428                 return TRUE;
 429         }
 430
 431         return TRUE;
 432 }
 433
 434 static void on_zclglobal_control_read_attributes_structured_resp(ZigBeeServiceInterface *service_interface,
 435         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 436 {
 437         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 438                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 439
 440         NOT_USED(cb_data);
 441         NOT_USED(service_interface);
 442         NOT_USED(request_id);
 443         NOT_USED(resp_data);
 444         NOT_USED(resp_data_len);
 445 }
 446
 447 static gboolean on_zclglobal_control_read_attributes_structured(ZigbeeZcl_global_control *zclglobal_control_object,
 448         GDBusMethodInvocation *invocation,
 449         GVariant *read_attribute,
 450         gint records_length,
 451         gshort node_id,
 452         gshort cluster_id,
 453         gchar zcl_frame_ctrl,
 454         gchar src_ep,
 455         gchar dest_ep,
 456         gpointer user_data)
 457 {
 458         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 459         ZigbeeZclGlobalControlReadAttributesStructed_t req;
 460         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 461
 462         GVariantIter *iter = NULL;
 463         gint i = 0;
 464
 465         gboolean ret;
 466
 467         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
 468
 469         /* Update request structure */
 470         g_variant_get(read_attribute, "ay", &iter);
 471         while (g_variant_iter_loop(iter, "y", req.read_records[i])) {
 472                 i++;
 473                 if (i >= records_length)
 474                         break;
 475         }
 476         req.records_len = records_length;
 477         req.node_id = node_id;
 478         req.cluster_id = cluster_id;
 479         req.zcl_frame_ctrl = zcl_frame_ctrl;
 480         req.src_ep = src_ep;
 481         req.dest_ep = dest_ep;
 482
 483         /* Allocate response callback data */
 484         resp_cb_data =
 485                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 486                         invocation, NULL, 0);
 487         if (NULL == resp_cb_data) {
 488                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 489
 490                 /* Send failure response */
 491                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 492
 493                 return TRUE;
 494         }
 495
 496         /* Dispatch request */
 497         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 498                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 499                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED,
 500                 &req, sizeof(req),
 501                 on_zclglobal_control_read_attributes_structured_resp, resp_cb_data);
 502         if (FALSE == ret) {
 503                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 504
 505                 /* Free response callback data */
 506                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 507
 508                 /* Send failure response */
 509                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 510
 511                 return TRUE;
 512         }
 513
 514         return TRUE;
 515 }
 516
 517 static void on_zclglobal_control_configure_reporting_req_resp(ZigBeeServiceInterface *service_interface,
 518         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 519 {
 520         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 521                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 522
 523         NOT_USED(cb_data);
 524         NOT_USED(service_interface);
 525         NOT_USED(request_id);
 526         NOT_USED(resp_data);
 527         NOT_USED(resp_data_len);
 528 }
 529
 530 static gboolean on_zclglobal_control_configure_reporting_req(ZigbeeZcl_global_control *zclglobal_control_object,
 531         GDBusMethodInvocation *invocation,
 532         GVariant *read_attribute,
 533         gint records_length,
 534         gshort node_id,
 535         gshort cluster_id,
 536         gchar zcl_frame_ctrl,
 537         gchar src_ep,
 538         gchar dest_ep,
 539         gpointer user_data)
 540 {
 541         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 542         ZigbeeZclGlobalControlConfigureReportingReq_t req;
 543         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 544
 545         GVariantIter *iter = NULL;
 546         gint i = 0;
 547
 548         gboolean ret;
 549
 550         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
 551
 552         /* Update request structure */
 553         g_variant_get(read_attribute, "ay", &iter);
 554         while (g_variant_iter_loop(iter, "y", req.read_records[i])) {
 555                 i++;
 556                 if (i >= records_length)
 557                         break;
 558         }
 559         req.records_len = records_length;
 560         req.node_id = node_id;
 561         req.cluster_id = cluster_id;
 562         req.zcl_frame_ctrl = zcl_frame_ctrl;
 563         req.src_ep = src_ep;
 564         req.dest_ep = dest_ep;
 565
 566         /* Allocate response callback data */
 567         resp_cb_data =
 568                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 569                         invocation, NULL, 0);
 570         if (NULL == resp_cb_data) {
 571                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 572
 573                 /* Send failure response */
 574                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 575
 576                 return TRUE;
 577         }
 578
 579         /* Dispatch request */
 580         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 581                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 582                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ,
 583                 &req, sizeof(req),
 584                 on_zclglobal_control_configure_reporting_req_resp, resp_cb_data);
 585         if (FALSE == ret) {
 586                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 587
 588                 /* Free response callback data */
 589                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 590
 591                 /* Send failure response */
 592                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 593
 594                 return TRUE;
 595         }
 596
 597         return TRUE;
 598 }
 599
 600 static void on_zclglobal_control_read_configure_reporting_resp(ZigBeeServiceInterface *service_interface,
 601         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 602 {
 603         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 604                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 605
 606         NOT_USED(cb_data);
 607         NOT_USED(service_interface);
 608         NOT_USED(request_id);
 609         NOT_USED(resp_data);
 610         NOT_USED(resp_data_len);
 611 }
 612
 613 static gboolean on_zclglobal_control_read_configure_reporting(ZigbeeZcl_global_control *zclglobal_control_object,
 614         GDBusMethodInvocation *invocation,
 615         GVariant *read_attribute,
 616         gint records_length,
 617         gshort node_id,
 618         gshort cluster_id,
 619         gchar zcl_frame_ctrl,
 620         gchar src_ep,
 621         gchar dest_ep,
 622         gpointer user_data)
 623 {
 624         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 625         ZigbeeZclGlobalControlReadConfigureReporting_t req;
 626         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 627
 628         GVariantIter *iter = NULL;
 629         gint i = 0;
 630
 631         gboolean ret;
 632
 633         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
 634
 635         /* Update request structure */
 636         g_variant_get(read_attribute, "ay", &iter);
 637         while (g_variant_iter_loop(iter, "y", req.read_records[i])) {
 638                 i++;
 639                 if (i >= records_length)
 640                         break;
 641         }
 642         req.records_len = records_length;
 643         req.node_id = node_id;
 644         req.cluster_id = cluster_id;
 645         req.zcl_frame_ctrl = zcl_frame_ctrl;
 646         req.src_ep = src_ep;
 647         req.dest_ep = dest_ep;
 648
 649         /* Allocate response callback data */
 650         resp_cb_data =
 651                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 652                         invocation, NULL, 0);
 653         if (NULL == resp_cb_data) {
 654                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 655
 656                 /* Send failure response */
 657                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 658
 659                 return TRUE;
 660         }
 661
 662         /* Dispatch request */
 663         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 664                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 665                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING,
 666                 &req, sizeof(req),
 667                 on_zclglobal_control_read_configure_reporting_resp, resp_cb_data);
 668         if (FALSE == ret) {
 669                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 670
 671                 /* Free response callback data */
 672                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 673
 674                 /* Send failure response */
 675                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 676
 677                 return TRUE;
 678         }
 679
 680         return TRUE;
 681 }
 682
 683 static void on_zclglobal_control_discover_attributes_resp(ZigBeeServiceInterface *service_interface,
 684         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 685 {
 686         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 687                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 688
 689         NOT_USED(cb_data);
 690         NOT_USED(service_interface);
 691         NOT_USED(request_id);
 692         NOT_USED(resp_data);
 693         NOT_USED(resp_data_len);
 694 }
 695
 696 static gboolean on_zclglobal_control_discover_attributes(ZigbeeZcl_global_control *zclglobal_control_object,
 697         GDBusMethodInvocation *invocation,
 698         gshort node_id,
 699         gchar dest_ep,
 700         gchar zcl_frame_ctrl,
 701         gshort cluster_id,
 702         gshort start_attr,
 703         gchar max,
 704         gpointer user_data)
 705 {
 706         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 707         ZigbeeZclGlobalControlDiscoverAttributes_t req;
 708         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 709
 710         gboolean ret;
 711
 712         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
 713
 714         /* Update request structure */
 715         req.node_id = node_id;
 716         req.dest_ep = dest_ep;
 717         req.zcl_frame_ctrl = zcl_frame_ctrl;
 718         req.cluster_id = cluster_id;
 719         req.start_attribute = start_attr;
 720         req.max = max;
 721
 722         /* Allocate response callback data */
 723         resp_cb_data =
 724                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 725                         invocation, NULL, 0);
 726         if (NULL == resp_cb_data) {
 727                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 728
 729                 /* Send failure response */
 730                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 731
 732                 return TRUE;
 733         }
 734
 735         /* Dispatch request */
 736         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 737                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 738                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES,
 739                 &req, sizeof(req),
 740                 on_zclglobal_control_discover_attributes_resp, resp_cb_data);
 741         if (FALSE == ret) {
 742                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 743
 744                 /* Free response callback data */
 745                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 746
 747                 /* Send failure response */
 748                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 749
 750                 return TRUE;
 751         }
 752
 753         return TRUE;
 754 }
 755
 756 static void on_zclglobal_control_discover_attributes_extended_resp(ZigBeeServiceInterface *service_interface,
 757         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 758 {
 759         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 760                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 761
 762         NOT_USED(cb_data);
 763         NOT_USED(service_interface);
 764         NOT_USED(request_id);
 765         NOT_USED(resp_data);
 766         NOT_USED(resp_data_len);
 767 }
 768
 769 static gboolean on_zclglobal_control_discover_attributes_extended(ZigbeeZcl_global_control *zclglobal_control_object,
 770         GDBusMethodInvocation *invocation,
 771         gshort node_id,
 772         gchar dest_ep,
 773         gchar zcl_frame_ctrl,
 774         gshort cluster_id,
 775         gshort start_attr,
 776         gchar max,
 777         gpointer user_data)
 778 {
 779         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 780         ZigbeeZclGlobalControlDiscoverAttributesExtended_t req;
 781         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 782
 783         gboolean ret;
 784
 785         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
 786
 787         /* Update request structure */
 788         req.node_id = node_id;
 789         req.dest_ep = dest_ep;
 790         req.zcl_frame_ctrl = zcl_frame_ctrl;
 791         req.cluster_id = cluster_id;
 792         req.start_attribute = start_attr;
 793         req.max = max;
 794
 795         /* Allocate response callback data */
 796         resp_cb_data =
 797                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 798                         invocation, NULL, 0);
 799         if (NULL == resp_cb_data) {
 800                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 801
 802                 /* Send failure response */
 803                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 804
 805                 return TRUE;
 806         }
 807
 808         /* Dispatch request */
 809         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 810                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 811                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED,
 812                 &req, sizeof(req),
 813                 on_zclglobal_control_discover_attributes_extended_resp, resp_cb_data);
 814         if (FALSE == ret) {
 815                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 816
 817                 /* Free response callback data */
 818                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 819
 820                 /* Send failure response */
 821                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 822
 823                 return TRUE;
 824         }
 825
 826         return TRUE;
 827 }
 828
 829 static void on_zclglobal_control_discover_commands_received_resp(ZigBeeServiceInterface *service_interface,
 830         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 831 {
 832         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 833                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 834
 835         NOT_USED(cb_data);
 836         NOT_USED(service_interface);
 837         NOT_USED(request_id);
 838         NOT_USED(resp_data);
 839         NOT_USED(resp_data_len);
 840 }
 841
 842 static gboolean on_zclglobal_control_discover_commands_received(ZigbeeZcl_global_control *zclglobal_control_object,
 843         GDBusMethodInvocation *invocation,
 844         gshort node_id,
 845         gchar dest_ep,
 846         gchar zcl_frame_ctrl,
 847         gshort cluster_id,
 848         gshort start_attr,
 849         gchar max,
 850         gpointer user_data)
 851 {
 852         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 853         ZigbeeZclGlobalControlDiscoverCommandsReceived_t req;
 854         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 855
 856         gboolean ret;
 857
 858         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
 859
 860         /* Update request structure */
 861         req.node_id = node_id;
 862         req.dest_ep = dest_ep;
 863         req.zcl_frame_ctrl = zcl_frame_ctrl;
 864         req.cluster_id = cluster_id;
 865         req.start_attribute = start_attr;
 866         req.max = max;
 867
 868         /* Allocate response callback data */
 869         resp_cb_data =
 870                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 871                         invocation, NULL, 0);
 872         if (NULL == resp_cb_data) {
 873                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 874
 875                 /* Send failure response */
 876                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 877
 878                 return TRUE;
 879         }
 880
 881         /* Dispatch request */
 882         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 883                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 884                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED,
 885                 &req, sizeof(req),
 886                 on_zclglobal_control_discover_commands_received_resp, resp_cb_data);
 887         if (FALSE == ret) {
 888                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 889
 890                 /* Free response callback data */
 891                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 892
 893                 /* Send failure response */
 894                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 895
 896                 return TRUE;
 897         }
 898
 899         return TRUE;
 900 }
 901
 902 static void on_zclglobal_control_discover_commands_generated_resp(ZigBeeServiceInterface *service_interface,
 903         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 904 {
 905         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 906                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 907
 908         NOT_USED(cb_data);
 909         NOT_USED(service_interface);
 910         NOT_USED(request_id);
 911         NOT_USED(resp_data);
 912         NOT_USED(resp_data_len);
 913 }
 914
 915 static gboolean on_zclglobal_control_discover_commands_generated(ZigbeeZcl_global_control *zclglobal_control_object,
 916         GDBusMethodInvocation *invocation,
 917         gshort node_id,
 918         gchar dest_ep,
 919         gchar zcl_frame_ctrl,
 920         gshort cluster_id,
 921         gshort start_attr,
 922         gchar max,
 923         gpointer user_data)
 924 {
 925         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 926         ZigbeeZclGlobalControlDiscoverCommandsGenerated_t req;
 927         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 928
 929         gboolean ret;
 930
 931         memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
 932
 933         /* Update request structure */
 934         req.node_id = node_id;
 935         req.dest_ep = dest_ep;
 936         req.zcl_frame_ctrl = zcl_frame_ctrl;
 937         req.cluster_id = cluster_id;
 938         req.start_attribute = start_attr;
 939         req.max = max;
 940
 941         /* Allocate response callback data */
 942         resp_cb_data =
 943                 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
 944                         invocation, NULL, 0);
 945         if (NULL == resp_cb_data) {
 946                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 947
 948                 /* Send failure response */
 949                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 950
 951                 return TRUE;
 952         }
 953
 954         /* Dispatch request */
 955         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 956                 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
 957                 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED,
 958                 &req, sizeof(req),
 959                 on_zclglobal_control_discover_commands_generated_resp, resp_cb_data);
 960         if (FALSE == ret) {
 961                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 962
 963                 /* Free response callback data */
 964                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 965
 966                 /* Send failure response */
 967                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 968
 969                 return TRUE;
 970         }
 971
 972         return TRUE;
 973 }
 974
 975 gboolean zigbee_service_dbus_interface_zcl_global_control_init(ZigBeeServiceInterface *service_interface,
 976         ZigbeeObjectSkeleton *zigbee_object)
 977 {
 978         ZigbeeZcl_global_control *zclglobal_control_object;
 979
 980         if (NULL == service_interface) {
 981                 Z_LOGE("service_interface is NULL");
 982                 return FALSE;
 983         }
 984
 985         zclglobal_control_object = zigbee_zcl_global_control_skeleton_new();
 986         zigbee_object_skeleton_set_zcl_global_control(zigbee_object, zclglobal_control_object);
 987         g_object_unref(zclglobal_control_object);
 988
 989         Z_LOGI("zclglobal_control_object: [%p]", zclglobal_control_object);
 990
 991         /*
 992          * Register signal handlers for 'zclglobal_control' interface
 993          */
 994         g_signal_connect(zclglobal_control_object,
 995                 "handle-read-attributes-req",
 996                 G_CALLBACK(on_zclglobal_control_read_attributes_req), service_interface);
 997
 998         g_signal_connect(zclglobal_control_object,
 999                 "handle-write-attributes-req",
1000                 G_CALLBACK(on_zclglobal_control_write_attributes_req), service_interface);
1001
1002         g_signal_connect(zclglobal_control_object,
1003                 "handle-write-attributes-undivided-req",
1004                 G_CALLBACK(on_zclglobal_control_write_attributes_undivided_req), service_interface);
1005
1006         g_signal_connect(zclglobal_control_object,
1007                 "handle-write-attributes-no-resp",
1008                 G_CALLBACK(on_zclglobal_control_write_attributes_no_resp), service_interface);
1009
1010         g_signal_connect(zclglobal_control_object,
1011                 "handle-write-attributes-structured",
1012                 G_CALLBACK(on_zclglobal_control_write_attributes_structured), service_interface);
1013
1014         g_signal_connect(zclglobal_control_object,
1015                 "handle-read-attributes-structured",
1016                 G_CALLBACK(on_zclglobal_control_read_attributes_structured), service_interface);
1017
1018         g_signal_connect(zclglobal_control_object,
1019                 "handle-configure-reporting-req",
1020                 G_CALLBACK(on_zclglobal_control_configure_reporting_req), service_interface);
1021
1022         g_signal_connect(zclglobal_control_object,
1023                 "handle-read-configure-reporting",
1024                 G_CALLBACK(on_zclglobal_control_read_configure_reporting), service_interface);
1025
1026         g_signal_connect(zclglobal_control_object,
1027                 "handle-discover-attributes",
1028                 G_CALLBACK(on_zclglobal_control_discover_attributes), service_interface);
1029
1030         g_signal_connect(zclglobal_control_object,
1031                 "handle-discover-attributes-extended",
1032                 G_CALLBACK(on_zclglobal_control_discover_attributes_extended), service_interface);
1033
1034         g_signal_connect(zclglobal_control_object,
1035                 "handle-discover-commands-received",
1036                 G_CALLBACK(on_zclglobal_control_discover_commands_received), service_interface);
1037
1038         g_signal_connect(zclglobal_control_object,
1039                 "handle-discover-commands-generated",
1040                 G_CALLBACK(on_zclglobal_control_discover_commands_generated), service_interface);
1041
1042         return TRUE;
1043 }