/*
* Check dependencies for an object
*/
static bool
ucl_schema_validate_dependencies (const ucl_object_t *deps,
const ucl_object_t *obj, struct ucl_schema_error *err,
const ucl_object_t *root)
{
const ucl_object_t *elt, *cur, *cur_dep;
ucl_object_iter_t iter = NULL, piter;
bool ret = true;
while (ret && (cur = ucl_iterate_object (deps, &iter, true)) != NULL) {
elt = ucl_object_find_key (obj, ucl_object_key (cur));
if (elt != NULL) {
/* Need to check dependencies */
if (cur->type == UCL_ARRAY) {
piter = NULL;
while (ret && (cur_dep = ucl_iterate_object (cur, &piter, true)) != NULL) {
if (ucl_object_find_key (obj, ucl_object_tostring (cur_dep)) == NULL) {
ucl_schema_create_error (err, UCL_SCHEMA_MISSING_DEPENDENCY, elt,
"dependency %s is missing for key %s",
ucl_object_tostring (cur_dep), ucl_object_key (cur));
ret = false;
break;
}
}
}
else if (cur->type == UCL_OBJECT) {
ret = ucl_schema_validate (cur, obj, true, err, root);
}
}
}
return ret;
}
static bool
ucl_schema_validate_string (const ucl_object_t *schema,
const ucl_object_t *obj, struct ucl_schema_error *err)
{
const ucl_object_t *elt;
ucl_object_iter_t iter = NULL;
bool ret = true;
int64_t constraint;
#ifdef HAVE_REGEX_H
regex_t re;
#endif
while (ret && (elt = ucl_iterate_object (schema, &iter, true)) != NULL) {
if (elt->type == UCL_INT &&
strcmp (ucl_object_key (elt), "maxLength") == 0) {
constraint = ucl_object_toint (elt);
if (obj->len > constraint) {
ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj,
"string is too big: %.3f, maximum is: %.3f",
obj->len, constraint);
ret = false;
break;
}
}
else if (elt->type == UCL_INT &&
strcmp (ucl_object_key (elt), "minLength") == 0) {
constraint = ucl_object_toint (elt);
if (obj->len < constraint) {
ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj,
"string is too short: %.3f, minimum is: %.3f",
obj->len, constraint);
ret = false;
break;
}
}
#ifdef HAVE_REGEX_H
else if (elt->type == UCL_STRING &&
strcmp (ucl_object_key (elt), "pattern") == 0) {
if (regcomp (&re, ucl_object_tostring (elt),
REG_EXTENDED | REG_NOSUB) != 0) {
ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt,
"cannot compile pattern %s", ucl_object_tostring (elt));
ret = false;
break;
}
if (regexec (&re, ucl_object_tostring (obj), 0, NULL, 0) != 0) {
ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj,
"string doesn't match regexp %s",
ucl_object_tostring (elt));
ret = false;
}
regfree (&re);
}
#endif
}
return ret;
}
static gboolean
rspamd_symbols_cache_process_settings (struct rspamd_task *task,
struct symbols_cache *cache)
{
const ucl_object_t *wl, *cur, *disabled;
struct metric *def;
struct rspamd_symbols_group *gr;
GHashTableIter gr_it;
ucl_object_iter_t it = NULL;
gpointer k, v;
wl = ucl_object_lookup (task->settings, "whitelist");
if (wl != NULL) {
msg_info_task ("<%s> is whitelisted", task->message_id);
task->flags |= RSPAMD_TASK_FLAG_SKIP;
return TRUE;
}
disabled = ucl_object_lookup (task->settings, "symbols_disabled");
if (disabled) {
it = NULL;
while ((cur = ucl_iterate_object (disabled, &it, true)) != NULL) {
rspamd_symbols_cache_disable_symbol (task, cache,
ucl_object_tostring (cur));
}
}
/* Disable groups of symbols */
disabled = ucl_object_lookup (task->settings, "groups_disabled");
def = g_hash_table_lookup (task->cfg->metrics, DEFAULT_METRIC);
if (def && disabled) {
it = NULL;
while ((cur = ucl_iterate_object (disabled, &it, true)) != NULL) {
if (ucl_object_type (cur) == UCL_STRING) {
gr = g_hash_table_lookup (def->groups,
ucl_object_tostring (cur));
if (gr) {
g_hash_table_iter_init (&gr_it, gr->symbols);
while (g_hash_table_iter_next (&gr_it, &k, &v)) {
rspamd_symbols_cache_disable_symbol (task, cache, k);
}
}
}
}
}
return FALSE;
}
static int
pkg_set_dirs_from_object(struct pkg *pkg, ucl_object_t *obj)
{
ucl_object_t *cur;
ucl_object_iter_t it = NULL;
const char *uname = NULL;
const char *gname = NULL;
void *set;
mode_t perm = 0;
bool try = false;
struct sbuf *dirname = NULL;
const char *key, *okey;
okey = ucl_object_key(obj);
if (okey == NULL)
return (EPKG_FATAL);
urldecode(okey, &dirname);
while ((cur = ucl_iterate_object(obj, &it, true))) {
key = ucl_object_key(cur);
if (key == NULL)
continue;
if (!strcasecmp(key, "uname") && cur->type == UCL_STRING)
uname = ucl_object_tostring(cur);
else if (!strcasecmp(key, "gname") && cur->type == UCL_STRING)
gname = ucl_object_tostring(cur);
else if (!strcasecmp(key, "perm") &&
(cur->type == UCL_STRING || cur->type == UCL_INT)) {
if ((set = setmode(ucl_object_tostring_forced(cur))) == NULL)
pkg_emit_error("Not a valid mode: %s",
ucl_object_tostring(cur));
else
perm = getmode(set, 0);
} else if (!strcasecmp(key, "try") && cur->type == UCL_BOOLEAN) {
try = ucl_object_toint(cur);
} else {
pkg_emit_error("Skipping unknown key for dir(%s): %s",
sbuf_data(dirname), key);
}
}
static PyObject *
_basic_ucl_type (ucl_object_t const *obj)
{
switch (obj->type) {
case UCL_INT:
return Py_BuildValue ("L", (long long)ucl_object_toint (obj));
case UCL_FLOAT:
return Py_BuildValue ("d", ucl_object_todouble (obj));
case UCL_STRING:
return Py_BuildValue ("s", ucl_object_tostring (obj));
case UCL_BOOLEAN:
return ucl_object_toboolean (obj) ? Py_True : Py_False;
case UCL_TIME:
return Py_BuildValue ("d", ucl_object_todouble (obj));
}
return NULL;
}
static ucl_object_t *
dynamic_metric_find_metric (const ucl_object_t *arr, const gchar *metric)
{
ucl_object_iter_t it = NULL;
const ucl_object_t *cur, *n;
while ((cur = ucl_iterate_object (arr, &it, true)) != NULL) {
if (cur->type == UCL_OBJECT) {
n = ucl_object_find_key (cur, "metric");
if (n && n->type == UCL_STRING &&
strcmp (metric, ucl_object_tostring (n)) == 0) {
return (ucl_object_t *)cur;
}
}
}
return NULL;
}
/*
* snprintkeys writes the value contained in obj to dst.
*/
static int
snprintval(char *dst, size_t size, ucl_object_t const *obj)
{
switch (ucl_object_type(obj)) {
case UCL_INT:
return snprintf(dst, size, "%" PRId64, ucl_object_toint(obj));
case UCL_FLOAT:
case UCL_TIME:
return snprintf(dst, size, "%0.10f", ucl_object_todouble(obj));
case UCL_STRING:
return snprintf(dst, size, "%s", ucl_object_tostring(obj));
case UCL_BOOLEAN:
return snprintf(dst, size, "%s", ucl_object_toboolean(obj) ? "true": "false");
default:
*dst = '\0';
return 0;
}
}
static int
pkg_set_files_from_object(struct pkg *pkg, ucl_object_t *obj)
{
ucl_object_t *cur;
ucl_object_iter_t it = NULL;
const char *sum = NULL;
const char *uname = NULL;
const char *gname = NULL;
void *set = NULL;
mode_t perm = 0;
struct sbuf *fname = NULL;
const char *key, *okey;
okey = ucl_object_key(obj);
if (okey == NULL)
return (EPKG_FATAL);
urldecode(okey, &fname);
while ((cur = ucl_iterate_object(obj, &it, true))) {
key = ucl_object_key(cur);
if (key == NULL)
continue;
if (!strcasecmp(key, "uname") && cur->type == UCL_STRING)
uname = ucl_object_tostring(cur);
else if (!strcasecmp(key, "gname") && cur->type == UCL_STRING)
gname = ucl_object_tostring(cur);
else if (!strcasecmp(key, "sum") && cur->type == UCL_STRING &&
strlen(ucl_object_tostring(cur)) == 64)
sum = ucl_object_tostring(cur);
else if (!strcasecmp(key, "perm") &&
(cur->type == UCL_STRING || cur->type == UCL_INT)) {
if ((set = setmode(ucl_object_tostring_forced(cur))) == NULL)
pkg_emit_error("Not a valid mode: %s",
ucl_object_tostring(cur));
else
perm = getmode(set, 0);
} else {
pkg_emit_error("Skipping unknown key for file(%s): %s",
sbuf_data(fname), ucl_object_tostring(cur));
}
}
pkg_addfile_attr(pkg, sbuf_data(fname), sum, uname, gname, perm, false);
sbuf_delete(fname);
return (EPKG_OK);
}
static int
pkg_object(struct pkg *pkg, ucl_object_t *obj, int attr)
{
struct sbuf *tmp = NULL;
ucl_object_t *cur;
ucl_object_iter_t it = NULL;
pkg_script script_type;
const char *key, *buf;
size_t len;
pkg_debug(3, "%s", "Manifest: parsing object");
while ((cur = ucl_iterate_object(obj, &it, true))) {
key = ucl_object_key(cur);
if (key == NULL)
continue;
switch (attr) {
case PKG_DEPS:
if (cur->type != UCL_OBJECT && cur->type != UCL_ARRAY)
pkg_emit_error("Skipping malformed dependency %s",
key);
else
pkg_set_deps_from_object(pkg, cur);
break;
case PKG_DIRS:
if (cur->type != UCL_OBJECT)
pkg_emit_error("Skipping malformed dirs %s",
key);
else
pkg_set_dirs_from_object(pkg, cur);
break;
case PKG_USERS:
if (cur->type == UCL_STRING)
pkg_adduid(pkg, key, ucl_object_tostring(cur));
else
pkg_emit_error("Skipping malformed users %s",
key);
break;
case PKG_GROUPS:
if (cur->type == UCL_STRING)
pkg_addgid(pkg, key, ucl_object_tostring(cur));
else
pkg_emit_error("Skipping malformed groups %s",
key);
break;
case PKG_DIRECTORIES:
if (cur->type == UCL_BOOLEAN) {
urldecode(key, &tmp);
pkg_adddir(pkg, sbuf_data(tmp), ucl_object_toboolean(cur), false);
} else if (cur->type == UCL_OBJECT) {
pkg_set_dirs_from_object(pkg, cur);
} else if (cur->type == UCL_STRING) {
urldecode(key, &tmp);
if (ucl_object_tostring(cur)[0] == 'y')
pkg_adddir(pkg, sbuf_data(tmp), 1, false);
else
pkg_adddir(pkg, sbuf_data(tmp), 0, false);
} else {
pkg_emit_error("Skipping malformed directories %s",
key);
}
break;
case PKG_FILES:
if (cur->type == UCL_STRING) {
buf = ucl_object_tolstring(cur, &len);
urldecode(key, &tmp);
pkg_addfile(pkg, sbuf_get(tmp), len == 64 ? buf : NULL, false);
} else if (cur->type == UCL_OBJECT)
pkg_set_files_from_object(pkg, cur);
else
pkg_emit_error("Skipping malformed files %s",
key);
break;
case PKG_OPTIONS:
if (cur->type != UCL_STRING && cur->type != UCL_BOOLEAN)
pkg_emit_error("Skipping malformed option %s",
key);
else
pkg_addoption(pkg, key, ucl_object_tostring_forced(cur));
break;
case PKG_OPTION_DEFAULTS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed option default %s",
key);
else
pkg_addoption_default(pkg, key,
ucl_object_tostring(cur));
break;
case PKG_OPTION_DESCRIPTIONS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed option description %s",
key);
else
pkg_addoption_description(pkg, key,
ucl_object_tostring(cur));
break;
case PKG_SCRIPTS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed scripts %s",
key);
else {
script_type = script_type_str(key);
if (script_type == PKG_SCRIPT_UNKNOWN) {
pkg_emit_error("Skipping unknown script "
"type: %s", key);
break;
}
urldecode(ucl_object_tostring(cur), &tmp);
pkg_addscript(pkg, sbuf_data(tmp), script_type);
}
break;
case PKG_ANNOTATIONS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed annotation %s",
key);
else
pkg_addannotation(pkg, key, ucl_object_tostring(cur));
break;
}
}
sbuf_free(tmp);
return (EPKG_OK);
}
static int
pkg_array(struct pkg *pkg, ucl_object_t *obj, int attr)
{
ucl_object_t *cur;
ucl_object_iter_t it = NULL;
pkg_debug(3, "%s", "Manifest: parsing array");
while ((cur = ucl_iterate_object(obj, &it, true))) {
switch (attr) {
case PKG_CATEGORIES:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed category");
else
pkg_addcategory(pkg, ucl_object_tostring(cur));
break;
case PKG_LICENSES:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed license");
else
pkg_addlicense(pkg, ucl_object_tostring(cur));
break;
case PKG_USERS:
if (cur->type == UCL_STRING)
pkg_adduser(pkg, ucl_object_tostring(cur));
else if (cur->type == UCL_OBJECT)
pkg_object(pkg, cur, attr);
else
pkg_emit_error("Skipping malformed license");
break;
case PKG_GROUPS:
if (cur->type == UCL_STRING)
pkg_addgroup(pkg, ucl_object_tostring(cur));
else if (cur->type == UCL_OBJECT)
pkg_object(pkg, cur, attr);
else
pkg_emit_error("Skipping malformed license");
break;
case PKG_DIRS:
if (cur->type == UCL_STRING)
pkg_adddir(pkg, ucl_object_tostring(cur), 1, false);
else if (cur->type == UCL_OBJECT)
pkg_object(pkg, cur, attr);
else
pkg_emit_error("Skipping malformed dirs");
break;
case PKG_SHLIBS_REQUIRED:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed required shared library");
else
pkg_addshlib_required(pkg, ucl_object_tostring(cur));
break;
case PKG_SHLIBS_PROVIDED:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed provided shared library");
else
pkg_addshlib_provided(pkg, ucl_object_tostring(cur));
break;
case PKG_CONFLICTS:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed conflict name");
else
pkg_addconflict(pkg, ucl_object_tostring(cur));
break;
case PKG_PROVIDES:
if (cur->type != UCL_STRING)
pkg_emit_error("Skipping malformed provide name");
else
pkg_addprovide(pkg, ucl_object_tostring(cur));
break;
}
}
return (EPKG_OK);
}
static struct rspamd_osb_tokenizer_config *
rspamd_tokenizer_osb_config_from_ucl (rspamd_mempool_t * pool,
const ucl_object_t *obj)
{
const ucl_object_t *elt;
struct rspamd_osb_tokenizer_config *cf, *def;
guchar *key = NULL;
gsize keylen;
if (pool != NULL) {
cf = rspamd_mempool_alloc0 (pool, sizeof (*cf));
}
else {
cf = g_malloc0 (sizeof (*cf));
}
/* Use default config */
def = rspamd_tokenizer_osb_default_config ();
memcpy (cf, def, sizeof (*cf));
elt = ucl_object_lookup (obj, "hash");
if (elt != NULL && ucl_object_type (elt) == UCL_STRING) {
if (g_ascii_strncasecmp (ucl_object_tostring (elt), "xxh", 3)
== 0) {
cf->ht = RSPAMD_OSB_HASH_XXHASH;
elt = ucl_object_lookup (obj, "seed");
if (elt != NULL && ucl_object_type (elt) == UCL_INT) {
cf->seed = ucl_object_toint (elt);
}
}
else if (g_ascii_strncasecmp (ucl_object_tostring (elt), "sip", 3)
== 0) {
cf->ht = RSPAMD_OSB_HASH_SIPHASH;
elt = ucl_object_lookup (obj, "key");
if (elt != NULL && ucl_object_type (elt) == UCL_STRING) {
key = rspamd_decode_base32 (ucl_object_tostring (elt),
0, &keylen);
if (keylen < sizeof (rspamd_sipkey_t)) {
msg_warn ("siphash key is too short: %z", keylen);
g_free (key);
}
else {
memcpy (cf->sk, key, sizeof (cf->sk));
g_free (key);
}
}
else {
msg_warn_pool ("siphash cannot be used without key");
}
}
}
else {
elt = ucl_object_lookup (obj, "compat");
if (elt != NULL && ucl_object_toboolean (elt)) {
cf->ht = RSPAMD_OSB_HASH_COMPAT;
}
}
elt = ucl_object_lookup (obj, "window");
if (elt != NULL && ucl_object_type (elt) == UCL_INT) {
cf->window_size = ucl_object_toint (elt);
if (cf->window_size > DEFAULT_FEATURE_WINDOW_SIZE * 4) {
msg_err_pool ("too large window size: %d", cf->window_size);
cf->window_size = DEFAULT_FEATURE_WINDOW_SIZE;
}
}
return cf;
}
static void
config_parse(const ucl_object_t *obj, pkg_conf_file_t conftype)
{
struct sbuf *buf = sbuf_new_auto();
const ucl_object_t *cur, *seq;
ucl_object_iter_t it = NULL, itseq = NULL;
struct config_entry *temp_config;
struct config_value *cv;
const char *key;
int i;
size_t j;
/* Temporary config for configs that may be disabled. */
temp_config = calloc(CONFIG_SIZE, sizeof(struct config_entry));
while ((cur = ucl_iterate_object(obj, &it, true))) {
key = ucl_object_key(cur);
if (key == NULL)
continue;
sbuf_clear(buf);
if (conftype == CONFFILE_PKG) {
for (j = 0; j < strlen(key); ++j)
sbuf_putc(buf, key[j]);
sbuf_finish(buf);
} else if (conftype == CONFFILE_REPO) {
if (strcasecmp(key, "url") == 0)
sbuf_cpy(buf, "PACKAGESITE");
else if (strcasecmp(key, "mirror_type") == 0)
sbuf_cpy(buf, "MIRROR_TYPE");
else if (strcasecmp(key, "signature_type") == 0)
sbuf_cpy(buf, "SIGNATURE_TYPE");
else if (strcasecmp(key, "fingerprints") == 0)
sbuf_cpy(buf, "FINGERPRINTS");
else if (strcasecmp(key, "enabled") == 0) {
if ((cur->type != UCL_BOOLEAN) ||
!ucl_object_toboolean(cur))
goto cleanup;
} else
continue;
sbuf_finish(buf);
}
for (i = 0; i < CONFIG_SIZE; i++) {
if (strcmp(sbuf_data(buf), c[i].key) == 0)
break;
}
/* Silently skip unknown keys to be future compatible. */
if (i == CONFIG_SIZE)
continue;
/* env has priority over config file */
if (c[i].envset)
continue;
/* Parse sequence value ["item1", "item2"] */
switch (c[i].type) {
case PKG_CONFIG_LIST:
if (cur->type != UCL_ARRAY) {
warnx("Skipping invalid array "
"value for %s.\n", c[i].key);
continue;
}
temp_config[i].list =
malloc(sizeof(*temp_config[i].list));
STAILQ_INIT(temp_config[i].list);
while ((seq = ucl_iterate_object(cur, &itseq, true))) {
if (seq->type != UCL_STRING)
continue;
cv = malloc(sizeof(struct config_value));
cv->value =
strdup(ucl_object_tostring(seq));
STAILQ_INSERT_TAIL(temp_config[i].list, cv,
next);
}
break;
case PKG_CONFIG_BOOL:
temp_config[i].value =
strdup(ucl_object_toboolean(cur) ? "yes" : "no");
break;
default:
/* Normal string value. */
temp_config[i].value = strdup(ucl_object_tostring(cur));
break;
}
}
/* Repo is enabled, copy over all settings from temp_config. */
for (i = 0; i < CONFIG_SIZE; i++) {
if (c[i].envset)
continue;
/* Prevent overriding ABI, ASSUME_ALWAYS_YES, etc. */
if (conftype != CONFFILE_PKG && c[i].main_only == true)
continue;
switch (c[i].type) {
case PKG_CONFIG_LIST:
c[i].list = temp_config[i].list;
break;
default:
c[i].value = temp_config[i].value;
break;
}
}
cleanup:
free(temp_config);
sbuf_delete(buf);
}
void
rspamd_stat_init (struct rspamd_config *cfg, struct event_base *ev_base)
{
GList *cur, *curst;
struct rspamd_classifier_config *clf;
struct rspamd_statfile_config *stf;
struct rspamd_stat_backend *bk;
struct rspamd_statfile *st;
struct rspamd_classifier *cl;
const ucl_object_t *cache_obj = NULL, *cache_name_obj;
const gchar *cache_name = NULL;
if (stat_ctx == NULL) {
stat_ctx = g_slice_alloc0 (sizeof (*stat_ctx));
}
stat_ctx->backends_subrs = stat_backends;
stat_ctx->backends_count = G_N_ELEMENTS (stat_backends);
stat_ctx->classifiers_subrs = stat_classifiers;
stat_ctx->classifiers_count = G_N_ELEMENTS (stat_classifiers);
stat_ctx->tokenizers_subrs = stat_tokenizers;
stat_ctx->tokenizers_count = G_N_ELEMENTS (stat_tokenizers);
stat_ctx->caches_subrs = stat_caches;
stat_ctx->caches_count = G_N_ELEMENTS (stat_caches);
stat_ctx->cfg = cfg;
stat_ctx->statfiles = g_ptr_array_new ();
stat_ctx->classifiers = g_ptr_array_new ();
stat_ctx->async_elts = g_queue_new ();
stat_ctx->ev_base = ev_base;
REF_RETAIN (stat_ctx->cfg);
/* Create statfiles from the classifiers */
cur = cfg->classifiers;
while (cur) {
clf = cur->data;
bk = rspamd_stat_get_backend (clf->backend);
if (bk == NULL) {
msg_err_config ("cannot get backend of type %s, so disable classifier"
" %s completely", clf->backend, clf->name);
cur = g_list_next (cur);
continue;
}
/* XXX:
* Here we get the first classifier tokenizer config as the only one
* We NO LONGER support multiple tokenizers per rspamd instance
*/
if (stat_ctx->tkcf == NULL) {
stat_ctx->tokenizer = rspamd_stat_get_tokenizer (clf->tokenizer->name);
g_assert (stat_ctx->tokenizer != NULL);
stat_ctx->tkcf = stat_ctx->tokenizer->get_config (cfg->cfg_pool,
clf->tokenizer, NULL);
}
cl = g_slice_alloc0 (sizeof (*cl));
cl->cfg = clf;
cl->ctx = stat_ctx;
cl->statfiles_ids = g_array_new (FALSE, FALSE, sizeof (gint));
cl->subrs = rspamd_stat_get_classifier (clf->classifier);
g_assert (cl->subrs != NULL);
cl->subrs->init_func (cfg->cfg_pool, cl);
/* Init classifier cache */
cache_name = NULL;
if (clf->opts) {
cache_obj = ucl_object_find_key (clf->opts, "cache");
cache_name_obj = NULL;
if (cache_obj) {
cache_name_obj = ucl_object_find_any_key (cache_obj,
"name", "type", NULL);
}
if (cache_name_obj) {
cache_name = ucl_object_tostring (cache_name_obj);
}
}
if (cache_name == NULL) {
/* We assume that learn cache is the same as backend */
cache_name = clf->backend;
}
curst = clf->statfiles;
while (curst) {
stf = curst->data;
st = g_slice_alloc0 (sizeof (*st));
st->classifier = cl;
st->stcf = stf;
st->backend = bk;
st->bkcf = bk->init (stat_ctx, cfg, st);
msg_debug_config ("added backend %s for symbol %s",
bk->name, stf->symbol);
/* XXX: bad hack to pass statfiles configuration to cache */
if (cl->cache == NULL) {
cl->cache = rspamd_stat_get_cache (cache_name);
g_assert (cl->cache != NULL);
cl->cachecf = cl->cache->init (stat_ctx, cfg, st, cache_obj);
if (cl->cachecf == NULL) {
msg_err_config ("error adding cache %s for symbol %s",
cl->cache->name, stf->symbol);
cl->cache = NULL;
}
else {
msg_debug_config ("added cache %s for symbol %s",
cl->cache->name, stf->symbol);
}
}
if (st->bkcf == NULL) {
msg_err_config ("cannot init backend %s for statfile %s",
clf->backend, stf->symbol);
g_slice_free1 (sizeof (*st), st);
}
else {
st->id = stat_ctx->statfiles->len;
g_ptr_array_add (stat_ctx->statfiles, st);
g_array_append_val (cl->statfiles_ids, st->id);
}
curst = curst->next;
}
g_ptr_array_add (stat_ctx->classifiers, cl);
cur = cur->next;
}
}
static void
add_repo(ucl_object_t *obj, struct pkg_repo *r, const char *rname)
{
ucl_object_t *cur, *tmp = NULL;
ucl_object_iter_t it = NULL;
bool enable = true;
const char *url = NULL, *pubkey = NULL, *mirror_type = NULL;
const char *signature_type = NULL, *fingerprints = NULL;
const char *key;
pkg_debug(1, "PkgConfig: parsing repository object %s", rname);
while ((cur = ucl_iterate_object(obj, &it, true))) {
key = ucl_object_key(cur);
if (key == NULL)
continue;
if (strcasecmp(key, "url") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
url = ucl_object_tostring(cur);
} else if (strcasecmp(key, "pubkey") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
pubkey = ucl_object_tostring(cur);
} else if (strcasecmp(key, "enabled") == 0) {
if (cur->type == UCL_STRING)
tmp = ucl_object_fromstring_common(ucl_object_tostring(cur),
strlen(ucl_object_tostring(cur)), UCL_STRING_PARSE_BOOLEAN);
if (cur->type != UCL_BOOLEAN && (tmp != NULL && tmp->type != UCL_BOOLEAN)) {
pkg_emit_error("Expecting a boolean for the "
"'%s' key of the '%s' repo",
key, rname);
if (tmp != NULL)
ucl_object_free(tmp);
return;
}
if (tmp != NULL)
pkg_emit_error("Warning: expecting a boolean for the '%s' key of the '%s' repo, "
" the value has been correctly converted, please consider fixing", key, rname);
enable = ucl_object_toboolean(tmp != NULL ? tmp : cur);
if (tmp != NULL)
ucl_object_free(tmp);
} else if (strcasecmp(key, "mirror_type") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
mirror_type = ucl_object_tostring(cur);
} else if (strcasecmp(key, "signature_type") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
signature_type = ucl_object_tostring(cur);
} else if (strcasecmp(key, "fingerprints") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
fingerprints = ucl_object_tostring(cur);
}
}
if (r == NULL && url == NULL) {
pkg_debug(1, "No repo and no url for %s", rname);
return;
}
if (r == NULL)
r = pkg_repo_new(rname, url);
if (signature_type != NULL) {
if (strcasecmp(signature_type, "pubkey") == 0)
r->signature_type = SIG_PUBKEY;
else if (strcasecmp(signature_type, "fingerprints") == 0)
r->signature_type = SIG_FINGERPRINT;
else
r->signature_type = SIG_NONE;
}
if (fingerprints != NULL) {
free(r->fingerprints);
r->fingerprints = strdup(fingerprints);
}
if (pubkey != NULL) {
free(r->pubkey);
r->pubkey = strdup(pubkey);
}
r->enable = enable;
if (mirror_type != NULL) {
if (strcasecmp(mirror_type, "srv") == 0)
r->mirror_type = SRV;
else if (strcasecmp(mirror_type, "http") == 0)
r->mirror_type = HTTP;
else
r->mirror_type = NOMIRROR;
}
}
static void
add_repo(const ucl_object_t *obj, struct pkg_repo *r, const char *rname, pkg_init_flags flags)
{
const ucl_object_t *cur, *enabled;
ucl_object_iter_t it = NULL;
bool enable = true;
const char *url = NULL, *pubkey = NULL, *mirror_type = NULL;
const char *signature_type = NULL, *fingerprints = NULL;
const char *key;
const char *type = NULL;
int use_ipvx = 0;
pkg_debug(1, "PkgConfig: parsing repository object %s", rname);
enabled = ucl_object_find_key(obj, "enabled");
if (enabled == NULL)
enabled = ucl_object_find_key(obj, "ENABLED");
if (enabled != NULL) {
enable = ucl_object_toboolean(enabled);
if (!enable && r == NULL) {
pkg_debug(1, "PkgConfig: skipping disabled repo %s", rname);
return;
}
else if (!enable && r != NULL) {
/*
* We basically want to remove the existing repo r and
* forget all stuff parsed
*/
pkg_debug(1, "PkgConfig: disabling repo %s", rname);
HASH_DEL(repos, r);
pkg_repo_free(r);
return;
}
}
while ((cur = ucl_iterate_object(obj, &it, true))) {
key = ucl_object_key(cur);
if (key == NULL)
continue;
if (strcasecmp(key, "url") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
url = ucl_object_tostring(cur);
} else if (strcasecmp(key, "pubkey") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
pubkey = ucl_object_tostring(cur);
} else if (strcasecmp(key, "mirror_type") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
mirror_type = ucl_object_tostring(cur);
} else if (strcasecmp(key, "signature_type") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
signature_type = ucl_object_tostring(cur);
} else if (strcasecmp(key, "fingerprints") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
fingerprints = ucl_object_tostring(cur);
} else if (strcasecmp(key, "type") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
type = ucl_object_tostring(cur);
} else if (strcasecmp(key, "ip_version") == 0) {
if (cur->type != UCL_INT) {
pkg_emit_error("Expecting a integer for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
use_ipvx = ucl_object_toint(cur);
if (use_ipvx != 4 && use_ipvx != 6)
use_ipvx = 0;
}
}
if (r == NULL && url == NULL) {
pkg_debug(1, "No repo and no url for %s", rname);
return;
}
if (r == NULL)
r = pkg_repo_new(rname, url, type);
else
pkg_repo_overwrite(r, rname, url, type);
if (signature_type != NULL) {
if (strcasecmp(signature_type, "pubkey") == 0)
r->signature_type = SIG_PUBKEY;
else if (strcasecmp(signature_type, "fingerprints") == 0)
r->signature_type = SIG_FINGERPRINT;
else
r->signature_type = SIG_NONE;
}
if (fingerprints != NULL) {
free(r->fingerprints);
r->fingerprints = strdup(fingerprints);
}
if (pubkey != NULL) {
free(r->pubkey);
r->pubkey = strdup(pubkey);
}
r->enable = enable;
if (mirror_type != NULL) {
if (strcasecmp(mirror_type, "srv") == 0)
r->mirror_type = SRV;
else if (strcasecmp(mirror_type, "http") == 0)
r->mirror_type = HTTP;
else
r->mirror_type = NOMIRROR;
}
if ((flags & PKG_INIT_FLAG_USE_IPV4) == PKG_INIT_FLAG_USE_IPV4)
use_ipvx = 4;
else if ((flags & PKG_INIT_FLAG_USE_IPV6) == PKG_INIT_FLAG_USE_IPV6)
use_ipvx = 6;
if (use_ipvx != 4 && use_ipvx != 6)
use_ipvx = pkg_object_int(pkg_config_get("IP_VERSION"));
if (use_ipvx == 4)
r->flags = REPO_FLAGS_USE_IPV4;
else if (use_ipvx == 6)
r->flags = REPO_FLAGS_USE_IPV6;
}
void
ucl_obj_dump (const ucl_object_t *obj, unsigned int shift)
{
int num = shift * 4 + 5;
char *pre = (char *) malloc (num * sizeof(char));
const ucl_object_t *cur, *tmp;
ucl_object_iter_t it = NULL, it_obj = NULL;
pre[--num] = 0x00;
while (num--)
pre[num] = 0x20;
tmp = obj;
while ((obj = ucl_iterate_object (tmp, &it, false))) {
printf ("%sucl object address: %p\n", pre + 4, obj);
if (obj->key != NULL) {
printf ("%skey: \"%s\"\n", pre, ucl_object_key (obj));
}
printf ("%sref: %u\n", pre, obj->ref);
printf ("%slen: %u\n", pre, obj->len);
printf ("%sprev: %p\n", pre, obj->prev);
printf ("%snext: %p\n", pre, obj->next);
if (obj->type == UCL_OBJECT) {
printf ("%stype: UCL_OBJECT\n", pre);
printf ("%svalue: %p\n", pre, obj->value.ov);
it_obj = NULL;
while ((cur = ucl_iterate_object (obj, &it_obj, true))) {
ucl_obj_dump (cur, shift + 2);
}
}
else if (obj->type == UCL_ARRAY) {
printf ("%stype: UCL_ARRAY\n", pre);
printf ("%svalue: %p\n", pre, obj->value.av);
it_obj = NULL;
while ((cur = ucl_iterate_object (obj, &it_obj, true))) {
ucl_obj_dump (cur, shift + 2);
}
}
else if (obj->type == UCL_INT) {
printf ("%stype: UCL_INT\n", pre);
printf ("%svalue: %jd\n", pre, (intmax_t)ucl_object_toint (obj));
}
else if (obj->type == UCL_FLOAT) {
printf ("%stype: UCL_FLOAT\n", pre);
printf ("%svalue: %f\n", pre, ucl_object_todouble (obj));
}
else if (obj->type == UCL_STRING) {
printf ("%stype: UCL_STRING\n", pre);
printf ("%svalue: \"%s\"\n", pre, ucl_object_tostring (obj));
}
else if (obj->type == UCL_BOOLEAN) {
printf ("%stype: UCL_BOOLEAN\n", pre);
printf ("%svalue: %s\n", pre, ucl_object_tostring_forced (obj));
}
else if (obj->type == UCL_TIME) {
printf ("%stype: UCL_TIME\n", pre);
printf ("%svalue: %f\n", pre, ucl_object_todouble (obj));
}
else if (obj->type == UCL_USERDATA) {
printf ("%stype: UCL_USERDATA\n", pre);
printf ("%svalue: %p\n", pre, obj->value.ud);
}
}
free (pre);
}
static gboolean
rspamd_redis_try_ucl (struct redis_stat_ctx *backend,
const ucl_object_t *obj,
struct rspamd_config *cfg,
const gchar *symbol)
{
const ucl_object_t *elt, *relt, *users_enabled;
const gchar *lua_script;
elt = ucl_object_lookup_any (obj, "read_servers", "servers", NULL);
if (elt == NULL) {
return FALSE;
}
backend->read_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (backend->read_servers, elt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err ("statfile %s cannot get read servers configuration",
symbol);
return FALSE;
}
relt = elt;
elt = ucl_object_lookup (obj, "write_servers");
if (elt == NULL) {
/* Use read servers as write ones */
g_assert (relt != NULL);
backend->write_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (backend->write_servers, relt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err ("statfile %s cannot get write servers configuration",
symbol);
return FALSE;
}
}
else {
backend->write_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (backend->write_servers, elt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err ("statfile %s cannot get write servers configuration",
symbol);
rspamd_upstreams_destroy (backend->write_servers);
backend->write_servers = NULL;
}
}
elt = ucl_object_lookup (obj, "prefix");
if (elt == NULL || ucl_object_type (elt) != UCL_STRING) {
/* Default non-users statistics */
backend->redis_object = REDIS_DEFAULT_OBJECT;
/*
* Make redis backend compatible with sqlite3 backend in users settings
*/
users_enabled = ucl_object_lookup_any (obj, "per_user",
"users_enabled", NULL);
if (users_enabled != NULL) {
if (ucl_object_type (users_enabled) == UCL_BOOLEAN) {
backend->enable_users = ucl_object_toboolean (users_enabled);
backend->cbref_user = -1;
if (backend->enable_users) {
backend->redis_object = REDIS_DEFAULT_USERS_OBJECT;
}
}
else if (ucl_object_type (users_enabled) == UCL_STRING) {
lua_script = ucl_object_tostring (users_enabled);
if (luaL_dostring (cfg->lua_state, lua_script) != 0) {
msg_err_config ("cannot execute lua script for users "
"extraction: %s", lua_tostring (cfg->lua_state, -1));
}
else {
if (lua_type (cfg->lua_state, -1) == LUA_TFUNCTION) {
backend->enable_users = TRUE;
backend->cbref_user = luaL_ref (cfg->lua_state,
LUA_REGISTRYINDEX);
}
else {
msg_err_config ("lua script must return "
"function(task) and not %s",
lua_typename (cfg->lua_state, lua_type (
cfg->lua_state, -1)));
}
}
}
}
else {
backend->enable_users = FALSE;
}
}
else {
/* XXX: sanity check */
backend->redis_object = ucl_object_tostring (elt);
}
elt = ucl_object_lookup (obj, "timeout");
if (elt) {
backend->timeout = ucl_object_todouble (elt);
}
else {
backend->timeout = REDIS_DEFAULT_TIMEOUT;
}
elt = ucl_object_lookup (obj, "password");
if (elt) {
backend->password = ucl_object_tostring (elt);
}
else {
backend->password = NULL;
}
elt = ucl_object_lookup_any (obj, "db", "database", "dbname", NULL);
if (elt) {
backend->dbname = ucl_object_tostring (elt);
}
else {
backend->dbname = NULL;
}
return TRUE;
}
static gint
fuzzy_parse_rule (struct rspamd_config *cfg, const ucl_object_t *obj, gint cb_id)
{
const ucl_object_t *value, *cur;
struct fuzzy_rule *rule;
ucl_object_iter_t it = NULL;
const char *k = NULL;
if (obj->type != UCL_OBJECT) {
msg_err_config ("invalid rule definition");
return -1;
}
rule = fuzzy_rule_new (fuzzy_module_ctx->default_symbol,
fuzzy_module_ctx->fuzzy_pool);
if ((value = ucl_object_find_key (obj, "mime_types")) != NULL) {
it = NULL;
while ((cur = ucl_iterate_object (value, &it, value->type == UCL_ARRAY))
!= NULL) {
rule->mime_types = g_list_concat (rule->mime_types,
parse_mime_types (ucl_obj_tostring (cur)));
}
}
if (rule->mime_types != NULL) {
rspamd_mempool_add_destructor (fuzzy_module_ctx->fuzzy_pool,
(rspamd_mempool_destruct_t)g_list_free, rule->mime_types);
}
if ((value = ucl_object_find_key (obj, "max_score")) != NULL) {
rule->max_score = ucl_obj_todouble (value);
}
if ((value = ucl_object_find_key (obj, "symbol")) != NULL) {
rule->symbol = ucl_obj_tostring (value);
}
if ((value = ucl_object_find_key (obj, "read_only")) != NULL) {
rule->read_only = ucl_obj_toboolean (value);
}
if ((value = ucl_object_find_key (obj, "skip_unknown")) != NULL) {
rule->skip_unknown = ucl_obj_toboolean (value);
}
if ((value = ucl_object_find_key (obj, "servers")) != NULL) {
rule->servers = rspamd_upstreams_create ();
rspamd_mempool_add_destructor (fuzzy_module_ctx->fuzzy_pool,
(rspamd_mempool_destruct_t)rspamd_upstreams_destroy,
rule->servers);
rspamd_upstreams_from_ucl (rule->servers, value, DEFAULT_PORT, NULL);
}
if ((value = ucl_object_find_key (obj, "fuzzy_map")) != NULL) {
it = NULL;
while ((cur = ucl_iterate_object (value, &it, true)) != NULL) {
parse_flags (rule, cfg, cur, cb_id);
}
}
if ((value = ucl_object_find_key (obj, "encryption_key")) != NULL) {
/* Create key from user's input */
k = ucl_object_tostring (value);
if (k == NULL || (rule->peer_key =
rspamd_http_connection_make_peer_key (k)) == NULL) {
msg_err_config ("bad encryption key value: %s",
k);
return -1;
}
rule->local_key = rspamd_http_connection_gen_key ();
}
if ((value = ucl_object_find_key (obj, "fuzzy_key")) != NULL) {
/* Create key from user's input */
k = ucl_object_tostring (value);
}
/* Setup keys */
if (k == NULL) {
/* Use some default key for all ops */
k = "rspamd";
}
rule->hash_key = g_string_sized_new (BLAKE2B_KEYBYTES);
blake2 (rule->hash_key->str, k, NULL, BLAKE2B_KEYBYTES, strlen (k), 0);
rule->hash_key->len = BLAKE2B_KEYBYTES;
if ((value = ucl_object_find_key (obj, "fuzzy_shingles_key")) != NULL) {
k = ucl_object_tostring (value);
}
if (k == NULL) {
k = "rspamd";
}
rule->shingles_key = g_string_sized_new (16);
blake2 (rule->shingles_key->str, k, NULL, 16, strlen (k), 0);
rule->shingles_key->len = 16;
if (rspamd_upstreams_count (rule->servers) == 0) {
msg_err_config ("no servers defined for fuzzy rule with symbol: %s",
rule->symbol);
return -1;
}
else {
fuzzy_module_ctx->fuzzy_rules = g_list_prepend (
fuzzy_module_ctx->fuzzy_rules,
rule);
if (rule->symbol != fuzzy_module_ctx->default_symbol) {
rspamd_symbols_cache_add_symbol (cfg->cache, rule->symbol,
0,
NULL, NULL,
SYMBOL_TYPE_VIRTUAL|SYMBOL_TYPE_FINE,
cb_id);
}
}
rspamd_mempool_add_destructor (fuzzy_module_ctx->fuzzy_pool, fuzzy_free_rule,
rule);
return 0;
}
gint
regexp_module_config (struct rspamd_config *cfg)
{
struct regexp_module_item *cur_item;
const ucl_object_t *sec, *value, *elt;
ucl_object_iter_t it = NULL;
gint res = TRUE, id;
if (!rspamd_config_is_module_enabled (cfg, "regexp")) {
return TRUE;
}
sec = ucl_object_find_key (cfg->rcl_obj, "regexp");
if (sec == NULL) {
msg_err_config ("regexp module enabled, but no rules are defined");
return TRUE;
}
regexp_module_ctx->max_size = 0;
while ((value = ucl_iterate_object (sec, &it, true)) != NULL) {
if (g_ascii_strncasecmp (ucl_object_key (value), "max_size",
sizeof ("max_size") - 1) == 0) {
regexp_module_ctx->max_size = ucl_obj_toint (value);
rspamd_mime_expression_set_re_limit (regexp_module_ctx->max_size);
}
else if (g_ascii_strncasecmp (ucl_object_key (value), "max_threads",
sizeof ("max_threads") - 1) == 0) {
msg_warn_config ("regexp module is now single threaded, max_threads is ignored");
}
else if (value->type == UCL_STRING) {
cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool,
sizeof (struct regexp_module_item));
cur_item->symbol = ucl_object_key (value);
if (!read_regexp_expression (regexp_module_ctx->regexp_pool,
cur_item, ucl_object_key (value),
ucl_obj_tostring (value), cfg)) {
res = FALSE;
}
else {
rspamd_symbols_cache_add_symbol (cfg->cache,
cur_item->symbol,
0,
process_regexp_item,
cur_item,
SYMBOL_TYPE_NORMAL, -1);
}
}
else if (value->type == UCL_USERDATA) {
/* Just a lua function */
cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool,
sizeof (struct regexp_module_item));
cur_item->symbol = ucl_object_key (value);
cur_item->lua_function = ucl_object_toclosure (value);
rspamd_symbols_cache_add_symbol (cfg->cache,
cur_item->symbol,
0,
process_regexp_item,
cur_item,
SYMBOL_TYPE_NORMAL, -1);
}
else if (value->type == UCL_OBJECT) {
const gchar *description = NULL, *group = NULL,
*metric = DEFAULT_METRIC;
gdouble score = 0.0;
gboolean one_shot = FALSE, is_lua = FALSE, valid_expression = TRUE;
/* We have some lua table, extract its arguments */
elt = ucl_object_find_key (value, "callback");
if (elt == NULL || elt->type != UCL_USERDATA) {
/* Try plain regexp expression */
elt = ucl_object_find_any_key (value, "regexp", "re", NULL);
if (elt != NULL && ucl_object_type (elt) == UCL_STRING) {
cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool,
sizeof (struct regexp_module_item));
cur_item->symbol = ucl_object_key (value);
if (!read_regexp_expression (regexp_module_ctx->regexp_pool,
cur_item, ucl_object_key (value),
ucl_obj_tostring (elt), cfg)) {
res = FALSE;
}
else {
valid_expression = TRUE;
}
}
else {
msg_err_config (
"no callback/expression defined for regexp symbol: "
"%s", ucl_object_key (value));
}
}
else {
is_lua = TRUE;
cur_item = rspamd_mempool_alloc0 (
regexp_module_ctx->regexp_pool,
sizeof (struct regexp_module_item));
cur_item->symbol = ucl_object_key (value);
cur_item->lua_function = ucl_object_toclosure (value);
}
if (cur_item && (is_lua || valid_expression)) {
id = rspamd_symbols_cache_add_symbol (cfg->cache,
cur_item->symbol,
0,
process_regexp_item,
cur_item,
SYMBOL_TYPE_NORMAL, -1);
elt = ucl_object_find_key (value, "condition");
if (elt != NULL && ucl_object_type (elt) == UCL_USERDATA) {
struct ucl_lua_funcdata *conddata;
conddata = ucl_object_toclosure (elt);
rspamd_symbols_cache_add_condition (cfg->cache, id,
conddata->L, conddata->idx);
}
elt = ucl_object_find_key (value, "metric");
if (elt) {
metric = ucl_object_tostring (elt);
}
elt = ucl_object_find_key (value, "description");
if (elt) {
description = ucl_object_tostring (elt);
}
elt = ucl_object_find_key (value, "group");
if (elt) {
group = ucl_object_tostring (elt);
}
elt = ucl_object_find_key (value, "score");
if (elt) {
score = ucl_object_todouble (elt);
}
elt = ucl_object_find_key (value, "one_shot");
if (elt) {
one_shot = ucl_object_toboolean (elt);
}
rspamd_config_add_metric_symbol (cfg, metric, cur_item->symbol,
score, description, group, one_shot, FALSE);
}
}
else {
msg_warn_config ("unknown type of attribute %s for regexp module",
ucl_object_key (value));
}
}
return res;
}
/**
* Apply configuration to the specified configuration
* @param conf_metrics
* @param cfg
*/
static void
apply_dynamic_conf (const ucl_object_t *top, struct rspamd_config *cfg)
{
gint test_act;
const ucl_object_t *cur_elt, *cur_nm, *it_val;
ucl_object_iter_t it = NULL;
struct metric *real_metric;
struct metric_action *cur_action;
struct rspamd_symbol_def *s;
while ((cur_elt = ucl_iterate_object (top, &it, true))) {
if (ucl_object_type (cur_elt) != UCL_OBJECT) {
msg_err ("loaded json array element is not an object");
continue;
}
cur_nm = ucl_object_find_key (cur_elt, "metric");
if (!cur_nm || ucl_object_type (cur_nm) != UCL_STRING) {
msg_err (
"loaded json metric object element has no 'metric' attribute");
continue;
}
real_metric = g_hash_table_lookup (cfg->metrics,
ucl_object_tostring (cur_nm));
if (real_metric == NULL) {
msg_warn ("cannot find metric %s", ucl_object_tostring (cur_nm));
continue;
}
cur_nm = ucl_object_find_key (cur_elt, "symbols");
/* Parse symbols */
if (cur_nm && ucl_object_type (cur_nm) == UCL_ARRAY) {
ucl_object_iter_t nit = NULL;
while ((it_val = ucl_iterate_object (cur_nm, &nit, true))) {
if (ucl_object_find_key (it_val, "name") &&
ucl_object_find_key (it_val, "value")) {
const ucl_object_t *n =
ucl_object_find_key (it_val, "name");
const ucl_object_t *v =
ucl_object_find_key (it_val, "value");
if((s = g_hash_table_lookup (real_metric->symbols,
ucl_object_tostring (n))) != NULL) {
*s->weight_ptr = ucl_object_todouble (v);
}
}
else {
msg_info (
"json symbol object has no mandatory 'name' and 'value' attributes");
}
}
}
else {
ucl_object_t *arr;
arr = ucl_object_typed_new (UCL_ARRAY);
ucl_object_insert_key ((ucl_object_t *)cur_elt, arr, "symbols",
sizeof ("symbols") - 1, false);
}
cur_nm = ucl_object_find_key (cur_elt, "actions");
/* Parse actions */
if (cur_nm && ucl_object_type (cur_nm) == UCL_ARRAY) {
ucl_object_iter_t nit = NULL;
while ((it_val = ucl_iterate_object (cur_nm, &nit, true))) {
if (ucl_object_find_key (it_val, "name") &&
ucl_object_find_key (it_val, "value")) {
if (!rspamd_action_from_str (ucl_object_tostring (
ucl_object_find_key (it_val, "name")), &test_act)) {
msg_err ("unknown action: %s",
ucl_object_tostring (ucl_object_find_key (it_val,
"name")));
continue;
}
cur_action = &real_metric->actions[test_act];
cur_action->action = test_act;
cur_action->score =
ucl_object_todouble (ucl_object_find_key (it_val,
"value"));
}
else {
msg_info (
"json action object has no mandatory 'name' and 'value' attributes");
}
}
}
else {
ucl_object_t *arr;
arr = ucl_object_typed_new (UCL_ARRAY);
ucl_object_insert_key ((ucl_object_t *)cur_elt, arr, "actions",
sizeof ("actions") - 1, false);
}
}
}
static gboolean
rspamd_redis_cache_try_ucl (struct rspamd_redis_cache_ctx *cache_ctx,
const ucl_object_t *obj,
struct rspamd_config *cfg,
const gchar *symbol)
{
const ucl_object_t *elt, *relt;
elt = ucl_object_lookup_any (obj, "read_servers", "servers", NULL);
if (elt == NULL) {
return FALSE;
}
cache_ctx->read_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (cache_ctx->read_servers, elt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err ("statfile %s cannot get read servers configuration",
symbol);
return FALSE;
}
relt = elt;
elt = ucl_object_lookup (obj, "write_servers");
if (elt == NULL) {
/* Use read servers as write ones */
g_assert (relt != NULL);
cache_ctx->write_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (cache_ctx->write_servers, relt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err ("statfile %s cannot get write servers configuration",
symbol);
return FALSE;
}
}
else {
cache_ctx->write_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (cache_ctx->write_servers, elt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err ("statfile %s cannot get write servers configuration",
symbol);
rspamd_upstreams_destroy (cache_ctx->write_servers);
cache_ctx->write_servers = NULL;
}
}
elt = ucl_object_lookup (obj, "timeout");
if (elt) {
cache_ctx->timeout = ucl_object_todouble (elt);
}
else {
cache_ctx->timeout = REDIS_DEFAULT_TIMEOUT;
}
elt = ucl_object_lookup (obj, "password");
if (elt) {
cache_ctx->password = ucl_object_tostring (elt);
}
else {
cache_ctx->password = NULL;
}
elt = ucl_object_lookup_any (obj, "db", "database", "dbname", NULL);
if (elt) {
cache_ctx->dbname = ucl_object_tostring (elt);
}
else {
cache_ctx->dbname = NULL;
}
elt = ucl_object_lookup_any (obj, "cache_key", "key", NULL);
if (elt == NULL || ucl_object_type (elt) != UCL_STRING) {
cache_ctx->redis_object = DEFAULT_REDIS_KEY;
}
else {
cache_ctx->redis_object = ucl_object_tostring (elt);
}
return TRUE;
}
/*
* Validate object
*/
static bool
ucl_schema_validate_object (const ucl_object_t *schema,
const ucl_object_t *obj, struct ucl_schema_error *err,
const ucl_object_t *root)
{
const ucl_object_t *elt, *prop, *found, *additional_schema = NULL,
*required = NULL, *pat, *pelt;
ucl_object_iter_t iter = NULL, piter = NULL;
bool ret = true, allow_additional = true;
int64_t minmax;
while (ret && (elt = ucl_iterate_object (schema, &iter, true)) != NULL) {
if (elt->type == UCL_OBJECT &&
strcmp (ucl_object_key (elt), "properties") == 0) {
piter = NULL;
while (ret && (prop = ucl_iterate_object (elt, &piter, true)) != NULL) {
found = ucl_object_find_key (obj, ucl_object_key (prop));
if (found) {
ret = ucl_schema_validate (prop, found, true, err, root);
}
}
}
else if (strcmp (ucl_object_key (elt), "additionalProperties") == 0) {
if (elt->type == UCL_BOOLEAN) {
if (!ucl_object_toboolean (elt)) {
/* Deny additional fields completely */
allow_additional = false;
}
}
else if (elt->type == UCL_OBJECT) {
/* Define validator for additional fields */
additional_schema = elt;
}
else {
ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt,
"additionalProperties attribute is invalid in schema");
ret = false;
break;
}
}
else if (strcmp (ucl_object_key (elt), "required") == 0) {
if (elt->type == UCL_ARRAY) {
required = elt;
}
else {
ucl_schema_create_error (err, UCL_SCHEMA_INVALID_SCHEMA, elt,
"required attribute is invalid in schema");
ret = false;
break;
}
}
else if (strcmp (ucl_object_key (elt), "minProperties") == 0
&& ucl_object_toint_safe (elt, &minmax)) {
if (obj->len < minmax) {
ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj,
"object has not enough properties: %u, minimum is: %u",
obj->len, (unsigned)minmax);
ret = false;
break;
}
}
else if (strcmp (ucl_object_key (elt), "maxProperties") == 0
&& ucl_object_toint_safe (elt, &minmax)) {
if (obj->len > minmax) {
ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj,
"object has too many properties: %u, maximum is: %u",
obj->len, (unsigned)minmax);
ret = false;
break;
}
}
else if (strcmp (ucl_object_key (elt), "patternProperties") == 0) {
piter = NULL;
while (ret && (prop = ucl_iterate_object (elt, &piter, true)) != NULL) {
found = ucl_schema_test_pattern (obj, ucl_object_key (prop));
if (found) {
ret = ucl_schema_validate (prop, found, true, err, root);
}
}
}
else if (elt->type == UCL_OBJECT &&
strcmp (ucl_object_key (elt), "dependencies") == 0) {
ret = ucl_schema_validate_dependencies (elt, obj, err, root);
}
}
if (ret) {
/* Additional properties */
if (!allow_additional || additional_schema != NULL) {
/* Check if we have exactly the same properties in schema and object */
iter = NULL;
prop = ucl_object_find_key (schema, "properties");
while ((elt = ucl_iterate_object (obj, &iter, true)) != NULL) {
found = ucl_object_find_key (prop, ucl_object_key (elt));
if (found == NULL) {
/* Try patternProperties */
piter = NULL;
pat = ucl_object_find_key (schema, "patternProperties");
while ((pelt = ucl_iterate_object (pat, &piter, true)) != NULL) {
found = ucl_schema_test_pattern (obj, ucl_object_key (pelt));
if (found != NULL) {
break;
}
}
}
if (found == NULL) {
if (!allow_additional) {
ucl_schema_create_error (err, UCL_SCHEMA_CONSTRAINT, obj,
"object has non-allowed property %s",
ucl_object_key (elt));
ret = false;
break;
}
else if (additional_schema != NULL) {
if (!ucl_schema_validate (additional_schema, elt, true, err, root)) {
ret = false;
break;
}
}
}
}
}
/* Required properties */
if (required != NULL) {
iter = NULL;
while ((elt = ucl_iterate_object (required, &iter, true)) != NULL) {
if (ucl_object_find_key (obj, ucl_object_tostring (elt)) == NULL) {
ucl_schema_create_error (err, UCL_SCHEMA_MISSING_PROPERTY, obj,
"object has missing property %s",
ucl_object_tostring (elt));
ret = false;
break;
}
}
}
}
return ret;
}
static int
parse_modules(struct rtpp_cfg_stable *csp, const ucl_object_t *wop)
{
ucl_object_iter_t it_conf;
const ucl_object_t *obj_file;
const char *cf_key;
const ucl_object_t *obj_key;
int ecode, success;
void *confp;
const conf_helper_map *fent, *map;
struct rtpp_module_conf *mcp;
char mpath[PATH_MAX + 1];
const char *cp, *mp;
struct rtpp_module_if *mif;
it_conf = ucl_object_iterate_new(wop);
if (it_conf == NULL)
return (-1);
ecode = 0;
while ((obj_file = ucl_object_iterate_safe(it_conf, true)) != NULL) {
cf_key = ucl_object_key(obj_file);
RTPP_LOG(csp->glog, RTPP_LOG_DBUG, "\tmodule: %s", cf_key);
obj_key = ucl_object_find_key(obj_file, "load");
if (obj_key == NULL) {
cp = rtpp_module_dsop_canonic(cf_key, mpath, sizeof(mpath));
if (cp == NULL) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "Error: Unable to find load parameter in module: %s", cf_key);
ecode = -1;
goto e0;
}
} else {
if (obj_key->type != UCL_STRING) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "Error: \"load\" parameter in %s has a wrong type, string is expected", cf_key);
ecode = -1;
goto e0;
}
mp = ucl_object_tostring(obj_key);
cp = realpath(mp, mpath);
if (cp == NULL) {
RTPP_ELOG(csp->glog, RTPP_LOG_ERR, "realpath() failed: %s", mp);
ecode = -1;
goto e0;
}
}
mif = rtpp_module_if_ctor(cp);
if (mif == NULL) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "dymanic module constructor has failed: %s", cp);
ecode = -1;
goto e0;
}
if (CALL_METHOD(mif, load, csp, csp->glog) != 0) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "%p->load() method has failed: %s", mif, cp);
goto e1;
}
if (CALL_METHOD(mif, get_mconf, &mcp) < 0) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "%p->get_mconf() method has failed: %s", mif, cp);
goto e1;
}
fent = NULL;
if (mcp != NULL) {
map = mcp->conf_map;
confp = mcp->conf_data;
} else {
map = default_module_map;
confp = NULL;
}
success = conf_helper_mapper(csp->glog, obj_file, map, confp, &fent);
if (!success) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "Config parsing issue in section %s",
cf_key);
if (fent != NULL && fent->conf_key != NULL) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "\tparameter %s", fent->conf_key);
}
goto e1;
}
if (CALL_METHOD(mif, config) < 0) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "%p->config() method has failed: %s", mif, cp);
goto e1;
}
rtpp_list_append(csp->modules_cf, mif);
continue;
e1:
ecode = -1;
CALL_SMETHOD(mif->rcnt, decref);
goto e0;
}
e0:
if (ucl_object_iter_chk_excpn(it_conf)) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "UCL has failed with an internal error");
ecode = -1;
}
ucl_object_iterate_free(it_conf);
return (ecode);
}
struct rspamd_map*
rspamd_map_add_from_ucl (struct rspamd_config *cfg,
const ucl_object_t *obj,
const gchar *description,
map_cb_t read_callback,
map_fin_cb_t fin_callback,
void **user_data)
{
ucl_object_iter_t it = NULL;
const ucl_object_t *cur, *elt;
struct rspamd_map *map;
struct rspamd_map_backend *bk;
g_assert (obj != NULL);
if (ucl_object_type (obj) == UCL_STRING) {
/* Just a plain string */
return rspamd_map_add (cfg, ucl_object_tostring (obj), NULL,
read_callback, fin_callback, user_data);
}
map = g_slice_alloc0 (sizeof (struct rspamd_map));
map->read_callback = read_callback;
map->fin_callback = fin_callback;
map->user_data = user_data;
map->cfg = cfg;
map->id = g_random_int ();
map->locked =
rspamd_mempool_alloc0_shared (cfg->cfg_pool, sizeof (gint));
map->cache =
rspamd_mempool_alloc0_shared (cfg->cfg_pool, sizeof (*map->cache));
map->backends = g_ptr_array_new ();
map->poll_timeout = cfg->map_timeout;
if (description) {
map->description = g_strdup (description);
}
if (ucl_object_type (obj) == UCL_ARRAY) {
/* Add array of maps as multiple backends */
while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) {
if (ucl_object_type (cur) == UCL_STRING) {
bk = rspamd_map_parse_backend (cfg, ucl_object_tostring (cur));
if (bk != NULL) {
g_ptr_array_add (map->backends, bk);
if (!map->name) {
map->name = g_strdup (ucl_object_tostring (cur));
}
}
}
else {
msg_err_config ("bad map element type: %s",
ucl_object_type_to_string (ucl_object_type (cur)));
}
}
if (map->backends->len == 0) {
msg_err_config ("map has no urls to be loaded");
goto err;
}
}
else if (ucl_object_type (obj) == UCL_OBJECT) {
elt = ucl_object_lookup (obj, "name");
if (elt && ucl_object_type (elt) == UCL_STRING) {
map->name = g_strdup (ucl_object_tostring (elt));
}
elt = ucl_object_lookup (obj, "description");
if (elt && ucl_object_type (elt) == UCL_STRING) {
if (map->description) {
g_free (map->description);
}
map->description = g_strdup (ucl_object_tostring (elt));
}
elt = ucl_object_lookup_any (obj, "timeout", "poll", "poll_time",
"watch_interval", NULL);
if (elt) {
map->poll_timeout = ucl_object_todouble (elt);
}
elt = ucl_object_lookup_any (obj, "upstreams", "url", "urls", NULL);
if (elt == NULL) {
msg_err_config ("map has no urls to be loaded");
goto err;
}
if (ucl_object_type (obj) == UCL_ARRAY) {
/* Add array of maps as multiple backends */
while ((cur = ucl_object_iterate (elt, &it, true)) != NULL) {
if (ucl_object_type (cur) == UCL_STRING) {
bk = rspamd_map_parse_backend (cfg, ucl_object_tostring (cur));
if (bk != NULL) {
g_ptr_array_add (map->backends, bk);
if (!map->name) {
map->name = g_strdup (ucl_object_tostring (cur));
}
}
}
else {
msg_err_config ("bad map element type: %s",
ucl_object_type_to_string (ucl_object_type (cur)));
goto err;
}
}
if (map->backends->len == 0) {
msg_err_config ("map has no urls to be loaded");
goto err;
}
}
else if (ucl_object_type (elt) == UCL_STRING) {
bk = rspamd_map_parse_backend (cfg, ucl_object_tostring (elt));
if (bk != NULL) {
g_ptr_array_add (map->backends, bk);
if (!map->name) {
map->name = g_strdup (ucl_object_tostring (cur));
}
}
}
if (map->backends->len == 0) {
msg_err_config ("map has no urls to be loaded");
goto err;
}
}
rspamd_map_calculate_hash (map);
msg_info_map ("added map from ucl");
cfg->maps = g_list_prepend (cfg->maps, map);
return map;
err:
g_ptr_array_free (map->backends, TRUE);
g_free (map->name);
g_free (map->description);
g_slice_free1 (sizeof (*map), map);
return NULL;
}
gint
dkim_module_config (struct rspamd_config *cfg)
{
const ucl_object_t *value;
gint res = TRUE, cb_id = -1, check_id = -1;
guint cache_size;
gboolean got_trusted = FALSE;
if (!rspamd_config_is_module_enabled (cfg, "dkim")) {
return TRUE;
}
dkim_module_ctx->whitelist_ip = radix_create_compressed ();
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "symbol_reject")) != NULL) {
dkim_module_ctx->symbol_reject = ucl_obj_tostring (value);
}
else {
dkim_module_ctx->symbol_reject = DEFAULT_SYMBOL_REJECT;
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim",
"symbol_tempfail")) != NULL) {
dkim_module_ctx->symbol_tempfail = ucl_obj_tostring (value);
}
else {
dkim_module_ctx->symbol_tempfail = DEFAULT_SYMBOL_TEMPFAIL;
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "symbol_allow")) != NULL) {
dkim_module_ctx->symbol_allow = ucl_obj_tostring (value);
}
else {
dkim_module_ctx->symbol_allow = DEFAULT_SYMBOL_ALLOW;
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "symbol_na")) != NULL) {
dkim_module_ctx->symbol_na = ucl_obj_tostring (value);
}
else {
dkim_module_ctx->symbol_na = DEFAULT_SYMBOL_NA;
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim",
"dkim_cache_size")) != NULL) {
cache_size = ucl_obj_toint (value);
}
else {
cache_size = DEFAULT_CACHE_SIZE;
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "time_jitter")) != NULL) {
dkim_module_ctx->time_jitter = ucl_obj_todouble (value);
}
else {
dkim_module_ctx->time_jitter = DEFAULT_TIME_JITTER;
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "max_sigs")) != NULL) {
dkim_module_ctx->max_sigs = ucl_object_toint (value);
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "whitelist")) != NULL) {
rspamd_config_radix_from_ucl (cfg, value, "DKIM whitelist",
&dkim_module_ctx->whitelist_ip, NULL);
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "domains")) != NULL) {
if (!rspamd_map_add_from_ucl (cfg, value,
"DKIM domains", rspamd_kv_list_read, rspamd_kv_list_fin,
(void **)&dkim_module_ctx->dkim_domains)) {
msg_warn_config ("cannot load dkim domains list from %s",
ucl_obj_tostring (value));
}
else {
got_trusted = TRUE;
}
}
if (!got_trusted && (value =
rspamd_config_get_module_opt (cfg, "dkim", "trusted_domains")) != NULL) {
if (!rspamd_map_add_from_ucl (cfg, value,
"DKIM domains", rspamd_kv_list_read, rspamd_kv_list_fin,
(void **)&dkim_module_ctx->dkim_domains)) {
msg_warn_config ("cannot load dkim domains list from %s",
ucl_obj_tostring (value));
}
else {
got_trusted = TRUE;
}
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim",
"strict_multiplier")) != NULL) {
dkim_module_ctx->strict_multiplier = ucl_obj_toint (value);
}
else {
dkim_module_ctx->strict_multiplier = 1;
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "trusted_only")) != NULL) {
dkim_module_ctx->trusted_only = ucl_obj_toboolean (value);
}
else {
dkim_module_ctx->trusted_only = FALSE;
}
if ((value =
rspamd_config_get_module_opt (cfg, "dkim", "skip_multi")) != NULL) {
dkim_module_ctx->skip_multi = ucl_obj_toboolean (value);
}
else {
dkim_module_ctx->skip_multi = FALSE;
}
if (dkim_module_ctx->trusted_only && !got_trusted) {
msg_err_config (
"trusted_only option is set and no trusted domains are defined; disabling dkim module completely as it is useless in this case");
}
else {
cb_id = rspamd_symbols_cache_add_symbol (cfg->cache,
dkim_module_ctx->symbol_reject,
0,
dkim_symbol_callback,
NULL,
SYMBOL_TYPE_NORMAL|SYMBOL_TYPE_FINE,
-1);
rspamd_symbols_cache_add_symbol (cfg->cache,
dkim_module_ctx->symbol_na,
0,
NULL, NULL,
SYMBOL_TYPE_VIRTUAL|SYMBOL_TYPE_FINE,
cb_id);
rspamd_symbols_cache_add_symbol (cfg->cache,
dkim_module_ctx->symbol_tempfail,
0,
NULL, NULL,
SYMBOL_TYPE_VIRTUAL|SYMBOL_TYPE_FINE,
cb_id);
rspamd_symbols_cache_add_symbol (cfg->cache,
dkim_module_ctx->symbol_allow,
0,
NULL, NULL,
SYMBOL_TYPE_VIRTUAL|SYMBOL_TYPE_FINE,
cb_id);
dkim_module_ctx->dkim_hash = rspamd_lru_hash_new (
cache_size,
g_free, /* Keys are just C-strings */
dkim_module_key_dtor);
msg_info_config ("init internal dkim module");
#ifndef HAVE_OPENSSL
msg_warn_config (
"openssl is not found so dkim rsa check is disabled, only check body hash, it is NOT safe to trust these results");
#endif
}
if ((value = rspamd_config_get_module_opt (cfg, "dkim", "sign_condition"))
!= NULL) {
const gchar *lua_script;
lua_script = ucl_object_tostring (value);
if (lua_script) {
if (luaL_dostring (cfg->lua_state, lua_script) != 0) {
msg_err_config ("cannot execute lua script for fuzzy "
"learn condition: %s", lua_tostring (cfg->lua_state, -1));
}
else {
if (lua_type (cfg->lua_state, -1) == LUA_TFUNCTION) {
dkim_module_ctx->sign_condition_ref = luaL_ref (cfg->lua_state,
LUA_REGISTRYINDEX);
dkim_module_ctx->dkim_sign_hash = rspamd_lru_hash_new (
128,
g_free, /* Keys are just C-strings */
(GDestroyNotify)rspamd_dkim_sign_key_unref);
check_id = rspamd_symbols_cache_add_symbol (cfg->cache,
"DKIM_SIGN",
0,
dkim_sign_callback,
NULL,
SYMBOL_TYPE_CALLBACK|SYMBOL_TYPE_FINE,
-1);
msg_info_config ("init condition script for DKIM signing");
/*
* Allow dkim signing to be executed only after dkim check
*/
if (cb_id > 0) {
rspamd_symbols_cache_add_delayed_dependency (cfg->cache,
"DKIM_SIGN", dkim_module_ctx->symbol_reject);
}
rspamd_config_add_metric_symbol (cfg, DEFAULT_METRIC,
"DKIM_SIGN", 0.0, "DKIM signature fake symbol",
"dkim", RSPAMD_SYMBOL_FLAG_IGNORE, 1);
}
else {
msg_err_config ("lua script must return "
"function(task) and not %s",
lua_typename (cfg->lua_state,
lua_type (cfg->lua_state, -1)));
}
}
}
}
return res;
}
static gboolean
rspamd_fuzzy_backend_redis_try_ucl (struct rspamd_fuzzy_backend_redis *backend,
const ucl_object_t *obj,
struct rspamd_config *cfg)
{
const ucl_object_t *elt, *relt;
elt = ucl_object_lookup_any (obj, "read_servers", "servers", NULL);
if (elt == NULL) {
return FALSE;
}
backend->read_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (backend->read_servers, elt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err_config ("cannot get read servers configuration");
return FALSE;
}
relt = elt;
elt = ucl_object_lookup (obj, "write_servers");
if (elt == NULL) {
/* Use read servers as write ones */
g_assert (relt != NULL);
backend->write_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (backend->write_servers, relt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err_config ("cannot get write servers configuration");
return FALSE;
}
}
else {
backend->write_servers = rspamd_upstreams_create (cfg->ups_ctx);
if (!rspamd_upstreams_from_ucl (backend->write_servers, elt,
REDIS_DEFAULT_PORT, NULL)) {
msg_err_config ("cannot get write servers configuration");
rspamd_upstreams_destroy (backend->write_servers);
backend->write_servers = NULL;
}
}
elt = ucl_object_lookup (obj, "prefix");
if (elt == NULL || ucl_object_type (elt) != UCL_STRING) {
backend->redis_object = REDIS_DEFAULT_OBJECT;
}
else {
backend->redis_object = ucl_object_tostring (elt);
}
elt = ucl_object_lookup (obj, "timeout");
if (elt) {
backend->timeout = ucl_object_todouble (elt);
}
else {
backend->timeout = REDIS_DEFAULT_TIMEOUT;
}
elt = ucl_object_lookup (obj, "password");
if (elt) {
backend->password = ucl_object_tostring (elt);
}
else {
backend->password = NULL;
}
elt = ucl_object_lookup_any (obj, "db", "database", "dbname", NULL);
if (elt) {
backend->dbname = ucl_object_tostring (elt);
}
else {
backend->dbname = NULL;
}
return TRUE;
}
