aboutsummaryrefslogtreecommitdiffstats
path: root/src/rspamd.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/rspamd.c')
-rw-r--r--src/rspamd.c1240
1 files changed, 618 insertions, 622 deletions
diff --git a/src/rspamd.c b/src/rspamd.c
index 57daf2319..58a3f8783 100644
--- a/src/rspamd.c
+++ b/src/rspamd.c
@@ -64,14 +64,14 @@
/* 10 seconds after getting termination signal to terminate all workers with SIGKILL */
#define TERMINATION_INTERVAL (0.2)
-static gboolean load_rspamd_config (struct rspamd_main *rspamd_main,
- struct rspamd_config *cfg,
- gboolean init_modules,
- enum rspamd_post_load_options opts,
- gboolean reload);
-static void rspamd_cld_handler (EV_P_ ev_child *w,
- struct rspamd_main *rspamd_main,
- struct rspamd_worker *wrk);
+static gboolean load_rspamd_config(struct rspamd_main *rspamd_main,
+ struct rspamd_config *cfg,
+ gboolean init_modules,
+ enum rspamd_post_load_options opts,
+ gboolean reload);
+static void rspamd_cld_handler(EV_P_ ev_child *w,
+ struct rspamd_main *rspamd_main,
+ struct rspamd_worker *wrk);
/* Control socket */
static gint control_fd;
@@ -104,61 +104,60 @@ extern module_t *modules[];
extern worker_t *workers[];
/* Command line options */
-static gboolean rspamd_parse_var (const gchar *option_name,
- const gchar *value, gpointer data,
- GError **error);
+static gboolean rspamd_parse_var(const gchar *option_name,
+ const gchar *value, gpointer data,
+ GError **error);
static GOptionEntry entries[] =
-{
- { "no-fork", 'f', 0, G_OPTION_ARG_NONE, &no_fork,
- "Do not daemonize main process", NULL },
- { "config", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &cfg_names,
- "Specify config file(s)", NULL },
- { "user", 'u', 0, G_OPTION_ARG_STRING, &rspamd_user,
- "User to run rspamd as", NULL },
- { "group", 'g', 0, G_OPTION_ARG_STRING, &rspamd_group,
- "Group to run rspamd as", NULL },
- { "pid", 'p', 0, G_OPTION_ARG_STRING, &rspamd_pidfile, "Path to pidfile",
- NULL },
- { "debug", 'd', 0, G_OPTION_ARG_NONE, &is_debug, "Force debug output",
- NULL },
- { "insecure", 'i', 0, G_OPTION_ARG_NONE, &is_insecure,
- "Ignore running workers as privileged users (insecure)", NULL },
- { "version", 'v', 0, G_OPTION_ARG_NONE, &show_version,
- "Show version and exit", NULL },
- {"var", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer)&rspamd_parse_var,
- "Redefine/define environment variable", NULL},
- {"skip-template", 'T', 0, G_OPTION_ARG_NONE, &skip_template,
- "Do not apply Jinja templates", NULL},
- {"lua-env", '\0', 0, G_OPTION_ARG_FILENAME_ARRAY, &lua_env,
- "Load lua environment from the specified files", NULL},
- { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
-};
+ {
+ {"no-fork", 'f', 0, G_OPTION_ARG_NONE, &no_fork,
+ "Do not daemonize main process", NULL},
+ {"config", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &cfg_names,
+ "Specify config file(s)", NULL},
+ {"user", 'u', 0, G_OPTION_ARG_STRING, &rspamd_user,
+ "User to run rspamd as", NULL},
+ {"group", 'g', 0, G_OPTION_ARG_STRING, &rspamd_group,
+ "Group to run rspamd as", NULL},
+ {"pid", 'p', 0, G_OPTION_ARG_STRING, &rspamd_pidfile, "Path to pidfile",
+ NULL},
+ {"debug", 'd', 0, G_OPTION_ARG_NONE, &is_debug, "Force debug output",
+ NULL},
+ {"insecure", 'i', 0, G_OPTION_ARG_NONE, &is_insecure,
+ "Ignore running workers as privileged users (insecure)", NULL},
+ {"version", 'v', 0, G_OPTION_ARG_NONE, &show_version,
+ "Show version and exit", NULL},
+ {"var", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer) &rspamd_parse_var,
+ "Redefine/define environment variable", NULL},
+ {"skip-template", 'T', 0, G_OPTION_ARG_NONE, &skip_template,
+ "Do not apply Jinja templates", NULL},
+ {"lua-env", '\0', 0, G_OPTION_ARG_FILENAME_ARRAY, &lua_env,
+ "Load lua environment from the specified files", NULL},
+ {NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL}};
static gboolean
-rspamd_parse_var (const gchar *option_name,
- const gchar *value, gpointer data,
- GError **error)
+rspamd_parse_var(const gchar *option_name,
+ const gchar *value, gpointer data,
+ GError **error)
{
gchar *k, *v, *t;
- t = strchr (value, '=');
+ t = strchr(value, '=');
if (t != NULL) {
- k = g_strdup (value);
+ k = g_strdup(value);
t = k + (t - value);
- v = g_strdup (t + 1);
+ v = g_strdup(t + 1);
*t = '\0';
if (ucl_vars == NULL) {
- ucl_vars = g_hash_table_new_full (rspamd_strcase_hash,
- rspamd_strcase_equal, g_free, g_free);
+ ucl_vars = g_hash_table_new_full(rspamd_strcase_hash,
+ rspamd_strcase_equal, g_free, g_free);
}
- g_hash_table_insert (ucl_vars, k, v);
+ g_hash_table_insert(ucl_vars, k, v);
}
else {
- g_set_error (error, g_quark_try_string ("main"), EINVAL,
- "Bad variable format: %s", value);
+ g_set_error(error, g_quark_try_string("main"), EINVAL,
+ "Bad variable format: %s", value);
return FALSE;
}
@@ -166,53 +165,53 @@ rspamd_parse_var (const gchar *option_name,
}
static void
-read_cmd_line (gint *argc, gchar ***argv, struct rspamd_config *cfg)
+read_cmd_line(gint *argc, gchar ***argv, struct rspamd_config *cfg)
{
GError *error = NULL;
GOptionContext *context;
guint cfg_num;
- context = g_option_context_new ("- run rspamd daemon");
+ context = g_option_context_new("- run rspamd daemon");
#if defined(GIT_VERSION) && GIT_VERSION == 1
- g_option_context_set_summary (context,
- "Summary:\n Rspamd daemon version " RVERSION "-git\n Git id: " RID);
+ g_option_context_set_summary(context,
+ "Summary:\n Rspamd daemon version " RVERSION "-git\n Git id: " RID);
#else
- g_option_context_set_summary (context,
- "Summary:\n Rspamd daemon version " RVERSION);
+ g_option_context_set_summary(context,
+ "Summary:\n Rspamd daemon version " RVERSION);
#endif
- g_option_context_add_main_entries (context, entries, NULL);
+ g_option_context_add_main_entries(context, entries, NULL);
- if (!g_option_context_parse (context, argc, argv, &error)) {
- fprintf (stderr, "option parsing failed: %s\n", error->message);
- g_option_context_free (context);
- exit (EXIT_FAILURE);
+ if (!g_option_context_parse(context, argc, argv, &error)) {
+ fprintf(stderr, "option parsing failed: %s\n", error->message);
+ g_option_context_free(context);
+ exit(EXIT_FAILURE);
}
cfg->rspamd_user = rspamd_user;
cfg->rspamd_group = rspamd_group;
- cfg_num = cfg_names != NULL ? g_strv_length (cfg_names) : 0;
+ cfg_num = cfg_names != NULL ? g_strv_length(cfg_names) : 0;
if (cfg_num == 0) {
cfg->cfg_name = FIXED_CONFIG_FILE;
}
else {
cfg->cfg_name = cfg_names[0];
- g_assert (cfg_num == 1);
+ g_assert(cfg_num == 1);
}
cfg->pid_file = rspamd_pidfile;
- g_option_context_free (context);
+ g_option_context_free(context);
}
static int
-rspamd_write_pid (struct rspamd_main *main)
+rspamd_write_pid(struct rspamd_main *main)
{
pid_t pid;
if (main->cfg->pid_file == NULL) {
return -1;
}
- main->pfh = rspamd_pidfile_open (main->cfg->pid_file, 0644, &pid);
+ main->pfh = rspamd_pidfile_open(main->cfg->pid_file, 0644, &pid);
if (main->pfh == NULL) {
return -1;
@@ -221,33 +220,33 @@ rspamd_write_pid (struct rspamd_main *main)
if (main->is_privileged) {
/* Force root user as owner of pid file */
#ifdef HAVE_PIDFILE_FILENO
- if (fchown (pidfile_fileno (main->pfh), 0, 0) == -1) {
+ if (fchown(pidfile_fileno(main->pfh), 0, 0) == -1) {
#else
- if (fchown (main->pfh->pf_fd, 0, 0) == -1) {
+ if (fchown(main->pfh->pf_fd, 0, 0) == -1) {
#endif
}
}
- rspamd_pidfile_write (main->pfh);
+ rspamd_pidfile_write(main->pfh);
return 0;
}
/* Detect privileged mode */
static void
-detect_priv (struct rspamd_main *rspamd_main)
+detect_priv(struct rspamd_main *rspamd_main)
{
struct passwd *pwd;
struct group *grp;
uid_t euid;
- euid = geteuid ();
+ euid = geteuid();
if (euid == 0) {
if (!rspamd_main->cfg->rspamd_user && !is_insecure) {
- msg_err_main (
+ msg_err_main(
"cannot run rspamd workers as root user, please add -u and -g options to select a proper unprivileged user or specify --insecure flag");
- exit (EXIT_FAILURE);
+ exit(EXIT_FAILURE);
}
else if (is_insecure) {
rspamd_main->is_privileged = TRUE;
@@ -256,18 +255,18 @@ detect_priv (struct rspamd_main *rspamd_main)
}
else {
rspamd_main->is_privileged = TRUE;
- pwd = getpwnam (rspamd_main->cfg->rspamd_user);
+ pwd = getpwnam(rspamd_main->cfg->rspamd_user);
if (pwd == NULL) {
- msg_err_main ("user specified does not exists (%s), aborting",
- strerror (errno));
- exit (-errno);
+ msg_err_main("user specified does not exists (%s), aborting",
+ strerror(errno));
+ exit(-errno);
}
if (rspamd_main->cfg->rspamd_group) {
- grp = getgrnam (rspamd_main->cfg->rspamd_group);
+ grp = getgrnam(rspamd_main->cfg->rspamd_group);
if (grp == NULL) {
- msg_err_main ("group specified does not exists (%s), aborting",
- strerror (errno));
- exit (-errno);
+ msg_err_main("group specified does not exists (%s), aborting",
+ strerror(errno));
+ exit(-errno);
}
rspamd_main->workers_gid = grp->gr_gid;
}
@@ -280,21 +279,21 @@ detect_priv (struct rspamd_main *rspamd_main)
}
else {
rspamd_main->is_privileged = FALSE;
- rspamd_main->workers_uid = (uid_t)-1;
- rspamd_main->workers_gid = (gid_t)-1;
+ rspamd_main->workers_uid = (uid_t) -1;
+ rspamd_main->workers_gid = (gid_t) -1;
}
}
static void
-config_logger (rspamd_mempool_t *pool, gpointer ud)
+config_logger(rspamd_mempool_t *pool, gpointer ud)
{
struct rspamd_main *rspamd_main = ud;
- rspamd_main->logger = rspamd_log_open_specific (rspamd_main->server_pool,
- rspamd_main->cfg,
- "main",
- rspamd_main->workers_uid,
- rspamd_main->workers_gid);
+ rspamd_main->logger = rspamd_log_open_specific(rspamd_main->server_pool,
+ rspamd_main->cfg,
+ "main",
+ rspamd_main->workers_uid,
+ rspamd_main->workers_gid);
if (rspamd_main->logger == NULL) {
/*
@@ -302,44 +301,44 @@ config_logger (rspamd_mempool_t *pool, gpointer ud)
* Error has been already logged (in fact,
* we might fall back to console logger here)
*/
- exit (EXIT_FAILURE);
+ exit(EXIT_FAILURE);
}
- rspamd_logger_configure_modules (rspamd_main->cfg->debug_modules);
+ rspamd_logger_configure_modules(rspamd_main->cfg->debug_modules);
}
static gboolean
-reread_config (struct rspamd_main *rspamd_main)
+reread_config(struct rspamd_main *rspamd_main)
{
struct rspamd_config *tmp_cfg, *old_cfg;
gchar *cfg_file;
- int load_opts = RSPAMD_CONFIG_INIT_VALIDATE|RSPAMD_CONFIG_INIT_SYMCACHE|
- RSPAMD_CONFIG_INIT_LIBS|RSPAMD_CONFIG_INIT_URL;
+ int load_opts = RSPAMD_CONFIG_INIT_VALIDATE | RSPAMD_CONFIG_INIT_SYMCACHE |
+ RSPAMD_CONFIG_INIT_LIBS | RSPAMD_CONFIG_INIT_URL;
- rspamd_symcache_save (rspamd_main->cfg->cache);
- tmp_cfg = rspamd_config_new (RSPAMD_CONFIG_INIT_DEFAULT);
+ rspamd_symcache_save(rspamd_main->cfg->cache);
+ tmp_cfg = rspamd_config_new(RSPAMD_CONFIG_INIT_DEFAULT);
tmp_cfg->libs_ctx = rspamd_main->cfg->libs_ctx;
- REF_RETAIN (tmp_cfg->libs_ctx);
- cfg_file = rspamd_mempool_strdup (tmp_cfg->cfg_pool,
- rspamd_main->cfg->cfg_name);
+ REF_RETAIN(tmp_cfg->libs_ctx);
+ cfg_file = rspamd_mempool_strdup(tmp_cfg->cfg_pool,
+ rspamd_main->cfg->cfg_name);
/* Save some variables */
tmp_cfg->cfg_name = cfg_file;
old_cfg = rspamd_main->cfg;
rspamd_main->cfg = tmp_cfg;
rspamd_logger_t *old_logger = rspamd_main->logger;
- if (!load_rspamd_config (rspamd_main, tmp_cfg, TRUE, load_opts, TRUE)) {
+ if (!load_rspamd_config(rspamd_main, tmp_cfg, TRUE, load_opts, TRUE)) {
rspamd_main->cfg = old_cfg;
rspamd_main->logger = old_logger;
- msg_err_main ("cannot parse new config file, revert to old one");
- REF_RELEASE (tmp_cfg);
+ msg_err_main("cannot parse new config file, revert to old one");
+ REF_RELEASE(tmp_cfg);
return FALSE;
}
else {
- rspamd_log_close (old_logger);
- msg_info_main ("replacing config");
- REF_RELEASE (old_cfg);
+ rspamd_log_close(old_logger);
+ msg_info_main("replacing config");
+ REF_RELEASE(old_cfg);
rspamd_main->cfg->rspamd_user = rspamd_user;
rspamd_main->cfg->rspamd_group = rspamd_group;
/* Here, we can do post actions with the existing config */
@@ -347,13 +346,13 @@ reread_config (struct rspamd_main *rspamd_main)
* As some rules are defined in lua, we need to process them, then init
* modules and merely afterwards to init modules
*/
- rspamd_lua_post_load_config (tmp_cfg);
- rspamd_init_filters (tmp_cfg, true, false);
+ rspamd_lua_post_load_config(tmp_cfg);
+ rspamd_init_filters(tmp_cfg, true, false);
/* Do post-load actions */
- rspamd_config_post_load (tmp_cfg,
- load_opts|RSPAMD_CONFIG_INIT_POST_LOAD_LUA|RSPAMD_CONFIG_INIT_PRELOAD_MAPS);
- msg_info_main ("config has been reread successfully");
+ rspamd_config_post_load(tmp_cfg,
+ load_opts | RSPAMD_CONFIG_INIT_POST_LOAD_LUA | RSPAMD_CONFIG_INIT_PRELOAD_MAPS);
+ msg_info_main("config has been reread successfully");
}
return TRUE;
@@ -361,45 +360,45 @@ reread_config (struct rspamd_main *rspamd_main)
struct waiting_worker {
struct rspamd_main *rspamd_main;
- struct ev_timer wait_ev;
+ struct ev_timer wait_ev;
struct rspamd_worker_conf *cf;
guint oldindex;
};
static void
-rspamd_fork_delayed_cb (EV_P_ ev_timer *w, int revents)
+rspamd_fork_delayed_cb(EV_P_ ev_timer *w, int revents)
{
- struct waiting_worker *waiting_worker = (struct waiting_worker *)w->data;
-
- ev_timer_stop (EV_A_ &waiting_worker->wait_ev);
- rspamd_fork_worker (waiting_worker->rspamd_main, waiting_worker->cf,
- waiting_worker->oldindex,
- waiting_worker->rspamd_main->event_loop,
- rspamd_cld_handler, listen_sockets);
- REF_RELEASE (waiting_worker->cf);
- g_free (waiting_worker);
+ struct waiting_worker *waiting_worker = (struct waiting_worker *) w->data;
+
+ ev_timer_stop(EV_A_ & waiting_worker->wait_ev);
+ rspamd_fork_worker(waiting_worker->rspamd_main, waiting_worker->cf,
+ waiting_worker->oldindex,
+ waiting_worker->rspamd_main->event_loop,
+ rspamd_cld_handler, listen_sockets);
+ REF_RELEASE(waiting_worker->cf);
+ g_free(waiting_worker);
}
static void
-rspamd_fork_delayed (struct rspamd_worker_conf *cf,
- guint index,
- struct rspamd_main *rspamd_main)
+rspamd_fork_delayed(struct rspamd_worker_conf *cf,
+ guint index,
+ struct rspamd_main *rspamd_main)
{
struct waiting_worker *nw;
- nw = g_malloc0 (sizeof (*nw));
+ nw = g_malloc0(sizeof(*nw));
nw->cf = cf;
nw->oldindex = index;
nw->rspamd_main = rspamd_main;
- REF_RETAIN (cf);
+ REF_RETAIN(cf);
nw->wait_ev.data = nw;
- ev_timer_init (&nw->wait_ev, rspamd_fork_delayed_cb, SOFT_FORK_TIME, 0.0);
- ev_timer_start (rspamd_main->event_loop, &nw->wait_ev);
+ ev_timer_init(&nw->wait_ev, rspamd_fork_delayed_cb, SOFT_FORK_TIME, 0.0);
+ ev_timer_start(rspamd_main->event_loop, &nw->wait_ev);
}
static GList *
-create_listen_socket (GPtrArray *addrs, guint cnt,
- enum rspamd_worker_socket_type listen_type)
+create_listen_socket(GPtrArray *addrs, guint cnt,
+ enum rspamd_worker_socket_type listen_type)
{
GList *result = NULL;
gint fd;
@@ -407,34 +406,34 @@ create_listen_socket (GPtrArray *addrs, guint cnt,
static const int listen_opts = RSPAMD_INET_ADDRESS_LISTEN_ASYNC;
struct rspamd_worker_listen_socket *ls;
- g_ptr_array_sort (addrs, rspamd_inet_address_compare_ptr);
- for (i = 0; i < cnt; i ++) {
+ g_ptr_array_sort(addrs, rspamd_inet_address_compare_ptr);
+ for (i = 0; i < cnt; i++) {
/*
* Copy address to avoid reload issues
*/
if (listen_type & RSPAMD_WORKER_SOCKET_TCP) {
- fd = rspamd_inet_address_listen (g_ptr_array_index (addrs, i),
- SOCK_STREAM,
- listen_opts, -1);
+ fd = rspamd_inet_address_listen(g_ptr_array_index(addrs, i),
+ SOCK_STREAM,
+ listen_opts, -1);
if (fd != -1) {
- ls = g_malloc0 (sizeof (*ls));
- ls->addr = rspamd_inet_address_copy(g_ptr_array_index (addrs, i), NULL);
+ ls = g_malloc0(sizeof(*ls));
+ ls->addr = rspamd_inet_address_copy(g_ptr_array_index(addrs, i), NULL);
ls->fd = fd;
ls->type = RSPAMD_WORKER_SOCKET_TCP;
- result = g_list_prepend (result, ls);
+ result = g_list_prepend(result, ls);
}
}
if (listen_type & RSPAMD_WORKER_SOCKET_UDP) {
- fd = rspamd_inet_address_listen (g_ptr_array_index (addrs, i),
- SOCK_DGRAM,
- listen_opts | RSPAMD_INET_ADDRESS_LISTEN_REUSEPORT, -1);
+ fd = rspamd_inet_address_listen(g_ptr_array_index(addrs, i),
+ SOCK_DGRAM,
+ listen_opts | RSPAMD_INET_ADDRESS_LISTEN_REUSEPORT, -1);
if (fd != -1) {
- ls = g_malloc0 (sizeof (*ls));
- ls->addr = rspamd_inet_address_copy(g_ptr_array_index (addrs, i), NULL);
+ ls = g_malloc0(sizeof(*ls));
+ ls->addr = rspamd_inet_address_copy(g_ptr_array_index(addrs, i), NULL);
ls->fd = fd;
ls->type = RSPAMD_WORKER_SOCKET_UDP;
- result = g_list_prepend (result, ls);
+ result = g_list_prepend(result, ls);
}
}
}
@@ -443,7 +442,7 @@ create_listen_socket (GPtrArray *addrs, guint cnt,
}
static GList *
-systemd_get_socket (struct rspamd_main *rspamd_main, const gchar *fdname)
+systemd_get_socket(struct rspamd_main *rspamd_main, const gchar *fdname)
{
int number, sock, num_passed, flags;
GList *result = NULL;
@@ -451,7 +450,7 @@ systemd_get_socket (struct rspamd_main *rspamd_main, const gchar *fdname)
gchar **fdnames;
gchar *end;
struct stat st;
- static const int sd_listen_fds_start = 3; /* SD_LISTEN_FDS_START */
+ static const int sd_listen_fds_start = 3; /* SD_LISTEN_FDS_START */
struct rspamd_worker_listen_socket *ls;
union {
@@ -460,74 +459,74 @@ systemd_get_socket (struct rspamd_main *rspamd_main, const gchar *fdname)
struct sockaddr_un sun;
struct sockaddr_in6 s6;
} addr_storage;
- socklen_t slen = sizeof (addr_storage);
+ socklen_t slen = sizeof(addr_storage);
gint stype;
- number = strtoul (fdname, &end, 10);
+ number = strtoul(fdname, &end, 10);
if (end != NULL && *end != '\0') {
/* Cannot parse as number, assume a name in LISTEN_FDNAMES. */
- e = getenv ("LISTEN_FDNAMES");
+ e = getenv("LISTEN_FDNAMES");
if (!e) {
- msg_err_main ("cannot get systemd variable 'LISTEN_FDNAMES'");
+ msg_err_main("cannot get systemd variable 'LISTEN_FDNAMES'");
errno = ENOENT;
return NULL;
}
- fdnames = g_strsplit (e, ":", -1);
+ fdnames = g_strsplit(e, ":", -1);
for (number = 0; fdnames[number]; number++) {
- if (!strcmp (fdnames[number], fdname)) {
+ if (!strcmp(fdnames[number], fdname)) {
break;
}
}
if (!fdnames[number]) {
number = -1;
}
- g_strfreev (fdnames);
+ g_strfreev(fdnames);
}
if (number < 0) {
- msg_warn_main ("cannot find systemd socket: %s", fdname);
+ msg_warn_main("cannot find systemd socket: %s", fdname);
errno = ENOENT;
return NULL;
}
- e = getenv ("LISTEN_FDS");
+ e = getenv("LISTEN_FDS");
if (e != NULL) {
errno = 0;
- num_passed = strtoul (e, &end, 10);
+ num_passed = strtoul(e, &end, 10);
if ((end == NULL || *end == '\0') && num_passed > number) {
sock = number + sd_listen_fds_start;
- if (fstat (sock, &st) == -1) {
- msg_warn_main ("cannot stat systemd descriptor %d", sock);
+ if (fstat(sock, &st) == -1) {
+ msg_warn_main("cannot stat systemd descriptor %d", sock);
return NULL;
}
- if (!S_ISSOCK (st.st_mode)) {
- msg_warn_main ("systemd descriptor %d is not a socket", sock);
+ if (!S_ISSOCK(st.st_mode)) {
+ msg_warn_main("systemd descriptor %d is not a socket", sock);
errno = EINVAL;
return NULL;
}
- flags = fcntl (sock, F_GETFD);
+ flags = fcntl(sock, F_GETFD);
if (flags != -1) {
- (void)fcntl (sock, F_SETFD, flags | FD_CLOEXEC);
+ (void) fcntl(sock, F_SETFD, flags | FD_CLOEXEC);
}
- rspamd_socket_nonblocking (sock);
+ rspamd_socket_nonblocking(sock);
- if (getsockname (sock, &addr_storage.sa, &slen) == -1) {
- msg_warn_main ("cannot get name for systemd descriptor %d: %s",
- sock, strerror (errno));
+ if (getsockname(sock, &addr_storage.sa, &slen) == -1) {
+ msg_warn_main("cannot get name for systemd descriptor %d: %s",
+ sock, strerror(errno));
errno = EINVAL;
return NULL;
}
- ls = g_malloc0 (sizeof (*ls));
- ls->addr = rspamd_inet_address_from_sa (&addr_storage.sa, slen);
+ ls = g_malloc0(sizeof(*ls));
+ ls->addr = rspamd_inet_address_from_sa(&addr_storage.sa, slen);
ls->fd = sock;
ls->is_systemd = true;
- slen = sizeof (stype);
- if (getsockopt (sock, SOL_SOCKET, SO_TYPE, &stype, &slen) != -1) {
+ slen = sizeof(stype);
+ if (getsockopt(sock, SOL_SOCKET, SO_TYPE, &stype, &slen) != -1) {
if (stype == SOCK_STREAM) {
ls->type = RSPAMD_WORKER_SOCKET_TCP;
}
@@ -536,22 +535,22 @@ systemd_get_socket (struct rspamd_main *rspamd_main, const gchar *fdname)
}
}
else {
- msg_warn_main ("cannot get type for systemd descriptor %d: %s",
- sock, strerror (errno));
+ msg_warn_main("cannot get type for systemd descriptor %d: %s",
+ sock, strerror(errno));
ls->type = RSPAMD_WORKER_SOCKET_TCP;
}
- result = g_list_prepend (result, ls);
+ result = g_list_prepend(result, ls);
}
else if (num_passed <= number) {
- msg_err_main ("systemd LISTEN_FDS does not contain the expected fd: %d",
- num_passed);
+ msg_err_main("systemd LISTEN_FDS does not contain the expected fd: %d",
+ num_passed);
errno = EINVAL;
}
}
else {
- msg_err_main ("cannot get systemd variable 'LISTEN_FDS'");
+ msg_err_main("cannot get systemd variable 'LISTEN_FDS'");
errno = ENOENT;
}
@@ -559,22 +558,22 @@ systemd_get_socket (struct rspamd_main *rspamd_main, const gchar *fdname)
}
static void
-pass_signal_cb (gpointer key, gpointer value, gpointer ud)
+pass_signal_cb(gpointer key, gpointer value, gpointer ud)
{
struct rspamd_worker *cur = value;
- gint signo = GPOINTER_TO_INT (ud);
+ gint signo = GPOINTER_TO_INT(ud);
- kill (cur->pid, signo);
+ kill(cur->pid, signo);
}
static void
-rspamd_pass_signal (GHashTable * workers, gint signo)
+rspamd_pass_signal(GHashTable *workers, gint signo)
{
- g_hash_table_foreach (workers, pass_signal_cb, GINT_TO_POINTER (signo));
+ g_hash_table_foreach(workers, pass_signal_cb, GINT_TO_POINTER(signo));
}
static inline uintptr_t
-make_listen_key (struct rspamd_worker_bind_conf *cf)
+make_listen_key(struct rspamd_worker_bind_conf *cf)
{
rspamd_cryptobox_fast_hash_state_t st;
guint i, keylen = 0;
@@ -582,61 +581,61 @@ make_listen_key (struct rspamd_worker_bind_conf *cf)
rspamd_inet_addr_t *addr;
guint16 port;
- rspamd_cryptobox_fast_hash_init (&st, rspamd_hash_seed ());
+ rspamd_cryptobox_fast_hash_init(&st, rspamd_hash_seed());
if (cf->is_systemd) {
/* Something like 'systemd:0' or 'systemd:controller'. */
- rspamd_cryptobox_fast_hash_update (&st, cf->name, strlen (cf->name));
+ rspamd_cryptobox_fast_hash_update(&st, cf->name, strlen(cf->name));
}
else {
- rspamd_cryptobox_fast_hash_update (&st, cf->name, strlen (cf->name));
- for (i = 0; i < cf->cnt; i ++) {
- addr = g_ptr_array_index (cf->addrs, i);
- key = rspamd_inet_address_get_hash_key (
- addr, &keylen);
- rspamd_cryptobox_fast_hash_update (&st, key, keylen);
- port = rspamd_inet_address_get_port (addr);
- rspamd_cryptobox_fast_hash_update (&st, &port, sizeof (port));
+ rspamd_cryptobox_fast_hash_update(&st, cf->name, strlen(cf->name));
+ for (i = 0; i < cf->cnt; i++) {
+ addr = g_ptr_array_index(cf->addrs, i);
+ key = rspamd_inet_address_get_hash_key(
+ addr, &keylen);
+ rspamd_cryptobox_fast_hash_update(&st, key, keylen);
+ port = rspamd_inet_address_get_port(addr);
+ rspamd_cryptobox_fast_hash_update(&st, &port, sizeof(port));
}
}
- return rspamd_cryptobox_fast_hash_final (&st);
+ return rspamd_cryptobox_fast_hash_final(&st);
}
static void
-spawn_worker_type (struct rspamd_main *rspamd_main, struct ev_loop *event_loop,
- struct rspamd_worker_conf *cf)
+spawn_worker_type(struct rspamd_main *rspamd_main, struct ev_loop *event_loop,
+ struct rspamd_worker_conf *cf)
{
gint i;
if (cf->count < 0) {
- msg_info_main ("skip spawning of worker %s: disabled in configuration",
- cf->worker->name);
+ msg_info_main("skip spawning of worker %s: disabled in configuration",
+ cf->worker->name);
return;
}
if (cf->worker->flags & RSPAMD_WORKER_UNIQUE) {
if (cf->count > 1) {
- msg_warn_main (
- "cannot spawn more than 1 %s worker, so spawn one",
- cf->worker->name);
+ msg_warn_main(
+ "cannot spawn more than 1 %s worker, so spawn one",
+ cf->worker->name);
}
- rspamd_fork_worker (rspamd_main, cf, 0, event_loop, rspamd_cld_handler,
- listen_sockets);
+ rspamd_fork_worker(rspamd_main, cf, 0, event_loop, rspamd_cld_handler,
+ listen_sockets);
}
else if (cf->worker->flags & RSPAMD_WORKER_THREADED) {
- rspamd_fork_worker (rspamd_main, cf, 0, event_loop, rspamd_cld_handler,
- listen_sockets);
+ rspamd_fork_worker(rspamd_main, cf, 0, event_loop, rspamd_cld_handler,
+ listen_sockets);
}
else {
for (i = 0; i < cf->count; i++) {
- rspamd_fork_worker (rspamd_main, cf, i, event_loop,
- rspamd_cld_handler, listen_sockets);
+ rspamd_fork_worker(rspamd_main, cf, i, event_loop,
+ rspamd_cld_handler, listen_sockets);
}
}
}
static void
-spawn_workers (struct rspamd_main *rspamd_main, struct ev_loop *ev_base)
+spawn_workers(struct rspamd_main *rspamd_main, struct ev_loop *ev_base)
{
GList *cur, *ls;
struct rspamd_worker_conf *cf;
@@ -649,7 +648,7 @@ spawn_workers (struct rspamd_main *rspamd_main, struct ev_loop *ev_base)
guint i;
/* Special hack for hs_helper if it's not defined in a config */
- seen_mandatory_workers = g_ptr_array_new ();
+ seen_mandatory_workers = g_ptr_array_new();
cur = rspamd_main->cfg->workers;
while (cur) {
@@ -657,47 +656,49 @@ spawn_workers (struct rspamd_main *rspamd_main, struct ev_loop *ev_base)
listen_ok = FALSE;
if (cf->worker == NULL) {
- msg_err_main ("type of worker is unspecified, skip spawning");
+ msg_err_main("type of worker is unspecified, skip spawning");
}
else {
if (!cf->enabled || cf->count <= 0) {
- msg_info_main ("worker of type %s(%s) is disabled in the config, "
- "skip spawning", g_quark_to_string (cf->type),
- cf->bind_conf ? cf->bind_conf->name : "none");
- cur = g_list_next (cur);
+ msg_info_main("worker of type %s(%s) is disabled in the config, "
+ "skip spawning",
+ g_quark_to_string(cf->type),
+ cf->bind_conf ? cf->bind_conf->name : "none");
+ cur = g_list_next(cur);
continue;
}
if (cf->worker->flags & RSPAMD_WORKER_ALWAYS_START) {
- g_ptr_array_add (seen_mandatory_workers, cf->worker);
+ g_ptr_array_add(seen_mandatory_workers, cf->worker);
}
if (cf->worker->flags & RSPAMD_WORKER_HAS_SOCKET) {
- LL_FOREACH (cf->bind_conf, bcf) {
- key = make_listen_key (bcf);
+ LL_FOREACH(cf->bind_conf, bcf)
+ {
+ key = make_listen_key(bcf);
if ((p =
- g_hash_table_lookup (listen_sockets,
- GINT_TO_POINTER (key))) == NULL) {
+ g_hash_table_lookup(listen_sockets,
+ GINT_TO_POINTER(key))) == NULL) {
if (!bcf->is_systemd) {
/* Create listen socket */
- ls = create_listen_socket (bcf->addrs, bcf->cnt,
- cf->worker->listen_type);
+ ls = create_listen_socket(bcf->addrs, bcf->cnt,
+ cf->worker->listen_type);
}
else {
- ls = systemd_get_socket (rspamd_main,
- g_ptr_array_index (bcf->addrs, 0));
+ ls = systemd_get_socket(rspamd_main,
+ g_ptr_array_index(bcf->addrs, 0));
}
if (ls == NULL) {
- msg_err_main ("cannot listen on %s socket %s: %s",
- bcf->is_systemd ? "systemd" : "normal",
- bcf->name,
- strerror (errno));
+ msg_err_main("cannot listen on %s socket %s: %s",
+ bcf->is_systemd ? "systemd" : "normal",
+ bcf->name,
+ strerror(errno));
}
else {
- g_hash_table_insert (listen_sockets, (gpointer)key, ls);
+ g_hash_table_insert(listen_sockets, (gpointer) key, ls);
listen_ok = TRUE;
}
}
@@ -707,68 +708,69 @@ spawn_workers (struct rspamd_main *rspamd_main, struct ev_loop *ev_base)
listen_ok = TRUE;
}
/* Do not add existing lists as it causes loops */
- if (g_list_position (cf->listen_socks, ls) == -1) {
- cf->listen_socks = g_list_concat (cf->listen_socks, ls);
+ if (g_list_position(cf->listen_socks, ls) == -1) {
+ cf->listen_socks = g_list_concat(cf->listen_socks, ls);
}
}
if (listen_ok) {
- spawn_worker_type (rspamd_main, ev_base, cf);
+ spawn_worker_type(rspamd_main, ev_base, cf);
}
else {
if (cf->bind_conf == NULL) {
- msg_err_main ("cannot create listen socket for %s",
- g_quark_to_string (cf->type));
- } else {
- msg_err_main ("cannot create listen socket for %s at %s",
- g_quark_to_string (cf->type), cf->bind_conf->name);
+ msg_err_main("cannot create listen socket for %s",
+ g_quark_to_string(cf->type));
+ }
+ else {
+ msg_err_main("cannot create listen socket for %s at %s",
+ g_quark_to_string(cf->type), cf->bind_conf->name);
}
- rspamd_hard_terminate (rspamd_main);
- g_assert_not_reached ();
+ rspamd_hard_terminate(rspamd_main);
+ g_assert_not_reached();
}
}
else {
- spawn_worker_type (rspamd_main, ev_base, cf);
+ spawn_worker_type(rspamd_main, ev_base, cf);
}
}
- cur = g_list_next (cur);
+ cur = g_list_next(cur);
}
- for (cw = workers; *cw != NULL; cw ++) {
+ for (cw = workers; *cw != NULL; cw++) {
gboolean seen = FALSE;
wrk = *cw;
if (wrk->flags & RSPAMD_WORKER_ALWAYS_START) {
- for (i = 0; i < seen_mandatory_workers->len; i ++) {
- if (wrk == g_ptr_array_index (seen_mandatory_workers, i)) {
+ for (i = 0; i < seen_mandatory_workers->len; i++) {
+ if (wrk == g_ptr_array_index(seen_mandatory_workers, i)) {
seen = TRUE;
break;
}
}
if (!seen) {
- cf = rspamd_config_new_worker (rspamd_main->cfg, NULL);
+ cf = rspamd_config_new_worker(rspamd_main->cfg, NULL);
cf->count = 1;
cf->worker = wrk;
- cf->type = g_quark_from_static_string (wrk->name);
+ cf->type = g_quark_from_static_string(wrk->name);
if (cf->worker->worker_init_func) {
- cf->ctx = cf->worker->worker_init_func (rspamd_main->cfg);
+ cf->ctx = cf->worker->worker_init_func(rspamd_main->cfg);
}
- spawn_worker_type (rspamd_main, ev_base, cf);
+ spawn_worker_type(rspamd_main, ev_base, cf);
}
}
}
- g_ptr_array_free (seen_mandatory_workers, TRUE);
+ g_ptr_array_free(seen_mandatory_workers, TRUE);
}
static void
-kill_old_workers (gpointer key, gpointer value, gpointer unused)
+kill_old_workers(gpointer key, gpointer value, gpointer unused)
{
struct rspamd_worker *w = value;
struct rspamd_main *rspamd_main;
@@ -777,18 +779,18 @@ kill_old_workers (gpointer key, gpointer value, gpointer unused)
if (w->state == rspamd_worker_state_wanna_die) {
w->state = rspamd_worker_state_terminating;
- kill (w->pid, SIGUSR2);
- ev_io_stop (rspamd_main->event_loop, &w->srv_ev);
- g_hash_table_remove_all (w->control_events_pending);
- msg_info_main ("send signal to worker %P", w->pid);
+ kill(w->pid, SIGUSR2);
+ ev_io_stop(rspamd_main->event_loop, &w->srv_ev);
+ g_hash_table_remove_all(w->control_events_pending);
+ msg_info_main("send signal to worker %P", w->pid);
}
else if (w->state != rspamd_worker_state_running) {
- msg_info_main ("do not send signal to worker %P, already sent", w->pid);
+ msg_info_main("do not send signal to worker %P, already sent", w->pid);
}
}
static void
-mark_old_workers (gpointer key, gpointer value, gpointer unused)
+mark_old_workers(gpointer key, gpointer value, gpointer unused)
{
struct rspamd_worker *w = value;
@@ -800,43 +802,43 @@ mark_old_workers (gpointer key, gpointer value, gpointer unused)
}
static void
-rspamd_worker_wait (struct rspamd_worker *w)
+rspamd_worker_wait(struct rspamd_worker *w)
{
struct rspamd_main *rspamd_main;
rspamd_main = w->srv;
if (term_attempts < 0) {
if (w->cf->worker->flags & RSPAMD_WORKER_KILLABLE) {
- if (kill (w->pid, SIGKILL) == -1) {
+ if (kill(w->pid, SIGKILL) == -1) {
if (errno == ESRCH) {
/* We have actually killed the process */
return;
}
}
else {
- msg_warn_main ("terminate worker %s(%P) with SIGKILL",
- g_quark_to_string (w->type), w->pid);
+ msg_warn_main("terminate worker %s(%P) with SIGKILL",
+ g_quark_to_string(w->type), w->pid);
}
}
else {
- kill (w->pid, SIGKILL);
+ kill(w->pid, SIGKILL);
if (errno == ESRCH) {
/* We have actually killed the process */
return;
}
else {
- msg_err_main ("data corruption warning: terminating "
- "special worker %s(%P) with SIGKILL",
- g_quark_to_string (w->type), w->pid);
+ msg_err_main("data corruption warning: terminating "
+ "special worker %s(%P) with SIGKILL",
+ g_quark_to_string(w->type), w->pid);
}
}
}
}
static void
-hash_worker_wait_callback (gpointer key, gpointer value, gpointer unused)
+hash_worker_wait_callback(gpointer key, gpointer value, gpointer unused)
{
- rspamd_worker_wait ((struct rspamd_worker *)value);
+ rspamd_worker_wait((struct rspamd_worker *) value);
}
struct core_check_cbdata {
@@ -850,11 +852,11 @@ struct core_check_cbdata {
static struct core_check_cbdata cores_cbdata;
static gint
-rspamd_check_core_cb (const gchar *path, const struct stat *st,
- gint flag, struct FTW *ft)
+rspamd_check_core_cb(const gchar *path, const struct stat *st,
+ gint flag, struct FTW *ft)
{
- if (S_ISREG (st->st_mode)) {
- cores_cbdata.total_count ++;
+ if (S_ISREG(st->st_mode)) {
+ cores_cbdata.total_count++;
/* Use physical size instead of displayed one */
cores_cbdata.total_size += st->st_blocks * 512;
}
@@ -865,7 +867,7 @@ rspamd_check_core_cb (const gchar *path, const struct stat *st,
#endif
static void
-rspamd_check_core_limits (struct rspamd_main *rspamd_main)
+rspamd_check_core_limits(struct rspamd_main *rspamd_main)
{
#ifdef HAVE_NFTW
struct rspamd_config *cfg = rspamd_main->cfg;
@@ -875,53 +877,52 @@ rspamd_check_core_limits (struct rspamd_main *rspamd_main)
cores_cbdata.total_size = 0;
if (cfg->cores_dir && (cfg->max_cores_count || cfg->max_cores_size)) {
- if (nftw (cfg->cores_dir, rspamd_check_core_cb, 1, FTW_MOUNT|FTW_PHYS)
- == -1) {
- msg_err_main ("nftw failed for path %s: %s", cfg->cores_dir,
- strerror (errno));
+ if (nftw(cfg->cores_dir, rspamd_check_core_cb, 1, FTW_MOUNT | FTW_PHYS) == -1) {
+ msg_err_main("nftw failed for path %s: %s", cfg->cores_dir,
+ strerror(errno));
}
else {
if (!rspamd_main->cores_throttling) {
if (cfg->max_cores_size &&
- cores_cbdata.total_size > cfg->max_cores_size) {
- msg_warn_main (
- "enable cores throttling as size of cores in"
- " %s is %Hz, limit is %Hz",
- cfg->cores_dir,
- cores_cbdata.total_size,
- cfg->max_cores_size);
+ cores_cbdata.total_size > cfg->max_cores_size) {
+ msg_warn_main(
+ "enable cores throttling as size of cores in"
+ " %s is %Hz, limit is %Hz",
+ cfg->cores_dir,
+ cores_cbdata.total_size,
+ cfg->max_cores_size);
rspamd_main->cores_throttling = TRUE;
}
if (cfg->max_cores_count &&
- cores_cbdata.total_count > cfg->max_cores_count) {
- msg_warn_main (
- "enable cores throttling as count of cores in"
- " %s is %z, limit is %z",
- cfg->cores_dir,
- cores_cbdata.total_count,
- cfg->max_cores_count);
+ cores_cbdata.total_count > cfg->max_cores_count) {
+ msg_warn_main(
+ "enable cores throttling as count of cores in"
+ " %s is %z, limit is %z",
+ cfg->cores_dir,
+ cores_cbdata.total_count,
+ cfg->max_cores_count);
rspamd_main->cores_throttling = TRUE;
}
}
else {
if (cfg->max_cores_size &&
- cores_cbdata.total_size < cfg->max_cores_size) {
- msg_info_main (
- "disable cores throttling as size of cores in"
- " %s is now %Hz, limit is %Hz",
- cfg->cores_dir,
- cores_cbdata.total_size,
- cfg->max_cores_size);
+ cores_cbdata.total_size < cfg->max_cores_size) {
+ msg_info_main(
+ "disable cores throttling as size of cores in"
+ " %s is now %Hz, limit is %Hz",
+ cfg->cores_dir,
+ cores_cbdata.total_size,
+ cfg->max_cores_size);
rspamd_main->cores_throttling = FALSE;
}
if (cfg->max_cores_count &&
- cores_cbdata.total_count < cfg->max_cores_count) {
- msg_info_main (
- "disable cores throttling as count of cores in"
- " %s is %z, limit is %z",
- cfg->cores_dir,
- cores_cbdata.total_count,
- cfg->max_cores_count);
+ cores_cbdata.total_count < cfg->max_cores_count) {
+ msg_info_main(
+ "disable cores throttling as count of cores in"
+ " %s is %z, limit is %z",
+ cfg->cores_dir,
+ cores_cbdata.total_count,
+ cfg->max_cores_count);
rspamd_main->cores_throttling = FALSE;
}
}
@@ -931,41 +932,41 @@ rspamd_check_core_limits (struct rspamd_main *rspamd_main)
}
static void
-reopen_log_handler (gpointer key, gpointer value, gpointer unused)
+reopen_log_handler(gpointer key, gpointer value, gpointer unused)
{
struct rspamd_worker *w = value;
struct rspamd_main *rspamd_main;
rspamd_main = w->srv;
- if (kill (w->pid, SIGUSR1) == -1) {
- msg_err_main ("kill failed for pid %P: %s", w->pid, strerror (errno));
+ if (kill(w->pid, SIGUSR1) == -1) {
+ msg_err_main("kill failed for pid %P: %s", w->pid, strerror(errno));
}
}
static gboolean
-load_rspamd_config (struct rspamd_main *rspamd_main,
- struct rspamd_config *cfg, gboolean init_modules,
- enum rspamd_post_load_options opts,
- gboolean reload)
+load_rspamd_config(struct rspamd_main *rspamd_main,
+ struct rspamd_config *cfg, gboolean init_modules,
+ enum rspamd_post_load_options opts,
+ gboolean reload)
{
cfg->compiled_modules = modules;
cfg->compiled_workers = workers;
- if (!rspamd_config_read (cfg, cfg->cfg_name, config_logger, rspamd_main,
- ucl_vars, skip_template, lua_env)) {
+ if (!rspamd_config_read(cfg, cfg->cfg_name, config_logger, rspamd_main,
+ ucl_vars, skip_template, lua_env)) {
return FALSE;
}
/* Strictly set temp dir */
if (!cfg->temp_dir) {
- msg_warn_main ("tempdir is not set, trying to use $TMPDIR");
+ msg_warn_main("tempdir is not set, trying to use $TMPDIR");
cfg->temp_dir =
- rspamd_mempool_strdup (cfg->cfg_pool, getenv ("TMPDIR"));
+ rspamd_mempool_strdup(cfg->cfg_pool, getenv("TMPDIR"));
if (!cfg->temp_dir) {
- msg_warn_main ("$TMPDIR is empty too, using /tmp as default");
- cfg->temp_dir = rspamd_mempool_strdup (cfg->cfg_pool, "/tmp");
+ msg_warn_main("$TMPDIR is empty too, using /tmp as default");
+ cfg->temp_dir = rspamd_mempool_strdup(cfg->cfg_pool, "/tmp");
}
}
@@ -974,16 +975,16 @@ load_rspamd_config (struct rspamd_main *rspamd_main,
* As some rules are defined in lua, we need to process them, then init
* modules and merely afterwards to init modules
*/
- rspamd_lua_post_load_config (cfg);
+ rspamd_lua_post_load_config(cfg);
if (init_modules) {
- if (!rspamd_init_filters (cfg, reload, false)) {
+ if (!rspamd_init_filters(cfg, reload, false)) {
return FALSE;
}
}
/* Do post-load actions */
- if (!rspamd_config_post_load (cfg, opts)) {
+ if (!rspamd_config_post_load(cfg, opts)) {
return FALSE;
}
}
@@ -992,74 +993,74 @@ load_rspamd_config (struct rspamd_main *rspamd_main,
}
static void
-rspamd_detach_worker (struct rspamd_main *rspamd_main, struct rspamd_worker *wrk)
+rspamd_detach_worker(struct rspamd_main *rspamd_main, struct rspamd_worker *wrk)
{
- ev_io_stop (rspamd_main->event_loop, &wrk->srv_ev);
- ev_timer_stop (rspamd_main->event_loop, &wrk->hb.heartbeat_ev);
+ ev_io_stop(rspamd_main->event_loop, &wrk->srv_ev);
+ ev_timer_stop(rspamd_main->event_loop, &wrk->hb.heartbeat_ev);
}
static void
-rspamd_attach_worker (struct rspamd_main *rspamd_main, struct rspamd_worker *wrk)
+rspamd_attach_worker(struct rspamd_main *rspamd_main, struct rspamd_worker *wrk)
{
- ev_io_start (rspamd_main->event_loop, &wrk->srv_ev);
- ev_timer_start (rspamd_main->event_loop, &wrk->hb.heartbeat_ev);
+ ev_io_start(rspamd_main->event_loop, &wrk->srv_ev);
+ ev_timer_start(rspamd_main->event_loop, &wrk->hb.heartbeat_ev);
}
static void
-stop_srv_ev (gpointer key, gpointer value, gpointer ud)
+stop_srv_ev(gpointer key, gpointer value, gpointer ud)
{
- struct rspamd_worker *cur = (struct rspamd_worker *)value;
- struct rspamd_main *rspamd_main = (struct rspamd_main *)ud;
+ struct rspamd_worker *cur = (struct rspamd_worker *) value;
+ struct rspamd_main *rspamd_main = (struct rspamd_main *) ud;
- rspamd_detach_worker (rspamd_main, cur);
+ rspamd_detach_worker(rspamd_main, cur);
}
static void
-start_srv_ev (gpointer key, gpointer value, gpointer ud)
+start_srv_ev(gpointer key, gpointer value, gpointer ud)
{
- struct rspamd_worker *cur = (struct rspamd_worker *)value;
- struct rspamd_main *rspamd_main = (struct rspamd_main *)ud;
+ struct rspamd_worker *cur = (struct rspamd_worker *) value;
+ struct rspamd_main *rspamd_main = (struct rspamd_main *) ud;
- rspamd_attach_worker (rspamd_main, cur);
+ rspamd_attach_worker(rspamd_main, cur);
}
static void
-rspamd_final_timer_handler (EV_P_ ev_timer *w, int revents)
+rspamd_final_timer_handler(EV_P_ ev_timer *w, int revents)
{
- struct rspamd_main *rspamd_main = (struct rspamd_main *)w->data;
+ struct rspamd_main *rspamd_main = (struct rspamd_main *) w->data;
term_attempts--;
- g_hash_table_foreach (rspamd_main->workers, hash_worker_wait_callback,
- NULL);
+ g_hash_table_foreach(rspamd_main->workers, hash_worker_wait_callback,
+ NULL);
- if (g_hash_table_size (rspamd_main->workers) == 0) {
- ev_break (rspamd_main->event_loop, EVBREAK_ALL);
+ if (g_hash_table_size(rspamd_main->workers) == 0) {
+ ev_break(rspamd_main->event_loop, EVBREAK_ALL);
}
}
/* Signal handlers */
static void
-rspamd_term_handler (struct ev_loop *loop, ev_signal *w, int revents)
+rspamd_term_handler(struct ev_loop *loop, ev_signal *w, int revents)
{
- struct rspamd_main *rspamd_main = (struct rspamd_main *)w->data;
+ struct rspamd_main *rspamd_main = (struct rspamd_main *) w->data;
static ev_timer ev_finale;
ev_tstamp shutdown_ts;
if (!rspamd_main->wanna_die) {
rspamd_main->wanna_die = TRUE;
- shutdown_ts = MAX (SOFT_SHUTDOWN_TIME,
- rspamd_main->cfg->task_timeout * 2.0);
- msg_info_main ("catch termination signal, waiting for %d children for %.2f seconds",
- (gint)g_hash_table_size (rspamd_main->workers),
- valgrind_mode ? shutdown_ts * 10 : shutdown_ts);
+ shutdown_ts = MAX(SOFT_SHUTDOWN_TIME,
+ rspamd_main->cfg->task_timeout * 2.0);
+ msg_info_main("catch termination signal, waiting for %d children for %.2f seconds",
+ (gint) g_hash_table_size(rspamd_main->workers),
+ valgrind_mode ? shutdown_ts * 10 : shutdown_ts);
/* Stop srv events to avoid false notifications */
- g_hash_table_foreach (rspamd_main->workers, stop_srv_ev, rspamd_main);
- rspamd_pass_signal (rspamd_main->workers, SIGTERM);
+ g_hash_table_foreach(rspamd_main->workers, stop_srv_ev, rspamd_main);
+ rspamd_pass_signal(rspamd_main->workers, SIGTERM);
if (control_fd != -1) {
- ev_io_stop (rspamd_main->event_loop, &control_ev);
- close (control_fd);
+ ev_io_stop(rspamd_main->event_loop, &control_ev);
+ close(control_fd);
}
if (valgrind_mode) {
@@ -1071,92 +1072,91 @@ rspamd_term_handler (struct ev_loop *loop, ev_signal *w, int revents)
}
ev_finale.data = rspamd_main;
- ev_timer_init (&ev_finale, rspamd_final_timer_handler,
- TERMINATION_INTERVAL, TERMINATION_INTERVAL);
- ev_timer_start (rspamd_main->event_loop, &ev_finale);
+ ev_timer_init(&ev_finale, rspamd_final_timer_handler,
+ TERMINATION_INTERVAL, TERMINATION_INTERVAL);
+ ev_timer_start(rspamd_main->event_loop, &ev_finale);
}
}
static void
-rspamd_usr1_handler (struct ev_loop *loop, ev_signal *w, int revents)
+rspamd_usr1_handler(struct ev_loop *loop, ev_signal *w, int revents)
{
- struct rspamd_main *rspamd_main = (struct rspamd_main *)w->data;
+ struct rspamd_main *rspamd_main = (struct rspamd_main *) w->data;
if (!rspamd_main->wanna_die) {
- rspamd_log_reopen (rspamd_main->logger,
- rspamd_main->cfg,
- rspamd_main->workers_uid,
- rspamd_main->workers_gid);
- msg_info_main ("logging reinitialised");
- g_hash_table_foreach (rspamd_main->workers, reopen_log_handler,
- NULL);
+ rspamd_log_reopen(rspamd_main->logger,
+ rspamd_main->cfg,
+ rspamd_main->workers_uid,
+ rspamd_main->workers_gid);
+ msg_info_main("logging reinitialised");
+ g_hash_table_foreach(rspamd_main->workers, reopen_log_handler,
+ NULL);
}
}
static void
-rspamd_stat_update_handler (struct ev_loop *loop, ev_timer *w, int revents)
+rspamd_stat_update_handler(struct ev_loop *loop, ev_timer *w, int revents)
{
- struct rspamd_main *rspamd_main = (struct rspamd_main *)w->data;
+ struct rspamd_main *rspamd_main = (struct rspamd_main *) w->data;
struct rspamd_stat cur_stat;
gchar proctitle[128];
- memcpy (&cur_stat, rspamd_main->stat, sizeof (cur_stat));
+ memcpy(&cur_stat, rspamd_main->stat, sizeof(cur_stat));
if (old_stat.messages_scanned > 0 &&
cur_stat.messages_scanned > old_stat.messages_scanned) {
- gdouble rate = (double)(cur_stat.messages_scanned - old_stat.messages_scanned) /
- w->repeat;
+ gdouble rate = (double) (cur_stat.messages_scanned - old_stat.messages_scanned) /
+ w->repeat;
gdouble old_spam = old_stat.actions_stat[METRIC_ACTION_REJECT] +
- old_stat.actions_stat[METRIC_ACTION_ADD_HEADER] +
- old_stat.actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
+ old_stat.actions_stat[METRIC_ACTION_ADD_HEADER] +
+ old_stat.actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
gdouble old_ham = old_stat.actions_stat[METRIC_ACTION_NOACTION];
gdouble new_spam = cur_stat.actions_stat[METRIC_ACTION_REJECT] +
- cur_stat.actions_stat[METRIC_ACTION_ADD_HEADER] +
- cur_stat.actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
+ cur_stat.actions_stat[METRIC_ACTION_ADD_HEADER] +
+ cur_stat.actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
gdouble new_ham = cur_stat.actions_stat[METRIC_ACTION_NOACTION];
gsize cnt = MAX_AVG_TIME_SLOTS;
- float sum = rspamd_sum_floats (cur_stat.avg_time.avg_time, &cnt);
+ float sum = rspamd_sum_floats(cur_stat.avg_time.avg_time, &cnt);
- rspamd_snprintf (proctitle, sizeof (proctitle),
- "main process; %.1f msg/sec, %.1f msg/sec spam, %.1f msg/sec ham; %.2fs avg processing time",
- rate,
- (new_spam - old_spam) / w->repeat,
- (new_ham - old_ham) / w->repeat,
- cnt > 0 ? sum / cnt : 0);
- setproctitle ("%s", proctitle);
+ rspamd_snprintf(proctitle, sizeof(proctitle),
+ "main process; %.1f msg/sec, %.1f msg/sec spam, %.1f msg/sec ham; %.2fs avg processing time",
+ rate,
+ (new_spam - old_spam) / w->repeat,
+ (new_ham - old_ham) / w->repeat,
+ cnt > 0 ? sum / cnt : 0);
+ setproctitle("%s", proctitle);
}
- memcpy (&old_stat, &cur_stat, sizeof (cur_stat));
+ memcpy(&old_stat, &cur_stat, sizeof(cur_stat));
}
static void
-rspamd_hup_handler (struct ev_loop *loop, ev_signal *w, int revents)
+rspamd_hup_handler(struct ev_loop *loop, ev_signal *w, int revents)
{
- struct rspamd_main *rspamd_main = (struct rspamd_main *)w->data;
+ struct rspamd_main *rspamd_main = (struct rspamd_main *) w->data;
if (!rspamd_main->wanna_die) {
- msg_info_main ("rspamd "
- RVERSION
- " is requested to reload configuration");
+ msg_info_main("rspamd " RVERSION
+ " is requested to reload configuration");
/* Detach existing workers and stop their heartbeats */
- g_hash_table_foreach (rspamd_main->workers, stop_srv_ev, rspamd_main);
+ g_hash_table_foreach(rspamd_main->workers, stop_srv_ev, rspamd_main);
- if (reread_config (rspamd_main)) {
- rspamd_check_core_limits (rspamd_main);
+ if (reread_config(rspamd_main)) {
+ rspamd_check_core_limits(rspamd_main);
/* Mark old workers */
- g_hash_table_foreach (rspamd_main->workers, mark_old_workers, NULL);
- msg_info_main ("spawn workers with a new config");
- spawn_workers (rspamd_main, rspamd_main->event_loop);
- msg_info_main ("workers spawning has been finished");
+ g_hash_table_foreach(rspamd_main->workers, mark_old_workers, NULL);
+ msg_info_main("spawn workers with a new config");
+ spawn_workers(rspamd_main, rspamd_main->event_loop);
+ msg_info_main("workers spawning has been finished");
/* Kill marked */
- msg_info_main ("kill old workers");
- g_hash_table_foreach (rspamd_main->workers, kill_old_workers, NULL);
+ msg_info_main("kill old workers");
+ g_hash_table_foreach(rspamd_main->workers, kill_old_workers, NULL);
}
else {
/* Reattach old workers */
- msg_info_main ("restore old workers with a old config");
- g_hash_table_foreach (rspamd_main->workers, start_srv_ev, rspamd_main);
+ msg_info_main("restore old workers with a old config");
+ g_hash_table_foreach(rspamd_main->workers, start_srv_ev, rspamd_main);
}
}
}
@@ -1164,32 +1164,32 @@ rspamd_hup_handler (struct ev_loop *loop, ev_signal *w, int revents)
/* Called when a dead child has been found */
static void
-rspamd_cld_handler (EV_P_ ev_child *w, struct rspamd_main *rspamd_main,
- struct rspamd_worker *wrk)
+rspamd_cld_handler(EV_P_ ev_child *w, struct rspamd_main *rspamd_main,
+ struct rspamd_worker *wrk)
{
gboolean need_refork;
static struct rspamd_control_command cmd;
/* Turn off locking for logger */
- ev_child_stop (EV_A_ w);
+ ev_child_stop(EV_A_ w);
/* Remove dead child form children list */
- g_hash_table_remove (rspamd_main->workers, GSIZE_TO_POINTER (wrk->pid));
- g_hash_table_remove_all (wrk->control_events_pending);
+ g_hash_table_remove(rspamd_main->workers, GSIZE_TO_POINTER(wrk->pid));
+ g_hash_table_remove_all(wrk->control_events_pending);
if (wrk->srv_pipe[0] != -1) {
/* Ugly workaround */
if (wrk->tmp_data) {
- g_free (wrk->tmp_data);
+ g_free(wrk->tmp_data);
}
- rspamd_detach_worker (rspamd_main, wrk);
+ rspamd_detach_worker(rspamd_main, wrk);
}
if (wrk->control_pipe[0] != -1) {
/* We also need to clean descriptors left */
- close (wrk->control_pipe[0]);
- close (wrk->srv_pipe[0]);
+ close(wrk->control_pipe[0]);
+ close(wrk->srv_pipe[0]);
}
if (!rspamd_main->wanna_die) {
@@ -1197,154 +1197,155 @@ rspamd_cld_handler (EV_P_ ev_child *w, struct rspamd_main *rspamd_main,
cmd.cmd.child_change.what = rspamd_child_terminated;
cmd.cmd.child_change.pid = wrk->pid;
cmd.cmd.child_change.additional = w->rstatus;
- rspamd_control_broadcast_srv_cmd (rspamd_main, &cmd, wrk->pid);
+ rspamd_control_broadcast_srv_cmd(rspamd_main, &cmd, wrk->pid);
}
- need_refork = rspamd_check_termination_clause (wrk->srv, wrk, w->rstatus);
+ need_refork = rspamd_check_termination_clause(wrk->srv, wrk, w->rstatus);
if (need_refork) {
/* Fork another worker in replace of dead one */
- msg_info_main ("respawn process %s in lieu of terminated process with pid %P",
- g_quark_to_string (wrk->type),
- wrk->pid);
- rspamd_check_core_limits (rspamd_main);
- rspamd_fork_delayed (wrk->cf, wrk->index, rspamd_main);
+ msg_info_main("respawn process %s in lieu of terminated process with pid %P",
+ g_quark_to_string(wrk->type),
+ wrk->pid);
+ rspamd_check_core_limits(rspamd_main);
+ rspamd_fork_delayed(wrk->cf, wrk->index, rspamd_main);
}
else {
- msg_info_main ("do not respawn process %s after found terminated process with pid %P",
- g_quark_to_string (wrk->type),
- wrk->pid);
+ msg_info_main("do not respawn process %s after found terminated process with pid %P",
+ g_quark_to_string(wrk->type),
+ wrk->pid);
}
- REF_RELEASE (wrk->cf);
- g_hash_table_unref (wrk->control_events_pending);
- g_free (wrk);
+ REF_RELEASE(wrk->cf);
+ g_hash_table_unref(wrk->control_events_pending);
+ g_free(wrk);
}
/* Control socket handler */
static void
-rspamd_control_handler (EV_P_ ev_io *w, int revents)
+rspamd_control_handler(EV_P_ ev_io *w, int revents)
{
- struct rspamd_main *rspamd_main = (struct rspamd_main *)w->data;
+ struct rspamd_main *rspamd_main = (struct rspamd_main *) w->data;
rspamd_inet_addr_t *addr = NULL;
gint nfd;
if ((nfd =
- rspamd_accept_from_socket (w->fd, &addr, NULL, NULL)) == -1) {
- msg_warn_main ("accept failed: %s", strerror (errno));
+ rspamd_accept_from_socket(w->fd, &addr, NULL, NULL)) == -1) {
+ msg_warn_main("accept failed: %s", strerror(errno));
return;
}
/* Check for EAGAIN */
if (nfd == 0) {
- rspamd_inet_address_free (addr);
+ rspamd_inet_address_free(addr);
return;
}
- msg_info_main ("accepted control connection from %s",
- rspamd_inet_address_to_string (addr));
+ msg_info_main("accepted control connection from %s",
+ rspamd_inet_address_to_string(addr));
- rspamd_control_process_client_socket (rspamd_main, nfd, addr);
+ rspamd_control_process_client_socket(rspamd_main, nfd, addr);
}
static guint
-rspamd_spair_hash (gconstpointer p)
+rspamd_spair_hash(gconstpointer p)
{
- return rspamd_cryptobox_fast_hash (p, PAIR_ID_LEN, rspamd_hash_seed ());
+ return rspamd_cryptobox_fast_hash(p, PAIR_ID_LEN, rspamd_hash_seed());
}
static gboolean
-rspamd_spair_equal (gconstpointer a, gconstpointer b)
+rspamd_spair_equal(gconstpointer a, gconstpointer b)
{
- return memcmp (a, b, PAIR_ID_LEN) == 0;
+ return memcmp(a, b, PAIR_ID_LEN) == 0;
}
static void
-rspamd_spair_close (gpointer p)
+rspamd_spair_close(gpointer p)
{
gint *fds = p;
- close (fds[0]);
- close (fds[1]);
- g_free (p);
+ close(fds[0]);
+ close(fds[1]);
+ g_free(p);
}
-const char*
-get_cpu_architecture(void) {
+const char *
+get_cpu_architecture(void)
+{
#if defined(__x86_64__) || defined(_M_X64)
return "x86_64";
#elif defined(__i386) || defined(_M_IX86)
return "x86";
#elif defined(__aarch64__)
- return "ARM64";
+ return "ARM64";
#elif defined(__arm__) || defined(_M_ARM)
- return "ARM";
+ return "ARM";
#elif defined(__mips__)
- return "MIPS";
+ return "MIPS";
#elif defined(__powerpc__) || defined(_M_PPC)
- return "PowerPC";
+ return "PowerPC";
#elif defined(__sparc__)
- return "SPARC";
+ return "SPARC";
#else
- return "Unknown";
+ return "Unknown";
#endif
}
static void
-version (struct rspamd_main *rspamd_main)
+version(struct rspamd_main *rspamd_main)
{
#if defined(GIT_VERSION) && GIT_VERSION == 1
- rspamd_printf ("Rspamd daemon version " RVERSION "-git." RID "\n\n");
+ rspamd_printf("Rspamd daemon version " RVERSION "-git." RID "\n\n");
#else
- rspamd_printf ("Rspamd daemon version " RVERSION "\n\n");
+ rspamd_printf("Rspamd daemon version " RVERSION "\n\n");
#endif
rspamd_printf("CPU architecture %s; features: %s\n",
- get_cpu_architecture(),
- rspamd_main->cfg->libs_ctx->crypto_ctx->cpu_extensions);
+ get_cpu_architecture(),
+ rspamd_main->cfg->libs_ctx->crypto_ctx->cpu_extensions);
#ifdef WITH_HYPERSCAN
- rspamd_printf ("Hyperscan enabled: TRUE\n");
+ rspamd_printf("Hyperscan enabled: TRUE\n");
#else
- rspamd_printf ("Hyperscan enabled: FALSE\n");
+ rspamd_printf("Hyperscan enabled: FALSE\n");
#endif
#ifdef WITH_JEMALLOC
- rspamd_printf ("Jemalloc enabled: TRUE\n");
+ rspamd_printf("Jemalloc enabled: TRUE\n");
#else
- rspamd_printf ("Jemalloc enabled: FALSE\n");
+ rspamd_printf("Jemalloc enabled: FALSE\n");
#endif
#ifdef WITH_LUAJIT
- rspamd_printf ("LuaJIT enabled: TRUE (LuaJIT version: %s)\n", LUAJIT_VERSION);
+ rspamd_printf("LuaJIT enabled: TRUE (LuaJIT version: %s)\n", LUAJIT_VERSION);
#else
- rspamd_printf ("LuaJIT enabled: FALSE (Lua version: %s)\n", LUA_VERSION);
+ rspamd_printf("LuaJIT enabled: FALSE (Lua version: %s)\n", LUA_VERSION);
#endif
#ifndef __has_feature
-# define __has_feature(x) 0
+#define __has_feature(x) 0
#endif
#if (defined(__has_feature) && __has_feature(address_sanitizer)) || defined(ADDRESS_SANITIZER)
- rspamd_printf ("ASAN enabled: TRUE\n");
+ rspamd_printf("ASAN enabled: TRUE\n");
#else
- rspamd_printf ("ASAN enabled: FALSE\n");
+ rspamd_printf("ASAN enabled: FALSE\n");
#endif
#ifdef HAVE_CBLAS
- rspamd_printf ("BLAS enabled: TRUE\n");
+ rspamd_printf("BLAS enabled: TRUE\n");
#else
- rspamd_printf ("BLAS enabled: FALSE\n");
+ rspamd_printf("BLAS enabled: FALSE\n");
#endif
#ifdef WITH_FASTTEXT
- rspamd_printf ("Fasttext enabled: TRUE\n");
+ rspamd_printf("Fasttext enabled: TRUE\n");
#else
- rspamd_printf ("Fasttext enabled: FALSE\n");
+ rspamd_printf("Fasttext enabled: FALSE\n");
#endif
}
static gboolean
-rspamd_main_daemon (struct rspamd_main *rspamd_main)
+rspamd_main_daemon(struct rspamd_main *rspamd_main)
{
int fd;
- pid_t old_pid = getpid ();
+ pid_t old_pid = getpid();
- switch (fork ()) {
+ switch (fork()) {
case -1:
- msg_err_main ("fork() failed: %s", strerror (errno));
+ msg_err_main("fork() failed: %s", strerror(errno));
return FALSE;
case 0:
@@ -1352,52 +1353,51 @@ rspamd_main_daemon (struct rspamd_main *rspamd_main)
default:
/* Old process */
- exit (0);
+ exit(0);
}
- rspamd_log_on_fork (g_quark_from_static_string ("main"),
- rspamd_main->cfg,
- rspamd_main->logger);
+ rspamd_log_on_fork(g_quark_from_static_string("main"),
+ rspamd_main->cfg,
+ rspamd_main->logger);
- if (setsid () == -1) {
- msg_err_main ("setsid () failed: %s", strerror (errno));
+ if (setsid() == -1) {
+ msg_err_main("setsid () failed: %s", strerror(errno));
return FALSE;
}
- umask (0);
+ umask(0);
- fd = open ("/dev/null", O_RDWR);
+ fd = open("/dev/null", O_RDWR);
if (fd == -1) {
- msg_err_main ("open(\"/dev/null\") failed: %s", strerror (errno));
+ msg_err_main("open(\"/dev/null\") failed: %s", strerror(errno));
return FALSE;
}
- if (dup2 (fd, STDIN_FILENO) == -1) {
- msg_err_main ("dup2(STDIN) failed: %s", strerror (errno));
+ if (dup2(fd, STDIN_FILENO) == -1) {
+ msg_err_main("dup2(STDIN) failed: %s", strerror(errno));
return FALSE;
}
- if (dup2 (fd, STDOUT_FILENO) == -1) {
- msg_err_main ("dup2(STDOUT) failed: %s", strerror (errno));
+ if (dup2(fd, STDOUT_FILENO) == -1) {
+ msg_err_main("dup2(STDOUT) failed: %s", strerror(errno));
return FALSE;
}
if (fd > STDERR_FILENO) {
if (close(fd) == -1) {
- msg_err_main ("close() failed: %s", strerror (errno));
+ msg_err_main("close() failed: %s", strerror(errno));
return FALSE;
}
}
- msg_info_main ("daemonized successfully; old pid %P, new pid %P; pid file: %s",
- old_pid, getpid (),
- rspamd_main->cfg->pid_file);
+ msg_info_main("daemonized successfully; old pid %P, new pid %P; pid file: %s",
+ old_pid, getpid(),
+ rspamd_main->cfg->pid_file);
return TRUE;
}
-gint
-main (gint argc, gchar **argv, gchar **env)
+gint main(gint argc, gchar **argv, gchar **env)
{
gint i, res = 0;
struct sigaction signals, sigpipe_act;
@@ -1410,65 +1410,65 @@ main (gint argc, gchar **argv, gchar **env)
sigset_t control_signals;
/* Block special signals on loading */
- sigemptyset (&control_signals);
- sigaddset (&control_signals, SIGHUP);
- sigaddset (&control_signals, SIGUSR1);
- sigaddset (&control_signals, SIGUSR2);
- sigprocmask (SIG_BLOCK, &control_signals, NULL);
-
- rspamd_main = (struct rspamd_main *) g_malloc0 (sizeof (struct rspamd_main));
-
- rspamd_main->server_pool = rspamd_mempool_new (rspamd_mempool_suggest_size (),
- "main", 0);
- rspamd_main->stat = rspamd_mempool_alloc0_shared_ (rspamd_main->server_pool,
- sizeof (struct rspamd_stat),
- RSPAMD_ALIGNOF(struct rspamd_stat),
- G_STRLOC);
+ sigemptyset(&control_signals);
+ sigaddset(&control_signals, SIGHUP);
+ sigaddset(&control_signals, SIGUSR1);
+ sigaddset(&control_signals, SIGUSR2);
+ sigprocmask(SIG_BLOCK, &control_signals, NULL);
+
+ rspamd_main = (struct rspamd_main *) g_malloc0(sizeof(struct rspamd_main));
+
+ rspamd_main->server_pool = rspamd_mempool_new(rspamd_mempool_suggest_size(),
+ "main", 0);
+ rspamd_main->stat = rspamd_mempool_alloc0_shared_(rspamd_main->server_pool,
+ sizeof(struct rspamd_stat),
+ RSPAMD_ALIGNOF(struct rspamd_stat),
+ G_STRLOC);
/* Set all time slots to nan */
- for (i = 0; i < MAX_AVG_TIME_SLOTS; i ++) {
+ for (i = 0; i < MAX_AVG_TIME_SLOTS; i++) {
rspamd_main->stat->avg_time.avg_time[i] = NAN;
}
- rspamd_main->cfg = rspamd_config_new (RSPAMD_CONFIG_INIT_DEFAULT);
- rspamd_main->spairs = g_hash_table_new_full (rspamd_spair_hash,
- rspamd_spair_equal, g_free, rspamd_spair_close);
- rspamd_main->start_mtx = rspamd_mempool_get_mutex (rspamd_main->server_pool);
+ rspamd_main->cfg = rspamd_config_new(RSPAMD_CONFIG_INIT_DEFAULT);
+ rspamd_main->spairs = g_hash_table_new_full(rspamd_spair_hash,
+ rspamd_spair_equal, g_free, rspamd_spair_close);
+ rspamd_main->start_mtx = rspamd_mempool_get_mutex(rspamd_main->server_pool);
- if (getenv ("VALGRIND") != NULL) {
+ if (getenv("VALGRIND") != NULL) {
valgrind_mode = TRUE;
}
#ifndef HAVE_SETPROCTITLE
- init_title (rspamd_main->server_pool, argc, argv, env);
+ init_title(rspamd_main->server_pool, argc, argv, env);
#endif
- rspamd_main->cfg->libs_ctx = rspamd_init_libs ();
- memset (&signals, 0, sizeof (struct sigaction));
+ rspamd_main->cfg->libs_ctx = rspamd_init_libs();
+ memset(&signals, 0, sizeof(struct sigaction));
- read_cmd_line (&argc, &argv, rspamd_main->cfg);
+ read_cmd_line(&argc, &argv, rspamd_main->cfg);
if (show_version) {
- version (rspamd_main);
- exit (EXIT_SUCCESS);
+ version(rspamd_main);
+ exit(EXIT_SUCCESS);
}
if (argc > 0) {
/* Parse variables */
for (i = 0; i < argc; i++) {
- if (strchr (argv[i], '=') != NULL) {
+ if (strchr(argv[i], '=') != NULL) {
gchar *k, *v, *t;
- k = g_strdup (argv[i]);
- t = strchr (k, '=');
- v = g_strdup (t + 1);
+ k = g_strdup(argv[i]);
+ t = strchr(k, '=');
+ v = g_strdup(t + 1);
*t = '\0';
if (ucl_vars == NULL) {
- ucl_vars = g_hash_table_new_full (rspamd_strcase_hash,
- rspamd_strcase_equal, g_free, g_free);
+ ucl_vars = g_hash_table_new_full(rspamd_strcase_hash,
+ rspamd_strcase_equal, g_free, g_free);
}
- g_hash_table_insert (ucl_vars, k, v);
+ g_hash_table_insert(ucl_vars, k, v);
}
}
}
@@ -1480,44 +1480,42 @@ main (gint argc, gchar **argv, gchar **env)
rspamd_main->cfg->log_level = G_LOG_LEVEL_MESSAGE;
}
- type = g_quark_from_static_string ("main");
+ type = g_quark_from_static_string("main");
/* First set logger to console logger */
- rspamd_main->logger = rspamd_log_open_emergency (rspamd_main->server_pool, 0);
- g_assert (rspamd_main->logger != NULL);
+ rspamd_main->logger = rspamd_log_open_emergency(rspamd_main->server_pool, 0);
+ g_assert(rspamd_main->logger != NULL);
if (is_debug) {
- rspamd_log_set_log_level (rspamd_main->logger, G_LOG_LEVEL_DEBUG);
+ rspamd_log_set_log_level(rspamd_main->logger, G_LOG_LEVEL_DEBUG);
}
else {
- rspamd_log_set_log_level (rspamd_main->logger, G_LOG_LEVEL_MESSAGE);
+ rspamd_log_set_log_level(rspamd_main->logger, G_LOG_LEVEL_MESSAGE);
}
- g_log_set_default_handler (rspamd_glib_log_function, rspamd_main->logger);
- g_set_printerr_handler (rspamd_glib_printerr_function);
+ g_log_set_default_handler(rspamd_glib_log_function, rspamd_main->logger);
+ g_set_printerr_handler(rspamd_glib_printerr_function);
- detect_priv (rspamd_main);
+ detect_priv(rspamd_main);
- msg_notice_main ("rspamd "
- RVERSION
- " is loading configuration, build id: "
- RID);
+ msg_notice_main("rspamd " RVERSION
+ " is loading configuration, build id: " RID);
pworker = &workers[0];
while (*pworker) {
/* Init string quarks */
- (void) g_quark_from_static_string ((*pworker)->name);
+ (void) g_quark_from_static_string((*pworker)->name);
pworker++;
}
/* Init listen sockets hash */
- listen_sockets = g_hash_table_new (g_direct_hash, g_direct_equal);
- sqlite3_initialize ();
+ listen_sockets = g_hash_table_new(g_direct_hash, g_direct_equal);
+ sqlite3_initialize();
/* Load config */
- if (!load_rspamd_config (rspamd_main, rspamd_main->cfg, TRUE,
- RSPAMD_CONFIG_LOAD_ALL, FALSE)) {
- exit (EXIT_FAILURE);
+ if (!load_rspamd_config(rspamd_main, rspamd_main->cfg, TRUE,
+ RSPAMD_CONFIG_LOAD_ALL, FALSE)) {
+ exit(EXIT_FAILURE);
}
/* Override pidfile from configuration by command line argument */
@@ -1527,204 +1525,202 @@ main (gint argc, gchar **argv, gchar **env)
/* Force debug log */
if (is_debug) {
- rspamd_log_set_log_level (rspamd_main->logger, G_LOG_LEVEL_DEBUG);
+ rspamd_log_set_log_level(rspamd_main->logger, G_LOG_LEVEL_DEBUG);
}
/* Create rolling history */
- rspamd_main->history = rspamd_roll_history_new (rspamd_main->server_pool,
- rspamd_main->cfg->history_rows, rspamd_main->cfg);
-
- msg_info_main ("rspamd "
- RVERSION
- " is starting, build id: "
- RID);
- rspamd_main->cfg->cfg_name = rspamd_mempool_strdup (
- rspamd_main->cfg->cfg_pool,
- rspamd_main->cfg->cfg_name);
- msg_info_main ("cpu features: %s",
- rspamd_main->cfg->libs_ctx->crypto_ctx->cpu_extensions);
- msg_info_main ("cryptobox configuration: curve25519(libsodium), "
- "chacha20(%s), poly1305(libsodium), siphash(libsodium), blake2(libsodium), base64(%s)",
- rspamd_main->cfg->libs_ctx->crypto_ctx->chacha20_impl,
- rspamd_main->cfg->libs_ctx->crypto_ctx->base64_impl);
- msg_info_main ("libottery prf: %s", ottery_get_impl_name ());
+ rspamd_main->history = rspamd_roll_history_new(rspamd_main->server_pool,
+ rspamd_main->cfg->history_rows, rspamd_main->cfg);
+
+ msg_info_main("rspamd " RVERSION
+ " is starting, build id: " RID);
+ rspamd_main->cfg->cfg_name = rspamd_mempool_strdup(
+ rspamd_main->cfg->cfg_pool,
+ rspamd_main->cfg->cfg_name);
+ msg_info_main("cpu features: %s",
+ rspamd_main->cfg->libs_ctx->crypto_ctx->cpu_extensions);
+ msg_info_main("cryptobox configuration: curve25519(libsodium), "
+ "chacha20(%s), poly1305(libsodium), siphash(libsodium), blake2(libsodium), base64(%s)",
+ rspamd_main->cfg->libs_ctx->crypto_ctx->chacha20_impl,
+ rspamd_main->cfg->libs_ctx->crypto_ctx->base64_impl);
+ msg_info_main("libottery prf: %s", ottery_get_impl_name());
/* Daemonize */
if (!no_fork) {
- if (!rspamd_main_daemon (rspamd_main)) {
- exit (EXIT_FAILURE);
+ if (!rspamd_main_daemon(rspamd_main)) {
+ exit(EXIT_FAILURE);
}
/* Close emergency logger */
- rspamd_log_close (rspamd_log_emergency_logger ());
+ rspamd_log_close(rspamd_log_emergency_logger());
}
/* Write info */
- rspamd_main->pid = getpid ();
+ rspamd_main->pid = getpid();
rspamd_main->type = type;
- rspamd_set_crash_handler (rspamd_main);
+ rspamd_set_crash_handler(rspamd_main);
/* Ignore SIGPIPE as we handle write errors manually */
- sigemptyset (&sigpipe_act.sa_mask);
- sigaddset (&sigpipe_act.sa_mask, SIGPIPE);
+ sigemptyset(&sigpipe_act.sa_mask);
+ sigaddset(&sigpipe_act.sa_mask, SIGPIPE);
sigpipe_act.sa_handler = SIG_IGN;
sigpipe_act.sa_flags = 0;
- sigaction (SIGPIPE, &sigpipe_act, NULL);
+ sigaction(SIGPIPE, &sigpipe_act, NULL);
if (rspamd_main->cfg->pid_file == NULL) {
- msg_info_main ("pid file is not specified, skipping writing it");
+ msg_info_main("pid file is not specified, skipping writing it");
skip_pid = TRUE;
}
else if (no_fork) {
- msg_info_main ("skip writing pid in no-fork mode");
+ msg_info_main("skip writing pid in no-fork mode");
skip_pid = TRUE;
}
- else if (rspamd_write_pid (rspamd_main) == -1) {
- msg_err_main ("cannot write pid file %s", rspamd_main->cfg->pid_file);
- exit (-errno);
+ else if (rspamd_write_pid(rspamd_main) == -1) {
+ msg_err_main("cannot write pid file %s", rspamd_main->cfg->pid_file);
+ exit(-errno);
}
- sigprocmask (SIG_BLOCK, &signals.sa_mask, NULL);
+ sigprocmask(SIG_BLOCK, &signals.sa_mask, NULL);
/* Set title */
- setproctitle ("main process");
+ setproctitle("main process");
/* Open control socket if needed */
control_fd = -1;
if (rspamd_main->cfg->control_socket_path) {
- if (!rspamd_parse_inet_address (&control_addr,
- rspamd_main->cfg->control_socket_path,
- strlen (rspamd_main->cfg->control_socket_path),
- RSPAMD_INET_ADDRESS_PARSE_DEFAULT)) {
- msg_err_main ("cannot parse inet address %s",
- rspamd_main->cfg->control_socket_path);
+ if (!rspamd_parse_inet_address(&control_addr,
+ rspamd_main->cfg->control_socket_path,
+ strlen(rspamd_main->cfg->control_socket_path),
+ RSPAMD_INET_ADDRESS_PARSE_DEFAULT)) {
+ msg_err_main("cannot parse inet address %s",
+ rspamd_main->cfg->control_socket_path);
}
else {
- control_fd = rspamd_inet_address_listen (control_addr, SOCK_STREAM,
- RSPAMD_INET_ADDRESS_LISTEN_ASYNC, -1);
+ control_fd = rspamd_inet_address_listen(control_addr, SOCK_STREAM,
+ RSPAMD_INET_ADDRESS_LISTEN_ASYNC, -1);
if (control_fd == -1) {
- msg_err_main ("cannot open control socket at path: %s",
- rspamd_main->cfg->control_socket_path);
+ msg_err_main("cannot open control socket at path: %s",
+ rspamd_main->cfg->control_socket_path);
}
}
}
/* Maybe read roll history */
if (rspamd_main->cfg->history_file) {
- rspamd_roll_history_load (rspamd_main->history,
- rspamd_main->cfg->history_file);
+ rspamd_roll_history_load(rspamd_main->history,
+ rspamd_main->cfg->history_file);
}
/* Init workers hash */
- rspamd_main->workers = g_hash_table_new (g_direct_hash, g_direct_equal);
+ rspamd_main->workers = g_hash_table_new(g_direct_hash, g_direct_equal);
/* Unblock control signals */
- sigprocmask (SIG_UNBLOCK, &control_signals, NULL);
+ sigprocmask(SIG_UNBLOCK, &control_signals, NULL);
/* Init event base */
- event_loop = ev_default_loop (rspamd_config_ev_backend_get (rspamd_main->cfg));
+ event_loop = ev_default_loop(rspamd_config_ev_backend_get(rspamd_main->cfg));
rspamd_main->event_loop = event_loop;
if (event_loop) {
- int loop_type = ev_backend (event_loop);
+ int loop_type = ev_backend(event_loop);
gboolean effective_backend;
const gchar *loop_str;
loop_str =
- rspamd_config_ev_backend_to_string (loop_type, &effective_backend);
+ rspamd_config_ev_backend_to_string(loop_type, &effective_backend);
if (!effective_backend) {
- msg_warn_main ("event loop uses non-optimal backend: %s", loop_str);
+ msg_warn_main("event loop uses non-optimal backend: %s", loop_str);
}
else {
- msg_info_main ("event loop initialised with backend: %s", loop_str);
+ msg_info_main("event loop initialised with backend: %s", loop_str);
}
}
else {
- msg_err ("cannot init event loop! exiting");
- exit (EXIT_FAILURE);
+ msg_err("cannot init event loop! exiting");
+ exit(EXIT_FAILURE);
}
/* Unblock signals */
- sigemptyset (&signals.sa_mask);
- sigprocmask (SIG_SETMASK, &signals.sa_mask, NULL);
+ sigemptyset(&signals.sa_mask);
+ sigprocmask(SIG_SETMASK, &signals.sa_mask, NULL);
/* Set events for signals */
- ev_signal_init (&rspamd_main->term_ev, rspamd_term_handler, SIGTERM);
+ ev_signal_init(&rspamd_main->term_ev, rspamd_term_handler, SIGTERM);
rspamd_main->term_ev.data = rspamd_main;
- ev_signal_start (event_loop, &rspamd_main->term_ev);
+ ev_signal_start(event_loop, &rspamd_main->term_ev);
- ev_signal_init (&rspamd_main->int_ev, rspamd_term_handler, SIGINT);
+ ev_signal_init(&rspamd_main->int_ev, rspamd_term_handler, SIGINT);
rspamd_main->int_ev.data = rspamd_main;
- ev_signal_start (event_loop, &rspamd_main->int_ev);
+ ev_signal_start(event_loop, &rspamd_main->int_ev);
- ev_signal_init (&rspamd_main->hup_ev, rspamd_hup_handler, SIGHUP);
+ ev_signal_init(&rspamd_main->hup_ev, rspamd_hup_handler, SIGHUP);
rspamd_main->hup_ev.data = rspamd_main;
- ev_signal_start (event_loop, &rspamd_main->hup_ev);
+ ev_signal_start(event_loop, &rspamd_main->hup_ev);
- ev_signal_init (&rspamd_main->usr1_ev, rspamd_usr1_handler, SIGUSR1);
+ ev_signal_init(&rspamd_main->usr1_ev, rspamd_usr1_handler, SIGUSR1);
rspamd_main->usr1_ev.data = rspamd_main;
- ev_signal_start (event_loop, &rspamd_main->usr1_ev);
+ ev_signal_start(event_loop, &rspamd_main->usr1_ev);
/* Update proctitle according to number of messages processed */
static const ev_tstamp stat_update_time = 10.0;
- memset (&old_stat, 0, sizeof (old_stat));
+ memset(&old_stat, 0, sizeof(old_stat));
stat_ev.data = rspamd_main;
- ev_timer_init (&stat_ev, rspamd_stat_update_handler,
- stat_update_time, stat_update_time);
- ev_timer_start (event_loop, &stat_ev);
+ ev_timer_init(&stat_ev, rspamd_stat_update_handler,
+ stat_update_time, stat_update_time);
+ ev_timer_start(event_loop, &stat_ev);
- rspamd_check_core_limits (rspamd_main);
- rspamd_mempool_lock_mutex (rspamd_main->start_mtx);
- spawn_workers (rspamd_main, event_loop);
- rspamd_mempool_unlock_mutex (rspamd_main->start_mtx);
+ rspamd_check_core_limits(rspamd_main);
+ rspamd_mempool_lock_mutex(rspamd_main->start_mtx);
+ spawn_workers(rspamd_main, event_loop);
+ rspamd_mempool_unlock_mutex(rspamd_main->start_mtx);
- rspamd_main->http_ctx = rspamd_http_context_create (rspamd_main->cfg,
- event_loop, rspamd_main->cfg->ups_ctx);
+ rspamd_main->http_ctx = rspamd_http_context_create(rspamd_main->cfg,
+ event_loop, rspamd_main->cfg->ups_ctx);
if (control_fd != -1) {
- msg_info_main ("listening for control commands on %s",
- rspamd_inet_address_to_string (control_addr));
- ev_io_init (&control_ev, rspamd_control_handler, control_fd, EV_READ);
+ msg_info_main("listening for control commands on %s",
+ rspamd_inet_address_to_string(control_addr));
+ ev_io_init(&control_ev, rspamd_control_handler, control_fd, EV_READ);
control_ev.data = rspamd_main;
- ev_io_start (event_loop, &control_ev);
+ ev_io_start(event_loop, &control_ev);
}
- ev_loop (event_loop, 0);
+ ev_loop(event_loop, 0);
/* Maybe save roll history */
if (rspamd_main->cfg->history_file) {
- rspamd_roll_history_save (rspamd_main->history,
- rspamd_main->cfg->history_file);
+ rspamd_roll_history_save(rspamd_main->history,
+ rspamd_main->cfg->history_file);
}
if (rspamd_main->cfg->cache) {
rspamd_symcache_save(rspamd_main->cfg->cache);
}
- msg_info_main ("terminating...");
+ msg_info_main("terminating...");
#ifdef WITH_HYPERSCAN
rspamd_hyperscan_cleanup_maybe();
#endif
- REF_RELEASE (rspamd_main->cfg);
- rspamd_log_close (rspamd_main->logger);
- g_hash_table_unref (rspamd_main->spairs);
- g_hash_table_unref (rspamd_main->workers);
- rspamd_mempool_delete (rspamd_main->server_pool);
+ REF_RELEASE(rspamd_main->cfg);
+ rspamd_log_close(rspamd_main->logger);
+ g_hash_table_unref(rspamd_main->spairs);
+ g_hash_table_unref(rspamd_main->workers);
+ rspamd_mempool_delete(rspamd_main->server_pool);
if (!skip_pid) {
- rspamd_pidfile_close (rspamd_main->pfh);
+ rspamd_pidfile_close(rspamd_main->pfh);
}
- rspamd_unset_crash_handler (rspamd_main);
- g_free (rspamd_main);
- ev_unref (event_loop);
- sqlite3_shutdown ();
+ rspamd_unset_crash_handler(rspamd_main);
+ g_free(rspamd_main);
+ ev_unref(event_loop);
+ sqlite3_shutdown();
if (control_addr) {
- rspamd_inet_address_free (control_addr);
+ rspamd_inet_address_free(control_addr);
}
return (res);