TEST_F(JitCompilerTest, AddsAndRemovesModules) {
auto compiler = JitCompiler{};
ASSERT_THROW(compiler.find_symbol<int32_t(int32_t, int32_t)>(_add_fn_symbol), std::logic_error);
auto module_handle = compiler.add_module(std::move(_module));
compiler.find_symbol<int32_t(int32_t, int32_t)>(_add_fn_symbol);
compiler.remove_module(module_handle);
ASSERT_THROW(compiler.find_symbol<int32_t(int32_t, int32_t)>(_add_fn_symbol), std::logic_error);
}
/* Perform some additional tasks to panels before they are being
* parsed.
*
* Note: This overwrites --enable-panel since it assumes there's
* truly nothing to do with the panel */
void
verify_panels (void)
{
int ignore_panel_idx = conf.ignore_panel_idx;
/* Remove virtual host panel if no '%v' within log format */
if (!conf.log_format)
return;
if (!strstr (conf.log_format, "%v") && ignore_panel_idx < TOTAL_MODULES) {
if (str_inarray ("VIRTUAL_HOSTS", conf.ignore_panels, ignore_panel_idx) < 0)
remove_module (VIRTUAL_HOSTS);
}
if (!strstr (conf.log_format, "%e") && ignore_panel_idx < TOTAL_MODULES) {
if (str_inarray ("REMOTE_USER", conf.ignore_panels, ignore_panel_idx) < 0)
remove_module (REMOTE_USER);
}
}
/*
* -- do_config
*
* Apply the configuration on the map. It expects each useful line to
* start with a known keyword. Note the unconventional return values.
* It returns NULL if successful or an error string in case of error.
*
*/
static char *
do_config(struct _como * m, int argc, char *argv[])
{
static char errstr[1024];
static int scope = CTX_GLOBAL; /* scope of current keyword */
static module_t * mdl = NULL; /* module currently open */
static int node_id = 0; /* current node */
static alias_t * alias = NULL; /* alias currently open */
keyword_t *t;
/*
* run some checks on the token (i.e., that it exists
* and that we have all the arguments it needs).
*/
t = match_token(argv[0], keywords);
if (t == NULL) {
sprintf(errstr, "unknown token \"%s\"\n", argv[0]);
return errstr;
}
if (argc < t->nargs) {
sprintf(errstr, "\"%s\", requires at least %d arguments\n", argv[0],
t->nargs);
return errstr;
}
/*
* Check if the keyword is ok in the current scope.
*/
if (!(t->scope & scope)) {
sprintf(errstr, "\"%s\" out of scope\n", argv[0]);
return errstr;
}
/*
* configuration actions
*/
switch (t->action) {
case TOK_DBDIR:
if (m->cli_args.dbdir_set == 0) {
safe_dup(&m->dbdir, argv[1]);
}
break;
case TOK_QUERYPORT:
if (m->cli_args.query_port_set == 0 || node_id > 0) {
m->node[node_id].query_port = atoi(argv[1]);
}
break;
case TOK_DESCRIPTION:
if (scope == CTX_MODULE)
safe_dup(&mdl->description, argv[1]);
else
safe_dup(&alias->description, argv[1]);
break;
case TOK_END:
if (scope == CTX_MODULE) {
/*
* "end" of a module configuration. run some checks depending
* on context to make sure that all mandatory fields are there
* and set default values
*/
if (check_module(m, mdl)) {
remove_module(m, mdl);
scope = CTX_GLOBAL;
break;
}
if (m->runmode == RUNMODE_INLINE)
m->inline_mdl = mdl;
logmsg(LOGUI, "... module%s %s [%d][%d] ",
(mdl->running == RUNNING_ON_DEMAND) ? " on-demand" : "",
mdl->name, mdl->node, mdl->priority);
logmsg(LOGUI, " filter %s; out %s (%uMB)\n",
mdl->filter_str, mdl->output, mdl->streamsize/(1024*1024));
} else if (scope == CTX_VIRTUAL) {
/*
* we are done with this virtual node. let's go back to
* the master node (i.e. node_id == 0)
*/
node_id = 0;
}
scope = CTX_GLOBAL;
break;
case TOK_FILTER:
if (scope == CTX_MODULE)
safe_dup(&mdl->filter_str, argv[1]);
else if (scope == CTX_VIRTUAL)
safe_dup(&m->node[node_id].filter_str, argv[1]);
break;
case TOK_HASHSIZE:
mdl->ex_hashsize = mdl->ca_hashsize = atoi(argv[1]);
break;
case TOK_SOURCE:
if (scope == CTX_MODULE) {
safe_dup(&mdl->source, argv[1]);
} else {
safe_dup(&m->node[node_id].source, argv[1]);
}
break;
case TOK_LIBRARYDIR:
if (m->cli_args.libdir_set == 0) {
safe_dup(&m->libdir, argv[1]);
}
break;
case TOK_LOGFLAGS:
if (m->cli_args.logflags_set == 0) {
m->logflags = set_flags(0, argv[1]);
}
break;
case TOK_MEMSIZE:
/* this keyword can be used in two contexts */
if (m->cli_args.mem_size_set == 0) {
m->mem_size = atoi(argv[1]);
}
break;
case TOK_MODULE:
if (scope == CTX_GLOBAL) {
int node = (m->runmode == RUNMODE_INLINE? -1 : 0);
mdl = new_module(m, argv[1], node, -1);
scope = CTX_MODULE; /* change scope */
} else {
safe_dup(&alias->module, argv[1]);
}
break;
case TOK_MODULE_MAX:
m->module_max = atoi(argv[1]);
m->modules = safe_realloc(m->modules, sizeof(module_t)*m->module_max);
break;
case TOK_OUTPUT:
safe_dup(&mdl->output, argv[1]);
break;
case TOK_SNIFFER:
add_sniffer(m, argv[1], argv[2], argc > 3 ? argv[3] : NULL);
break;
case TOK_STREAMSIZE:
mdl->streamsize = parse_size(argv[1]);
break;
case TOK_MAXFILESIZE:
m->maxfilesize = parse_size(argv[1]);
if (m->maxfilesize > 1024*1024*1024) {
m->maxfilesize = DEFAULT_FILESIZE;
sprintf(errstr, "'filesize' should be < 1GB --> set to %dMB\n",
(int)(m->maxfilesize / (1024*1024)));
return errstr;
}
break;
case TOK_ARGS:
/* copy the arguments. one line may have multiple arguments
* starting from argv[1]. that's why we pass the pointer to
* argv[1] and reduce argc by one.
*/
if (scope == CTX_MODULE)
mdl->args = copy_args(mdl->args, &argv[1], argc - 1);
else if (scope == CTX_VIRTUAL)
m->node[node_id].args = copy_args(m->node->args, &argv[1], argc-1);
else if (scope == CTX_ALIAS) {
alias->args = copy_args(alias->args, &argv[1], argc - 1);
alias->ac += argc - 1;
}
break;
case TOK_ARGSFILE:
if (scope == CTX_MODULE) {
mdl->args = copy_args_from_file(mdl->args, argv[1], NULL);
} else if (scope == CTX_VIRTUAL) {
m->node[node_id].args =
copy_args_from_file(m->node[node_id].args, argv[1], NULL);
} else if (scope == CTX_ALIAS) {
int count;
alias->args = copy_args_from_file(alias->args, argv[1], &count);
alias->ac += count;
}
break;
case TOK_PRIORITY:
mdl->priority = atoi(argv[1]);
break;
case TOK_RUNNING:
mdl->running = (strcmp(argv[1], "on-demand") == 0) ?
RUNNING_ON_DEMAND : RUNNING_NORMAL;
break;
case TOK_NAME:
safe_dup(&m->node[node_id].name, argv[1]);
break;
case TOK_LOCATION:
safe_dup(&m->node[node_id].location, argv[1]);
break;
case TOK_TYPE:
safe_dup(&m->node[node_id].type, argv[1]);
break;
case TOK_COMMENT:
safe_dup(&m->node[node_id].comment, argv[1]);
break;
case TOK_VIRTUAL:
m->node = safe_realloc(m->node, (m->node_count + 1) * sizeof(node_t));
node_id = m->node_count;
bzero(&m->node[node_id], sizeof(node_t));
safe_dup(&m->node[node_id].name, argv[1]);
m->node[node_id].location = strdup("Unknown");
m->node[node_id].type = strdup("Unknown");
m->node_count++;
scope = CTX_VIRTUAL;
break;
case TOK_ALIAS:
alias = safe_calloc(1, sizeof(alias_t));
safe_dup(&alias->name, argv[1]);
alias->next = m->aliases;
m->aliases = alias;
scope = CTX_ALIAS;
break;
case TOK_ASNFILE:
safe_dup(&m->asnfile, argv[1]);
break;
case TOK_LIVE_THRESH:
m->live_thresh = TIME2TS(0, atoi(argv[1]));
break;
default:
sprintf(errstr, "unknown keyword %s\n", argv[0]);
return errstr;
}
return NULL;
}
void remove_selected_module(){
remove_module(selected_module);
selected_module = NULL;
}
void clear_rack() {
while(modules.size()>0)
remove_module(*modules.begin());
}
/*
* -- do_config
*
* Apply the configuration on the map. It expects each useful line to
* start with a known keyword. Note the unconventional return values.
* It returns NULL if successful or an error string in case of error.
*
*/
static char *
do_config(struct _como * m, int argc, char *argv[])
{
static char errstr[1024];
static int scope = CTX_GLOBAL; /* scope of current keyword */
static module_t * mdl = NULL; /* module currently open */
keyword_t *t;
/*
* run some checks on the token (i.e., that it exists
* and that we have all the arguments it needs).
*/
t = match_token(argv[0], keywords);
if (t == NULL) {
sprintf(errstr, "unknown token \"%s\"\n", argv[0]);
return errstr;
}
if (argc < t->nargs) {
sprintf(errstr, "\"%s\", requires at least %d arguments\n", argv[0],
t->nargs);
return errstr;
}
/*
* Check if the keyword is ok in the current scope.
*/
if (!(t->scope & scope)) {
sprintf(errstr, "\"%s\" out of scope\n", argv[0]);
return errstr;
}
/*
* configuration actions
*/
switch (t->action) {
case TOK_BASEDIR:
safe_dup(&m->basedir, argv[1]);
break;
case TOK_QUERYPORT:
m->node->query_port = atoi(argv[1]);
break;
case TOK_DESCRIPTION:
safe_dup(&mdl->description, argv[1]);
break;
case TOK_END:
if (scope == CTX_MODULE) {
/*
* "end" of a module configuration. run some checks depending
* on context to make sure that all mandatory fields are there
* and set default values
*/
if (check_module(m, mdl)) {
remove_module(m, mdl);
scope = CTX_GLOBAL;
break;
}
if (m->running == INLINE)
m->inline_mdl = mdl;
logmsg(LOGUI, "... module%s %s [%d][%d] ",
(mdl->running == RUNNING_ON_DEMAND) ? " on-demand" : "",
mdl->name, mdl->node, mdl->priority);
logmsg(LOGUI, " filter %s; out %s (%uMB)\n",
mdl->filter_str, mdl->output, mdl->streamsize/(1024*1024));
if (mdl->description != NULL)
logmsg(LOGUI, " -- %s\n", mdl->description);
scope = CTX_GLOBAL;
} else if (scope == CTX_VIRTUAL) {
/*
* we are done with this virtual node. let's recover
* the master node (associated with the global context)
*/
node_t *p, *q;
for (p = m->node, q = NULL; p->id != 0; q = p, p = p->next)
;
if (q) {
/* the master node is not at the head of the list.
* move it there.
*/
q->next = p->next;
p->next = m->node;
m->node = p;
}
scope = CTX_GLOBAL;
}
break;
case TOK_FILTER:
if (scope == CTX_MODULE)
safe_dup(&mdl->filter_str, argv[1]);
else if (scope == CTX_VIRTUAL)
safe_dup(&m->node->filter_str, argv[1]);
break;
case TOK_HASHSIZE:
mdl->ex_hashsize = mdl->ca_hashsize = atoi(argv[1]);
break;
case TOK_SOURCE:
safe_dup(&mdl->source, argv[1]);
break;
case TOK_LIBRARYDIR:
safe_dup(&m->libdir, argv[1]);
break;
case TOK_LOGFLAGS:
m->logflags = set_flags(0, argv[1]);
break;
case TOK_MEMSIZE:
/* this keyword can be used in two contexts */
m->mem_size = atoi(argv[1]);
if (m->mem_size <= 0 || m->mem_size > 512) {
sprintf(errstr,
"invalid memory size %d, range is 1..512\n",
m->mem_size);
return errstr;
}
break;
case TOK_MODULE:
mdl = new_module(m, argv[1], (m->running == INLINE? -1 : 0), -1);
scope = CTX_MODULE; /* change scope */
break;
case TOK_MODULE_MAX:
m->module_max = atoi(argv[1]);
m->modules = safe_realloc(m->modules, sizeof(module_t)*m->module_max);
break;
case TOK_OUTPUT:
safe_dup(&mdl->output, argv[1]);
break;
case TOK_SNIFFER:
add_sniffer(m, argv[1], argv[2], argc > 3 ? argv[3] : NULL);
break;
case TOK_STREAMSIZE:
mdl->streamsize = parse_size(argv[1]);
break;
case TOK_MAXFILESIZE:
m->maxfilesize = parse_size(argv[1]);
if (m->maxfilesize > 1024*1024*1024) {
m->maxfilesize = DEFAULT_FILESIZE;
sprintf(errstr, "'filesize' should be < 1GB --> set to %dMB\n",
m->maxfilesize / (1024*1024));
return errstr;
}
break;
case TOK_ARGS:
do {
int i,j;
if (mdl->args == NULL) {
mdl->args = safe_calloc(argc, sizeof(char *));
j = 0;
} else {
/*
* we need to add the current list of optional arguments
* to the list we already have. first, count how many we
* have got so far and then reallocate memory accordingly
*/
for (j = 0; mdl->args[j]; j++)
;
mdl->args = safe_realloc(mdl->args, (argc + j) * sizeof(char*));
}
for (i = 1; i < argc; i++)
mdl->args[i+j-1] = safe_strdup(argv[i]);
/*
* Last position is set to null to be able to know
* when args finish from the modules
*/
mdl->args[i+j-1] = NULL;
} while (0);
break;
case TOK_ARGSFILE:
do {
FILE *auxfp;
char line[512];
int j;
/* open the file */
auxfp = fopen(argv[1], "r");
if (auxfp == NULL) {
sprintf(errstr, "opening file %s: %s\n", argv[1],
strerror(errno));
return errstr;
}
/* count the number of arguments we already have */
for (j = 0; mdl->args[j]; j++)
;
/* read each line in the file and parse it again */
/* XXX we reallocate mdl->args for each line in the file.
* this should be done better in a less expensive way.
*/
while (fgets(line, sizeof(line), auxfp)) {
j++;
mdl->args = safe_realloc(mdl->args, j * sizeof(char *));
mdl->args[j - 1] = safe_strdup(line);
}
/* add the last NULL pointer */
mdl->args = safe_realloc(mdl->args, (j + 1) * sizeof(char *));
mdl->args[j] = NULL;
fclose(auxfp);
} while (0);
break;
case TOK_PRIORITY:
mdl->priority = atoi(argv[1]);
break;
case TOK_RUNNING:
mdl->running = (strcmp(argv[1], "on-demand") == 0) ?
RUNNING_ON_DEMAND : RUNNING_NORMAL;
break;
case TOK_NAME:
safe_dup(&m->node->name, argv[1]);
break;
case TOK_LOCATION:
safe_dup(&m->node->location, argv[1]);
break;
case TOK_TYPE:
safe_dup(&m->node->type, argv[1]);
break;
case TOK_COMMENT:
safe_dup(&m->node->comment, argv[1]);
break;
case TOK_VIRTUAL:
do {
node_t * node;
node = safe_calloc(1, sizeof(struct _node));
node->id = m->node_count;
safe_dup(&node->name, argv[1]);
node->next = m->node;
m->node = node;
m->node_count++;
scope = CTX_VIRTUAL;
} while (0);
break;
default:
sprintf(errstr, "unknown keyword %s\n", argv[0]);
return errstr;
}
return NULL;
}
