#include "blas-config.h"
+#include <string>
+#include <string_view>
+#include "fmt/core.h"
+#include "cxx/util.hxx"
+#include "frozen/unordered_map.h"
+#include "frozen/string.h"
+
#define DEFAULT_SCORE 10.0
#define DEFAULT_RLIMIT_NOFILE 2048
struct rspamd_ucl_map_cbdata {
struct rspamd_config *cfg;
- GString *buf;
+ std::string buf;
+
+ explicit rspamd_ucl_map_cbdata(struct rspamd_config *cfg)
+ : cfg(cfg)
+ {
+ }
};
static gchar *rspamd_ucl_read_cb(gchar *chunk,
gint len,
const gchar *fdname;
gboolean ret = TRUE;
- if (str == NULL) {
+ if (str == nullptr) {
return FALSE;
}
- cnf = g_malloc0(sizeof(struct rspamd_worker_bind_conf));
+ cnf = rspamd_mempool_alloc0_type(cfg->cfg_pool, struct rspamd_worker_bind_conf);
cnf->cnt = 1024;
- cnf->bind_line = g_strdup(str);
+ cnf->bind_line = rspamd_mempool_strdup(cfg->cfg_pool, str);
+
+ auto bind_line = std::string_view{cnf->bind_line};
- if (g_ascii_strncasecmp(str, "systemd:", sizeof("systemd:") - 1) == 0) {
+ if (bind_line.starts_with("systemd:")) {
/* The actual socket will be passed by systemd environment */
fdname = str + sizeof("systemd:") - 1;
cnf->is_systemd = TRUE;
- cnf->addrs = g_ptr_array_new_full(1, g_free);
+ cnf->addrs = g_ptr_array_new_full(1, nullptr);
+ rspamd_mempool_add_destructor(cfg->cfg_pool,
+ rspamd_ptr_array_free_hard, cnf->addrs);
if (fdname[0]) {
- g_ptr_array_add(cnf->addrs, g_strdup(fdname));
+ g_ptr_array_add(cnf->addrs, rspamd_mempool_strdup(cfg->cfg_pool, fdname));
cnf->cnt = cnf->addrs->len;
- cnf->name = g_strdup(str);
+ cnf->name = rspamd_mempool_strdup(cfg->cfg_pool, str);
LL_PREPEND(cf->bind_conf, cnf);
}
else {
}
else {
if (rspamd_parse_host_port_priority(str, &cnf->addrs,
- NULL, &cnf->name, DEFAULT_BIND_PORT, TRUE, NULL) == RSPAMD_PARSE_ADDR_FAIL) {
+ nullptr, &cnf->name, DEFAULT_BIND_PORT, TRUE, cfg->cfg_pool) == RSPAMD_PARSE_ADDR_FAIL) {
msg_err_config("cannot parse bind line: %s", str);
ret = FALSE;
}
}
}
- if (!ret) {
- if (cnf->addrs) {
- g_ptr_array_free(cnf->addrs, TRUE);
- }
-
- g_free(cnf->name);
- g_free(cnf);
- }
-
return ret;
}
for (int i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
struct rspamd_action *action;
- action = rspamd_mempool_alloc0(cfg->cfg_pool, sizeof(*action));
+ action = rspamd_mempool_alloc0_type(cfg->cfg_pool, struct rspamd_action);
action->threshold = NAN;
action->name = rspamd_mempool_strdup(cfg->cfg_pool,
- rspamd_action_to_str(i));
- action->action_type = i;
+ rspamd_action_to_str(static_cast<rspamd_action_type>(i)));
+ action->action_type = static_cast<rspamd_action_type>(i);
if (i == METRIC_ACTION_SOFT_REJECT) {
action->flags |= RSPAMD_ACTION_NO_THRESHOLD | RSPAMD_ACTION_HAM;
cfg->max_opts_len = 4096;
/* Default log line */
- cfg->log_format_str = "id: <$mid>,$if_qid{ qid: <$>,}$if_ip{ ip: $,}"
- "$if_user{ user: $,}$if_smtp_from{ from: <$>,} (default: $is_spam "
- "($action): [$scores] [$symbols_scores_params]), len: $len, time: $time_real, "
- "dns req: $dns_req, digest: <$digest>"
- "$if_smtp_rcpts{ rcpts: <$>, }$if_mime_rcpt{ mime_rcpt: <$>, }";
+ cfg->log_format_str = rspamd_mempool_strdup(cfg->cfg_pool,
+ "id: <$mid>,$if_qid{ qid: <$>,}$if_ip{ ip: $,}"
+ "$if_user{ user: $,}$if_smtp_from{ from: <$>,} (default: $is_spam "
+ "($action): [$scores] [$symbols_scores_params]), len: $len, time: $time_real, "
+ "dns req: $dns_req, digest: <$digest>"
+ "$if_smtp_rcpts{ rcpts: <$>, }$if_mime_rcpt{ mime_rcpt: <$>, }");
/* Allow non-mime input by default */
cfg->allow_raw_input = TRUE;
/* Default maximum words processed */
cfg->full_gc_iters = DEFAULT_GC_MAXITERS;
/* Default hyperscan cache */
- cfg->hs_cache_dir = RSPAMD_DBDIR "/";
+ cfg->hs_cache_dir = rspamd_mempool_strdup(cfg->cfg_pool, RSPAMD_DBDIR "/");
if (!(flags & RSPAMD_CONFIG_INIT_SKIP_LUA)) {
- cfg->lua_state = rspamd_lua_init(flags & RSPAMD_CONFIG_INIT_WIPE_LUA_MEM);
+ cfg->lua_state = (void *) rspamd_lua_init(flags & RSPAMD_CONFIG_INIT_WIPE_LUA_MEM);
cfg->own_lua_state = TRUE;
- cfg->lua_thread_pool = lua_thread_pool_new(cfg->lua_state);
+ cfg->lua_thread_pool = (void *) lua_thread_pool_new(RSPAMD_LUA_CFG_STATE(cfg));
}
cfg->cache = rspamd_symcache_new(cfg);
*/
cfg->enable_shutdown_workaround = TRUE;
- cfg->ssl_ciphers = "HIGH:!aNULL:!kRSA:!PSK:!SRP:!MD5:!RC4";
+ cfg->ssl_ciphers = rspamd_mempool_strdup(cfg->cfg_pool, "HIGH:!anullptr:!kRSA:!PSK:!SRP:!MD5:!RC4");
cfg->max_message = DEFAULT_MAX_MESSAGE;
cfg->max_pic_size = DEFAULT_MAX_PIC;
cfg->images_cache_size = 256;
struct rspamd_config_settings_elt *set, *stmp;
struct rspamd_worker_log_pipe *lp, *ltmp;
- rspamd_lua_run_config_unload(cfg->lua_state, cfg);
+ rspamd_lua_run_config_unload(RSPAMD_LUA_CFG_STATE(cfg), cfg);
/* Scripts part */
DL_FOREACH_SAFE(cfg->on_term_scripts, sc, sctmp)
{
- luaL_unref(cfg->lua_state, LUA_REGISTRYINDEX, sc->cbref);
+ luaL_unref(RSPAMD_LUA_CFG_STATE(cfg), LUA_REGISTRYINDEX, sc->cbref);
}
DL_FOREACH_SAFE(cfg->on_load_scripts, sc, sctmp)
{
- luaL_unref(cfg->lua_state, LUA_REGISTRYINDEX, sc->cbref);
+ luaL_unref(RSPAMD_LUA_CFG_STATE(cfg), LUA_REGISTRYINDEX, sc->cbref);
}
DL_FOREACH_SAFE(cfg->post_init_scripts, sc, sctmp)
{
- luaL_unref(cfg->lua_state, LUA_REGISTRYINDEX, sc->cbref);
+ luaL_unref(RSPAMD_LUA_CFG_STATE(cfg), LUA_REGISTRYINDEX, sc->cbref);
}
DL_FOREACH_SAFE(cfg->config_unload_scripts, sc, sctmp)
{
- luaL_unref(cfg->lua_state, LUA_REGISTRYINDEX, sc->cbref);
+ luaL_unref(RSPAMD_LUA_CFG_STATE(cfg), LUA_REGISTRYINDEX, sc->cbref);
}
DL_FOREACH_SAFE(cfg->setting_ids, set, stmp)
rspamd_monitored_ctx_destroy(cfg->monitored_ctx);
}
- if (cfg->lua_state && cfg->own_lua_state) {
- lua_thread_pool_free(cfg->lua_thread_pool);
- rspamd_lua_close(cfg->lua_state);
+ if (RSPAMD_LUA_CFG_STATE(cfg) && cfg->own_lua_state) {
+ lua_thread_pool_free((struct lua_thread_pool *) cfg->lua_thread_pool);
+ rspamd_lua_close(RSPAMD_LUA_CFG_STATE(cfg));
}
if (cfg->redis_pool) {
const gchar *module_name,
const gchar *opt_name)
{
- const ucl_object_t *res = NULL, *sec;
+ const ucl_object_t *res = nullptr, *sec;
sec = ucl_obj_get_key(cfg->rcl_obj, module_name);
- if (sec != NULL) {
+ if (sec != nullptr) {
res = ucl_obj_get_key(sec, opt_name);
}
return -1;
}
+// A mapping between names and log format types + flags
+constexpr const auto config_vars = frozen::make_unordered_map<frozen::string, std::pair<rspamd_log_format_type, int>>({
+ {"mid", {RSPAMD_LOG_MID, 0}},
+ {"qid", {RSPAMD_LOG_QID, 0}},
+ {"user", {RSPAMD_LOG_USER, 0}},
+ {"ip", {RSPAMD_LOG_IP, 0}},
+ {"len", {RSPAMD_LOG_LEN, 0}},
+ {"dns_req", {RSPAMD_LOG_DNS_REQ, 0}},
+ {"smtp_from", {RSPAMD_LOG_SMTP_FROM, 0}},
+ {"mime_from", {RSPAMD_LOG_MIME_FROM, 0}},
+ {"smtp_rcpt", {RSPAMD_LOG_SMTP_RCPT, 0}},
+ {"mime_rcpt", {RSPAMD_LOG_MIME_RCPT, 0}},
+ {"smtp_rcpts", {RSPAMD_LOG_SMTP_RCPTS, 0}},
+ {"mime_rcpts", {RSPAMD_LOG_MIME_RCPTS, 0}},
+ {"time_real", {RSPAMD_LOG_TIME_REAL, 0}},
+ {"time_virtual", {RSPAMD_LOG_TIME_VIRTUAL, 0}},
+ {"lua", {RSPAMD_LOG_LUA, 0}},
+ {"digest", {RSPAMD_LOG_DIGEST, 0}},
+ {"checksum", {RSPAMD_LOG_DIGEST, 0}},
+ {"filename", {RSPAMD_LOG_FILENAME, 0}},
+ {"forced_action", {RSPAMD_LOG_FORCED_ACTION, 0}},
+ {"settings_id", {RSPAMD_LOG_SETTINGS_ID, 0}},
+ {"mempool_size", {RSPAMD_LOG_MEMPOOL_SIZE, 0}},
+ {"mempool_waste", {RSPAMD_LOG_MEMPOOL_WASTE, 0}},
+ {"action", {RSPAMD_LOG_ACTION, 0}},
+ {"scores", {RSPAMD_LOG_SCORES, 0}},
+ {"symbols", {RSPAMD_LOG_SYMBOLS, 0}},
+ {"symbols_scores", {RSPAMD_LOG_SYMBOLS, RSPAMD_LOG_FMT_FLAG_SYMBOLS_SCORES}},
+ {"symbols_params", {RSPAMD_LOG_SYMBOLS, RSPAMD_LOG_FMT_FLAG_SYMBOLS_PARAMS}},
+ {"symbols_scores_params", {RSPAMD_LOG_SYMBOLS, RSPAMD_LOG_FMT_FLAG_SYMBOLS_PARAMS | RSPAMD_LOG_FMT_FLAG_SYMBOLS_SCORES}},
+ {"groups", {RSPAMD_LOG_GROUPS, 0}},
+ {"public_groups", {RSPAMD_LOG_PUBLIC_GROUPS, 0}},
+});
+
static gboolean
rspamd_config_process_var(struct rspamd_config *cfg, const rspamd_ftok_t *var,
const rspamd_ftok_t *content)
{
- guint flags = RSPAMD_LOG_FLAG_DEFAULT;
- struct rspamd_log_format *lf;
- enum rspamd_log_format_type type;
- rspamd_ftok_t tok;
- gint id;
+ g_assert(var != nullptr);
- g_assert(var != NULL);
+ auto flags = 0;
+ auto lc_var = std::string{var->begin, var->len};
+ std::transform(lc_var.begin(), lc_var.end(), lc_var.begin(), g_ascii_tolower);
+ auto tok = std::string_view{lc_var};
- if (var->len > 3 && rspamd_lc_cmp(var->begin, "if_", 3) == 0) {
+ if (var->len > 3 && tok.starts_with("if_")) {
flags |= RSPAMD_LOG_FMT_FLAG_CONDITION;
- tok.begin = var->begin + 3;
- tok.len = var->len - 3;
- }
- else {
- tok.begin = var->begin;
- tok.len = var->len;
+ tok = tok.substr(3);
}
- /* Now compare variable and check what we have */
- if (rspamd_ftok_cstr_equal(&tok, "mid", TRUE)) {
- type = RSPAMD_LOG_MID;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "qid", TRUE)) {
- type = RSPAMD_LOG_QID;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "user", TRUE)) {
- type = RSPAMD_LOG_USER;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "is_spam", TRUE)) {
- type = RSPAMD_LOG_ISSPAM;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "action", TRUE)) {
- type = RSPAMD_LOG_ACTION;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "scores", TRUE)) {
- type = RSPAMD_LOG_SCORES;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "symbols", TRUE)) {
- type = RSPAMD_LOG_SYMBOLS;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "symbols_scores", TRUE)) {
- type = RSPAMD_LOG_SYMBOLS;
- flags |= RSPAMD_LOG_FMT_FLAG_SYMBOLS_SCORES;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "symbols_params", TRUE)) {
- type = RSPAMD_LOG_SYMBOLS;
- flags |= RSPAMD_LOG_FMT_FLAG_SYMBOLS_PARAMS;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "symbols_scores_params", TRUE)) {
- type = RSPAMD_LOG_SYMBOLS;
- flags |= RSPAMD_LOG_FMT_FLAG_SYMBOLS_PARAMS | RSPAMD_LOG_FMT_FLAG_SYMBOLS_SCORES;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "groups", TRUE)) {
- type = RSPAMD_LOG_GROUPS;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "public_groups", TRUE)) {
- type = RSPAMD_LOG_PUBLIC_GROUPS;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "ip", TRUE)) {
- type = RSPAMD_LOG_IP;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "len", TRUE)) {
- type = RSPAMD_LOG_LEN;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "dns_req", TRUE)) {
- type = RSPAMD_LOG_DNS_REQ;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "smtp_from", TRUE)) {
- type = RSPAMD_LOG_SMTP_FROM;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "mime_from", TRUE)) {
- type = RSPAMD_LOG_MIME_FROM;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "smtp_rcpt", TRUE)) {
- type = RSPAMD_LOG_SMTP_RCPT;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "mime_rcpt", TRUE)) {
- type = RSPAMD_LOG_MIME_RCPT;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "smtp_rcpts", TRUE)) {
- type = RSPAMD_LOG_SMTP_RCPTS;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "mime_rcpts", TRUE)) {
- type = RSPAMD_LOG_MIME_RCPTS;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "time_real", TRUE)) {
- type = RSPAMD_LOG_TIME_REAL;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "time_virtual", TRUE)) {
- type = RSPAMD_LOG_TIME_VIRTUAL;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "lua", TRUE)) {
- type = RSPAMD_LOG_LUA;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "digest", TRUE) ||
- rspamd_ftok_cstr_equal(&tok, "checksum", TRUE)) {
- type = RSPAMD_LOG_DIGEST;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "filename", TRUE)) {
- type = RSPAMD_LOG_FILENAME;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "forced_action", TRUE)) {
- type = RSPAMD_LOG_FORCED_ACTION;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "settings_id", TRUE)) {
- type = RSPAMD_LOG_SETTINGS_ID;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "mempool_size", TRUE)) {
- type = RSPAMD_LOG_MEMPOOL_SIZE;
- }
- else if (rspamd_ftok_cstr_equal(&tok, "mempool_waste", TRUE)) {
- type = RSPAMD_LOG_MEMPOOL_WASTE;
- }
- else {
- msg_err_config("unknown log variable: %T", &tok);
- return FALSE;
- }
+ auto maybe_fmt_var = rspamd::find_map(config_vars, tok);
- lf = rspamd_mempool_alloc0(cfg->cfg_pool, sizeof(*lf));
- lf->type = type;
- lf->flags = flags;
+ if (maybe_fmt_var) {
+ auto &fmt_var = maybe_fmt_var.value().get();
+ auto *log_format = rspamd_mempool_alloc0_type(cfg->cfg_pool, rspamd_log_format);
- if (type != RSPAMD_LOG_LUA) {
- if (content && content->len > 0) {
- lf->data = rspamd_mempool_alloc0(cfg->cfg_pool,
- sizeof(rspamd_ftok_t));
- memcpy(lf->data, content, sizeof(*content));
- lf->len = sizeof(*content);
- }
- }
- else {
- /* Load lua code and ensure that we have function ref returned */
- if (!content || content->len == 0) {
- msg_err_config("lua variable needs content: %T", &tok);
- return FALSE;
- }
+ log_format->type = fmt_var.first;
+ log_format->flags = fmt_var.second | flags;
- if (luaL_loadbuffer(cfg->lua_state, content->begin, content->len,
- "lua log variable") != 0) {
- msg_err_config("error loading lua code: '%T': %s", content,
- lua_tostring(cfg->lua_state, -1));
- return FALSE;
+ if (log_format->type != RSPAMD_LOG_LUA) {
+ if (content && content->len > 0) {
+ log_format->data = rspamd_mempool_alloc0(cfg->cfg_pool,
+ sizeof(rspamd_ftok_t));
+ memcpy(log_format->data, content, sizeof(*content));
+ log_format->len = sizeof(*content);
+ }
}
- if (lua_pcall(cfg->lua_state, 0, 1, 0) != 0) {
- msg_err_config("error executing lua code: '%T': %s", content,
- lua_tostring(cfg->lua_state, -1));
- lua_pop(cfg->lua_state, 1);
+ else {
+ /* Load lua code and ensure that we have function ref returned */
+ if (!content || content->len == 0) {
+ msg_err_config("lua variable needs content: %T", &tok);
+ return FALSE;
+ }
- return FALSE;
- }
+ if (luaL_loadbuffer(RSPAMD_LUA_CFG_STATE(cfg), content->begin, content->len,
+ "lua log variable") != 0) {
+ msg_err_config("error loading lua code: '%T': %s", content,
+ lua_tostring(RSPAMD_LUA_CFG_STATE(cfg), -1));
+ return FALSE;
+ }
+ if (lua_pcall(RSPAMD_LUA_CFG_STATE(cfg), 0, 1, 0) != 0) {
+ msg_err_config("error executing lua code: '%T': %s", content,
+ lua_tostring(RSPAMD_LUA_CFG_STATE(cfg), -1));
+ lua_pop(RSPAMD_LUA_CFG_STATE(cfg), 1);
- if (lua_type(cfg->lua_state, -1) != LUA_TFUNCTION) {
- msg_err_config("lua variable should return function: %T", content);
- lua_pop(cfg->lua_state, 1);
- return FALSE;
+ return FALSE;
+ }
+
+ if (lua_type(RSPAMD_LUA_CFG_STATE(cfg), -1) != LUA_TFUNCTION) {
+ msg_err_config("lua variable should return function: %T", content);
+ lua_pop(RSPAMD_LUA_CFG_STATE(cfg), 1);
+ return FALSE;
+ }
+
+ auto id = luaL_ref(RSPAMD_LUA_CFG_STATE(cfg), LUA_REGISTRYINDEX);
+ log_format->data = GINT_TO_POINTER(id);
+ log_format->len = 0;
}
- id = luaL_ref(cfg->lua_state, LUA_REGISTRYINDEX);
- lf->data = GINT_TO_POINTER(id);
- lf->len = 0;
+ DL_APPEND(cfg->log_format, log_format);
}
+ else {
+ std::string known_formats;
- DL_APPEND(cfg->log_format, lf);
+ for (const auto &v: config_vars) {
+ known_formats += std::string_view{v.first.data(), v.first.size()};
+ known_formats += ", ";
+ }
+
+ if (known_formats.size() > 2) {
+ // Remove last comma
+ known_formats.resize(known_formats.size() - 2);
+ }
+ msg_err_config("unknown log variable: %T, known vars are: \"%s\"", var, known_formats.c_str());
+ return FALSE;
+ }
return TRUE;
}
{
const gchar *p, *c, *end, *s;
gchar *d;
- struct rspamd_log_format *lf = NULL;
+ struct rspamd_log_format *lf = nullptr;
rspamd_ftok_t var, var_content;
enum {
parse_str,
} state = parse_str;
gint braces = 0;
- g_assert(cfg != NULL);
+ g_assert(cfg != nullptr);
c = cfg->log_format_str;
- if (c == NULL) {
+ if (c == nullptr) {
return FALSE;
}
case parse_dollar:
if (p > c) {
/* We have string element that we need to store */
- lf = rspamd_mempool_alloc0(cfg->cfg_pool, sizeof(*lf));
+ lf = rspamd_mempool_alloc0_type(cfg->cfg_pool, struct rspamd_log_format);
lf->type = RSPAMD_LOG_STRING;
lf->data = rspamd_mempool_alloc(cfg->cfg_pool, p - c + 1);
/* Filter \r\n from the destination */
s = c;
- d = lf->data;
+ d = (char *) lf->data;
while (s < p) {
if (*s != '\r' && *s != '\n') {
lf->len = d - (char *) lf->data;
DL_APPEND(cfg->log_format, lf);
- lf = NULL;
+ lf = nullptr;
}
p++;
c = p;
var.len = p - c;
c = p;
- if (!rspamd_config_process_var(cfg, &var, NULL)) {
+ if (!rspamd_config_process_var(cfg, &var, nullptr)) {
return FALSE;
}
case parse_str:
if (p > c) {
/* We have string element that we need to store */
- lf = rspamd_mempool_alloc0(cfg->cfg_pool, sizeof(*lf));
+ lf = rspamd_mempool_alloc0_type(cfg->cfg_pool, struct rspamd_log_format);
lf->type = RSPAMD_LOG_STRING;
lf->data = rspamd_mempool_alloc(cfg->cfg_pool, p - c + 1);
/* Filter \r\n from the destination */
s = c;
- d = lf->data;
+ d = (char *) lf->data;
while (s < p) {
if (*s != '\r' && *s != '\n') {
lf->len = d - (char *) lf->data;
DL_APPEND(cfg->log_format, lf);
- lf = NULL;
+ lf = nullptr;
}
break;
var.begin = c;
var.len = p - c;
- if (!rspamd_config_process_var(cfg, &var, NULL)) {
+ if (!rspamd_config_process_var(cfg, &var, nullptr)) {
return FALSE;
}
break;
rspamd_url_deinit();
}
-/*
- * Perform post load actions
- */
-gboolean
-rspamd_config_post_load(struct rspamd_config *cfg,
- enum rspamd_post_load_options opts)
+static void
+rspamd_adjust_clocks_resolution(struct rspamd_config *cfg)
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec ts;
#endif
- gboolean ret = TRUE;
#ifdef HAVE_CLOCK_GETTIME
#ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
#else
clock_getres(CLOCK_REALTIME, &ts);
#endif
- rspamd_logger_configure_modules(cfg->debug_modules);
-
cfg->clock_res = log10(1000000. / ts.tv_nsec);
if (cfg->clock_res < 0) {
cfg->clock_res = 0;
/* For gettimeofday */
cfg->clock_res = 1;
#endif
+}
+
+/*
+ * Perform post load actions
+ */
+gboolean
+rspamd_config_post_load(struct rspamd_config *cfg,
+ enum rspamd_post_load_options opts)
+{
+
+ auto ret = TRUE;
+
+ rspamd_adjust_clocks_resolution(cfg);
+ rspamd_logger_configure_modules(cfg->debug_modules);
if (cfg->one_shot_mode) {
msg_info_config("enabling one shot mode (was %d max shots)",
cfg->default_max_shots = 1;
}
- rspamd_regexp_library_init(cfg);
- rspamd_multipattern_library_init(cfg->hs_cache_dir);
-
#if defined(WITH_HYPERSCAN) && !defined(__aarch64__) && !defined(__powerpc64__)
if (!cfg->disable_hyperscan) {
if (!(cfg->libs_ctx->crypto_ctx->cpu_config & CPUID_SSSE3)) {
}
#endif
+ rspamd_regexp_library_init(cfg);
+ rspamd_multipattern_library_init(cfg->hs_cache_dir);
+
if (opts & RSPAMD_CONFIG_INIT_URL) {
- if (cfg->tld_file == NULL) {
+ if (cfg->tld_file == nullptr) {
/* Try to guess tld file */
- GString *fpath = g_string_new(NULL);
+ auto fpath = fmt::format("{0}{1}{2}", RSPAMD_SHAREDIR,
+ G_DIR_SEPARATOR, "effective_tld_names.dat");
- rspamd_printf_gstring(fpath, "%s%c%s", RSPAMD_SHAREDIR,
- G_DIR_SEPARATOR, "effective_tld_names.dat");
-
- if (access(fpath->str, R_OK) != -1) {
+ if (access(fpath.c_str(), R_OK) != -1) {
msg_debug_config("url_tld option is not specified but %s is available,"
" therefore this file is assumed as TLD file for URL"
" extraction",
- fpath->str);
- cfg->tld_file = rspamd_mempool_strdup(cfg->cfg_pool, fpath->str);
+ fpath.c_str());
+ cfg->tld_file = rspamd_mempool_strdup(cfg->cfg_pool, fpath.c_str());
}
else {
if (opts & RSPAMD_CONFIG_INIT_VALIDATE) {
ret = FALSE;
}
}
-
- g_string_free(fpath, TRUE);
}
else {
if (access(cfg->tld_file, R_OK) == -1) {
else {
msg_debug_config("cannot access tld file %s: %s", cfg->tld_file,
strerror(errno));
- cfg->tld_file = NULL;
+ cfg->tld_file = nullptr;
}
}
}
if (opts & RSPAMD_CONFIG_INIT_NO_TLD) {
- rspamd_url_init(NULL);
+ rspamd_url_init(nullptr);
}
else {
rspamd_url_init(cfg->tld_file);
}
rspamd_mempool_add_destructor(cfg->cfg_pool, rspamd_urls_config_dtor,
- NULL);
+ nullptr);
}
init_dynamic_config(cfg);
/* Parse format string that we have */
if (!rspamd_config_parse_log_format(cfg)) {
msg_err_config("cannot parse log format, task logging will not be available");
+ if (opts & RSPAMD_CONFIG_INIT_VALIDATE) {
+ ret = FALSE;
+ }
}
if (opts & RSPAMD_CONFIG_INIT_SYMCACHE) {
/* Init config cache */
- rspamd_symcache_init(cfg->cache);
+ ret &= rspamd_symcache_init(cfg->cache);
/* Init re cache */
rspamd_re_cache_init(cfg->re_cache, cfg);
/* Try load Hypersan */
- rspamd_re_cache_load_hyperscan(cfg->re_cache,
- cfg->hs_cache_dir ? cfg->hs_cache_dir : RSPAMD_DBDIR "/",
- true);
+ auto hs_ret = rspamd_re_cache_load_hyperscan(cfg->re_cache,
+ cfg->hs_cache_dir ? cfg->hs_cache_dir : RSPAMD_DBDIR "/",
+ true);
+
+ if (hs_ret == RSPAMD_HYPERSCAN_LOAD_ERROR) {
+ ret = FALSE;
+ }
}
if (opts & RSPAMD_CONFIG_INIT_LIBS) {
/* Config other libraries */
- rspamd_config_libs(cfg->libs_ctx, cfg);
+ ret &= rspamd_config_libs(cfg->libs_ctx, cfg);
}
/* Validate cache */
if (opts & RSPAMD_CONFIG_INIT_VALIDATE) {
/* Check for actions sanity */
- gboolean seen_controller = FALSE;
- GList *cur;
- struct rspamd_worker_conf *wcf;
+ auto seen_controller = FALSE;
- cur = cfg->workers;
+ auto *cur = cfg->workers;
while (cur) {
- wcf = cur->data;
+ auto *wcf = (struct rspamd_worker_conf *) cur->data;
if (wcf->type == g_quark_from_static_string("controller")) {
seen_controller = TRUE;
" Rspamd features will be broken");
}
- ret = rspamd_symcache_validate(cfg->cache, cfg, FALSE) && ret;
+ ret &= rspamd_symcache_validate(cfg->cache, cfg, FALSE);
}
if (opts & RSPAMD_CONFIG_INIT_POST_LOAD_LUA) {
- rspamd_lua_run_config_post_init(cfg->lua_state, cfg);
+ rspamd_lua_run_config_post_init(RSPAMD_LUA_CFG_STATE(cfg), cfg);
}
if (opts & RSPAMD_CONFIG_INIT_PRELOAD_MAPS) {
rspamd_config_new_classifier(struct rspamd_config *cfg,
struct rspamd_classifier_config *c)
{
- if (c == NULL) {
+ if (c == nullptr) {
c =
- rspamd_mempool_alloc0(cfg->cfg_pool,
- sizeof(struct rspamd_classifier_config));
+ rspamd_mempool_alloc0_type(cfg->cfg_pool,
+ struct rspamd_classifier_config);
c->min_prob_strength = 0.05;
c->min_token_hits = 2;
}
- if (c->labels == NULL) {
+ if (c->labels == nullptr) {
c->labels = g_hash_table_new_full(rspamd_str_hash,
rspamd_str_equal,
- NULL,
+ nullptr,
(GDestroyNotify) g_list_free);
rspamd_mempool_add_destructor(cfg->cfg_pool,
(rspamd_mempool_destruct_t) g_hash_table_destroy,
rspamd_config_new_statfile(struct rspamd_config *cfg,
struct rspamd_statfile_config *c)
{
- if (c == NULL) {
+ if (c == nullptr) {
c =
- rspamd_mempool_alloc0(cfg->cfg_pool,
- sizeof(struct rspamd_statfile_config));
+ rspamd_mempool_alloc0_type(cfg->cfg_pool, struct rspamd_statfile_config);
}
return c;
{
struct rspamd_symbols_group *gr;
- gr = rspamd_mempool_alloc0(cfg->cfg_pool, sizeof(*gr));
+ gr = rspamd_mempool_alloc0_type(cfg->cfg_pool, struct rspamd_symbols_group);
gr->symbols = g_hash_table_new(rspamd_strcase_hash,
rspamd_strcase_equal);
rspamd_mempool_add_destructor(cfg->cfg_pool,
LL_FOREACH_SAFE(wcf->bind_conf, cnf, tmp)
{
- g_free(cnf->name);
- g_free(cnf->bind_line);
g_ptr_array_free(cnf->addrs, TRUE);
- g_free(cnf);
}
ucl_object_unref(wcf->options);
static void
rspamd_worker_conf_cfg_fin(gpointer d)
{
- struct rspamd_worker_conf *wcf = d;
+ auto *wcf = (struct rspamd_worker_conf *) d;
REF_RELEASE(wcf);
}
rspamd_config_new_worker(struct rspamd_config *cfg,
struct rspamd_worker_conf *c)
{
- if (c == NULL) {
- c = g_malloc0(sizeof(struct rspamd_worker_conf));
+ if (c == nullptr) {
+ c = g_new0(struct rspamd_worker_conf, 1);
c->params = g_hash_table_new(rspamd_str_hash, rspamd_str_equal);
c->active_workers = g_queue_new();
#ifdef HAVE_SC_NPROCESSORS_ONLN
- c->count = MIN(DEFAULT_MAX_WORKERS,
- MAX(1, sysconf(_SC_NPROCESSORS_ONLN) - 2));
+ auto nproc = sysconf(_SC_NPROCESSORS_ONLN);
+ c->count = MIN(DEFAULT_MAX_WORKERS, MAX(1, nproc - 2));
#else
c->count = DEFAULT_MAX_WORKERS;
#endif
rspamd_include_map_handler(const guchar *data, gsize len,
const ucl_object_t *args, void *ud)
{
- struct rspamd_config *cfg = (struct rspamd_config *) ud;
- struct rspamd_ucl_map_cbdata *cbdata, **pcbdata;
- gchar *map_line;
+ auto *cfg = (struct rspamd_config *) ud;
- map_line = rspamd_mempool_alloc(cfg->cfg_pool, len + 1);
- rspamd_strlcpy(map_line, data, len + 1);
+ auto *map_line = rspamd_mempool_ftokdup(cfg->cfg_pool,
+ (rspamd_ftok_t{.len = len + 1, .begin = (char *) data}));
- cbdata = g_malloc(sizeof(struct rspamd_ucl_map_cbdata));
- pcbdata = g_malloc(sizeof(struct rspamd_ucl_map_cbdata *));
- cbdata->buf = NULL;
- cbdata->cfg = cfg;
- *pcbdata = cbdata;
+ auto *cbdata = new rspamd_ucl_map_cbdata{cfg};
+ auto **pcbdata = new rspamd_ucl_map_cbdata *(cbdata);
return rspamd_map_add(cfg,
map_line,
rspamd_ucl_fin_cb,
rspamd_ucl_dtor_cb,
(void **) pcbdata,
- NULL, RSPAMD_MAP_DEFAULT) != NULL;
+ nullptr, RSPAMD_MAP_DEFAULT) != nullptr;
}
/*
ucl_parser_register_variable(parser, RSPAMD_HOSTNAME_MACRO,
hostbuf);
- if (vars != NULL) {
+ if (vars != nullptr) {
g_hash_table_iter_init(&it, vars);
while (g_hash_table_iter_next(&it, &k, &v)) {
struct rspamd_config *cfg = ud;
/* Actually, statistics should act like any ordinary symbol */
- rspamd_symcache_add_symbol(cfg->cache, key, 0, NULL, NULL,
+ rspamd_symcache_add_symbol(cfg->cache, key, 0, nullptr, nullptr,
SYMBOL_TYPE_CLASSIFIER | SYMBOL_TYPE_NOSTAT, -1);
}
GList *cur;
struct rspamd_classifier_config *cf;
- if (name == NULL) {
- return NULL;
+ if (name == nullptr) {
+ return nullptr;
}
cur = cfg->classifiers;
cur = g_list_next(cur);
}
- return NULL;
+ return nullptr;
}
gboolean
struct map_cb_data *data,
gboolean final)
{
- struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev;
+ auto *cbdata = (struct rspamd_ucl_map_cbdata *) data->cur_data;
+ auto *prev = (struct rspamd_ucl_map_cbdata *) data->prev_data;
- if (cbdata == NULL) {
- cbdata = g_malloc(sizeof(struct rspamd_ucl_map_cbdata));
- prev = data->prev_data;
- cbdata->buf = g_string_sized_new(BUFSIZ);
- cbdata->cfg = prev->cfg;
+ if (cbdata == nullptr) {
+ cbdata = new rspamd_ucl_map_cbdata{prev->cfg};
data->cur_data = cbdata;
}
- g_string_append_len(cbdata->buf, chunk, len);
+ cbdata->buf.append(chunk, len);
/* Say not to copy any part of this buffer */
- return NULL;
+ return nullptr;
}
static void
rspamd_ucl_fin_cb(struct map_cb_data *data, void **target)
{
- struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev =
- data->prev_data;
- ucl_object_t *obj;
- struct ucl_parser *parser;
- ucl_object_iter_t it = NULL;
- const ucl_object_t *cur;
- struct rspamd_config *cfg = data->map->cfg;
-
- if (cbdata == NULL) {
- msg_err_config("map fin error: new data is NULL");
+ auto *cbdata = (struct rspamd_ucl_map_cbdata *) data->cur_data;
+ auto *prev = (struct rspamd_ucl_map_cbdata *) data->prev_data;
+ auto *cfg = data->map->cfg;
+
+ if (cbdata == nullptr) {
+ msg_err_config("map fin error: new data is nullptr");
return;
}
/* New data available */
- parser = ucl_parser_new(0);
- if (!ucl_parser_add_chunk(parser, cbdata->buf->str,
- cbdata->buf->len)) {
+ auto *parser = ucl_parser_new(0);
+ if (!ucl_parser_add_chunk(parser, (unsigned char *) cbdata->buf.data(),
+ cbdata->buf.size())) {
msg_err_config("cannot parse map %s: %s",
data->map->name,
ucl_parser_get_error(parser));
ucl_parser_free(parser);
}
else {
- obj = ucl_parser_get_object(parser);
- ucl_parser_free(parser);
- it = NULL;
+ auto *obj = ucl_parser_get_object(parser);
+ ucl_object_iter_t it = nullptr;
- while ((cur = ucl_object_iterate(obj, &it, true))) {
+ for (auto *cur = ucl_object_iterate(obj, &it, true); cur != nullptr; cur = ucl_object_iterate(obj, &it, true)) {
ucl_object_replace_key(cbdata->cfg->rcl_obj, (ucl_object_t *) cur,
cur->key, cur->keylen, false);
}
+
+ ucl_parser_free(parser);
ucl_object_unref(obj);
}
*target = data->cur_data;
}
- if (prev != NULL) {
- if (prev->buf != NULL) {
- g_string_free(prev->buf, TRUE);
- }
- g_free(prev);
- }
+ delete prev;
}
static void
rspamd_ucl_dtor_cb(struct map_cb_data *data)
{
- struct rspamd_ucl_map_cbdata *cbdata = data->cur_data;
+ auto *cbdata = (struct rspamd_ucl_map_cbdata *) data->cur_data;
- if (cbdata != NULL) {
- if (cbdata->buf != NULL) {
- g_string_free(cbdata->buf, TRUE);
- }
- g_free(cbdata);
- }
+ delete cbdata;
}
gboolean
{
gboolean ret = TRUE;
- if (mod != NULL) {
+ if (mod != nullptr) {
if (mod->module_version != RSPAMD_CUR_MODULE_VERSION) {
msg_err_config("module %s has incorrect version %xd (%xd expected)",
mod->name, (gint) mod->module_version, RSPAMD_CUR_MODULE_VERSION);
{
gboolean ret = TRUE;
- if (wrk != NULL) {
+ if (wrk != nullptr) {
if (wrk->worker_version != RSPAMD_CUR_WORKER_VERSION) {
msg_err_config("worker %s has incorrect version %xd (%xd expected)",
wrk->name, wrk->worker_version, RSPAMD_CUR_WORKER_VERSION);
/* Init all compiled modules */
- for (pmod = cfg->compiled_modules; pmod != NULL && *pmod != NULL; pmod++) {
+ for (pmod = cfg->compiled_modules; pmod != nullptr && *pmod != nullptr; pmod++) {
mod = *pmod;
if (rspamd_check_module(cfg, mod)) {
if (mod->module_init_func(cfg, &mod_ctx) == 0) {
- g_assert(mod_ctx != NULL);
+ g_assert(mod_ctx != nullptr);
g_ptr_array_add(cfg->c_modules, mod_ctx);
mod_ctx->mod = mod;
mod->ctx_offset = i++;
while (cur) {
/* Perform modules configuring */
- mod_ctx = NULL;
+ mod_ctx = nullptr;
PTR_ARRAY_FOREACH(cfg->c_modules, i, cur_ctx)
{
if (g_ascii_strcasecmp(cur_ctx->mod->name,
}
}
- if (mod_ctx == NULL) {
+ if (mod_ctx == nullptr) {
msg_warn_config("requested unknown module %s", cur->data);
}
{
struct rspamd_symbols_group *sym_group;
struct rspamd_symbol *sym_def;
- gdouble *score_ptr;
+ double *score_ptr;
sym_def =
- rspamd_mempool_alloc0(cfg->cfg_pool, sizeof(struct rspamd_symbol));
- score_ptr = rspamd_mempool_alloc(cfg->cfg_pool, sizeof(gdouble));
+ rspamd_mempool_alloc0_type(cfg->cfg_pool, struct rspamd_symbol);
+ score_ptr = rspamd_mempool_alloc_type(cfg->cfg_pool, double);
if (isnan(score)) {
/* In fact, it could be defined later */
g_hash_table_insert(cfg->symbols, sym_def->name, sym_def);
/* Search for symbol group */
- if (group == NULL) {
+ if (group == nullptr) {
group = "ungrouped";
sym_def->flags |= RSPAMD_SYMBOL_FLAG_UNGROUPED;
}
}
}
- sym_group = g_hash_table_lookup(cfg->groups, group);
- if (sym_group == NULL) {
+ sym_group = reinterpret_cast<rspamd_symbols_group *>(g_hash_table_lookup(cfg->groups, group));
+ if (sym_group == nullptr) {
/* Create new group */
sym_group = rspamd_config_new_group(cfg, group);
}
struct rspamd_symbols_group *sym_group;
guint i;
- g_assert(cfg != NULL);
- g_assert(symbol != NULL);
+ g_assert(cfg != nullptr);
+ g_assert(symbol != nullptr);
- sym_def = g_hash_table_lookup(cfg->symbols, symbol);
+ sym_def = reinterpret_cast<rspamd_symbol *>(g_hash_table_lookup(cfg->symbols, symbol));
- if (sym_def != NULL) {
- if (group != NULL) {
+ if (sym_def != nullptr) {
+ if (group != nullptr) {
gboolean has_group = FALSE;
PTR_ARRAY_FOREACH(sym_def->groups, i, sym_group)
if (!has_group) {
/* Non-empty group has a priority over non-grouped one */
- sym_group = g_hash_table_lookup(cfg->groups, group);
+ sym_group = reinterpret_cast<rspamd_symbols_group *>(g_hash_table_lookup(cfg->groups, group));
- if (sym_group == NULL) {
+ if (sym_group == nullptr) {
/* Create new group */
sym_group = rspamd_config_new_group(cfg, group);
}
/* We also check group information in this case */
- if (group != NULL && sym_def->gr != NULL &&
+ if (group != nullptr && sym_def->gr != nullptr &&
strcmp(group, sym_def->gr->name) != 0) {
- sym_group = g_hash_table_lookup(cfg->groups, group);
+ sym_group = reinterpret_cast<rspamd_symbols_group *>(g_hash_table_lookup(cfg->groups, group));
- if (sym_group == NULL) {
+ if (sym_group == nullptr) {
/* Create new group */
sym_group = rspamd_config_new_group(cfg, group);
}
struct rspamd_symbols_group *sym_group;
guint i;
- g_assert(cfg != NULL);
- g_assert(symbol != NULL);
- g_assert(group != NULL);
+ g_assert(cfg != nullptr);
+ g_assert(symbol != nullptr);
+ g_assert(group != nullptr);
- sym_def = g_hash_table_lookup(cfg->symbols, symbol);
+ sym_def = reinterpret_cast<rspamd_symbol *>(g_hash_table_lookup(cfg->symbols, symbol));
- if (sym_def != NULL) {
+ if (sym_def != nullptr) {
gboolean has_group = FALSE;
PTR_ARRAY_FOREACH(sym_def->groups, i, sym_group)
if (!has_group) {
/* Non-empty group has a priority over non-grouped one */
- sym_group = g_hash_table_lookup(cfg->groups, group);
+ sym_group = reinterpret_cast<rspamd_symbols_group *>(g_hash_table_lookup(cfg->groups, group));
- if (sym_group == NULL) {
+ if (sym_group == nullptr) {
/* Create new group */
sym_group = rspamd_config_new_group(cfg, group);
}
rspamd_config_is_enabled_from_ucl(rspamd_mempool_t *pool,
const ucl_object_t *obj)
{
- {
- const ucl_object_t *enabled;
- enabled = ucl_object_lookup(obj, "enabled");
+ const ucl_object_t *enabled;
- if (enabled) {
- if (ucl_object_type(enabled) == UCL_BOOLEAN) {
- return ucl_object_toboolean(enabled);
- }
- else if (ucl_object_type(enabled) == UCL_STRING) {
- gint ret = rspamd_config_parse_flag(ucl_object_tostring(enabled), 0);
+ enabled = ucl_object_lookup(obj, "enabled");
- if (ret == 0) {
- return FALSE;
- }
- else if (ret == -1) {
+ if (enabled) {
+ if (ucl_object_type(enabled) == UCL_BOOLEAN) {
+ return ucl_object_toboolean(enabled);
+ }
+ else if (ucl_object_type(enabled) == UCL_STRING) {
+ gint ret = rspamd_config_parse_flag(ucl_object_tostring(enabled), 0);
- msg_info_pool_check("wrong value for the `enabled` key");
- return FALSE;
- }
- /* Default return is TRUE here */
+ if (ret == 0) {
+ return FALSE;
}
+ else if (ret == -1) {
+
+ msg_info_pool_check("wrong value for the `enabled` key");
+ return FALSE;
+ }
+ /* Default return is TRUE here */
}
}
- {
- const ucl_object_t *disabled;
- disabled = ucl_object_lookup(obj, "disabled");
+ const ucl_object_t *disabled;
- if (disabled) {
- if (ucl_object_type(disabled) == UCL_BOOLEAN) {
- return !ucl_object_toboolean(disabled);
- }
- else if (ucl_object_type(disabled) == UCL_STRING) {
- gint ret = rspamd_config_parse_flag(ucl_object_tostring(disabled), 0);
+ disabled = ucl_object_lookup(obj, "disabled");
- if (ret == 0) {
- return TRUE;
- }
- else if (ret == -1) {
+ if (disabled) {
+ if (ucl_object_type(disabled) == UCL_BOOLEAN) {
+ return !ucl_object_toboolean(disabled);
+ }
+ else if (ucl_object_type(disabled) == UCL_STRING) {
+ gint ret = rspamd_config_parse_flag(ucl_object_tostring(disabled), 0);
- msg_info_pool_check("wrong value for the `disabled` key");
- return FALSE;
- }
+ if (ret == 0) {
+ return TRUE;
+ }
+ else if (ret == -1) {
+ msg_info_pool_check("wrong value for the `disabled` key");
return FALSE;
}
+
+ return FALSE;
}
}
const ucl_object_t *conf;
GList *cur;
struct rspamd_symbols_group *gr;
- lua_State *L = cfg->lua_state;
+ lua_State *L = RSPAMD_LUA_CFG_STATE(cfg);
struct module_ctx *cur_ctx;
guint i;
}
}
- if (g_hash_table_lookup(cfg->explicit_modules, module_name) != NULL) {
+ if (g_hash_table_lookup(cfg->explicit_modules, module_name) != nullptr) {
/* Always load module */
rspamd_plugins_table_push_elt(L, "enabled", module_name);
cur = g_list_first(cfg->filters);
while (cur) {
- if (strcmp(cur->data, module_name) == 0) {
+ if (strcmp((char *) cur->data, module_name) == 0) {
found = TRUE;
break;
}
conf = ucl_object_lookup(cfg->rcl_obj, module_name);
- if (conf == NULL) {
+ if (conf == nullptr) {
rspamd_plugins_table_push_elt(L, "disabled_unconfigured", module_name);
msg_info_config("%s module %s is enabled but has not been configured",
}
/* Now we check symbols group */
- gr = g_hash_table_lookup(cfg->groups, module_name);
+ gr = reinterpret_cast<rspamd_symbols_group *>(g_hash_table_lookup(cfg->groups, module_name));
if (gr) {
if (gr->flags & RSPAMD_SYMBOL_GROUP_DISABLED) {
if (obj_type == UCL_OBJECT) {
obj_type = ucl_object_type(obj);
- elt = ucl_object_lookup_any(obj, "score", "threshold", NULL);
+ elt = ucl_object_lookup_any(obj, "score", "threshold", nullptr);
if (elt) {
threshold = ucl_object_todouble(elt);
if (elt && ucl_object_type(elt) == UCL_ARRAY) {
const ucl_object_t *cur;
- ucl_object_iter_t it = NULL;
+ ucl_object_iter_t it = nullptr;
- while ((cur = ucl_object_iterate(elt, &it, true)) != NULL) {
+ while ((cur = ucl_object_iterate(elt, &it, true)) != nullptr) {
if (ucl_object_type(cur) == UCL_STRING) {
const gchar *fl_str = ucl_object_tostring(cur);
const ucl_object_t *elt;
guint priority = ucl_object_get_priority(obj), obj_type;
- g_assert(cfg != NULL);
- g_assert(action_name != NULL);
+ g_assert(cfg != nullptr);
+ g_assert(action_name != nullptr);
obj_type = ucl_object_type(obj);
struct rspamd_action *
rspamd_config_get_action(struct rspamd_config *cfg, const gchar *name)
{
- struct rspamd_action *res = NULL;
+ struct rspamd_action *res = nullptr;
HASH_FIND_STR(cfg->actions, name, res);
}
}
- return NULL;
+ return nullptr;
}
gboolean
struct rspamd_worker *worker, const gchar *map_name)
{
ucl_type_t type;
- ucl_object_iter_t it = NULL;
+ ucl_object_iter_t it = nullptr;
const ucl_object_t *cur, *cur_elt;
const gchar *str;
/* Cleanup */
- *target = NULL;
+ *target = nullptr;
LL_FOREACH(obj, cur_elt)
{
rspamd_radix_fin,
rspamd_radix_dtor,
(void **) target,
- worker, RSPAMD_MAP_DEFAULT) == NULL) {
+ worker, RSPAMD_MAP_DEFAULT) == nullptr) {
g_set_error(err,
g_quark_from_static_string("rspamd-config"),
EINVAL, "bad map definition %s for %s", str,
rspamd_radix_fin,
rspamd_radix_dtor,
(void **) target,
- worker, RSPAMD_MAP_DEFAULT) == NULL) {
+ worker, RSPAMD_MAP_DEFAULT) == nullptr) {
g_set_error(err,
g_quark_from_static_string("rspamd-config"),
EINVAL, "bad map object for %s", ucl_object_key(obj));
/* List of IP addresses */
it = ucl_object_iterate_new(cur_elt);
- while ((cur = ucl_object_iterate_safe(it, true)) != NULL) {
+ while ((cur = ucl_object_iterate_safe(it, true)) != nullptr) {
if (ucl_object_type(cur) == UCL_STRING) {
}
}
- return NULL;
+ return nullptr;
}
struct rspamd_config_settings_elt *rspamd_config_find_settings_name_ref(
int rspamd_config_ev_backend_get(struct rspamd_config *cfg)
{
#define AUTO_BACKEND (ev_supported_backends() & ~EVBACKEND_IOURING)
- if (cfg == NULL || cfg->events_backend == NULL) {
+ if (cfg == nullptr || cfg->events_backend == nullptr) {
return AUTO_BACKEND;
}
const gchar *
rspamd_config_ev_backend_to_string(int ev_backend, gboolean *effective)
{
-#define SET_EFFECTIVE(b) \
- do { \
- if ((effective) != NULL) *(effective) = b; \
+#define SET_EFFECTIVE(b) \
+ do { \
+ if ((effective) != nullptr) *(effective) = b; \
} while (0)
if ((ev_backend & EVBACKEND_ALL) == EVBACKEND_ALL) {
ottery_config_disable_entropy_sources(ottery_cfg,
OTTERY_ENTROPY_SRC_RDRAND);
#if OPENSSL_VERSION_NUMBER >= 0x1000104fL && OPENSSL_VERSION_NUMBER < 0x30000000L && !defined(LIBRESSL_VERSION_NUMBER)
- RAND_set_rand_engine(NULL);
+ RAND_set_rand_engine(nullptr);
#endif
}
g_assert(ottery_init(ottery_cfg) == 0);
#ifdef HAVE_LOCALE_H
- if (getenv("LANG") == NULL) {
+ if (getenv("LANG") == nullptr) {
setlocale(LC_ALL, "C");
setlocale(LC_CTYPE, "C");
setlocale(LC_MESSAGES, "C");
dict = g_malloc0(sizeof(*dict));
dict->dict = rspamd_file_xmap(path, PROT_READ, &dict->size, TRUE);
- if (dict->dict == NULL) {
+ if (dict->dict == nullptr) {
g_free(dict);
- return NULL;
+ return nullptr;
}
dict->id = -1;
if (dict->id == 0) {
g_free(dict);
- return NULL;
+ return nullptr;
}
return dict;
size_t r;
gboolean ret = TRUE;
- g_assert(cfg != NULL);
+ g_assert(cfg != nullptr);
- if (ctx != NULL) {
+ if (ctx != nullptr) {
if (cfg->local_addrs) {
ret = rspamd_config_radix_from_ucl(cfg, cfg->local_addrs,
"Local addresses",
(struct rspamd_radix_map_helper **) ctx->local_addrs,
- NULL,
- NULL, "local addresses");
+ nullptr,
+ nullptr, "local addresses");
}
rspamd_free_zstd_dictionary(ctx->in_dict);
if (ctx->out_zstream) {
ZSTD_freeCStream(ctx->out_zstream);
- ctx->out_zstream = NULL;
+ ctx->out_zstream = nullptr;
}
if (ctx->in_zstream) {
ZSTD_freeDStream(ctx->in_zstream);
- ctx->in_zstream = NULL;
+ ctx->in_zstream = nullptr;
}
if (cfg->zstd_input_dictionary) {
ctx->in_dict = rspamd_open_zstd_dictionary(
cfg->zstd_input_dictionary);
- if (ctx->in_dict == NULL) {
+ if (ctx->in_dict == nullptr) {
msg_err_config("cannot open zstd dictionary in %s",
cfg->zstd_input_dictionary);
}
ctx->out_dict = rspamd_open_zstd_dictionary(
cfg->zstd_output_dictionary);
- if (ctx->out_dict == NULL) {
+ if (ctx->out_dict == nullptr) {
msg_err_config("cannot open zstd dictionary in %s",
cfg->zstd_output_dictionary);
}
/* Toggle FIPS mode */
if (mode == 0) {
#if defined(OPENSSL_VERSION_MAJOR) && (OPENSSL_VERSION_MAJOR >= 3)
- if (EVP_set_default_properties(NULL, "fips=yes") != 1) {
+ if (EVP_set_default_properties(nullptr, "fips=yes") != 1) {
#else
if (FIPS_mode_set(1) != 1) {
#endif
#else
msg_err_config("FIPS_mode_set failed: %s",
#endif
- ERR_error_string(err, NULL));
+ ERR_error_string(err, nullptr));
ret = FALSE;
}
else {
msg_err("cannot init decompression stream: %s",
ZSTD_getErrorName(r));
ZSTD_freeDStream(ctx->in_zstream);
- ctx->in_zstream = NULL;
+ ctx->in_zstream = nullptr;
}
/* Init compression */
msg_err("cannot init compression stream: %s",
ZSTD_getErrorName(r));
ZSTD_freeCStream(ctx->out_zstream);
- ctx->out_zstream = NULL;
+ ctx->out_zstream = nullptr;
}
#ifdef HAVE_OPENBLAS_SET_NUM_THREADS
openblas_set_num_threads(cfg->max_blas_threads);
{
gsize r;
- if (ctx->in_zstream == NULL) {
+ if (ctx->in_zstream == nullptr) {
return FALSE;
}
else {
msg_err("cannot init decompression stream: %s",
ZSTD_getErrorName(r));
ZSTD_freeDStream(ctx->in_zstream);
- ctx->in_zstream = NULL;
+ ctx->in_zstream = nullptr;
return FALSE;
}
{
gsize r;
- if (ctx->out_zstream == NULL) {
+ if (ctx->out_zstream == nullptr) {
return FALSE;
}
else {
msg_err("cannot init compression stream: %s",
ZSTD_getErrorName(r));
ZSTD_freeCStream(ctx->out_zstream);
- ctx->out_zstream = NULL;
+ ctx->out_zstream = nullptr;
return FALSE;
}
void rspamd_deinit_libs(struct rspamd_external_libs_ctx *ctx)
{
- if (ctx != NULL) {
+ if (ctx != nullptr) {
g_free(ctx->ottery_cfg);
#ifdef HAVE_OPENSSL
rspamd_ip_is_local_cfg(struct rspamd_config *cfg,
const rspamd_inet_addr_t *addr)
{
- struct rspamd_radix_map_helper *local_addrs = NULL;
+ struct rspamd_radix_map_helper *local_addrs = nullptr;
if (cfg && cfg->libs_ctx) {
local_addrs = *(struct rspamd_radix_map_helper **) cfg->libs_ctx->local_addrs;
}
if (local_addrs) {
- if (rspamd_match_radix_map_addr(local_addrs, addr) != NULL) {
+ if (rspamd_match_radix_map_addr(local_addrs, addr) != nullptr) {
return TRUE;
}
}
projects / thirdparty / rspamd.git / commitdiff
