diff --git a/include/maat.h b/include/maat.h index 5100134..09d1799 100644 --- a/include/maat.h +++ b/include/maat.h @@ -70,32 +70,55 @@ enum log_level { LOG_LEVEL_ERROR, LOG_LEVEL_FATAL }; + /* update_type: MAAT_UPDATE_TYPE_FULL or MAAT_UPDATE_TYPE_INC */ typedef void maat_start_callback_t(int update_type, void *u_param); + typedef void maat_update_callback_t(int table_id, const char *table_line, void *u_para); + typedef void maat_finish_callback_t(void *u_para); typedef void maat_ex_new_func_t(const char *table_name, int table_id, const char *key, const char *table_line, void **ad, long argl, void *argp); + typedef void maat_ex_free_func_t(int table_id, void **ad, long argl, void *argp); + typedef void maat_ex_dup_func_t(int table_id, void **to, void **from, long argl, void *argp); /* maat_instance options API */ struct maat_options; + struct maat_options *maat_options_new(void); + void maat_options_free(struct maat_options *opts); -int maat_options_set_caller_thread_number(struct maat_options *opts, size_t n_thread); -int maat_options_set_accept_tags(struct maat_options *opts, const char *accept_tags); -int maat_options_set_rule_effect_interval_ms(struct maat_options *opts, int interval_ms); -int maat_options_set_rule_update_checking_interval_ms(struct maat_options *opts, int interval_ms); -int maat_options_set_gc_timeout_ms(struct maat_options *opts, int interval_ms); +/** + * @brief set maat instance name + * + * @note The maximum length of instance_name is 15 bytes +*/ int maat_options_set_instance_name(struct maat_options *opts, const char *instance_name); + +int maat_options_set_caller_thread_number(struct maat_options *opts, size_t n_thread); + +int maat_options_set_accept_tags(struct maat_options *opts, const char *accept_tags); + +int maat_options_set_rule_effect_interval_ms(struct maat_options *opts, int interval_ms); + +int maat_options_set_rule_update_checking_interval_ms(struct maat_options *opts, int interval_ms); + +int maat_options_set_gc_timeout_ms(struct maat_options *opts, int interval_ms); + int maat_options_set_deferred_load_on(struct maat_options *opts); + int maat_options_set_stat_on(struct maat_options *opts); + int maat_options_set_perf_on(struct maat_options *opts); + int maat_options_set_foreign_cont_dir(struct maat_options *opts, const char *dir); -int maat_options_set_logger(struct maat_options *opts, const char *log_path, enum log_level level); + +int maat_options_set_logger(struct maat_options *opts, const char *log_path, + enum log_level level); int maat_options_set_iris(struct maat_options *opts, const char *full_directory, const char *increment_directory); diff --git a/scanner/adapter_hs/adapter_hs.cpp b/scanner/adapter_hs/adapter_hs.cpp index 6eb1434..1cd545c 100644 --- a/scanner/adapter_hs/adapter_hs.cpp +++ b/scanner/adapter_hs/adapter_hs.cpp @@ -103,8 +103,8 @@ struct adapter_hs_stream { struct log_handle *logger; }; -int _hs_alloc_scratch(hs_database_t *db, hs_scratch_t **scratches, size_t n_worker_thread, - struct log_handle *logger) +int _hs_alloc_scratch(hs_database_t *db, hs_scratch_t **scratches, + size_t n_worker_thread, struct log_handle *logger) { size_t scratch_size = 0; @@ -119,14 +119,16 @@ int _hs_alloc_scratch(hs_database_t *db, hs_scratch_t **scratches, size_t n_work hs_error_t err = hs_clone_scratch(scratches[0], &scratches[i]); if (err != HS_SUCCESS) { log_error(logger, MODULE_ADAPTER_HS, - "[%s:%d] Unable to clone scratch", __FUNCTION__, __LINE__); + "[%s:%d] Unable to clone scratch", + __FUNCTION__, __LINE__); return -1; } err = hs_scratch_size(scratches[i], &scratch_size); if (err != HS_SUCCESS) { log_error(logger, MODULE_ADAPTER_HS, - "[%s:%d] Unable to query scratch size", __FUNCTION__, __LINE__); + "[%s:%d] Unable to query scratch size", + __FUNCTION__, __LINE__); return -1; } } @@ -134,8 +136,10 @@ int _hs_alloc_scratch(hs_database_t *db, hs_scratch_t **scratches, size_t n_work return 0; } -static int adpt_hs_alloc_scratch(struct adapter_hs_runtime *hs_rt, size_t n_worker_thread, - enum hs_pattern_type pattern_type, struct log_handle *logger) +static int adpt_hs_alloc_scratch(struct adapter_hs_runtime *hs_rt, + size_t n_worker_thread, + enum hs_pattern_type pattern_type, + struct log_handle *logger) { int ret = 0; @@ -178,9 +182,11 @@ static int adpt_hs_build_database(struct adapter_hs_runtime *hs_rt, } if (literal_cd != NULL) { - err = hs_compile_lit_multi((const char *const *)literal_cd->patterns, literal_cd->flags, - literal_cd->ids, literal_cd->pattern_lens, literal_cd->n_patterns, - HS_MODE_STREAM, NULL, &hs_rt->literal_db, &compile_err); + err = hs_compile_lit_multi((const char *const *)literal_cd->patterns, + literal_cd->flags,literal_cd->ids, + literal_cd->pattern_lens, literal_cd->n_patterns, + HS_MODE_STREAM | HS_MODE_SOM_HORIZON_SMALL, NULL, + &hs_rt->literal_db, &compile_err); if (err != HS_SUCCESS) { if (compile_err) { log_error(logger, MODULE_ADAPTER_HS, "[%s:%d] compile error: %s", @@ -193,9 +199,10 @@ static int adpt_hs_build_database(struct adapter_hs_runtime *hs_rt, } if (regex_cd != NULL) { - err = hs_compile_multi((const char *const *)regex_cd->patterns, regex_cd->flags, regex_cd->ids, - regex_cd->n_patterns, HS_MODE_STREAM | HS_MODE_SOM_HORIZON_SMALL, NULL, - &hs_rt->regex_db, &compile_err); + err = hs_compile_multi((const char *const *)regex_cd->patterns, + regex_cd->flags, regex_cd->ids, regex_cd->n_patterns, + HS_MODE_STREAM | HS_MODE_SOM_HORIZON_SMALL, + NULL, &hs_rt->regex_db, &compile_err); if (err != HS_SUCCESS) { if (compile_err) { log_error(logger, MODULE_ADAPTER_HS, "[%s:%d] compile error: %s", @@ -250,8 +257,8 @@ void adpt_hs_compile_data_free(struct adpt_hs_compile_data *hs_cd) FREE(hs_cd); } -void populate_compile_data(struct adpt_hs_compile_data *compile_data, int index, int pattern_id, - char *pat, size_t pat_len, int case_sensitive) +void populate_compile_data(struct adpt_hs_compile_data *compile_data, int index, + int pattern_id, char *pat, size_t pat_len, int case_sensitive) { compile_data->ids[index] = pattern_id; @@ -266,8 +273,10 @@ void populate_compile_data(struct adpt_hs_compile_data *compile_data, int index, memcpy(compile_data->patterns[index], pat, pat_len); } -struct bool_expr *bool_exprs_new(struct expr_rule *rules, size_t n_rule, struct pattern_attribute *pattern_attr, - struct adpt_hs_compile_data *literal_cd, struct adpt_hs_compile_data *regex_cd, +struct bool_expr *bool_exprs_new(struct expr_rule *rules, size_t n_rule, + struct pattern_attribute *pattern_attr, + struct adpt_hs_compile_data *literal_cd, + struct adpt_hs_compile_data *regex_cd, size_t *n_pattern) { uint32_t pattern_index = 0; @@ -329,8 +338,9 @@ int verify_regex_expression(const char *regex_str, struct log_handle *logger) if (err != HS_SUCCESS) { // Expression will fail compilation and report error elsewhere. if (logger != NULL) { - log_error(logger, MODULE_ADAPTER_HS, "[%s:%d] illegal regex expression: \"%s\": %s", - __FUNCTION__, __LINE__, regex_str, error->message); + log_error(logger, MODULE_ADAPTER_HS, + "[%s:%d] illegal regex expression: \"%s\": %s", + __FUNCTION__, __LINE__, regex_str, error->message); } FREE(info); @@ -354,13 +364,12 @@ int adapter_hs_verify_regex_expression(const char *regex_expr, struct log_handle return verify_regex_expression(regex_expr, logger); } -struct adapter_hs *adapter_hs_new(size_t n_worker_thread, - struct expr_rule *rules, size_t n_rule, - struct log_handle *logger) +struct adapter_hs *adapter_hs_new(struct expr_rule *rules, size_t n_rule, + size_t n_worker_thread, struct log_handle *logger) { if (0 == n_worker_thread || NULL == rules || 0 == n_rule) { - log_error(logger, MODULE_ADAPTER_HS, "[%s:%d] input parameters illegal!", - __FUNCTION__, __LINE__); + log_error(logger, MODULE_ADAPTER_HS, + "[%s:%d] input parameters illegal!", __FUNCTION__, __LINE__); return NULL; } @@ -370,8 +379,9 @@ struct adapter_hs *adapter_hs_new(size_t n_worker_thread, for (size_t i = 0; i < n_rule; i++) { if (rules[i].n_patterns > MAX_EXPR_PATTERN_NUM) { log_error(logger, MODULE_ADAPTER_HS, - "[%s:%d] the number of patterns in one expression should less than %d", - __FUNCTION__, __LINE__, MAX_EXPR_PATTERN_NUM); + "[%s:%d] the number of patterns in one expression " + "should less than %d", __FUNCTION__, __LINE__, + MAX_EXPR_PATTERN_NUM); return NULL; } @@ -379,7 +389,8 @@ struct adapter_hs *adapter_hs_new(size_t n_worker_thread, /* pat_len should not 0 */ if (0 == rules[i].patterns[j].pat_len) { log_error(logger, MODULE_ADAPTER_HS, - "[%s:%d] expr pattern length should not 0", __FUNCTION__, __LINE__); + "[%s:%d] expr pattern length should not 0", + __FUNCTION__, __LINE__); return NULL; } @@ -392,8 +403,8 @@ struct adapter_hs *adapter_hs_new(size_t n_worker_thread, } if (0 == literal_pattern_num && 0 == regex_pattern_num) { - log_error(logger, MODULE_ADAPTER_HS, "[%s:%d] exprs has no valid pattern", - __FUNCTION__, __LINE__); + log_error(logger, MODULE_ADAPTER_HS, + "[%s:%d] exprs has no valid pattern", __FUNCTION__, __LINE__); return NULL; } @@ -408,30 +419,32 @@ struct adapter_hs *adapter_hs_new(size_t n_worker_thread, } size_t pattern_cnt = literal_pattern_num + regex_pattern_num; - struct adapter_hs *hs_instance = ALLOC(struct adapter_hs, 1); - hs_instance->hs_attr = ALLOC(struct pattern_attribute, pattern_cnt); - hs_instance->logger = logger; - hs_instance->n_worker_thread = n_worker_thread; - hs_instance->n_expr = n_rule; + struct adapter_hs *hs_inst = ALLOC(struct adapter_hs, 1); + hs_inst->hs_attr = ALLOC(struct pattern_attribute, pattern_cnt); + hs_inst->logger = logger; + hs_inst->n_worker_thread = n_worker_thread; + hs_inst->n_expr = n_rule; - struct bool_expr *bool_exprs = bool_exprs_new(rules, n_rule, hs_instance->hs_attr, + struct bool_expr *bool_exprs = bool_exprs_new(rules, n_rule, hs_inst->hs_attr, literal_cd, regex_cd, &pattern_cnt); if (NULL == bool_exprs) { return NULL; } - hs_instance->n_patterns = pattern_cnt; + hs_inst->n_patterns = pattern_cnt; /* create bool matcher */ size_t mem_size = 0; int hs_ret = 0; - hs_instance->hs_rt = ALLOC(struct adapter_hs_runtime, 1); - hs_instance->hs_rt->bm = bool_matcher_new(bool_exprs, n_rule, &mem_size); - if (hs_instance->hs_rt->bm != NULL) { + + hs_inst->hs_rt = ALLOC(struct adapter_hs_runtime, 1); + hs_inst->hs_rt->bm = bool_matcher_new(bool_exprs, n_rule, &mem_size); + if (hs_inst->hs_rt->bm != NULL) { log_info(logger, MODULE_ADAPTER_HS, - "Adapter_hs module: build bool matcher of %zu expressions with %zu bytes memory", - n_rule, mem_size); + "Adapter_hs module: build bool matcher of %zu expressions" + " with %zu bytes memory", n_rule, mem_size); } else { - log_error(logger, MODULE_ADAPTER_HS, "[%s:%d] Adapter_hs module: build bool matcher failed", + log_error(logger, MODULE_ADAPTER_HS, + "[%s:%d] Adapter_hs module: build bool matcher failed", __FUNCTION__, __LINE__); hs_ret = -1; @@ -439,7 +452,7 @@ struct adapter_hs *adapter_hs_new(size_t n_worker_thread, FREE(bool_exprs); /* build hs database */ - int ret = adpt_hs_build_database(hs_instance->hs_rt, literal_cd, regex_cd, logger); + int ret = adpt_hs_build_database(hs_inst->hs_rt, literal_cd, regex_cd, logger); if (ret < 0) { hs_ret = -1; } @@ -456,97 +469,101 @@ struct adapter_hs *adapter_hs_new(size_t n_worker_thread, goto error; } - hs_instance->hs_rt->scratch = ALLOC(struct adapter_hs_scratch, 1); - hs_instance->hs_rt->scratch->bool_match_buffs = ALLOC(struct bool_expr_match *, n_worker_thread); + hs_inst->hs_rt->scratch = ALLOC(struct adapter_hs_scratch, 1); + hs_inst->hs_rt->scratch->bool_match_buffs = ALLOC(struct bool_expr_match *, + n_worker_thread); for (size_t i = 0; i < n_worker_thread; i++) { - hs_instance->hs_rt->scratch->bool_match_buffs[i] = ALLOC(struct bool_expr_match, hs_instance->n_expr); + hs_inst->hs_rt->scratch->bool_match_buffs[i] = ALLOC(struct bool_expr_match, + hs_inst->n_expr); } /* literal and regex scratch can't reuse */ if (literal_pattern_num > 0) { - ret = adpt_hs_alloc_scratch(hs_instance->hs_rt, n_worker_thread, HS_PATTERN_TYPE_STR, logger); + ret = adpt_hs_alloc_scratch(hs_inst->hs_rt, n_worker_thread, + HS_PATTERN_TYPE_STR, logger); if (ret < 0) { goto error; } } if (regex_pattern_num > 0) { - ret = adpt_hs_alloc_scratch(hs_instance->hs_rt, n_worker_thread, HS_PATTERN_TYPE_REG, logger); + ret = adpt_hs_alloc_scratch(hs_inst->hs_rt, n_worker_thread, + HS_PATTERN_TYPE_REG, logger); if (ret < 0) { goto error; } } - return hs_instance; + return hs_inst; error: - adapter_hs_free(hs_instance); + adapter_hs_free(hs_inst); return NULL; } -void adapter_hs_free(struct adapter_hs *hs_instance) +void adapter_hs_free(struct adapter_hs *hs_inst) { - if (NULL == hs_instance) { + if (NULL == hs_inst) { return; } - if (hs_instance->hs_rt != NULL) { - if (hs_instance->hs_rt->literal_db != NULL) { - hs_free_database(hs_instance->hs_rt->literal_db); - hs_instance->hs_rt->literal_db = NULL; + if (hs_inst->hs_rt != NULL) { + if (hs_inst->hs_rt->literal_db != NULL) { + hs_free_database(hs_inst->hs_rt->literal_db); + hs_inst->hs_rt->literal_db = NULL; } - if (hs_instance->hs_rt->regex_db != NULL) { - hs_free_database(hs_instance->hs_rt->regex_db); - hs_instance->hs_rt->regex_db = NULL; + if (hs_inst->hs_rt->regex_db != NULL) { + hs_free_database(hs_inst->hs_rt->regex_db); + hs_inst->hs_rt->regex_db = NULL; } - if (hs_instance->hs_rt->scratch != NULL) { - if (hs_instance->hs_rt->scratch->literal_scratches != NULL) { - for (size_t i = 0; i < hs_instance->n_worker_thread; i++) { - if (hs_instance->hs_rt->scratch->literal_scratches[i] != NULL) { - hs_free_scratch(hs_instance->hs_rt->scratch->literal_scratches[i]); - hs_instance->hs_rt->scratch->literal_scratches[i] = NULL; + if (hs_inst->hs_rt->scratch != NULL) { + if (hs_inst->hs_rt->scratch->literal_scratches != NULL) { + for (size_t i = 0; i < hs_inst->n_worker_thread; i++) { + if (hs_inst->hs_rt->scratch->literal_scratches[i] != NULL) { + hs_free_scratch(hs_inst->hs_rt->scratch->literal_scratches[i]); + hs_inst->hs_rt->scratch->literal_scratches[i] = NULL; } } - FREE(hs_instance->hs_rt->scratch->literal_scratches); + FREE(hs_inst->hs_rt->scratch->literal_scratches); } - if (hs_instance->hs_rt->scratch->regex_scratches != NULL) { - for (size_t i = 0; i < hs_instance->n_worker_thread; i++) { - if (hs_instance->hs_rt->scratch->regex_scratches[i] != NULL) { - hs_free_scratch(hs_instance->hs_rt->scratch->regex_scratches[i]); - hs_instance->hs_rt->scratch->regex_scratches[i] = NULL; + if (hs_inst->hs_rt->scratch->regex_scratches != NULL) { + for (size_t i = 0; i < hs_inst->n_worker_thread; i++) { + if (hs_inst->hs_rt->scratch->regex_scratches[i] != NULL) { + hs_free_scratch(hs_inst->hs_rt->scratch->regex_scratches[i]); + hs_inst->hs_rt->scratch->regex_scratches[i] = NULL; } } - FREE(hs_instance->hs_rt->scratch->regex_scratches); + FREE(hs_inst->hs_rt->scratch->regex_scratches); } - if (hs_instance->hs_rt->scratch->bool_match_buffs != NULL) { - for (size_t i = 0; i < hs_instance->n_worker_thread; i++) { - if (hs_instance->hs_rt->scratch->bool_match_buffs[i] != NULL) { - FREE(hs_instance->hs_rt->scratch->bool_match_buffs[i]); + if (hs_inst->hs_rt->scratch->bool_match_buffs != NULL) { + for (size_t i = 0; i < hs_inst->n_worker_thread; i++) { + if (hs_inst->hs_rt->scratch->bool_match_buffs[i] != NULL) { + FREE(hs_inst->hs_rt->scratch->bool_match_buffs[i]); } } - FREE(hs_instance->hs_rt->scratch->bool_match_buffs); + FREE(hs_inst->hs_rt->scratch->bool_match_buffs); } - FREE(hs_instance->hs_rt->scratch); + FREE(hs_inst->hs_rt->scratch); } - if (hs_instance->hs_rt->bm != NULL) { - bool_matcher_free(hs_instance->hs_rt->bm); - hs_instance->hs_rt->bm = NULL; + if (hs_inst->hs_rt->bm != NULL) { + bool_matcher_free(hs_inst->hs_rt->bm); + hs_inst->hs_rt->bm = NULL; } - FREE(hs_instance->hs_rt); + FREE(hs_inst->hs_rt); } - if (hs_instance->hs_attr != NULL) { - FREE(hs_instance->hs_attr); + if (hs_inst->hs_attr != NULL) { + FREE(hs_inst->hs_attr); } - FREE(hs_instance); + FREE(hs_inst); } static inline int compare_pattern_id(const void *a, const void *b) @@ -641,7 +658,8 @@ int matched_event_cb(unsigned int id, unsigned long long from, } UT_icd ut_pattern_id_icd = {sizeof(unsigned long long), NULL, NULL, NULL}; -struct adapter_hs_stream *adapter_hs_stream_open(struct adapter_hs *hs_instance, int thread_id) +struct adapter_hs_stream * +adapter_hs_stream_open(struct adapter_hs *hs_instance, int thread_id) { if (NULL == hs_instance || thread_id < 0) { return NULL; @@ -662,17 +680,21 @@ struct adapter_hs_stream *adapter_hs_stream_open(struct adapter_hs *hs_instance, int err_count = 0; if (hs_instance->hs_rt->literal_db != NULL) { - err = hs_open_stream(hs_instance->hs_rt->literal_db, 0, &hs_stream->literal_stream); + err = hs_open_stream(hs_instance->hs_rt->literal_db, 0, + &hs_stream->literal_stream); if (err != HS_SUCCESS) { - log_error(hs_instance->logger, MODULE_ADAPTER_HS, "hs_open_stream failed, hs err:%d", err); + log_error(hs_instance->logger, MODULE_ADAPTER_HS, + "hs_open_stream failed, hs err:%d", err); err_count++; } } if (hs_instance->hs_rt->regex_db != NULL) { - err = hs_open_stream(hs_instance->hs_rt->regex_db, 0, &hs_stream->regex_stream); + err = hs_open_stream(hs_instance->hs_rt->regex_db, 0, + &hs_stream->regex_stream); if (err != HS_SUCCESS) { - log_error(hs_instance->logger, MODULE_ADAPTER_HS, "hs_open_stream failed, hs err:%d", err); + log_error(hs_instance->logger, MODULE_ADAPTER_HS, + "hs_open_stream failed, hs err:%d", err); err_count++; } } diff --git a/scanner/adapter_hs/adapter_hs.h b/scanner/adapter_hs/adapter_hs.h index 181bc9f..b16f093 100644 --- a/scanner/adapter_hs/adapter_hs.h +++ b/scanner/adapter_hs/adapter_hs.h @@ -86,15 +86,14 @@ int adapter_hs_verify_regex_expression(const char *regex_expr, /** * @brief new adapter_hs instance * - * @param nr_worker_threads: the number of scan threads which will call adapter_hs_scan() * @param rules: logic AND expression's array * @param n_rule: the number of logic AND expression's array + * @param nr_worker_threads: the number of scan threads which will call adapter_hs_scan() * * @retval the pointer to adapter_hs instance */ -struct adapter_hs *adapter_hs_new(size_t n_worker_thread, - struct expr_rule *rules, size_t n_rule, - struct log_handle *logger); +struct adapter_hs *adapter_hs_new(struct expr_rule *rules, size_t n_rule, + size_t n_worker_thread, struct log_handle *logger); /** * @brief scan input data to match logic AND expression, return all matched expr_id diff --git a/src/inc_internal/maat_compile.h b/src/inc_internal/maat_compile.h index 5881f31..ef59f92 100644 --- a/src/inc_internal/maat_compile.h +++ b/src/inc_internal/maat_compile.h @@ -49,8 +49,7 @@ void *compile_runtime_new(void *compile_schema, size_t max_thread_num, struct log_handle *logger); void compile_runtime_free(void *compile_runtime); -void compile_runtime_init(void *compile_runtime, struct maat_runtime *maat_rt, - void *g2c_runtime); +void compile_runtime_init(void *compile_runtime, struct maat_runtime *maat_rt); int compile_runtime_update(void *compile_runtime, void *compile_schema, const char *table_name, const char *line, @@ -81,7 +80,9 @@ void compile_runtime_ex_data_iterate(struct compile_runtime *compile_rt, void *group2compile_runtime_new(void *g2c_schema, size_t max_thread_num, struct maat_garbage_bin *garbage_bin, struct log_handle *logger); + void group2compile_runtime_init(void *g2c_runtime, void *compile_runtime); + void group2compile_runtime_free(void *g2c_runtime); int group2compile_runtime_update(void *g2c_runtime, void *g2c_schema, diff --git a/src/inc_internal/maat_limits.h b/src/inc_internal/maat_limits.h index ade14e6..357acfc 100644 --- a/src/inc_internal/maat_limits.h +++ b/src/inc_internal/maat_limits.h @@ -17,9 +17,13 @@ extern "C" #endif #define MAX_KEYWORDS_STR 1024 + #define MAX_MAAT_STAT_NUM 64 + #define MAX_NAME_STR_LEN 64 +#define MAX_INSTANCE_NAME_LEN 15 + #ifdef __cplusplus } #endif diff --git a/src/inc_internal/maat_rule.h b/src/inc_internal/maat_rule.h index 6f83d9a..9e931cb 100644 --- a/src/inc_internal/maat_rule.h +++ b/src/inc_internal/maat_rule.h @@ -36,7 +36,6 @@ extern "C" #include "hiredis/hiredis.h" #define MAX_TABLE_NUM 1024 -#define MAX_COMPILE_TABLE_NUM 16 #define DISTRICT_ANY -1 #define DISTRICT_UNKNOWN -2 @@ -109,13 +108,13 @@ struct source_redis_ctx { }; struct maat_options { - char instance_name[NAME_MAX]; + char inst_name[MAX_INSTANCE_NAME_LEN + 1]; char foreign_cont_dir[NAME_MAX]; char decrypt_algo[MAX_KEYWORDS_STR]; char decrypt_key[MAX_KEYWORDS_STR]; char log_path[PATH_MAX]; int log_level; - char stat_file[PATH_MAX]; + char stat_file[NAME_MAX]; size_t nr_worker_thread; char *accept_tags; @@ -194,7 +193,7 @@ enum last_scan_flag { }; struct maat_state { - struct maat *maat_instance; + struct maat *maat_inst; struct maat_compile_state *compile_state; int scan_cnt; int district_id; //-1: Any District; -2: Unkonwn District; diff --git a/src/maat_api.c b/src/maat_api.c index 07e8a30..fa9fb8b 100644 --- a/src/maat_api.c +++ b/src/maat_api.c @@ -50,8 +50,8 @@ enum district_flag { }; struct maat_stream { - struct maat *ref_maat_instance; - struct adapter_hs_stream *s_handle; //each physical table open one stream + struct maat *ref_maat_inst; + struct adapter_hs_stream *handle; //each physical table open one stream long long last_full_version; long long expr_rt_version; struct log_handle *logger; @@ -137,11 +137,11 @@ int maat_options_set_gc_timeout_ms(struct maat_options *opts, int interval_ms) int maat_options_set_instance_name(struct maat_options *opts, const char *instance_name) { if (NULL == opts || NULL == instance_name || - strlen(instance_name) >= NAME_MAX) { + strlen(instance_name) > MAX_INSTANCE_NAME_LEN) { return -1; } - memcpy(opts->instance_name, instance_name, strlen(instance_name)); + memcpy(opts->inst_name, instance_name, strlen(instance_name)); return 0; } @@ -265,34 +265,34 @@ int maat_options_set_logger(struct maat_options *opts, const char *log_path, enu return 0; } -void _maat_free(struct maat *maat_instance) +void _maat_free(struct maat *maat_inst) { - if (NULL == maat_instance) { + if (NULL == maat_inst) { return; } - if (maat_instance->logger != NULL) { - log_handle_destroy(maat_instance->logger); - maat_instance->logger = NULL; + if (maat_inst->logger != NULL) { + log_handle_destroy(maat_inst->logger); + maat_inst->logger = NULL; } - if (maat_instance->garbage_bin != NULL) { - maat_garbage_bin_free(maat_instance->garbage_bin); - maat_instance->garbage_bin = NULL; + if (maat_inst->garbage_bin != NULL) { + maat_garbage_bin_free(maat_inst->garbage_bin); + maat_inst->garbage_bin = NULL; } - if (maat_instance->stat != NULL) { - maat_stat_free(maat_instance->stat); - maat_instance->stat = NULL; + if (maat_inst->stat != NULL) { + maat_stat_free(maat_inst->stat); + maat_inst->stat = NULL; } - if (maat_instance->opts.accept_tags != NULL) { - FREE(maat_instance->opts.accept_tags); + if (maat_inst->opts.accept_tags != NULL) { + FREE(maat_inst->opts.accept_tags); } - pthread_mutex_destroy(&(maat_instance->background_update_mutex)); + pthread_mutex_destroy(&(maat_inst->background_update_mutex)); - FREE(maat_instance); + FREE(maat_inst); } struct maat *maat_new(struct maat_options *opts, const char *table_info_path) @@ -301,98 +301,98 @@ struct maat *maat_new(struct maat_options *opts, const char *table_info_path) return NULL; } - struct maat *maat_instance = ALLOC(struct maat, 1); + struct maat *maat_inst = ALLOC(struct maat, 1); - maat_instance->opts = *opts; + maat_inst->opts = *opts; - if (strlen(maat_instance->opts.log_path) != 0) { - maat_instance->logger = log_handle_create(maat_instance->opts.log_path, - maat_instance->opts.log_level); + if (strlen(maat_inst->opts.log_path) != 0) { + maat_inst->logger = log_handle_create(maat_inst->opts.log_path, + maat_inst->opts.log_level); } else { - char log_path[1024] = {0}; - if (strlen(maat_instance->opts.instance_name) > 0) { - snprintf(log_path, sizeof(log_path), "%s.log", maat_instance->opts.instance_name); + char log_path[MAX_NAME_STR_LEN] = {0}; + if (strlen(maat_inst->opts.inst_name) > 0) { + snprintf(log_path, sizeof(log_path), "%s.log", maat_inst->opts.inst_name); } else { snprintf(log_path, sizeof(log_path), "maat.log"); } - maat_instance->logger = log_handle_create(log_path, maat_instance->opts.log_level); + maat_inst->logger = log_handle_create(log_path, maat_inst->opts.log_level); } - if (0 == strlen(maat_instance->opts.foreign_cont_dir)) { - snprintf(maat_instance->opts.foreign_cont_dir, sizeof(maat_instance->opts.foreign_cont_dir), + if (0 == strlen(maat_inst->opts.foreign_cont_dir)) { + snprintf(maat_inst->opts.foreign_cont_dir, sizeof(maat_inst->opts.foreign_cont_dir), "%s_files", table_info_path); } - system_cmd_mkdir(maat_instance->opts.foreign_cont_dir); + system_cmd_mkdir(maat_inst->opts.foreign_cont_dir); - if (0 == strlen(maat_instance->opts.stat_file)) { - snprintf(maat_instance->opts.stat_file, sizeof(maat_instance->opts.stat_file), "maat.fs3"); + if (0 == strlen(maat_inst->opts.stat_file)) { + snprintf(maat_inst->opts.stat_file, sizeof(maat_inst->opts.stat_file), "maat.fs3"); } - snprintf(maat_instance->opts.decrypt_algo, sizeof(maat_instance->opts.decrypt_algo), "aes-256-cbc"); + snprintf(maat_inst->opts.decrypt_algo, sizeof(maat_inst->opts.decrypt_algo), "aes-256-cbc"); - maat_instance->is_running = 0; - maat_instance->maat_version = 0; - maat_instance->last_full_version = 0; + maat_inst->is_running = 0; + maat_inst->maat_version = 0; + maat_inst->last_full_version = 0; - int garbage_gc_timeout_s = (maat_instance->opts.rule_effect_interval_ms / 1000) + - (maat_instance->opts.gc_timeout_ms / 1000); + int garbage_gc_timeout_s = (maat_inst->opts.rule_effect_interval_ms / 1000) + + (maat_inst->opts.gc_timeout_ms / 1000); - if (maat_instance->opts.input_mode != DATA_SOURCE_IRIS_FILE && - maat_instance->opts.input_mode != DATA_SOURCE_JSON_FILE && - maat_instance->opts.input_mode != DATA_SOURCE_REDIS) { - log_error(maat_instance->logger, MODULE_MAAT_API, + if (maat_inst->opts.input_mode != DATA_SOURCE_IRIS_FILE && + maat_inst->opts.input_mode != DATA_SOURCE_JSON_FILE && + maat_inst->opts.input_mode != DATA_SOURCE_REDIS) { + log_error(maat_inst->logger, MODULE_MAAT_API, "[%s:%d] data source(%d) unsupported", - __FUNCTION__, __LINE__, maat_instance->opts.input_mode); + __FUNCTION__, __LINE__, maat_inst->opts.input_mode); goto failed; } - maat_instance->garbage_bin = maat_garbage_bin_new(garbage_gc_timeout_s); - maat_instance->stat = maat_stat_new(maat_instance->opts.stat_file, maat_instance->opts.nr_worker_thread, - maat_instance->logger); + maat_inst->garbage_bin = maat_garbage_bin_new(garbage_gc_timeout_s); + maat_inst->stat = maat_stat_new(maat_inst->opts.stat_file, maat_inst->opts.nr_worker_thread, + maat_inst->logger); - pthread_mutex_init(&(maat_instance->background_update_mutex), NULL); + pthread_mutex_init(&(maat_inst->background_update_mutex), NULL); - maat_instance->tbl_mgr = table_manager_create(table_info_path, maat_instance->opts.accept_tags, - maat_instance->garbage_bin, maat_instance->logger); - if (NULL == maat_instance->tbl_mgr) { + maat_inst->tbl_mgr = table_manager_create(table_info_path, maat_inst->opts.accept_tags, + maat_inst->garbage_bin, maat_inst->logger); + if (NULL == maat_inst->tbl_mgr) { goto failed; } - if (0 == maat_instance->opts.deferred_load_on) { - maat_read_full_config(maat_instance); + if (0 == maat_inst->opts.deferred_load_on) { + maat_read_full_config(maat_inst); } - if (1 == maat_instance->opts.stat_on) { - int ret = maat_stat_init(maat_instance->stat, maat_instance->tbl_mgr, maat_instance->garbage_bin); + if (1 == maat_inst->opts.stat_on) { + int ret = maat_stat_init(maat_inst->stat, maat_inst->tbl_mgr, maat_inst->garbage_bin); if (ret < 0) { - log_error(maat_instance->logger, MODULE_MAAT_API, + log_error(maat_inst->logger, MODULE_MAAT_API, "[%s:%d] maat_stat_init failed.", __FUNCTION__, __LINE__); goto failed; } } - pthread_create(&(maat_instance->cfg_mon_thread), NULL, rule_monitor_loop, (void *)maat_instance); + pthread_create(&(maat_inst->cfg_mon_thread), NULL, rule_monitor_loop, (void *)maat_inst); - return maat_instance; + return maat_inst; failed: - _maat_free(maat_instance); + _maat_free(maat_inst); return NULL; } -void maat_free(struct maat *maat_instance) +void maat_free(struct maat *maat_inst) { - if (NULL == maat_instance) { + if (NULL == maat_inst) { return; } void *ret = NULL; - while (0 == maat_instance->is_running) { + while (0 == maat_inst->is_running) { usleep(500 * 1000); } - maat_instance->is_running = 0; - pthread_join(maat_instance->cfg_mon_thread, &ret); + maat_inst->is_running = 0; + pthread_join(maat_inst->cfg_mon_thread, &ret); } int maat_helper_read_column(const char *table_line, int Nth_column, @@ -415,11 +415,11 @@ int maat_helper_verify_regex_expression(const char *regex_expr) } } -int maat_get_table_id(struct maat *maat_instance, const char *table_name) +int maat_get_table_id(struct maat *maat_inst, const char *table_name) { int table_id = -1; - struct table_manager *table_mgr = maat_instance->tbl_mgr; + struct table_manager *table_mgr = maat_inst->tbl_mgr; table_id = table_manager_get_table_id(table_mgr, table_name); return table_id; @@ -436,7 +436,7 @@ static inline void maat_runtime_ref_dec(struct maat_runtime *maat_rt, int thread } /* must be plugin table */ -int maat_table_callback_register(struct maat *maat_instance, int table_id, +int maat_table_callback_register(struct maat *maat_inst, int table_id, maat_start_callback_t *start, maat_update_callback_t *update, maat_finish_callback_t *finish, @@ -444,34 +444,34 @@ int maat_table_callback_register(struct maat *maat_instance, int table_id, { int ret = -1; - pthread_mutex_lock(&(maat_instance->background_update_mutex)); - void *schema = table_manager_get_schema(maat_instance->tbl_mgr, table_id); + pthread_mutex_lock(&(maat_inst->background_update_mutex)); + void *schema = table_manager_get_schema(maat_inst->tbl_mgr, table_id); if (NULL == schema) { - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); - log_error(maat_instance->logger, MODULE_MAAT_API, + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); + log_error(maat_inst->logger, MODULE_MAAT_API, "[%s:%d] table(table_id:%d) schema is NULL, register callback failed", __FUNCTION__, __LINE__, table_id); return -1; } ret = plugin_table_add_callback(schema, table_id, start, update, finish, - u_para, maat_instance->logger); + u_para, maat_inst->logger); if (ret < 0) { - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); return -1; } - if (!maat_instance->maat_rt) { - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); + if (!maat_inst->maat_rt) { + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); return 0; } - void *runtime = table_manager_get_runtime(maat_instance->tbl_mgr, table_id); + void *runtime = table_manager_get_runtime(maat_inst->tbl_mgr, table_id); - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, table_id); + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (table_type != TABLE_TYPE_PLUGIN) { - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); - log_error(maat_instance->logger, MODULE_MAAT_API, + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); + log_error(maat_inst->logger, MODULE_MAAT_API, "[%s:%d] table type:%d illegal", __FUNCTION__, __LINE__, table_type); return -1; } @@ -496,18 +496,18 @@ int maat_table_callback_register(struct maat *maat_instance, int table_id, } } - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); return 0; } -int compile_table_ex_schema_register(struct maat *maat_instance, int table_id, +int compile_table_ex_schema_register(struct maat *maat_inst, int table_id, maat_ex_new_func_t *new_func, maat_ex_free_func_t *free_func, maat_ex_dup_func_t *dup_func, long argl, void *argp) { - void *schema = table_manager_get_schema(maat_instance->tbl_mgr, table_id); + void *schema = table_manager_get_schema(maat_inst->tbl_mgr, table_id); assert(schema != NULL); int ret = compile_table_set_ex_data_schema((struct compile_schema *)schema, table_id, @@ -517,8 +517,8 @@ int compile_table_ex_schema_register(struct maat *maat_instance, int table_id, return -1; } - if (maat_instance->maat_rt != NULL) { - void *runtime = table_manager_get_runtime(maat_instance->tbl_mgr, table_id); + if (maat_inst->maat_rt != NULL) { + void *runtime = table_manager_get_runtime(maat_inst->tbl_mgr, table_id); assert(runtime != NULL); compile_runtime_ex_data_iterate((struct compile_runtime *)runtime, (struct compile_schema *)schema); @@ -672,31 +672,31 @@ int generic_plugin_runtime_commit_ex_schema(void *runtime, void *schema, const c return 0; } -int generic_plugin_table_ex_schema_register(struct maat *maat_instance, +int generic_plugin_table_ex_schema_register(struct maat *maat_inst, const char *table_name, int table_id, maat_ex_new_func_t *new_func, maat_ex_free_func_t *free_func, maat_ex_dup_func_t *dup_func, long argl, void *argp) { - int ret = generic_plugin_table_set_ex_schema(maat_instance->tbl_mgr, table_id, + int ret = generic_plugin_table_set_ex_schema(maat_inst->tbl_mgr, table_id, new_func, free_func, dup_func, - argl, argp, maat_instance->logger); + argl, argp, maat_inst->logger); if (ret < 0) { return -1; } enum table_type table_type = TABLE_TYPE_INVALID; int valid_column = -1; - if (maat_instance->maat_rt != NULL) { - void *runtime = table_manager_get_runtime(maat_instance->tbl_mgr, table_id); - void *schema = table_manager_get_schema(maat_instance->tbl_mgr, table_id); + if (maat_inst->maat_rt != NULL) { + void *runtime = table_manager_get_runtime(maat_inst->tbl_mgr, table_id); + void *schema = table_manager_get_schema(maat_inst->tbl_mgr, table_id); assert(runtime != NULL && schema != NULL); - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, table_id); - valid_column = table_manager_get_valid_column(maat_instance->tbl_mgr, table_id); + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); + valid_column = table_manager_get_valid_column(maat_inst->tbl_mgr, table_id); if (table_type == TABLE_TYPE_INVALID || valid_column < 0) { - log_error(maat_instance->logger, MODULE_MAAT_API, + log_error(maat_inst->logger, MODULE_MAAT_API, "[%s:%d] table_type:%d or valid_column:%d invalid", __FUNCTION__, __LINE__, table_type, valid_column); return -1; @@ -704,62 +704,62 @@ int generic_plugin_table_ex_schema_register(struct maat *maat_instance, ret = generic_plugin_runtime_commit_ex_schema(runtime, schema, table_name, table_type, valid_column, - maat_instance->logger); + maat_inst->logger); } return ret; } -int maat_plugin_table_ex_schema_register(struct maat *maat_instance, +int maat_plugin_table_ex_schema_register(struct maat *maat_inst, const char *table_name, maat_ex_new_func_t *new_func, maat_ex_free_func_t *free_func, maat_ex_dup_func_t *dup_func, long argl, void *argp) { - if (NULL == maat_instance || NULL == table_name) { - log_error(maat_instance->logger, MODULE_MAAT_API, + if (NULL == maat_inst || NULL == table_name) { + log_error(maat_inst->logger, MODULE_MAAT_API, "[%s:%d] [table:%s] ex_schema register input parameter is invalid.", __FUNCTION__, __LINE__, table_name); return -1; } - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); if (table_id < 0) { - log_error(maat_instance->logger, MODULE_MAAT_API, + log_error(maat_inst->logger, MODULE_MAAT_API, "[%s:%d] [table:%s] is not registered before.", __FUNCTION__, __LINE__, table_name); return -1; } - pthread_mutex_lock(&(maat_instance->background_update_mutex)); + pthread_mutex_lock(&(maat_inst->background_update_mutex)); int ret = -1; - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (TABLE_TYPE_COMPILE == table_type) { - ret = compile_table_ex_schema_register(maat_instance, table_id, new_func, + ret = compile_table_ex_schema_register(maat_inst, table_id, new_func, free_func, dup_func, argl, argp); } else { - ret = generic_plugin_table_ex_schema_register(maat_instance, table_name, + ret = generic_plugin_table_ex_schema_register(maat_inst, table_name, table_id, new_func, free_func, dup_func, argl, argp); } - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); return ret; } -void *maat_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, +void *maat_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, const char *key, size_t key_len) { - if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM + if (NULL == maat_inst || table_id < 0 || table_id >= MAX_TABLE_NUM || NULL == key) { return NULL; } - struct maat_runtime *maat_rt = maat_instance->maat_rt; + struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { return NULL; } @@ -775,7 +775,7 @@ void *maat_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, } void *ret = NULL; - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (TABLE_TYPE_COMPILE == table_type) { ret = compile_runtime_get_ex_data(runtime, schema, *(long long *)key); @@ -788,16 +788,16 @@ void *maat_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, return ret; } -int maat_ip_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, +int maat_ip_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, const struct ip_addr *ip_addr, void **ex_data_array, size_t n_ex_data) { - if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM + if (NULL == maat_inst || table_id < 0 || table_id >= MAX_TABLE_NUM || NULL == ip_addr || NULL == ex_data_array || 0 == n_ex_data) { return -1; } - struct maat_runtime *maat_rt = maat_instance->maat_rt; + struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { return -1; } @@ -816,16 +816,16 @@ int maat_ip_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, return n_hit_ex_data; } -int maat_fqdn_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, +int maat_fqdn_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, const char *fqdn, void **ex_data_array, size_t n_ex_data) { - if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM + if (NULL == maat_inst || table_id < 0 || table_id >= MAX_TABLE_NUM || NULL == fqdn || NULL == ex_data_array || 0 == n_ex_data) { return -1; } - struct maat_runtime *maat_rt = maat_instance->maat_rt; + struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { return -1; } @@ -844,16 +844,16 @@ int maat_fqdn_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, return n_hit_ex_data; } -int maat_bool_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, +int maat_bool_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, unsigned long long *item_ids, size_t n_item, void **ex_data_array, size_t n_ex_data) { - if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM + if (NULL == maat_inst || table_id < 0 || table_id >= MAX_TABLE_NUM || NULL == item_ids || NULL == ex_data_array || 0 == n_ex_data) { return -1; } - struct maat_runtime *maat_rt = maat_instance->maat_rt; + struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { return -1; } @@ -1039,7 +1039,7 @@ int expr_stream_scan(struct maat_stream *stream, const char *data, size_t data_l return 0; } - struct table_manager *tbl_mgr = stream->ref_maat_instance->tbl_mgr; + struct table_manager *tbl_mgr = stream->ref_maat_inst->tbl_mgr; enum table_type table_type = table_manager_get_table_type(tbl_mgr, stream->physical_table_id); if (table_type == TABLE_TYPE_EXPR_PLUS && DISTRICT_FLAG_UNSET == state->is_set_district) { @@ -1055,7 +1055,7 @@ int expr_stream_scan(struct maat_stream *stream, const char *data, size_t data_l return -1; } - int group_hit_cnt = expr_runtime_stream_scan((struct expr_runtime *)expr_rt, stream->s_handle, + int group_hit_cnt = expr_runtime_stream_scan((struct expr_runtime *)expr_rt, stream->handle, data, data_len, stream->vtable_id, state); if (group_hit_cnt <= 0) { return group_hit_cnt; @@ -1066,7 +1066,7 @@ int expr_stream_scan(struct maat_stream *stream, const char *data, size_t data_l return group_hit_cnt; } -size_t group_to_compile(struct maat *maat_instance, long long *results, size_t n_result, +size_t group_to_compile(struct maat *maat_inst, long long *results, size_t n_result, struct maat_state *state) { int compile_table_id = -1; @@ -1074,10 +1074,10 @@ size_t group_to_compile(struct maat *maat_instance, long long *results, size_t n if (state->compile_table_id > 0) { compile_table_id = state->compile_table_id; } else { - compile_table_id = table_manager_get_default_compile_table_id(maat_instance->tbl_mgr); + compile_table_id = table_manager_get_default_compile_table_id(maat_inst->tbl_mgr); } - void *compile_rt = table_manager_get_runtime(maat_instance->tbl_mgr, compile_table_id); + void *compile_rt = table_manager_get_runtime(maat_inst->tbl_mgr, compile_table_id); if (NULL == compile_rt) { return 0; } @@ -1092,84 +1092,84 @@ size_t group_to_compile(struct maat *maat_instance, long long *results, size_t n return n_hit_compile; } -int maat_scan_flag(struct maat *maat_instance, int table_id, +int maat_scan_flag(struct maat *maat_inst, int table_id, long long flag, long long *results, size_t n_result, size_t *n_hit_result, struct maat_state *state) { - if ((NULL == maat_instance) || table_id < 0 || table_id >= MAX_TABLE_NUM + if ((NULL == maat_inst) || table_id < 0 || table_id >= MAX_TABLE_NUM || (NULL == results) || (0 == n_result) || (NULL == state) || (state->thread_id < 0)) { return MAAT_SCAN_ERR; } struct timespec start, end; - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &start); } state->scan_cnt++; - if (NULL == maat_instance->maat_rt) { + if (NULL == maat_inst->maat_rt) { return MAAT_SCAN_OK; } int vtable_id = 0; int physical_table_id = -1; - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, table_id); + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (table_type == TABLE_TYPE_VIRTUAL) { - physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, table_id); + physical_table_id = vtable_get_physical_table_id(maat_inst->tbl_mgr, table_id); vtable_id = table_id; } else { physical_table_id = table_id; } if (physical_table_id < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, physical_table_id); + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, physical_table_id); if (table_type != TABLE_TYPE_FLAG && table_type != TABLE_TYPE_FLAG_PLUS) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - maat_runtime_ref_inc(maat_instance->maat_rt, state->thread_id); - alignment_int64_array_add(maat_instance->stat->thread_call_cnt, state->thread_id, 1); + maat_runtime_ref_inc(maat_inst->maat_rt, state->thread_id); + alignment_int64_array_add(maat_inst->stat->thread_call_cnt, state->thread_id, 1); - int hit_group_cnt = flag_scan(maat_instance->tbl_mgr, state->thread_id, flag, + int hit_group_cnt = flag_scan(maat_inst->tbl_mgr, state->thread_id, flag, physical_table_id, vtable_id, state); if (hit_group_cnt < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } size_t sum_hit_compile_cnt = 0; if (hit_group_cnt > 0 || scan_status_should_compile_NOT(state)) { - sum_hit_compile_cnt = group_to_compile(maat_instance, results, n_result, state); + sum_hit_compile_cnt = group_to_compile(maat_inst, results, n_result, state); *n_hit_result = sum_hit_compile_cnt; } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_instance->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); if (0 == hit_group_cnt) { //hit NOT group - alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + alignment_int64_array_add(maat_inst->stat->not_grp_hit_cnt, state->thread_id, 1); } } - void *flag_rt = table_manager_get_runtime(maat_instance->tbl_mgr, physical_table_id); + void *flag_rt = table_manager_get_runtime(maat_inst->tbl_mgr, physical_table_id); assert(flag_rt != NULL); - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &end); flag_runtime_perf_stat(flag_rt, &start, &end, state->thread_id); } else { flag_runtime_perf_stat(flag_rt, NULL, NULL, state->thread_id); } - maat_runtime_ref_dec(maat_instance->maat_rt, state->thread_id); + maat_runtime_ref_dec(maat_inst->maat_rt, state->thread_id); if (sum_hit_compile_cnt > 0) { return MAAT_SCAN_HIT; @@ -1180,33 +1180,33 @@ int maat_scan_flag(struct maat *maat_instance, int table_id, } } -int maat_scan_integer(struct maat *maat_instance, int table_id, +int maat_scan_integer(struct maat *maat_inst, int table_id, long long integer, long long *results, size_t n_result, size_t *n_hit_result, struct maat_state *state) { - if ((NULL == maat_instance) || table_id < 0 || table_id >= MAX_TABLE_NUM + if ((NULL == maat_inst) || table_id < 0 || table_id >= MAX_TABLE_NUM || (NULL == results) || (0 == n_result) || (NULL == state) || (state->thread_id < 0)) { return MAAT_SCAN_ERR; } struct timespec start, end; - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &start); } state->scan_cnt++; - if (NULL == maat_instance->maat_rt) { + if (NULL == maat_inst->maat_rt) { return MAAT_SCAN_OK; } int vtable_id = 0; int physical_table_id = -1; - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (table_type == TABLE_TYPE_VIRTUAL) { - physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, + physical_table_id = vtable_get_physical_table_id(maat_inst->tbl_mgr, table_id); vtable_id = table_id; } else { @@ -1214,53 +1214,53 @@ int maat_scan_integer(struct maat *maat_instance, int table_id, } if (physical_table_id < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, physical_table_id); + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, physical_table_id); if (table_type != TABLE_TYPE_INTERVAL && table_type != TABLE_TYPE_INTERVAL_PLUS) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - maat_runtime_ref_inc(maat_instance->maat_rt, state->thread_id); - alignment_int64_array_add(maat_instance->stat->thread_call_cnt, state->thread_id, 1); + maat_runtime_ref_inc(maat_inst->maat_rt, state->thread_id); + alignment_int64_array_add(maat_inst->stat->thread_call_cnt, state->thread_id, 1); - int hit_group_cnt = interval_scan(maat_instance->tbl_mgr, state->thread_id, integer, + int hit_group_cnt = interval_scan(maat_inst->tbl_mgr, state->thread_id, integer, physical_table_id, vtable_id, state); if (hit_group_cnt < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } size_t sum_hit_compile_cnt = 0; if (hit_group_cnt > 0 || scan_status_should_compile_NOT(state)) { - sum_hit_compile_cnt = group_to_compile(maat_instance, results, n_result, state); + sum_hit_compile_cnt = group_to_compile(maat_inst, results, n_result, state); *n_hit_result = sum_hit_compile_cnt; } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_instance->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); if (0 == hit_group_cnt) { //hit NOT group - alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + alignment_int64_array_add(maat_inst->stat->not_grp_hit_cnt, state->thread_id, 1); } } - void *interval_rt = table_manager_get_runtime(maat_instance->tbl_mgr, + void *interval_rt = table_manager_get_runtime(maat_inst->tbl_mgr, physical_table_id); assert(interval_rt != NULL); - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &end); interval_runtime_perf_stat(interval_rt, &start, &end, state->thread_id); } else { interval_runtime_perf_stat(interval_rt, NULL, NULL, state->thread_id); } - maat_runtime_ref_dec(maat_instance->maat_rt, state->thread_id); + maat_runtime_ref_dec(maat_inst->maat_rt, state->thread_id); if (sum_hit_compile_cnt > 0) { return MAAT_SCAN_HIT; @@ -1271,33 +1271,33 @@ int maat_scan_integer(struct maat *maat_instance, int table_id, } } -int maat_scan_ipv4(struct maat *maat_instance, int table_id, uint32_t ip_addr, +int maat_scan_ipv4(struct maat *maat_inst, int table_id, uint32_t ip_addr, uint16_t port, int protocol, long long *results, size_t n_result, size_t *n_hit_result, struct maat_state *state) { - if ((NULL == maat_instance) || table_id < 0 || table_id >= MAX_TABLE_NUM + if ((NULL == maat_inst) || table_id < 0 || table_id >= MAX_TABLE_NUM || (protocol < -1) || (NULL == results) || (0 == n_result) || (NULL == state) || (state->thread_id < 0)) { return MAAT_SCAN_ERR; } struct timespec start, end; - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &start); } state->scan_cnt++; - if (NULL == maat_instance->maat_rt) { + if (NULL == maat_inst->maat_rt) { return MAAT_SCAN_OK; } int vtable_id = 0; int physical_table_id = -1; - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (table_type == TABLE_TYPE_VIRTUAL) { - physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, + physical_table_id = vtable_get_physical_table_id(maat_inst->tbl_mgr, table_id); vtable_id = table_id; } else { @@ -1305,52 +1305,52 @@ int maat_scan_ipv4(struct maat *maat_instance, int table_id, uint32_t ip_addr, } if (physical_table_id < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, physical_table_id); + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, physical_table_id); if (table_type != TABLE_TYPE_IP_PLUS) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - maat_runtime_ref_inc(maat_instance->maat_rt, state->thread_id); - alignment_int64_array_add(maat_instance->stat->thread_call_cnt, state->thread_id, 1); + maat_runtime_ref_inc(maat_inst->maat_rt, state->thread_id); + alignment_int64_array_add(maat_inst->stat->thread_call_cnt, state->thread_id, 1); - int hit_group_cnt = ipv4_scan(maat_instance->tbl_mgr, state->thread_id, ip_addr, + int hit_group_cnt = ipv4_scan(maat_inst->tbl_mgr, state->thread_id, ip_addr, port, protocol, physical_table_id, vtable_id, state); if (hit_group_cnt < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } size_t sum_hit_compile_cnt = 0; if (hit_group_cnt > 0 || scan_status_should_compile_NOT(state)) { - sum_hit_compile_cnt = group_to_compile(maat_instance, results, n_result, state); + sum_hit_compile_cnt = group_to_compile(maat_inst, results, n_result, state); *n_hit_result = sum_hit_compile_cnt; } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_instance->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); if (0 == hit_group_cnt) { //hit NOT group - alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + alignment_int64_array_add(maat_inst->stat->not_grp_hit_cnt, state->thread_id, 1); } } - void *ip_rt = table_manager_get_runtime(maat_instance->tbl_mgr, physical_table_id); + void *ip_rt = table_manager_get_runtime(maat_inst->tbl_mgr, physical_table_id); assert(ip_rt != NULL); - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &end); ip_runtime_perf_stat(ip_rt, &start, &end, state->thread_id); } else { ip_runtime_perf_stat(ip_rt, NULL, NULL, state->thread_id); } - maat_runtime_ref_dec(maat_instance->maat_rt, state->thread_id); + maat_runtime_ref_dec(maat_inst->maat_rt, state->thread_id); if (sum_hit_compile_cnt > 0) { return MAAT_SCAN_HIT; @@ -1361,34 +1361,34 @@ int maat_scan_ipv4(struct maat *maat_instance, int table_id, uint32_t ip_addr, } } -int maat_scan_ipv6(struct maat *maat_instance, int table_id, +int maat_scan_ipv6(struct maat *maat_inst, int table_id, uint8_t *ip_addr, uint16_t port, int protocol, long long *results, size_t n_result, size_t *n_hit_result, struct maat_state *state) { - if ((NULL == maat_instance) || table_id < 0 || table_id >= MAX_TABLE_NUM + if ((NULL == maat_inst) || table_id < 0 || table_id >= MAX_TABLE_NUM || (protocol < -1) || (NULL == ip_addr) || (NULL == results) || (0 == n_result) || (NULL == state) || (state->thread_id < 0)) { return MAAT_SCAN_ERR; } struct timespec start, end; - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &start); } state->scan_cnt++; - if (NULL == maat_instance->maat_rt) { + if (NULL == maat_inst->maat_rt) { return MAAT_SCAN_OK; } int vtable_id = 0; int physical_table_id = -1; - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (table_type == TABLE_TYPE_VIRTUAL) { - physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, + physical_table_id = vtable_get_physical_table_id(maat_inst->tbl_mgr, table_id); vtable_id = table_id; } else { @@ -1396,52 +1396,52 @@ int maat_scan_ipv6(struct maat *maat_instance, int table_id, } if (physical_table_id < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, physical_table_id); + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, physical_table_id); if (table_type != TABLE_TYPE_IP_PLUS) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - maat_runtime_ref_inc(maat_instance->maat_rt, state->thread_id); - alignment_int64_array_add(maat_instance->stat->thread_call_cnt, state->thread_id, 1); + maat_runtime_ref_inc(maat_inst->maat_rt, state->thread_id); + alignment_int64_array_add(maat_inst->stat->thread_call_cnt, state->thread_id, 1); - int hit_group_cnt = ipv6_scan(maat_instance->tbl_mgr, state->thread_id, ip_addr, + int hit_group_cnt = ipv6_scan(maat_inst->tbl_mgr, state->thread_id, ip_addr, port, protocol, physical_table_id, vtable_id, state); if (hit_group_cnt < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } size_t sum_hit_compile_cnt = 0; if (hit_group_cnt > 0 || scan_status_should_compile_NOT(state)) { - sum_hit_compile_cnt = group_to_compile(maat_instance, results, n_result, state); + sum_hit_compile_cnt = group_to_compile(maat_inst, results, n_result, state); *n_hit_result = sum_hit_compile_cnt; } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_instance->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); if (0 == hit_group_cnt) { //hit NOT group - alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + alignment_int64_array_add(maat_inst->stat->not_grp_hit_cnt, state->thread_id, 1); } } - void *ip_rt = table_manager_get_runtime(maat_instance->tbl_mgr, physical_table_id); + void *ip_rt = table_manager_get_runtime(maat_inst->tbl_mgr, physical_table_id); assert(ip_rt != NULL); - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &end); ip_runtime_perf_stat(ip_rt, &start, &end, state->thread_id); } else { ip_runtime_perf_stat(ip_rt, NULL, NULL, state->thread_id); } - maat_runtime_ref_dec(maat_instance->maat_rt, state->thread_id); + maat_runtime_ref_dec(maat_inst->maat_rt, state->thread_id); if (sum_hit_compile_cnt > 0) { return MAAT_SCAN_HIT; @@ -1452,33 +1452,33 @@ int maat_scan_ipv6(struct maat *maat_instance, int table_id, } } -int maat_scan_string(struct maat *maat_instance, int table_id, const char *data, +int maat_scan_string(struct maat *maat_inst, int table_id, const char *data, size_t data_len, long long *results, size_t n_result, size_t *n_hit_result, struct maat_state *state) { - if ((NULL == maat_instance) || table_id < 0 || table_id >= MAX_TABLE_NUM + if ((NULL == maat_inst) || table_id < 0 || table_id >= MAX_TABLE_NUM || (NULL == data) || (0 == data_len) || (NULL == results) || (0 == n_result) || (NULL == state) || (state->thread_id < 0)) { return MAAT_SCAN_ERR; } struct timespec start, end; - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &start); } state->scan_cnt++; - if (NULL == maat_instance->maat_rt) { + if (NULL == maat_inst->maat_rt) { return MAAT_SCAN_OK; } int vtable_id = 0; int physical_table_id = -1; - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (table_type == TABLE_TYPE_VIRTUAL) { - physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, + physical_table_id = vtable_get_physical_table_id(maat_inst->tbl_mgr, table_id); vtable_id = table_id; } else { @@ -1486,52 +1486,52 @@ int maat_scan_string(struct maat *maat_instance, int table_id, const char *data, } if (physical_table_id < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, physical_table_id); + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, physical_table_id); if (table_type != TABLE_TYPE_EXPR && table_type != TABLE_TYPE_EXPR_PLUS) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } - maat_runtime_ref_inc(maat_instance->maat_rt, state->thread_id); - alignment_int64_array_add(maat_instance->stat->thread_call_cnt, state->thread_id, 1); + maat_runtime_ref_inc(maat_inst->maat_rt, state->thread_id); + alignment_int64_array_add(maat_inst->stat->thread_call_cnt, state->thread_id, 1); - int hit_group_cnt = string_scan(maat_instance->tbl_mgr, state->thread_id, data, data_len, + int hit_group_cnt = string_scan(maat_inst->tbl_mgr, state->thread_id, data, data_len, physical_table_id, vtable_id, state); if (hit_group_cnt < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } size_t sum_hit_compile_cnt = 0; if (hit_group_cnt > 0 || scan_status_should_compile_NOT(state)) { - sum_hit_compile_cnt = group_to_compile(maat_instance, results, n_result, state); + sum_hit_compile_cnt = group_to_compile(maat_inst, results, n_result, state); *n_hit_result = sum_hit_compile_cnt; } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_instance->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); if (0 == hit_group_cnt) { //hit NOT group - alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + alignment_int64_array_add(maat_inst->stat->not_grp_hit_cnt, state->thread_id, 1); } } - void *expr_rt = table_manager_get_runtime(maat_instance->tbl_mgr, physical_table_id); + void *expr_rt = table_manager_get_runtime(maat_inst->tbl_mgr, physical_table_id); assert(expr_rt != NULL); - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &end); expr_runtime_perf_stat(expr_rt, data_len, &start, &end, state->thread_id); } else { expr_runtime_perf_stat(expr_rt, data_len, NULL, NULL, state->thread_id); } - maat_runtime_ref_dec(maat_instance->maat_rt, state->thread_id); + maat_runtime_ref_dec(maat_inst->maat_rt, state->thread_id); if (sum_hit_compile_cnt > 0) { return MAAT_SCAN_HIT; @@ -1542,24 +1542,24 @@ int maat_scan_string(struct maat *maat_instance, int table_id, const char *data, } } -struct maat_stream *maat_stream_new(struct maat *maat_instance, int table_id, +struct maat_stream *maat_stream_new(struct maat *maat_inst, int table_id, struct maat_state *state) { - if (NULL == maat_instance || table_id < 0 || table_id > MAX_TABLE_NUM + if (NULL == maat_inst || table_id < 0 || table_id > MAX_TABLE_NUM || NULL == state || state->thread_id < 0) { return NULL; } struct maat_stream *stream = ALLOC(struct maat_stream, 1); - stream->ref_maat_instance = maat_instance; - stream->last_full_version = maat_instance->last_full_version; + stream->ref_maat_inst = maat_inst; + stream->last_full_version = maat_inst->last_full_version; stream->thread_id = state->thread_id; - stream->logger = maat_instance->logger; + stream->logger = maat_inst->logger; - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (table_type == TABLE_TYPE_VIRTUAL) { - stream->physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, + stream->physical_table_id = vtable_get_physical_table_id(maat_inst->tbl_mgr, table_id); stream->vtable_id = table_id; } else { @@ -1571,23 +1571,24 @@ struct maat_stream *maat_stream_new(struct maat *maat_instance, int table_id, return NULL; } - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, stream->physical_table_id); if (table_type != TABLE_TYPE_EXPR && table_type != TABLE_TYPE_EXPR_PLUS) { return NULL; } - void *expr_rt = table_manager_get_runtime(stream->ref_maat_instance->tbl_mgr, + void *expr_rt = table_manager_get_runtime(stream->ref_maat_inst->tbl_mgr, stream->physical_table_id); assert(expr_rt != NULL); stream->expr_rt_version = expr_runtime_get_version(expr_rt); + maat_runtime_ref_inc(maat_inst->maat_rt, state->thread_id); struct adapter_hs_stream *handle = expr_runtime_stream_open((struct expr_runtime *)expr_rt, state->thread_id); if (NULL == handle) { goto error; } - stream->s_handle = handle; + stream->handle = handle; return stream; @@ -1606,18 +1607,18 @@ int maat_stream_scan(struct maat_stream *maat_stream, const char *data, int data } struct timespec start, end; - if (1 == maat_stream->ref_maat_instance->opts.perf_on) { + if (1 == maat_stream->ref_maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &start); } state->scan_cnt++; - struct maat *maat_instance = maat_stream->ref_maat_instance; - if (maat_stream->last_full_version != maat_instance->last_full_version) { + struct maat *maat_inst = maat_stream->ref_maat_inst; + if (maat_stream->last_full_version != maat_inst->last_full_version) { return MAAT_SCAN_OK; } - void *expr_rt = table_manager_get_runtime(maat_instance->tbl_mgr, + void *expr_rt = table_manager_get_runtime(maat_inst->tbl_mgr, maat_stream->physical_table_id); assert(expr_rt != NULL); @@ -1626,31 +1627,31 @@ int maat_stream_scan(struct maat_stream *maat_stream, const char *data, int data return MAAT_SCAN_OK; } - alignment_int64_array_add(maat_instance->stat->thread_call_cnt, + alignment_int64_array_add(maat_inst->stat->thread_call_cnt, maat_stream->thread_id, 1); int hit_group_cnt = expr_stream_scan(maat_stream, data, data_len, state); if (hit_group_cnt < 0) { - maat_instance->stat->scan_err_cnt++; + maat_inst->stat->scan_err_cnt++; return MAAT_SCAN_ERR; } size_t sum_hit_compile_cnt = 0; if (hit_group_cnt > 0 || scan_status_should_compile_NOT(state)) { - sum_hit_compile_cnt = group_to_compile(maat_instance, results, n_result, state); + sum_hit_compile_cnt = group_to_compile(maat_inst, results, n_result, state); *n_hit_result = sum_hit_compile_cnt; } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_instance->stat->hit_cnt, maat_stream->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_cnt, maat_stream->thread_id, 1); if (0 == hit_group_cnt) { //hit NOT group - alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + alignment_int64_array_add(maat_inst->stat->not_grp_hit_cnt, maat_stream->thread_id, 1); } } - if (1 == maat_instance->opts.perf_on) { + if (1 == maat_inst->opts.perf_on) { clock_gettime(CLOCK_MONOTONIC, &end); expr_runtime_perf_stat(expr_rt, data_len, &start, &end, state->thread_id); } else { @@ -1672,30 +1673,39 @@ void maat_stream_free(struct maat_stream *maat_stream) return; } - void *expr_rt = table_manager_get_runtime(maat_stream->ref_maat_instance->tbl_mgr, + struct maat *maat_inst = maat_stream->ref_maat_inst; + void *expr_rt = table_manager_get_runtime(maat_inst->tbl_mgr, maat_stream->physical_table_id); assert(expr_rt != NULL); - expr_runtime_stream_close(expr_rt, maat_stream->thread_id, maat_stream->s_handle); + long long cur_expr_rt_version = expr_runtime_get_version(expr_rt); + if ((maat_stream->last_full_version == maat_inst->last_full_version) && + (maat_stream->expr_rt_version == cur_expr_rt_version)) { + maat_runtime_ref_dec(maat_inst->maat_rt, maat_stream->thread_id); + } else { + maat_inst->stat->zombie_rs_stream--; + } + + expr_runtime_stream_close(expr_rt, maat_stream->thread_id, maat_stream->handle); FREE(maat_stream); } -struct maat_state *maat_state_new(struct maat *maat_instance, int thread_id) +struct maat_state *maat_state_new(struct maat *maat_inst, int thread_id) { - if (NULL == maat_instance || thread_id < 0) { + if (NULL == maat_inst || thread_id < 0) { return NULL; } struct maat_state *state = ALLOC(struct maat_state, 1); - state->maat_instance = maat_instance; + state->maat_inst = maat_inst; state->is_set_district = DISTRICT_FLAG_UNSET; state->is_last_scan = LAST_SCAN_UNSET; state->district_id = DISTRICT_ANY; state->thread_id = thread_id; //state->compile_state no need to alloc memory at this point, but alloc it after hitting items - alignment_int64_array_add(maat_instance->stat->maat_state_cnt, thread_id, 1); + alignment_int64_array_add(maat_inst->stat->maat_state_cnt, thread_id, 1); return state; } @@ -1723,26 +1733,26 @@ void maat_state_free(struct maat_state *state) return; } - assert(state->maat_instance != NULL); + assert(state->maat_inst != NULL); - struct maat *maat_instance = state->maat_instance; + struct maat *maat_inst = state->maat_inst; long long thread_id = state->thread_id; if (state->compile_state != NULL) { - maat_compile_state_free(state->compile_state, maat_instance, thread_id); + maat_compile_state_free(state->compile_state, maat_inst, thread_id); state->compile_state = NULL; - alignment_int64_array_add(maat_instance->stat->maat_compile_state_cnt, + alignment_int64_array_add(maat_inst->stat->maat_compile_state_cnt, thread_id, -1); } - state->maat_instance = NULL; + state->maat_inst = NULL; FREE(state); - alignment_int64_array_add(maat_instance->stat->maat_state_cnt, + alignment_int64_array_add(maat_inst->stat->maat_state_cnt, thread_id, -1); - alignment_int64_array_add(maat_instance->stat->maat_state_free_cnt, + alignment_int64_array_add(maat_inst->stat->maat_state_free_cnt, thread_id, 1); - alignment_int64_array_add(maat_instance->stat->maat_state_free_bytes, + alignment_int64_array_add(maat_inst->stat->maat_state_free_bytes, thread_id, sizeof(struct maat_state)); } @@ -1753,35 +1763,35 @@ int maat_state_set_scan_district(struct maat_state *state, int vtable_id, return -1; } - struct maat *maat_instance = state->maat_instance; - assert(maat_instance != NULL); + struct maat *maat_inst = state->maat_inst; + assert(maat_inst != NULL); - if (NULL == maat_instance->maat_rt) { - log_error(maat_instance->logger, MODULE_MAAT_API, + if (NULL == maat_inst->maat_rt) { + log_error(maat_inst->logger, MODULE_MAAT_API, "maat runtime is NULL, can't set district"); return -1; } - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, vtable_id); if (table_type != TABLE_TYPE_FLAG_PLUS && table_type != TABLE_TYPE_EXPR_PLUS && table_type != TABLE_TYPE_INTERVAL_PLUS && table_type != TABLE_TYPE_VIRTUAL) { - log_error(maat_instance->logger, MODULE_MAAT_API, + log_error(maat_inst->logger, MODULE_MAAT_API, "table_type:%d is invalid, can't set district", table_type); return -1; } int physical_table_id = vtable_id; if (table_type == TABLE_TYPE_VIRTUAL) { - physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, + physical_table_id = vtable_get_physical_table_id(maat_inst->tbl_mgr, vtable_id); } int ret = -1; long long district_id; - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, physical_table_id); - void *runtime = table_manager_get_runtime(maat_instance->tbl_mgr, + void *runtime = table_manager_get_runtime(maat_inst->tbl_mgr, physical_table_id); assert(runtime != NULL); @@ -1799,7 +1809,7 @@ int maat_state_set_scan_district(struct maat_state *state, int vtable_id, district, district_len, &district_id); break; default: - log_error(maat_instance->logger, MODULE_MAAT_API, + log_error(maat_inst->logger, MODULE_MAAT_API, "[%s:%d] table_type:%d can't set district", __FUNCTION__, __LINE__, table_type); break; @@ -1822,10 +1832,10 @@ int maat_state_set_last_scan(struct maat_state *state) return -1; } - struct maat *maat_instance = state->maat_instance; - assert(maat_instance != NULL); + struct maat *maat_inst = state->maat_inst; + assert(maat_inst != NULL); - if (NULL == maat_instance->maat_rt) { + if (NULL == maat_inst->maat_rt) { return -1; } @@ -1841,10 +1851,10 @@ int maat_state_set_scan_compile_table(struct maat_state *state, int compile_tabl return -1; } - struct maat *maat_instance = state->maat_instance; - assert(maat_instance != NULL); + struct maat *maat_inst = state->maat_inst; + assert(maat_inst != NULL); - if (NULL == maat_instance->maat_rt) { + if (NULL == maat_inst->maat_rt) { return -1; } @@ -1860,10 +1870,10 @@ int maat_state_get_hit_paths(struct maat_state *state, struct maat_hit_path *pat return -1; } - struct maat *maat_instance = state->maat_instance; - assert(maat_instance != NULL); + struct maat *maat_inst = state->maat_inst; + assert(maat_inst != NULL); - if (NULL == maat_instance->maat_rt) { + if (NULL == maat_inst->maat_rt) { return -1; } @@ -1871,17 +1881,17 @@ int maat_state_get_hit_paths(struct maat_state *state, struct maat_hit_path *pat if (state->compile_table_id > 0) { compile_table_id = state->compile_table_id; } else { - compile_table_id = table_manager_get_default_compile_table_id(maat_instance->tbl_mgr); + compile_table_id = table_manager_get_default_compile_table_id(maat_inst->tbl_mgr); } - void *compile_rt = table_manager_get_runtime(maat_instance->tbl_mgr, + void *compile_rt = table_manager_get_runtime(maat_inst->tbl_mgr, compile_table_id); if (NULL == compile_rt) { return -1; } - int g2g_table_id = table_manager_get_group2group_table_id(maat_instance->tbl_mgr); - void *g2g_runtime = table_manager_get_runtime(maat_instance->tbl_mgr, g2g_table_id); + int g2g_table_id = table_manager_get_group2group_table_id(maat_inst->tbl_mgr); + void *g2g_runtime = table_manager_get_runtime(maat_inst->tbl_mgr, g2g_table_id); size_t internal_hit_path_cnt = maat_compile_state_get_internal_hit_paths(state->compile_state, (struct compile_runtime *)compile_rt, @@ -1899,8 +1909,8 @@ int maat_state_get_hit_groups(struct maat_state *state, struct maat_hit_group *g return -1; } - int g2g_table_id = table_manager_get_group2group_table_id(state->maat_instance->tbl_mgr); - void *g2g_runtime = table_manager_get_runtime(state->maat_instance->tbl_mgr, g2g_table_id); + int g2g_table_id = table_manager_get_group2group_table_id(state->maat_inst->tbl_mgr); + void *g2g_runtime = table_manager_get_runtime(state->maat_inst->tbl_mgr, g2g_table_id); return maat_compile_state_get_hit_groups(state->compile_state, (struct group2group_runtime *)g2g_runtime, diff --git a/src/maat_bool_plugin.c b/src/maat_bool_plugin.c index 409aa78..696134a 100644 --- a/src/maat_bool_plugin.c +++ b/src/maat_bool_plugin.c @@ -32,7 +32,6 @@ struct bool_plugin_schema { struct bool_plugin_runtime { struct bool_matcher *matcher; struct ex_data_runtime *ex_data_rt; - long long version; long long rule_num; size_t n_worker_thread; struct maat_garbage_bin *ref_garbage_bin; @@ -493,13 +492,10 @@ int bool_plugin_runtime_commit(void *bool_plugin_runtime, const char *table_name } bool_plugin_rt->rule_num = rule_cnt; - if (maat_rt_version != 0) { - bool_plugin_rt->version = maat_rt_version; - } log_info(bool_plugin_rt->logger, MODULE_BOOL_PLUGIN, "table[%s] commit %zu bool_plugin rules and rebuild bool_matcher completed" - ", version:%lld", table_name, rule_cnt, bool_plugin_rt->version); + ", version:%lld", table_name, rule_cnt, maat_rt_version); if (rules != NULL) { FREE(rules); diff --git a/src/maat_command.c b/src/maat_command.c index 9534fef..e98e664 100644 --- a/src/maat_command.c +++ b/src/maat_command.c @@ -184,31 +184,31 @@ static int connect_redis_for_write(struct source_redis_ctx *redis_ctx, } } -redisContext *get_redis_ctx_for_write(struct maat *maat_instance) +redisContext *get_redis_ctx_for_write(struct maat *maat_inst) { - if (NULL == maat_instance->opts.redis_ctx.write_ctx) { - int ret = connect_redis_for_write(&(maat_instance->opts.redis_ctx), - maat_instance->logger); + if (NULL == maat_inst->opts.redis_ctx.write_ctx) { + int ret = connect_redis_for_write(&(maat_inst->opts.redis_ctx), + maat_inst->logger); if (ret != 0) { return NULL; } } - return maat_instance->opts.redis_ctx.write_ctx; + return maat_inst->opts.redis_ctx.write_ctx; } -int maat_cmd_flushDB(struct maat *maat_instance) +int maat_cmd_flushDB(struct maat *maat_inst) { int ret = 0; - redisContext *write_ctx = get_redis_ctx_for_write(maat_instance); + redisContext *write_ctx = get_redis_ctx_for_write(maat_inst); if (NULL == write_ctx) { return -1; } do { - ret = redis_flushDB(maat_instance->opts.redis_ctx.write_ctx, - maat_instance->opts.redis_ctx.redis_db, - maat_instance->logger); + ret = redis_flushDB(maat_inst->opts.redis_ctx.write_ctx, + maat_inst->opts.redis_ctx.redis_db, + maat_inst->logger); } while(0 == ret); return 0; @@ -317,13 +317,13 @@ int maat_cmd_wrap_redis_get_reply(redisContext *c, redisReply **reply) return redisGetReply(c, (void **)reply); } -int maat_cmd_set_line(struct maat *maat_instance, const struct maat_cmd_line *line_rule) +int maat_cmd_set_line(struct maat *maat_inst, const struct maat_cmd_line *line_rule) { int i = 0; int ret = 0; long long absolute_expire_time = 0; - redisContext *write_ctx = get_redis_ctx_for_write(maat_instance); + redisContext *write_ctx = get_redis_ctx_for_write(maat_inst); if (NULL == write_ctx) { return -1; } @@ -335,18 +335,18 @@ int maat_cmd_set_line(struct maat *maat_instance, const struct maat_cmd_line *li struct serial_rule *s_rule = ALLOC(struct serial_rule, 1); - int table_id = table_manager_get_table_id(maat_instance->tbl_mgr, line_rule->table_name); + int table_id = table_manager_get_table_id(maat_inst->tbl_mgr, line_rule->table_name); if (table_id < 0) { - log_error(maat_instance->logger, MODULE_MAAT_COMMAND, + log_error(maat_inst->logger, MODULE_MAAT_COMMAND, "[%s:%d] Command set line id %lld failed: unknown table %s", __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name); FREE(s_rule); return -1; } - int valid_column = table_manager_get_valid_column(maat_instance->tbl_mgr, table_id); + int valid_column = table_manager_get_valid_column(maat_inst->tbl_mgr, table_id); if (valid_column < 0) { - log_error(maat_instance->logger, MODULE_MAAT_COMMAND, + log_error(maat_inst->logger, MODULE_MAAT_COMMAND, "[%s:%d] Command set line id %lld failed: table %s is not a plugin or ip_plugin table", __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name); FREE(s_rule); @@ -355,7 +355,7 @@ int maat_cmd_set_line(struct maat *maat_instance, const struct maat_cmd_line *li int valid_offset = maat_cmd_get_valid_flag_offset(line_rule->table_line, valid_column); if (valid_offset < 0) { - log_error(maat_instance->logger, MODULE_MAAT_COMMAND, + log_error(maat_inst->logger, MODULE_MAAT_COMMAND, "[%s:%d] Command set line id %lld failed: table %s valid_offset error", __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name); FREE(s_rule); @@ -370,14 +370,14 @@ int maat_cmd_set_line(struct maat *maat_instance, const struct maat_cmd_line *li maat_cmd_set_serial_rule(s_rule + i, (enum maat_operation)is_valid, line_rule->rule_id, line_rule->table_name, line_rule->table_line, absolute_expire_time); - int success_cnt = maat_cmd_write_rule(write_ctx, s_rule, 1, server_time, maat_instance->logger); + int success_cnt = maat_cmd_write_rule(write_ctx, s_rule, 1, server_time, maat_inst->logger); if (success_cnt != 1) { ret = -1; goto error_out; } ret = success_cnt; - maat_instance->stat->line_cmd_acc_num += success_cnt; + maat_inst->stat->line_cmd_acc_num += success_cnt; error_out: maat_cmd_clear_rule_cache(s_rule); @@ -386,12 +386,12 @@ error_out: return ret; } -int maat_cmd_set_file(struct maat *maat_instance, const char *key, const char *value, +int maat_cmd_set_file(struct maat *maat_inst, const char *key, const char *value, size_t size, enum maat_operation op) { - redisContext *ctx = maat_instance->opts.redis_ctx.write_ctx; + redisContext *ctx = maat_inst->opts.redis_ctx.write_ctx; if (NULL == ctx) { - log_error(maat_instance->logger, MODULE_MAAT_COMMAND, + log_error(maat_inst->logger, MODULE_MAAT_COMMAND, "[%s:%d] failed: Redis is not connected.", __FUNCTION__, __LINE__); return -1; @@ -411,7 +411,7 @@ int maat_cmd_set_file(struct maat *maat_instance, const char *key, const char *v redisReply *reply = NULL; if (0 != strncmp(key, foreign_key_prefix, strlen(foreign_key_prefix))) { - log_error(maat_instance->logger, MODULE_MAAT_COMMAND, + log_error(maat_inst->logger, MODULE_MAAT_COMMAND, "Invalid File key, prefix %s is mandatory.", foreign_key_prefix); return -1; } @@ -430,7 +430,7 @@ int maat_cmd_set_file(struct maat *maat_instance, const char *key, const char *v } if (NULL == reply || reply->type == REDIS_REPLY_NIL || reply->type == REDIS_REPLY_ERROR) { - log_error(maat_instance->logger, MODULE_MAAT_COMMAND, + log_error(maat_inst->logger, MODULE_MAAT_COMMAND, "Set file failed, maybe Redis is busy."); freeReplyObject(reply); reply = NULL; @@ -442,11 +442,11 @@ int maat_cmd_set_file(struct maat *maat_instance, const char *key, const char *v return 1; } -long long maat_cmd_incrby(struct maat *maat_instance, const char *key, int increment) +long long maat_cmd_incrby(struct maat *maat_inst, const char *key, int increment) { long long result = 0; - redisContext *write_ctx = get_redis_ctx_for_write(maat_instance); + redisContext *write_ctx = get_redis_ctx_for_write(maat_inst); if (NULL == write_ctx) { return -1; } @@ -464,26 +464,26 @@ long long maat_cmd_incrby(struct maat *maat_instance, const char *key, int incre return result; } -long long maat_cmd_get_config_version(struct maat *maat_instance) +long long maat_cmd_get_config_version(struct maat *maat_inst) { long long new_version = -1; - if (maat_instance->new_version != INVALID_VERSION) { - new_version = maat_instance->new_version; + if (maat_inst->new_version != INVALID_VERSION) { + new_version = maat_inst->new_version; } else { - new_version = maat_instance->maat_version; + new_version = maat_inst->maat_version; } return new_version; } -int maat_cmd_config_is_updating(struct maat *maat_instance) +int maat_cmd_config_is_updating(struct maat *maat_inst) { int ret = 0; - if (0 == pthread_mutex_trylock(&(maat_instance->background_update_mutex))) { + if (0 == pthread_mutex_trylock(&(maat_inst->background_update_mutex))) { ret = 0; - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); } else { ret = 1; } @@ -522,4 +522,4 @@ char *maat_cmd_str_escape(char *dst, int size, const char *src) dst[j] = '\0'; return dst; -} \ No newline at end of file +} diff --git a/src/maat_compile.c b/src/maat_compile.c index b7e70a7..94744fc 100644 --- a/src/maat_compile.c +++ b/src/maat_compile.c @@ -96,12 +96,11 @@ struct compile_rule { /* compile_runtime and group2compile_runtime share compile_hash_map */ struct compile_runtime { struct bool_matcher *bm; - struct rcu_hash_table *cfg_hash_tbl; // + struct rcu_hash_table *cfg_hash; // struct maat_runtime *ref_maat_rt; time_t version; struct maat_clause *clause_by_literals_hash; struct literal_clause *literal2clause_hash; - struct group2compile_runtime *ref_g2c_rt; long long rule_num; long long update_err_cnt; @@ -222,7 +221,7 @@ void maat_compile_free(struct maat_compile *compile) FREE(compile); } -void rcu_maat_compile_free(void *user_ctx, void *data) +void rcu_compile_cfg_free(void *user_ctx, void *data) { struct maat_compile *compile = (struct maat_compile *)data; maat_compile_free(compile); @@ -253,7 +252,7 @@ int compile_table_set_ex_data_schema(struct compile_schema *compile_schema, int void *compile_runtime_get_user_data(struct compile_runtime *compile_rt, long long compile_id) { - struct maat_compile *compile = rcu_hash_find(compile_rt->cfg_hash_tbl, + struct maat_compile *compile = rcu_hash_find(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long)); void *ret = NULL; if (compile != NULL) { @@ -291,9 +290,9 @@ void compile_runtime_user_data_iterate(struct compile_runtime *compile_rt, void (*callback)(void *user_data, void *param, const char *table_name, int table_id), void *param, int table_id) { - /* I'm in background_update_mutex, config update can't happen, so no need to lock cfg_hash_tbl */ + /* I'm in background_update_mutex, config update can't happen, so no need to lock cfg_hash */ void **data_array = NULL; - size_t data_cnt = rcu_hash_list(compile_rt->cfg_hash_tbl, &data_array); + size_t data_cnt = rcu_hash_list(compile_rt->cfg_hash, &data_array); for (size_t i = 0; i < data_cnt; i++) { struct maat_compile *compile = (struct maat_compile *)data_array[i]; @@ -573,7 +572,7 @@ void *compile_runtime_new(void *compile_schema, size_t max_thread_num, compile_rt->expr_match_buff = ALLOC(struct bool_expr_match, max_thread_num * MAX_SCANNER_HIT_COMPILE_NUM); compile_rt->version = time(NULL); - compile_rt->cfg_hash_tbl = rcu_hash_new(rcu_maat_compile_free, NULL); + compile_rt->cfg_hash = rcu_hash_new(rcu_compile_cfg_free, NULL); compile_rt->clause_by_literals_hash = NULL; compile_rt->literal2clause_hash = NULL; compile_rt->logger = logger; @@ -628,9 +627,9 @@ void compile_runtime_free(void *compile_runtime) compile_rt->bm = NULL; } - if (compile_rt->cfg_hash_tbl != NULL) { - rcu_hash_free(compile_rt->cfg_hash_tbl); - compile_rt->cfg_hash_tbl = NULL; + if (compile_rt->cfg_hash != NULL) { + rcu_hash_free(compile_rt->cfg_hash); + compile_rt->cfg_hash = NULL; } if (compile_rt->literal2clause_hash != NULL) { @@ -650,21 +649,14 @@ void compile_runtime_free(void *compile_runtime) FREE(compile_rt); } -void compile_runtime_init(void *compile_runtime, struct maat_runtime *maat_rt, - void *g2c_runtime) +void compile_runtime_init(void *compile_runtime, struct maat_runtime *maat_rt) { if (NULL == compile_runtime) { return; } struct compile_runtime *compile_rt = (struct compile_runtime *)compile_runtime; - if (maat_rt != NULL) { - compile_rt->ref_maat_rt = maat_rt; - } - - if (g2c_runtime != NULL) { - compile_rt->ref_g2c_rt = g2c_runtime; - } + compile_rt->ref_maat_rt = maat_rt; } void *group2compile_runtime_new(void *g2c_schema, size_t max_thread_num, @@ -896,22 +888,22 @@ maat_clause_hash_fetch_clause(struct compile_runtime *compile_rt, return clause; } -struct bool_matcher *maat_compile_bool_matcher_new(struct compile_runtime *compile_rt, - size_t *compile_cnt) +struct bool_matcher * +maat_compile_bool_matcher_new(struct compile_runtime *compile_rt, size_t *compile_cnt) { if (NULL == compile_rt) { return NULL; } - size_t i = 0, j = 0; + size_t i = 0, j = 0, idx = 0; int has_clause_num = 0; const struct maat_clause *clause = NULL; + struct maat_literal_id *literal_ids = NULL; // STEP 1, update clause_id of each compile and literal void **data_array = NULL; - size_t idx = 0; struct maat_compile *iter_compile = NULL; - size_t rule_cnt = rcu_updating_hash_list(compile_rt->cfg_hash_tbl, &data_array); + size_t rule_cnt = rcu_updating_hash_list(compile_rt->cfg_hash, &data_array); *compile_cnt = rule_cnt; for (idx = 0; idx < rule_cnt; idx++) { @@ -924,7 +916,7 @@ struct bool_matcher *maat_compile_bool_matcher_new(struct compile_runtime *compi } has_clause_num++; - struct maat_literal_id *literal_ids = (struct maat_literal_id *)utarray_eltptr(clause_state->ut_literal_ids, 0); + literal_ids = (struct maat_literal_id *)utarray_eltptr(clause_state->ut_literal_ids, 0); size_t n_literal_id = utarray_len(clause_state->ut_literal_ids); clause = maat_clause_hash_fetch_clause(compile_rt, literal_ids, n_literal_id); clause_state->clause_id = clause->clause_id; @@ -974,7 +966,8 @@ struct bool_matcher *maat_compile_bool_matcher_new(struct compile_runtime *compi size_t mem_size = 0; if (0 == expr_cnt) { log_error(compile_rt->logger, MODULE_COMPILE, - "[%s:%d] No bool expression to build bool matcher.", __FUNCTION__, __LINE__); + "[%s:%d] No bool expression to build bool matcher.", + __FUNCTION__, __LINE__); FREE(bool_expr_array); return NULL; } @@ -985,8 +978,8 @@ struct bool_matcher *maat_compile_bool_matcher_new(struct compile_runtime *compi "Build bool matcher of %zu expressions with %zu bytes memory.", expr_cnt, mem_size); } else { - log_error(compile_rt->logger, MODULE_COMPILE, "[%s:%d] Build bool matcher failed!", - __FUNCTION__, __LINE__); + log_error(compile_rt->logger, MODULE_COMPILE, + "[%s:%d] Build bool matcher failed!", __FUNCTION__, __LINE__); } FREE(bool_expr_array); @@ -1019,7 +1012,8 @@ static inline int compare_hit_group(const void *pa, const void *pb) return ret; } -struct literal_clause *maat_compile_build_literal2clause_hash(struct compile_runtime *compile_rt) +struct literal_clause * +maat_compile_build_literal2clause_hash(struct compile_runtime *compile_rt) { if (NULL == compile_rt) { return NULL; @@ -1030,7 +1024,7 @@ struct literal_clause *maat_compile_build_literal2clause_hash(struct compile_run struct maat_literal_id *tmp_literal_id = NULL; struct literal_clause *l2c_value = NULL; struct literal_clause *literal2clause_hash = NULL; - size_t compile_cnt = rcu_updating_hash_list(compile_rt->cfg_hash_tbl, &data_array); + size_t compile_cnt = rcu_updating_hash_list(compile_rt->cfg_hash, &data_array); for (size_t idx = 0; idx < compile_cnt; idx++) { struct maat_compile *compile = (struct maat_compile *)data_array[idx]; @@ -1216,7 +1210,8 @@ void compile_rule_free(struct compile_rule *compile_rule) assert(compile_rule->magic_num == COMPILE_RULE_MAGIC); if (1 == schema->set_flag) { - rule_ex_data_free(schema->table_id, compile_rule->ex_data, &(schema->ex_schema)); + rule_ex_data_free(schema->table_id, compile_rule->ex_data, + &(schema->ex_schema)); *compile_rule->ex_data = NULL; } @@ -1419,8 +1414,9 @@ int maat_remove_group_from_compile(struct rcu_hash_table *hash_tbl, } } else { log_error(logger, MODULE_COMPILE, - "[%s:%d] Remove group_id:%lld from compile_id:%lld failed, compile is not exisited.", - __FUNCTION__, __LINE__, g2c_item->group_id, compile_id); + "[%s:%d] Remove group_id:%lld from compile_id:%lld failed, " + "compile is not exisited.", __FUNCTION__, __LINE__, + g2c_item->group_id, compile_id); return -1; } } @@ -1456,7 +1452,7 @@ void maat_compile_state_reset(struct maat_compile_state *compile_state) } void maat_compile_state_free(struct maat_compile_state *compile_state, - struct maat *maat_instance, int thread_id) + struct maat *maat_inst, int thread_id) { if (NULL == compile_state) { return; @@ -1484,7 +1480,7 @@ void maat_compile_state_free(struct maat_compile_state *compile_state, FREE(compile_state); free_bytes += sizeof(struct maat_compile_state); - alignment_int64_array_add(maat_instance->stat->maat_state_free_bytes, thread_id, free_bytes); + alignment_int64_array_add(maat_inst->stat->maat_state_free_bytes, thread_id, free_bytes); } static int maat_compile_hit_path_add(UT_array *hit_paths, long long item_id, @@ -1602,8 +1598,8 @@ size_t compile_runtime_get_hit_paths(struct compile_runtime *compile_rt, int thr } void maat_compile_state_update_hit_path(struct maat_compile_state *compile_state, - long long item_id, long long group_id, int vtable_id, - int Nth_scan, int Nth_item_result) + long long item_id, long long group_id, + int vtable_id, int Nth_scan, int Nth_item_result) { if (compile_state->Nth_scan != Nth_scan) { assert(compile_state->this_scan_hit_item_flag == 0); @@ -1618,16 +1614,15 @@ void maat_compile_state_update_hit_path(struct maat_compile_state *compile_state } void maat_compile_state_update_hit_clause(struct maat_compile_state *compile_state, - void *compile_runtime, long long group_id, - int vtable_id) + struct compile_runtime *compile_rt, + long long group_id, int vtable_id) { - if (NULL == compile_state || NULL == compile_runtime) { + if (NULL == compile_state || NULL == compile_rt) { return; } struct maat_literal_id literal_id = {group_id, vtable_id}; struct literal_clause *l2c_val = NULL; - struct compile_runtime *compile_rt = (struct compile_runtime *)compile_runtime; HASH_FIND(hh, compile_rt->literal2clause_hash, &literal_id, sizeof(literal_id), l2c_val); if (!l2c_val) { @@ -1685,7 +1680,8 @@ void *compile_runtime_get_ex_data(struct compile_runtime *compile_rt, } struct compile_rule *compile_rule = NULL; - compile_rule = (struct compile_rule *)compile_runtime_get_user_data(compile_rt, compile_id); + compile_rule = (struct compile_rule *)compile_runtime_get_user_data(compile_rt, + compile_id); if (NULL == compile_rule) { return NULL; } @@ -1712,9 +1708,9 @@ int compile_runtime_add_compile(struct compile_runtime *compile_rt, struct compi struct compile_rule *compile_rule = compile_rule_new(compile_item, schema, table_name, line); compile_item_free(compile_item); - int updating_flag = rcu_hash_is_updating(compile_rt->cfg_hash_tbl); + int updating_flag = rcu_hash_is_updating(compile_rt->cfg_hash); if (1 == updating_flag) { - compile = rcu_updating_hash_find(compile_rt->cfg_hash_tbl, (char *)&compile_id, + compile = rcu_updating_hash_find(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long)); if (compile != NULL) { /**************************************************************** @@ -1734,10 +1730,10 @@ int compile_runtime_add_compile(struct compile_runtime *compile_rt, struct compi assert(compile != NULL); maat_compile_set(compile, table_name, compile_rule->declared_clause_num, compile_rule, (void (*)(void *))compile_rule_free); - rcu_hash_add(compile_rt->cfg_hash_tbl, (char *)&compile_id, sizeof(long long), compile); + rcu_hash_add(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long), compile); } } else { - compile = rcu_hash_find(compile_rt->cfg_hash_tbl, (char *)&compile_id, sizeof(long long)); + compile = rcu_hash_find(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long)); if (compile != NULL) { /******************************************************************************** compile found in effective hash(added by group2compile runtime), which means @@ -1752,19 +1748,19 @@ int compile_runtime_add_compile(struct compile_runtime *compile_rt, struct compi assert(copy_compile != NULL); /* delete compile from rcu hash */ - rcu_hash_del(compile_rt->cfg_hash_tbl, (char *)&compile_id, sizeof(long long)); + rcu_hash_del(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long)); /* copy_compile has group2compile_table info, so set compile_table info */ maat_compile_set(copy_compile, table_name, compile_rule->declared_clause_num, compile_rule, (void (*)(void *))compile_rule_free); /* add copy_compile to rcu hash */ - rcu_hash_add(compile_rt->cfg_hash_tbl, (char *)&compile_id, sizeof(long long), copy_compile); + rcu_hash_add(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long), copy_compile); } else { compile = maat_compile_new(compile_rule->compile_id); assert(compile != NULL); maat_compile_set(compile, table_name, compile_rule->declared_clause_num, compile_rule, (void (*)(void *))compile_rule_free); - rcu_hash_add(compile_rt->cfg_hash_tbl, (char *)&compile_id, sizeof(long long), compile); + rcu_hash_add(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long), compile); } } @@ -1775,11 +1771,11 @@ void compile_runtime_del_compile(struct compile_runtime *compile_rt, long long c { struct maat_compile *compile = NULL; - int updating_flag = rcu_hash_is_updating(compile_rt->cfg_hash_tbl); + int updating_flag = rcu_hash_is_updating(compile_rt->cfg_hash); if (1 == updating_flag) { // find in updating hash - compile = rcu_updating_hash_find(compile_rt->cfg_hash_tbl, (char *)&compile_id, + compile = rcu_updating_hash_find(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long)); if (compile != NULL) { /**************************************************************** @@ -1795,12 +1791,12 @@ void compile_runtime_del_compile(struct compile_runtime *compile_rt, long long c } if (0 == compile->actual_clause_num) { - rcu_hash_del(compile_rt->cfg_hash_tbl, (char *)&compile_id, sizeof(long long)); + rcu_hash_del(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long)); } } } else { // find in effective hash - compile = rcu_hash_find(compile_rt->cfg_hash_tbl, (char *)&compile_id, sizeof(long long)); + compile = rcu_hash_find(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long)); if (compile != NULL) { /******************************************************************* compile found in effective hash, which means @@ -1815,12 +1811,12 @@ void compile_runtime_del_compile(struct compile_runtime *compile_rt, long long c assert(copy_compile != NULL); /* delete compile from rcu hash */ - rcu_hash_del(compile_rt->cfg_hash_tbl, (char *)&compile_id, sizeof(long long)); + rcu_hash_del(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long)); if (0 == copy_compile->actual_clause_num) { maat_compile_free(copy_compile); } else { - rcu_hash_add(compile_rt->cfg_hash_tbl, (char *)&compile_id, + rcu_hash_add(compile_rt->cfg_hash, (char *)&compile_id, sizeof(long long), copy_compile); } } @@ -1904,7 +1900,7 @@ int group2compile_runtime_update(void *g2c_runtime, void *g2c_schema, if (0 == is_valid) { //delete - ret = maat_remove_group_from_compile(compile_rt->cfg_hash_tbl, g2c_item, + ret = maat_remove_group_from_compile(compile_rt->cfg_hash, g2c_item, compile_rt->logger); if (0 == ret) { if (g2c_item->not_flag) { @@ -1916,7 +1912,8 @@ int group2compile_runtime_update(void *g2c_runtime, void *g2c_schema, } } else { //add - ret = maat_add_group_to_compile(compile_rt->cfg_hash_tbl, g2c_item, compile_rt->logger); + ret = maat_add_group_to_compile(compile_rt->cfg_hash, g2c_item, + compile_rt->logger); if (0 == ret) { if (g2c_item->not_flag) { g2c_rt->not_flag_group++; @@ -1970,7 +1967,7 @@ int compile_runtime_commit(void *compile_runtime, const char *table_name, struct compile_runtime *compile_rt = (struct compile_runtime *)compile_runtime; - int updating_flag = rcu_hash_is_updating(compile_rt->cfg_hash_tbl); + int updating_flag = rcu_hash_is_updating(compile_rt->cfg_hash); if (0 == updating_flag) { return 0; } @@ -2003,14 +2000,14 @@ int compile_runtime_commit(void *compile_runtime, const char *table_name, compile_rt->bm = new_bool_matcher; compile_rt->literal2clause_hash = new_literal2clause; - rcu_hash_commit(compile_rt->cfg_hash_tbl); + rcu_hash_commit(compile_rt->cfg_hash); maat_garbage_bagging(compile_rt->ref_garbage_bin, old_bool_matcher, NULL, garbage_bool_matcher_free); maat_garbage_bagging(compile_rt->ref_garbage_bin, old_literal2clause, NULL, garbage_literal2clause_hash_free); - compile_rt->rule_num = rcu_hash_count(compile_rt->cfg_hash_tbl); + compile_rt->rule_num = rcu_hash_count(compile_rt->cfg_hash); return ret; } @@ -2100,10 +2097,10 @@ void maat_compile_state_update(int vtable_id, struct maat_item *hit_items, hit_cnt = MAX_SCANNER_HIT_GROUP_NUM; } - struct maat *maat_instance = state->maat_instance; + struct maat *maat_inst = state->maat_inst; if (NULL == state->compile_state) { state->compile_state = maat_compile_state_new(); - alignment_int64_array_add(maat_instance->stat->maat_compile_state_cnt, + alignment_int64_array_add(maat_inst->stat->maat_compile_state_cnt, state->thread_id, 1); } @@ -2118,17 +2115,17 @@ void maat_compile_state_update(int vtable_id, struct maat_item *hit_items, if (state->compile_table_id > 0) { compile_table_id = state->compile_table_id; } else { - compile_table_id = table_manager_get_default_compile_table_id(maat_instance->tbl_mgr); + compile_table_id = table_manager_get_default_compile_table_id(maat_inst->tbl_mgr); } - void *compile_rt = table_manager_get_runtime(maat_instance->tbl_mgr, - compile_table_id); + struct compile_runtime *compile_rt = table_manager_get_runtime(maat_inst->tbl_mgr, + compile_table_id); if (NULL == compile_rt) { return; } - int g2g_table_id = table_manager_get_group2group_table_id(maat_instance->tbl_mgr); - void *g2g_rt = table_manager_get_runtime(maat_instance->tbl_mgr, g2g_table_id); + int g2g_table_id = table_manager_get_group2group_table_id(maat_inst->tbl_mgr); + void *g2g_rt = table_manager_get_runtime(maat_inst->tbl_mgr, g2g_table_id); if (NULL == g2g_rt) { return; } @@ -2260,4 +2257,4 @@ size_t maat_compile_state_get_internal_hit_paths(struct maat_compile_state *comp } return hit_path_cnt; -} \ No newline at end of file +} diff --git a/src/maat_config_monitor.c b/src/maat_config_monitor.c index 115f4b5..2a1841c 100644 --- a/src/maat_config_monitor.c +++ b/src/maat_config_monitor.c @@ -392,7 +392,7 @@ void config_monitor_traverse(long long current_version, const char *idx_dir, FREE(idx_path_array); } -int load_maat_json_file(struct maat *maat_instance, const char *json_filename, +int load_maat_json_file(struct maat *maat_inst, const char *json_filename, char *err_str, size_t err_str_sz) { int ret = 0; @@ -404,18 +404,18 @@ int load_maat_json_file(struct maat *maat_instance, const char *json_filename, size_t decrypted_buff_sz = 0; size_t uncompressed_buff_sz = 0; - log_info(maat_instance->logger, MODULE_CONFIG_MONITOR, + log_info(maat_inst->logger, MODULE_CONFIG_MONITOR, "Maat initial with JSON file %s, formating...", json_filename); - if (strlen(maat_instance->opts.decrypt_key) && strlen(maat_instance->opts.decrypt_algo)) { - ret = decrypt_open(json_filename, maat_instance->opts.decrypt_key, - maat_instance->opts.decrypt_algo, + if (strlen(maat_inst->opts.decrypt_key) && strlen(maat_inst->opts.decrypt_algo)) { + ret = decrypt_open(json_filename, maat_inst->opts.decrypt_key, + maat_inst->opts.decrypt_algo, (unsigned char **)&decrypted_buff, &decrypted_buff_sz, err_str, err_str_sz); if (ret < 0) { - log_error(maat_instance->logger, MODULE_CONFIG_MONITOR, + log_error(maat_inst->logger, MODULE_CONFIG_MONITOR, "[%s:%d] Decrypt Maat JSON file %s failed", __FUNCTION__, __LINE__, json_filename); return -1; @@ -425,12 +425,12 @@ int load_maat_json_file(struct maat *maat_instance, const char *json_filename, json_buff_sz = decrypted_buff_sz; } - if (maat_instance->opts.maat_json_is_gzipped) { + if (maat_inst->opts.maat_json_is_gzipped) { ret = gzip_uncompress(json_buff, json_buff_sz, &uncompressed_buff, &uncompressed_buff_sz); FREE(json_buff); if (ret < 0) { - log_error(maat_instance->logger, MODULE_CONFIG_MONITOR, + log_error(maat_inst->logger, MODULE_CONFIG_MONITOR, "[%s:%d] Uncompress Maat JSON file %s failed", __FUNCTION__, __LINE__, json_filename); return -1; @@ -444,7 +444,7 @@ int load_maat_json_file(struct maat *maat_instance, const char *json_filename, if (NULL == json_buff) { ret = load_file_to_memory(json_filename, &json_buff, &json_buff_sz); if (ret < 0) { - log_error(maat_instance->logger, MODULE_CONFIG_MONITOR, + log_error(maat_inst->logger, MODULE_CONFIG_MONITOR, "[%s:%d] Read Maat JSON file %s failed", __FUNCTION__, __LINE__, json_filename); return -1; @@ -452,27 +452,27 @@ int load_maat_json_file(struct maat *maat_instance, const char *json_filename, } ret = json2iris((const char*)json_buff, json_filename, NULL, - maat_instance->opts.json_ctx.iris_file, - sizeof(maat_instance->opts.json_ctx.iris_file), - strlen(maat_instance->opts.decrypt_key) ? maat_instance->opts.decrypt_key : NULL, - strlen(maat_instance->opts.decrypt_algo) ? maat_instance->opts.decrypt_algo : NULL, - maat_instance->logger); + maat_inst->opts.json_ctx.iris_file, + sizeof(maat_inst->opts.json_ctx.iris_file), + strlen(maat_inst->opts.decrypt_key) ? maat_inst->opts.decrypt_key : NULL, + strlen(maat_inst->opts.decrypt_algo) ? maat_inst->opts.decrypt_algo : NULL, + maat_inst->logger); FREE(json_buff); if (ret < 0) { return -1; } ret = stat(json_filename, &fstat_buf); - maat_instance->opts.json_ctx.last_md5_time = fstat_buf.st_ctim; + maat_inst->opts.json_ctx.last_md5_time = fstat_buf.st_ctim; - md5_file(maat_instance->opts.json_ctx.json_file, maat_instance->opts.json_ctx.effective_json_md5); - log_info(maat_instance->logger, MODULE_CONFIG_MONITOR, + md5_file(maat_inst->opts.json_ctx.json_file, maat_inst->opts.json_ctx.effective_json_md5); + log_info(maat_inst->logger, MODULE_CONFIG_MONITOR, "JSON file %s md5: %s, generate index file %s OK", - maat_instance->opts.json_ctx.json_file, - maat_instance->opts.json_ctx.effective_json_md5, - maat_instance->opts.json_ctx.iris_file); + maat_inst->opts.json_ctx.json_file, + maat_inst->opts.json_ctx.effective_json_md5, + maat_inst->opts.json_ctx.iris_file); - maat_instance->opts.input_mode = DATA_SOURCE_JSON_FILE; + maat_inst->opts.input_mode = DATA_SOURCE_JSON_FILE; return 0; -} \ No newline at end of file +} diff --git a/src/maat_expr.c b/src/maat_expr.c index c4b3783..d010019 100644 --- a/src/maat_expr.c +++ b/src/maat_expr.c @@ -875,7 +875,7 @@ int expr_runtime_commit(void *expr_runtime, const char *table_name, struct adapter_hs *old_adapter_hs = NULL; if (rule_cnt > 0) { - new_adapter_hs = adapter_hs_new(expr_rt->n_worker_thread, rules, real_rule_cnt, + new_adapter_hs = adapter_hs_new(rules, real_rule_cnt, expr_rt->n_worker_thread, expr_rt->logger); if (NULL == new_adapter_hs) { log_error(expr_rt->logger, MODULE_EXPR, diff --git a/src/maat_flag.c b/src/maat_flag.c index 4f4908a..b49c898 100644 --- a/src/maat_flag.c +++ b/src/maat_flag.c @@ -49,7 +49,6 @@ struct flag_runtime { struct rcu_hash_table *item_hash; // long long rule_num; - long long version; size_t n_worker_thread; struct log_handle *logger; struct maat_garbage_bin *ref_garbage_bin; @@ -510,11 +509,10 @@ int flag_runtime_commit(void *flag_runtime, const char *table_name, } flag_rt->rule_num = rule_cnt; - flag_rt->version = maat_rt_version; log_info(flag_rt->logger, MODULE_FLAG, "table[%s] commit %zu flag rules and rebuild flag_matcher completed," - " version:%lld", table_name, rule_cnt, flag_rt->version); + " version:%lld", table_name, rule_cnt, maat_rt_version); if (rules != NULL) { FREE(rules); diff --git a/src/maat_fqdn_plugin.c b/src/maat_fqdn_plugin.c index d269745..10b36fc 100644 --- a/src/maat_fqdn_plugin.c +++ b/src/maat_fqdn_plugin.c @@ -33,7 +33,6 @@ struct fqdn_plugin_schema { struct fqdn_plugin_runtime { struct FQDN_engine *engine; struct ex_data_runtime *ex_data_rt; - long long version; long long rule_num; long long update_err_cnt; size_t n_worker_thread; @@ -499,13 +498,10 @@ int fqdn_plugin_runtime_commit(void *fqdn_plugin_runtime, const char *table_name } fqdn_plugin_rt->rule_num = rule_cnt; - if (maat_rt_version != 0) { - fqdn_plugin_rt->version = maat_rt_version; - } log_info(fqdn_plugin_rt->logger, MODULE_FQDN_PLUGIN, "table[%s] commit %zu fqdn_plugin rules and rebuild FQDN engine completed" - ", version:%lld", table_name, rule_cnt, fqdn_plugin_rt->version); + ", version:%lld", table_name, rule_cnt, maat_rt_version); if (rules != NULL) { FREE(rules); diff --git a/src/maat_group.c b/src/maat_group.c index 2ae6b9a..570de3a 100644 --- a/src/maat_group.c +++ b/src/maat_group.c @@ -62,7 +62,6 @@ struct maat_group_topology { struct group2group_runtime { struct maat_group_topology *group_topo; struct maat_group_topology *updating_group_topo; - long long version; long long rule_num; long long excl_rule_num; //exclude g2g rule num long long update_err_cnt; @@ -774,11 +773,10 @@ int group2group_runtime_commit(void *g2g_runtime, const char *table_name, maat_garbage_bagging(g2g_rt->ref_garbage_bin, old_group_topo, NULL, garbage_maat_group_topology_free); - g2g_rt->version = maat_rt_version; log_info(g2g_rt->logger, MODULE_GROUP, "table[%s] commit %zu g2g rules and rebuild super_groups completed," - " version:%lld", table_name, g2g_rt->rule_num, g2g_rt->version); + " version:%lld", table_name, g2g_rt->rule_num, maat_rt_version); return 0; } diff --git a/src/maat_interval.c b/src/maat_interval.c index 9f6ba3e..5771a86 100644 --- a/src/maat_interval.c +++ b/src/maat_interval.c @@ -45,7 +45,6 @@ struct interval_runtime { struct interval_matcher *matcher; struct rcu_hash_table *item_hash; // - long long version; long long rule_num; size_t n_worker_thread; struct log_handle *logger; @@ -514,11 +513,10 @@ int interval_runtime_commit(void *interval_runtime, const char *table_name, } interval_rt->rule_num = rule_cnt; - interval_rt->version = maat_rt_version; log_info(interval_rt->logger, MODULE_INTERVAL, "table[%s] commit %zu interval rules and rebuild interval_matcher " - "completed, version:%lld", table_name, rule_cnt, interval_rt->version); + "completed, version:%lld", table_name, rule_cnt, maat_rt_version); if (rules != NULL) { FREE(rules); diff --git a/src/maat_ip.c b/src/maat_ip.c index 4c62724..16dc19c 100644 --- a/src/maat_ip.c +++ b/src/maat_ip.c @@ -69,7 +69,6 @@ struct ip_runtime { struct interval_matcher *intval_matcher; struct rcu_hash_table *item_hash; // - long long version; long long rule_num; long long ipv6_rule_num; size_t n_worker_thread; @@ -641,11 +640,10 @@ int ip_runtime_commit(void *ip_runtime, const char *table_name, } ip_rt->rule_num = rule_cnt; - ip_rt->version = maat_rt_version; log_info(ip_rt->logger, MODULE_IP, "table[%s] commit %zu ip rules and rebuild ip_matcher completed" - ", version:%lld", table_name, rule_cnt, ip_rt->version); + ", version:%lld", table_name, rule_cnt, maat_rt_version); if (rules != NULL) { FREE(rules); diff --git a/src/maat_ip_plugin.c b/src/maat_ip_plugin.c index cd7ee1c..beee297 100644 --- a/src/maat_ip_plugin.c +++ b/src/maat_ip_plugin.c @@ -37,7 +37,6 @@ struct ip_plugin_schema { struct ip_plugin_runtime { struct ip_matcher *ip_matcher; struct ex_data_runtime *ex_data_rt; - long long version; long long rule_num; long long update_err_cnt; size_t n_worker_thread; @@ -539,13 +538,10 @@ int ip_plugin_runtime_commit(void *ip_plugin_runtime, const char *table_name, } ip_plugin_rt->rule_num = rule_cnt; - if (maat_rt_version != 0) { - ip_plugin_rt->version = maat_rt_version; - } log_info(ip_plugin_rt->logger, MODULE_IP_PLUGIN, "table[%s] commit %zu ip_plugin rules and rebuild ip_matcher " - "completed, version:%lld", table_name, rule_cnt, ip_plugin_rt->version); + "completed, version:%lld", table_name, rule_cnt, maat_rt_version); if (rules != NULL) { FREE(rules); diff --git a/src/maat_plugin.c b/src/maat_plugin.c index dc80033..52b1c71 100644 --- a/src/maat_plugin.c +++ b/src/maat_plugin.c @@ -33,7 +33,6 @@ struct plugin_callback_schema { struct plugin_runtime { long long acc_line_num; struct ex_data_runtime *ex_data_rt; - long long version; long long rule_num; long long update_err_cnt; struct maat_garbage_bin *ref_garbage_bin; @@ -572,13 +571,10 @@ int plugin_runtime_commit(void *plugin_runtime, const char *table_name, ex_data_runtime_commit(ex_data_rt); plugin_rt->rule_num = ex_data_runtime_ex_container_count(ex_data_rt); - if (maat_rt_version != 0) { - plugin_rt->version = maat_rt_version; - } log_info(plugin_rt->logger, MODULE_PLUGIN, "table[%s] commit %zu plugin rules, version:%lld", - table_name, plugin_rt->rule_num, plugin_rt->version); + table_name, plugin_rt->rule_num, maat_rt_version); return 0; } diff --git a/src/maat_redis_monitor.c b/src/maat_redis_monitor.c index aeaed9a..a720948 100644 --- a/src/maat_redis_monitor.c +++ b/src/maat_redis_monitor.c @@ -118,7 +118,7 @@ void _get_foregin_keys(struct serial_rule *p_rule, int *foreign_columns, } int get_foreign_keys_define(redisContext *ctx, struct serial_rule *rule_list, - int rule_num, struct maat *maat_instance, const char *dir) + int rule_num, struct maat *maat_inst, const char *dir) { int rule_with_foreign_key = 0; @@ -127,9 +127,9 @@ int get_foreign_keys_define(redisContext *ctx, struct serial_rule *rule_list, continue; } - int table_id = table_manager_get_table_id(maat_instance->tbl_mgr, rule_list[i].table_name); - void *schema = table_manager_get_schema(maat_instance->tbl_mgr, table_id); - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, table_id); + int table_id = table_manager_get_table_id(maat_inst->tbl_mgr, rule_list[i].table_name); + void *schema = table_manager_get_schema(maat_inst->tbl_mgr, table_id); + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); if (!schema || table_type != TABLE_TYPE_PLUGIN) { continue; } @@ -141,7 +141,7 @@ int get_foreign_keys_define(redisContext *ctx, struct serial_rule *rule_list, continue; } - _get_foregin_keys(rule_list+i, foreign_columns, n_foreign_column, dir, maat_instance->logger); + _get_foregin_keys(rule_list+i, foreign_columns, n_foreign_column, dir, maat_inst->logger); rule_with_foreign_key++; } @@ -1380,14 +1380,14 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, int no_table_num = 0; int call_update_num = 0; int valid_column = -1; - struct maat *maat_instance = (struct maat *)u_param; + struct maat *maat_inst = (struct maat *)u_param; //authorized to write if (mr_ctx->write_ctx != NULL && mr_ctx->write_ctx->err == 0) { //For thread safe, deliberately use redis_read_ctx but not redis_write_ctx. if (1 == redlock_try_lock(mr_ctx->read_ctx, mr_expire_lock, mr_expire_lock_timeout_ms)) { - check_maat_expiration(mr_ctx->read_ctx, maat_instance->logger); - cleanup_update_status(mr_ctx->read_ctx, maat_instance->logger); + check_maat_expiration(mr_ctx->read_ctx, maat_inst->logger); + cleanup_update_status(mr_ctx->read_ctx, maat_inst->logger); redlock_unlock(mr_ctx->read_ctx, mr_expire_lock); } } @@ -1402,12 +1402,12 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, redisFree(mr_ctx->read_ctx); mr_ctx->read_ctx = NULL; } - log_info(maat_instance->logger, MODULE_REDIS_MONITOR, "Reconnecting..."); + log_info(maat_inst->logger, MODULE_REDIS_MONITOR, "Reconnecting..."); mr_ctx->read_ctx = maat_cmd_connect_redis(mr_ctx->redis_ip, mr_ctx->redis_port, mr_ctx->redis_db, - maat_instance->logger); + maat_inst->logger); if (NULL == mr_ctx->read_ctx) { return; } else { @@ -1420,11 +1420,11 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, int update_type = MAAT_UPDATE_TYPE_INC; int rule_num = maat_cmd_get_rm_key_list(mr_ctx->read_ctx, version, - maat_instance->load_specific_version, - &new_version, maat_instance->tbl_mgr, + maat_inst->load_specific_version, + &new_version, maat_inst->tbl_mgr, &rule_list, &update_type, - maat_instance->opts.cumulative_update_off, - maat_instance->logger); + maat_inst->opts.cumulative_update_off, + maat_inst->logger); //redis communication error if (rule_num < 0) { redisFree(mr_ctx->read_ctx); @@ -1432,7 +1432,7 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, return; } - maat_instance->load_specific_version = 0;//only valid for one time. + maat_inst->load_specific_version = 0;//only valid for one time. //error or nothing changed if (0 == rule_num && update_type == MAAT_UPDATE_TYPE_INC) { return; @@ -1440,12 +1440,12 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, if (rule_num > 0) { ret = maat_cmd_get_redis_value(mr_ctx->read_ctx, rule_list, rule_num, - 0, maat_instance->logger); + 0, maat_inst->logger); //redis communication error if (ret < 0) { redisFree(mr_ctx->read_ctx); mr_ctx->read_ctx = NULL; - log_error(maat_instance->logger, MODULE_REDIS_MONITOR, + log_error(maat_inst->logger, MODULE_REDIS_MONITOR, "[%s:%d] Get Redis value failed, abandon update and close connection", __FUNCTION__, __LINE__); goto clean_up; @@ -1458,21 +1458,21 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, } if (empty_value_num == rule_num) { - log_info(maat_instance->logger, MODULE_REDIS_MONITOR, + log_info(maat_inst->logger, MODULE_REDIS_MONITOR, "All %d rules are empty, abandon update", empty_value_num); goto clean_up; } ret = get_foreign_keys_define(mr_ctx->read_ctx, rule_list, rule_num, - maat_instance, maat_instance->opts.foreign_cont_dir); + maat_inst, maat_inst->opts.foreign_cont_dir); if (ret > 0) { maat_cmd_get_foreign_conts(mr_ctx->read_ctx, rule_list, rule_num, 0, - maat_instance->logger); + maat_inst->logger); } } start_fn(new_version, update_type, u_param); - log_info(maat_instance->logger, MODULE_REDIS_MONITOR, + log_info(maat_inst->logger, MODULE_REDIS_MONITOR, "Start %s update: %lld -> %lld (%d entries)", update_type == MAAT_UPDATE_TYPE_INC ? "INC" : "FULL", version, new_version, rule_num); @@ -1482,7 +1482,7 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, continue; } - table_id = table_manager_get_table_id(maat_instance->tbl_mgr, rule_list[i].table_name); + table_id = table_manager_get_table_id(maat_inst->tbl_mgr, rule_list[i].table_name); //Unrecognized table. if (table_id < 0) { no_table_num++; @@ -1490,10 +1490,10 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, } if (rule_list[i].op == MAAT_OP_DEL) { - valid_column = table_manager_get_valid_column(maat_instance->tbl_mgr, table_id); + valid_column = table_manager_get_valid_column(maat_inst->tbl_mgr, table_id); ret = invalidate_line(rule_list[i].table_line, valid_column); if (ret < 0) { - log_error(maat_instance->logger, MODULE_REDIS_MONITOR, + log_error(maat_inst->logger, MODULE_REDIS_MONITOR, "[%s:%d] Invalidate line failed, invaid format %s", __FUNCTION__, __LINE__, rule_list[i].table_line); continue; @@ -1511,7 +1511,7 @@ void redis_monitor_traverse(long long version, struct source_redis_ctx *mr_ctx, finish_fn(u_param); if (call_update_num < rule_num) { - log_error(maat_instance->logger, MODULE_REDIS_MONITOR, + log_error(maat_inst->logger, MODULE_REDIS_MONITOR, "[%s:%d] Load %d entries to match engine, no table: %d, empty value: %d", __FUNCTION__, __LINE__, call_update_num, no_table_num, empty_value_num); } @@ -1522,4 +1522,4 @@ clean_up: } FREE(rule_list); -} \ No newline at end of file +} diff --git a/src/maat_rule.c b/src/maat_rule.c index 59f8216..82d0d90 100644 --- a/src/maat_rule.c +++ b/src/maat_rule.c @@ -32,25 +32,25 @@ #define MODULE_MAAT_RULE module_name_str("maat.rule") -struct maat_runtime* maat_runtime_create(long long version, struct maat *maat_instance) +struct maat_runtime* maat_runtime_create(long long version, struct maat *maat_inst) { struct maat_runtime *maat_rt = ALLOC(struct maat_runtime, 1); maat_rt->version = version; - int ret = table_manager_runtime_create(maat_instance->tbl_mgr, - maat_instance->opts.nr_worker_thread, - maat_instance->garbage_bin); + int ret = table_manager_runtime_create(maat_inst->tbl_mgr, + maat_inst->opts.nr_worker_thread, + maat_inst->garbage_bin); if (ret < 0) { FREE(maat_rt); return NULL; } - maat_rt->ref_tbl_mgr = maat_instance->tbl_mgr; - maat_rt->max_table_num = table_manager_table_size(maat_instance->tbl_mgr); + maat_rt->ref_tbl_mgr = maat_inst->tbl_mgr; + maat_rt->max_table_num = table_manager_table_size(maat_inst->tbl_mgr); maat_rt->sequence_map = maat_kv_store_new(); - maat_rt->logger = maat_instance->logger; - maat_rt->ref_garbage_bin = maat_instance->garbage_bin; - maat_rt->ref_cnt = alignment_int64_array_alloc(maat_instance->opts.nr_worker_thread); + maat_rt->logger = maat_inst->logger; + maat_rt->ref_garbage_bin = maat_inst->garbage_bin; + maat_rt->ref_cnt = alignment_int64_array_alloc(maat_inst->opts.nr_worker_thread); return maat_rt; } @@ -67,30 +67,32 @@ void maat_runtime_commit(struct maat_runtime *maat_rt, int update_type, void maat_start_cb(long long new_version, int update_type, void *u_param) { - struct maat *maat_instance = (struct maat *)u_param; - maat_instance->new_version = new_version; size_t i = 0; - size_t max_table_cnt = table_manager_table_size(maat_instance->tbl_mgr); enum table_type table_type = TABLE_TYPE_INVALID; + struct maat *maat_inst = (struct maat *)u_param; + + size_t max_table_cnt = table_manager_table_size(maat_inst->tbl_mgr); + maat_inst->new_version = new_version; if (update_type == MAAT_UPDATE_TYPE_FULL) { - maat_instance->creating_maat_rt = maat_runtime_create(new_version, maat_instance); + maat_inst->creating_maat_rt = maat_runtime_create(new_version, maat_inst); + for (i = 0; i < max_table_cnt; i++) { - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, i); + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, i); if (table_type == TABLE_TYPE_COMPILE) { // compile runtime need a reference to maat runtime - void *compile_rt = table_manager_get_updating_runtime(maat_instance->tbl_mgr, i); - compile_runtime_init(compile_rt, maat_instance->creating_maat_rt, NULL); + void *compile_rt = table_manager_get_updating_runtime(maat_inst->tbl_mgr, i); + compile_runtime_init(compile_rt, maat_inst->creating_maat_rt); } } } else { - maat_instance->maat_version = new_version; + maat_inst->maat_version = new_version; } for (i = 0; i < max_table_cnt; i++) { - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, i); + table_type = table_manager_get_table_type(maat_inst->tbl_mgr, i); if (table_type == TABLE_TYPE_PLUGIN) { - void *schema = table_manager_get_schema(maat_instance->tbl_mgr, i); + void *schema = table_manager_get_schema(maat_inst->tbl_mgr, i); plugin_table_all_callback_start((struct plugin_schema *)schema, update_type); } } @@ -102,30 +104,30 @@ int maat_update_cb(const char *table_name, const char *line, void *u_param) return 0; } - struct maat *maat_instance =(struct maat *)u_param; + struct maat *maat_inst =(struct maat *)u_param; struct maat_runtime* maat_rt = NULL; - int table_id = table_manager_get_table_id(maat_instance->tbl_mgr, table_name); + int table_id = table_manager_get_table_id(maat_inst->tbl_mgr, table_name); if (table_id < 0) { - log_error(maat_instance->logger, MODULE_MAAT_RULE, + log_error(maat_inst->logger, MODULE_MAAT_RULE, "[%s:%d] update warning, unknown table name %s", __FUNCTION__, __LINE__, table_name); return -1; } - void *schema = table_manager_get_schema(maat_instance->tbl_mgr, table_id); + void *schema = table_manager_get_schema(maat_inst->tbl_mgr, table_id); if (NULL == schema) { - log_error(maat_instance->logger, MODULE_MAAT_RULE, + log_error(maat_inst->logger, MODULE_MAAT_RULE, "[%s:%d] update warning, table name %s doesn't have table schema", __FUNCTION__, __LINE__, table_name); return -1; } int update_type = MAAT_UPDATE_TYPE_INC; - if (maat_instance->creating_maat_rt != NULL) { //Full update - maat_rt = maat_instance->creating_maat_rt; + if (maat_inst->creating_maat_rt != NULL) { //Full update + maat_rt = maat_inst->creating_maat_rt; update_type = MAAT_UPDATE_TYPE_FULL; } else { - maat_rt = maat_instance->maat_rt; + maat_rt = maat_inst->maat_rt; } table_manager_update_runtime(maat_rt->ref_tbl_mgr, table_name, table_id, line, update_type); @@ -166,107 +168,107 @@ void maat_plugin_table_all_callback_finish(struct table_manager *tbl_mgr) void maat_finish_cb(void *u_param) { - struct maat *maat_instance = (struct maat *)u_param; + struct maat *maat_inst = (struct maat *)u_param; - maat_plugin_table_all_callback_finish(maat_instance->tbl_mgr); + maat_plugin_table_all_callback_finish(maat_inst->tbl_mgr); - if (maat_instance->creating_maat_rt != NULL) { - maat_runtime_commit(maat_instance->creating_maat_rt, MAAT_UPDATE_TYPE_FULL, - maat_instance->creating_maat_rt->version, maat_instance->logger); - maat_instance->creating_maat_rt->rule_num = maat_runtime_rule_num(maat_instance->creating_maat_rt); - log_info(maat_instance->logger, MODULE_MAAT_RULE, + if (maat_inst->creating_maat_rt != NULL) { + maat_runtime_commit(maat_inst->creating_maat_rt, MAAT_UPDATE_TYPE_FULL, + maat_inst->creating_maat_rt->version, maat_inst->logger); + maat_inst->creating_maat_rt->rule_num = maat_runtime_rule_num(maat_inst->creating_maat_rt); + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Full config version %llu load %d entries complete", - maat_instance->creating_maat_rt->version, - maat_instance->creating_maat_rt->rule_num); - } else if (maat_instance->maat_rt != NULL) { - maat_instance->maat_rt->version = maat_instance->maat_version; - maat_runtime_commit(maat_instance->maat_rt, MAAT_UPDATE_TYPE_INC, - maat_instance->maat_rt->version, maat_instance->logger); - maat_instance->maat_rt->rule_num = maat_runtime_rule_num(maat_instance->maat_rt); - log_info(maat_instance->logger, MODULE_MAAT_RULE, + maat_inst->creating_maat_rt->version, + maat_inst->creating_maat_rt->rule_num); + } else if (maat_inst->maat_rt != NULL) { + maat_inst->maat_rt->version = maat_inst->maat_version; + maat_runtime_commit(maat_inst->maat_rt, MAAT_UPDATE_TYPE_INC, + maat_inst->maat_rt->version, maat_inst->logger); + maat_inst->maat_rt->rule_num = maat_runtime_rule_num(maat_inst->maat_rt); + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Inc config version %llu load %d entries complete", - maat_instance->maat_rt->version, - maat_instance->maat_rt->rule_num); + maat_inst->maat_rt->version, + maat_inst->maat_rt->rule_num); } else { - log_info(maat_instance->logger, MODULE_MAAT_RULE, + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Version %d has no valid rules, plugin callback complete.", - maat_instance->maat_version); + maat_inst->maat_version); } - maat_instance->new_version = INVALID_VERSION; + maat_inst->new_version = INVALID_VERSION; } -void maat_read_full_config(struct maat *maat_instance) +void maat_read_full_config(struct maat *maat_inst) { int ret = -1; char err_str[NAME_MAX] = {0}; struct source_redis_ctx *redis_ctx = NULL; - switch (maat_instance->opts.input_mode) { + switch (maat_inst->opts.input_mode) { case DATA_SOURCE_REDIS: - redis_ctx = &(maat_instance->opts.redis_ctx); - log_info(maat_instance->logger, MODULE_MAAT_RULE, + redis_ctx = &(maat_inst->opts.redis_ctx); + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Maat initiate from Redis %s:%hu db%d", redis_ctx->redis_ip, redis_ctx->redis_port, redis_ctx->redis_db); redis_ctx->read_ctx = maat_cmd_connect_redis(redis_ctx->redis_ip, redis_ctx->redis_port, redis_ctx->redis_db, - maat_instance->logger); + maat_inst->logger); if (redis_ctx->read_ctx != NULL) { - redis_monitor_traverse(maat_instance->maat_version, redis_ctx, + redis_monitor_traverse(maat_inst->maat_version, redis_ctx, maat_start_cb, maat_update_cb, maat_finish_cb, - maat_instance); + maat_inst); } - if (NULL == maat_instance->creating_maat_rt) { - log_error(maat_instance->logger, MODULE_MAAT_RULE, + if (NULL == maat_inst->creating_maat_rt) { + log_error(maat_inst->logger, MODULE_MAAT_RULE, "[%s:%d] At initiation: NO effective rule in redis %s:%hu db%d", __FUNCTION__, __LINE__, redis_ctx->redis_ip, redis_ctx->redis_port, redis_ctx->redis_db); } break; case DATA_SOURCE_IRIS_FILE: - config_monitor_traverse(maat_instance->maat_version, - maat_instance->opts.iris_ctx.full_idx_dir, + config_monitor_traverse(maat_inst->maat_version, + maat_inst->opts.iris_ctx.full_idx_dir, maat_start_cb, maat_update_cb, maat_finish_cb, - maat_instance, maat_instance->opts.decrypt_key, - maat_instance->logger); - if (NULL == maat_instance->creating_maat_rt) { - log_error(maat_instance->logger, MODULE_MAAT_RULE, + maat_inst, maat_inst->opts.decrypt_key, + maat_inst->logger); + if (NULL == maat_inst->creating_maat_rt) { + log_error(maat_inst->logger, MODULE_MAAT_RULE, "[%s:%d] At initiation: NO effective rule in %s", - __FUNCTION__, __LINE__, maat_instance->opts.iris_ctx.full_idx_dir); + __FUNCTION__, __LINE__, maat_inst->opts.iris_ctx.full_idx_dir); } break; case DATA_SOURCE_JSON_FILE: - ret = load_maat_json_file(maat_instance, maat_instance->opts.json_ctx.json_file, + ret = load_maat_json_file(maat_inst, maat_inst->opts.json_ctx.json_file, err_str, sizeof(err_str)); if (ret < 0) { - log_error(maat_instance->logger, MODULE_MAAT_RULE, + log_error(maat_inst->logger, MODULE_MAAT_RULE, "[%s:%d] Maat re-initiate with JSON file %s failed: %s", - __FUNCTION__, __LINE__, maat_instance->opts.json_ctx.json_file, err_str); + __FUNCTION__, __LINE__, maat_inst->opts.json_ctx.json_file, err_str); } - config_monitor_traverse(maat_instance->maat_version, - maat_instance->opts.json_ctx.iris_file, + config_monitor_traverse(maat_inst->maat_version, + maat_inst->opts.json_ctx.iris_file, maat_start_cb, maat_update_cb, maat_finish_cb, - maat_instance, maat_instance->opts.decrypt_key, - maat_instance->logger); - if (NULL == maat_instance->creating_maat_rt) { - log_error(maat_instance->logger, MODULE_MAAT_RULE, + maat_inst, maat_inst->opts.decrypt_key, + maat_inst->logger); + if (NULL == maat_inst->creating_maat_rt) { + log_error(maat_inst->logger, MODULE_MAAT_RULE, "[%s:%d] At initiation: NO effective rule in %s", - __FUNCTION__, __LINE__, maat_instance->opts.json_ctx.iris_file); + __FUNCTION__, __LINE__, maat_inst->opts.json_ctx.iris_file); } break; default: break; } - maat_instance->maat_rt = maat_instance->creating_maat_rt; - maat_instance->creating_maat_rt = NULL; - maat_instance->is_running = 1; - if (maat_instance->maat_rt != NULL) { - maat_instance->maat_version = maat_instance->maat_rt->version; - maat_instance->last_full_version = maat_instance->maat_rt->version; + maat_inst->maat_rt = maat_inst->creating_maat_rt; + maat_inst->creating_maat_rt = NULL; + maat_inst->is_running = 1; + if (maat_inst->maat_rt != NULL) { + maat_inst->maat_version = maat_inst->maat_rt->version; + maat_inst->last_full_version = maat_inst->maat_rt->version; } } @@ -326,74 +328,77 @@ void *rule_monitor_loop(void *arg) { /* Defined by prctl: The name can be up to 16 bytes long, and should be null terminated if it contains fewer bytes. */ - char maat_name[16] = {0}; - struct maat *maat_instance = (struct maat *)arg; + char maat_name[MAX_INSTANCE_NAME_LEN + 1] = {0}; + struct maat *maat_inst = (struct maat *)arg; - if (strlen(maat_instance->opts.instance_name) > 0) { - snprintf(maat_name, sizeof(maat_name), "MAAT_%s", maat_instance->opts.instance_name); + if (strlen(maat_inst->opts.inst_name) > 0) { + snprintf(maat_name, sizeof(maat_name), "%s", maat_inst->opts.inst_name); } else { - snprintf(maat_name, sizeof(maat_name), "MAAT"); + snprintf(maat_name, sizeof(maat_name), "MAAT_LOOP"); } int ret = prctl(PR_SET_NAME, (unsigned long long)maat_name, NULL, NULL, NULL); assert(ret >= 0); - pthread_mutex_lock(&(maat_instance->background_update_mutex)); + pthread_mutex_lock(&(maat_inst->background_update_mutex)); /* if deferred load on */ - if (maat_instance->opts.deferred_load_on != 0) { - log_info(maat_instance->logger, MODULE_MAAT_RULE, + if (maat_inst->opts.deferred_load_on != 0) { + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Deferred Loading ON, updating in %s:%d", __FUNCTION__, __LINE__); - maat_read_full_config(maat_instance); + maat_read_full_config(maat_inst); } - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); char md5_tmp[MD5_DIGEST_LENGTH * 2 + 1] = {0}; char err_str[NAME_MAX] = {0}; struct stat attrib; - while (maat_instance->is_running) { + + while (maat_inst->is_running) { if (time(NULL) % 10 == 0) { - log_info(maat_instance->logger, MODULE_MAAT_RULE, + log_info(maat_inst->logger, MODULE_MAAT_RULE, "%s thread still alive.........", __FUNCTION__); } - usleep(maat_instance->opts.rule_update_checking_interval_ms * 1000); - if (0 == pthread_mutex_trylock(&(maat_instance->background_update_mutex))) { - switch (maat_instance->opts.input_mode) { + usleep(maat_inst->opts.rule_update_checking_interval_ms * 1000); + + if (0 == pthread_mutex_trylock(&(maat_inst->background_update_mutex))) { + switch (maat_inst->opts.input_mode) { case DATA_SOURCE_REDIS: - redis_monitor_traverse(maat_instance->maat_version, - &(maat_instance->opts.redis_ctx), - maat_start_cb, maat_update_cb, maat_finish_cb, - maat_instance); + redis_monitor_traverse(maat_inst->maat_version, + &(maat_inst->opts.redis_ctx), + maat_start_cb, maat_update_cb, maat_finish_cb, + maat_inst); break; case DATA_SOURCE_IRIS_FILE: - config_monitor_traverse(maat_instance->maat_version, - maat_instance->opts.iris_ctx.inc_idx_dir, + config_monitor_traverse(maat_inst->maat_version, + maat_inst->opts.iris_ctx.inc_idx_dir, maat_start_cb, maat_update_cb, maat_finish_cb, - maat_instance, maat_instance->opts.decrypt_key, - maat_instance->logger); + maat_inst, maat_inst->opts.decrypt_key, + maat_inst->logger); break; case DATA_SOURCE_JSON_FILE: memset(md5_tmp, 0, sizeof(md5_tmp)); - stat(maat_instance->opts.json_ctx.json_file, &attrib); - if (memcmp(&attrib.st_ctim, &(maat_instance->opts.json_ctx.last_md5_time), sizeof(attrib.st_ctim))) { - maat_instance->opts.json_ctx.last_md5_time = attrib.st_ctim; - md5_file(maat_instance->opts.json_ctx.json_file, md5_tmp); - if (0 != strcmp(md5_tmp, maat_instance->opts.json_ctx.effective_json_md5)) { - ret = load_maat_json_file(maat_instance, maat_instance->opts.json_ctx.json_file, + stat(maat_inst->opts.json_ctx.json_file, &attrib); + if (memcmp(&attrib.st_ctim, &(maat_inst->opts.json_ctx.last_md5_time), + sizeof(attrib.st_ctim))) { + maat_inst->opts.json_ctx.last_md5_time = attrib.st_ctim; + md5_file(maat_inst->opts.json_ctx.json_file, md5_tmp); + if (0 != strcmp(md5_tmp, maat_inst->opts.json_ctx.effective_json_md5)) { + ret = load_maat_json_file(maat_inst, maat_inst->opts.json_ctx.json_file, err_str, sizeof(err_str)); if (ret < 0) { - log_error(maat_instance->logger, MODULE_MAAT_RULE, + log_error(maat_inst->logger, MODULE_MAAT_RULE, "[%s:%d] Maat re-initiate with JSON file %s (md5=%s)failed: %s\n", - __FUNCTION__, __LINE__, maat_instance->opts.json_ctx.json_file, + __FUNCTION__, __LINE__, maat_inst->opts.json_ctx.json_file, md5_tmp, err_str); } else { - config_monitor_traverse(0, maat_instance->opts.json_ctx.iris_file, + config_monitor_traverse(0, maat_inst->opts.json_ctx.iris_file, maat_start_cb, maat_update_cb, maat_finish_cb, - maat_instance, maat_instance->opts.decrypt_key, - maat_instance->logger); - log_info(maat_instance->logger, MODULE_MAAT_RULE, + maat_inst, maat_inst->opts.decrypt_key, + maat_inst->logger); + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Maat re-initiate with JSON file %s success, md5: %s\n", - maat_instance->opts.json_ctx.json_file, md5_tmp); + maat_inst->opts.json_ctx.json_file, md5_tmp); } } } @@ -402,77 +407,81 @@ void *rule_monitor_loop(void *arg) break; } - if (maat_instance->creating_maat_rt != NULL) { - struct maat_runtime *old_maat_rt = maat_instance->maat_rt; - maat_instance->maat_rt = maat_instance->creating_maat_rt; + if (maat_inst->creating_maat_rt != NULL) { + struct maat_runtime *old_maat_rt = maat_inst->maat_rt; + maat_inst->maat_rt = maat_inst->creating_maat_rt; if (old_maat_rt != NULL) { - if (maat_instance->maat_rt->version > old_maat_rt->version) { - log_info(maat_instance->logger, MODULE_MAAT_RULE, + if (maat_inst->maat_rt->version > old_maat_rt->version) { + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Maat version updated %lld -> %lld\n", - old_maat_rt->version, maat_instance->maat_rt->version); + old_maat_rt->version, maat_inst->maat_rt->version); } else { - log_info(maat_instance->logger, MODULE_MAAT_RULE, + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Maat version roll back %lld -> %lld\n", - old_maat_rt->version, maat_instance->maat_rt->version); + old_maat_rt->version, maat_inst->maat_rt->version); } - maat_garbage_bagging(maat_instance->garbage_bin, old_maat_rt, NULL, + + maat_inst->stat->zombie_rs_stream += alignment_int64_array_sum(old_maat_rt->ref_cnt, + maat_inst->opts.nr_worker_thread); + maat_garbage_bagging(maat_inst->garbage_bin, old_maat_rt, NULL, garbage_maat_runtime_destroy); } - maat_instance->creating_maat_rt = NULL; - maat_instance->maat_version = maat_instance->maat_rt->version; - maat_instance->last_full_version = maat_instance->maat_rt->version; + maat_inst->creating_maat_rt = NULL; + maat_inst->maat_version = maat_inst->maat_rt->version; + maat_inst->last_full_version = maat_inst->maat_rt->version; } - if (maat_instance->maat_rt != NULL) { - time_t time_window = time(NULL) - maat_instance->maat_rt->last_update_time; + if (maat_inst->maat_rt != NULL) { + time_t time_window = time(NULL) - maat_inst->maat_rt->last_update_time; - if (time_window >= maat_instance->opts.rule_effect_interval_ms / 1000) { - maat_runtime_commit(maat_instance->maat_rt, MAAT_UPDATE_TYPE_INC, - maat_instance->maat_rt->version, maat_instance->logger); - log_info(maat_instance->logger, MODULE_MAAT_RULE, + if (time_window >= maat_inst->opts.rule_effect_interval_ms / 1000) { + maat_runtime_commit(maat_inst->maat_rt, MAAT_UPDATE_TYPE_INC, + maat_inst->maat_rt->version, maat_inst->logger); + log_info(maat_inst->logger, MODULE_MAAT_RULE, "Actual update config version %u, %d entries load to maat runtime.", - maat_instance->maat_rt->version, maat_instance->maat_rt->rule_num); + maat_inst->maat_rt->version, maat_inst->maat_rt->rule_num); } } - pthread_mutex_unlock(&(maat_instance->background_update_mutex)); + pthread_mutex_unlock(&(maat_inst->background_update_mutex)); } - maat_garbage_collect_routine(maat_instance->garbage_bin); - if ((1 == maat_instance->opts.stat_on) && (time(NULL) % 2 == 0)) { - maat_stat_output(maat_instance->stat, maat_instance->maat_version, maat_instance->opts.perf_on); + + maat_garbage_collect_routine(maat_inst->garbage_bin); + if ((1 == maat_inst->opts.stat_on) && (time(NULL) % 2 == 0)) { + maat_stat_output(maat_inst->stat, maat_inst->maat_version, maat_inst->opts.perf_on); } } - maat_runtime_destroy(maat_instance->maat_rt); - maat_garbage_bin_free(maat_instance->garbage_bin); - table_manager_destroy(maat_instance->tbl_mgr); //table manager MUST be freed at last. + maat_runtime_destroy(maat_inst->maat_rt); + maat_garbage_bin_free(maat_inst->garbage_bin); + table_manager_destroy(maat_inst->tbl_mgr); //table manager MUST be freed at last. - if (maat_instance->stat != NULL) { - maat_stat_free(maat_instance->stat); - maat_instance->stat = NULL; + if (maat_inst->stat != NULL) { + maat_stat_free(maat_inst->stat); + maat_inst->stat = NULL; } - if (maat_instance->opts.input_mode == DATA_SOURCE_REDIS) { - if (maat_instance->opts.redis_ctx.read_ctx != NULL) { - redisFree(maat_instance->opts.redis_ctx.read_ctx); - maat_instance->opts.redis_ctx.read_ctx = NULL; + if (maat_inst->opts.input_mode == DATA_SOURCE_REDIS) { + if (maat_inst->opts.redis_ctx.read_ctx != NULL) { + redisFree(maat_inst->opts.redis_ctx.read_ctx); + maat_inst->opts.redis_ctx.read_ctx = NULL; } - if (maat_instance->opts.redis_ctx.write_ctx != NULL) { - redisFree(maat_instance->opts.redis_ctx.write_ctx); - maat_instance->opts.redis_ctx.write_ctx = NULL; + if (maat_inst->opts.redis_ctx.write_ctx != NULL) { + redisFree(maat_inst->opts.redis_ctx.write_ctx); + maat_inst->opts.redis_ctx.write_ctx = NULL; } } - if (maat_instance->opts.accept_tags != NULL) { - FREE(maat_instance->opts.accept_tags); - maat_instance->opts.accept_tags = NULL; + if (maat_inst->opts.accept_tags != NULL) { + FREE(maat_inst->opts.accept_tags); + maat_inst->opts.accept_tags = NULL; } - log_handle_destroy(maat_instance->logger); - FREE(maat_instance); + log_handle_destroy(maat_inst->logger); + FREE(maat_inst); return NULL; -} \ No newline at end of file +} diff --git a/src/rcu_hash.c b/src/rcu_hash.c index 8934b5c..fe15130 100644 --- a/src/rcu_hash.c +++ b/src/rcu_hash.c @@ -44,7 +44,7 @@ struct rcu_hash_table { struct rcu_hash_node { char *key; size_t key_len; - void *data; //table_runtime解析成两个成员 + void *data; /* htable the node belongs to */ struct rcu_hash_table *htable; diff --git a/test/adapter_hs_gtest.cpp b/test/adapter_hs_gtest.cpp index d1e8825..46b4981 100644 --- a/test/adapter_hs_gtest.cpp +++ b/test/adapter_hs_gtest.cpp @@ -235,23 +235,23 @@ TEST(adapter_hs_init, invalid_input_parameter) struct expr_rule rules[64]; size_t n_rule = 0; - struct adapter_hs *hs_instance = adapter_hs_new(1, NULL, 0, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(NULL, 0, 1, g_logger); EXPECT_TRUE(hs_instance == NULL); - hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance == NULL); n_rule = 1; rules[0].expr_id = 101; rules[0].n_patterns = 10; - hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance == NULL); memset(rules, 0, sizeof(rules)); n_rule = 1; rules[0].expr_id = 101; rules[0].n_patterns = 1; - hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance == NULL); } @@ -263,7 +263,7 @@ TEST(adapter_hs_scan, literal_sub_has_normal_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -310,7 +310,7 @@ TEST(adapter_hs_scan, literal_sub_has_left_unlimit_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -358,7 +358,7 @@ TEST(adapter_hs_scan, literal_sub_has_right_unlimit_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -413,7 +413,7 @@ TEST(adapter_hs_scan, literal_sub_with_no_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -460,7 +460,7 @@ TEST(adapter_hs_scan, literal_exactly) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -501,7 +501,7 @@ TEST(adapter_hs_scan, literal_prefix) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -551,7 +551,7 @@ TEST(adapter_hs_scan, literal_suffix) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -601,7 +601,7 @@ TEST(adapter_hs_scan, literal_sub_with_hexbin) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -633,7 +633,7 @@ TEST(adapter_hs_scan, literal_with_chinese) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -657,7 +657,7 @@ TEST(adapter_hs_scan, same_pattern_different_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); @@ -681,7 +681,7 @@ TEST(adapter_hs_scan, long_scan_data) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct adapter_hs *hs_instance = adapter_hs_new(1, rules, n_rule, g_logger); + struct adapter_hs *hs_instance = adapter_hs_new(rules, n_rule, 1, g_logger); EXPECT_TRUE(hs_instance != NULL); expr_array_free(rules, n_rule); diff --git a/test/maat_ex_data_gtest.cpp b/test/maat_ex_data_gtest.cpp index 49f9b89..6ae78cc 100644 --- a/test/maat_ex_data_gtest.cpp +++ b/test/maat_ex_data_gtest.cpp @@ -12,7 +12,7 @@ const char *table_info_path = "./table_info.conf"; const char *json_filename = "maat_json.json"; struct log_handle *g_logger = NULL; -struct maat *g_maat_instance = NULL; +struct maat *g_maat_inst = NULL; struct user_info { char name[256]; @@ -55,7 +55,7 @@ void ex_data_dup_cb(int table_id, void **to, void **from, long argl, void *argp) TEST(EXDataRuntime, Update) { const char *table_name = "TEST_PLUGIN_EXDATA_TABLE"; - int table_id = maat_get_table_id(g_maat_instance, table_name); + int table_id = maat_get_table_id(g_maat_inst, table_name); ASSERT_GT(table_id, 0); int ex_data_counter = 0; @@ -145,14 +145,14 @@ int main(int argc, char ** argv) snprintf(json_path, sizeof(json_path), "./%s", json_filename); maat_options_set_json_file(opts, json_path); - g_maat_instance = maat_new(opts, table_info_path); + g_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - EXPECT_TRUE(g_maat_instance != NULL); + EXPECT_TRUE(g_maat_inst != NULL); ret=RUN_ALL_TESTS(); log_handle_destroy(g_logger); - maat_free(g_maat_instance); - g_maat_instance = NULL; + maat_free(g_maat_inst); + g_maat_inst = NULL; return ret; } diff --git a/test/maat_framework_gtest.cpp b/test/maat_framework_gtest.cpp index 8d26c0a..efb5567 100644 --- a/test/maat_framework_gtest.cpp +++ b/test/maat_framework_gtest.cpp @@ -23,15 +23,15 @@ const char *json_filename = "maat_json.json"; size_t g_thread_num = 4; -void wait_for_cmd_effective(struct maat *maat_instance, long long version_before) +void wait_for_cmd_effective(struct maat *maat_inst, long long version_before) { long long version_after = version_before; int is_updating = 1; long long wating_us = 0, sleep_us = 1000 * 100; while (is_updating || version_before == version_after) { - is_updating = maat_cmd_config_is_updating(maat_instance); - version_after = maat_cmd_get_config_version(maat_instance); + is_updating = maat_cmd_config_is_updating(maat_inst); + version_after = maat_cmd_get_config_version(maat_inst); usleep(sleep_us);//waiting for commands go into effect wating_us += sleep_us; @@ -156,7 +156,7 @@ int write_config_to_redis(char *redis_ip, int redis_port, int redis_db, return 0; } -int compile_table_set_line(struct maat *maat_instance, const char *table_name, +int compile_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long compile_id, const char *user_region, int clause_num, int expire_after) { @@ -170,10 +170,10 @@ int compile_table_set_line(struct maat *maat_instance, const char *table_name, line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } #define TO_GROUP2X_KEY(group_id, parent_id) ((unsigned long)group_id<<32|parent_id) -int group2compile_table_set_line(struct maat *maat_instance, const char *table_name, +int group2compile_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long group_id, long long compile_id, int not_flag, const char *vtable_name, int clause_index, int expire_after) @@ -188,10 +188,10 @@ int group2compile_table_set_line(struct maat *maat_instance, const char *table_n line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -int group2group_table_set_line(struct maat *maat_instance, const char *table_name, enum maat_operation op, +int group2group_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long group_id, long long superior_group_id, int is_exclude, int expire_after) { char table_line[128] = {0}; @@ -203,20 +203,20 @@ int group2group_table_set_line(struct maat *maat_instance, const char *table_nam line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -int expr_table_set_line(struct maat *maat_instance, const char *table_name, enum maat_operation op, +int expr_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long item_id, long long group_id, const char *keywords, const char *district, int expr_type, int match_method, int is_hexbin, int expire_after) { char table_line[1024] = {0}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); if (table_id < 0) { return 0; } - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, table_id); + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); assert(table_type == TABLE_TYPE_EXPR || table_type == TABLE_TYPE_EXPR_PLUS); if (table_type == TABLE_TYPE_EXPR_PLUS) { @@ -233,20 +233,20 @@ int expr_table_set_line(struct maat *maat_instance, const char *table_name, enum line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -int intval_table_set_line(struct maat *maat_instance, const char *table_name, enum maat_operation op, +int intval_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long item_id, long long group_id, unsigned int low_boundary, unsigned int up_boundary, const char *district, int expire_after) { char table_line[1024] = {0}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); if (table_id < 0) { return 0; } - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, table_id); + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); assert(table_type == TABLE_TYPE_INTERVAL || table_type == TABLE_TYPE_INTERVAL_PLUS); if (table_type == TABLE_TYPE_INTERVAL_PLUS) { @@ -263,15 +263,15 @@ int intval_table_set_line(struct maat *maat_instance, const char *table_name, en line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -int ip_table_set_line(struct maat *maat_instance, const char *table_name, enum maat_operation op, +int ip_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long item_id, long long group_id, enum IP_TYPE type, const char *ip1, const char *ip2, uint16_t port_min, uint16_t port_max, int expire_after) { char table_line[1024] = {0}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); if (table_id < 0) { return 0; } @@ -290,10 +290,10 @@ int ip_table_set_line(struct maat *maat_instance, const char *table_name, enum m line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -int test_add_expr_command(struct maat *maat_instance, const char *expr_table, +int test_add_expr_command(struct maat *maat_inst, const char *expr_table, long long compile_id, int timeout, const char *keywords) { char huge_serv_def[1024 * 2] = {0}; @@ -301,26 +301,26 @@ int test_add_expr_command(struct maat *maat_instance, const char *expr_table, memset(huge_serv_def, 's', sizeof(huge_serv_def) - 1); huge_serv_def[sizeof(huge_serv_def) - 1] = '\0'; - int ret = compile_table_set_line(maat_instance, "COMPILE", MAAT_OP_ADD, compile_id, + int ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_ADD, compile_id, huge_serv_def, 1, timeout); EXPECT_EQ(ret, 1); - long long group_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, "GROUP2COMPILE", MAAT_OP_ADD, group_id, + long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, "GROUP2COMPILE", MAAT_OP_ADD, group_id, compile_id, 0, "null", 1, timeout); EXPECT_EQ(ret, 1); - long long item_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, expr_table, MAAT_OP_ADD, item_id, group_id, keywords, + long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, expr_table, MAAT_OP_ADD, item_id, group_id, keywords, "null", 1, 0, 0, 0); EXPECT_EQ(ret, 1); return ret; } -int del_command(struct maat *maat_instance, int compile_id) +int del_command(struct maat *maat_inst, int compile_id) { - return compile_table_set_line(maat_instance, "COMPILE", MAAT_OP_DEL, compile_id, "null", 1, 0); + return compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_DEL, compile_id, "null", 1, 0); } static void random_keyword_generate(char *keyword_buf, size_t sz) @@ -354,9 +354,9 @@ protected: maat_options_set_accept_tags(opts, accept_tags); const char *table_info_path = "./test_table_info.conf"; - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in MaatIris failed.", __FUNCTION__, __LINE__); @@ -364,25 +364,25 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatIris::_shared_maat_instance; +struct maat *MaatIris::_shared_maat_inst; struct log_handle *MaatIris::logger; TEST_F(MaatIris, basic) { - struct maat *maat_instance = MaatIris::_shared_maat_instance; + struct maat *maat_inst = MaatIris::_shared_maat_inst; struct log_handle *logger = MaatIris::logger; long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); uint32_t sip_addr; uint32_t dip_addr; @@ -395,9 +395,9 @@ TEST_F(MaatIris, basic) { clock_gettime(CLOCK_MONOTONIC, &start); for (int i = 0; i < 100000; i++) { - int table_id = maat_get_table_id(maat_instance, "TSG_SECURITY_SOURCE_ADDR"); + int table_id = maat_get_table_id(maat_inst, "TSG_SECURITY_SOURCE_ADDR"); ASSERT_GT(table_id, 0); - int ret = maat_scan_ipv4(maat_instance, table_id, sip_addr, sport, 6, + int ret = maat_scan_ipv4(maat_inst, table_id, sip_addr, sport, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_reset(state); @@ -410,16 +410,16 @@ TEST_F(MaatIris, basic) { for (int i = 0; i < 100000; i++) { - int table_id = maat_get_table_id(maat_instance, "TSG_SECURITY_SOURCE_ADDR"); + int table_id = maat_get_table_id(maat_inst, "TSG_SECURITY_SOURCE_ADDR"); ASSERT_GT(table_id, 0); - int ret = maat_scan_ipv4(maat_instance, table_id, sip_addr, sport, 6, + int ret = maat_scan_ipv4(maat_inst, table_id, sip_addr, sport, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, "TSG_OBJ_APP_ID"); + table_id = maat_get_table_id(maat_inst, "TSG_OBJ_APP_ID"); ASSERT_GT(table_id, 0); - ret = maat_scan_integer(maat_instance, table_id, 32, results, ARRAY_SIZE, + ret = maat_scan_integer(maat_inst, table_id, 32, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -457,9 +457,9 @@ protected: maat_options_set_json_file_decrypt_key(opts, json_decrypt_key); maat_options_set_rule_update_checking_interval_ms(opts, scan_interval_ms); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in JsonUpdate failed.", __FUNCTION__, __LINE__); @@ -468,18 +468,18 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *JsonUpdate::_shared_maat_instance; +struct maat *JsonUpdate::_shared_maat_inst; struct log_handle *JsonUpdate::logger; -void scan_with_old_or_new_cfg(struct maat *maat_instance, int is_old) +void scan_with_old_or_new_cfg(struct maat *maat_inst, int is_old) { const char *hit_old_data = "Hello world! I'm eve."; const char *hit_new_data = "Maat was borned in MESA."; @@ -487,12 +487,12 @@ void scan_with_old_or_new_cfg(struct maat *maat_instance, int is_old) long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, hit_old_data, + int ret = maat_scan_string(maat_inst, table_id, hit_old_data, strlen(hit_old_data), results, ARRAY_SIZE, &n_hit_result, state); if (is_old) { @@ -503,7 +503,7 @@ void scan_with_old_or_new_cfg(struct maat *maat_instance, int is_old) } maat_state_reset(state); - ret = maat_scan_string(maat_instance, table_id, hit_new_data, + ret = maat_scan_string(maat_inst, table_id, hit_new_data, strlen(hit_new_data), results, ARRAY_SIZE, &n_hit_result, state); if (!is_old) { @@ -517,20 +517,20 @@ void scan_with_old_or_new_cfg(struct maat *maat_instance, int is_old) } TEST_F(JsonUpdate, OldCfg) { - scan_with_old_or_new_cfg(JsonUpdate::_shared_maat_instance, 1); + scan_with_old_or_new_cfg(JsonUpdate::_shared_maat_inst, 1); } TEST_F(JsonUpdate, NewCfg) { system_cmd_gzip(corrupted_json, tmp_gzipped_file_name); system_cmd_encrypt(tmp_gzipped_file_name, watched_json, json_decrypt_key); sleep(2); - scan_with_old_or_new_cfg(JsonUpdate::_shared_maat_instance, 1); + scan_with_old_or_new_cfg(JsonUpdate::_shared_maat_inst, 1); system_cmd_gzip(new_json, tmp_gzipped_file_name); int ret = system_cmd_encrypt(tmp_gzipped_file_name, watched_json, json_decrypt_key); EXPECT_EQ(ret, 0); sleep(5); - scan_with_old_or_new_cfg(JsonUpdate::_shared_maat_instance, 0); + scan_with_old_or_new_cfg(JsonUpdate::_shared_maat_inst, 0); } class MaatFlagScan : public testing::Test @@ -556,9 +556,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in MaatFlagScan failed.", __FUNCTION__, __LINE__); @@ -566,31 +566,31 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatFlagScan::_shared_maat_instance; +struct maat *MaatFlagScan::_shared_maat_inst; struct log_handle *MaatFlagScan::logger; TEST_F(MaatFlagScan, basic) { const char *flag_table_name = "FLAG_CONFIG"; - struct maat *maat_instance = MaatFlagScan::_shared_maat_instance; + struct maat *maat_inst = MaatFlagScan::_shared_maat_inst; - int flag_table_id = maat_get_table_id(maat_instance, flag_table_name); + int flag_table_id = maat_get_table_id(maat_inst, flag_table_name); //compile_id:192 flag: 0000 0001 mask: 0000 0011 //scan_data: 0000 1001 or 0000 1101 should hit long long scan_data = 9; long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int ret = maat_scan_flag(maat_instance, flag_table_id, scan_data, results, + int ret = maat_scan_flag(maat_inst, flag_table_id, scan_data, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -606,7 +606,7 @@ TEST_F(MaatFlagScan, basic) { scan_data = 13; memset(results, 0, sizeof(results)); n_hit_result = 0; - ret = maat_scan_flag(maat_instance, flag_table_id, scan_data, results, + ret = maat_scan_flag(maat_inst, flag_table_id, scan_data, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -617,7 +617,7 @@ TEST_F(MaatFlagScan, basic) { scan_data = 6; memset(results, 0, sizeof(results)); n_hit_result = 0; - ret = maat_scan_flag(maat_instance, flag_table_id, scan_data, results, + ret = maat_scan_flag(maat_inst, flag_table_id, scan_data, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); EXPECT_EQ(n_hit_result, 0); @@ -628,19 +628,19 @@ TEST_F(MaatFlagScan, basic) { TEST_F(MaatFlagScan, withExprRegion) { const char *flag_table_name = "FLAG_CONFIG"; const char *expr_table_name = "HTTP_URL"; - struct maat *maat_instance = MaatFlagScan::_shared_maat_instance; + struct maat *maat_inst = MaatFlagScan::_shared_maat_inst; - int flag_table_id = maat_get_table_id(maat_instance, flag_table_name); - int expr_table_id = maat_get_table_id(maat_instance, expr_table_name); + int flag_table_id = maat_get_table_id(maat_inst, flag_table_name); + int expr_table_id = maat_get_table_id(maat_inst, expr_table_name); //compile_id:193 flag: 0000 0010 mask: 0000 0011 //scan_data: 0000 0010 or 0000 0100 should hit long long flag_scan_data = 2; long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int ret = maat_scan_flag(maat_instance, flag_table_id, flag_scan_data, results, + int ret = maat_scan_flag(maat_inst, flag_table_id, flag_scan_data, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); EXPECT_EQ(n_hit_result, 0); @@ -651,7 +651,7 @@ TEST_F(MaatFlagScan, withExprRegion) { EXPECT_NE(n_read, 0); const char *expr_scan_data = "hello world"; - ret = maat_scan_string(maat_instance, expr_table_id, expr_scan_data, + ret = maat_scan_string(maat_inst, expr_table_id, expr_scan_data, strlen(expr_scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -663,9 +663,9 @@ TEST_F(MaatFlagScan, withExprRegion) { TEST_F(MaatFlagScan, hitMultiCompile) { const char *flag_table_name = "FLAG_CONFIG"; - struct maat *maat_instance = MaatFlagScan::_shared_maat_instance; + struct maat *maat_inst = MaatFlagScan::_shared_maat_inst; - int flag_table_id = maat_get_table_id(maat_instance, flag_table_name); + int flag_table_id = maat_get_table_id(maat_inst, flag_table_name); //compile_id:192 flag: 0000 0001 mask: 0000 0011 //compile_id:194 flag: 0001 0101 mask: 0001 1111 //scan_data: 0001 0101 should hit compile192 and compile194 @@ -673,9 +673,9 @@ TEST_F(MaatFlagScan, hitMultiCompile) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int ret = maat_scan_flag(maat_instance, flag_table_id, flag_scan_data, results, + int ret = maat_scan_flag(maat_inst, flag_table_id, flag_scan_data, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 3); @@ -684,7 +684,7 @@ TEST_F(MaatFlagScan, hitMultiCompile) { EXPECT_EQ(results[2], 192); memset(results, 0, sizeof(results)); - ret = maat_scan_flag(maat_instance, flag_table_id, flag_scan_data, results, + ret = maat_scan_flag(maat_inst, flag_table_id, flag_scan_data, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -699,18 +699,18 @@ TEST_F(MaatFlagScan, hitMultiCompile) { TEST_F(MaatFlagScan, hitRepeatedCompile) { const char *flag_table_name = "FLAG_CONFIG"; - struct maat *maat_instance = MaatFlagScan::_shared_maat_instance; + struct maat *maat_inst = MaatFlagScan::_shared_maat_inst; - int flag_table_id = maat_get_table_id(maat_instance, flag_table_name); + int flag_table_id = maat_get_table_id(maat_inst, flag_table_name); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); //compile_id:192 flag: 0000 0001 mask: 0000 0011 //scan_data: 0000 1001 or 0000 1101 should hit long long flag_scan_data1 = 9; - int ret = maat_scan_flag(maat_instance, flag_table_id, flag_scan_data1, results, + int ret = maat_scan_flag(maat_inst, flag_table_id, flag_scan_data1, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -722,14 +722,14 @@ TEST_F(MaatFlagScan, hitRepeatedCompile) { //scan_data: 0001 0101 should hit compile192 and compile194 long long flag_scan_data2 = 21; memset(results, 0, sizeof(results)); - ret = maat_scan_flag(maat_instance, flag_table_id, flag_scan_data2, results, + ret = maat_scan_flag(maat_inst, flag_table_id, flag_scan_data2, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], 194); memset(results, 0, sizeof(results)); - ret = maat_scan_flag(maat_instance, flag_table_id, flag_scan_data2, results, + ret = maat_scan_flag(maat_inst, flag_table_id, flag_scan_data2, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -745,31 +745,31 @@ TEST_F(MaatFlagScan, hitRepeatedCompile) { TEST_F(MaatFlagScan, FlagPlus) { const char *flag_table_name = "FLAG_PLUS_CONFIG"; const char *region_name = "I love China"; - struct maat *maat_instance = MaatFlagScan::_shared_maat_instance; + struct maat *maat_inst = MaatFlagScan::_shared_maat_inst; - int flag_table_id = maat_get_table_id(maat_instance, flag_table_name); + int flag_table_id = maat_get_table_id(maat_inst, flag_table_name); //compile_id:196 flag: 0001 1111 mask: 0000 1111 //scan_data: 0000 1111 or 0001 1111 should hit long long scan_data1 = 15; long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int ret = maat_scan_flag(maat_instance, flag_table_id, scan_data1, results, + int ret = maat_scan_flag(maat_inst, flag_table_id, scan_data1, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_ERR); ret = maat_state_set_scan_district(state, flag_table_id, region_name, strlen(region_name)); ASSERT_EQ(ret, 0); - ret = maat_scan_flag(maat_instance, flag_table_id, scan_data1, results, + ret = maat_scan_flag(maat_inst, flag_table_id, scan_data1, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], 196); - ret = maat_scan_flag(maat_instance, flag_table_id, scan_data1, results, + ret = maat_scan_flag(maat_inst, flag_table_id, scan_data1, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -804,9 +804,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in MaatStringScan failed.", __FUNCTION__, __LINE__); @@ -814,31 +814,31 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatStringScan::_shared_maat_instance; +struct maat *MaatStringScan::_shared_maat_inst; struct log_handle *MaatStringScan::logger; TEST_F(MaatStringScan, ScanDataOnlyOneByte) { const char *table_name = "HTTP_URL"; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char scan_data = 0x20; - int ret = maat_scan_string(maat_instance, table_id, &scan_data, sizeof(scan_data), + int ret = maat_scan_string(maat_inst, table_id, &scan_data, sizeof(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); EXPECT_EQ(n_hit_result, 0); @@ -848,18 +848,18 @@ TEST_F(MaatStringScan, ScanDataOnlyOneByte) { TEST_F(MaatStringScan, Full) { const char *table_name = "HTTP_URL"; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=username,abckkk,1234567"; - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -875,11 +875,11 @@ TEST_F(MaatStringScan, Regex) { int thread_id = 0; const char *cookie = "Cookie: Txa123aheadBCAxd"; const char *table_name = "HTTP_URL"; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); - ret = maat_scan_string(maat_instance, table_id, cookie, strlen(cookie), + int table_id = maat_get_table_id(maat_inst, table_name); + ret = maat_scan_string(maat_inst, table_id, cookie, strlen(cookie), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(results[0], 146); @@ -896,17 +896,17 @@ TEST_F(MaatStringScan, ExprPlus) { const char *scan_data1 = "http://www.cyberessays.com/search_results.php?action=search&query=abckkk,1234567"; const char *scan_data2 = "Addis Sapphire Hotel"; const char *table_name = "HTTP_SIGNATURE"; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); - int ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + int table_id = maat_get_table_id(maat_inst, table_name); + int ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_ERR);//Should return error for district not setting. ret = maat_state_set_scan_district(state, table_id, region_name1, strlen(region_name1)); ASSERT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(results[0], 128); @@ -914,7 +914,7 @@ TEST_F(MaatStringScan, ExprPlus) { ret = maat_state_set_scan_district(state, table_id, region_name2, strlen(region_name2)); ASSERT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, scan_data2, strlen(scan_data2), + ret = maat_scan_string(maat_inst, table_id, scan_data2, strlen(scan_data2), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(results[0], 190); @@ -927,8 +927,8 @@ TEST_F(MaatStringScan, ExprPlusWithOffset) long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *region_name = "Payload"; unsigned char udp_payload_not_hit[] = { /* Stun packet */ 0x00, 0x03, 0x00, 0x4a, 0x21, 0x12, 0xa4, 0x42, @@ -957,17 +957,17 @@ TEST_F(MaatStringScan, ExprPlusWithOffset) 0xf6, 0x30, 0x81, 0xf4, 0x3f, 0xc2, 0x19, 0x6a, 0x68, 0x61, 0x93, 0x08, 0xc0, 0x0a }; - int table_id = maat_get_table_id(maat_instance, "APP_PAYLOAD"); + int table_id = maat_get_table_id(maat_inst, "APP_PAYLOAD"); ASSERT_GT(table_id, 0); int ret = maat_state_set_scan_district(state, table_id, region_name, strlen(region_name)); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, (char*)udp_payload_not_hit, sizeof(udp_payload_not_hit), + ret = maat_scan_string(maat_inst, table_id, (char*)udp_payload_not_hit, sizeof(udp_payload_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - ret = maat_scan_string(maat_instance, table_id, (char*)udp_payload_hit, sizeof(udp_payload_hit), + ret = maat_scan_string(maat_inst, table_id, (char*)udp_payload_hit, sizeof(udp_payload_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(results[0], 148); @@ -980,31 +980,31 @@ TEST_F(MaatStringScan, ExprPlusWithHex) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *scan_data1 = "text/html; charset=UTF-8"; const char *scan_data2 = "Batman\\:Take me Home.Superman/:Fine,stay with me."; const char *region_name1 = "Content-Type"; const char *region_name2 = "User-Agent"; - int table_id = maat_get_table_id(maat_instance, "HTTP_SIGNATURE"); + int table_id = maat_get_table_id(maat_inst, "HTTP_SIGNATURE"); ASSERT_GT(table_id, 0); int ret = maat_state_set_scan_district(state, table_id, region_name1, strlen(region_name1)); ASSERT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(results[0], 156); ret = maat_state_set_scan_district(state, table_id, region_name2, strlen(region_name2)); ASSERT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); //maat-v3 consider as half hit, it's unreasonable - table_id = maat_get_table_id(maat_instance, "KEYWORDS_TABLE"); - ret = maat_scan_string(maat_instance, table_id, scan_data2, strlen(scan_data2), + table_id = maat_get_table_id(maat_inst, "KEYWORDS_TABLE"); + ret = maat_scan_string(maat_inst, table_id, scan_data2, strlen(scan_data2), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(results[0], 132); @@ -1016,27 +1016,27 @@ TEST_F(MaatStringScan, ExprAndExprPlus) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *expr_table_name = "HTTP_URL"; const char *expr_plus_table_name = "HTTP_SIGNATURE"; const char *region_name = "I love China"; const char *scan_data = "today is Monday and yesterday is Tuesday"; - int expr_table_id = maat_get_table_id(maat_instance, expr_table_name); - int expr_plus_table_id = maat_get_table_id(maat_instance, expr_plus_table_name); + int expr_table_id = maat_get_table_id(maat_inst, expr_table_name); + int expr_plus_table_id = maat_get_table_id(maat_inst, expr_plus_table_name); - int ret = maat_scan_string(maat_instance, expr_plus_table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, expr_plus_table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_ERR); ret = maat_state_set_scan_district(state, expr_plus_table_id, region_name, strlen(region_name)); ASSERT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, expr_plus_table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, expr_plus_table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - ret = maat_scan_string(maat_instance, expr_table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, expr_table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(results[0], 195); @@ -1048,8 +1048,8 @@ TEST_F(MaatStringScan, ShouldNotHitExprPlus) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *region_name = "tcp.payload"; unsigned char udp_payload_not_hit[] = { /* Stun packet */ 0x00, 0x03, 0x00, 0x4a, 0x21, 0x12, 0xa4, 0x42, @@ -1065,13 +1065,13 @@ TEST_F(MaatStringScan, ShouldNotHitExprPlus) { 0xf6, 0x30, 0x81, 0xf4, 0x3f, 0xc2, 0x19, 0x6a, 0x68, 0x61, 0x93, 0x08, 0xc0, 0x0a, 0xab, 0x00 }; - int table_id = maat_get_table_id(maat_instance, "APP_PAYLOAD"); + int table_id = maat_get_table_id(maat_inst, "APP_PAYLOAD"); ASSERT_GT(table_id, 0); int ret = maat_state_set_scan_district(state, table_id, region_name, strlen(region_name)); ASSERT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, (char *)udp_payload_not_hit, sizeof(udp_payload_not_hit), + ret = maat_scan_string(maat_inst, table_id, (char *)udp_payload_not_hit, sizeof(udp_payload_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); //maat-v3 consider as half hit, it's unreasonable maat_state_free(state); @@ -1081,14 +1081,14 @@ TEST_F(MaatStringScan, ShouldNotHitExprPlus) { TEST_F(MaatStringScan, Expr8) { const char *table_name = "KEYWORDS_TABLE"; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int table_id = maat_get_table_id(maat_inst, table_name); char scan_data[128] = "string1, string2, string3, string4, string5, string6, string7, string8"; long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -1106,21 +1106,21 @@ TEST_F(MaatStringScan, HexBinCaseSensitive) { const char *table_name = "KEYWORDS_TABLE"; const char *scan_data1 = "String TeST should not hit."; const char *scan_data2 = "String TEST should hit"; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; int thread_id = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); maat_state_reset(state); - ret = maat_scan_string(maat_instance, table_id, scan_data2, strlen(scan_data2), + ret = maat_scan_string(maat_inst, table_id, scan_data2, strlen(scan_data2), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -1149,16 +1149,16 @@ TEST_F(MaatStringScan, BugReport20190325) { 0x00, 0x31, 0x3a, 0x47, 0x32, 0x2e, 0x34, 0x30, 0x00}; const char *table_name = "TROJAN_PAYLOAD"; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; int thread_id = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int ret = maat_scan_string(maat_instance, table_id, (char *)scan_data, sizeof(scan_data), + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int ret = maat_scan_string(maat_inst, table_id, (char *)scan_data, sizeof(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -1173,22 +1173,22 @@ TEST_F(MaatStringScan, PrefixAndSuffix) { const char *hit_prefix = "ceshi3@mailhost.cn11111111111"; const char *cont_sz_table_name = "CONTENT_SIZE"; const char *mail_addr_table_name = "MAIL_ADDR"; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; int thread_id = 0; - int cont_sz_table_id = maat_get_table_id(maat_instance, cont_sz_table_name); + int cont_sz_table_id = maat_get_table_id(maat_inst, cont_sz_table_name); ASSERT_GT(cont_sz_table_id, 0); - int mail_addr_table_id = maat_get_table_id(maat_instance, mail_addr_table_name); + int mail_addr_table_id = maat_get_table_id(maat_inst, mail_addr_table_name); ASSERT_GT(mail_addr_table_id, 0); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int ret = maat_scan_integer(maat_instance, cont_sz_table_id, 2015, results, + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int ret = maat_scan_integer(maat_inst, cont_sz_table_id, 2015, results, ARRAY_SIZE, &n_hit_result, state); - ret = maat_scan_string(maat_instance, mail_addr_table_id, hit_twice, strlen(hit_twice), + ret = maat_scan_string(maat_inst, mail_addr_table_id, hit_twice, strlen(hit_twice), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -1196,15 +1196,15 @@ TEST_F(MaatStringScan, PrefixAndSuffix) { EXPECT_EQ(results[1], 152); maat_state_reset(state); - ret = maat_scan_string(maat_instance, mail_addr_table_id, hit_suffix, strlen(hit_suffix), + ret = maat_scan_string(maat_inst, mail_addr_table_id, hit_suffix, strlen(hit_suffix), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], 151); - ret = maat_scan_integer(maat_instance, cont_sz_table_id, 2015, results, + ret = maat_scan_integer(maat_inst, cont_sz_table_id, 2015, results, ARRAY_SIZE, &n_hit_result, state); - ret = maat_scan_string(maat_instance, mail_addr_table_id, hit_prefix, strlen(hit_prefix), + ret = maat_scan_string(maat_inst, mail_addr_table_id, hit_prefix, strlen(hit_prefix), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -1216,16 +1216,16 @@ TEST_F(MaatStringScan, PrefixAndSuffix) { TEST_F(MaatStringScan, MaatUnescape) { const char *scan_data = "Batman\\:Take me Home.Superman/:Fine,stay with me."; const char *table_name = "KEYWORDS_TABLE"; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; int thread_id = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -1240,17 +1240,17 @@ TEST_F(MaatStringScan, OffsetChunk64) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); FILE *fp = fopen(file_name, "r"); ASSERT_FALSE(fp==NULL); char scan_data[64]; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - struct maat_stream *sp = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state); ASSERT_TRUE(sp != NULL); int ret = 0; @@ -1279,17 +1279,17 @@ TEST_F(MaatStringScan, OffsetChunk1460) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); FILE *fp = fopen(file_name, "r"); ASSERT_FALSE(fp==NULL); char scan_data[1460]; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - struct maat_stream *sp = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state); ASSERT_TRUE(sp != NULL); int ret = 0; @@ -1319,16 +1319,16 @@ TEST_F(MaatStringScan, StreamScanUTF8) { size_t n_hit_result = 0; int thread_id = 0; char scan_data[2048]; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); FILE *fp = fopen(file_name, "r"); ASSERT_FALSE(fp == NULL); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - struct maat_stream *sp = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state); ASSERT_FALSE(sp == NULL); int pass_flag = 0; @@ -1354,15 +1354,15 @@ TEST_F(MaatStringScan, StreamInput) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=yulingjing,abckkk,1234567"; const char *table_name = "HTTP_URL"; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - struct maat_stream *sp = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state); ASSERT_TRUE(sp != NULL); int ret = maat_stream_scan(sp, "www.cyberessays.com", strlen("www.cyberessays.com"), @@ -1385,11 +1385,11 @@ TEST_F(MaatStringScan, dynamic_config) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStringScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStringScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); - int ret = maat_scan_string(maat_instance, table_id, data, strlen(data), results, + int table_id = maat_get_table_id(maat_inst, table_name); + int ret = maat_scan_string(maat_inst, table_id, data, strlen(data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); EXPECT_EQ(n_hit_result, 0); @@ -1399,26 +1399,26 @@ TEST_F(MaatStringScan, dynamic_config) { const char *g2c_table_name = "GROUP2COMPILE"; /* compile table add line */ - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile_id, "null", 1, 0); + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); /* group2compile table add line */ - long long group_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group_id, + long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group_id, compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); /* expr table add line */ - long long item_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); + long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); const char *keywords = "welcome to maat"; - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item_id, group_id, + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id, keywords, NULL, 1, 0, 0, 0); /* EXPR_TYPE_AND MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_string(maat_instance, table_id, data, strlen(data), results, + ret = maat_scan_string(maat_inst, table_id, data, strlen(data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -1426,22 +1426,22 @@ TEST_F(MaatStringScan, dynamic_config) { maat_state_reset(state); /* expr table del line */ - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_DEL, item_id, group_id, + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_DEL, item_id, group_id, keywords, NULL, 1, 0, 0, 0); /* EXPR_TYPE_AND MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); /* group2compile table del line */ - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_DEL, group_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_DEL, group_id, compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); /* compile table del line */ - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, compile_id, "null", 1, 0); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_string(maat_instance, table_id, data, strlen(data), results, + ret = maat_scan_string(maat_inst, table_id, data, strlen(data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); EXPECT_EQ(n_hit_result, 0); @@ -1461,28 +1461,28 @@ protected: maat_options_set_redis(opts, redis_ip, redis_port, redis_db); maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); - _shared_maat_instance = maat_new(opts, table_info_path); - assert(_shared_maat_instance != NULL); + _shared_maat_inst = maat_new(opts, table_info_path); + assert(_shared_maat_inst != NULL); - maat_cmd_flushDB(_shared_maat_instance); - maat_free(_shared_maat_instance); + maat_cmd_flushDB(_shared_maat_inst); + maat_free(_shared_maat_inst); maat_options_set_foreign_cont_dir(opts, "./foreign_files/"); maat_options_set_rule_effect_interval_ms(opts, 0); maat_options_set_gc_timeout_ms(opts, 0); // start GC immediately maat_options_set_stat_file(opts, "./stat.log"); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); } - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatStreamScan::_shared_maat_instance; +struct maat *MaatStreamScan::_shared_maat_inst; TEST_F(MaatStreamScan, dynamic_config) { const char *scan_data1 = "hello world cyberessays.com/search_results.php?action=search&query=yulingjing,abckkk,1234567"; @@ -1492,20 +1492,20 @@ TEST_F(MaatStreamScan, dynamic_config) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatStreamScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatStreamScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); // STEP 1: add keywords1 and wait scan stream to hit - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = test_add_expr_command(maat_instance, table_name, compile1_id, 0, keywords1); + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = test_add_expr_command(maat_inst, table_name, compile1_id, 0, keywords1); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - struct maat_stream *sp = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state); ASSERT_TRUE(sp != NULL); ret = maat_stream_scan(sp, "www.cyberessays.com", strlen("www.cyberessays.com"), @@ -1520,8 +1520,8 @@ TEST_F(MaatStreamScan, dynamic_config) { // STEP 2: Inc config update, use same stream to scan and wait old expr_runtime invalid random_keyword_generate(keyword_buf, sizeof(keyword_buf)); - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = test_add_expr_command(maat_instance, table_name, compile_id, 0, keyword_buf); + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = test_add_expr_command(maat_inst, table_name, compile_id, 0, keyword_buf); EXPECT_EQ(ret, 1); // Inc config has not yet taken effect, stream scan can hit compile @@ -1567,9 +1567,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in MaatIPScan failed.", __FUNCTION__, __LINE__); @@ -1577,23 +1577,23 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatIPScan::_shared_maat_instance; +struct maat *MaatIPScan::_shared_maat_inst; struct log_handle *MaatIPScan::logger; TEST_F(MaatIPScan, IPv4_IPPort) { const char *table_name = "IP_PLUS_CONFIG"; - struct maat *maat_instance = MaatIPScan::_shared_maat_instance; + struct maat *maat_inst = MaatIPScan::_shared_maat_inst; int thread_id = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); char ip_str[32] = "10.0.7.100"; @@ -1605,8 +1605,8 @@ TEST_F(MaatIPScan, IPv4_IPPort) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - ret = maat_scan_ipv4(maat_instance, table_id, sip, port, proto, + struct maat_state *state = maat_state_new(maat_inst, thread_id); + ret = maat_scan_ipv4(maat_inst, table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -1618,10 +1618,10 @@ TEST_F(MaatIPScan, IPv4_IPPort) { TEST_F(MaatIPScan, IPv4_Port) { const char *table_name = "IP_PLUS_CONFIG"; - struct maat *maat_instance = MaatIPScan::_shared_maat_instance; + struct maat *maat_inst = MaatIPScan::_shared_maat_inst; int thread_id = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); char ip_str[32] = "0.0.0.0"; @@ -1633,14 +1633,14 @@ TEST_F(MaatIPScan, IPv4_Port) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - ret = maat_scan_ipv4(maat_instance, table_id, sip, port, proto, + struct maat_state *state = maat_state_new(maat_inst, thread_id); + ret = maat_scan_ipv4(maat_inst, table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); maat_state_reset(state); port = htons(64999); - ret = maat_scan_ipv4(maat_instance, table_id, sip, port, proto, + ret = maat_scan_ipv4(maat_inst, table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -1652,10 +1652,10 @@ TEST_F(MaatIPScan, IPv4_Port) { TEST_F(MaatIPScan, IPv6_IPPort) { const char *table_name = "IP_PLUS_CONFIG"; - struct maat *maat_instance = MaatIPScan::_shared_maat_instance; + struct maat *maat_inst = MaatIPScan::_shared_maat_inst; int thread_id = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); char ip_str[32] = "1001:da8:205:1::101"; uint8_t sip[16]; int ret = inet_pton(AF_INET6, ip_str, &sip); @@ -1665,8 +1665,8 @@ TEST_F(MaatIPScan, IPv6_IPPort) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - ret = maat_scan_ipv6(maat_instance, table_id, sip, port, proto, + struct maat_state *state = maat_state_new(maat_inst, thread_id); + ret = maat_scan_ipv6(maat_inst, table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -1678,10 +1678,10 @@ TEST_F(MaatIPScan, IPv6_IPPort) { TEST_F(MaatIPScan, BugReport20210515) { const char *table_name = "IP_CONFIG"; - struct maat *maat_instance = MaatIPScan::_shared_maat_instance; + struct maat *maat_inst = MaatIPScan::_shared_maat_inst; int thread_id = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); char ip_str[64] = "2409:8915:3430:7e7:8c9b:ff2a:7aa1:e74"; uint8_t ip_addr[sizeof(struct in6_addr)]; int ret = inet_pton(AF_INET6, ip_str, &ip_addr); @@ -1691,8 +1691,8 @@ TEST_F(MaatIPScan, BugReport20210515) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - ret = maat_scan_ipv6(maat_instance, table_id, ip_addr, port, proto, + struct maat_state *state = maat_state_new(maat_inst, thread_id); + ret = maat_scan_ipv6(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); @@ -1702,10 +1702,10 @@ TEST_F(MaatIPScan, BugReport20210515) { TEST_F(MaatIPScan, dynamic_config) { const char *table_name = "IP_PLUS_CONFIG"; - struct maat *maat_instance = MaatIPScan::_shared_maat_instance; + struct maat *maat_inst = MaatIPScan::_shared_maat_inst; int thread_id = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); char ip_str[32] = "100.100.100.100"; uint32_t sip; int ret = inet_pton(AF_INET, ip_str, &sip); @@ -1715,8 +1715,8 @@ TEST_F(MaatIPScan, dynamic_config) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - ret = maat_scan_ipv4(maat_instance, table_id, sip, port, proto, + struct maat_state *state = maat_state_new(maat_inst, thread_id); + ret = maat_scan_ipv4(maat_inst, table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); EXPECT_EQ(n_hit_result, 0); @@ -1726,26 +1726,26 @@ TEST_F(MaatIPScan, dynamic_config) { const char *g2c_table_name = "GROUP2COMPILE"; /* compile table add line */ - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); /* group2compile table add line */ - long long group_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, + long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group_id, compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); /* ip table add line */ - long long item_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = ip_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item_id, group_id, + long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = ip_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id, IPv4, "100.100.100.100", "100.100.100.100", 100, 100, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_ipv4(maat_instance, table_id, sip, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -1753,23 +1753,23 @@ TEST_F(MaatIPScan, dynamic_config) { maat_state_reset(state); /* ip table del line */ - ret = ip_table_set_line(maat_instance, table_name, MAAT_OP_DEL, item_id, group_id, + ret = ip_table_set_line(maat_inst, table_name, MAAT_OP_DEL, item_id, group_id, IPv4, "100.100.100.100", "100.100.100.100", 100, 100, 0); EXPECT_EQ(ret, 1); /* group2compile table del line */ - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_DEL, group_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_DEL, group_id, compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); /* compile table del line */ - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_ipv4(maat_instance, table_id, sip, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); @@ -1799,9 +1799,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in MaatIntervalScan failed.", __FUNCTION__, __LINE__); @@ -1809,15 +1809,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatIntervalScan::_shared_maat_instance; +struct maat *MaatIntervalScan::_shared_maat_inst; struct log_handle *MaatIntervalScan::logger; TEST_F(MaatIntervalScan, Pure) { @@ -1825,19 +1825,19 @@ TEST_F(MaatIntervalScan, Pure) { size_t n_hit_result = 0; int thread_id = 0; const char *table_name = "CONTENT_SIZE"; - struct maat *maat_instance = MaatIntervalScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatIntervalScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); unsigned int scan_data1 = 2015; - int ret = maat_scan_integer(maat_instance, table_id, scan_data1, results, ARRAY_SIZE, + int ret = maat_scan_integer(maat_inst, table_id, scan_data1, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_reset(state); unsigned int scan_data2 = 300; - ret = maat_scan_integer(maat_instance, table_id, scan_data2, results, ARRAY_SIZE, + ret = maat_scan_integer(maat_inst, table_id, scan_data2, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); EXPECT_EQ(n_hit_result, 0); @@ -1850,17 +1850,17 @@ TEST_F(MaatIntervalScan, IntervalPlus) { size_t n_hit_result = 0; int thread_id = 0; const char *table_name = "INTERGER_PLUS"; - struct maat *maat_instance = MaatIntervalScan::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatIntervalScan::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); const char *district_str = "interval.plus"; int ret = maat_state_set_scan_district(state, table_id, district_str, strlen(district_str)); EXPECT_EQ(ret, 0); unsigned int scan_data1 = 2020; - ret = maat_scan_integer(maat_instance, table_id, scan_data1, results, ARRAY_SIZE, + ret = maat_scan_integer(maat_inst, table_id, scan_data1, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -1892,9 +1892,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in NOTLogic failed.", __FUNCTION__, __LINE__); @@ -1902,15 +1902,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *NOTLogic::_shared_maat_instance; +struct maat *NOTLogic::_shared_maat_inst; struct log_handle *NOTLogic::logger; TEST_F(NOTLogic, OneRegion) { @@ -1921,14 +1921,14 @@ TEST_F(NOTLogic, OneRegion) { size_t n_hit_result = 0; int thread_id = 0; const char *table_name = "HTTP_URL"; - struct maat *maat_instance = NOTLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = NOTLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); maat_state_set_last_scan(state); - int ret = maat_scan_string(maat_instance, table_id, string_should_hit, strlen(string_should_hit), + int ret = maat_scan_string(maat_inst, table_id, string_should_hit, strlen(string_should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -1937,7 +1937,7 @@ TEST_F(NOTLogic, OneRegion) { maat_state_reset(state); maat_state_set_last_scan(state); - ret = maat_scan_string(maat_instance, table_id, string_should_not_hit, strlen(string_should_not_hit), + ret = maat_scan_string(maat_inst, table_id, string_should_not_hit, strlen(string_should_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_free(state); @@ -1953,21 +1953,21 @@ TEST_F(NOTLogic, ScanNotAtLast) { int thread_id = 0; const char *hit_table_name = "HTTP_URL"; const char *not_hit_table_name = "KEYWORDS_TABLE"; - struct maat *maat_instance = NOTLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = NOTLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int hit_table_id = maat_get_table_id(maat_instance, hit_table_name); + int hit_table_id = maat_get_table_id(maat_inst, hit_table_name); ASSERT_GT(hit_table_id, 0); - int ret = maat_scan_string(maat_instance, hit_table_id, string_should_hit, strlen(string_should_hit), + int ret = maat_scan_string(maat_inst, hit_table_id, string_should_hit, strlen(string_should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - int not_hit_table_id = maat_get_table_id(maat_instance, not_hit_table_name); + int not_hit_table_id = maat_get_table_id(maat_inst, not_hit_table_name); ASSERT_GT(not_hit_table_id, 0); maat_state_set_last_scan(state); - ret = maat_scan_string(maat_instance, not_hit_table_id, string_should_not_hit, strlen(string_should_not_hit), + ret = maat_scan_string(maat_inst, not_hit_table_id, string_should_not_hit, strlen(string_should_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_free(state); @@ -1982,21 +1982,21 @@ TEST_F(NOTLogic, ScanIrrelavantAtLast) { int thread_id = 0; const char *hit_table_name = "HTTP_URL"; const char *not_hit_table_name = "KEYWORDS_TABLE"; - struct maat *maat_instance = NOTLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = NOTLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int hit_table_id = maat_get_table_id(maat_instance, hit_table_name); + int hit_table_id = maat_get_table_id(maat_inst, hit_table_name); ASSERT_GT(hit_table_id, 0); - int ret = maat_scan_string(maat_instance, hit_table_id, string_should_hit, strlen(string_should_hit), + int ret = maat_scan_string(maat_inst, hit_table_id, string_should_hit, strlen(string_should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - int not_hit_table_id = maat_get_table_id(maat_instance, not_hit_table_name); + int not_hit_table_id = maat_get_table_id(maat_inst, not_hit_table_name); ASSERT_GT(hit_table_id, 0); maat_state_set_last_scan(state); - ret = maat_scan_string(maat_instance, not_hit_table_id, string_irrelevant, strlen(string_irrelevant), + ret = maat_scan_string(maat_inst, not_hit_table_id, string_irrelevant, strlen(string_irrelevant), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -2014,13 +2014,13 @@ TEST_F(NOTLogic, ScanHitAtLastEmptyExpr) { const char *not_hit_table_name = "HTTP_URL"; const char *hit_table_name = "IP_PLUS_CONFIG"; const char *empty_table_name = "EMPTY_KEYWORD"; - struct maat *maat_instance = NOTLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = NOTLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int not_hit_table_id = maat_get_table_id(maat_instance, not_hit_table_name); + int not_hit_table_id = maat_get_table_id(maat_inst, not_hit_table_name); ASSERT_GT(not_hit_table_id, 0); - int ret = maat_scan_string(maat_instance, not_hit_table_id, + int ret = maat_scan_string(maat_inst, not_hit_table_id, string_should_not_hit, strlen(string_should_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); @@ -2030,18 +2030,18 @@ TEST_F(NOTLogic, ScanHitAtLastEmptyExpr) { uint16_t port = htons(18611); int proto = 6; - int hit_table_id = maat_get_table_id(maat_instance, hit_table_name); + int hit_table_id = maat_get_table_id(maat_inst, hit_table_name); ASSERT_GT(hit_table_id, 0); - ret = maat_scan_ipv4(maat_instance, hit_table_id, sip, port, proto, results, + ret = maat_scan_ipv4(maat_inst, hit_table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - int empty_table_id = maat_get_table_id(maat_instance, empty_table_name); + int empty_table_id = maat_get_table_id(maat_inst, empty_table_name); ASSERT_GT(empty_table_id, 0); maat_state_set_last_scan(state); - ret = maat_scan_string(maat_instance, empty_table_id, string_match_no_region, + ret = maat_scan_string(maat_inst, empty_table_id, string_match_no_region, strlen(string_match_no_region), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -2059,13 +2059,13 @@ TEST_F(NOTLogic, ScanHitAtLastEmptyInteger) { const char *not_hit_table_name = "HTTP_URL"; const char *hit_table_name = "IP_PLUS_CONFIG"; const char *empty_table_name = "EMPTY_INTERGER"; - struct maat *maat_instance = NOTLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = NOTLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int not_hit_table_id = maat_get_table_id(maat_instance, not_hit_table_name); + int not_hit_table_id = maat_get_table_id(maat_inst, not_hit_table_name); ASSERT_GT(not_hit_table_id, 0); - int ret = maat_scan_string(maat_instance, not_hit_table_id, string_should_not_hit, + int ret = maat_scan_string(maat_inst, not_hit_table_id, string_should_not_hit, strlen(string_should_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); @@ -2075,18 +2075,18 @@ TEST_F(NOTLogic, ScanHitAtLastEmptyInteger) { uint16_t port = htons(18611); int proto = 6; - int hit_table_id = maat_get_table_id(maat_instance, hit_table_name); + int hit_table_id = maat_get_table_id(maat_inst, hit_table_name); ASSERT_GT(hit_table_id, 0); - ret = maat_scan_ipv4(maat_instance, hit_table_id, sip, port, proto, + ret = maat_scan_ipv4(maat_inst, hit_table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - int empty_table_id = maat_get_table_id(maat_instance, empty_table_name); + int empty_table_id = maat_get_table_id(maat_inst, empty_table_name); ASSERT_GT(empty_table_id, 0); maat_state_set_last_scan(state); - ret = maat_scan_integer(maat_instance, empty_table_id, 2015, + ret = maat_scan_integer(maat_inst, empty_table_id, 2015, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(results[0], 187); @@ -2101,13 +2101,13 @@ TEST_F(NOTLogic, ScanNotIP) { int thread_id = 0; const char *hit_table_name = "HTTP_URL"; const char *not_hit_table_name = "IP_CONFIG"; - struct maat *maat_instance = NOTLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = NOTLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int hit_table_id = maat_get_table_id(maat_instance, hit_table_name); + int hit_table_id = maat_get_table_id(maat_inst, hit_table_name); ASSERT_GT(hit_table_id, 0); - int ret = maat_scan_string(maat_instance, hit_table_id, string_should_hit, + int ret = maat_scan_string(maat_inst, hit_table_id, string_should_hit, strlen(string_should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -2117,11 +2117,11 @@ TEST_F(NOTLogic, ScanNotIP) { uint16_t port = htons(50001); int proto = 6; - int not_hit_table_id = maat_get_table_id(maat_instance, not_hit_table_name); + int not_hit_table_id = maat_get_table_id(maat_inst, not_hit_table_name); ASSERT_GT(not_hit_table_id, 0); maat_state_set_last_scan(state); - ret = maat_scan_ipv4(maat_instance, not_hit_table_id, sip, port, proto, + ret = maat_scan_ipv4(maat_inst, not_hit_table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_free(state); @@ -2150,9 +2150,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in NOTLogic failed.", __FUNCTION__, __LINE__); @@ -2160,15 +2160,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *ExcludeLogic::_shared_maat_instance; +struct maat *ExcludeLogic::_shared_maat_inst; struct log_handle *ExcludeLogic::logger; TEST_F(ExcludeLogic, ScanExcludeAtFirst) { @@ -2179,20 +2179,20 @@ TEST_F(ExcludeLogic, ScanExcludeAtFirst) { int thread_id = 0; const char *not_hit_table_name = "KEYWORDS_TABLE"; const char *hit_table_name = "HTTP_URL"; - struct maat *maat_instance = ExcludeLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = ExcludeLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int not_hit_table_id = maat_get_table_id(maat_instance, not_hit_table_name); + int not_hit_table_id = maat_get_table_id(maat_inst, not_hit_table_name); ASSERT_GT(not_hit_table_id, 0); - int ret = maat_scan_string(maat_instance, not_hit_table_id, string_should_not_hit, strlen(string_should_not_hit), + int ret = maat_scan_string(maat_inst, not_hit_table_id, string_should_not_hit, strlen(string_should_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - int hit_table_id = maat_get_table_id(maat_instance, hit_table_name); + int hit_table_id = maat_get_table_id(maat_inst, hit_table_name); ASSERT_GT(hit_table_id, 0); - ret = maat_scan_string(maat_instance, hit_table_id, string_should_hit, strlen(string_should_hit), + ret = maat_scan_string(maat_inst, hit_table_id, string_should_hit, strlen(string_should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -2209,13 +2209,13 @@ TEST_F(ExcludeLogic, ScanExcludeAtLast) { size_t n_hit_result = 0; int thread_id = 0; const char *table_name = "HTTP_URL"; - struct maat *maat_instance = ExcludeLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = ExcludeLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, string_should_hit, strlen(string_should_hit), + int ret = maat_scan_string(maat_inst, table_id, string_should_hit, strlen(string_should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -2223,7 +2223,7 @@ TEST_F(ExcludeLogic, ScanExcludeAtLast) { EXPECT_EQ(results[0], 200); maat_state_reset(state); - ret = maat_scan_string(maat_instance, table_id, string_should_not_hit, strlen(string_should_not_hit), + ret = maat_scan_string(maat_inst, table_id, string_should_not_hit, strlen(string_should_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_free(state); @@ -2238,22 +2238,22 @@ TEST_F(ExcludeLogic, ScanIrrelavantAtLast) { int thread_id = 0; const char *hit_table_name = "HTTP_URL"; const char *not_hit_table_name = "KEYWORDS_TABLE"; - struct maat *maat_instance = ExcludeLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = ExcludeLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int hit_table_id = maat_get_table_id(maat_instance, hit_table_name); + int hit_table_id = maat_get_table_id(maat_inst, hit_table_name); ASSERT_GT(hit_table_id, 0); - int ret = maat_scan_string(maat_instance, hit_table_id, string_should_hit, strlen(string_should_hit), + int ret = maat_scan_string(maat_inst, hit_table_id, string_should_hit, strlen(string_should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], 200); - int not_hit_table_id = maat_get_table_id(maat_instance, not_hit_table_name); + int not_hit_table_id = maat_get_table_id(maat_inst, not_hit_table_name); ASSERT_GT(hit_table_id, 0); - ret = maat_scan_string(maat_instance, not_hit_table_id, string_irrelevant, strlen(string_irrelevant), + ret = maat_scan_string(maat_inst, not_hit_table_id, string_irrelevant, strlen(string_irrelevant), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); @@ -2265,11 +2265,11 @@ TEST_F(ExcludeLogic, ScanVirtualTable) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = ExcludeLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = ExcludeLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *table_name = "VIRTUAL_IP_PLUS_TABLE"; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); uint32_t should_hit_ip; @@ -2278,7 +2278,7 @@ TEST_F(ExcludeLogic, ScanVirtualTable) { uint16_t port = htons(5210); - int ret = maat_scan_ipv4(maat_instance, table_id, should_hit_ip, port, 6, + int ret = maat_scan_ipv4(maat_inst, table_id, should_hit_ip, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -2286,7 +2286,7 @@ TEST_F(ExcludeLogic, ScanVirtualTable) { maat_state_reset(state); inet_pton(AF_INET, "100.64.1.5", &should_hit_ip); - ret = maat_scan_ipv4(maat_instance, table_id, should_hit_ip, port, 6, + ret = maat_scan_ipv4(maat_inst, table_id, should_hit_ip, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -2294,13 +2294,13 @@ TEST_F(ExcludeLogic, ScanVirtualTable) { maat_state_reset(state); inet_pton(AF_INET, "100.64.1.6", &should_not_hit_ip); - ret = maat_scan_ipv4(maat_instance, table_id, should_not_hit_ip, port, 6, + ret = maat_scan_ipv4(maat_inst, table_id, should_not_hit_ip, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_reset(state); inet_pton(AF_INET, "100.64.1.11", &should_not_hit_ip); - ret = maat_scan_ipv4(maat_instance, table_id, should_not_hit_ip, port, 6, + ret = maat_scan_ipv4(maat_inst, table_id, should_not_hit_ip, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_reset(state); @@ -2312,39 +2312,39 @@ TEST_F(ExcludeLogic, ScanWithMultiClause) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = ExcludeLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = ExcludeLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *ip_table_name = "VIRTUAL_IP_PLUS_TABLE"; - int ip_table_id = maat_get_table_id(maat_instance, ip_table_name); + int ip_table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(ip_table_id, 0); uint32_t ip_addr; inet_pton(AF_INET, "192.168.50.43", &ip_addr); uint16_t port = htons(56168); - int ret = maat_scan_ipv4(maat_instance, ip_table_id, ip_addr, port, 6, + int ret = maat_scan_ipv4(maat_inst, ip_table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); inet_pton(AF_INET, "47.92.108.93", &ip_addr); port = htons(443); - ret = maat_scan_ipv4(maat_instance, ip_table_id, ip_addr, port, 6, + ret = maat_scan_ipv4(maat_inst, ip_table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); const char *expr_table_name = "HTTP_RESPONSE_KEYWORDS"; - int expr_table_id = maat_get_table_id(maat_instance, expr_table_name); + int expr_table_id = maat_get_table_id(maat_inst, expr_table_name); ASSERT_GT(expr_table_id, 0); const char *should_not_hit_expr = "www.jianshu.com"; - ret = maat_scan_string(maat_instance, expr_table_id, should_not_hit_expr, + ret = maat_scan_string(maat_inst, expr_table_id, should_not_hit_expr, strlen(should_not_hit_expr), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); const char *should_hit_expr = "mail.jianshu.com"; - ret = maat_scan_string(maat_instance, expr_table_id, should_hit_expr, + ret = maat_scan_string(maat_inst, expr_table_id, should_hit_expr, strlen(should_hit_expr), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -2359,46 +2359,46 @@ TEST_F(ExcludeLogic, ExcludeInDifferentLevel) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = ExcludeLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = ExcludeLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *ip_table_name = "VIRTUAL_IP_PLUS_TABLE"; - int ip_table_id = maat_get_table_id(maat_instance, ip_table_name); + int ip_table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(ip_table_id, 0); uint32_t ip_addr; inet_pton(AF_INET, "100.64.2.1", &ip_addr); uint16_t port = htons(56168); - int ret = maat_scan_ipv4(maat_instance, ip_table_id, ip_addr, port, 6, + int ret = maat_scan_ipv4(maat_inst, ip_table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); inet_pton(AF_INET, "100.64.2.6", &ip_addr); port = htons(443); - ret = maat_scan_ipv4(maat_instance, ip_table_id, ip_addr, port, 6, + ret = maat_scan_ipv4(maat_inst, ip_table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); const char *expr_table_name = "HTTP_RESPONSE_KEYWORDS"; - int expr_table_id = maat_get_table_id(maat_instance, expr_table_name); + int expr_table_id = maat_get_table_id(maat_inst, expr_table_name); ASSERT_GT(expr_table_id, 0); const char *should_not_hit_expr1 = "www.baidu.com"; - ret = maat_scan_string(maat_instance, expr_table_id, should_not_hit_expr1, + ret = maat_scan_string(maat_inst, expr_table_id, should_not_hit_expr1, strlen(should_not_hit_expr1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); const char *should_not_hit_expr2 = "mail.baidu.com"; - ret = maat_scan_string(maat_instance, expr_table_id, should_not_hit_expr2, + ret = maat_scan_string(maat_inst, expr_table_id, should_not_hit_expr2, strlen(should_not_hit_expr2), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); const char *should_hit_expr = "hit.baidu.com"; - ret = maat_scan_string(maat_instance, expr_table_id, should_hit_expr, strlen(should_hit_expr), + ret = maat_scan_string(maat_inst, expr_table_id, should_hit_expr, strlen(should_hit_expr), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -2414,13 +2414,13 @@ TEST_F(ExcludeLogic, ScanNotIP) { int thread_id = 0; const char *hit_table_name = "HTTP_URL"; const char *not_hit_table_name = "IP_CONFIG"; - struct maat *maat_instance = ExcludeLogic::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = ExcludeLogic::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int hit_table_id = maat_get_table_id(maat_instance, hit_table_name); + int hit_table_id = maat_get_table_id(maat_inst, hit_table_name); ASSERT_GT(hit_table_id, 0); - int ret = maat_scan_string(maat_instance, hit_table_id, string_should_hit, + int ret = maat_scan_string(maat_inst, hit_table_id, string_should_hit, strlen(string_should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -2432,10 +2432,10 @@ TEST_F(ExcludeLogic, ScanNotIP) { uint16_t port = htons(50001); int proto = 6; - int not_hit_table_id = maat_get_table_id(maat_instance, not_hit_table_name); + int not_hit_table_id = maat_get_table_id(maat_inst, not_hit_table_name); ASSERT_GT(not_hit_table_id, 0); - ret = maat_scan_ipv4(maat_instance, not_hit_table_id, sip, port, proto, + ret = maat_scan_ipv4(maat_inst, not_hit_table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -2502,9 +2502,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in PluginTable failed.", __FUNCTION__, __LINE__); @@ -2512,27 +2512,27 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *PluginTable::_shared_maat_instance; +struct maat *PluginTable::_shared_maat_inst; struct log_handle *PluginTable::logger; TEST_F(PluginTable, Callback) { const char *table_name = "QD_ENTRY_INFO"; - struct maat *maat_instance = PluginTable::_shared_maat_instance; + struct maat *maat_inst = PluginTable::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); - int ret = maat_table_callback_register(maat_instance, table_id, + int table_id = maat_get_table_id(maat_inst, table_name); + int ret = maat_table_callback_register(maat_inst, table_id, maat_read_entry_start_cb, maat_read_entry_cb, maat_read_entry_finish_cb, - maat_instance); + maat_inst); EXPECT_EQ(ret, 0); } @@ -2575,13 +2575,13 @@ void plugin_EX_dup_cb(int table_id, void **to, void **from, long argl, void *arg TEST_F(PluginTable, EX_DATA) { const char *table_name = "TEST_PLUGIN_EXDATA_TABLE"; - struct maat *maat_instance = PluginTable::_shared_maat_instance; + struct maat *maat_inst = PluginTable::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int plugin_ex_data_counter = 0; - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, plugin_EX_new_cb, plugin_EX_free_cb, plugin_EX_dup_cb, @@ -2591,7 +2591,7 @@ TEST_F(PluginTable, EX_DATA) { const char *key1 = "HeBei"; struct plugin_ud *ud = NULL; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, key1, strlen(key1)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "Shijiazhuang"); @@ -2599,7 +2599,7 @@ TEST_F(PluginTable, EX_DATA) { plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); const char *key2 = "ShanDong"; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, key2, strlen(key2)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "Jinan"); @@ -2609,13 +2609,13 @@ TEST_F(PluginTable, EX_DATA) { TEST_F(PluginTable, LONG_KEY_TYPE) { const char *table_name = "TEST_PLUGIN_LONG_KEY_TYPE_TABLE"; - struct maat *maat_instance = PluginTable::_shared_maat_instance; + struct maat *maat_inst = PluginTable::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int plugin_ex_data_counter = 0; - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, plugin_EX_new_cb, plugin_EX_free_cb, plugin_EX_dup_cb, @@ -2625,7 +2625,7 @@ TEST_F(PluginTable, LONG_KEY_TYPE) { long long key1 = 11111111; struct plugin_ud *ud = NULL; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)&key1, sizeof(long long)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "Shijiazhuang"); @@ -2633,7 +2633,7 @@ TEST_F(PluginTable, LONG_KEY_TYPE) { plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); long long key2 = 33333333; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)&key2, sizeof(long long)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "Jinan"); @@ -2641,20 +2641,20 @@ TEST_F(PluginTable, LONG_KEY_TYPE) { plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); int key3 = 22222222; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)&key3, sizeof(key3)); ASSERT_TRUE(ud == NULL); } TEST_F(PluginTable, INT_KEY_TYPE) { const char *table_name = "TEST_PLUGIN_INT_KEY_TYPE_TABLE"; - struct maat *maat_instance = PluginTable::_shared_maat_instance; + struct maat *maat_inst = PluginTable::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int plugin_ex_data_counter = 0; - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, plugin_EX_new_cb, plugin_EX_free_cb, plugin_EX_dup_cb, @@ -2664,7 +2664,7 @@ TEST_F(PluginTable, INT_KEY_TYPE) { int key1 = 101; struct plugin_ud *ud = NULL; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)&key1, sizeof(key1)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "China"); @@ -2672,7 +2672,7 @@ TEST_F(PluginTable, INT_KEY_TYPE) { plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); int key2 = 102; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)&key2, sizeof(key2)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "America"); @@ -2680,20 +2680,20 @@ TEST_F(PluginTable, INT_KEY_TYPE) { plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); long long key3 = 103; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)&key3, sizeof(key3)); ASSERT_TRUE(ud == NULL); } TEST_F(PluginTable, IP_KEY_TYPE) { const char *table_name = "TEST_PLUGIN_IP_KEY_TYPE_TABLE"; - struct maat *maat_instance = PluginTable::_shared_maat_instance; + struct maat *maat_inst = PluginTable::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int plugin_ex_data_counter = 0; - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, plugin_EX_new_cb, plugin_EX_free_cb, plugin_EX_dup_cb, @@ -2706,7 +2706,7 @@ TEST_F(PluginTable, IP_KEY_TYPE) { EXPECT_EQ(ret, 1); struct plugin_ud *ud = NULL; - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)&ipv4_addr1, sizeof(ipv4_addr1)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "XiZang"); @@ -2717,7 +2717,7 @@ TEST_F(PluginTable, IP_KEY_TYPE) { ret = inet_pton(AF_INET, "100.64.1.2", &ipv4_addr2); EXPECT_EQ(ret, 1); - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)&ipv4_addr2, sizeof(ipv4_addr2)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "XinJiang"); @@ -2728,7 +2728,7 @@ TEST_F(PluginTable, IP_KEY_TYPE) { ret = inet_pton(AF_INET6, "2001:da8:205:1::101", ipv6_addr1); EXPECT_EQ(ret, 1); - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)ipv6_addr1, sizeof(ipv6_addr1)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "GuiZhou"); @@ -2739,7 +2739,7 @@ TEST_F(PluginTable, IP_KEY_TYPE) { ret = inet_pton(AF_INET6, "1001:da8:205:1::101", ipv6_addr2); EXPECT_EQ(ret, 1); - ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_inst, table_id, (char *)ipv6_addr2, sizeof(ipv6_addr2)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "SiChuan"); @@ -2769,9 +2769,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in IPPluginTable failed.", __FUNCTION__, __LINE__); @@ -2779,15 +2779,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *IPPluginTable::_shared_maat_instance; +struct maat *IPPluginTable::_shared_maat_inst; struct log_handle *IPPluginTable::logger; struct ip_plugin_ud { @@ -2837,12 +2837,12 @@ void ip_plugin_ex_dup_cb(int table_id, void **to, void **from, long argl, void * TEST_F(IPPluginTable, EX_DATA) { int ip_plugin_ex_data_counter = 0; const char *table_name = "TEST_IP_PLUGIN_WITH_EXDATA"; - struct maat *maat_instance = IPPluginTable::_shared_maat_instance; + struct maat *maat_inst = IPPluginTable::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, ip_plugin_ex_new_cb, ip_plugin_ex_free_cb, ip_plugin_ex_dup_cb, @@ -2856,7 +2856,7 @@ TEST_F(IPPluginTable, EX_DATA) { EXPECT_EQ(ret, 1); struct ip_plugin_ud *results[ARRAY_SIZE]; - ret = maat_ip_plugin_table_get_ex_data(maat_instance, table_id, &ipv4, + ret = maat_ip_plugin_table_get_ex_data(maat_inst, table_id, &ipv4, (void **)results, ARRAY_SIZE); EXPECT_EQ(ret, 2); EXPECT_EQ(results[0]->rule_id, 101); @@ -2872,7 +2872,7 @@ TEST_F(IPPluginTable, EX_DATA) { inet_pton(AF_INET6, "2001:db8:1234::5210", &(ipv6.ipv6)); memset(results, 0, sizeof(results)); - ret = maat_ip_plugin_table_get_ex_data(maat_instance, table_id, &ipv6, + ret = maat_ip_plugin_table_get_ex_data(maat_inst, table_id, &ipv6, (void**)results, ARRAY_SIZE); EXPECT_EQ(ret, 2); EXPECT_EQ(results[0]->rule_id, 104); @@ -2884,7 +2884,7 @@ TEST_F(IPPluginTable, EX_DATA) { //Reproduce BugReport-Liumengyan-20210515 inet_pton(AF_INET6, "240e:97c:4010:104::17", &(ipv6.ipv6)); - ret = maat_ip_plugin_table_get_ex_data(maat_instance, table_id, &ipv6, + ret = maat_ip_plugin_table_get_ex_data(maat_inst, table_id, &ipv6, (void**)results, ARRAY_SIZE); EXPECT_EQ(ret, 0); } @@ -2911,9 +2911,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in FQDNPluginTable failed.", __FUNCTION__, __LINE__); @@ -2921,15 +2921,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *FQDNPluginTable::_shared_maat_instance; +struct maat *FQDNPluginTable::_shared_maat_inst; struct log_handle *FQDNPluginTable::logger; #define FQDN_PLUGIN_EX_DATA @@ -2978,13 +2978,13 @@ void fqdn_plugin_ex_dup_cb(int table_id, void **to, void **from, long argl, void TEST_F(FQDNPluginTable, EX_DATA) { const char *table_name = "TEST_FQDN_PLUGIN_WITH_EXDATA"; - struct maat *maat_instance = FQDNPluginTable::_shared_maat_instance; + struct maat *maat_inst = FQDNPluginTable::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int fqdn_plugin_ex_data_counter = 0; - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, fqdn_plugin_ex_new_cb, fqdn_plugin_ex_free_cb, fqdn_plugin_ex_dup_cb, @@ -2995,7 +2995,7 @@ TEST_F(FQDNPluginTable, EX_DATA) { int i = 0; struct fqdn_plugin_ud *result[4]; - ret = maat_fqdn_plugin_table_get_ex_data(maat_instance, table_id, "www.example1.com", (void**)result, 4); + ret = maat_fqdn_plugin_table_get_ex_data(maat_inst, table_id, "www.example1.com", (void**)result, 4); ASSERT_EQ(ret, 2); EXPECT_EQ(result[0]->rule_id, 201); EXPECT_EQ(result[1]->rule_id, 202); @@ -3004,10 +3004,10 @@ TEST_F(FQDNPluginTable, EX_DATA) { fqdn_plugin_ex_free_cb(0, (void**)&(result[i]), 0, NULL); } - ret = maat_fqdn_plugin_table_get_ex_data(maat_instance, table_id, "www.example3.com", (void**)result, 4); + ret = maat_fqdn_plugin_table_get_ex_data(maat_inst, table_id, "www.example3.com", (void**)result, 4); EXPECT_EQ(ret, 0); - ret = maat_fqdn_plugin_table_get_ex_data(maat_instance, table_id, "r3---sn-i3belne6.example2.com", (void**)result, 4); + ret = maat_fqdn_plugin_table_get_ex_data(maat_inst, table_id, "r3---sn-i3belne6.example2.com", (void**)result, 4); ASSERT_EQ(ret, 2); EXPECT_TRUE(result[0]->rule_id == 205 || result[0]->rule_id == 204); @@ -3080,9 +3080,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in BoolPluginTable failed.", __FUNCTION__, __LINE__); @@ -3090,26 +3090,26 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *BoolPluginTable::_shared_maat_instance; +struct maat *BoolPluginTable::_shared_maat_inst; struct log_handle *BoolPluginTable::logger; TEST_F(BoolPluginTable, EX_DATA) { int ex_data_counter = 0, i = 0; const char *table_name = "TEST_BOOL_PLUGIN_WITH_EXDATA"; - struct maat *maat_instance = BoolPluginTable::_shared_maat_instance; + struct maat *maat_inst = BoolPluginTable::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, bool_plugin_ex_new_cb, bool_plugin_ex_free_cb, bool_plugin_ex_dup_cb, @@ -3119,7 +3119,7 @@ TEST_F(BoolPluginTable, EX_DATA) { struct bool_plugin_ud *result[6]; unsigned long long items_1[] = {999}; - ret = maat_bool_plugin_table_get_ex_data(maat_instance, table_id, items_1, + ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items_1, 1, (void**)result, 6); EXPECT_EQ(ret, 0); for (i = 0; i < ret; i++) { @@ -3127,7 +3127,7 @@ TEST_F(BoolPluginTable, EX_DATA) { } unsigned long long items_2[] = {1, 2, 1000}; - ret = maat_bool_plugin_table_get_ex_data(maat_instance, table_id, items_2, + ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items_2, 3, (void**)result, 6); EXPECT_EQ(ret, 1); EXPECT_EQ(result[0]->id, 301); @@ -3136,7 +3136,7 @@ TEST_F(BoolPluginTable, EX_DATA) { } unsigned long long items_3[]={101, 102, 1000}; - ret = maat_bool_plugin_table_get_ex_data(maat_instance, table_id, items_3, + ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items_3, 3, (void**)result, 6); EXPECT_EQ(ret, 4); for (i = 0; i < ret; i++) { @@ -3144,7 +3144,7 @@ TEST_F(BoolPluginTable, EX_DATA) { } unsigned long long items_4[]={7, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7}; - ret = maat_bool_plugin_table_get_ex_data(maat_instance, table_id, items_4, + ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items_4, sizeof(items_4)/sizeof(unsigned long long), (void**)result, 6); EXPECT_EQ(ret, 1); @@ -3176,9 +3176,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in VirtualTable failed.", __FUNCTION__, __LINE__); @@ -3186,15 +3186,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *VirtualTable::_shared_maat_instance; +struct maat *VirtualTable::_shared_maat_inst; struct log_handle *VirtualTable::logger; TEST_F(VirtualTable, basic) { @@ -3202,13 +3202,13 @@ TEST_F(VirtualTable, basic) { size_t n_hit_result = 0; int thread_id = 0; const char *table_name = "HTTP_RESPONSE_KEYWORDS"; - struct maat *maat_instance = VirtualTable::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = VirtualTable::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); char scan_data[128] = "string1, string2, string3, string4, string5, string6, string7, string8"; - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); EXPECT_EQ(n_hit_result, 0); @@ -3238,9 +3238,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in CompileTable failed.", __FUNCTION__, __LINE__); @@ -3248,15 +3248,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *CompileTable::_shared_maat_instance; +struct maat *CompileTable::_shared_maat_inst; struct log_handle *CompileTable::logger; struct rule_ex_param { @@ -3317,15 +3317,15 @@ void compile_ex_param_dup(int table_id, void **to, void **from, long argl, void } TEST_F(CompileTable, CompileRuleUpdate) { - struct maat *maat_instance = CompileTable::_shared_maat_instance; + struct maat *maat_inst = CompileTable::_shared_maat_inst; const char *compile_table_name = "COMPILE"; - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile_id, "null", 1, 0); + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, compile_id, "null", 1, 0); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); } @@ -3337,12 +3337,12 @@ TEST_F(CompileTable, Conjunction1) { const char *scan_data = "i.ytimg.com/vi/OtCNcustg_I/hqdefault.jpg?sqp=-oaymwEZCNAC" "ELwBSFXyq4qpAwsIARUAAIhCGAFwAQ==&rs=AOn4CLDOp_5fHMaCA9XZuJdCRv4DNDorMg"; const char *table_name = "HTTP_URL"; - struct maat *maat_instance = CompileTable::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + struct maat *maat_inst = CompileTable::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -3364,13 +3364,13 @@ TEST_F(CompileTable, Conjunction2) { const char *scan_data = "i.ytimg.com/vi/OtCNcustg_I/hqdefault.jpg?sqp=-oaymwEZCNACELw" "BSFXyq4qpAwsIARUAAIhCGAFwAQ==&rs=AOn4CLDOp_5fHMaCA9XZuJdCRv4DNDorMg"; const char *table_name = "HTTP_URL"; - struct maat *maat_instance = CompileTable::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = CompileTable::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -3381,7 +3381,7 @@ TEST_F(CompileTable, Conjunction2) { int n_read = maat_state_get_hit_paths(state, hit_path, HIT_PATH_SIZE); EXPECT_EQ(n_read, 2); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -3414,9 +3414,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in Policy failed.", __FUNCTION__, __LINE__); @@ -3424,15 +3424,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *Policy::_shared_maat_instance; +struct maat *Policy::_shared_maat_inst; struct log_handle *Policy::logger; void accept_tags_entry_cb(int table_id, const char *table_line, void *u_para) @@ -3449,13 +3449,13 @@ void accept_tags_entry_cb(int table_id, const char *table_line, void *u_para) TEST_F(Policy, PluginRuleTags1) { const char *table_name = "TEST_EFFECTIVE_RANGE_TABLE"; - struct maat *maat_instance = Policy::_shared_maat_instance; + struct maat *maat_inst = Policy::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int callback_times=0; - int ret = maat_table_callback_register(maat_instance, table_id, + int ret = maat_table_callback_register(maat_inst, table_id, NULL, accept_tags_entry_cb, NULL, @@ -3472,13 +3472,13 @@ void accept_tags_entry2_cb(int table_id, const char *table_line, void *u_para) TEST_F(Policy, PluginRuleTags2) { const char *table_name = "IR_INTERCEPT_IP"; - struct maat *maat_instance = Policy::_shared_maat_instance; + struct maat *maat_inst = Policy::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int callback_times = 0; - int ret = maat_table_callback_register(maat_instance, table_id, + int ret = maat_table_callback_register(maat_inst, table_id, NULL, accept_tags_entry2_cb, NULL, @@ -3494,18 +3494,18 @@ TEST_F(Policy, CompileRuleTags) { const char *should_hit = "string bbb should hit"; const char *should_not_hit = "string aaa should not hit"; const char *table_name = "HTTP_URL"; - struct maat *maat_instance = Policy::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = Policy::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, should_not_hit, + int ret = maat_scan_string(maat_inst, table_id, should_not_hit, strlen(should_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - ret = maat_scan_string(maat_instance, table_id, should_hit, + ret = maat_scan_string(maat_inst, table_id, should_hit, strlen(should_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -3522,14 +3522,14 @@ TEST_F(Policy, CompileEXData) { const char *table_name = "HTTP_URL"; const char *compile_table_name = "COMPILE_FIREWALL"; const char *expect_name = "I have a name"; - struct maat *maat_instance = Policy::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = Policy::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); - int compile_table_id = maat_get_table_id(maat_instance, compile_table_name); + int table_id = maat_get_table_id(maat_inst, table_name); + int compile_table_id = maat_get_table_id(maat_inst, compile_table_name); int ex_data_counter = 0; - int ret = maat_plugin_table_ex_schema_register(maat_instance, compile_table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, compile_table_name, compile_ex_param_new, compile_ex_param_free, compile_ex_param_dup, @@ -3540,13 +3540,13 @@ TEST_F(Policy, CompileEXData) { ret = maat_state_set_scan_compile_table(state, compile_table_id); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, url, strlen(url), + ret = maat_scan_string(maat_inst, table_id, url, strlen(url), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], 198); - void *ex_data = maat_plugin_table_get_ex_data(maat_instance, compile_table_id, + void *ex_data = maat_plugin_table_get_ex_data(maat_inst, compile_table_id, (char *)&results[0], sizeof(long long)); ASSERT_TRUE(ex_data!=NULL); struct rule_ex_param *param = (struct rule_ex_param *)ex_data; @@ -3564,25 +3564,25 @@ TEST_F(Policy, SubGroup) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = Policy::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = Policy::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *scan_data = "ceshi6@mailhost.cn"; uint32_t ip_addr; inet_pton(AF_INET,"10.0.6.205", &ip_addr); uint16_t port = htons(50001); - int table_id = maat_get_table_id(maat_instance, "MAIL_ADDR"); + int table_id = maat_get_table_id(maat_inst, "MAIL_ADDR"); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, "IP_CONFIG"); + table_id = maat_get_table_id(maat_inst, "IP_CONFIG"); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -3596,13 +3596,13 @@ TEST_F(Policy, EvaluationOrder) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = Policy::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = Policy::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, "HTTP_URL"); + int table_id = maat_get_table_id(maat_inst, "HTTP_URL"); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, url, strlen(url), + int ret = maat_scan_string(maat_inst, table_id, url, strlen(url), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 3); @@ -3614,11 +3614,11 @@ TEST_F(Policy, EvaluationOrder) { inet_pton(AF_INET, "192.168.23.23", &ip_addr); uint16_t port = htons(65530); - table_id = maat_get_table_id(maat_instance, "IP_PLUS_CONFIG"); + table_id = maat_get_table_id(maat_inst, "IP_PLUS_CONFIG"); ASSERT_GT(table_id, 0); memset(results, 0, sizeof(results)); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -3664,9 +3664,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in TableInfo failed.", __FUNCTION__, __LINE__); @@ -3674,15 +3674,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *TableInfo::_shared_maat_instance; +struct maat *TableInfo::_shared_maat_inst; struct log_handle *TableInfo::logger; TEST_F(TableInfo, Conjunction) { @@ -3692,16 +3692,16 @@ TEST_F(TableInfo, Conjunction) { const char *scan_data = "soq is using table conjunction function.http://www.3300av.com/novel/27122.txt"; const char *table_name = "HTTP_URL"; const char *conj_table_name = "HTTP_HOST"; - struct maat *maat_instance = TableInfo::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = TableInfo::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int conj_table_id = maat_get_table_id(maat_instance, conj_table_name); + int conj_table_id = maat_get_table_id(maat_inst, conj_table_name); ASSERT_GT(conj_table_id, 0); - int ret = maat_scan_string(maat_instance, conj_table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, conj_table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -3728,34 +3728,34 @@ protected: maat_options_set_rule_effect_interval_ms(opts, effective_interval_ms); maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); - _shared_maat_instance = maat_new(opts, table_info); + _shared_maat_inst = maat_new(opts, table_info); maat_options_free(opts); - EXPECT_TRUE(_shared_maat_instance != NULL); + EXPECT_TRUE(_shared_maat_inst != NULL); } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); } - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatFileTest::_shared_maat_instance; +struct maat *MaatFileTest::_shared_maat_inst; TEST_F(MaatFileTest, StreamFiles) { const char test_data_dir[64] = "./test_streamfiles"; const char *table_name = "NTC_HTTP_REQ_BODY"; int thread_id = 0; - struct maat *maat_instance = MaatFileTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatFileTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); struct dirent **name_list; int n = my_scandir(test_data_dir, &name_list, NULL, (int (*)(const void*, const void*))alphasort); ASSERT_GT(n, 0); - struct maat_stream *stream = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *stream = maat_stream_new(maat_inst, table_id, state); ASSERT_FALSE(stream == NULL); struct stat file_info; @@ -3829,9 +3829,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in HierarchyTest failed.", __FUNCTION__, __LINE__); @@ -3839,15 +3839,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *HierarchyTest::_shared_maat_instance; +struct maat *HierarchyTest::_shared_maat_inst; struct log_handle *HierarchyTest::logger; TEST_F(HierarchyTest, VirtualOfOnePhysical) @@ -3859,20 +3859,20 @@ TEST_F(HierarchyTest, VirtualOfOnePhysical) long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = HierarchyTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = HierarchyTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, url_table_name); + int table_id = maat_get_table_id(maat_inst, url_table_name); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, http_url, strlen(http_url), + int ret = maat_scan_string(maat_inst, table_id, http_url, strlen(http_url), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, keywords_table_name); + table_id = maat_get_table_id(maat_inst, keywords_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, http_content, strlen(http_content), + ret = maat_scan_string(maat_inst, table_id, http_content, strlen(http_content), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -3880,7 +3880,7 @@ TEST_F(HierarchyTest, VirtualOfOnePhysical) maat_state_reset(state); const char *should_not_hit = "2018-10-05 is a keywords of table KEYWORDS_TABLE. Should not hit."; - ret = maat_scan_string(maat_instance, table_id, should_not_hit, strlen(should_not_hit), + ret = maat_scan_string(maat_inst, table_id, should_not_hit, strlen(should_not_hit), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_free(state); @@ -3895,26 +3895,26 @@ TEST_F(HierarchyTest, VirtualWithVirtual) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = HierarchyTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = HierarchyTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, req_table_name); + int table_id = maat_get_table_id(maat_inst, req_table_name); ASSERT_GT(table_id, 0); int ret = maat_state_set_scan_district(state, table_id, "User-Agent", strlen("User-Agent")); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, http_req_hdr_ua, strlen(http_req_hdr_ua), + ret = maat_scan_string(maat_inst, table_id, http_req_hdr_ua, strlen(http_req_hdr_ua), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, res_table_name); + table_id = maat_get_table_id(maat_inst, res_table_name); ASSERT_GT(table_id, 0); ret = maat_state_set_scan_district(state, table_id, "Cookie", strlen("Cookie")); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), + ret = maat_scan_string(maat_inst, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -3931,26 +3931,26 @@ TEST_F(HierarchyTest, OneGroupInTwoVirtual) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = HierarchyTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = HierarchyTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, req_table_name); + int table_id = maat_get_table_id(maat_inst, req_table_name); ASSERT_GT(table_id, 0); int ret = maat_state_set_scan_district(state, table_id, "Cookie", strlen("Cookie")); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), + ret = maat_scan_string(maat_inst, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, res_table_name); + table_id = maat_get_table_id(maat_inst, res_table_name); ASSERT_GT(table_id, 0); ret = maat_state_set_scan_district(state, table_id, "Cookie", strlen("Cookie")); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), + ret = maat_scan_string(maat_inst, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -3970,23 +3970,23 @@ TEST_F(HierarchyTest, TwoVirtualInOneClause) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = HierarchyTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = HierarchyTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); //-------------------------------------- // Source ASN & Dest ASN //-------------------------------------- - int table_id = maat_get_table_id(maat_instance, src_asn_table_name); + int table_id = maat_get_table_id(maat_inst, src_asn_table_name); ASSERT_GT(table_id, 0); - int ret = maat_scan_string(maat_instance, table_id, src_asn, strlen(src_asn), + int ret = maat_scan_string(maat_inst, table_id, src_asn, strlen(src_asn), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, dst_asn_table_name); + table_id = maat_get_table_id(maat_inst, dst_asn_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, dst_asn, strlen(dst_asn), + ret = maat_scan_string(maat_inst, table_id, dst_asn, strlen(dst_asn), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -3997,21 +3997,21 @@ TEST_F(HierarchyTest, TwoVirtualInOneClause) { //-------------------------------------- // Source IP & Dest ASN //-------------------------------------- - table_id = maat_get_table_id(maat_instance, ip_table_name); + table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); uint32_t ip_addr; inet_pton(AF_INET, "192.168.40.88", &ip_addr); uint16_t port = htons(8888); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, dst_asn_table_name); + table_id = maat_get_table_id(maat_inst, dst_asn_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, dst_asn, strlen(dst_asn), + ret = maat_scan_string(maat_inst, table_id, dst_asn, strlen(dst_asn), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4022,17 +4022,17 @@ TEST_F(HierarchyTest, TwoVirtualInOneClause) { //-------------------------------------- // Source Geo & Dest ASN //-------------------------------------- - table_id = maat_get_table_id(maat_instance, src_ip_geo_table_name); + table_id = maat_get_table_id(maat_inst, src_ip_geo_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, my_county, strlen(my_county), + ret = maat_scan_string(maat_inst, table_id, my_county, strlen(my_county), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, dst_asn_table_name); + table_id = maat_get_table_id(maat_inst, dst_asn_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, dst_asn, strlen(dst_asn), + ret = maat_scan_string(maat_inst, table_id, dst_asn, strlen(dst_asn), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4054,29 +4054,29 @@ protected: maat_options_set_redis(opts, redis_ip, redis_port, redis_db); maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); - _shared_maat_instance = maat_new(opts, table_info_path); - assert(_shared_maat_instance != NULL); + _shared_maat_inst = maat_new(opts, table_info_path); + assert(_shared_maat_inst != NULL); - maat_cmd_flushDB(_shared_maat_instance); - maat_free(_shared_maat_instance); + maat_cmd_flushDB(_shared_maat_inst); + maat_free(_shared_maat_inst); maat_options_set_foreign_cont_dir(opts, "./foreign_files/"); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); _ex_data_counter = ALLOC(int, 1); } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); FREE(_ex_data_counter); } - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; static int *_ex_data_counter; }; -struct maat *MaatCmdTest::_shared_maat_instance; +struct maat *MaatCmdTest::_shared_maat_inst; int *MaatCmdTest::_ex_data_counter; TEST_F(MaatCmdTest, SetIP) { @@ -4087,18 +4087,18 @@ TEST_F(MaatCmdTest, SetIP) { const char *ip_table_name = "IP_CONFIG"; const char *compile_table_name = "COMPILE"; const char *g2c_table_name = "GROUP2COMPILE"; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); /* compile table add line */ - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile_id, + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); /* group2compile table add line */ - long long group_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group_id, + long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group_id, compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); @@ -4107,13 +4107,13 @@ TEST_F(MaatCmdTest, SetIP) { const char *ip2 = "172.0.0.1"; uint16_t port_min = 53331; uint16_t port_max = 53331; - long long item_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item_id, group_id, + long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item_id, group_id, IPv4, ip1, ip2, port_min, port_max, 0); EXPECT_EQ(ret, 1); - version_before = maat_cmd_get_config_version(maat_instance); - wait_for_cmd_effective(maat_instance, version_before); + version_before = maat_cmd_get_config_version(maat_inst); + wait_for_cmd_effective(maat_inst, version_before); uint32_t sip; ret = inet_pton(AF_INET, ip1, &sip); @@ -4121,10 +4121,10 @@ TEST_F(MaatCmdTest, SetIP) { uint16_t port = htons(53331); int proto = 6; - int table_id = maat_get_table_id(maat_instance, ip_table_name); + int table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GE(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, sip, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, sip, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4146,49 +4146,49 @@ TEST_F(MaatCmdTest, SetExpr) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); maat_cmd_str_escape(escape_buff1, sizeof(escape_buff1), keywords1); maat_cmd_str_escape(escape_buff2, sizeof(escape_buff2), keywords2); snprintf(keywords, sizeof(keywords), "%s&%s", escape_buff1, escape_buff2); - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 2); + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 2); - test_add_expr_command(maat_instance, table_name, compile_id - 1, 0, keywords); - test_add_expr_command(maat_instance, table_name, compile_id, 0, keywords); - long long version_before = maat_cmd_get_config_version(maat_instance); + test_add_expr_command(maat_inst, table_name, compile_id - 1, 0, keywords); + test_add_expr_command(maat_inst, table_name, compile_id, 0, keywords); + long long version_before = maat_cmd_get_config_version(maat_inst); - wait_for_cmd_effective(maat_instance, version_before); + wait_for_cmd_effective(maat_inst, version_before); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); memset(results, 0, sizeof(results)); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_TRUE(results[0] == compile_id || results[0] == (compile_id - 1)); maat_state_reset(state); - ret = compile_table_set_line(maat_instance, "COMPILE", MAAT_OP_DEL, compile_id-1, + ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_DEL, compile_id-1, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = compile_table_set_line(maat_instance, "COMPILE", MAAT_OP_DEL, compile_id, + ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_DEL, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_reset(state); int timeout = 1; - compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - test_add_expr_command(maat_instance, table_name, compile_id, timeout, keywords); + compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + test_add_expr_command(maat_inst, table_name, compile_id, timeout, keywords); sleep(timeout + 1); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_free(state); @@ -4209,49 +4209,49 @@ TEST_F(MaatCmdTest, SetExpr8) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); /* compile table add line */ - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile_id, "null", 1, 0); + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); /* group2compile table add line */ - long long group_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group_id, + long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group_id, compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); /* expr table add line */ - long long item_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item_id, group_id, + long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id, keywords8, NULL, 1, 0, 0, 0); /* EXPR_TYPE_AND MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, scan_data8, strlen(scan_data8), + ret = maat_scan_string(maat_inst, table_id, scan_data8, strlen(scan_data8), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], compile_id); maat_state_reset(state); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_DEL, item_id, group_id, + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_DEL, item_id, group_id, keywords8, NULL, 1, 0, 0, 0); EXPECT_EQ(ret, 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item_id, group_id, + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id, keywords7, NULL, 1, 0, 0, 0); sleep(WAIT_FOR_EFFECTIVE_S); memset(&results, 0, sizeof(results)); - ret = maat_scan_string(maat_instance, table_id, scan_data7, strlen(scan_data7), + ret = maat_scan_string(maat_inst, table_id, scan_data7, strlen(scan_data7), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4267,36 +4267,36 @@ TEST_F(MaatCmdTest, RuleIDRecycle) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - long long rule_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - test_add_expr_command(maat_instance, table_name, rule_id, 0, keywords); + long long rule_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + test_add_expr_command(maat_inst, table_name, rule_id, 0, keywords); sleep(WAIT_FOR_EFFECTIVE_S); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); maat_state_reset(state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], rule_id); - del_command(maat_instance, rule_id); + del_command(maat_inst, rule_id); sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); maat_state_reset(state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - test_add_expr_command(maat_instance, table_name, rule_id, 0, keywords); + test_add_expr_command(maat_inst, table_name, rule_id, 0, keywords); sleep(WAIT_FOR_EFFECTIVE_S); memset(results, 0, sizeof(results)); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); maat_state_free(state); state = NULL; @@ -4313,27 +4313,27 @@ TEST_F(MaatCmdTest, ReturnRuleIDWithDescendingOrder) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int i = 0; int repeat_times = 4; long long expect_rule_id[ARRAY_SIZE] = {0}; - long long rule_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", repeat_times); + long long rule_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", repeat_times); for (i = 0; i < repeat_times; i++) { //add in ascending order expect_rule_id[i] = rule_id + 1 - repeat_times + i; - test_add_expr_command(maat_instance, table_name, expect_rule_id[i], 0, keywords); + test_add_expr_command(maat_inst, table_name, expect_rule_id[i], 0, keywords); } sleep(WAIT_FOR_EFFECTIVE_S); memset(results, 0, sizeof(results)); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); maat_state_free(state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -4355,40 +4355,40 @@ TEST_F(MaatCmdTest, SubGroup) { const char *keyword2 = "ask.leju.com/b&/detail/12189672562229248/?&?bi=tg\\&type=sina-pc\\&&\\&pos=" "index-dbtlwzl\\&&\\&type=sina-pc\\&pos=index-dbtlwzl\\&"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); /* compile table add line */ //compile1 - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); //compile2 - long long compile2_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, + long long compile2_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile2_id, "null", 1, 0); EXPECT_EQ(ret, 1); /* group2compile table add line */ //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); //group1 -> compile2 - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile2_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); //group2 -> group1 -> compile1 - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2group_table_set_line(maat_instance, g2g_table_name, MAAT_OP_ADD, + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2group_table_set_line(maat_inst, g2g_table_name, MAAT_OP_ADD, group2_id, group1_id, 0, 0); EXPECT_EQ(ret, 1); @@ -4396,15 +4396,15 @@ TEST_F(MaatCmdTest, SubGroup) { \ \ _ compile2 */ - long long item_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item_id, group2_id, + long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group2_id, keyword1, NULL, 1, 0, 0, 0);/* EXPR_TYPE_AND MATCH_METHOD_SUB */ sleep(4); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 2); @@ -4416,12 +4416,12 @@ TEST_F(MaatCmdTest, SubGroup) { \ \_ X -> compile2 */ - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_DEL, group1_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_DEL, group1_id, compile2_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - sleep(2); + sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), results, + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4432,19 +4432,19 @@ TEST_F(MaatCmdTest, SubGroup) { \ \_ -> compile2 */ - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_DEL, group1_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_DEL, group1_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, compile1_id, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile2_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(2); - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4456,16 +4456,16 @@ TEST_F(MaatCmdTest, SubGroup) { \_ -> compile2 item2 -> group3 */ - long long group3_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2group_table_set_line(maat_instance, g2g_table_name, MAAT_OP_ADD, group3_id, + long long group3_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2group_table_set_line(maat_inst, g2g_table_name, MAAT_OP_ADD, group3_id, group1_id, 0, 0); EXPECT_EQ(ret, 1); - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item2_id, group3_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item2_id, group3_id, keyword2, NULL, 1, 0, 0, 0);/* EXPR_TYPE_AND MATCH_METHOD_SUB */ sleep(2); - ret = maat_scan_string(maat_instance, table_id, scan_data2, strlen(scan_data2), + ret = maat_scan_string(maat_inst, table_id, scan_data2, strlen(scan_data2), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); maat_state_reset(state); @@ -4475,22 +4475,22 @@ TEST_F(MaatCmdTest, SubGroup) { \_ -> compile2 item2 -> group3 */ - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, compile1_id, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_DEL, group1_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_DEL, group1_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(2); - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4507,27 +4507,27 @@ TEST_F(MaatCmdTest, RefGroup) { const char* keyword1 = "something-should-not-hit"; const char* keyword2 = "facebook.com/help/2297503110373101"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); //TODO: value=0 MAAT_OPT_ENABLE_UPDATE - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item1_id, group1_id, keyword1, NULL, 1, 0, 0, 0); /* EXPR_TYPE_AND MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); @@ -4540,26 +4540,26 @@ TEST_F(MaatCmdTest, RefGroup) { / item2 -> group2 */ - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item2_id, group2_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item2_id, group2_id, keyword2, NULL, 1, 0, 0, 0);/* EXPR_TYPE_AND MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_DEL, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_DEL, group1_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); @@ -4569,7 +4569,7 @@ TEST_F(MaatCmdTest, RefGroup) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4583,23 +4583,23 @@ TEST_F(MaatCmdTest, VirtualTable) { const char* compile_table_name = "COMPILE"; const char* table_name="HTTP_SIGNATURE"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 2, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "HTTP_REQUEST_HEADER", 1, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item1_id, group1_id, "AppleWebKit", "User-Agent", 0, 0, 0, 0);/*EXPR_TYPE_STRING MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); @@ -4607,8 +4607,8 @@ TEST_F(MaatCmdTest, VirtualTable) { / group2_/ */ - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile1_id, 0, "HTTP_RESPONSE_HEADER", 2, 0); EXPECT_EQ(ret, 1); @@ -4616,8 +4616,8 @@ TEST_F(MaatCmdTest, VirtualTable) { / item2 -> group2/ */ - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item2_id, group2_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item2_id, group2_id, "uid=12345678;", "Cookie", 0, 0, 0, 0);/*EXPR_TYPE_STRING MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); @@ -4629,23 +4629,23 @@ TEST_F(MaatCmdTest, VirtualTable) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - int table_id = maat_get_table_id(maat_instance, "HTTP_REQUEST_HEADER"); + int table_id = maat_get_table_id(maat_inst, "HTTP_REQUEST_HEADER"); ASSERT_GT(table_id, 0); ret = maat_state_set_scan_district(state, table_id, "User-Agent", strlen("User-Agent")); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, http_req_hdr_ua, strlen(http_req_hdr_ua), + ret = maat_scan_string(maat_inst, table_id, http_req_hdr_ua, strlen(http_req_hdr_ua), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, "HTTP_RESPONSE_HEADER"); + table_id = maat_get_table_id(maat_inst, "HTTP_RESPONSE_HEADER"); ASSERT_GT(table_id, 0); ret = maat_state_set_scan_district(state, table_id, "Cookie", strlen("Cookie")); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), + ret = maat_scan_string(maat_inst, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4653,24 +4653,24 @@ TEST_F(MaatCmdTest, VirtualTable) { maat_state_reset(state); //delete group1 - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_DEL, group1_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_DEL, group1_id, compile1_id, 0, "HTTP_REQUEST_HEADER", 1, 0); EXPECT_EQ(ret, 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, compile1_id, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile1_id, "null", 2, 0); EXPECT_EQ(ret, 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(2); - table_id = maat_get_table_id(maat_instance, "HTTP_RESPONSE_HEADER"); + table_id = maat_get_table_id(maat_inst, "HTTP_RESPONSE_HEADER"); ASSERT_GT(table_id, 0); ret = maat_state_set_scan_district(state, table_id, "Cookie", strlen("Cookie")); EXPECT_EQ(ret, 0); - ret = maat_scan_string(maat_instance, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), + ret = maat_scan_string(maat_inst, table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -4684,7 +4684,7 @@ TEST_F(MaatCmdTest, SetLines) { const int TEST_CMD_LINE_NUM = 4; const char *table_name = "QD_ENTRY_INFO"; struct maat_cmd_line line_rule; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; long long expect_rule_id[TEST_CMD_LINE_NUM] = {0}; const char *table_line_add[TEST_CMD_LINE_NUM] = { "1\t192.168.0.1\t100\t1", @@ -4701,13 +4701,13 @@ TEST_F(MaatCmdTest, SetLines) { int ret = 0; for (i = 0; i < TEST_CMD_LINE_NUM; i++) { - expect_rule_id[i] = maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + expect_rule_id[i] = maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.rule_id = expect_rule_id[i]; line_rule.table_name = table_name; line_rule.table_line = table_line_add[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } @@ -4718,7 +4718,7 @@ TEST_F(MaatCmdTest, SetLines) { line_rule.table_line = table_line_del[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } } @@ -4735,13 +4735,13 @@ void pause_update_test_entry_cb(int table_id,const char* table_line,void* u_para } TEST_F(MaatCmdTest, PauseUpdate) { - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; const char *table_name = "QD_ENTRY_INFO"; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_table_callback_register(maat_instance, table_id, NULL, + int ret = maat_table_callback_register(maat_inst, table_id, NULL, pause_update_test_entry_cb, NULL, NULL); //TODO: value = 0 MAAT_OPT_ENABLE_UPDATE @@ -4749,13 +4749,13 @@ TEST_F(MaatCmdTest, PauseUpdate) { char *line = NULL; struct maat_cmd_line line_rule; - line_rule.rule_id = maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + line_rule.rule_id = maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.table_name = table_name; asprintf(&line, "1\t192.168.0.1\t101\t1"); line_rule.table_line = line; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_EQ(ret, 1); free(line); @@ -4840,13 +4840,13 @@ void foreign_key_test_entry_cb(int table_id, const char *table_line, void *u_par } TEST_F(MaatCmdTest, SetFile) { - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; const char* table_name = "TEST_FOREIGN_KEY"; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_table_callback_register(maat_instance, table_id, NULL, + int ret = maat_table_callback_register(maat_inst, table_id, NULL, foreign_key_test_entry_cb, NULL, NULL); EXPECT_EQ(ret, 0); @@ -4857,13 +4857,13 @@ TEST_F(MaatCmdTest, SetFile) { size_t file_size = 0; prepare_file_to_set(file1_name, &file_buff, &file_size, file1_key, sizeof(file1_key)); - ret = maat_cmd_set_file(maat_instance, file1_key, file_buff, file_size, MAAT_OP_ADD); + ret = maat_cmd_set_file(maat_inst, file1_key, file_buff, file_size, MAAT_OP_ADD); EXPECT_EQ(ret, 1); free(file_buff); file_buff = NULL; prepare_file_to_set(file2_name, &file_buff, &file_size, file2_key, sizeof(file2_key)); - ret = maat_cmd_set_file(maat_instance, file2_key, file_buff, file_size, MAAT_OP_ADD); + ret = maat_cmd_set_file(maat_inst, file2_key, file_buff, file_size, MAAT_OP_ADD); EXPECT_EQ(ret, 1); free(file_buff); file_buff = NULL; @@ -4872,22 +4872,22 @@ TEST_F(MaatCmdTest, SetFile) { char line[1024] = {0}; int tag = 0; struct maat_cmd_line line_rule; - line_rule.rule_id = maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + line_rule.rule_id = maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.table_name = table_name; snprintf(line, sizeof(line),"%lld\t2\t%d\t1\t%s\tredis://%s\t%s\tredis://%s\tEnd", line_rule.rule_id, tag, file1_name, file1_key, file2_name, file2_key); line_rule.table_line = line; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S);//wait for callback triggered. EXPECT_EQ(g_test_foregin_read_OK, 1); g_test_foreign_del_OK = 0; - ret = maat_cmd_set_file(maat_instance, file1_key, NULL, 0, MAAT_OP_DEL); + ret = maat_cmd_set_file(maat_inst, file1_key, NULL, 0, MAAT_OP_DEL); EXPECT_EQ(ret, 1); - ret = maat_cmd_set_file(maat_instance, file2_key, NULL, 0, MAAT_OP_DEL); + ret = maat_cmd_set_file(maat_inst, file2_key, NULL, 0, MAAT_OP_DEL); EXPECT_EQ(ret, 1); struct maat_cmd_line line_rule_del; @@ -4898,7 +4898,7 @@ TEST_F(MaatCmdTest, SetFile) { line_rule.rule_id, tag, file1_name, file1_key, file2_name, file2_key); line_rule_del.table_line = line; line_rule_del.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule_del); + ret = maat_cmd_set_line(maat_inst, &line_rule_del); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); @@ -4911,7 +4911,7 @@ TEST_F(MaatCmdTest, SetFile) { // Test empty file, file key is a string "null". memset(&line_rule, 0, sizeof(line_rule)); memset(line, 0, sizeof(line)); - line_rule.rule_id = maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + line_rule.rule_id = maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.table_name=table_name; snprintf(line, sizeof(line),"%lld\t2\t%d\t1\t%s\tredis://%s\t%s\t%s\tEnd", line_rule.rule_id, tag, file1_name, file1_key, empty_file_name, "null"); @@ -4920,7 +4920,7 @@ TEST_F(MaatCmdTest, SetFile) { g_test_foregin_read_OK = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S);//wait for callback triggered. EXPECT_EQ(g_test_foregin_read_OK, 1); @@ -4964,7 +4964,7 @@ void plugin_ex_dup_cb(int table_id, void **to, void **from, long argl, void *arg TEST_F(MaatCmdTest, PluginEXData) { const char *table_name = "TEST_PLUGIN_EXDATA_TABLE"; const int TEST_CMD_LINE_NUM = 4; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; int *ex_data_counter = MaatCmdTest::_ex_data_counter; const char *table_line_add[TEST_CMD_LINE_NUM] = {"1\t192.168.0.1\tmahuateng\t1\t0", "2\t192.168.0.2\tliuqiangdong\t1\t0", @@ -4976,7 +4976,7 @@ TEST_F(MaatCmdTest, PluginEXData) { "3\t192.168.0.3\tmayun\t0\t0", "4\t192.168.0.4\tliyanhong\t0\t0"}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int i = 0, ret = 0; @@ -4985,19 +4985,19 @@ TEST_F(MaatCmdTest, PluginEXData) { /* 1st line */ for (i = 0; i < TEST_CMD_LINE_NUM; i++) { memset(&line_rule, 0, sizeof(line_rule)); - rule_id[i] = maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + rule_id[i] = maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.rule_id = rule_id[i]; line_rule.table_name = table_name; line_rule.table_line = table_line_add[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } sleep(WAIT_FOR_EFFECTIVE_S); *ex_data_counter = 0; - ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, plugin_ex_new_cb, plugin_ex_free_cb, plugin_ex_dup_cb, @@ -5007,7 +5007,7 @@ TEST_F(MaatCmdTest, PluginEXData) { struct user_info *uinfo = NULL; const char *key1 = "192.168.0.2"; - uinfo = (struct user_info *)maat_plugin_table_get_ex_data(maat_instance, table_id, + uinfo = (struct user_info *)maat_plugin_table_get_ex_data(maat_inst, table_id, key1, strlen(key1)); ASSERT_TRUE(uinfo != NULL); EXPECT_EQ(0, strcmp(uinfo->name, "liuqiangdong")); @@ -5020,12 +5020,12 @@ TEST_F(MaatCmdTest, PluginEXData) { line_rule.table_line = table_line_del[1]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); sleep(WAIT_FOR_EFFECTIVE_S); const char *key2 = "192.168.0.2"; - uinfo = (struct user_info *)maat_plugin_table_get_ex_data(maat_instance, table_id, + uinfo = (struct user_info *)maat_plugin_table_get_ex_data(maat_inst, table_id, key2, strlen(key2)); ASSERT_TRUE(uinfo == NULL); } @@ -5033,7 +5033,7 @@ TEST_F(MaatCmdTest, PluginEXData) { TEST_F(MaatCmdTest, UpdateIPPlugin) { const char *table_name = "TEST_IP_PLUGIN_WITH_EXDATA"; const int TEST_CMD_LINE_NUM = 4; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; int *ex_data_counter = MaatCmdTest::_ex_data_counter; const char *table_line_add[TEST_CMD_LINE_NUM] = { "101\t4\t192.168.30.99\t192.168.30.101\tSomething-like-json\t1\trange", @@ -5046,7 +5046,7 @@ TEST_F(MaatCmdTest, UpdateIPPlugin) { "103\t6\t2001:db8:1234::\t2001:db8:1235::\tBigger-range-should-in-the-back\t0\trange", "104\t6\t2001:db8:1234::1\t2001:db8:1234::5210\tSomething-like-json\t0\trange"}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int i = 0, ret = 0; @@ -5055,20 +5055,20 @@ TEST_F(MaatCmdTest, UpdateIPPlugin) { //add lines for (i = 0; i < TEST_CMD_LINE_NUM; i++) { memset(&line_rule, 0, sizeof(line_rule)); - rule_id[i] = maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + rule_id[i] = maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.rule_id = rule_id[i]; line_rule.table_name = table_name; line_rule.table_line = table_line_add[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } sleep(WAIT_FOR_EFFECTIVE_S); *ex_data_counter = 0; - ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, ip_plugin_ex_new_cb, ip_plugin_ex_free_cb, ip_plugin_ex_dup_cb, @@ -5082,7 +5082,7 @@ TEST_F(MaatCmdTest, UpdateIPPlugin) { inet_pton(AF_INET, "192.168.30.100", &(ipv4.ipv4)); memset(results, 0, sizeof(results)); - ret = maat_ip_plugin_table_get_ex_data(maat_instance, table_id, &ipv4, + ret = maat_ip_plugin_table_get_ex_data(maat_inst, table_id, &ipv4, (void **)results, ARRAY_SIZE); EXPECT_EQ(ret, 2); EXPECT_EQ(results[0]->rule_id, 101); @@ -5095,7 +5095,7 @@ TEST_F(MaatCmdTest, UpdateIPPlugin) { inet_pton(AF_INET6, "2001:db8:1234::5210", &(ipv6.ipv6)); memset(results, 0, sizeof(results)); - ret = maat_ip_plugin_table_get_ex_data(maat_instance, table_id, &ipv6, + ret = maat_ip_plugin_table_get_ex_data(maat_inst, table_id, &ipv6, (void **)results, ARRAY_SIZE); EXPECT_EQ(ret, 2); EXPECT_EQ(results[0]->rule_id, 104); @@ -5112,14 +5112,14 @@ TEST_F(MaatCmdTest, UpdateIPPlugin) { line_rule.table_line = table_line_del[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } sleep(WAIT_FOR_EFFECTIVE_S); memset(results, 0, sizeof(results)); - ret = maat_ip_plugin_table_get_ex_data(maat_instance, table_id, &ipv4, + ret = maat_ip_plugin_table_get_ex_data(maat_inst, table_id, &ipv4, (void **)results, ARRAY_SIZE); EXPECT_EQ(ret, 0); } @@ -5127,7 +5127,7 @@ TEST_F(MaatCmdTest, UpdateIPPlugin) { TEST_F(MaatCmdTest, UpdateFQDNPlugin) { const char *table_name = "TEST_FQDN_PLUGIN_WITH_EXDATA"; const int TEST_CMD_LINE_NUM = 5; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; int *ex_data_counter = MaatCmdTest::_ex_data_counter; const char *table_line_add[TEST_CMD_LINE_NUM]={ "201\t0\twww.example1.com\tcatid=1\t1", @@ -5142,7 +5142,7 @@ TEST_F(MaatCmdTest, UpdateFQDNPlugin) { "204\t0\tr3---sn-i3belne6.example2.com\tcatid=3\t0", "205\t0\tr3---sn-i3belne6.example2.com\tcatid=3\t0"}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); int i = 0, ret = 0; @@ -5151,20 +5151,20 @@ TEST_F(MaatCmdTest, UpdateFQDNPlugin) { //add lines for (i = 0; i < TEST_CMD_LINE_NUM; i++) { memset(&line_rule, 0, sizeof(line_rule)); - rule_id[i] = maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + rule_id[i] = maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.rule_id = rule_id[i]; line_rule.table_name = table_name; line_rule.table_line = table_line_add[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } sleep(WAIT_FOR_EFFECTIVE_S); *ex_data_counter = 0; - ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, fqdn_plugin_ex_new_cb, fqdn_plugin_ex_free_cb, fqdn_plugin_ex_dup_cb, @@ -5175,7 +5175,7 @@ TEST_F(MaatCmdTest, UpdateFQDNPlugin) { struct fqdn_plugin_ud *results[ARRAY_SIZE]; memset(results, 0, sizeof(results)); - ret = maat_fqdn_plugin_table_get_ex_data(maat_instance, table_id, + ret = maat_fqdn_plugin_table_get_ex_data(maat_inst, table_id, "r3---sn-i3belne6.example2.com", (void**)results, ARRAY_SIZE); ASSERT_EQ(ret, 2); @@ -5191,12 +5191,12 @@ TEST_F(MaatCmdTest, UpdateFQDNPlugin) { line_rule.table_line = table_line_del[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_fqdn_plugin_table_get_ex_data(maat_instance, table_id, + ret = maat_fqdn_plugin_table_get_ex_data(maat_inst, table_id, "r3---sn-i3belne6.example2.com", (void**)results, ARRAY_SIZE); ASSERT_EQ(ret, 0); @@ -5205,7 +5205,7 @@ TEST_F(MaatCmdTest, UpdateFQDNPlugin) { TEST_F(MaatCmdTest, UpdateBoolPlugin) { const char *table_name = "TEST_BOOL_PLUGIN_WITH_EXDATA"; const int TEST_CMD_LINE_NUM = 6; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; int *ex_data_counter = MaatCmdTest::_ex_data_counter; const char *table_line_add[TEST_CMD_LINE_NUM] = { "301\t1&2&1000\ttunnel1\t1", @@ -5222,7 +5222,7 @@ TEST_F(MaatCmdTest, UpdateBoolPlugin) { "305\t0&1&2&3&4&5&6&7\ttunnel5\t0", "306\t101&101\tinvalid\t0"}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); long long rule_id[TEST_CMD_LINE_NUM] = {0}; @@ -5231,20 +5231,20 @@ TEST_F(MaatCmdTest, UpdateBoolPlugin) { for (i = 0; i < TEST_CMD_LINE_NUM; i++) { memset(&line_rule, 0, sizeof(line_rule)); - rule_id[i] = maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + rule_id[i] = maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.rule_id = rule_id[i]; line_rule.table_name = table_name; line_rule.table_line = table_line_add[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } sleep(WAIT_FOR_EFFECTIVE_S); *ex_data_counter = 0; - ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, bool_plugin_ex_new_cb, bool_plugin_ex_free_cb, bool_plugin_ex_dup_cb, @@ -5255,7 +5255,7 @@ TEST_F(MaatCmdTest, UpdateBoolPlugin) { unsigned long long items[] = {101, 102, 1000}; struct bool_plugin_ud *results[ARRAY_SIZE]; memset(results, 0, sizeof(results)); - ret = maat_bool_plugin_table_get_ex_data(maat_instance, table_id, items, 3, + ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items, 3, (void **)results, ARRAY_SIZE); EXPECT_EQ(ret, 4); for (i = 0; i < ret; i++) { @@ -5269,13 +5269,13 @@ TEST_F(MaatCmdTest, UpdateBoolPlugin) { line_rule.table_line = table_line_del[i]; line_rule.expire_after = 0; - ret = maat_cmd_set_line(maat_instance, &line_rule); + ret = maat_cmd_set_line(maat_inst, &line_rule); EXPECT_GT(ret, 0); } sleep(WAIT_FOR_EFFECTIVE_S); memset(results, 0, sizeof(results)); - ret = maat_bool_plugin_table_get_ex_data(maat_instance, table_id, items, 3, + ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items, 3, (void **)results, ARRAY_SIZE); EXPECT_EQ(ret, 2); for (i = 0; i < ret; i++) { @@ -5290,27 +5290,27 @@ TEST_F(MaatCmdTest, GroupInMassCompiles) { const char* table_url = "HTTP_URL"; const char* table_appid = "APP_ID"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); //item_url1 -> group1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - int ret = expr_table_set_line(maat_instance, table_url, MAAT_OP_ADD, item1_id, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + int ret = expr_table_set_line(maat_inst, table_url, MAAT_OP_ADD, item1_id, group1_id, "baidu.com&tsg", NULL, 1, 0, 0, 0);/* EXPR_TYPE_AND MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); //item_url2 -> group2 - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_url, MAAT_OP_ADD, item2_id, group2_id, + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_url, MAAT_OP_ADD, item2_id, group2_id, "baidu.com&zhengzhou", NULL, 1, 0, 0, 0);/* EXPR_TYPE_AND MATCH_METHOD_SUB */ EXPECT_EQ(ret, 1); //item_appid -> group3 - long long group3_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - long long item3_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = intval_table_set_line(maat_instance, table_appid, MAAT_OP_ADD, item3_id, group3_id, + long long group3_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + long long item3_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = intval_table_set_line(maat_inst, table_appid, MAAT_OP_ADD, item3_id, group3_id, 100, 100, NULL, 0); EXPECT_EQ(ret, 1); @@ -5321,18 +5321,18 @@ TEST_F(MaatCmdTest, GroupInMassCompiles) { int i = 0; long long compile_id[COMPILE_ID_NUMS] = {0}; for (i = 0; i < COMPILE_ID_NUMS; i++) { - compile_id[i] = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile_id[i], + compile_id[i] = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile_id[i], "mass_compile", 2, 0); EXPECT_EQ(ret, 1); } for (i = 0; i < COMPILE_ID_NUMS; i++) { - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile_id[i], 0, "null", 0, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group3_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group3_id, compile_id[i], 0, "null", 2, 0); EXPECT_EQ(ret, 1); } @@ -5341,14 +5341,14 @@ TEST_F(MaatCmdTest, GroupInMassCompiles) { / item_appid -> group3_/ */ - long long target_compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, target_compile_id, + long long target_compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, target_compile_id, "null", 2, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, target_compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group3_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group3_id, target_compile_id, 0, "null", 2, 0); EXPECT_EQ(ret, 1); @@ -5358,30 +5358,30 @@ TEST_F(MaatCmdTest, GroupInMassCompiles) { const char* http_url2 = "https://www.baidu.com/s?wd=zhengzhou&rsv_spt=1" "&rsv_iqid=0x8b4cae8100000560&issp=1&f=8&rsv_bp=1"; - int url_table_id = maat_get_table_id(maat_instance, table_url); + int url_table_id = maat_get_table_id(maat_inst, table_url); ASSERT_GT(url_table_id, 0); - int appid_table_id = maat_get_table_id(maat_instance, table_appid); + int appid_table_id = maat_get_table_id(maat_inst, table_appid); ASSERT_GT(appid_table_id, 0); long long results[4] = {0}; size_t n_hit_result = 0; - ret = maat_scan_string(maat_instance, url_table_id, http_url2, strlen(http_url2), + ret = maat_scan_string(maat_inst, url_table_id, http_url2, strlen(http_url2), results, 4, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - ret = maat_scan_integer(maat_instance, appid_table_id, 100, results, 4, + ret = maat_scan_integer(maat_inst, appid_table_id, 100, results, 4, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], target_compile_id); maat_state_reset(state); - ret = maat_scan_string(maat_instance, url_table_id, http_url1, strlen(http_url1), + ret = maat_scan_string(maat_inst, url_table_id, http_url1, strlen(http_url1), results, 4, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - ret = maat_scan_integer(maat_instance, appid_table_id, 100, results, 4, + ret = maat_scan_integer(maat_inst, appid_table_id, 100, results, 4, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 4); @@ -5397,24 +5397,24 @@ TEST_F(MaatCmdTest, HitPath) { const char *ip_table_name = "IP_CONFIG"; const char *keywords_table_name = "KEYWORDS_TABLE"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); /* compile1 */ - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 2, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "HTTP_REQUEST_HEADER", 1, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, http_sig_table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, http_sig_table_name, MAAT_OP_ADD, item1_id, group1_id, "graph_theory", "URL", 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -5422,8 +5422,8 @@ TEST_F(MaatCmdTest, HitPath) { / group21_/ */ - long long group21_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group21_id, + long long group21_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group21_id, compile1_id, 0, "HTTP_RESPONSE_HEADER", 2, 0); EXPECT_EQ(ret, 1); @@ -5431,8 +5431,8 @@ TEST_F(MaatCmdTest, HitPath) { / group2 -> group21 _/ */ - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2group_table_set_line(maat_instance, g2g_table_name, MAAT_OP_ADD, group2_id, + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2group_table_set_line(maat_inst, g2g_table_name, MAAT_OP_ADD, group2_id, group21_id, 0, 0); EXPECT_EQ(ret, 1); @@ -5440,8 +5440,8 @@ TEST_F(MaatCmdTest, HitPath) { / item2 -> group2 -> group21 _/ */ - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, http_sig_table_name, MAAT_OP_ADD, item2_id, group2_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, http_sig_table_name, MAAT_OP_ADD, item2_id, group2_id, "time=2020-02-11", "Cookie", 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -5452,23 +5452,23 @@ TEST_F(MaatCmdTest, HitPath) { / item2 -> group2 -> group21 _/ */ - long long group11_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2group_table_set_line(maat_instance, g2g_table_name, MAAT_OP_ADD, group1_id, + long long group11_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2group_table_set_line(maat_inst, g2g_table_name, MAAT_OP_ADD, group1_id, group11_id, 0, 0); EXPECT_EQ(ret, 1); //item3 -> group3, group3 is not referenced by any compile. - long long item3_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - long long group3_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item3_id, group3_id, + long long item3_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + long long group3_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item3_id, group3_id, IPv4, "220.181.38.148", "220.181.38.149", 0, 65535, 0); EXPECT_EQ(ret, 1); char temp[1024]={0}; //item4 -> group4, group4 is not referenced by any compile. - long long item4_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - long long group4_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = expr_table_set_line(maat_instance, keywords_table_name, MAAT_OP_ADD, item4_id, group4_id, + long long item4_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + long long group4_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = expr_table_set_line(maat_inst, keywords_table_name, MAAT_OP_ADD, item4_id, group4_id, maat_cmd_str_escape(temp, sizeof(temp), "a finite or infinite"), NULL, 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -5479,7 +5479,7 @@ TEST_F(MaatCmdTest, HitPath) { const char* http_resp_hdr_cookie = "laptop=thinkpad X1 extrem;time=2020-02-11T15:34:00;" "main[XWJOKE]=hoho; Hm_lvt_bbac0322e6ee13093f98d5c4b5a10912=1578874808;"; - int http_req_table_id = maat_get_table_id(maat_instance, "HTTP_REQUEST_HEADER"); + int http_req_table_id = maat_get_table_id(maat_inst, "HTTP_REQUEST_HEADER"); ASSERT_GT(http_req_table_id, 0); ret = maat_state_set_scan_district(state, http_req_table_id, "URL", strlen("URL")); @@ -5490,7 +5490,7 @@ TEST_F(MaatCmdTest, HitPath) { Nth_scan++; long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - ret = maat_scan_string(maat_instance, http_req_table_id, http_url, strlen(http_url), + ret = maat_scan_string(maat_inst, http_req_table_id, http_url, strlen(http_url), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -5524,14 +5524,14 @@ TEST_F(MaatCmdTest, HitPath) { EXPECT_EQ(hit_path[path_idx].vtable_id, http_req_table_id); EXPECT_EQ(hit_path[path_idx].compile_id, -1); - int http_res_table_id = maat_get_table_id(maat_instance, "HTTP_RESPONSE_HEADER"); + int http_res_table_id = maat_get_table_id(maat_inst, "HTTP_RESPONSE_HEADER"); ASSERT_GT(http_res_table_id, 0); ret = maat_state_set_scan_district(state, http_res_table_id, "Cookie", strlen("Cookie")); EXPECT_EQ(ret, 0); Nth_scan++; - ret = maat_scan_string(maat_instance, http_res_table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), + ret = maat_scan_string(maat_inst, http_res_table_id, http_resp_hdr_cookie, strlen(http_resp_hdr_cookie), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -5590,10 +5590,10 @@ are all distinct (and since the vertices are distinct, so are the edges). "; sequence of edges which joins a sequence of distinct vertices, but with the added restriction\ that the edges be all directed in the same direction."; - int keywords_table_id = maat_get_table_id(maat_instance, keywords_table_name); + int keywords_table_id = maat_get_table_id(maat_inst, keywords_table_name); ASSERT_GT(keywords_table_id, 0); - struct maat_stream *stream = maat_stream_new(maat_instance, keywords_table_id, state); + struct maat_stream *stream = maat_stream_new(maat_inst, keywords_table_id, state); Nth_scan++; ret = maat_stream_scan(stream, keywords1, strlen(keywords1), results, ARRAY_SIZE, &n_hit_result, state); @@ -5624,14 +5624,14 @@ that the edges be all directed in the same direction."; EXPECT_EQ(hit_path[path_idx].vtable_id, 0); EXPECT_EQ(hit_path[path_idx].compile_id, -1); - int ip_table_id = maat_get_table_id(maat_instance, ip_table_name); + int ip_table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(ip_table_id, 0); Nth_scan++; uint32_t ip_addr; inet_pton(AF_INET, "220.181.38.148", &ip_addr); uint16_t port = htons(17272); - ret = maat_scan_ipv4(maat_instance, ip_table_id, ip_addr, port, 6, results, ARRAY_SIZE, + ret = maat_scan_ipv4(maat_inst, ip_table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -5689,11 +5689,11 @@ TEST_F(MaatCmdTest, SameScanStatusWhenClauseUpdate_TSG6419) { const char* ip_table_name = "IP_PLUS_CONFIG"; const char *app_id_table_name = "APP_ID"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 2, 0); EXPECT_EQ(ret, 1); @@ -5701,23 +5701,23 @@ TEST_F(MaatCmdTest, SameScanStatusWhenClauseUpdate_TSG6419) { / item21 -> group21 -> clause2 _/ */ - long long group11_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group11_id, + long long group11_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group11_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - long long item11_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item11_id, group11_id, + long long item11_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item11_id, group11_id, IPv4, "192.168.2.1", "192.168.2.4", 0, 65535, 0); EXPECT_EQ(ret, 1); - long long group21_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group21_id, + long long group21_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group21_id, compile1_id, 0, "null", 2, 0); EXPECT_EQ(ret, 1); - long long item21_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = intval_table_set_line(maat_instance, app_id_table_name, MAAT_OP_ADD, item21_id, + long long item21_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = intval_table_set_line(maat_inst, app_id_table_name, MAAT_OP_ADD, item21_id, group21_id, 31, 31, NULL, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); @@ -5728,14 +5728,14 @@ TEST_F(MaatCmdTest, SameScanStatusWhenClauseUpdate_TSG6419) { inet_pton(AF_INET, "192.168.2.2", &ip_addr); uint16_t port = htons(50001); - int table_id = maat_get_table_id(maat_instance, ip_table_name); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, results, ARRAY_SIZE, + int table_id = maat_get_table_id(maat_inst, ip_table_name); + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); int scan_app_id = 32; - table_id = maat_get_table_id(maat_instance, app_id_table_name); - ret = maat_scan_integer(maat_instance, table_id, scan_app_id, results, ARRAY_SIZE, + table_id = maat_get_table_id(maat_inst, app_id_table_name); + ret = maat_scan_integer(maat_inst, table_id, scan_app_id, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); @@ -5744,31 +5744,31 @@ TEST_F(MaatCmdTest, SameScanStatusWhenClauseUpdate_TSG6419) { item21 -> group21 -> clause2 _/ item22 -> group22 -> clause3 _/ */ - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, compile1_id, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile1_id, "null", 2, 0); EXPECT_EQ(ret, 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 3, 0); EXPECT_EQ(ret, 1); - long long group22_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group22_id, + long long group22_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group22_id, compile1_id, 0, "null", 3, 0); EXPECT_EQ(ret, 1); - long long item22_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = intval_table_set_line(maat_instance, app_id_table_name, MAAT_OP_ADD, item22_id, + long long item22_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = intval_table_set_line(maat_inst, app_id_table_name, MAAT_OP_ADD, item22_id, group22_id, 32, 32, NULL, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - table_id = maat_get_table_id(maat_instance, app_id_table_name); - ret = maat_scan_integer(maat_instance, table_id, 31, results, ARRAY_SIZE, + table_id = maat_get_table_id(maat_inst, app_id_table_name); + ret = maat_scan_integer(maat_inst, table_id, 31, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - ret = maat_scan_integer(maat_instance, table_id, scan_app_id, results, ARRAY_SIZE, + ret = maat_scan_integer(maat_inst, table_id, scan_app_id, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -5783,34 +5783,34 @@ TEST_F(MaatCmdTest, GroupEdit) { const char *ip_table_name = "IP_PLUS_CONFIG"; const char *app_id_table_name = "APP_ID"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 2, 0); EXPECT_EQ(ret, 1); /* item11 -> group11 -> clause1 -> compile1 item21 -> group21 -> clause2 _/ */ - long long group11_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group11_id, + long long group11_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group11_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - long long item11_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item11_id, group11_id, + long long item11_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item11_id, group11_id, IPv4, "192.168.3.1", "192.168.3.4", 0, 65535, 0); EXPECT_EQ(ret, 1); - long long group21_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group21_id, + long long group21_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group21_id, compile1_id, 0, "null", 2, 0); EXPECT_EQ(ret, 1); - long long item21_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = intval_table_set_line(maat_instance, app_id_table_name, MAAT_OP_ADD, item21_id, + long long item21_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = intval_table_set_line(maat_inst, app_id_table_name, MAAT_OP_ADD, item21_id, group21_id, 41, 41, NULL, 0); EXPECT_EQ(ret, 1); @@ -5823,18 +5823,18 @@ TEST_F(MaatCmdTest, GroupEdit) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - int table_id = maat_get_table_id(maat_instance, ip_table_name); + int table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, results, ARRAY_SIZE, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, app_id_table_name); + table_id = maat_get_table_id(maat_inst, app_id_table_name); ASSERT_GT(table_id, 0); int scan_app_id = 42; - ret = maat_scan_integer(maat_instance, table_id, scan_app_id, results, ARRAY_SIZE, + ret = maat_scan_integer(maat_inst, table_id, scan_app_id, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); maat_state_reset(state); @@ -5843,24 +5843,24 @@ TEST_F(MaatCmdTest, GroupEdit) { item21 -> group21 -> clause2 _/ item22 -> / */ - long long item22_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = intval_table_set_line(maat_instance, app_id_table_name, MAAT_OP_ADD, item22_id, group21_id, + long long item22_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = intval_table_set_line(maat_inst, app_id_table_name, MAAT_OP_ADD, item22_id, group21_id, scan_app_id, scan_app_id, NULL, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); - table_id = maat_get_table_id(maat_instance, ip_table_name); + table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, results, ARRAY_SIZE, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); //TODO: EXPECT_EQ(ret,?) - table_id = maat_get_table_id(maat_instance, app_id_table_name); + table_id = maat_get_table_id(maat_inst, app_id_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_integer(maat_instance, table_id, scan_app_id, results, ARRAY_SIZE, + ret = maat_scan_integer(maat_inst, table_id, scan_app_id, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -5876,20 +5876,20 @@ TEST_F(MaatCmdTest, GroupEdit) { /* item11 -> group11 -> clause1 -> compile1 item21 -> group21 -> clause2 _/ */ - ret = intval_table_set_line(maat_instance, app_id_table_name, MAAT_OP_DEL, item22_id, group21_id, + ret = intval_table_set_line(maat_inst, app_id_table_name, MAAT_OP_DEL, item22_id, group21_id, scan_app_id, scan_app_id, NULL, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); memset(results, 0, sizeof(results)); - table_id = maat_get_table_id(maat_instance, ip_table_name); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, results, ARRAY_SIZE, + table_id = maat_get_table_id(maat_inst, ip_table_name); + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - table_id = maat_get_table_id(maat_instance, app_id_table_name); - ret = maat_scan_integer(maat_instance, table_id, scan_app_id, results, ARRAY_SIZE, + table_id = maat_get_table_id(maat_inst, app_id_table_name); + ret = maat_scan_integer(maat_inst, table_id, scan_app_id, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); maat_state_free(state); @@ -5901,22 +5901,22 @@ TEST_F(MaatCmdTest, CompileDelete_TSG6548) { const char* compile_table_name = "COMPILE"; const char* ip_table_name = "IP_PLUS_CONFIG"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); //item11 -> group11 -> clause1 -> compile1 - long long group11_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group11_id, + long long group11_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group11_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - long long item11_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item11_id, group11_id, + long long item11_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item11_id, group11_id, IPv4, "192.168.73.163", "192.168.73.180", 0, 65535, 0); EXPECT_EQ(ret, 1); @@ -5929,20 +5929,20 @@ TEST_F(MaatCmdTest, CompileDelete_TSG6548) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - int table_id = maat_get_table_id(maat_instance, ip_table_name); + int table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, results, ARRAY_SIZE, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], compile1_id); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_DEL, compile1_id, + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_DEL, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_DEL, group11_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_DEL, group11_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); @@ -5951,7 +5951,7 @@ TEST_F(MaatCmdTest, CompileDelete_TSG6548) { time_t update_time = time(NULL); time_t now = update_time; while (now - update_time < 3) { - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, results, ARRAY_SIZE, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { hit_cnt++; @@ -5972,23 +5972,23 @@ TEST_F(MaatCmdTest, UpdateDeadLockDetection) { const char* compile_table_name = "COMPILE"; const char* table_http_url = "HTTP_URL"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 0, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_http_url, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_http_url, MAAT_OP_ADD, item1_id, group1_id, "part-1", NULL, 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -6000,42 +6000,42 @@ TEST_F(MaatCmdTest, UpdateDeadLockDetection) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - int table_id = maat_get_table_id(maat_instance, table_http_url); + int table_id = maat_get_table_id(maat_inst, table_http_url); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, scan_data1, strlen(scan_data1), + ret = maat_scan_string(maat_inst, table_id, scan_data1, strlen(scan_data1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], compile1_id); - long long compile2_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile2_id, + long long compile2_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile2_id, "null", 1, 0); EXPECT_EQ(ret, 1); //group2 -> compile2 - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile2_id, 0, "null", 0, 0); EXPECT_EQ(ret, 1); //item2 -> group2 -> compile2 - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_http_url, MAAT_OP_ADD, item2_id, group2_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_http_url, MAAT_OP_ADD, item2_id, group2_id, "part-2", NULL, 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); //DON'T DO THIS!!! //Roll back version, trigger full udpate. //This operation generates some FATAL logs in test_maat_redis.log.yyyy-mm-dd. - maat_cmd_incrby(maat_instance, "MAAT_VERSION", -100); + maat_cmd_incrby(maat_inst, "MAAT_VERSION", -100); //Wating for scanner garbage collect expiration. sleep(10); memset(results, 0, sizeof(results)); - ret = maat_scan_string(maat_instance, table_id, scan_data2, strlen(scan_data2), + ret = maat_scan_string(maat_inst, table_id, scan_data2, strlen(scan_data2), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); //After full update, clause ids are re-orgnized, therefore mid are not compatible to the new scanner (hierarchy). maat_state_free(state); @@ -6047,17 +6047,17 @@ TEST_F(MaatCmdTest, StreamScanWhenExprTableIncUpdate) { const char* compile_table_name = "COMPILE"; const char* scan_table_name = "KEYWORDS_TABLE"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 0, 0); EXPECT_EQ(ret, 1); @@ -6067,17 +6067,17 @@ TEST_F(MaatCmdTest, StreamScanWhenExprTableIncUpdate) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - int table_id = maat_get_table_id(maat_instance, scan_table_name); + int table_id = maat_get_table_id(maat_inst, scan_table_name); ASSERT_GT(table_id, 0); - struct maat_stream *stream = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *stream = maat_stream_new(maat_inst, table_id, state); ret = maat_stream_scan(stream, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, scan_table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, scan_table_name, MAAT_OP_ADD, item1_id, group1_id, "stream-keywords-001-inc-update", NULL, 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -6092,7 +6092,7 @@ TEST_F(MaatCmdTest, StreamScanWhenExprTableIncUpdate) { maat_stream_free(stream); - stream = maat_stream_new(maat_instance, table_id, state); + stream = maat_stream_new(maat_inst, table_id, state); ret = maat_stream_scan(stream, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -6109,23 +6109,23 @@ TEST_F(MaatCmdTest, StreamScanSegfaultWhenVersionRollBack_TSG6324) { const char* compile_table_name = "COMPILE"; const char* scan_table_name = "KEYWORDS_TABLE"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 0, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, scan_table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, scan_table_name, MAAT_OP_ADD, item1_id, group1_id, "stream-keywords-002", NULL, 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -6135,10 +6135,10 @@ TEST_F(MaatCmdTest, StreamScanSegfaultWhenVersionRollBack_TSG6324) { long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - int table_id = maat_get_table_id(maat_instance, scan_table_name); + int table_id = maat_get_table_id(maat_inst, scan_table_name); ASSERT_GT(table_id, 0); - struct maat_stream *stream = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *stream = maat_stream_new(maat_inst, table_id, state); ret = maat_stream_scan(stream, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -6149,7 +6149,7 @@ TEST_F(MaatCmdTest, StreamScanSegfaultWhenVersionRollBack_TSG6324) { //Roll back version, trigger full update. //This operation generates FATAL logs in test_maat_redis.log.yyyy-mm-dd. //For example: Add group 22 vt_id 0 to clause 2 of compile 979 failed, group is already exisited - maat_cmd_incrby(maat_instance, "MAAT_VERSION", -100); + maat_cmd_incrby(maat_inst, "MAAT_VERSION", -100); //Wating for scanner garbage collect expiration. sleep(10); @@ -6169,23 +6169,23 @@ TEST_F(MaatCmdTest, IPAndStreamScanWhenIncUpdate) { const char *expr_table_name = "KEYWORDS_TABLE"; const char *ip_table_name = "IP_PLUS_CONFIG"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 2, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 0, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, expr_table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, expr_table_name, MAAT_OP_ADD, item1_id, group1_id, "stream-keywords-003", NULL, 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -6193,13 +6193,13 @@ TEST_F(MaatCmdTest, IPAndStreamScanWhenIncUpdate) { / item2 -> group2 --/ */ - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item2_id, group2_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item2_id, group2_id, IPv4, "100.100.100.1", "100.100.100.1", 100, 100, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); @@ -6215,26 +6215,26 @@ TEST_F(MaatCmdTest, IPAndStreamScanWhenIncUpdate) { uint16_t port = htons(100); int proto = 6; - int table_id = maat_get_table_id(maat_instance, ip_table_name); + int table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); //add compile2 for compile runtime inc update - long long compile2_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile2_id, + long long compile2_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile2_id, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); const char *scan_data = "Here is a stream-keywords-003, this should hit."; - table_id = maat_get_table_id(maat_instance, expr_table_name); + table_id = maat_get_table_id(maat_inst, expr_table_name); ASSERT_GT(table_id, 0); - struct maat_stream *stream = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *stream = maat_stream_new(maat_inst, table_id, state); ret = maat_stream_scan(stream, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); @@ -6244,9 +6244,9 @@ TEST_F(MaatCmdTest, IPAndStreamScanWhenIncUpdate) { /* becase compile1_id has been returned, maat_scan_xx will not return duplicate compile_id again */ - table_id = maat_get_table_id(maat_instance, ip_table_name); + table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -6261,23 +6261,23 @@ TEST_F(MaatCmdTest, IPAndStreamScanWhenFullUpdate) { const char *ip_table_name = "IP_PLUS_CONFIG"; const char *expr_table_name = "KEYWORDS_TABLE"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 0, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, expr_table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, expr_table_name, MAAT_OP_ADD, item1_id, group1_id, "stream-keywords-004", NULL, 0, 0, 0, 0); /*EXPR_TYPE_STRING MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -6285,13 +6285,13 @@ TEST_F(MaatCmdTest, IPAndStreamScanWhenFullUpdate) { / item2 -> group2 --/ */ - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item2_id, group2_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item2_id, group2_id, IPv4, "100.100.100.2", "100.100.100.2", 100, 100, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); @@ -6307,25 +6307,25 @@ TEST_F(MaatCmdTest, IPAndStreamScanWhenFullUpdate) { uint16_t port = htons(100); int proto = 6; - int table_id = maat_get_table_id(maat_instance, ip_table_name); + int table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); //DON'T DO THIS!!! //Roll back version, trigger full update. - maat_cmd_incrby(maat_instance, "MAAT_VERSION", -100); + maat_cmd_incrby(maat_inst, "MAAT_VERSION", -100); //Wating for scanner garbage collect expiration. sleep(10); const char *scan_data = "Here is a stream-keywords-004, this should hit."; - table_id = maat_get_table_id(maat_instance, expr_table_name); + table_id = maat_get_table_id(maat_inst, expr_table_name); ASSERT_GT(table_id, 0); - struct maat_stream *stream = maat_stream_new(maat_instance, table_id, state); + struct maat_stream *stream = maat_stream_new(maat_inst, table_id, state); ret = maat_stream_scan(stream, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -6334,9 +6334,9 @@ TEST_F(MaatCmdTest, IPAndStreamScanWhenFullUpdate) { After full updating, new compile_rt version is different from that of maat_state, so MAAT_SCAN_HIT will never happen. */ - table_id = maat_get_table_id(maat_instance, ip_table_name); + table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -6352,23 +6352,23 @@ TEST_F(MaatCmdTest, IPAndStringScanWhenIncUpdate) { const char *ip_table_name = "IP_PLUS_CONFIG"; const char *keywords = "IP&stringinc"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 2, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 0, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, expr_table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, expr_table_name, MAAT_OP_ADD, item1_id, group1_id, keywords, NULL, 1, 0, 0, 0); /*EXPR_TYPE_AND MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -6376,13 +6376,13 @@ TEST_F(MaatCmdTest, IPAndStringScanWhenIncUpdate) { / item2 -> group2 --/ */ - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item2_id, group2_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item2_id, group2_id, IPv4, "100.100.100.1", "100.100.100.1", 100, 100, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); @@ -6398,26 +6398,26 @@ TEST_F(MaatCmdTest, IPAndStringScanWhenIncUpdate) { uint16_t port = htons(100); int proto = 6; - int table_id = maat_get_table_id(maat_instance, ip_table_name); + int table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); //add compile2 for compile runtime inc update - long long compile2_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile2_id, + long long compile2_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile2_id, "null", 1, 0); EXPECT_EQ(ret, 1); sleep(WAIT_FOR_EFFECTIVE_S); const char *scan_data = "Here is a IP and stringinc, this should hit."; - table_id = maat_get_table_id(maat_instance, expr_table_name); + table_id = maat_get_table_id(maat_inst, expr_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -6426,9 +6426,9 @@ TEST_F(MaatCmdTest, IPAndStringScanWhenIncUpdate) { /* becase compile1_id has been returned, maat_scan_xx will not return duplicate compile_id again */ - table_id = maat_get_table_id(maat_instance, ip_table_name); + table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -6443,23 +6443,23 @@ TEST_F(MaatCmdTest, IPAndStringScanWhenFullupdate) { const char *expr_table_name = "HTTP_URL"; const char *keywords = "IP&string"; int thread_id = 0; - struct maat *maat_instance = MaatCmdTest::_shared_maat_instance; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat *maat_inst = MaatCmdTest::_shared_maat_inst; + struct maat_state *state = maat_state_new(maat_inst, thread_id); - long long compile1_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, compile_table_name, MAAT_OP_ADD, compile1_id, + long long compile1_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, compile_table_name, MAAT_OP_ADD, compile1_id, "null", 1, 0); EXPECT_EQ(ret, 1); //group1 -> compile1 - long long group1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group1_id, + long long group1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group1_id, compile1_id, 0, "null", 0, 0); EXPECT_EQ(ret, 1); //item1 -> group1 -> compile1 - long long item1_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, expr_table_name, MAAT_OP_ADD, item1_id, group1_id, + long long item1_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, expr_table_name, MAAT_OP_ADD, item1_id, group1_id, keywords, "null", 1, 0, 0, 0); /*EXPR_TYPE_AND MATCH_METHOD_SUB*/ EXPECT_EQ(ret, 1); @@ -6467,13 +6467,13 @@ TEST_F(MaatCmdTest, IPAndStringScanWhenFullupdate) { / item2 -> group2 --/ */ - long long item2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - long long group2_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = ip_table_set_line(maat_instance, ip_table_name, MAAT_OP_ADD, item2_id, group2_id, + long long item2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + long long group2_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = ip_table_set_line(maat_inst, ip_table_name, MAAT_OP_ADD, item2_id, group2_id, IPv4, "100.100.100.3", "100.100.100.3", 100, 100, 0); EXPECT_EQ(ret, 1); - ret = group2compile_table_set_line(maat_instance, g2c_table_name, MAAT_OP_ADD, group2_id, + ret = group2compile_table_set_line(maat_inst, g2c_table_name, MAAT_OP_ADD, group2_id, compile1_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); @@ -6489,25 +6489,25 @@ TEST_F(MaatCmdTest, IPAndStringScanWhenFullupdate) { uint16_t port = htons(100); int proto = 6; - int table_id = maat_get_table_id(maat_instance, ip_table_name); + int table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); //DON'T DO THIS!!! //Roll back version, trigger full update. - maat_cmd_incrby(maat_instance, "MAAT_VERSION", -100); + maat_cmd_incrby(maat_inst, "MAAT_VERSION", -100); //Wating for scanner garbage collect expiration. sleep(10); const char *scan_data = "scan IP and string, this should hit."; - table_id = maat_get_table_id(maat_instance, expr_table_name); + table_id = maat_get_table_id(maat_inst, expr_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -6515,10 +6515,10 @@ TEST_F(MaatCmdTest, IPAndStringScanWhenFullupdate) { After full updating, new compile_rt version is different from that of maat_state, so MAAT_SCAN_HIT will never happen. */ - table_id = maat_get_table_id(maat_instance, ip_table_name); + table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(table_id, 0); - ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, proto, results, + ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); @@ -6548,9 +6548,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO); maat_options_set_accept_tags(opts, accept_tags); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_GTEST, "[%s:%d] create maat instance in MaatRollbackTest failed.", __FUNCTION__, __LINE__); @@ -6558,14 +6558,14 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatRollbackTest::_shared_maat_instance; +struct maat *MaatRollbackTest::_shared_maat_inst; struct log_handle *MaatRollbackTest::logger; static int clear_config_in_redis(redisContext *c, struct log_handle *logger) @@ -6657,19 +6657,19 @@ static int rollback_redis_version(redisContext *c, struct log_handle *logger) TEST_F(MaatRollbackTest, FullConfigRollback) { const char *table_name = "HTTP_URL"; - struct maat *maat_instance = MaatRollbackTest::_shared_maat_instance; + struct maat *maat_inst = MaatRollbackTest::_shared_maat_inst; struct log_handle *logger = MaatRollbackTest::logger; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=username,abckkk,1234567"; - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -6695,7 +6695,7 @@ TEST_F(MaatRollbackTest, FullConfigRollback) { sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -6706,19 +6706,19 @@ TEST_F(MaatRollbackTest, FullConfigRollback) { TEST_F(MaatRollbackTest, FullConfigRollbackWhenScanUnfinished) { const char *table_name = "HTTP_URL"; - struct maat *maat_instance = MaatRollbackTest::_shared_maat_instance; + struct maat *maat_inst = MaatRollbackTest::_shared_maat_inst; struct log_handle *logger = MaatRollbackTest::logger; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); + struct maat_state *state = maat_state_new(maat_inst, thread_id); const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=username,abckkk,1234567"; - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -6744,7 +6744,7 @@ TEST_F(MaatRollbackTest, FullConfigRollbackWhenScanUnfinished) { sleep(WAIT_FOR_EFFECTIVE_S); - ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); diff --git a/test/maat_framework_perf_gtest.cpp b/test/maat_framework_perf_gtest.cpp index 4c399e6..2b3d378 100644 --- a/test/maat_framework_perf_gtest.cpp +++ b/test/maat_framework_perf_gtest.cpp @@ -22,7 +22,7 @@ const char *json_filename = "maat_json.json"; struct thread_param { int thread_id; int test_count; - struct maat *maat_instance; + struct maat *maat_inst; const char *table_name; long long time_elapse_ms; struct log_handle *logger; @@ -162,7 +162,7 @@ static int write_config_to_redis(char *redis_ip, int redis_port, int redis_db, return 0; } -static int compile_table_set_line(struct maat *maat_instance, const char *table_name, +static int compile_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long compile_id, const char *user_region, int clause_num, int expire_after) { @@ -176,10 +176,10 @@ static int compile_table_set_line(struct maat *maat_instance, const char *table_ line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -static int group2compile_table_set_line(struct maat *maat_instance, const char *table_name, +static int group2compile_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long group_id, long long compile_id, int not_flag, const char *vtable_name, int clause_num, int expire_after) @@ -194,20 +194,20 @@ static int group2compile_table_set_line(struct maat *maat_instance, const char * line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -static int expr_table_set_line(struct maat *maat_instance, const char *table_name, enum maat_operation op, +static int expr_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long item_id, long long group_id, const char *keywords, const char *district, int expr_type, int match_method, int is_hexbin, int expire_after) { char table_line[1024] = {0}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); if (table_id < 0) { return 0; } - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, table_id); + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); assert(table_type == TABLE_TYPE_EXPR || table_type == TABLE_TYPE_EXPR_PLUS); if (table_type == TABLE_TYPE_EXPR_PLUS) { @@ -224,15 +224,15 @@ static int expr_table_set_line(struct maat *maat_instance, const char *table_nam line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -static int ip_table_set_line(struct maat *maat_instance, const char *table_name, enum maat_operation op, +static int ip_table_set_line(struct maat *maat_inst, const char *table_name, enum maat_operation op, long long item_id, long long group_id, enum IP_TYPE type, const char *ip1, const char *ip2, uint16_t port_min, uint16_t port_max, int expire_after) { char table_line[1024] = {0}; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); if (table_id < 0) { return 0; } @@ -252,41 +252,41 @@ static int ip_table_set_line(struct maat *maat_instance, const char *table_name, line_rule.table_name = table_name; line_rule.expire_after = expire_after; - return maat_cmd_set_line(maat_instance, &line_rule); + return maat_cmd_set_line(maat_inst, &line_rule); } -void test_add_expr_command(struct maat *maat_instance, const char *table_name, +void test_add_expr_command(struct maat *maat_inst, const char *table_name, const char *keywords) { - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, "COMPILE", MAAT_OP_ADD, compile_id, "null", 1, 0); + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_ADD, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); - long long group_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, "GROUP2COMPILE", MAAT_OP_ADD, group_id, + long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, "GROUP2COMPILE", MAAT_OP_ADD, group_id, compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - long long item_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = expr_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item_id, group_id, + long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id, keywords, NULL, 1, 0, 0, 0); EXPECT_EQ(ret, 1); } -void test_add_ip_command(struct maat *maat_instance, const char *table_name, +void test_add_ip_command(struct maat *maat_inst, const char *table_name, const char *ip, uint16_t port) { - long long compile_id = maat_cmd_incrby(maat_instance, "TEST_SEQ", 1); - int ret = compile_table_set_line(maat_instance, "COMPILE", MAAT_OP_ADD, compile_id, "null", 1, 0); + long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1); + int ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_ADD, compile_id, "null", 1, 0); EXPECT_EQ(ret, 1); - long long group_id = maat_cmd_incrby(maat_instance, "SEQUENCE_GROUP", 1); - ret = group2compile_table_set_line(maat_instance, "GROUP2COMPILE", MAAT_OP_ADD, group_id, + long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1); + ret = group2compile_table_set_line(maat_inst, "GROUP2COMPILE", MAAT_OP_ADD, group_id, compile_id, 0, "null", 1, 0); EXPECT_EQ(ret, 1); - long long item_id = maat_cmd_incrby(maat_instance, "SEQUENCE_REGION", 1); - ret = ip_table_set_line(maat_instance, table_name, MAAT_OP_ADD, item_id, group_id, + long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1); + ret = ip_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id, IPv4, ip, ip, port, port, 0); EXPECT_EQ(ret, 1); } @@ -316,9 +316,9 @@ protected: maat_options_set_accept_tags(opts, accept_tags); maat_options_set_caller_thread_number(opts, 5); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_PERF_GTEST, "[%s:%d] create maat instance in MaatFlagScan failed.", __FUNCTION__, __LINE__); @@ -326,34 +326,34 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatPerfStringScan::_shared_maat_instance; +struct maat *MaatPerfStringScan::_shared_maat_inst; struct log_handle *MaatPerfStringScan::logger; void *perf_string_scan_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; const char *table_name = param->table_name; struct timespec start, end; const char *scan_data = "String TEST should hit"; long long results[ARRAY_SIZE] = {0}; int hit_times = 0; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, param->thread_id); + struct maat_state *state = maat_state_new(maat_inst, param->thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); clock_gettime(CLOCK_MONOTONIC, &start); for (int i = 0; i < param->test_count; i++) { - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { hit_times++; @@ -374,14 +374,14 @@ void *perf_string_scan_thread(void *arg) void *perf_string_update_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; const char *table_name = param->table_name; const int CMD_EXPR_NUM = 10; char keyword_buf[128]; for (int i = 0; i < CMD_EXPR_NUM; i++) { random_keyword_generate(keyword_buf, sizeof(keyword_buf)); - test_add_expr_command(maat_instance, table_name, keyword_buf); + test_add_expr_command(maat_inst, table_name, keyword_buf); sleep(1); } @@ -394,7 +394,7 @@ void *perf_string_update_thread(void *arg) void *perf_ip_scan_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; const char *table_name = param->table_name; struct timespec start, end; char ip_str[32] = "10.0.7.100"; @@ -407,12 +407,12 @@ void *perf_ip_scan_thread(void *arg) int hit_times = 0; long long results[ARRAY_SIZE] = {0}; size_t n_hit_result = 0; - struct maat_state *state = maat_state_new(maat_instance, param->thread_id); - int table_id = maat_get_table_id(maat_instance, table_name); + struct maat_state *state = maat_state_new(maat_inst, param->thread_id); + int table_id = maat_get_table_id(maat_inst, table_name); clock_gettime(CLOCK_MONOTONIC, &start); for (int i = 0; i < param->test_count; i++) { - int ret = maat_scan_ipv4(maat_instance, table_id, ip_addr, port, 6, + int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { hit_times++; @@ -433,7 +433,7 @@ void *perf_ip_scan_thread(void *arg) void *perf_ip_update_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; const char *table_name = param->table_name; const int CMD_EXPR_NUM = 10; char ip_str[10][32] = { @@ -450,7 +450,7 @@ void *perf_ip_update_thread(void *arg) uint16_t port = 65530; for (int i = 0; i < CMD_EXPR_NUM; i++) { - test_add_ip_command(maat_instance, table_name, ip_str[i], port); + test_add_ip_command(maat_inst, table_name, ip_str[i], port); sleep(1); } @@ -462,9 +462,9 @@ void *perf_ip_update_thread(void *arg) TEST_F(MaatPerfStringScan, MultiThread) { const char *table_name = "KEYWORDS_TABLE"; - struct maat *maat_instance = MaatPerfStringScan::_shared_maat_instance; + struct maat *maat_inst = MaatPerfStringScan::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); pthread_t threads[PERF_THREAD_NUM + 1]; @@ -473,7 +473,7 @@ TEST_F(MaatPerfStringScan, MultiThread) { int *is_all_hit = NULL; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { - thread_params[i].maat_instance = maat_instance; + thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; thread_params[i].test_count = PERF_SCAN_COUNT; @@ -502,7 +502,7 @@ TEST_F(MaatPerfStringScan, MultiThread) { } scan_per_second = scan_count * 1000 / time_elapse_ms; //EXPECT_GT(scan_per_second, 800 * 1000); - log_info(maat_instance->logger, MODULE_FRAMEWORK_PERF_GTEST, + log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "StringScan match rate on %d-threads speed %lld lookups/s/thread", PERF_THREAD_NUM, scan_per_second); } @@ -532,9 +532,9 @@ protected: maat_options_set_accept_tags(opts, accept_tags); maat_options_set_caller_thread_number(opts, 5); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_PERF_GTEST, "[%s:%d] create maat instance in MaatFlagScan failed.", __FUNCTION__, __LINE__); @@ -542,21 +542,21 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatPerfStreamScan::_shared_maat_instance; +struct maat *MaatPerfStreamScan::_shared_maat_inst; struct log_handle *MaatPerfStreamScan::logger; void *perf_stream_scan_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; const char *table_name = param->table_name; struct timespec start, end; const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=yulingjing,abckkk,1234567"; @@ -565,13 +565,13 @@ void *perf_stream_scan_thread(void *arg) size_t n_hit_result = 0; struct maat_state *state_array[ARRAY_SIZE]; struct maat_stream *sp[ARRAY_SIZE]; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); clock_gettime(CLOCK_MONOTONIC, &start); for (int i = 0; i < param->test_count; i++) { for (int j = 0; j < ARRAY_SIZE; j++) { - state_array[j] = maat_state_new(maat_instance, param->thread_id); - sp[j] = maat_stream_new(maat_instance, table_id, state_array[j]); + state_array[j] = maat_state_new(maat_inst, param->thread_id); + sp[j] = maat_stream_new(maat_inst, table_id, state_array[j]); ret = maat_stream_scan(sp[j], scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state_array[j]); @@ -597,14 +597,14 @@ void *perf_stream_scan_thread(void *arg) void *perf_stream_update_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; const char *table_name = param->table_name; const int CMD_EXPR_NUM = 10; char keyword_buf[128]; for (int i = 0; i < CMD_EXPR_NUM; i++) { random_keyword_generate(keyword_buf, sizeof(keyword_buf)); - test_add_expr_command(maat_instance, table_name, keyword_buf); + test_add_expr_command(maat_inst, table_name, keyword_buf); sleep(1); } @@ -616,9 +616,9 @@ void *perf_stream_update_thread(void *arg) TEST_F(MaatPerfStreamScan, MultiThread) { const char *table_name = "HTTP_URL"; - struct maat *maat_instance = MaatPerfStreamScan::_shared_maat_instance; + struct maat *maat_inst = MaatPerfStreamScan::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); pthread_t threads[PERF_THREAD_NUM + 1]; @@ -627,7 +627,7 @@ TEST_F(MaatPerfStreamScan, MultiThread) { int *is_all_hit = NULL; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { - thread_params[i].maat_instance = maat_instance; + thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; thread_params[i].test_count = PERF_SCAN_COUNT / 10; @@ -656,7 +656,7 @@ TEST_F(MaatPerfStreamScan, MultiThread) { } scan_per_second = scan_count * 1000 / time_elapse_ms; - log_info(maat_instance->logger, MODULE_FRAMEWORK_PERF_GTEST, + log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "StreamScan match rate on %d-threads speed %lld lookups/s/thread", PERF_THREAD_NUM, scan_per_second); } @@ -686,9 +686,9 @@ protected: maat_options_set_accept_tags(opts, accept_tags); maat_options_set_caller_thread_number(opts, 5); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_PERF_GTEST, "[%s:%d] create maat instance in MaatFlagScan failed.", __FUNCTION__, __LINE__); @@ -696,23 +696,23 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatPerfIPScan::_shared_maat_instance; +struct maat *MaatPerfIPScan::_shared_maat_inst; struct log_handle *MaatPerfIPScan::logger; TEST_F(MaatPerfIPScan, MultiThread) { const char *table_name = "IP_PLUS_CONFIG"; - struct maat *maat_instance = MaatPerfIPScan::_shared_maat_instance; + struct maat *maat_inst = MaatPerfIPScan::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); pthread_t threads[PERF_THREAD_NUM + 1]; @@ -721,7 +721,7 @@ TEST_F(MaatPerfIPScan, MultiThread) int *is_all_hit = NULL; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { - thread_params[i].maat_instance = maat_instance; + thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; thread_params[i].test_count = PERF_SCAN_COUNT; @@ -750,7 +750,7 @@ TEST_F(MaatPerfIPScan, MultiThread) } scan_per_second = scan_count * 1000 / time_elapse_ms; - log_info(maat_instance->logger, MODULE_FRAMEWORK_PERF_GTEST, + log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "IPScan match rate on %d-threads speed %lld lookups/s/thread", PERF_THREAD_NUM, scan_per_second); } @@ -780,9 +780,9 @@ protected: maat_options_set_accept_tags(opts, accept_tags); maat_options_set_caller_thread_number(opts, 5); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_PERF_GTEST, "[%s:%d] create maat instance in MaatFlagScan failed.", __FUNCTION__, __LINE__); @@ -790,15 +790,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatPerfFQDNPluginScan::_shared_maat_instance; +struct maat *MaatPerfFQDNPluginScan::_shared_maat_inst; struct log_handle *MaatPerfFQDNPluginScan::logger; struct perf_fqdn_plugin_ud { @@ -846,11 +846,11 @@ void perf_fqdn_plugin_EX_dup_cb(int table_id, void **to, void **from, long argl, void* perf_fqdn_plugin_scan_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; struct perf_fqdn_plugin_ud *result[ARRAY_SIZE]; int i=0, j=0, ret=0, hit_times=0; - int table_id = maat_get_table_id(maat_instance, param->table_name); + int table_id = maat_get_table_id(maat_inst, param->table_name); memset(&result, 0, sizeof(result)); struct timespec start, end; @@ -858,7 +858,7 @@ void* perf_fqdn_plugin_scan_thread(void *arg) clock_gettime(CLOCK_MONOTONIC, &start); for (i = 0; i < param->test_count; i++) { - ret = maat_fqdn_plugin_table_get_ex_data(maat_instance, table_id, + ret = maat_fqdn_plugin_table_get_ex_data(maat_inst, table_id, "r3---sn-i3belne6.example2.com", (void**)result, ARRAY_SIZE); if (ret == 2) { @@ -907,20 +907,20 @@ void random_fqdn_generate(char *fqdn_buff, int sz) void *perf_fqdn_plugin_update_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; const int CMD_EXPR_NUM = 20; int i = 0; struct maat_cmd_line line_rule; char line_buff[1024], fqdn_buff[256]; for (i = 0; i < CMD_EXPR_NUM; i++) { - line_rule.rule_id = (int)maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + line_rule.rule_id = (int)maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.table_name = param->table_name; random_fqdn_generate(fqdn_buff, sizeof(fqdn_buff)); snprintf(line_buff, 1024, "%lld\t1\t%s\tcatid=4\t1", line_rule.rule_id, fqdn_buff); line_rule.table_line = line_buff; line_rule.expire_after = 0; - maat_cmd_set_line(maat_instance, &line_rule); + maat_cmd_set_line(maat_inst, &line_rule); sleep(WAIT_FOR_EFFECTIVE_S); } @@ -931,11 +931,11 @@ void *perf_fqdn_plugin_update_thread(void *arg) } TEST_F(MaatPerfFQDNPluginScan, MultiThread) { - struct maat *maat_instance = MaatPerfFQDNPluginScan::_shared_maat_instance; + struct maat *maat_inst = MaatPerfFQDNPluginScan::_shared_maat_inst; const char *table_name = "TEST_FQDN_PLUGIN_WITH_EXDATA"; int fqdn_plugin_ex_data_counter = 0; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); pthread_t threads[PERF_THREAD_NUM + 1]; @@ -943,7 +943,7 @@ TEST_F(MaatPerfFQDNPluginScan, MultiThread) { int i = 0; int *is_all_hit = NULL; - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, perf_fqdn_plugin_EX_new_cb, perf_fqdn_plugin_EX_free_cb, perf_fqdn_plugin_EX_dup_cb, @@ -951,7 +951,7 @@ TEST_F(MaatPerfFQDNPluginScan, MultiThread) { ASSERT_TRUE(ret>=0); for (i = 0; i < PERF_THREAD_NUM + 1; i++) { - thread_params[i].maat_instance = maat_instance; + thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; thread_params[i].test_count = PERF_SCAN_COUNT; @@ -980,7 +980,7 @@ TEST_F(MaatPerfFQDNPluginScan, MultiThread) { } scan_per_second = scan_count * 1000 / time_elapse_ms; - log_info(maat_instance->logger, MODULE_FRAMEWORK_PERF_GTEST, + log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "FQDNPluginScan match rate on %d-threads speed %lld lookups/s/thread", PERF_THREAD_NUM, scan_per_second); } @@ -1010,9 +1010,9 @@ protected: maat_options_set_accept_tags(opts, accept_tags); maat_options_set_caller_thread_number(opts, 5); - _shared_maat_instance = maat_new(opts, table_info_path); + _shared_maat_inst = maat_new(opts, table_info_path); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_PERF_GTEST, "[%s:%d] create maat instance in BoolPluginScan failed.", __FUNCTION__, __LINE__); @@ -1020,15 +1020,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatPerfBoolPluginScan::_shared_maat_instance; +struct maat *MaatPerfBoolPluginScan::_shared_maat_inst; struct log_handle *MaatPerfBoolPluginScan::logger; struct bool_plugin_ud { @@ -1076,11 +1076,11 @@ void perf_bool_plugin_ex_dup_cb(int table_id, void **to, void **from, long argl, void* perf_bool_plugin_scan_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; struct perf_fqdn_plugin_ud *result[ARRAY_SIZE]; int i=0, j=0, ret=0, hit_times=0; - int table_id = maat_get_table_id(maat_instance, param->table_name); + int table_id = maat_get_table_id(maat_inst, param->table_name); memset(&result, 0, sizeof(result)); struct timespec start, end; @@ -1089,7 +1089,7 @@ void* perf_bool_plugin_scan_thread(void *arg) clock_gettime(CLOCK_MONOTONIC, &start); for (i = 0; i < param->test_count; i++) { - ret = maat_bool_plugin_table_get_ex_data(maat_instance, table_id, items_4, + ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items_4, sizeof(items_4)/sizeof(unsigned long long), (void**)result, 6); if (ret == 1) { @@ -1116,19 +1116,19 @@ void* perf_bool_plugin_scan_thread(void *arg) void *perf_bool_plugin_update_thread(void *arg) { struct thread_param *param = (struct thread_param *)arg; - struct maat *maat_instance = param->maat_instance; + struct maat *maat_inst = param->maat_inst; const int CMD_EXPR_NUM = 20; int i = 0; struct maat_cmd_line line_rule; char line_buff[1024]; for (i = 0; i < CMD_EXPR_NUM; i++) { - line_rule.rule_id = (int)maat_cmd_incrby(maat_instance, "TEST_PLUG_SEQ", 1); + line_rule.rule_id = (int)maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1); line_rule.table_name = param->table_name; snprintf(line_buff, 1024, "%lld\t1&%d\ttunnel2\t1", line_rule.rule_id, i); line_rule.table_line = line_buff; line_rule.expire_after = 0; - maat_cmd_set_line(maat_instance, &line_rule); + maat_cmd_set_line(maat_inst, &line_rule); sleep(WAIT_FOR_EFFECTIVE_S); } @@ -1141,12 +1141,12 @@ void *perf_bool_plugin_update_thread(void *arg) TEST_F(MaatPerfBoolPluginScan, MultiThread) { int ex_data_counter = 0; const char *table_name = "TEST_BOOL_PLUGIN_WITH_EXDATA"; - struct maat *maat_instance = MaatPerfBoolPluginScan::_shared_maat_instance; + struct maat *maat_inst = MaatPerfBoolPluginScan::_shared_maat_inst; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, perf_bool_plugin_ex_new_cb, perf_bool_plugin_ex_free_cb, perf_bool_plugin_ex_dup_cb, @@ -1159,7 +1159,7 @@ TEST_F(MaatPerfBoolPluginScan, MultiThread) { int *is_all_hit = NULL; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { - thread_params[i].maat_instance = maat_instance; + thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; thread_params[i].test_count = PERF_SCAN_COUNT; @@ -1188,7 +1188,7 @@ TEST_F(MaatPerfBoolPluginScan, MultiThread) { } scan_per_second = scan_count * 1000 / time_elapse_ms; - log_info(maat_instance->logger, MODULE_FRAMEWORK_PERF_GTEST, + log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "BoolPluginScan match rate on %d-threads speed %lld lookups/s/thread", PERF_THREAD_NUM, scan_per_second); } @@ -1208,9 +1208,9 @@ protected: maat_options_set_logger(opts, "./maat_framework_perf_gtest.log", LOG_LEVEL_INFO); maat_options_set_caller_thread_number(opts, 5); - _shared_maat_instance = maat_new(opts, table_info); + _shared_maat_inst = maat_new(opts, table_info); maat_options_free(opts); - if (NULL == _shared_maat_instance) { + if (NULL == _shared_maat_inst) { log_error(logger, MODULE_FRAMEWORK_PERF_GTEST, "[%s:%d] create maat instance in MaatPerfFileScan failed.", __FUNCTION__, __LINE__); @@ -1218,15 +1218,15 @@ protected: } static void TearDownTestCase() { - maat_free(_shared_maat_instance); + maat_free(_shared_maat_inst); log_handle_destroy(logger); } static struct log_handle *logger; - static struct maat *_shared_maat_instance; + static struct maat *_shared_maat_inst; }; -struct maat *MaatPerfFileScan::_shared_maat_instance; +struct maat *MaatPerfFileScan::_shared_maat_inst; struct log_handle *MaatPerfFileScan::logger; struct perf_ip_plugin_ud { @@ -1274,9 +1274,9 @@ static void *ip_plugin_get_thread(void *arg) const char *table_name = "TSG_IP_LOCATION_BUILT_IN"; int test_times = 1000*1000, hit_times = 0; int ret = 0, i=0, j=0; - struct maat *maat_instance = (struct maat *)arg; + struct maat *maat_inst = (struct maat *)arg; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); struct timespec start, end; struct ip_addr ipv4; @@ -1287,7 +1287,7 @@ static void *ip_plugin_get_thread(void *arg) clock_gettime(CLOCK_MONOTONIC, &start); struct perf_ip_plugin_ud *results[ARRAY_SIZE]; for (i = 0; i < test_times; i++) { - ret = maat_ip_plugin_table_get_ex_data(maat_instance, table_id, &ipv4, (void**)results, 4); + ret = maat_ip_plugin_table_get_ex_data(maat_inst, table_id, &ipv4, (void**)results, 4); if (ret > 0) { hit_times++; } @@ -1299,7 +1299,7 @@ static void *ip_plugin_get_thread(void *arg) clock_gettime(CLOCK_MONOTONIC, &end); long long time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; - log_info(maat_instance->logger, MODULE_FRAMEWORK_PERF_GTEST, + log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "ip_plugin_get_ex_data time_elapse:%lldms hit_times:%d", time_elapse_ms, hit_times); @@ -1309,15 +1309,15 @@ static void *ip_plugin_get_thread(void *arg) } TEST_F(MaatPerfFileScan, IPPlugin) { - struct maat *maat_instance = MaatPerfFileScan::_shared_maat_instance; + struct maat *maat_inst = MaatPerfFileScan::_shared_maat_inst; const char* table_name = "TSG_IP_LOCATION_BUILT_IN"; int ip_plugin_ex_data_counter = 0; int* is_all_hit = NULL; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); ASSERT_GT(table_id, 0); - int ret = maat_plugin_table_ex_schema_register(maat_instance, table_name, + int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name, perf_ip_plugin_EX_new_cb, perf_ip_plugin_EX_free_cb, perf_ip_plugin_EX_dup_cb, @@ -1328,7 +1328,7 @@ TEST_F(MaatPerfFileScan, IPPlugin) { pthread_t threads[PERF_THREAD_NUM]; for (i = 0; i < PERF_THREAD_NUM; i++) { - pthread_create(&(threads[i]), NULL, ip_plugin_get_thread, maat_instance); + pthread_create(&(threads[i]), NULL, ip_plugin_get_thread, maat_inst); } for (i = 0; i < PERF_THREAD_NUM; i++) { @@ -1347,4 +1347,4 @@ int main(int argc, char ** argv) ret=RUN_ALL_TESTS(); return ret; -} \ No newline at end of file +} diff --git a/test/maat_input_mode_gtest.cpp b/test/maat_input_mode_gtest.cpp index 82b4d2e..9bcf34f 100644 --- a/test/maat_input_mode_gtest.cpp +++ b/test/maat_input_mode_gtest.cpp @@ -37,33 +37,33 @@ TEST(json_mode, maat_scan_string) { maat_options_set_json_file(opts, json_path); maat_options_set_logger(opts, "./maat_input_mode_gtest.log", LOG_LEVEL_INFO); - struct maat *maat_instance = maat_new(opts, table_info_path); - EXPECT_TRUE(maat_instance != NULL); + struct maat *maat_inst = maat_new(opts, table_info_path); + EXPECT_TRUE(maat_inst != NULL); const char *table_name = "KEYWORDS_TABLE"; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); char scan_data[128] = "string1, string2, string3, string4, string5, string6, string7, string8"; long long results[5] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, sizeof(results), &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); EXPECT_EQ(results[0], 182); - long long clause_id = maat_runtime_get_sequence(maat_instance->maat_rt, "test_seq"); + long long clause_id = maat_runtime_get_sequence(maat_inst->maat_rt, "test_seq"); EXPECT_EQ(clause_id, 0); - clause_id = maat_runtime_get_sequence(maat_instance->maat_rt, "test_seq"); + clause_id = maat_runtime_get_sequence(maat_inst->maat_rt, "test_seq"); EXPECT_EQ(clause_id, 1); - clause_id = maat_runtime_get_sequence(maat_instance->maat_rt, "test_seq"); + clause_id = maat_runtime_get_sequence(maat_inst->maat_rt, "test_seq"); EXPECT_EQ(clause_id, 2); maat_options_free(opts); maat_state_free(state); state = NULL; - maat_free(maat_instance); + maat_free(maat_inst); } TEST(iris_mode, maat_scan_string) { @@ -93,17 +93,17 @@ TEST(iris_mode, maat_scan_string) { maat_options_set_iris(opts, tmp_iris_full_idx_path, tmp_iris_inc_idx_path); maat_options_set_logger(opts, "./maat_input_mode_gtest.log", LOG_LEVEL_INFO); - struct maat *maat_instance = maat_new(opts, table_info_path); - EXPECT_TRUE(maat_instance != NULL); + struct maat *maat_inst = maat_new(opts, table_info_path); + EXPECT_TRUE(maat_inst != NULL); const char *table_name = "KEYWORDS_TABLE"; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); char scan_data[128] = "string1, string2, string3, string4, string5, string6, string7, string8"; long long results[5] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, sizeof(results), &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -112,7 +112,7 @@ TEST(iris_mode, maat_scan_string) { maat_options_free(opts); maat_state_free(state); state = NULL; - maat_free(maat_instance); + maat_free(maat_inst); } int count_line_num_cb(const char *table_name, const char *line, void *u_para) @@ -217,15 +217,15 @@ TEST(redis_mode, maat_scan_string) { maat_options_set_redis(opts, redis_ip, redis_port, redis_db); maat_options_set_logger(opts, "./maat_input_mode_gtest.log", LOG_LEVEL_INFO); - struct maat *maat_instance = maat_new(opts, table_info_path); + struct maat *maat_inst = maat_new(opts, table_info_path); const char *table_name = "KEYWORDS_TABLE"; - int table_id = maat_get_table_id(maat_instance, table_name); + int table_id = maat_get_table_id(maat_inst, table_name); char scan_data[128] = "string1, string2, string3, string4, string5, string6, string7, string8"; long long results[5] = {0}; size_t n_hit_result = 0; int thread_id = 0; - struct maat_state *state = maat_state_new(maat_instance, thread_id); - int ret = maat_scan_string(maat_instance, table_id, scan_data, strlen(scan_data), + struct maat_state *state = maat_state_new(maat_inst, thread_id); + int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, sizeof(results), &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HIT); EXPECT_EQ(n_hit_result, 1); @@ -234,7 +234,7 @@ TEST(redis_mode, maat_scan_string) { maat_options_free(opts); maat_state_free(state); state = NULL; - maat_free(maat_instance); + maat_free(maat_inst); } int main(int argc, char ** argv)