/// @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 = ib_mm_strdup(MM(), nulstrval);
ASSERT_STRNE(NULL, nulcopy);
rc = ib_field_create(&f, MM(), IB_S2SL("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, MM(), IB_S2SL("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, MM(),
(uint8_t *)nulstrval, strlen(nulstrval));
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(f);
rc = ib_field_create(&f, MM(), IB_S2SL("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, MM(), IB_S2SL("test_nulstr_ex"),
IB_FTYPE_NULSTR, ib_ftype_nulstr_in(nulstrval));
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(f);
rc = ib_field_create(&f, MM(), IB_S2SL("test_num_ex"),
IB_FTYPE_NUM, ib_ftype_num_in(&numval));
ASSERT_EQ(IB_OK, rc);
ASSERT_TRUE(f);
rc = ib_field_create(&f, MM(), IB_S2SL("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_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);
}
static ib_status_t dyn_get(
const ib_field_t *f,
void *out_value,
const void *arg,
size_t alen,
void *data
)
{
ib_mpool_t *mp = (ib_mpool_t *)data;
ib_num_t numval = 5;
ib_field_t *newf;
ib_status_t rc;
ib_list_t *l;
const char* carg = (const char *)arg;
rc = ib_list_create(&l, mp);
if (rc != IB_OK) {
return rc;
}
rc = ib_field_create(&newf, mp, carg, alen, IB_FTYPE_NUM,
ib_ftype_num_in(&numval));
if (rc != IB_OK) {
return rc;
}
rc = ib_list_push(l, newf);
*(void**)out_value = l;
return IB_OK;
}
void Field::set_number(
int64_t value,
const char* arg, size_t arg_length
) const
{
Internal::check_type(NUMBER, type());
Internal::set_value(ib(), ib_ftype_num_in(&value), arg, arg_length);
}
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(TestIBUtilField, Alias)
{
ib_num_t num1;
ib_num_t num2;
ib_float_t flt1;
ib_float_t flt2;
char *s = NULL;
const char *v;
ib_field_t *f;
ib_status_t rc;
rc = ib_field_create_alias(&f, MM(), "foo", 3,
IB_FTYPE_NULSTR,
ib_ftype_nulstr_mutable_out(&s));
ASSERT_EQ(IB_OK, rc);
v = "hello";
rc = ib_field_setv(f, ib_ftype_nulstr_in(v));
ASSERT_EQ(IB_OK, rc);
ASSERT_STREQ(v, s);
/*
* Alias a numeric field
*/
num1 = 1;
rc = ib_field_create_alias(&f, MM(), "num", 3,
IB_FTYPE_NUM,
ib_ftype_num_in(&num1));
ASSERT_EQ(IB_OK, rc);
rc = ib_field_value(f, ib_ftype_num_out(&num2));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(num1, num2);
num1 = 3;
rc = ib_field_value(f, ib_ftype_num_out(&num2));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(num1, num2);
/*
* Alias a floating point field
*/
flt1 = 1.1;
rc = ib_field_create_alias(&f, MM(), "flt", 3,
IB_FTYPE_FLOAT,
ib_ftype_float_in(&flt1));
ASSERT_EQ(IB_OK, rc);
rc = ib_field_value(f, ib_ftype_float_out(&flt2));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(flt1, flt2);
flt1 = 1.5;
rc = ib_field_value(f, ib_ftype_float_out(&flt2));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(flt1, flt2);
}
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);
}
Field Field::create_number(
MemoryPool pool,
const char* name,
size_t name_length,
int64_t value
)
{
return Internal::create_field(
pool,
name, name_length,
Field::NUMBER,
ib_ftype_num_in(&value)
);
}
ib_status_t ib_field_copy(
ib_field_t **pf,
ib_mpool_t *mp,
const char *name,
size_t nlen,
const ib_field_t *src
)
{
ib_status_t rc;
if (ib_field_is_dynamic(src)) {
rc = ib_field_create_dynamic(
pf, mp, name, nlen,
src->type,
src->val->fn_get,
src->val->cbdata_get,
src->val->fn_set,
src->val->cbdata_set
);
}
else {
switch (src->type) {
case IB_FTYPE_NUM:
{
ib_num_t v;
rc = ib_field_value(src, ib_ftype_num_out(&v));
if (rc != IB_OK) {
goto failed;
}
rc = ib_field_create(
pf, mp, name, nlen,
src->type,
ib_ftype_num_in(&v)
);
break;
}
case IB_FTYPE_FLOAT:
{
ib_float_t v;
rc = ib_field_value(src, ib_ftype_float_out(&v));
if (rc != IB_OK) {
goto failed;
}
rc = ib_field_create(
pf, mp, name, nlen,
src->type,
ib_ftype_float_in(&v)
);
break;
}
default:
{
void *v;
rc = ib_field_value(src, &v);
if (rc != IB_OK) {
goto failed;
}
rc = ib_field_create(
pf, mp, name, nlen,
src->type,
v
);
}
}
}
if (rc != IB_OK) {
goto failed;
}
ib_field_util_log_debug("FIELD_COPY", (*pf));
return rc;
failed:
*pf = NULL;
return rc;
}
/**
* Attempt to convert a single field.
*
* If the desired type matches the in_field type, out_field is set to NULL
* and IB_OK is returned.
*
* @param[in,out] mp Memory pool to use.
* @param[in] desired_type The type to try to convert this to.
* @param[in] in_field The input field.
* @param[out] out_field The output field to write to.
*
* @returns
* - IB_OK On success.
* - IB_EINVAL If a string cannot be converted to a number type
* or some other invalid type conversion is requested.
* - IB_EALLOC Memory allocation error.
*/
ib_status_t ib_field_convert(
ib_mpool_t *mp,
const ib_ftype_t desired_type,
const ib_field_t *in_field,
ib_field_t **out_field)
{
assert(mp);
assert(in_field);
ib_status_t rc;
/* Holder values for in_field values before being set in out_field. */
size_t sz;
const char *str;
const ib_bytestr_t *bstr;
ib_num_t num;
ib_float_t flt;
void *new_field_value;
if (in_field->type == desired_type) {
*out_field = NULL;
return IB_OK;
}
switch (in_field->type) {
case IB_FTYPE_NULSTR:
/* Extract string. */
rc = ib_field_value(in_field, ib_ftype_nulstr_out(&str));
if (rc!=IB_OK){
return rc;
}
switch(desired_type) {
case IB_FTYPE_BYTESTR:
rc = ib_bytestr_dup_nulstr((ib_bytestr_t **)&bstr, mp, str);
if (rc!=IB_OK){
return rc;
}
new_field_value = ib_ftype_bytestr_in(bstr);
break;
case IB_FTYPE_NUM:
rc = ib_string_to_num(str, 0, &num);
new_field_value = ib_ftype_num_in(&num);
break;
case IB_FTYPE_FLOAT:
rc = ib_string_to_float(str, &flt);
new_field_value = ib_ftype_float_in(&flt);
break;
default:
return IB_EINVAL;
}
break;
case IB_FTYPE_BYTESTR:
/* Extract bytestr. */
rc = ib_field_value(in_field, ib_ftype_bytestr_out(&bstr));
if (rc!=IB_OK){
return rc;
}
sz = ib_bytestr_length(bstr);
/* Convert byte str. */
switch(desired_type) {
case IB_FTYPE_NULSTR:
str = ib_mpool_memdup_to_str(mp, bstr, sz);
if (!str) {
return rc;
}
new_field_value = ib_ftype_nulstr_in(str);
break;
case IB_FTYPE_NUM:
rc = ib_string_to_num_ex((char *)bstr, sz, 0, &num);
new_field_value = ib_ftype_num_in(&num);
break;
case IB_FTYPE_FLOAT:
rc = ib_string_to_float_ex((char *)bstr, sz, &flt);
new_field_value = ib_ftype_float_in(&flt);
break;
default:
return IB_EINVAL;
}
break;
case IB_FTYPE_NUM:
/* Extract unum. */
rc = ib_field_value(in_field, ib_ftype_num_out(&num));
if (rc!=IB_OK){
return rc;
}
switch(desired_type) {
case IB_FTYPE_NULSTR:
str = ib_num_to_string(mp, num);
if (!str) {
return IB_EINVAL;
}
new_field_value = ib_ftype_nulstr_in(str);
break;
case IB_FTYPE_BYTESTR:
str = ib_num_to_string(mp, num);
if (!str) {
return IB_EINVAL;
}
rc = ib_bytestr_dup_nulstr((ib_bytestr_t **)&bstr, mp, str);
if (rc!=IB_OK){
return rc;
}
new_field_value = ib_ftype_bytestr_in(bstr);
break;
case IB_FTYPE_FLOAT:
flt = (ib_float_t)num;
new_field_value = ib_ftype_float_in(&flt);
break;
default:
return IB_EINVAL;
}
break;
case IB_FTYPE_FLOAT:
/* Extract unum. */
rc = ib_field_value(in_field, ib_ftype_float_out(&flt));
if (rc!=IB_OK){
return rc;
}
switch(desired_type) {
case IB_FTYPE_NULSTR:
str = ib_float_to_string(mp, flt);
if (!str) {
return IB_EINVAL;
}
new_field_value = ib_ftype_nulstr_in(str);
break;
case IB_FTYPE_BYTESTR:
str = ib_float_to_string(mp, flt);
if (!str) {
return IB_EINVAL;
}
rc = ib_bytestr_dup_nulstr((ib_bytestr_t **)&bstr, mp, str);
if (rc!=IB_OK){
return rc;
}
new_field_value = ib_ftype_bytestr_in(bstr);
break;
case IB_FTYPE_NUM:
num = (ib_float_t)flt;
new_field_value = ib_ftype_num_in(&num);
break;
default:
return IB_EINVAL;
}
break;
default:
return IB_EINVAL;
}
rc = ib_field_create(
out_field,
mp,
in_field->name,
in_field->nlen,
desired_type,
new_field_value);
return rc;
}
TEST_F(TestIBUtilField, ConvertNumbers)
{
ib_field_t *f1;
ib_field_t *f2;
ib_status_t rc;
ib_num_t num;
ib_float_t flt;
/*
* Convert numeric to a float
*/
/* Create the field */
num = 1;
rc = ib_field_create(&f1, MM(), "one", 3,
IB_FTYPE_NUM, ib_ftype_num_in(&num));
ASSERT_EQ(IB_OK, rc);
/* Attempt a numeric conversion. */
rc = ib_field_convert(MM(), IB_FTYPE_FLOAT, f1, &f2);
ASSERT_EQ(IB_OK, rc);
/* Pull out param value for check. */
rc = ib_field_value(f2, ib_ftype_float_out(&flt));
ASSERT_EQ(IB_OK, rc);
ASSERT_FLOAT_EQ(1.0, flt);
/*
* Convert floating-point to num
*/
/* Create the field */
flt = 1.0;
rc = ib_field_create(&f1, MM(), "one", 3,
IB_FTYPE_FLOAT, ib_ftype_float_in(&flt));
ASSERT_EQ(IB_OK, rc);
/* Attempt a numeric conversion. */
rc = ib_field_convert(MM(), IB_FTYPE_NUM, f1, &f2);
ASSERT_EQ(IB_OK, rc);
/* Pull out param value for check. */
rc = ib_field_value(f2, ib_ftype_num_in(&num));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(1, num);
/*
* Convert floating-point to num
*/
/* Create the field */
flt = 1.1;
rc = ib_field_create(&f1, MM(), "one", 3,
IB_FTYPE_FLOAT, ib_ftype_float_in(&flt));
ASSERT_EQ(IB_OK, rc);
/* Attempt a numeric conversion. */
rc = ib_field_convert(MM(), IB_FTYPE_NUM, f1, &f2);
ASSERT_EQ(IB_OK, rc);
/* Pull out param value for check. */
rc = ib_field_value(f2, ib_ftype_num_in(&num));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(1, num);
}
ib_status_t ib_field_convert(
ib_mpool_t *mp,
const ib_ftype_t desired_type,
const ib_field_t *in_field,
ib_field_t **out_field
)
{
assert(mp);
assert(in_field);
ib_status_t rc;
/* Holder values for in_field values before being set in out_field. */
size_t sz;
const char *str;
const ib_bytestr_t *bstr;
ib_num_t num;
ib_time_t tme;
ib_float_t flt;
void *new_field_value;
if (in_field->type == desired_type) {
*out_field = NULL;
return IB_OK;
}
switch (in_field->type) {
case IB_FTYPE_NULSTR:
/* Extract string. Note that a zero-length nulstr field can
* have a NULL value in the union. */
if ( (in_field->val->u.nulstr == NULL) &&
(in_field->val->pval == NULL) )
{
str = "";
}
else {
rc = ib_field_value(in_field, ib_ftype_nulstr_out(&str));
if (rc != IB_OK){
return rc;
}
}
switch (desired_type) {
case IB_FTYPE_BYTESTR:
rc = ib_bytestr_dup_nulstr((ib_bytestr_t **)&bstr, mp, str);
if (rc != IB_OK) {
return rc;
}
new_field_value = ib_ftype_bytestr_in(bstr);
break;
case IB_FTYPE_TIME:
rc = ib_string_to_time(str, &tme);
if (rc != IB_OK) {
return rc;
}
new_field_value = ib_ftype_time_in(&tme);
break;
case IB_FTYPE_NUM:
rc = ib_string_to_num(str, 0, &num);
if (rc != IB_OK) {
return rc;
}
new_field_value = ib_ftype_num_in(&num);
break;
case IB_FTYPE_FLOAT:
rc = ib_string_to_float(str, &flt);
if (rc != IB_OK) {
return rc;
}
new_field_value = ib_ftype_float_in(&flt);
break;
default:
return IB_EINVAL;
}
break;
case IB_FTYPE_BYTESTR:
/* Extract bytestr. */
rc = ib_field_value(in_field, ib_ftype_bytestr_out(&bstr));
if (rc != IB_OK){
return rc;
}
str = (const char *)ib_bytestr_const_ptr(bstr);
sz = ib_bytestr_length(bstr);
/* Convert byte str. */
switch(desired_type) {
case IB_FTYPE_NULSTR:
str = ib_mpool_memdup_to_str(mp, str, sz);
if (!str) {
return rc;
}
new_field_value = ib_ftype_nulstr_in(str);
break;
case IB_FTYPE_TIME:
rc = ib_string_to_time_ex(str, sz, &tme);
if (rc != IB_OK) {
return rc;
}
new_field_value = ib_ftype_time_in(&tme);
break;
case IB_FTYPE_NUM:
rc = ib_string_to_num_ex(str, sz, 0, &num);
if (rc != IB_OK) {
return rc;
}
new_field_value = ib_ftype_num_in(&num);
break;
case IB_FTYPE_FLOAT:
rc = ib_string_to_float_ex(str, sz, &flt);
if (rc != IB_OK) {
return rc;
}
new_field_value = ib_ftype_float_in(&flt);
break;
default:
return IB_EINVAL;
}
break;
case IB_FTYPE_TIME:
/* Extract time. */
rc = ib_field_value(in_field, ib_ftype_time_out(&tme));
if (rc != IB_OK){
return rc;
}
switch (desired_type) {
case IB_FTYPE_NULSTR:
str = ib_time_to_string(mp, tme);
if (! str) {
return IB_EINVAL;
}
new_field_value = ib_ftype_nulstr_in(str);
break;
case IB_FTYPE_BYTESTR:
str = ib_time_to_string(mp, tme);
if (! str) {
return IB_EINVAL;
}
rc = ib_bytestr_dup_nulstr((ib_bytestr_t **)&bstr, mp, str);
if (rc != IB_OK){
return rc;
}
new_field_value = ib_ftype_bytestr_in(bstr);
break;
case IB_FTYPE_FLOAT:
flt = (ib_float_t)tme;
/* Check that our assignment is within error=1, or fail. */
if (llabs(tme - flt) > 1) {
return IB_EINVAL;
}
new_field_value = ib_ftype_float_in(&flt);
break;
default:
return IB_EINVAL;
}
break;
case IB_FTYPE_NUM:
/* Extract unum. */
rc = ib_field_value(in_field, ib_ftype_num_out(&num));
if (rc != IB_OK){
return rc;
}
switch (desired_type) {
case IB_FTYPE_NULSTR:
str = ib_num_to_string(mp, num);
if (! str) {
return IB_EINVAL;
}
new_field_value = ib_ftype_nulstr_in(str);
break;
case IB_FTYPE_BYTESTR:
str = ib_num_to_string(mp, num);
if (! str) {
return IB_EINVAL;
}
rc = ib_bytestr_dup_nulstr((ib_bytestr_t **)&bstr, mp, str);
if (rc != IB_OK){
return rc;
}
new_field_value = ib_ftype_bytestr_in(bstr);
break;
case IB_FTYPE_TIME:
if (num < 0) {
return IB_EINVAL;
}
tme = (ib_time_t)num;
new_field_value = ib_ftype_time_in(&tme);
break;
case IB_FTYPE_FLOAT:
flt = (ib_float_t)num;
if (llabs(flt - num) > 1) {
return IB_EINVAL;
}
new_field_value = ib_ftype_float_in(&flt);
break;
default:
return IB_EINVAL;
}
break;
case IB_FTYPE_FLOAT:
/* Extract unum. */
rc = ib_field_value(in_field, ib_ftype_float_out(&flt));
if (rc != IB_OK){
return rc;
}
switch (desired_type) {
case IB_FTYPE_NULSTR:
str = ib_float_to_string(mp, flt);
if (!str) {
return IB_EINVAL;
}
new_field_value = ib_ftype_nulstr_in(str);
break;
case IB_FTYPE_BYTESTR:
str = ib_float_to_string(mp, flt);
if (!str) {
return IB_EINVAL;
}
rc = ib_bytestr_dup_nulstr((ib_bytestr_t **)&bstr, mp, str);
if (rc != IB_OK){
return rc;
}
new_field_value = ib_ftype_bytestr_in(bstr);
break;
case IB_FTYPE_TIME:
if (flt < 0) {
return IB_EINVAL;
}
tme = (ib_float_t)flt;
new_field_value = ib_ftype_time_in(&tme);
break;
case IB_FTYPE_NUM:
num = (ib_float_t)flt;
new_field_value = ib_ftype_num_in(&num);
break;
default:
return IB_EINVAL;
}
break;
default:
return IB_EINVAL;
}
rc = ib_field_create(
out_field,
mp,
in_field->name,
in_field->nlen,
desired_type,
new_field_value
);
return rc;
}
void Field::set_number(int64_t value) const
{
Internal::check_type(NUMBER, type());
Internal::set_value(ib(), ib_ftype_num_in(&value));
}
static ib_status_t field_from_string_internal(
ib_mpool_t *mp,
const char *name,
size_t nlen,
const char *vstr,
size_t vlen,
bool vstr_is_nulstr,
ib_field_t **pfield)
{
assert(mp != NULL);
assert(name != NULL);
assert(vstr != NULL);
assert(pfield != NULL);
ib_status_t conv;
ib_status_t rc = IB_OK;
ib_field_t *field;
*pfield = NULL;
/* Try to convert to an integer */
if (*pfield == NULL) {
ib_num_t num_val;
if (vstr_is_nulstr) {
conv = ib_string_to_num(vstr, 0, &num_val);
}
else {
conv = ib_string_to_num_ex(vstr, vlen, 0, &num_val);
}
if (conv == IB_OK) {
rc = ib_field_create(&field, mp,
name, nlen,
IB_FTYPE_NUM,
ib_ftype_num_in(&num_val));
*pfield = field;
}
}
/* Try to convert to a float */
if (*pfield == NULL) {
ib_float_t float_val;
if (vstr_is_nulstr) {
conv = ib_string_to_float(vstr, &float_val);
}
else {
conv = ib_string_to_float_ex(vstr, vlen, &float_val);
}
if (conv == IB_OK) {
rc = ib_field_create(&field, mp,
name, nlen,
IB_FTYPE_FLOAT,
ib_ftype_float_in(&float_val));
*pfield = field;
}
}
/* Finally, assume that it's a string */
if (*pfield == NULL) {
if (vstr_is_nulstr) {
rc = ib_field_create(&field, mp,
name, nlen,
IB_FTYPE_NULSTR,
ib_ftype_nulstr_in(vstr));
}
else {
ib_bytestr_t *bs;
rc = ib_bytestr_dup_mem(&bs, mp, (const uint8_t *)vstr, vlen);
if (rc != IB_OK) {
return rc;
}
rc = ib_field_create(&field, mp,
name, nlen,
IB_FTYPE_BYTESTR,
ib_ftype_bytestr_in(bs));
}
*pfield = field;
}
return rc;
}
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 {
const ib_num_t len = 1;
rc = ib_field_create(
&fnew, mp, fin->name, fin->nlen, IB_FTYPE_NUM,
ib_ftype_num_in(&len)
);
}
if (rc == IB_OK) {
*fout = fnew;
}
return rc;
}
/**
* Count 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.
/**
* 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 {
static
ib_status_t sqli_op_execute(
ib_tx_t *tx,
const ib_field_t *field,
ib_field_t *capture,
ib_num_t *result,
void *instance_data,
void *cbdata
)
{
assert(tx != NULL);
assert(field != NULL);
assert(result != NULL);
const sqli_fingerprint_set_t *ps = (const sqli_fingerprint_set_t *)instance_data;
sfilter sf;
ib_bytestr_t *bs;
ib_status_t rc;
sqli_callback_data_t callback_data;
*result = 0;
/* Currently only bytestring types are supported.
* Other types will just get passed through. */
if (field->type != IB_FTYPE_BYTESTR) {
return IB_OK;
}
rc = ib_field_value(field, ib_ftype_bytestr_mutable_out(&bs));
if (rc != IB_OK) {
return rc;
}
/* Run through libinjection. */
libinjection_sqli_init(
&sf,
(const char *)ib_bytestr_const_ptr(bs),
ib_bytestr_length(bs),
FLAG_NONE
);
callback_data.confidence = 0;
callback_data.fingerprint_set = NULL;
if (ps != NULL) {
callback_data.fingerprint_set = ps;
libinjection_sqli_callback(&sf, sqli_lookup_word, (void *)&callback_data);
}
if (libinjection_is_sqli(&sf)) {
ib_log_debug_tx(tx, "Matched SQLi fingerprint: %s", sf.fingerprint);
*result = 1;
}
if (*result == 1 && capture != NULL) {
{
ib_field_t *fingerprint_field;
size_t fingerprint_length = strlen(sf.fingerprint);
const uint8_t *fingerprint;
fingerprint = ib_mm_memdup(
tx->mm,
sf.fingerprint, fingerprint_length
);
if (fingerprint == NULL) {
return IB_EALLOC;
}
rc = ib_field_create_bytestr_alias(
&fingerprint_field,
tx->mm,
IB_S2SL("fingerprint"),
fingerprint, fingerprint_length
);
if (rc != IB_OK) {
return rc;
}
rc = ib_field_list_add(capture, fingerprint_field);
if (rc != IB_OK) {
return rc;
}
}
{
ib_field_t *confidence_field;
rc = ib_field_create(
&confidence_field,
tx->mm,
IB_S2SL("confidence"),
IB_FTYPE_NUM,
ib_ftype_num_in(&callback_data.confidence)
);
if (rc != IB_OK) {
return rc;
}
rc = ib_field_list_add(capture, confidence_field);
if (rc != IB_OK) {
return rc;
}
}
}
return IB_OK;
}
