int output_log_xml_init(struct output *o) {
struct output_log_xml_priv *priv = log_xml_init();
if (!priv)
return POM_ERR;
priv->p_source = ptype_alloc("string");
if (!priv->p_source)
goto err;
output_set_priv(o, priv);
struct registry_instance *inst = output_get_reg_instance(o);
priv->perf_events = registry_instance_add_perf(inst, "events", registry_perf_type_counter, "Number of events process", "events");
if (!priv->perf_events)
goto err;
struct registry_param *p = registry_new_param("filename", "log.xml", priv->p_filename, "XML log file", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
p = registry_new_param("source", "", priv->p_source, "Define the type of event being logged", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
return POM_OK;
err:
output_log_xml_cleanup(priv);
return POM_ERR;
}
int output_file_init(struct output *o) {
struct output_file_priv *priv = malloc(sizeof(struct output_file_priv));
if (!priv) {
pom_oom(sizeof(struct output_file_priv));
return POM_ERR;
}
memset(priv, 0, sizeof(struct output_file_priv));
output_set_priv(o, priv);
priv->p_listen_pload_evt = ptype_alloc("bool");
priv->p_path = ptype_alloc("string");
priv->p_filter = ptype_alloc("string");
if (!priv->p_path || !priv->p_listen_pload_evt || !priv->p_filter)
goto err;
struct registry_instance *inst = output_get_reg_instance(o);
priv->perf_files_closed = registry_instance_add_perf(inst, "files_closed", registry_perf_type_counter, "Number of files fully written and closed", "files");
priv->perf_files_open = registry_instance_add_perf(inst, "files_open", registry_perf_type_gauge, "Number of files currently open", "files");
priv->perf_bytes_written = registry_instance_add_perf(inst, "bytes_written", registry_perf_type_counter, "Number of bytes written", "bytes");
if (!priv->perf_files_closed || !priv->perf_files_open || !priv->perf_bytes_written)
goto err;
struct registry_param *p = registry_new_param("listen_pload_events", "no", priv->p_listen_pload_evt, "Listen to all events that generate payloads", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
p = registry_new_param("path", "/tmp/", priv->p_path, "Path where to store the files", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
p = registry_new_param("filter", "", priv->p_filter, "Payload filter", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
return POM_OK;
err:
if (p)
registry_cleanup_param(p);
output_file_cleanup(priv);
return POM_ERR;
}
static int output_inject_init(struct output *o) {
struct output_inject_priv *priv = malloc(sizeof(struct output_inject_priv));
if (!priv) {
pom_oom(sizeof(struct output_inject_priv));
return POM_ERR;
}
memset(priv, 0, sizeof(struct output_inject_priv));
output_set_priv(o, priv);
priv->p_interface = ptype_alloc("string");
priv->p_filter = ptype_alloc("string");
if (!priv->p_interface || !priv->p_filter)
goto err;
struct registry_instance *inst = output_get_reg_instance(o);
priv->perf_pkts_out = registry_instance_add_perf(inst, "pkts_out", registry_perf_type_counter, "Number of packets injected", "pkts");
priv->perf_bytes_out = registry_instance_add_perf(inst, "bytes_out", registry_perf_type_counter, "Number of packet bytes injected", "bytes");
char err[PCAP_ERRBUF_SIZE] = { 0 };
char *dev = pcap_lookupdev(err);
if (!dev) {
pomlog(POMLOG_WARN, "Warning, could not find a suitable interface to inject packets to : %s", err);
dev = "none";
}
struct registry_param *p = registry_new_param("interface", dev, priv->p_interface, "Output interface", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
p = registry_new_param("filter", "", priv->p_filter, "Filter", REGISTRY_PARAM_FLAG_NOT_LOCKED_WHILE_RUNNING);
if (output_add_param(o, p) != POM_OK)
goto err;
registry_param_set_callbacks(p, priv, output_inject_filter_parse, output_inject_filter_update);
return POM_OK;
err:
output_inject_cleanup(priv);
return POM_ERR;
}
int output_tap_init(struct output *o) {
struct output_tap_priv *priv = tap_init();
if (!priv)
return POM_ERR;
output_set_priv(o, priv);
struct registry_instance *inst = output_get_reg_instance(o);
priv->perf_pkts_out = registry_instance_add_perf(inst, "pkts_out", registry_perf_type_counter, "Number of packets processed", "pkts");
priv->perf_bytes_out = registry_instance_add_perf(inst, "bytes_out", registry_perf_type_counter, "Number of bytes processed", "bytes");
if (!priv->perf_pkts_out || !priv->perf_bytes_out)
goto err;
struct registry_param *p = registry_new_param("ifname", "pom0", priv->p_ifname, "Name of the interface to create", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
p = registry_new_param("persistent", "no", priv->p_persistent, "Create a persistent interface", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
p = registry_new_param("filter", "", priv->p_filter, "Filter", REGISTRY_PARAM_FLAG_NOT_LOCKED_WHILE_RUNNING);
if (output_add_param(o, p) != POM_OK)
goto err;
registry_param_set_callbacks(p, priv, output_tap_filter_parse, output_tap_filter_update);
return POM_OK;
err:
output_tap_cleanup(priv);
return POM_ERR;
}
int addon_output_init(struct output *o) {
struct addon *addon = o->info->reg_info->mod->priv;
lua_State *L = addon_create_state(addon->filename); // Stack : empty
if (!L) {
pomlog(POMLOG_ERR "Error while creating new lua state for output %s", o->info->reg_info->name);
return POM_ERR;
}
// Get the output from the outputs table
lua_getfield(L, LUA_REGISTRYINDEX, ADDON_OUTPUTS_TABLE); // Stack : outputs
lua_getfield(L, -1, o->info->reg_info->name); // Stack : outputs, output
// Get rid of the outputs table
lua_remove(L, -2); // Stack : output
lua_pushnil(L); // Stack : output, nil
lua_setfield(L, LUA_REGISTRYINDEX, ADDON_OUTPUTS_TABLE); // Stack : output
// Add the output to the registry
lua_pushvalue(L, -1); // Stack : output, output
lua_setfield(L, LUA_REGISTRYINDEX, ADDON_INSTANCE); // Stack : output
// Create the private data
// TODO make __priv read-only
struct addon_instance_priv *p = lua_newuserdata(L, sizeof(struct addon_instance_priv)); // Stack : output, priv
if (!p) {
pom_oom(sizeof(struct addon_instance_priv));
return POM_ERR;
}
memset(p, 0, sizeof(struct addon_instance_priv));
o->priv = p;
p->instance = o;
p->L = L;
if (pthread_mutex_init(&p->lock, NULL)) {
pomlog(POMLOG_ERR "Error while initializing mutex : %s", pom_strerror(errno));
abort();
return POM_ERR;
}
// Assign the output_priv metatable
luaL_getmetatable(L, ADDON_OUTPUT_PRIV_METATABLE); // Stack : output, priv, metatable
lua_setmetatable(L, -2); // Stack : output, priv
// Add it to __priv
lua_setfield(L, -2, "__priv"); // Stack : output
// Fetch the parameters table
lua_getfield(L, -1, "__params"); // Stack : output, params
// Parse each param from the class
lua_pushnil(L); // Stack : output, params, nil
while (lua_next(L, -2) != 0) { // Stack : output, params, key, param
if (!lua_istable(L, -1)) {
pomlog(POMLOG_ERR "Parameters should be described in tables");
goto err;
}
// Fetch the name
lua_pushinteger(L, 1); // Stack : output, params, key, param, 1
lua_gettable(L, -2); // Stack : output, params, key, param, name
if (!lua_isstring(L, -1)) {
pomlog(POMLOG_ERR "Parameter name is not a string");
goto err;
}
const char *name = luaL_checkstring(L, -1);
lua_pop(L, 1); // Stack : output, params, key, param
// Fetch the ptype type
lua_pushinteger(L, 2); // Stack : output, params, key, param, 2
lua_gettable(L, -2); // Stack : output, params, key, param, type
if (!lua_isstring(L, -1)) {
pomlog(POMLOG_ERR "Parameter type is not a string");
goto err;
}
const char *type = lua_tostring(L, -1);
lua_pop(L, 1); // Stack : output, params, key, param
// Fetch the default value
lua_pushinteger(L, 3); // Stack : output, params, key, param, 3
lua_gettable(L, -2); // Stack : output, params, key, param, defval
if (!lua_isstring(L, -1)) {
pomlog(POMLOG_ERR "Parameter default value is not a string");
goto err;
}
const char *defval = lua_tostring(L, -1);
lua_pop(L, 1); // Stack : output, params, key, param
// Fetch the description
lua_pushinteger(L, 4); // Stack : output, params, key, param, 4
lua_gettable(L, -2); // Stack : output, params, key, param, descr
if (!lua_isstring(L, -1)) {
pomlog(POMLOG_ERR "Parameter description is not a string");
goto err;
}
const char *descr = lua_tostring(L, -1);
lua_pop(L, 1); // Stack : output, params, key, param
// Allocate it
struct addon_param *param = malloc(sizeof(struct addon_param));
if (!param) {
pom_oom(sizeof(struct addon_param));
goto err;
}
param->name = strdup(name);
if (!param->name) {
free(param);
pom_oom(strlen(name) + 1);
goto err;
}
param->value = ptype_alloc(type);
if (!param->value) {
free(param->name);
free(param);
goto err;
}
struct registry_param *reg_param = registry_new_param((char*)name, (char*)defval, param->value, (char*)descr, 0);
if (output_add_param(o, reg_param) != POM_OK) {
pomlog(POMLOG_ERR "Error while adding parameter to the output instance");
if (reg_param)
registry_cleanup_param(reg_param);
free(param->name);
ptype_cleanup(param->value);
free(param);
goto err;
}
param->next = p->params;
p->params = param;
// Pop the value (the param table)
lua_pop(L, 1); // Stack : output, params, key
}
// At this point the stack is : output, params
lua_pop(L, 2); // Stack : empty
pomlog(POMLOG_DEBUG "Output %s created", o->name);
return POM_OK;
err:
lua_close(L);
p->L = NULL;
return POM_ERR;
}
