From: hyunuk.tak Date: Tue, 30 Aug 2022 01:57:06 +0000 (+0900) Subject: Refactor for duplication code X-Git-Tag: accepted/tizen/unified/20221115.022354~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c76f302db9656f1229a17543418067be27b3e121;p=platform%2Fcore%2Fapi%2Fsmart-traffic-control.git Refactor for duplication code Change-Id: Ie4217266d6dc8f8833e41ee5d2609a457e201f43 Signed-off-by: hyunuk.tak --- diff --git a/include/stc_mgr_internal.h b/include/stc_mgr_internal.h index c1aef71..5e04c60 100755 --- a/include/stc_mgr_internal.h +++ b/include/stc_mgr_internal.h @@ -185,7 +185,7 @@ int stc_reset_stats(stc_h stc, stc_reset_rule_h rule); * @see stc_get_restriction_type() * @see stc_unset_restriction() */ -int stc_set_restriction(stc_h stc, stc_restriction_rule_h rule); +int stc_set_restriction(stc_h stc, stc_restriction_rule_h rule_h); /** * @brief Unsets the existing restriction for application. @@ -232,7 +232,7 @@ int stc_set_restriction(stc_h stc, stc_restriction_rule_h rule); * @see stc_foreach_restriction() * @see stc_get_restriction_type() */ -int stc_unset_restriction(stc_h stc, stc_restriction_rule_h rule); +int stc_unset_restriction(stc_h stc, stc_restriction_rule_h rule_h); /** * @brief Gets the restriction rule per application. diff --git a/packaging/capi-network-stc.spec b/packaging/capi-network-stc.spec index 7880065..ddeaa4f 100755 --- a/packaging/capi-network-stc.spec +++ b/packaging/capi-network-stc.spec @@ -1,6 +1,6 @@ Name: capi-network-stc Summary: A Smart Traffic Control (STC) libraries in Native API -Version: 0.0.40 +Version: 0.0.41 Release: 1 Group: Network & Connectivity/API License: Apache-2.0 diff --git a/src/include/stc-restriction.h b/src/include/stc-restriction.h index e84608d..f59b8bf 100755 --- a/src/include/stc-restriction.h +++ b/src/include/stc-restriction.h @@ -64,6 +64,24 @@ extern "C" { #define STC_RESTRICTION_LIST_NAME "name" #define STC_RESTRICTION_LIST_STATE "state" +#define STC_VALIDATE_RSTN_RULE(rule) \ + { \ + if (_stc_restriction_check_rule_validity(rule) == false) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + +#define STC_VALIDATE_RSTN_LIST(list) \ + { \ + if (_stc_restriction_check_list_validity(list) == false) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + typedef struct { char app_id[STC_APP_ID_LEN]; char iface_name[STC_IFNAME_LEN]; diff --git a/src/internal/include/stc-private.h b/src/internal/include/stc-private.h index 9059031..a5d6a42 100755 --- a/src/internal/include/stc-private.h +++ b/src/internal/include/stc-private.h @@ -64,12 +64,46 @@ extern "C" { #define STC_LOCK \ do { \ _stc_lock(); \ - } while(0) + } while (0) #define STC_UNLOCK \ do { \ _stc_unlock(); \ - } while(0) + } while (0) + +#define STC_RETURN_VAL_IF_NOT_ERROR_NONE(val) \ + { \ + if (val != STC_ERROR_NONE) { \ + return val; \ + } \ + } + +#define STC_RETURN_VAL_IF(expr, val, fmt, arg...) \ + { \ + if (expr) { \ + STC_LOGE(fmt, ##arg); \ + STC_UNLOCK; \ + return val; \ + } \ + } + +#define STC_VALIDATE_HANDLE(handle) \ + { \ + if (!(_stc_handle_check_validity(handle))) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + +#define STC_VALIDATE_INPUT_PARAMETER(arg) \ + { \ + if (arg == NULL) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } typedef struct { stc_event_handle_info_s event_handle; diff --git a/src/internal/include/stc-util.h b/src/internal/include/stc-util.h index df966e8..76ae0d9 100755 --- a/src/internal/include/stc-util.h +++ b/src/internal/include/stc-util.h @@ -58,13 +58,6 @@ } \ } while (0) -#define STC_RETURN_VAL_IF(expr, val, fmt, arg...) do { \ - if (expr) { \ - STC_LOGE(fmt, ##arg); \ - return val; \ - } \ -} while (0) - #define TIZEN_FEATURE_STC "http://tizen.org/feature/network.traffic_control" #define CHECK_FEATURE_SUPPORTED(feature_name)\ diff --git a/src/stc-firewall.c b/src/stc-firewall.c index 4b55070..3146e08 100755 --- a/src/stc-firewall.c +++ b/src/stc-firewall.c @@ -54,6 +54,42 @@ * Macros and Typedefs *****************************************************************************/ +#define STC_VALIDATE_FW_CHAIN(chain) \ + { \ + if (__stc_fw_check_chain_validity(chain) == false) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + +#define STC_CHECK_FW_CHAIN_CREATED(chain) \ + { \ + if (__stc_fw_check_chain_created(chain) == true) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + +#define STC_VALIDATE_FW_RULE(rule) \ + { \ + if (__stc_fw_check_rule_validity(rule) == false) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + +#define STC_CHECK_FW_RULE_CREATED(chain) \ + { \ + if (__stc_fw_check_rule_created(rule_h) == true) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + /***************************************************************************** * Global Variables *****************************************************************************/ @@ -994,11 +1030,7 @@ EXPORT_API int stc_firewall_lock(stc_h stc) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); ret = _stc_fw_lock(stc); if (ret != STC_ERROR_NONE) { @@ -1022,11 +1054,7 @@ EXPORT_API int stc_firewall_unlock(stc_h stc) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); ret = _stc_fw_unlock(stc); if (ret != STC_ERROR_NONE) { @@ -1050,11 +1078,7 @@ EXPORT_API int stc_firewall_get_lock(stc_h stc, stc_firewall_lock_e *state) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); ret = _stc_fw_get_lock(stc, state); if (ret != STC_ERROR_NONE) { @@ -1077,17 +1101,10 @@ EXPORT_API int stc_firewall_chain_create(stc_h stc, const char *name, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (!chain_h || !name) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(chain_h); + STC_VALIDATE_INPUT_PARAMETER(name); stc_fw_chain_s *fw_chain = MALLOC0(stc_fw_chain_s, 1); if (!fw_chain) { @@ -1114,12 +1131,9 @@ EXPORT_API int stc_firewall_chain_clone(stc_firewall_chain_h origin_h, STC_LOCK; - if (__stc_fw_check_chain_validity(origin_h) == false || - cloned_chain_h == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(origin_h); + + STC_VALIDATE_INPUT_PARAMETER(cloned_chain_h); stc_fw_chain_s *fw_chain = MALLOC0(stc_fw_chain_s, 1); if (!fw_chain) { @@ -1145,11 +1159,7 @@ EXPORT_API int stc_firewall_chain_destroy(stc_firewall_chain_h chain_h) STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); __stc_fw_remove_from_chain_list(chain_h); __stc_fw_deinit_chain(chain_h); @@ -1166,17 +1176,9 @@ EXPORT_API int stc_firewall_chain_get_name(stc_firewall_chain_h chain_h, char ** STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); - if (!name) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(name); stc_fw_chain_s *fw_chain = (stc_fw_chain_s *)chain_h; @@ -1195,17 +1197,9 @@ EXPORT_API int stc_firewall_chain_get_target(stc_firewall_chain_h chain_h, STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); - if (!target) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(target); stc_fw_chain_s *fw_chain = (stc_fw_chain_s *)chain_h; @@ -1224,17 +1218,9 @@ EXPORT_API int stc_firewall_chain_get_priority(stc_firewall_chain_h chain_h, STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); - if (!priority) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(priority); stc_fw_chain_s *fw_chain = (stc_fw_chain_s *)chain_h; @@ -1254,11 +1240,7 @@ EXPORT_API int stc_firewall_chain_add(stc_h stc, stc_firewall_chain_h chain_h) STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); if (__stc_fw_check_chain_created(chain_h) == false) { STC_LOGE("Invalid parameter"); @@ -1286,17 +1268,9 @@ EXPORT_API int stc_firewall_chain_remove(stc_h stc, stc_firewall_chain_h chain_h STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); - if (__stc_fw_check_chain_created(chain_h) == true) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_CHECK_FW_CHAIN_CREATED(chain_h); ret = _stc_fw_chain_remove(stc, (stc_fw_chain_s *)chain_h); if (ret != STC_ERROR_NONE) { @@ -1318,17 +1292,9 @@ EXPORT_API int stc_firewall_chain_flush(stc_h stc, stc_firewall_chain_h chain_h) STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); - if (__stc_fw_check_chain_created(chain_h) == true) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_CHECK_FW_CHAIN_CREATED(chain_h); ret = _stc_fw_chain_flush(stc, (stc_fw_chain_s *)chain_h); if (ret != STC_ERROR_NONE) { @@ -1351,18 +1317,11 @@ EXPORT_API int stc_firewall_chain_foreach(stc_h stc, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); STC_UNLOCK; - if (callback == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(callback); ret = _stc_fw_chain_foreach(stc, callback, user_data); if (ret != STC_ERROR_NONE) { @@ -1383,17 +1342,9 @@ EXPORT_API int stc_firewall_chain_set(stc_h stc, stc_firewall_chain_h chain_h, STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); - if (__stc_fw_check_chain_created(chain_h) == true) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_CHECK_FW_CHAIN_CREATED(chain_h); __stc_fw_set_chain(chain_h, target); @@ -1417,17 +1368,9 @@ EXPORT_API int stc_firewall_chain_unset(stc_h stc, stc_firewall_chain_h chain_h) STC_LOCK; - if (__stc_fw_check_chain_validity(chain_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_CHAIN(chain_h); - if (__stc_fw_check_chain_created(chain_h) == true) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_CHECK_FW_CHAIN_CREATED(chain_h); ret = _stc_fw_chain_unset(stc, (stc_fw_chain_s *)chain_h); if (ret != STC_ERROR_NONE) { @@ -1447,17 +1390,9 @@ EXPORT_API int stc_firewall_rule_create(stc_h stc, stc_firewall_rule_h *rule_h) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (!rule_h) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(rule_h); stc_fw_rule_s *fw_rule = MALLOC0(stc_fw_rule_s, 1); if (!fw_rule) { @@ -1484,12 +1419,9 @@ EXPORT_API int stc_firewall_rule_clone(stc_firewall_rule_h origin_h, STC_LOCK; - if (__stc_fw_check_rule_validity(origin_h) == false || - cloned_rule_h == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(origin_h); + + STC_VALIDATE_INPUT_PARAMETER(cloned_rule_h); stc_fw_rule_s *fw_rule = MALLOC0(stc_fw_rule_s, 1); if (!fw_rule) { @@ -1515,11 +1447,7 @@ EXPORT_API int stc_firewall_rule_destroy(stc_firewall_rule_h rule_h) STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); __stc_fw_remove_from_rule_list(rule_h); __stc_fw_deinit_rule(rule_h); @@ -1536,11 +1464,7 @@ EXPORT_API int stc_firewall_rule_set_chain(stc_firewall_rule_h rule_h, char *cha STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); if (!chain || strlen(chain) == 0) { STC_LOGE("Invalid parameter"); @@ -1566,17 +1490,10 @@ EXPORT_API int stc_firewall_rule_set_direction(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (direction > STC_FIREWALL_DIRECTION_OUT) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_RETURN_VAL_IF(direction > STC_FIREWALL_DIRECTION_OUT, + STC_ERROR_INVALID_PARAMETER, "Invalid parameter"); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1595,17 +1512,10 @@ EXPORT_API int stc_firewall_rule_set_src_ip_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (type > STC_FIREWALL_IP_RANGE) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_RETURN_VAL_IF(type > STC_FIREWALL_IP_RANGE, + STC_ERROR_INVALID_PARAMETER, "Invalid parameter"); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1624,17 +1534,10 @@ EXPORT_API int stc_firewall_rule_set_dst_ip_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (type > STC_FIREWALL_IP_RANGE) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_RETURN_VAL_IF(type > STC_FIREWALL_IP_RANGE, + STC_ERROR_INVALID_PARAMETER, "Invalid parameter"); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1653,17 +1556,10 @@ EXPORT_API int stc_firewall_rule_set_src_port_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (type > STC_FIREWALL_PORT_RANGE) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_RETURN_VAL_IF(type > STC_FIREWALL_PORT_RANGE, + STC_ERROR_INVALID_PARAMETER, "Invalid parameter"); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1682,17 +1578,10 @@ EXPORT_API int stc_firewall_rule_set_dst_port_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (type > STC_FIREWALL_PORT_RANGE) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_RETURN_VAL_IF(type > STC_FIREWALL_PORT_RANGE, + STC_ERROR_INVALID_PARAMETER, "Invalid parameter"); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1711,17 +1600,10 @@ EXPORT_API int stc_firewall_rule_set_protocol_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (type > STC_FIREWALL_PROTOCOL_ALL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_RETURN_VAL_IF(type > STC_FIREWALL_PROTOCOL_ALL, + STC_ERROR_INVALID_PARAMETER, "Invalid parameter"); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1740,17 +1622,10 @@ EXPORT_API int stc_firewall_rule_set_family_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (type > STC_FIREWALL_FAMILY_V6) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_RETURN_VAL_IF(type > STC_FIREWALL_FAMILY_V6, + STC_ERROR_INVALID_PARAMETER, "Invalid parameter"); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1769,11 +1644,7 @@ EXPORT_API int stc_firewall_rule_set_src_ip(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1795,11 +1666,7 @@ EXPORT_API int stc_firewall_rule_set_dst_ip(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1821,11 +1688,7 @@ EXPORT_API int stc_firewall_rule_set_src_port(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1845,11 +1708,7 @@ EXPORT_API int stc_firewall_rule_set_dst_port(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1868,11 +1727,7 @@ EXPORT_API int stc_firewall_rule_set_ifname(stc_firewall_rule_h rule_h, char *if STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1892,11 +1747,7 @@ EXPORT_API int stc_firewall_rule_set_target(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1916,11 +1767,7 @@ EXPORT_API int stc_firewall_rule_set_log_level(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1939,11 +1786,7 @@ EXPORT_API int stc_firewall_rule_set_log_prefix(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1963,11 +1806,7 @@ EXPORT_API int stc_firewall_rule_set_nflog_group(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -1986,11 +1825,7 @@ EXPORT_API int stc_firewall_rule_set_nflog_prefix(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2010,11 +1845,7 @@ EXPORT_API int stc_firewall_rule_set_nflog_range(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2033,11 +1864,7 @@ EXPORT_API int stc_firewall_rule_set_nflog_threshold(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2055,17 +1882,9 @@ EXPORT_API int stc_firewall_rule_get_chain(stc_firewall_rule_h rule_h, char **ch STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!chain) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(chain); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2084,17 +1903,9 @@ EXPORT_API int stc_firewall_rule_get_direction(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!direction) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(direction); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2113,17 +1924,9 @@ EXPORT_API int stc_firewall_rule_get_src_ip_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!type) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(type); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2142,17 +1945,9 @@ EXPORT_API int stc_firewall_rule_get_dst_ip_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!type) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(type); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2171,17 +1966,9 @@ EXPORT_API int stc_firewall_rule_get_src_port_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!type) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(type); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2200,17 +1987,9 @@ EXPORT_API int stc_firewall_rule_get_dst_port_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!type) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(type); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2229,17 +2008,9 @@ EXPORT_API int stc_firewall_rule_get_protocol_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!type) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(type); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2258,17 +2029,9 @@ EXPORT_API int stc_firewall_rule_get_family_type(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!type) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(type); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2287,17 +2050,10 @@ EXPORT_API int stc_firewall_rule_get_src_ip(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!ip1 || !ip2) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(ip1); + STC_VALIDATE_INPUT_PARAMETER(ip2); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2317,17 +2073,10 @@ EXPORT_API int stc_firewall_rule_get_dst_ip(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!ip1 || !ip2) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(ip1); + STC_VALIDATE_INPUT_PARAMETER(ip2); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2347,17 +2096,10 @@ EXPORT_API int stc_firewall_rule_get_src_port(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!port1 || !port2) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(port1); + STC_VALIDATE_INPUT_PARAMETER(port2); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2377,17 +2119,10 @@ EXPORT_API int stc_firewall_rule_get_dst_port(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!port1 || !port2) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(port1); + STC_VALIDATE_INPUT_PARAMETER(port2); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2406,17 +2141,9 @@ EXPORT_API int stc_firewall_rule_get_ifname(stc_firewall_rule_h rule_h, char **i STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!ifname) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(ifname); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2435,17 +2162,9 @@ EXPORT_API int stc_firewall_rule_get_target(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!target) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(target); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2464,17 +2183,9 @@ EXPORT_API int stc_firewall_rule_get_log_level(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!level) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(level); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2493,17 +2204,9 @@ EXPORT_API int stc_firewall_rule_get_log_prefix(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!prefix) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(prefix); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2522,17 +2225,9 @@ EXPORT_API int stc_firewall_rule_get_nflog_group(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!group) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(group); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2551,17 +2246,9 @@ EXPORT_API int stc_firewall_rule_get_nflog_prefix(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!prefix) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(prefix); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2580,17 +2267,9 @@ EXPORT_API int stc_firewall_rule_get_nflog_range(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!range) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(range); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2609,17 +2288,9 @@ EXPORT_API int stc_firewall_rule_get_nflog_threshold(stc_firewall_rule_h rule_h, STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (!threshold) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(threshold); stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h; @@ -2639,11 +2310,7 @@ EXPORT_API int stc_firewall_rule_add(stc_h stc, stc_firewall_rule_h rule_h) STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); if (__stc_fw_check_rule_created(rule_h) == false) { STC_LOGE("Invalid parameter"); @@ -2671,17 +2338,9 @@ EXPORT_API int stc_firewall_rule_remove(stc_h stc, stc_firewall_rule_h rule_h) STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (__stc_fw_check_rule_created(rule_h) == true) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_CHECK_FW_RULE_CREATED(rule_h); ret = _stc_fw_rule_remove(stc, (stc_fw_rule_s *)rule_h); if (ret != STC_ERROR_NONE) { @@ -2703,17 +2362,9 @@ EXPORT_API int stc_firewall_rule_update(stc_h stc, stc_firewall_rule_h rule_h) STC_LOCK; - if (__stc_fw_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_FW_RULE(rule_h); - if (__stc_fw_check_rule_created(rule_h) == true) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_CHECK_FW_RULE_CREATED(rule_h); ret = _stc_fw_rule_update(stc, (stc_fw_rule_s *)rule_h); if (ret != STC_ERROR_NONE) { @@ -2735,18 +2386,11 @@ EXPORT_API int stc_firewall_rule_foreach(stc_h stc, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); STC_UNLOCK; - if (callback == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(callback); ret = _stc_fw_rule_foreach(stc, callback, user_data); if (ret != STC_ERROR_NONE) { @@ -2757,3 +2401,4 @@ EXPORT_API int stc_firewall_rule_foreach(stc_h stc, return STC_ERROR_NONE; } +//LCOV_EXCL_STOP \ No newline at end of file diff --git a/src/stc-info.c b/src/stc-info.c index 67d06c2..822860d 100755 --- a/src/stc-info.c +++ b/src/stc-info.c @@ -66,10 +66,8 @@ EXPORT_API int stc_stats_info_clone(stc_stats_info_h info, stc_stats_info_h *clo { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL || cloned == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); + STC_VALIDATE_INPUT_PARAMETER(cloned); stc_stats_info_s *stats_info = MALLOC0(stc_stats_info_s, 1); if (!stats_info) { @@ -102,10 +100,7 @@ EXPORT_API int stc_stats_info_destroy(stc_stats_info_h info) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); FREE(info); @@ -118,10 +113,8 @@ EXPORT_API int stc_stats_info_get_app_id(stc_stats_info_h info, char **app_id) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL || app_id == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); + STC_VALIDATE_INPUT_PARAMETER(app_id); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; @@ -139,10 +132,8 @@ EXPORT_API int stc_stats_info_get_iface_name(stc_stats_info_h info, char **iface { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL || iface_name == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); + STC_VALIDATE_INPUT_PARAMETER(iface_name); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; @@ -162,10 +153,8 @@ EXPORT_API int stc_stats_info_get_subscriber_id(stc_stats_info_h info, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL || subscriber_id == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); + STC_VALIDATE_INPUT_PARAMETER(subscriber_id); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; @@ -185,10 +174,7 @@ EXPORT_API int stc_stats_info_get_time_interval(stc_stats_info_h info, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; @@ -206,10 +192,7 @@ EXPORT_API int stc_stats_info_get_iface_type(stc_stats_info_h info, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; @@ -227,10 +210,7 @@ EXPORT_API int stc_stats_info_get_counter(stc_stats_info_h info, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; @@ -249,10 +229,7 @@ EXPORT_API int stc_stats_info_get_roaming_type(stc_stats_info_h info, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; @@ -270,10 +247,7 @@ EXPORT_API int stc_stats_info_get_protocol_type(stc_stats_info_h info, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; @@ -291,10 +265,7 @@ EXPORT_API int stc_stats_info_get_process_state(stc_stats_info_h info, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(info); stc_stats_info_s *stats_info = (stc_stats_info_s *)info; diff --git a/src/stc-manager.c b/src/stc-manager.c index 969c1da..83d322f 100755 --- a/src/stc-manager.c +++ b/src/stc-manager.c @@ -56,6 +56,17 @@ * Macros and Typedefs *****************************************************************************/ +#define STC_VALIDATE_RESTRICTION_RULE(rule) \ + { \ + ret = _stc_restriction_validate_rule(rule); \ + if (ret != STC_ERROR_NONE) { \ + STC_LOGE("Invalid restriction rule [%s]", \ + _stc_convert_error_type_to_string(ret)); \ + STC_UNLOCK; \ + return ret; \ + } \ + } + /***************************************************************************** * Global Variables *****************************************************************************/ @@ -149,11 +160,7 @@ EXPORT_API int stc_reset_stats(stc_h stc, stc_reset_rule_h rule) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); ret = _stc_reset_check_rule(rule); if (ret != STC_ERROR_NONE) { @@ -187,17 +194,9 @@ EXPORT_API int stc_get_stats(stc_h stc, stc_stats_rule_h rule, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER;//LCOV_EXCL_LINE - } + STC_VALIDATE_HANDLE(stc); - if (info_cb == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_INPUT_PARAMETER(info_cb); ret = _stc_stats_check_get_rule(rule); if (ret != STC_ERROR_NONE) { @@ -231,17 +230,9 @@ EXPORT_API int stc_foreach_stats(stc_h stc, stc_stats_rule_h rule, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_HANDLE(stc); - if (info_cb == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_INPUT_PARAMETER(info_cb); ret = _stc_stats_check_get_all_rule(rule); if (ret != STC_ERROR_NONE) { @@ -275,17 +266,9 @@ int stc_get_all_stats(stc_h stc, stc_stats_rule_h rule, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_HANDLE(stc); - if (finished_cb == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_INPUT_PARAMETER(finished_cb); ret = _stc_stats_check_get_all_rule(rule); if (ret != STC_ERROR_NONE) { @@ -318,11 +301,7 @@ int stc_foreach_all_stats(stc_all_stats_info_h info, STC_LOCK; - if (info_cb == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_INPUT_PARAMETER(info_cb); ret = _stc_stats_foreach_all(info, info_cb, user_data); if (ret != STC_ERROR_NONE) { @@ -345,17 +324,9 @@ EXPORT_API int stc_get_total_stats(stc_h stc, stc_stats_rule_h rule, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_HANDLE(stc); - if (info_cb == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_INPUT_PARAMETER(info_cb); ret = _stc_stats_check_get_total_rule(rule); if (ret != STC_ERROR_NONE) { @@ -382,7 +353,7 @@ EXPORT_API int stc_get_total_stats(stc_h stc, stc_stats_rule_h rule, //LCOV_EXCL_START EXPORT_API int stc_set_restriction(stc_h stc, - stc_restriction_rule_h rule) + stc_restriction_rule_h rule_h) { int ret = STC_ERROR_NONE; @@ -390,27 +361,11 @@ EXPORT_API int stc_set_restriction(stc_h stc, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - ret = _stc_restriction_validate_rule(rule); - if (ret != STC_ERROR_NONE) { - STC_LOGE("Invalid restriction rule [%s]", - _stc_convert_error_type_to_string(ret)); - STC_UNLOCK; - return ret; - } + STC_VALIDATE_HANDLE(stc); + STC_VALIDATE_RSTN_RULE(rule_h); + STC_VALIDATE_RESTRICTION_RULE(rule_h); - ret = _stc_restriction_set(stc, rule); + ret = _stc_restriction_set(stc, rule_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to set restriction [%s]", _stc_convert_error_type_to_string(ret)); @@ -422,7 +377,7 @@ EXPORT_API int stc_set_restriction(stc_h stc, return STC_ERROR_NONE; } -EXPORT_API int stc_unset_restriction(stc_h stc, stc_restriction_rule_h rule) +EXPORT_API int stc_unset_restriction(stc_h stc, stc_restriction_rule_h rule_h) { int ret = STC_ERROR_NONE; @@ -430,27 +385,11 @@ EXPORT_API int stc_unset_restriction(stc_h stc, stc_restriction_rule_h rule) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - ret = _stc_restriction_validate_rule(rule); - if (ret != STC_ERROR_NONE) { - STC_LOGE("Invalid restriction rule [%s]", - _stc_convert_error_type_to_string(ret)); - STC_UNLOCK; - return ret; - } + STC_VALIDATE_HANDLE(stc); + STC_VALIDATE_RSTN_RULE(rule_h); + STC_VALIDATE_RESTRICTION_RULE(rule_h); - ret = _stc_restriction_unset(stc, rule); + ret = _stc_restriction_unset(stc, rule_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to unset restriction [%s]", _stc_convert_error_type_to_string(ret)); @@ -471,23 +410,10 @@ EXPORT_API int stc_get_restriction(stc_h stc, stc_restriction_rule_h rule, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); + STC_VALIDATE_RSTN_RULE(rule); - if (rule_cb == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(rule_cb); ret = _stc_restriction_check_get_rule(rule); if (ret != STC_ERROR_NONE) { @@ -519,17 +445,9 @@ EXPORT_API int stc_set_restriction_threshold_crossed_cb(stc_h stc, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (crossed_cb == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(crossed_cb); _stc_callback_set_restriction_threshold_crossed(stc, crossed_cb, user_data); @@ -543,11 +461,7 @@ EXPORT_API int stc_unset_restriction_threshold_crossed_cb(stc_h stc) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); _stc_callback_set_restriction_threshold_crossed(stc, NULL, NULL); @@ -562,17 +476,9 @@ EXPORT_API int stc_set_warn_threshold_crossed_cb(stc_h stc, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (crossed_cb == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(crossed_cb); _stc_callback_set_warn_threshold_crossed(stc, crossed_cb, user_data); @@ -586,11 +492,7 @@ EXPORT_API int stc_unset_warn_threshold_crossed_cb(stc_h stc) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); _stc_callback_set_warn_threshold_crossed(stc, NULL, NULL); @@ -607,23 +509,10 @@ EXPORT_API int stc_foreach_restriction(stc_h stc, stc_restriction_rule_h rule, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); + STC_VALIDATE_RSTN_RULE(rule); - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (rule_cb == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(rule_cb); ret = _stc_restriction_check_get_all_rule(rule); if (ret != STC_ERROR_NONE) { @@ -657,17 +546,8 @@ EXPORT_API int stc_get_restriction_type(stc_h stc, stc_restriction_rule_h rule, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); + STC_VALIDATE_RSTN_RULE(rule); ret = _stc_restriction_check_get_type_rule(rule); if (ret != STC_ERROR_NONE) { @@ -700,25 +580,9 @@ EXPORT_API int stc_add_restriction_rule_to_list(stc_restriction_list_h list_h, STC_LOCK; - if (_stc_restriction_check_list_validity(list_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (_stc_restriction_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - ret = _stc_restriction_validate_rule(rule_h); - if (ret != STC_ERROR_NONE) { - STC_LOGE("Invalid restriction rule [%s]", - _stc_convert_error_type_to_string(ret)); - STC_UNLOCK; - return ret; - } + STC_VALIDATE_RSTN_LIST(list_h); + STC_VALIDATE_RSTN_RULE(rule_h); + STC_VALIDATE_RESTRICTION_RULE(rule_h); if (_stc_restriction_add_rule_to_list(list_h, rule_h) == false) { STC_LOGE("Failed to add restriction rule to list[%s]", @@ -742,25 +606,9 @@ EXPORT_API int stc_remove_restriction_rule_from_list(stc_restriction_list_h list STC_LOCK; - if (_stc_restriction_check_list_validity(list_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (_stc_restriction_check_rule_validity(rule_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - ret = _stc_restriction_validate_rule(rule_h); - if (ret != STC_ERROR_NONE) { - STC_LOGE("Invalid restriction rule [%s]", - _stc_convert_error_type_to_string(ret)); - STC_UNLOCK; - return ret; - } + STC_VALIDATE_RSTN_LIST(list_h); + STC_VALIDATE_RSTN_RULE(rule_h); + STC_VALIDATE_RESTRICTION_RULE(rule_h); if (_stc_restriction_remove_rule_from_list(list_h, rule_h) == false) { STC_LOGE("Failed to remove restriction rule from list[%s]", @@ -784,18 +632,11 @@ EXPORT_API int stc_foreach_restriction_rule_from_list(stc_restriction_list_h lis STC_LOCK; - if (_stc_restriction_check_list_validity(list_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_LIST(list_h); STC_UNLOCK; - if (rule_cb == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(rule_cb); ret = _stc_restriction_foreach_rule_from_list(list_h, rule_cb, user_data); if (ret != STC_ERROR_NONE) { @@ -815,17 +656,9 @@ EXPORT_API int stc_set_restriction_list(stc_h stc, stc_restriction_list_h list_h STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (_stc_restriction_check_list_validity(list_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_LIST(list_h); ret = _stc_restriction_set_list(stc, list_h); if (ret != STC_ERROR_NONE) { @@ -847,17 +680,9 @@ EXPORT_API int stc_unset_restriction_list(stc_h stc, stc_restriction_list_h list STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (_stc_restriction_check_list_validity(list_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_LIST(list_h); ret = _stc_restriction_unset_list(stc, list_h); if (ret != STC_ERROR_NONE) { @@ -880,17 +705,9 @@ EXPORT_API int stc_iptables_commit(stc_h stc, const char *option, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (option == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(option); ret = _stc_iptables_commit(stc, option, err_num, err_str); if (ret != STC_ERROR_NONE) { @@ -913,17 +730,9 @@ EXPORT_API int stc_ip6tables_commit(stc_h stc, const char *option, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (option == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(option); ret = _stc_ip6tables_commit(stc, option, err_num, err_str); if (ret != STC_ERROR_NONE) { diff --git a/src/stc-pcap.c b/src/stc-pcap.c index 2c3cb7b..6c5950d 100755 --- a/src/stc-pcap.c +++ b/src/stc-pcap.c @@ -53,6 +53,24 @@ * Macros and Typedefs *****************************************************************************/ +#define STC_VALIDATE_PCAP(pcap) \ + { \ + if (__stc_pcap_check_validity(pcap) == false) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + +#define STC_CHECK_PCAP_PARAM(pcap) \ + { \ + if (__stc_pcap_check_param(pcap) == false) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + /***************************************************************************** * Global Variables *****************************************************************************/ @@ -456,11 +474,7 @@ EXPORT_API int stc_pcap_create(stc_h stc, stc_pcap_h *pcap_h) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); if (!pcap_h) { STC_LOGE("Invalid parameter"); @@ -492,11 +506,7 @@ EXPORT_API int stc_pcap_destroy(stc_pcap_h pcap_h) STC_LOCK; - if (__stc_pcap_check_validity(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_PCAP(pcap_h); __stc_pcap_remove_from_list(pcap_h); __stc_pcap_deinit(pcap_h); @@ -515,23 +525,9 @@ EXPORT_API int stc_pcap_start(stc_h stc, stc_pcap_h pcap_h) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (__stc_pcap_check_validity(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (__stc_pcap_check_param(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); + STC_VALIDATE_PCAP(pcap_h); + STC_CHECK_PCAP_PARAM(pcap_h); ret = _stc_pcap_start(stc, (stc_pcap_s *)pcap_h); if (ret != STC_ERROR_NONE) { @@ -553,23 +549,9 @@ EXPORT_API int stc_pcap_stop(stc_h stc, stc_pcap_h pcap_h) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (__stc_pcap_check_validity(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } - - if (__stc_pcap_check_param(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); + STC_VALIDATE_PCAP(pcap_h); + STC_CHECK_PCAP_PARAM(pcap_h); ret = _stc_pcap_stop(stc, (stc_pcap_s *)pcap_h); if (ret != STC_ERROR_NONE) { @@ -592,18 +574,11 @@ EXPORT_API int stc_pcap_foreach(stc_h stc, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); STC_UNLOCK; - if (callback == NULL) { - STC_LOGE("Invalid parameter"); - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(callback); ret = _stc_pcap_foreach(stc, callback, user_data); if (ret != STC_ERROR_NONE) { @@ -624,17 +599,9 @@ EXPORT_API int stc_pcap_find_all_devs(stc_h stc, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (callback == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(callback); _stc_pcap_set_callback(stc, callback, user_data); @@ -656,11 +623,7 @@ EXPORT_API int stc_pcap_set_ifname(stc_pcap_h pcap_h, char *ifname) STC_LOCK; - if (__stc_pcap_check_validity(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_PCAP(pcap_h); stc_pcap_s *pcap = (stc_pcap_s *)pcap_h; @@ -679,11 +642,7 @@ EXPORT_API int stc_pcap_set_nflog_group(stc_pcap_h pcap_h, int group) STC_LOCK; - if (__stc_pcap_check_validity(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_PCAP(pcap_h); stc_pcap_s *pcap = (stc_pcap_s *)pcap_h; @@ -701,11 +660,7 @@ EXPORT_API int stc_pcap_get_ifname(stc_pcap_h pcap_h, char **ifname) STC_LOCK; - if (__stc_pcap_check_validity(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_PCAP(pcap_h); if (!ifname) { STC_LOGE("Invalid parameter"); @@ -729,11 +684,7 @@ EXPORT_API int stc_pcap_get_nflog_group(stc_pcap_h pcap_h, int *group) STC_LOCK; - if (__stc_pcap_check_validity(pcap_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_PCAP(pcap_h); if (!group) { STC_LOGE("Invalid parameter"); diff --git a/src/stc-reset.c b/src/stc-reset.c index 0ebfc0c..cb16a29 100755 --- a/src/stc-reset.c +++ b/src/stc-reset.c @@ -53,6 +53,15 @@ * Macros and Typedefs *****************************************************************************/ +#define STC_VALIDATE_RESET_RULE(rule) \ + { \ + if (__stc_reset_check_rule_validity(rule) == false) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + /***************************************************************************** * Global Variables *****************************************************************************/ @@ -192,17 +201,9 @@ EXPORT_API int stc_reset_rule_create(stc_h stc, stc_reset_rule_h *rule) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (rule == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(rule); stc_reset_rule_s *reset_rule = g_try_malloc0(sizeof(stc_reset_rule_s)); if (reset_rule == NULL) { @@ -227,11 +228,7 @@ EXPORT_API int stc_reset_rule_destroy(stc_reset_rule_h rule) STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); __stc_reset_remove_rule(rule); __stc_reset_deinit_rule(rule); @@ -248,11 +245,7 @@ EXPORT_API int stc_reset_rule_set_app_id(stc_reset_rule_h rule, const char *app_ STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); stc_reset_rule_s *reset_rule = rule; @@ -274,11 +267,7 @@ EXPORT_API int stc_reset_rule_set_subscriber_id(stc_reset_rule_h rule, STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); stc_reset_rule_s *reset_rule = rule; @@ -300,11 +289,7 @@ EXPORT_API int stc_reset_rule_set_iface_type(stc_reset_rule_h rule, STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); stc_reset_rule_s *reset_rule = rule; @@ -337,11 +322,7 @@ EXPORT_API int stc_reset_rule_set_time_interval(stc_reset_rule_h rule, STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); if (from < 0 || to < 0) { STC_LOGE("Invalid parameter"); @@ -366,17 +347,9 @@ EXPORT_API int stc_reset_rule_get_app_id(stc_reset_rule_h rule, char **app_id) STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); - if (app_id == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(app_id); stc_reset_rule_s *reset_rule = (stc_reset_rule_s *)rule; @@ -399,17 +372,9 @@ EXPORT_API int stc_reset_rule_get_subscriber_id(stc_reset_rule_h rule, STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); - if (subscriber_id == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(subscriber_id); stc_reset_rule_s *reset_rule = (stc_reset_rule_s *)rule; @@ -432,11 +397,7 @@ EXPORT_API int stc_reset_rule_get_iface_type(stc_reset_rule_h rule, STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); stc_reset_rule_s *reset_rule = (stc_reset_rule_s *)rule; @@ -455,11 +416,7 @@ EXPORT_API int stc_reset_rule_get_time_interval(stc_reset_rule_h rule, STC_LOCK; - if (__stc_reset_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RESET_RULE(rule); stc_reset_rule_s *reset_rule = (stc_reset_rule_s *)rule; diff --git a/src/stc-restriction.c b/src/stc-restriction.c index a073c59..6e47911 100755 --- a/src/stc-restriction.c +++ b/src/stc-restriction.c @@ -599,7 +599,8 @@ bool _stc_restriction_check_list_validity(stc_restriction_list_h list_h) return false; } -stc_error_e _stc_restriction_set_list(stc_h stc, stc_restriction_list_h list_h) +stc_error_e _stc_restriction_list_invoke_dbus(stc_h stc, + stc_restriction_list_h list_h, const char *dbus_method) { GVariant *message = NULL; GVariant *params = NULL; @@ -616,7 +617,7 @@ stc_error_e _stc_restriction_set_list(stc_h stc, stc_restriction_list_h list_h) STC_MANAGER_SERVICE, STC_MANAGER_RESTRICTION_PATH, STC_MANAGER_RESTRICTION_INTERFACE, - STC_MANAGER_METHOD_RESTRICTION_SET_LIST, + dbus_method, params, &error); @@ -624,127 +625,86 @@ stc_error_e _stc_restriction_set_list(stc_h stc, stc_restriction_list_h list_h) error, "Failed to invoke dbus method"); g_variant_get(message, "(i)", &result); - STC_LOGI("Successfully set restriction list [%d]", result); + STC_LOGI("Successfully %s restriction list [%d]", dbus_method, result); g_variant_unref(message); return STC_ERROR_NONE; } -stc_error_e _stc_restriction_unset_list(stc_h stc, stc_restriction_list_h list_h) +stc_error_e _stc_restriction_set_list(stc_h stc, stc_restriction_list_h list_h) { - GVariant *message = NULL; - GVariant *params = NULL; - GVariantBuilder *builder = NULL; - stc_error_e error = STC_ERROR_NONE; - int result = 0; - - builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}")); - __stc_restriction_list_foreach(list_h, builder); - params = g_variant_new("(aa{sv})", builder); - g_variant_builder_unref(builder); - - message = _stc_dbus_invoke_method(stc, - STC_MANAGER_SERVICE, - STC_MANAGER_RESTRICTION_PATH, - STC_MANAGER_RESTRICTION_INTERFACE, - STC_MANAGER_METHOD_RESTRICTION_UNSET_LIST, - params, - &error); + return _stc_restriction_list_invoke_dbus(stc, list_h, + STC_MANAGER_METHOD_RESTRICTION_SET_LIST); +} - STC_RETURN_VAL_IF(message == NULL, - error, "Failed to invoke dbus method"); +stc_error_e _stc_restriction_unset_list(stc_h stc, stc_restriction_list_h list_h) +{ + return _stc_restriction_list_invoke_dbus(stc, list_h, + STC_MANAGER_METHOD_RESTRICTION_UNSET_LIST); +} - g_variant_get(message, "(i)", &result); - STC_LOGI("Successfully unset restriction list [%d]", result); - g_variant_unref(message); +static stc_error_e __stc_restriction_validate_rule( + stc_restriction_rule_s *restriction_rule) +{ + STC_RETURN_VAL_IF(restriction_rule == NULL, + STC_ERROR_INVALID_PARAMETER, + "Restriction rule should be set"); return STC_ERROR_NONE; } -stc_error_e _stc_restriction_validate_rule( - stc_restriction_rule_h rule) - +static stc_error_e __stc_restriction_validate_rule_app_id( + stc_restriction_rule_s *restriction_rule) { - stc_restriction_rule_s *restriction_rule = rule; - - STC_RETURN_VAL_IF(restriction_rule == NULL, + STC_RETURN_VAL_IF(restriction_rule->app_id[0] == '\0', STC_ERROR_INVALID_PARAMETER, - "Restriction rule should be set"); + "Application ID is required argument"); + + return STC_ERROR_NONE; +} +static stc_error_e __stc_restriction_validate_rule_rstn_type( + stc_restriction_rule_s *restriction_rule) +{ STC_RETURN_VAL_IF(restriction_rule->rstn_type < STC_RSTN_TYPE_UNKNOWN || restriction_rule->rstn_type >= STC_RSTN_TYPE_LAST_ELEM, STC_ERROR_INVALID_PARAMETER, "Invalid restriction type"); - STC_RETURN_VAL_IF(restriction_rule->app_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Application ID is required argument"); + return STC_ERROR_NONE; +} +static stc_error_e __stc_restriction_validate_rule_iface_type( + stc_restriction_rule_s *restriction_rule) +{ STC_RETURN_VAL_IF(restriction_rule->iface_type <= STC_IFACE_UNKNOWN || restriction_rule->iface_type > STC_IFACE_ALL, STC_ERROR_INVALID_PARAMETER, "Invalid restriction network interface type [%s]", _stc_convert_iface_type_to_string(restriction_rule->iface_type)); - if (restriction_rule->rstn_type == STC_RSTN_TYPE_DROP) { - STC_RETURN_VAL_IF(restriction_rule->data_limit < -1, - STC_ERROR_INVALID_PARAMETER, - "Invalid data limit [%"PRId64"] bytes", - restriction_rule->data_limit); - - STC_RETURN_VAL_IF(restriction_rule->data_warn_limit < -1, - STC_ERROR_INVALID_PARAMETER, - "Invalid data warn limit [%"PRId64"] bytes", - restriction_rule->data_warn_limit); - - STC_RETURN_VAL_IF(restriction_rule->monthly_limit < -1, - STC_ERROR_INVALID_PARAMETER, - "Invalid monthly limit [%"PRId64"] bytes", - restriction_rule->monthly_limit); - - STC_RETURN_VAL_IF(restriction_rule->weekly_limit < -1, - STC_ERROR_INVALID_PARAMETER, - "Invalid weekly limit [%"PRId64"] bytes", - restriction_rule->weekly_limit); - - STC_RETURN_VAL_IF(restriction_rule->daily_limit < -1, - STC_ERROR_INVALID_PARAMETER, - "Invalid daily limit [%"PRId64"] bytes", - restriction_rule->daily_limit); - - STC_RETURN_VAL_IF(restriction_rule->month_start_date < 0, - STC_ERROR_INVALID_PARAMETER, - "Invalid month start date [%d]", - restriction_rule->month_start_date); - } - - STC_RETURN_VAL_IF(restriction_rule->roaming_type > STC_ROAMING_DISABLED, - STC_ERROR_INVALID_PARAMETER, - "Roaming type is not valid [%s]", - _stc_convert_roaming_to_string(restriction_rule->roaming_type)); - return STC_ERROR_NONE; } -stc_error_e _stc_restriction_check_set_rule( - stc_restriction_rule_h rule) +static stc_error_e __stc_restriction_validate_rule_data_limit( + stc_restriction_rule_s *restriction_rule) { - stc_restriction_rule_s *restriction_rule = rule; - - STC_RETURN_VAL_IF(restriction_rule == NULL, + STC_RETURN_VAL_IF(restriction_rule->data_limit < 0, STC_ERROR_INVALID_PARAMETER, - "Restriction rule should be set"); + "Invalid tx limit [%"PRId64"] bytes", + restriction_rule->data_limit); - STC_RETURN_VAL_IF(restriction_rule->app_id[0] == '\0', + STC_RETURN_VAL_IF(restriction_rule->data_warn_limit < 0, STC_ERROR_INVALID_PARAMETER, - "Application ID is required argument"); + "Invalid rx limit [%"PRId64"] bytes", + restriction_rule->data_warn_limit); - STC_RETURN_VAL_IF(restriction_rule->iface_type <= STC_IFACE_UNKNOWN || - restriction_rule->iface_type > STC_IFACE_ALL, - STC_ERROR_INVALID_PARAMETER, - "Invalid restriction network interface type [%s]", - _stc_convert_iface_type_to_string(restriction_rule->iface_type)); + return STC_ERROR_NONE; +} +static stc_error_e __stc_restriction_validate_rule_limit( + stc_restriction_rule_s *restriction_rule) +{ STC_RETURN_VAL_IF(restriction_rule->data_limit < -1, STC_ERROR_INVALID_PARAMETER, "Invalid data limit [%"PRId64"] bytes", @@ -770,16 +730,34 @@ stc_error_e _stc_restriction_check_set_rule( "Invalid daily limit [%"PRId64"] bytes", restriction_rule->daily_limit); + return STC_ERROR_NONE; +} + +static stc_error_e __stc_restriction_validate_rule_month_start_date( + stc_restriction_rule_s *restriction_rule) +{ STC_RETURN_VAL_IF(restriction_rule->month_start_date < 0, STC_ERROR_INVALID_PARAMETER, "Invalid month start date [%d]", restriction_rule->month_start_date); + return STC_ERROR_NONE; +} + +static stc_error_e __stc_restriction_validate_rule_roaming_type( + stc_restriction_rule_s *restriction_rule) +{ STC_RETURN_VAL_IF(restriction_rule->roaming_type > STC_ROAMING_DISABLED, STC_ERROR_INVALID_PARAMETER, "Roaming type is not valid [%s]", _stc_convert_roaming_to_string(restriction_rule->roaming_type)); + return STC_ERROR_NONE; +} + +static stc_error_e __stc_restriction_validate_rule_subscriber_id( + stc_restriction_rule_s *restriction_rule) +{ STC_RETURN_VAL_IF(restriction_rule->subscriber_id[0] == '\0', STC_ERROR_INVALID_PARAMETER, "Subscriber ID is not valid"); @@ -787,105 +765,88 @@ stc_error_e _stc_restriction_check_set_rule( return STC_ERROR_NONE; } -stc_error_e _stc_restriction_check_get_rule( - stc_restriction_rule_h rule) +stc_error_e _stc_restriction_validate_rule( + stc_restriction_rule_h rule) { stc_restriction_rule_s *restriction_rule = rule; - STC_RETURN_VAL_IF(restriction_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Restriction rule should be set"); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_rstn_type(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_app_id(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_iface_type(restriction_rule)); - STC_RETURN_VAL_IF(restriction_rule->app_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Application ID is required argument"); + if (restriction_rule->rstn_type == STC_RSTN_TYPE_DROP) { + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_limit(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_month_start_date(restriction_rule)); + } - STC_RETURN_VAL_IF(restriction_rule->iface_type <= STC_IFACE_UNKNOWN || - restriction_rule->iface_type > STC_IFACE_ALL, - STC_ERROR_INVALID_PARAMETER, - "Invalid restriction network interface type [%d]", - restriction_rule->iface_type); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_roaming_type(restriction_rule)); return STC_ERROR_NONE; } -stc_error_e _stc_restriction_check_get_all_rule( +stc_error_e _stc_restriction_check_set_rule( stc_restriction_rule_h rule) { stc_restriction_rule_s *restriction_rule = rule; - STC_RETURN_VAL_IF(restriction_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Restriction rule should be set"); - - STC_RETURN_VAL_IF(restriction_rule->iface_type <= STC_IFACE_UNKNOWN || - restriction_rule->iface_type > STC_IFACE_ALL, - STC_ERROR_INVALID_PARAMETER, - "Invalid restriction network interface type [%d]", - restriction_rule->iface_type); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_app_id(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_iface_type(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_limit(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_month_start_date(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_roaming_type(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_subscriber_id(restriction_rule)); return STC_ERROR_NONE; } -stc_error_e _stc_restriction_check_get_type_rule( +stc_error_e _stc_restriction_check_get_rule( stc_restriction_rule_h rule) { stc_restriction_rule_s *restriction_rule = rule; - STC_RETURN_VAL_IF(restriction_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Restriction rule should be set"); - - STC_RETURN_VAL_IF(restriction_rule->app_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Application ID is required argument"); - - STC_RETURN_VAL_IF(restriction_rule->iface_type <= STC_IFACE_UNKNOWN || - restriction_rule->iface_type > STC_IFACE_ALL, - STC_ERROR_INVALID_PARAMETER, - "Invalid restriction network interface type [%d]", - restriction_rule->iface_type); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_app_id(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_iface_type(restriction_rule)); return STC_ERROR_NONE; } -stc_error_e _stc_restriction_check_remove_rule( +stc_error_e _stc_restriction_check_get_all_rule( stc_restriction_rule_h rule) { stc_restriction_rule_s *restriction_rule = rule; - STC_RETURN_VAL_IF(restriction_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Restriction rule should be set"); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_iface_type(restriction_rule)); - STC_RETURN_VAL_IF(restriction_rule->app_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Application ID is required argument"); + return STC_ERROR_NONE; +} - STC_RETURN_VAL_IF(restriction_rule->iface_type <= STC_IFACE_UNKNOWN || - restriction_rule->iface_type > STC_IFACE_ALL, - STC_ERROR_INVALID_PARAMETER, - "Invalid restriction network interface type [%d]", - restriction_rule->iface_type); +stc_error_e _stc_restriction_check_get_type_rule( + stc_restriction_rule_h rule) +{ + stc_restriction_rule_s *restriction_rule = rule; - STC_RETURN_VAL_IF(restriction_rule->data_limit < 0, - STC_ERROR_INVALID_PARAMETER, - "Invalid tx limit [%"PRId64"] bytes", - restriction_rule->data_limit); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_app_id(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_iface_type(restriction_rule)); - STC_RETURN_VAL_IF(restriction_rule->data_warn_limit < 0, - STC_ERROR_INVALID_PARAMETER, - "Invalid rx limit [%"PRId64"] bytes", - restriction_rule->data_warn_limit); + return STC_ERROR_NONE; +} - STC_RETURN_VAL_IF(restriction_rule->roaming_type > STC_ROAMING_DISABLED, - STC_ERROR_INVALID_PARAMETER, - "Roaming type is not valid [%d]", - restriction_rule->roaming_type); +stc_error_e _stc_restriction_check_remove_rule( + stc_restriction_rule_h rule) +{ + stc_restriction_rule_s *restriction_rule = rule; - STC_RETURN_VAL_IF(restriction_rule->subscriber_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Subscriber ID is not valid"); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_app_id(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_iface_type(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_data_limit(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_roaming_type(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_subscriber_id(restriction_rule)); return STC_ERROR_NONE; } @@ -895,38 +856,12 @@ stc_error_e _stc_restriction_check_exclude_rule( { stc_restriction_rule_s *restriction_rule = rule; - STC_RETURN_VAL_IF(restriction_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Restriction rule should be set"); - - STC_RETURN_VAL_IF(restriction_rule->app_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Application ID is required argument"); - - STC_RETURN_VAL_IF(restriction_rule->iface_type <= STC_IFACE_UNKNOWN || - restriction_rule->iface_type > STC_IFACE_ALL, - STC_ERROR_INVALID_PARAMETER, - "Invalid restriction network interface type [%d]", - restriction_rule->iface_type); - - STC_RETURN_VAL_IF(restriction_rule->data_limit < 0, - STC_ERROR_INVALID_PARAMETER, - "Invalid tx limit [%"PRId64"] bytes", - restriction_rule->data_limit); - - STC_RETURN_VAL_IF(restriction_rule->data_warn_limit < 0, - STC_ERROR_INVALID_PARAMETER, - "Invalid rx limit [%"PRId64"] bytes", - restriction_rule->data_warn_limit); - - STC_RETURN_VAL_IF(restriction_rule->roaming_type > STC_ROAMING_DISABLED, - STC_ERROR_INVALID_PARAMETER, - "Roaming type is not valid [%d]", - restriction_rule->roaming_type); - - STC_RETURN_VAL_IF(restriction_rule->subscriber_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Subscriber ID is not valid"); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_app_id(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_iface_type(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_data_limit(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_roaming_type(restriction_rule)); + STC_RETURN_VAL_IF_NOT_ERROR_NONE(__stc_restriction_validate_rule_subscriber_id(restriction_rule)); return STC_ERROR_NONE; } @@ -1096,17 +1031,9 @@ EXPORT_API int stc_restriction_rule_create(stc_h stc, stc_restriction_rule_h *ru STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (rule == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(rule); stc_restriction_rule_s *restriction_rule = g_try_malloc0(sizeof(stc_restriction_rule_s)); @@ -1132,11 +1059,7 @@ EXPORT_API int stc_restriction_rule_destroy(stc_restriction_rule_h rule) STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); _stc_restriction_remove_rule(rule); __stc_restriction_deinit_rule(rule); @@ -1154,11 +1077,7 @@ EXPORT_API int stc_restriction_rule_set_app_id(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1182,11 +1101,7 @@ EXPORT_API int stc_restriction_rule_set_iface_name(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1209,11 +1124,7 @@ EXPORT_API int stc_restriction_rule_set_iface_type(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1247,11 +1158,7 @@ EXPORT_API int stc_restriction_rule_set_type(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1282,11 +1189,7 @@ EXPORT_API int stc_restriction_rule_set_limit(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1306,11 +1209,7 @@ EXPORT_API int stc_restriction_rule_set_warning_limit(stc_restriction_rule_h rul STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1331,11 +1230,7 @@ EXPORT_API int stc_restriction_rule_set_monthly_limit(stc_restriction_rule_h rul STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1356,11 +1251,7 @@ EXPORT_API int stc_restriction_rule_set_weekly_limit(stc_restriction_rule_h rule STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1381,11 +1272,7 @@ EXPORT_API int stc_restriction_rule_set_daily_limit(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1406,11 +1293,7 @@ EXPORT_API int stc_restriction_rule_set_month_start_date(stc_restriction_rule_h STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1431,11 +1314,7 @@ EXPORT_API int stc_restriction_rule_set_roaming_type(stc_restriction_rule_h rule STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1465,11 +1344,7 @@ EXPORT_API int stc_restriction_rule_set_subscriber_id(stc_restriction_rule_h rul STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1491,17 +1366,9 @@ EXPORT_API int stc_restriction_rule_get_app_id(stc_restriction_rule_h rule, char STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (app_id == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(app_id); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1525,17 +1392,9 @@ EXPORT_API int stc_restriction_rule_get_iface_name(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (iface_name == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(iface_name); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1559,11 +1418,7 @@ EXPORT_API int stc_restriction_rule_get_iface_type(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1583,11 +1438,7 @@ EXPORT_API int stc_restriction_rule_get_type(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1607,17 +1458,9 @@ EXPORT_API int stc_restriction_rule_get_limit(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (data_limit == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(data_limit); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1637,17 +1480,9 @@ EXPORT_API int stc_restriction_rule_get_warning_limit(stc_restriction_rule_h rul STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (data_warn_limit == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(data_warn_limit); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1667,17 +1502,9 @@ EXPORT_API int stc_restriction_rule_get_monthly_limit(stc_restriction_rule_h rul STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (limit == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(limit); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1697,17 +1524,9 @@ EXPORT_API int stc_restriction_rule_get_weekly_limit(stc_restriction_rule_h rule STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (limit == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(limit); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1727,17 +1546,9 @@ EXPORT_API int stc_restriction_rule_get_daily_limit(stc_restriction_rule_h rule, STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (limit == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(limit); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1757,17 +1568,9 @@ EXPORT_API int stc_restriction_rule_get_month_start_date(stc_restriction_rule_h STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (date == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(date); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1787,11 +1590,7 @@ EXPORT_API int stc_restriction_rule_get_roaming_type(stc_restriction_rule_h rule STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1812,17 +1611,9 @@ EXPORT_API int stc_restriction_rule_get_subscriber_id(stc_restriction_rule_h rul STC_LOCK; - if (_stc_restriction_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_RULE(rule); - if (subscriber_id == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(subscriber_id); stc_restriction_rule_s *restriction_rule = (stc_restriction_rule_s *)rule; @@ -1846,17 +1637,9 @@ EXPORT_API int stc_restriction_list_create(stc_h stc, STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); - if (list_h == NULL) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_INPUT_PARAMETER(list_h); stc_restriction_list_s *restriction_list = g_try_malloc0(sizeof(stc_restriction_list_s)); @@ -1882,11 +1665,7 @@ EXPORT_API int stc_restriction_list_destroy(stc_restriction_list_h list_h) STC_LOCK; - if (_stc_restriction_check_list_validity(list_h) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_RSTN_LIST(list_h); _stc_restriction_remove_from_list(list_h); diff --git a/src/stc-statistics.c b/src/stc-statistics.c index 432d1af..aac8809 100755 --- a/src/stc-statistics.c +++ b/src/stc-statistics.c @@ -54,6 +54,15 @@ * Macros and Typedefs *****************************************************************************/ +#define STC_VALIDATE_STATS_RULE(rule) \ + { \ + if (__stc_stats_check_rule_validity(rule) == false) { \ + STC_LOGE("Invalid parameter"); \ + STC_UNLOCK; \ + return STC_ERROR_INVALID_PARAMETER; \ + } \ + } + /***************************************************************************** * Global Variables *****************************************************************************/ @@ -77,14 +86,9 @@ static void __stc_stats_deinit_rule(stc_stats_rule_h rule) FREE(rule); } -static void __stc_stats_get_make_params( - stc_stats_rule_h rule, GVariant **params) +static void __stc_stats_make_param_interval(GVariantBuilder *builder, + stc_stats_rule_s *stats_rule) { - GVariantBuilder *builder; - stc_stats_rule_s *stats_rule = rule; - - builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); - g_variant_builder_add(builder, "{sv}", STC_STATS_RULE_INTERVAL_FROM, g_variant_new_uint64(stats_rule->interval.from)); @@ -92,18 +96,48 @@ static void __stc_stats_get_make_params( g_variant_builder_add(builder, "{sv}", STC_STATS_RULE_INTERVAL_TO, g_variant_new_uint64(stats_rule->interval.to)); +} +static void __stc_stats_make_param_iface_type(GVariantBuilder *builder, + stc_stats_rule_s *stats_rule) +{ if (stats_rule->iface_type != STC_IFACE_UNKNOWN) { g_variant_builder_add(builder, "{sv}", STC_STATS_RULE_IFTYPE, g_variant_new_uint16(stats_rule->iface_type)); } +} +static void __stc_stats_make_param_time_period(GVariantBuilder *builder, + stc_stats_rule_s *stats_rule) +{ if (stats_rule->time_period != STC_TIME_PERIOD_UNKNOWN) { g_variant_builder_add(builder, "{sv}", STC_STATS_RULE_TIME_PERIOD, g_variant_new_int32(stats_rule->time_period)); } +} + +static void __stc_stats_make_param_app_id(GVariantBuilder *builder, + stc_stats_rule_s *stats_rule) +{ + if (strlen(stats_rule->app_id) > 0) { + g_variant_builder_add(builder, "{sv}", + STC_STATS_RULE_APP_ID, + g_variant_new_string(stats_rule->app_id)); + } +} + +static void __stc_stats_get_make_params( + stc_stats_rule_h rule, GVariant **params) +{ + GVariantBuilder *builder; + stc_stats_rule_s *stats_rule = rule; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + __stc_stats_make_param_interval(builder, stats_rule); + __stc_stats_make_param_iface_type(builder, stats_rule); + __stc_stats_make_param_time_period(builder, stats_rule); *params = g_variant_new("(s@a{sv})", stats_rule->app_id, g_variant_builder_end(builder)); @@ -118,32 +152,10 @@ static void __stc_stats_get_all_make_params( stc_stats_rule_s *stats_rule = rule; builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); - - g_variant_builder_add(builder, "{sv}", - STC_STATS_RULE_INTERVAL_FROM, - g_variant_new_uint64(stats_rule->interval.from)); - - g_variant_builder_add(builder, "{sv}", - STC_STATS_RULE_INTERVAL_TO, - g_variant_new_uint64(stats_rule->interval.to)); - - if (stats_rule->iface_type != STC_IFACE_UNKNOWN) { - g_variant_builder_add(builder, "{sv}", //LCOV_EXCL_LINE - STC_STATS_RULE_IFTYPE, - g_variant_new_uint16(stats_rule->iface_type)); - } - - if (stats_rule->time_period != STC_TIME_PERIOD_UNKNOWN) { - g_variant_builder_add(builder, "{sv}", //LCOV_EXCL_LINE - STC_STATS_RULE_TIME_PERIOD, - g_variant_new_int32(stats_rule->time_period)); - } - - if (strlen(stats_rule->app_id) > 0) { - g_variant_builder_add(builder, "{sv}", - STC_STATS_RULE_APP_ID, - g_variant_new_string(stats_rule->app_id)); - } + __stc_stats_make_param_interval(builder, stats_rule); + __stc_stats_make_param_iface_type(builder, stats_rule); + __stc_stats_make_param_time_period(builder, stats_rule); + __stc_stats_make_param_app_id(builder, stats_rule); *params = g_variant_new("(@a{sv})", g_variant_builder_end(builder)); @@ -157,26 +169,9 @@ static void __stc_stats_get_total_make_params( stc_stats_rule_s *stats_rule = rule; builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); - - g_variant_builder_add(builder, "{sv}", - STC_STATS_RULE_INTERVAL_FROM, - g_variant_new_uint64(stats_rule->interval.from)); - - g_variant_builder_add(builder, "{sv}", - STC_STATS_RULE_INTERVAL_TO, - g_variant_new_uint64(stats_rule->interval.to)); - - if (stats_rule->iface_type != STC_IFACE_UNKNOWN) { - g_variant_builder_add(builder, "{sv}", //LCOV_EXCL_LINE - STC_STATS_RULE_IFTYPE, - g_variant_new_uint16(stats_rule->iface_type)); - } - - if (stats_rule->time_period != STC_TIME_PERIOD_UNKNOWN) { - g_variant_builder_add(builder, "{sv}", //LCOV_EXCL_LINE - STC_STATS_RULE_TIME_PERIOD, - g_variant_new_int32(stats_rule->time_period)); - } + __stc_stats_make_param_interval(builder, stats_rule); + __stc_stats_make_param_iface_type(builder, stats_rule); + __stc_stats_make_param_time_period(builder, stats_rule); *params = g_variant_new("(s@a{sv})", "", g_variant_builder_end(builder)); @@ -274,8 +269,8 @@ static void __stc_stats_print_info(stc_stats_info_s *info) } //LCOV_EXCL_STOP -static void __stc_stats_get_per_app_id_reply( - GObject *source_object, GAsyncResult *res, gpointer user_data) +static void __stc_stats_reply(GObject *source_object, GAsyncResult *res, + gpointer user_data, stc_request_table_e request_table, stc_event_e event) { GDBusConnection *conn = NULL; GError *dbus_error = NULL; @@ -296,8 +291,8 @@ static void __stc_stats_get_per_app_id_reply( g_error_free(dbus_error); //LCOV_EXCL_LINE } - if (_stc_event_get_request_table_state(STC_REQUEST_TABLE_STATS_GET)) - _stc_event_set_request_table_state(STC_REQUEST_TABLE_STATS_GET, false); + if (_stc_event_get_request_table_state(request_table)) + _stc_event_set_request_table_state(request_table, false); if (error == STC_ERROR_NONE) { g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); @@ -321,20 +316,20 @@ static void __stc_stats_get_per_app_id_reply( g_variant_iter_free(iter); event_data->handle = stc_handle; - event_data->event = STC_EVENT_STATS_GET_RSP; + event_data->event = event; event_data->info_data = (GSList *)stats_list; event_data->datalength = g_slist_length(stats_list); event_data->error = dbus_result; } } else { //LCOV_EXCL_START - STC_LOGE("Get stats per app id response error [%s]", + STC_LOGE("Get stats response error [%s]", _stc_convert_error_type_to_string(error)); event_data = g_try_malloc0(sizeof(stc_event_info_s)); if (event_data != NULL) { event_data->handle = stc_handle; - event_data->event = STC_EVENT_STATS_GET_RSP; + event_data->event = event; event_data->info_data = NULL; event_data->datalength = 0; event_data->error = error; @@ -346,220 +341,32 @@ static void __stc_stats_get_per_app_id_reply( g_free(event_data); } -static void __stc_stats_foreach_reply( +static void __stc_stats_get_per_app_id_reply( GObject *source_object, GAsyncResult *res, gpointer user_data) { - GDBusConnection *conn = NULL; - GError *dbus_error = NULL; - GVariant *dbus_data = NULL; - GVariantIter *iter = NULL; - GVariantIter *iter_row = NULL; - stc_error_e dbus_result = STC_ERROR_NONE; - stc_error_e error = STC_ERROR_NONE; - stc_stats_info_s *stats_info = NULL; - GSList *stats_list = NULL; - stc_event_info_s *event_data = NULL; - stc_handle_s *stc_handle = (stc_handle_s *)user_data; - - conn = G_DBUS_CONNECTION(source_object); - dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); - if (dbus_error != NULL) { - error = _stc_convert_error_string_to_enum(dbus_error->message); //LCOV_EXCL_LINE - g_error_free(dbus_error); //LCOV_EXCL_LINE - } - - if (_stc_event_get_request_table_state(STC_REQUEST_TABLE_STATS_FOREACH)) - _stc_event_set_request_table_state(STC_REQUEST_TABLE_STATS_FOREACH, false); - - if (error == STC_ERROR_NONE) { - g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); - - event_data = g_try_malloc0(sizeof(stc_event_info_s)); - if (event_data != NULL) { - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); - if (stats_info != NULL) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_stats_extract_info_cb, stats_info); - - __stc_stats_print_info(stats_info); - - stats_list = g_slist_append(stats_list, - (stc_stats_info_s *)stats_info); - - g_variant_iter_free(iter_row); - } - } - g_variant_iter_free(iter); - - event_data->handle = stc_handle; - event_data->event = STC_EVENT_STATS_FOREACH_RSP; - event_data->info_data = (GSList *)stats_list; - event_data->datalength = g_slist_length(stats_list); - event_data->error = dbus_result; - } - } else { - //LCOV_EXCL_START - STC_LOGE("Get stats all response error [%s]", - _stc_convert_error_type_to_string(error)); - - event_data = g_try_malloc0(sizeof(stc_event_info_s)); - if (event_data != NULL) { - event_data->handle = stc_handle; - event_data->event = STC_EVENT_STATS_FOREACH_RSP; - event_data->info_data = NULL; - event_data->datalength = 0; - event_data->error = error; - } - //LCOV_EXCL_STOP - } + __stc_stats_reply(source_object, res, user_data, + STC_REQUEST_TABLE_STATS_GET, STC_EVENT_STATS_GET_RSP); +} - stc_handle->event_handle.event_callback(event_data, user_data); - g_free(event_data); +static void __stc_stats_foreach_reply( + GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + __stc_stats_reply(source_object, res, user_data, + STC_REQUEST_TABLE_STATS_FOREACH, STC_EVENT_STATS_FOREACH_RSP); } static void __stc_stats_get_all_reply( GObject *source_object, GAsyncResult *res, gpointer user_data) { - GDBusConnection *conn = NULL; - GError *dbus_error = NULL; - GVariant *dbus_data = NULL; - GVariantIter *iter = NULL; - GVariantIter *iter_row = NULL; - stc_error_e dbus_result = STC_ERROR_NONE; - stc_error_e error = STC_ERROR_NONE; - stc_stats_info_s *stats_info = NULL; - GSList *stats_list = NULL; - stc_event_info_s *event_data = NULL; - stc_handle_s *stc_handle = (stc_handle_s *)user_data; - - conn = G_DBUS_CONNECTION(source_object); - dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); - if (dbus_error != NULL) { - error = _stc_convert_error_string_to_enum(dbus_error->message); //LCOV_EXCL_LINE - g_error_free(dbus_error); //LCOV_EXCL_LINE - } - - if (_stc_event_get_request_table_state(STC_REQUEST_TABLE_STATS_GET_ALL)) - _stc_event_set_request_table_state(STC_REQUEST_TABLE_STATS_GET_ALL, false); - - if (error == STC_ERROR_NONE) { - g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); - - event_data = g_try_malloc0(sizeof(stc_event_info_s)); - if (event_data != NULL) { - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); - if (stats_info != NULL) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_stats_extract_info_cb, stats_info); - - __stc_stats_print_info(stats_info); - - stats_list = g_slist_append(stats_list, - (stc_stats_info_s *)stats_info); - - g_variant_iter_free(iter_row); - } - } - g_variant_iter_free(iter); - - event_data->handle = stc_handle; - event_data->event = STC_EVENT_STATS_GET_ALL_RSP; - event_data->info_data = (GSList *)stats_list; - event_data->datalength = g_slist_length(stats_list); - event_data->error = dbus_result; - } - } else { - //LCOV_EXCL_START - STC_LOGE("Get stats all response error [%s]", - _stc_convert_error_type_to_string(error)); - - event_data = g_try_malloc0(sizeof(stc_event_info_s)); - if (event_data != NULL) { - event_data->handle = stc_handle; - event_data->event = STC_EVENT_STATS_GET_ALL_RSP; - event_data->info_data = NULL; - event_data->datalength = 0; - event_data->error = error; - } - //LCOV_EXCL_STOP - } - - stc_handle->event_handle.event_callback(event_data, user_data); - g_free(event_data); + __stc_stats_reply(source_object, res, user_data, + STC_REQUEST_TABLE_STATS_GET_ALL, STC_EVENT_STATS_GET_ALL_RSP); } static void __stc_stats_get_total_reply( GObject *source_object, GAsyncResult *res, gpointer user_data) { - GDBusConnection *conn = NULL; - GError *dbus_error = NULL; - GVariant *dbus_data = NULL; - GVariantIter *iter = NULL; - GVariantIter *iter_row = NULL; - stc_error_e dbus_result = STC_ERROR_NONE; - stc_error_e error = STC_ERROR_NONE; - stc_stats_info_s *stats_info = NULL; - GSList *stats_list = NULL; - stc_event_info_s *event_data = NULL; - stc_handle_s *stc_handle = (stc_handle_s *)user_data; - - conn = G_DBUS_CONNECTION(source_object); - dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); - if (dbus_error != NULL) { - error = _stc_convert_error_string_to_enum(dbus_error->message); //LCOV_EXCL_LINE - g_error_free(dbus_error); //LCOV_EXCL_LINE - } - - if (_stc_event_get_request_table_state(STC_REQUEST_TABLE_STATS_GET_TOTAL)) - _stc_event_set_request_table_state(STC_REQUEST_TABLE_STATS_GET_TOTAL, false); - - if (error == STC_ERROR_NONE) { - g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); - - event_data = g_try_malloc0(sizeof(stc_event_info_s)); - if (event_data != NULL) { - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); - if (stats_info != NULL) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_stats_extract_info_cb, stats_info); - - __stc_stats_print_info(stats_info); - - stats_list = g_slist_append(stats_list, - (stc_stats_info_s *)stats_info); - - g_variant_iter_free(iter_row); - } - } - g_variant_iter_free(iter); - - event_data->handle = stc_handle; - event_data->event = STC_EVENT_STATS_GET_TOTAL_RSP; - event_data->info_data = (GSList *)stats_list; - event_data->datalength = g_slist_length(stats_list); - event_data->error = dbus_result; - } - } else { - //LCOV_EXCL_START - STC_LOGE("Get stats total response error [%s]", - _stc_convert_error_type_to_string(error)); - - event_data = g_try_malloc0(sizeof(stc_event_info_s)); - if (event_data != NULL) { - event_data->handle = stc_handle; - event_data->event = STC_EVENT_STATS_GET_TOTAL_RSP; - event_data->info_data = NULL; - event_data->datalength = 0; - event_data->error = error; - } - //LCOV_EXCL_STOP - } - - stc_handle->event_handle.event_callback(event_data, user_data); - g_free(event_data); + __stc_stats_reply(source_object, res, user_data, + STC_REQUEST_TABLE_STATS_GET_TOTAL, STC_EVENT_STATS_GET_TOTAL_RSP); } static void __stc_stats_add_rule(stc_stats_rule_h rule) @@ -586,19 +393,13 @@ static bool __stc_stats_check_rule_validity(stc_stats_rule_h rule) return false; } -stc_error_e _stc_stats_check_get_rule( - stc_stats_rule_h rule) +static stc_error_e __stc_stats_check_rule( + stc_stats_rule_s *stats_rule) { - stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; - STC_RETURN_VAL_IF(stats_rule == NULL, STC_ERROR_INVALID_PARAMETER, "Stats rule should be set"); - STC_RETURN_VAL_IF(stats_rule->app_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Application ID is required argument"); - STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, STC_ERROR_INVALID_PARAMETER, "Invalid time interval for [from]"); @@ -610,44 +411,30 @@ stc_error_e _stc_stats_check_get_rule( return STC_ERROR_NONE; } -stc_error_e _stc_stats_check_get_all_rule( +stc_error_e _stc_stats_check_get_rule( stc_stats_rule_h rule) { stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; - STC_RETURN_VAL_IF(stats_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Stats rule should be set"); - - STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, + STC_RETURN_VAL_IF(stats_rule->app_id[0] == '\0', STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [from]"); + "Application ID is required argument"); - STC_RETURN_VAL_IF(stats_rule->interval.to <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [to]"); + return __stc_stats_check_rule(stats_rule); +} - return STC_ERROR_NONE; +stc_error_e _stc_stats_check_get_all_rule( + stc_stats_rule_h rule) +{ + stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; + return __stc_stats_check_rule(stats_rule); } stc_error_e _stc_stats_check_get_total_rule( stc_stats_rule_h rule) { stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; - - STC_RETURN_VAL_IF(stats_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Stats rule should be set"); - - STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [from]"); - - STC_RETURN_VAL_IF(stats_rule->interval.to <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [to]"); - - return STC_ERROR_NONE; + return __stc_stats_check_rule(stats_rule); } stc_error_e _stc_stats_get(stc_h stc, stc_stats_rule_h rule) @@ -828,17 +615,9 @@ EXPORT_API int stc_stats_rule_create(stc_h stc, stc_stats_rule_h *rule) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_HANDLE(stc); - if (rule == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_INPUT_PARAMETER(rule); stc_stats_rule_s *stats_rule = g_try_malloc0(sizeof(stc_stats_rule_s)); if (stats_rule == NULL) { @@ -863,11 +642,7 @@ EXPORT_API int stc_stats_rule_destroy(stc_stats_rule_h rule) STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); __stc_stats_remove_rule(rule); __stc_stats_deinit_rule(rule); @@ -885,11 +660,7 @@ EXPORT_API int stc_stats_rule_set_app_id(stc_stats_rule_h rule, STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; @@ -911,11 +682,7 @@ EXPORT_API int stc_stats_rule_set_time_interval(stc_stats_rule_h rule, STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); if (from < 0 || to < 0) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE @@ -941,11 +708,7 @@ EXPORT_API int stc_stats_rule_set_iface_type( STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; @@ -978,11 +741,7 @@ EXPORT_API int stc_stats_rule_set_time_period(stc_stats_rule_h rule, STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; @@ -1013,17 +772,9 @@ EXPORT_API int stc_stats_rule_get_app_id(stc_stats_rule_h rule, char **app_id) STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); - if (app_id == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_INPUT_PARAMETER(app_id); stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; @@ -1046,11 +797,7 @@ EXPORT_API int stc_stats_rule_get_time_interval(stc_stats_rule_h rule, STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; @@ -1070,11 +817,7 @@ EXPORT_API int stc_stats_rule_get_iface_type(stc_stats_rule_h rule, STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; @@ -1093,11 +836,7 @@ EXPORT_API int stc_stats_rule_get_time_period(stc_stats_rule_h rule, STC_LOCK; - if (__stc_stats_check_rule_validity(rule) == false) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_STATS_RULE(rule); stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; diff --git a/src/stc.c b/src/stc.c index 74b4fa1..9e45403 100755 --- a/src/stc.c +++ b/src/stc.c @@ -64,11 +64,7 @@ EXPORT_API int stc_initialize(stc_h *stc) STC_LOCK; - if (stc == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - STC_UNLOCK; //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_VALIDATE_INPUT_PARAMETER(stc); ret = _stc_handle_create(stc); if (ret != STC_ERROR_NONE) { @@ -101,11 +97,7 @@ EXPORT_API int stc_deinitialize(stc_h stc) STC_LOCK; - if (!(_stc_handle_check_validity(stc))) { - STC_LOGE("Invalid parameter"); - STC_UNLOCK; - return STC_ERROR_INVALID_PARAMETER; - } + STC_VALIDATE_HANDLE(stc); STC_LOGI("Destroy handle [%p]", stc); _stc_deinitialize(stc); diff --git a/test/firewall.c b/test/firewall.c index fec1e2a..68af3f0 100755 --- a/test/firewall.c +++ b/test/firewall.c @@ -286,7 +286,7 @@ static stc_callback_ret_e __test_stc_fw_rule_info_cb(stc_firewall_rule_h info_h, return TRUE; } -static int __test_stc_fw_set_rule_info(void) +static int __test_stc_fw_set_rule(stc_firewall_rule_h rule_h) { stc_firewall_direction_e direction = (int)strtol(g_rule_direction, NULL, 10); @@ -322,214 +322,20 @@ static int __test_stc_fw_set_rule_info(void) (unsigned int)strtol(g_rule_nflog_threshold, NULL, 10); int ret = STC_ERROR_NONE; - if (strlen(g_rule_chain) == 0) { - msg(LOG_RED "Invalid parameter" LOG_END); - return STC_ERROR_INVALID_PARAMETER; - } - - ret = stc_firewall_rule_set_chain(g_fw_rule_h, g_rule_chain); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set chain of rule" LOG_END); - else - msg("Fail to set chain of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - if (direction <= STC_FIREWALL_DIRECTION_OUT) { - ret = stc_firewall_rule_set_direction(g_fw_rule_h, direction); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set direction of rule" LOG_END); - else - msg("Fail to set direction of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_ifname(g_fw_rule_h, g_rule_ifname); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set interface name of rule" LOG_END); - else - msg("Fail to set interface name of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - } - - if (family <= STC_FIREWALL_FAMILY_V6) { - ret = stc_firewall_rule_set_family_type(g_fw_rule_h, family); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set family type of rule" LOG_END); - else - msg("Fail to set family type of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - } - - if (s_ip_type <= STC_FIREWALL_IP_RANGE) { - ret = stc_firewall_rule_set_src_ip_type(g_fw_rule_h, s_ip_type); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set source IP type of rule" LOG_END); - else - msg("Fail to set source IP type of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_src_ip(g_fw_rule_h, g_rule_s_ip1, g_rule_s_ip2); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set source IP of rule" LOG_END); - else - msg("Fail to set source IP of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - } - - if (d_ip_type <= STC_FIREWALL_IP_RANGE) { - ret = stc_firewall_rule_set_dst_ip_type(g_fw_rule_h, d_ip_type); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set destination IP type of rule" LOG_END); - else - msg("Fail to set destination IP type of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_dst_ip(g_fw_rule_h, g_rule_d_ip1, g_rule_d_ip2); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set destination IP of rule" LOG_END); - else - msg("Fail to set destination IP of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - } - - if (protocol <= STC_FIREWALL_PROTOCOL_ALL) { - ret = stc_firewall_rule_set_protocol_type(g_fw_rule_h, protocol); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set protocol type of rule" LOG_END); - else - msg("Fail to set protocol type of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - if (s_port_type <= STC_FIREWALL_PORT_RANGE) { - ret = stc_firewall_rule_set_src_port_type(g_fw_rule_h, s_port_type); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set source port type of rule" LOG_END); - else - msg("Fail to set source port type of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_src_port(g_fw_rule_h, s_port1, s_port2); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set source port of rule" LOG_END); - else - msg("Fail to set source port of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); + if (rule_h == g_fw_rule_h) { + if (strlen(g_rule_chain) == 0) { + msg(LOG_RED "Invalid parameter" LOG_END); + return STC_ERROR_INVALID_PARAMETER; } - if (d_port_type <= STC_FIREWALL_PORT_RANGE) { - ret = stc_firewall_rule_set_dst_port_type(g_fw_rule_h, d_port_type); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set destination port type of rule" LOG_END); - else - msg("Fail to set destination port type of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_dst_port(g_fw_rule_h, d_port1, d_port2); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set destination port of rule" LOG_END); - else - msg("Fail to set destination port of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - } - } - - if (target < STC_FIREWALL_RULE_TARGET_MAX) { - ret = stc_firewall_rule_set_target(g_fw_rule_h, target); + ret = stc_firewall_rule_set_chain(rule_h, g_rule_chain); if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set target of rule" LOG_END); + msg(LOG_GREEN "Success to set chain of rule" LOG_END); else - msg("Fail to set target of rule " LOG_RED "[%s]" LOG_END, + msg("Fail to set chain of rule " LOG_RED "[%s]" LOG_END, test_stc_convert_error_type_to_string(ret)); - - if (target == STC_FIREWALL_RULE_TARGET_LOG) { - ret = stc_firewall_rule_set_log_level(g_fw_rule_h, log_level); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set log level of rule" LOG_END); - else - msg("Fail to set log level of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_log_prefix(g_fw_rule_h, g_rule_log_prefix); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set log prefix of rule" LOG_END); - else - msg("Fail to set log prefix of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - } else if (target == STC_FIREWALL_RULE_TARGET_NFLOG) { - ret = stc_firewall_rule_set_nflog_group(g_fw_rule_h, nflog_group); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set nflog group of rule" LOG_END); - else - msg("Fail to set nflog group of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_nflog_prefix(g_fw_rule_h, g_rule_nflog_prefix); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set nflog prefix of rule" LOG_END); - else - msg("Fail to set nflog prefix of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_nflog_range(g_fw_rule_h, nflog_range); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set nflog range of rule" LOG_END); - else - msg("Fail to set nflog range of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - - ret = stc_firewall_rule_set_nflog_threshold(g_fw_rule_h, nflog_threshold); - if (ret == STC_ERROR_NONE) - msg(LOG_GREEN "Success to set nflog threshold of rule" LOG_END); - else - msg("Fail to set nflog threshold of rule " LOG_RED "[%s]" LOG_END, - test_stc_convert_error_type_to_string(ret)); - } } - msg(HR_SINGLE); - - __test_stc_fw_print_rule(g_fw_rule_h); - - msg(HR_SINGLE); - - return STC_ERROR_NONE; -} - -static int __test_stc_fw_update_rule_info(stc_firewall_rule_h rule_h) -{ - stc_firewall_direction_e direction = - (int)strtol(g_rule_direction, NULL, 10); - stc_firewall_ip_type_e s_ip_type = - (int)strtol(g_rule_s_ip_type, NULL, 10); - stc_firewall_ip_type_e d_ip_type = - (int)strtol(g_rule_d_ip_type, NULL, 10); - stc_firewall_port_type_e s_port_type = - (int)strtol(g_rule_s_port_type, NULL, 10); - stc_firewall_port_type_e d_port_type = - (int)strtol(g_rule_d_port_type, NULL, 10); - stc_firewall_protocol_type_e protocol = - (int)strtol(g_rule_protocol, NULL, 10); - stc_firewall_family_type_e family = - (int)strtol(g_rule_family, NULL, 10); - stc_firewall_rule_target_e target = - (int)strtol(g_rule_target, NULL, 10); - unsigned int s_port1 = - (unsigned int)strtol(g_rule_s_port1, NULL, 10); - unsigned int s_port2 = - (unsigned int)strtol(g_rule_s_port2, NULL, 10); - unsigned int d_port1 = - (unsigned int)strtol(g_rule_d_port1, NULL, 10); - unsigned int d_port2 = - (unsigned int)strtol(g_rule_d_port2, NULL, 10); - unsigned int log_level = - (unsigned int)strtol(g_rule_log_level, NULL, 10); - unsigned int nflog_group = - (unsigned int)strtol(g_rule_nflog_group, NULL, 10); - unsigned int nflog_range = - (unsigned int)strtol(g_rule_nflog_range, NULL, 10); - unsigned int nflog_threshold = - (unsigned int)strtol(g_rule_nflog_threshold, NULL, 10); - int ret = STC_ERROR_NONE; - if (direction <= STC_FIREWALL_DIRECTION_OUT) { ret = stc_firewall_rule_set_direction(rule_h, direction); if (ret == STC_ERROR_NONE) @@ -690,6 +496,16 @@ static int __test_stc_fw_update_rule_info(stc_firewall_rule_h rule_h) return STC_ERROR_NONE; } +static int __test_stc_fw_set_rule_info(void) +{ + return __test_stc_fw_set_rule(g_fw_rule_h); +} + +static int __test_stc_fw_update_rule_info(stc_firewall_rule_h rule_h) +{ + return __test_stc_fw_set_rule(rule_h); +} + static int __test_stc_fw_create_rule(void) { int ret = STC_ERROR_NONE;