Fix for SAM score

Change-Id: Iad2b918fe3b4f9e68aa1b6447c0f59376dd4a60a
Signed-off-by: Jihoon Jung <jh8801.jung@samsung.com>

diff --git a/common/zb-common.h b/common/zb-common.h
index 399424db8f417005663c33fed24531bd904a0f74..0956cf798f2ff14220f5b64dcd4fc644a75d455d 100644 (file)
--- a/common/zb-common.h
+++ b/common/zb-common.h
@@ -107,6 +107,21 @@
 
 #define NOT_USED(var) ((var) = (var))
 
+#define CHECK_PRECONDITION(handle, addr16, ep) \
+       do { \
+               CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE); \
+               RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER); \
+               RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR); \
+               RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS); \
+               RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT); \
+       } while (0)
+
+#define CHECK_RECORDS(records, count) \
+       do { \
+               RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER); \
+               RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER); \
+       } while (0)
+
 /*---------------------------------------------------------------------------------------
  * For Event
  *--------------------------------------------------------------------------------------*/

diff --git a/src/zbl-zcl-alarm.c b/src/zbl-zcl-alarm.c
index 905cb426d288cfc65410e2c5f703fb9a35807ca0..490f1f6795130b5a69a410487c7c4d1ab5399104 100644 (file)
--- a/src/zbl-zcl-alarm.c
+++ b/src/zbl-zcl-alarm.c
@@ -21,11 +21,7 @@ API int zb_zcl_alarm_reset_alarm(zb_zigbee_h handle, zb_nwk_addr addr16, unsigne
        unsigned char alarm_code, zb_cluster_id clusterid)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_reset_alarm(addr16, ep, alarm_code, clusterid);
        return ret;
