static void
_jump_prepend(asl_object_private_t *obj, asl_object_private_t *newobj)
{
int type = asl_get_type((asl_object_t)newobj);
if ((type != ASL_TYPE_QUERY) && (type != ASL_TYPE_MSG)) return;
asl_msg_list_prepend((asl_msg_list_t *)obj, newobj);
}
static asl_object_private_t *
_jump_match(asl_object_private_t *obj, asl_object_private_t *qlist, size_t *last, size_t start, size_t count, uint32_t duration, int32_t dir)
{
int type = asl_get_type((asl_object_t)qlist);
if ((qlist != NULL) && (type != ASL_TYPE_LIST)) return NULL;
return (asl_object_private_t *)asl_msg_list_match((asl_msg_list_t *)obj, (asl_msg_list_t *)qlist, last, start, count, duration, dir);
}
static asl_object_private_t *
_jump_search(asl_object_private_t *obj, asl_object_private_t *query)
{
int type = asl_get_type((asl_object_t)query);
if ((query != NULL) && (type != ASL_TYPE_QUERY) && (type != ASL_TYPE_MSG)) return NULL;
asl_msg_list_t *out = asl_msg_list_search((asl_msg_list_t *)obj, (asl_msg_t *)query);
if (out == NULL) return NULL;
return (asl_object_private_t *)out;
}
void
asl_msg_list_insert(asl_msg_list_t *list, uint32_t x, void *obj)
{
uint32_t i, j;
asl_object_private_t *oo = (asl_object_private_t *)obj;
if (list == NULL) return;
if (obj == NULL) return;
if (list->count == UINT32_MAX) return;
if (x >= list->count) x = list->count;
uint32_t type = asl_get_type((asl_object_t)oo);
uint32_t count = 0;
if ((type == ASL_TYPE_MSG) || (type == ASL_TYPE_QUERY)) count = 1;
else count = asl_object_count(oo);
if (count == 0) return;
uint64_t check = list->count;
check += count;
if (check > UINT32_MAX) return;
list->msg = (asl_msg_t **)reallocf(list->msg, (list->count + count) * sizeof(asl_msg_t *));
if (list->msg == NULL)
{
list->count = 0;
list->curr = 0;
return;
}
for (i = list->count, j = i - 1; i > x; i--, j--) list->msg[i] = list->msg[j];
asl_object_set_iteration_index(oo, 0);
if ((type == ASL_TYPE_MSG) || (type == ASL_TYPE_QUERY))
{
list->msg[x] = (asl_msg_t *)asl_retain((asl_object_t)oo);
}
else
{
for (i = x, j = 0; j < count; i++, j++) list->msg[i] = (asl_msg_t *)asl_object_next(oo);
}
asl_object_set_iteration_index(oo, 0);
list->count += count;
}
TEST_F(AslTests, test_create_asl_query) {
QueryContext ctx;
ctx.constraints["sender"].add(Constraint(EQUALS, "bar"));
ctx.constraints["sender"].add(Constraint(LIKE, "%a%"));
ctx.constraints["message"].affinity = INTEGER_TYPE;
ctx.constraints["message"].add(Constraint(LESS_THAN, "10"));
aslmsg query = createAslQuery(ctx);
ASSERT_EQ((uint32_t)ASL_TYPE_QUERY, asl_get_type(query));
ASSERT_EQ((size_t)3, asl_count(query));
const char *key, *val;
uint32_t op;
// Ordering doesn't really matter here, only that we only ended up with
// (message, baz, LESS) and (sender, bar, EQUAL)
ASSERT_EQ(0, asl_fetch_key_val_op(query, 0, &key, &val, &op));
ASSERT_STREQ("Message", key);
ASSERT_STREQ("10", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_LESS | ASL_QUERY_OP_NUMERIC), op);
ASSERT_EQ(0, asl_fetch_key_val_op(query, 1, &key, &val, &op));
ASSERT_STREQ("Sender", key);
ASSERT_STREQ("bar", val);
ASSERT_EQ((uint32_t)ASL_QUERY_OP_EQUAL, op);
ASSERT_EQ(0, asl_fetch_key_val_op(query, 2, &key, &val, &op));
ASSERT_STREQ("Sender", key);
ASSERT_STREQ(".*a.*", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_EQUAL | ASL_QUERY_OP_REGEX |
ASL_QUERY_OP_CASEFOLD),
op);
asl_release(query);
}
TEST_F(AslTests, test_add_query_op) {
aslmsg query = asl_new(ASL_TYPE_QUERY);
ASSERT_EQ((uint32_t)ASL_TYPE_QUERY, asl_get_type(query));
ASSERT_EQ((size_t)0, asl_count(query));
const char *key, *val;
uint32_t op;
addQueryOp(query, "sender", "bar", EQUALS, TEXT_TYPE);
ASSERT_EQ((size_t)1, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 0, &key, &val, &op));
ASSERT_STREQ("Sender", key);
ASSERT_STREQ("bar", val);
ASSERT_EQ((uint32_t)ASL_QUERY_OP_EQUAL, op);
addQueryOp(query, "level", "1", GREATER_THAN, INTEGER_TYPE);
ASSERT_EQ((size_t)2, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 1, &key, &val, &op));
ASSERT_STREQ("Level", key);
ASSERT_STREQ("1", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_GREATER | ASL_QUERY_OP_NUMERIC), op);
addQueryOp(query, "gid", "999", LESS_THAN, BIGINT_TYPE);
ASSERT_EQ((size_t)3, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 2, &key, &val, &op));
ASSERT_STREQ("GID", key);
ASSERT_STREQ("999", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_LESS | ASL_QUERY_OP_NUMERIC), op);
addQueryOp(query, "facility", "hoo", GREATER_THAN_OR_EQUALS, TEXT_TYPE);
ASSERT_EQ((size_t)4, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 3, &key, &val, &op));
ASSERT_STREQ("Facility", key);
ASSERT_STREQ("hoo", val);
ASSERT_EQ((uint32_t)ASL_QUERY_OP_GREATER_EQUAL, op);
addQueryOp(query, "pid", "30", LESS_THAN_OR_EQUALS, INTEGER_TYPE);
ASSERT_EQ((size_t)5, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 4, &key, &val, &op));
ASSERT_STREQ("PID", key);
ASSERT_STREQ("30", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_LESS_EQUAL | ASL_QUERY_OP_NUMERIC), op);
addQueryOp(query, "ref_proc", "%tom%", LIKE, TEXT_TYPE);
ASSERT_EQ((size_t)6, asl_count(query));
ASSERT_EQ(0, asl_fetch_key_val_op(query, 5, &key, &val, &op));
ASSERT_STREQ("RefProc", key);
ASSERT_STREQ(".*tom.*", val);
ASSERT_EQ((uint32_t)(ASL_QUERY_OP_EQUAL | ASL_QUERY_OP_REGEX |
ASL_QUERY_OP_CASEFOLD),
op);
// Queries against the extra column should not be sent to ASL
addQueryOp(query, "extra", "tom", EQUALS, TEXT_TYPE);
ASSERT_EQ((size_t)6, asl_count(query));
// Queries with unsupported operators should not be sent to ASL
addQueryOp(query, "host", "tom", GLOB, TEXT_TYPE);
ASSERT_EQ((size_t)6, asl_count(query));
asl_release(query);
}
