/// @test Test ironbee library - transformation registration TEST(TestIronBee, test_tfn) { ib_engine_t *ib; ib_status_t rc; ib_tfn_t *tfn = (ib_tfn_t *)-1; ib_flags_t flags; uint8_t data_in[128]; ib_field_t *fin; const ib_field_t *fout; ib_bytestr_t *bs; ibtest_engine_create(&ib); ASSERT_EQ(IB_OK, ib_tfn_register(ib, "foo2bar", foo2bar, IB_TFN_FLAG_NONE, NULL)); ASSERT_EQ(IB_OK, ib_tfn_lookup(ib, "foo2bar", &tfn)); ASSERT_NE((ib_tfn_t *)-1, tfn); ASSERT_TRUE(tfn); ib_bytestr_dup_nulstr(&bs, ib->mp, "foo"); fin = NULL; ib_field_create( &fin, ib->mp, IB_FIELD_NAME("ByteStr"), IB_FTYPE_BYTESTR, ib_ftype_bytestr_in(bs) ); fout = NULL; flags = 0; rc = ib_tfn_transform(ib, ib->mp, tfn, fin, &fout, &flags); ASSERT_EQ(rc, IB_OK); ASSERT_NE((ib_tfn_t *)-1, tfn); ASSERT_TRUE(IB_TFN_CHECK_FMODIFIED(flags)); ASSERT_NE(fin, fout); strcpy((char *)data_in, "foo"); fin = NULL; ib_field_create( &fin, ib->mp, IB_FIELD_NAME("NulStr"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in((char *)data_in) ); fout = NULL; flags = 0; rc = ib_tfn_transform(ib, ib->mp, tfn, fin, &fout, &flags); ASSERT_EQ(rc, IB_OK); ASSERT_NE((ib_tfn_t *)-1, tfn); ASSERT_TRUE(IB_TFN_CHECK_FMODIFIED(flags)); ASSERT_NE(fin, fout); ibtest_engine_destroy(ib); }
TEST_F(TestIBUtilField, AliasBytestr) { const char s1[] = "hello"; const char s2[] = "bye"; ib_field_t *f; const ib_bytestr_t *obs; ib_status_t rc; ib_bytestr_t *bs; uint8_t *copy; copy = (uint8_t *)MemPoolMemDup("x", 1); rc = ib_field_create_bytestr_alias(&f, MemPool(), IB_FIELD_NAME("foo"), copy, 0); ASSERT_EQ(IB_OK, rc); rc = ib_bytestr_dup_nulstr(&bs, MemPool(), s1); ASSERT_EQ(IB_OK, rc); rc = ib_field_setv(f, bs); ASSERT_EQ(IB_OK, rc); rc = ib_field_value(f, ib_ftype_bytestr_out(&obs)); ASSERT_EQ(IB_OK, rc); ASSERT_EQ(strlen(s1), ib_bytestr_length(obs)); ASSERT_EQ(0, memcmp(s1, ib_bytestr_const_ptr(obs), ib_bytestr_length(obs)) ); rc = ib_bytestr_dup_nulstr(&bs, MemPool(), s2); ASSERT_EQ(IB_OK, rc); rc = ib_field_setv(f, bs); ASSERT_EQ(IB_OK, rc); rc = ib_field_value(f, ib_ftype_bytestr_out(&obs)); ASSERT_EQ(IB_OK, rc); ASSERT_EQ(strlen(s2), ib_bytestr_length(obs)); ASSERT_EQ(0, memcmp(s2, ib_bytestr_const_ptr(obs), ib_bytestr_length(obs)) ); }
/// @test Test util field library - ib_field_format() with numeric types TEST_F(TestIBUtilField, test_field_format_num) { ib_field_t *f; ib_status_t rc; char fmtbuf[32]; ib_num_t num; const char *tname; const char *buf; num = -10; rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_num"), IB_FTYPE_NUM, ib_ftype_num_in(&num)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); buf = ib_field_format(f, false, false, &tname, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ("-10", fmtbuf); ASSERT_STREQ("NUM", tname); ASSERT_EQ(buf, fmtbuf); buf = ib_field_format(f, true, true, &tname, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ("-10", fmtbuf); ASSERT_STREQ("NUM", tname); ASSERT_EQ(buf, fmtbuf); }
ib_status_t ib_action_inst_create_ex( ib_engine_t *ib, const char *name, const char *parameters, ib_action_inst_t **act_inst) { assert(ib != NULL); assert(name != NULL); ib_hash_t *action_hash = ib->actions; ib_action_t *action; ib_status_t rc; ib_mpool_t *mpool = ib_engine_pool_main_get(ib); assert(mpool != NULL); rc = ib_hash_get(action_hash, &action, name); if (rc != IB_OK) { /* name is not registered */ return rc; } *act_inst = (ib_action_inst_t *)ib_mpool_alloc(mpool, sizeof(ib_action_inst_t)); if (*act_inst == NULL) { return IB_EALLOC; } (*act_inst)->action = action; (*act_inst)->params = ib_mpool_strdup(mpool, parameters); (*act_inst)->fparam = NULL; if (action->fn_create != NULL) { rc = action->fn_create( ib, parameters, *act_inst, action->cbdata_create ); if (rc != IB_OK) { return rc; } } else { rc = IB_OK; } if ((*act_inst)->fparam == NULL) { rc = ib_field_create(&((*act_inst)->fparam), mpool, IB_FIELD_NAME("param"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(parameters)); } return rc; }
TEST_F(TestIronBeeModuleRulesLua, operator_test) { const ib_operator_t *op; void *instance_data; ib_num_t result; ib_field_t* field1; const char* op_name = "test_module_rules_lua.lua"; const char* rule_name = "luarule001"; char* str1 = (char *)ib_mpool_strdup(ib_engine->mp, "string 1"); ASSERT_TRUE(str1); // Create field 1. ASSERT_EQ(IB_OK, ib_field_create( &field1, ib_engine->mp, IB_FIELD_NAME("field1"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(str1) ) ); /* Configure the operator. */ configureIronBee(); // Ensure that the operator exists. ASSERT_EQ(IB_OK, ib_operator_lookup(ib_engine, op_name, &op) ); ASSERT_EQ(IB_OK, ib_operator_inst_create(op, ib_context_main(ib_engine), IB_OP_CAPABILITY_NON_STREAM, rule_name, &instance_data)); performTx(); // Attempt to match. ASSERT_EQ(IB_OK, ib_operator_inst_execute(op, instance_data, ib_tx, field1, NULL, &result)); // This time we should succeed. ASSERT_TRUE(result); }
/// @test Test util field library - ib_field_create() ib_field_create() TEST_F(TestIBUtilField, test_field_create) { ib_field_t *f; ib_status_t rc; const char *nulstrval = "TestValue"; ib_num_t numval = 5; ib_bytestr_t *bytestrval; const char *nulout; const char *nulcopy; nulcopy = MemPoolStrDup(nulstrval); ASSERT_STRNE(NULL, nulcopy); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_nulstr"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(nulcopy)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(11UL, f->nlen); ASSERT_EQ(0, memcmp("test_nulstr", f->name, 11)); rc = ib_field_value(f, ib_ftype_nulstr_out(&nulout)); ASSERT_EQ(IB_OK, rc); ASSERT_STREQ(nulstrval, nulout); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_num"), IB_FTYPE_NUM, ib_ftype_num_in(&numval)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(8UL, f->nlen); ASSERT_EQ(0, memcmp("test_num", f->name, 8)); rc = ib_bytestr_dup_mem(&bytestrval, MemPool(), (uint8_t *)nulstrval, strlen(nulstrval)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_bytestr"), IB_FTYPE_BYTESTR, ib_ftype_bytestr_in(bytestrval)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(12UL, f->nlen); ASSERT_EQ(0, memcmp("test_bytestr", f->name, 12)); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_nulstr_ex"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(nulstrval)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_num_ex"), IB_FTYPE_NUM, ib_ftype_num_in(&numval)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_bytestr_ex"), IB_FTYPE_BYTESTR, ib_ftype_bytestr_in(bytestrval)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); }
/// @test Test util field library - ib_field_from_string() TEST_F(TestIBUtilField, test_field_from_string) { ib_field_t *f; ib_status_t rc; ib_num_t fnum; ib_float_t ffloat; const char *fnulstr; rc = ib_field_from_string(MemPool(), IB_FIELD_NAME("test_num"), "11", &f); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(IB_FTYPE_NUM, f->type); ASSERT_EQ(IB_OK, ib_field_value(f, ib_ftype_num_out(&fnum))); ASSERT_EQ(11, fnum); rc = ib_field_from_string(MemPool(), IB_FIELD_NAME("test_num"), "-11", &f); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(IB_FTYPE_NUM, f->type); ASSERT_EQ(IB_OK, ib_field_value(f, ib_ftype_num_out(&fnum))); ASSERT_EQ(-11, fnum); rc = ib_field_from_string(MemPool(), IB_FIELD_NAME("test_float"), "1.0", &f); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(IB_FTYPE_FLOAT, f->type); ASSERT_EQ(IB_OK, ib_field_value(f, ib_ftype_float_out(&ffloat))); ASSERT_EQ(1.0, ffloat); rc = ib_field_from_string(MemPool(), IB_FIELD_NAME("test_num"), "-1.0", &f); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(IB_FTYPE_FLOAT, f->type); ASSERT_EQ(IB_OK, ib_field_value(f, ib_ftype_float_out(&ffloat))); ASSERT_EQ(-1.0, ffloat); rc = ib_field_from_string(MemPool(), IB_FIELD_NAME("test_str"), "x", &f); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(IB_FTYPE_NULSTR, f->type); ASSERT_EQ(IB_OK, ib_field_value(f, ib_ftype_nulstr_out(&fnulstr))); ASSERT_STREQ("x", fnulstr); rc = ib_field_from_string(MemPool(), IB_FIELD_NAME("test_str"), "-1.1x", &f); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); ASSERT_EQ(IB_FTYPE_NULSTR, f->type); ASSERT_EQ(IB_OK, ib_field_value(f, ib_ftype_nulstr_out(&fnulstr))); ASSERT_STREQ("-1.1x", fnulstr); }
TEST_F(CoreOperatorsTest, NeTest) { ib_status_t status; ib_num_t call_result; ib_operator_inst_t *op; ib_rule_t *rule = NULL; /* Not used by this operator. */ status = ib_operator_inst_create(ib_engine, NULL, rule, IB_OP_FLAG_PHASE, "ne", "1", IB_OPINST_FLAG_NONE, &op); ASSERT_EQ(IB_OK, status); // call contains ib_field_t *field; const ib_num_t matching = 2; const ib_num_t nonmatching = 1; ib_field_create( &field, ib_engine_pool_main_get(ib_engine), IB_FIELD_NAME("testfield"), IB_FTYPE_NUM, ib_ftype_num_in(&matching) ); ib_rule_exec_t rule_exec; memset(&rule_exec, 0, sizeof(rule_exec)); rule_exec.ib = ib_engine; rule_exec.tx = ib_tx; rule_exec.rule = rule; ib_field_setv(field, ib_ftype_num_in(&matching)); status = ib_operator_execute(&rule_exec, op, field, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(1, call_result); ib_field_setv(field, ib_ftype_num_in(&nonmatching)); status = ib_operator_execute(&rule_exec, op, field, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(0, call_result); }
TEST_F(CoreOperatorsTest, ContainsTest) { ib_status_t status; ib_num_t call_result; ib_operator_inst_t *op; ib_rule_t *rule = NULL; /* Not used by this operator. */ status = ib_operator_inst_create(ib_engine, NULL, rule, IB_OP_FLAG_PHASE, "contains", "needle", IB_OPINST_FLAG_NONE, &op); ASSERT_EQ(IB_OK, status); // call contains ib_field_t *field; const char *matching = "data with needle in it"; const char *nonmatching = "non matching string"; ib_field_create( &field, ib_engine_pool_main_get(ib_engine), IB_FIELD_NAME("testfield"), IB_FTYPE_NULSTR, NULL ); ib_rule_exec_t rule_exec; memset(&rule_exec, 0, sizeof(rule_exec)); rule_exec.ib = ib_engine; rule_exec.rule = rule; ib_field_setv(field, ib_ftype_nulstr_in(matching)); status = ib_operator_execute(&rule_exec, op, field, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(1, call_result); ib_field_setv(field, ib_ftype_nulstr_in(nonmatching)); status = ib_operator_execute(&rule_exec, op, field, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(0, call_result); }
/** * Store a field in the agent list * * Creates a new field and adds it to the agent list field list. * * @param[in] ib IronBee object * @param[in,out] mp Memory pool to allocate from * @param[in] agent_list Field to add the field to * @param[in] name Field name * @param[in] value Field value * * @returns Status code */ static ib_status_t modua_store_field(ib_engine_t *ib, ib_mpool_t *mp, ib_field_t *agent_list, const char *name, const char *value) { IB_FTRACE_INIT(); ib_field_t *tmp_field = NULL; ib_status_t rc = IB_OK; /* No value? Do nothing */ if (value == NULL) { ib_log_debug3(ib, "No %s field in user agent", name); IB_FTRACE_RET_STATUS(IB_OK); } /* Create the field */ rc = ib_field_create( &tmp_field, mp, IB_FIELD_NAME(name), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(value) ); if (rc != IB_OK) { ib_log_alert(ib, "Error creating user agent %s field: %s", name, ib_status_to_string(rc)); IB_FTRACE_RET_STATUS(rc); } /* Add the field to the list */ rc = ib_field_list_add(agent_list, tmp_field); if (rc != IB_OK) { ib_log_alert(ib, "Error adding user agent %s field: %s", name, ib_status_to_string(rc)); IB_FTRACE_RET_STATUS(rc); } ib_log_debug3(ib, "Stored user agent %s '%s'", name, value); IB_FTRACE_RET_STATUS(IB_OK); }
TEST_F(CoreOperatorsTest, ContainsTest) { ib_status_t status; ib_num_t call_result; const ib_operator_t *op; void *instance_data; status = ib_operator_lookup(ib_engine, "contains", &op); ASSERT_EQ(IB_OK, status); status = ib_operator_inst_create(op, ib_context_main(ib_engine), IB_OP_CAPABILITY_NON_STREAM, "needle", &instance_data); ASSERT_EQ(IB_OK, status); // call contains ib_field_t *field; const char *matching = "data with needle in it"; const char *nonmatching = "non matching string"; ib_field_create( &field, ib_engine_pool_main_get(ib_engine), IB_FIELD_NAME("testfield"), IB_FTYPE_NULSTR, NULL ); ib_field_setv(field, ib_ftype_nulstr_in(matching)); status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(1, call_result); ib_field_setv(field, ib_ftype_nulstr_in(nonmatching)); status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(0, call_result); }
TEST_F(CoreOperatorsTest, NeTest) { ib_status_t status; ib_num_t call_result; const ib_operator_t *op; void *instance_data; status = ib_operator_lookup(ib_engine, "ne", &op); ASSERT_EQ(IB_OK, status); status = ib_operator_inst_create(op, ib_context_main(ib_engine), IB_OP_CAPABILITY_NON_STREAM, "1", &instance_data); ASSERT_EQ(IB_OK, status); // call contains ib_field_t *field; const ib_num_t matching = 2; const ib_num_t nonmatching = 1; ib_field_create( &field, ib_engine_pool_main_get(ib_engine), IB_FIELD_NAME("testfield"), IB_FTYPE_NUM, ib_ftype_num_in(&matching) ); ib_field_setv(field, ib_ftype_num_in(&matching)); status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(1, call_result); ib_field_setv(field, ib_ftype_num_in(&nonmatching)); status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(0, call_result); }
/** * Lookup the IP address in the GeoIP database * * @param[in] ib IronBee engine * @param[in] tx Transaction * @param[in] event Event * @param[in] data callback data (Module configuration) */ static ib_status_t geoip_lookup( ib_engine_t *ib, ib_tx_t *tx, ib_state_event_type_t event, void *data ) { assert(ib != NULL); assert(event == handle_context_tx_event); assert(data != NULL); const char *ip = tx->er_ipstr; const module_data_t *mod_data = (const module_data_t *)data; if (ip == NULL) { ib_log_alert_tx(tx, "Trying to lookup NULL IP in GEOIP"); return IB_EINVAL; } #ifdef GEOIP_HAVE_VERSION /** * Some configurations exist as single characters and must be converted to * a string. This is simply a place to assemble that string before * it is passed into ip_data_add_nulstr. * This is only needed if we have support confidence items. WAM */ char one_char_str[2] = { '\0', '\0' }; #endif /* GEOIP_HAVE_VERSION */ ib_status_t rc; /* Declare and initialize the GeoIP property list. * Regardless of if we find a record or not, we want to create the list * artifact so that later modules know we ran and did [not] find a * record. */ ib_field_t *geoip_lst = NULL; ib_field_t *tmp_field = NULL; /* Id of geo ip record to read. */ int geoip_id; ib_log_debug_tx(tx, "GeoIP Lookup '%s'", ip); /* Build a new list. */ rc = ib_var_source_initialize( mod_data->geoip_source, &geoip_lst, tx->var_store, IB_FTYPE_LIST ); /* NOTICE: Called before GeoIP_record_by_addr allocates a * GeoIPRecord. */ if (rc != IB_OK) { ib_log_alert_tx(tx, "Unable to add GEOIP var."); return IB_EINVAL; } if (mod_data->geoip_db == NULL) { ib_log_alert_tx(tx, "GeoIP database was never opened. Perhaps the " "configuration file needs a GeoIPDatabaseFile " "\"/usr/share/geoip/GeoLite.dat\" line?"); return IB_EINVAL; } geoip_id = GeoIP_id_by_addr(mod_data->geoip_db, ip); if (geoip_id > 0) { const char *tmp_str; ib_log_debug_tx(tx, "GeoIP record found."); /* Add integers. */ tmp_field = NULL; tmp_str = GeoIP_code_by_id(geoip_id); if (tmp_str) { ib_field_create(&tmp_field, tx->mp, IB_FIELD_NAME("country_code"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(tmp_str)); ib_field_list_add(geoip_lst, tmp_field); } tmp_str = GeoIP_code3_by_id(geoip_id); if (tmp_str) { ib_field_create(&tmp_field, tx->mp, IB_FIELD_NAME("country_code3"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(tmp_str)); ib_field_list_add(geoip_lst, tmp_field); } tmp_str = GeoIP_country_name_by_id(mod_data->geoip_db, geoip_id); if (tmp_str) { ib_field_create(&tmp_field, tx->mp, IB_FIELD_NAME("country_name"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(tmp_str)); ib_field_list_add(geoip_lst, tmp_field); } tmp_str = GeoIP_continent_by_id(geoip_id); if (tmp_str) { ib_field_create(&tmp_field, tx->mp, IB_FIELD_NAME("continent_code"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(tmp_str)); ib_field_list_add(geoip_lst, tmp_field); } } else { ib_log_debug_tx(tx, "No GeoIP record found."); ib_field_create(&tmp_field, tx->mp, IB_FIELD_NAME("country_code"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in("O1")); ib_field_list_add(geoip_lst, tmp_field); ib_field_create(&tmp_field, tx->mp, IB_FIELD_NAME("country_code3"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in("O01")); ib_field_list_add(geoip_lst, tmp_field); ib_field_create(&tmp_field, tx->mp, IB_FIELD_NAME("country_name"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in("Other Country")); ib_field_list_add(geoip_lst, tmp_field); ib_field_create(&tmp_field, tx->mp, IB_FIELD_NAME("continent_code"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in("O1")); ib_field_list_add(geoip_lst, tmp_field); } return IB_OK; }
/// @test Test ironbee library - data provider TEST(TestIronBee, test_data_dynf) { ib_engine_t *ib; ib_data_config_t *dataconfig; ib_data_t *data; ib_field_t *dynf; ib_field_t *f; ib_field_t *f2; ib_status_t rc; ib_num_t n; ib_list_t* l; ibtest_engine_create(&ib); ASSERT_EQ(IB_OK, ib_data_config_create(ib_engine_pool_main_get(ib), & dataconfig)); ASSERT_EQ(IB_OK, ib_data_create(dataconfig, ib_engine_pool_main_get(ib), &data)); ASSERT_TRUE(data); /* Create a field with no initial value. */ ASSERT_EQ( IB_OK, ib_field_create_dynamic( &dynf, ib_engine_pool_main_get(ib), IB_FIELD_NAME("test_dynf"), IB_FTYPE_LIST, dyn_get, (void *)ib_engine_pool_main_get(ib), NULL, NULL ) ); ASSERT_TRUE(dynf); ASSERT_EQ(9UL, dynf->nlen); ASSERT_MEMEQ("test_dynf", dynf->name, 9); /* Add the field to the data store. */ ASSERT_EQ(IB_OK, ib_data_add(data, dynf)); /* Fetch the field from the data store */ ASSERT_EQ(IB_OK, ib_data_get(data, "test_dynf", &f)); ASSERT_TRUE(f); ASSERT_EQ(dynf, f); /* Fetch a dynamic field from the data store */ ASSERT_EQ(IB_OK, ib_data_get(data, "test_dynf:dyn_subkey", &f)); ASSERT_TRUE(f); ASSERT_EQ(9UL, f->nlen); /* Get the list value from the dynamic field. */ rc = ib_field_mutable_value(f, ib_ftype_list_mutable_out(&l)); ASSERT_EQ(IB_OK, rc); ASSERT_EQ(1UL, ib_list_elements(l)); /* Get the single value from the list. */ f2 = (ib_field_t *)ib_list_node_data(ib_list_first(l)); ASSERT_TRUE(f2); ASSERT_EQ(10UL, f2->nlen); rc = ib_field_value(f2, ib_ftype_num_out(&n)); ASSERT_EQ(IB_OK, rc); ASSERT_EQ(5, n); /* Fetch a another subkey */ ASSERT_EQ(IB_OK, ib_data_get(data, "test_dynf:dyn_subkey2", &f)); ASSERT_TRUE(f); ASSERT_EQ(9UL, f->nlen); /* Get the list value from the dynamic field. */ rc = ib_field_mutable_value(f, ib_ftype_list_mutable_out(&l)); ASSERT_EQ(IB_OK, rc); ASSERT_EQ(1UL, ib_list_elements(l)); /* Get the single value from the list. */ f2 = (ib_field_t *)ib_list_node_data(ib_list_first(l)); ASSERT_TRUE(f2); ASSERT_EQ(11UL, f2->nlen); rc = ib_field_value(f2, ib_ftype_num_out(&n)); ASSERT_EQ(IB_OK, rc); ASSERT_EQ(5, n); ibtest_engine_destroy(ib); }
TEST_F(OperatorTest, OperatorCallTest) { ib_status_t status; ib_num_t call_result; ib_rule_t *rule = NULL; /* Unused by this operator. */ ib_operator_inst_t *op; status = ib_operator_register(ib_engine, "test_op", IB_OP_FLAG_PHASE, test_create_fn, NULL, test_destroy_fn, NULL, test_execute_fn, NULL); ASSERT_EQ(IB_OK, status); status = ib_operator_inst_create(ib_engine, NULL, rule, IB_OP_FLAG_PHASE, "test_op", "INVALID", IB_OPINST_FLAG_NONE, &op); ASSERT_EQ(IB_EINVAL, status); status = ib_operator_inst_create(ib_engine, NULL, rule, IB_OP_FLAG_PHASE, "test_op", "data", IB_OPINST_FLAG_NONE, &op); ASSERT_EQ(IB_OK, status); ib_rule_exec_t rule_exec; memset(&rule_exec, 0, sizeof(rule_exec)); rule_exec.ib = ib_engine; rule_exec.rule = rule; ib_field_t *field; const char *matching = "data matching string"; const char *nonmatching = "non matching string"; ib_field_create( &field, ib_engine_pool_main_get(ib_engine), IB_FIELD_NAME("testfield"), IB_FTYPE_NULSTR, NULL ); ib_field_setv(field, ib_ftype_nulstr_in(matching)); status = ib_operator_execute(&rule_exec, op, field, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(1, call_result); ib_field_setv(field, ib_ftype_nulstr_in(nonmatching)); status = ib_operator_execute(&rule_exec, op, field, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(0, call_result); status = ib_operator_inst_destroy(op); ASSERT_EQ(IB_OK, status); }
/// @test Test util field library - ib_field_format() with bytestr TEST_F(TestIBUtilField, test_field_format_bytestr) { ib_field_t *f; ib_status_t rc; char fmtbuf[32]; const uint8_t in1[] = "a\0b"; const uint8_t in2[] = "\fabcd\0efghijk\t"; size_t size; ib_bytestr_t *bs; const char *tname; const char *buf; size = sizeof(in1) - 1; rc = ib_bytestr_dup_mem(&bs, MemPool(), in1, size); ASSERT_EQ(IB_OK, rc); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_bytestr"), IB_FTYPE_BYTESTR, ib_ftype_bytestr_in(bs)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f != NULL); buf = ib_field_format(f, false, false, &tname, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ((const char *)in1, fmtbuf); ASSERT_STREQ("BYTESTR", tname); ASSERT_EQ(buf, fmtbuf); buf = ib_field_format(f, false, true, &tname, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ("a\\u0000b", fmtbuf); ASSERT_STREQ("BYTESTR", tname); ASSERT_EQ(buf, fmtbuf); buf = ib_field_format(f, true, true, &tname, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ("\"a\\u0000b\"", fmtbuf); ASSERT_STREQ("BYTESTR", tname); ASSERT_EQ(buf, fmtbuf); size = sizeof(in2) - 1; rc = ib_bytestr_dup_mem(&bs, MemPool(), in2, size); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f != NULL); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_bytestr"), IB_FTYPE_BYTESTR, ib_ftype_bytestr_in(bs)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); buf = ib_field_format(f, false, false, NULL, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ((const char *)in2, fmtbuf); ASSERT_EQ(buf, fmtbuf); buf = ib_field_format(f, true, false, NULL, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ("\"\fabcd\"", fmtbuf); ASSERT_EQ(buf, fmtbuf); buf = ib_field_format(f, false, true, NULL, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ("\\fabcd\\u0000efghijk\\t", fmtbuf); ASSERT_EQ(buf, fmtbuf); buf = ib_field_format(f, true, true, NULL, fmtbuf, sizeof(fmtbuf)); ASSERT_STREQ("\"\\fabcd\\u0000efghijk\\t\"", fmtbuf); ASSERT_EQ(buf, fmtbuf); }
/** * Handle managed collection registration for vars "name=value" parameters * * @param[in] ib Engine * @param[in] module Collection manager's module object (unused) * @param[in] manager The collection manager object to register with (unused) * @param[in] mp Memory pool to use for allocations * @param[in] collection_name Name of the collection * @param[in] uri Full collection URI (unused) * @param[in] uri_scheme URI scheme (unused) * @param[in] uri_data Hierarchical/data part of the URI * @param[in] params List of parameter strings * @param[in] register_data Register callback data (unused) * @param[out] pmanager_inst_data Pointer to manager specific collection data * * @returns Status code: * - IB_OK All OK * - IB_Exxx Other error */ static ib_status_t core_managed_collection_vars_register_fn( const ib_engine_t *ib, const ib_module_t *module, const ib_collection_manager_t *manager, ib_mpool_t *mp, const char *collection_name, const char *uri, const char *uri_scheme, const char *uri_data, const ib_list_t *params, void *register_data, void **pmanager_inst_data) { assert(ib != NULL); assert(module != NULL); assert(mp != NULL); assert(collection_name != NULL); assert(params != NULL); assert(pmanager_inst_data != NULL); const ib_list_node_t *node; ib_list_t *vars_list; ib_list_t *field_list; ib_mpool_t *tmp = ib_engine_pool_temp_get(ib); ib_status_t rc; if (strlen(uri_data) != 0) { return IB_DECLINED; } if (ib_list_elements(params) < 1) { return IB_EINVAL; } /* Create a temporary list */ rc = ib_list_create(&vars_list, tmp); if (rc != IB_OK) { return rc; } /* First pass; walk through all params, look for "a=b" type syntax */ IB_LIST_LOOP_CONST(params, node) { static const int ovecsize = 9; int ovector[ovecsize]; const char *param = (const char *)node->data; core_vars_t *vars; int pcre_rc; pcre_rc = pcre_exec(core_vars_manager.pattern, NULL, param, strlen(param), 0, 0, ovector, ovecsize); if (pcre_rc < 0) { return IB_DECLINED; } vars = ib_mpool_alloc(tmp, sizeof(*vars)); if (vars == NULL) { return IB_EALLOC; } vars->name = ib_mpool_memdup_to_str(tmp, param + ovector[2], ovector[3] - ovector[2]); vars->value = ib_mpool_memdup_to_str(tmp, param + ovector[4], ovector[5] - ovector[4]); if ( (vars->name == NULL) || (vars->value == NULL) ) { return IB_EALLOC; } rc = ib_list_push(vars_list, vars); if (rc != IB_OK) { return rc; } } /* Build the list of fields */ rc = ib_list_create(&field_list, mp); if (rc != IB_OK) { return rc; } /* Now walk though the list, creating a field for each one */ IB_LIST_LOOP_CONST(vars_list, node) { const core_vars_t *vars = (const core_vars_t *)node->data; ib_field_t *field; ib_field_val_union_t fval; rc = ib_field_from_string(mp, IB_FIELD_NAME(vars->name), vars->value, &field, &fval); if (rc != IB_OK) { ib_log_error(ib, "Error creating field (\"%s\", \"%s\"): %s", vars->name, vars->value, ib_status_to_string(rc)); return rc; } rc = ib_list_push(field_list, field); if (rc != IB_OK) { return rc; } if (field->type == IB_FTYPE_NUM) { ib_log_trace(ib, "Created numeric field \"%s\" %"PRId64" in \"%s\"", vars->name, fval.num, collection_name); } else if (field->type == IB_FTYPE_FLOAT) { ib_log_trace(ib, "Created float field \"%s\" %f in \"%s\"", vars->name, (double)fval.fnum, collection_name); } else { ib_log_trace(ib, "Created string field \"%s\" \"%s\" in \"%s\"", vars->name, fval.nulstr, collection_name); } } /* Finally, store the list as the manager specific collection data */ *pmanager_inst_data = field_list; return IB_OK; }
///@test Test util field library - ib_field_dyn_register_get() TEST_F(TestIBUtilField, test_dyn_field) { ib_field_t *dynf; ib_field_t *cdynf; ib_status_t rc; const char *fval; /* Create a field with no initial value. */ rc = ib_field_create_dynamic( &dynf, MemPool(), IB_FIELD_NAME("test_dynf"), IB_FTYPE_NULSTR, dyn_get, (void *)"dynf_get", dyn_set, (void *)"dynf_set" ); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(dynf); ASSERT_EQ(9UL, dynf->nlen); ASSERT_EQ(0, memcmp("test_dynf", dynf->name, 9)); /* Get the value from the dynamic field. */ rc = ib_field_value_ex(dynf, ib_ftype_nulstr_out(&fval), (void *)"fetch1", 6 ); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(fval); ASSERT_EQ( std::string("testval_dynf_get_fetch1_call01"), fval ); /* Get the value from the dynamic field again. */ rc = ib_field_value_ex(dynf, ib_ftype_nulstr_out(&fval), (void *)"fetch2", 6 ); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(fval); ASSERT_EQ( std::string("testval_dynf_get_fetch2_call02"), fval ); /* Set */ rc = ib_field_setv_ex(dynf, (void *)"val1", (void *)"set1", 4); ASSERT_EQ(IB_OK, rc); ASSERT_EQ(std::string("testval_dynf_set_set1_val1_call03"), g_dyn_call_val); /* Reset call counter. */ g_dyn_call_count = 0; /* Create another field with no initial value. */ rc = ib_field_create_dynamic( &cdynf, MemPool(), IB_FIELD_NAME("test_cdynf"), IB_FTYPE_NULSTR, dyn_get_cached, (void *)("cdynf_get"), dyn_set, NULL ); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(cdynf); ASSERT_EQ(10UL, cdynf->nlen); ASSERT_EQ(0, memcmp("test_cdynf", cdynf->name, 10)); /* Get the value from the dynamic field. */ rc = ib_field_value_ex(cdynf, ib_ftype_nulstr_out(&fval), (void *)"fetch1", 6 ); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(fval); ASSERT_EQ( std::string("testval_cdynf_get_fetch1_call01"), fval ); /* Get the value from the dynamic field again. */ rc = ib_field_value_ex(cdynf, ib_ftype_nulstr_out(&fval), NULL, 0 ); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(fval); ASSERT_EQ( std::string("testval_cdynf_get_fetch1_call01"), fval ); }
/** * Length transformation * * @param[in] ib IronBee engine * @param[in] mp Memory pool to use for allocations. * @param[in] fndata Function specific data. * @param[in] fin Input field. * @param[out] fout Output field. * @param[out] pflags Transformation flags. * * @returns IB_OK if successful. */ static ib_status_t tfn_length(ib_engine_t *ib, ib_mpool_t *mp, void *fndata, const ib_field_t *fin, ib_field_t **fout, ib_flags_t *pflags) { IB_FTRACE_INIT(); ib_status_t rc = IB_OK; assert(mp != NULL); assert(fin != NULL); assert(fout != NULL); assert(pflags != NULL); /** * This works on C-style (NUL terminated) and byte strings. Note * that data is assumed to be a NUL terminated string (because our * configuration parser can't produce anything else). **/ if (fin->type == IB_FTYPE_NULSTR) { const char *fval; rc = ib_field_value(fin, ib_ftype_nulstr_out(&fval)); if (rc != IB_OK) { IB_FTRACE_RET_STATUS(rc); } const ib_unum_t len = strlen(fval); rc = ib_field_create( fout, mp, IB_FIELD_NAME("Length"), IB_FTYPE_UNUM, ib_ftype_unum_in(&len) ); } else if (fin->type == IB_FTYPE_BYTESTR) { const ib_bytestr_t *value; rc = ib_field_value(fin, ib_ftype_bytestr_out(&value)); if (rc != IB_OK) { IB_FTRACE_RET_STATUS(rc); } const ib_unum_t len = ib_bytestr_length(value); rc = ib_field_create( fout, mp, IB_FIELD_NAME("Length"), IB_FTYPE_UNUM, ib_ftype_unum_in(&len) ); } else if (fin->type == IB_FTYPE_LIST) { const ib_list_node_t *node = NULL; const ib_list_t *ilist; /** Incoming list */ /* Get the incoming list */ // @todo Remove mutable once list is const correct. rc = ib_field_value(fin, ib_ftype_list_out(&ilist)); if (rc != IB_OK) { IB_FTRACE_RET_STATUS(rc); } if (ilist == NULL) { IB_FTRACE_RET_STATUS(IB_EUNKNOWN); } /* Create the outgoing list field */ rc = ib_field_create( fout, mp, IB_FIELD_NAME("Length"), IB_FTYPE_LIST, NULL ); if (rc != IB_OK) { IB_FTRACE_RET_STATUS(rc); } /* Walk through the incoming fields */ IB_LIST_LOOP_CONST(ilist, node) { const ib_field_t *ifield = (ib_field_t *)node->data; ib_field_t *ofield = NULL; ib_flags_t flags = 0; rc = tfn_length(ib, mp, NULL, ifield, &ofield, &flags); if (rc != IB_OK) { IB_FTRACE_RET_STATUS(rc); } rc = ib_field_list_add(*fout, ofield); if (rc != IB_OK) { IB_FTRACE_RET_STATUS(rc); } } } else {
TEST_F(OperatorTest, OperatorCallTest) { ib_status_t status; ib_num_t call_result; void *instance_data; ib_operator_t *op; const ib_operator_t *cop; status = ib_operator_create_and_register( &op, ib_engine, "test_op", IB_OP_CAPABILITY_NON_STREAM, test_create_fn, NULL, NULL, NULL, test_execute_fn, NULL ); ASSERT_EQ(IB_OK, status); status = ib_operator_lookup(ib_engine, "test_op", &cop); ASSERT_EQ(IB_OK, status); status = ib_operator_inst_create(op, ib_context_main(ib_engine), IB_OP_CAPABILITY_NON_STREAM, "INVALID", &instance_data); ASSERT_EQ(IB_EINVAL, status); status = ib_operator_inst_create(op, ib_context_main(ib_engine), IB_OP_CAPABILITY_NON_STREAM, "data", &instance_data); ASSERT_EQ(IB_OK, status); ib_field_t *field; const char *matching = "data matching string"; const char *nonmatching = "non matching string"; ib_field_create( &field, ib_engine_pool_main_get(ib_engine), IB_FIELD_NAME("testfield"), IB_FTYPE_NULSTR, NULL ); ib_field_setv(field, ib_ftype_nulstr_in(matching)); status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(1, call_result); ib_field_setv(field, ib_ftype_nulstr_in(nonmatching)); status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result); ASSERT_EQ(IB_OK, status); EXPECT_EQ(0, call_result); status = ib_operator_inst_destroy(op, instance_data); ASSERT_EQ(IB_OK, status); }
/** * Length transformation * * @param[in] mp Memory pool to use for allocations. * @param[in] fin Input field. * @param[out] fout Output field. This is NULL on error. * @param[in] fndata Callback data * * @returns IB_OK if successful. */ static ib_status_t tfn_length(ib_mpool_t *mp, const ib_field_t *fin, const ib_field_t **fout, void *fndata) { assert(mp != NULL); assert(fin != NULL); assert(fout != NULL); ib_status_t rc = IB_OK; ib_field_t *fnew; /* Initialize the output field pointer */ *fout = NULL; /** * This works on C-style (NUL terminated) and byte strings. Note * that data is assumed to be a NUL terminated string (because our * configuration parser can't produce anything else). **/ if (fin->type == IB_FTYPE_NULSTR) { const char *fval; rc = ib_field_value(fin, ib_ftype_nulstr_out(&fval)); if (rc != IB_OK) { return rc; } const ib_num_t len = strlen(fval); rc = ib_field_create( &fnew, mp, IB_FIELD_NAME("Length"), IB_FTYPE_NUM, ib_ftype_num_in(&len) ); } else if (fin->type == IB_FTYPE_BYTESTR) { const ib_bytestr_t *value; rc = ib_field_value(fin, ib_ftype_bytestr_out(&value)); if (rc != IB_OK) { return rc; } const ib_num_t len = ib_bytestr_length(value); rc = ib_field_create( &fnew, mp, IB_FIELD_NAME("Length"), IB_FTYPE_NUM, ib_ftype_num_in(&len) ); } else if (fin->type == IB_FTYPE_LIST) { const ib_list_node_t *node = NULL; const ib_list_t *ilist; /** Incoming list */ /* Get the incoming list */ // @todo Remove mutable once list is const correct. rc = ib_field_value(fin, ib_ftype_list_out(&ilist)); if (rc != IB_OK) { return rc; } if (ilist == NULL) { return IB_EUNKNOWN; } /* Create the outgoing list field */ rc = ib_field_create( &fnew, mp, IB_FIELD_NAME("Length"), IB_FTYPE_LIST, NULL ); if (rc != IB_OK) { return rc; } /* Walk through the incoming fields */ IB_LIST_LOOP_CONST(ilist, node) { const ib_field_t *ifield = (ib_field_t *)node->data; const ib_field_t *ofield = NULL; rc = tfn_length(mp, ifield, &ofield, NULL); if (rc != IB_OK) { return rc; } rc = ib_field_list_add_const(fnew, ofield); if (rc != IB_OK) { return rc; } } } else {
/// @test Test util field library - ib_field_format() with nulstr TEST_F(TestIBUtilField, test_field_format_nulstr) { ib_field_t *f; ib_status_t rc; char fmtbuf1[8]; char fmtbuf2[32]; const char *nul1 = "\"a\n\""; const char *nul2 = "\fabcdefghijk\t"; const char *tname; const char *buf; char *nulcopy; nulcopy = MemPoolStrDup(nul1); ASSERT_STRNE(NULL, nulcopy); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_nulstr"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(nulcopy)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); buf = ib_field_format(f, false, false, &tname, fmtbuf1, sizeof(fmtbuf1)); ASSERT_STREQ(nul1, fmtbuf1); ASSERT_STREQ("NULSTR", tname); ASSERT_EQ(buf, fmtbuf1); buf = ib_field_format(f, true, false, &tname, fmtbuf1, sizeof(fmtbuf1)); ASSERT_STREQ("\"\"a\n\"\"", fmtbuf1); ASSERT_STREQ("NULSTR", tname); ASSERT_EQ(buf, fmtbuf1); buf = ib_field_format(f, true, true, &tname, fmtbuf1, sizeof(fmtbuf1)); ASSERT_STREQ("\"\\\"a\\n\"", fmtbuf1); ASSERT_STREQ("NULSTR", tname); ASSERT_EQ(buf, fmtbuf1); nulcopy = MemPoolStrDup(nul2); ASSERT_STRNE(NULL, nulcopy); rc = ib_field_create(&f, MemPool(), IB_FIELD_NAME("test_nulstr"), IB_FTYPE_NULSTR, ib_ftype_nulstr_in(nulcopy)); ASSERT_EQ(IB_OK, rc); ASSERT_TRUE(f); buf = ib_field_format(f, false, false, NULL, fmtbuf1, sizeof(fmtbuf1)); ASSERT_STREQ("\fabcdef", fmtbuf1); ASSERT_EQ(buf, fmtbuf1); buf = ib_field_format(f, false, false, NULL, fmtbuf2, sizeof(fmtbuf2)); ASSERT_STREQ(nul2, fmtbuf2); ASSERT_EQ(buf, fmtbuf2); buf = ib_field_format(f, true, false, NULL, fmtbuf2, sizeof(fmtbuf2)); ASSERT_STREQ("\"\fabcdefghijk\t\"", fmtbuf2); ASSERT_EQ(buf, fmtbuf2); buf = ib_field_format(f, false, true, NULL, fmtbuf2, sizeof(fmtbuf2)); ASSERT_STREQ("\\fabcdefghijk\\t", fmtbuf2); ASSERT_EQ(buf, fmtbuf2); buf = ib_field_format(f, true, true, NULL, fmtbuf2, sizeof(fmtbuf2)); ASSERT_STREQ("\"\\fabcdefghijk\\t\"", fmtbuf2); ASSERT_EQ(buf, fmtbuf2); }