gfwleak/tango-maat
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix hit repeated compile_id bug & unify compile+plugin table register API

Browse Source
This commit is contained in:
liuwentan
2023-03-01 13:12:22 +08:00
parent 1566a30002
commit 2c6cca6f56
8 changed files with 236 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/maat.h
View File

@@ -95,15 +95,6 @@ int maat_table_callback_register(struct maat *instance, int table_id,
maat_finish_callback_t *finish,
void *u_para);
/* maat compile table API */
int maat_compile_table_ex_schema_register(struct maat *instance, 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 *maat_compile_table_get_ex_data(struct maat *instance, int compile_table_id,
long long compile_id);
/* maat plugin table API */
int maat_plugin_table_ex_schema_register(struct maat *instance, int table_id,
maat_ex_new_func_t *new_func,
@@ -112,7 +103,8 @@ int maat_plugin_table_ex_schema_register(struct maat *instance, int table_id,
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. */
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,

9
src/inc_internal/maat_compile.h
View File

@@ -42,8 +42,6 @@ int compile_table_set_ex_data_schema(struct compile_schema *compile_schema, int
maat_ex_dup_func_t *dup_func,
long argl, void *argp,
struct log_handle *logger);
void *compile_table_get_ex_data(struct compile_schema *compile_schema, long long compile_id);
void compile_table_ex_data_iterate(struct compile_schema *compile_schema);
/* compile runtime API */
void *compile_runtime_new(void *compile_schema, int max_thread_num,
@@ -63,6 +61,13 @@ size_t compile_runtime_get_hit_paths(struct compile_runtime *compile_rt,
struct maat_compile_state *compile_state,
struct maat_hit_path *hit_paths,
size_t hit_path_index, size_t n_hit_path);
void *compile_runtime_get_ex_data(struct compile_runtime *compile_rt,
struct compile_schema *compile_schema,
long long compile_id);
void compile_runtime_ex_data_iterate(struct compile_runtime *compile_rt,
struct compile_schema *compile_schema);
/* group2compile runtime API */
void *group2compile_runtime_new(void *g2c_schema, int max_thread_num,
struct maat_garbage_bin *garbage_bin,

3
src/inc_internal/maat_plugin.h
View File

@@ -64,7 +64,8 @@ size_t plugin_runtime_cached_row_count(void *plugin_runtime);
const char *plugin_runtime_cached_row_get(void *plugin_runtime, size_t index);
void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema, const char *key);
void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema,
const char *key, size_t key_len);
#ifdef __cplusplus
}

125
src/maat_api.c
View File

@@ -458,66 +458,38 @@ int maat_table_callback_register(struct maat *maat_instance, int table_id,
return 0;
}
int maat_compile_table_ex_schema_register(struct maat *maat_instance, int table_id,
int compile_table_ex_schema_register(struct maat *maat_instance, 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)
{
if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM) {
return -1;
}
void *schema = table_manager_get_schema(maat_instance->tbl_mgr, table_id);
assert(schema != NULL);
enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, table_id);
if (table_type != TABLE_TYPE_COMPILE) {
log_error(maat_instance->logger, MODULE_MAAT_API,
"table(tabld_id:%d) is not compile table", table_id);
return -1;
}
void *compile_schema = table_manager_get_schema(maat_instance->tbl_mgr, table_id);
assert(compile_schema != NULL);
pthread_mutex_lock(&(maat_instance->background_update_mutex));
int ret = compile_table_set_ex_data_schema((struct compile_schema *)compile_schema, table_id,
new_func, free_func, dup_func,
int ret = compile_table_set_ex_data_schema((struct compile_schema *)schema,
table_id, new_func, free_func, dup_func,
argl, argp, maat_instance->logger);
if (ret < 0) {
pthread_mutex_unlock(&(maat_instance->background_update_mutex));
return -1;
}
if (maat_instance->maat_rt != NULL) {
compile_table_ex_data_iterate((struct compile_schema *)compile_schema);
void *runtime = table_manager_get_runtime(maat_instance->tbl_mgr, table_id);
assert(runtime != NULL);
compile_runtime_ex_data_iterate((struct compile_runtime *)runtime,
(struct compile_schema *)schema);
}
pthread_mutex_unlock(&(maat_instance->background_update_mutex));
return 0;
}
void *maat_compile_table_get_ex_data(struct maat *maat_instance, int compile_table_id,
long long compile_id)
{
struct compile_schema *schema = (struct compile_schema *)table_manager_get_schema(maat_instance->tbl_mgr,
compile_table_id);
enum table_type table_type = table_manager_get_table_type(maat_instance->tbl_mgr, compile_table_id);
assert(table_type == TABLE_TYPE_COMPILE);
return compile_table_get_ex_data(schema, compile_id);
}
int generic_plugin_table_ex_schema_register(struct table_manager *tbl_mgr, int table_id,
int generic_plugin_table_set_ex_schema(struct table_manager *tbl_mgr, 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, struct log_handle *logger)
{
if (NULL == tbl_mgr || NULL == new_func || NULL == free_func || NULL == dup_func) {
assert(0);
log_error(logger, MODULE_MAAT_API,
"table(table_id:%d) %s failed: invalid parameter", __FUNCTION__);
return -1;
}
void *schema = table_manager_get_schema(tbl_mgr, table_id);
if (NULL == schema) {
log_error(logger, MODULE_MAAT_API,
@@ -574,7 +546,10 @@ int generic_plugin_table_ex_schema_register(struct table_manager *tbl_mgr, int t
dup_func, argl, argp, logger);
break;
default:
break;
log_error(logger, MODULE_MAAT_API,
"Error: %s, table(table_id:%d) is not plugin table, can't set ex schema",
__FUNCTION__, table_id);
return -1;
}
return 0;
@@ -653,22 +628,16 @@ void generic_plugin_runtime_commit_ex_schema(void *runtime, void *schema, int ta
}
}
int maat_plugin_table_ex_schema_register(struct maat *maat_instance, int table_id,
int generic_plugin_table_ex_schema_register(struct maat *maat_instance, 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)
{
if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM) {
return -1;
}
pthread_mutex_lock(&(maat_instance->background_update_mutex));
int ret = generic_plugin_table_ex_schema_register(maat_instance->tbl_mgr, table_id,
int ret = generic_plugin_table_set_ex_schema(maat_instance->tbl_mgr, table_id,
new_func, free_func, dup_func,
argl, argp, maat_instance->logger);
if (ret < 0) {
pthread_mutex_unlock(&(maat_instance->background_update_mutex));
return -1;
}
@@ -683,34 +652,80 @@ int maat_plugin_table_ex_schema_register(struct maat *maat_instance, int table_i
valid_column = table_manager_get_valid_column(maat_instance->tbl_mgr, table_id);
generic_plugin_runtime_commit_ex_schema(runtime, schema, table_id, table_type, valid_column);
}
pthread_mutex_unlock(&(maat_instance->background_update_mutex));
return 0;
}
void *maat_plugin_table_get_ex_data(struct maat *maat_instance, int table_id, const char *key)
int maat_plugin_table_ex_schema_register(struct maat *maat_instance, 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)
{
if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM) {
return -1;
}
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);
if (TABLE_TYPE_COMPILE == table_type) {
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_id,
new_func, free_func, dup_func,
argl, argp);
}
pthread_mutex_unlock(&(maat_instance->background_update_mutex));
return ret;
}
void *maat_plugin_table_get_ex_data(struct maat *maat_instance, int table_id,
const char *key, size_t key_len)
{
if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM || NULL == key) {
if (NULL == maat_instance || table_id < 0 || table_id >= MAX_TABLE_NUM
|| NULL == key || 0 == key_len) {
log_error(maat_instance->logger, MODULE_MAAT_API,
"input parameter is invalid.");
return NULL;
}
struct maat_runtime *maat_rt = maat_instance->maat_rt;
if (NULL == maat_rt) {
log_error(maat_instance->logger, MODULE_MAAT_API, "maat runtime is NULL");
return NULL;
}
void *plugin_rt = table_manager_get_runtime(maat_rt->ref_tbl_mgr, table_id);
if (NULL == plugin_rt) {
void *runtime = table_manager_get_runtime(maat_rt->ref_tbl_mgr, table_id);
if (NULL == runtime) {
log_error(maat_instance->logger, MODULE_MAAT_API,
"table(table_id:%d) runtime is NULL", table_id);
return NULL;
}
void *plugin_schema = table_manager_get_schema(maat_rt->ref_tbl_mgr, table_id);
if (NULL == plugin_schema) {
void *schema = table_manager_get_schema(maat_rt->ref_tbl_mgr, table_id);
if (NULL == schema) {
log_error(maat_instance->logger, MODULE_MAAT_API,
"table(table_id:%d) schema is NULL", table_id);
return NULL;
}
return plugin_runtime_get_ex_data(plugin_rt, plugin_schema, key);
void *ret = NULL;
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, key_len);
} else {
return NULL;
}
return ret;
}
int maat_ip_plugin_table_get_ex_data(struct maat *maat_instance, int table_id,

122
src/maat_compile.c
View File

@@ -163,9 +163,7 @@ int compile_table_set_ex_data_schema(struct compile_schema *compile_schema,
return -1;
}
//compile_schema->ex_schema[idx].table_id = table_id;
compile_schema->ex_schema = ALLOC(struct ex_data_schema, 1);
compile_schema->ex_schema->argl = argl;
compile_schema->ex_schema->argp = argp;
compile_schema->ex_schema->new_func = new_func;
@@ -237,46 +235,6 @@ void compile_runtime_user_data_iterate(struct compile_runtime *compile_rt,
pthread_rwlock_unlock(&compile_rt->rwlock);
}
void compile_table_ex_data_iterate(struct compile_schema *compile_schema)
{
if (NULL == compile_schema) {
return;
}
if (NULL == compile_schema->ex_schema) {
return;
}
struct ex_data_schema *ex_schema = compile_schema->ex_schema;
struct compile_runtime *compile_rt = NULL;
compile_rt = (struct compile_runtime *)table_manager_get_runtime(compile_schema->ref_tbl_mgr,
compile_schema->table_id);
compile_runtime_user_data_iterate(compile_rt, rule_ex_data_new_cb, ex_schema, compile_schema->table_id);
}
void *compile_table_get_ex_data(struct compile_schema *compile_schema, long long compile_id)
{
if (NULL == compile_schema) {
return NULL;
}
struct compile_rule *compile_rule = NULL;
struct compile_runtime *compile_rt = NULL;
compile_rt = (struct compile_runtime *)table_manager_get_runtime(compile_schema->ref_tbl_mgr,
compile_schema->table_id);
compile_rule = (struct compile_rule *)compile_runtime_get_user_data(compile_rt, compile_id, 0);
if (NULL == compile_rule) {
return NULL;
}
void *ex_data = NULL;
struct ex_data_schema *ex_schema = compile_schema->ex_schema;
ex_schema->dup_func(compile_schema->table_id, &ex_data, compile_rule->ex_data, ex_schema->argl, ex_schema->argp);
return ex_data;
}
UT_icd ut_literal_id_icd = {sizeof(struct maat_literal_id), NULL, NULL, NULL};
UT_icd ut_clause_id_icd = {sizeof(long long), NULL, NULL, NULL};
UT_icd ut_hit_path_icd = {sizeof(struct maat_internal_hit_path), NULL, NULL, NULL};
@@ -997,7 +955,7 @@ maat_compile_bool_matcher_new(struct maat_compile *compile_hash,
#if 0
struct maat_literal_id *p = NULL;
for(p = (struct maat_literal_id *)utarray_front(compile->clause_states[i].literal_ids); p!=NULL; p=(struct maat_literal_id *)utarray_next(compile->clause_states[i].literal_ids,p)) {
printf("compile_id:%llu, clause_id:%llu, literal{%llu: %d}\n",
printf("<before bool_matcher_new> compile_id:%llu, clause_id:%llu, literal{%llu: %d}\n",
compile->compile_id, compile->clause_states[i].clause_id, p->group_id, p->vtable_id);
}
#endif
@@ -1063,6 +1021,43 @@ void maat_compile_bool_matcher_free(struct bool_matcher *bm)
bool_matcher_free(bm);
}
static int maat_compile_has_clause(struct maat_compile *compile,
unsigned long long clause_id)
{
struct maat_clause_state *clause_state = NULL;
for (size_t i = 0; i < MAX_ITEMS_PER_BOOL_EXPR; i++) {
clause_state = compile->clause_states + i;
if (!clause_state->in_use) {
continue;
}
if (clause_state->clause_id == clause_id) {
return 1;
}
}
return 0;
}
static size_t compile_state_if_new_hit_compile(struct maat_compile_state *compile_state,
struct maat_compile *compile)
{
size_t r_in_c_cnt = 0;
int ret = 0;
unsigned long long new_hit_clause_id = 0;
for (size_t i = 0; i < utarray_len(compile_state->this_scan_hit_clauses); i++) {
new_hit_clause_id = *(unsigned long long*)utarray_eltptr(compile_state->this_scan_hit_clauses, i);
ret = maat_compile_has_clause(compile, new_hit_clause_id);
if (ret) {
r_in_c_cnt++;
}
}
return r_in_c_cnt;
}
size_t maat_compile_bool_matcher_match(struct bool_matcher *bm, int is_last_scan,
struct maat_compile_state *compile_state,
void **user_data_array, size_t ud_array_size)
@@ -1092,16 +1087,22 @@ size_t maat_compile_bool_matcher_match(struct bool_matcher *bm, int is_last_scan
continue;
}
size_t n_new_hit_compile = compile_state_if_new_hit_compile(compile_state, compile);
size_t n_this_scan_hit_item = compile_state->this_scan_hit_item_cnt;
if ((compile->not_clause_cnt > 0) && (LAST_SCAN_UNSET == is_last_scan)) {
compile_state->not_clause_hitted_flag = 1;
}
//TODO: not_clause
if (compile->user_data) {
if (n_new_hit_compile > 0 || 0 == n_this_scan_hit_item) {
/* compile hit because of new item or
hit a compile that refer a NOT-logic group in previous scan */
user_data_array[ud_result_cnt] = compile->user_data;
ud_result_cnt++;
}
}
}
compile_state->this_scan_hit_item_cnt = 0;
return ud_result_cnt;
@@ -1461,6 +1462,41 @@ void destroy_compile_rule(struct compile_rule *compile_rule)
FREE(compile_rule);
}
void compile_runtime_ex_data_iterate(struct compile_runtime *compile_rt,
struct compile_schema *compile_schema)
{
if (NULL == compile_rt || NULL == compile_schema ||
NULL == compile_schema->ex_schema) {
return;
}
compile_runtime_user_data_iterate(compile_rt, rule_ex_data_new_cb,
compile_schema->ex_schema,
compile_schema->table_id);
}
void *compile_runtime_get_ex_data(struct compile_runtime *compile_rt,
struct compile_schema *compile_schema,
long long compile_id)
{
if (NULL == compile_rt || NULL == compile_schema || compile_id < 0) {
return NULL;
}
struct compile_rule *compile_rule = NULL;
compile_rule = (struct compile_rule *)compile_runtime_get_user_data(compile_rt, compile_id, 0);
if (NULL == compile_rule) {
return NULL;
}
void *ex_data = NULL;
struct ex_data_schema *ex_schema = compile_schema->ex_schema;
ex_schema->dup_func(compile_schema->table_id, &ex_data, compile_rule->ex_data,
ex_schema->argl, ex_schema->argp);
return ex_data;
}
int compile_runtime_update(void *compile_runtime, void *compile_schema,
const char *line, int valid_column)
{

5
src/maat_plugin.c
View File

@@ -438,7 +438,8 @@ const char *plugin_runtime_cached_row_get(void *plugin_runtime, size_t index)
return ex_data_runtime_cached_row_get(plugin_rt->ex_data_rt, index);
}
void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema, const char *key)
void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema,
const char *key, size_t key_len)
{
if (NULL == plugin_runtime || NULL == plugin_schema) {
return NULL;
@@ -450,5 +451,5 @@ void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema, cons
return NULL;
}
return ex_data_runtime_get_ex_data_by_key(plugin_rt->ex_data_rt, key, strlen(key));
return ex_data_runtime_get_ex_data_by_key(plugin_rt->ex_data_rt, key, key_len);
}

