From c5accc49f2e4b607dd68330d360ffdd1d9078800 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=96=87=E5=9D=9B?= Date: Thu, 8 Jun 2023 07:32:41 +0000 Subject: [PATCH] [PATCH] maat_plugin_table_get_ex_data add key_len (23.06) --- include/maat.h | 7 +- src/alignment.c | 3 +- src/json2iris.c | 64 ++++++++----- src/maat_api.c | 140 +++++++++++++++++----------- src/maat_compile.c | 3 +- src/maat_kv.c | 9 +- src/maat_plugin.c | 169 ++++++++++++++++++++++++++++------ src/maat_table.c | 7 +- src/maat_utils.c | 8 +- src/maat_virtual.c | 6 +- test/maat_framework_gtest.cpp | 124 +++++++++++++++++++++++-- test/maat_json.json | 38 ++++++-- test/table_info.conf | 28 +++++- 13 files changed, 463 insertions(+), 143 deletions(-) diff --git a/include/maat.h b/include/maat.h index 3a994a5..5100134 100644 --- a/include/maat.h +++ b/include/maat.h @@ -149,9 +149,12 @@ int maat_plugin_table_ex_schema_register(struct maat *instance, const char *tabl long argl, void *argp); /** * returned data is duplicated by dup_func of maat_plugin_table_ex_schema_register, - * caller is responsible to free the data. + * caller is responsible to free the data. + * NOTE: support three key type(integer, pointer, ip_addr) specified in table_info.conf + * if use ip_addr key type, then key should be ip address in network order. */ -void *maat_plugin_table_get_ex_data(struct maat *instance, int table_id, const char *key); +void *maat_plugin_table_get_ex_data(struct maat *instance, int table_id, + const char *key, size_t key_len); int maat_ip_plugin_table_get_ex_data(struct maat *instance, int table_id, const struct ip_addr *ip, void **ex_data_array, diff --git a/src/alignment.c b/src/alignment.c index 6c6af77..613dc6d 100644 --- a/src/alignment.c +++ b/src/alignment.c @@ -33,7 +33,8 @@ inline long long alignment_int64_array_sum(long long *array, int size) return sum; } -inline long long alignment_int64_array_add(long long *array, int offset, long long op_val) +inline long long alignment_int64_array_add(long long *array, int offset, + long long op_val) { int idx = (CPU_CACHE_ALIGMENT / sizeof(long long)) * offset; array[idx] += op_val; diff --git a/src/json2iris.c b/src/json2iris.c index 84aa1c1..8367ca2 100644 --- a/src/json2iris.c +++ b/src/json2iris.c @@ -105,7 +105,8 @@ struct iris_table *query_table_info(struct iris_description *p_iris, strlen(table_name))); snprintf(table_info->table_path, sizeof(table_info->table_path), "%s/%s.local", p_iris->tmp_iris_dir, table_info->table_name); - HASH_ADD_KEYPTR(hh, p_iris->iris_table_map, table_info->table_name, strlen(table_name), table_info); + HASH_ADD_KEYPTR(hh, p_iris->iris_table_map, table_info->table_name, + strlen(table_name), table_info); } return table_info; @@ -127,11 +128,13 @@ int set_iris_descriptor(const char *json_file, cJSON *json, struct iris_description *iris_cfg) { memset(iris_cfg, 0, sizeof(struct iris_description)); - snprintf(iris_cfg->tmp_iris_dir, sizeof(iris_cfg->tmp_iris_dir), "%s_iris_tmp", json_file); + snprintf(iris_cfg->tmp_iris_dir, sizeof(iris_cfg->tmp_iris_dir), + "%s_iris_tmp", json_file); snprintf(iris_cfg->tmp_iris_index_dir, sizeof(iris_cfg->tmp_iris_index_dir), "%s_iris_tmp/index", json_file); - snprintf(iris_cfg->index_path, sizeof(iris_cfg->index_path), "%s/full_config_index.%010d", - iris_cfg->tmp_iris_index_dir, json_version); + snprintf(iris_cfg->index_path, sizeof(iris_cfg->index_path), + "%s/full_config_index.%010d", iris_cfg->tmp_iris_index_dir, + json_version); iris_cfg->redis_write_ctx = redis_write_ctx; iris_cfg->str2int_map = maat_kv_store_new(); @@ -173,9 +176,12 @@ int set_iris_descriptor(const char *json_file, cJSON *json, maat_kv_register(iris_cfg->str2int_map, "hexbin", 1); maat_kv_register(iris_cfg->str2int_map, "case plain", 2); - iris_cfg->compile_table = query_table_info(iris_cfg, compile_tn, TABLE_TYPE_COMPILE); - iris_cfg->group2compile_table = query_table_info(iris_cfg, group2compile_tn, TABLE_TYPE_GROUP2COMPILE); - iris_cfg->group2group_table = query_table_info(iris_cfg, group2group_tn, TABLE_TYPE_GROUP2GROUP); + iris_cfg->compile_table = query_table_info(iris_cfg, compile_tn, + TABLE_TYPE_COMPILE); + iris_cfg->group2compile_table = query_table_info(iris_cfg, group2compile_tn, + TABLE_TYPE_GROUP2COMPILE); + iris_cfg->group2group_table = query_table_info(iris_cfg, group2group_tn, + TABLE_TYPE_GROUP2GROUP); if (encrypt_key && encrypt_algo) { iris_cfg->encrypt_key = maat_strdup(encrypt_key); @@ -236,8 +242,9 @@ int write_plugin_line(cJSON *plug_table_json, int sequence, cJSON *item = cJSON_GetObjectItem(plug_table_json, "table_name"); if (NULL == item || item->type != cJSON_String) { log_error(logger, MODULE_JSON2IRIS, - "[%s:%d] The %d plugin_table's table_name not defined or format error", - __FUNCTION__, __LINE__, sequence); + "[%s:%d] The %d plugin_table's table_name " + "not defined or format error", __FUNCTION__, + __LINE__, sequence); return -1; } const char *table_name = item->valuestring; @@ -250,7 +257,8 @@ int write_plugin_line(cJSON *plug_table_json, int sequence, return -1; } int line_cnt = cJSON_GetArraySize(table_content); - struct iris_table *table_info = query_table_info(p_iris, table_name, TABLE_TYPE_PLUGIN); + struct iris_table *table_info = query_table_info(p_iris, table_name, + TABLE_TYPE_PLUGIN); cJSON *each_line = NULL; const char *line_content = NULL; @@ -265,7 +273,8 @@ int write_plugin_line(cJSON *plug_table_json, int sequence, line_content = each_line->valuestring; table_info->write_pos += memcat(&(table_info->buff), table_info->write_pos, - &(table_info->buff_sz), line_content, strlen(line_content)); + &(table_info->buff_sz), line_content, + strlen(line_content)); table_info->write_pos += memcat(&(table_info->buff), table_info->write_pos, &(table_info->buff_sz), "\n", 1); table_info->line_count++; @@ -315,7 +324,8 @@ static struct group_info *group_info_add_unsafe(struct iris_description *p_iris, group_info = ALLOC(struct group_info, 1); group_info->group_id = get_group_seq(p_iris); strncpy(group_info->group_name, group_name, sizeof(group_info->group_name)); - HASH_ADD_KEYPTR(hh, p_iris->group_name_map, group_info->group_name, strlen(group_name), group_info); + HASH_ADD_KEYPTR(hh, p_iris->group_name_map, group_info->group_name, + strlen(group_name), group_info); } return group_info; } @@ -327,7 +337,7 @@ static int get_region_seq(struct iris_description *iris_cfg) if (NULL == iris_cfg->redis_write_ctx) { sequence = iris_cfg->region_cnt; } else { - redisReply *data_reply = maat_cmd_wrap_redis_command(iris_cfg->redis_write_ctx, + redisReply *data_reply = maat_cmd_wrap_redis_command(iris_cfg->redis_write_ctx, "INCRBY %s 1", mr_region_id_var); sequence = (int)data_reply->integer - 1; freeReplyObject(data_reply); @@ -608,8 +618,8 @@ int write_region_rule(cJSON *region_json, int compile_id, int group_id, cJSON *item = cJSON_GetObjectItem(region_json, "table_name"); if (NULL == item || item->type != cJSON_String) { log_error(logger, MODULE_JSON2IRIS, - "[%s:%d] compile rule %d's table_name not defined or format error", - __FUNCTION__, __LINE__, compile_id); + "[%s:%d] compile rule %d's table_name not defined " + "or format error", __FUNCTION__, __LINE__, compile_id); return -1; } const char *table_name = item->valuestring; @@ -617,8 +627,9 @@ int write_region_rule(cJSON *region_json, int compile_id, int group_id, item = cJSON_GetObjectItem(region_json, "table_type"); if (NULL == item || item->type != cJSON_String) { log_error(logger, MODULE_JSON2IRIS, - "[%s:%d] compile rule %d's table name %s's table_type not defined or format error", - __FUNCTION__, __LINE__, compile_id, table_name); + "[%s:%d] compile rule %d's table name %s's table_type " + "not defined or format error", __FUNCTION__, __LINE__, + compile_id, table_name); return -1; } @@ -635,8 +646,9 @@ int write_region_rule(cJSON *region_json, int compile_id, int group_id, cJSON *table_content = cJSON_GetObjectItem(region_json, "table_content"); if (NULL == table_content || table_content->type != cJSON_Object) { log_error(logger, MODULE_JSON2IRIS, - "[%s:%d] compile rule %d table name %s's table_content not defined or format error", - __FUNCTION__, __LINE__, compile_id, table_name); + "[%s:%d] compile rule %d table name %s's table_content " + "not defined or format error", __FUNCTION__, __LINE__, + compile_id, table_name); return -1; } @@ -645,7 +657,8 @@ int write_region_rule(cJSON *region_json, int compile_id, int group_id, cJSON_AddNumberToObject(table_content, "group_id", group_id); cJSON_AddNumberToObject(table_content, "is_valid", 1); - struct iris_table *table_info = query_table_info(p_iris, table_name, table_type_int); + struct iris_table *table_info = query_table_info(p_iris, table_name, + table_type_int); switch (table_type_int) { case TABLE_TYPE_FLAG: case TABLE_TYPE_FLAG_PLUS: @@ -686,9 +699,9 @@ int write_group2compile_line(int group_id, int compile_id, int group_not_flag, table = p_iris->group2compile_table; } - snprintf(buff, sizeof(buff), "%d\t%d\t1\t%d\t%s\t%d\n", group_id, compile_id, + snprintf(buff, sizeof(buff), "%d\t%d\t1\t%d\t%s\t%d\n", group_id, compile_id, group_not_flag, vtable, clause_index); - table->write_pos += memcat(&(table->buff), table->write_pos, &(table->buff_sz), + table->write_pos += memcat(&(table->buff), table->write_pos, &(table->buff_sz), buff, strlen(buff)); table->line_count++; @@ -779,8 +792,8 @@ int write_group_rule(cJSON *group_json, int parent_id, if (region_json != NULL) { cJSON *region_rule = NULL; cJSON_ArrayForEach(region_rule, region_json) { - ret = write_region_rule(region_rule, tracking_compile_id, group_info->group_id, - p_iris, logger); + ret = write_region_rule(region_rule, tracking_compile_id, + group_info->group_id, p_iris, logger); if (ret < 0) { log_error(logger, MODULE_JSON2IRIS, "[%s:%d] compile rule %d write region error", @@ -806,7 +819,8 @@ int write_group_rule(cJSON *group_json, int parent_id, if (NULL == region_json && NULL == sub_groups) { log_info(logger, MODULE_JSON2IRIS, - "[%s:%d] A group of compile rule %d has neither regions, sub groups, nor refered another exisited group", + "[%s:%d] A group of compile rule %d has neither regions, " + "sub groups, nor refered another exisited group", __FUNCTION__, __LINE__, tracking_compile_id); } } diff --git a/src/maat_api.c b/src/maat_api.c index fa384ba..5bf1073 100644 --- a/src/maat_api.c +++ b/src/maat_api.c @@ -733,13 +733,15 @@ int maat_plugin_table_ex_schema_register(struct maat *maat_instance, pthread_mutex_lock(&(maat_instance->background_update_mutex)); int ret = -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_instance->tbl_mgr, + table_id); if (TABLE_TYPE_COMPILE == table_type) { - ret = compile_table_ex_schema_register(maat_instance, table_id, new_func, free_func, - dup_func, argl, argp); + ret = compile_table_ex_schema_register(maat_instance, table_id, new_func, + free_func, dup_func, argl, argp); } else { - ret = generic_plugin_table_ex_schema_register(maat_instance, table_name, table_id, new_func, - free_func, dup_func, argl, argp); + ret = generic_plugin_table_ex_schema_register(maat_instance, table_name, + table_id, new_func, free_func, + dup_func, argl, argp); } pthread_mutex_unlock(&(maat_instance->background_update_mutex)); @@ -747,7 +749,7 @@ int maat_plugin_table_ex_schema_register(struct maat *maat_instance, } void *maat_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, - const char *key) + const char *key, size_t key_len) { if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM @@ -771,11 +773,12 @@ 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, table_id); + enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + table_id); if (TABLE_TYPE_COMPILE == table_type) { ret = compile_runtime_get_ex_data(runtime, schema, *(long long *)key); } else if (TABLE_TYPE_PLUGIN == table_type) { - ret = plugin_runtime_get_ex_data(runtime, schema, key, strlen(key)); + ret = plugin_runtime_get_ex_data(runtime, schema, key, key_len); } else { return NULL; } @@ -858,7 +861,7 @@ int maat_bool_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, return -1; } - int n_hit_ex_data = bool_plugin_runtime_get_ex_data(bool_plugin_rt, item_ids, n_item, + int n_hit_ex_data = bool_plugin_runtime_get_ex_data(bool_plugin_rt, item_ids, n_item, ex_data_array, n_ex_data); if (n_hit_ex_data < 0) { return -1; @@ -889,7 +892,8 @@ int flag_scan(struct table_manager *tbl_mgr, int thread_id, long long flag, int physical_table_id, int vtable_id, struct maat_state *state) { enum table_type table_type = table_manager_get_table_type(tbl_mgr, physical_table_id); - if (table_type == TABLE_TYPE_FLAG_PLUS && DISTRICT_FLAG_UNSET == state->is_set_district) { + if (table_type == TABLE_TYPE_FLAG_PLUS && + DISTRICT_FLAG_UNSET == state->is_set_district) { return -1; } @@ -1148,7 +1152,8 @@ int maat_scan_flag(struct maat *maat_instance, int table_id, alignment_int64_array_add(maat_instance->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, state->thread_id, 1); + alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + state->thread_id, 1); } } @@ -1196,9 +1201,11 @@ int maat_scan_integer(struct maat *maat_instance, int table_id, 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_instance->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_instance->tbl_mgr, + table_id); vtable_id = table_id; } else { physical_table_id = table_id; @@ -1235,11 +1242,13 @@ int maat_scan_integer(struct maat *maat_instance, int table_id, alignment_int64_array_add(maat_instance->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, state->thread_id, 1); + alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + state->thread_id, 1); } } - void *interval_rt = table_manager_get_runtime(maat_instance->tbl_mgr, physical_table_id); + void *interval_rt = table_manager_get_runtime(maat_instance->tbl_mgr, + physical_table_id); assert(interval_rt != NULL); if (1 == maat_instance->opts.perf_on) { @@ -1260,9 +1269,8 @@ 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, uint16_t port, int protocol, - long long *results, size_t n_result, +int maat_scan_ipv4(struct maat *maat_instance, 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 @@ -1284,9 +1292,11 @@ int maat_scan_ipv4(struct maat *maat_instance, int table_id, 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_instance->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_instance->tbl_mgr, + table_id); vtable_id = table_id; } else { physical_table_id = table_id; @@ -1306,8 +1316,8 @@ int maat_scan_ipv4(struct maat *maat_instance, int table_id, 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); - int hit_group_cnt = ipv4_scan(maat_instance->tbl_mgr, state->thread_id, ip_addr, port, protocol, - physical_table_id, vtable_id, state); + int hit_group_cnt = ipv4_scan(maat_instance->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++; return MAAT_SCAN_ERR; @@ -1323,7 +1333,8 @@ int maat_scan_ipv4(struct maat *maat_instance, int table_id, alignment_int64_array_add(maat_instance->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, state->thread_id, 1); + alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + state->thread_id, 1); } } @@ -1372,9 +1383,11 @@ int maat_scan_ipv6(struct maat *maat_instance, int table_id, 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_instance->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_instance->tbl_mgr, + table_id); vtable_id = table_id; } else { physical_table_id = table_id; @@ -1394,8 +1407,8 @@ int maat_scan_ipv6(struct maat *maat_instance, int table_id, 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); - int hit_group_cnt = ipv6_scan(maat_instance->tbl_mgr, state->thread_id, ip_addr, port, protocol, - physical_table_id, vtable_id, state); + int hit_group_cnt = ipv6_scan(maat_instance->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++; return MAAT_SCAN_ERR; @@ -1411,7 +1424,8 @@ int maat_scan_ipv6(struct maat *maat_instance, int table_id, alignment_int64_array_add(maat_instance->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, state->thread_id, 1); + alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + state->thread_id, 1); } } @@ -1459,9 +1473,11 @@ int maat_scan_string(struct maat *maat_instance, int table_id, const char *data, 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_instance->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_instance->tbl_mgr, + table_id); vtable_id = table_id; } else { physical_table_id = table_id; @@ -1481,7 +1497,7 @@ int maat_scan_string(struct maat *maat_instance, int table_id, const char *data, 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); - int hit_group_cnt = string_scan(maat_instance->tbl_mgr, state->thread_id, data, data_len, + int hit_group_cnt = string_scan(maat_instance->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++; @@ -1498,7 +1514,8 @@ int maat_scan_string(struct maat *maat_instance, int table_id, const char *data, alignment_int64_array_add(maat_instance->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, state->thread_id, 1); + alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + state->thread_id, 1); } } @@ -1537,9 +1554,11 @@ struct maat_stream *maat_stream_new(struct maat *maat_instance, int table_id, stream->thread_id = state->thread_id; stream->logger = maat_instance->logger; - 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_instance->tbl_mgr, + table_id); if (table_type == TABLE_TYPE_VIRTUAL) { - stream->physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, table_id); + stream->physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, + table_id); stream->vtable_id = table_id; } else { stream->physical_table_id = table_id; @@ -1550,7 +1569,8 @@ 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, stream->physical_table_id); + table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + stream->physical_table_id); if (table_type != TABLE_TYPE_EXPR && table_type != TABLE_TYPE_EXPR_PLUS) { return NULL; } @@ -1595,7 +1615,8 @@ int maat_stream_scan(struct maat_stream *maat_stream, const char *data, int data return MAAT_SCAN_OK; } - void *expr_rt = table_manager_get_runtime(maat_instance->tbl_mgr, maat_stream->physical_table_id); + void *expr_rt = table_manager_get_runtime(maat_instance->tbl_mgr, + maat_stream->physical_table_id); assert(expr_rt != NULL); long long cur_expr_rt_version = expr_runtime_get_version(expr_rt); @@ -1603,7 +1624,8 @@ 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, maat_stream->thread_id, 1); + alignment_int64_array_add(maat_instance->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) { @@ -1621,7 +1643,8 @@ int maat_stream_scan(struct maat_stream *maat_stream, const char *data, int data alignment_int64_array_add(maat_instance->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, maat_stream->thread_id, 1); + alignment_int64_array_add(maat_instance->stat->not_grp_hit_cnt, + maat_stream->thread_id, 1); } } @@ -1711,7 +1734,8 @@ void maat_state_free(struct maat_state *state) state->maat_instance = NULL; FREE(state); - alignment_int64_array_add(maat_instance->stat->maat_state_cnt, thread_id, -1); + alignment_int64_array_add(maat_instance->stat->maat_state_cnt, + thread_id, -1); } int maat_state_set_scan_district(struct maat_state *state, int vtable_id, @@ -1730,7 +1754,8 @@ int maat_state_set_scan_district(struct maat_state *state, int vtable_id, return -1; } - enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, vtable_id); + enum table_type table_type = table_manager_get_table_type(maat_instance->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, @@ -1740,26 +1765,32 @@ int maat_state_set_scan_district(struct maat_state *state, int vtable_id, int physical_table_id = vtable_id; if (table_type == TABLE_TYPE_VIRTUAL) { - physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, vtable_id); + physical_table_id = vtable_get_physical_table_id(maat_instance->tbl_mgr, + vtable_id); } int ret = -1; - table_type = table_manager_get_table_type(maat_instance->tbl_mgr, physical_table_id); - void *runtime = table_manager_get_runtime(maat_instance->tbl_mgr, physical_table_id); + table_type = table_manager_get_table_type(maat_instance->tbl_mgr, + physical_table_id); + void *runtime = table_manager_get_runtime(maat_instance->tbl_mgr, + physical_table_id); assert(runtime != NULL); switch (table_type) { case TABLE_TYPE_FLAG_PLUS: - ret = flag_runtime_set_scan_district((struct flag_runtime *)runtime, district, - district_len, &(state->district_id)); + ret = flag_runtime_set_scan_district((struct flag_runtime *)runtime, + district, district_len, + &(state->district_id)); break; case TABLE_TYPE_EXPR_PLUS: - ret = expr_runtime_set_scan_district((struct expr_runtime *)runtime, district, - district_len, &(state->district_id)); + ret = expr_runtime_set_scan_district((struct expr_runtime *)runtime, + district, district_len, + &(state->district_id)); break; case TABLE_TYPE_INTERVAL_PLUS: - ret = interval_runtime_set_scan_district((struct interval_runtime *)runtime, district, - district_len, &(state->district_id)); + ret = interval_runtime_set_scan_district((struct interval_runtime *)runtime, + district, district_len, + &(state->district_id)); break; default: log_error(maat_instance->logger, MODULE_MAAT_API, @@ -1814,7 +1845,8 @@ int maat_state_set_scan_compile_table(struct maat_state *state, int compile_tabl return 0; } -int maat_state_get_hit_paths(struct maat_state *state, struct maat_hit_path *paths, size_t n_path) +int maat_state_get_hit_paths(struct maat_state *state, struct maat_hit_path *paths, + size_t n_path) { if (NULL == state || NULL == paths || 0 == n_path) { return -1; @@ -1834,12 +1866,14 @@ int maat_state_get_hit_paths(struct maat_state *state, struct maat_hit_path *pat compile_table_id = maat_instance->default_compile_table_id; } - void *compile_rt = table_manager_get_runtime(maat_instance->tbl_mgr, compile_table_id); + void *compile_rt = table_manager_get_runtime(maat_instance->tbl_mgr, + compile_table_id); if (NULL == compile_rt) { return -1; } - void *g2g_runtime = table_manager_get_runtime(maat_instance->tbl_mgr, maat_instance->g2g_table_id); + void *g2g_runtime = table_manager_get_runtime(maat_instance->tbl_mgr, + maat_instance->g2g_table_id); size_t internal_hit_path_cnt = maat_compile_state_get_internal_hit_paths(state->compile_state, (struct compile_runtime *)compile_rt, (struct group2group_runtime *)g2g_runtime, @@ -1863,4 +1897,4 @@ int maat_state_get_hit_groups(struct maat_state *state, struct maat_hit_group *g int maat_hit_group_compile_id(struct maat *instance, struct maat_hit_group *group) { return 0; -} \ No newline at end of file +} diff --git a/src/maat_compile.c b/src/maat_compile.c index 7063191..2aaf34b 100644 --- a/src/maat_compile.c +++ b/src/maat_compile.c @@ -1227,8 +1227,7 @@ struct compile_rule *compile_rule_clone(struct compile_rule *rule) new_rule->table_line = ALLOC(char, new_rule->table_line_len); memcpy(new_rule->table_line, rule->table_line, new_rule->table_line_len); - if (1 == rule->ref_schema->set_flag) - { + if (1 == rule->ref_schema->set_flag) { *(new_rule->ex_data) = rule_ex_data_new(rule->table_name, rule->ref_schema->table_id, rule->table_line, &(rule->ref_schema->ex_schema)); } diff --git a/src/maat_kv.c b/src/maat_kv.c index 3c586af..7c0d4c8 100644 --- a/src/maat_kv.c +++ b/src/maat_kv.c @@ -84,7 +84,8 @@ void maat_kv_store_free(struct maat_kv_store *store) FREE(store); } -int maat_kv_register_unNull(struct maat_kv_store *store, const char *key, size_t keylen, long long value) +int maat_kv_register_unNull(struct maat_kv_store *store, const char *key, + size_t keylen, long long value) { if (keylen > MAAT_KV_MAX_KEY_LEN) { return -1; @@ -112,7 +113,8 @@ int maat_kv_register(struct maat_kv_store* store, const char *key, long long val return ret; } -int maat_kv_read_unNull(struct maat_kv_store *store, const char* key, size_t keylen, long long *value) +int maat_kv_read_unNull(struct maat_kv_store *store, const char* key, + size_t keylen, long long *value) { struct maat_kv_pair *kv = NULL; char key_lowercase[MAAT_KV_MAX_KEY_LEN] = {0}; @@ -136,7 +138,8 @@ int maat_kv_read(struct maat_kv_store *store, const char * key, long long *value return maat_kv_read_unNull(store, key, strlen(key), value); } -int maat_kv_write_unNull(struct maat_kv_store* store, const char* key, size_t keylen, long long value) +int maat_kv_write_unNull(struct maat_kv_store* store, const char* key, + size_t keylen, long long value) { struct maat_kv_pair *kv = NULL; char key_lowercase[MAAT_KV_MAX_KEY_LEN] = {0}; diff --git a/src/maat_plugin.c b/src/maat_plugin.c index d999319..dc80033 100644 --- a/src/maat_plugin.c +++ b/src/maat_plugin.c @@ -43,14 +43,16 @@ struct plugin_runtime { enum plugin_key_type { PLUGIN_KEY_TYPE_INVALID = 0, PLUGIN_KEY_TYPE_POINTER, - PLUGIN_KEY_TYPE_INTEGER + PLUGIN_KEY_TYPE_INTEGER, + PLUGIN_KEY_TYPE_IP_ADDR }; #define MAX_PLUGIN_PER_TABLE 32 struct plugin_schema { enum plugin_key_type key_type; - int addr_type_column; + int key_len; int key_column; + int addr_type_column; int rule_tag_column; int n_foreign; int foreign_columns[MAX_FOREIGN_CLMN_NUM]; @@ -120,12 +122,31 @@ void *plugin_schema_new(cJSON *json, struct table_manager *tbl_mgr, schema->key_type = PLUGIN_KEY_TYPE_POINTER; } else if (strcmp(custom_item->valuestring, "integer") == 0) { schema->key_type = PLUGIN_KEY_TYPE_INTEGER; + custom_item = cJSON_GetObjectItem(item, "key_len"); + if (NULL == custom_item || custom_item->type != cJSON_Number) { + log_error(logger, MODULE_PLUGIN, + "[%s:%d]plugin table:<%s> schema integer key must" + " have key_len column", __FUNCTION__, __LINE__, + table_name); + goto error; + } + schema->key_len = custom_item->valueint; + } else if (strcmp(custom_item->valuestring, "ip_addr") == 0) { + schema->key_type = PLUGIN_KEY_TYPE_IP_ADDR; + custom_item = cJSON_GetObjectItem(item, "addr_type"); + if (NULL == custom_item || custom_item->type != cJSON_Number) { + log_error(logger, MODULE_PLUGIN, + "[%s:%d]plugin table:<%s> schema ip_addr key must" + " have addr_type column", __FUNCTION__, __LINE__, + table_name); + goto error; + } + schema->addr_type_column = custom_item->valueint; } else { log_error(logger, MODULE_PLUGIN, "[%s:%d]plugin table:<%s> schema key_type:%s is illegal, " - "just allow {pointer}, {integer}", - __FUNCTION__, __LINE__, table_name, - custom_item->valuestring); + "just allow {pointer}, {integer}, {ip_addr}", + __FUNCTION__, __LINE__, table_name, custom_item->valuestring); goto error; } @@ -142,8 +163,7 @@ void *plugin_schema_new(cJSON *json, struct table_manager *tbl_mgr, MAX_FOREIGN_CLMN_NUM); } else if (custom_item->type == cJSON_Array) { schema->n_foreign = cJSON_GetArraySize(custom_item); - for (int i = 0; i < schema->n_foreign; i++) - { + for (int i = 0; i < schema->n_foreign; i++) { cJSON *foreign_item = cJSON_GetArrayItem(custom_item, i); assert(foreign_item->type == cJSON_Number); schema->foreign_columns[i] = foreign_item->valueint; @@ -197,7 +217,8 @@ int plugin_table_add_callback(void *plugin_schema, int table_id, return 0; } -void plugin_table_all_callback_start(struct plugin_schema *plugin_schema, int update_type) +void plugin_table_all_callback_start(struct plugin_schema *plugin_schema, + int update_type) { for (size_t i = 0; i < plugin_schema->cb_cnt; i++) { if (plugin_schema->cb[i].start != NULL) { @@ -241,8 +262,9 @@ int plugin_table_set_ex_container_schema(void *plugin_schema, int table_id, if (1 == schema->container_schema.set_flag) { log_error(schema->logger, MODULE_PLUGIN, - "[%s:%d] plugin table(table_id:%d) ex_container_schema has been set, can't set again", - __FUNCTION__, __LINE__, table_id); + "[%s:%d] plugin table(table_id:%d) ex_container_schema" + " has been set, can't set again", __FUNCTION__, __LINE__, + table_id); return -1; } @@ -258,7 +280,8 @@ int plugin_table_set_ex_container_schema(void *plugin_schema, int table_id, return 0; } -struct ex_container_schema *plugin_table_get_ex_container_schema(void *plugin_schema) +struct ex_container_schema * +plugin_table_get_ex_container_schema(void *plugin_schema) { struct plugin_schema *schema = (struct plugin_schema *)plugin_schema; @@ -337,7 +360,8 @@ int plugin_runtime_update_row(struct plugin_runtime *plugin_rt, size_t cb_count = plugin_schema->cb_cnt; if (cb_count > 0) { for (size_t i = 0; i < cb_count; i++) { - plugin_schema->cb[i].update(plugin_schema->table_id, row, plugin_schema->cb[i].u_para); + plugin_schema->cb[i].update(plugin_schema->table_id, row, + plugin_schema->cb[i].u_para); } } @@ -356,11 +380,13 @@ int plugin_accept_tag_match(struct plugin_schema *schema, const char *table_name size_t n_tag = table_manager_accept_tags_count(schema->ref_tbl_mgr); if (schema->rule_tag_column > 0 && n_tag > 0) { - int ret = get_column_pos(line, schema->rule_tag_column, &column_offset, &column_len); + int ret = get_column_pos(line, schema->rule_tag_column, &column_offset, + &column_len); if (ret < 0) { log_error(logger, MODULE_PLUGIN, - "[%s:%d] table: <%s> has no rule_tag(column_seq:%d) in table_line:%s", - __FUNCTION__, __LINE__, table_name, schema->rule_tag_column, line); + "[%s:%d] table: <%s> has no rule_tag(column_seq:%d) " + "in table_line:%s", __FUNCTION__, __LINE__, table_name, + schema->rule_tag_column, line); return TAG_MATCH_ERR; } @@ -388,6 +414,97 @@ int plugin_accept_tag_match(struct plugin_schema *schema, const char *table_name return TAG_MATCH_MATCHED; } +int plugin_table_line_get_key(struct plugin_schema *schema, const char *table_name, + const char *line, char *dst_key, size_t *dst_key_len, + struct log_handle *logger) +{ + size_t key_offset = 0, key_len = 0; + + int ret = get_column_pos(line, schema->key_column, &key_offset, &key_len); + if (ret < 0) { + log_error(logger, MODULE_PLUGIN, + "[%s:%d] plugin table:<%s> has no key(column seq:%d)" + " in table_line:%s", __FUNCTION__, __LINE__, table_name, + schema->key_column, line); + return -1; + } + + const char *common_key = line + key_offset; + if (schema->key_type == PLUGIN_KEY_TYPE_POINTER) { + memcpy(dst_key, common_key, key_len); + *dst_key_len = key_len; + } else if (schema->key_type == PLUGIN_KEY_TYPE_INTEGER) { + if (schema->key_len == sizeof(long long)) { + long long key_ll = atoll(common_key); + memcpy(dst_key, (char *)&key_ll, schema->key_len); + } else { + int key_int = atoi(common_key); + memcpy(dst_key, (char *)&key_int, schema->key_len); + } + *dst_key_len = schema->key_len; + } else if (schema->key_type == PLUGIN_KEY_TYPE_IP_ADDR) { + if (key_len >= INET6_ADDRSTRLEN) { + log_error(logger, MODULE_PLUGIN, + "[%s:%d] plugin table:<%s> ip_key too long(illegal) in " + "table_line:%s", __FUNCTION__, __LINE__, table_name, line); + return -1; + } + + size_t addr_type_offset = 0, addr_type_len = 0; + + ret = get_column_pos(line, schema->addr_type_column, &addr_type_offset, + &addr_type_len); + if (ret < 0) { + log_error(logger, MODULE_PLUGIN, + "[%s:%d] plugin table:<%s> has no addr_type(column seq:%d)" + " in table_line:%s", __FUNCTION__, __LINE__, table_name, + schema->addr_type_column, line); + return -1; + } + + char ip_key[INET6_ADDRSTRLEN] = {0}; + //snprintf() write at most (key_len+1) bytes (including the terminating null{'\0}) to ip_key. + snprintf(ip_key, key_len + 1, "%s", common_key); + + int addr_type = atoi(line + addr_type_offset); + if (IPV4 == addr_type) { + uint32_t ipv4_addr; + ret = inet_pton(AF_INET, ip_key, &ipv4_addr); + if (ret <= 0) { + log_error(logger, MODULE_PLUGIN, + "[%s:%d] plugin table:<%s> ipv4 key(column seq:%d)" + " illegal in table_line:%s", __FUNCTION__, __LINE__, + table_name, schema->key_column, line); + return -1; + } + + memcpy(dst_key, (char *)&ipv4_addr, sizeof(ipv4_addr)); + *dst_key_len = sizeof(ipv4_addr); + } else if (IPV6 == addr_type) { + uint8_t ipv6_addr[16]; + ret = inet_pton(AF_INET6, ip_key, ipv6_addr); + if (ret <= 0) { + log_error(logger, MODULE_PLUGIN, + "[%s:%d] plugin table:<%s> ipv6 key(column seq:%d)" + " illegal in table_line:%s", __FUNCTION__, __LINE__, + table_name, schema->key_column, line); + return -1; + } + + memcpy(dst_key, (char *)&ipv6_addr, sizeof(ipv6_addr)); + *dst_key_len = sizeof(ipv6_addr); + } else { + log_error(logger, MODULE_PLUGIN, + "[%s:%d] plugin table:<%s> addr_type:%d illegal, just" + " allow{4, 6}, table_line:%s", __FUNCTION__, __LINE__, + table_name, addr_type, line); + return -1; + } + } + + return 0; +} + int plugin_runtime_update(void *plugin_runtime, void *plugin_schema, const char *table_name, const char *line, int valid_column) @@ -415,21 +532,15 @@ int plugin_runtime_update(void *plugin_runtime, void *plugin_schema, return -1; } - size_t key_offset = 0, key_len = 0; - ret = get_column_pos(line, schema->key_column, &key_offset, &key_len); + char key[MAX_KEYWORDS_STR] = {0}; + size_t key_len = 0; + ret = plugin_table_line_get_key(schema, table_name, line, key, &key_len, + plugin_rt->logger); if (ret < 0) { plugin_rt->update_err_cnt++; return -1; } - long long key_int = 0; - const char *key = line + key_offset; - if (schema->key_type == PLUGIN_KEY_TYPE_INTEGER) { - key_int = atoll(key); - key = (char *)&key_int; - key_len = sizeof(long long); - } - ret = plugin_runtime_update_row(plugin_rt, schema, table_name, line, key, key_len, is_valid); if (ret < 0) { @@ -539,10 +650,10 @@ void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema, struct plugin_runtime *plugin_rt = (struct plugin_runtime *)plugin_runtime; struct plugin_schema *schema = (struct plugin_schema *)plugin_schema; - - if (schema->key_type == PLUGIN_KEY_TYPE_INTEGER) { - key_len = sizeof(long long); + if (schema->key_type == PLUGIN_KEY_TYPE_INTEGER && + schema->key_len != key_len) { + return NULL; } - + return ex_data_runtime_get_ex_data_by_key(plugin_rt->ex_data_rt, key, key_len); } \ No newline at end of file diff --git a/src/maat_table.c b/src/maat_table.c index 53385ac..71167c1 100644 --- a/src/maat_table.c +++ b/src/maat_table.c @@ -367,7 +367,8 @@ static int compare_each_tag(cJSON *tag_obj, const struct rule_tag *accept_tags, } //@param tag_set likes [{"tag":"location","value":["北京/朝阳/华严北里","上海/浦东/陆家嘴"]},{"tag":"isp","value":["电信","移动"]}] -static int compare_each_tag_set(cJSON *tag_set, const struct rule_tag *accept_tags, size_t n_accept_tag) +static int compare_each_tag_set(cJSON *tag_set, const struct rule_tag *accept_tags, + size_t n_accept_tag) { int matched = 0; @@ -433,8 +434,8 @@ error: return ret; } -void *maat_table_schema_new(cJSON *json, const char *table_name, - enum table_type table_type, +void *maat_table_schema_new(cJSON *json, const char *table_name, + enum table_type table_type, struct table_manager *tbl_mgr, struct log_handle *logger) { diff --git a/src/maat_utils.c b/src/maat_utils.c index 84c6391..0edbbae 100644 --- a/src/maat_utils.c +++ b/src/maat_utils.c @@ -296,7 +296,8 @@ int crypt_memory(const unsigned char *inbuf, size_t inlen, unsigned char **pp_ou OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) == 16); /* Now we can set key and IV */ - //It should be set to 1 for encryption, 0 for decryption and -1 to leave the value unchanged (the actual value of 'enc' being supplied in a previous call). + //It should be set to 1 for encryption, 0 for decryption and -1 + //to leave the value unchanged (the actual value of 'enc' being supplied in a previous call). EVP_CipherInit_ex(ctx, NULL, NULL, cipher_key, cipher_iv, -1); int out_blk_len = 0; int out_buff_offset = 0; @@ -389,7 +390,8 @@ int gzip_uncompress(const unsigned char *in_compressed_data, size_t in_compresse break; case Z_BUF_ERROR: buffer_sz *= 2; - *out_uncompressed_data = (unsigned char *)realloc(*out_uncompressed_data, buffer_sz); + *out_uncompressed_data = (unsigned char *)realloc(*out_uncompressed_data, + buffer_sz); memset(*out_uncompressed_data, 0, buffer_sz); break; default: @@ -440,7 +442,7 @@ enum port_format port_format_str2int(const char *format) return PORT_FORMAT_UNKNOWN; } -int ip_format2range(int ip_type, enum ip_format format, const char *ip1, const char *ip2, +int ip_format2range(int ip_type, enum ip_format format, const char *ip1, const char *ip2, uint32_t range_begin[], uint32_t range_end[]) { int cidr = 0; diff --git a/src/maat_virtual.c b/src/maat_virtual.c index 865c8d4..464c407 100644 --- a/src/maat_virtual.c +++ b/src/maat_virtual.c @@ -43,7 +43,7 @@ void *virtual_schema_new(cJSON *json, struct table_manager *tbl_mgr, item = cJSON_GetObjectItem(json, "physical_table"); if (NULL == item || item->type != cJSON_String) { log_error(logger, MODULE_VIRTUAL, - "[%s:%d] virtual table:<%s> schema has no physical_table column", + "[%s:%d] virtual table:<%s> schema has no physical_table column", __FUNCTION__, __LINE__, table_name); goto error; } @@ -51,11 +51,11 @@ void *virtual_schema_new(cJSON *json, struct table_manager *tbl_mgr, schema->physical_table_id = table_manager_get_table_id(tbl_mgr, item->valuestring); if (schema->physical_table_id < 0) { log_error(logger, MODULE_VIRTUAL, - "[%s:%d] virtual table:<%s>'s physical table:<%s> unregistered.", + "[%s:%d] virtual table:<%s>'s physical table:<%s> unregistered.", __FUNCTION__, __LINE__, table_name, item->valuestring); goto error; } - + return schema; error: FREE(schema); diff --git a/test/maat_framework_gtest.cpp b/test/maat_framework_gtest.cpp index d0691e2..f010573 100644 --- a/test/maat_framework_gtest.cpp +++ b/test/maat_framework_gtest.cpp @@ -2594,7 +2594,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, - key1); + key1, strlen(key1)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "Shijiazhuang"); EXPECT_EQ(ud->id, 1); @@ -2602,15 +2602,15 @@ TEST_F(PluginTable, EX_DATA) { const char *key2 = "ShanDong"; ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, - key2); + key2, strlen(key2)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "Jinan"); EXPECT_EQ(ud->id, 3); plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); } -TEST_F(PluginTable, KEY_TYPE) { - const char *table_name = "TEST_PLUGIN_KEY_TYPE_TABLE"; +TEST_F(PluginTable, LONG_KEY_TYPE) { + const char *table_name = "TEST_PLUGIN_LONG_KEY_TYPE_TABLE"; struct maat *maat_instance = PluginTable::_shared_maat_instance; int table_id = maat_get_table_id(maat_instance, table_name); @@ -2628,7 +2628,7 @@ TEST_F(PluginTable, 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, - (char *)&key1); + (char *)&key1, sizeof(long long)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "Shijiazhuang"); EXPECT_EQ(ud->id, 1); @@ -2636,11 +2636,117 @@ TEST_F(PluginTable, KEY_TYPE) { long long key2 = 33333333; ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, - (char *)&key2); + (char *)&key2, sizeof(long long)); ASSERT_TRUE(ud != NULL); EXPECT_STREQ(ud->value, "Jinan"); EXPECT_EQ(ud->id, 3); 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, + (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; + + int table_id = maat_get_table_id(maat_instance, 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, + plugin_EX_new_cb, + plugin_EX_free_cb, + plugin_EX_dup_cb, + 0, &plugin_ex_data_counter); + EXPECT_EQ(ret, 0); + EXPECT_EQ(plugin_ex_data_counter, 4); + + int key1 = 101; + struct plugin_ud *ud = NULL; + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + (char *)&key1, sizeof(key1)); + ASSERT_TRUE(ud != NULL); + EXPECT_STREQ(ud->value, "China"); + EXPECT_EQ(ud->id, 1); + 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, + (char *)&key2, sizeof(key2)); + ASSERT_TRUE(ud != NULL); + EXPECT_STREQ(ud->value, "America"); + EXPECT_EQ(ud->id, 2); + 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, + (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; + + int table_id = maat_get_table_id(maat_instance, 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, + plugin_EX_new_cb, + plugin_EX_free_cb, + plugin_EX_dup_cb, + 0, &plugin_ex_data_counter); + EXPECT_EQ(ret, 0); + EXPECT_EQ(plugin_ex_data_counter, 4); + + uint32_t ipv4_addr1; + ret = inet_pton(AF_INET, "100.64.1.1", &ipv4_addr1); + EXPECT_EQ(ret, 1); + + struct plugin_ud *ud = NULL; + ud = (struct plugin_ud *)maat_plugin_table_get_ex_data(maat_instance, table_id, + (char *)&ipv4_addr1, sizeof(ipv4_addr1)); + ASSERT_TRUE(ud != NULL); + EXPECT_STREQ(ud->value, "XiZang"); + EXPECT_EQ(ud->id, 4); + plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); + + uint32_t ipv4_addr2; + 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, + (char *)&ipv4_addr2, sizeof(ipv4_addr2)); + ASSERT_TRUE(ud != NULL); + EXPECT_STREQ(ud->value, "XinJiang"); + EXPECT_EQ(ud->id, 4); + plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); + + uint8_t ipv6_addr1[16]; + 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, + (char *)ipv6_addr1, sizeof(ipv6_addr1)); + ASSERT_TRUE(ud != NULL); + EXPECT_STREQ(ud->value, "GuiZhou"); + EXPECT_EQ(ud->id, 6); + plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); + + uint8_t ipv6_addr2[16]; + 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, + (char *)ipv6_addr2, sizeof(ipv6_addr2)); + ASSERT_TRUE(ud != NULL); + EXPECT_STREQ(ud->value, "SiChuan"); + EXPECT_EQ(ud->id, 6); + plugin_EX_free_cb(table_id, (void **)&ud, 0, NULL); } class IPPluginTable : public testing::Test @@ -3443,7 +3549,7 @@ TEST_F(Policy, CompileEXData) { EXPECT_EQ(results[0], 198); void *ex_data = maat_plugin_table_get_ex_data(maat_instance, compile_table_id, - (char *)&results[0]); + (char *)&results[0], sizeof(long long)); ASSERT_TRUE(ex_data!=NULL); struct rule_ex_param *param = (struct rule_ex_param *)ex_data; EXPECT_EQ(param->id, 7799); @@ -4898,7 +5004,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, - key1); + key1, strlen(key1)); ASSERT_TRUE(uinfo != NULL); EXPECT_EQ(0, strcmp(uinfo->name, "liuqiangdong")); EXPECT_EQ(uinfo->id, 2); @@ -4916,7 +5022,7 @@ TEST_F(MaatCmdTest, PluginEXData) { 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, - key2); + key2, strlen(key2)); ASSERT_TRUE(uinfo == NULL); } diff --git a/test/maat_json.json b/test/maat_json.json index 28755d9..18de689 100644 --- a/test/maat_json.json +++ b/test/maat_json.json @@ -2970,15 +2970,6 @@ "4\tShanXi\tTaiyuan\t1\t0" ] }, - { - "table_name": "TEST_PLUGIN_KEY_TYPE_TABLE", - "table_content": [ - "1\t11111111\tShijiazhuang\t1\t0", - "2\t22222222\tZhengzhou\t1\t0", - "3\t33333333\tJinan\t1\t0", - "4\t44444444\tTaiyuan\t1\t0" - ] - }, { "table_name": "TEST_EFFECTIVE_RANGE_TABLE", "table_content": [ @@ -3027,6 +3018,35 @@ "305\t0&1&2&3&4&5&6&7\ttunnel5\t1", "306\t101&101\tinvalid\t1" ] + }, + { + "table_name": "TEST_PLUGIN_LONG_KEY_TYPE_TABLE", + "table_content": [ + "1\t11111111\tShijiazhuang\t1\t0", + "2\t22222222\tZhengzhou\t1\t0", + "3\t33333333\tJinan\t1\t0", + "4\t44444444\tTaiyuan\t1\t0" + ] + }, + { + "table_name": "TEST_PLUGIN_INT_KEY_TYPE_TABLE", + "table_content": [ + "1\t101\tChina\t1\t0", + "2\t102\tAmerica\t1\t0", + "3\t103\tRussia\t1\t0", + "4\t104\tJapan\t1\t0" + ] + }, + { + "table_name": "TEST_PLUGIN_IP_KEY_TYPE_TABLE", + "table_content": [ + "4\t100.64.1.1\tXiZang\t1\t0", + "4\t100.64.1.2\tXinJiang\t1\t0", + "6\t2001:da8:205:1::101\tGuiZhou\t1\t0", + "6\t1001:da8:205:1::101\tSiChuan\t1\t0", + "7\t100.64.1.3\tQingHai\t1\t0", + "6\t100.64.1.4\tGanSu\t1\t0" + ] } ] } \ No newline at end of file diff --git a/test/table_info.conf b/test/table_info.conf index 07e0506..dad4167 100644 --- a/test/table_info.conf +++ b/test/table_info.conf @@ -128,6 +128,7 @@ "valid_column":4, "custom": { "key_type":"integer", + "key_len":8, "key":1 } }, @@ -167,6 +168,7 @@ "valid_column":4, "custom": { "key_type":"integer", + "key_len":8, "key":1, "tag":5 } @@ -450,13 +452,37 @@ }, { "table_id":38, - "table_name":"TEST_PLUGIN_KEY_TYPE_TABLE", + "table_name":"TEST_PLUGIN_LONG_KEY_TYPE_TABLE", "table_type":"plugin", "valid_column":4, "custom": { "key_type":"integer", + "key_len":8, "key":2, "tag":5 } + }, + { + "table_id":39, + "table_name":"TEST_PLUGIN_INT_KEY_TYPE_TABLE", + "table_type":"plugin", + "valid_column":4, + "custom": { + "key_type":"integer", + "key_len":4, + "key":2, + "tag":5 + } + }, + { + "table_id":40, + "table_name":"TEST_PLUGIN_IP_KEY_TYPE_TABLE", + "table_type":"plugin", + "valid_column":4, + "custom": { + "key_type":"ip_addr", + "addr_type":1, + "key":2 + } } ] \ No newline at end of file