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

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Contact: Suresh Kumar N (suresh.n@samsung.com)
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include "zigbee_service_interface_common.h"
  20
  21 #include <zblib_driver_service.h>
  22
  23 static void *_service_interface_ref_zigbee_service(ZigBeeServiceInterface *service_interface)
  24 {
  25         ZigbeeObjectSkeleton *zigbee_object = NULL;
  26         ZigbeeCustomData_t *custom_data = NULL;
  27         ZigbeeService *service = NULL;
  28
  29         custom_data = (ZigbeeCustomData_t *)zblib_service_interface_ref_user_data(service_interface);
  30         if (NULL == custom_data) {
  31                 Z_LOGE("D-BUS service interface custom_data is NULL!");
  32                 return NULL;
  33         }
  34
  35         /* Get zigbee object */
  36         zigbee_object = g_hash_table_lookup(custom_data->objects, ZIGBEE_SERVICE_PATH);
  37         if (NULL == zigbee_object) {
  38                 Z_LOGW("Cannot find ZigBee D-BUS interface object!", zigbee_object);
  39                 return NULL;
  40         }
  41
  42         service = zigbee_object_get_service(ZIGBEE_OBJECT(zigbee_object));
  43         return service;
  44 }
  45
  46 static void on_service_enable_resp(ZigBeeServiceInterface *service_interface,
  47         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
  48 {
  49         ZigbeeServiceInterfaceRespCbData_t *cb_data =
  50                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
  51
  52         ZigbeeService *service_object;
  53         GDBusMethodInvocation *invocation;
  54         ZigbeeServiceServiceStateResp_t *payload =
  55                 (ZigbeeServiceServiceStateResp_t*)resp_data;
  56
  57         NOT_USED(service_interface);
  58         NOT_USED(request_id);
  59
  60         if (NULL == resp_data || 0 == resp_data_len) {
  61                 Z_LOGE("resp_data is null");
  62                 return;
  63         }
  64
  65         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
  66         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
  67
  68         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
  69         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
  70
  71         zigbee_service_complete_enable(service_object, invocation,
  72                 payload->result, payload->enabled);
  73
  74         g_free(cb_data);
  75 }
  76
  77 static gboolean on_service_enable(ZigbeeService *service_object,
  78         GDBusMethodInvocation *invocation,
  79         gpointer user_data)
  80 {
  81         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
  82         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
  83
  84         gboolean ret;
  85
  86         Z_LOGE("KSR");
  87
  88         /* Allocate response callback data */
  89         resp_cb_data =
  90                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
  91                         invocation, NULL, 0);
  92         if (NULL == resp_cb_data) {
  93                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
  94
  95                 /* Send failure response */
  96                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
  97
  98                 return TRUE;
  99         }
 100
 101         /* Dispatch request */
 102         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 103                 ZBLIB_DRIVER_TYPE_SERVICE,
 104                 ZBLIB_SERVICE_OPS_ENABLE,
 105                 NULL, 0,
 106                 on_service_enable_resp, resp_cb_data);
 107         if (FALSE == ret) {
 108                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 109
 110                 /* Free response callback data */
 111                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 112
 113                 /* Send failure response */
 114                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 115
 116                 return TRUE;
 117         }
 118
 119         return TRUE;
 120 }
 121
 122 static void on_service_disable_resp(ZigBeeServiceInterface *service_interface,
 123         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 124 {
 125         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 126                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 127
 128         ZigbeeService *service_object;
 129         GDBusMethodInvocation *invocation;
 130         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 131
 132         NOT_USED(service_interface);
 133         NOT_USED(request_id);
 134
 135         if (NULL == resp_data || 0 == resp_data_len) {
 136                 Z_LOGE("resp_data is null");
 137                 return;
 138         }
 139
 140         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 141         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 142
 143         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 144         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 145
 146         zigbee_service_complete_disable(service_object, invocation, payload->result);
 147
 148         g_free(cb_data);
 149 }
 150
 151 static gboolean on_service_disable(ZigbeeService *service_object,
 152         GDBusMethodInvocation *invocation,
 153         gpointer user_data)
 154 {
 155         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 156         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 157
 158         gboolean ret;
 159
 160         /* Allocate response callback data */
 161         resp_cb_data =
 162                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 163                         invocation, NULL, 0);
 164         if (NULL == resp_cb_data) {
 165                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 166
 167                 /* Send failure response */
 168                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 169
 170                 return TRUE;
 171         }
 172
 173         /* Dispatch request */
 174         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 175                 ZBLIB_DRIVER_TYPE_SERVICE,
 176                 ZBLIB_SERVICE_OPS_DISABLE,
 177                 NULL, 0,
 178                 on_service_disable_resp, resp_cb_data);
 179         if (FALSE == ret) {
 180                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 181
 182                 /* Free response callback data */
 183                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 184
 185                 /* Send failure response */
 186                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 187
 188                 return TRUE;
 189         }
 190
 191         return TRUE;
 192 }
 193
 194 static void on_service_zb_hw_reset_resp(ZigBeeServiceInterface *service_interface,
 195         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 196 {
 197         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 198                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 199
 200         ZigbeeService *service_object;
 201         GDBusMethodInvocation *invocation;
 202         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 203
 204         NOT_USED(service_interface);
 205         NOT_USED(request_id);
 206
 207         if (NULL == resp_data || 0 == resp_data_len) {
 208                 Z_LOGE("resp_data is null");
 209                 return;
 210         }
 211
 212         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 213         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 214
 215         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 216         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 217
 218         zigbee_service_complete_zb_hw_reset(service_object, invocation, payload->result);
 219
 220         g_free(cb_data);
 221 }
 222
 223 static gboolean on_service_zb_hw_reset(ZigbeeService *service_object,
 224         GDBusMethodInvocation *invocation,
 225         gpointer user_data)
 226 {
 227         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 228         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 229
 230         gboolean ret;
 231
 232         /* Allocate response callback data */
 233         resp_cb_data =
 234                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 235                         invocation, NULL, 0);
 236         if (NULL == resp_cb_data) {
 237                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 238
 239                 /* Send failure response */
 240                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 241
 242                 return TRUE;
 243         }
 244
 245         /* Dispatch request */
 246         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 247                 ZBLIB_DRIVER_TYPE_SERVICE,
 248                 ZBLIB_SERVICE_OPS_ZB_HW_RESET,
 249                 NULL, 0,
 250                 on_service_zb_hw_reset_resp, resp_cb_data);
 251         if (FALSE == ret) {
 252                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 253
 254                 /* Free response callback data */
 255                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 256
 257                 /* Send failure response */
 258                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 259
 260                 return TRUE;
 261         }
 262
 263         return TRUE;
 264 }
 265
 266 static void on_service_form_network_resp(ZigBeeServiceInterface *service_interface,
 267         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 268 {
 269         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 270                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 271
 272         ZigbeeService *service_object;
 273         GDBusMethodInvocation *invocation;
 274         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 275
 276         NOT_USED(service_interface);
 277         NOT_USED(request_id);
 278
 279         if (NULL == resp_data || 0 == resp_data_len) {
 280                 Z_LOGE("resp_data is null");
 281                 return;
 282         }
 283
 284         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 285         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 286
 287         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 288         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 289
 290         zigbee_service_complete_form_network(service_object, invocation, payload->result);
 291
 292         g_free(cb_data);
 293 }
 294
 295 static gboolean on_service_form_network(ZigbeeService *service_object,
 296         GDBusMethodInvocation *invocation,
 297         gpointer user_data)
 298 {
 299         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 300         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 301
 302         gboolean ret;
 303
 304         /* Allocate response callback data */
 305         resp_cb_data =
 306                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 307                         invocation, NULL, 0);
 308         if (NULL == resp_cb_data) {
 309                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 310
 311                 /* Send failure response */
 312                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 313
 314                 return TRUE;
 315         }
 316
 317         /* Dispatch request */
 318         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 319                 ZBLIB_DRIVER_TYPE_SERVICE,
 320                 ZBLIB_SERVICE_OPS_FORM_NETWORK,
 321                 NULL, 0,
 322                 on_service_form_network_resp, resp_cb_data);
 323         if (FALSE == ret) {
 324                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 325
 326                 /* Free response callback data */
 327                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 328
 329                 /* Send failure response */
 330                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 331
 332                 return TRUE;
 333         }
 334
 335         return TRUE;
 336 }
 337
 338 static void on_service_coex_start_resp(ZigBeeServiceInterface *service_interface,
 339         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 340 {
 341         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 342                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 343
 344         ZigbeeService *service_object;
 345         GDBusMethodInvocation *invocation;
 346         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 347
 348         NOT_USED(service_interface);
 349         NOT_USED(request_id);
 350
 351         if (NULL == resp_data || 0 == resp_data_len) {
 352                 Z_LOGE("resp_data is null");
 353                 return;
 354         }
 355
 356         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 357         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 358
 359         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 360         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 361
 362         zigbee_service_complete_coex_start(service_object, invocation, payload->result);
 363
 364         g_free(cb_data);
 365 }
 366
 367 static gboolean on_service_coex_start(ZigbeeService *service_object,
 368         GDBusMethodInvocation *invocation,
 369         gchar channel,
 370         gpointer user_data)
 371 {
 372         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 373         ZigbeeServiceCoexStart_t req;
 374         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 375
 376         gboolean ret;
 377
 378         memset(&req, 0x0, sizeof(ZigbeeServiceCoexStart_t));
 379
 380         /* Update request structure */
 381         req.channel = channel;
 382
 383         /* Allocate response callback data */
 384         resp_cb_data =
 385                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 386                         invocation, NULL, 0);
 387         if (NULL == resp_cb_data) {
 388                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 389
 390                 /* Send failure response */
 391                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 392
 393                 return TRUE;
 394         }
 395
 396         /* Dispatch request */
 397         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 398                 ZBLIB_DRIVER_TYPE_SERVICE,
 399                 ZBLIB_SERVICE_OPS_COEX_START,
 400                 &req, sizeof(req),
 401                 on_service_coex_start_resp, resp_cb_data);
 402         if (FALSE == ret) {
 403                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 404
 405                 /* Free response callback data */
 406                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 407
 408                 /* Send failure response */
 409                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 410
 411                 return TRUE;
 412         }
 413
 414         return TRUE;
 415 }
 416
 417 static void on_service_coex_stop_resp(ZigBeeServiceInterface *service_interface,
 418         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 419 {
 420         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 421                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 422
 423         ZigbeeService *service_object;
 424         GDBusMethodInvocation *invocation;
 425         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 426
 427         NOT_USED(service_interface);
 428         NOT_USED(request_id);
 429
 430         if (NULL == resp_data || 0 == resp_data_len) {
 431                 Z_LOGE("resp_data is null");
 432                 return;
 433         }
 434
 435         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 436         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 437
 438         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 439         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 440
 441         zigbee_service_complete_coex_stop(service_object, invocation, payload->result);
 442
 443         g_free(cb_data);
 444 }
 445
 446 static gboolean on_service_coex_stop(ZigbeeService *service_object,
 447         GDBusMethodInvocation *invocation,
 448         gpointer user_data)
 449 {
 450         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 451         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 452
 453         gboolean ret;
 454
 455         /* Allocate response callback data */
 456         resp_cb_data =
 457                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 458                         invocation, NULL, 0);
 459         if (NULL == resp_cb_data) {
 460                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 461
 462                 /* Send failure response */
 463                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 464
 465                 return TRUE;
 466         }
 467
 468         /* Dispatch request */
 469         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 470                 ZBLIB_DRIVER_TYPE_SERVICE,
 471                 ZBLIB_SERVICE_OPS_COEX_STOP,
 472                 NULL, 0,
 473                 on_service_coex_stop_resp, resp_cb_data);
 474         if (FALSE == ret) {
 475                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 476
 477                 /* Free response callback data */
 478                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 479
 480                 /* Send failure response */
 481                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 482
 483                 return TRUE;
 484         }
 485
 486         return TRUE;
 487 }
 488
 489 static void on_service_leave_network_resp(ZigBeeServiceInterface *service_interface,
 490         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 491 {
 492         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 493                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 494
 495         ZigbeeService *service_object;
 496         GDBusMethodInvocation *invocation;
 497         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 498
 499         NOT_USED(service_interface);
 500         NOT_USED(request_id);
 501
 502         if (NULL == resp_data || 0 == resp_data_len) {
 503                 Z_LOGE("resp_data is null");
 504                 return;
 505         }
 506
 507         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 508         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 509
 510         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 511         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 512
 513         zigbee_service_complete_leave_network(service_object, invocation, payload->result);
 514
 515         g_free(cb_data);
 516 }
 517
 518 static gboolean on_service_leave_network(ZigbeeService *service_object,
 519         GDBusMethodInvocation *invocation,
 520         gpointer user_data)
 521 {
 522         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 523         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 524
 525         gboolean ret;
 526
 527         /* Allocate response callback data */
 528         resp_cb_data =
 529                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 530                         invocation, NULL, 0);
 531         if (NULL == resp_cb_data) {
 532                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 533
 534                 /* Send failure response */
 535                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 536
 537                 return TRUE;
 538         }
 539
 540         /* Dispatch request */
 541         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 542                 ZBLIB_DRIVER_TYPE_SERVICE,
 543                 ZBLIB_SERVICE_OPS_LEAVE_NETWORK,
 544                 NULL, 0,
 545                 on_service_leave_network_resp, resp_cb_data);
 546         if (FALSE == ret) {
 547                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 548
 549                 /* Free response callback data */
 550                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 551
 552                 /* Send failure response */
 553                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 554
 555                 return TRUE;
 556         }
 557
 558         return TRUE;
 559 }
 560
 561 static void on_service_get_network_info_resp(ZigBeeServiceInterface *service_interface,
 562         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 563 {
 564         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 565                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 566
 567         ZigbeeService *service_object;
 568         GDBusMethodInvocation *invocation;
 569
 570         ZigbeeServiceGetNetworkInfoResp_t *payload =
 571                 (ZigbeeServiceGetNetworkInfoResp_t*)resp_data;
 572
 573         GVariant *v_eui64 = NULL;
 574
 575         NOT_USED(service_interface);
 576         NOT_USED(request_id);
 577
 578         if (NULL == resp_data || 0 == resp_data_len) {
 579                 Z_LOGE("resp_data is null");
 580                 return;
 581         }
 582
 583         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 584         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 585
 586         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 587         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 588
 589         v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
 590                 payload->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
 591
 592         zigbee_service_complete_get_network_info(service_object, invocation,
 593                 payload->result, v_eui64, payload->node_id,
 594                 payload->pan_id, payload->channel, payload->radio_tx_power);
 595
 596         g_free(cb_data);
 597 }
 598
 599 static gboolean on_service_get_network_info(ZigbeeService *service_object,
 600         GDBusMethodInvocation *invocation,
 601         gpointer user_data)
 602 {
 603         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 604         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 605
 606         gboolean ret;
 607
 608         /* Allocate response callback data */
 609         resp_cb_data =
 610                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 611                         invocation, NULL, 0);
 612         if (NULL == resp_cb_data) {
 613                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 614
 615                 /* Send failure response */
 616                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 617
 618                 return TRUE;
 619         }
 620
 621         /* Dispatch request */
 622         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 623                 ZBLIB_DRIVER_TYPE_SERVICE,
 624                 ZBLIB_SERVICE_OPS_GET_NETWORK_INFO,
 625                 NULL, 0,
 626                 on_service_get_network_info_resp, resp_cb_data);
 627         if (FALSE == ret) {
 628                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 629
 630                 /* Free response callback data */
 631                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 632
 633                 /* Send failure response */
 634                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 635
 636                 return TRUE;
 637         }
 638
 639         return TRUE;
 640 }
 641
 642 static void on_service_permit_join_resp(ZigBeeServiceInterface *service_interface,
 643         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 644 {
 645         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 646                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 647
 648         ZigbeeService *service_object;
 649         GDBusMethodInvocation *invocation;
 650         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 651
 652         NOT_USED(service_interface);
 653         NOT_USED(request_id);
 654
 655         if (NULL == resp_data || 0 == resp_data_len) {
 656                 Z_LOGE("resp_data is null");
 657                 return;
 658         }
 659
 660         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 661         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 662
 663         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 664         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 665
 666         zigbee_service_complete_permit_join(service_object, invocation, payload->result);
 667
 668         g_free(cb_data);
 669 }
 670
 671 static gboolean on_service_permit_join(ZigbeeService *service_object,
 672         GDBusMethodInvocation *invocation,
 673         gint duration,
 674         gboolean permit_join,
 675         gpointer user_data)
 676 {
 677         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 678         ZigbeeServicePermitJoin_t req;
 679         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 680
 681         gboolean ret;
 682
 683         memset(&req, 0x0, sizeof(ZigbeeServicePermitJoin_t));
 684
 685         /* Update request structure */
 686         req.duration = duration;
 687         req.permit_join = permit_join;
 688
 689         /* Allocate response callback data */
 690         resp_cb_data =
 691                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 692                         invocation, NULL, 0);
 693         if (NULL == resp_cb_data) {
 694                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 695
 696                 /* Send failure response */
 697                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 698
 699                 return TRUE;
 700         }
 701
 702         /* Dispatch request */
 703         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 704                 ZBLIB_DRIVER_TYPE_SERVICE,
 705                 ZBLIB_SERVICE_OPS_PERMIT_JOIN,
 706                 &req, sizeof(req),
 707                 on_service_permit_join_resp, resp_cb_data);
 708         if (FALSE == ret) {
 709                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 710
 711                 /* Free response callback data */
 712                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 713
 714                 /* Send failure response */
 715                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 716
 717                 return TRUE;
 718         }
 719
 720         return TRUE;
 721 }
 722
 723 static void on_service_leave_request_resp(ZigBeeServiceInterface *service_interface,
 724         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 725 {
 726         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 727                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 728
 729         ZigbeeService *service_object;
 730         GDBusMethodInvocation *invocation;
 731         ZigbeeGeneralResp_t *payload = (ZigbeeGeneralResp_t*)resp_data;
 732
 733         NOT_USED(service_interface);
 734         NOT_USED(request_id);
 735
 736         if (NULL == resp_data || 0 == resp_data_len) {
 737                 Z_LOGE("resp_data is null");
 738                 return;
 739         }
 740
 741         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 742         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 743
 744         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 745         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 746
 747         zigbee_service_complete_leave_request(service_object, invocation, payload->result);
 748
 749         g_free(cb_data);
 750 }
 751
 752 static gboolean on_service_leave_request(ZigbeeService *service_object,
 753         GDBusMethodInvocation *invocation,
 754         GVariant *eui64,
 755         gchar remove_child,
 756         gchar rejoin,
 757         gpointer user_data)
 758 {
 759         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 760         ZigbeeServiceLeaveRequest_t req;
 761         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 762
 763         GVariantIter *iter = NULL;
 764         guint i = 0;
 765
 766         gboolean ret;
 767
 768         memset(&req, 0x0, sizeof(ZigbeeServiceLeaveRequest_t));
 769
 770         /* Update request structure */
 771         g_variant_get(eui64, "ay", &iter);
 772         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
 773                 i++;
 774                 if (i >= ZIGBEE_EUI64_SIZE)
 775                         break;
 776         }
 777         req.remove_child = remove_child;
 778         req.rejoin = rejoin;
 779
 780         /* Allocate response callback data */
 781         resp_cb_data =
 782                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 783                         invocation, NULL, 0);
 784         if (NULL == resp_cb_data) {
 785                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 786
 787                 /* Send failure response */
 788                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 789
 790                 return TRUE;
 791         }
 792
 793         /* Dispatch request */
 794         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 795                 ZBLIB_DRIVER_TYPE_SERVICE,
 796                 ZBLIB_SERVICE_OPS_LEAVE_REQUEST,
 797                 &req, sizeof(req),
 798                 on_service_leave_request_resp, resp_cb_data);
 799         if (FALSE == ret) {
 800                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 801
 802                 /* Free response callback data */
 803                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 804
 805                 /* Send failure response */
 806                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 807
 808                 return TRUE;
 809         }
 810
 811         return TRUE;
 812 }
 813
 814 static void on_service_get_device_list_resp(ZigBeeServiceInterface *service_interface,
 815         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 816 {
 817         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 818                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 819
 820         ZigbeeService *service_object;
 821         GDBusMethodInvocation *invocation;
 822
 823         NOT_USED(service_interface);
 824         NOT_USED(request_id);
 825
 826         if (NULL == resp_data || 0 == resp_data_len) {
 827                 Z_LOGE("resp_data is null");
 828                 g_free(cb_data);
 829                 return;
 830         }
 831
 832         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 833         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 834
 835         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 836         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 837
 838         /* To-To : zigbee_service_complete_get_device_list */
 839         //zigbee_service_complete_get_device_list(service_object, invocation,   resp_data);
 840
 841         g_free(cb_data);
 842 }
 843
 844 static gboolean on_service_get_device_list(ZigbeeService *service_object,
 845         GDBusMethodInvocation *invocation,
 846         gpointer user_data)
 847 {
 848         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 849         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 850
 851         gboolean ret;
 852
 853         /* Allocate response callback data */
 854         resp_cb_data =
 855                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 856                         invocation, NULL, 0);
 857         if (NULL == resp_cb_data) {
 858                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 859
 860                 /* Send failure response */
 861                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 862
 863                 return TRUE;
 864         }
 865
 866         /* Dispatch request */
 867         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 868                 ZBLIB_DRIVER_TYPE_SERVICE,
 869                 ZBLIB_SERVICE_OPS_GET_DEVICE_LIST,
 870                 NULL, 0,
 871                 on_service_get_device_list_resp, resp_cb_data);
 872         if (FALSE == ret) {
 873                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 874
 875                 /* Free response callback data */
 876                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 877
 878                 /* Send failure response */
 879                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 880
 881                 return TRUE;
 882         }
 883
 884         return TRUE;
 885 }
 886
 887 static void on_service_get_mac_resp(ZigBeeServiceInterface *service_interface,
 888         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 889 {
 890         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 891                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 892
 893         ZigbeeService *service_object;
 894         GDBusMethodInvocation *invocation;
 895         ZigbeeServiceGetMacResp_t *payload =
 896                 (ZigbeeServiceGetMacResp_t*)resp_data;
 897
 898         GVariant *v_eui64 = NULL;
 899
 900         NOT_USED(service_interface);
 901         NOT_USED(request_id);
 902
 903         if (NULL == resp_data || 0 == resp_data_len) {
 904                 Z_LOGE("resp_data is null");
 905                 g_free(cb_data);
 906                 return;
 907         }
 908
 909         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 910         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 911
 912         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 913         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 914
 915         v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
 916                 payload->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
 917
 918         zigbee_service_complete_get_mac(service_object, invocation, payload->result,
 919                 v_eui64);
 920
 921         g_free(cb_data);
 922 }
 923
 924 static gboolean on_service_get_mac(ZigbeeService *service_object,
 925         GDBusMethodInvocation *invocation,
 926         gpointer user_data)
 927 {
 928         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
 929         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
 930
 931         gboolean ret;
 932
 933         /* Allocate response callback data */
 934         resp_cb_data =
 935                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
 936                         invocation, NULL, 0);
 937         if (NULL == resp_cb_data) {
 938                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
 939
 940                 /* Send failure response */
 941                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 942
 943                 return TRUE;
 944         }
 945
 946         /* Dispatch request */
 947         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
 948                 ZBLIB_DRIVER_TYPE_SERVICE,
 949                 ZBLIB_SERVICE_OPS_GET_MAC,
 950                 NULL, 0,
 951                 on_service_get_mac_resp, resp_cb_data);
 952         if (FALSE == ret) {
 953                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
 954
 955                 /* Free response callback data */
 956                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
 957
 958                 /* Send failure response */
 959                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
 960
 961                 return TRUE;
 962         }
 963
 964         return TRUE;
 965 }
 966
 967 static void on_service_get_device_info_resp(ZigBeeServiceInterface *service_interface,
 968         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
 969 {
 970         ZigbeeServiceInterfaceRespCbData_t *cb_data =
 971                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
 972
 973         ZigbeeService *service_object;
 974         GDBusMethodInvocation *invocation;
 975         ZigbeeServiceGetDeviceInfoResp_t *payload =
 976                 (ZigbeeServiceGetDeviceInfoResp_t*)resp_data;
 977
 978         GVariant *variant = NULL;
 979         GVariantBuilder* builder = NULL;
 980         int i = 0;
 981         int index = 0;
 982
 983         NOT_USED(service_interface);
 984         NOT_USED(request_id);
 985
 986         if (NULL == resp_data || 0 == resp_data_len) {
 987                 Z_LOGE("resp_data is null");
 988                 g_free(cb_data);
 989                 return;
 990         }
 991
 992         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
 993         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
 994
 995         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
 996         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
 997
 998         builder = g_variant_builder_new(G_VARIANT_TYPE ("a(qyayyay)"));
 999         for (index = 0; index < payload->count; index++) {
1000                 ZigbeeServiceGetDeviceInfoDetailResp_t *device = &(payload->list[index]);
1001                 GVariantBuilder* mac_builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
1002                 GVariantBuilder* endpoint_builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
1003
1004                 for (i = 0; i < ZIGBEE_EUI64_SIZE; i++) {
1005                         g_variant_builder_add (mac_builder, "y", device->eui64[i]);
1006                 }
1007                 for (i = 0; i < device->endpoint_count; i++) {
1008                         g_variant_builder_add (endpoint_builder, "y", device->endpoints[i]);
1009                 }
1010
1011                 g_variant_builder_add (builder, "(qyayyay)",
1012                         device->node_id, device->node_type,
1013                         mac_builder, device->endpoint_count, endpoint_builder);
1014
1015                 g_variant_builder_unref (mac_builder);
1016                 g_variant_builder_unref (endpoint_builder);
1017         }
1018
1019         variant = g_variant_builder_end(builder);
1020         zigbee_service_complete_get_device_info(service_object, invocation,
1021                 payload->result, variant);
1022
1023         g_free(cb_data);
1024 }
1025
1026 static gboolean on_service_get_device_info(ZigbeeService *service_object,
1027         GDBusMethodInvocation *invocation,
1028         gpointer user_data)
1029 {
1030         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1031         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1032
1033         gboolean ret;
1034
1035         /* Allocate response callback data */
1036         resp_cb_data =
1037                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
1038                         invocation, NULL, 0);
1039         if (NULL == resp_cb_data) {
1040                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1041
1042                 /* Send failure response */
1043                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1044
1045                 return TRUE;
1046         }
1047
1048         /* Dispatch request */
1049         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1050                 ZBLIB_DRIVER_TYPE_SERVICE,
1051                 ZBLIB_SERVICE_OPS_GET_DEVICE_INFO,
1052                 NULL, 0,
1053                 on_service_get_device_info_resp, resp_cb_data);
1054         if (FALSE == ret) {
1055                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1056
1057                 /* Free response callback data */
1058                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1059
1060                 /* Send failure response */
1061                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1062
1063                 return TRUE;
1064         }
1065
1066         return TRUE;
1067 }
1068
1069 static void on_service_get_endpoint_list_resp(ZigBeeServiceInterface *service_interface,
1070         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1071 {
1072         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1073                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1074
1075         ZigbeeService *service_object;
1076         GDBusMethodInvocation *invocation;
1077         ZigbeeServiceGetEndpointListResp_t *payload =
1078                 (ZigbeeServiceGetEndpointListResp_t*)resp_data;
1079         GVariant *v_endpoints = NULL;
1080
1081         NOT_USED(service_interface);
1082         NOT_USED(request_id);
1083
1084         if (NULL == resp_data || 0 == resp_data_len) {
1085                 Z_LOGE("resp_data is null");
1086                 g_free(cb_data);
1087                 return;
1088         }
1089
1090         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1091         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
1092
1093         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1094         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1095
1096         v_endpoints = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1097                 payload->endpoints, payload->endpoint_count, TRUE, NULL, NULL);
1098
1099         zigbee_service_complete_get_endpoint_list(service_object, invocation,
1100                 payload->result, v_endpoints);
1101
1102         g_free(cb_data);
1103 }
1104
1105 static gboolean on_service_get_endpoint_list(ZigbeeService *service_object,
1106         GDBusMethodInvocation *invocation,
1107         GVariant *eui64,
1108         gpointer user_data)
1109 {
1110         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1111         ZigbeeServiceGetEndpointList_t req;
1112         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1113
1114         GVariantIter *iter = NULL;
1115         guint i = 0;
1116
1117         gboolean ret;
1118
1119         memset(&req, 0x0, sizeof(ZigbeeServiceGetEndpointList_t));
1120
1121         /* Update request structure */
1122         g_variant_get(eui64, "ay", &iter);
1123         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
1124                 i++;
1125                 if (i >= ZIGBEE_EUI64_SIZE)
1126                         break;
1127         }
1128
1129         /* Allocate response callback data */
1130         resp_cb_data =
1131                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
1132                         invocation, NULL, 0);
1133         if (NULL == resp_cb_data) {
1134                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1135
1136                 /* Send failure response */
1137                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1138
1139                 return TRUE;
1140         }
1141
1142         /* Dispatch request */
1143         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1144                 ZBLIB_DRIVER_TYPE_SERVICE,
1145                 ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST,
1146                 &req, sizeof(req),
1147                 on_service_get_endpoint_list_resp, resp_cb_data);
1148         if (FALSE == ret) {
1149                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1150
1151                 /* Free response callback data */
1152                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1153
1154                 /* Send failure response */
1155                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1156
1157                 return TRUE;
1158         }
1159
1160         return TRUE;
1161 }
1162
1163 static void on_service_get_cluster_list_resp(ZigBeeServiceInterface *service_interface,
1164         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1165 {
1166         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1167                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1168
1169         ZigbeeService *service_object;
1170         GDBusMethodInvocation *invocation;
1171         ZigbeeServiceGetClusterListResp_t *payload =
1172                 (ZigbeeServiceGetClusterListResp_t*)resp_data;
1173         GVariant *v_clusters = NULL;
1174
1175         NOT_USED(service_interface);
1176         NOT_USED(request_id);
1177
1178         if (NULL == resp_data || 0 == resp_data_len) {
1179                 Z_LOGE("resp_data is null");
1180                 g_free(cb_data);
1181                 return;
1182         }
1183
1184         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1185         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
1186
1187         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1188         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1189
1190         v_clusters = g_variant_new_from_data(G_VARIANT_TYPE("aq"),
1191                 payload->clusters, payload->cluster_count, TRUE, NULL, NULL);
1192
1193         zigbee_service_complete_get_cluster_list(service_object, invocation,
1194                 payload->result, v_clusters);
1195
1196         g_free(cb_data);
1197 }
1198
1199 static gboolean on_service_get_cluster_list(ZigbeeService *service_object,
1200         GDBusMethodInvocation *invocation,
1201         GVariant *eui64,
1202         gchar endpoint,
1203         gpointer user_data)
1204 {
1205         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1206         ZigbeeServiceGetClusterList_t req;
1207         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1208
1209         GVariantIter *iter = NULL;
1210         guint i = 0;
1211
1212         gboolean ret;
1213
1214         memset(&req, 0x0, sizeof(ZigbeeServiceGetClusterList_t));
1215
1216         /* Update request structure */
1217         g_variant_get(eui64, "ay", &iter);
1218         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
1219                 i++;
1220                 if (i >= ZIGBEE_EUI64_SIZE)
1221                         break;
1222         }
1223         req.endpoint = endpoint;
1224
1225         /* Allocate response callback data */
1226         resp_cb_data =
1227                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
1228                         invocation, NULL, 0);
1229         if (NULL == resp_cb_data) {
1230                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1231
1232                 /* Send failure response */
1233                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1234
1235                 return TRUE;
1236         }
1237
1238         /* Dispatch request */
1239         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1240                 ZBLIB_DRIVER_TYPE_SERVICE,
1241                 ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST,
1242                 &req, sizeof(req),
1243                 on_service_get_cluster_list_resp, resp_cb_data);
1244         if (FALSE == ret) {
1245                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1246
1247                 /* Free response callback data */
1248                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1249
1250                 /* Send failure response */
1251                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1252
1253                 return TRUE;
1254         }
1255
1256         return TRUE;
1257 }
1258
1259 static void on_service_get_node_type_resp(ZigBeeServiceInterface *service_interface,
1260         guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1261 {
1262         ZigbeeServiceInterfaceRespCbData_t *cb_data =
1263                 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1264
1265         ZigbeeService *service_object;
1266         GDBusMethodInvocation *invocation;
1267         ZigbeeServiceServiceNodeTypeResp_t *payload =
1268                 (ZigbeeServiceServiceNodeTypeResp_t *)resp_data;
1269
1270         NOT_USED(service_interface);
1271         NOT_USED(request_id);
1272
1273         if (NULL == resp_data || 0 == resp_data_len) {
1274                 Z_LOGE("resp_data is null");
1275                 g_free(cb_data);
1276                 return;
1277         }
1278
1279         service_object = zigbee_service_dbus_interface_ref_interface_object(cb_data);
1280         zblib_check_null_free_and_ret("service_object", service_object, cb_data);
1281
1282         invocation = zigbee_service_dbus_interface_ref_invocation(cb_data);
1283         zblib_check_null_free_and_ret("invocation", invocation, cb_data);
1284
1285         zigbee_service_complete_get_node_type(service_object, invocation,
1286                 payload->result, payload->node_type);
1287
1288         g_free(cb_data);
1289 }
1290
1291 static gboolean on_service_get_node_type(ZigbeeService *service_object,
1292         GDBusMethodInvocation *invocation,
1293         GVariant *eui64,
1294         gpointer user_data)
1295 {
1296         ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1297         ZigbeeServiceGetNodeType_t req;
1298         ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1299
1300         GVariantIter *iter = NULL;
1301         guint i = 0;
1302
1303         gboolean ret;
1304
1305         memset(&req, 0x0, sizeof(ZigbeeServiceGetNodeType_t));
1306
1307         /* Update request structure */
1308         g_variant_get(eui64, "ay", &iter);
1309         while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
1310                 i++;
1311                 if (i >= ZIGBEE_EUI64_SIZE)
1312                         break;
1313         }
1314
1315         /* Allocate response callback data */
1316         resp_cb_data =
1317                 zigbee_service_dbus_interface_create_resp_cb_data(service_object,
1318                         invocation, NULL, 0);
1319         if (NULL == resp_cb_data) {
1320                 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1321
1322                 /* Send failure response */
1323                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1324
1325                 return TRUE;
1326         }
1327
1328         /* Dispatch request */
1329         ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1330                 ZBLIB_DRIVER_TYPE_SERVICE,
1331                 ZBLIB_SERVICE_OPS_GET_NODE_TYPE,
1332                 &req, sizeof(req),
1333                 on_service_get_node_type_resp, resp_cb_data);
1334         if (FALSE == ret) {
1335                 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1336
1337                 /* Free response callback data */
1338                 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1339
1340                 /* Send failure response */
1341                 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1342
1343                 return TRUE;
1344         }
1345
1346         return TRUE;
1347 }
1348
1349 void zigbee_service_dbus_interface_service_notification(ZigBeeServiceInterface *service_interface,
1350         guint noti_id, gpointer noti_data, guint noti_data_len, gpointer noti_cb_data)
1351 {
1352         ZigbeeService *service_object;
1353
1354         zblib_check_null_ret("service_interface", service_interface);
1355
1356         if (NULL == noti_data || 0 == noti_data_len) {
1357                 Z_LOGE("noti_data is NULL");
1358                 return;
1359         }
1360
1361         service_object = _service_interface_ref_zigbee_service(service_interface);
1362         zblib_check_null_ret("service_object", service_object);
1363
1364         NOT_USED(noti_cb_data);
1365
1366         switch(noti_id) {
1367         case ZBLIB_SERVICE_NOTI_FORM_NETWORK_DONE: {
1368                 ZigbeeServiceServiceFormNetworkDone_t *panid_t =
1369                         (ZigbeeServiceServiceFormNetworkDone_t*)noti_data;
1370
1371                 Z_LOGD("form_network_done : [0x%X]", panid_t->pan_id);
1372
1373                 zigbee_service_emit_form_network_done(service_object, panid_t->pan_id);
1374         }
1375         break;
1376         case ZBLIB_SERVICE_NOTI_CHILD_JOINED: {
1377                 ZigbeeServiceServiceChildJoined_t *child_t =
1378                         (ZigbeeServiceServiceChildJoined_t*)noti_data;
1379
1380                 GVariant *v_eui64 = NULL;
1381                 GVariant *v_endpoints = NULL;
1382
1383                 v_eui64 = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1384                         child_t->eui64, ZIGBEE_EUI64_SIZE, TRUE, NULL, NULL);
1385                 v_endpoints = g_variant_new_from_data(G_VARIANT_TYPE("a(y)"),
1386                         child_t->endpoints, child_t->endpoint_count, TRUE, NULL, NULL);
1387                 if (NULL == v_eui64 || NULL == v_endpoints) {
1388                         Z_LOGE("Failed to create variant!");
1389                         if (v_eui64)
1390                                 g_object_unref(v_eui64);
1391                         if (v_endpoints)
1392                                 g_object_unref(v_endpoints);
1393                 } else {
1394                         zigbee_service_emit_child_joined(service_object,
1395                                 v_eui64, child_t->endpoint_count, v_endpoints, child_t->node_id);
1396                 }
1397         }
1398         break;
1399         case ZBLIB_SERVICE_NOTI_CHILD_REJOINED: {
1400                 ZigbeeServiceServiceChildRejoined_t ieee_addr_t;
1401                 memcpy(&ieee_addr_t, noti_data, noti_data_len);
1402                 zigbee_service_emit_child_rejoined(service_object, ieee_addr_t.eui64);
1403         }
1404         break;
1405         case ZBLIB_SERVICE_NOTI_CHILD_LEFT: {
1406                 ZigbeeServiceServiceChildLeft_t child_left_t;
1407                 memcpy(&child_left_t, noti_data, noti_data_len);
1408                 zigbee_service_emit_child_left(service_object, child_left_t.eui64, child_left_t.status);
1409         }
1410         break;
1411         case ZBLIB_SERVICE_NOTI_LEAVE_NETWORK_DONE: {
1412                 ZigbeeServiceServiceLeaveNetworkDone_t leave_net_t;
1413                 memcpy(&leave_net_t, noti_data, noti_data_len);
1414                 zigbee_service_emit_leave_network_done(service_object, leave_net_t.pan_id);
1415         }
1416         break;
1417         default:
1418                 Z_LOGE("Unexpected notification [%x]", noti_id);
1419         break;
1420         }
1421
1422         /* ZigbeeService should be dereferenced */
1423         g_object_unref(service_object);
1424 }
1425
1426 gboolean zigbee_service_dbus_interface_service_init(ZigBeeServiceInterface *service_interface,
1427         ZigbeeObjectSkeleton *zigbee_object)
1428 {
1429         ZigbeeService *service_object;
1430
1431         if (NULL == service_interface) {
1432                 Z_LOGE("service_interface is NULL");
1433                 return FALSE;
1434         }
1435
1436         service_object = zigbee_service_skeleton_new();
1437         zigbee_object_skeleton_set_service(zigbee_object, service_object);
1438         g_object_unref(service_object);
1439
1440         Z_LOGI("service_object: [%p]", service_object);
1441
1442         /*
1443          * Register signal handlers for 'service' interface
1444          */
1445         g_signal_connect(service_object,
1446                 "handle-enable",
1447                 G_CALLBACK(on_service_enable), service_interface);
1448
1449         g_signal_connect(service_object,
1450                 "handle-disable",
1451                 G_CALLBACK(on_service_disable), service_interface);
1452
1453         g_signal_connect(service_object,
1454                 "handle-zb-hw-reset",
1455                 G_CALLBACK(on_service_zb_hw_reset), service_interface);
1456
1457         g_signal_connect(service_object,
1458                 "handle-form-network",
1459                 G_CALLBACK(on_service_form_network), service_interface);
1460
1461         g_signal_connect(service_object,
1462                 "handle-coex-start",
1463                 G_CALLBACK(on_service_coex_start), service_interface);
1464
1465         g_signal_connect(service_object,
1466                 "handle-coex-stop",
1467                 G_CALLBACK(on_service_coex_stop), service_interface);
1468
1469         g_signal_connect(service_object,
1470                 "handle-leave-network",
1471                 G_CALLBACK(on_service_leave_network), service_interface);
1472
1473         g_signal_connect(service_object,
1474                 "handle-get-network-info",
1475                 G_CALLBACK(on_service_get_network_info), service_interface);
1476
1477         g_signal_connect(service_object,
1478                 "handle-permit-join",
1479                 G_CALLBACK(on_service_permit_join), service_interface);
1480
1481         g_signal_connect(service_object,
1482                 "handle-leave-request",
1483                 G_CALLBACK(on_service_leave_request), service_interface);
1484
1485         g_signal_connect(service_object,
1486                 "handle-get-device-list",
1487                 G_CALLBACK(on_service_get_device_list), service_interface);
1488
1489         g_signal_connect(service_object,
1490                 "handle-get-mac",
1491                 G_CALLBACK(on_service_get_mac), service_interface);
1492
1493         g_signal_connect(service_object,
1494                 "handle-get-device-info",
1495                 G_CALLBACK(on_service_get_device_info), service_interface);
1496
1497         g_signal_connect(service_object,
1498                 "handle-get-endpoint-list",
1499                 G_CALLBACK(on_service_get_endpoint_list), service_interface);
1500
1501         g_signal_connect(service_object,
1502                 "handle-get-cluster-list",
1503                 G_CALLBACK(on_service_get_cluster_list), service_interface);
1504
1505         g_signal_connect(service_object,
1506                 "handle-get-node-type",
1507                 G_CALLBACK(on_service_get_node_type), service_interface);
1508
1509         return TRUE;
1510 }