2
src/maat_table.c
View File

@@ -54,7 +54,6 @@ struct table_manager {
int default_compile_table_id;
int g2g_table_id;
struct maat_kv_store *tablename2id_map;
struct maat_kv_store *district_map;
struct maat_kv_store *tmp_district_map;
uint32_t district_num;
@@ -597,7 +596,6 @@ void table_manager_destroy(struct table_manager *tbl_mgr)
FREE(tbl_mgr->accept_tags);
maat_kv_store_free(tbl_mgr->tablename2id_map);
FREE(tbl_mgr);
}

66
test/maat_framework_gtest.cpp
View File

@@ -125,10 +125,50 @@ TEST_F(MaatFlagScan, hitMultiCompile) {
EXPECT_EQ(results[0], 194);
EXPECT_EQ(results[1], 192);
// memset(results, 0, sizeof(results));
// ret = maat_scan_flag(g_maat_instance, flag_table_id, 0, flag_scan_data, results,
// ARRAY_SIZE, &n_hit_result, &state);
// EXPECT_EQ(ret, MAAT_SCAN_OK);
memset(results, 0, sizeof(results));
ret = maat_scan_flag(g_maat_instance, flag_table_id, 0, flag_scan_data, results,
ARRAY_SIZE, &n_hit_result, &state);
EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT);
struct maat_hit_path hit_path[HIT_PATH_SIZE] = {0};
int n_read = 0;
n_read = maat_state_get_hit_paths(g_maat_instance, &state, hit_path, HIT_PATH_SIZE);
EXPECT_NE(n_read, 0);
maat_state_free(&state);
}
TEST_F(MaatFlagScan, hitRepeatedCompile) {
const char *flag_table_name = "FLAG_CONFIG";
int flag_table_id = maat_table_get_id(g_maat_instance, flag_table_name);
long long results[ARRAY_SIZE] = {0};
size_t n_hit_result = 0;
struct maat_state *state = NULL;
//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(g_maat_instance, flag_table_id, 0, flag_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], 192);
//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
long long flag_scan_data2 = 21;
memset(results, 0, sizeof(results));
ret = maat_scan_flag(g_maat_instance, flag_table_id, 0, 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(g_maat_instance, flag_table_id, 0, flag_scan_data2, results,
ARRAY_SIZE, &n_hit_result, &state);
EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT);
struct maat_hit_path hit_path[HIT_PATH_SIZE] = {0};
int n_read = 0;
@@ -1197,7 +1237,7 @@ TEST_F(CompileTable, CompileEXData) {
int compile_table_id = maat_table_get_id(g_maat_instance, compile_table_name);
int ex_data_counter = 0;
int ret = maat_compile_table_ex_schema_register(g_maat_instance, compile_table_id,
int ret = maat_plugin_table_ex_schema_register(g_maat_instance, compile_table_id,
compile_ex_param_new,
compile_ex_param_free,
compile_ex_param_dup,
@@ -1210,7 +1250,8 @@ TEST_F(CompileTable, CompileEXData) {
EXPECT_EQ(n_hit_result, 1);
EXPECT_EQ(results[0], 141);
void *ex_data = maat_compile_table_get_ex_data(g_maat_instance, compile_table_id, results[0]);
void *ex_data = maat_plugin_table_get_ex_data(g_maat_instance, 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;
EXPECT_EQ(param->id, 7799);
@@ -1358,7 +1399,7 @@ TEST_F(Policy, CompileEXData) {
int ex_data_counter = 0;
int compile_table_id = maat_table_get_id(g_maat_instance, "COMPILE");
int ret = maat_compile_table_ex_schema_register(g_maat_instance, compile_table_id,
int ret = maat_plugin_table_ex_schema_register(g_maat_instance, compile_table_id,
compile_ex_param_new,
compile_ex_param_free,
compile_ex_param_dup,
@@ -1371,7 +1412,8 @@ TEST_F(Policy, CompileEXData) {
EXPECT_EQ(ret, MAAT_SCAN_HIT);
EXPECT_EQ(results[0], 141);
void *ex_data = maat_compile_table_get_ex_data(g_maat_instance, compile_table_id, results[0]);
void *ex_data = maat_plugin_table_get_ex_data(g_maat_instance, 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;
@@ -1523,7 +1565,9 @@ TEST_F(MaatCmdTest, PluginEXData) {
EXPECT_EQ(ex_data_counter, TEST_CMD_LINE_NUM);
struct user_info *uinfo = NULL;
uinfo = (struct user_info *)maat_plugin_table_get_ex_data(g_maat_instance, table_id, "192.168.0.4");
const char *key1 = "192.168.0.4";
uinfo = (struct user_info *)maat_plugin_table_get_ex_data(g_maat_instance, table_id,
key1, strlen(key1));
ASSERT_TRUE(uinfo != NULL);
EXPECT_EQ(0, strcmp(uinfo->name, "liuqiangdong"));
EXPECT_EQ(uinfo->id, 2);
@@ -1533,7 +1577,9 @@ TEST_F(MaatCmdTest, PluginEXData) {
EXPECT_GT(ret, 0);
sleep(1);
uinfo = (struct user_info *)maat_plugin_table_get_ex_data(g_maat_instance, table_id, "192.168.0.2");
const char *key2 = "192.168.0.2";
uinfo = (struct user_info *)maat_plugin_table_get_ex_data(g_maat_instance, table_id,
key2, strlen(key2));
ASSERT_TRUE(uinfo == NULL);
}
#endif