/// @test Test util list library - IB_LIST_LOOP()
TEST_F(TestIBUtilList, test_list_loop)
{
ib_list_t *list;
ib_list_node_t *node;
ib_status_t rc;
int init[] = { 0, 1, 2, 3, 4 };
int *val;
int i;
rc = ib_list_create(&list, MemPool());
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(list);
ASSERT_EQ(0UL, ib_list_elements(list));
for (i = 0; i < 5; i++) {
rc = ib_list_push(list, &init[i]);
ASSERT_EQ(IB_OK, rc);
}
ASSERT_EQ(5UL, ib_list_elements(list));
i = 0;
IB_LIST_LOOP(list, node) {
val = (int *)ib_list_node_data(node);
ASSERT_EQ(init[i], *val);
i++;
}
ib_status_t DLL_PUBLIC ib_cfgparser_block_pop(ib_cfgparser_t *cp,
const char **pname)
{
IB_FTRACE_INIT(ib_cfgparser_block_pop);
ib_engine_t *ib = cp->ib;
const char *name;
ib_status_t rc;
if (pname != NULL) {
*pname = NULL;
}
rc = ib_list_pop(cp->block, &name);
if (rc != IB_OK) {
ib_log_error(ib, 4, "Failed to pop block: %d", rc);
cp->cur_blkname = NULL;
IB_FTRACE_RET_STATUS(rc);
}
if (pname != NULL) {
*pname = name;
}
/* The last in the list is now the current. */
cp->cur_blkname = (const char *)ib_list_node_data(ib_list_last(cp->block));
IB_FTRACE_RET_STATUS(IB_OK);
}
ib_status_t ib_cfgparser_context_pop(ib_cfgparser_t *cp,
ib_context_t **pctx)
{
IB_FTRACE_INIT(ib_cfgparser_context_pop);
ib_engine_t *ib = cp->ib;
ib_context_t *ctx;
ib_status_t rc;
if (pctx != NULL) {
*pctx = NULL;
}
/* Remove the last item. */
rc = ib_list_pop(cp->stack, &ctx);
if (rc != IB_OK) {
ib_log_error(ib, 4, "Failed to pop context: %d", rc);
IB_FTRACE_RET_STATUS(rc);
}
if (pctx != NULL) {
*pctx = ctx;
}
/* The last in the list is now the current. */
ctx = (ib_context_t *)ib_list_node_data(ib_list_last(cp->stack));
cfgp_set_current(cp, ctx);
ib_log_debug(ib, 9, "Stack: ctx=%p site=%p(%s) loc=%p(%s)",
cp->cur_ctx,
cp->cur_site, cp->cur_site?cp->cur_site->name:"NONE",
cp->cur_loc, cp->cur_loc?cp->cur_loc->path:"/");
IB_FTRACE_RET_STATUS(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);
}
/*********************************
* Helper Functions
*********************************/
static
ib_status_t sqli_create_pattern_set_from_file(
sqli_pattern_set_t **out_ps,
const char *path,
ib_mpool_t *mp
)
{
assert(out_ps != NULL);
assert(path != NULL);
assert(mp != NULL);
ib_status_t rc;
FILE *fp = NULL;
char *buffer = NULL;
size_t buffer_size = 0;
ib_list_t *items = NULL;
ib_list_node_t *n = NULL;
ib_mpool_t *tmp = NULL;
sqli_pattern_set_t *ps = NULL;
size_t i = 0;
/* Temporary memory pool for this function only. */
rc = ib_mpool_create(&tmp, "sqli tmp", NULL);
assert(rc == IB_OK);
assert(tmp != NULL);
fp = fopen(path, "r");
if (fp == NULL) {
goto fail;
}
rc = ib_list_create(&items, tmp);
assert(rc == IB_OK);
assert(items != NULL);
for (;;) {
char *buffer_copy;
int read = getline(&buffer, &buffer_size, fp);
if (read == -1) {
if (! feof(fp)) {
fclose(fp);
goto fail;
}
else {
break;
}
}
buffer_copy = ib_mpool_memdup(mp, buffer, read);
assert(buffer_copy != NULL);
while (buffer_copy[read-1] == '\n' || buffer_copy[read-1] == '\r') {
buffer_copy[read-1] = '\0';
--read;
}
rc = ib_list_push(items, (void *)buffer_copy);
assert(rc == IB_OK);
}
fclose(fp);
ps = ib_mpool_alloc(mp, sizeof(*ps));
assert(ps != NULL);
ps->num_patterns = ib_list_elements(items);
ps->patterns =
ib_mpool_alloc(mp, ps->num_patterns * sizeof(*ps->patterns));
assert(ps->patterns != NULL);
i = 0;
IB_LIST_LOOP(items, n) {
ps->patterns[i] = ib_list_node_data(n);
++i;
}
/**
* @internal
* Handle signature execution.
*
* @param ib Engine
* @param tx Transaction
* @param cbdata Phase passed as pointer value
*
* @return Status code
*/
static ib_status_t pocsig_handle_sigs(ib_engine_t *ib,
ib_tx_t *tx,
void *cbdata)
{
IB_FTRACE_INIT(pocsig_handle_post);
pocsig_cfg_t *cfg;
pocsig_phase_t phase = (pocsig_phase_t)(uintptr_t)cbdata;
ib_list_t *sigs;
ib_list_node_t *node;
int dbglvl;
ib_status_t rc;
/* Get the pocsig configuration for this context. */
rc = ib_context_module_config(tx->ctx, IB_MODULE_STRUCT_PTR, (void *)&cfg);
if (rc != IB_OK) {
ib_log_error(ib, 1, "Failed to fetch %s config: %d",
MODULE_NAME_STR, rc);
}
/* If tracing is enabled, lower the log level. */
dbglvl = cfg->trace ? 4 : 9;
/* Get the list of sigs for this phase. */
sigs = cfg->phase[phase];
if (sigs == NULL) {
ib_log_debug(ib, dbglvl, "No signatures for phase=%d ctx=%p",
phase, tx->ctx);
IB_FTRACE_RET_STATUS(IB_OK);
}
ib_log_debug(ib, dbglvl, "Executing %d signatures for phase=%d ctx=%p",
ib_list_elements(sigs), phase, tx->ctx);
/* Run all the sigs for this phase. */
IB_LIST_LOOP(sigs, node) {
pocsig_sig_t *s = (pocsig_sig_t *)ib_list_node_data(node);
ib_field_t *f;
/* Fetch the field. */
rc = ib_data_get(tx->dpi, s->target, &f);
if (rc != IB_OK) {
ib_log_error(ib, 4, "PocSig: No field named \"%s\"", s->target);
continue;
}
/* Perform the match. */
ib_log_debug(ib, dbglvl, "PocSig: Matching \"%s\" against field \"%s\"",
s->patt, s->target);
rc = ib_matcher_match_field(cfg->pcre, s->cpatt, 0, f, NULL);
if (rc == IB_OK) {
ib_logevent_t *e;
ib_log_debug(ib, dbglvl, "PocSig MATCH: %s at %s", s->patt, s->target);
/* Create the event. */
rc = ib_logevent_create(
&e,
tx->mp,
"-",
IB_LEVENT_TYPE_ALERT,
IB_LEVENT_ACT_UNKNOWN,
IB_LEVENT_PCLASS_UNKNOWN,
IB_LEVENT_SCLASS_UNKNOWN,
90,
80,
IB_LEVENT_SYS_UNKNOWN,
IB_LEVENT_ACTION_IGNORE,
IB_LEVENT_ACTION_IGNORE,
s->emsg
);
if (rc != IB_OK) {
ib_log_error(ib, 3, "PocSig: Error generating event: %d", rc);
continue;
}
/* Log the event. */
ib_clog_event(tx->ctx, e);
}
else {
ib_log_debug(ib, dbglvl, "PocSig NOMATCH");
}
}
/*
* Callback used to generate request header fields.
*/
static ib_status_t core_gen_request_header_fields(ib_engine_t *ib,
ib_tx_t *tx,
ib_state_event_type_t event,
void *cbdata)
{
ib_field_t *f;
ib_status_t rc;
assert(ib != NULL);
assert(tx != NULL);
assert(event == request_header_finished_event);
/**
* Alias connection remote and server addresses
*/
rc = ib_data_get(tx->conn->data, "server_addr", &f);
if (rc != IB_OK) {
return rc;
}
rc = ib_data_add(tx->data, f);
if (rc != IB_OK) {
return rc;
}
rc = ib_data_get(tx->conn->data, "server_port", &f);
if (rc != IB_OK) {
return rc;
}
rc = ib_data_add(tx->data, f);
if (rc != IB_OK) {
return rc;
}
rc = ib_data_get(tx->conn->data, "remote_addr", &f);
if (rc != IB_OK) {
return rc;
}
rc = ib_data_add(tx->data, f);
if (rc != IB_OK) {
return rc;
}
rc = ib_data_get(tx->conn->data, "remote_port", &f);
if (rc != IB_OK) {
return rc;
}
rc = ib_data_add(tx->data, f);
if (rc != IB_OK) {
return rc;
}
core_gen_tx_numeric_field(tx, "conn_tx_count",
tx->conn->tx_count);
if (tx->request_line != NULL) {
core_gen_tx_bytestr_alias_field(tx, "request_line",
tx->request_line->raw);
core_gen_tx_bytestr_alias_field(tx, "request_method",
tx->request_line->method);
core_gen_tx_bytestr_alias_field(tx, "request_uri_raw",
tx->request_line->uri);
core_gen_tx_bytestr_alias_field(tx, "request_protocol",
tx->request_line->protocol);
}
/* Populate the ARGS collection. */
rc = ib_data_get(tx->data, "ARGS", &f);
if (rc == IB_OK) {
ib_field_t *param_list;
/* Add request URI parameters to ARGS collection. */
rc = ib_data_get(tx->data, "request_uri_params", ¶m_list);
if (rc == IB_OK) {
ib_list_t *field_list;
ib_list_node_t *node = NULL;
rc = ib_field_mutable_value(
param_list,
ib_ftype_list_mutable_out(&field_list)
);
if (rc != IB_OK) {
return rc;
}
IB_LIST_LOOP(field_list, node) {
ib_field_t *param = (ib_field_t *)ib_list_node_data(node);
/* Add the field to the ARGS collection. */
rc = ib_field_list_add(f, param);
if (rc != IB_OK) {
ib_log_notice_tx(tx,
"Failed to add parameter to "
"ARGS collection: %s",
ib_status_to_string(rc));
}
}
/// @test Test util list library - ib_list_push() and ib_list_pop()
TEST_F(TestIBUtilList, test_list_push_and_pop)
{
ib_list_t *list;
ib_status_t rc;
int v0 = 0;
int v1 = 1;
int v2 = 2;
int v3 = 3;
int v4 = 4;
int *val;
rc = ib_list_create(&list, MemPool());
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(list);
ASSERT_EQ(0UL, ib_list_elements(list));
/* Pop invalid. */
rc = ib_list_pop(list,(void *)&val);
ASSERT_EQ(IB_ENOENT, rc);
ASSERT_FALSE(val);
ASSERT_EQ(0UL, ib_list_elements(list));
/* Simple pushes followed by pops. */
rc = ib_list_push(list, &v0);
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(1UL, ib_list_elements(list));
rc = ib_list_push(list, &v1);
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(2UL, ib_list_elements(list));
rc = ib_list_push(list, &v2);
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(3UL, ib_list_elements(list));
rc = ib_list_push(list, &v3);
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(4UL, ib_list_elements(list));
rc = ib_list_push(list, &v4);
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(5UL, ib_list_elements(list));
ASSERT_EQ(v0, *(int *)(ib_list_node_data(ib_list_first(list))));
ASSERT_EQ(v4, *(int *)(ib_list_node_data(ib_list_last(list))));
rc = ib_list_pop(list, (void *)&val);
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(val);
ASSERT_EQ(v4, *val);
ASSERT_EQ(4UL, ib_list_elements(list));
rc = ib_list_pop(list, (void *)&val);
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(val);
ASSERT_EQ(v3, *val);
ASSERT_EQ(3UL, ib_list_elements(list));
rc = ib_list_pop(list, (void *)&val);
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(val);
ASSERT_EQ(v2, *val);
ASSERT_EQ(2UL, ib_list_elements(list));
rc = ib_list_pop(list, (void *)&val);
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(val);
ASSERT_EQ(v1, *val);
ASSERT_EQ(1UL, ib_list_elements(list));
rc = ib_list_pop(list, (void *)&val);
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(val);
ASSERT_EQ(v0, *val);
ASSERT_EQ(0UL, ib_list_elements(list));
}
ib_status_t ib_config_directive_process(ib_cfgparser_t *cp,
const char *name,
ib_list_t *args)
{
IB_FTRACE_INIT(ib_config_directive_process);
ib_engine_t *ib = cp->ib;
ib_dirmap_init_t *rec;
ib_list_node_t *node;
size_t nargs = ib_list_elements(args);
const char *p1;
const char *p2;
ib_flags_t flags;
ib_flags_t fmask;
ib_status_t rc;
int i;
rc = ib_hash_get(ib->dirmap, name, (void *)&rec);
if (rc != IB_OK) {
IB_FTRACE_RET_STATUS(rc);
}
switch (rec->type) {
case IB_DIRTYPE_ONOFF:
if (nargs != 1) {
ib_log_error(ib, 1, "OnOff directive \"%s\" takes one parameter, not %d",
name, nargs);
rc = IB_EINVAL;
break;
}
ib_list_shift(args, &p1);
if ( (strcasecmp("on", p1) == 0)
|| (strcasecmp("yes", p1) == 0)
|| (strcasecmp("true", p1) == 0))
{
rc = rec->cb.fn_onoff(cp, name, 1, rec->cbdata);
}
else {
rc = rec->cb.fn_onoff(cp, name, 0, rec->cbdata);
}
break;
case IB_DIRTYPE_PARAM1:
if (nargs != 1) {
ib_log_error(ib, 1, "Param1 directive \"%s\" takes one parameter, not %d",
name, nargs);
rc = IB_EINVAL;
break;
}
ib_list_shift(args, &p1);
rc = rec->cb.fn_param1(cp, name, p1, rec->cbdata);
break;
case IB_DIRTYPE_PARAM2:
if (nargs != 2) {
ib_log_error(ib, 1, "Param2 directive \"%s\" takes two parameters, not %d",
name, nargs);
rc = IB_EINVAL;
break;
}
ib_list_shift(args, &p1);
ib_list_shift(args, &p2);
rc = rec->cb.fn_param2(cp, name, p1, p2, rec->cbdata);
break;
case IB_DIRTYPE_LIST:
rc = rec->cb.fn_list(cp, name, args, rec->cbdata);
break;
case IB_DIRTYPE_OPFLAGS:
i = 0;
flags = 0;
fmask = 0;
IB_LIST_LOOP(args, node) {
const char *opname = (const char *)ib_list_node_data(node);
int oper = (*opname == '-') ? -1 : ((*opname == '+') ? 1 : 0);
ib_num_t val;
/* If the first option does not use an operator, then
* this is setting all flags so set all the mask bits.
*/
if ((i == 0) && (oper == 0)) {
fmask = ~0;
}
ib_log_debug(ib, 9, "Processing %s option: %s", name, opname);
/* Remove the operator from the name if required.
* and determine the numeric value of the option
* by using the value map.
*/
if (oper != 0) {
opname++;
}
rc = cfgp_opval(opname, rec->valmap, &val);
if (rc != IB_OK) {
ib_log_error(ib, 3, "Invalid %s option: %s", name, opname);
IB_FTRACE_RET_STATUS(rc);
}
/* Mark which bit(s) we are setting. */
fmask |= val;
/* Set/Unset the appropriate bits. */
if (oper == -1) {
flags = flags & ~val;
}
else {
flags |= val;
}
i++;
}
rc = rec->cb.fn_opflags(cp, name, flags, fmask, rec->cbdata);
break;
case IB_DIRTYPE_SBLK1:
if (nargs != 1) {
ib_log_error(ib, 1, "SBlk1 directive \"%s\" takes one parameter, not %d",
name, nargs);
rc = IB_EINVAL;
break;
}
ib_list_shift(args, &p1);
rc = rec->cb.fn_sblk1(cp, name, p1, rec->cbdata);
break;
default:
rc = IB_EINVAL;
}
IB_FTRACE_RET_STATUS(rc);
}
/*********************************
* Helper Functions
*********************************/
static
ib_status_t sqli_create_fingerprint_set_from_file(
sqli_fingerprint_set_t **out_ps,
const char *path,
ib_mm_t mm
)
{
assert(out_ps != NULL);
assert(path != NULL);
ib_status_t rc;
FILE *fp = NULL;
char *buffer = NULL;
size_t buffer_size = 0;
ib_list_t *items = NULL;
ib_list_node_t *n = NULL;
ib_mpool_lite_t *tmp = NULL;
ib_mm_t tmp_mm;
sqli_fingerprint_set_t *ps = NULL;
size_t i = 0;
/* Temporary memory pool for this function only. */
rc = ib_mpool_lite_create(&tmp);
assert(rc == IB_OK);
assert(tmp != NULL);
tmp_mm = ib_mm_mpool_lite(tmp);
fp = fopen(path, "r");
if (fp == NULL) {
goto fail;
}
rc = ib_list_create(&items, tmp_mm);
assert(rc == IB_OK);
assert(items != NULL);
for (;;) {
char *buffer_copy;
int read = getline(&buffer, &buffer_size, fp);
char *space = NULL;
ib_num_t confidence = 0;
sqli_fingerprint_entry_t *entry = ib_mm_alloc(tmp_mm, sizeof(*entry));
if (read == -1) {
if (! feof(fp)) {
fclose(fp);
goto fail;
}
else {
break;
}
}
while (buffer[read-1] == '\n' || buffer[read-1] == '\r') {
buffer[read-1] = '\0';
--read;
}
space = strstr(buffer, " ");
if (space != NULL) {
rc = ib_type_atoi(space + 1, 10, &confidence);
if (rc != IB_OK || confidence > 100) {
return IB_EINVAL;
}
*space = '\0';
}
buffer_copy = ib_mm_strdup(mm, buffer);
assert(buffer_copy != NULL);
entry->confidence = confidence;
entry->fingerprint = buffer_copy;
rc = ib_list_push(items, (void *)entry);
assert(rc == IB_OK);
}
fclose(fp);
ps = ib_mm_alloc(mm, sizeof(*ps));
assert(ps != NULL);
ps->num_fingerprints = ib_list_elements(items);
ps->fingerprints =
ib_mm_alloc(mm, ps->num_fingerprints * sizeof(*ps->fingerprints));
assert(ps->fingerprints != NULL);
i = 0;
IB_LIST_LOOP(items, n) {
const sqli_fingerprint_entry_t *entry =
(const sqli_fingerprint_entry_t *)ib_list_node_data(n);
ps->fingerprints[i] = *entry;
++i;
}
assert(i == ps->num_fingerprints);
ib_mpool_lite_destroy(tmp);
qsort(
ps->fingerprints, ps->num_fingerprints,
sizeof(*ps->fingerprints),
&sqli_cmp
);
*out_ps = ps;
return IB_OK;
fail:
ib_mpool_lite_destroy(tmp);
return IB_EINVAL;
}
/*
* Callback used to generate request header fields.
*/
static ib_status_t core_gen_request_header_fields(ib_engine_t *ib,
ib_tx_t *tx,
ib_state_event_type_t event,
void *cbdata)
{
ib_field_t *f;
ib_status_t rc;
ib_conn_t *conn = tx->conn;
assert(ib != NULL);
assert(tx != NULL);
assert(event == handle_request_header_event);
core_gen_tx_bytestr_alias2(tx, "server_addr",
conn->local_ipstr,
strlen(conn->local_ipstr));
core_gen_tx_numeric(tx, "server_port", conn->local_port);
core_gen_tx_bytestr_alias2(tx, "remote_addr",
conn->remote_ipstr,
strlen(conn->remote_ipstr));
core_gen_tx_numeric(tx, "remote_port", conn->remote_port);
core_gen_tx_numeric(tx, "conn_tx_count",
tx->conn->tx_count);
if (tx->request_line != NULL) {
core_gen_tx_bytestr_alias(tx, "request_line",
tx->request_line->raw);
core_gen_tx_bytestr_alias(tx, "request_method",
tx->request_line->method);
core_gen_tx_bytestr_alias(tx, "request_uri_raw",
tx->request_line->uri);
core_gen_tx_bytestr_alias(tx, "request_protocol",
tx->request_line->protocol);
}
/* Populate the ARGS collection. */
rc = core_slow_get(&f, tx, "ARGS");
if (rc == IB_OK) {
ib_field_t *param_list;
rc = core_slow_get(¶m_list, tx, "request_uri_params");
if (rc == IB_OK) {
ib_list_t *field_list;
ib_list_node_t *node = NULL;
rc = ib_field_mutable_value(
param_list,
ib_ftype_list_mutable_out(&field_list)
);
if (rc != IB_OK) {
return rc;
}
IB_LIST_LOOP(field_list, node) {
ib_field_t *param = (ib_field_t *)ib_list_node_data(node);
/* Add the field to the ARGS collection. */
rc = ib_field_list_add(f, param);
if (rc != IB_OK) {
ib_log_notice_tx(tx,
"Failed to add parameter to "
"ARGS collection: %s",
ib_status_to_string(rc));
}
}