@@ -35,11 +31,7 @@ API int zb_zcl_alarm_reset_all_alarm(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_reset_all_alarm(addr16, ep);
        return ret;
@@ -49,11 +41,7 @@ API int zb_zcl_alarm_get_alarm(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned
        zb_zcl_alarm_get_alarm_cb cb, void *user_data)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_get_alarm(addr16, ep, cb, user_data);
        return ret;
@@ -63,11 +51,7 @@ API int zb_zcl_alarm_reset_all_alarm_log(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_reset_all_alarm_log(addr16, ep);
        return ret;

diff --git a/src/zbl-zcl-basic.c b/src/zbl-zcl-basic.c
index d46187b5850f9b4cd31476e61f800d811563cc53..80a928b5627d48a953c21a57d19521899b7fd6c1 100644 (file)
--- a/src/zbl-zcl-basic.c
+++ b/src/zbl-zcl-basic.c
@@ -21,11 +21,8 @@ API int zb_zcl_basic_reset_factory_default(zb_zigbee_h handle, zb_nwk_addr addr1
        unsigned char ep)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
+
        ret = zbl_reset_factory_default(addr16, ep);
        return ret;
 }

diff --git a/src/zbl-zcl-color-control.c b/src/zbl-zcl-color-control.c
index 1668cdc1906095452e668285bdeb1621aea29db5..99290f10d7e89fc49ffff514f1527832c72b138e 100644 (file)
--- a/src/zbl-zcl-color-control.c
+++ b/src/zbl-zcl-color-control.c
@@ -22,11 +22,7 @@ API int zb_zcl_ccontrol_move_to_hue(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned short transition_time)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_move_to_hue(addr16, ep, hue, direction, transition_time);
        return ret;
@@ -36,11 +32,7 @@ API int zb_zcl_ccontrol_move_hue(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep, unsigned char move_mode, unsigned char rate)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_move_hue(addr16, ep, move_mode, rate);
        return ret;
@@ -51,11 +43,7 @@ API int zb_zcl_ccontrol_step_hue(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char transition_time)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_step_hue(addr16, ep, step_mode, step_size, transition_time);
        return ret;
@@ -66,11 +54,7 @@ API int zb_zcl_ccontrol_move_to_saturation(zb_zigbee_h handle,
        unsigned short transition_time)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_move_to_saturation(addr16, ep, saturation, transition_time);
        return ret;
@@ -80,11 +64,7 @@ API int zb_zcl_ccontrol_move_saturation(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep, unsigned char move_mode, unsigned char rate)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_move_saturation(addr16, ep, move_mode, rate);
        return ret;
@@ -95,11 +75,7 @@ API int zb_zcl_ccontrol_step_saturation(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char transition_time)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_step_saturation(addr16, ep, step_mode, step_size, transition_time);
        return ret;
@@ -110,11 +86,7 @@ API int zb_zcl_ccontrol_move_to_hue_and_saturation(zb_zigbee_h handle,
        unsigned short transition_time)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_move_to_hue_and_saturation(addr16, ep, hue, saturation, transition_time);
        return ret;
@@ -125,11 +97,7 @@ API int zb_zcl_ccontrol_move_to_color(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned short transition_time)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_move_to_color(addr16, ep, color_x, color_y, transition_time);
        return ret;
@@ -139,11 +107,7 @@ API int zb_zcl_ccontrol_move_color(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep, unsigned short rate_x, unsigned short rate_y)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_move_color(addr16, ep, rate_x, rate_y);
        return ret;
@@ -154,11 +118,7 @@ API int zb_zcl_ccontrol_step_color(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned short transition_time)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_step_color(addr16, ep, step_x, step_y, transition_time);
        return ret;
@@ -169,11 +129,7 @@ API int zb_zcl_ccontrol_move_to_color_temperature(zb_zigbee_h handle,
        unsigned short transition_time)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_ccontrol_move_to_color_temperature(addr16, ep, color_temperature, transition_time);
        return ret;

diff --git a/src/zbl-zcl-global-cmd.c b/src/zbl-zcl-global-cmd.c
index 1a57b896cccbaa9001a677b19c60c090fd7e6124..670ace332f570ffe7207b9b77c461cca6daf2f9d 100644 (file)
--- a/src/zbl-zcl-global-cmd.c
+++ b/src/zbl-zcl-global-cmd.c
@@ -26,11 +26,8 @@ API int zb_zcl_global_attr_read(zb_zigbee_h handle, zb_nwk_addr addr16,
        zb_zcl_global_attr_read_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
        RETV_IF(NULL == attribute_ids, ZIGBEE_ERROR_INVALID_PARAMETER);
        RETV_IF(0 == attribute_ids_len, ZIGBEE_ERROR_INVALID_PARAMETER);
        ret = zbl_read_attr_req(handle, addr16, dst_ep, zcl_fc, clusterid,
@@ -46,13 +43,9 @@ API int zb_zcl_global_attr_read_structured(zb_zigbee_h handle, zb_nwk_addr addr1
 #if (0 == ZIGBEE_SUPPORT_ORDERED_SEQUENCE_DATA)
        return ZIGBEE_ERROR_NOT_SUPPORTED;
 #endif
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
-       RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_RECORDS(records, count);
 
        return ZIGBEE_ERROR_NONE;
 }
@@ -63,13 +56,10 @@ API int zb_zcl_global_attr_write(zb_zigbee_h handle, zb_nwk_addr addr16,
        zb_zcl_global_attr_write_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
-       RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_RECORDS(records, count);
+
        ret = zbl_write_attr_req(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, records, count, cb, user_data);
        return ret;
@@ -82,13 +72,10 @@ API int zb_zcl_global_attr_write_undivided(zb_zigbee_h handle,
        zb_zcl_global_attr_write_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
-       RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_RECORDS(records, count);
+
        ret = zbl_wattr_undivided_req(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, records, count, cb, user_data);
        return ret;
@@ -102,13 +89,9 @@ API int zb_zcl_global_attr_write_structured(zb_zigbee_h handle, zb_nwk_addr addr
 #if (0 == ZIGBEE_SUPPORT_ORDERED_SEQUENCE_DATA)
        return ZIGBEE_ERROR_NOT_SUPPORTED;
 #endif
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
-       RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_RECORDS(records, count);
 
        return ZIGBEE_ERROR_NONE;
 }
@@ -118,13 +101,10 @@ API int zb_zcl_global_attr_write_no_rsp(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned short clusterid, zb_zcl_write_attr_record_h *records, int count)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
-       RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_RECORDS(records, count);
+
        ret = zbl_wattr_req_no_cb(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, records, count);
        return ret;
@@ -136,13 +116,10 @@ API int zb_zcl_global_config_report_write(zb_zigbee_h handle, zb_nwk_addr addr16
        zb_zcl_global_config_report_write_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
-       RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_RECORDS(records, count);
+
        ret = zbl_write_config_report(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, records, count, cb, user_data);
        return ret;
@@ -154,13 +131,10 @@ API int zb_zcl_global_config_report_read(zb_zigbee_h handle, zb_nwk_addr addr16,
        int count, zb_zcl_global_config_report_read_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
-       RETV_IF(NULL == records, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(0 == count, ZIGBEE_ERROR_INVALID_PARAMETER);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_RECORDS(records, count);
+
        ret = zbl_read_config_report(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, records, count, cb, user_data);
        return ret;
@@ -172,11 +146,9 @@ API int zb_zcl_global_attr_discover(zb_zigbee_h handle, zb_nwk_addr addr16,
        zb_zcl_global_attr_discover_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+
        ret = zbl_discover_attr_req(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, start_id, max_attribute_ids, cb, user_data);
        return ret;
@@ -188,11 +160,9 @@ API int zb_zcl_global_discover_cmds_received(zb_zigbee_h handle,
        unsigned char max_command_ids, zb_zcl_global_discover_cmds_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+
        ret = zbl_discover_cmds_recv(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, start_command_id, max_command_ids, cb, user_data);
        return ret;
@@ -204,11 +174,9 @@ API int zb_zcl_global_discover_cmds_generated(zb_zigbee_h handle,
        unsigned char max_command_ids, zb_zcl_global_discover_cmds_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+
        ret = zbl_discover_cmds_gen(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, start_command_id, max_command_ids, cb, user_data);
        return ret;
@@ -221,11 +189,9 @@ API int zb_zcl_global_attr_extended_discover(zb_zigbee_h handle,
        void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == src_ep || 0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, src_ep);
+       RETV_IF(0 == dst_ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+
        ret = zbl_discover_attr_ext(handle, addr16, src_ep, dst_ep, zcl_fc,
                        clusterid, start_id, max_attribute_ids, cb, user_data);
        return ret;

diff --git a/src/zbl-zcl-groups.c b/src/zbl-zcl-groups.c
index ae54a921efbc57a807f8b530a5cc60e486a84937..c5e03610fafeb3ce1a0266e7ce046dde3045b201 100644 (file)
--- a/src/zbl-zcl-groups.c
+++ b/src/zbl-zcl-groups.c
@@ -22,11 +22,7 @@ API int zb_zcl_group_add_group(zb_zigbee_h handle, zb_nwk_addr addr16,
        zb_zcl_group_add_group_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        RETV_IF(NULL == group_name, ZIGBEE_ERROR_INVALID_PARAMETER);
        ret = zbl_add_group(addr16, ep, group_id, group_name, cb, user_data);
        return ret;
@@ -37,11 +33,7 @@ API int zb_zcl_group_view_group(zb_zigbee_h handle, zb_nwk_addr addr16,
        void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_view_group(addr16, ep, group_id, cb, user_data);
        return ret;
 }
@@ -51,11 +43,7 @@ API int zb_zcl_group_get_group_membership(zb_zigbee_h handle, zb_nwk_addr addr16
        zb_zcl_group_get_group_membership_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        RETV_IF(NULL == group_list, ZIGBEE_ERROR_INVALID_PARAMETER);
        ret = zbl_group_get_group_membership(addr16, ep, group_count, group_list, cb, user_data);
        return ret;
@@ -66,11 +54,7 @@ API int zb_zcl_group_remove_group(zb_zigbee_h handle, zb_nwk_addr addr16,
        void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_remove_group(addr16, ep, group_id, cb, user_data);
        return ret;
 }
@@ -79,11 +63,7 @@ API int zb_zcl_group_remove_all_group(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_remove_all_group(addr16, ep);
        return ret;
 }
@@ -92,11 +72,7 @@ API int zb_zcl_group_add_group_if_identifying(zb_zigbee_h handle, zb_nwk_addr ad
        unsigned char ep, unsigned short group_id, const char *group_name)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_add_group_if_identifying(addr16, ep, group_id, group_name);
        return ret;
 }

diff --git a/src/zbl-zcl-identify.c b/src/zbl-zcl-identify.c
index 984c725580d3874a96fd9a2b8065d9fb9c59efd6..7b1ee6cdb812e4e3fbdfcc3fc23defeb74ab5a9c 100644 (file)
--- a/src/zbl-zcl-identify.c
+++ b/src/zbl-zcl-identify.c
@@ -21,11 +21,7 @@ API int zb_zcl_identify(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned char ep
        unsigned short identify_time)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_identify(addr16, ep, identify_time);
        return ret;
 }
@@ -34,11 +30,7 @@ API int zb_zcl_identify_query(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned c
        zb_zcl_identify_query_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_identify_query(addr16, ep, cb, user_data);
        return ret;
 }

diff --git a/src/zbl-zcl-isa-zone.c b/src/zbl-zcl-isa-zone.c
index 8d8aa66c8eca28d26ca2ccd7a480a65cf36d95f6..19767321c76ae6e5d8b29eb16beedae23e510d0f 100644 (file)
--- a/src/zbl-zcl-isa-zone.c
+++ b/src/zbl-zcl-isa-zone.c
@@ -21,11 +21,7 @@ API int zb_zcl_zone_enroll_response(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep, unsigned char enroll_response_code, unsigned char zone_id)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_zone_enroll_response(addr16, ep, enroll_response_code, zone_id);
        return ret;
 }

diff --git a/src/zbl-zcl-level-control.c b/src/zbl-zcl-level-control.c
index 24022a9ae32be66a30e5b5a59637218be0e5637c..eb3346e0beaccb7a8ac7f9b949b2a0fe4e4b3759 100644 (file)
--- a/src/zbl-zcl-level-control.c
+++ b/src/zbl-zcl-level-control.c
@@ -21,11 +21,7 @@ API int zb_zcl_levelctrl_move_to_level(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep, unsigned char level, unsigned short transition_time)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_level_control_move_to_level(addr16, ep, level, transition_time);
        return ret;
@@ -35,11 +31,7 @@ API int zb_zcl_levelctrl_move(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep, unsigned char move_mode, unsigned char rate)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_level_control_move(addr16, ep, move_mode, rate);
        return ret;
@@ -49,11 +41,7 @@ API int zb_zcl_levelctrl_step(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned c
        unsigned char step_mode, unsigned char step_size, unsigned short transition_time)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_level_control_step(addr16, ep, step_mode, step_size, transition_time);
        return ret;
@@ -62,11 +50,7 @@ API int zb_zcl_levelctrl_step(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned c
 API int zb_zcl_levelctrl_stop(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned char ep)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_level_control_stop(addr16, ep);
        return ret;
@@ -76,11 +60,7 @@ API int zb_zcl_levelctrl_move_to_level_with_on_off(zb_zigbee_h handle, zb_nwk_ad
        unsigned char ep, unsigned char level, unsigned short transition_time)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_level_control_move_to_level_with_on_off(addr16, ep, level, transition_time);
        return ret;
@@ -90,11 +70,7 @@ API int zb_zcl_levelctrl_move_with_on_off(zb_zigbee_h handle, zb_nwk_addr addr16
        unsigned char ep, unsigned char move_mode, unsigned char rate)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_level_control_move_with_on_off(addr16, ep, move_mode, rate);
        return ret;
@@ -105,11 +81,7 @@ API int zb_zcl_levelctrl_step_with_on_off(zb_zigbee_h handle, zb_nwk_addr addr16
        unsigned short transition_time)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_level_control_step_with_on_off(addr16, ep, step_mode, step_size, transition_time);
        return ret;

diff --git a/src/zbl-zcl-on-off.c b/src/zbl-zcl-on-off.c
index 3999c56d36a702b7ce9ad0779e92546193a9b729..894b9d38a831c8bf41cb92fc28a32d047e65782d 100644 (file)
--- a/src/zbl-zcl-on-off.c
+++ b/src/zbl-zcl-on-off.c
@@ -21,11 +21,7 @@ API int zb_zcl_on_off_control(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned c
        zb_zcl_on_off_e on_off_type)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
 
        ret = zbl_onoff_set(addr16, ep, on_off_type);
        return ret;

diff --git a/src/zbl-zcl-poll-control.c b/src/zbl-zcl-poll-control.c
index 27e634a7f11582014302a25eee4359d2cdb6184a..c6ff158039fc155ed6eab9aa9b87cddddd8fa3be 100644 (file)
--- a/src/zbl-zcl-poll-control.c
+++ b/src/zbl-zcl-poll-control.c
@@ -21,11 +21,7 @@ API int zb_zcl_pollctrl_check_in_response(zb_zigbee_h handle, zb_nwk_addr addr16
        unsigned char ep, unsigned char start_fast_polling, unsigned short fast_poll_timeout)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_pollcontrol_check_in_response(addr16, ep, start_fast_polling,
                fast_poll_timeout);
        return ret;
@@ -35,11 +31,7 @@ API int zb_zcl_pollctrl_fast_poll_stop(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_pollcontrol_fast_poll_stop(addr16, ep);
        return ret;
 }
@@ -49,11 +41,7 @@ API int zb_zcl_pollctrl_set_long_poll_interval(zb_zigbee_h handle,
        zb_zcl_pollctrl_check_in_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_pollcontrol_set_long_poll_interval(addr16, ep, new_long_poll_interval,
                cb, user_data);
        return ret;
@@ -64,11 +52,7 @@ API int zb_zcl_pollctrl_set_short_poll_interval(zb_zigbee_h handle,
        zb_zcl_pollctrl_check_in_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_pollcontrol_set_short_poll_interval(addr16, ep, new_short_poll_interval,
                cb, user_data);
        return ret;

diff --git a/src/zbl-zcl-scenes.c b/src/zbl-zcl-scenes.c
index 190f6df5e83c14911eda4abd059aca217b97011e..8a3db0040d5411b80ab0b093bbf03d1e870c7e8f 100644 (file)
--- a/src/zbl-zcl-scenes.c
+++ b/src/zbl-zcl-scenes.c
@@ -23,11 +23,7 @@ API int zb_zcl_scene_add_scene(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned
        const char *extension_field_sets, zb_zcl_scene_add_scene_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        RETV_IF(NULL == scene_name, ZIGBEE_ERROR_INVALID_PARAMETER);
        RETV_IF(NULL == extension_field_sets, ZIGBEE_ERROR_INVALID_PARAMETER);
        ret = zbl_add_scene(addr16, ep, group_id, scene_id, transition_time, scene_name,
@@ -40,11 +36,7 @@ API int zb_zcl_scene_view_scene(zb_zigbee_h handle, zb_nwk_addr addr16, unsigned
        void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_view_scene(addr16, ep, group_id, scene_id, cb, user_data);
        return ret;
 }
@@ -54,11 +46,7 @@ API int zb_zcl_scene_remove_scene(zb_zigbee_h handle, zb_nwk_addr addr16,
        zb_zcl_scene_remove_scene_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_remove_scene(addr16, ep, group_id, scene_id, cb, user_data);
        return ret;
 }
@@ -68,11 +56,7 @@ API int zb_zcl_scene_remove_all_scene(zb_zigbee_h handle, zb_nwk_addr addr16,
        void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_remove_all_scene(addr16, ep, group_id, cb, user_data);
        return ret;
 }
@@ -82,11 +66,7 @@ API int zb_zcl_scene_store_scene(zb_zigbee_h handle, zb_nwk_addr addr16, unsigne
        void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_store_scene(addr16, ep, group_id, scene_id, cb, user_data);
        return ret;
 }
@@ -95,11 +75,7 @@ API int zb_zcl_scene_recall_scene(zb_zigbee_h handle, zb_nwk_addr addr16,
        unsigned char ep, unsigned short group_id, unsigned char scene_id)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_recall_scene(addr16, ep, group_id, scene_id);
        return ret;
 }
@@ -109,11 +85,7 @@ API int zb_zcl_scene_get_scene_membership(zb_zigbee_h handle, zb_nwk_addr addr16
        zb_zcl_scene_get_scene_membership_cb cb, void *user_data)
 {
        int ret;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
+       CHECK_PRECONDITION(handle, addr16, ep);
        ret = zbl_get_scene_membership(addr16, ep, group_id, cb, user_data);
        return ret;
 }

diff --git a/src/zbl-zcl-thermostat.c b/src/zbl-zcl-thermostat.c
index 09edcd5385928f2134e38d230f21419b34432f2b..f40a483bd315b2b58a270ca5a577a2b42671e2d0 100644 (file)
--- a/src/zbl-zcl-thermostat.c
+++ b/src/zbl-zcl-thermostat.c
@@ -21,12 +21,8 @@ API int zb_zcl_thermostat_adjust_setpoint(zb_zigbee_h handle, zb_nwk_addr addr16
        unsigned char ep, unsigned char mode, unsigned char amount)
 {
        int ret = ZIGBEE_ERROR_NONE;
-       CHECK_FEATURE_SUPPORTED(ZIGBEE_FEATURE);
-       RETV_IF(NULL == handle, ZIGBEE_ERROR_INVALID_PARAMETER);
-       RETV_IF(NULL == zbl_dbus_get_object(), ZIGBEE_ERROR_IO_ERROR);
-       RETV_IF(0 == addr16, ZIGBEE_ERROR_INVALID_ADDRESS);
+       CHECK_PRECONDITION(handle, addr16, ep);
        RETV_IF(0x02 < mode, ZIGBEE_ERROR_PARAMETER_OUT_OF_RANGE);
-       RETV_IF(0 == ep, ZIGBEE_ERROR_INVALID_ENDPOINT);
 
        ret = zbl_thermostat_adjust_setpoint(addr16, ep, mode, amount);
        return ret;