static char* test_init_error()
{
// null sandbox
int result = lsb_init(NULL, NULL);
mu_assert(result == 0, "lsb_init() null sandbox ptr");
// load error
lua_sandbox* sb = lsb_create(NULL, "lua/simple1.lua", 65765, 1000,
1024);
mu_assert(sb, "lsb_create() received: NULL");
result = lsb_init(sb, NULL);
mu_assert(result == 2, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
lsb_state s = lsb_get_state(sb);
mu_assert(s == LSB_TERMINATED, "lsb_get_state() received: %d", s);
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
// out of memory
sb = lsb_create(NULL, "lua/simple.lua", 6000, 1000, 1024);
mu_assert(sb, "lsb_create() received: NULL");
result = lsb_init(sb, NULL);
mu_assert(result == 2, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s\n", e);
return NULL;
}
static char* test_cbuf()
{
const char* outputs[] = {
"{\"time\":0,\"rows\":3,\"columns\":3,\"seconds_per_row\":1,\"column_info\":[{\"name\":\"Add_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Set_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Get_column\",\"unit\":\"count\",\"aggregation\":\"sum\"}]}\n0\t0\t0\n0\t0\t0\n0\t0\t0\n"
, "{\"time\":0,\"rows\":3,\"columns\":3,\"seconds_per_row\":1,\"column_info\":[{\"name\":\"Add_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Set_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Get_column\",\"unit\":\"count\",\"aggregation\":\"sum\"}]}\n1\t1\t1\n2\t1\t2\n3\t1\t3\n"
, "{\"time\":2,\"rows\":3,\"columns\":3,\"seconds_per_row\":1,\"column_info\":[{\"name\":\"Add_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Set_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Get_column\",\"unit\":\"count\",\"aggregation\":\"sum\"}]}\n3\t1\t3\n0\t0\t0\n1\t1\t1\n"
, "{\"time\":8,\"rows\":3,\"columns\":3,\"seconds_per_row\":1,\"column_info\":[{\"name\":\"Add_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Set_column\",\"unit\":\"count\",\"aggregation\":\"sum\"},{\"name\":\"Get_column\",\"unit\":\"count\",\"aggregation\":\"sum\"}]}\n0\t0\t0\n0\t0\t0\n1\t1\t1\n"
, NULL
};
lua_sandbox* sb = lsb_create(NULL, "lua/circular_buffer.lua", 32767,
1000, 32767);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
lsb_add_function(sb, &write_output, "write");
result = report(sb, 0);
mu_assert(lsb_get_state(sb) == LSB_RUNNING, "error %s",
lsb_get_error(sb));
mu_assert(strcmp(outputs[0], written_data) == 0, "received: %s",
written_data);
process(sb, 0);
process(sb, 1e9);
process(sb, 1e9);
process(sb, 2e9);
process(sb, 2e9);
process(sb, 2e9);
result = report(sb, 0);
mu_assert(result == 0, "report() received: %d", result);
mu_assert(strcmp(outputs[1], written_data) == 0, "received: %s",
written_data);
process(sb, 4e9);
result = report(sb, 0);
mu_assert(result == 0, "report() received: %d", result);
mu_assert(strcmp(outputs[2], written_data) == 0, "received: %s",
written_data);
process(sb, 10e9);
result = report(sb, 0);
mu_assert(result == 0, "report() received: %d", result);
mu_assert(strcmp(outputs[3], written_data) == 0, "received: %s",
written_data);
result = report(sb, 1);
mu_assert(result == 0, "report() received: %d", result);
result = report(sb, 3);
mu_assert(result == 0, "report() received: %d", result);
e = lsb_destroy(sb, "circular_buffer.preserve");
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_cbuf_errors()
{
const char* tests[] =
{
"process() lua/circular_buffer_errors.lua:9: bad argument #0 to 'new' (incorrect number of arguments)"
, "process() lua/circular_buffer_errors.lua:11: bad argument #1 to 'new' (number expected, got nil)"
, "process() lua/circular_buffer_errors.lua:13: bad argument #1 to 'new' (rows must be > 1)"
, "process() lua/circular_buffer_errors.lua:15: bad argument #2 to 'new' (number expected, got nil)"
, "process() lua/circular_buffer_errors.lua:17: bad argument #2 to 'new' (columns must be > 0)"
, "process() lua/circular_buffer_errors.lua:19: bad argument #3 to 'new' (number expected, got nil)"
, "process() lua/circular_buffer_errors.lua:21: bad argument #3 to 'new' (seconds_per_row is out of range)"
, "process() lua/circular_buffer_errors.lua:23: bad argument #3 to 'new' (seconds_per_row is out of range)"
, "process() not enough memory"
, "process() lua/circular_buffer_errors.lua:28: bad argument #2 to 'set' (column out of range)"
, "process() lua/circular_buffer_errors.lua:31: bad argument #2 to 'set' (column out of range)"
, "process() lua/circular_buffer_errors.lua:34: bad argument #2 to 'set' (number expected, got nil)"
, "process() lua/circular_buffer_errors.lua:37: bad argument #1 to 'set' (number expected, got nil)"
, "process() lua/circular_buffer_errors.lua:41: bad argument #1 to 'get' (Heka.circular_buffer expected, got number)"
, "process() lua/circular_buffer_errors.lua:44: bad argument #3 to 'set' (number expected, got nil)"
, "process() lua/circular_buffer_errors.lua:47: bad argument #-1 to 'set' (incorrect number of arguments)"
, "process() lua/circular_buffer_errors.lua:50: bad argument #-1 to 'add' (incorrect number of arguments)"
, "process() lua/circular_buffer_errors.lua:53: bad argument #-1 to 'get' (incorrect number of arguments)"
, "process() lua/circular_buffer_errors.lua:56: bad argument #-1 to 'compute' (incorrect number of arguments)"
, "process() lua/circular_buffer_errors.lua:59: bad argument #1 to 'compute' (invalid option 'func')"
, "process() lua/circular_buffer_errors.lua:62: bad argument #2 to 'compute' (column out of range)"
, "process() lua/circular_buffer_errors.lua:65: bad argument #4 to 'compute' (end must be >= start)"
, "process() lua/circular_buffer_errors.lua:68: bad argument #1 to 'format' (invalid option 'invalid')"
, "process() lua/circular_buffer_errors.lua:71: bad argument #-1 to 'format' (incorrect number of arguments)"
, "process() lua/circular_buffer_errors.lua:74: bad argument #-1 to 'format' (incorrect number of arguments)"
, NULL
};
for (int i = 0; tests[i]; ++i) {
lua_sandbox* sb = lsb_create(NULL, "lua/circular_buffer_errors.lua",
32767, 1000, 128);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
result = process(sb, i);
mu_assert(result == 1, "test: %d received: %d", i, result);
const char* le = lsb_get_error(sb);
mu_assert(le, "test: %d received NULL", i);
mu_assert(strcmp(tests[i], le) == 0, "test: %d received: %s", i, le);
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
}
return NULL;
}
static char* test_restore()
{
const char *output_file = "restore.preserve";
remove(output_file);
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/restore.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
lsb_err_value ret = lsb_init(sb, output_file);
mu_assert(!ret, "lsb_init() received: %s", ret);
lsb_add_function(sb, &lsb_test_write_output, "write_output");
int result = lsb_test_process(sb, 0);
mu_assert(result == 0, "process() received: %d %s", result,
lsb_get_error(sb));
mu_assert(strcmp("101", lsb_test_output) == 0, "test: initial load received: %s",
lsb_test_output);
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
// re-load to test the preserved data
sb = lsb_create(NULL, "lua/restore.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
ret = lsb_init(sb, output_file);
mu_assert(!ret, "lsb_init() received: %s", ret);
lsb_add_function(sb, &lsb_test_write_output, "write_output");
result = lsb_test_process(sb, 0);
mu_assert(result == 0, "process() received: %d %s", result,
lsb_get_error(sb));
mu_assert(strcmp("102", lsb_test_output) == 0, "test: reload received: %s",
lsb_test_output);
result = lsb_test_report(sb, 2); // change the preservation version
mu_assert(result == 0, "report() received: %d", result);
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
// re-load to test the preserved data with a version change
sb = lsb_create(NULL, "lua/restore.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
ret = lsb_init(sb, output_file);
mu_assert(!ret, "lsb_init() received: %s", ret);
lsb_add_function(sb, &lsb_test_write_output, "write_output");
result = lsb_test_process(sb, 0);
mu_assert(result == 0, "process() received: %d %s", result,
lsb_get_error(sb));
mu_assert(strcmp("101", lsb_test_output) == 0,
"test: reload with version change received: %s", lsb_test_output);
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_serialize()
{
const char* output_file = "serialize.preserve";
lua_sandbox* sb = lsb_create(NULL, "lua/serialize.lua", 64000, 1000,
64000);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
e = lsb_destroy(sb, output_file);
mu_assert(!e, "lsb_destroy() received: %s", e);
#ifdef LUA_JIT
char* expected = read_file("output/serialize.data");
#else
char* expected = read_file("output/serialize.lua51.data");
#endif
char* actual = read_file(output_file);
mu_assert(strcmp(expected, actual) == 0, "serialization mismatch");
free(expected);
free(actual);
return NULL;
}
static char* test_api_assertion()
{
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/counter.lua", "", NULL);
lsb_err_value ret = lsb_init(sb, NULL);
mu_assert(!ret, "lsb_init() received: %s", ret);
lsb_stop_sandbox(NULL);
mu_assert(lsb_destroy(NULL) == NULL, "not null");
mu_assert(lsb_usage(NULL, 0, 0) == 0, "not 0");
mu_assert(lsb_usage(sb, LSB_UT_MAX, 0) == 0, "not 0");
mu_assert(lsb_usage(sb, 0, LSB_US_MAX) == 0, "not 0");
mu_assert(strcmp(lsb_get_error(NULL), "") == 0, "not empty");
lsb_set_error(NULL, "foo");
mu_assert(lsb_get_lua(NULL) == NULL, "not null");
mu_assert(lsb_get_lua_file(NULL) == NULL, "not null");
mu_assert(lsb_get_parent(NULL) == NULL, "not null");
mu_assert(lsb_get_logger(NULL) == NULL, "not null");
mu_assert(lsb_get_state(NULL) == LSB_UNKNOWN, "not unknown");
lsb_add_function(NULL, lsb_test_write_output, "foo");
lsb_add_function(sb, NULL, "foo");
lsb_add_function(sb, lsb_test_write_output, NULL);
mu_assert(lsb_pcall_setup(NULL, "foo") == LSB_ERR_UTIL_NULL, "not null");
mu_assert(lsb_pcall_setup(sb, NULL) == LSB_ERR_UTIL_NULL, "not null");
lsb_add_function(NULL, NULL, NULL);
lsb_pcall_teardown(NULL);
lsb_terminate(NULL, NULL);
lsb_terminate(sb, NULL);
lsb_add_function(sb, lsb_test_write_output, "write_output");
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_output()
{
const char *outputs[] = {
"1.2 string nil true false",
"foo",
NULL
};
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/output.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
add_ud_module(sb);
lsb_err_value ret = lsb_init(sb, NULL);
mu_assert(!ret, "lsb_init() received: %s", ret);
lsb_add_function(sb, &lsb_test_write_output, "write_output");
for (int x = 0; outputs[x]; ++x) {
int result = lsb_test_process(sb, x);
mu_assert(!result, "process() test: %d failed: %d %s", x, result,
lsb_get_error(sb));
if (outputs[x][0]) {
mu_assert(strcmp(outputs[x], lsb_test_output) == 0,
"test: %d received: %s", x, lsb_test_output);
}
}
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_output_errors()
{
const char *tests[] =
{
"process() lua/output_errors.lua:10: bad argument #1 to 'output' (unsupported type)"
, "process() lua/output_errors.lua:16: output_limit exceeded"
, "process() lua/output_errors.lua:18: bad argument #1 to 'write_output' (unknown userdata type)"
, NULL
};
for (int i = 0; tests[i]; ++i) {
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/output_errors.lua",
MODULE_PATH "output_limit = 128", NULL);
mu_assert(sb, "lsb_create() received: NULL");
lsb_err_value ret = lsb_init(sb, NULL);
mu_assert(!ret, "lsb_init() received: %s", ret);
lsb_add_function(sb, &lsb_test_write_output, "write_output");
int result = lsb_test_process(sb, i);
mu_assert(result == 1, "test: %d received: %d", i, result);
const char *le = lsb_get_error(sb);
mu_assert(le, "test: %d received NULL", i);
mu_assert(strcmp(tests[i], le) == 0, "test: %d received: %s", i, le);
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
}
return NULL;
}
static char* test_print_lsb_test_logger()
{
const char *tests[] =
{
""
, "7 test.print foo \t10\ttrue"
, NULL
};
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/print.lua", "log_level = 7;Logger = 'test.print';", &printer);
mu_assert(sb, "lsb_create() received: NULL");
lsb_err_value ret = lsb_init(sb, NULL);
mu_assert(!ret, "lsb_init() received: %s", ret);
for (int i = 0; tests[i]; ++i) {
print_out[0] = 0;
int result = lsb_test_process(sb, i);
mu_assert(result == 0, "test: %d received: %d error: %s", i, result, lsb_get_error(sb));
mu_assert(strcmp(tests[i], print_out) == 0, "test: %d expected: %s received: %s", i, tests[i], print_out);
}
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static int inject_message_analysis(lua_State *lua)
{
luaL_checktype(lua, 1, LUA_TTABLE);
lsb_lua_sandbox *lsb = lua_touserdata(lua, lua_upvalueindex(1));
if (NULL == lsb) {
return luaL_error(lua, "%s() invalid lightuserdata", im_func_name);
}
lsb_heka_sandbox *hsb = lsb_get_parent(lsb);
lua_pushstring(lua, hsb->name);
lua_setfield(lua, 1, LSB_LOGGER);
lua_pushstring(lua, hsb->hostname);
lua_setfield(lua, 1, LSB_HOSTNAME);
if (heka_encode_message_table(lsb, 1)) {
return luaL_error(lua, "%s() failed: %s", im_func_name, lsb_get_error(lsb));
}
size_t output_len = 0;
const char *output = lsb_get_output(lsb, &output_len);
if (hsb->cb.aim(hsb->parent, output, output_len) != 0) {
return luaL_error(lua, "%s() failed: rejected by the callback",
im_func_name);
}
++hsb->stats.im_cnt;
hsb->stats.im_bytes += output_len;
return 0;
}
int heka_encode_message(lua_State *lua)
{
int n = lua_gettop(lua);
bool framed = false;
switch (n) {
case 2:
luaL_checktype(lua, 2, LUA_TBOOLEAN);
framed = lua_toboolean(lua, 2);
// fall thru
case 1:
luaL_checktype(lua, 1, LUA_TTABLE);
break;
default:
return luaL_argerror(lua, n, "incorrect number of arguments");
}
lsb_lua_sandbox *lsb = lua_touserdata(lua, lua_upvalueindex(1));
if (!lsb) {
return luaL_error(lua, "encode_message() invalid upvalueindex");
}
lsb_heka_sandbox *hsb = lsb_get_parent(lsb);
set_missing_headers(lua, 1, hsb);
lsb->output.pos = 0;
lsb_err_value ret = heka_encode_message_table(lsb, 1);
if (ret) {
const char *err = lsb_get_error(lsb);
if (strlen(err) == 0) err = ret;
return luaL_error(lua, "encode_message() failed: %s", err);
}
size_t len = 0;
const char *output = lsb_get_output(lsb, &len);
lsb->usage[LSB_UT_OUTPUT][LSB_US_CURRENT] = len;
if (framed) {
char header[14] = "\x1e\x00\x08"; // up to 10 varint bytes and a \x1f
int hlen = lsb_pb_output_varint(header + 3, len) + 1;
lsb->usage[LSB_UT_OUTPUT][LSB_US_CURRENT] = len + hlen + LSB_HDR_FRAME_SIZE;
header[1] = (char)hlen;
header[hlen + 2] = '\x1f';
luaL_Buffer b;
luaL_buffinit(lua, &b);
luaL_addlstring(&b, header, hlen + LSB_HDR_FRAME_SIZE);
luaL_addlstring(&b, output, len);
luaL_pushresult(&b);
} else {
lua_pushlstring(lua, output, len);
}
if (lsb->usage[LSB_UT_OUTPUT][LSB_US_CURRENT]
> lsb->usage[LSB_UT_OUTPUT][LSB_US_MAXIMUM]) {
lsb->usage[LSB_UT_OUTPUT][LSB_US_MAXIMUM] =
lsb->usage[LSB_UT_OUTPUT][LSB_US_CURRENT];
}
return 1;
}
static char* test_simple_error()
{
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/simple.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
lsb_err_value ret = lsb_init(sb, NULL);
mu_assert(!ret, "lsb_init() received: %s", ret);
int result = lsb_test_process(sb, 1);
mu_assert(result == 0, "process() received: %d %s", result,
lsb_get_error(sb));
mu_assert(strcmp("ok", lsb_get_error(sb)) == 0, "process() received: %d %s", result,
lsb_get_error(sb));
result = lsb_test_process(sb, 0);
mu_assert(result == 0, "process() received: %d %s", result,
lsb_get_error(sb));
mu_assert(strcmp("", lsb_get_error(sb)) == 0, "process() received: %d %s", result,
lsb_get_error(sb));
result = lsb_test_process(sb, 2);
mu_assert(result == 1, "process() received: %d %s", result,
lsb_get_error(sb));
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static void terminate_sandbox(hs_analysis_thread* at, int i)
{
hs_log(g_module, 3, "terminated: %s msg: %s", at->list[i]->sb->name,
lsb_get_error(at->list[i]->sb->lsb));
free_analysis_plugin(at->list[i]);
free(at->list[i]);
at->list[i] = NULL;
--at->list_cnt;
}
static void shutdown_timer_event(hs_output_plugin* p)
{
if (lsb_get_state(p->sb->lsb) != LSB_TERMINATED) {
if (hs_timer_event(p->sb->lsb, time(NULL))) {
hs_log(g_module, 3, "terminated: %s msg: %s", p->sb->name,
lsb_get_error(p->sb->lsb));
}
}
}
static char* test_misc()
{
lsb_state s = lsb_get_state(NULL);
mu_assert(s == LSB_UNKNOWN, "lsb_get_state() received: %d", s);
const char* le = lsb_get_error(NULL);
mu_assert(strlen(le) == 0, "lsb_get_error() received: %s", le);
return NULL;
}
static char* test_core()
{
lsb_lua_sandbox *sb = lsb_create(NULL, "test.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
lsb_err_value ret = lsb_init(sb, NULL);
mu_assert(!ret, "lsb_init() received: %s %s", ret, lsb_get_error(sb));
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_cjson()
{
lua_sandbox* sb = lsb_create(NULL, "lua/cjson.lua", 32767, 1000,
32767);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
result = process(sb, 0);
mu_assert(result == 0, "process() received: %d %s", result,
lsb_get_error(sb));
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_init_error()
{
// null sandbox
lsb_err_value ret = lsb_init(NULL, NULL);
mu_assert(ret == LSB_ERR_UTIL_NULL, "lsb_init() null sandbox ptr");
// load error
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/simple1.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
ret = lsb_init(sb, NULL);
mu_assert(ret == LSB_ERR_LUA, "lsb_init() received: %s", lsb_err_string(ret));
lsb_state s = lsb_get_state(sb);
mu_assert(s == LSB_TERMINATED, "lsb_get_state() received: %d", s);
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
// out of memory
sb = lsb_create(NULL, "lua/simple.lua", "memory_limit = 6000", NULL);
mu_assert(sb, "lsb_create() received: NULL");
ret = lsb_init(sb, NULL);
mu_assert(ret == LSB_ERR_LUA, "lsb_init() received: %s", lsb_err_string(ret));
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s\n", e);
sb = lsb_create(NULL, "lua/no_external_modules.lua", NULL, NULL);
mu_assert(sb, "lsb_create() received: NULL");
// disabled external modules
ret = lsb_init(sb, NULL);
mu_assert(ret == LSB_ERR_LUA, "lsb_init() received: %s", lsb_err_string(ret));
const char *expected = "no 'path' configuration was specified for the "
"sandbox; external modules have been disabled";
mu_assert(strcmp(lsb_get_error(sb), expected) == 0,
"lsb_get_error() received: %s", lsb_get_error(sb));
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_simple()
{
lua_sandbox* sb = lsb_create(NULL, "lua/simple.lua", 65765, 1000,
1024);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
unsigned u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_CURRENT);
mu_assert(u > 0, "Current memory usage received: %u", u);
printf("cur_mem %u\n", u);
u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_MAXIMUM);
mu_assert(u > 0, "Maximum memory usage received: %u", u);
printf("max_mem %u\n", u);
u = lsb_usage(sb, LSB_UT_MEMORY, LSB_US_LIMIT);
mu_assert(u == 65765, "Memory limit received: %u", u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_CURRENT);
mu_assert(u == 7, "Current instructions received: %u", u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_MAXIMUM);
mu_assert(u == 7, "Maximum instructions received: %u", u);
printf("max_ins %u\n", u);
u = lsb_usage(sb, LSB_UT_INSTRUCTION, LSB_US_LIMIT);
mu_assert(u == 1000, "Instruction limit received: %u", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_CURRENT);
mu_assert(u == 0, "Current output received: %u", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_MAXIMUM);
mu_assert(u == 0, "Maximum output received: %u", u);
printf("max_out %u\n", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_LIMIT);
mu_assert(u == 1024, "Output limit received: %u", u);
u = lsb_usage(sb, LSB_UT_OUTPUT, LSB_US_LIMIT);
mu_assert(u == 1024, "Output limit received: %u", u);
lsb_state s = lsb_get_state(sb);
mu_assert(s == LSB_RUNNING, "lsb_get_state() received: %d", s);
e = lsb_destroy(sb, "simple.preserve");
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static char* test_errors()
{
const char* tests[] = {
"process() lua/errors.lua:9: library 'unknown' is not available"
, "process() lua/errors.lua:11: output() must have at least one argument"
, "process() not enough memory"
, "process() instruction_limit exceeded"
, "process() lua/errors.lua:20: attempt to perform arithmetic on global 'x' (a nil value)"
, "process() must return a single numeric value"
, "process() must return a single numeric value"
, "process() lua/errors.lua:27: output_limit exceeded"
, NULL
};
for (int i = 0; tests[i]; ++i) {
lua_sandbox* sb = lsb_create(NULL, "lua/errors.lua", 32767, 1000,
128);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
result = process(sb, i);
mu_assert(result == 1, "test: %d received: %d", i, result);
const char* le = lsb_get_error(sb);
mu_assert(le, "test: %d received NULL", i);
mu_assert(strcmp(tests[i], le) == 0, "test: %d received: %s", i, le);
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
}
return NULL;
}
static char* test_lpeg()
{
const char* expected = "{\"table\":[\"1\",\"string with spaces\","
"\"quoted string, with comma and \\\"quoted\\\" text\"]}\n";
lua_sandbox* sb = lsb_create(NULL, "lua/lpeg_csv.lua", 100000, 1000,
8000);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
lsb_add_function(sb, &write_output, "write");
result = process(sb, 0);
mu_assert(result == 0, "process() received: %d %s", result,
lsb_get_error(sb));
mu_assert(strcmp(expected, written_data) == 0, "received: %s", written_data);
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
return NULL;
}
static int inject_message(lua_State* L)
{
static unsigned char header[14];
void* luserdata = lua_touserdata(L, lua_upvalueindex(1));
if (NULL == luserdata) {
return luaL_error(L, "inject_message() invalid lightuserdata");
}
lua_sandbox* lsb = (lua_sandbox*)luserdata;
hs_analysis_plugin* p = (hs_analysis_plugin*)lsb_get_parent(lsb);
if (lua_type(L, 1) == LUA_TTABLE) {
lua_pushstring(L, p->sb->name);
lua_setfield(L, 1, "Logger");
lua_pushstring(L, p->at->plugins->cfg->hostname);
lua_setfield(L, 1, "Hostname");
lua_pushinteger(L, p->at->plugins->cfg->pid);
lua_setfield(L, 1, "Pid");
}
if (lsb_output_protobuf(lsb, 1, 0) != 0) {
return luaL_error(L, "inject_message() could not encode protobuf - %s",
lsb_get_error(lsb));
}
size_t output_len = 0;
const char* output = lsb_get_output(lsb, &output_len);
pthread_mutex_lock(&p->at->plugins->output.lock);
int len = hs_write_varint(header + 3, output_len);
int tlen = 4 + len + output_len;
++p->sb->stats.im_cnt;
p->sb->stats.im_bytes += tlen;
header[0] = 0x1e;
header[1] = (char)(len + 1);
header[2] = 0x08;
header[3 + len] = 0x1f;
fwrite(header, 4 + len, 1, p->at->plugins->output.fh);
fwrite(output, output_len, 1, p->at->plugins->output.fh);
p->at->plugins->output.offset += tlen;
if (p->at->plugins->output.offset >= (size_t)p->at->plugins->cfg->output_size) {
++p->at->plugins->output.id;
hs_open_output_file(&p->at->plugins->output);
}
pthread_mutex_unlock(&p->at->plugins->output.lock);
return 0;
}
void hs_load_analysis_plugins(hs_analysis_plugins* plugins,
const hs_config* cfg,
const char* path)
{
char dir[HS_MAX_PATH];
if (!hs_get_fqfn(path, hs_analysis_dir, dir, sizeof(dir))) {
hs_log(g_module, 0, "load path too long");
exit(EXIT_FAILURE);
}
struct dirent* entry;
DIR* dp = opendir(dir);
if (dp == NULL) {
exit(EXIT_FAILURE);
}
while ((entry = readdir(dp))) {
hs_sandbox_config sbc;
if (hs_load_sandbox_config(dir, entry->d_name,
&sbc, &cfg->apd, HS_SB_TYPE_ANALYSIS)) {
hs_analysis_plugin* p = create_analysis_plugin(cfg, &sbc);
if (p) {
p->sb->mm = hs_create_message_matcher(plugins->mmb,
sbc.message_matcher);
int ret = hs_init_analysis_sandbox(p->sb, &inject_message);
if (!p->sb->mm || ret) {
if (!p->sb->mm) {
hs_log(g_module, 3, "%s invalid message_matcher: %s",
p->sb->name,
sbc.message_matcher);
} else {
hs_log(g_module, 3, "lsb_init: %s received: %d %s",
p->sb->name, ret, lsb_get_error(p->sb->lsb));
}
free_analysis_plugin(p);
free(p);
p = NULL;
hs_free_sandbox_config(&sbc);
continue;
}
add_to_analysis_plugins(&sbc, plugins, p);
}
}
hs_free_sandbox_config(&sbc);
}
closedir(dp);
}
int write_output(lua_State* lua)
{
static const char* default_type = "txt";
// static const char* default_name = "";
void* luserdata = lua_touserdata(lua, lua_upvalueindex(1));
if (NULL == luserdata) {
luaL_error(lua, "write() invalid lightuserdata");
}
lua_sandbox* lsb = (lua_sandbox*)luserdata;
// void* ud = NULL;
const char* type = default_type;
// const char* name = default_name;
switch (lua_gettop(lua)) {
case 0:
break;
case 2:
// name = luaL_checkstring(lua, 2);
// fallthru
case 1:
switch (lua_type(lua, 1)) {
case LUA_TSTRING:
type = lua_tostring(lua, 1);
if (strlen(type) == 0) type = default_type;
break;
case LUA_TTABLE:
type = "";
if (lsb_output_protobuf(lsb, 1, 0) != 0) {
luaL_error(lua, "write() cound not encode protobuf - %s",
lsb_get_error(lsb));
}
break;
case LUA_TUSERDATA:
type = lsb_output_userdata(lsb, 1, 0);
break;
default:
luaL_typerror(lua, 1, "string, table, or circular_buffer");
break;
}
break;
default:
luaL_error(lua, "write() takes a maximum of 2 arguments");
break;
}
written_data = lsb_get_output(lsb, &written_data_len);
return 0;
}
static char* test_serialize_noglobal()
{
const char* output_file = "serialize_noglobal.preserve";
const char* expected = "preserve_global_data cannot access the global table";
lua_sandbox* sb = lsb_create(NULL, "lua/serialize_noglobal.lua",
32767, 1000, 1024);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
e = lsb_destroy(sb, output_file);
mu_assert(e, "lsb_destroy() received: no error");
mu_assert(strcmp(e, expected) == 0, "lsb_destroy() received: %s", e);
free(e);
mu_assert(file_exists(output_file) == 0, "output file was not cleaned up");
return NULL;
}
static char* benchmark_counter()
{
int iter = 10000000;
lua_sandbox* sb = lsb_create(NULL, "lua/counter.lua", 32000, 10, 0);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
clock_t t = clock();
for (int x = 0; x < iter; ++x) {
process(sb, 0);
}
t = clock() - t;
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
printf("benchmark_counter() %g seconds\n", ((float)t) / CLOCKS_PER_SEC / iter);
return NULL;
}
static char* benchmark_deserialize()
{
int iter = 10000;
clock_t t = clock();
for (int x = 0; x < iter; ++x) {
lua_sandbox* sb = lsb_create(NULL, "lua/serialize.lua", 32767, 1000,
1024);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, "output/serialize.data");
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
e = lsb_destroy(sb, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
}
t = clock() - t;
printf("benchmark_deserialize() %g seconds\n", ((float)t) / CLOCKS_PER_SEC / iter);
return NULL;
}
static char* benchmark_lua_types_output()
{
int iter = 1000000;
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/output.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
lsb_err_value ret = lsb_init(sb, NULL);
mu_assert(!ret, "lsb_init() received: %s", ret);
lsb_add_function(sb, &lsb_test_write_output, "write_output");
clock_t t = clock();
for (int x = 0; x < iter; ++x) {
mu_assert(0 == lsb_test_process(sb, 0), "%s", lsb_get_error(sb));
}
t = clock() - t;
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
printf("benchmark_lua_types_output() %g seconds\n", ((double)t)
/ CLOCKS_PER_SEC / iter);
return NULL;
}
static char* test_destroy_error()
{
const char* expected = "preserve_global_data could not open: "
"invaliddir/simple.preserve";
e = lsb_destroy(NULL, NULL);
mu_assert(!e, "lsb_destroy() received: %s", e);
lua_sandbox* sb = lsb_create(NULL, "lua/simple.lua", 65765, 1000,
1024);
mu_assert(sb, "lsb_create() received: NULL");
int result = lsb_init(sb, NULL);
mu_assert(result == 0, "lsb_init() received: %d %s", result,
lsb_get_error(sb));
e = lsb_destroy(sb, "invaliddir/simple.preserve");
mu_assert(e, "lsb_destroy() received NULL");
mu_assert(strcmp(e, expected) == 0,
"lsb_destroy() received: %s", e);
free(e);
e = NULL;
return NULL;
}
static char* benchmark_serialize()
{
int iter = 1000;
const char *output_file = "serialize.preserve";
clock_t t = clock();
for (int x = 0; x < iter; ++x) {
remove(output_file);
lsb_lua_sandbox *sb = lsb_create(NULL, "lua/serialize.lua", test_cfg, NULL);
mu_assert(sb, "lsb_create() received: NULL");
add_ud_module(sb);
lsb_err_value ret = lsb_init(sb, output_file);
mu_assert(!ret, "lsb_init() received: %s %s", ret, lsb_get_error(sb));
e = lsb_destroy(sb);
mu_assert(!e, "lsb_destroy() received: %s", e);
}
t = clock() - t;
printf("benchmark_serialize() %g seconds\n", ((double)t) / CLOCKS_PER_SEC
/ iter);
return NULL;
}
