2 * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 #include "zb-common.h"
26 API int zb_ev_get_enable_status(zb_event_data_h ev, zb_error_e* status)
28 zb_event_data_s *event = ev;
29 zb_event_enable_s *enable = NULL;
31 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
38 *status = enable->status;
40 return ZIGBEE_ERROR_NONE;
44 API int zb_ev_get_form_network_panid(zb_event_data_h ev, zb_nwk_addr* pan_id)
46 zb_event_data_s *event = ev;
47 zb_event_form_network_s *form_network = NULL;
49 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
56 *pan_id = form_network->pan_id;
58 return ZIGBEE_ERROR_NONE;
62 API int zb_ev_get_join_count(zb_event_data_h ev, unsigned char* count)
64 zb_event_data_s *event = ev;
65 zb_event_join_s *join = NULL;
67 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
76 return ZIGBEE_ERROR_NONE;
79 API int zb_ev_get_join_ep(zb_event_data_h ev, unsigned char** ep)
81 zb_event_data_s *event = ev;
82 zb_event_join_s *join = NULL;
84 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
91 *ep = calloc(join->count, sizeof(unsigned char));
93 ERR("Couldn't Allocate Memory");
94 return ZIGBEE_ERROR_OUT_OF_MEMORY;
96 memcpy(*ep, join->ep, join->count);
98 return ZIGBEE_ERROR_NONE;
101 API int zb_ev_get_child_left_status(zb_event_data_h ev, zb_error_e* status)
103 zb_event_data_s *event = ev;
104 zb_event_child_left_s *child_left = NULL;
106 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
113 *status = child_left->status;
115 return ZIGBEE_ERROR_NONE;
118 API int zb_ev_get_global_default_rsp_ep(zb_event_data_h ev, unsigned char* ep)
120 zb_event_data_s *event = ev;
121 zb_event_global_default_rsp_s *global_default_rsp = NULL;
123 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
130 *ep = global_default_rsp->ep;
132 return ZIGBEE_ERROR_NONE;
135 API int zb_ev_get_global_default_rsp_cluster_id(zb_event_data_h ev,
136 unsigned short* clusterid)
138 zb_event_data_s *event = ev;
139 zb_event_global_default_rsp_s *global_default_rsp = NULL;
141 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
148 *clusterid = global_default_rsp->clusterid;
150 return ZIGBEE_ERROR_NONE;
153 API int zb_ev_get_global_default_rsp_command_id(zb_event_data_h ev,
154 unsigned char* commandid)
156 zb_event_data_s *event = ev;
157 zb_event_global_default_rsp_s *global_default_rsp = NULL;
159 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
166 *commandid = global_default_rsp->commandid;
168 return ZIGBEE_ERROR_NONE;
171 API int zb_ev_get_global_default_rsp_status(zb_event_data_h ev,
172 zb_zcl_status_e* status)
174 zb_event_data_s *event = ev;
175 zb_event_global_default_rsp_s *global_default_rsp = NULL;
177 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
184 *status = global_default_rsp->status;
186 return ZIGBEE_ERROR_NONE;
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)
193 zb_event_data_s *event = ev;
194 zb_event_global_attr_report_s *global_attr_repor = NULL;
196 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
203 *records = global_attr_repor->records;
204 *count = global_attr_repor->count;
206 return ZIGBEE_ERROR_NONE;
209 API int zb_ev_get_alarm_count(zb_event_data_h ev, unsigned short* count)
211 zb_event_data_s *event = ev;
212 zb_event_alarm_s *alarm = NULL;
214 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
221 *count = alarm->count;
223 return ZIGBEE_ERROR_NONE;
226 API int zb_ev_get_enroll_request_src_ep(zb_event_data_h ev, unsigned char* src_ep)
228 zb_event_data_s *event = ev;
229 zb_event_ias_enroll_request_s* ias_enroll_request = NULL;
231 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
238 *src_ep = ias_enroll_request->src_ep;
240 return ZIGBEE_ERROR_NONE;
243 API int zb_ev_get_enroll_request_zone_type(zb_event_data_h ev,
244 zb_zcl_ias_zone_type_e * zone_type)
246 zb_event_data_s *event = ev;
247 zb_event_ias_enroll_request_s* ias_enroll_request = NULL;
249 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
256 *zone_type = ias_enroll_request->zone_type;
258 return ZIGBEE_ERROR_NONE;
261 API int zb_ev_get_enroll_request_mfg_code(zb_event_data_h ev,
262 unsigned char* mfg_code)
264 zb_event_data_s *event = ev;
265 zb_event_ias_enroll_request_s* ias_enroll_request = NULL;
267 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
274 *mfg_code = ias_enroll_request->mfg_code;
276 return ZIGBEE_ERROR_NONE;
280 API int zb_ev_get_ias_noti_src_ep(zb_event_data_h ev, unsigned char* src_ep)
282 zb_event_data_s *event = ev;
283 zb_event_ias_noti_s* ias_noti = NULL;
285 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
292 *src_ep = ias_noti->src_ep;
294 return ZIGBEE_ERROR_NONE;
297 API int zb_ev_get_ias_noti_zone_status(zb_event_data_h ev,
298 unsigned short* zone_status)
300 zb_event_data_s *event = ev;
301 zb_event_ias_noti_s* ias_noti = NULL;
303 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
310 *zone_status = ias_noti->zone_status;
312 return ZIGBEE_ERROR_NONE;
315 API int zb_ev_get_ias_ext_noti_src_ep(zb_event_data_h ev, unsigned char* src_ep)
317 zb_event_data_s *event = ev;
318 zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
320 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
327 *src_ep = ias_extended_noti->src_ep;
329 return ZIGBEE_ERROR_NONE;
332 API int zb_ev_get_ias_ext_noti_status(zb_event_data_h ev, unsigned char* status)
334 zb_event_data_s *event = ev;
335 zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
337 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
344 *status = ias_extended_noti->status;
346 return ZIGBEE_ERROR_NONE;
349 API int zb_ev_get_ias_ext_noti_zone_status(zb_event_data_h ev,
350 unsigned short* zone_status)
352 zb_event_data_s *event = ev;
353 zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
355 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
362 *zone_status = ias_extended_noti->zone_status;
364 return ZIGBEE_ERROR_NONE;
367 API int zb_ev_get_ias_ext_noti_delay(zb_event_data_h ev, unsigned short* delay)
369 zb_event_data_s *event = ev;
370 zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
372 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
379 *delay = ias_extended_noti->delay;
381 return ZIGBEE_ERROR_NONE;
384 API int zb_ev_get_ias_ext_noti_zone_id(zb_event_data_h ev, unsigned char* zone_id)
386 zb_event_data_s *event = ev;
387 zb_event_ias_extended_noti_s* ias_extended_noti = NULL;
389 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
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);
396 *zone_id = ias_extended_noti->zone_id;
398 return ZIGBEE_ERROR_NONE;
401 API int zb_create(zb_zigbee_h *handle)
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);
410 #if !GLIB_CHECK_VERSION(2, 35, 0)
413 #if !GLIB_CHECK_VERSION(2, 31, 0)
416 ret = zbl_dbus_start(*handle);
417 DBG("zbl_dbus_start()=0x%X", ret);
422 API int zb_destroy(zb_zigbee_h handle)
424 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
425 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
427 zbl_dbus_stop(handle);
428 return ZIGBEE_ERROR_NONE;
431 API int zb_enable(zb_zigbee_h handle)
433 int ret = ZIGBEE_ERROR_NONE;
434 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
435 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
437 ret = zbl_enable(handle);
438 DBG("zbl_enable()=0x%X", ret);
442 API int zb_set_event_cb(zb_zigbee_h handle, zb_event_cb event_handler)
444 int ret = ZIGBEE_ERROR_NONE;
445 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
446 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
448 ret = zbl_set_event_cb(handle, event_handler);
449 DBG("zb_set_event_cb()=0x%X", ret);
453 API int zb_disable(zb_zigbee_h handle)
455 int ret = ZIGBEE_ERROR_NONE;
456 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
457 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
460 DBG("zbl_disable()=0x%X", ret);
464 API int zb_hw_reset(zb_zigbee_h handle)
466 int ret = ZIGBEE_ERROR_NONE;
467 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
468 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
470 ret = zbl_hw_reset();
471 DBG("zbl_hw_reset()=0x%X", ret);
475 API int zb_coex_start(zb_zigbee_h handle, unsigned char channel)
477 int ret = ZIGBEE_ERROR_NONE;
478 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
479 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
481 ret = zbl_coex_start(channel);
482 DBG("zbl_coex_start()=0x%X", ret);
486 API int zb_coex_stop(zb_zigbee_h handle)
488 int ret = ZIGBEE_ERROR_NONE;
489 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
490 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
492 ret = zbl_coex_stop();
493 DBG("zbl_coex_stop()=0x%X", ret);
497 API int zb_form_network(zb_zigbee_h handle, zb_form_network_cb cb, void *user_data)
499 int ret = ZIGBEE_ERROR_NONE;
500 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
501 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
503 ret = zbl_form_network(handle, cb, user_data);
504 DBG("zbl_form_network()=0x%X", ret);
508 API int zb_disable_network(zb_zigbee_h handle, zb_disable_network_cb cb, void *user_data)
510 int ret = ZIGBEE_ERROR_NONE;
511 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
512 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
514 ret = zbl_disable_network(handle, cb, user_data);
515 DBG("zb_disable_network()=0x%X", ret);
519 API int zb_leave_device(zb_zigbee_h handle, zb_ieee_addr addr, bool remove_children, bool rejoin)
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);
526 ret = zbl_leave_device(addr, remove_children, rejoin);
527 DBG("zbl_leave_device()=0x%X", ret);
531 API int zb_permit_join(zb_zigbee_h handle, unsigned char timeout)
533 int ret = ZIGBEE_ERROR_NONE;
534 CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
535 RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
537 ret = zbl_permit_join(timeout, TRUE);
538 DBG("zb_permit_join()=0x%X", ret);
542 API int zb_get_controller_mac_address(zb_zigbee_h handle, zb_ieee_addr addr64)
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);
549 ret = zbl_get_controller_mac_address(addr64);
550 DBG("zbl_get_controller_mac_address()=0x%X", ret);
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)
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);
562 ret = zbl_get_network_info(addr64, nodeid, panid, channel, tx_power);
563 DBG("zbl_get_network_info()=0x%X", ret);
567 API int zb_end_dev_info_list_free(zb_end_dev_info_h *list)
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);
576 while (plist[i]->desc && plist[i]->desc[j]) {
577 free(plist[i]->desc[j]);
581 free(plist[i]->desc);
587 return ZIGBEE_ERROR_NONE;