lib/zbl-zdo-nwk-mgr.c

   1 /*
   2  * Copyright (c) 2016 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 "zbl.h"
  17 #include "zbl-dbus.h"
  18 #include "zb-common.h"
  19
  20 API int zb_zdo_mgmt_nwk_disc_req(zb_zigbee_h handle, zb_nwk_addr addr16,
  21         unsigned int scan_channels, unsigned char scan_duration, unsigned char scan_count,
  22         unsigned char start_idx, zb_zdo_mgmt_nwk_disc_cb cb, void *user_data)
  23 {
  24         int ret;
  25         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  26         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  27         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  28         ret = zbl_mgmt_nwk_disc_req(addr16, scan_channels, scan_duration, scan_count,
  29                 start_idx, cb, user_data);
  30         return ret;
  31 }
  32
  33 API int zb_zdo_mgmt_lqi_req(zb_zigbee_h handle, zb_nwk_addr addr16,
  34         unsigned char start_idx, zb_zdo_mgmt_lqi_cb cb, void *user_data)
  35 {
  36         int ret;
  37         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  38         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  39         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  40         ret = zbl_mgmt_lqi_req(addr16, start_idx, cb, user_data);
  41         return ret;
  42 }
  43
  44 API int zb_zdo_mgmt_rtg_req(zb_zigbee_h handle, zb_nwk_addr addr16,
  45         unsigned char start_idx, zb_zdo_mgmt_rtg_cb cb, void *user_data)
  46 {
  47         int ret;
  48         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  49         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  50         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  51         ret = zbl_mgmt_rtg_req(addr16, start_idx, cb, user_data);
  52         return ret;
  53 }
  54
  55 API int zb_zdo_mgmt_bind_req(zb_zigbee_h handle, zb_nwk_addr addr16,
  56         unsigned char start_idx, zb_zdo_mgmt_bind_cb cb, void *user_data)
  57 {
  58         int ret;
  59         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  60         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  61         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  62         ret = zbl_mgmt_bind_req(addr16, start_idx, cb, user_data);
  63         return ret;
  64 }
  65
  66 API int zb_zdo_mgmt_leave_req(zb_zigbee_h handle, zb_ieee_addr addr64,
  67         bool remove_children, bool rejoin, zb_zdo_mgmt_leave_cb cb,
  68         void *user_data)
  69 {
  70         int ret;
  71         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  72         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  73         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  74         RETV_IF(0 == addr64, ZIGBEE_ERROR_INVALID_ADDRESS);
  75         ret = zbl_mgmt_leave_device(addr64, remove_children, rejoin, cb, user_data);
  76         return ret;
  77 }
  78
  79 API int zb_zdo_mgmt_direct_join_req(zb_zigbee_h handle, zb_ieee_addr addr64,
  80         unsigned char capability, zb_zdo_mgmt_direct_join_cb cb, void *user_data)
  81 {
  82         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  83         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  84         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  85         RETV_IF(0 == addr64, ZIGBEE_ERROR_INVALID_ADDRESS);
  86         return ZIGBEE_ERROR_NONE;
  87 }
  88
  89 API int zb_zdo_mgmt_permit_joining_req(zb_zigbee_h handle, zb_nwk_addr addr16,
  90         unsigned char duration, unsigned char tc_significance,
  91         zb_zdo_mgmt_permit_joining_cb cb, void *user_data)
  92 {
  93         int ret;
  94         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
  95         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
  96         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
  97         ret = zbl_mgmt_permit_joining_req(addr16, duration, tc_significance, cb, user_data);
  98         return ret;
  99 }
 100
 101 API int zb_zdo_mgmt_cache_req(zb_zigbee_h handle, zb_nwk_addr addr16,
 102         unsigned char start_idx, zb_zdo_mgmt_cache_cb cb, void *user_data)
 103 {
 104         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 105         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 106         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 107         return ZIGBEE_ERROR_NONE;
 108 }
 109
 110 API int zb_zdo_mgmt_nwk_update_req(zb_zigbee_h handle, unsigned int scan_channels,
 111         unsigned char scan_duration, unsigned char scan_count, unsigned char nwk_update_id,
 112         zb_nwk_addr nwk_manager_addr)
 113 {
 114         int ret;
 115         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 116         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 117         RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
 118         RETV_IF(0 == nwk_manager_addr, ZIGBEE_ERROR_INVALID_ADDRESS);
 119         ret = zbl_mgmt_nwk_update_req(scan_channels, scan_duration, scan_count, nwk_update_id,
 120                 nwk_manager_addr);
 121         return ret;
 122 }
 123
 124 API int zb_network_list_record_get_extended_pan_id(
 125         zb_zdo_network_list_record_h handle, zb_ieee_addr extended_pan_id)
 126 {
 127         struct zb_zdo_network_list_record_s *h = handle;
 128         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 129         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 130         RETV_IF(NULL == extended_pan_id, ZIGBEE_ERROR_INVALID_PARAMETER);
 131
 132         memcpy(extended_pan_id, h->extended_pan_id, sizeof(zb_ieee_addr));
 133         return ZIGBEE_ERROR_NONE;
 134 }
 135
 136 API int zb_network_list_record_get_logical_channel(
 137         zb_zdo_network_list_record_h handle, unsigned char* logical_channel)
 138 {
 139         struct zb_zdo_network_list_record_s *h = handle;
 140         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 141         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 142         RETV_IF(NULL == logical_channel, ZIGBEE_ERROR_INVALID_PARAMETER);
 143
 144         *logical_channel = h->logical_channel;
 145         return ZIGBEE_ERROR_NONE;
 146 }
 147
 148 API int zb_network_list_record_get_zigbee_version(
 149         zb_zdo_network_list_record_h handle, unsigned char* zigbee_version)
 150 {
 151         struct zb_zdo_network_list_record_s *h = handle;
 152         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 153         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 154         RETV_IF(NULL == zigbee_version, ZIGBEE_ERROR_INVALID_PARAMETER);
 155
 156         *zigbee_version = h->zigbee_version;
 157         return ZIGBEE_ERROR_NONE;
 158 }
 159
 160 API int zb_network_list_record_get_stack_profile(
 161         zb_zdo_network_list_record_h handle, unsigned char* stack_profile)
 162 {
 163         struct zb_zdo_network_list_record_s *h = handle;
 164         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 165         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 166         RETV_IF(NULL == stack_profile, ZIGBEE_ERROR_INVALID_PARAMETER);
 167
 168         *stack_profile = h->stack_profile;
 169         return ZIGBEE_ERROR_NONE;
 170 }
 171
 172 API int zb_network_list_record_get_beacon_order(
 173         zb_zdo_network_list_record_h handle, unsigned char* beacon_order)
 174 {
 175         struct zb_zdo_network_list_record_s *h = handle;
 176         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 177         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 178         RETV_IF(NULL == beacon_order, ZIGBEE_ERROR_INVALID_PARAMETER);
 179
 180         *beacon_order = h->beacon_order;
 181         return ZIGBEE_ERROR_NONE;
 182 }
 183
 184 API int zb_network_list_record_get_superframe_order(
 185         zb_zdo_network_list_record_h handle, unsigned char* superframe_order)
 186 {
 187         struct zb_zdo_network_list_record_s *h = handle;
 188         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 189         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 190         RETV_IF(NULL == superframe_order, ZIGBEE_ERROR_INVALID_PARAMETER);
 191
 192         *superframe_order = h->superframe_order;
 193         return ZIGBEE_ERROR_NONE;
 194 }
 195
 196 API int zb_network_list_record_get_permit_joining(
 197         zb_zdo_network_list_record_h handle, unsigned char* permit_joining)
 198 {
 199         struct zb_zdo_network_list_record_s *h = handle;
 200         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 201         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 202         RETV_IF(NULL == permit_joining, ZIGBEE_ERROR_INVALID_PARAMETER);
 203
 204         *permit_joining = h->permit_joining;
 205         return ZIGBEE_ERROR_NONE;
 206 }
 207
 208 API int zb_neighbor_table_desc_get_extended_pan_id(
 209         zb_zdo_neighbor_table_desc_h handle, zb_ieee_addr extended_pan_id)
 210 {
 211         struct zb_zdo_neighbor_table_desc_s *h = handle;
 212         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 213         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 214         RETV_IF(NULL == h->extended_pan_id, ZIGBEE_ERROR_INVALID_PARAMETER);
 215         RETV_IF(NULL == extended_pan_id, ZIGBEE_ERROR_INVALID_PARAMETER);
 216
 217         memcpy(extended_pan_id, h->extended_pan_id, sizeof(zb_ieee_addr));
 218         return ZIGBEE_ERROR_NONE;
 219 }
 220
 221 API int zb_neighbor_table_desc_get_ieee_addr(
 222         zb_zdo_neighbor_table_desc_h handle, zb_ieee_addr addr64)
 223 {
 224         struct zb_zdo_neighbor_table_desc_s *h = handle;
 225         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 226         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 227         RETV_IF(NULL == h->addr64, ZIGBEE_ERROR_INVALID_PARAMETER);
 228         RETV_IF(NULL == addr64, ZIGBEE_ERROR_INVALID_PARAMETER);
 229
 230         memcpy(addr64, h->addr64, sizeof(zb_ieee_addr));
 231         return ZIGBEE_ERROR_NONE;
 232 }
 233
 234 API int zb_neighbor_table_desc_get_nwk_addr(
 235         zb_zdo_neighbor_table_desc_h handle, zb_nwk_addr* addr16)
 236 {
 237         struct zb_zdo_neighbor_table_desc_s *h = handle;
 238         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 239         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 240         RETV_IF(NULL == addr16, ZIGBEE_ERROR_INVALID_PARAMETER);
 241
 242         *addr16 = h->addr16;
 243         return ZIGBEE_ERROR_NONE;
 244 }
 245
 246 API int zb_neighbor_table_desc_get_device_type(
 247         zb_zdo_neighbor_table_desc_h handle, unsigned char* device_type)
 248 {
 249         struct zb_zdo_neighbor_table_desc_s *h = handle;
 250         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 251         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 252         RETV_IF(NULL == device_type, ZIGBEE_ERROR_INVALID_PARAMETER);
 253
 254         *device_type = h->device_type;
 255         return ZIGBEE_ERROR_NONE;
 256 }
 257
 258 API int zb_neighbor_table_desc_get_rx_on_when_idle(
 259         zb_zdo_neighbor_table_desc_h handle, unsigned char* rx_on_when_idle)
 260 {
 261         struct zb_zdo_neighbor_table_desc_s *h = handle;
 262         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 263         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 264         RETV_IF(NULL == rx_on_when_idle, ZIGBEE_ERROR_INVALID_PARAMETER);
 265
 266         *rx_on_when_idle = h->rx_on_when_idle;
 267         return ZIGBEE_ERROR_NONE;
 268 }
 269
 270 API int zb_neighbor_table_desc_get_relationship(
 271         zb_zdo_neighbor_table_desc_h handle, unsigned char* releationship)
 272 {
 273         struct zb_zdo_neighbor_table_desc_s *h = handle;
 274         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 275         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 276         RETV_IF(NULL == releationship, ZIGBEE_ERROR_INVALID_PARAMETER);
 277
 278         *releationship = h->relationship;
 279         return ZIGBEE_ERROR_NONE;
 280 }
 281
 282 API int zb_neighbor_table_desc_get_permit_joining(
 283         zb_zdo_neighbor_table_desc_h handle, unsigned char* permit_joining)
 284 {
 285         struct zb_zdo_neighbor_table_desc_s *h = handle;
 286         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 287         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 288         RETV_IF(NULL == permit_joining, ZIGBEE_ERROR_INVALID_PARAMETER);
 289
 290         *permit_joining = h->permit_joining;
 291         return ZIGBEE_ERROR_NONE;
 292 }
 293
 294 API int zb_neighbor_table_desc_get_depth(
 295         zb_zdo_neighbor_table_desc_h handle, unsigned char* depth)
 296 {
 297         struct zb_zdo_neighbor_table_desc_s *h = handle;
 298         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 299         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 300         RETV_IF(NULL == depth, ZIGBEE_ERROR_INVALID_PARAMETER);
 301
 302         *depth = h->depth;
 303         return ZIGBEE_ERROR_NONE;
 304 }
 305
 306 API int zb_neighbor_table_desc_get_lqi(zb_zdo_neighbor_table_desc_h handle,
 307         unsigned char* lqi)
 308 {
 309         struct zb_zdo_neighbor_table_desc_s *h = handle;
 310         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 311         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 312         RETV_IF(NULL == lqi, ZIGBEE_ERROR_INVALID_PARAMETER);
 313
 314         *lqi = h->lqi;
 315         return ZIGBEE_ERROR_NONE;
 316 }
 317
 318 API int zb_routing_table_get_dst_addr(zb_zdo_routing_table_h handle,
 319         zb_nwk_addr* dst_addr)
 320 {
 321         struct zb_zdo_routing_table_s *h = handle;
 322         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 323         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 324         RETV_IF(NULL == dst_addr, ZIGBEE_ERROR_INVALID_PARAMETER);
 325
 326         *dst_addr = h->dst_addr;
 327         return ZIGBEE_ERROR_NONE;
 328 }
 329
 330 API int zb_routing_table_get_dst_status(zb_zdo_routing_table_h handle,
 331         zb_zdp_status_e *status)
 332 {
 333         struct zb_zdo_routing_table_s *h = handle;
 334         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 335         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 336         RETV_IF(NULL == status, ZIGBEE_ERROR_INVALID_PARAMETER);
 337
 338         *status = h->status;
 339         return ZIGBEE_ERROR_NONE;
 340 }
 341
 342 API int zb_routing_table_get_memory_constrained(
 343         zb_zdo_routing_table_h handle, unsigned char *memory_constrained)
 344 {
 345         struct zb_zdo_routing_table_s *h = handle;
 346         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 347         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 348         RETV_IF(NULL == memory_constrained, ZIGBEE_ERROR_INVALID_PARAMETER);
 349
 350         *memory_constrained = h->memory_constrained;
 351         return ZIGBEE_ERROR_NONE;
 352 }
 353
 354 API int zb_routing_table_get_many_to_one(zb_zdo_routing_table_h handle,
 355         unsigned char *many_to_one)
 356 {
 357         struct zb_zdo_routing_table_s *h = handle;
 358         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 359         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 360         RETV_IF(NULL == many_to_one, ZIGBEE_ERROR_INVALID_PARAMETER);
 361
 362         *many_to_one = h->many_to_one;
 363         return ZIGBEE_ERROR_NONE;
 364 }
 365
 366 API int zb_routing_table_get_route_record_required(
 367         zb_zdo_routing_table_h handle, unsigned char *route_record_required)
 368 {
 369         struct zb_zdo_routing_table_s *h = handle;
 370         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 371         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 372         RETV_IF(NULL == route_record_required, ZIGBEE_ERROR_INVALID_PARAMETER);
 373
 374         *route_record_required = h->route_record_required;
 375         return ZIGBEE_ERROR_NONE;
 376 }
 377
 378 API int zb_routing_table_get_next_hop_addr(
 379         zb_zdo_routing_table_h handle, zb_nwk_addr *next_hop_addr)
 380 {
 381         struct zb_zdo_routing_table_s *h = handle;
 382         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 383         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 384         RETV_IF(NULL == next_hop_addr, ZIGBEE_ERROR_INVALID_PARAMETER);
 385
 386         *next_hop_addr = h->next_hop_addr;
 387         return ZIGBEE_ERROR_NONE;
 388 }
 389
 390 API int zb_binding_table_get_src_addr(zb_zdo_binding_table_h handle,
 391         zb_ieee_addr src_addr)
 392 {
 393         struct zb_zdo_binding_table_s *h = handle;
 394         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 395         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 396         RETV_IF(NULL == src_addr, ZIGBEE_ERROR_INVALID_PARAMETER);
 397
 398         memcpy(src_addr, h->src_addr64, sizeof(zb_ieee_addr));
 399         return ZIGBEE_ERROR_NONE;
 400 }
 401
 402 API int zb_binding_table_get_src_ep(zb_zdo_binding_table_h handle,
 403         unsigned char* src_ep)
 404 {
 405         struct zb_zdo_binding_table_s *h = handle;
 406         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 407         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 408         RETV_IF(NULL == src_ep, ZIGBEE_ERROR_INVALID_PARAMETER);
 409
 410         *src_ep = h->src_ep;
 411         return ZIGBEE_ERROR_NONE;
 412 }
 413
 414 API int zb_binding_table_get_cluster_id(zb_zdo_binding_table_h handle,
 415         unsigned short *clusterid)
 416 {
 417         struct zb_zdo_binding_table_s *h = handle;
 418         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 419         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 420         RETV_IF(NULL == clusterid, ZIGBEE_ERROR_INVALID_PARAMETER);
 421
 422         *clusterid = h->clusterid;
 423         return ZIGBEE_ERROR_NONE;
 424 }
 425
 426 API int zb_binding_table_get_dst_addr_mode(zb_zdo_binding_table_h handle,
 427         unsigned char* dst_addr_mode)
 428 {
 429         struct zb_zdo_binding_table_s *h = handle;
 430         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 431         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 432         RETV_IF(NULL == dst_addr_mode, ZIGBEE_ERROR_INVALID_PARAMETER);
 433
 434         *dst_addr_mode = h->dst_addr_mode;
 435         return ZIGBEE_ERROR_NONE;
 436 }
 437
 438 API int zb_binding_table_get_dst_addr16(zb_zdo_binding_table_h handle,
 439         zb_nwk_addr* addr16)
 440 {
 441         struct zb_zdo_binding_table_s *h = handle;
 442         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 443         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 444         RETV_IF(NULL == addr16, ZIGBEE_ERROR_INVALID_PARAMETER);
 445
 446         *addr16 = h->dst_addr16;
 447         return ZIGBEE_ERROR_NONE;
 448 }
 449
 450 API int zb_binding_table_get_dst_addr64(zb_zdo_binding_table_h handle,
 451         zb_ieee_addr addr64)
 452 {
 453         struct zb_zdo_binding_table_s *h = handle;
 454         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 455         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 456         RETV_IF(NULL == addr64, ZIGBEE_ERROR_INVALID_PARAMETER);
 457
 458         memcpy(addr64, h->dst_addr64, sizeof(zb_ieee_addr));
 459         return ZIGBEE_ERROR_NONE;
 460 }
 461
 462 API int zb_binding_table_get_dst_ep(zb_zdo_binding_table_h handle,
 463         unsigned char* dst_ep)
 464 {
 465         struct zb_zdo_binding_table_s *h = handle;
 466         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 467         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 468         RETV_IF(NULL == dst_ep, ZIGBEE_ERROR_INVALID_PARAMETER);
 469
 470         *dst_ep = h->dst_ep;
 471         return ZIGBEE_ERROR_NONE;
 472 }
 473
 474 API int zb_discovery_cache_get_ieee_addr(zb_zdo_discovery_cache_h handle,
 475         zb_ieee_addr addr64)
 476 {
 477         struct zb_zdo_discovery_cache_s *h = handle;
 478         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 479         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 480         RETV_IF(NULL == addr64, ZIGBEE_ERROR_INVALID_PARAMETER);
 481
 482         memcpy(addr64, h->addr64, sizeof(zb_ieee_addr));
 483         return ZIGBEE_ERROR_NONE;
 484 }
 485
 486 API int zb_discovery_cache_get_nwk_addr(zb_zdo_discovery_cache_h handle,
 487         zb_nwk_addr* addr16)
 488 {
 489         struct zb_zdo_discovery_cache_s *h = handle;
 490         CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
 491         RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
 492         RETV_IF(NULL == addr16, ZIGBEE_ERROR_INVALID_PARAMETER);
 493
 494         *addr16 = h->addr16;
 495         return ZIGBEE_ERROR_NONE;
 496 }
 497
 498