lib/zbl.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
  17 #include <glib.h>
  18 #include <errno.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #include "zbl.h"
  23 #include "zbl-dbus.h"
  24 #include "zb-common.h"
  25
  26 API int zb_ev_get_enable_status(zb_event_data_h ev, zb_error_e* status)
  27 {
  28         zb_event_data_s *event = ev;
  29         zb_event_enable_s *enable = NULL;
  30
  31         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  32
  33         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
  34         enable = event->data.enable;
  35         RETV_IF(NULL == enable, ZIGBEE_ERROR_INVALID_PARAMETER);
  36         RETV_IF(NULL == status, ZIGBEE_ERROR_INVALID_PARAMETER);
  37
  38         *status = enable->status;
  39
  40         return ZIGBEE_ERROR_NONE;
  41 }
  42
  43
  44 API int zb_ev_get_form_network_panid(zb_event_data_h ev, zb_nwk_addr* pan_id)
  45 {
  46         zb_event_data_s *event = ev;
  47         zb_event_form_network_s *form_network = NULL;
  48
  49         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  50
  51         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
  52         form_network = event->data.form_network;
  53         RETV_IF(NULL == form_network, ZIGBEE_ERROR_INVALID_PARAMETER);
  54         RETV_IF(NULL == pan_id, ZIGBEE_ERROR_INVALID_PARAMETER);
  55
  56         *pan_id = form_network->pan_id;
  57
  58         return ZIGBEE_ERROR_NONE;
  59 }
  60
  61
  62 API int zb_ev_get_join_count(zb_event_data_h ev, unsigned char* count)
  63 {
  64         zb_event_data_s *event = ev;
  65         zb_event_join_s *join = NULL;
  66
  67         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  68
  69         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
  70         join = event->data.join;
  71         RETV_IF(NULL == join, ZIGBEE_ERROR_INVALID_PARAMETER);
  72         RETV_IF(NULL == count, ZIGBEE_ERROR_INVALID_PARAMETER);
  73
  74         *count = join->count;
  75
  76         return ZIGBEE_ERROR_NONE;
  77 }
  78
  79 API int zb_ev_get_join_ep(zb_event_data_h ev, unsigned char** ep)
  80 {
  81         zb_event_data_s *event = ev;
  82         zb_event_join_s *join = NULL;
  83
  84         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  85
  86         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
  87         join = event->data.join;
  88         RETV_IF(NULL == join, ZIGBEE_ERROR_INVALID_PARAMETER);
  89         RETV_IF(NULL == ep, ZIGBEE_ERROR_INVALID_PARAMETER);
  90
  91         *ep = calloc(join->count, sizeof(unsigned char));
  92         if (NULL == *ep) {
  93                 ERR("Couldn't Allocate Memory");
  94                 return ZIGBEE_ERROR_OUT_OF_MEMORY;
  95         }
  96         memcpy(*ep, join->ep, join->count);
  97
  98         return ZIGBEE_ERROR_NONE;
  99 }
 100
 101 API int zb_ev_get_child_left_status(zb_event_data_h ev, zb_error_e* status)
 102 {
 103         zb_event_data_s *event = ev;
 104         zb_event_child_left_s *child_left = NULL;
 105
 106         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 107
 108         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 109         child_left = event->data.child_left;
 110         RETV_IF(NULL == child_left, ZIGBEE_ERROR_INVALID_PARAMETER);
 111         RETV_IF(NULL == status, ZIGBEE_ERROR_INVALID_PARAMETER);
 112
 113         *status = child_left->status;
 114
 115         return ZIGBEE_ERROR_NONE;
 116 }
 117
 118 API int zb_ev_get_global_default_rsp_ep(zb_event_data_h ev, unsigned char* ep)
 119 {
 120         zb_event_data_s *event = ev;
 121         zb_event_global_default_rsp_s *global_default_rsp = NULL;
 122
 123         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 124
 125         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 126         global_default_rsp = event->data.global_default_rsp;
 127         RETV_IF(NULL == global_default_rsp, ZIGBEE_ERROR_INVALID_PARAMETER);
 128         RETV_IF(NULL == ep, ZIGBEE_ERROR_INVALID_PARAMETER);
 129
 130         *ep = global_default_rsp->ep;
 131
 132         return ZIGBEE_ERROR_NONE;
 133 }
 134
 135 API int zb_ev_get_global_default_rsp_cluster_id(zb_event_data_h ev,
 136         unsigned short* clusterid)
 137 {
 138         zb_event_data_s *event = ev;
 139         zb_event_global_default_rsp_s *global_default_rsp = NULL;
 140
 141         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 142
 143         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 144         global_default_rsp = event->data.global_default_rsp;
 145         RETV_IF(NULL == global_default_rsp, ZIGBEE_ERROR_INVALID_PARAMETER);
 146         RETV_IF(NULL == clusterid, ZIGBEE_ERROR_INVALID_PARAMETER);
 147
 148         *clusterid = global_default_rsp->clusterid;
 149
 150         return ZIGBEE_ERROR_NONE;
 151 }
 152
 153 API int zb_ev_get_global_default_rsp_command_id(zb_event_data_h ev,
 154         unsigned char* commandid)
 155 {
 156         zb_event_data_s *event = ev;
 157         zb_event_global_default_rsp_s *global_default_rsp = NULL;
 158
 159         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 160
 161         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 162         global_default_rsp = event->data.global_default_rsp;
 163         RETV_IF(NULL == global_default_rsp, ZIGBEE_ERROR_INVALID_PARAMETER);
 164         RETV_IF(NULL == commandid, ZIGBEE_ERROR_INVALID_PARAMETER);
 165
 166         *commandid = global_default_rsp->commandid;
 167
 168         return ZIGBEE_ERROR_NONE;
 169 }
 170
 171 API int zb_ev_get_global_default_rsp_status(zb_event_data_h ev,
 172         zb_zcl_status_e* status)
 173 {
 174         zb_event_data_s *event = ev;
 175         zb_event_global_default_rsp_s *global_default_rsp = NULL;
 176
 177         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 178
 179         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 180         global_default_rsp = event->data.global_default_rsp;
 181         RETV_IF(NULL == global_default_rsp, ZIGBEE_ERROR_INVALID_PARAMETER);
 182         RETV_IF(NULL == status, ZIGBEE_ERROR_INVALID_PARAMETER);
 183
 184         *status = global_default_rsp->status;
 185
 186         return ZIGBEE_ERROR_NONE;
 187 }
 188
 189 /* Need to be test, because we don't know things send this reports to coordinator */
 190 API int zb_ev_get_global_attr_report_records(zb_event_data_h ev,
 191         zb_zcl_attr_report_h* records, unsigned char *count)
 192 {
 193         zb_event_data_s *event = ev;
 194         zb_event_global_attr_report_s *global_attr_repor = NULL;
 195
 196         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 197
 198         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 199         global_attr_repor = event->data.global_attr_report;
 200         RETV_IF(NULL == global_attr_repor, ZIGBEE_ERROR_INVALID_PARAMETER);
 201         RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
 202
 203         *records = global_attr_repor->records;
 204         *count = global_attr_repor->count;
 205
 206         return ZIGBEE_ERROR_NONE;
 207 }
 208
 209 API int zb_ev_get_alarm_count(zb_event_data_h ev, unsigned short* count)
 210 {
 211         zb_event_data_s *event = ev;
 212         zb_event_alarm_s *alarm = NULL;
 213
 214         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 215
 216         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 217         alarm = event->data.alarm;
 218         RETV_IF(NULL == alarm, ZIGBEE_ERROR_INVALID_PARAMETER);
 219         RETV_IF(NULL == count, ZIGBEE_ERROR_INVALID_PARAMETER);
 220
 221         *count = alarm->count;
 222
 223         return ZIGBEE_ERROR_NONE;
 224 }
 225
 226 API int zb_ev_get_enroll_request_src_ep(zb_event_data_h ev, unsigned char* src_ep)
 227 {
 228         zb_event_data_s *event = ev;
 229         zb_event_ias_enroll_request_s* ias_enroll_request = NULL;
 230
 231         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 232
 233         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 234         ias_enroll_request = event->data.ias_enroll_request;
 235         RETV_IF(NULL == ias_enroll_request, ZIGBEE_ERROR_INVALID_PARAMETER);
 236         RETV_IF(NULL == src_ep, ZIGBEE_ERROR_INVALID_PARAMETER);
 237
 238         *src_ep = ias_enroll_request->src_ep;
 239
 240         return ZIGBEE_ERROR_NONE;
 241 }
 242
 243 API int zb_ev_get_enroll_request_zone_type(zb_event_data_h ev,
 244         zb_zcl_ias_zone_type_e * zone_type)
 245 {
 246         zb_event_data_s *event = ev;
 247         zb_event_ias_enroll_request_s* ias_enroll_request = NULL;
 248
 249         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 250
 251         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 252         ias_enroll_request = event->data.ias_enroll_request;
 253         RETV_IF(NULL == ias_enroll_request, ZIGBEE_ERROR_INVALID_PARAMETER);
 254         RETV_IF(NULL == zone_type, ZIGBEE_ERROR_INVALID_PARAMETER);
 255
 256         *zone_type = ias_enroll_request->zone_type;
 257
 258         return ZIGBEE_ERROR_NONE;
 259 }
 260
 261 API int zb_ev_get_enroll_request_mfg_code(zb_event_data_h ev,
 262         unsigned char* mfg_code)
 263 {
 264         zb_event_data_s *event = ev;
 265         zb_event_ias_enroll_request_s* ias_enroll_request = NULL;
 266
 267         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 268
 269         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 270         ias_enroll_request = event->data.ias_enroll_request;
 271         RETV_IF(NULL == ias_enroll_request, ZIGBEE_ERROR_INVALID_PARAMETER);
 272         RETV_IF(NULL == mfg_code, ZIGBEE_ERROR_INVALID_PARAMETER);
 273
 274         *mfg_code = ias_enroll_request->mfg_code;
 275
 276         return ZIGBEE_ERROR_NONE;
 277 }
 278
 279
 280 API int zb_ev_get_ias_noti_src_ep(zb_event_data_h ev, unsigned char* src_ep)
 281 {
 282         zb_event_data_s *event = ev;
 283         zb_event_ias_noti_s* ias_noti = NULL;
 284
 285         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 286
 287         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 288         ias_noti = event->data.ias_noti;
 289         RETV_IF(NULL == ias_noti, ZIGBEE_ERROR_INVALID_PARAMETER);
 290         RETV_IF(NULL == src_ep, ZIGBEE_ERROR_INVALID_PARAMETER);
 291
 292         *src_ep = ias_noti->src_ep;
 293
 294         return ZIGBEE_ERROR_NONE;
 295 }
 296
 297 API int zb_ev_get_ias_noti_zone_status(zb_event_data_h ev,
 298         unsigned short* zone_status)
 299 {
 300         zb_event_data_s *event = ev;
 301         zb_event_ias_noti_s* ias_noti = NULL;
 302
 303         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 304
 305         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 306         ias_noti = event->data.ias_noti;
 307         RETV_IF(NULL == ias_noti, ZIGBEE_ERROR_INVALID_PARAMETER);
 308         RETV_IF(NULL == zone_status, ZIGBEE_ERROR_INVALID_PARAMETER);
 309
 310         *zone_status = ias_noti->zone_status;
 311
 312         return ZIGBEE_ERROR_NONE;
 313 }
 314
 315 API int zb_ev_get_ias_ext_noti_src_ep(zb_event_data_h ev, unsigned char* src_ep)
 316 {
 317         zb_event_data_s *event = ev;
 318         zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
 319
 320         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 321
 322         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 323         ias_extended_noti = event->data.ias_extended_noti;
 324         RETV_IF(NULL == ias_extended_noti, ZIGBEE_ERROR_INVALID_PARAMETER);
 325         RETV_IF(NULL == src_ep, ZIGBEE_ERROR_INVALID_PARAMETER);
 326
 327         *src_ep = ias_extended_noti->src_ep;
 328
 329         return ZIGBEE_ERROR_NONE;
 330 }
 331
 332 API int zb_ev_get_ias_ext_noti_status(zb_event_data_h ev, unsigned char* status)
 333 {
 334         zb_event_data_s *event = ev;
 335         zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
 336
 337         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 338
 339         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 340         ias_extended_noti = event->data.ias_extended_noti;
 341         RETV_IF(NULL == ias_extended_noti, ZIGBEE_ERROR_INVALID_PARAMETER);
 342         RETV_IF(NULL == status, ZIGBEE_ERROR_INVALID_PARAMETER);
 343
 344         *status = ias_extended_noti->status;
 345
 346         return ZIGBEE_ERROR_NONE;
 347 }
 348
 349 API int zb_ev_get_ias_ext_noti_zone_status(zb_event_data_h ev,
 350         unsigned short* zone_status)
 351 {
 352         zb_event_data_s *event = ev;
 353         zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
 354
 355         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 356
 357         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 358         ias_extended_noti = event->data.ias_extended_noti;
 359         RETV_IF(NULL == ias_extended_noti, ZIGBEE_ERROR_INVALID_PARAMETER);
 360         RETV_IF(NULL == zone_status, ZIGBEE_ERROR_INVALID_PARAMETER);
 361
 362         *zone_status = ias_extended_noti->zone_status;
 363
 364         return ZIGBEE_ERROR_NONE;
 365 }
 366
 367 API int zb_ev_get_ias_ext_noti_delay(zb_event_data_h ev, unsigned short* delay)
 368 {
 369         zb_event_data_s *event = ev;
 370         zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
 371
 372         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 373
 374         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 375         ias_extended_noti = event->data.ias_extended_noti;
 376         RETV_IF(NULL == ias_extended_noti, ZIGBEE_ERROR_INVALID_PARAMETER);
 377         RETV_IF(NULL == delay, ZIGBEE_ERROR_INVALID_PARAMETER);
 378
 379         *delay = ias_extended_noti->delay;
 380
 381         return ZIGBEE_ERROR_NONE;
 382 }
 383
 384 API int zb_ev_get_ias_ext_noti_zone_id(zb_event_data_h ev, unsigned char* zone_id)
 385 {
 386         zb_event_data_s *event = ev;
 387         zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
 388
 389         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 390
 391         RETV_IF(NULL == ev, ZIGBEE_ERROR_INVALID_PARAMETER);
 392         ias_extended_noti = event->data.ias_extended_noti;
 393         RETV_IF(NULL == ias_extended_noti, ZIGBEE_ERROR_INVALID_PARAMETER);
 394         RETV_IF(NULL == zone_id, ZIGBEE_ERROR_INVALID_PARAMETER);
 395
 396         *zone_id = ias_extended_noti->zone_id;
 397
 398         return ZIGBEE_ERROR_NONE;
 399 }
 400
 401 API int zb_create(zb_zigbee_h *handle)
 402 {
 403         int ret = ZIGBEE_ERROR_NONE;
 404         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 405         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 406         zb_zigbee_h h = calloc(1, sizeof(struct zbl_zigbee_s));
 407         RETVM_IF(NULL == h, ZIGBEE_ERROR_OUT_OF_MEMORY, "calloc() Fail(%d)", errno);
 408         *handle = h;
 409
 410 #if !GLIB_CHECK_VERSION(2, 35, 0)
 411         g_type_init();
 412 #endif
 413 #if !GLIB_CHECK_VERSION(2, 31, 0)
 414         g_thread_init(NULL);
 415 #endif
 416         ret = zbl_dbus_start(*handle);
 417         DBG("zbl_dbus_start()=0x%X", ret);
 418
 419         return ret;
 420 }
 421
 422 API int zb_destroy(zb_zigbee_h handle)
 423 {
 424         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 425         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 426
 427         zbl_dbus_stop(handle);
 428         return ZIGBEE_ERROR_NONE;
 429 }
 430
 431 API int zb_enable(zb_zigbee_h handle)
 432 {
 433         int ret = ZIGBEE_ERROR_NONE;
 434         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 435         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 436
 437         ret = zbl_enable(handle);
 438         DBG("zbl_enable()=0x%X", ret);
 439         return ret;
 440 }
 441
 442 API int zb_set_event_cb(zb_zigbee_h handle, zb_event_cb event_handler)
 443 {
 444         int ret = ZIGBEE_ERROR_NONE;
 445         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 446         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 447
 448         ret = zbl_set_event_cb(handle, event_handler);
 449         DBG("zb_set_event_cb()=0x%X", ret);
 450         return ret;
 451 }
 452
 453 API int zb_disable(zb_zigbee_h handle)
 454 {
 455         int ret = ZIGBEE_ERROR_NONE;
 456         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 457         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 458
 459         ret = zbl_disable();
 460         DBG("zbl_disable()=0x%X", ret);
 461         return ret;
 462 }
 463
 464 API int zb_hw_reset(zb_zigbee_h handle)
 465 {
 466         int ret = ZIGBEE_ERROR_NONE;
 467         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 468         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 469
 470         ret = zbl_hw_reset();
 471         DBG("zbl_hw_reset()=0x%X", ret);
 472         return ret;
 473 }
 474
 475 API int zb_coex_start(zb_zigbee_h handle, unsigned char channel)
 476 {
 477         int ret = ZIGBEE_ERROR_NONE;
 478         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 479         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 480
 481         ret = zbl_coex_start(channel);
 482         DBG("zbl_coex_start()=0x%X", ret);
 483         return ret;
 484 }
 485
 486 API int zb_coex_stop(zb_zigbee_h handle)
 487 {
 488         int ret = ZIGBEE_ERROR_NONE;
 489         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 490         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 491
 492         ret = zbl_coex_stop();
 493         DBG("zbl_coex_stop()=0x%X", ret);
 494         return ret;
 495 }
 496
 497 API int zb_form_network(zb_zigbee_h handle, zb_form_network_cb cb, void *user_data)
 498 {
 499         int ret = ZIGBEE_ERROR_NONE;
 500         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 501         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 502
 503         ret = zbl_form_network(handle, cb, user_data);
 504         DBG("zbl_form_network()=0x%X", ret);
 505         return ret;
 506 }
 507
 508 API int zb_disable_network(zb_zigbee_h handle, zb_disable_network_cb cb, void *user_data)
 509 {
 510         int ret = ZIGBEE_ERROR_NONE;
 511         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 512         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 513
 514         ret = zbl_disable_network(handle, cb, user_data);
 515         DBG("zb_disable_network()=0x%X", ret);
 516         return ret;
 517 }
 518
 519 API int zb_leave_device(zb_zigbee_h handle, zb_ieee_addr addr, bool remove_children, bool rejoin)
 520 {
 521         int ret = ZIGBEE_ERROR_NONE;
 522         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 523         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 524         RETV_IF(NULL == addr, ZIGBEE_ERROR_INVALID_PARAMETER);
 525
 526         ret = zbl_leave_device(addr, remove_children, rejoin);
 527         DBG("zbl_leave_device()=0x%X", ret);
 528         return ret;
 529 }
 530
 531 API int zb_permit_join(zb_zigbee_h handle, unsigned char timeout)
 532 {
 533         int ret = ZIGBEE_ERROR_NONE;
 534         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 535         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 536
 537         ret = zbl_permit_join(timeout, TRUE);
 538         DBG("zb_permit_join()=0x%X", ret);
 539         return ret;
 540 }
 541
 542 API int zb_get_controller_mac_address(zb_zigbee_h handle, zb_ieee_addr addr64)
 543 {
 544         int ret = ZIGBEE_ERROR_NONE;
 545         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 546         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 547         RETV_IF(NULL == addr64, ZIGBEE_ERROR_INVALID_PARAMETER);
 548
 549         ret = zbl_get_controller_mac_address(addr64);
 550         DBG("zbl_get_controller_mac_address()=0x%X", ret);
 551         return ret;
 552 }
 553
 554 API int zb_get_network_info(zb_zigbee_h handle, zb_ieee_addr addr64, zb_nwk_addr *nodeid,
 555                 zb_nwk_addr *panid, unsigned char *channel, unsigned char *tx_power)
 556 {
 557         int ret = ZIGBEE_ERROR_NONE;
 558         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 559         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 560         RETV_IF(NULL == addr64, ZIGBEE_ERROR_INVALID_PARAMETER);
 561
 562         ret = zbl_get_network_info(addr64, nodeid, panid, channel, tx_power);
 563         DBG("zbl_get_network_info()=0x%X", ret);
 564         return ret;
 565 }
 566
 567 API int zb_end_dev_info_list_free(zb_end_dev_info_h *list)
 568 {
 569         int i = 0, j = 0;
 570         struct zb_end_device_info_s **plist = (struct zb_end_device_info_s **)list;
 571         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 572         RETV_IF(NULL == list, ZIGBEE_ERROR_INVALID_PARAMETER);
 573
 574         while (plist[i]) {
 575                 j = 0;
 576                 while (plist[i]->desc && plist[i]->desc[j]) {
 577                         free(plist[i]->desc[j]);
 578                         j++;
 579                 }
 580                 if (plist[i]->desc)
 581                         free(plist[i]->desc);
 582                 free(plist[i]);
 583                 i++;
 584         }
 585         free(plist);
 586         plist = NULL;
 587         return ZIGBEE_ERROR_NONE;
 588 }