lib/zbl-dbus.c

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include <errno.h>
  17 #include <string.h>
  18 #include <stdlib.h>
  19 #include <glib.h>
  20 #include <gio/gio.h>
  21
  22 #include <zb-log.h>
  23 #include <zb-type.h>
  24 #include <zb-utils.h>
  25 #include <zb-error.h>
  26 #include <zb-common.h>
  27 #include <zcl/zb-zcl-type.h>
  28 #include <zdo/zb-zdo-type.h>
  29
  30 #include "zbl.h"
  31 #include "zbl-dbus.h"
  32
  33 #define USE_ASYNC_DBUS_CALL
  34
  35 static int zbl_ref_count;
  36
  37 static GDBusConnection *gdbus_conn = NULL;
  38 static GDBusProxy *manager_gproxy = NULL;
  39 static GDBusProxy *service_gproxy = NULL;
  40 static GDBusProxy *on_off_gproxy = NULL;
  41 static GDBusProxy *door_lock_gproxy = NULL;
  42 static GDBusProxy *level_control_gproxy = NULL;
  43 static GDBusProxy *thermostat_gproxy = NULL;
  44 static GDBusProxy *alarm_gproxy = NULL;
  45 static GDBusProxy *fan_control_gproxy = NULL;
  46 static GDBusProxy *mfglib_gproxy = NULL;
  47 static GDBusProxy *zcl_global_proxy = NULL;
  48 static GDBusProxy *zdo_dev_proxy = NULL;
  49 static GDBusProxy *zcl_basic_proxy = NULL;
  50 static GDBusProxy *zcl_identify_proxy = NULL;
  51 static GDBusProxy *zcl_ias_zone_proxy = NULL;
  52 static GDBusProxy *zcl_poll_control_proxy = NULL;
  53 static GDBusProxy *zcl_group_proxy = NULL;
  54 static GDBusProxy *zcl_scene_proxy = NULL;
  55 static GDBusProxy *zdo_bind_proxy = NULL;
  56 static GDBusProxy *zcl_color_control_proxy = NULL;
  57 static GDBusProxy *custom_gproxy = NULL;
  58
  59 /* command id */
  60 typedef enum {
  61         /* Service */
  62         ZBL_SERVICE_FORM_NETWORK = 0,
  63         ZBL_SERVICE_DISABLE_NETWORK,
  64         /* ZDP except Bind */
  65         ZBL_ZDO_NWK_ADDR_REQ,
  66         ZBL_ZDO_NWK_ADDR_EXT_REQ,
  67         ZBL_ZDO_ACTIVE_EP_REQ,
  68         ZBL_ZDO_SIMPLE_DESC_REQ,
  69         ZBL_ZDO_MATCHED_DESCRIPTOR_REQ,
  70         ZBL_ZDO_COMPLEX_DESC_REQ,
  71         ZBL_ZDO_MGMT_BIND_REQ,
  72         ZBL_ZDO_MGMT_LQI_REQ,
  73         ZBL_ZDO_MGMT_RTG_REQ,
  74         ZBL_ZDO_MGMT_NWK_DISC_REQ,
  75         ZBL_ZDO_MGMT_PERMIT_JOIN_REQ,
  76         ZBL_ZDO_MGMT_LEAVE_REQ,
  77         ZBL_ZDO_NODE_DESC_REQ,
  78         ZBL_ZDO_POWER_DESC_REQ,
  79         ZBL_ZDO_USER_DESC_REQ,
  80         ZBL_ZDO_USER_DESC_SET_REQ,
  81         /* ZDP Bind */
  82         ZBL_ZDO_BIND_REQ,
  83         ZBL_ZDO_UNBIND_REQ,
  84         /* ZCL Global */
  85         ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ,
  86         ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ,
  87         ZBL_ZCL_GLOBAL_CONFIGURE_REPORTING_REQ,
  88         ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ,
  89         ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_STRUCTURED_REQ,
  90         ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ,
  91         ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ,
  92         ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ,
  93         ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ,
  94         /* Custom */
  95         ZBL_CUSTOM_APS_SEND_REQ,
  96         ZBL_CUSTOM_ZCL_SEND_REQ,
  97         ZBL_CUSTOM_LOCAL_SEND_REQ,
  98         /* ZCL Alarm */
  99         ZBL_ZCL_ALARM_GET_ALARM_REQ,
 100         /* ZCL Doorlock */
 101         ZBL_ZCL_DOORLOCK_LOCK_STATE,
 102         /* ZCL Fanmode */
 103         ZBL_ZCL_FANMODE_FAN_MODE_STATE,
 104         /* ZCL Group */
 105         ZBL_ZCL_GROUP_ADD_GROUP_REQ,
 106         ZBL_ZCL_GROUP_VIEW_GROUP_REQ,
 107         ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ,
 108         ZBL_ZCL_GROUP_REMOVE_GROUP_REQ,
 109         /* ZCL Identify */
 110         ZBL_ZCL_IDENTIFY_QUERY_REQ,
 111         /* ZCL On/Off */
 112         ZBL_ZCL_ON_OFF_GET_ON_OFF_STATE,
 113         /* ZCL Pollcontrol */
 114         ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ,
 115         /* ZCL Scene */
 116         ZBL_ZCL_SCENE_ADD_SCENE_REQ,
 117         ZBL_ZCL_SCENE_VIEW_SCENE_REQ,
 118         ZBL_ZCL_SCENE_REMOVE_SCENE_REQ,
 119         ZBL_ZCL_SCENE_STORE_SCENE_REQ,
 120         ZBL_ZCL_SCENE_REMOVE_ALL_SCENE_REQ,
 121         ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ,
 122         /* ZCL Thermostat */
 123         ZBL_ZCL_THERMOSTAT_GET_LOCAL_TEMP,
 124 } zbl_command_id_e;
 125
 126 typedef struct {
 127         bool found;
 128         void *cb;
 129         void *userdata;
 130         unsigned int sid;
 131         int tid;
 132 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
 133         void *global_cmd;
 134         void *handle;
 135 #endif
 136         zbl_command_id_e cid;
 137 } zbl_req_cb_s;
 138
 139 #define ZCL_REPORTING_DIRECTION_REPORTED 0x00
 140 #define ZCL_REPORTING_DIRECTION_RECEIVED 0x01
 141
 142 static GDBusConnection *_zbl_get_connection(void)
 143 {
 144         GError *error = NULL;
 145
 146         return g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 147 }
 148
 149 static GDBusProxy *_zbl_get_manager_proxy(void)
 150 {
 151         GDBusProxy *proxy = NULL;
 152         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 153
 154         if (NULL == manager_gproxy) {
 155                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 156                         ZIGBEE_SERVER_NAME, ZIGBEE_DBUS_OBJPATH, ZIGBEE_MANAGER_INTERFACE,
 157                         NULL, NULL);
 158         } else
 159                 proxy = manager_gproxy;
 160
 161         return proxy;
 162 }
 163
 164 static GDBusProxy *_zbl_get_service_proxy(void)
 165 {
 166         GDBusProxy *proxy = NULL;
 167         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 168
 169         if (NULL == service_gproxy) {
 170                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 171                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_SERVICE_INTERFACE,
 172                         NULL, NULL);
 173         } else
 174                 proxy = service_gproxy;
 175
 176         return proxy;
 177 }
 178
 179 static GDBusProxy *_zbl_get_on_off_proxy(void)
 180 {
 181         GDBusProxy *proxy = NULL;
 182         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 183
 184         if (NULL == on_off_gproxy) {
 185                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 186                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 187                         ZIGBEE_ZCL_ON_OFF_INTERFACE, NULL, NULL);
 188         } else
 189                 proxy = on_off_gproxy;
 190
 191         return proxy;
 192 }
 193
 194 static GDBusProxy *_zbl_get_door_lock_proxy(void)
 195 {
 196         GDBusProxy *proxy = NULL;
 197         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 198
 199         if (NULL == door_lock_gproxy) {
 200                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 201                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 202                         ZIGBEE_ZCL_DOOR_LOCK_INTERFACE, NULL, NULL);
 203         } else
 204                 proxy = door_lock_gproxy;
 205
 206         return proxy;
 207 }
 208
 209 static GDBusProxy *_zbl_get_level_control_proxy(void)
 210 {
 211         GDBusProxy *proxy = NULL;
 212         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 213
 214         if (NULL == level_control_gproxy) {
 215                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 216                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 217                         ZIGBEE_ZCL_LEVEL_CONTROL_INTERFACE, NULL, NULL);
 218         } else
 219                 proxy = level_control_gproxy;
 220
 221         return proxy;
 222 }
 223
 224 static GDBusProxy *_zbl_get_thermostat_proxy(void)
 225 {
 226         GDBusProxy *proxy = NULL;
 227         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 228
 229         if (NULL == thermostat_gproxy) {
 230                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 231                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 232                         ZIGBEE_ZCL_THERMOSTAT_INTERFACE, NULL, NULL);
 233         } else
 234                 proxy = thermostat_gproxy;
 235
 236         return proxy;
 237 }
 238
 239 static GDBusProxy *_zbl_get_alarm_proxy(void)
 240 {
 241         GDBusProxy *proxy = NULL;
 242         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 243
 244         if (NULL == alarm_gproxy) {
 245                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 246                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZCL_ALARM_INTERFACE,
 247                         NULL, NULL);
 248         } else
 249                 proxy = alarm_gproxy;
 250
 251         return proxy;
 252 }
 253
 254 static GDBusProxy *_zbl_get_fan_control_proxy(void)
 255 {
 256         GDBusProxy *proxy = NULL;
 257         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 258
 259         if (NULL == fan_control_gproxy) {
 260                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 261                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 262                         ZIGBEE_ZCL_FAN_CONTROL_INTERFACE, NULL, NULL);
 263         } else
 264                 proxy = fan_control_gproxy;
 265
 266         return proxy;
 267 }
 268
 269 static GDBusProxy *_zbl_get_mfglib_proxy(void)
 270 {
 271         GDBusProxy *proxy = NULL;
 272         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 273
 274         if (NULL == mfglib_gproxy) {
 275                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 276                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 277                         ZIGBEE_MFGLIB_CONTROL_INTERFACE, NULL, NULL);
 278         } else
 279                 proxy = mfglib_gproxy;
 280
 281         return proxy;
 282 }
 283
 284 static GDBusProxy *_zbl_get_zcl_global_proxy(void)
 285 {
 286         GDBusProxy *proxy = NULL;
 287         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 288
 289         if (NULL == zcl_global_proxy) {
 290                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 291                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 292                         ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, NULL, NULL);
 293         } else
 294                 proxy = zcl_global_proxy;
 295
 296         return proxy;
 297 }
 298
 299 static GDBusProxy *_zbl_get_zdo_dev_proxy(void)
 300 {
 301         GDBusProxy *proxy = NULL;
 302         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 303
 304         if (NULL == zdo_dev_proxy) {
 305                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 306                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 307                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE, NULL, NULL);
 308         } else
 309                 proxy = zdo_dev_proxy;
 310
 311         return proxy;
 312 }
 313
 314 static GDBusProxy *_zbl_get_basic_proxy(void)
 315 {
 316         GDBusProxy *proxy = NULL;
 317         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 318
 319         if (NULL == zcl_basic_proxy) {
 320                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 321                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZCL_BASIC_INTERFACE,
 322                         NULL, NULL);
 323         } else
 324                 proxy = zcl_basic_proxy;
 325
 326         return proxy;
 327 }
 328
 329 static GDBusProxy *_zbl_get_identify_proxy(void)
 330 {
 331         GDBusProxy *proxy = NULL;
 332         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 333
 334         if (NULL == zcl_identify_proxy) {
 335                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 336                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 337                         ZIGBEE_ZCL_IDENTIFY_INTERFACE, NULL, NULL);
 338         } else
 339                 proxy = zcl_identify_proxy;
 340
 341         return proxy;
 342 }
 343
 344 static GDBusProxy *_zbl_get_ias_zone_proxy(void)
 345 {
 346         GDBusProxy *proxy = NULL;
 347         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 348
 349         if (NULL == zcl_ias_zone_proxy) {
 350                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 351                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 352                         ZIGBEE_ZCL_IAS_ZONE_INTERFACE, NULL, NULL);
 353         } else
 354                 proxy = zcl_ias_zone_proxy;
 355
 356         return proxy;
 357 }
 358
 359 static GDBusProxy *_zbl_get_poll_control_proxy(void)
 360 {
 361         GDBusProxy *proxy = NULL;
 362         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 363
 364         if (NULL == zcl_poll_control_proxy) {
 365                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 366                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 367                         ZIGBEE_ZCL_POLL_CONTROL_INTERFACE, NULL, NULL);
 368         } else
 369                 proxy = zcl_poll_control_proxy;
 370
 371         return proxy;
 372 }
 373
 374 static GDBusProxy *_zbl_get_group_proxy(void)
 375 {
 376         GDBusProxy *proxy = NULL;
 377         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 378
 379         if (NULL == zcl_group_proxy) {
 380                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 381                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZCL_GROUP_INTERFACE,
 382                         NULL, NULL);
 383         } else
 384                 proxy = zcl_group_proxy;
 385
 386         return proxy;
 387 }
 388
 389 static GDBusProxy *_zbl_get_scene_proxy(void)
 390 {
 391         GDBusProxy *proxy = NULL;
 392         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 393
 394         if (NULL == zcl_scene_proxy) {
 395                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 396                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZCL_SCENE_INTERFACE,
 397                         NULL, NULL);
 398         } else
 399                 proxy = zcl_scene_proxy;
 400
 401         return proxy;
 402 }
 403
 404 static GDBusProxy *_zbl_get_zdo_bind_proxy(void)
 405 {
 406         GDBusProxy *proxy = NULL;
 407         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 408
 409         if (NULL == zdo_bind_proxy) {
 410                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 411                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_ZDO_BIND_INTERFACE,
 412                         NULL, NULL);
 413         } else
 414                 proxy = zdo_bind_proxy;
 415
 416         return proxy;
 417 }
 418
 419 static GDBusProxy *_zbl_get_color_control_proxy(void)
 420 {
 421         GDBusProxy *proxy = NULL;
 422         RETVM_IF(NULL == gdbus_conn, NULL, "Connection Object is invalid");
 423
 424         if (NULL == zcl_color_control_proxy) {
 425                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 426                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH,
 427                         ZIGBEE_ZCL_COLOR_CONTROL_INTERFACE, NULL, NULL);
 428         } else
 429                 proxy = zcl_color_control_proxy;
 430
 431         return proxy;
 432 }
 433
 434 static GDBusProxy *_zbl_get_custom_gproxy(void)
 435 {
 436         GDBusProxy *proxy = NULL;
 437         RETVM_IF(NULL == gdbus_conn, NULL, "Custom Object is invalid");
 438
 439         if (NULL == custom_gproxy) {
 440                 proxy = g_dbus_proxy_new_sync(gdbus_conn, G_DBUS_PROXY_FLAGS_NONE, NULL,
 441                         ZIGBEE_SERVER_NAME, ZIGBEE_CONTROL_OBJECT_PATH, ZIGBEE_CUSTOM_INTERFACE,
 442                         NULL, NULL);
 443         } else
 444                 proxy = custom_gproxy;
 445
 446         return proxy;
 447 }
 448
 449 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
 450 static gint _global_compare_func(gconstpointer a, gconstpointer b)
 451 {
 452         const zbl_req_cb_s *left = (const zbl_req_cb_s*)a;
 453         const zbl_req_cb_s *right = (const zbl_req_cb_s*)b;
 454         zb_event_global_default_rsp_s *left_data = NULL;
 455         zb_event_global_default_rsp_s *right_data = NULL;
 456
 457         if (NULL == left || NULL == left->global_cmd)
 458                 return -1;
 459         if (NULL == right || NULL == right->global_cmd)
 460                 return 1;
 461
 462         left_data = left->global_cmd;
 463         right_data = right->global_cmd;
 464
 465         if (left_data->ep > right_data->ep)
 466                 return 1;
 467         else if (left_data->ep < right_data->ep)
 468                 return -1;
 469
 470         if (left_data->cluster_id > right_data->cluster_id)
 471                 return 1;
 472         else if (left_data->cluster_id < right_data->cluster_id)
 473                 return -1;
 474
 475         if (left_data->command_id > right_data->command_id)
 476                 return 1;
 477         else if (left_data->command_id < right_data->command_id)
 478                 return -1;
 479
 480         /* endpoint, cluster_id and command_id are equal */
 481         return 0;
 482 }
 483
 484 static void _zbl_register_global_req(zigbee_h handle, zbl_req_cb_s *container)
 485 {
 486         GList *list = NULL;
 487         GList *item = NULL;
 488
 489         if (NULL == handle || NULL == container)
 490                 return;
 491
 492         list = handle->global_cmd_req;
 493
 494         /* Insert item if not exists */
 495         DBG("Insert global cmd info");
 496         if (list) {
 497                 item = g_list_find_custom(list, container, _global_compare_func);
 498                 if (NULL != item)
 499                         handle->global_cmd_req = g_list_append(list, container);
 500         } else
 501                 handle->global_cmd_req = g_list_append(list, container);
 502 }
 503
 504 static void _zbl_deregister_global_req(zigbee_h handle, zbl_req_cb_s *container)
 505 {
 506         GList *list = NULL;
 507         GList *item = NULL;
 508
 509         if (NULL == handle || NULL == container)
 510                 return;
 511
 512         list = handle->global_cmd_req;
 513         if (NULL == list)
 514                 return;
 515
 516         /* Remove item if exists */
 517         DBG("Remove global cmd info");
 518         item = g_list_find_custom(list, container, _global_compare_func);
 519         if (NULL != item)
 520                 handle->global_cmd_req = g_list_remove(list, container);
 521 }
 522
 523 static void _zbl_remove_global_req(zigbee_h handle, unsigned char ep,
 524         unsigned short cluster_id, unsigned char command_id)
 525 {
 526         GList *head = NULL;
 527         GList *iter = NULL;
 528         zbl_req_cb_s *ret = NULL;
 529
 530         if (NULL == handle)
 531                 return;
 532
 533         head = handle->global_cmd_req;
 534         iter = head;
 535
 536         while (NULL != iter) {
 537                 GList *next = iter->next;
 538                 zbl_req_cb_s *container = iter->data;
 539                 if (container && container->global_cmd) {
 540                         zb_event_global_default_rsp_s *data = container->global_cmd;
 541
 542                         if (data && data->ep == ep && data->cluster_id == cluster_id
 543                                         && data->command_id == command_id) {
 544                                 DBG("  Found: ep[%d] cluster_id[%X] command_id[%X] / sid[%d]",
 545                                         ep, cluster_id, command_id, container->sid);
 546                                 ret = container;
 547                                 break;
 548                         }
 549                 }
 550                 iter = next;
 551         }
 552
 553         if (ret) {
 554                 if (ret->sid)
 555                         g_dbus_connection_signal_unsubscribe(gdbus_conn, ret->sid);
 556
 557                 if (ret->tid) {
 558                         g_source_remove(ret->tid);
 559                         DBG("tid=%d removed");
 560                         ret->tid = 0;
 561                 }
 562
 563                 _zbl_deregister_global_req(handle, ret);
 564         }
 565
 566 }
 567 #endif /* ZB_FEATURE_GLOBAL_RSP_SYNC */
 568
 569 static void _zbl_signal_handler(GDBusConnection *connection,
 570                 const gchar *sender_name, const gchar *object_path, const gchar *interface_name,
 571                 const gchar *signal_name, GVariant *parameters, gpointer user_data)
 572 {
 573         zigbee_h container = (zigbee_h)user_data;
 574         RETM_IF(NULL == container, "container is null");
 575         RETM_IF(NULL == container->event_handler, "event_handler is null");
 576         DBG("%s signal received", signal_name);
 577
 578         if (g_strcmp0(signal_name, "service_enabled") == 0) {
 579                 gboolean enabled;
 580                 g_variant_get(parameters, "(b)", &enabled);
 581
 582                 zb_event_data_s ev;
 583                 ev.data.enable = calloc(1, sizeof(zb_event_enable_s));
 584                 RETM_IF(NULL == ev.data.enable, "Failed to memory allocation !");
 585
 586                 ev.data.enable->status = (unsigned char)enabled;
 587                 container->event_handler(0, NULL, ZB_ZDP_ENABLE_EVENT, ev);
 588                 free(ev.data.enable);
 589         } else if (g_strcmp0(signal_name, "form_network_done") == 0) {
 590                 nwk_addr pan_id;
 591                 g_variant_get(parameters, "(q)", &pan_id);
 592
 593                 zb_event_data_s ev;
 594                 ev.data.form_network = calloc(1, sizeof(zb_event_form_network_s));
 595                 RETM_IF(NULL == ev.data.form_network, "Failed to memory allocation !");
 596
 597                 memcpy(&ev.data.form_network->pan_id, &pan_id, sizeof(nwk_addr));
 598                 container->event_handler(pan_id, NULL, ZB_ZDP_FORM_NETWORK_DONE, ev);
 599                 free(ev.data.form_network);
 600         } else if (g_strcmp0(signal_name, "child_joined") == 0) {
 601                 nwk_addr addr16;
 602                 ieee_addr addr64;
 603                 unsigned char count;
 604                 unsigned char ep[10];
 605                 unsigned char value;
 606
 607                 int j = 0;
 608                 GVariantIter *iter1 = NULL;
 609                 GVariantIter *iter2 = NULL;
 610
 611                 g_variant_get(parameters, "(a(y)ya(y)q)", &iter1, &count, &iter2, &addr16);
 612                 while (g_variant_iter_loop(iter1, "(y)", &value)) {
 613                         addr64[j] = value;
 614                         j++;
 615                 }
 616                 if (NULL != iter1)
 617                         g_variant_iter_free(iter1);
 618
 619                 j = 0;
 620                 while (g_variant_iter_loop(iter2, "(y)", &value)) {
 621                         ep[j] = value;
 622                         j++;
 623                 }
 624                 if (NULL != iter2)
 625                         g_variant_iter_free(iter2);
 626
 627                 zb_event_data_s ev;
 628                 ev.data.join = calloc(1, sizeof(zb_event_join_s));
 629                 RETM_IF(NULL == ev.data.join, "Failed to memory allocation !");
 630
 631                 ev.data.join->count = count;
 632                 memcpy(ev.data.join->ep, ep, count);
 633                 container->event_handler(addr16, addr64, ZB_ZDP_JOIN_EVENT, ev);
 634                 free(ev.data.join);
 635         } else if (g_strcmp0(signal_name, "child_rejoined") == 0) {
 636                 ieee_addr addr64;
 637                 unsigned char value;
 638
 639                 int j = 0;
 640                 GVariantIter *iter = NULL;
 641
 642                 g_variant_get(parameters, "(a(y))", &iter);
 643                 while (g_variant_iter_loop(iter, "(y)", &value)) {
 644                         addr64[j] = value;
 645                         j++;
 646                 }
 647                 if (NULL != iter)
 648                         g_variant_iter_free(iter);
 649
 650                 zb_event_data_s ev;
 651                 memset(&ev, 0, sizeof(zb_event_data_s));
 652                 container->event_handler(0, addr64, ZB_ZDP_REJOIN_EVENT, ev);
 653         } else if (g_strcmp0(signal_name, "child_left") == 0) {
 654                 int j = 0;
 655                 ieee_addr addr64;
 656                 GVariantIter *iter = NULL;
 657                 unsigned char value, status;
 658
 659                 g_variant_get(parameters, "(a(y)y)", &iter, &status);
 660                 while (g_variant_iter_loop(iter, "(y)", &value)) {
 661                         addr64[j] = value;
 662                         j++;
 663                 }
 664                 if (NULL != iter)
 665                         g_variant_iter_free(iter);
 666
 667                 zb_event_data_s ev;
 668                 ev.data.child_left = calloc(1, sizeof(zb_event_child_left_s));
 669                 RETM_IF(NULL == ev.data.child_left, "Failed to memory allocation !");
 670
 671                 ev.data.child_left->status = status;
 672                 container->event_handler(0, addr64, ZB_ZDP_CHILD_LEFT, ev);
 673                 free(ev.data.child_left);
 674         } else if (g_strcmp0(signal_name, "leave_network_done") == 0) {
 675                 nwk_addr addr16;
 676                 g_variant_get(parameters, "(q)", &addr16);
 677
 678                 zb_event_data_s ev;
 679                 memset(&ev, 0, sizeof(zb_event_data_s));
 680                 container->event_handler(addr16, NULL, ZB_ZDP_LEAVE_DONE_EVENT, ev);
 681         } else if (!g_strcmp0(signal_name, "zcl_global_default_response")) {
 682                 nwk_addr addr16;
 683                 unsigned char ep;
 684                 unsigned short cluster_id;
 685                 unsigned char command_id;
 686                 unsigned char status;
 687
 688                 g_variant_get(parameters, "(qyqyy)",  &addr16, &ep, &cluster_id, &command_id, &status);
 689
 690                 zb_event_data_s ev;
 691                 ev.data.global_default_rsp = calloc(1, sizeof(zb_event_global_default_rsp_s));
 692                 RETM_IF(NULL == ev.data.global_default_rsp, "Failed to memory allocation !");
 693
 694                 ev.data.global_default_rsp->ep = ep;
 695                 ev.data.global_default_rsp->cluster_id = cluster_id;
 696                 ev.data.global_default_rsp->command_id = command_id;
 697                 ev.data.global_default_rsp->status = status;
 698
 699 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
 700                 /* If there is global request already, remove that. */
 701                 if (0x00 != status)
 702                         _zbl_remove_global_req(container, ep, cluster_id, command_id);
 703 #endif
 704
 705                 container->event_handler(addr16, NULL, ZB_ZCL_GLOBAL_DEFAULT_RSP_EVENT, ev);
 706                 free(ev.data.global_default_rsp);
 707         } else if (!g_strcmp0(signal_name, "alarm_count")) {
 708                 unsigned short alarm_count;
 709                 g_variant_get(parameters, "(q)", &alarm_count);
 710
 711                 zb_event_data_s ev;
 712                 ev.data.alarm = calloc(1, sizeof(zb_event_alarm_s));
 713                 RETM_IF(NULL == ev.data.alarm, "Failed to memory allocation !");
 714
 715                 ev.data.alarm->count = alarm_count;
 716                 container->event_handler(0, NULL, ZB_ZCL_ALARM_EVENT, ev);
 717                 free(ev.data.alarm);
 718         } else if (!g_strcmp0(signal_name, "report_attr_handler_rsp")) {
 719                 nwk_addr addr16;
 720                 unsigned char ep;
 721                 unsigned char value;
 722                 unsigned short attrData;
 723                 unsigned short cluster_id;
 724                 unsigned char dataType;
 725                 unsigned short data_size;
 726                 int dsizeIndex = 0;
 727                 char dSize[3] = {'\0', '\0'};
 728                 int i = 0, j = 0, records_len;
 729                 GVariantIter *attr_iter = NULL;
 730                 GVariantIter *dataType_iter = NULL;
 731                 GVariantIter *data_iter = NULL;
 732
 733                 attr_report_h *records = NULL;
 734
 735                 g_variant_get(parameters, "(qyqaqayayi)",  &addr16, &ep,
 736                          &cluster_id, &attr_iter, &dataType_iter, &data_iter, &records_len);
 737
 738                 records = calloc(records_len, sizeof(attr_report_h));
 739                 RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
 740                 for (j = 0; j < records_len; j++) {
 741                         records[j] = calloc(1, sizeof(struct attribute_report_s));
 742                         if (NULL == records[j]) {
 743                                 for (i = 0; i < j; i++)
 744                                         free(records[i]);
 745                                 free(records);
 746                                 if (NULL != attr_iter)
 747                                         g_variant_iter_free(attr_iter);
 748                                 if (NULL != dataType_iter)
 749                                         g_variant_iter_free(dataType_iter);
 750                                 if (NULL != data_iter)
 751                                         g_variant_iter_free(data_iter);
 752
 753                                 ERR("calloc() Fail(%d)", errno);
 754                                 return;
 755                         }
 756                 }
 757                 DBG("record_length %d", records_len);
 758
 759                 j = 0;
 760                 while (g_variant_iter_loop(attr_iter, "q", &attrData)
 761                                 && g_variant_iter_loop(dataType_iter, "y", &dataType)) {
 762                         records[j]->id = attrData;
 763                         records[j]->type = dataType;
 764                         DBG("dataType 0x%02x", records[j]->type);
 765                         DBG("AttributeId 0x%04x", records[j]->id);
 766                         j++;
 767                 }
 768                 if (NULL != attr_iter)
 769                         g_variant_iter_free(attr_iter);
 770                 if (NULL != dataType_iter)
 771                         g_variant_iter_free(dataType_iter);
 772
 773                 j = 0;
 774                 while (j < records_len) {
 775                         switch (records[j]->type) {
 776                         /* String */
 777                         case ZB_ZCL_OCTAT_STRING:
 778                         case ZB_ZCL_CHRACTER_STRING:
 779                                 g_variant_iter_loop(data_iter, "y", &value);
 780                                 data_size = value + 1;
 781                                 records[j]->value = calloc(data_size, sizeof(unsigned char));
 782                                 if (NULL == records[j]->value) {
 783                                         for (i = 0; i < j; i++)
 784                                                 free(records[i]->value);
 785                                         for (i = 0; i < records_len; i++)
 786                                                 free(records[i]);
 787                                         free(records);
 788                                         ERR("calloc() Fail(%d)", errno);
 789                                         return;
 790                                 }
 791                                 records[j]->value[dsizeIndex] = value;
 792                                 dsizeIndex++;
 793                                 for (i = dsizeIndex; i < data_size - 2; i++) {
 794                                         g_variant_iter_loop(data_iter, "y", &value);
 795                                         records[j]->value[i] = value;
 796                                 }
 797                                 if (NULL != data_iter)
 798                                         g_variant_iter_free(data_iter);
 799                                 break;
 800                         case ZB_ZCL_LONG_OCTAT_STRING:
 801                         case ZB_ZCL_LONG_CHRACTER_STRING:
 802                                 g_variant_iter_loop(data_iter, "y", &value);
 803                                 dSize[0] = value;
 804                                 g_variant_iter_loop(data_iter, "y", &value);
 805                                 dSize[1] =  value;
 806                                 data_size = dSize[1];
 807                                 data_size = (data_size << 8) | dSize[0];
 808                                 data_size += 2;
 809                                 records[j]->value = calloc(data_size, sizeof(unsigned char));
 810                                 if (NULL == records[j]->value) {
 811                                         for (i = 0; i < j; i++)
 812                                                 free(records[i]->value);
 813                                         for (i = 0; i < records_len; i++)
 814                                                 free(records[i]);
 815                                         free(records);
 816                                         ERR("calloc() Fail(%d)", errno);
 817                                         return;
 818                                 }
 819                                 records[j]->value[dsizeIndex] = dSize[dsizeIndex];
 820                                 dsizeIndex++;
 821                                 records[j]->value[dsizeIndex] = dSize[dsizeIndex];
 822                                 dsizeIndex++;
 823                                 for (i = dsizeIndex; i < data_size - 2; i++) {
 824                                         g_variant_iter_loop(data_iter, "y", &value);
 825                                         records[j]->value[i] = value;
 826                                 }
 827                                 if (NULL != data_iter)
 828                                         g_variant_iter_free(data_iter);
 829                                 break;
 830                         /* Array, set and bag */
 831                         case ZB_ZCL_ARRAY:
 832                         case ZB_ZCL_SET:
 833                         case ZB_ZCL_BAG:
 834                         /* structure */
 835                         case ZB_ZCL_STRUCTURE:
 836                                 ERR("Not supported type = %d", records[i]->type);
 837                                 continue;
 838                         default:
 839                                 data_size = zb_get_data_size(records[j]->type);
 840                                 records[j]->value = calloc(data_size, sizeof(unsigned char));
 841                                 if (NULL == records[j]->value) {
 842                                         for (i = 0; i < j; i++)
 843                                                 free(records[i]->value);
 844                                         for (i = 0; i < records_len; i++)
 845                                                 free(records[i]);
 846                                         free(records);
 847                                         ERR("calloc() Fail(%d)", errno);
 848                                         return;
 849                                 }
 850                                 if (data_size != 0xFF) {
 851                                         for (i = 0; i < data_size; i++) {
 852                                                 g_variant_iter_loop(data_iter, "y", &value);
 853                                                 records[j]->value[i] = value;
 854                                                 DBG("value[%d] 0x%02X", i, records[j]->value[i]);
 855                                         }
 856                                 }
 857                                 if (NULL != data_iter)
 858                                         g_variant_iter_free(data_iter);
 859                         }
 860                         DBG("DataType = 0x%02X Data Size = %d", records[j]->type, data_size);
 861                         j++;
 862                 }
 863
 864                 zb_event_data_s ev;
 865                 ev.data.global_attr_report = calloc(1, sizeof(zb_event_global_attr_report_s));
 866                 if (NULL == ev.data.global_attr_report) {
 867                         ERR("Failed to memory allocation !");
 868                         for (j = 0; j < records_len; j++) {
 869                                 free(records[j]->value);
 870                                 free(records[j]);
 871                         }
 872                         return;
 873                 }
 874
 875                 ev.data.global_attr_report->records = records;
 876                 ev.data.global_attr_report->count = records_len;
 877                 container->event_handler(addr16, NULL, ZB_ZCL_GLOBAL_ATTRIBUTE_REPORT_EVENT, ev);
 878                 for (j = 0; j < records_len; j++) {
 879                         free(records[j]->value);
 880                         free(records[j]);
 881                 }
 882                 free(records);
 883                 free(ev.data.global_attr_report);
 884         } else if (!g_strcmp0(signal_name, "status_change_rpt")) {
 885                 zb_event_data_s ev;
 886                 nwk_addr addr16;
 887                 unsigned char src_ep;
 888                 unsigned char extended_status;
 889                 unsigned short zone_status;
 890                 unsigned short delay;
 891                 unsigned char zone_id;
 892                 g_variant_get(parameters, "(qyqyyq)", &addr16, &src_ep, &zone_status,
 893                         &extended_status, &zone_id, &delay);
 894                 if (0xff == zone_id) {
 895                         ev.data.ias_noti = calloc(1, sizeof(zb_event_ias_noti_s));
 896                         RETM_IF(NULL == ev.data.ias_noti, "Failed to memory allocation !");
 897
 898                         ev.data.ias_noti->src_ep = src_ep;
 899                         ev.data.ias_noti->zone_status = zone_status;
 900                         container->event_handler(addr16, NULL,
 901                                 ZB_ZCL_IAS_ZONE_STATUS_CHANGE_NOTIFICATION_EVENT, ev);
 902
 903                         free(ev.data.ias_noti);
 904                 } else {
 905                         ev.data.ias_extended_noti = calloc(1, sizeof(zb_event_ias_extended_noti_s));
 906                         RETM_IF(NULL == ev.data.ias_extended_noti, "Failed to memory allocation !");
 907
 908                         ev.data.ias_extended_noti->src_ep = src_ep;
 909                         ev.data.ias_extended_noti->zone_status = zone_status;
 910                         ev.data.ias_extended_noti->extended_status = extended_status;
 911                         ev.data.ias_extended_noti->zone_id = zone_id;
 912                         ev.data.ias_extended_noti->delay = delay;
 913                         container->event_handler(addr16, NULL,
 914                                 ZB_ZCL_IAS_ZONE_STATUS_CHANGE_EXTENDED_NOTIFICATION_EVENT, ev);
 915
 916                         free(ev.data.ias_extended_noti);
 917                 }
 918         } else if (!g_strcmp0(signal_name, "enroll_request")) {
 919                 nwk_addr addr16;
 920                 unsigned char src_ep;
 921                 unsigned short zone_type;
 922                 unsigned char mfg_code;
 923                 zb_event_data_s ev;
 924                 ev.data.ias_enroll_request = calloc(1, sizeof(zb_event_ias_enroll_request_s));
 925                 RETM_IF(NULL == ev.data.ias_enroll_request, "Failed to memory allocation !");
 926
 927                 g_variant_get(parameters, "(qyqy)", &addr16, &src_ep, &zone_type, &mfg_code);
 928                 ev.data.ias_enroll_request->src_ep = src_ep;
 929                 ev.data.ias_enroll_request->zone_type = zone_type;
 930                 ev.data.ias_enroll_request->mfg_code = mfg_code;
 931                 container->event_handler(addr16, NULL, ZB_ZCL_IAS_ZONE_ENROLL_REQUEST_EVENT, ev);
 932                 free(ev.data.ias_enroll_request);
 933         } else
 934                 ERR("Can't handle this signal=%s", signal_name);
 935         return;
 936 }
 937
 938 static void _zbl_dbus_unsubscribe_signal(GList *sub_ids)
 939 {
 940         GDBusConnection *conn = _zbl_get_connection();
 941         if (NULL == conn || NULL == sub_ids)
 942                 return;
 943
 944         while (sub_ids) {
 945                 g_dbus_connection_signal_unsubscribe(conn, GPOINTER_TO_UINT(sub_ids));
 946                 sub_ids = g_list_remove(sub_ids, sub_ids);
 947         }
 948 }
 949
 950 static int _zbl_dbus_subscribe_signal(zigbee_h handle)
 951 {
 952         unsigned int id;
 953
 954         /* Section 1. Subscribe ZDO signal */
 955         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_SERVICE_INTERFACE,
 956                                                 "service_enabled", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
 957                                                 G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
 958         if (0 == id) {
 959                 ERR("g_dbus_connection_signal_subscribe(service_enabled) Fail(%d)", errno);
 960                 return ZIGBEE_ERROR_IO_ERROR;
 961         }
 962         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
 963         DBG("subscribed for service_enabled signal %d", id);
 964
 965         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_SERVICE_INTERFACE,
 966                                                 "child_joined", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
 967                                                 G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
 968         if (0 == id) {
 969                 ERR("g_dbus_connection_signal_subscribe(child_rejoined) Fail(%d)\n", errno);
 970                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
 971                 return ZIGBEE_ERROR_IO_ERROR;
 972         }
 973         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
 974         DBG("subscribed for child_joined signal %d", id);
 975
 976         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_SERVICE_INTERFACE,
 977                                                 "child_rejoined", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
 978                                                 G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
 979         if (0 == id) {
 980                 ERR("g_dbus_connection_signal_subscribe(child_rejoined) Fail(%d)\n", errno);
 981                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
 982                 return ZIGBEE_ERROR_IO_ERROR;
 983         }
 984         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
 985         DBG("subscribed for child_rejoined signal %d", id);
 986
 987         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_SERVICE_INTERFACE,
 988                                                 "child_left", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
 989                                                 G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
 990         if (0 == id) {
 991                 ERR("g_dbus_connection_signal_subscribe(child_left) Fail(%d)\n", errno);
 992                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
 993                 return ZIGBEE_ERROR_IO_ERROR;
 994         }
 995         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
 996         DBG("subscribed for child_left signal %d", id);
 997
 998         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_SERVICE_INTERFACE,
 999                                                 "leave_network_done", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
1000                                                 G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
1001         if (0 == id) {
1002                 ERR("g_dbus_connection_signal_subscribe(leave_network_done) Fail(%d)\n", errno);
1003                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
1004                 return ZIGBEE_ERROR_IO_ERROR;
1005         }
1006         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
1007         DBG("subscribed for leave_network_done signal %d", id);
1008
1009         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_SERVICE_INTERFACE,
1010                                                 "form_network_done", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
1011                                                 G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
1012         if (0 == id) {
1013                 ERR("g_dbus_connection_signal_subscribe(form_network_done) Fail(%d)\n", errno);
1014                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
1015                 return ZIGBEE_ERROR_IO_ERROR;
1016         }
1017         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
1018         DBG("subscribed for form_network_done signal %d", id);
1019
1020         /* Section 3. Subscribe ZCL global command */
1021         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
1022                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "zcl_global_default_response",
1023                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, G_DBUS_CALL_FLAGS_NONE,
1024                 _zbl_signal_handler, handle, NULL);
1025         if (0 == id) {
1026                 ERR("g_dbus_connection_signal_subscribe(zcl_global_default_response) Fail(%d)\n", errno);
1027                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
1028                 return ZIGBEE_ERROR_IO_ERROR;
1029         }
1030         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
1031         DBG("subscribed for zcl_global_default_response signal %d", id);
1032
1033         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
1034                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "report_attr_handler_rsp",
1035                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, G_DBUS_CALL_FLAGS_NONE,
1036                 _zbl_signal_handler, handle, NULL);
1037         if (0 == id) {
1038                 ERR("g_dbus_connection_signal_subscribe(report_attr_handler_rsp) Fail(%d)\n", errno);
1039                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
1040                 return ZIGBEE_ERROR_IO_ERROR;
1041         }
1042         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
1043         DBG("subscribed for report_attr_handler_rsp signal %d", id);
1044
1045         /* Section 2. Subscribe ZCL alarm cluster signal */
1046         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_ALARM_INTERFACE,
1047                                                 "alarm_count", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
1048                                                 G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
1049         if (0 == id) {
1050                 ERR("g_dbus_connection_signal_subscribe(alarm_count) Fail(%d)\n", errno);
1051                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
1052                 return ZIGBEE_ERROR_IO_ERROR;
1053         }
1054         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
1055         DBG("subscribed for alarm_count signal %d", id);
1056
1057         /* Section 3. Subscribe ZCL IAS cluster signal */
1058         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_IAS_ZONE_INTERFACE,
1059                                         "status_change_rpt", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
1060                                         G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
1061         if (0 == id) {
1062                 ERR("g_dbus_connection_signal_subscribe(status_change_rpt) Fail(%d)\n", errno);
1063                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
1064                 return ZIGBEE_ERROR_IO_ERROR;
1065         }
1066         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
1067         DBG("subscribed for status_change_rpt signal %d", id);
1068
1069         id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL, ZIGBEE_ZCL_IAS_ZONE_INTERFACE,
1070                                                 "enroll_request", ZIGBEE_CONTROL_OBJECT_PATH, NULL,
1071                                                 G_DBUS_CALL_FLAGS_NONE, _zbl_signal_handler, handle, NULL);
1072         if (0 == id) {
1073                 ERR("g_dbus_connection_signal_subscribe(enroll_request) Fail(%d)\n", errno);
1074                 _zbl_dbus_unsubscribe_signal(handle->dbus_sub_ids);
1075                 return ZIGBEE_ERROR_IO_ERROR;
1076         }
1077         handle->dbus_sub_ids = g_list_append(handle->dbus_sub_ids, GUINT_TO_POINTER(id));
1078         DBG("subscribed for enroll_request signal %d", id);
1079
1080         return ZIGBEE_ERROR_NONE;
1081 }
1082
1083 static void _zbl_dbus_name_owner_notify(GObject *object, GParamSpec *pspec,
1084                 gpointer *user_data)
1085 {
1086         GDBusProxy *proxy = G_DBUS_PROXY(object);
1087         gchar *name_owner = g_dbus_proxy_get_name_owner(proxy);
1088         if (name_owner)
1089                 return;
1090         zbl_dbus_stop();
1091 }
1092
1093 static void _zbl_request_cleanup(gpointer data)
1094 {
1095         zbl_req_cb_s *container = data;
1096         RET_IF(NULL == container);
1097
1098         if (container->tid) {
1099                 g_source_remove(container->tid);
1100                 DBG("tid=%d removed");
1101                 container->tid = 0;
1102         }
1103
1104 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
1105         _zbl_deregister_global_req(container->handle, container);
1106 #endif
1107
1108         free(container);
1109 }
1110
1111 static gboolean _zbl_timeout_cb(gpointer p)
1112 {
1113         zbl_req_cb_s *container = (zbl_req_cb_s *)p;
1114
1115         RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL");
1116         RETVM_IF(NULL == p, G_SOURCE_REMOVE, "container is NULL");
1117         RETVM_IF(NULL == container->cb, G_SOURCE_REMOVE, "cb is NULL");
1118         RETVM_IF(true == container->found, G_SOURCE_REMOVE, "cb was alreay handled");
1119
1120         switch (container->cid) {
1121                 /* Service */
1122         case ZBL_SERVICE_FORM_NETWORK: {
1123                 zb_form_network_cb cb = container->cb;
1124                 cb(0x0000, container->userdata);
1125         }
1126         break;
1127         case ZBL_SERVICE_DISABLE_NETWORK: {
1128                 zb_disable_network_cb cb = container->cb;
1129                 cb(0x0000, container->userdata);
1130                 cb(ZB_ZDP_TIMEOUT, container->userdata);
1131         }
1132         break;
1133         /* ZDP except Bind */
1134         case ZBL_ZDO_NWK_ADDR_REQ: {
1135                 zb_zdo_addr_rsp cb = container->cb;
1136                 cb(ZB_ZDP_TIMEOUT, NULL, 0, 0, 0, NULL, container->userdata);
1137         }
1138         break;
1139         case ZBL_ZDO_NWK_ADDR_EXT_REQ: {
1140                 zb_zdo_addr_rsp cb = container->cb;
1141                 cb(ZB_ZDP_TIMEOUT, NULL, 0, 0, 0, NULL, container->userdata);
1142         }
1143         break;
1144         case ZBL_ZDO_ACTIVE_EP_REQ: {
1145                 zb_zdo_active_ep_rsp cb = container->cb;
1146                 cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata);
1147         }
1148         break;
1149         case ZBL_ZDO_SIMPLE_DESC_REQ: {
1150                 zb_zdo_simple_desc_rsp cb = container->cb;
1151                 cb(0, 0, NULL, container->userdata);
1152         }
1153         break;
1154         case ZBL_ZDO_MATCHED_DESCRIPTOR_REQ: {
1155                 zb_zdo_match_desc_rsp cb = container->cb;
1156                 cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata);
1157         }
1158         break;
1159         case ZBL_ZDO_COMPLEX_DESC_REQ: {
1160                 zb_zdo_complex_desc_rsp cb = container->cb;
1161                 cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata);
1162         }
1163         break;
1164         case ZBL_ZDO_MGMT_BIND_REQ: {
1165                 zb_zdo_mgmt_bind_rsp cb = container->cb;
1166                 zb_zdo_binding_table_h *records = NULL;
1167
1168                 records = calloc(1, sizeof(zb_zdo_binding_table_h));
1169                 if (records)
1170                         records[0] = calloc(1, sizeof(struct zb_zdo_binding_table_s));
1171
1172                 cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata);
1173
1174                 free(records[0]);
1175                 free(records);
1176         }
1177         break;
1178         case ZBL_ZDO_MGMT_LQI_REQ: {
1179                 zb_zdo_mgmt_lqi_rsp cb = container->cb;
1180                 zb_zdo_neighbor_table_desc_h *records = NULL;
1181
1182                 records = calloc(1, sizeof(zb_zdo_neighbor_table_desc_h));
1183                 if (records)
1184                         records[0] = calloc(1, sizeof(struct zb_zdo_neighbor_table_desc_s));
1185
1186                 cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata);
1187
1188                 free(records[0]);
1189                 free(records);
1190         }
1191         break;
1192         case ZBL_ZDO_MGMT_RTG_REQ: {
1193                 zb_zdo_mgmt_rtg_rsp cb = container->cb;
1194                 zb_zdo_routing_table_h *records = NULL;
1195
1196                 records = calloc(1, sizeof(zb_zdo_routing_table_h));
1197                 if (records)
1198                         records[0] = calloc(1, sizeof(struct zb_zdo_routing_table_s));
1199
1200                 cb(ZB_ZDP_TIMEOUT, 0, 0, 0, records, container->userdata);
1201
1202                 free(records[0]);
1203                 free(records);
1204         }
1205         break;
1206         case ZBL_ZDO_MGMT_NWK_DISC_REQ: {
1207                 zb_zdo_mgmt_nwk_disc_rsp cb = container->cb;
1208                 zb_zdo_network_list_record_h *records = NULL;
1209                 records = calloc(1, sizeof(zb_zdo_network_list_record_h));
1210                 if (records)
1211                         records[0] = calloc(1, sizeof(struct zb_zdo_network_list_record_s));
1212
1213                 cb(0, 0, 0, 0, records, container->userdata);
1214                 free(records[0]);
1215                 free(records);
1216         }
1217         break;
1218         case ZBL_ZDO_MGMT_PERMIT_JOIN_REQ: {
1219                 zb_zdo_mgmt_permit_joining_rsp cb = container->cb;
1220                 cb(ZB_ZDP_TIMEOUT, container->userdata);
1221         }
1222         break;
1223         case ZBL_ZDO_MGMT_LEAVE_REQ: {
1224                 zb_zdo_mgmt_leave_rsp cb = container->cb;
1225                 cb(ZB_ZDP_TIMEOUT, container->userdata);
1226         }
1227         break;
1228         case ZBL_ZDO_NODE_DESC_REQ: {
1229                 zb_zdo_node_desc_rsp cb = container->cb;
1230                 cb(ZB_ZDP_TIMEOUT, 0, NULL, container->userdata);
1231         }
1232         break;
1233         case ZBL_ZDO_POWER_DESC_REQ: {
1234                 zb_zdo_power_desc_rsp cb = container->cb;
1235                 cb(0, 0, NULL, container->userdata);
1236         }
1237         break;
1238         case ZBL_ZDO_USER_DESC_REQ: {
1239                 zb_zdo_user_desc_rsp cb = container->cb;
1240                 cb(ZB_ZDP_TIMEOUT, 0, 0, NULL, container->userdata);
1241         }
1242         case ZBL_ZDO_USER_DESC_SET_REQ: {
1243                 zb_zdo_user_desc_conf cb = container->cb;
1244                 cb(ZB_ZDP_TIMEOUT, container->userdata);
1245         }
1246         break;
1247         /* ZDP Bind */
1248         case ZBL_ZDO_BIND_REQ: {
1249                 zb_zdo_bind_rsp cb = container->cb;
1250                 cb(ZB_ZDP_TIMEOUT, container->userdata);
1251         }
1252         break;
1253         case ZBL_ZDO_UNBIND_REQ: {
1254                 zb_zdo_unbind_rsp cb = container->cb;
1255                 cb(ZB_ZDP_TIMEOUT, container->userdata);
1256         }
1257         break;
1258         /* Custom */
1259         case ZBL_CUSTOM_APS_SEND_REQ: {
1260                 zb_aps_send_rsp cb = container->cb;
1261                 cb(0, 0, 0, 0, 0, 0, NULL, container->userdata);
1262         } break;
1263         case ZBL_CUSTOM_ZCL_SEND_REQ: {
1264                 zb_zcl_send_rsp cb = container->cb;
1265                 cb(0, 0, 0, 0, 0, 0, NULL, container->userdata);
1266         }
1267         break;
1268         case ZBL_CUSTOM_LOCAL_SEND_REQ: {
1269                 zb_send_to_local_rsp cb = container->cb;
1270                 cb(0, NULL, container->userdata);
1271         }
1272         break;
1273         /* ZCL Global */
1274         case ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ: {
1275                 zb_zcl_global_rsp cb = container->cb;
1276                 cb(0, 0, 0, NULL, 0, container->userdata);
1277         }
1278         break;
1279         case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ: {
1280                 zb_zcl_global_rsp cb = container->cb;
1281                 cb(0, 0, 0, NULL, 0, container->userdata);
1282         }
1283         break;
1284         case ZBL_ZCL_GLOBAL_CONFIGURE_REPORTING_REQ: {
1285                 zb_zcl_global_rsp cb = container->cb;
1286                 cb(0, 0, 0, NULL, 0, container->userdata);
1287         }
1288         break;
1289         case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ: {
1290                 zb_zcl_global_discover_attr_rsp cb = container->cb;
1291                 cb(0, 0, 0, 0, NULL, 0, container->userdata);
1292         }
1293         break;
1294         case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_STRUCTURED_REQ: {
1295                 zb_zcl_global_rsp cb = container->cb;
1296                 cb(0, 0, 0, NULL, 0, container->userdata);
1297         }
1298         break;
1299         case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ: {
1300                 zb_zcl_global_discover_cmds_rsp cb = container->cb;
1301                 cb(0, 0, 0, 0, NULL, 0, container->userdata);
1302         }
1303         break;
1304         case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ: {
1305                 zb_zcl_global_discover_cmds_rsp cb = container->cb;
1306                 cb(0, 0, 0, 0, NULL, 0, container->userdata);
1307         }
1308         break;
1309         case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ: {
1310                 zb_zcl_global_discover_attr_extended_rsp cb = container->cb;
1311                 cb(0, 0, 0, 0, NULL, 0, container->userdata);
1312         }
1313         break;
1314         case ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ: {
1315                 zb_zcl_global_rsp cb = container->cb;
1316                 cb(0, 0, 0, NULL, 0, container->userdata);
1317         }
1318         break;
1319         /* ZCL Alarm */
1320         case ZBL_ZCL_ALARM_GET_ALARM_REQ: {
1321                 zb_zcl_alarm_get_alarm_rsp cb = container->cb;
1322                 cb(ZB_ZCL_TIMEOUT, 0, ZB_ZCL_UNSUP_CLUSTER_COMMAND, 0, 0, 0, container->userdata);
1323         }
1324         break;
1325         /* ZCL Doorlock */
1326         case ZBL_ZCL_DOORLOCK_LOCK_STATE: {
1327                 zb_form_network_cb cb = container->cb;
1328                 cb(0x0000, container->userdata);
1329         }
1330         break;
1331         /* ZCL Fanmode */
1332         case ZBL_ZCL_FANMODE_FAN_MODE_STATE: {
1333                 zb_form_network_cb cb = container->cb;
1334                 cb(0x0000, container->userdata);
1335         }
1336         break;
1337         /* ZCL Group */
1338         case ZBL_ZCL_GROUP_ADD_GROUP_REQ: {
1339                 zb_zcl_group_add_group_rsp cb = container->cb;
1340                 cb(0, 0, 0, 0, container->userdata);
1341         }
1342         break;
1343         case ZBL_ZCL_GROUP_VIEW_GROUP_REQ: {
1344                 zb_zcl_group_view_group_rsp cb = container->cb;
1345                 cb(0, 0, 0, 0, NULL, container->userdata);
1346         }
1347         break;
1348         case ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ: {
1349                 zb_zcl_group_get_group_membership_rsp cb = container->cb;
1350                 cb(0, 0, 0, 0, NULL, container->userdata);
1351         }
1352         break;
1353         case ZBL_ZCL_GROUP_REMOVE_GROUP_REQ: {
1354                 zb_zcl_group_remove_group_rsp cb = container->cb;
1355                 cb(0, 0, 0, 0, container->userdata);
1356         }
1357         break;
1358         /* ZCL Identify */
1359         case ZBL_ZCL_IDENTIFY_QUERY_REQ: {
1360                 zb_zcl_identify_query_cb cb = container->cb;
1361                 cb(0, 0, container->userdata);
1362         }
1363         break;
1364         /* ZCL On/Off */
1365         case ZBL_ZCL_ON_OFF_GET_ON_OFF_STATE: {
1366                 zb_form_network_cb cb = container->cb;
1367                 cb(0x0000, container->userdata);
1368         }
1369         break;
1370         /* ZCL Pollcontrol */
1371         case ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ: {
1372                 zb_zcl_pollctrl_check_in cb = container->cb;
1373                 cb(0, 0, container->userdata);
1374         }
1375         break;
1376         /* ZCL Scene */
1377         case ZBL_ZCL_SCENE_ADD_SCENE_REQ: {
1378                 zb_zcl_scene_add_scene_rsp cb = container->cb;
1379                 cb(0, 0, 0, 0, 0, container->userdata);
1380         }
1381         break;
1382         case ZBL_ZCL_SCENE_VIEW_SCENE_REQ: {
1383                 zb_zcl_scene_view_scene_rsp cb = container->cb;
1384                 cb(0, 0, 0, 0, 0, 0, NULL, NULL, 0, container->userdata);
1385         }
1386         break;
1387         case ZBL_ZCL_SCENE_REMOVE_SCENE_REQ: {
1388                 zb_zcl_scene_remove_scene_rsp cb = container->cb;
1389                 cb(0, 0, 0, 0, 0, container->userdata);
1390         }
1391         break;
1392         case ZBL_ZCL_SCENE_STORE_SCENE_REQ: {
1393                 zb_zcl_scene_store_scene_rsp cb = container->cb;
1394                 cb(0, 0, 0, 0, 0, container->userdata);
1395         }
1396         break;
1397         case ZBL_ZCL_SCENE_REMOVE_ALL_SCENE_REQ: {
1398                 zb_zcl_scene_remove_all_scene_rsp cb = container->cb;
1399                 cb(0, 0, 0, 0, container->userdata);
1400         }
1401         break;
1402         case ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ: {
1403                 zb_zcl_scene_get_scene_membership_rsp cb = container->cb;
1404                 cb(0, 0, 0, 0, 0, 0, NULL, container->userdata);
1405         }
1406         break;
1407         /* ZCL Thermostat */
1408         case ZBL_ZCL_THERMOSTAT_GET_LOCAL_TEMP: {
1409                 zb_form_network_cb cb = container->cb;
1410                 cb(0x0000, container->userdata);
1411         }
1412         break;
1413         default:
1414                 ERR("Unhandled cid = %d", container->cid);
1415         }
1416
1417         container->tid = 0;
1418         g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid);
1419         container->sid = 0;
1420
1421         return G_SOURCE_REMOVE;
1422 }
1423
1424 static void _zbl_response_cb(GDBusConnection *connection,
1425                 const gchar *sender_name, const gchar *object_path, const gchar *interface_name,
1426                 const gchar *signal_name, GVariant *parameters, gpointer user_data)
1427 {
1428         zbl_req_cb_s *container = user_data;
1429         RETM_IF(NULL == container, "container is null");
1430         RETM_IF(NULL == container->cb, "cb is NULL");
1431
1432         container->found = true;
1433         g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid);
1434
1435         switch (container->cid) {
1436                 /* Service */
1437         case ZBL_SERVICE_FORM_NETWORK: {
1438                 zb_form_network_cb cb = container->cb;
1439                 nwk_addr panid;
1440                 g_variant_get(parameters, "(q)", &panid);
1441                 cb(panid, container->userdata);
1442         }
1443         break;
1444         case ZBL_SERVICE_DISABLE_NETWORK: {
1445                 zb_disable_network_cb cb = container->cb;
1446                 unsigned char ret = ZB_ZDP_SUCCESS;
1447                 g_variant_get(parameters, "(y)", &ret);
1448                 cb(ret, container->userdata);
1449         }
1450         break;
1451         /* ZDP except Bind */
1452         case ZBL_ZDO_NWK_ADDR_REQ: {
1453                 zb_zdo_addr_rsp cb = container->cb;
1454
1455                 int j = 0;
1456                 nwk_addr addr16;
1457                 ieee_addr addr64;
1458                 unsigned char status;
1459                 unsigned char num;
1460                 unsigned char start_idx;
1461                 unsigned char value;
1462                 GVariantIter *mac_iter = NULL;
1463
1464                 g_variant_get(parameters, "(ya(y)qyy)", &status, &mac_iter, &addr16, &num, &start_idx);
1465                 while (g_variant_iter_loop(mac_iter, "(y)", &value)) {
1466                         addr64[j] = value;
1467                         j++;
1468                 }
1469
1470                 cb(status, addr64, addr16, num, start_idx, NULL, container->userdata);
1471                 if (NULL != mac_iter)
1472                         g_variant_iter_free(mac_iter);
1473         }
1474         break;
1475         case ZBL_ZDO_NWK_ADDR_EXT_REQ: {
1476                 zb_zdo_addr_rsp cb = container->cb;
1477
1478                 int j = 0;
1479                 nwk_addr addr16;
1480                 ieee_addr addr64;
1481                 unsigned char status;
1482                 unsigned char num;
1483                 unsigned char start_idx;
1484                 unsigned char value;
1485                 GVariantIter *mac_iter = NULL;
1486                 GVariantIter *assoc_iter = NULL;
1487
1488                 g_variant_get(parameters, "(ya(y)qyyaq)", &status, &mac_iter,
1489                         &addr16, &num, &start_idx, &assoc_iter);
1490                 while (g_variant_iter_loop(mac_iter, "(y)", &value)) {
1491                         addr64[j] = value;
1492                         j++;
1493                 }
1494                 if (NULL != mac_iter)
1495                         g_variant_iter_free(mac_iter);
1496                 if (NULL != assoc_iter)
1497                         g_variant_iter_free(assoc_iter);
1498
1499                 cb(status, addr64, addr16, num, start_idx, NULL, container->userdata);
1500         }
1501         break;
1502         case ZBL_ZDO_ACTIVE_EP_REQ: {
1503                 zb_zdo_active_ep_rsp cb = container->cb;
1504
1505                 int j = 0;
1506                 nwk_addr addr16;
1507                 unsigned char status;
1508                 unsigned char count;
1509                 unsigned char value;
1510                 GVariantIter *ep_iter = NULL;
1511                 unsigned char *ep_list;
1512
1513                 g_variant_get(parameters, "(yqa(y)y)", &status, &addr16, &ep_iter, &count);
1514                 ep_list = calloc(count+1, sizeof(unsigned char));
1515                 RETM_IF(NULL == ep_list, "calloc() Fail(%d)", errno);
1516
1517                 while (g_variant_iter_loop(ep_iter, "(y)", &value)) {
1518                         ep_list[j] = value;
1519                         j++;
1520                 }
1521                 if (NULL != ep_iter)
1522                         g_variant_iter_free(ep_iter);
1523
1524                 cb(status, addr16, count, ep_list, container->userdata);
1525                 free(ep_list);
1526         }
1527         break;
1528         case ZBL_ZDO_SIMPLE_DESC_REQ: {
1529                 zb_zdo_simple_desc_rsp cb = container->cb;
1530
1531                 int j = 0;
1532                 int count;
1533                 unsigned short addr16;
1534                 unsigned short value;
1535                 GVariantIter *in_iter = NULL;
1536                 GVariantIter *out_iter = NULL;
1537                 zb_zdo_simple_desc_h records;
1538
1539                 records = calloc(1, sizeof(struct zb_zdo_simple_desc_s));
1540                 RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
1541
1542                 container->found = true;
1543
1544                 g_variant_get(parameters, "(qiyyqqyyaqaq)", &addr16, &count,
1545                                 &records->device_ver,
1546                                 &records->ep, &records->profile_id, &records->device_id,
1547                                 &records->num_of_in_clusters, &records->num_of_out_clusters,
1548                                 &in_iter, &out_iter);
1549 #if 0
1550                 records->in_clusters = calloc(records->num_of_in_clusters, sizeof(unsigned short));
1551                 if (NULL == records->in_clusters) {
1552                         ERR("calloc() Fail(%d)", errno);
1553                         if (NULL != in_iter)
1554                                 g_variant_iter_free(in_iter);
1555                         if (NULL != out_iter)
1556                                 g_variant_iter_free(out_iter);
1557                         return;
1558                 }
1559                 records->out_clusters = calloc(records->num_of_out_clusters, sizeof(unsigned short));
1560                 if (NULL == records->out_clusters) {
1561                         ERR("calloc() Fail(%d)", errno);
1562                         free(records->in_clusters);
1563                         if (NULL != in_iter)
1564                                 g_variant_iter_free(in_iter);
1565                         if (NULL != out_iter)
1566                                 g_variant_iter_free(out_iter);
1567                         return;
1568                 }
1569 #endif
1570                 while (g_variant_iter_loop(in_iter, "q", &value)) {
1571                         records->in_clusters[j] = value;
1572                         j++;
1573                 }
1574                 if (NULL != in_iter)
1575                         g_variant_iter_free(in_iter);
1576
1577                 j = 0;
1578                 while (g_variant_iter_loop(out_iter, "q", &value)) {
1579                         records->out_clusters[j] = value;
1580                         j++;
1581                 }
1582                 if (NULL != out_iter)
1583                         g_variant_iter_free(out_iter);
1584
1585                 DBG("addr16=0x%x, count=%d, records->ep=%d, records->device_id=0x%x",
1586                         addr16, count, records->ep, records->device_id);
1587                 for (j = 0; j < records->num_of_in_clusters; j++)
1588                         DBG("in_clusters[%d] = 0x%x", j, records->in_clusters[j]);
1589                 for (j = 0; j < records->num_of_out_clusters; j++)
1590                         DBG("out_clusters[%d] = 0x%x", j, records->out_clusters[j]);
1591
1592                 cb(addr16, count, records, container->userdata);
1593 #if 0
1594                 free(records->in_clusters);
1595                 free(records->out_clusters);
1596 #endif
1597                 free(records);
1598         }
1599         break;
1600         case ZBL_ZDO_MATCHED_DESCRIPTOR_REQ: {
1601                 zb_zdo_match_desc_rsp cb = container->cb;
1602
1603                 int j = 0;
1604                 int match_len;
1605                 nwk_addr addr16;
1606                 unsigned char value;
1607                 unsigned char status;
1608                 GVariantIter *ml_iter = NULL;
1609                 unsigned char *match_list = NULL;
1610                 g_variant_get(parameters, "(yqya(y))", &status, &addr16, &value, &ml_iter);
1611                 match_len = value;
1612
1613                 if (match_len > 0) {
1614                         match_list = calloc(match_len+1, sizeof(unsigned char));
1615                         RETM_IF(NULL == match_list, "calloc() Fail(%d)", errno);
1616                         while (g_variant_iter_loop(ml_iter, "(y)", &value)) {
1617                                 match_list[j] = value;
1618                                 DBG("match_list[i]=%d", j, match_list[j]);
1619                                 j++;
1620                         }
1621                         if (NULL != ml_iter)
1622                                 g_variant_iter_free(ml_iter);
1623                 }
1624
1625                 DBG("Match count : [%d]", match_len);
1626                 DBG("Match list  : [%p]", match_list);
1627
1628                 cb(status, addr16, match_len, match_list, container->userdata);
1629
1630                 if (match_list)
1631                         free(match_list);
1632         }
1633         break;
1634         case ZBL_ZDO_NODE_DESC_REQ: {
1635                 zb_zdo_node_desc_rsp cb = container->cb;
1636
1637                 nwk_addr addr16;
1638                 unsigned char status;
1639                 zb_zdo_node_descriptor_h desc;
1640
1641                 desc = calloc(1, sizeof(struct zb_zdo_node_descriptor_s));
1642                 RETM_IF(NULL == desc, "calloc() Fail(%d)", errno);
1643
1644                 container->found = true;
1645
1646                 g_variant_get(parameters, "(yqyyyyyyqyqqqy)", &status, &addr16,
1647                         &desc->logical_type, &desc->complex_desciptor_available,
1648                         &desc->user_descriptor_available, &desc->aps_flags, &desc->frequency_band,
1649                         &desc->mac_capability_flags, &desc->manufacturer_code, &desc->maximum_buffer_size,
1650                         &desc->maximum_incoming_transfer_size, &desc->server_mask,
1651                         &desc->maximum_outgoing_transfer_size, &desc->descriptor_capability_field);
1652
1653                 cb(status, addr16, desc, container->userdata);
1654                 free(desc);
1655         }
1656         break;
1657         case ZBL_ZDO_POWER_DESC_REQ: {
1658                 zb_zdo_power_desc_rsp cb = container->cb;
1659
1660                 nwk_addr addr16;
1661                 unsigned char status;
1662                 zb_zdo_node_power_descriptor_h desc;
1663
1664                 desc = calloc(1, sizeof(struct zb_zdo_node_power_descriptor_s));
1665                 RETM_IF(NULL == desc, "calloc() Fail(%d)", errno);
1666
1667                 g_variant_get(parameters, "(yqyyyy)", &status, &addr16,
1668                                         &desc->current_power_mode, &desc->available_power_sources,
1669                                         &desc->current_power_source, &desc->current_power_source_level);
1670
1671                 cb(status, addr16, desc, container->userdata);
1672                 free(desc);
1673         }
1674         break;
1675         case ZBL_ZDO_COMPLEX_DESC_REQ: {
1676                 zb_zdo_complex_desc_rsp cb = container->cb;
1677
1678                 int length;
1679                 nwk_addr addr16;
1680                 unsigned char j = 0;
1681                 unsigned char value;
1682                 unsigned char status;
1683                 GVariantIter *comp_iter = NULL;
1684                 unsigned char *complex_desc = NULL;
1685
1686                 g_variant_get(parameters, "(yqya(y))", &status, &addr16, &length, &comp_iter);
1687                 if (length > 0) {
1688                         complex_desc = calloc(length, sizeof(char));
1689                         if (NULL == complex_desc) {
1690                                 if (NULL != comp_iter)
1691                                         g_variant_iter_free(comp_iter);
1692                                 ERR("calloc() Fail(%d)", errno);
1693                                 return;
1694                         }
1695
1696                         while (g_variant_iter_loop(comp_iter, "(y)", &value)) {
1697                                 complex_desc[j] = value;
1698                                 j++;
1699                         }
1700                         if (NULL != comp_iter)
1701                                 g_variant_iter_free(comp_iter);
1702                 }
1703
1704                 cb(status, addr16, length, complex_desc, container->userdata);
1705                 free(complex_desc);
1706         }
1707         break;
1708         case ZBL_ZDO_USER_DESC_REQ: {
1709                 zb_zdo_user_desc_rsp cb = container->cb;
1710
1711                 int length;
1712                 nwk_addr addr16;
1713                 unsigned char j = 0;
1714                 unsigned char value;
1715                 unsigned char status;
1716                 GVariantIter *comp_iter = NULL;
1717                 unsigned char *complex_desc = NULL;
1718
1719                 g_variant_get(parameters, "(yqya(y))", &status, &addr16, &length, &comp_iter);
1720                 if (length > 0) {
1721                         complex_desc = calloc(length, sizeof(char));
1722                         if (NULL == complex_desc) {
1723                                 if (NULL != comp_iter)
1724                                         g_variant_iter_free(comp_iter);
1725                                 ERR("calloc() Fail(%d)", errno);
1726                                 return;
1727                         }
1728                         while (g_variant_iter_loop(comp_iter, "(y)", &value)) {
1729                                 complex_desc[j] = value;
1730                                 j++;
1731                         }
1732                         if (NULL != comp_iter)
1733                                 g_variant_iter_free(comp_iter);
1734                 }
1735
1736                 cb(status, addr16, length, complex_desc, container->userdata);
1737                 free(complex_desc);
1738         }
1739         case ZBL_ZDO_USER_DESC_SET_REQ: {
1740                 zb_zdo_user_desc_conf cb = container->cb;
1741                 unsigned char status;
1742                 g_variant_get(parameters, "(y)", &status);
1743                 cb(status, container->userdata);
1744         }
1745         break;
1746         case ZBL_ZDO_MGMT_BIND_REQ: {
1747                 zb_zdo_mgmt_bind_rsp cb = container->cb;
1748
1749                 unsigned char status;
1750                 unsigned char value;
1751
1752                 int i = 0;
1753                 int j = 0;
1754                 unsigned char binding_table_enteries;
1755                 unsigned char binding_table_list_count;
1756                 unsigned char start_index;
1757                 unsigned short dst_addr16 = 0;
1758                 unsigned char dst_ep = 0;
1759
1760                 GVariantIter *mac_iter = NULL;
1761                 GVariantIter *rsp_iter = NULL;
1762                 GVariantIter *destep_iter = NULL;
1763                 zb_zdo_binding_table_h *records = NULL;
1764
1765                 g_variant_get(parameters, "(yyyya(ayyqyqayy))", &status,
1766                                 &binding_table_enteries, &start_index,
1767                                 &binding_table_list_count, &rsp_iter);
1768
1769                 if (binding_table_list_count > 0) {
1770                         records = calloc(binding_table_list_count, sizeof(zb_zdo_binding_table_h));
1771                         RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
1772                         for (i = 0; i < binding_table_list_count; i++) {
1773                                 records[i] = calloc(binding_table_list_count, sizeof(struct zb_zdo_binding_table_s));
1774                                 if (NULL == records[i]) {
1775                                         if (NULL != mac_iter)
1776                                                 g_variant_iter_free(mac_iter);
1777                                         if (NULL != rsp_iter)
1778                                                 g_variant_iter_free(rsp_iter);
1779                                         if (NULL != destep_iter)
1780                                                 g_variant_iter_free(destep_iter);
1781                                         ERR("calloc() Fail(%d)", errno);
1782                                         goto MGMT_NWK_BIND_REQ_OUT;
1783                                 }
1784                         }
1785                 }
1786                 for (i = 0; i < binding_table_list_count; i++) {
1787                         g_variant_iter_loop(rsp_iter, "(ayyqyqayy)", &mac_iter,
1788                                 &records[i]->src_ep, &records[i]->cluster_id,
1789                                 &records[i]->dst_addr_mode, &dst_addr16,
1790                                 &destep_iter, &dst_ep);
1791                         for (j = 0; j < 8; j++) {
1792                                 g_variant_iter_loop(mac_iter, "y", &value);
1793                                 records[i]->src_addr64[j] = value;
1794                         }
1795                         if (NULL != mac_iter)
1796                                 g_variant_iter_free(mac_iter);
1797
1798                         if (0x03 == records[i]->dst_addr_mode) {
1799                                 for (j = 0; j < 8; j++) {
1800                                         g_variant_iter_loop(destep_iter, "y", &value);
1801                                         records[i]->dst_addr64[j] = value;
1802                                 }
1803                                 records[i]->dst_ep = dst_ep;
1804                                 DBG("Destination MAC Addr : %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
1805                                         records[i]->dst_addr64[7], records[i]->dst_addr64[6],
1806                                         records[i]->dst_addr64[5], records[i]->dst_addr64[4],
1807                                         records[i]->dst_addr64[3], records[i]->dst_addr64[2],
1808                                         records[i]->dst_addr64[1], records[i]->dst_addr64[0]);
1809
1810                         } else if (0x01 == records[i]->dst_addr_mode) {
1811                                 records[i]->dst_addr16 = dst_addr16;
1812                         }
1813                         if (NULL != destep_iter)
1814                                 g_variant_iter_free(destep_iter);
1815                 }
1816                 if (NULL != rsp_iter)
1817                         g_variant_iter_free(rsp_iter);
1818
1819                 cb(status, binding_table_enteries, start_index, binding_table_list_count,
1820                         records, container->userdata);
1821
1822 MGMT_NWK_BIND_REQ_OUT:
1823                 for (i = 0; i < binding_table_list_count; i++) {
1824                         if (records[i])
1825                                 free(records[i]);
1826                 }
1827                 free(records);
1828         }
1829         break;
1830         case ZBL_ZDO_MGMT_LQI_REQ: {
1831                 zb_zdo_mgmt_lqi_rsp cb = container->cb;
1832
1833                 int i = 0;
1834                 int j = 0;
1835                 unsigned char value;
1836                 unsigned char status;
1837                 unsigned char start_index;
1838                 unsigned char neighbor_table_enteries;
1839                 unsigned char neighbor_table_list_count;
1840
1841                 GVariantIter *resp_iter = NULL;
1842                 GVariantIter *mac_iter = NULL;
1843                 GVariantIter *mac_iter1 = NULL;
1844                 zb_zdo_neighbor_table_desc_h *records = NULL;
1845
1846                 g_variant_get(parameters, "(yyyya(ayayyqyyyyy))", &status, &neighbor_table_enteries,
1847                                 &start_index, &neighbor_table_list_count, &resp_iter);
1848
1849                 if (neighbor_table_list_count > 0) {
1850                         records = calloc(neighbor_table_list_count, sizeof(zb_zdo_neighbor_table_desc_h));
1851                         RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
1852                         for (i = 0; i < neighbor_table_list_count; i++) {
1853                                 records[i] = calloc(1, sizeof(struct zb_zdo_neighbor_table_desc_s));
1854                                 if (NULL == records[i]) {
1855                                         ERR("calloc() Fail(%d)", errno);
1856                                         goto MGMT_LQI_REQ_OUT;
1857                                 }
1858                         }
1859                 }
1860                 for (i = 0; i < neighbor_table_list_count; i++) {
1861                         g_variant_iter_loop(resp_iter, "(ayayyqyyyyy)",
1862                                         &mac_iter, &mac_iter1,
1863                                         &records[i]->device_type, &records[i]->addr16,
1864                                         &records[i]->rx_on_when_idle, &records[i]->relationship,
1865                                         &records[i]->permit_joining, &records[i]->depth,
1866                                         &records[i]->lqi);
1867                         for (j = 0; j < 8; j++) {
1868                                 g_variant_iter_loop(mac_iter, "y", &value);
1869                                 records[i]->extended_pan_id[j] = value;
1870                                 g_variant_iter_loop(mac_iter1, "y", &value);
1871                                 records[i]->addr64[j] = value;
1872                         }
1873                         if (NULL != mac_iter)
1874                                 g_variant_iter_free(mac_iter);
1875                         if (NULL != mac_iter1)
1876                                 g_variant_iter_free(mac_iter1);
1877
1878                         DBG("ext PAN ID = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
1879                         records[i]->extended_pan_id[0], records[i]->extended_pan_id[1],
1880                         records[i]->extended_pan_id[2], records[i]->extended_pan_id[3],
1881                         records[i]->extended_pan_id[4], records[i]->extended_pan_id[5],
1882                         records[i]->extended_pan_id[6], records[i]->extended_pan_id[7]);
1883
1884                         DBG("IEEE address = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
1885                         records[i]->addr64[0], records[i]->addr64[1], records[i]->addr64[2], records[i]->addr64[3],
1886                         records[i]->addr64[4], records[i]->addr64[5], records[i]->addr64[6], records[i]->addr64[7]);
1887                 }
1888                 if (NULL != resp_iter)
1889                         g_variant_iter_free(resp_iter);
1890
1891                 cb(status, neighbor_table_enteries, start_index, neighbor_table_list_count,
1892                         records, container->userdata);
1893
1894 MGMT_LQI_REQ_OUT:
1895                 for (i = 0; i < neighbor_table_list_count; i++) {
1896                         if (records[i])
1897                                 free(records[i]);
1898                 }
1899                 free(records);
1900         }
1901         break;
1902         case ZBL_ZDO_MGMT_RTG_REQ: {
1903                 zb_zdo_mgmt_rtg_rsp cb = container->cb;
1904
1905                 int i;
1906                 unsigned char status;
1907                 unsigned char start_index;
1908                 unsigned char routing_table_enteries;
1909                 unsigned char routing_table_list_count;
1910
1911                 GVariantIter *rsp_iter = NULL;
1912                 zb_zdo_routing_table_h *records = NULL;
1913
1914                 g_variant_get(parameters, "(yyyya(qyyyyq))", &status, &routing_table_enteries,
1915                                 &start_index, &routing_table_list_count, &rsp_iter);
1916
1917                 if (routing_table_list_count > 0) {
1918                         records = calloc(routing_table_list_count, sizeof(zb_zdo_routing_table_h));
1919                         RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
1920                         for (i = 0; i < routing_table_list_count; i++) {
1921                                 records[i] = calloc(1, sizeof(struct zb_zdo_routing_table_s));
1922                                 if (NULL == records[i]) {
1923                                         ERR("calloc() Fail(%d)", errno);
1924                                         goto MGMT_NWK_RTG_REQ_OUT;
1925                                 }
1926                         }
1927                 }
1928
1929                 for (i = 0; i < routing_table_list_count; i++) {
1930                         g_variant_iter_loop(rsp_iter, "(qyyyyq)", &records[i]->dst_addr,
1931                                 &records[i]->status, &records[i]->memory_constrained,
1932                                 &records[i]->route_record_required,
1933                                 &records[i]->many_to_one, &records[i]->next_hop_addr);
1934                 }
1935                 if (NULL != rsp_iter)
1936                         g_variant_iter_free(rsp_iter);
1937
1938                 cb(status, routing_table_enteries, start_index, routing_table_list_count,
1939                         records, container->userdata);
1940
1941 MGMT_NWK_RTG_REQ_OUT:
1942                 for (i = 0; i < routing_table_list_count; i++) {
1943                         if (records[i])
1944                                 free(records[i]);
1945                 }
1946                 free(records);
1947         }
1948         break;
1949         case ZBL_ZDO_MGMT_NWK_DISC_REQ: {
1950                 zb_zdo_mgmt_nwk_disc_rsp cb = container->cb;
1951                         int i = 0;
1952                 int j = 0;
1953                 unsigned char value;
1954                 unsigned char status = 0;
1955                 unsigned char nwk_count = 0;
1956                 unsigned char start_index = 0;
1957                 unsigned char nwk_list_count = 0;
1958
1959                 GVariantIter *mac_iter = NULL;
1960                 GVariantIter *resp_iter = NULL;
1961
1962                 DBG("_zbl_mgmt_nwk_disc_req_cb()");
1963
1964                 g_variant_get(parameters, "(yyyya(ayyyyyyy))", &status, &nwk_count,
1965                         &start_index, &nwk_list_count, &resp_iter);
1966
1967                 zb_zdo_network_list_record_h *records = NULL;
1968
1969                 if (!status) {
1970                         if (nwk_list_count > 0) {
1971                                 records = calloc(nwk_list_count, sizeof(zb_zdo_network_list_record_h));
1972                                 RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
1973                                 for (i = 0; i < nwk_list_count; i++) {
1974                                         records[i] = calloc(1, sizeof(struct zb_zdo_network_list_record_s));
1975                                         if (NULL == records[i]) {
1976                                                 ERR("calloc() Fail(%d)", errno);
1977                                                 goto MGMT_NWK_DISC_REQ_OUT;
1978                                         }
1979                                 }
1980                         }
1981                         for (i = 0; i < nwk_list_count; i++) {
1982                                 g_variant_iter_loop(resp_iter, "(ayyyyyyy)", &mac_iter, &records[i]->logical_channel,
1983                                         &records[i]->stack_profile, &records[i]->zigbee_version, &records[i]->beacon_order,
1984                                         &records[i]->superframe_order, &records[i]->permit_joining);
1985                                 for (j = 0; j < 8; j++) {
1986                                         g_variant_iter_loop(mac_iter, "y", &value);
1987                                         records[i]->extended_pan_id[j] = value;
1988                                 }
1989                                 if (NULL != mac_iter)
1990                                         g_variant_iter_free(mac_iter);
1991                         }
1992                         if (NULL != resp_iter)
1993                                 g_variant_iter_free(resp_iter);
1994                 }
1995
1996                 cb(status, nwk_count, start_index, nwk_list_count, records, container->userdata);
1997
1998 MGMT_NWK_DISC_REQ_OUT:
1999                 for (i = 0; i < nwk_list_count; i++) {
2000                         if (records[i])
2001                                 free(records[i]);
2002                 }
2003                 free(records);
2004         }
2005         break;
2006         case ZBL_ZDO_MGMT_PERMIT_JOIN_REQ: {
2007                 zb_zdo_mgmt_permit_joining_rsp cb = container->cb;
2008                 unsigned char status;
2009                 g_variant_get(parameters, "(y)", &status);
2010                 cb(status, container->userdata);
2011         }
2012         break;
2013         case ZBL_ZDO_MGMT_LEAVE_REQ: {
2014                 zb_zdo_mgmt_leave_rsp cb = container->cb;
2015                 unsigned char status;
2016                 g_variant_get(parameters, "(y)", &status);
2017                 cb(status, container->userdata);
2018         }
2019         break;
2020         /* ZDP Bind */
2021         case ZBL_ZDO_BIND_REQ: {
2022                 zb_zdo_bind_rsp cb = container->cb;
2023                 unsigned char status;
2024                 g_variant_get(parameters, "(y)", &status);
2025                 cb(status, container->userdata);
2026         }
2027         break;
2028         case ZBL_ZDO_UNBIND_REQ: {
2029                 zb_zdo_unbind_rsp cb = container->cb;
2030                 unsigned char status;
2031                 g_variant_get(parameters, "(y)", &status);
2032                 cb(status, container->userdata);
2033         }
2034         break;
2035         /* Custom */
2036         case ZBL_CUSTOM_APS_SEND_REQ: {
2037                 zb_aps_send_rsp cb = container->cb;
2038
2039                 unsigned short addr16;
2040                 unsigned char src_ep;
2041                 unsigned char dst_ep;
2042                 unsigned short cluster_id;
2043                 unsigned short profile_id;
2044                 unsigned short payload_len = 0;
2045                 unsigned char *payload = NULL;
2046
2047                 unsigned char value;
2048                 GVariantIter *payload_iter = NULL;
2049                 int i = 0;
2050
2051                 g_variant_get(parameters, "(qyyqqqa(y))", &addr16, &src_ep, &dst_ep,
2052                                 &cluster_id, &profile_id, &payload_len, &payload_iter);
2053
2054                 if (payload_len > 0) {
2055                         payload = calloc(payload_len+1, sizeof(unsigned char));
2056                         while (g_variant_iter_loop(payload_iter, "(y)", &value))
2057                                 payload[i++] = value;
2058
2059                         if (NULL != payload_iter)
2060                                 g_variant_iter_free(payload_iter);
2061                 }
2062
2063                 cb(addr16, src_ep, dst_ep, cluster_id, profile_id, payload_len, payload,
2064                         container->userdata);
2065
2066                 free(payload);
2067         }
2068         break;
2069         case ZBL_CUSTOM_ZCL_SEND_REQ: {
2070                 zb_zcl_send_rsp cb = container->cb;
2071
2072                 unsigned short addr16;
2073                 unsigned char src_ep;
2074                 unsigned char dst_ep;
2075                 unsigned short cluster_id;
2076                 unsigned short profile_id;
2077                 unsigned short payload_len = 0;
2078                 unsigned char *payload = NULL;
2079
2080                 unsigned char value;
2081                 GVariantIter *payload_iter = NULL;
2082                 int i = 0;
2083
2084                 g_variant_get(parameters, "(qyyqqqa(y))", &addr16, &src_ep, &dst_ep,
2085                                 &cluster_id, &profile_id, &payload_len, &payload_iter);
2086
2087                 if (payload_len > 0) {
2088                         payload = calloc(payload_len + 1, sizeof(unsigned char));
2089                         while (g_variant_iter_loop(payload_iter, "(y)", &value))
2090                                 payload[i++] = value;
2091
2092                         if (NULL != payload_iter)
2093                                 g_variant_iter_free(payload_iter);
2094                 }
2095
2096                 cb(addr16, src_ep, dst_ep, cluster_id, profile_id, payload_len, payload,
2097                         container->userdata);
2098
2099                 free(payload);
2100         }
2101         break;
2102         case ZBL_CUSTOM_LOCAL_SEND_REQ: {
2103                 zb_send_to_local_rsp cb = container->cb;
2104
2105                 unsigned char *data = NULL;
2106                 unsigned short length = 0;
2107                 unsigned char value;
2108                 GVariantIter *payload_iter = NULL;
2109                 int i = 0;
2110
2111                 g_variant_get(parameters, "(qa(y))", &length, &payload_iter);
2112
2113                 if (length > 0) {
2114                         data = calloc(length, sizeof(unsigned char));
2115                         while (g_variant_iter_loop(payload_iter, "(y)", &value))
2116                                 data[i++] = value;
2117
2118                         if (NULL != payload_iter)
2119                                 g_variant_iter_free(payload_iter);
2120                 }
2121
2122                 cb(length, data, container->userdata);
2123
2124                 free(data);
2125         }
2126         break;
2127         /* ZCL Global */
2128         case ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ: {
2129                 zb_zcl_global_rsp cb = container->cb;
2130
2131                 int j = 0;
2132                 int isString;
2133                 unsigned char value;
2134
2135                 nwk_addr addr16;
2136                 unsigned char ep;
2137                 unsigned short attr_id;
2138                 unsigned short cluster_id;
2139                 unsigned char status;
2140                 unsigned char type;
2141                 unsigned short records_len;
2142                 unsigned char attr_value[128];
2143
2144                 GVariantIter *iter = NULL;
2145                 read_attr_status_record_h records;
2146                 zb_global_record_data_s *data;
2147
2148                 data = calloc(1, sizeof(zb_global_record_data_s));
2149                 records = calloc(1, sizeof(struct read_attribute_status_record_s));
2150                 if (!records || !data) {
2151                         ERR("calloc() Fail(%d)", errno);
2152                         goto GLOBAL_READ_ATTRIBUTE_REQ_OUT;
2153                 }
2154
2155                 g_variant_get(parameters, "(qya(y)qqyyqi)",
2156                         &addr16, &ep, &iter, &attr_id, &cluster_id, &status, &type, &records_len, &isString);
2157                 if (!isString) {
2158                         while (g_variant_iter_loop(iter, "(y)", &value)) {
2159                                 attr_value[j] = value;
2160                                 DBG("attr_value[%d] = 0x%02X", j, value);
2161                                 j++;
2162                         }
2163                         if (NULL != iter)
2164                                 g_variant_iter_free(iter);
2165                 } else {
2166                         while (g_variant_iter_loop(iter, "(y)", &value)) {
2167                                 if (j == 0)
2168                                         records_len = value;
2169                                 attr_value[j] = value;
2170                                 DBG("attr_value[%d] = 0x%02X", j, value);
2171                                 j++;
2172                         }
2173                         if (NULL != iter)
2174                                 g_variant_iter_free(iter);
2175                 }
2176
2177                 records->id = attr_id;
2178                 records->status = status;
2179                 records->type = type;
2180                 records->value = attr_value;
2181                 data->type = ZB_GLOBAL_READ_ATTR;
2182                 data->record.read_attr = &records;
2183                 data->records_len = records_len;
2184
2185                 cb(addr16, ep, cluster_id, data, records_len, container->userdata);
2186
2187 GLOBAL_READ_ATTRIBUTE_REQ_OUT:
2188                 if (records)
2189                         free(records);
2190                 if (data)
2191                         free(data);
2192         }
2193         break;
2194         case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ: {
2195                 zb_zcl_global_rsp cb = container->cb;
2196
2197                 int i = 0;
2198                 nwk_addr addr16;
2199                 unsigned char ep;
2200                 unsigned short cluster_id;
2201                 unsigned short attribute_id;
2202                 int records_len;
2203                 unsigned char value;
2204
2205                 GVariantIter *stat_iter = NULL;
2206                 GVariantIter *attr_iter = NULL;
2207                 write_attr_status_record_h records;
2208                 zb_global_record_data_s *data;
2209
2210                 g_variant_get(parameters, "(qya(y)aqqi)",
2211                         &addr16, &ep, &stat_iter, &attr_iter, &cluster_id, &records_len);
2212
2213                 records = calloc(records_len, sizeof(struct write_attribute_status_record_s));
2214                 data = calloc(1, sizeof(zb_global_record_data_s));
2215                 if (!records || !data) {
2216                         if (NULL != stat_iter)
2217                                 g_variant_iter_free(stat_iter);
2218                         if (NULL != attr_iter)
2219                                 g_variant_iter_free(attr_iter);
2220                         ERR("calloc() Fail(%d)", errno);
2221                         goto GLOBAL_WRITE_ATTRIBUTE_REQ_OUT;
2222                 }
2223
2224                 while (g_variant_iter_loop(stat_iter, "(y)", &value)) {
2225                         records[i].status = value;
2226                         i++;
2227                 }
2228                 if (NULL != stat_iter)
2229                         g_variant_iter_free(stat_iter);
2230
2231                 i = 0;
2232                 while (g_variant_iter_loop(attr_iter, "q", &attribute_id)) {
2233                         records[i].id = attribute_id;
2234                         DBG("Attribute Id 0x%04X", attribute_id);
2235                         i++;
2236                 }
2237                 if (NULL != attr_iter)
2238                         g_variant_iter_free(attr_iter);
2239
2240                 data->type = ZB_GLOBAL_WRITE_ATTR;
2241                 data->record.write_attr = &records;
2242                 data->records_len = records_len;
2243
2244                 cb(addr16, ep, cluster_id, data, records_len, container->userdata);
2245
2246 GLOBAL_WRITE_ATTRIBUTE_REQ_OUT:
2247                 free(records);
2248                 free(data);
2249         }
2250         break;
2251         case ZBL_ZCL_GLOBAL_CONFIGURE_REPORTING_REQ: {
2252                 zb_zcl_global_rsp cb = container->cb;
2253                 nwk_addr addr16;
2254                 unsigned char ep;
2255                 unsigned short cluster_id;
2256                 unsigned short attIdVal;
2257                 unsigned char value;
2258                 int j = 0, l = 0, k = 0, rec_len;
2259                 GVariantIter *stat_iter = NULL;
2260                 GVariantIter *attr_iter = NULL;
2261                 GVariantIter *dir_iter = NULL;
2262                 report_config_response_record_h records;
2263                 zb_global_record_data_s *data;
2264
2265                 g_variant_get(parameters, "(a(y)aqa(y)qiqy)",
2266                         &stat_iter, &attr_iter, &dir_iter, &cluster_id, &rec_len, &addr16, &ep);
2267
2268                 records = calloc(rec_len, sizeof(struct reporting_configuration_response_record_s));
2269                 data = calloc(1, sizeof(zb_global_record_data_s));
2270                 if (!data || !records) {
2271                         if (NULL != stat_iter)
2272                                 g_variant_iter_free(stat_iter);
2273                         if (NULL != attr_iter)
2274                                 g_variant_iter_free(attr_iter);
2275                         if (NULL != dir_iter)
2276                                 g_variant_iter_free(dir_iter);
2277                         ERR("calloc() Fail(%d)", errno);
2278                         goto GLOBAL_CONFIGURE_REPORTING_REQ_OUT;
2279                 }
2280
2281                 while (g_variant_iter_loop(stat_iter, "(y)", &value)) {
2282                         DBG("Value 0x%02X", value);
2283                         records[j].status = value;
2284                         j++;
2285                 }
2286                 if (NULL != stat_iter)
2287                         g_variant_iter_free(stat_iter);
2288
2289                 while (g_variant_iter_loop(attr_iter, "q", &attIdVal)) {
2290                         if (records[l].status != ZB_ZCL_SUCCESS)
2291                                 records[l].id = attIdVal;
2292                         l++;
2293                 }
2294                 if (NULL != attr_iter)
2295                         g_variant_iter_free(attr_iter);
2296
2297                 while (g_variant_iter_loop(dir_iter, "(y)", &value)) {
2298                         if (records[k].status != ZB_ZCL_SUCCESS)
2299                                 records[k].dir = value;
2300                         k++;
2301                 }
2302                 if (NULL != dir_iter)
2303                         g_variant_iter_free(dir_iter);
2304
2305                 data->type = ZB_GLOBAL_CONFIG_REPORT;
2306                 data->record.report_config_rsp = &records;
2307                 data->records_len = rec_len;
2308
2309                 cb(addr16, ep, cluster_id, data, rec_len, container->userdata);
2310
2311 GLOBAL_CONFIGURE_REPORTING_REQ_OUT:
2312                 free(records);
2313                 free(data);
2314         }
2315         break;
2316         case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ: {
2317                 zb_zcl_global_discover_attr_rsp cb = container->cb;
2318                 nwk_addr addr16;
2319                 unsigned char ep;
2320                 discover_attr_info_record_h *records;
2321
2322                 int records_len;
2323                 unsigned short cluster_id;
2324                 unsigned short attribute_id;
2325                 unsigned char value;
2326                 int j = 0, l = 0;
2327                 int discovery_complete;
2328                 GVariantIter *stat_iter = NULL;
2329                 GVariantIter *attr_iter = NULL;
2330
2331                 g_variant_get(parameters, "(qya(y)aqqii)",  &addr16, &ep, &stat_iter,
2332                                                 &attr_iter, &cluster_id, &records_len, &discovery_complete);
2333                 records = calloc(records_len, sizeof(discover_attr_info_record_h));
2334                 RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
2335                 for (j = 0; j < records_len; j++) {
2336                         records[j] = calloc(1, sizeof(struct discover_attribute_info_record_s));
2337                         if (NULL == records[j]) {
2338                                 ERR("calloc() Fail(%d)", errno);
2339                                 for (l = 0; l < j; l++)
2340                                         free(records[l]);
2341                                 free(records);
2342                                 if (NULL != stat_iter)
2343                                         g_variant_iter_free(stat_iter);
2344                                 if (NULL != attr_iter)
2345                                         g_variant_iter_free(attr_iter);
2346                                 return;
2347                         }
2348                 }
2349
2350                 j = 0;
2351                 while (g_variant_iter_loop(stat_iter, "(y)", &value)) {
2352                         records[j]->type = value;
2353                         DBG("Attribute Type 0x%02X", value);
2354                         j++;
2355                 }
2356                 if (NULL != stat_iter)
2357                         g_variant_iter_free(stat_iter);
2358
2359                 while (g_variant_iter_loop(attr_iter, "q", &attribute_id)) {
2360                         records[l]->id = attribute_id;
2361                         DBG("Attribute Id 0x%04X", attribute_id);
2362                         l++;
2363                 }
2364                 if (NULL != attr_iter)
2365                         g_variant_iter_free(attr_iter);
2366
2367                 cb(addr16, ep, cluster_id, discovery_complete, records, records_len,
2368                         container->userdata);
2369
2370                 for (j = 0; j < records_len; j++)
2371                         free(records[j]);
2372                 free(records);
2373         }
2374         break;
2375         case ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_STRUCTURED_REQ: {
2376                 zb_zcl_global_rsp cb = container->cb;
2377                 cb(0, 0, 0, NULL, 0, container->userdata);
2378         }
2379         break;
2380         /* GLOBAL_DISCOVER_COMMAND_RECEIVED and GLOBAL_DISCOVER_COMMAND_GENERATED should be handled as same way */
2381         case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ:
2382         case ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ: {
2383                 zb_zcl_global_discover_cmds_rsp cb = container->cb;
2384
2385                 nwk_addr addr16;
2386                 unsigned char ep;
2387
2388                 int j = 0;
2389                 char value;
2390                 unsigned short cluster_id;
2391                 unsigned short cmd_len;
2392                 unsigned char *cmd_data;
2393                 unsigned char discoveryComplete;
2394                 GVariantIter *cmd_iter = NULL;
2395
2396                 g_variant_get(parameters, "(a(y)qqqyy)",  &cmd_iter, &cluster_id, &cmd_len,
2397                         &addr16, &ep, &discoveryComplete);
2398
2399                 cmd_data = calloc(cmd_len+1, sizeof(char));
2400                 if (NULL == cmd_data) {
2401                         ERR("calloc() Fail(%d)", errno);
2402                         if (NULL != cmd_iter)
2403                                 g_variant_iter_free(cmd_iter);
2404                         return;
2405                 }
2406
2407                 while (g_variant_iter_loop(cmd_iter, "(y)", &value)) {
2408                         DBG("Value 0x%02X", value);
2409                         cmd_data[j] = value;
2410                         j++;
2411                 }
2412                 if (NULL != cmd_iter)
2413                         g_variant_iter_free(cmd_iter);
2414
2415                 cb(addr16, ep, cluster_id, discoveryComplete, cmd_data, cmd_len, container->userdata);
2416                 free(cmd_data);
2417         }
2418         break;
2419         case ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ: {
2420                 zb_zcl_global_discover_attr_extended_rsp cb = container->cb;
2421                 nwk_addr addr16;
2422                 unsigned char ep;
2423
2424                 int i = 0;
2425                 int j = 0;
2426                 unsigned short cluster_id;
2427                 unsigned char t_value;
2428                 unsigned char ac_value;
2429
2430                 unsigned short rec_len;
2431                 unsigned short attr_data;
2432                 unsigned char discoveryComplete;
2433                 GVariantIter *attr_iter = NULL;
2434                 GVariantIter *type_iter = NULL;
2435                 GVariantIter *ac_iter = NULL;
2436                 extended_attr_info_h *records;
2437
2438                 DBG("Will get the value now");
2439
2440                 g_variant_get(parameters, "(aqa(y)a(y)qqqyy)", &attr_iter, &type_iter, &ac_iter,
2441                         &cluster_id, &rec_len, &addr16, &ep, &discoveryComplete);
2442
2443                 DBG("records length 0x%04X", rec_len);
2444
2445                 records = calloc(rec_len, sizeof(extended_attr_info_h));
2446                 RETM_IF(NULL == records, "calloc() Fail(%d)", errno);
2447                 for (j = 0; j < rec_len; j++) {
2448                         records[j] = calloc(1, sizeof(struct extended_attribute_infomation_s));
2449                         if (NULL == records[j]) {
2450                                 for (i = 0; i < j; i++)
2451                                         free(records[i]);
2452                                 free(records);
2453                                 if (NULL != attr_iter)
2454                                         g_variant_iter_free(attr_iter);
2455                                 if (NULL != type_iter)
2456                                         g_variant_iter_free(type_iter);
2457                                 if (NULL != ac_iter)
2458                                         g_variant_iter_free(ac_iter);
2459
2460                                 ERR("calloc() Fail(%d)", errno);
2461                                 return;
2462                         }
2463                 }
2464
2465                 j = 0;
2466                 while (g_variant_iter_loop(attr_iter, "q", &attr_data)
2467                                 && g_variant_iter_loop(type_iter, "(y)", &t_value)
2468                                 && g_variant_iter_loop(ac_iter, "(y)", &ac_value)) {
2469                         DBG("attrData 0x%04X", attr_data);
2470                         DBG("t_value 0x%02X", t_value);
2471                         DBG("ac_value 0x%02X", ac_value);
2472                         records[j]->id = attr_data;
2473                         records[j]->type = t_value;
2474                         records[j]->acl = ac_value;
2475                         j++;
2476                 }
2477                 if (NULL != attr_iter)
2478                         g_variant_iter_free(attr_iter);
2479                 if (NULL != type_iter)
2480                         g_variant_iter_free(type_iter);
2481                 if (NULL != ac_iter)
2482                         g_variant_iter_free(ac_iter);
2483
2484                 cb(addr16, ep, cluster_id, discoveryComplete, records, rec_len, container->userdata);
2485
2486                 for (j = 0; j < rec_len; j++)
2487                         free(records[j]);
2488                 free(records);
2489         }
2490         break;
2491         case ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ: {
2492                 zb_zcl_global_rsp cb = container->cb;
2493                 nwk_addr addr16;
2494                 unsigned char ep;
2495                 unsigned short cluster_id;
2496
2497                 int i = 0;
2498                 int j = 0;
2499                 char value;
2500                 unsigned char *status = NULL;
2501                 unsigned char *data_size = NULL;
2502                 unsigned char *change = NULL;
2503                 unsigned short record_length;
2504                 GVariantIter *resp_iter = NULL;
2505                 GVariantIter *data_iter = NULL;
2506
2507                 report_config_record_h *records = NULL;
2508                 zb_global_record_data_s *data = NULL;
2509
2510                 g_variant_get(parameters, "(qyqqa(yyqyqqayq))",
2511                         &addr16, &ep, &cluster_id, &record_length, &resp_iter);
2512
2513                 records = calloc(record_length, sizeof(report_config_record_h));
2514                 for (i = 0; i < record_length; i++) {
2515                         records[i] = calloc(1, sizeof(struct reporting_configuration_record_s));
2516                         if (NULL == records[i]) {
2517                                 ERR("calloc() Fail(%d)", errno);
2518                                 goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT;
2519                         }
2520                 }
2521                 data = calloc(1, sizeof(zb_global_record_data_s));
2522                 if (!data || !records) {
2523                         ERR("calloc() Fail(%d)", errno);
2524                         goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT;
2525                 }
2526
2527                 DBG("record_length %d", record_length);
2528                 status = calloc(record_length, sizeof(unsigned char));
2529                 data_size = calloc(record_length, sizeof(unsigned char));
2530                 if (!status || !data_size) {
2531                         ERR("Couldn't allocate the memory (%s)", errno);
2532                         goto GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT;
2533                 }
2534
2535                 for (i = 0; i < record_length; i++) {
2536                         g_variant_iter_loop(resp_iter, "(yyqyqqayq)", &status[i], &records[i]->dir,
2537                                 &records[i]->id, &records[i]->type, &records[i]->max_i, &records[i]->min_i,
2538                                 &data_iter, &records[i]->to);
2539                         if (records[i]->dir != ZCL_REPORTING_DIRECTION_REPORTED &&
2540                                 (zb_get_analog_or_discret(records[i]->type) == DATA_TYPE_ANALOG)) {
2541                                 data_size[i] = zb_get_data_size(records[j]->type);
2542                                 j = 0;
2543                                 if (data_size[i] != 0xff) {
2544                                         change = calloc(data_size[i]+1, sizeof(unsigned char));
2545                                         if (!change) {
2546                                                 ERR("calloc() Fail(%d)", errno);
2547                                                 records[i]->change = NULL;
2548                                                 if (NULL != data_iter)
2549                                                         g_variant_iter_free(data_iter);
2550                                                 continue;
2551                                         }
2552                                         while (g_variant_iter_loop(data_iter, "y", &value)) {
2553                                                 change[j] = value;
2554                                                 j++;
2555                                         }
2556                                         if (NULL != data_iter)
2557                                                 g_variant_iter_free(data_iter);
2558                                         records[i]->change = change;
2559                                 } else
2560                                         records[i]->change = NULL;
2561                         } else
2562                                 records[i]->change = NULL;
2563                 }
2564                 if (NULL != resp_iter)
2565                         g_variant_iter_free(resp_iter);
2566
2567                 data->type = ZB_GLOBAL_READ_REPORT_CONFIG;
2568                 data->record.report_config = records;
2569                 data->records_len = record_length;
2570
2571                 cb(addr16, ep, cluster_id, data, record_length, container->userdata);
2572
2573 GLOBAL_READ_CONFIGURE_REPORTING_REQ_OUT:
2574                 free(data_size);
2575                 free(status);
2576                 for (i = 0; i < record_length; i++)
2577                         free(records[i]);
2578                 free(records);
2579                 free(data);
2580         }
2581         break;
2582         /* ZCL Alarm */
2583         case ZBL_ZCL_ALARM_GET_ALARM_REQ: {
2584                 zb_zcl_alarm_get_alarm_rsp cb = container->cb;
2585
2586                 nwk_addr addr16 = 0;
2587                 unsigned char ep = 0;
2588                 unsigned char status = 0;
2589                 unsigned char alarm_code = 0;
2590                 unsigned short cluster_id = 0;
2591                 unsigned int time_stamp = 0;
2592
2593                 g_variant_get(parameters, "(qyyyqu)", &addr16, &ep, &status, &alarm_code,
2594                                         &cluster_id, &time_stamp);
2595                 cb(addr16, ep, status, alarm_code, cluster_id, time_stamp, container->userdata);
2596         }
2597         break;
2598         /* ZCL Doorlock */
2599         case ZBL_ZCL_DOORLOCK_LOCK_STATE: {
2600                 ERR("Unhandled cid = %d", container->cid);
2601         }
2602         break;
2603         /* ZCL Fanmode */
2604         case ZBL_ZCL_FANMODE_FAN_MODE_STATE: {
2605                 ERR("Unhandled cid = %d", container->cid);
2606         }
2607         break;
2608         /* ZCL Group */
2609         case ZBL_ZCL_GROUP_ADD_GROUP_REQ: {
2610                 zb_zcl_group_add_group_rsp cb = container->cb;
2611
2612                 nwk_addr addr16;
2613                 unsigned char ep;
2614                 unsigned char status;
2615                 unsigned short group_id;
2616
2617                 g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id);
2618                 cb(addr16, ep, status, group_id, container->userdata);
2619         }
2620         break;
2621         case ZBL_ZCL_GROUP_VIEW_GROUP_REQ: {
2622                 zb_zcl_group_view_group_rsp cb = container->cb;
2623
2624                 int j = 0;
2625                 nwk_addr addr16;
2626                 unsigned char ep;
2627                 unsigned char value;
2628                 unsigned char status;
2629                 unsigned short group_id;
2630                 char *group_name = NULL;
2631                 GVariantIter *grpNameiter = NULL;
2632
2633                 g_variant_get(parameters, "(qyyqay)", &addr16, &ep, &status, &group_id, &grpNameiter);
2634                 g_variant_iter_loop(grpNameiter, "y", &value);
2635                 /* first byte indicates the length of the string */
2636                 if ((value - '0') > 0) {
2637                         DBG("Value %d ", (value - '0'));
2638                         group_name = calloc((value - '0') + 1, sizeof(char));
2639                         if (NULL == group_name) {
2640                                 if (NULL != grpNameiter)
2641                                         g_variant_iter_free(grpNameiter);
2642                                 ERR("calloc() Fail(%d)", errno);
2643                                 goto GROUP_VIEW_GROUP_REQ_OUT;
2644                         }
2645                         group_name[j] = value;
2646                         j++;
2647                         while (g_variant_iter_loop(grpNameiter, "y", &value) && (j <= (value - '0'))) {
2648                                 group_name[j] = value;
2649                                 DBG("Name %c", group_name[j]);
2650                                 j++;
2651                         }
2652                         if (NULL != grpNameiter)
2653                                 g_variant_iter_free(grpNameiter);
2654                 } else {
2655                         group_name = calloc(1, sizeof(char));
2656                         if (NULL == group_name) {
2657                                 if (NULL != grpNameiter)
2658                                         g_variant_iter_free(grpNameiter);
2659                                 ERR("calloc() Fail(%d)", errno);
2660                                 goto GROUP_VIEW_GROUP_REQ_OUT;
2661                         }
2662                         group_name[j] = value;
2663                         j++;
2664                         group_name[j] = '\0';
2665                         j++;
2666                 }
2667
2668                 DBG("GroupName = %s", group_name);
2669                 cb(addr16, ep, status, group_id, group_name, container->userdata);
2670 GROUP_VIEW_GROUP_REQ_OUT:
2671                 free(group_name);
2672         }
2673         break;
2674         case ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ: {
2675                 zb_zcl_group_get_group_membership_rsp cb = container->cb;
2676
2677                 int j = 0;
2678                 nwk_addr addr16;
2679                 unsigned char ep;
2680                 unsigned short gl_value;
2681                 unsigned char capacity;
2682                 unsigned char group_count;
2683                 unsigned short *grouplist = NULL;
2684                 GVariantIter *grpListiter = NULL;
2685
2686                 g_variant_get(parameters, "(qyyyaq)", &addr16, &ep, &capacity, &group_count, &grpListiter);
2687
2688                 if (group_count > 0) {
2689                         grouplist = calloc(group_count+1, sizeof(unsigned short));
2690                         if (NULL == grouplist) {
2691                                 if (NULL != grpListiter)
2692                                         g_variant_iter_free(grpListiter);
2693                                 ERR("calloc() Fail(%d)", errno);
2694                                 return;
2695                         }
2696                         RETM_IF(NULL == grouplist, "calloc() Fail(%d)", errno);
2697
2698                         while (g_variant_iter_loop(grpListiter, "q", &gl_value)) {
2699                                 grouplist[j] = gl_value;
2700                                 j++;
2701                         }
2702                         if (NULL != grpListiter)
2703                                 g_variant_iter_free(grpListiter);
2704                 }
2705
2706                 cb(addr16, ep, capacity, group_count, grouplist, container->userdata);
2707
2708                 free(grouplist);
2709         }
2710         break;
2711         case ZBL_ZCL_GROUP_REMOVE_GROUP_REQ: {
2712                 zb_zcl_group_remove_group_rsp cb = container->cb;
2713
2714                 nwk_addr addr16;
2715                 unsigned char ep;
2716                 unsigned char status;
2717                 unsigned short group_id;
2718
2719                 g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id);
2720
2721                 cb(addr16, ep, status, group_id, container->userdata);
2722         }
2723         break;
2724         /* ZCL Identify */
2725         case ZBL_ZCL_IDENTIFY_QUERY_REQ: {
2726                 zb_zcl_identify_query_cb cb = container->cb;
2727
2728                 nwk_addr addr16 = 0;
2729                 unsigned short identify_time = 0;
2730                 g_variant_get(parameters, "(qq)", &addr16, &identify_time);
2731
2732                 cb(addr16, identify_time, container->userdata);
2733         }
2734         break;
2735         /* ZCL On/Off */
2736         case ZBL_ZCL_ON_OFF_GET_ON_OFF_STATE: {
2737                 ERR("Unhandled cid = %d", container->cid);
2738         }
2739         break;
2740         /* ZCL Pollcontrol */
2741         case ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ: {
2742                 zb_zcl_pollctrl_check_in cb = container->cb;
2743
2744                 nwk_addr addr16 = 0;
2745                 unsigned char ep = 0;
2746
2747                 g_variant_get(parameters, "(qy)", &addr16, &ep);
2748                 cb(addr16, ep, container->userdata);
2749         }
2750         break;
2751         /* ZCL Scene */
2752         case ZBL_ZCL_SCENE_ADD_SCENE_REQ: {
2753                 zb_zcl_scene_add_scene_rsp cb = container->cb;
2754
2755                 nwk_addr addr16 = 0;
2756                 unsigned char ep;
2757                 unsigned char status;
2758                 unsigned short group_id;
2759                 unsigned char scene_id;
2760
2761                 g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status,     &group_id, &scene_id);
2762                 cb(addr16, ep, status, group_id, scene_id, container->userdata);
2763         }
2764         break;
2765         case ZBL_ZCL_SCENE_VIEW_SCENE_REQ: {
2766                 zb_zcl_scene_view_scene_rsp cb = container->cb;
2767
2768                 int j = 0;
2769                 int len;
2770                 nwk_addr addr16 = 0;
2771                 unsigned char ep;
2772                 unsigned char status;
2773                 unsigned short group_id;
2774                 unsigned char scene_id;
2775                 unsigned short transition_time = 0;
2776                 unsigned char value;
2777                 unsigned short ext_len = 0;
2778                 char *scene_name = NULL;
2779                 char *extendedFieldSets = NULL;
2780                 GVariantIter *sceneNameIter = NULL;
2781                 GVariantIter *extendedSetIter = NULL;
2782
2783                 g_variant_get(parameters, "(qyyqyqa(y)ya(y))", &addr16, &ep, &status, &group_id, &scene_id,
2784                         &transition_time, &sceneNameIter, &ext_len, &extendedSetIter);
2785
2786                 g_variant_iter_loop(sceneNameIter, "(y)", &value);
2787
2788                 /** first byte indicates the length of the string */
2789                 len = value -'0';
2790                 if (0 < len) {
2791                         scene_name = calloc(len + 1, sizeof(char));
2792                         if (NULL == scene_name) {
2793                                 ERR("calloc() Fail(%d)", errno);
2794                                 goto SCENE_VIEW_SCENE_REQ_OUT;
2795                         }
2796                         scene_name[j] = value;
2797                         j++;
2798                         while (g_variant_iter_loop(sceneNameIter, "(y)", &value)) {
2799                                 scene_name[j] = value;
2800                                 j++;
2801                         }
2802                 } else {
2803                         scene_name = calloc(1 + 1, sizeof(char));
2804                         if (NULL == scene_name) {
2805                                 ERR("calloc() Fail(%d)", errno);
2806                                 goto SCENE_VIEW_SCENE_REQ_OUT;
2807                         }
2808                         scene_name[j] = value;
2809                 }
2810
2811                 j = 0;
2812                 if (0 < ext_len) {
2813                         extendedFieldSets = calloc(ext_len + 1, sizeof(char));
2814                         if (NULL == extendedFieldSets) {
2815                                 ERR("calloc() Fail(%d)", errno);
2816                                 goto SCENE_VIEW_SCENE_REQ_OUT;
2817                         }
2818                         while (g_variant_iter_loop(extendedSetIter, "(y)", &value)) {
2819                                 extendedFieldSets[j] = value;
2820                                 j++;
2821                         }
2822                 }
2823
2824                 cb(addr16, ep, status, group_id, scene_id, transition_time, scene_name,
2825                                 extendedFieldSets, ext_len, container->userdata);
2826
2827 SCENE_VIEW_SCENE_REQ_OUT:
2828                 free(scene_name);
2829                 free(extendedFieldSets);
2830         }
2831         break;
2832         case ZBL_ZCL_SCENE_REMOVE_SCENE_REQ: {
2833                 zb_zcl_scene_remove_scene_rsp cb = container->cb;
2834
2835                 nwk_addr addr16 = 0;
2836                 unsigned char ep;
2837                 unsigned char status;
2838                 unsigned short group_id;
2839                 unsigned char scene_id;
2840
2841                 g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status, &group_id, &scene_id);
2842                 cb(addr16, ep, status, group_id, scene_id, container->userdata);
2843         }
2844         break;
2845         case ZBL_ZCL_SCENE_STORE_SCENE_REQ: {
2846                 zb_zcl_scene_store_scene_rsp cb = container->cb;
2847
2848                 nwk_addr addr16 = 0;
2849                 unsigned char ep;
2850                 unsigned char status;
2851                 unsigned short group_id;
2852                 unsigned char scene_id;
2853
2854                 g_variant_get(parameters, "(qyyqy)", &addr16, &ep, &status, &group_id, &scene_id);
2855                 cb(addr16, ep, status, group_id, scene_id, container->userdata);
2856         }
2857         break;
2858         case ZBL_ZCL_SCENE_REMOVE_ALL_SCENE_REQ: {
2859                 zb_zcl_scene_remove_all_scene_rsp cb = container->cb;
2860
2861                 nwk_addr addr16 = 0;
2862                 unsigned char ep;
2863                 unsigned char status;
2864                 unsigned short group_id;
2865
2866                 g_variant_get(parameters, "(qyyq)", &addr16, &ep, &status, &group_id);
2867                 cb(addr16, ep, status, group_id, container->userdata);
2868         }
2869         break;
2870         case ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ: {
2871                 zb_zcl_scene_get_scene_membership_rsp cb = container->cb;
2872
2873                 int j = 0;
2874                 nwk_addr addr16 = 0;
2875                 unsigned char ep;
2876                 unsigned char status;
2877                 unsigned short group_id;
2878                 unsigned char capacity;
2879                 unsigned char value;
2880                 unsigned char scene_count = 0;
2881                 unsigned char *scene_list = NULL;
2882                 GVariantIter *sceneListIter = NULL;
2883
2884                 g_variant_get(parameters, "(qyyyqya(y))", &addr16, &ep, &status, &capacity, &group_id,
2885                         &scene_count, &sceneListIter);
2886
2887                 if (0 < scene_count) {
2888                         scene_list = calloc(scene_count+1, sizeof(char));
2889                         if (NULL == scene_list) {
2890                                 ERR("calloc() Fail(%d)", errno);
2891                                 goto SCENE_GET_SCENE_MEMBERSHIP_REQ_OUT;
2892                         }
2893                         while (g_variant_iter_loop(sceneListIter, "(y)", &value)) {
2894                                 scene_list[j] = value;
2895                                 DBG("Scene_List 0x%02X", scene_list[j]);
2896                                 j++;
2897                         }
2898                 }
2899
2900                 cb(addr16, ep, status, capacity, group_id, scene_count, scene_list, container->userdata);
2901 SCENE_GET_SCENE_MEMBERSHIP_REQ_OUT:
2902                 free(scene_list);
2903         }
2904         break;
2905         /* ZCL Thermostat */
2906         case ZBL_ZCL_THERMOSTAT_GET_LOCAL_TEMP: {
2907                 ERR("Unhandled cid = %d", container->cid);
2908         }
2909         break;
2910         default:
2911                 ERR("Unhandled cid = %d", container->cid);
2912         }
2913 }
2914
2915 int zbl_set_event_cb(zigbee_h handle, zb_event_cb event_handler)
2916 {
2917         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
2918         handle->event_handler = event_handler;
2919         return ZIGBEE_ERROR_NONE;
2920 }
2921
2922 static gboolean _zbl_timeout_enable(gpointer p)
2923 {
2924         zbl_req_cb_s *container = NULL;
2925         zb_enable_cb cb = NULL;
2926
2927         DBG("zb_enable_cb()");
2928
2929         RETVM_IF(NULL == gdbus_conn, G_SOURCE_REMOVE, "gdbus_conn is NULL");
2930         container = p;
2931         RETVM_IF(NULL == container, G_SOURCE_REMOVE, "cb_container is NULL");
2932         cb = container->cb;
2933
2934         if (false == container->found && container->cb)
2935                 cb(ZB_ZDP_NOT_SUPPORTED, container->userdata);
2936
2937         container->tid = 0;
2938
2939         g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid);
2940         DBG("container->sid=%d unsubscribed");
2941         container->sid = 0;
2942
2943         return G_SOURCE_REMOVE;
2944 }
2945
2946 static void _zbl_enable_cb(GDBusConnection *connection,
2947                 const gchar *sender_name, const gchar *object_path, const gchar *interface_name,
2948                 const gchar *signal_name, GVariant *parameters, gpointer user_data)
2949 {
2950         zbl_req_cb_s *container = user_data;
2951         zb_enable_cb cb = container->cb;
2952
2953         unsigned char ret = ZB_ZDP_SUCCESS;
2954         gboolean value = TRUE;
2955
2956         container->found = true;
2957
2958         DBG("_zbl_enable_cb");
2959
2960         g_variant_get(parameters, "(b)", &value);
2961         if (!value)
2962                 ret = ZB_ZDP_UNKNOWN;
2963
2964         if (cb)
2965                 cb(ret, container->userdata);
2966
2967         if (container->sid)
2968                 g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid);
2969 }
2970
2971
2972 int zbl_enable(zigbee_h handle, zb_enable_cb cb, void *user_data)
2973 {
2974         int sub_id, to;
2975         zbl_req_cb_s *container;
2976
2977         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
2978         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
2979         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
2980
2981         DBG("zbl_enable()");
2982
2983         container = calloc(1, sizeof(zbl_req_cb_s));
2984         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
2985
2986         to = zbl_dbus_get_timeout(manager_gproxy);
2987         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
2988                         ZIGBEE_MANAGER_INTERFACE, "zigbee_state", ZIGBEE_DBUS_OBJPATH,
2989                         NULL, G_DBUS_SIGNAL_FLAGS_NONE,
2990                         _zbl_enable_cb, container, _zbl_request_cleanup);
2991
2992         if (0 == sub_id) {
2993                 ERR("g_dbus_connection_signal_subscribe() Fail");
2994                 free(container);
2995                 return ZIGBEE_ERROR_IO_ERROR;
2996         }
2997
2998         container->cb = cb;
2999         container->sid = sub_id;
3000         container->tid = g_timeout_add_seconds(to, _zbl_timeout_enable, container);
3001         container->userdata = user_data;
3002
3003         g_dbus_proxy_call(manager_gproxy, "enable", NULL,
3004                 G_DBUS_CALL_FLAGS_NONE, to,
3005                 NULL, NULL, container);
3006
3007         return ZIGBEE_ERROR_NONE;
3008 }
3009
3010 int zbl_disable(void)
3011 {
3012         GVariant *variant = NULL;
3013         GError *dbus_err = NULL;
3014         int result = ZIGBEE_ERROR_NONE;
3015
3016         DBG("zbl_disable()");
3017
3018         if (0 >= zbl_ref_count) {
3019                 WARN("dbus does not initiaized\n");
3020                 return ZIGBEE_ERROR_NO_DATA;
3021         }
3022
3023         if (0 > --zbl_ref_count) {
3024                 DBG("all connections closed\n");
3025                 return ZIGBEE_ERROR_NONE;
3026         }
3027
3028         if (gdbus_conn) {
3029                 variant = g_dbus_connection_call_sync(gdbus_conn,
3030                                 ZIGBEE_SERVER_NAME,
3031                                 ZIGBEE_DBUS_OBJPATH,
3032                                 ZIGBEE_DBUS_INTERFACE,
3033                                 "disable",
3034                                 NULL, NULL,
3035                                 G_DBUS_CALL_FLAGS_NONE,
3036                                 -1,
3037                                 NULL,
3038                                 &dbus_err);
3039
3040                 if (!variant) {
3041                         ERR("Failed to get 'disable' [%s]", dbus_err->message);
3042                         g_error_free(dbus_err);
3043                 }
3044
3045                 g_variant_get(variant, "(i)", &result);
3046                 DBG("ret = [0x%x]", result);
3047                 g_variant_unref(variant);
3048
3049                 g_object_unref(manager_gproxy);
3050                 manager_gproxy = NULL;
3051                 g_object_unref(service_gproxy);
3052                 service_gproxy = NULL;
3053                 g_object_unref(on_off_gproxy);
3054                 on_off_gproxy = NULL;
3055                 g_object_unref(door_lock_gproxy);
3056                 door_lock_gproxy = NULL;
3057                 g_object_unref(level_control_gproxy);
3058                 level_control_gproxy = NULL;
3059                 g_object_unref(thermostat_gproxy);
3060                 thermostat_gproxy = NULL;
3061                 g_object_unref(alarm_gproxy);
3062                 alarm_gproxy = NULL;
3063                 g_object_unref(fan_control_gproxy);
3064                 fan_control_gproxy = NULL;
3065
3066                 g_object_unref(mfglib_gproxy);
3067                 mfglib_gproxy = NULL;
3068                 g_object_unref(zcl_global_proxy);
3069                 zcl_global_proxy = NULL;
3070                 g_object_unref(zcl_color_control_proxy);
3071                 zcl_color_control_proxy = NULL;
3072                 g_object_unref(custom_gproxy);
3073                 custom_gproxy = NULL;
3074
3075                 g_object_unref(gdbus_conn);
3076                 gdbus_conn = NULL;
3077         }
3078
3079         return ZIGBEE_ERROR_NONE;
3080 }
3081
3082 int zbl_hw_reset(void)
3083 {
3084         int result = ZIGBEE_ERROR_NONE;
3085         GVariant *variant = NULL;
3086         GError *dbus_err = NULL;
3087
3088         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3089         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3090
3091         variant = g_dbus_proxy_call_sync(service_gproxy, "zb_hw_reset", NULL,
3092                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3093
3094         if (!variant) {
3095                 ERR("Failed to get 'zb_hw_reset' [%s]", dbus_err->message);
3096                 g_error_free(dbus_err);
3097                 return ZIGBEE_ERROR_IO_ERROR;
3098         }
3099
3100         g_variant_get(variant, "(i)", &result);
3101         DBG("ret = [0x%x]", result);
3102         g_variant_unref(variant);
3103
3104         return result;
3105 }
3106
3107 int zbl_get_network_info(ieee_addr addr64, nwk_addr *nodeid, nwk_addr *panid,
3108                 unsigned char *channel, unsigned char *tx_power)
3109 {
3110         GVariant *variant = NULL;
3111         GVariantIter *iter = NULL;
3112         GError *dbus_err = NULL;
3113         int result = ZIGBEE_ERROR_NONE;
3114
3115         nwk_addr _nodeid;
3116         nwk_addr _panid;
3117         unsigned char _radio_channel;
3118         unsigned char _radio_tx_power;
3119         unsigned char value;
3120         int i = 0;
3121
3122         DBG("zbl_get_network_info()");
3123         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3124         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3125
3126         variant = g_dbus_proxy_call_sync(service_gproxy, "get_network_info",
3127                                 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3128
3129         if (!variant) {
3130                 ERR("Failed to 'get_network_info' [%s]", dbus_err->message);
3131                 g_error_free(dbus_err);
3132                 return ZIGBEE_ERROR_IO_ERROR;
3133         }
3134
3135         g_variant_get(variant, "(ia(y)qqyy)", &result, &iter,
3136                                 &_nodeid, &_panid, &_radio_channel, &_radio_tx_power);
3137
3138         /* Get EUI */
3139         i = 0;
3140         while (g_variant_iter_loop(iter, "(y)", &value)) {
3141                 addr64[i] = value;
3142                 i++;
3143         }
3144
3145         DBG("  Result: [%X]", result);
3146         DBG("  EUI(%d) : %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", i,
3147                         addr64[0], addr64[1], addr64[2], addr64[3],
3148                         addr64[4], addr64[5], addr64[6], addr64[7]);
3149         DBG("  nodeID [0x%04X]", _nodeid);
3150         DBG("  PanID [0x%04X]", _panid);
3151         DBG("  Channel [%d] Tx Power [%d]", _radio_channel, _radio_tx_power);
3152
3153         if (nodeid)
3154                 *nodeid = _nodeid;
3155         if (panid)
3156                 *panid = _panid;
3157         if (channel)
3158                 *channel = _radio_channel;
3159         if (tx_power)
3160                 *tx_power = _radio_tx_power;
3161
3162         if (iter)
3163                 g_variant_iter_free(iter);
3164         g_variant_unref(variant);
3165
3166         return result;
3167 }
3168
3169 int zbl_get_controller_mac_address(ieee_addr addr64)
3170 {
3171         GVariant *variant = NULL;
3172         GVariantIter *iter = NULL;
3173         GError *dbus_err = NULL;
3174
3175         char value;
3176         int j = 0;
3177         int result = ZIGBEE_ERROR_NONE;
3178
3179         DBG("zbl_get_controller_mac_address()");
3180         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3181         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3182
3183         variant = g_dbus_proxy_call_sync(service_gproxy, "get_mac",
3184                         NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3185
3186         if (!variant) {
3187                 ERR("Failed to get_mac [%s]", dbus_err->message);
3188                 g_error_free(dbus_err);
3189                 return ZIGBEE_ERROR_IO_ERROR;
3190         }
3191         g_variant_get(variant, "(ia(y))", &result, &iter);
3192
3193         while (g_variant_iter_loop(iter, "(y)", &value)) {
3194                 addr64[j] = value;
3195                 j++;
3196         }
3197
3198         DBG("IEEE ADDR 0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X:0x%02X, Ret=%d ",
3199                 addr64[0], addr64[1], addr64[2], addr64[3], addr64[4], addr64[5],
3200                 addr64[6], addr64[7], result);
3201
3202         if (iter)
3203                 g_variant_iter_free(iter);
3204         g_variant_unref(variant);
3205
3206         return result;
3207 }
3208
3209 int zbl_get_cluster_list(ieee_addr eui64, unsigned char endpoint,
3210                 unsigned char *in_cluster_count, unsigned short in_cluster_list[],
3211                 unsigned char *out_cluster_count, unsigned short out_cluster_list[])
3212 {
3213         GVariant *variant = NULL;
3214         GVariantBuilder *mac_builder = NULL;
3215         GVariant *mac_variant = NULL;
3216         GVariantIter *in_cluster_iter = NULL;
3217         GVariantIter *out_cluster_iter = NULL;
3218         GError *dbus_err = NULL;
3219         unsigned short cluster = 0;
3220         int i = 0;
3221         int result = 0;
3222
3223         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3224         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3225
3226         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
3227         g_variant_builder_add(mac_builder, "(y)", eui64[7]);
3228         g_variant_builder_add(mac_builder, "(y)", eui64[6]);
3229         g_variant_builder_add(mac_builder, "(y)", eui64[5]);
3230         g_variant_builder_add(mac_builder, "(y)", eui64[4]);
3231         g_variant_builder_add(mac_builder, "(y)", eui64[3]);
3232         g_variant_builder_add(mac_builder, "(y)", eui64[2]);
3233         g_variant_builder_add(mac_builder, "(y)", eui64[1]);
3234         g_variant_builder_add(mac_builder, "(y)", eui64[0]);
3235         mac_variant = g_variant_builder_end(mac_builder);
3236         g_variant_builder_unref(mac_builder);
3237
3238         variant = g_dbus_proxy_call_sync(service_gproxy, "get_cluster_list",
3239                                 g_variant_new("(@a(y)y)", mac_variant, endpoint), G_DBUS_CALL_FLAGS_NONE,
3240                                 -1, NULL, &dbus_err);
3241
3242         if (variant) {
3243                 g_variant_get(variant, "(iaqaq)", &result, &in_cluster_iter, &out_cluster_iter);
3244                 DBG("ret = [0x%x]", result);
3245
3246                 /* In clusters */
3247                 while (g_variant_iter_loop(in_cluster_iter, "q", &cluster)) {
3248                         DBG("In Cluster 0x%04X", cluster);
3249                         in_cluster_list[i++] = cluster;
3250                 }
3251                 *in_cluster_count = i;
3252                 if (0 == i)
3253                         ERR("No In Clusters for Endpoint %0X", endpoint);
3254
3255                 /* Out clusters */
3256                 i = 0;
3257                 while (g_variant_iter_loop(out_cluster_iter, "q", &cluster)) {
3258                         DBG("Out Cluster 0x%04X", cluster);
3259                         out_cluster_list[i++] = cluster;
3260                 }
3261                 *out_cluster_count = i;
3262                 if (0 == i)
3263                         ERR("No Out Clusters for Endpoint %0X", endpoint);
3264
3265                 if (NULL != in_cluster_iter)
3266                         g_variant_iter_free(in_cluster_iter);
3267                 if (NULL != out_cluster_iter)
3268                         g_variant_iter_free(out_cluster_iter);
3269                 g_variant_unref(variant);
3270         } else {
3271                 ERR("No In/Out Clusters for Endpoint %0X [%s]", endpoint, dbus_err->message);
3272                 g_error_free(dbus_err);
3273                 *in_cluster_count = 0;
3274                 *out_cluster_count = 0;
3275         }
3276
3277         return ZIGBEE_ERROR_NONE;
3278 }
3279
3280 int zbl_get_endpoint_list(ieee_addr eui64, unsigned char *count, unsigned char list[])
3281 {
3282         GVariant *variant = NULL;
3283         GVariantBuilder *mac_builder = NULL;
3284         GVariant *mac_variant = NULL;
3285         GVariantIter *iter = NULL;
3286         GError *dbus_err = NULL;
3287         unsigned char endpoint;
3288         int i = 0;
3289         int result = ZIGBEE_ERROR_NONE;
3290
3291         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3292         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3293
3294         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
3295         g_variant_builder_add(mac_builder, "(y)", eui64[7]);
3296         g_variant_builder_add(mac_builder, "(y)", eui64[6]);
3297         g_variant_builder_add(mac_builder, "(y)", eui64[5]);
3298         g_variant_builder_add(mac_builder, "(y)", eui64[4]);
3299         g_variant_builder_add(mac_builder, "(y)", eui64[3]);
3300         g_variant_builder_add(mac_builder, "(y)", eui64[2]);
3301         g_variant_builder_add(mac_builder, "(y)", eui64[1]);
3302         g_variant_builder_add(mac_builder, "(y)", eui64[0]);
3303         mac_variant = g_variant_builder_end(mac_builder);
3304         g_variant_builder_unref(mac_builder);
3305
3306         variant = g_dbus_proxy_call_sync(service_gproxy, "get_endpoint_list",
3307                 g_variant_new("(@a(y))", mac_variant),
3308                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3309
3310         if (variant) {
3311                 g_variant_get(variant, "(ia(y))", &result, &iter);
3312                 DBG("ret = [0x%x]", result);
3313
3314                 while (g_variant_iter_loop(iter, "(y)", &endpoint)) {
3315                         DBG("Endpoint 0x%X", endpoint);
3316                         list[i++] = endpoint;
3317                 }
3318                 if (i > 0) {
3319                         *count = i;
3320                         DBG("Endpoint Count %d", i);
3321                 } else {
3322                         ERR("No Endpoints");
3323                         *count = 0;
3324                 }
3325                 if (NULL != iter)
3326                         g_variant_iter_free(iter);
3327                 g_variant_unref(variant);
3328
3329         } else {
3330                 ERR("NULL Variant");
3331                 ERR("No Endpoints");
3332                 ERR("[%s]", dbus_err->message);
3333                 g_error_free(dbus_err);
3334                 *count = 0;
3335         }
3336
3337         return ZIGBEE_ERROR_NONE;
3338 }
3339
3340 int zbl_api_get_node_type(ieee_addr eui64, unsigned char *node_type)
3341 {
3342         GVariant *variant = NULL;
3343         GVariantBuilder *mac_builder = NULL;
3344         int result = ZIGBEE_ERROR_NONE;
3345         GVariant *mac_variant = NULL;
3346         GError *dbus_err = NULL;
3347
3348         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3349         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3350
3351         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
3352         g_variant_builder_add(mac_builder, "(y)", eui64[7]);
3353         g_variant_builder_add(mac_builder, "(y)", eui64[6]);
3354         g_variant_builder_add(mac_builder, "(y)", eui64[5]);
3355         g_variant_builder_add(mac_builder, "(y)", eui64[4]);
3356         g_variant_builder_add(mac_builder, "(y)", eui64[3]);
3357         g_variant_builder_add(mac_builder, "(y)", eui64[2]);
3358         g_variant_builder_add(mac_builder, "(y)", eui64[1]);
3359         g_variant_builder_add(mac_builder, "(y)", eui64[0]);
3360         mac_variant = g_variant_builder_end(mac_builder);
3361         g_variant_builder_unref(mac_builder);
3362
3363         variant = g_dbus_proxy_call_sync(service_gproxy, "get_node_type",
3364                 g_variant_new("(@a(y))", mac_variant),
3365                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3366
3367         if (!variant) {
3368                 ERR("Failed to get 'get_node_type' [%s]", dbus_err->message);
3369                 g_error_free(dbus_err);
3370                 return ZIGBEE_ERROR_IO_ERROR;
3371         }
3372
3373         g_variant_get(variant, "(i)", &result);
3374         DBG("ret = [0x%x]", result);
3375         g_variant_unref(variant);
3376
3377         return result;
3378 }
3379
3380 int zbl_get_all_device_info(zb_end_device_info_h **dev_list, unsigned char* num)
3381 {
3382         int i = 0;
3383         int j = 0;
3384         int k = 0;
3385         struct zb_end_device_info_s **list;
3386         GVariant *variant = NULL;
3387         GVariantIter *iter = NULL;
3388         GVariantIter *mac_iter = NULL;
3389         GVariantIter *endpoint_iter = NULL;
3390         GError *dbus_err = NULL;
3391         int result = 0;
3392         unsigned short node_id;
3393         unsigned char node_type;
3394         unsigned char node_mac_address[8] = {0x00};
3395         unsigned char endpoint_cnt = 0;
3396         unsigned char value;
3397         unsigned char value_endpoint;
3398
3399         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3400         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3401
3402         /* check the format string when there are no input args */
3403         variant = g_dbus_proxy_call_sync(service_gproxy, "get_device_info",
3404                                 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3405
3406         if (variant) {
3407                 g_variant_get(variant, "(ia(qyayyay))", &result, &iter);
3408                 DBG("ret = [0x%x]", result);
3409
3410                 list = calloc(MAX_DEVICE_LIST+1, sizeof(zb_end_device_info_h));
3411                 RETV_IF(NULL == list, ZIGBEE_ERROR_OUT_OF_MEMORY);
3412                 for (i = 0; i < MAX_DEVICE_LIST && list; i++) {
3413                         list[i] = calloc(1, sizeof(struct zb_end_device_info_s));
3414                         if (NULL == list[i]) {
3415                                 for (j = 0; j < i; j++)
3416                                         free(list[j]);
3417                                 free(list);
3418                                 g_variant_unref(variant);
3419                                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
3420                         }
3421                 }
3422
3423                 i = 0;
3424                 while (g_variant_iter_loop(iter, "(qyayyay)", &node_id, &node_type, &mac_iter,
3425                                 &endpoint_cnt, &endpoint_iter)) {
3426                         j = 0;
3427                         k = 0;
3428                         /* Get Network Address */
3429                         list[i]->addr16 = node_id;
3430                         DBG("Node ID: 0x%04X", node_id);
3431                         /* Get Node Type */
3432                         list[i]->node_type = node_type;
3433                         DBG("Node Type : 0x%02X", node_type);
3434                         /* Get End-Point count */
3435                         list[i]->num_of_ep = endpoint_cnt;
3436                         DBG("Endpoint Count: 0x%X", endpoint_cnt);
3437                         /* Get End-Point list */
3438                         list[i]->num_of_ep = endpoint_cnt;
3439                         while (g_variant_iter_loop(endpoint_iter, "y", &value_endpoint)) {
3440                                 list[i]->ep[k] = value_endpoint;
3441                                 DBG("Endpoint : %d", value_endpoint);
3442                                 k++;
3443                         }
3444                         /* Get IEEE address */
3445                         while (g_variant_iter_loop(mac_iter, "y", &value)) {
3446                                 node_mac_address[j] = value;
3447                                 j++;
3448                         }
3449                         memcpy(list[i]->addr64, node_mac_address, sizeof(ieee_addr));
3450                         DBG("Node MAC Addr : %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
3451                                 node_mac_address[0], node_mac_address[1], node_mac_address[2],
3452                                 node_mac_address[3], node_mac_address[4], node_mac_address[5],
3453                                 node_mac_address[6], node_mac_address[7]);
3454                         i++;
3455
3456                 }
3457                 if (0 == i)
3458                         ERR("No attached nodes");
3459
3460                 *num = i;
3461                 *dev_list = list;
3462                 if (NULL != iter)
3463                         g_variant_iter_free(iter);
3464                 g_variant_unref(variant);
3465         } else {
3466                 ERR("NULL Variant [%s]", dbus_err->message);
3467                 ERR("No attached nodes");
3468                 g_error_free(dbus_err);
3469                 *num = 0;
3470         }
3471
3472         return ZIGBEE_ERROR_NONE;
3473 }
3474
3475 int zbl_coex_start(unsigned char channel)
3476 {
3477         int result = ZIGBEE_ERROR_NONE;
3478         GVariant *variant = NULL;
3479         GError *dbus_err = NULL;
3480
3481         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3482         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3483
3484         variant = g_dbus_proxy_call_sync(service_gproxy, "coex_start", g_variant_new("(y)", channel),
3485                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3486
3487         if (!variant) {
3488                 ERR("Failed to get 'coex_start' [%s]", dbus_err->message);
3489                 g_error_free(dbus_err);
3490                 return ZIGBEE_ERROR_IO_ERROR;
3491         }
3492
3493         g_variant_get(variant, "(i)", &result);
3494         DBG("ret = [0x%x]", result);
3495         g_variant_unref(variant);
3496
3497         return result;
3498 }
3499
3500 int zbl_coex_stop(void)
3501 {
3502         int result = ZIGBEE_ERROR_NONE;
3503         GVariant *variant = NULL;
3504         GError *dbus_err = NULL;
3505
3506         DBG("zbl_coex_stop()");
3507
3508         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3509         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3510
3511         variant = g_dbus_proxy_call_sync(service_gproxy, "coex_stop", NULL,
3512                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3513
3514         if (!variant) {
3515                 ERR("Failed to get 'coex_stop' [%s]", dbus_err->message);
3516                 g_error_free(dbus_err);
3517                 return ZIGBEE_ERROR_IO_ERROR;
3518         }
3519
3520         g_variant_get(variant, "(i)", &result);
3521         DBG("ret = [0x%x]", result);
3522         g_variant_unref(variant);
3523
3524         return result;
3525 }
3526
3527 int zbl_form_network(zigbee_h handle, zb_form_network_cb cb, void *user_data)
3528 {
3529         int sub_id, to;
3530         zbl_req_cb_s *container;
3531
3532         int result = ZIGBEE_ERROR_NONE;
3533         GVariant *variant = NULL;
3534         GError *dbus_err = NULL;
3535
3536         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3537         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3538
3539         container = calloc(1, sizeof(zbl_req_cb_s));
3540         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
3541
3542         to = zbl_dbus_get_timeout(service_gproxy);
3543         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
3544                         ZIGBEE_SERVICE_INTERFACE,  "form_network_done", ZIGBEE_SERVICE_OBJECT_PATH, NULL, 0,
3545                         _zbl_response_cb, container, _zbl_request_cleanup);
3546
3547         if (0 == sub_id) {
3548                 ERR("g_dbus_connection_signal_subscribe() Fail");
3549                 free(container);
3550                 return ZIGBEE_ERROR_IO_ERROR;
3551         }
3552
3553         container->cb = cb;
3554         container->sid = sub_id;
3555         container->cid = ZBL_SERVICE_FORM_NETWORK;
3556         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
3557         container->userdata = user_data;
3558
3559         variant = g_dbus_proxy_call_sync(service_gproxy, "form_network", NULL,
3560                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
3561
3562         if (!variant) {
3563                 ERR("Failed to get 'form_network' [%s]", dbus_err->message);
3564                 g_error_free(dbus_err);
3565                 return ZIGBEE_ERROR_IO_ERROR;
3566         }
3567
3568         g_variant_get(variant, "(i)", &result);
3569         DBG("ret = [0x%x]", result);
3570         g_variant_unref(variant);
3571
3572         return result;
3573 }
3574
3575 int zbl_disable_network(zigbee_h handle, zb_disable_network_cb cb, void *user_data)
3576 {
3577         int sub_id, to;
3578         zbl_req_cb_s *container;
3579
3580         int result = ZIGBEE_ERROR_NONE;
3581         GVariant *variant = NULL;
3582         GError *dbus_err = NULL;
3583
3584         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3585         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3586
3587         DBG("zbl_disable_network()");
3588
3589         container = calloc(1, sizeof(zbl_req_cb_s));
3590         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
3591
3592         to = zbl_dbus_get_timeout(service_gproxy);
3593         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
3594                         ZIGBEE_SERVICE_INTERFACE,  "disable_network_done", ZIGBEE_SERVICE_OBJECT_PATH, NULL, 0,
3595                         _zbl_response_cb, container, _zbl_request_cleanup);
3596
3597         if (0 == sub_id) {
3598                 ERR("g_dbus_connection_signal_subscribe() Fail");
3599                 free(container);
3600                 return ZIGBEE_ERROR_IO_ERROR;
3601         }
3602
3603         container->cb = cb;
3604         container->sid = sub_id;
3605         container->cid = ZBL_SERVICE_DISABLE_NETWORK;
3606         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
3607         container->userdata = user_data;
3608
3609         variant = g_dbus_proxy_call_sync(service_gproxy, "leave_network", NULL,
3610                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
3611
3612         if (!variant) {
3613                 ERR("Failed to get 'leave_network' [%s]", dbus_err->message);
3614                 g_error_free(dbus_err);
3615                 return ZIGBEE_ERROR_IO_ERROR;
3616         }
3617
3618         g_variant_get(variant, "(i)", &result);
3619         DBG("ret = [0x%x]", result);
3620         g_variant_unref(variant);
3621
3622         return result;
3623 }
3624
3625 int zbl_leave_device(ieee_addr addr64, bool remove_children, bool rejoin)
3626 {
3627         int result = ZIGBEE_ERROR_NONE;
3628         GVariant *variant = NULL;
3629         GError *dbus_err = NULL;
3630
3631         GVariantBuilder *mac_builder = NULL;
3632         GVariant* mac_variant = NULL;
3633         unsigned char _remove_children = (remove_children) ? 1 : 0;
3634         unsigned char _rejoin = (rejoin) ? 1 : 0;
3635
3636         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3637         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3638
3639         DBG("IEEE Address = %X:%X:%X:%X:%X:%X:%X:%X",
3640                 addr64[0], addr64[1], addr64[2], addr64[3],
3641                 addr64[4], addr64[5], addr64[6], addr64[7]);
3642
3643         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
3644         g_variant_builder_add(mac_builder, "(y)", addr64[7]);
3645         g_variant_builder_add(mac_builder, "(y)", addr64[6]);
3646         g_variant_builder_add(mac_builder, "(y)", addr64[5]);
3647         g_variant_builder_add(mac_builder, "(y)", addr64[4]);
3648         g_variant_builder_add(mac_builder, "(y)", addr64[3]);
3649         g_variant_builder_add(mac_builder, "(y)", addr64[2]);
3650         g_variant_builder_add(mac_builder, "(y)", addr64[1]);
3651         g_variant_builder_add(mac_builder, "(y)", addr64[0]);
3652         mac_variant = g_variant_builder_end(mac_builder);
3653         g_variant_builder_unref(mac_builder);
3654
3655         variant = g_dbus_proxy_call_sync(service_gproxy, "leave_request",
3656                 g_variant_new("(@a(y)yy)", mac_variant, _remove_children, _rejoin),
3657                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3658
3659         if (!variant) {
3660                 ERR("Failed to get 'leave_request' [%s]", dbus_err->message);
3661                 g_error_free(dbus_err);
3662                 return ZIGBEE_ERROR_IO_ERROR;
3663         }
3664
3665         g_variant_get(variant, "(i)", &result);
3666         DBG("ret = [0x%x]", result);
3667         g_variant_unref(variant);
3668
3669         return result;
3670 }
3671
3672 int zbl_permit_join(unsigned char duration, bool broadcast)
3673 {
3674         int result = ZIGBEE_ERROR_NONE;
3675         GVariant *variant = NULL;
3676         GError *dbus_err = NULL;
3677
3678         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3679         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
3680
3681         variant = g_dbus_proxy_call_sync(service_gproxy, "permit_join",
3682                 g_variant_new("(ib)", duration, broadcast),     G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
3683
3684         if (!variant) {
3685                 ERR("Failed to get 'permit_join' [%s]", dbus_err->message);
3686                 g_error_free(dbus_err);
3687                 return ZIGBEE_ERROR_IO_ERROR;
3688         }
3689
3690         g_variant_get(variant, "(i)", &result);
3691         DBG("ret = [0x%x]", result);
3692         g_variant_unref(variant);
3693
3694         return result;
3695 }
3696
3697 int zbl_nwk_addr_req(zigbee_h handle, ieee_addr addr64, unsigned char request_type,
3698         unsigned char start_idx, zb_zdo_addr_rsp cb, void *user_data)
3699 {
3700         int sub_id, to;
3701         zbl_req_cb_s *container;
3702         GVariantBuilder *mac_builder = NULL;
3703         GVariant* mac_variant = NULL;
3704
3705         int result = ZIGBEE_ERROR_NONE;
3706         GVariant *variant = NULL;
3707         GError *dbus_err = NULL;
3708
3709         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3710         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
3711
3712         DBG(" zbl_nwk_addr_req()");
3713
3714         container = calloc(1, sizeof(zbl_req_cb_s));
3715         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
3716
3717         to = zbl_dbus_get_timeout(zdo_dev_proxy);
3718         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
3719                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "nwk_addr_rsp",
3720                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container,
3721                         _zbl_request_cleanup);
3722
3723         if (0 == sub_id) {
3724                 ERR("g_dbus_connection_signal_subscribe() Fail");
3725                 free(container);
3726                 return ZIGBEE_ERROR_IO_ERROR;
3727         }
3728
3729         container->cb = cb;
3730         container->sid = sub_id;
3731         container->cid = ZBL_ZDO_NWK_ADDR_REQ;
3732         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
3733         container->userdata = user_data;
3734
3735         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
3736         g_variant_builder_add(mac_builder, "(y)", addr64[7]);
3737         g_variant_builder_add(mac_builder, "(y)", addr64[6]);
3738         g_variant_builder_add(mac_builder, "(y)", addr64[5]);
3739         g_variant_builder_add(mac_builder, "(y)", addr64[4]);
3740         g_variant_builder_add(mac_builder, "(y)", addr64[3]);
3741         g_variant_builder_add(mac_builder, "(y)", addr64[2]);
3742         g_variant_builder_add(mac_builder, "(y)", addr64[1]);
3743         g_variant_builder_add(mac_builder, "(y)", addr64[0]);
3744         mac_variant = g_variant_builder_end(mac_builder);
3745         g_variant_builder_unref(mac_builder);
3746
3747         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "nwk_addr_req",
3748                 g_variant_new("(@a(y)yy)", mac_variant, request_type, start_idx),
3749                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
3750
3751         if (!variant) {
3752                 ERR("Failed to get 'nwk_addr_req' [%s]", dbus_err->message);
3753                 g_error_free(dbus_err);
3754                 return ZIGBEE_ERROR_IO_ERROR;
3755         }
3756
3757         g_variant_get(variant, "(i)", &result);
3758         DBG("ret = [0x%x]", result);
3759         g_variant_unref(variant);
3760
3761         return result;
3762 }
3763
3764 int zbl_ieee_addr_req(zigbee_h handle, nwk_addr addr16, zb_zdo_addr_rsp cb,
3765                 void *user_data)
3766 {
3767         int sub_id, to;
3768         zbl_req_cb_s *container;
3769
3770         int result = ZIGBEE_ERROR_NONE;
3771         GVariant *variant = NULL;
3772         GError *dbus_err = NULL;
3773
3774         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3775         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
3776
3777         DBG("zbl_ieee_addr_req()");
3778
3779         container = calloc(1, sizeof(zbl_req_cb_s));
3780         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
3781
3782         to = zbl_dbus_get_timeout(zdo_dev_proxy);
3783         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
3784                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "nwk_addr_rsp",
3785                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
3786                         _zbl_response_cb, container, _zbl_request_cleanup);
3787
3788         if (0 == sub_id) {
3789                 ERR("g_dbus_connection_signal_subscribe() Fail");
3790                 free(container);
3791                 return ZIGBEE_ERROR_IO_ERROR;
3792         }
3793
3794         container->cb = cb;
3795         container->sid = sub_id;
3796         container->cid = ZBL_ZDO_NWK_ADDR_REQ;
3797         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
3798         container->userdata = user_data;
3799
3800         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "ieee_addr_req", g_variant_new("(q)", addr16),
3801                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
3802
3803         if (!variant) {
3804                 ERR("Failed to get 'ieee_addr_req' [%s]", dbus_err->message);
3805                 g_error_free(dbus_err);
3806                 return ZIGBEE_ERROR_IO_ERROR;
3807         }
3808
3809         g_variant_get(variant, "(i)", &result);
3810         DBG("ret = [0x%x]", result);
3811         g_variant_unref(variant);
3812
3813         return result;
3814 }
3815
3816 int zbl_active_ep(zigbee_h handle, nwk_addr addr16, zb_zdo_active_ep_rsp cb,
3817                 void *user_data)
3818 {
3819         int sub_id, to;
3820         zbl_req_cb_s *container;
3821
3822         int result = ZIGBEE_ERROR_NONE;
3823         GVariant *variant = NULL;
3824         GError *dbus_err = NULL;
3825
3826         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3827         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
3828
3829         DBG("zbl_active_ep()");
3830
3831         container = calloc(1, sizeof(zbl_req_cb_s));
3832         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
3833
3834         to = zbl_dbus_get_timeout(zdo_dev_proxy);
3835         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
3836                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "active_ep_rsp",
3837                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
3838                         _zbl_response_cb, container, _zbl_request_cleanup);
3839
3840         if (0 == sub_id) {
3841                 ERR("g_dbus_connection_signal_subscribe() Fail");
3842                 free(container);
3843                 return ZIGBEE_ERROR_IO_ERROR;
3844         }
3845
3846         container->cb = cb;
3847         container->sid = sub_id;
3848         container->cid = ZBL_ZDO_ACTIVE_EP_REQ;
3849         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
3850         container->userdata = user_data;
3851
3852         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "active_ep_req",
3853                 g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
3854
3855         if (!variant) {
3856                 ERR("Failed to get 'active_ep_req' [%s]", dbus_err->message);
3857                 g_error_free(dbus_err);
3858                 return ZIGBEE_ERROR_IO_ERROR;
3859         }
3860
3861         g_variant_get(variant, "(i)", &result);
3862         DBG("ret = [0x%x]", result);
3863         g_variant_unref(variant);
3864
3865         return result;
3866 }
3867
3868 int zbl_simple_desc_req(zigbee_h handle, nwk_addr addr16, unsigned char ep,
3869                 zb_zdo_simple_desc_rsp cb, void *user_data)
3870 {
3871         int sub_id, to;
3872         zbl_req_cb_s *container;
3873
3874         int result = ZIGBEE_ERROR_NONE;
3875         GVariant *variant = NULL;
3876         GError *dbus_err = NULL;
3877
3878         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3879         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
3880
3881         DBG("zbl_simple_desc_req() : [%X]", addr16);
3882
3883         container = calloc(1, sizeof(zbl_req_cb_s));
3884         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
3885
3886         to = zbl_dbus_get_timeout(zdo_dev_proxy);
3887         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
3888                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "simple_desc_rsp",
3889                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
3890                         _zbl_response_cb, container, _zbl_request_cleanup);
3891
3892         if (0 == sub_id) {
3893                 ERR("g_dbus_connection_signal_subscribe() Fail");
3894                 free(container);
3895                 return ZIGBEE_ERROR_IO_ERROR;
3896         }
3897
3898         container->cb = cb;
3899         container->sid = sub_id;
3900         container->cid = ZBL_ZDO_SIMPLE_DESC_REQ;
3901         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
3902         container->userdata = user_data;
3903
3904         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "simple_desc_req",
3905                 g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
3906
3907         if (!variant) {
3908                 ERR("Failed to get 'simple_desc_req' [%s]", dbus_err->message);
3909                 g_error_free(dbus_err);
3910                 return ZIGBEE_ERROR_IO_ERROR;
3911         }
3912
3913         g_variant_get(variant, "(i)", &result);
3914         DBG("ret = [0x%x]", result);
3915         g_variant_unref(variant);
3916
3917         return result;
3918 }
3919
3920 #ifdef ZB_SUPPORT_PRIORITY_5
3921 int zbl_extended_simple_desc_req(zigbee_h handle, nwk_addr addr16,
3922                 unsigned char start_idx, zb_zdo_extended_simple_desc_rsp cb, void *user_data)
3923 {
3924         return ZIGBEE_ERROR_NOT_SUPPORTED;
3925 }
3926 #endif /* ZB_SUPPORT_PRIORITY_5 */
3927
3928 int zbl_match_desc_req(zigbee_h handle, nwk_addr addr16,
3929                 unsigned short profile_id, unsigned char num_in_clusters,
3930                 unsigned short *in_clusters, unsigned char num_out_clusters,
3931                 unsigned short *out_clusters, zb_zdo_match_desc_rsp cb, void *user_data)
3932 {
3933         int sub_id, to;
3934         zbl_req_cb_s *container;
3935
3936         int result = ZIGBEE_ERROR_NONE;
3937         GVariant *variant = NULL;
3938         GError *dbus_err = NULL;
3939
3940         int i;
3941         GVariantBuilder *incl_builder = NULL;
3942         GVariant* incl_variant = NULL;
3943         GVariantBuilder *outcl_builder = NULL;
3944         GVariant* outcl_variant = NULL;
3945
3946         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
3947         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
3948
3949         DBG("zbl_match_desc_req()");
3950
3951         container = calloc(1, sizeof(zbl_req_cb_s));
3952         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
3953
3954         to = zbl_dbus_get_timeout(zdo_dev_proxy);
3955         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
3956                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "matched_descriptor_rsp",
3957                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
3958                         _zbl_response_cb, container, _zbl_request_cleanup);
3959
3960         if (0 == sub_id) {
3961                 ERR("g_dbus_connection_signal_subscribe() Fail");
3962                 free(container);
3963                 return ZIGBEE_ERROR_IO_ERROR;
3964         }
3965
3966         container->cb = cb;
3967         container->sid = sub_id;
3968         container->cid = ZBL_ZDO_MATCHED_DESCRIPTOR_REQ;
3969         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
3970         container->userdata = user_data;
3971
3972         incl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
3973         for (i = 0; i < num_in_clusters; i++)
3974                 g_variant_builder_add(incl_builder, "q", in_clusters[i]);
3975
3976         outcl_builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
3977         for (i = 0; i < num_out_clusters; i++)
3978                 g_variant_builder_add(outcl_builder, "q", out_clusters[i]);
3979
3980         incl_variant = g_variant_builder_end(incl_builder);
3981         outcl_variant = g_variant_builder_end(outcl_builder);
3982         g_variant_builder_unref(incl_builder);
3983         g_variant_builder_unref(outcl_builder);
3984
3985         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "matched_descriptor_req",
3986                 g_variant_new("(qqy@aqy@aq)", addr16, profile_id, num_in_clusters,
3987                 incl_variant, num_out_clusters, outcl_variant),
3988                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
3989
3990         if (!variant) {
3991                 ERR("Failed to get 'matched_descriptor_req' [%s]", dbus_err->message);
3992                 g_error_free(dbus_err);
3993                 return ZIGBEE_ERROR_IO_ERROR;
3994         }
3995
3996         g_variant_get(variant, "(i)", &result);
3997         DBG("ret = [0x%x]", result);
3998         g_variant_unref(variant);
3999
4000         return result;
4001 }
4002
4003 int zbl_node_desc_req(nwk_addr addr16, zb_zdo_node_desc_rsp cb, void *user_data)
4004 {
4005         int sub_id, to;
4006         zbl_req_cb_s *container;
4007
4008         int result = ZIGBEE_ERROR_NONE;
4009         GVariant *variant = NULL;
4010         GError *dbus_err = NULL;
4011
4012         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4013         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4014
4015         DBG("zbl_node_desc_req()");
4016
4017         container = calloc(1, sizeof(zbl_req_cb_s));
4018         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4019
4020         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4021         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4022                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "node_desc_rsp",
4023                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
4024                         _zbl_response_cb, container, _zbl_request_cleanup);
4025
4026         if (0 == sub_id) {
4027                 ERR("g_dbus_connection_signal_subscribe() Fail");
4028                 free(container);
4029                 return ZIGBEE_ERROR_IO_ERROR;
4030         }
4031
4032         container->cb = cb;
4033         container->sid = sub_id;
4034         container->cid = ZBL_ZDO_NODE_DESC_REQ;
4035         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4036         container->userdata = user_data;
4037
4038         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "node_desc_req",
4039                 g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4040
4041         if (!variant) {
4042                 ERR("Failed to get 'node_desc_req' [%s]", dbus_err->message);
4043                 g_error_free(dbus_err);
4044                 return ZIGBEE_ERROR_IO_ERROR;
4045         }
4046
4047         g_variant_get(variant, "(i)", &result);
4048         DBG("ret = [0x%x]", result);
4049         g_variant_unref(variant);
4050
4051         return result;
4052 }
4053
4054 int zbl_power_desc_req(nwk_addr addr16, zb_zdo_power_desc_rsp cb,       void *user_data)
4055 {
4056         int sub_id, to;
4057         zbl_req_cb_s *container;
4058
4059         int result = ZIGBEE_ERROR_NONE;
4060         GVariant *variant = NULL;
4061         GError *dbus_err = NULL;
4062
4063         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4064         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4065
4066         container = calloc(1, sizeof(zbl_req_cb_s));
4067         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4068
4069         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4070         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4071                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "power_desc_rsp",
4072                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
4073                         _zbl_response_cb, container, _zbl_request_cleanup);
4074
4075         if (0 == sub_id) {
4076                 ERR("g_dbus_connection_signal_subscribe() Fail");
4077                 free(container);
4078                 return ZIGBEE_ERROR_IO_ERROR;
4079         }
4080
4081         container->cb = cb;
4082         container->sid = sub_id;
4083         container->cid = ZBL_ZDO_POWER_DESC_REQ;
4084         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4085         container->userdata = user_data;
4086
4087         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "power_desc_req",
4088                 g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4089
4090         if (!variant) {
4091                 ERR("Failed to get 'power_desc_req' [%s]", dbus_err->message);
4092                 g_error_free(dbus_err);
4093                 return ZIGBEE_ERROR_IO_ERROR;
4094         }
4095
4096         g_variant_get(variant, "(i)", &result);
4097         DBG("ret = [0x%x]", result);
4098         g_variant_unref(variant);
4099
4100         return result;
4101 }
4102
4103 int zbl_complex_desc_req(nwk_addr addr16, zb_zdo_complex_desc_rsp cb, void *user_data)
4104 {
4105         int sub_id, to;
4106         zbl_req_cb_s *container;
4107
4108         int result = ZIGBEE_ERROR_NONE;
4109         GVariant *variant = NULL;
4110         GError *dbus_err = NULL;
4111
4112         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4113         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4114
4115         container = calloc(1, sizeof(zbl_req_cb_s));
4116         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4117
4118         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4119         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4120                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "complex_desc_rsp",
4121                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
4122                         _zbl_response_cb, container, _zbl_request_cleanup);
4123
4124         if (0 == sub_id) {
4125                 ERR("g_dbus_connection_signal_subscribe() Fail");
4126                 free(container);
4127                 return ZIGBEE_ERROR_IO_ERROR;
4128         }
4129
4130         container->cb = cb;
4131         container->sid = sub_id;
4132         container->cid = ZBL_ZDO_COMPLEX_DESC_REQ;
4133         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4134         container->userdata = user_data;
4135
4136         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "complex_desc_req",
4137                 g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4138
4139         if (!variant) {
4140                 ERR("Failed to get 'complex_desc_req' [%s]", dbus_err->message);
4141                 g_error_free(dbus_err);
4142                 return ZIGBEE_ERROR_IO_ERROR;
4143         }
4144
4145         g_variant_get(variant, "(i)", &result);
4146         DBG("ret = [0x%x]", result);
4147         g_variant_unref(variant);
4148
4149         return result;
4150 }
4151
4152 int zbl_user_desc_req(nwk_addr addr16, zb_zdo_user_desc_rsp cb, void *user_data)
4153 {
4154         int sub_id, to;
4155         zbl_req_cb_s *container;
4156
4157         int result = ZIGBEE_ERROR_NONE;
4158         GVariant *variant = NULL;
4159         GError *dbus_err = NULL;
4160
4161         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4162         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4163
4164         container = calloc(1, sizeof(zbl_req_cb_s));
4165         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4166
4167         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4168         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4169                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "user_desc_rsp",
4170                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
4171                         _zbl_response_cb, container, _zbl_request_cleanup);
4172
4173         if (0 == sub_id) {
4174                 ERR("g_dbus_connection_signal_subscribe() Fail");
4175                 free(container);
4176                 return ZIGBEE_ERROR_IO_ERROR;
4177         }
4178
4179         container->cb = cb;
4180         container->sid = sub_id;
4181         container->cid = ZBL_ZDO_USER_DESC_REQ;
4182         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4183         container->userdata = user_data;
4184
4185         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "user_desc_req",
4186                 g_variant_new("(q)", addr16), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4187
4188         if (!variant) {
4189                 ERR("Failed to get 'user_desc_req' [%s]", dbus_err->message);
4190                 g_error_free(dbus_err);
4191                 return ZIGBEE_ERROR_IO_ERROR;
4192         }
4193
4194         g_variant_get(variant, "(i)", &result);
4195         DBG("ret = [0x%x]", result);
4196         g_variant_unref(variant);
4197
4198         return result;
4199 }
4200
4201 #define MAX_USER_DESC_SIZE 0x10
4202 #define USER_DESC_COMMAND_SIZE 20
4203
4204 int zbl_user_desc_set(zigbee_h handle, nwk_addr addr16, unsigned char len,
4205                 unsigned char *user_desc, zb_zdo_user_desc_conf cb, void *user_data)
4206 {
4207         int sub_id, to;
4208         zbl_req_cb_s *container;
4209
4210         int result = ZIGBEE_ERROR_NONE;
4211         GVariant *variant = NULL;
4212         GError *dbus_err = NULL;
4213
4214         unsigned char j = 0x00;
4215         GVariantBuilder *user_desc_builder = NULL;
4216         GVariant *user_desc_variant = NULL;
4217
4218         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4219         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4220         RETVM_IF(len > MAX_USER_DESC_SIZE || len < 0x00, ZIGBEE_ERROR_INVALID_PARAMETER,
4221                 "invalid length=%d", len);
4222         RETVM_IF(NULL == user_data, ZIGBEE_ERROR_INVALID_PARAMETER, "invalid data");
4223
4224         container = calloc(1, sizeof(zbl_req_cb_s));
4225         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4226
4227         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4228         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4229                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "user_desc_confirm",
4230                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
4231                         _zbl_response_cb, container, _zbl_request_cleanup);
4232
4233         if (0 == sub_id) {
4234                 ERR("g_dbus_connection_signal_subscribe() Fail");
4235                 free(container);
4236                 return ZIGBEE_ERROR_IO_ERROR;
4237         }
4238
4239         container->cb = cb;
4240         container->sid = sub_id;
4241         container->cid = ZBL_ZDO_USER_DESC_SET_REQ;
4242         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4243         container->userdata = user_data;
4244
4245         user_desc_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4246         for (j = 0; j < len; j++)
4247                 g_variant_builder_add(user_desc_builder, "(y)", user_desc[j]);
4248
4249         user_desc_variant = g_variant_builder_end(user_desc_builder);
4250         g_variant_builder_unref(user_desc_builder);
4251
4252         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "user_desc_set_req",
4253                 g_variant_new("(qy@a(y))", addr16, len, user_desc_variant),
4254                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4255
4256         if (!variant) {
4257                 ERR("Failed to get 'user_desc_set_req' [%s]", dbus_err->message);
4258                 g_error_free(dbus_err);
4259                 return ZIGBEE_ERROR_IO_ERROR;
4260         }
4261
4262         g_variant_get(variant, "(i)", &result);
4263         DBG("ret = [0x%x]", result);
4264         g_variant_unref(variant);
4265
4266         return result;
4267 }
4268
4269 int zbl_device_annce(zigbee_h handle, nwk_addr addr16, ieee_addr addr64,
4270                 unsigned char capability)
4271 {
4272         int result = ZIGBEE_ERROR_NONE;
4273         GError *dbus_err = NULL;
4274         GVariant *variant = NULL;
4275
4276         GVariantBuilder *mac_builder = NULL;
4277         GVariant* mac_variant = NULL;
4278
4279         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4280         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4281
4282         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4283         g_variant_builder_add(mac_builder, "(y)", addr64[7]);
4284         g_variant_builder_add(mac_builder, "(y)", addr64[6]);
4285         g_variant_builder_add(mac_builder, "(y)", addr64[5]);
4286         g_variant_builder_add(mac_builder, "(y)", addr64[4]);
4287         g_variant_builder_add(mac_builder, "(y)", addr64[3]);
4288         g_variant_builder_add(mac_builder, "(y)", addr64[2]);
4289         g_variant_builder_add(mac_builder, "(y)", addr64[1]);
4290         g_variant_builder_add(mac_builder, "(y)", addr64[0]);
4291         mac_variant = g_variant_builder_end(mac_builder);
4292         g_variant_builder_unref(mac_builder);
4293
4294         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "device_announce",
4295                 g_variant_new("(q@a(y)y)", addr16, mac_variant, capability),
4296                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
4297
4298         if (!variant) {
4299                 ERR("Failed to get 'device_announce' [%s]", dbus_err->message);
4300                 g_error_free(dbus_err);
4301                 return ZIGBEE_ERROR_IO_ERROR;
4302         }
4303
4304         g_variant_get(variant, "(i)", &result);
4305         DBG("ret = [0x%x]", result);
4306         g_variant_unref(variant);
4307
4308         return result;
4309 }
4310
4311 int zbl_bind_req(nwk_addr dst_addr16, ieee_addr src_addr64,
4312                 unsigned char src_ep, unsigned short cluster_id, ieee_addr dst_addr64,
4313                 unsigned char type, nwk_addr group_addr, unsigned char dst_ep,
4314                 zb_zdo_bind_rsp cb, void *user_data)
4315 {
4316         int i;
4317         int sub_id, to;
4318         zbl_req_cb_s *container;
4319
4320         int result = ZIGBEE_ERROR_NONE;
4321         GError *dbus_err = NULL;
4322         GVariant *variant = NULL;
4323
4324         GVariantBuilder *src_addr64_builder = NULL;
4325         GVariant* src_addr64_variant = NULL;
4326         GVariantBuilder *dst_addr64_builder = NULL;
4327         GVariant* dst_addr64_variant = NULL;
4328
4329         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4330         RETV_IF(NULL == zdo_bind_proxy, ZIGBEE_ERROR_IO_ERROR);
4331
4332         DBG("zbl_zdo_bind_req()");
4333
4334         container = calloc(1, sizeof(zbl_req_cb_s));
4335         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4336
4337         to = zbl_dbus_get_timeout(zdo_bind_proxy);
4338         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4339                         ZIGBEE_ZDO_BIND_INTERFACE,  "bind_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
4340                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
4341         if (0 == sub_id) {
4342                 ERR("g_dbus_connection_signal_subscribe() Fail");
4343                 free(container);
4344                 return ZIGBEE_ERROR_IO_ERROR;
4345         }
4346
4347         container->cb = cb;
4348         container->sid = sub_id;
4349         container->cid = ZBL_ZDO_BIND_REQ;
4350         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4351         container->userdata = user_data;
4352
4353         src_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4354
4355         if (src_addr64) {
4356                 for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--)
4357                         g_variant_builder_add(src_addr64_builder, "(y)", src_addr64[i]);
4358         }
4359         src_addr64_variant = g_variant_builder_end(src_addr64_builder);
4360         g_variant_builder_unref(src_addr64_builder);
4361
4362         dst_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4363         if (dst_addr64) {
4364                 for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--)
4365                         g_variant_builder_add(dst_addr64_builder, "(y)", dst_addr64[i]);
4366         }
4367         dst_addr64_variant = g_variant_builder_end(dst_addr64_builder);
4368         g_variant_builder_unref(dst_addr64_builder);
4369
4370         variant = g_dbus_proxy_call_sync(zdo_bind_proxy, "bind_req",
4371                 g_variant_new("(q@a(y)yq@a(y)yqy)", dst_addr16, src_addr64_variant, src_ep,
4372                                                 cluster_id, dst_addr64_variant, type, group_addr, dst_ep),
4373                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4374
4375         if (!variant) {
4376                 ERR("Failed to get 'bind_req' [%s]", dbus_err->message);
4377                 g_error_free(dbus_err);
4378                 return ZIGBEE_ERROR_IO_ERROR;
4379         }
4380
4381         g_variant_get(variant, "(i)", &result);
4382         DBG("ret = [0x%x]", result);
4383         g_variant_unref(variant);
4384
4385         return result;
4386 }
4387
4388 int zbl_unbind_req(nwk_addr dst_addr16,
4389                 ieee_addr src_addr64, unsigned char src_ep, unsigned short cluster_id,
4390                 ieee_addr dst_addr64, unsigned char type, nwk_addr group_addr,
4391                 unsigned char dst_ep, zb_zdo_unbind_rsp cb, void *user_data)
4392 {
4393         int i;
4394         int sub_id, to;
4395         zbl_req_cb_s *container;
4396
4397         int result = ZIGBEE_ERROR_NONE;
4398         GError *dbus_err = NULL;
4399         GVariant *variant = NULL;
4400
4401         GVariantBuilder *src_addr64_builder = NULL;
4402         GVariant* src_addr64_variant = NULL;
4403         GVariantBuilder *dst_addr64_builder = NULL;
4404         GVariant* dst_addr64_variant = NULL;
4405
4406         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4407         RETV_IF(NULL == zdo_bind_proxy, ZIGBEE_ERROR_IO_ERROR);
4408
4409         DBG("zbl_zdo_unbind_req()");
4410
4411         container = calloc(1, sizeof(zbl_req_cb_s));
4412         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4413
4414         to = zbl_dbus_get_timeout(zdo_bind_proxy);
4415         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4416                         ZIGBEE_ZDO_BIND_INTERFACE,  "unbind_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
4417                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
4418         if (0 == sub_id) {
4419                 ERR("g_dbus_connection_signal_subscribe() Fail");
4420                 free(container);
4421                 return ZIGBEE_ERROR_IO_ERROR;
4422         }
4423
4424         container->cb = cb;
4425         container->sid = sub_id;
4426         container->cid = ZBL_ZDO_UNBIND_REQ;
4427         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4428         container->userdata = user_data;
4429
4430         src_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4431         if (src_addr64) {
4432                 for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--)
4433                         g_variant_builder_add(src_addr64_builder, "(y)", src_addr64[i]);
4434         }
4435         src_addr64_variant = g_variant_builder_end(src_addr64_builder);
4436         g_variant_builder_unref(src_addr64_builder);
4437
4438         dst_addr64_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4439         if (dst_addr64) {
4440                 for (i = sizeof(ieee_addr) - 1 ; i >= 0; i--)
4441                         g_variant_builder_add(dst_addr64_builder, "(y)", dst_addr64[i]);
4442         }
4443         dst_addr64_variant = g_variant_builder_end(dst_addr64_builder);
4444         g_variant_builder_unref(dst_addr64_builder);
4445
4446         variant = g_dbus_proxy_call_sync(zdo_bind_proxy, "unbind_req",
4447                 g_variant_new("(q@a(y)yq@a(y)yqy)", dst_addr16, src_addr64_variant, src_ep,
4448                                                 cluster_id, dst_addr64_variant, type, group_addr, dst_ep),
4449                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4450
4451         if (!variant) {
4452                 ERR("Failed to get 'unbind_req' [%s]", dbus_err->message);
4453                 g_error_free(dbus_err);
4454                 return ZIGBEE_ERROR_IO_ERROR;
4455         }
4456
4457         g_variant_get(variant, "(i)", &result);
4458         DBG("ret = [0x%x]", result);
4459         g_variant_unref(variant);
4460
4461         return result;
4462 }
4463
4464 int zbl_mgmt_nwk_disc_req(nwk_addr addr16, unsigned int scan_channels,
4465         unsigned char scan_duration, unsigned char scan_count, unsigned char start_idx,
4466         zb_zdo_mgmt_nwk_disc_rsp cb, void *user_data)
4467 {
4468         int sub_id, to;
4469         zbl_req_cb_s *container;
4470
4471         int result = ZIGBEE_ERROR_NONE;
4472         GVariant *variant = NULL;
4473         GError *dbus_err = NULL;
4474
4475         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4476         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4477
4478         DBG("zbl_mgmt_nwk_disc_req()");
4479
4480         container = calloc(1, sizeof(zbl_req_cb_s));
4481         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4482
4483         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4484         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4485                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "mgmt_nwk_disc_rsp",
4486                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb,
4487                         container, _zbl_request_cleanup);
4488
4489         if (0 == sub_id) {
4490                 ERR("g_dbus_connection_signal_subscribe() Fail");
4491                 free(container);
4492                 return ZIGBEE_ERROR_IO_ERROR;
4493         }
4494
4495         container->cb = cb;
4496         container->sid = sub_id;
4497         container->cid = ZBL_ZDO_MGMT_NWK_DISC_REQ;
4498         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4499         container->userdata = user_data;
4500
4501         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "mgmt_nwk_disc_req",
4502                 g_variant_new("(quyqy)", addr16, scan_channels, scan_duration, scan_count, start_idx),
4503                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4504
4505         if (!variant) {
4506                 ERR("Failed to get 'mgmt_nwk_disc_req' [%s]", dbus_err->message);
4507                 g_error_free(dbus_err);
4508                 return ZIGBEE_ERROR_IO_ERROR;
4509         }
4510
4511         g_variant_get(variant, "(i)", &result);
4512         DBG("ret = [0x%x]", result);
4513         g_variant_unref(variant);
4514
4515         return result;
4516 }
4517
4518 int zbl_mgmt_nwk_update_req(unsigned int scan_channels, unsigned char scan_duration,
4519         unsigned char scan_count, unsigned char nwk_update_id, nwk_addr nwk_manager_addr)
4520 {
4521         int result = ZIGBEE_ERROR_NONE;
4522         GVariant *variant = NULL;
4523         GError *dbus_err = NULL;
4524
4525         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4526         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4527
4528         DBG("zbl_mgmt_nwk_update_req()");
4529
4530         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "mgmt_nwk_update_req",
4531                 g_variant_new("(quyyy)", nwk_manager_addr, scan_channels, scan_duration,
4532                 scan_count, nwk_update_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
4533
4534         if (!variant) {
4535                 ERR("Failed to get 'mgmt_nwk_update_req' [%s]", dbus_err->message);
4536                 g_error_free(dbus_err);
4537                 return ZIGBEE_ERROR_IO_ERROR;
4538         }
4539
4540         g_variant_get(variant, "(i)", &result);
4541         DBG("ret = [0x%x]", result);
4542         g_variant_unref(variant);
4543
4544         return result;
4545 }
4546
4547 int zbl_mgmt_lqi_req(nwk_addr addr16, unsigned char start_idx,
4548                 zb_zdo_mgmt_lqi_rsp cb, void *user_data)
4549 {
4550         int sub_id, to;
4551         zbl_req_cb_s *container;
4552
4553         int result = ZIGBEE_ERROR_NONE;
4554         GVariant *variant = NULL;
4555         GError *dbus_err = NULL;
4556
4557         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4558         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4559
4560         DBG("zbl_mgmt_lqi_req()");
4561
4562         container = calloc(1, sizeof(zbl_req_cb_s));
4563         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4564
4565         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4566         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4567                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "mgmt_lqi_rsp",
4568                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container,
4569                         _zbl_request_cleanup);
4570
4571         if (0 == sub_id) {
4572                 ERR("g_dbus_connection_signal_subscribe() Fail");
4573                 free(container);
4574                 return ZIGBEE_ERROR_IO_ERROR;
4575         }
4576
4577         container->cb = cb;
4578         container->sid = sub_id;
4579         container->cid = ZBL_ZDO_MGMT_LQI_REQ;
4580         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4581         container->userdata = user_data;
4582
4583         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "mgmt_lqi_req",
4584                 g_variant_new("(qy)", addr16, start_idx),
4585                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4586
4587         if (!variant) {
4588                 ERR("Failed to get 'mgmt_lqi_req' [%s]", dbus_err->message);
4589                 g_error_free(dbus_err);
4590                 return ZIGBEE_ERROR_IO_ERROR;
4591         }
4592
4593         g_variant_get(variant, "(i)", &result);
4594         DBG("ret = [0x%x]", result);
4595         g_variant_unref(variant);
4596
4597         return result;
4598 }
4599
4600 int zbl_mgmt_rtg_req(nwk_addr addr16, unsigned char start_idx,
4601                 zb_zdo_mgmt_rtg_rsp cb, void *user_data)
4602 {
4603         int sub_id, to;
4604         zbl_req_cb_s *container;
4605
4606         int result = ZIGBEE_ERROR_NONE;
4607         GVariant *variant = NULL;
4608         GError *dbus_err = NULL;
4609
4610         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4611         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4612
4613         DBG("zbl_mgmt_rtg_req()");
4614
4615         container = calloc(1, sizeof(zbl_req_cb_s));
4616         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4617
4618         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4619         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4620                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "mgmt_rtg_rsp",
4621                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,  _zbl_response_cb, container,
4622                         _zbl_request_cleanup);
4623
4624         if (0 == sub_id) {
4625                 ERR("g_dbus_connection_signal_subscribe() Fail");
4626                 free(container);
4627                 return ZIGBEE_ERROR_IO_ERROR;
4628         }
4629
4630         container->cb = cb;
4631         container->sid = sub_id;
4632         container->cid = ZBL_ZDO_MGMT_RTG_REQ;
4633         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4634         container->userdata = user_data;
4635
4636         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "mgmt_rtg_req",
4637                 g_variant_new("(qy)", addr16, start_idx),
4638                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4639
4640         if (!variant) {
4641                 ERR("Failed to get 'mgmt_rtg_req' [%s]", dbus_err->message);
4642                 g_error_free(dbus_err);
4643                 return ZIGBEE_ERROR_IO_ERROR;
4644         }
4645
4646         g_variant_get(variant, "(i)", &result);
4647         DBG("ret = [0x%x]", result);
4648         g_variant_unref(variant);
4649
4650         return result;
4651 }
4652
4653 int zbl_mgmt_bind_req(nwk_addr addr16, unsigned char start_idx,
4654                 zb_zdo_mgmt_bind_rsp cb, void *user_data)
4655 {
4656         int sub_id, to;
4657         zbl_req_cb_s *container;
4658
4659         int result = ZIGBEE_ERROR_NONE;
4660         GVariant *variant = NULL;
4661         GError *dbus_err = NULL;
4662
4663         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4664         RETV_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR);
4665
4666         DBG("zbl_mgmt_bind_req()");
4667
4668         container = calloc(1, sizeof(zbl_req_cb_s));
4669         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4670
4671         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4672         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4673                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "mgmt_bind_rsp",
4674                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,  _zbl_response_cb, container,
4675                         _zbl_request_cleanup);
4676
4677         if (0 == sub_id) {
4678                 ERR("g_dbus_connection_signal_subscribe() Fail");
4679                 free(container);
4680                 return ZIGBEE_ERROR_IO_ERROR;
4681         }
4682
4683         container->cb = cb;
4684         container->sid = sub_id;
4685         container->cid = ZBL_ZDO_MGMT_BIND_REQ;
4686         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4687         container->userdata = user_data;
4688
4689         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "mgmt_bind_req",
4690                 g_variant_new("(qy)", addr16, start_idx),
4691                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4692
4693         if (!variant) {
4694                 ERR("Failed to get 'mgmt_bind_req' [%s]", dbus_err->message);
4695                 g_error_free(dbus_err);
4696                 return ZIGBEE_ERROR_IO_ERROR;
4697         }
4698
4699         g_variant_get(variant, "(i)", &result);
4700         DBG("ret = [0x%x]", result);
4701         g_variant_unref(variant);
4702
4703         return result;
4704 }
4705
4706 int zbl_mgmt_leave_device(ieee_addr addr64, unsigned char remove_children,
4707                 unsigned rejoin, zb_zdo_mgmt_leave_rsp cb, void *user_data)
4708 {
4709         int sub_id, to;
4710         zbl_req_cb_s *container;
4711
4712         int result = ZIGBEE_ERROR_NONE;
4713         GVariant *variant = NULL;
4714         GError *dbus_err = NULL;
4715
4716         GVariantBuilder *mac_builder = NULL;
4717         GVariant* mac_variant = NULL;
4718
4719         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4720         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
4721
4722         container = calloc(1, sizeof(zbl_req_cb_s));
4723         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4724
4725         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4726         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4727                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "mgmt_leave_rsp",
4728                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,  _zbl_response_cb, container,
4729                         _zbl_request_cleanup);
4730
4731         if (0 == sub_id) {
4732                 ERR("g_dbus_connection_signal_subscribe() Fail");
4733                 free(container);
4734                 return ZIGBEE_ERROR_IO_ERROR;
4735         }
4736
4737         container->cb = cb;
4738         container->sid = sub_id;
4739         container->cid = ZBL_ZDO_MGMT_LEAVE_REQ;
4740         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4741         container->userdata = user_data;
4742
4743         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4744         g_variant_builder_add(mac_builder, "(y)", addr64[7]);
4745         g_variant_builder_add(mac_builder, "(y)", addr64[6]);
4746         g_variant_builder_add(mac_builder, "(y)", addr64[5]);
4747         g_variant_builder_add(mac_builder, "(y)", addr64[4]);
4748         g_variant_builder_add(mac_builder, "(y)", addr64[3]);
4749         g_variant_builder_add(mac_builder, "(y)", addr64[2]);
4750         g_variant_builder_add(mac_builder, "(y)", addr64[1]);
4751         g_variant_builder_add(mac_builder, "(y)", addr64[0]);
4752         mac_variant = g_variant_builder_end(mac_builder);
4753         g_variant_builder_unref(mac_builder);
4754
4755         variant = g_dbus_proxy_call_sync(service_gproxy, "leave_request",
4756                 g_variant_new("(@a(y)yy)", mac_variant, remove_children, rejoin),
4757                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4758
4759         if (!variant) {
4760                 ERR("Failed to get 'leave_request' [%s]", dbus_err->message);
4761                 g_error_free(dbus_err);
4762                 return ZIGBEE_ERROR_IO_ERROR;
4763         }
4764
4765         g_variant_get(variant, "(i)", &result);
4766         DBG("ret = [0x%x]", result);
4767         g_variant_unref(variant);
4768
4769         return result;
4770 }
4771
4772 int zbl_mgmt_permit_joining_req(nwk_addr addr16, unsigned char duration,
4773                 unsigned char tc_significance, zb_zdo_mgmt_permit_joining_rsp cb, void *user_data)
4774 {
4775         int sub_id, to;
4776         zbl_req_cb_s *container;
4777
4778         int result = ZIGBEE_ERROR_NONE;
4779         GVariant *variant = NULL;
4780         GError *dbus_err = NULL;
4781
4782         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4783         RETV_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR);
4784
4785         container = calloc(1, sizeof(zbl_req_cb_s));
4786         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4787
4788         to = zbl_dbus_get_timeout(zdo_dev_proxy);
4789         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4790                         ZIGBEE_ZDO_DEV_CONTROL_INTERFACE,  "mgmt_permit_join_rsp",
4791                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb,
4792                         container, _zbl_request_cleanup);
4793
4794         if (0 == sub_id) {
4795                 ERR("g_dbus_connection_signal_subscribe() Fail");
4796                 free(container);
4797                 return ZIGBEE_ERROR_IO_ERROR;
4798         }
4799
4800         container->cb = cb;
4801         container->sid = sub_id;
4802         container->cid = ZBL_ZDO_MGMT_PERMIT_JOIN_REQ;
4803         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4804         container->userdata = user_data;
4805
4806         variant = g_dbus_proxy_call_sync(zdo_dev_proxy, "mgmt_permit_join_req",
4807                 g_variant_new("(qyy)", addr16, duration, tc_significance),
4808                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4809
4810         if (!variant) {
4811                 ERR("Failed to get 'mgmt_permit_join_req' [%s]", dbus_err->message);
4812                 g_error_free(dbus_err);
4813                 return ZIGBEE_ERROR_IO_ERROR;
4814         }
4815
4816         g_variant_get(variant, "(i)", &result);
4817         DBG("ret = [0x%x]", result);
4818         g_variant_unref(variant);
4819
4820         return result;
4821 }
4822
4823 int zbl_aps_send(nwk_addr addr16, unsigned char aps_frame_ctl, unsigned char src_ep,
4824         unsigned char dst_ep, unsigned short cluster_id, unsigned short profile_id,
4825         unsigned char zcl_frame_ctl, unsigned short mfg_code, unsigned char cmd_id,
4826         unsigned short payload_len, unsigned char *payload, zb_aps_send_rsp cb, void *user_data)
4827 {
4828         int sub_id, to, i;
4829         zbl_req_cb_s *container;
4830
4831         int result = ZIGBEE_ERROR_NONE;
4832         GVariant *variant = NULL;
4833         GError *dbus_err = NULL;
4834
4835         GVariantBuilder *payload_builder = NULL;
4836         GVariant *payload_variant = NULL;
4837
4838         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4839         RETV_IF(NULL == custom_gproxy, ZIGBEE_ERROR_IO_ERROR);
4840
4841         container = calloc(1, sizeof(zbl_req_cb_s));
4842         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4843
4844         to = zbl_dbus_get_timeout(custom_gproxy);
4845         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4846                         ZIGBEE_CUSTOM_INTERFACE,  "aps_send_rsp", ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
4847                         _zbl_response_cb, container, _zbl_request_cleanup);
4848
4849         if (0 == sub_id) {
4850                 ERR("g_dbus_connection_signal_subscribe() Fail");
4851                 free(container);
4852                 return ZIGBEE_ERROR_IO_ERROR;
4853         }
4854
4855         container->cb = cb;
4856         container->sid = sub_id;
4857         container->cid = ZBL_CUSTOM_APS_SEND_REQ;
4858         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4859         container->userdata = user_data;
4860
4861         payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4862         if (payload_len > 0) {
4863                 for (i = payload_len - 1; i >= 0 ; i--)
4864                         g_variant_builder_add(payload_builder, "(y)", payload[i]);
4865         }
4866         payload_variant = g_variant_builder_end(payload_builder);
4867         g_variant_builder_unref(payload_builder);
4868
4869         variant = g_dbus_proxy_call_sync(custom_gproxy, "aps_send",
4870                 g_variant_new("(qyyyqqyqyq@a(y))", addr16, aps_frame_ctl, src_ep, dst_ep, cluster_id,
4871                 profile_id, zcl_frame_ctl, mfg_code, cmd_id, payload_len, payload_variant),
4872                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4873
4874         if (!variant) {
4875                 ERR("Failed to get 'aps_send' [%s]", dbus_err->message);
4876                 g_error_free(dbus_err);
4877                 return ZIGBEE_ERROR_IO_ERROR;
4878         }
4879
4880         g_variant_get(variant, "(i)", &result);
4881         DBG("ret = [0x%x]", result);
4882         g_variant_unref(variant);
4883
4884         return result;
4885 }
4886
4887 int zbl_zcl_send(nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
4888                 unsigned short cluster_id, unsigned char zcl_frame_ctl, unsigned char cmd,
4889                 unsigned short payload_len, unsigned char *payload,
4890                 zb_zcl_send_rsp cb, void *user_data)
4891 {
4892         int sub_id, to, i;
4893         zbl_req_cb_s *container;
4894
4895         int result = ZIGBEE_ERROR_NONE;
4896         GVariant *variant = NULL;
4897         GError *dbus_err = NULL;
4898
4899         GVariantBuilder *payload_builder = NULL;
4900         GVariant *payload_variant = NULL;
4901
4902         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4903         RETV_IF(NULL == custom_gproxy, ZIGBEE_ERROR_IO_ERROR);
4904
4905         container = calloc(1, sizeof(zbl_req_cb_s));
4906         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4907
4908         to = zbl_dbus_get_timeout(custom_gproxy);
4909         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4910                         ZIGBEE_CUSTOM_INTERFACE,  "zcl_send_rsp", ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
4911                         _zbl_response_cb, container, _zbl_request_cleanup);
4912
4913         if (0 == sub_id) {
4914                 ERR("g_dbus_connection_signal_subscribe() Fail");
4915                 free(container);
4916                 return ZIGBEE_ERROR_IO_ERROR;
4917         }
4918
4919         container->cb = cb;
4920         container->sid = sub_id;
4921         container->cid = ZBL_CUSTOM_ZCL_SEND_REQ;
4922         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4923         container->userdata = user_data;
4924
4925         payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4926         if (payload_len > 0) {
4927                 for (i = payload_len - 1; i >= 0 ; i--)
4928                         g_variant_builder_add(payload_builder, "(y)", payload[i]);
4929         }
4930         payload_variant = g_variant_builder_end(payload_builder);
4931         g_variant_builder_unref(payload_builder);
4932
4933         variant = g_dbus_proxy_call_sync(custom_gproxy, "zcl_send",
4934                 g_variant_new("(qyyqyyq@a(y))", addr16, src_ep, dst_ep, cluster_id, zcl_frame_ctl,
4935                 cmd, payload_len, payload_variant), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4936
4937         if (!variant) {
4938                 ERR("Failed to get 'zcl_send' [%s]", dbus_err->message);
4939                 g_error_free(dbus_err);
4940                 return ZIGBEE_ERROR_IO_ERROR;
4941         }
4942
4943         g_variant_get(variant, "(i)", &result);
4944         DBG("ret = [0x%x]", result);
4945         g_variant_unref(variant);
4946
4947         return result;
4948 }
4949
4950 int zbl_send_to_local(unsigned short length, unsigned char *data,
4951                 zb_send_to_local_rsp cb, void *user_data)
4952 {
4953         int sub_id, to, i;
4954         zbl_req_cb_s *container;
4955
4956         int result = ZIGBEE_ERROR_NONE;
4957         GVariant *variant = NULL;
4958         GError *dbus_err = NULL;
4959
4960         GVariantBuilder *payload_builder = NULL;
4961         GVariant *payload_variant = NULL;
4962
4963         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
4964         RETV_IF(NULL == custom_gproxy, ZIGBEE_ERROR_IO_ERROR);
4965
4966         container = calloc(1, sizeof(zbl_req_cb_s));
4967         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
4968
4969         to = zbl_dbus_get_timeout(custom_gproxy);
4970         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
4971                         ZIGBEE_CUSTOM_INTERFACE,  "send_to_local_rsp", ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
4972                         _zbl_response_cb, container, _zbl_request_cleanup);
4973
4974         if (0 == sub_id) {
4975                 ERR("g_dbus_connection_signal_subscribe() Fail");
4976                 free(container);
4977                 return ZIGBEE_ERROR_IO_ERROR;
4978         }
4979
4980         container->cb = cb;
4981         container->sid = sub_id;
4982         container->cid = ZBL_CUSTOM_LOCAL_SEND_REQ;
4983         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
4984         container->userdata = user_data;
4985
4986         payload_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
4987         if (length > 0) {
4988                 for (i = length - 1; i >= 0 ; i--)
4989                         g_variant_builder_add(payload_builder, "(y)", data[i]);
4990         }
4991         payload_variant = g_variant_builder_end(payload_builder);
4992         g_variant_builder_unref(payload_builder);
4993
4994         variant = g_dbus_proxy_call_sync(custom_gproxy, "send_to_local",
4995                 g_variant_new("(q@a(y))", length, payload_variant),
4996                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
4997
4998         if (!variant) {
4999                 ERR("Failed to get 'send_to_local' [%s]", dbus_err->message);
5000                 g_error_free(dbus_err);
5001                 return ZIGBEE_ERROR_IO_ERROR;
5002         }
5003
5004         g_variant_get(variant, "(i)", &result);
5005         DBG("ret = [0x%x]", result);
5006         g_variant_unref(variant);
5007
5008         return result;
5009 }
5010
5011 int zbl_read_attr_req(zigbee_h handle, unsigned short addr16, unsigned char dest_ep,
5012         unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned short *attribute_ids,
5013         int attribute_ids_len, zb_zcl_global_rsp cb, void *user_data)
5014 {
5015         int sub_id, to;
5016         zbl_req_cb_s *container;
5017
5018         int result = ZIGBEE_ERROR_NONE;
5019         GVariant *variant = NULL;
5020         GError *dbus_err = NULL;
5021
5022 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5023         zb_event_global_default_rsp_s *global_req = NULL;
5024 #endif
5025
5026         int i = 0;
5027         unsigned char *t;
5028         GVariant *attr_variant = NULL;
5029         GVariantBuilder *attr_builder = NULL;
5030
5031         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
5032         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
5033
5034         DBG("zbl_read_attr_req()");
5035
5036         container = calloc(1, sizeof(zbl_req_cb_s));
5037         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
5038
5039         to = zbl_dbus_get_timeout(zcl_global_proxy);
5040         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
5041                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "read_attributes_rsp",
5042                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
5043                 _zbl_response_cb, container, _zbl_request_cleanup);
5044
5045         if (0 == sub_id) {
5046                 ERR("g_dbus_connection_signal_subscribe() Fail");
5047                 free(container);
5048                 return ZIGBEE_ERROR_IO_ERROR;
5049         }
5050
5051         container->cb = cb;
5052         container->sid = sub_id;
5053         container->cid = ZBL_ZCL_GLOBAL_READ_ATTRIBUTE_REQ;
5054         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
5055         container->userdata = user_data;
5056 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5057         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
5058         if (NULL == global_req) {
5059                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
5060                 g_source_remove(container->tid);
5061                 container->tid = 0;
5062                 free(container);
5063                 ERR("calloc() Fail(%d)", errno);
5064                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5065         }
5066         global_req->ep = dest_ep;
5067         global_req->cluster_id = cluster_id;
5068         global_req->command_id = ZB_ZCL_READ_ATTRIBUTES_COMMAND_ID;
5069
5070         container->global_cmd = global_req;
5071         container->handle = handle;
5072
5073         /* Register global request information into handle */
5074         _zbl_register_global_req(handle, container);
5075 #endif
5076
5077         t = (unsigned char *)attribute_ids;
5078         attr_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
5079         for (i = 0; i < attribute_ids_len*sizeof(unsigned short); i++)
5080                 g_variant_builder_add(attr_builder, "(y)", t[i]);
5081         attr_variant = g_variant_builder_end(attr_builder);
5082         g_variant_builder_unref(attr_builder);
5083
5084         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "read_attributes_req",
5085                 g_variant_new("(@a(y)iqqyy)", attr_variant, attribute_ids_len,
5086                 addr16, cluster_id, zcl_frame_ctl, dest_ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
5087
5088         if (!variant) {
5089                 ERR("Failed to get 'read_attributes_req' [%s]", dbus_err->message);
5090                 g_error_free(dbus_err);
5091                 return ZIGBEE_ERROR_IO_ERROR;
5092         }
5093
5094         g_variant_get(variant, "(i)", &result);
5095         DBG("ret = [0x%x]", result);
5096         g_variant_unref(variant);
5097
5098         return result;
5099 }
5100
5101 int zbl_write_attr_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
5102                 unsigned char zcl_frame_ctl, unsigned short cluster_id, write_attr_record_h *records,
5103                 int records_len, zb_zcl_global_rsp cb, void *user_data)
5104 {
5105         int sub_id, to;
5106         zbl_req_cb_s *container;
5107
5108         int result = ZIGBEE_ERROR_NONE;
5109         GVariant *variant = NULL;
5110         GError *dbus_err = NULL;
5111
5112 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5113         zb_event_global_default_rsp_s *global_req = NULL;
5114 #endif
5115
5116         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
5117         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
5118
5119         DBG("zbl_write_attr_req()");
5120
5121         GVariantBuilder *rec_builder = NULL;
5122         GVariant *rec_variant = NULL;
5123
5124         int i = 0;
5125         int j = 0;
5126
5127         char dSize[3] = {'\0', '\0'};
5128         int writeAttributeIndex = 0;
5129         int size_of_allo = 0;
5130
5131         unsigned char *isString = NULL;
5132         unsigned short *dataSize = NULL;
5133         unsigned char *writeAttribute = NULL;
5134
5135         isString = calloc(records_len + 1, sizeof(unsigned char));
5136         RETVM_IF(NULL == isString, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
5137
5138         dataSize = calloc(records_len + 1, sizeof(unsigned short));
5139         if (NULL == dataSize) {
5140                 ERR("calloc() Fail(%d)", errno);
5141                 free(isString);
5142                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5143         }
5144
5145         DBG("Records Length %d", records_len);
5146
5147         while (j < records_len) {
5148                 dataSize[j] = zb_get_data_size((*records)[j].type);
5149                 if (0xff != dataSize[j]) {
5150                         isString[j] = 0;
5151                         size_of_allo = size_of_allo + (dataSize[j] + 3);
5152                 } else {
5153                         if ((*records)[j].value) {
5154                                 if ((*records)[j].type == ZB_ZCL_CHRACTER_STRING
5155                                         || (*records)[j].type == ZB_ZCL_OCTAT_STRING) {
5156                                                 isString[j] = 1;
5157                                                 dataSize[j] = (*records)[j].value[0];
5158                                                 size_of_allo = size_of_allo + (dataSize[j] + 3 + 1);
5159                                 } else if ((*records)[j].type == ZB_ZCL_LONG_OCTAT_STRING
5160                                         || (*records)[j].type == ZB_ZCL_LONG_CHRACTER_STRING) {
5161                                         isString[j] = 2;
5162                                         dSize[0] = (*records)[j].value[0];
5163                                         dSize[1] = (*records)[j].value[1];
5164                                         dataSize[j] = dSize[1];
5165                                         dataSize[j] = (dataSize[j] << 8) | dSize[0];
5166                                         size_of_allo = size_of_allo + (dataSize[j] + 3 + 2);
5167                                 }
5168                         } else
5169                                 ERR("Data is not present");
5170                 }
5171                 j++;
5172         }
5173         DBG("size_of_allo Length %d", size_of_allo);
5174
5175         writeAttribute = calloc(size_of_allo + 1, sizeof(unsigned char));
5176         if (NULL == writeAttribute) {
5177                 ERR("Couldn't Allocate Memory");
5178                 free(isString);
5179                 free(dataSize);
5180                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5181         }
5182
5183         j = 0;
5184         while (j < records_len && writeAttributeIndex < size_of_allo) {
5185                 writeAttribute[writeAttributeIndex++] = ((*records)[j].id) & 0xff;
5186                 writeAttribute[writeAttributeIndex++] = (((*records)[j].id) >> 8) & 0xff;
5187                 writeAttribute[writeAttributeIndex++] = (*records)[j].type;
5188                 for (i = 0; i < (dataSize[j] + isString[j]); i++) {
5189                         writeAttribute[writeAttributeIndex++] = (*records)[j].value[i];
5190                         DBG("0x%02X", (*records)[j].value[i]);
5191                 }
5192                 j++;
5193         }
5194
5195         rec_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
5196         DBG("   ");
5197         for (i = 0; i < writeAttributeIndex ; i++) {
5198                 DBG("0x%02X", writeAttribute[i]);
5199                 g_variant_builder_add(rec_builder, "(y)", writeAttribute[i]);
5200         }
5201
5202         rec_variant = g_variant_builder_end(rec_builder);
5203         g_variant_builder_unref(rec_builder);
5204
5205         container = calloc(1, sizeof(zbl_req_cb_s));
5206         if (NULL == container) {
5207                 ERR("calloc() Fail(%d)", errno);
5208                 free(isString);
5209                 free(dataSize);
5210                 free(writeAttribute);
5211                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5212         }
5213
5214         to = zbl_dbus_get_timeout(zcl_global_proxy);
5215         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
5216                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "write_attributes_rsp",
5217                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb,
5218                 container, _zbl_request_cleanup);
5219
5220         if (0 == sub_id) {
5221                 ERR("g_dbus_connection_signal_subscribe() Fail");
5222                 free(isString);
5223                 free(dataSize);
5224                 free(container);
5225                 free(writeAttribute);
5226                 return ZIGBEE_ERROR_IO_ERROR;
5227         }
5228
5229         container->cb = cb;
5230         container->sid = sub_id;
5231         container->cid = ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ;
5232         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
5233         container->userdata = user_data;
5234 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5235         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
5236         if (NULL == global_req) {
5237                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
5238                 g_source_remove(container->tid);
5239                 container->tid = 0;
5240                 free(container);
5241                 free(isString);
5242                 free(dataSize);
5243                 free(writeAttribute);
5244                 ERR("calloc() Fail(%d)", errno);
5245                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5246         }
5247         global_req->ep = dst_ep;
5248         global_req->cluster_id = cluster_id;
5249         global_req->command_id = ZB_ZCL_WRITE_ATTRIBUTES_COMMAND_ID;
5250
5251         container->global_cmd = global_req;
5252         container->handle = handle;
5253
5254         /* Register global request information into handle */
5255         _zbl_register_global_req(handle, container);
5256 #endif
5257
5258         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "write_attributes_req",
5259                 g_variant_new("(@a(y)iqqyyy)", rec_variant, writeAttributeIndex, addr16,
5260                 cluster_id, zcl_frame_ctl, src_ep, dst_ep), G_DBUS_CALL_FLAGS_NONE,
5261                 to, NULL, &dbus_err);
5262
5263         free(isString);
5264         free(dataSize);
5265         free(writeAttribute);
5266
5267         if (!variant) {
5268                 ERR("Failed to get 'write_attributes_req' [%s]", dbus_err->message);
5269                 g_error_free(dbus_err);
5270                 return ZIGBEE_ERROR_IO_ERROR;
5271         }
5272
5273         g_variant_get(variant, "(i)", &result);
5274         DBG("ret = [0x%x]", result);
5275         g_variant_unref(variant);
5276
5277         return result;
5278 }
5279
5280 int zbl_wattr_undivided_req(zigbee_h handle, nwk_addr addr16, unsigned char src_ep,
5281                 unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id,
5282                 write_attr_record_h *records, int records_len,
5283                 zb_zcl_global_rsp cb, void *user_data)
5284 {
5285         int sub_id, to;
5286         zbl_req_cb_s *container;
5287
5288         int result = ZIGBEE_ERROR_NONE;
5289         GVariant *variant = NULL;
5290         GError *dbus_err = NULL;
5291
5292 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5293         zb_event_global_default_rsp_s *global_req = NULL;
5294 #endif
5295
5296         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
5297         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
5298
5299         DBG("zbl_wattr_undivided_req()");
5300
5301         GVariantBuilder *rec_builder = NULL;
5302         GVariant *rec_variant = NULL;
5303
5304         int i = 0;
5305         int j = 0;
5306
5307         char dSize[3] = {'\0', '\0'};
5308         int writeAttributeIndex = 0;
5309         int size_of_allo = 0;
5310
5311         unsigned char *isString = NULL;
5312         unsigned short *dataSize = NULL;
5313         unsigned char *writeAttribute = NULL;
5314
5315         isString = calloc(records_len + 1, sizeof(unsigned char));
5316         RETVM_IF(NULL == isString, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
5317
5318         dataSize = calloc(records_len + 1, sizeof(unsigned short));
5319         if (NULL == dataSize) {
5320                 ERR("calloc() Fail(%d)", errno);
5321                 free(isString);
5322                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5323         }
5324
5325         DBG("Records Length %d", records_len);
5326
5327         while (j < records_len) {
5328                 dataSize[j] = zb_get_data_size((*records)[j].type);
5329                 if (0xff != dataSize[j]) {
5330                         isString[j] = 0;
5331                         size_of_allo = size_of_allo + (dataSize[j] + 3);
5332                 } else {
5333                         if ((*records)[j].value) {
5334                                 if ((*records)[j].type == ZB_ZCL_CHRACTER_STRING
5335                                         || (*records)[j].type == ZB_ZCL_OCTAT_STRING) {
5336                                                 isString[j] = 1;
5337                                                 dataSize[j] = (*records)[j].value[0];
5338                                                 size_of_allo = size_of_allo + (dataSize[j] + 3 + 1);
5339                                 } else if ((*records)[j].type == ZB_ZCL_LONG_OCTAT_STRING
5340                                         || (*records)[j].type == ZB_ZCL_LONG_CHRACTER_STRING) {
5341                                         isString[j] = 2;
5342                                         dSize[0] = (*records)[j].value[0];
5343                                         dSize[1] = (*records)[j].value[1];
5344                                         dataSize[j] = dSize[1];
5345                                         dataSize[j] = (dataSize[j] << 8) | dSize[0];
5346                                         size_of_allo = size_of_allo + (dataSize[j] + 3 + 2);
5347                                 }
5348                         } else
5349                                 ERR("Data is not present");
5350                 }
5351                 j++;
5352         }
5353         DBG("size_of_allo Length %d", size_of_allo);
5354
5355         writeAttribute = calloc(size_of_allo + 1, sizeof(unsigned char));
5356         if (NULL == writeAttribute) {
5357                 ERR("Couldn't Allocate Memory");
5358                 free(isString);
5359                 free(dataSize);
5360                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5361         }
5362
5363         j = 0;
5364         while (j < records_len && writeAttributeIndex < size_of_allo) {
5365                 writeAttribute[writeAttributeIndex++] = ((*records)[j].id) & 0xff;
5366                 writeAttribute[writeAttributeIndex++] = (((*records)[j].id) >> 8) & 0xff;
5367                 writeAttribute[writeAttributeIndex++] = (*records)[j].type;
5368                 for (i = 0; i < (dataSize[j] + isString[j]); i++) {
5369                         writeAttribute[writeAttributeIndex++] = (*records)[j].value[i];
5370                         DBG("0x%02X", (*records)[j].value[i]);
5371                 }
5372                 j++;
5373         }
5374
5375         rec_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
5376         DBG("   ");
5377         for (i = 0; i < writeAttributeIndex ; i++) {
5378                 DBG("0x%02X", writeAttribute[i]);
5379                 g_variant_builder_add(rec_builder, "(y)", writeAttribute[i]);
5380         }
5381
5382         rec_variant = g_variant_builder_end(rec_builder);
5383         g_variant_builder_unref(rec_builder);
5384
5385         container = calloc(1, sizeof(zbl_req_cb_s));
5386         if (NULL == container) {
5387                 ERR("calloc() Fail(%d)", errno);
5388                 free(isString);
5389                 free(dataSize);
5390                 free(writeAttribute);
5391                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5392         }
5393
5394         to = zbl_dbus_get_timeout(zcl_global_proxy);
5395         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
5396                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "write_attributes_rsp",
5397                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb,
5398                 container, _zbl_request_cleanup);
5399
5400         if (0 == sub_id) {
5401                 ERR("g_dbus_connection_signal_subscribe() Fail");
5402                 free(isString);
5403                 free(dataSize);
5404                 free(container);
5405                 free(writeAttribute);
5406                 return ZIGBEE_ERROR_IO_ERROR;
5407         }
5408
5409         container->cb = cb;
5410         container->sid = sub_id;
5411         container->cid = ZBL_ZCL_GLOBAL_WRITE_ATTRIBUTE_REQ;
5412         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
5413         container->userdata = user_data;
5414 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5415         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
5416         if (NULL == global_req) {
5417                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
5418                 g_source_remove(container->tid);
5419                 container->tid = 0;
5420                 free(container);
5421                 free(isString);
5422                 free(dataSize);
5423                 free(writeAttribute);
5424                 ERR("calloc() Fail(%d)", errno);
5425                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5426         }
5427         global_req->ep = dst_ep;
5428         global_req->cluster_id = cluster_id;
5429         global_req->command_id = ZB_ZCL_WRITE_ATTRIBUTES_UNDIVIDED_COMMAND_ID;
5430
5431         container->global_cmd = global_req;
5432         container->handle = handle;
5433
5434         /* Register global request information into handle */
5435         _zbl_register_global_req(handle, container);
5436 #endif
5437
5438         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "write_attributes_undivided_req",
5439                 g_variant_new("(@a(y)iqqyyy)", rec_variant, writeAttributeIndex, addr16,
5440                 cluster_id, zcl_frame_ctl, src_ep, dst_ep), G_DBUS_CALL_FLAGS_NONE,
5441                 to, NULL, &dbus_err);
5442
5443         free(isString);
5444         free(dataSize);
5445         free(writeAttribute);
5446
5447         if (!variant) {
5448                 ERR("Failed to get 'write_attributes_undivided_req' [%s]", dbus_err->message);
5449                 g_error_free(dbus_err);
5450                 return ZIGBEE_ERROR_IO_ERROR;
5451         }
5452
5453         g_variant_get(variant, "(i)", &result);
5454         DBG("ret = [0x%x]", result);
5455         g_variant_unref(variant);
5456
5457         return result;
5458 }
5459
5460 int zbl_wattr_req_no_rsp(zigbee_h handle, nwk_addr addr16, unsigned char src_ep,
5461                 unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id,
5462                 write_attr_record_h *records, int records_len)
5463 {
5464         int result = ZIGBEE_ERROR_NONE;
5465         GError *dbus_err = NULL;
5466         GVariant *variant = NULL;
5467
5468         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
5469         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
5470
5471         DBG("zbl_wattr_req_no_rsp()");
5472
5473         GVariantBuilder *rec_builder = NULL;
5474         GVariant *rec_variant = NULL;
5475
5476         int i = 0;
5477         int j = 0;
5478
5479         char dSize[3] = {'\0', '\0'};
5480         int writeAttributeIndex = 0;
5481         int size_of_allo = 0;
5482
5483         unsigned char *isString = NULL;
5484         unsigned short *dataSize = NULL;
5485         unsigned char *writeAttribute = NULL;
5486
5487         isString = calloc(records_len + 1, sizeof(unsigned char));
5488         RETVM_IF(NULL == isString, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
5489
5490         dataSize = calloc(records_len + 1, sizeof(unsigned short));
5491         if (NULL == dataSize) {
5492                 ERR("calloc() Fail(%d)", errno);
5493                 free(isString);
5494                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5495         }
5496
5497         DBG("Records Length %d", records_len);
5498
5499         while (j < records_len) {
5500                 dataSize[j] = zb_get_data_size((*records)[j].type);
5501                 if (0xff != dataSize[j]) {
5502                         isString[j] = 0;
5503                         size_of_allo = size_of_allo + (dataSize[j] + 3);
5504                 } else {
5505                         if ((*records)[j].value) {
5506                                 if ((*records)[j].type == ZB_ZCL_CHRACTER_STRING
5507                                         || (*records)[j].type == ZB_ZCL_OCTAT_STRING) {
5508                                                 isString[j] = 1;
5509                                                 dataSize[j] = (*records)[j].value[0];
5510                                                 size_of_allo = size_of_allo + (dataSize[j] + 3 + 1);
5511                                 } else if ((*records)[j].type == ZB_ZCL_LONG_OCTAT_STRING
5512                                         || (*records)[j].type == ZB_ZCL_LONG_CHRACTER_STRING) {
5513                                         isString[j] = 2;
5514                                         dSize[0] = (*records)[j].value[0];
5515                                         dSize[1] = (*records)[j].value[1];
5516                                         dataSize[j] = dSize[1];
5517                                         dataSize[j] = (dataSize[j] << 8) | dSize[0];
5518                                         size_of_allo = size_of_allo + (dataSize[j] + 3 + 2);
5519                                 }
5520                         } else
5521                                 ERR("Data is not present");
5522                 }
5523                 j++;
5524         }
5525         DBG("size_of_allo Length %d", size_of_allo);
5526
5527         writeAttribute = calloc(size_of_allo + 1, sizeof(unsigned char));
5528         if (NULL == writeAttribute) {
5529                 ERR("Couldn't Allocate Memory");
5530                 free(isString);
5531                 free(dataSize);
5532                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5533         }
5534
5535         j = 0;
5536         while (j < records_len && writeAttributeIndex < size_of_allo) {
5537                 writeAttribute[writeAttributeIndex++] = ((*records)[j].id) & 0xff;
5538                 writeAttribute[writeAttributeIndex++] = (((*records)[j].id) >> 8) & 0xff;
5539                 writeAttribute[writeAttributeIndex++] = (*records)[j].type;
5540                 for (i = 0; i < (dataSize[j] + isString[j]); i++) {
5541                         writeAttribute[writeAttributeIndex++] = (*records)[j].value[i];
5542                         DBG("0x%02X", (*records)[j].value[i]);
5543                 }
5544                 j++;
5545         }
5546
5547         rec_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
5548         DBG("   ");
5549         for (i = 0; i < writeAttributeIndex ; i++) {
5550                 DBG("0x%02X", writeAttribute[i]);
5551                 g_variant_builder_add(rec_builder, "(y)", writeAttribute[i]);
5552         }
5553
5554         rec_variant = g_variant_builder_end(rec_builder);
5555         g_variant_builder_unref(rec_builder);
5556
5557         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "write_attributes_no_resp",
5558                 g_variant_new("(@a(y)iqqyyy)", rec_variant, writeAttributeIndex, addr16,
5559                 cluster_id, zcl_frame_ctl, src_ep, dst_ep), G_DBUS_CALL_FLAGS_NONE,
5560                 -1, NULL, &dbus_err);
5561
5562         free(isString);
5563         free(dataSize);
5564         free(writeAttribute);
5565
5566         if (!variant) {
5567                 ERR("Failed to get 'write_attributes_no_rep' [%s]", dbus_err->message);
5568                 g_error_free(dbus_err);
5569                 return ZIGBEE_ERROR_IO_ERROR;
5570         }
5571
5572         g_variant_get(variant, "(i)", &result);
5573         DBG("ret = [0x%x]", result);
5574         g_variant_unref(variant);
5575
5576         return result;
5577 }
5578
5579 int zbl_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char src_ep,
5580                 unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id,
5581                 report_config_record_h *records, int records_len,
5582                 zb_zcl_global_rsp cb, void *user_data)
5583 {
5584         int sub_id, to;
5585         zbl_req_cb_s *container;
5586
5587         int result = ZIGBEE_ERROR_NONE;
5588         GVariant *variant = NULL;
5589         GError *dbus_err = NULL;
5590
5591 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5592         zb_event_global_default_rsp_s *global_req = NULL;
5593 #endif
5594
5595         int i = 0;
5596         int j = 0;
5597         int len = 0;
5598         int count = 0;
5599
5600         GVariantBuilder *rec_builder = NULL;
5601         GVariant *rec_variant = NULL;
5602
5603         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
5604         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
5605
5606         DBG("zbl_configure_reporting()");
5607
5608         container = calloc(1, sizeof(zbl_req_cb_s));
5609         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
5610
5611         to = zbl_dbus_get_timeout(zcl_global_proxy);
5612         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
5613                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "configure_reporting_rsp",
5614                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb,
5615                 container, _zbl_request_cleanup);
5616
5617         if (0 == sub_id) {
5618                 ERR("g_dbus_connection_signal_subscribe() Fail");
5619                 free(container);
5620                 return ZIGBEE_ERROR_IO_ERROR;
5621         }
5622
5623         container->cb = cb;
5624         container->sid = sub_id;
5625         container->cid = ZBL_ZCL_GLOBAL_CONFIGURE_REPORTING_REQ;
5626         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
5627         container->userdata = user_data;
5628 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5629         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
5630         if (NULL == global_req) {
5631                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
5632                 g_source_remove(container->tid);
5633                 container->tid = 0;
5634                 free(container);
5635                 ERR("calloc() Fail(%d)", errno);
5636                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5637         }
5638         global_req->ep = dst_ep;
5639         global_req->cluster_id = cluster_id;
5640         global_req->command_id = ZB_ZCL_CONFIGURE_REPORTING_COMMAND_ID;
5641
5642         container->global_cmd = global_req;
5643         container->handle = handle;
5644
5645         /* Register global request information into handle */
5646         _zbl_register_global_req(handle, container);
5647 #endif
5648
5649         rec_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
5650         for (i = 0; i < records_len; i++) {
5651                 g_variant_builder_add(rec_builder, "(y)", (*records)[i].dir);
5652                 DBG("dir = 0x%02X", (*records)[i].dir);
5653                 count += sizeof((*records)[i].dir);
5654                 g_variant_builder_add(rec_builder, "(y)", (*records)[i].id & 0xff);
5655                 g_variant_builder_add(rec_builder, "(y)", ((*records)[i].id >> 8) & 0xff);
5656                 DBG("id = 0x%04X", (*records)[i].id);
5657                 count += sizeof((*records)[i].id);
5658                 g_variant_builder_add(rec_builder, "(y)", (*records)[i].type);
5659                 count += sizeof((*records)[i].type);
5660                 DBG("type = 0x%04X", (*records)[i].type);
5661                 g_variant_builder_add(rec_builder, "(y)", (*records)[i].min_i & 0xff);
5662                 g_variant_builder_add(rec_builder, "(y)", ((*records)[i].min_i >> 8) & 0xff);
5663                 DBG("min_i = 0x%04X", (*records)[i].min_i);
5664                 count += sizeof((*records)[i].min_i);
5665                 g_variant_builder_add(rec_builder, "(y)", (*records)[i].max_i & 0xff);
5666                 g_variant_builder_add(rec_builder, "(y)", ((*records)[i].max_i >> 8) & 0xff);
5667                 DBG("max_i = 0x%04X", (*records)[i].max_i);
5668                 count += sizeof((*records)[i].max_i);
5669
5670                 len = zb_get_data_size((*records)[i].type);
5671                 count += len;
5672                 DBG("change length = %d", len);
5673                 DBG("payload length = %d", count);
5674
5675                 for (j = 0; j < len && (*records)[i].change+j; j++) {
5676                         DBG("records[%d]->value[%d] = %d", i, j, (*records)[i].change[j]);
5677                         g_variant_builder_add(rec_builder, "(y)", (*records)[i].change[j]);
5678                 }
5679
5680         }
5681         rec_variant = g_variant_builder_end(rec_builder);
5682         g_variant_builder_unref(rec_builder);
5683
5684         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "configure_reporting_req",
5685                 g_variant_new("(@a(y)qqqyyy)", rec_variant, count, addr16, cluster_id,
5686                 zcl_frame_ctl, src_ep, dst_ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
5687
5688         if (!variant) {
5689                 ERR("Failed to get 'configure_reporting_req' [%s]", dbus_err->message);
5690                 g_error_free(dbus_err);
5691                 return ZIGBEE_ERROR_IO_ERROR;
5692         }
5693
5694         g_variant_get(variant, "(i)", &result);
5695         DBG("ret = [0x%x]", result);
5696         g_variant_unref(variant);
5697
5698         return result;
5699 }
5700
5701 int zbl_read_configure_reporting(zigbee_h handle, nwk_addr addr16, unsigned char src_ep,
5702                 unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id,
5703                 read_report_config_record_h *records, int records_len,
5704                 zb_zcl_global_rsp cb, void *user_data)
5705 {
5706         int sub_id, to;
5707         zbl_req_cb_s *container;
5708
5709         int result = ZIGBEE_ERROR_NONE;
5710         GVariant *variant = NULL;
5711         GError *dbus_err = NULL;
5712
5713 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5714         zb_event_global_default_rsp_s *global_req = NULL;
5715 #endif
5716
5717         int i = 0;
5718         int j = 0;
5719         int size_of_allo = 0;
5720         unsigned short idx = 0;
5721         GVariantBuilder *rec_builder = NULL;
5722         GVariant *rec_variant = NULL;
5723         unsigned char *read_attributes;
5724
5725         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
5726         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
5727
5728         DBG("zbl_read_configure_reporting()");
5729
5730         container = calloc(1, sizeof(zbl_req_cb_s));
5731         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
5732
5733         to = zbl_dbus_get_timeout(zcl_global_proxy);
5734         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
5735                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "read_configure_reporting_rsp",
5736                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb,
5737                 container, _zbl_request_cleanup);
5738
5739         if (0 == sub_id) {
5740                 ERR("g_dbus_connection_signal_subscribe() Fail");
5741                 free(container);
5742                 return ZIGBEE_ERROR_IO_ERROR;
5743         }
5744
5745         container->cb = cb;
5746         container->sid = sub_id;
5747         container->cid = ZBL_ZCL_GLOBAL_READ_CONFIGURE_REPORTING_REQ;
5748         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
5749         container->userdata = user_data;
5750 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5751         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
5752         if (NULL == global_req) {
5753                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
5754                 g_source_remove(container->tid);
5755                 container->tid = 0;
5756                 free(container);
5757                 ERR("calloc() Fail(%d)", errno);
5758                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5759         }
5760         global_req->ep = dst_ep;
5761         global_req->cluster_id = cluster_id;
5762         global_req->command_id = ZB_ZCL_READ_REPORTING_CONFIGURATION_COMMAND_ID;
5763
5764         container->global_cmd = global_req;
5765         container->handle = handle;
5766
5767         /* Register global request information into handle */
5768         _zbl_register_global_req(handle, container);
5769 #endif
5770
5771         DBG("Records Length %d", records_len);
5772         /**
5773          * According to zcl spec
5774          * Memory needed for the read_reporting_configured_frame.
5775          * 1 byte(direction) + 2 bytes(AttributeId)
5776          *  = 3 bytes/variable
5777          */
5778         while (j < records_len) {
5779                 size_of_allo = size_of_allo + 3;
5780                 j++;
5781         }
5782         DBG("size_of_allo Length %d", size_of_allo);
5783
5784         read_attributes = calloc(size_of_allo, sizeof(unsigned char));
5785         if (NULL == read_attributes) {
5786                 ERR("Couldn't Allocate Memory");
5787                 g_dbus_connection_signal_unsubscribe(gdbus_conn, container->sid);
5788                 g_source_remove(container->tid);
5789                 container->tid = 0;
5790                 free(container);
5791                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5792         }
5793         j = 0;
5794         while (j < records_len && idx < size_of_allo) {
5795                 read_attributes[idx++] = (*records)[j].dir;
5796                 read_attributes[idx++] = (*records)[j].id & 0xff;
5797                 read_attributes[idx++] = (*records)[j].id >> 8 & 0xff;
5798                 DBG("Id copied \n");
5799                 j++;
5800         }
5801
5802         rec_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
5803
5804         for (i = 0; i < idx ; i++) {
5805                 DBG("0x%02X", read_attributes[i]);
5806                 g_variant_builder_add(rec_builder, "(y)", read_attributes[i]);
5807         }
5808
5809         rec_variant = g_variant_builder_end(rec_builder);
5810         g_variant_builder_unref(rec_builder);
5811
5812         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "read_configure_reporting",
5813                 g_variant_new("(@a(y)qqqyyy)", rec_variant, idx, addr16, cluster_id, zcl_frame_ctl,
5814                 src_ep, dst_ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
5815
5816         free(read_attributes);
5817
5818         if (!variant) {
5819                 ERR("Failed to get 'read_configure_reporting' [%s]", dbus_err->message);
5820                 g_error_free(dbus_err);
5821                 return ZIGBEE_ERROR_IO_ERROR;
5822         }
5823
5824         g_variant_get(variant, "(i)", &result);
5825         DBG("ret = [0x%x]", result);
5826         g_variant_unref(variant);
5827
5828         return result;
5829 }
5830
5831 int zbl_discover_attr_req(zigbee_h handle, unsigned short addr16, unsigned char src_ep,
5832                 unsigned char dest_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id,
5833                 unsigned short start_id, unsigned char max_attribute_ids,
5834                 zb_zcl_global_discover_attr_rsp cb, void *user_data)
5835 {
5836         int sub_id, to;
5837         zbl_req_cb_s *container;
5838
5839         int result = ZIGBEE_ERROR_NONE;
5840         GVariant *variant = NULL;
5841         GError *dbus_err = NULL;
5842
5843 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5844         zb_event_global_default_rsp_s *global_req = NULL;
5845 #endif
5846
5847         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
5848         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
5849
5850         DBG("zbl_discover_attr_req()");
5851
5852         container = calloc(1, sizeof(zbl_req_cb_s));
5853         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
5854
5855         to = zbl_dbus_get_timeout(zcl_global_proxy);
5856         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
5857                         ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE,  "discover_attribute_rsp",
5858                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
5859                         _zbl_response_cb, container, _zbl_request_cleanup);
5860
5861         if (0 == sub_id) {
5862                 ERR("g_dbus_connection_signal_subscribe() Fail");
5863                 free(container);
5864                 return ZIGBEE_ERROR_IO_ERROR;
5865         }
5866
5867         container->cb = cb;
5868         container->sid = sub_id;
5869         container->cid = ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_REQ;
5870         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
5871         container->userdata = user_data;
5872 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5873         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
5874         if (NULL == global_req) {
5875                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
5876                 g_source_remove(container->tid);
5877                 container->tid = 0;
5878                 free(container);
5879                 ERR("calloc() Fail(%d)", errno);
5880                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5881         }
5882         global_req->ep = dest_ep;
5883         global_req->cluster_id = cluster_id;
5884         global_req->command_id = ZB_ZCL_DISCOVER_ATTRIBUTES_COMMAND_ID;
5885
5886         container->global_cmd = global_req;
5887         container->handle = handle;
5888
5889         /* Register global request information into handle */
5890         _zbl_register_global_req(handle, container);
5891 #endif
5892
5893         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "discover_attributes",
5894                 g_variant_new("(qyyqqy)",
5895                 addr16, dest_ep, zcl_frame_ctl, cluster_id, start_id, max_attribute_ids),
5896                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
5897
5898         if (!variant) {
5899                 ERR("Failed to get 'discover_attributes' [%s]", dbus_err->message);
5900                 g_error_free(dbus_err);
5901                 return ZIGBEE_ERROR_IO_ERROR;
5902         }
5903
5904         g_variant_get(variant, "(i)", &result);
5905         DBG("ret = [0x%x]", result);
5906         g_variant_unref(variant);
5907
5908         return result;
5909 }
5910
5911 int zbl_discover_cmds_gen(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
5912                 unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id,
5913                 unsigned char max_command_ids, zb_zcl_global_discover_cmds_rsp cb, void *user_data)
5914 {
5915         int sub_id, to;
5916         zbl_req_cb_s *container;
5917
5918         int result = ZIGBEE_ERROR_NONE;
5919         GVariant *variant = NULL;
5920         GError *dbus_err = NULL;
5921
5922 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5923         zb_event_global_default_rsp_s *global_req = NULL;
5924 #endif
5925
5926         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
5927         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
5928
5929         DBG("zbl_discover_attr_gen()");
5930
5931         container = calloc(1, sizeof(zbl_req_cb_s));
5932         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
5933
5934         to = zbl_dbus_get_timeout(zcl_global_proxy);
5935         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
5936                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "discover_commands_generated_rsp",
5937                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container,
5938                 _zbl_request_cleanup);
5939
5940         if (0 == sub_id) {
5941                 ERR("g_dbus_connection_signal_subscribe() Fail");
5942                 free(container);
5943                 return ZIGBEE_ERROR_IO_ERROR;
5944         }
5945
5946         container->cb = cb;
5947         container->sid = sub_id;
5948         container->cid = ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_GENERATED_REQ;
5949         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
5950         container->userdata = user_data;
5951 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
5952         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
5953         if (NULL == global_req) {
5954                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
5955                 g_source_remove(container->tid);
5956                 container->tid = 0;
5957                 free(container);
5958                 ERR("calloc() Fail(%d)", errno);
5959                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
5960         }
5961         global_req->ep = dst_ep;
5962         global_req->cluster_id = cluster_id;
5963         global_req->command_id = ZB_ZCL_DISCOVER_COMMANDS_GENERATED_COMMAND_ID;
5964
5965         container->global_cmd = global_req;
5966         container->handle = handle;
5967
5968         /* Register global request information into handle */
5969         _zbl_register_global_req(handle, container);
5970 #endif
5971
5972         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "discover_commands_generated",
5973                 g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl, cluster_id,
5974                 start_command_id, max_command_ids), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
5975
5976         if (!variant) {
5977                 ERR("Failed to get 'discover_commands_received' [%s]", dbus_err->message);
5978                 g_error_free(dbus_err);
5979                 return ZIGBEE_ERROR_IO_ERROR;
5980         }
5981
5982         g_variant_get(variant, "(i)", &result);
5983         DBG("ret = [0x%x]", result);
5984         g_variant_unref(variant);
5985
5986         return result;
5987 }
5988
5989 int zbl_discover_cmds_recv(zigbee_h handle, nwk_addr addr16, unsigned char src_ep, unsigned char dst_ep,
5990                 unsigned char zcl_frame_ctl, unsigned short cluster_id, unsigned char start_command_id,
5991                 unsigned char max_command_ids, zb_zcl_global_discover_cmds_rsp cb, void *user_data)
5992 {
5993         int sub_id, to;
5994         zbl_req_cb_s *container;
5995
5996         int result = ZIGBEE_ERROR_NONE;
5997         GVariant *variant = NULL;
5998         GError *dbus_err = NULL;
5999
6000 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
6001         zb_event_global_default_rsp_s *global_req = NULL;
6002 #endif
6003
6004         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6005         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
6006
6007         DBG("zbl_discover_cmds_recv()");
6008
6009         container = calloc(1, sizeof(zbl_req_cb_s));
6010         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
6011
6012         to = zbl_dbus_get_timeout(zcl_global_proxy);
6013         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
6014                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "discover_commands_received_rsp",
6015                 ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container,
6016                 _zbl_request_cleanup);
6017
6018         if (0 == sub_id) {
6019                 ERR("g_dbus_connection_signal_subscribe() Fail");
6020                 free(container);
6021                 return ZIGBEE_ERROR_IO_ERROR;
6022         }
6023
6024         container->cb = cb;
6025         container->sid = sub_id;
6026         container->cid = ZBL_ZCL_GLOBAL_DISCOVER_COMMAND_RECEIVED_REQ;
6027         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
6028         container->userdata = user_data;
6029 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
6030         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
6031         if (NULL == global_req) {
6032                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
6033                 g_source_remove(container->tid);
6034                 container->tid = 0;
6035                 free(container);
6036                 ERR("calloc() Fail(%d)", errno);
6037                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
6038         }
6039         global_req->ep = dst_ep;
6040         global_req->cluster_id = cluster_id;
6041         global_req->command_id = ZB_ZCL_DISCOVER_COMMANDS_RECEIVED_COMMAND_ID;
6042
6043         container->global_cmd = global_req;
6044         container->handle = handle;
6045
6046         /* Register global request information into handle */
6047         _zbl_register_global_req(handle, container);
6048 #endif
6049
6050         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "discover_commands_received",
6051                 g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl, cluster_id,
6052                 start_command_id, max_command_ids), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
6053
6054         if (!variant) {
6055                 ERR("Failed to get 'discover_commands_received' [%s]", dbus_err->message);
6056                 g_error_free(dbus_err);
6057                 return ZIGBEE_ERROR_IO_ERROR;
6058         }
6059
6060         g_variant_get(variant, "(i)", &result);
6061         DBG("ret = [0x%x]", result);
6062         g_variant_unref(variant);
6063
6064         return result;
6065 }
6066
6067 int zbl_discover_attr_ext(zigbee_h handle, nwk_addr addr16, unsigned char src_ep,
6068         unsigned char dst_ep, unsigned char zcl_frame_ctl, unsigned short cluster_id,
6069         unsigned short start_id, unsigned char max_attribute_ids,
6070         zb_zcl_global_discover_attr_extended_rsp cb, void *user_data)
6071 {
6072         int sub_id, to;
6073         zbl_req_cb_s *container;
6074
6075         int result = ZIGBEE_ERROR_NONE;
6076         GVariant *variant = NULL;
6077         GError *dbus_err = NULL;
6078
6079 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
6080         zb_event_global_default_rsp_s *global_req = NULL;
6081 #endif
6082
6083         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6084         RETV_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR);
6085
6086         DBG("zbl_discover_attr_ext()");
6087
6088         container = calloc(1, sizeof(zbl_req_cb_s));
6089         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
6090
6091         to = zbl_dbus_get_timeout(zcl_global_proxy);
6092         sub_id = g_dbus_connection_signal_subscribe(gdbus_conn, NULL,
6093                 ZIGBEE_ZCL_GLOBAL_CONTROL_INTERFACE, "discover_attributes_extended_rsp",
6094                 ZIGBEE_CONTROL_OBJECT_PATH,     NULL, 0, _zbl_response_cb, container,
6095                 _zbl_request_cleanup);
6096
6097         if (0 == sub_id) {
6098                 ERR("g_dbus_connection_signal_subscribe() Fail");
6099                 free(container);
6100                 return ZIGBEE_ERROR_IO_ERROR;
6101         }
6102
6103         container->cb = cb;
6104         container->sid = sub_id;
6105         container->cid = ZBL_ZCL_GLOBAL_DISCOVER_ATTRIBUTE_EXTENDED_REQ;
6106         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
6107         container->userdata = user_data;
6108 #ifdef ZB_FEATURE_GLOBAL_RSP_SYNC
6109         global_req = calloc(1, sizeof(zb_event_global_default_rsp_s));
6110         if (NULL == global_req) {
6111                 g_dbus_connection_signal_unsubscribe(gdbus_conn, sub_id);
6112                 g_source_remove(container->tid);
6113                 container->tid = 0;
6114                 free(container);
6115                 ERR("calloc() Fail(%d)", errno);
6116                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
6117         }
6118         global_req->ep = dst_ep;
6119         global_req->cluster_id = cluster_id;
6120         global_req->command_id = ZB_ZCL_DISCOVER_ATTRIBUTES_EXTENDED_COMMAND_ID;
6121
6122         container->global_cmd = global_req;
6123         container->handle = handle;
6124
6125         /* Register global request information into handle */
6126         _zbl_register_global_req(handle, container);
6127 #endif
6128
6129         variant = g_dbus_proxy_call_sync(zcl_global_proxy, "discover_attributes_extended",
6130                 g_variant_new("(qyyqqy)", addr16, dst_ep, zcl_frame_ctl, cluster_id, start_id,
6131                 max_attribute_ids), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
6132
6133         if (!variant) {
6134                 ERR("Failed to get 'discover_attributes_extended' [%s]", dbus_err->message);
6135                 g_error_free(dbus_err);
6136                 return ZIGBEE_ERROR_IO_ERROR;
6137         }
6138
6139         g_variant_get(variant, "(i)", &result);
6140         DBG("ret = [0x%x]", result);
6141         g_variant_unref(variant);
6142
6143         return result;
6144 }
6145
6146 int zbl_reset_alarm(nwk_addr addr16, unsigned char ep, unsigned char alarm_code,
6147                 unsigned short cluster_id)
6148 {
6149         int result = ZIGBEE_ERROR_NONE;
6150         GVariant *variant = NULL;
6151         GError *dbus_err = NULL;
6152
6153         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6154         RETV_IF(NULL == alarm_gproxy, ZIGBEE_ERROR_IO_ERROR);
6155
6156         variant = g_dbus_proxy_call_sync(alarm_gproxy, "reset_alarm",
6157                 g_variant_new("(qyyq)", addr16, ep, alarm_code, cluster_id),
6158                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6159
6160         if (!variant) {
6161                 ERR("Failed to get 'reset_alarm' [%s]", dbus_err->message);
6162                 g_error_free(dbus_err);
6163                 return ZIGBEE_ERROR_IO_ERROR;
6164         }
6165
6166         g_variant_get(variant, "(i)", &result);
6167         DBG("ret = [0x%x]", result);
6168         g_variant_unref(variant);
6169
6170         return result;
6171 }
6172
6173 int zbl_reset_all_alarm(nwk_addr addr16, unsigned char ep)
6174 {
6175         int result = ZIGBEE_ERROR_NONE;
6176         GVariant *variant = NULL;
6177         GError *dbus_err = NULL;
6178
6179         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6180         RETV_IF(NULL == alarm_gproxy, ZIGBEE_ERROR_IO_ERROR);
6181
6182         variant = g_dbus_proxy_call_sync(alarm_gproxy, "reset_all_alarm",
6183                 g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6184
6185         if (!variant) {
6186                 ERR("Failed to get 'reset_all_alarm' [%s]", dbus_err->message);
6187                 g_error_free(dbus_err);
6188                 return ZIGBEE_ERROR_IO_ERROR;
6189         }
6190
6191         g_variant_get(variant, "(i)", &result);
6192         DBG("ret = [0x%x]", result);
6193         g_variant_unref(variant);
6194
6195         return result;
6196 }
6197
6198 int zbl_get_alarm(nwk_addr addr16, unsigned char ep, zb_zcl_alarm_get_alarm_rsp cb,
6199                 void *user_data)
6200 {
6201         int sub_id, to;
6202         zbl_req_cb_s *container;
6203
6204         int result = ZIGBEE_ERROR_NONE;
6205         GVariant *variant = NULL;
6206         GError *dbus_err = NULL;
6207
6208         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6209         RETV_IF(NULL == alarm_gproxy, ZIGBEE_ERROR_IO_ERROR);
6210
6211         DBG("zbl_get_alarm()");
6212
6213         container = calloc(1, sizeof(zbl_req_cb_s));
6214         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
6215
6216         to = zbl_dbus_get_timeout(alarm_gproxy);
6217         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
6218                         ZIGBEE_ZCL_ALARM_INTERFACE,  "get_alarm_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
6219                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
6220
6221         if (0 == sub_id) {
6222                 ERR("g_dbus_connection_signal_subscribe() Fail");
6223                 free(container);
6224                 return ZIGBEE_ERROR_IO_ERROR;
6225         }
6226
6227         container->cb = cb;
6228         container->sid = sub_id;
6229         container->cid = ZBL_ZCL_ALARM_GET_ALARM_REQ;
6230         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
6231         container->userdata = user_data;
6232
6233         variant = g_dbus_proxy_call_sync(alarm_gproxy, "get_alarm",
6234                 g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
6235
6236         if (!variant) {
6237                 ERR("Failed to get 'get_alarm' [%s]", dbus_err->message);
6238                 g_error_free(dbus_err);
6239                 return ZIGBEE_ERROR_IO_ERROR;
6240         }
6241
6242         g_variant_get(variant, "(i)", &result);
6243         DBG("ret = [0x%x]", result);
6244         g_variant_unref(variant);
6245
6246         return result;
6247 }
6248
6249 int zbl_reset_all_alarm_log(nwk_addr addr16, unsigned char ep)
6250 {
6251         int result = ZIGBEE_ERROR_NONE;
6252         GVariant *variant = NULL;
6253         GError *dbus_err = NULL;
6254
6255         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6256         RETV_IF(NULL == alarm_gproxy, ZIGBEE_ERROR_IO_ERROR);
6257
6258         variant = g_dbus_proxy_call_sync(alarm_gproxy, "reset_alarm_log",
6259                 g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6260
6261         if (!variant) {
6262                 ERR("Failed to get 'reset_alarm_log' [%s]", dbus_err->message);
6263                 g_error_free(dbus_err);
6264                 return ZIGBEE_ERROR_IO_ERROR;
6265         }
6266
6267         g_variant_get(variant, "(i)", &result);
6268         DBG("ret = [0x%x]", result);
6269         g_variant_unref(variant);
6270
6271         return result;
6272 }
6273
6274 int zbl_ccontrol_move_to_hue(nwk_addr addr16, unsigned char ep,
6275                 unsigned char hue, unsigned char direction,
6276                 unsigned short transition_time)
6277 {
6278         int result = ZIGBEE_ERROR_NONE;
6279         GVariant *variant = NULL;
6280         GError *dbus_err = NULL;
6281
6282         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6283         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6284
6285         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_to_hue",
6286                         g_variant_new("(qyyyq)", addr16, ep, hue, direction, transition_time),
6287                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6288
6289         if (!variant) {
6290                 ERR("Failed to get 'move_to_hue' [%s]", dbus_err->message);
6291                 g_error_free(dbus_err);
6292                 return ZIGBEE_ERROR_IO_ERROR;
6293         }
6294
6295         g_variant_get(variant, "(i)", &result);
6296         DBG("ret = [0x%x]", result);
6297         g_variant_unref(variant);
6298
6299         return result;
6300 }
6301
6302
6303 int zbl_ccontrol_move_hue(nwk_addr addr16, unsigned char ep,
6304                 unsigned char move_mode, unsigned char rate)
6305 {
6306         int result = ZIGBEE_ERROR_NONE;
6307         GVariant *variant = NULL;
6308         GError *dbus_err = NULL;
6309
6310         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6311         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6312
6313         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_hue",
6314                         g_variant_new("(qyyy)", addr16, ep, move_mode, rate),
6315                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6316
6317         if (!variant) {
6318                 ERR("Failed to get 'move_hue' [%s]", dbus_err->message);
6319                 g_error_free(dbus_err);
6320                 return ZIGBEE_ERROR_IO_ERROR;
6321         }
6322
6323         g_variant_get(variant, "(i)", &result);
6324         DBG("ret = [0x%x]", result);
6325         g_variant_unref(variant);
6326
6327         return result;
6328 }
6329
6330 int zbl_ccontrol_step_hue(nwk_addr addr16, unsigned char ep,
6331                 unsigned char step_mode, unsigned char step_size,
6332                 unsigned char transition_time)
6333 {
6334         int result = ZIGBEE_ERROR_NONE;
6335         GVariant *variant = NULL;
6336         GError *dbus_err = NULL;
6337
6338         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6339         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6340
6341         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "step_hue",
6342                         g_variant_new("(qyyyy)", addr16, ep, step_mode, step_size, transition_time),
6343                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6344
6345         if (!variant) {
6346                 ERR("Failed to get 'step_hue' [%s]", dbus_err->message);
6347                 g_error_free(dbus_err);
6348                 return ZIGBEE_ERROR_IO_ERROR;
6349         }
6350
6351         g_variant_get(variant, "(i)", &result);
6352         DBG("ret = [0x%x]", result);
6353         g_variant_unref(variant);
6354
6355         return result;
6356 }
6357
6358 int zbl_ccontrol_move_to_saturation(nwk_addr addr16, unsigned char ep,
6359                 unsigned char saturation, unsigned short transition_time)
6360 {
6361         int result = ZIGBEE_ERROR_NONE;
6362         GVariant *variant = NULL;
6363         GError *dbus_err = NULL;
6364
6365         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6366         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6367
6368         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_to_saturation",
6369                         g_variant_new("(qyyq)", addr16, ep, saturation, transition_time),
6370                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6371
6372         if (!variant) {
6373                 ERR("Failed to get 'move_to_saturation' [%s]", dbus_err->message);
6374                 g_error_free(dbus_err);
6375                 return ZIGBEE_ERROR_IO_ERROR;
6376         }
6377
6378         g_variant_get(variant, "(i)", &result);
6379         DBG("ret = [0x%x]", result);
6380         g_variant_unref(variant);
6381
6382         return result;
6383 }
6384
6385 int zbl_ccontrol_move_saturation(nwk_addr addr16, unsigned char ep,
6386                 unsigned char move_mode, unsigned char rate)
6387 {
6388         int result = ZIGBEE_ERROR_NONE;
6389         GVariant *variant = NULL;
6390         GError *dbus_err = NULL;
6391
6392         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6393         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6394
6395         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_saturation",
6396                         g_variant_new("(qyyy)", addr16, ep, move_mode, rate),
6397                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6398
6399         if (!variant) {
6400                 ERR("Failed to get 'move_saturation' [%s]", dbus_err->message);
6401                 g_error_free(dbus_err);
6402                 return ZIGBEE_ERROR_IO_ERROR;
6403         }
6404
6405         g_variant_get(variant, "(i)", &result);
6406         DBG("ret = [0x%x]", result);
6407         g_variant_unref(variant);
6408
6409         return result;
6410 }
6411
6412 int zbl_ccontrol_step_saturation(nwk_addr addr16, unsigned char ep,
6413                 unsigned char step_mode, unsigned char step_size,
6414                 unsigned char transition_time)
6415 {
6416         int result = ZIGBEE_ERROR_NONE;
6417         GVariant *variant = NULL;
6418         GError *dbus_err = NULL;
6419
6420         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6421         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6422
6423         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "step_saturation",
6424                         g_variant_new("(qyyyy)", addr16, ep, step_mode, step_size, transition_time),
6425                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6426
6427         if (!variant) {
6428                 ERR("Failed to get 'step_saturation' [%s]", dbus_err->message);
6429                 g_error_free(dbus_err);
6430                 return ZIGBEE_ERROR_IO_ERROR;
6431         }
6432
6433         g_variant_get(variant, "(i)", &result);
6434         DBG("ret = [0x%x]", result);
6435         g_variant_unref(variant);
6436
6437         return result;
6438 }
6439
6440 int zbl_ccontrol_move_to_hue_and_saturation(nwk_addr addr16, unsigned char ep,
6441                 unsigned char hue, unsigned char saturation,
6442                 unsigned short transition_time)
6443 {
6444         int result = ZIGBEE_ERROR_NONE;
6445         GVariant *variant = NULL;
6446         GError *dbus_err = NULL;
6447
6448         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6449         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6450
6451         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_to_hue_and_saturation",
6452                         g_variant_new("(qyyyq)", addr16, ep, hue, saturation, transition_time),
6453                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6454
6455         if (!variant) {
6456                 ERR("Failed to get 'move_to_hue_and_saturation' [%s]", dbus_err->message);
6457                 g_error_free(dbus_err);
6458                 return ZIGBEE_ERROR_IO_ERROR;
6459         }
6460
6461         g_variant_get(variant, "(i)", &result);
6462         DBG("ret = [0x%x]", result);
6463         g_variant_unref(variant);
6464
6465         return result;
6466 }
6467
6468 int zbl_ccontrol_move_to_color(nwk_addr addr16, unsigned char ep,
6469                 unsigned short color_x, unsigned short color_y,
6470                 unsigned short transition_time)
6471 {
6472         int result = ZIGBEE_ERROR_NONE;
6473         GVariant *variant = NULL;
6474         GError *dbus_err = NULL;
6475
6476         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6477         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6478
6479         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_to_color",
6480                         g_variant_new("(qyqqq)", addr16, ep, color_x, color_y, transition_time),
6481                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6482
6483         if (!variant) {
6484                 ERR("Failed to get 'move_to_color' [%s]", dbus_err->message);
6485                 g_error_free(dbus_err);
6486                 return ZIGBEE_ERROR_IO_ERROR;
6487         }
6488
6489         g_variant_get(variant, "(i)", &result);
6490         DBG("ret = [0x%x]", result);
6491         g_variant_unref(variant);
6492
6493         return result;
6494 }
6495
6496 int zbl_ccontrol_move_color(nwk_addr addr16, unsigned char ep,
6497                 unsigned short rate_x, unsigned short rate_y)
6498 {
6499         int result = ZIGBEE_ERROR_NONE;
6500         GVariant *variant = NULL;
6501         GError *dbus_err = NULL;
6502
6503         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6504         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6505
6506         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_color",
6507                         g_variant_new("(qyqq)", addr16, ep, rate_x, rate_y),
6508                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6509
6510         if (!variant) {
6511                 ERR("Failed to get 'move_color' [%s]", dbus_err->message);
6512                 g_error_free(dbus_err);
6513                 return ZIGBEE_ERROR_IO_ERROR;
6514         }
6515
6516         g_variant_get(variant, "(i)", &result);
6517         DBG("ret = [0x%x]", result);
6518         g_variant_unref(variant);
6519
6520         return result;
6521 }
6522
6523 int zbl_ccontrol_step_color(nwk_addr addr16, unsigned char ep,
6524                 unsigned short step_x, unsigned short step_y,
6525                 unsigned short transition_time)
6526 {
6527         int result = ZIGBEE_ERROR_NONE;
6528         GVariant *variant = NULL;
6529         GError *dbus_err = NULL;
6530
6531         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6532         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6533
6534         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "step_color",
6535                         g_variant_new("(qyqqq)", addr16, ep, step_x, step_y, transition_time),
6536                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6537
6538         if (!variant) {
6539                 ERR("Failed to get 'step_color' [%s]", dbus_err->message);
6540                 g_error_free(dbus_err);
6541                 return ZIGBEE_ERROR_IO_ERROR;
6542         }
6543
6544         g_variant_get(variant, "(i)", &result);
6545         DBG("ret = [0x%x]", result);
6546         g_variant_unref(variant);
6547
6548         return result;
6549 }
6550
6551 int zbl_ccontrol_move_to_color_temperature(nwk_addr addr16, unsigned char ep,
6552                 unsigned short color_temperature,
6553                 unsigned short transition_time)
6554 {
6555         int result = ZIGBEE_ERROR_NONE;
6556         GVariant *variant = NULL;
6557         GError *dbus_err = NULL;
6558
6559         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6560         RETV_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR);
6561
6562         variant = g_dbus_proxy_call_sync(zcl_color_control_proxy, "move_color_temperature",
6563                         g_variant_new("(qyqq)", addr16, ep, color_temperature, transition_time),
6564                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6565
6566         if (!variant) {
6567                 ERR("Failed to get 'move_color_temperature' [%s]", dbus_err->message);
6568                 g_error_free(dbus_err);
6569                 return ZIGBEE_ERROR_IO_ERROR;
6570         }
6571
6572         g_variant_get(variant, "(i)", &result);
6573         DBG("ret = [0x%x]", result);
6574         g_variant_unref(variant);
6575
6576         return result;
6577 }
6578
6579 int zbl_reset_factory_default(nwk_addr addr16, unsigned char ep)
6580 {
6581         int result = ZIGBEE_ERROR_NONE;
6582         GVariant *variant = NULL;
6583         GError *dbus_err = NULL;
6584
6585         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6586         RETV_IF(NULL == zcl_basic_proxy, ZIGBEE_ERROR_IO_ERROR);
6587
6588         variant = g_dbus_proxy_call_sync(zcl_basic_proxy, "reset_factory_default",
6589                 g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6590
6591         if (!variant) {
6592                 ERR("Failed to get 'reset_factory_default' [%s]", dbus_err->message);
6593                 g_error_free(dbus_err);
6594                 return ZIGBEE_ERROR_IO_ERROR;
6595         }
6596
6597         g_variant_get(variant, "(i)", &result);
6598         DBG("ret = [0x%x]", result);
6599         g_variant_unref(variant);
6600
6601         return result;
6602 }
6603
6604 int zbl_identify(nwk_addr addr16, unsigned char dst_ep, unsigned short identify_time)
6605 {
6606         int result = ZIGBEE_ERROR_NONE;
6607         GVariant *variant = NULL;
6608         GError *dbus_err = NULL;
6609
6610         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6611         RETV_IF(NULL == zcl_identify_proxy, ZIGBEE_ERROR_IO_ERROR);
6612
6613         variant = g_dbus_proxy_call_sync(zcl_identify_proxy, "identify",
6614                 g_variant_new("(qyq)", addr16, dst_ep, identify_time),
6615                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6616
6617         if (!variant) {
6618                 ERR("Failed to get 'identify' [%s]", dbus_err->message);
6619                 g_error_free(dbus_err);
6620                 return ZIGBEE_ERROR_IO_ERROR;
6621         }
6622
6623         g_variant_get(variant, "(i)", &result);
6624         DBG("ret = [0x%x]", result);
6625         g_variant_unref(variant);
6626
6627         return result;
6628 }
6629
6630 int zbl_identify_query(nwk_addr addr16, unsigned char dst_ep,
6631                 zb_zcl_identify_query_cb cb, void *user_data)
6632 {
6633         int result = ZIGBEE_ERROR_NONE;
6634         GVariant *variant = NULL;
6635         GError *dbus_err = NULL;
6636
6637         int sub_id, to;
6638         zbl_req_cb_s *container;
6639
6640         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6641         RETV_IF(NULL == zcl_identify_proxy, ZIGBEE_ERROR_IO_ERROR);
6642
6643         DBG("zbl_identify_query()");
6644
6645         container = calloc(1, sizeof(zbl_req_cb_s));
6646         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
6647
6648         to = zbl_dbus_get_timeout(zcl_identify_proxy);
6649         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
6650                         ZIGBEE_ZCL_IDENTIFY_INTERFACE, "query_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
6651                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
6652
6653         if (0 == sub_id) {
6654                 ERR("g_dbus_connection_signal_subscribe() Fail");
6655                 free(container);
6656                 return ZIGBEE_ERROR_IO_ERROR;
6657         }
6658
6659         container->cb = cb;
6660         container->sid = sub_id;
6661         container->cid = ZBL_ZCL_IDENTIFY_QUERY_REQ;
6662         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
6663         container->userdata = user_data;
6664
6665         variant = g_dbus_proxy_call_sync(zcl_identify_proxy, "query",
6666                 g_variant_new("(qy)", addr16, dst_ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6667
6668         if (!variant) {
6669                 ERR("Failed to get 'query' [%s]", dbus_err->message);
6670                 g_error_free(dbus_err);
6671                 return ZIGBEE_ERROR_IO_ERROR;
6672         }
6673
6674         g_variant_get(variant, "(i)", &result);
6675         DBG("ret = [0x%x]", result);
6676         g_variant_unref(variant);
6677
6678         return result;
6679 }
6680
6681 int zbl_add_group(nwk_addr addr16, unsigned char ep, unsigned short group_id,
6682                 const char *group_name, zb_zcl_group_add_group_rsp cb, void *user_data)
6683 {
6684         int result = ZIGBEE_ERROR_NONE;
6685         GVariant *variant = NULL;
6686         GError *dbus_err = NULL;
6687
6688         int sub_id, to;
6689         zbl_req_cb_s *container;
6690
6691         int j = 0;
6692         GVariant *groupname_variant = NULL;
6693         GVariantBuilder *groupname_builder = NULL;
6694
6695         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6696         RETV_IF(NULL == zcl_group_proxy, ZIGBEE_ERROR_IO_ERROR);
6697
6698         DBG("zbl_add_group()");
6699
6700         container = calloc(1, sizeof(zbl_req_cb_s));
6701         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
6702
6703         to = zbl_dbus_get_timeout(zcl_group_proxy);
6704         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
6705                         ZIGBEE_ZCL_GROUP_INTERFACE, "add_group_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
6706                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
6707
6708         if (0 == sub_id) {
6709                 ERR("g_dbus_connection_signal_subscribe() Fail");
6710                 free(container);
6711                 return ZIGBEE_ERROR_IO_ERROR;
6712         }
6713
6714         container->cb = cb;
6715         container->sid = sub_id;
6716         container->cid = ZBL_ZCL_GROUP_ADD_GROUP_REQ;
6717         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
6718         container->userdata = user_data;
6719
6720         groupname_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
6721         while (group_name[j] != '\0') {
6722                 g_variant_builder_add(groupname_builder, "(y)", (group_name[j]));
6723                 j++;
6724         }
6725         groupname_variant = g_variant_builder_end(groupname_builder);
6726         g_variant_builder_unref(groupname_builder);
6727
6728         variant = g_dbus_proxy_call_sync(zcl_group_proxy, "add_group",
6729                 g_variant_new("(qyq@a(y))", addr16, ep, group_id, groupname_variant),
6730                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6731
6732         if (!variant) {
6733                 ERR("Failed to get 'add_group' [%s]", dbus_err->message);
6734                 g_error_free(dbus_err);
6735                 return ZIGBEE_ERROR_IO_ERROR;
6736         }
6737
6738         g_variant_get(variant, "(i)", &result);
6739         DBG("ret = [0x%x]", result);
6740         g_variant_unref(variant);
6741
6742         return result;
6743 }
6744
6745 int zbl_view_group(nwk_addr addr16, unsigned char ep, unsigned short group_id,
6746                 zb_zcl_group_view_group_rsp cb, void *user_data)
6747 {
6748         int result = ZIGBEE_ERROR_NONE;
6749         GVariant *variant = NULL;
6750         GError *dbus_err = NULL;
6751
6752         int sub_id, to;
6753         zbl_req_cb_s *container;
6754
6755         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6756         RETV_IF(NULL == zcl_group_proxy, ZIGBEE_ERROR_IO_ERROR);
6757
6758         DBG("zbl_view_group()");
6759
6760         container = calloc(1, sizeof(zbl_req_cb_s));
6761         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
6762
6763         to = zbl_dbus_get_timeout(zcl_group_proxy);
6764         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
6765                         ZIGBEE_ZCL_GROUP_INTERFACE,  "view_group_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
6766                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
6767
6768         if (0 == sub_id) {
6769                 ERR("g_dbus_connection_signal_subscribe() Fail");
6770                 free(container);
6771                 return ZIGBEE_ERROR_IO_ERROR;
6772         }
6773
6774         container->cb = cb;
6775         container->sid = sub_id;
6776         container->cid = ZBL_ZCL_GROUP_VIEW_GROUP_REQ;
6777         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
6778         container->userdata = user_data;
6779
6780         variant = g_dbus_proxy_call_sync(zcl_group_proxy, "view_group",
6781                 g_variant_new("(qyq)", addr16, ep, group_id),
6782                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6783
6784         if (!variant) {
6785                 ERR("Failed to get 'view_group' [%s]", dbus_err->message);
6786                 g_error_free(dbus_err);
6787                 return ZIGBEE_ERROR_IO_ERROR;
6788         }
6789
6790         g_variant_get(variant, "(i)", &result);
6791         DBG("ret = [0x%x]", result);
6792         g_variant_unref(variant);
6793
6794         return result;
6795 }
6796
6797 int zbl_group_get_group_membership(nwk_addr addr16, unsigned char ep,
6798                 unsigned char group_count, unsigned short *group_list,
6799                 zb_zcl_group_get_group_membership_rsp cb, void *user_data)
6800 {
6801         int result = ZIGBEE_ERROR_NONE;
6802         GVariant *variant = NULL;
6803         GError *dbus_err = NULL;
6804
6805         int sub_id, to;
6806         zbl_req_cb_s *container;
6807
6808         int j = 0;
6809         GVariant *grouplist_variant = NULL;
6810         GVariantBuilder *grouplist_builder = NULL;
6811
6812         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6813         RETV_IF(NULL == zcl_group_proxy, ZIGBEE_ERROR_IO_ERROR);
6814
6815         DBG("zbl_group_get_group_membership()");
6816
6817         container = calloc(1, sizeof(zbl_req_cb_s));
6818         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
6819
6820         to = zbl_dbus_get_timeout(zcl_group_proxy);
6821         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
6822                         ZIGBEE_ZCL_GROUP_INTERFACE,  "get_group_membership_rsp",
6823                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb,
6824                         container, _zbl_request_cleanup);
6825
6826         if (0 == sub_id) {
6827                 ERR("g_dbus_connection_signal_subscribe() Fail");
6828                 free(container);
6829                 return ZIGBEE_ERROR_IO_ERROR;
6830         }
6831
6832         container->cb = cb;
6833         container->sid = sub_id;
6834         container->cid = ZBL_ZCL_GROUP_GET_GROUP_MEMBERSHIP_REQ;
6835         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
6836         container->userdata = user_data;
6837
6838         grouplist_builder = g_variant_builder_new(G_VARIANT_TYPE("aq"));
6839         while (j < group_count) {
6840                 g_variant_builder_add(grouplist_builder, "q", group_list[j]);
6841                 j++;
6842         }
6843         grouplist_variant = g_variant_builder_end(grouplist_builder);
6844         g_variant_builder_unref(grouplist_builder);
6845
6846         variant = g_dbus_proxy_call_sync(zcl_group_proxy, "get_group_membership",
6847                 g_variant_new("(qyy@aq)", addr16, ep, group_count,      grouplist_variant),
6848                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6849
6850         if (!variant) {
6851                 ERR("Failed to get 'get_group_membership' [%s]", dbus_err->message);
6852                 g_error_free(dbus_err);
6853                 return ZIGBEE_ERROR_IO_ERROR;
6854         }
6855
6856         g_variant_get(variant, "(i)", &result);
6857         DBG("ret = [0x%x]", result);
6858         g_variant_unref(variant);
6859
6860         return result;
6861 }
6862
6863 int zbl_remove_group(nwk_addr addr16, unsigned char ep, unsigned short group_id,
6864                 zb_zcl_group_remove_group_rsp cb, void *user_data)
6865 {
6866         int result = ZIGBEE_ERROR_NONE;
6867         GVariant *variant = NULL;
6868         GError *dbus_err = NULL;
6869
6870         int sub_id, to;
6871         zbl_req_cb_s *container;
6872
6873         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6874         RETV_IF(NULL == zcl_group_proxy, ZIGBEE_ERROR_IO_ERROR);
6875
6876         DBG("zbl_group_remove_group()");
6877
6878         container = calloc(1, sizeof(zbl_req_cb_s));
6879         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
6880
6881         to = zbl_dbus_get_timeout(zcl_group_proxy);
6882         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
6883                         ZIGBEE_ZCL_GROUP_INTERFACE,  "remove_group_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
6884                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
6885
6886         if (0 == sub_id) {
6887                 ERR("g_dbus_connection_signal_subscribe() Fail");
6888                 free(container);
6889                 return ZIGBEE_ERROR_IO_ERROR;
6890         }
6891
6892         container->cb = cb;
6893         container->sid = sub_id;
6894         container->cid = ZBL_ZCL_GROUP_REMOVE_GROUP_REQ;
6895         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
6896         container->userdata = user_data;
6897
6898         variant = g_dbus_proxy_call_sync(zcl_group_proxy, "remove_group", g_variant_new("(qyq)",
6899                 addr16, ep, group_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6900
6901         if (!variant) {
6902                 ERR("Failed to get 'remove_group' [%s]", dbus_err->message);
6903                 g_error_free(dbus_err);
6904                 return ZIGBEE_ERROR_IO_ERROR;
6905         }
6906
6907         g_variant_get(variant, "(i)", &result);
6908         DBG("ret = [0x%x]", result);
6909         g_variant_unref(variant);
6910
6911         return result;
6912 }
6913
6914 int zbl_remove_all_group(nwk_addr addr16, unsigned char ep)
6915 {
6916         int result = ZIGBEE_ERROR_NONE;
6917         GVariant *variant = NULL;
6918         GError *dbus_err = NULL;
6919
6920         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6921         RETV_IF(NULL == zcl_group_proxy, ZIGBEE_ERROR_IO_ERROR);
6922
6923         DBG("zbl_group_remove_all_group()");
6924
6925         variant = g_dbus_proxy_call_sync(zcl_group_proxy, "remove_all_group",
6926                 g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6927
6928         if (!variant) {
6929                 ERR("Failed to get 'remove_all_group' [%s]", dbus_err->message);
6930                 g_error_free(dbus_err);
6931                 return ZIGBEE_ERROR_IO_ERROR;
6932         }
6933
6934         g_variant_get(variant, "(i)", &result);
6935         DBG("ret = [0x%x]", result);
6936         g_variant_unref(variant);
6937
6938         return result;
6939 }
6940
6941 int zbl_add_group_if_identifying(nwk_addr addr16, unsigned char ep,
6942                 unsigned short group_id, const char *group_name)
6943 {
6944         int result = ZIGBEE_ERROR_NONE;
6945         GVariant *variant = NULL;
6946         GError *dbus_err = NULL;
6947
6948         int j = 0;
6949         GVariant *groupname_variant = NULL;
6950         GVariantBuilder *groupname_builder = NULL;
6951
6952         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6953         RETV_IF(NULL == zcl_group_proxy, ZIGBEE_ERROR_IO_ERROR);
6954
6955         groupname_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
6956         while (group_name[j] != '\0') {
6957                 g_variant_builder_add(groupname_builder, "(y)", group_name[j]);
6958                 j++;
6959         }
6960         groupname_variant = g_variant_builder_end(groupname_builder);
6961         g_variant_builder_unref(groupname_builder);
6962
6963         variant = g_dbus_proxy_call_sync(zcl_group_proxy, "add_group_if_identifying",
6964                 g_variant_new("(qyq@a(y))", addr16, ep, group_id, groupname_variant),
6965                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6966
6967         if (!variant) {
6968                 ERR("Failed to get 'add_group_if_identifying' [%s]", dbus_err->message);
6969                 g_error_free(dbus_err);
6970                 return ZIGBEE_ERROR_IO_ERROR;
6971         }
6972
6973         g_variant_get(variant, "(i)", &result);
6974         DBG("ret = [0x%x]", result);
6975         g_variant_unref(variant);
6976
6977         return result;
6978 }
6979
6980 int zbl_level_control_move_to_level(nwk_addr addr16, unsigned char ep,
6981                 unsigned char level, unsigned short transition_time)
6982 {
6983         int result = ZIGBEE_ERROR_NONE;
6984         GVariant *variant = NULL;
6985         GError *dbus_err = NULL;
6986
6987         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
6988         RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR);
6989
6990         DBG("zbl_level_control_move_to_level()");
6991
6992         variant = g_dbus_proxy_call_sync(level_control_gproxy, "move_to_level",
6993                 g_variant_new("(qyyq)", addr16, ep, level, transition_time),
6994                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
6995
6996         if (!variant) {
6997                 ERR("Failed to get 'move_to_level' [%s]", dbus_err->message);
6998                 g_error_free(dbus_err);
6999                 return ZIGBEE_ERROR_IO_ERROR;
7000         }
7001
7002         g_variant_get(variant, "(i)", &result);
7003         DBG("ret = [0x%x]", result);
7004         g_variant_unref(variant);
7005
7006         return result;
7007 }
7008
7009 int zbl_level_control_move(nwk_addr addr16, unsigned char ep,
7010                 unsigned char move_mode, unsigned char rate)
7011 {
7012         int result = ZIGBEE_ERROR_NONE;
7013         GVariant *variant = NULL;
7014         GError *dbus_err = NULL;
7015
7016         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7017         RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR);
7018
7019         DBG("zbl_level_control_move()");
7020
7021         variant = g_dbus_proxy_call_sync(level_control_gproxy, "move",
7022                 g_variant_new("(qyyy)", addr16, ep, move_mode, rate),
7023                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7024
7025         if (!variant) {
7026                 ERR("Failed to get 'move' [%s]", dbus_err->message);
7027                 g_error_free(dbus_err);
7028                 return ZIGBEE_ERROR_IO_ERROR;
7029         }
7030
7031         g_variant_get(variant, "(i)", &result);
7032         DBG("ret = [0x%x]", result);
7033         g_variant_unref(variant);
7034
7035         return result;
7036 }
7037
7038 int zbl_level_control_step(nwk_addr addr16, unsigned char ep,
7039                 unsigned char step_mode, unsigned char step_size,
7040                 unsigned short transition_time)
7041 {
7042         int result = ZIGBEE_ERROR_NONE;
7043         GVariant *variant = NULL;
7044         GError *dbus_err = NULL;
7045
7046         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7047         RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR);
7048
7049         DBG("zbl_level_control_step()");
7050
7051         variant = g_dbus_proxy_call_sync(level_control_gproxy, "step",
7052                 g_variant_new("(qyyyq)", addr16, ep, step_mode, step_size, transition_time),
7053                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7054
7055         if (!variant) {
7056                 ERR("Failed to get 'step' [%s]", dbus_err->message);
7057                 g_error_free(dbus_err);
7058                 return ZIGBEE_ERROR_IO_ERROR;
7059         }
7060
7061         g_variant_get(variant, "(i)", &result);
7062         DBG("ret = [0x%x]", result);
7063         g_variant_unref(variant);
7064
7065         return result;
7066 }
7067
7068 int zbl_level_control_stop(nwk_addr addr16, unsigned char ep)
7069 {
7070         int result = ZIGBEE_ERROR_NONE;
7071         GVariant *variant = NULL;
7072         GError *dbus_err = NULL;
7073
7074         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7075         RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR);
7076
7077         DBG("zbl_level_control_stop()");
7078
7079         variant = g_dbus_proxy_call_sync(level_control_gproxy, "stop",
7080                 g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7081
7082         if (!variant) {
7083                 ERR("Failed to get 'stop' [%s]", dbus_err->message);
7084                 g_error_free(dbus_err);
7085                 return ZIGBEE_ERROR_IO_ERROR;
7086         }
7087
7088         g_variant_get(variant, "(i)", &result);
7089         DBG("ret = [0x%x]", result);
7090         g_variant_unref(variant);
7091
7092         return result;
7093 }
7094
7095 int zbl_level_control_move_to_level_with_on_off(nwk_addr addr16,
7096                 unsigned char ep, unsigned char level, unsigned short transition_time)
7097 {
7098         int result = ZIGBEE_ERROR_NONE;
7099         GVariant *variant = NULL;
7100         GError *dbus_err = NULL;
7101
7102         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7103         RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR);
7104
7105         DBG("zbl_level_control_move_to_level_with_on_off()");
7106
7107         variant = g_dbus_proxy_call_sync(level_control_gproxy, "move_to_level_with_on_off",
7108                 g_variant_new("(qyyq)", addr16, ep, level, transition_time),
7109                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7110
7111         if (!variant) {
7112                 ERR("Failed to get 'move_to_level_with_on_off' [%s]", dbus_err->message);
7113                 g_error_free(dbus_err);
7114                 return ZIGBEE_ERROR_IO_ERROR;
7115         }
7116
7117         g_variant_get(variant, "(i)", &result);
7118         DBG("ret = [0x%x]", result);
7119         g_variant_unref(variant);
7120
7121         return result;
7122 }
7123
7124 int zbl_level_control_move_with_on_off(nwk_addr addr16, unsigned char ep,
7125                 unsigned char move_mode, unsigned char rate)
7126 {
7127         int result = ZIGBEE_ERROR_NONE;
7128         GVariant *variant = NULL;
7129         GError *dbus_err = NULL;
7130
7131         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7132         RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR);
7133
7134         DBG("zbl_level_control_move_with_on_off()");
7135
7136         variant = g_dbus_proxy_call_sync(level_control_gproxy, "move_with_on_off",
7137                 g_variant_new("(qyyy)", addr16, ep, move_mode, rate),
7138                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7139
7140         if (!variant) {
7141                 ERR("Failed to get 'move_with_on_off' [%s]", dbus_err->message);
7142                 g_error_free(dbus_err);
7143                 return ZIGBEE_ERROR_IO_ERROR;
7144         }
7145
7146         g_variant_get(variant, "(i)", &result);
7147         DBG("ret = [0x%x]", result);
7148         g_variant_unref(variant);
7149
7150         return result;
7151 }
7152
7153 int zbl_level_control_step_with_on_off(nwk_addr addr16, unsigned char ep,
7154                 unsigned char step_mode, unsigned char step_size,
7155                 unsigned short transition_time)
7156 {
7157         int result = ZIGBEE_ERROR_NONE;
7158         GVariant *variant = NULL;
7159         GError *dbus_err = NULL;
7160
7161         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7162         RETV_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR);
7163
7164         DBG("zbl_level_control_step_with_on_off()");
7165
7166         variant = g_dbus_proxy_call_sync(level_control_gproxy, "step_with_on_off",
7167                 g_variant_new("(qyyyq)", addr16, ep, step_mode, step_size, transition_time),
7168                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7169
7170         if (!variant) {
7171                 ERR("Failed to get 'step_with_on_off' [%s]", dbus_err->message);
7172                 g_error_free(dbus_err);
7173                 return ZIGBEE_ERROR_IO_ERROR;
7174         }
7175
7176         g_variant_get(variant, "(i)", &result);
7177         DBG("ret = [0x%x]", result);
7178         g_variant_unref(variant);
7179
7180         return result;
7181 }
7182
7183 int zbl_onoff_set(nwk_addr addr16, unsigned char ep, unsigned char on_off_type)
7184 {
7185         int result = ZIGBEE_ERROR_NONE;
7186         GVariant *variant = NULL;
7187         GError *dbus_err = NULL;
7188
7189         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7190         RETV_IF(NULL == on_off_gproxy, ZIGBEE_ERROR_IO_ERROR);
7191
7192         variant = g_dbus_proxy_call_sync(on_off_gproxy, "set_on_off",
7193                 g_variant_new("(qyy)", addr16, ep, on_off_type), G_DBUS_CALL_FLAGS_NONE,
7194                 -1, NULL, &dbus_err);
7195
7196         if (!variant) {
7197                 ERR("Failed to get 'set_on_off' [%s]", dbus_err->message);
7198                 g_error_free(dbus_err);
7199                 return ZIGBEE_ERROR_IO_ERROR;
7200         }
7201
7202         g_variant_get(variant, "(i)", &result);
7203         DBG("ret = [0x%x]", result);
7204         g_variant_unref(variant);
7205
7206         return result;
7207 }
7208
7209 int zbl_zone_enroll_response(nwk_addr addr16, unsigned char dst_ep,
7210                 unsigned char enroll_response_code, unsigned char zone_id)
7211 {
7212         int result = ZIGBEE_ERROR_NONE;
7213         GVariant *variant = NULL;
7214         GError *dbus_err = NULL;
7215
7216         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7217         RETV_IF(NULL == zcl_ias_zone_proxy, ZIGBEE_ERROR_IO_ERROR);
7218
7219         variant = g_dbus_proxy_call_sync(zcl_ias_zone_proxy, "enroll_response",
7220                 g_variant_new("(qyyy)", addr16, dst_ep, enroll_response_code, zone_id),
7221                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7222
7223         if (!variant) {
7224                 ERR("Failed to get 'enroll_response' [%s]", dbus_err->message);
7225                 g_error_free(dbus_err);
7226                 return ZIGBEE_ERROR_IO_ERROR;
7227         }
7228
7229         g_variant_get(variant, "(i)", &result);
7230         DBG("ret = [0x%x]", result);
7231         g_variant_unref(variant);
7232
7233         return result;
7234 }
7235
7236 int zbl_pollcontrol_check_in_response(nwk_addr addr16, unsigned char ep,
7237                 unsigned char start_fast_polling, unsigned short fast_poll_timeout)
7238 {
7239         int result = ZIGBEE_ERROR_NONE;
7240         GVariant *variant = NULL;
7241         GError *dbus_err = NULL;
7242
7243         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7244         RETV_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR);
7245
7246         variant = g_dbus_proxy_call_sync(zcl_poll_control_proxy, "check_in_response",
7247                 g_variant_new("(qyyq)", addr16, ep, start_fast_polling, fast_poll_timeout),
7248                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7249
7250         if (!variant) {
7251                 ERR("Failed to get 'check_in_response' [%s]", dbus_err->message);
7252                 g_error_free(dbus_err);
7253                 return ZIGBEE_ERROR_IO_ERROR;
7254         }
7255
7256         g_variant_get(variant, "(i)", &result);
7257         DBG("ret = [0x%x]", result);
7258         g_variant_unref(variant);
7259
7260         return result;
7261 }
7262
7263 int zbl_pollcontrol_fast_poll_stop(nwk_addr addr16, unsigned char ep)
7264 {
7265         int result = ZIGBEE_ERROR_NONE;
7266         GVariant *variant = NULL;
7267         GError *dbus_err = NULL;
7268
7269         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7270         RETV_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR);
7271
7272         variant = g_dbus_proxy_call_sync(zcl_poll_control_proxy, "fast_poll_stop",
7273                 g_variant_new("(qy)", addr16, ep), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7274
7275         if (!variant) {
7276                 ERR("Failed to get 'fast_poll_stop' [%s]", dbus_err->message);
7277                 g_error_free(dbus_err);
7278                 return ZIGBEE_ERROR_IO_ERROR;
7279         }
7280
7281         g_variant_get(variant, "(i)", &result);
7282         DBG("ret = [0x%x]", result);
7283         g_variant_unref(variant);
7284
7285         return result;
7286 }
7287
7288 int zbl_pollcontrol_set_long_poll_interval(nwk_addr addr16, unsigned char ep,
7289         unsigned int new_long_poll_interval, zb_zcl_pollctrl_check_in cb, void *user_data)
7290 {
7291         int sub_id, to;
7292         zbl_req_cb_s *container;
7293
7294         int result = ZIGBEE_ERROR_NONE;
7295         GVariant *variant = NULL;
7296         GError *dbus_err = NULL;
7297
7298         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7299         RETV_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR);
7300
7301         DBG("zbl_pollcontrol_set_long_poll_interval()");
7302
7303         container = calloc(1, sizeof(zbl_req_cb_s));
7304         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
7305
7306         to = zbl_dbus_get_timeout(zcl_poll_control_proxy);
7307         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
7308                         ZIGBEE_ZCL_POLL_CONTROL_INTERFACE,  "checkin_response",
7309                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
7310                         _zbl_response_cb, container, _zbl_request_cleanup);
7311
7312         if (0 == sub_id) {
7313                 ERR("g_dbus_connection_signal_subscribe() Fail");
7314                 free(container);
7315                 return ZIGBEE_ERROR_IO_ERROR;
7316         }
7317
7318         container->cb = cb;
7319         container->sid = sub_id;
7320         container->cid = ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ;
7321         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
7322         container->userdata = user_data;
7323
7324         variant = g_dbus_proxy_call_sync(zcl_poll_control_proxy, "set_long_poll_interval",
7325                         g_variant_new("(qyu)", addr16, ep, new_long_poll_interval),
7326                         G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
7327
7328         if (!variant) {
7329                 ERR("Failed to get 'set_long_poll_interval' [%s]", dbus_err->message);
7330                 g_error_free(dbus_err);
7331                 return ZIGBEE_ERROR_IO_ERROR;
7332         }
7333
7334         g_variant_get(variant, "(i)", &result);
7335         DBG("ret = [0x%x]", result);
7336         g_variant_unref(variant);
7337
7338         return result;
7339 }
7340
7341 int zbl_pollcontrol_set_short_poll_interval(nwk_addr addr16, unsigned char ep,
7342         unsigned int new_short_poll_interval, zb_zcl_pollctrl_check_in cb, void *user_data)
7343 {
7344         int sub_id, to;
7345         zbl_req_cb_s *container;
7346
7347         int result = ZIGBEE_ERROR_NONE;
7348         GVariant *variant = NULL;
7349         GError *dbus_err = NULL;
7350
7351         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7352         RETV_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR);
7353
7354         DBG("zbl_pollcontrol_set_short_poll_interval()");
7355
7356         container = calloc(1, sizeof(zbl_req_cb_s));
7357         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
7358
7359         to = zbl_dbus_get_timeout(zcl_poll_control_proxy);
7360         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
7361                         ZIGBEE_ZCL_POLL_CONTROL_INTERFACE,  "checkin_response",
7362                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
7363                         _zbl_response_cb, container, _zbl_request_cleanup);
7364
7365         if (0 == sub_id) {
7366                 ERR("g_dbus_connection_signal_subscribe() Fail");
7367                 free(container);
7368                 return ZIGBEE_ERROR_IO_ERROR;
7369         }
7370
7371         container->cb = cb;
7372         container->sid = sub_id;
7373         container->cid = ZBL_ZCL_POLLCONTROL_SET_POLL_INTERVAL_REQ;
7374         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
7375         container->userdata = user_data;
7376
7377         variant = g_dbus_proxy_call_sync(zcl_poll_control_proxy, "set_short_poll_interval",
7378                         g_variant_new("(qyu)", addr16, ep, new_short_poll_interval),
7379                         G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
7380
7381         if (!variant) {
7382                 ERR("Failed to get 'set_short_poll_interval' [%s]", dbus_err->message);
7383                 g_error_free(dbus_err);
7384                 return ZIGBEE_ERROR_IO_ERROR;
7385         }
7386
7387         g_variant_get(variant, "(i)", &result);
7388         DBG("ret = [0x%x]", result);
7389         g_variant_unref(variant);
7390
7391         return result;
7392 }
7393
7394 int zbl_add_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id,
7395         unsigned char scene_id, unsigned short transition_time, const char *scene_name,
7396         unsigned short ext_field_len, const char *extension_field_sets,
7397         zb_zcl_scene_add_scene_rsp cb, void *user_data)
7398 {
7399         int sub_id, to;
7400         zbl_req_cb_s *container;
7401
7402         int result = ZIGBEE_ERROR_NONE;
7403         GVariant *variant = NULL;
7404         GError *dbus_err = NULL;
7405
7406         int j = 0;
7407         int index = 0;
7408         GVariant *scenename_variant = NULL;
7409         GVariantBuilder *scenename_builder = NULL;
7410         GVariant *extensionfieldSet_variant = NULL;
7411         GVariantBuilder *extensionfieldSet_builder = NULL;
7412
7413         DBG("zbl_add_scene()");
7414
7415         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7416         RETV_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR);
7417
7418         container = calloc(1, sizeof(zbl_req_cb_s));
7419         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
7420
7421         to = zbl_dbus_get_timeout(zcl_scene_proxy);
7422         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
7423                         ZIGBEE_ZCL_SCENE_INTERFACE,  "add_scene_rsp", ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
7424                         _zbl_response_cb, container, _zbl_request_cleanup);
7425
7426         if (0 == sub_id) {
7427                 ERR("g_dbus_connection_signal_subscribe() Fail");
7428                 free(container);
7429                 return ZIGBEE_ERROR_IO_ERROR;
7430         }
7431
7432         container->cb = cb;
7433         container->sid = sub_id;
7434         container->cid = ZBL_ZCL_SCENE_ADD_SCENE_REQ;
7435         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
7436         container->userdata = user_data;
7437
7438         scenename_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
7439         while ('\0' != scene_name[j]) {
7440                 g_variant_builder_add(scenename_builder, "(y)", scene_name[j]);
7441                 j++;
7442         }
7443         scenename_variant = g_variant_builder_end(scenename_builder);
7444         g_variant_builder_unref(scenename_builder);
7445
7446         extensionfieldSet_builder = g_variant_builder_new(G_VARIANT_TYPE("a(y)"));
7447
7448         while (index < ext_field_len) {
7449                 INFO("Ext contents 0x%02X", extension_field_sets[index]);
7450                 g_variant_builder_add(extensionfieldSet_builder, "(y)", extension_field_sets[index]);
7451                 index++;
7452         }
7453         extensionfieldSet_variant = g_variant_builder_end(extensionfieldSet_builder);
7454         g_variant_builder_unref(extensionfieldSet_builder);
7455
7456         variant = g_dbus_proxy_call_sync(zcl_scene_proxy, "add_scene",
7457                 g_variant_new("(qyqyqq@a(y)@a(y))", addr16, ep, group_id, scene_id, transition_time,
7458                 ext_field_len, scenename_variant, extensionfieldSet_variant), G_DBUS_CALL_FLAGS_NONE,
7459                 to, NULL, &dbus_err);
7460
7461         if (!variant) {
7462                 ERR("Failed to get 'add_scene' [%s]", dbus_err->message);
7463                 g_error_free(dbus_err);
7464                 return ZIGBEE_ERROR_IO_ERROR;
7465         }
7466
7467         g_variant_get(variant, "(i)", &result);
7468         DBG("ret = [0x%x]", result);
7469         g_variant_unref(variant);
7470
7471         return result;
7472 }
7473
7474 int zbl_view_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id,
7475         unsigned char scene_id, zb_zcl_scene_view_scene_rsp cb, void *user_data)
7476 {
7477         int sub_id, to;
7478         zbl_req_cb_s *container;
7479
7480         int result = ZIGBEE_ERROR_NONE;
7481         GVariant *variant = NULL;
7482         GError *dbus_err = NULL;
7483
7484         DBG("zbl_scene_view_scene()");
7485
7486         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7487         RETV_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR);
7488
7489         container = calloc(1, sizeof(zbl_req_cb_s));
7490         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
7491
7492         to = zbl_dbus_get_timeout(zcl_scene_proxy);
7493         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
7494                         ZIGBEE_ZCL_SCENE_INTERFACE,  "view_scene_rsp", ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0,
7495                         _zbl_response_cb, container, _zbl_request_cleanup);
7496
7497         if (0 == sub_id) {
7498                 ERR("g_dbus_connection_signal_subscribe() Fail");
7499                 free(container);
7500                 return ZIGBEE_ERROR_IO_ERROR;
7501         }
7502
7503         container->cb = cb;
7504         container->sid = sub_id;
7505         container->cid = ZBL_ZCL_SCENE_VIEW_SCENE_REQ;
7506         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
7507         container->userdata = user_data;
7508
7509         variant = g_dbus_proxy_call_sync(zcl_scene_proxy, "view_scene",
7510                 g_variant_new("(qyqy)", addr16, ep, group_id, scene_id), G_DBUS_CALL_FLAGS_NONE,
7511                 to, NULL, &dbus_err);
7512
7513         if (!variant) {
7514                 ERR("Failed to get 'view_scene' [%s]", dbus_err->message);
7515                 g_error_free(dbus_err);
7516                 return ZIGBEE_ERROR_IO_ERROR;
7517         }
7518
7519         g_variant_get(variant, "(i)", &result);
7520         DBG("ret = [0x%x]", result);
7521         g_variant_unref(variant);
7522
7523         return result;
7524 }
7525
7526 int zbl_remove_scene(nwk_addr addr16, unsigned char ep,
7527         unsigned short group_id, unsigned char scene_id, zb_zcl_scene_remove_scene_rsp cb,
7528         void *user_data)
7529 {
7530         int sub_id, to;
7531         zbl_req_cb_s *container;
7532
7533         int result = ZIGBEE_ERROR_NONE;
7534         GVariant *variant = NULL;
7535         GError *dbus_err = NULL;
7536
7537         DBG("zbl_scene_remove_scene()");
7538
7539         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7540         RETV_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR);
7541
7542         container = calloc(1, sizeof(zbl_req_cb_s));
7543         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
7544
7545         to = zbl_dbus_get_timeout(zcl_scene_proxy);
7546         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
7547                         ZIGBEE_ZCL_SCENE_INTERFACE,  "remove_scene_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
7548                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
7549
7550         if (0 == sub_id) {
7551                 ERR("g_dbus_connection_signal_subscribe() Fail");
7552                 free(container);
7553                 return ZIGBEE_ERROR_IO_ERROR;
7554         }
7555
7556         container->cb = cb;
7557         container->sid = sub_id;
7558         container->cid = ZBL_ZCL_SCENE_REMOVE_SCENE_REQ;
7559         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
7560         container->userdata = user_data;
7561
7562         variant = g_dbus_proxy_call_sync(zcl_scene_proxy, "remove_scene",
7563                 g_variant_new("(qyqy)", addr16, ep, group_id, scene_id),
7564                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
7565
7566         if (!variant) {
7567                 ERR("Failed to get 'remove_scene' [%s]", dbus_err->message);
7568                 g_error_free(dbus_err);
7569                 return ZIGBEE_ERROR_IO_ERROR;
7570         }
7571
7572         g_variant_get(variant, "(i)", &result);
7573         DBG("ret = [0x%x]", result);
7574         g_variant_unref(variant);
7575
7576         return result;
7577 }
7578
7579 int zbl_remove_all_scene(nwk_addr addr16, unsigned char ep,
7580         unsigned short group_id, zb_zcl_scene_remove_all_scene_rsp cb, void *user_data)
7581 {
7582         int sub_id, to;
7583         zbl_req_cb_s *container;
7584
7585         int result = ZIGBEE_ERROR_NONE;
7586         GVariant *variant = NULL;
7587         GError *dbus_err = NULL;
7588
7589         DBG("zbl_scene_remove_all_scene()");
7590
7591         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7592         RETV_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR);
7593
7594         container = calloc(1, sizeof(zbl_req_cb_s));
7595         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
7596
7597         to = zbl_dbus_get_timeout(zcl_scene_proxy);
7598         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
7599                         ZIGBEE_ZCL_SCENE_INTERFACE,  "remove_all_scene_rsp",
7600                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container,
7601                         _zbl_request_cleanup);
7602
7603         if (0 == sub_id) {
7604                 ERR("g_dbus_connection_signal_subscribe() Fail");
7605                 free(container);
7606                 return ZIGBEE_ERROR_IO_ERROR;
7607         }
7608
7609         container->cb = cb;
7610         container->sid = sub_id;
7611         container->cid = ZBL_ZCL_SCENE_REMOVE_ALL_SCENE_REQ;
7612         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
7613         container->userdata = user_data;
7614
7615         variant = g_dbus_proxy_call_sync(zcl_scene_proxy, "remove_all_scene",
7616                 g_variant_new("(qyq)", addr16, ep, group_id),
7617                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
7618
7619         if (!variant) {
7620                 ERR("Failed to get 'remove_all_scene' [%s]", dbus_err->message);
7621                 g_error_free(dbus_err);
7622                 return ZIGBEE_ERROR_IO_ERROR;
7623         }
7624
7625         g_variant_get(variant, "(i)", &result);
7626         DBG("ret = [0x%x]", result);
7627         g_variant_unref(variant);
7628
7629         return result;
7630 }
7631
7632 int zbl_store_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id,
7633         unsigned char scene_id, zb_zcl_scene_store_scene_rsp cb, void *user_data)
7634 {
7635         int sub_id, to;
7636         zbl_req_cb_s *container;
7637
7638         int result = ZIGBEE_ERROR_NONE;
7639         GVariant *variant = NULL;
7640         GError *dbus_err = NULL;
7641
7642         DBG("zbl_scene_store_scene()");
7643
7644         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7645         RETV_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR);
7646
7647         container = calloc(1, sizeof(zbl_req_cb_s));
7648         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
7649
7650         to = zbl_dbus_get_timeout(zcl_scene_proxy);
7651         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
7652                         ZIGBEE_ZCL_SCENE_INTERFACE,  "store_scene_rsp", ZIGBEE_CONTROL_OBJECT_PATH,
7653                         NULL, 0, _zbl_response_cb, container, _zbl_request_cleanup);
7654
7655         if (0 == sub_id) {
7656                 ERR("g_dbus_connection_signal_subscribe() Fail");
7657                 free(container);
7658                 return ZIGBEE_ERROR_IO_ERROR;
7659         }
7660
7661         container->cb = cb;
7662         container->sid = sub_id;
7663         container->cid = ZBL_ZCL_SCENE_STORE_SCENE_REQ;
7664         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
7665         container->userdata = user_data;
7666
7667         variant = g_dbus_proxy_call_sync(zcl_scene_proxy, "store_scene",
7668                 g_variant_new("(qyqy)", addr16, ep, group_id, scene_id),
7669                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
7670
7671         if (!variant) {
7672                 ERR("Failed to get 'store_scene' [%s]", dbus_err->message);
7673                 g_error_free(dbus_err);
7674                 return ZIGBEE_ERROR_IO_ERROR;
7675         }
7676
7677         g_variant_get(variant, "(i)", &result);
7678         DBG("ret = [0x%x]", result);
7679         g_variant_unref(variant);
7680
7681         return result;
7682 }
7683
7684 int zbl_recall_scene(nwk_addr addr16, unsigned char ep, unsigned short group_id,
7685         unsigned char scene_id)
7686 {
7687         int result = ZIGBEE_ERROR_NONE;
7688         GVariant *variant = NULL;
7689         GError *dbus_err = NULL;
7690
7691         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7692         RETV_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR);
7693
7694         variant = g_dbus_proxy_call_sync(zcl_scene_proxy, "recall_scene",
7695                 g_variant_new("(qyqy)", addr16, ep, group_id, scene_id), G_DBUS_CALL_FLAGS_NONE,
7696                 -1, NULL, &dbus_err);
7697
7698         if (!variant) {
7699                 ERR("Failed to get 'recall_scene' [%s]", dbus_err->message);
7700                 g_error_free(dbus_err);
7701                 return ZIGBEE_ERROR_IO_ERROR;
7702         }
7703
7704         g_variant_get(variant, "(i)", &result);
7705         DBG("ret = [0x%x]", result);
7706         g_variant_unref(variant);
7707
7708         return result;
7709 }
7710
7711 int zbl_get_scene_membership(nwk_addr addr16, unsigned char ep,
7712         unsigned short group_id, zb_zcl_scene_get_scene_membership_rsp cb, void *user_data)
7713 {
7714         int sub_id, to;
7715         zbl_req_cb_s *container;
7716
7717         int result = ZIGBEE_ERROR_NONE;
7718         GVariant *variant = NULL;
7719         GError *dbus_err = NULL;
7720
7721         DBG("zbl_scene_get_scene_membership()");
7722
7723         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7724         RETV_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR);
7725
7726         container = calloc(1, sizeof(zbl_req_cb_s));
7727         RETVM_IF(NULL == container, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
7728
7729         to = zbl_dbus_get_timeout(zcl_scene_proxy);
7730         sub_id = g_dbus_connection_signal_subscribe((GDBusConnection*)gdbus_conn, NULL,
7731                         ZIGBEE_ZCL_SCENE_INTERFACE, "get_scene_membership_rsp",
7732                         ZIGBEE_CONTROL_OBJECT_PATH, NULL, 0, _zbl_response_cb, container,
7733                         _zbl_request_cleanup);
7734
7735         if (0 == sub_id) {
7736                 ERR("g_dbus_connection_signal_subscribe() Fail");
7737                 free(container);
7738                 return ZIGBEE_ERROR_IO_ERROR;
7739         }
7740
7741         container->cb = cb;
7742         container->sid = sub_id;
7743         container->cid = ZBL_ZCL_SCENE_GET_SCENE_MEMBERSHIP_REQ;
7744         container->tid = g_timeout_add_seconds(to, _zbl_timeout_cb, container);
7745         container->userdata = user_data;
7746
7747         variant = g_dbus_proxy_call_sync(zcl_scene_proxy, "get_scene_membership",
7748                 g_variant_new("(qyq)", addr16, ep, group_id),
7749                 G_DBUS_CALL_FLAGS_NONE, to, NULL, &dbus_err);
7750
7751         if (!variant) {
7752                 ERR("Failed to get get_scene_membership [%s]", dbus_err->message);
7753                 g_error_free(dbus_err);
7754                 return ZIGBEE_ERROR_IO_ERROR;
7755         }
7756
7757         g_variant_get(variant, "(i)", &result);
7758         DBG("ret = [0x%x]", result);
7759         g_variant_unref(variant);
7760
7761         return result;
7762 }
7763
7764 int zbl_thermostat_adjust_setpoint(nwk_addr addr16, unsigned char ep, unsigned char mode,
7765         unsigned char amount)
7766 {
7767         int result = ZIGBEE_ERROR_IO_ERROR;
7768         GVariant *variant = NULL;
7769         GError *dbus_err = NULL;
7770
7771         RETV_IF(NULL == gdbus_conn, ZIGBEE_ERROR_IO_ERROR);
7772         RETV_IF(NULL == thermostat_gproxy, ZIGBEE_ERROR_IO_ERROR);
7773
7774         variant = g_dbus_proxy_call_sync(thermostat_gproxy, "setpoint_raise_lower",
7775                 g_variant_new("(qyyy)", addr16, ep, mode, amount),
7776                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &dbus_err);
7777
7778         if (!variant) {
7779                 ERR("Failed to get 'setpoint_raise_lower' [%s]", dbus_err->message);
7780                 g_error_free(dbus_err);
7781                 return ZIGBEE_ERROR_IO_ERROR;
7782         }
7783
7784         g_variant_get(variant, "(i)", &result);
7785         DBG("ret = [0x%x]", result);
7786         g_variant_unref(variant);
7787
7788         return result;
7789 }
7790
7791 int zbl_dbus_start(zigbee_h handle)
7792 {
7793         FN_CALL;
7794
7795         unsigned int id;
7796
7797         if (gdbus_conn) {
7798                 zbl_ref_count++;
7799                 return ZIGBEE_ERROR_NONE;
7800         }
7801
7802         gdbus_conn = _zbl_get_connection();
7803         if (!gdbus_conn) {
7804                 ERR("Couldn't connect to the System bus");
7805                 return ZIGBEE_ERROR_IO_ERROR;
7806         }
7807
7808         id = g_signal_connect(gdbus_conn, "notify::g-name-owner",
7809                         G_CALLBACK(_zbl_dbus_name_owner_notify), NULL);
7810         if (0 == id) {
7811                 ERR("g_signal_connect() Fail\n");
7812                 return ZIGBEE_ERROR_IO_ERROR;
7813         }
7814
7815         /* Phase 1. Subscribe signals */
7816         _zbl_dbus_subscribe_signal(handle);
7817
7818         /* Phase 2. Make proxies */
7819         manager_gproxy = _zbl_get_manager_proxy();
7820         RETVM_IF(NULL == manager_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get manager_gproxy");
7821         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(manager_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7822
7823         service_gproxy = _zbl_get_service_proxy();
7824         RETVM_IF(NULL == service_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get service_gproxy");
7825         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(service_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7826
7827         on_off_gproxy = _zbl_get_on_off_proxy();
7828         RETVM_IF(NULL == on_off_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get on_off_gproxy");
7829         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(on_off_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7830
7831         door_lock_gproxy = _zbl_get_door_lock_proxy();
7832         RETVM_IF(NULL == door_lock_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get door_lock_gproxy");
7833         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(door_lock_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7834
7835         level_control_gproxy = _zbl_get_level_control_proxy();
7836         RETVM_IF(NULL == level_control_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get level_control_gproxy");
7837         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(level_control_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7838
7839         thermostat_gproxy = _zbl_get_thermostat_proxy();
7840         RETVM_IF(NULL == thermostat_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get thermostat_gproxy");
7841         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(thermostat_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7842
7843         fan_control_gproxy = _zbl_get_fan_control_proxy();
7844         RETVM_IF(NULL == fan_control_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get fan_control_gproxy");
7845         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(fan_control_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7846
7847         alarm_gproxy = _zbl_get_alarm_proxy();
7848         RETVM_IF(NULL == alarm_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get alarm_gproxy");
7849         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(alarm_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7850
7851         mfglib_gproxy = _zbl_get_mfglib_proxy();
7852         RETVM_IF(NULL == mfglib_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get mfglib_gproxy");
7853         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(mfglib_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7854
7855         zcl_global_proxy = _zbl_get_zcl_global_proxy();
7856         RETVM_IF(NULL == zcl_global_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zcl_global_proxy");
7857         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zcl_global_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7858
7859         zdo_dev_proxy = _zbl_get_zdo_dev_proxy();
7860         RETVM_IF(NULL == zdo_dev_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zdo_dev_proxy");
7861         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zdo_dev_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7862
7863         zcl_basic_proxy = _zbl_get_basic_proxy();
7864         RETVM_IF(NULL == zcl_basic_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zcl_basic_proxy");
7865         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zcl_basic_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7866
7867         zcl_identify_proxy = _zbl_get_identify_proxy();
7868         RETVM_IF(NULL == zcl_identify_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zcl_identify_proxy");
7869         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zcl_identify_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7870
7871         zcl_ias_zone_proxy = _zbl_get_ias_zone_proxy();
7872         RETVM_IF(NULL == zcl_ias_zone_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zcl_ias_zone_proxy");
7873         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zcl_ias_zone_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7874
7875         zcl_poll_control_proxy = _zbl_get_poll_control_proxy();
7876         RETVM_IF(NULL == zcl_poll_control_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zcl_poll_control_proxy");
7877         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zcl_poll_control_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7878
7879         zcl_group_proxy = _zbl_get_group_proxy();
7880         RETVM_IF(NULL == zcl_group_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zcl_group_proxy");
7881         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zcl_group_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7882
7883         zcl_scene_proxy = _zbl_get_scene_proxy();
7884         RETVM_IF(NULL == zcl_scene_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zcl_scene_proxy");
7885         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zcl_scene_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7886
7887         zdo_bind_proxy = _zbl_get_zdo_bind_proxy();
7888         RETVM_IF(NULL == zdo_bind_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zdo_bind_proxy");
7889         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zdo_bind_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7890
7891         zcl_color_control_proxy = _zbl_get_color_control_proxy();
7892         RETVM_IF(NULL == zcl_color_control_proxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get zcl_color_control_proxy");
7893         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(zcl_color_control_proxy), ZIGBEE_BROADCAST_TIMEOUT);
7894
7895         custom_gproxy = _zbl_get_custom_gproxy();
7896         RETVM_IF(NULL == custom_gproxy, ZIGBEE_ERROR_IO_ERROR, "Couldn't get custom_gproxy");
7897         g_dbus_proxy_set_default_timeout(G_DBUS_PROXY(custom_gproxy), ZIGBEE_BROADCAST_TIMEOUT);
7898
7899         zbl_ref_count++;
7900
7901         return ZIGBEE_ERROR_NONE;
7902 }
7903
7904 void zbl_dbus_stop(void)
7905 {
7906         if (0 <= zbl_ref_count) {
7907                 WARN("dbus does not initiaized\n");
7908                 return;
7909         }
7910         if (0 > --zbl_ref_count)
7911                 DBG("all connections closed\n");
7912
7913         g_object_unref(gdbus_conn);
7914         gdbus_conn = NULL;
7915         return;
7916 }
7917
7918 GDBusConnection* zbl_dbus_get_object(void)
7919 {
7920         return gdbus_conn;
7921 }
7922
7923 int zbl_dbus_get_timeout(GDBusProxy *proxy)
7924 {
7925         gint timeout;
7926         RETV_IF(NULL == gdbus_conn, ZIGBEE_BROADCAST_TIMEOUT);
7927         timeout = g_dbus_proxy_get_default_timeout(proxy);
7928         if (timeout <= 0) {
7929                 ERR("Invalid timeout (%d)", timeout);
7930                 return ZIGBEE_BROADCAST_TIMEOUT;
7931         }
7932         return timeout;
7933 }
7934