* @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.
* @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.
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
#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];
#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;
} \
} 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)\
* 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
*****************************************************************************/
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) {
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) {
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) {
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) {
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) {
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);
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;
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;
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;
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");
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) {
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) {
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) {
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);
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) {
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) {
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) {
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);
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");
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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");
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) {
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) {
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) {
return STC_ERROR_NONE;
}
+//LCOV_EXCL_STOP
\ No newline at end of file
{
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) {
{
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);
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
* 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
*****************************************************************************/
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) {
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) {
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) {
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) {
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) {
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) {
//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;
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));
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;
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));
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) {
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);
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);
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);
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);
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) {
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) {
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]",
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]",
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) {
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) {
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) {
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) {
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) {
* 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
*****************************************************************************/
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");
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);
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) {
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) {
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) {
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);
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;
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;
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");
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");
* 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
*****************************************************************************/
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) {
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);
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;
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;
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;
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");
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;
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;
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;
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;
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;
STC_MANAGER_SERVICE,
STC_MANAGER_RESTRICTION_PATH,
STC_MANAGER_RESTRICTION_INTERFACE,
- STC_MANAGER_METHOD_RESTRICTION_SET_LIST,
+ dbus_method,
params,
&error);
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",
"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");
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;
}
{
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;
}
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));
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);
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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));
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);
* 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
*****************************************************************************/
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));
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));
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));
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));
}
//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;
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);
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;
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)
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]");
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)
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) {
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);
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;
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
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;
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;
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;
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;
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;
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;
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) {
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);
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);
(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)
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;
projects / platform / core / api / smart-traffic-control.git / commitdiff