void
cf_path(char *path)
{
cf_filename = strdup(path);
if (cf_filename == NULL)
{
log_sys_die(EX_OSERR, "cf_file: strdup");
}
return;
}
static void *
module_symbol_load(void *handle, char *path, char *suffix, int die)
{
char symbol[BUFLEN];
char *error;
int len;
void *p;
module_symbol_name(path, symbol, sizeof symbol);
len = strlen(symbol);
/*
* Append _suffix
*/
if (sizeof symbol < len + strlen(suffix) + 2)
{
log_die(EX_SOFTWARE, "module_symbol_load: buffer exhausted");
}
symbol[len++] = '_';
strcpy(symbol + len, suffix);
/*
* Clear existing error
*/
dlerror();
/*
* Load symbol
*/
p = dlsym(handle, symbol);
error = (char *) dlerror();
if (error == NULL)
{
return p;
}
if(die)
{
log_sys_die(EX_SOFTWARE, "module_symbol_load: dlsym: %s", error);
}
log_debug("module_symbol_load: dlsym: %s", error);
return p;
}
static acl_reply_t *
acl_reply_create(void)
{
acl_reply_t *ar;
ar = (acl_reply_t *) malloc(sizeof (acl_reply_t));
if (ar == NULL)
{
log_sys_die(EX_OSERR, "acl_reply_create: malloc");
}
memset(ar, 0, sizeof (acl_reply_t));
return ar;
}
static void
cf_setup_hostname(void **data)
{
char buffer[1024];
if (gethostname(buffer, sizeof(buffer))) {
log_sys_error("cf_setup_hostname: gethostname failed");
strcpy(buffer, "unknown");
}
*data = strdup(buffer);
if (*data == NULL) {
log_sys_die(EX_CONFIG, "cf_setup_hostname: strdup");
}
return;
}
exp_t *
exp_ternary_cond(exp_t *condition, exp_t *cond_true, exp_t *cond_false)
{
exp_ternary_condition_t *etc;
etc = (exp_ternary_condition_t *)
malloc(sizeof (exp_ternary_condition_t));
if (etc == NULL)
{
log_sys_die(EX_OSERR, "exp_ternary_cond: malloc");
}
etc->etc_condition = condition;
etc->etc_true = cond_true;
etc->etc_false = cond_false;
return exp_create(EX_TERNARY_COND, etc);
}
static void
cf_load_defaults(void)
{
char *buffer = &_binary_cf_defaults_conf_start;
size_t size = &_binary_cf_defaults_conf_end - buffer;
cf_in = fmemopen(buffer, size, "r");
if (cf_in == NULL)
{
log_sys_die(EX_OSERR, "cf_load_defaults: fmemopen failed");
}
log_debug("cf_init: load default configuration");
parser(&cf_parser, "BUILT-IN CONFIGURATION", 0, &cf_in, cf_parse);
parser_clear(&cf_parser);
fclose(cf_in);
return;
}
exp_t *
exp_create(exp_type_t type, void *data)
{
exp_t *exp;
exp = (exp_t *) malloc(sizeof (exp_t));
if (exp == NULL)
{
log_sys_die(EX_OSERR, "exp_create: malloc");
}
exp->ex_type = type;
exp->ex_data = data;
if (LL_INSERT(exp_garbage, exp) == -1)
{
log_die(EX_OSERR, "exp_create: LL_INSERT failed");
}
return exp;
}
exp_t *
exp_function(char *id, exp_t *args)
{
exp_function_t *ef;
if (acl_function_lookup(id) == NULL)
{
acl_parser_error("unknown function \"%s\"", id);
}
ef = (exp_function_t *) malloc(sizeof (exp_function_t));
if (ef == NULL)
{
log_sys_die(EX_OSERR, "exp_function: malloc");
}
ef->ef_name = id;
ef->ef_args = args;
return exp_create(EX_FUNCTION, ef);
}
exp_t *
exp_operation(int operator, exp_t *op1, exp_t *op2)
{
exp_operation_t *eo;
eo = (exp_operation_t *) malloc(sizeof (exp_operation_t));
if (eo == NULL)
{
log_sys_die(EX_OSERR, "exp_operation: malloc");
}
eo->eo_operator = operator;
eo->eo_operand[0] = op1;
eo->eo_operand[1] = op2;
if (operator == '=' && op1->ex_type != EX_VARIABLE)
{
acl_parser_error("bad use of '=' operator");
}
return exp_create(EX_OPERATION, eo);
}
msgmod_t *
msgmod_create(msgmod_mod_t mod, msgmod_target_t target, ...)
{
msgmod_t *mm;
va_list ap;
exp_t *exp;
mm = (msgmod_t *) malloc(sizeof (msgmod_t));
if (mm == NULL)
{
log_sys_die(EX_OSERR, "msgmod_create: malloc");
}
mm->mm_callback = msgmod_get_callback(mod, target);
if (mm->mm_callback == NULL)
{
acl_parser_error("syntax error (msgmod callback)");
// Not reached.
return NULL;
}
mm->mm_args = ll_create();
if (mm->mm_args == NULL)
{
log_die(EX_SOFTWARE, "msgmod_create: ll_create failed");
}
va_start(ap, target);
while ((exp = va_arg(ap, exp_t *)))
{
if (LL_INSERT(mm->mm_args, exp) == -1)
{
log_die(EX_SOFTWARE, "msgmod_create: LL_INSERT failed");
}
}
return mm;
}
void
module_load(char *file)
{
module_t *mod;
VAR_INT_T *load;
char key[256];
if (util_stripped_filename(key, sizeof key, file))
{
log_die(EX_SOFTWARE, "module_load: util_stripped_filename failed");
}
load = (VAR_INT_T *) cf_get_value(VT_INT, "modules", key, NULL);
if (load != NULL)
{
if (!*load)
{
log_debug("module_glob: %s disabled in config", file);
return;
}
}
log_debug("module_glob: load %s", file);
mod = (module_t *) malloc(sizeof (module_t));
if (mod == NULL)
{
log_sys_die(EX_SOFTWARE, "module_load: malloc");
}
mod->mod_path = strdup(file);
mod->mod_name = strrchr(mod->mod_path, '/') + 1;
/*
* Open module
*/
mod->mod_handle = dlopen(file, RTLD_LAZY);
if (mod->mod_handle == NULL)
{
log_sys_die(EX_SOFTWARE, "module_load: dlopen: %s", dlerror());
}
/*
* Load Symbols
*/
mod->mod_init = module_symbol_load(mod->mod_handle, file, "init", 1);
mod->mod_fini = module_symbol_load(mod->mod_handle, file, "fini", 0);
/*
* Initialize module
*/
if (mod->mod_init())
{
log_die(EX_SOFTWARE, "module_load: %s: init failed",
mod->mod_name);
}
if (LL_INSERT(module_list, mod) == -1)
{
log_die(EX_SOFTWARE, "module_load: LL_INSERT failed");
}
return;
}
