[Rework] Use clang-format to unify formatting in all sources

No meaningful changes.

1 files changed, 2261 insertions, 2252 deletions

diff --git a/src/libserver/cfg_rcl.c b/src/libserver/cfg_rcl.c
index 073a01126..8267a4bc8 100644
--- a/src/libserver/cfg_rcl.c
+++ b/src/libserver/cfg_rcl.c
@@ -42,19 +42,19 @@ struct rspamd_rcl_default_handler_data {
 };
 
 struct rspamd_rcl_section {
-	const gchar *name;                  /**< name of section */
+	const gchar *name; /**< name of section */
 	const gchar *key_attr;
 	const gchar *default_key;
-	rspamd_rcl_handler_t handler;       /**< handler of section attributes */
-	enum ucl_type type;         /**< type of attribute */
-	gboolean required;                  /**< whether this param is required */
-	gboolean strict_type;               /**< whether we need strict type */
-	UT_hash_handle hh;                  /** hash handle */
-	struct rspamd_rcl_section *subsections; /**< hash table of subsections */
+	rspamd_rcl_handler_t handler;                           /**< handler of section attributes */
+	enum ucl_type type;                                     /**< type of attribute */
+	gboolean required;                                      /**< whether this param is required */
+	gboolean strict_type;                                   /**< whether we need strict type */
+	UT_hash_handle hh;                                      /** hash handle */
+	struct rspamd_rcl_section *subsections;                 /**< hash table of subsections */
 	struct rspamd_rcl_default_handler_data *default_parser; /**< generic parsing fields */
-	rspamd_rcl_section_fin_t fin; /** called at the end of section parsing */
+	rspamd_rcl_section_fin_t fin;                           /** called at the end of section parsing */
 	gpointer fin_ud;
-	ucl_object_t *doc_ref;       /**< reference to the section's documentation */
+	ucl_object_t *doc_ref; /**< reference to the section's documentation */
 };
 
 struct rspamd_worker_param_key {
@@ -63,255 +63,257 @@ struct rspamd_worker_param_key {
 };
 
 struct rspamd_worker_param_parser {
-	rspamd_rcl_default_handler_t handler;           /**< handler function									*/
-	struct rspamd_rcl_struct_parser parser;         /**< parser attributes									*/
+	rspamd_rcl_default_handler_t handler;   /**< handler function									*/
+	struct rspamd_rcl_struct_parser parser; /**< parser attributes									*/
 
 	struct rspamd_worker_param_key key;
 };
 
 struct rspamd_worker_cfg_parser {
-	GHashTable *parsers;                            /**< parsers hash										*/
-	gint type;                                      /**< workers quark										*/
-	gboolean (*def_obj_parser)(ucl_object_t *obj, gpointer ud);   /**<
+	GHashTable *parsers;                                        /**< parsers hash										*/
+	gint type;                                                  /**< workers quark										*/
+	gboolean (*def_obj_parser)(ucl_object_t *obj, gpointer ud); /**<
  														 default object parser								*/
 	gpointer def_ud;
 };
 
-static gboolean rspamd_rcl_process_section (struct rspamd_config *cfg,
-		struct rspamd_rcl_section *sec,
-		gpointer ptr, const ucl_object_t *obj, rspamd_mempool_t *pool,
-		GError **err);
+static gboolean rspamd_rcl_process_section(struct rspamd_config *cfg,
+										   struct rspamd_rcl_section *sec,
+										   gpointer ptr, const ucl_object_t *obj, rspamd_mempool_t *pool,
+										   GError **err);
 
 /*
  * Common section handlers
  */
 static gboolean
-rspamd_rcl_logging_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-	const gchar *key, gpointer ud, struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_logging_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+						   const gchar *key, gpointer ud, struct rspamd_rcl_section *section,
+						   GError **err)
 {
 	const ucl_object_t *val;
 	const gchar *facility = NULL, *log_type = NULL, *log_level = NULL;
 	struct rspamd_config *cfg = ud;
 
-	val = ucl_object_lookup (obj, "type");
-	if (val != NULL && ucl_object_tostring_safe (val, &log_type)) {
-		if (g_ascii_strcasecmp (log_type, "file") == 0) {
+	val = ucl_object_lookup(obj, "type");
+	if (val != NULL && ucl_object_tostring_safe(val, &log_type)) {
+		if (g_ascii_strcasecmp(log_type, "file") == 0) {
 			/* Need to get filename */
-			val = ucl_object_lookup (obj, "filename");
+			val = ucl_object_lookup(obj, "filename");
 			if (val == NULL || val->type != UCL_STRING) {
-				g_set_error (err,
-					CFG_RCL_ERROR,
-					ENOENT,
-					"filename attribute must be specified for file logging type");
+				g_set_error(err,
+							CFG_RCL_ERROR,
+							ENOENT,
+							"filename attribute must be specified for file logging type");
 				return FALSE;
 			}
 			cfg->log_type = RSPAMD_LOG_FILE;
-			cfg->log_file = rspamd_mempool_strdup (cfg->cfg_pool,
-					ucl_object_tostring (val));
+			cfg->log_file = rspamd_mempool_strdup(cfg->cfg_pool,
+												  ucl_object_tostring(val));
 		}
-		else if (g_ascii_strcasecmp (log_type, "syslog") == 0) {
+		else if (g_ascii_strcasecmp(log_type, "syslog") == 0) {
 			/* Need to get facility */
 #ifdef HAVE_SYSLOG_H
 			cfg->log_facility = LOG_DAEMON;
 			cfg->log_type = RSPAMD_LOG_SYSLOG;
-			val = ucl_object_lookup (obj, "facility");
-			if (val != NULL && ucl_object_tostring_safe (val, &facility)) {
-				if (g_ascii_strcasecmp (facility, "LOG_AUTH") == 0 ||
-					g_ascii_strcasecmp (facility, "auth") == 0 ) {
+			val = ucl_object_lookup(obj, "facility");
+			if (val != NULL && ucl_object_tostring_safe(val, &facility)) {
+				if (g_ascii_strcasecmp(facility, "LOG_AUTH") == 0 ||
+					g_ascii_strcasecmp(facility, "auth") == 0) {
 					cfg->log_facility = LOG_AUTH;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_CRON") == 0 ||
-					g_ascii_strcasecmp (facility, "cron") == 0 ) {
+				else if (g_ascii_strcasecmp(facility, "LOG_CRON") == 0 ||
+						 g_ascii_strcasecmp(facility, "cron") == 0) {
 					cfg->log_facility = LOG_CRON;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_DAEMON") == 0 ||
-					g_ascii_strcasecmp (facility, "daemon") == 0 ) {
+				else if (g_ascii_strcasecmp(facility, "LOG_DAEMON") == 0 ||
+						 g_ascii_strcasecmp(facility, "daemon") == 0) {
 					cfg->log_facility = LOG_DAEMON;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_MAIL") == 0 ||
-					g_ascii_strcasecmp (facility, "mail") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_MAIL") == 0 ||
+						 g_ascii_strcasecmp(facility, "mail") == 0) {
 					cfg->log_facility = LOG_MAIL;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_USER") == 0 ||
-					g_ascii_strcasecmp (facility, "user") == 0 ) {
+				else if (g_ascii_strcasecmp(facility, "LOG_USER") == 0 ||
+						 g_ascii_strcasecmp(facility, "user") == 0) {
 					cfg->log_facility = LOG_USER;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_LOCAL0") == 0 ||
-					g_ascii_strcasecmp (facility, "local0") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_LOCAL0") == 0 ||
+						 g_ascii_strcasecmp(facility, "local0") == 0) {
 					cfg->log_facility = LOG_LOCAL0;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_LOCAL1") == 0 ||
-					g_ascii_strcasecmp (facility, "local1") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_LOCAL1") == 0 ||
+						 g_ascii_strcasecmp(facility, "local1") == 0) {
 					cfg->log_facility = LOG_LOCAL1;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_LOCAL2") == 0 ||
-					g_ascii_strcasecmp (facility, "local2") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_LOCAL2") == 0 ||
+						 g_ascii_strcasecmp(facility, "local2") == 0) {
 					cfg->log_facility = LOG_LOCAL2;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_LOCAL3") == 0 ||
-					g_ascii_strcasecmp (facility, "local3") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_LOCAL3") == 0 ||
+						 g_ascii_strcasecmp(facility, "local3") == 0) {
 					cfg->log_facility = LOG_LOCAL3;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_LOCAL4") == 0 ||
-					g_ascii_strcasecmp (facility, "local4") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_LOCAL4") == 0 ||
+						 g_ascii_strcasecmp(facility, "local4") == 0) {
 					cfg->log_facility = LOG_LOCAL4;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_LOCAL5") == 0 ||
-					g_ascii_strcasecmp (facility, "local5") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_LOCAL5") == 0 ||
+						 g_ascii_strcasecmp(facility, "local5") == 0) {
 					cfg->log_facility = LOG_LOCAL5;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_LOCAL6") == 0 ||
-					g_ascii_strcasecmp (facility, "local6") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_LOCAL6") == 0 ||
+						 g_ascii_strcasecmp(facility, "local6") == 0) {
 					cfg->log_facility = LOG_LOCAL6;
 				}
-				else if (g_ascii_strcasecmp (facility, "LOG_LOCAL7") == 0 ||
-					g_ascii_strcasecmp (facility, "local7") == 0) {
+				else if (g_ascii_strcasecmp(facility, "LOG_LOCAL7") == 0 ||
+						 g_ascii_strcasecmp(facility, "local7") == 0) {
 					cfg->log_facility = LOG_LOCAL7;
 				}
 				else {
-					g_set_error (err,
-						CFG_RCL_ERROR,
-						EINVAL,
-						"invalid log facility: %s",
-						facility);
+					g_set_error(err,
+								CFG_RCL_ERROR,
+								EINVAL,
+								"invalid log facility: %s",
+								facility);
 					return FALSE;
 				}
 			}
 #endif
 		}
-		else if (g_ascii_strcasecmp (log_type,
-			"stderr") == 0 || g_ascii_strcasecmp (log_type, "console") == 0) {
+		else if (g_ascii_strcasecmp(log_type,
+									"stderr") == 0 ||
+				 g_ascii_strcasecmp(log_type, "console") == 0) {
 			cfg->log_type = RSPAMD_LOG_CONSOLE;
 		}
 		else {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"invalid log type: %s",
-				log_type);
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"invalid log type: %s",
+						log_type);
 			return FALSE;
 		}
 	}
 	else {
 		/* No type specified */
-		msg_warn_config (
+		msg_warn_config(
 			"logging type is not specified correctly, log output to the console");
 	}
 
 	/* Handle log level */
-	val = ucl_object_lookup (obj, "level");
-	if (val != NULL && ucl_object_tostring_safe (val, &log_level)) {
-		if (g_ascii_strcasecmp (log_level, "error") == 0) {
+	val = ucl_object_lookup(obj, "level");
+	if (val != NULL && ucl_object_tostring_safe(val, &log_level)) {
+		if (g_ascii_strcasecmp(log_level, "error") == 0) {
 			cfg->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
 		}
-		else if (g_ascii_strcasecmp (log_level, "warning") == 0) {
+		else if (g_ascii_strcasecmp(log_level, "warning") == 0) {
 			cfg->log_level = G_LOG_LEVEL_WARNING;
 		}
-		else if (g_ascii_strcasecmp (log_level, "info") == 0) {
+		else if (g_ascii_strcasecmp(log_level, "info") == 0) {
 			cfg->log_level = G_LOG_LEVEL_INFO | G_LOG_LEVEL_MESSAGE;
 		}
-		else if (g_ascii_strcasecmp (log_level, "message") == 0 ||
-				g_ascii_strcasecmp (log_level, "notice") == 0) {
-			cfg->log_level =  G_LOG_LEVEL_MESSAGE;
+		else if (g_ascii_strcasecmp(log_level, "message") == 0 ||
+				 g_ascii_strcasecmp(log_level, "notice") == 0) {
+			cfg->log_level = G_LOG_LEVEL_MESSAGE;
 		}
-		else if (g_ascii_strcasecmp (log_level, "silent") == 0) {
-			cfg->log_level =  G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO;
+		else if (g_ascii_strcasecmp(log_level, "silent") == 0) {
+			cfg->log_level = G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO;
 			cfg->log_silent_workers = TRUE;
 		}
-		else if (g_ascii_strcasecmp (log_level, "debug") == 0) {
+		else if (g_ascii_strcasecmp(log_level, "debug") == 0) {
 			cfg->log_level = G_LOG_LEVEL_DEBUG;
 		}
 		else {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"invalid log level: %s",
-				log_level);
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"invalid log level: %s",
+						log_level);
 			return FALSE;
 		}
 	}
 
 	/* Handle flags */
-	val = ucl_object_lookup_any (obj, "color", "log_color", NULL);
-	if (val && ucl_object_toboolean (val)) {
+	val = ucl_object_lookup_any(obj, "color", "log_color", NULL);
+	if (val && ucl_object_toboolean(val)) {
 		cfg->log_flags |= RSPAMD_LOG_FLAG_COLOR;
 	}
 
-	val = ucl_object_lookup_any (obj, "severity", "log_severity", NULL);
-	if (val && ucl_object_toboolean (val)) {
+	val = ucl_object_lookup_any(obj, "severity", "log_severity", NULL);
+	if (val && ucl_object_toboolean(val)) {
 		cfg->log_flags |= RSPAMD_LOG_FLAG_SEVERITY;
 	}
 
-	val = ucl_object_lookup_any (obj, "systemd", "log_systemd", NULL);
-	if (val && ucl_object_toboolean (val)) {
+	val = ucl_object_lookup_any(obj, "systemd", "log_systemd", NULL);
+	if (val && ucl_object_toboolean(val)) {
 		cfg->log_flags |= RSPAMD_LOG_FLAG_SYSTEMD;
 	}
 
-	val = ucl_object_lookup (obj, "log_re_cache");
-	if (val && ucl_object_toboolean (val)) {
+	val = ucl_object_lookup(obj, "log_re_cache");
+	if (val && ucl_object_toboolean(val)) {
 		cfg->log_flags |= RSPAMD_LOG_FLAG_RE_CACHE;
 	}
 
-	val = ucl_object_lookup_any (obj, "usec", "log_usec", NULL);
-	if (val && ucl_object_toboolean (val)) {
+	val = ucl_object_lookup_any(obj, "usec", "log_usec", NULL);
+	if (val && ucl_object_toboolean(val)) {
 		cfg->log_flags |= RSPAMD_LOG_FLAG_USEC;
 	}
 
-	return rspamd_rcl_section_parse_defaults (cfg, section, cfg->cfg_pool, obj,
-			cfg, err);
+	return rspamd_rcl_section_parse_defaults(cfg, section, cfg->cfg_pool, obj,
+											 cfg, err);
 }
 
 static gboolean
-rspamd_rcl_options_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-	const gchar *key, gpointer ud,
-	struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_options_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+						   const gchar *key, gpointer ud,
+						   struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *dns, *upstream, *neighbours;
 	struct rspamd_config *cfg = ud;
 	struct rspamd_rcl_section *dns_section, *upstream_section, *neighbours_section;
 
-	HASH_FIND_STR (section->subsections, "dns", dns_section);
+	HASH_FIND_STR(section->subsections, "dns", dns_section);
 
-	dns = ucl_object_lookup (obj, "dns");
+	dns = ucl_object_lookup(obj, "dns");
 	if (dns_section != NULL && dns != NULL) {
-		if (!rspamd_rcl_section_parse_defaults (cfg,
-				dns_section, cfg->cfg_pool, dns,
-				cfg, err)) {
+		if (!rspamd_rcl_section_parse_defaults(cfg,
+											   dns_section, cfg->cfg_pool, dns,
+											   cfg, err)) {
 			return FALSE;
 		}
 	}
 
-	HASH_FIND_STR (section->subsections, "upstream", upstream_section);
+	HASH_FIND_STR(section->subsections, "upstream", upstream_section);
 
-	upstream = ucl_object_lookup_any (obj, "upstream", "upstreams", NULL);
+	upstream = ucl_object_lookup_any(obj, "upstream", "upstreams", NULL);
 	if (upstream_section != NULL && upstream != NULL) {
-		if (!rspamd_rcl_section_parse_defaults (cfg,
-				upstream_section, cfg->cfg_pool,
-				upstream, cfg, err)) {
+		if (!rspamd_rcl_section_parse_defaults(cfg,
+											   upstream_section, cfg->cfg_pool,
+											   upstream, cfg, err)) {
 			return FALSE;
 		}
 	}
 
-	HASH_FIND_STR (section->subsections, "neighbours", neighbours_section);
+	HASH_FIND_STR(section->subsections, "neighbours", neighbours_section);
 
-	neighbours = ucl_object_lookup (obj, "neighbours");
+	neighbours = ucl_object_lookup(obj, "neighbours");
 	if (neighbours_section != NULL && neighbours != NULL) {
 		const ucl_object_t *cur;
 
-		LL_FOREACH (neighbours, cur) {
-			if (!rspamd_rcl_process_section (cfg, neighbours_section, cfg, cur,
-					pool, err)) {
+		LL_FOREACH(neighbours, cur)
+		{
+			if (!rspamd_rcl_process_section(cfg, neighbours_section, cfg, cur,
+											pool, err)) {
 				return FALSE;
 			}
 		}
 	}
 
-	if (rspamd_rcl_section_parse_defaults (cfg,
-			section, cfg->cfg_pool, obj,
-			cfg, err)) {
+	if (rspamd_rcl_section_parse_defaults(cfg,
+										  section, cfg->cfg_pool, obj,
+										  cfg, err)) {
 		/* We need to init this early */
-		rspamd_multipattern_library_init (cfg->hs_cache_dir);
+		rspamd_multipattern_library_init(cfg->hs_cache_dir);
 
 		return TRUE;
 	}
@@ -325,9 +327,9 @@ struct rspamd_rcl_symbol_data {
 };
 
 static gboolean
-rspamd_rcl_group_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-		const gchar *key, gpointer ud,
-		struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_group_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+						 const gchar *key, gpointer ud,
+						 struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_config *cfg = ud;
 	struct rspamd_symbols_group *gr;
@@ -336,112 +338,112 @@ rspamd_rcl_group_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 	struct rspamd_rcl_symbol_data sd;
 	const gchar *description = NULL;
 
-	g_assert (key != NULL);
+	g_assert(key != NULL);
 
-	gr = g_hash_table_lookup (cfg->groups, key);
+	gr = g_hash_table_lookup(cfg->groups, key);
 
 	if (gr == NULL) {
-		gr = rspamd_config_new_group (cfg, key);
+		gr = rspamd_config_new_group(cfg, key);
 	}
 
-	if (!rspamd_rcl_section_parse_defaults (cfg, section, pool, obj,
-			gr, err)) {
+	if (!rspamd_rcl_section_parse_defaults(cfg, section, pool, obj,
+										   gr, err)) {
 		return FALSE;
 	}
 
-	if ((elt = ucl_object_lookup (obj, "one_shot")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"one_shot attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "one_shot")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"one_shot attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
-		if (ucl_object_toboolean (elt)) {
+		if (ucl_object_toboolean(elt)) {
 			gr->flags |= RSPAMD_SYMBOL_GROUP_ONE_SHOT;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "disabled")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"disabled attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "disabled")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"disabled attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
-		if (ucl_object_toboolean (elt)) {
+		if (ucl_object_toboolean(elt)) {
 			gr->flags |= RSPAMD_SYMBOL_GROUP_DISABLED;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "enabled")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"enabled attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "enabled")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"enabled attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
-		if (!ucl_object_toboolean (elt)) {
+		if (!ucl_object_toboolean(elt)) {
 			gr->flags |= RSPAMD_SYMBOL_GROUP_DISABLED;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "public")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"public attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "public")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"public attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
-		if (ucl_object_toboolean (elt)) {
+		if (ucl_object_toboolean(elt)) {
 			gr->flags |= RSPAMD_SYMBOL_GROUP_PUBLIC;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "private")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"private attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "private")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"private attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
-		if (!ucl_object_toboolean (elt)) {
+		if (!ucl_object_toboolean(elt)) {
 			gr->flags |= RSPAMD_SYMBOL_GROUP_PUBLIC;
 		}
 	}
 
-	elt = ucl_object_lookup (obj, "description");
+	elt = ucl_object_lookup(obj, "description");
 	if (elt) {
-		description = ucl_object_tostring (elt);
+		description = ucl_object_tostring(elt);
 
-		gr->description = rspamd_mempool_strdup (cfg->cfg_pool,
-				description);
+		gr->description = rspamd_mempool_strdup(cfg->cfg_pool,
+												description);
 	}
 
 	sd.gr = gr;
 	sd.cfg = cfg;
 
 	/* Handle symbols */
-	val = ucl_object_lookup (obj, "symbols");
-	if (val != NULL && ucl_object_type (val) == UCL_OBJECT) {
-		HASH_FIND_STR (section->subsections, "symbols", subsection);
-		g_assert (subsection != NULL);
-		if (!rspamd_rcl_process_section (cfg, subsection, &sd, val,
-				pool, err)) {
+	val = ucl_object_lookup(obj, "symbols");
+	if (val != NULL && ucl_object_type(val) == UCL_OBJECT) {
+		HASH_FIND_STR(section->subsections, "symbols", subsection);
+		g_assert(subsection != NULL);
+		if (!rspamd_rcl_process_section(cfg, subsection, &sd, val,
+										pool, err)) {
 
 			return FALSE;
 		}
@@ -451,9 +453,9 @@ rspamd_rcl_group_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 }
 
 static gboolean
-rspamd_rcl_symbol_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-		const gchar *key, gpointer ud,
-		struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_symbol_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+						  const gchar *key, gpointer ud,
+						  struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_rcl_symbol_data *sd = ud;
 	struct rspamd_config *cfg;
@@ -463,192 +465,193 @@ rspamd_rcl_symbol_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 	guint priority = 1, flags = 0;
 	gint nshots = 0;
 
-	g_assert (key != NULL);
+	g_assert(key != NULL);
 	cfg = sd->cfg;
 
-	if ((elt = ucl_object_lookup (obj, "one_shot")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"one_shot attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "one_shot")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"one_shot attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
-		if (ucl_object_toboolean (elt)) {
+		if (ucl_object_toboolean(elt)) {
 			nshots = 1;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "any_shot")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"any_shot attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "any_shot")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"any_shot attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
-		if (ucl_object_toboolean (elt)) {
+		if (ucl_object_toboolean(elt)) {
 			nshots = -1;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "one_param")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"one_param attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "one_param")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"one_param attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
 
-		if (ucl_object_toboolean (elt)) {
+		if (ucl_object_toboolean(elt)) {
 			flags |= RSPAMD_SYMBOL_FLAG_ONEPARAM;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "ignore")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"ignore attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "ignore")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"ignore attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
 
-		if (ucl_object_toboolean (elt)) {
+		if (ucl_object_toboolean(elt)) {
 			flags |= RSPAMD_SYMBOL_FLAG_IGNORE_METRIC;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "enabled")) != NULL) {
-		if (ucl_object_type (elt) != UCL_BOOLEAN) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"enabled attribute is not boolean for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "enabled")) != NULL) {
+		if (ucl_object_type(elt) != UCL_BOOLEAN) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"enabled attribute is not boolean for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
 
-		if (!ucl_object_toboolean (elt)) {
+		if (!ucl_object_toboolean(elt)) {
 			flags |= RSPAMD_SYMBOL_FLAG_DISABLED;
 		}
 	}
 
-	if ((elt = ucl_object_lookup (obj, "nshots")) != NULL) {
-		if (ucl_object_type (elt) != UCL_FLOAT && ucl_object_type (elt) != UCL_INT) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"nshots attribute is not numeric for symbol: '%s'",
-					key);
+	if ((elt = ucl_object_lookup(obj, "nshots")) != NULL) {
+		if (ucl_object_type(elt) != UCL_FLOAT && ucl_object_type(elt) != UCL_INT) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"nshots attribute is not numeric for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
 
-		nshots = ucl_object_toint (elt);
+		nshots = ucl_object_toint(elt);
 	}
 
-	elt = ucl_object_lookup_any (obj, "score", "weight", NULL);
+	elt = ucl_object_lookup_any(obj, "score", "weight", NULL);
 	if (elt) {
-		if (ucl_object_type (elt) != UCL_FLOAT && ucl_object_type (elt) != UCL_INT) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"score attribute is not numeric for symbol: '%s'",
-					key);
+		if (ucl_object_type(elt) != UCL_FLOAT && ucl_object_type(elt) != UCL_INT) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"score attribute is not numeric for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
 
-		score = ucl_object_todouble (elt);
+		score = ucl_object_todouble(elt);
 	}
 
-	elt = ucl_object_lookup (obj, "priority");
+	elt = ucl_object_lookup(obj, "priority");
 	if (elt) {
-		if (ucl_object_type (elt) != UCL_FLOAT && ucl_object_type (elt) != UCL_INT) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"priority attribute is not numeric for symbol: '%s'",
-					key);
+		if (ucl_object_type(elt) != UCL_FLOAT && ucl_object_type(elt) != UCL_INT) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"priority attribute is not numeric for symbol: '%s'",
+						key);
 
 			return FALSE;
 		}
 
-		priority = ucl_object_toint (elt);
+		priority = ucl_object_toint(elt);
 	}
 	else {
-		priority = ucl_object_get_priority (obj) + 1;
+		priority = ucl_object_get_priority(obj) + 1;
 	}
 
-	elt = ucl_object_lookup (obj, "description");
+	elt = ucl_object_lookup(obj, "description");
 	if (elt) {
-		description = ucl_object_tostring (elt);
+		description = ucl_object_tostring(elt);
 	}
 
 	if (sd->gr) {
-		rspamd_config_add_symbol (cfg, key, score,
-				description, sd->gr->name, flags, priority, nshots);
+		rspamd_config_add_symbol(cfg, key, score,
+								 description, sd->gr->name, flags, priority, nshots);
 	}
 	else {
-		rspamd_config_add_symbol (cfg, key, score,
-				description, NULL, flags, priority, nshots);
+		rspamd_config_add_symbol(cfg, key, score,
+								 description, NULL, flags, priority, nshots);
 	}
 
-	elt = ucl_object_lookup (obj, "groups");
+	elt = ucl_object_lookup(obj, "groups");
 
 	if (elt) {
 		ucl_object_iter_t gr_it;
 		const ucl_object_t *cur_gr;
 
-		gr_it = ucl_object_iterate_new (elt);
+		gr_it = ucl_object_iterate_new(elt);
 
-		while ((cur_gr = ucl_object_iterate_safe (gr_it, true)) != NULL) {
-			rspamd_config_add_symbol_group (cfg, key,
-					ucl_object_tostring (cur_gr));
+		while ((cur_gr = ucl_object_iterate_safe(gr_it, true)) != NULL) {
+			rspamd_config_add_symbol_group(cfg, key,
+										   ucl_object_tostring(cur_gr));
 		}
 
-		ucl_object_iterate_free (gr_it);
+		ucl_object_iterate_free(gr_it);
 	}
 
 	return TRUE;
 }
 
 static gboolean
-rspamd_rcl_actions_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-		const gchar *key, gpointer ud,
-		struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_actions_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+						   const gchar *key, gpointer ud,
+						   struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_config *cfg = ud;
 	const ucl_object_t *cur;
 	ucl_object_iter_t it;
 
-	it = ucl_object_iterate_new (obj);
+	it = ucl_object_iterate_new(obj);
 
-	while ((cur = ucl_object_iterate_safe (it, true)) != NULL) {
-		gint type = ucl_object_type (cur);
+	while ((cur = ucl_object_iterate_safe(it, true)) != NULL) {
+		gint type = ucl_object_type(cur);
 
 		if (type == UCL_NULL) {
-			rspamd_config_maybe_disable_action (cfg, ucl_object_key (cur),
-					ucl_object_get_priority (cur));
+			rspamd_config_maybe_disable_action(cfg, ucl_object_key(cur),
+											   ucl_object_get_priority(cur));
 		}
 		else if (type == UCL_OBJECT || type == UCL_FLOAT || type == UCL_INT) {
 			/* Exceptions */
 			struct rspamd_rcl_default_handler_data *sec_cur, *sec_tmp;
 			gboolean default_elt = FALSE;
 
-			HASH_ITER (hh, section->default_parser, sec_cur, sec_tmp) {
-				if (strcmp (ucl_object_key (cur), sec_cur->key) == 0) {
+			HASH_ITER(hh, section->default_parser, sec_cur, sec_tmp)
+			{
+				if (strcmp(ucl_object_key(cur), sec_cur->key) == 0) {
 					default_elt = TRUE;
 				}
 			}
@@ -658,30 +661,30 @@ rspamd_rcl_actions_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 			}
 
 			/* Something non-default */
-			if (!rspamd_config_set_action_score (cfg,
-					ucl_object_key (cur),
-					cur)) {
-				g_set_error (err,
-						CFG_RCL_ERROR,
-						EINVAL,
-						"invalid action definition for: '%s'",
-						ucl_object_key (cur));
-				ucl_object_iterate_free (it);
+			if (!rspamd_config_set_action_score(cfg,
+												ucl_object_key(cur),
+												cur)) {
+				g_set_error(err,
+							CFG_RCL_ERROR,
+							EINVAL,
+							"invalid action definition for: '%s'",
+							ucl_object_key(cur));
+				ucl_object_iterate_free(it);
 
 				return FALSE;
 			}
 		}
 	}
 
-	ucl_object_iterate_free (it);
+	ucl_object_iterate_free(it);
 
-	return rspamd_rcl_section_parse_defaults (cfg, section, pool, obj, cfg, err);
+	return rspamd_rcl_section_parse_defaults(cfg, section, pool, obj, cfg, err);
 }
 
 static gboolean
-rspamd_rcl_worker_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-		const gchar *key, gpointer ud,
-		struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_worker_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+						  const gchar *key, gpointer ud,
+						  struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *val, *cur, *cur_obj;
 	ucl_object_t *robj;
@@ -694,84 +697,85 @@ rspamd_rcl_worker_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 	struct rspamd_worker_param_parser *whandler;
 	struct rspamd_worker_param_key srch;
 
-	g_assert (key != NULL);
+	g_assert(key != NULL);
 	worker_type = key;
 
-	qtype = g_quark_try_string (worker_type);
+	qtype = g_quark_try_string(worker_type);
 	if (qtype != 0) {
-		wrk = rspamd_config_new_worker (cfg, NULL);
-		wrk->options = ucl_object_copy (obj);
-		wrk->worker = rspamd_get_worker_by_type (cfg, qtype);
+		wrk = rspamd_config_new_worker(cfg, NULL);
+		wrk->options = ucl_object_copy(obj);
+		wrk->worker = rspamd_get_worker_by_type(cfg, qtype);
 
 		if (wrk->worker == NULL) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"unknown worker type: %s",
-					worker_type);
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"unknown worker type: %s",
+						worker_type);
 			return FALSE;
 		}
 
 		wrk->type = qtype;
 
 		if (wrk->worker->worker_init_func) {
-			wrk->ctx = wrk->worker->worker_init_func (cfg);
+			wrk->ctx = wrk->worker->worker_init_func(cfg);
 		}
 	}
 	else {
-		msg_err_config ("unknown worker type: %s", worker_type);
+		msg_err_config("unknown worker type: %s", worker_type);
 		return TRUE;
 	}
 
-	val = ucl_object_lookup_any (obj, "bind_socket", "listen", "bind", NULL);
+	val = ucl_object_lookup_any(obj, "bind_socket", "listen", "bind", NULL);
 	/* This name is more logical */
 	if (val != NULL) {
-		it = ucl_object_iterate_new (val);
+		it = ucl_object_iterate_new(val);
 
-		while ((cur = ucl_object_iterate_safe (it, true)) != NULL) {
-			if (!ucl_object_tostring_safe (cur, &worker_bind)) {
+		while ((cur = ucl_object_iterate_safe(it, true)) != NULL) {
+			if (!ucl_object_tostring_safe(cur, &worker_bind)) {
 				continue;
 			}
-			if (!rspamd_parse_bind_line (cfg, wrk, worker_bind)) {
-				g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot parse bind line: %s",
-					worker_bind);
-				ucl_object_iterate_free (it);
+			if (!rspamd_parse_bind_line(cfg, wrk, worker_bind)) {
+				g_set_error(err,
+							CFG_RCL_ERROR,
+							EINVAL,
+							"cannot parse bind line: %s",
+							worker_bind);
+				ucl_object_iterate_free(it);
 				return FALSE;
 			}
 		}
 
-		ucl_object_iterate_free (it);
+		ucl_object_iterate_free(it);
 	}
 
-	if (!rspamd_rcl_section_parse_defaults (cfg, section, cfg->cfg_pool, obj,
-			wrk, err)) {
+	if (!rspamd_rcl_section_parse_defaults(cfg, section, cfg->cfg_pool, obj,
+										   wrk, err)) {
 		return FALSE;
 	}
 
 	/* Parse other attributes */
-	wparser = g_hash_table_lookup (cfg->wrk_parsers, &qtype);
+	wparser = g_hash_table_lookup(cfg->wrk_parsers, &qtype);
 
 	if (wparser != NULL && obj->type == UCL_OBJECT) {
-		it = ucl_object_iterate_new (obj);
+		it = ucl_object_iterate_new(obj);
 
-		while ((cur = ucl_object_iterate_full (it, UCL_ITERATE_EXPLICIT)) != NULL) {
-			srch.name = ucl_object_key (cur);
+		while ((cur = ucl_object_iterate_full(it, UCL_ITERATE_EXPLICIT)) != NULL) {
+			srch.name = ucl_object_key(cur);
 			srch.ptr = wrk->ctx; /* XXX: is it valid? Update! no, it is not valid, omfg... */
-			whandler = g_hash_table_lookup (wparser->parsers, &srch);
+			whandler = g_hash_table_lookup(wparser->parsers, &srch);
 
 			if (whandler != NULL) {
 
-				LL_FOREACH (cur, cur_obj) {
-					if (!whandler->handler (cfg->cfg_pool,
-							cur_obj,
-							&whandler->parser,
-							section,
-							err)) {
+				LL_FOREACH(cur, cur_obj)
+				{
+					if (!whandler->handler(cfg->cfg_pool,
+										   cur_obj,
+										   &whandler->parser,
+										   section,
+										   err)) {
 
-						ucl_object_iterate_free (it);
+						ucl_object_iterate_free(it);
 						return FALSE;
 					}
 
@@ -782,34 +786,34 @@ rspamd_rcl_worker_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 			}
 		}
 
-		ucl_object_iterate_free (it);
+		ucl_object_iterate_free(it);
 
 		if (wparser->def_obj_parser != NULL) {
-			robj = ucl_object_ref (obj);
+			robj = ucl_object_ref(obj);
 
-			if (!wparser->def_obj_parser (robj, wparser->def_ud)) {
-				ucl_object_unref (robj);
+			if (!wparser->def_obj_parser(robj, wparser->def_ud)) {
+				ucl_object_unref(robj);
 
 				return FALSE;
 			}
 
-			ucl_object_unref (robj);
+			ucl_object_unref(robj);
 		}
 	}
 
-	cfg->workers = g_list_prepend (cfg->workers, wrk);
+	cfg->workers = g_list_prepend(cfg->workers, wrk);
 
 	return TRUE;
 }
 
 static gboolean
-rspamd_rcl_lua_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-		const gchar *key, gpointer ud,
-		struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_lua_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+					   const gchar *key, gpointer ud,
+					   struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_config *cfg = ud;
-	const gchar *lua_src = rspamd_mempool_strdup (pool,
-			ucl_object_tostring (obj));
+	const gchar *lua_src = rspamd_mempool_strdup(pool,
+												 ucl_object_tostring(obj));
 	gchar *cur_dir, *lua_dir, *lua_file;
 	lua_State *L = cfg->lua_state;
 	gint err_idx;
@@ -818,78 +822,77 @@ rspamd_rcl_lua_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 	lua_file = g_path_get_basename(lua_src);
 
 	if (lua_dir && lua_file) {
-		cur_dir = g_malloc (PATH_MAX);
-		if (getcwd (cur_dir, PATH_MAX) != NULL && chdir (lua_dir) != -1) {
+		cur_dir = g_malloc(PATH_MAX);
+		if (getcwd(cur_dir, PATH_MAX) != NULL && chdir(lua_dir) != -1) {
 			/* Push traceback function */
-			lua_pushcfunction (L, &rspamd_lua_traceback);
-			err_idx = lua_gettop (L);
+			lua_pushcfunction(L, &rspamd_lua_traceback);
+			err_idx = lua_gettop(L);
 
 			/* Load file */
-			if (luaL_loadfile (L, lua_file) != 0) {
-				g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot load lua file %s: %s",
-					lua_src,
-					lua_tostring (L, -1));
-				if (chdir (cur_dir) == -1) {
-					msg_err_config ("cannot chdir to %s: %s", cur_dir,
-						strerror (errno));
+			if (luaL_loadfile(L, lua_file) != 0) {
+				g_set_error(err,
+							CFG_RCL_ERROR,
+							EINVAL,
+							"cannot load lua file %s: %s",
+							lua_src,
+							lua_tostring(L, -1));
+				if (chdir(cur_dir) == -1) {
+					msg_err_config("cannot chdir to %s: %s", cur_dir,
+								   strerror(errno));
 				}
-				g_free (cur_dir);
-				g_free (lua_dir);
-				g_free (lua_file);
+				g_free(cur_dir);
+				g_free(lua_dir);
+				g_free(lua_file);
 				return FALSE;
 			}
 
 			/* Now do it */
-			if (lua_pcall (L, 0, 0, err_idx) != 0) {
-				g_set_error (err,
-						CFG_RCL_ERROR,
-						EINVAL,
-						"cannot init lua file %s: %s",
-						lua_src,
-						lua_tostring (L, -1));
-				lua_settop (L, 0);
-
-				if (chdir (cur_dir) == -1) {
-					msg_err_config ("cannot chdir to %s: %s", cur_dir,
-						strerror (errno));
+			if (lua_pcall(L, 0, 0, err_idx) != 0) {
+				g_set_error(err,
+							CFG_RCL_ERROR,
+							EINVAL,
+							"cannot init lua file %s: %s",
+							lua_src,
+							lua_tostring(L, -1));
+				lua_settop(L, 0);
+
+				if (chdir(cur_dir) == -1) {
+					msg_err_config("cannot chdir to %s: %s", cur_dir,
+								   strerror(errno));
 				}
 
-				g_free (cur_dir);
-				g_free (lua_file);
-				g_free (lua_dir);
+				g_free(cur_dir);
+				g_free(lua_file);
+				g_free(lua_dir);
 
 				return FALSE;
 			}
 
-			lua_pop (L, 1);
+			lua_pop(L, 1);
 		}
 		else {
-			g_set_error (err, CFG_RCL_ERROR, ENOENT, "cannot chdir to %s: %s",
-					lua_dir, strerror (errno));
-			if (chdir (cur_dir) == -1) {
-				msg_err_config ("cannot chdir to %s: %s", cur_dir, strerror (errno));
+			g_set_error(err, CFG_RCL_ERROR, ENOENT, "cannot chdir to %s: %s",
+						lua_dir, strerror(errno));
+			if (chdir(cur_dir) == -1) {
+				msg_err_config("cannot chdir to %s: %s", cur_dir, strerror(errno));
 			}
-			g_free (cur_dir);
-			g_free (lua_dir);
-			g_free (lua_file);
+			g_free(cur_dir);
+			g_free(lua_dir);
+			g_free(lua_file);
 			return FALSE;
-
 		}
-		if (chdir (cur_dir) == -1) {
-			msg_err_config ("cannot chdir to %s: %s", cur_dir, strerror (errno));
+		if (chdir(cur_dir) == -1) {
+			msg_err_config("cannot chdir to %s: %s", cur_dir, strerror(errno));
 		}
-		g_free (cur_dir);
-		g_free (lua_dir);
-		g_free (lua_file);
+		g_free(cur_dir);
+		g_free(lua_dir);
+		g_free(lua_file);
 	}
 	else {
-		g_free (lua_dir);
-		g_free (lua_file);
-		g_set_error (err, CFG_RCL_ERROR, ENOENT, "cannot find to %s: %s",
-			lua_src, strerror (errno));
+		g_free(lua_dir);
+		g_free(lua_file);
+		g_set_error(err, CFG_RCL_ERROR, ENOENT, "cannot find to %s: %s",
+					lua_src, strerror(errno));
 		return FALSE;
 	}
 
@@ -897,11 +900,11 @@ rspamd_rcl_lua_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 }
 
 gboolean
-rspamd_rcl_add_lua_plugins_path (struct rspamd_config *cfg,
-		const gchar *path,
-		gboolean main_path,
-		GHashTable *modules_seen,
-		GError **err)
+rspamd_rcl_add_lua_plugins_path(struct rspamd_config *cfg,
+								const gchar *path,
+								gboolean main_path,
+								GHashTable *modules_seen,
+								GError **err)
 {
 	struct stat st;
 	struct script_module *cur_mod, *seen_mod;
@@ -909,113 +912,115 @@ rspamd_rcl_add_lua_plugins_path (struct rspamd_config *cfg,
 	gchar *fname, *ext_pos;
 	guint i;
 
-	if (stat (path, &st) == -1) {
+	if (stat(path, &st) == -1) {
 
 		if (errno != ENOENT || main_path) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					errno,
-					"cannot stat path %s, %s",
-					path,
-					strerror (errno));
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						errno,
+						"cannot stat path %s, %s",
+						path,
+						strerror(errno));
 			return FALSE;
 		}
 		else {
-			msg_debug_config ("optional plugins path %s is absent, skip it", path);
+			msg_debug_config("optional plugins path %s is absent, skip it", path);
 
 			return TRUE;
 		}
 	}
 
 	/* Handle directory */
-	if (S_ISDIR (st.st_mode)) {
-		paths = rspamd_glob_path (path, "*.lua", TRUE, err);
+	if (S_ISDIR(st.st_mode)) {
+		paths = rspamd_glob_path(path, "*.lua", TRUE, err);
 
 		if (!paths) {
 			return FALSE;
 		}
 
-		PTR_ARRAY_FOREACH (paths, i, fname) {
+		PTR_ARRAY_FOREACH(paths, i, fname)
+		{
 			cur_mod =
-					rspamd_mempool_alloc (cfg->cfg_pool,
-							sizeof (struct script_module));
-			cur_mod->path = rspamd_mempool_strdup (cfg->cfg_pool, fname);
-			cur_mod->name = g_path_get_basename (cur_mod->path);
-			rspamd_mempool_add_destructor (cfg->cfg_pool, g_free,
-					cur_mod->name);
-			ext_pos = strstr (cur_mod->name, ".lua");
+				rspamd_mempool_alloc(cfg->cfg_pool,
+									 sizeof(struct script_module));
+			cur_mod->path = rspamd_mempool_strdup(cfg->cfg_pool, fname);
+			cur_mod->name = g_path_get_basename(cur_mod->path);
+			rspamd_mempool_add_destructor(cfg->cfg_pool, g_free,
+										  cur_mod->name);
+			ext_pos = strstr(cur_mod->name, ".lua");
 
 			if (ext_pos != NULL) {
 				*ext_pos = '\0';
 			}
 
 			if (modules_seen) {
-				seen_mod = g_hash_table_lookup (modules_seen, cur_mod->name);
+				seen_mod = g_hash_table_lookup(modules_seen, cur_mod->name);
 
 				if (seen_mod != NULL) {
-					msg_info_config ("already seen module %s at %s, skip %s",
-							cur_mod->name, seen_mod->path, cur_mod->path);
+					msg_info_config("already seen module %s at %s, skip %s",
+									cur_mod->name, seen_mod->path, cur_mod->path);
 					continue;
 				}
 			}
 
 			if (cfg->script_modules == NULL) {
-				cfg->script_modules = g_list_append (cfg->script_modules,
-						cur_mod);
-				rspamd_mempool_add_destructor (cfg->cfg_pool,
-						(rspamd_mempool_destruct_t) g_list_free,
-						cfg->script_modules);
-			} else {
-				cfg->script_modules = g_list_append (cfg->script_modules,
-						cur_mod);
+				cfg->script_modules = g_list_append(cfg->script_modules,
+													cur_mod);
+				rspamd_mempool_add_destructor(cfg->cfg_pool,
+											  (rspamd_mempool_destruct_t) g_list_free,
+											  cfg->script_modules);
+			}
+			else {
+				cfg->script_modules = g_list_append(cfg->script_modules,
+													cur_mod);
 			}
 
 			if (modules_seen) {
-				g_hash_table_insert (modules_seen, cur_mod->name, cur_mod);
+				g_hash_table_insert(modules_seen, cur_mod->name, cur_mod);
 			}
 		}
 
-		g_ptr_array_free (paths, TRUE);
+		g_ptr_array_free(paths, TRUE);
 	}
 	else {
 		/* Handle single file */
 		cur_mod =
-			rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct script_module));
-		cur_mod->path = rspamd_mempool_strdup (cfg->cfg_pool, path);
-		cur_mod->name = g_path_get_basename (cur_mod->path);
-		rspamd_mempool_add_destructor (cfg->cfg_pool, g_free,
-				cur_mod->name);
-		ext_pos = strstr (cur_mod->name, ".lua");
+			rspamd_mempool_alloc(cfg->cfg_pool, sizeof(struct script_module));
+		cur_mod->path = rspamd_mempool_strdup(cfg->cfg_pool, path);
+		cur_mod->name = g_path_get_basename(cur_mod->path);
+		rspamd_mempool_add_destructor(cfg->cfg_pool, g_free,
+									  cur_mod->name);
+		ext_pos = strstr(cur_mod->name, ".lua");
 
 		if (ext_pos != NULL) {
 			*ext_pos = '\0';
 		}
 
 		if (modules_seen) {
-			seen_mod = g_hash_table_lookup (modules_seen, cur_mod->name);
+			seen_mod = g_hash_table_lookup(modules_seen, cur_mod->name);
 
 			if (seen_mod != NULL) {
-				msg_info_config ("already seen module %s at %s, skip %s",
-						cur_mod->name, seen_mod->path, cur_mod->path);
+				msg_info_config("already seen module %s at %s, skip %s",
+								cur_mod->name, seen_mod->path, cur_mod->path);
 
 				return TRUE;
 			}
 		}
 
 		if (cfg->script_modules == NULL) {
-			cfg->script_modules = g_list_append (cfg->script_modules,
-					cur_mod);
-			rspamd_mempool_add_destructor (cfg->cfg_pool,
-					(rspamd_mempool_destruct_t)g_list_free,
-					cfg->script_modules);
+			cfg->script_modules = g_list_append(cfg->script_modules,
+												cur_mod);
+			rspamd_mempool_add_destructor(cfg->cfg_pool,
+										  (rspamd_mempool_destruct_t) g_list_free,
+										  cfg->script_modules);
 		}
 		else {
-			cfg->script_modules = g_list_append (cfg->script_modules,
-					cur_mod);
+			cfg->script_modules = g_list_append(cfg->script_modules,
+												cur_mod);
 		}
 
 		if (modules_seen) {
-			g_hash_table_insert (modules_seen, cur_mod->name, cur_mod);
+			g_hash_table_insert(modules_seen, cur_mod->name, cur_mod);
 		}
 	}
 
@@ -1023,28 +1028,29 @@ rspamd_rcl_add_lua_plugins_path (struct rspamd_config *cfg,
 }
 
 static gboolean
-rspamd_rcl_modules_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-		const gchar *key, gpointer ud,
-		struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_modules_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+						   const gchar *key, gpointer ud,
+						   struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *val, *cur;
 	struct rspamd_config *cfg = ud;
 	const gchar *data;
 
 	if (obj->type == UCL_OBJECT) {
-		GHashTable *mods_seen = g_hash_table_new (rspamd_strcase_hash,
-				rspamd_strcase_equal);
-		val = ucl_object_lookup (obj, "path");
+		GHashTable *mods_seen = g_hash_table_new(rspamd_strcase_hash,
+												 rspamd_strcase_equal);
+		val = ucl_object_lookup(obj, "path");
 
 		if (val) {
-			LL_FOREACH (val, cur) {
-				if (ucl_object_tostring_safe (cur, &data)) {
-					if (!rspamd_rcl_add_lua_plugins_path (cfg,
-							rspamd_mempool_strdup (cfg->cfg_pool, data),
-							TRUE,
-							mods_seen,
-							err)) {
-						g_hash_table_unref (mods_seen);
+			LL_FOREACH(val, cur)
+			{
+				if (ucl_object_tostring_safe(cur, &data)) {
+					if (!rspamd_rcl_add_lua_plugins_path(cfg,
+														 rspamd_mempool_strdup(cfg->cfg_pool, data),
+														 TRUE,
+														 mods_seen,
+														 err)) {
+						g_hash_table_unref(mods_seen);
 
 						return FALSE;
 					}
@@ -1052,26 +1058,27 @@ rspamd_rcl_modules_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 			}
 		}
 		else {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"path attribute is missing");
-			g_hash_table_unref (mods_seen);
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"path attribute is missing");
+			g_hash_table_unref(mods_seen);
 
 			return FALSE;
 		}
 
-		val = ucl_object_lookup (obj, "fallback_path");
+		val = ucl_object_lookup(obj, "fallback_path");
 
 		if (val) {
-			LL_FOREACH (val, cur) {
-				if (ucl_object_tostring_safe (cur, &data)) {
-					if (!rspamd_rcl_add_lua_plugins_path (cfg,
-							rspamd_mempool_strdup (cfg->cfg_pool, data),
-							FALSE,
-							mods_seen,
-							err)) {
-						g_hash_table_unref (mods_seen);
+			LL_FOREACH(val, cur)
+			{
+				if (ucl_object_tostring_safe(cur, &data)) {
+					if (!rspamd_rcl_add_lua_plugins_path(cfg,
+														 rspamd_mempool_strdup(cfg->cfg_pool, data),
+														 FALSE,
+														 mods_seen,
+														 err)) {
+						g_hash_table_unref(mods_seen);
 
 						return FALSE;
 					}
@@ -1079,17 +1086,18 @@ rspamd_rcl_modules_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 			}
 		}
 
-		val = ucl_object_lookup (obj, "try_path");
+		val = ucl_object_lookup(obj, "try_path");
 
 		if (val) {
-			LL_FOREACH (val, cur) {
-				if (ucl_object_tostring_safe (cur, &data)) {
-					if (!rspamd_rcl_add_lua_plugins_path (cfg,
-							rspamd_mempool_strdup (cfg->cfg_pool, data),
-							FALSE,
-							mods_seen,
-							err)) {
-						g_hash_table_unref (mods_seen);
+			LL_FOREACH(val, cur)
+			{
+				if (ucl_object_tostring_safe(cur, &data)) {
+					if (!rspamd_rcl_add_lua_plugins_path(cfg,
+														 rspamd_mempool_strdup(cfg->cfg_pool, data),
+														 FALSE,
+														 mods_seen,
+														 err)) {
+						g_hash_table_unref(mods_seen);
 
 						return FALSE;
 					}
@@ -1097,19 +1105,19 @@ rspamd_rcl_modules_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 			}
 		}
 
-		g_hash_table_unref (mods_seen);
+		g_hash_table_unref(mods_seen);
 	}
-	else if (ucl_object_tostring_safe (obj, &data)) {
-		if (!rspamd_rcl_add_lua_plugins_path (cfg,
-				rspamd_mempool_strdup (cfg->cfg_pool, data), TRUE, NULL, err)) {
+	else if (ucl_object_tostring_safe(obj, &data)) {
+		if (!rspamd_rcl_add_lua_plugins_path(cfg,
+											 rspamd_mempool_strdup(cfg->cfg_pool, data), TRUE, NULL, err)) {
 			return FALSE;
 		}
 	}
 	else {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"module parameter has wrong type (must be an object or a string)");
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"module parameter has wrong type (must be an object or a string)");
 		return FALSE;
 	}
 
@@ -1122,9 +1130,9 @@ struct statfile_parser_data {
 };
 
 static gboolean
-rspamd_rcl_statfile_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
-		const gchar *key, gpointer ud,
-		struct rspamd_rcl_section *section, GError **err)
+rspamd_rcl_statfile_handler(rspamd_mempool_t *pool, const ucl_object_t *obj,
+							const gchar *key, gpointer ud,
+							struct rspamd_rcl_section *section, GError **err)
 {
 	struct statfile_parser_data *stud = ud;
 	struct rspamd_classifier_config *ccf;
@@ -1133,67 +1141,66 @@ rspamd_rcl_statfile_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 	struct rspamd_statfile_config *st;
 	GList *labels;
 
-	g_assert (key != NULL);
+	g_assert(key != NULL);
 
 	cfg = stud->cfg;
 	ccf = stud->ccf;
 
-	st = rspamd_config_new_statfile (cfg, NULL);
-	st->symbol = rspamd_mempool_strdup (cfg->cfg_pool, key);
+	st = rspamd_config_new_statfile(cfg, NULL);
+	st->symbol = rspamd_mempool_strdup(cfg->cfg_pool, key);
 
-	if (rspamd_rcl_section_parse_defaults (cfg, section, pool, obj, st, err)) {
-		ccf->statfiles = rspamd_mempool_glist_prepend (pool, ccf->statfiles, st);
+	if (rspamd_rcl_section_parse_defaults(cfg, section, pool, obj, st, err)) {
+		ccf->statfiles = rspamd_mempool_glist_prepend(pool, ccf->statfiles, st);
 
 		if (st->label != NULL) {
-			labels = g_hash_table_lookup (ccf->labels, st->label);
+			labels = g_hash_table_lookup(ccf->labels, st->label);
 			if (labels != NULL) {
-				labels = g_list_append (labels, st);
+				labels = g_list_append(labels, st);
 			}
 			else {
-				g_hash_table_insert (ccf->labels, st->label,
-					g_list_prepend (NULL, st));
+				g_hash_table_insert(ccf->labels, st->label,
+									g_list_prepend(NULL, st));
 			}
 		}
 
 		if (st->symbol != NULL) {
-			g_hash_table_insert (cfg->classifiers_symbols, st->symbol, st);
+			g_hash_table_insert(cfg->classifiers_symbols, st->symbol, st);
 		}
 		else {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"statfile must have a symbol defined");
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"statfile must have a symbol defined");
 			return FALSE;
 		}
 
-		st->opts = (ucl_object_t *)obj;
+		st->opts = (ucl_object_t *) obj;
 		st->clcf = ccf;
 
-		val = ucl_object_lookup (obj, "spam");
+		val = ucl_object_lookup(obj, "spam");
 		if (val == NULL) {
-			msg_info_config (
+			msg_info_config(
 				"statfile %s has no explicit 'spam' setting, trying to guess by symbol",
 				st->symbol);
-			if (rspamd_substring_search_caseless (st->symbol,
-					strlen (st->symbol),"spam", 4) != -1) {
+			if (rspamd_substring_search_caseless(st->symbol,
+												 strlen(st->symbol), "spam", 4) != -1) {
 				st->is_spam = TRUE;
 			}
-			else if (rspamd_substring_search_caseless (st->symbol,
-					strlen (st->symbol),"ham", 3) != -1) {
+			else if (rspamd_substring_search_caseless(st->symbol,
+													  strlen(st->symbol), "ham", 3) != -1) {
 				st->is_spam = FALSE;
 			}
 			else {
-				g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot guess spam setting from %s",
-					st->symbol);
+				g_set_error(err,
+							CFG_RCL_ERROR,
+							EINVAL,
+							"cannot guess spam setting from %s",
+							st->symbol);
 				return FALSE;
 			}
-			msg_info_config ("guessed that statfile with symbol %s is %s",
-				st->symbol,
-				st->is_spam ?
-				"spam" : "ham");
+			msg_info_config("guessed that statfile with symbol %s is %s",
+							st->symbol,
+							st->is_spam ? "spam" : "ham");
 		}
 		return TRUE;
 	}
@@ -1202,12 +1209,12 @@ rspamd_rcl_statfile_handler (rspamd_mempool_t *pool, const ucl_object_t *obj,
 }
 
 static gboolean
-rspamd_rcl_classifier_handler (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	const gchar *key,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_classifier_handler(rspamd_mempool_t *pool,
+							  const ucl_object_t *obj,
+							  const gchar *key,
+							  gpointer ud,
+							  struct rspamd_rcl_section *section,
+							  GError **err)
 {
 	const ucl_object_t *val, *cur;
 	ucl_object_iter_t it = NULL;
@@ -1220,15 +1227,15 @@ rspamd_rcl_classifier_handler (rspamd_mempool_t *pool,
 	struct rspamd_tokenizer_config *tkcf = NULL;
 	lua_State *L = cfg->lua_state;
 
-	g_assert (key != NULL);
-	ccf = rspamd_config_new_classifier (cfg, NULL);
+	g_assert(key != NULL);
+	ccf = rspamd_config_new_classifier(cfg, NULL);
 
-	ccf->classifier = rspamd_mempool_strdup (cfg->cfg_pool, key);
+	ccf->classifier = rspamd_mempool_strdup(cfg->cfg_pool, key);
 
-	if (rspamd_rcl_section_parse_defaults (cfg, section, cfg->cfg_pool, obj,
-			ccf, err)) {
+	if (rspamd_rcl_section_parse_defaults(cfg, section, cfg->cfg_pool, obj,
+										  ccf, err)) {
 
-		HASH_FIND_STR (section->subsections, "statfile", stat_section);
+		HASH_FIND_STR(section->subsections, "statfile", stat_section);
 
 		if (ccf->classifier == NULL) {
 			ccf->classifier = "bayes";
@@ -1238,42 +1245,43 @@ rspamd_rcl_classifier_handler (rspamd_mempool_t *pool,
 			ccf->name = ccf->classifier;
 		}
 
-		it = ucl_object_iterate_new (obj);
+		it = ucl_object_iterate_new(obj);
 
-		while ((val = ucl_object_iterate_safe (it, true)) != NULL && res) {
-			st_key = ucl_object_key (val);
+		while ((val = ucl_object_iterate_safe(it, true)) != NULL && res) {
+			st_key = ucl_object_key(val);
 
 			if (st_key != NULL) {
-				if (g_ascii_strcasecmp (st_key, "statfile") == 0) {
-					LL_FOREACH (val, cur) {
+				if (g_ascii_strcasecmp(st_key, "statfile") == 0) {
+					LL_FOREACH(val, cur)
+					{
 						stud.cfg = cfg;
 						stud.ccf = ccf;
-						res = rspamd_rcl_process_section (cfg, stat_section, &stud,
-								cur, cfg->cfg_pool, err);
+						res = rspamd_rcl_process_section(cfg, stat_section, &stud,
+														 cur, cfg->cfg_pool, err);
 
 						if (!res) {
-							ucl_object_iterate_free (it);
+							ucl_object_iterate_free(it);
 
 							return FALSE;
 						}
 					}
 				}
-				else if (g_ascii_strcasecmp (st_key, "tokenizer") == 0) {
-					tkcf = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (*tkcf));
+				else if (g_ascii_strcasecmp(st_key, "tokenizer") == 0) {
+					tkcf = rspamd_mempool_alloc0(cfg->cfg_pool, sizeof(*tkcf));
 
-					if (ucl_object_type (val) == UCL_STRING) {
-						tkcf->name = ucl_object_tostring (val);
+					if (ucl_object_type(val) == UCL_STRING) {
+						tkcf->name = ucl_object_tostring(val);
 					}
-					else if (ucl_object_type (val) == UCL_OBJECT) {
-						cur = ucl_object_lookup (val, "name");
+					else if (ucl_object_type(val) == UCL_OBJECT) {
+						cur = ucl_object_lookup(val, "name");
 						if (cur != NULL) {
-							tkcf->name = ucl_object_tostring (cur);
+							tkcf->name = ucl_object_tostring(cur);
 							tkcf->opts = val;
 						}
 						else {
-							cur = ucl_object_lookup (val, "type");
+							cur = ucl_object_lookup(val, "type");
 							if (cur != NULL) {
-								tkcf->name = ucl_object_tostring (cur);
+								tkcf->name = ucl_object_tostring(cur);
 								tkcf->opts = val;
 							}
 						}
@@ -1282,25 +1290,25 @@ rspamd_rcl_classifier_handler (rspamd_mempool_t *pool,
 			}
 		}
 
-		ucl_object_iterate_free (it);
+		ucl_object_iterate_free(it);
 	}
 	else {
-		msg_err_config ("fatal configuration error, cannot parse statfile definition");
+		msg_err_config("fatal configuration error, cannot parse statfile definition");
 	}
 
 	if (tkcf == NULL) {
-		tkcf = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (*tkcf));
+		tkcf = rspamd_mempool_alloc0(cfg->cfg_pool, sizeof(*tkcf));
 		tkcf->name = NULL;
-
 	}
 
 	ccf->tokenizer = tkcf;
 
 	/* Handle lua conditions */
-	val = ucl_object_lookup_any (obj, "learn_condition", NULL);
+	val = ucl_object_lookup_any(obj, "learn_condition", NULL);
 
 	if (val) {
-		LL_FOREACH (val, cur) {
+		LL_FOREACH(val, cur)
+		{
 			if (ucl_object_type(cur) == UCL_STRING) {
 				const gchar *lua_script;
 				gsize slen;
@@ -1308,7 +1316,7 @@ rspamd_rcl_classifier_handler (rspamd_mempool_t *pool,
 
 				lua_script = ucl_object_tolstring(cur, &slen);
 				ref_idx = rspamd_lua_function_ref_from_str(L,
-						lua_script, slen, "learn_condition", err);
+														   lua_script, slen, "learn_condition", err);
 
 				if (ref_idx == LUA_NOREF) {
 					return FALSE;
@@ -1316,17 +1324,18 @@ rspamd_rcl_classifier_handler (rspamd_mempool_t *pool,
 
 				rspamd_lua_add_ref_dtor(L, cfg->cfg_pool, ref_idx);
 				ccf->learn_conditions = rspamd_mempool_glist_append(
-						cfg->cfg_pool,
-						ccf->learn_conditions,
-						GINT_TO_POINTER (ref_idx));
+					cfg->cfg_pool,
+					ccf->learn_conditions,
+					GINT_TO_POINTER(ref_idx));
 			}
 		}
 	}
 
-	val = ucl_object_lookup_any (obj, "classify_condition", NULL);
+	val = ucl_object_lookup_any(obj, "classify_condition", NULL);
 
 	if (val) {
-		LL_FOREACH (val, cur) {
+		LL_FOREACH(val, cur)
+		{
 			if (ucl_object_type(cur) == UCL_STRING) {
 				const gchar *lua_script;
 				gsize slen;
@@ -1334,92 +1343,92 @@ rspamd_rcl_classifier_handler (rspamd_mempool_t *pool,
 
 				lua_script = ucl_object_tolstring(cur, &slen);
 				ref_idx = rspamd_lua_function_ref_from_str(L,
-						lua_script, slen, "classify_condition", err);
+														   lua_script, slen, "classify_condition", err);
 
 				if (ref_idx == LUA_NOREF) {
 					return FALSE;
 				}
 
-				rspamd_lua_add_ref_dtor (L, cfg->cfg_pool, ref_idx);
+				rspamd_lua_add_ref_dtor(L, cfg->cfg_pool, ref_idx);
 				ccf->classify_conditions = rspamd_mempool_glist_append(
-						cfg->cfg_pool,
-						ccf->classify_conditions,
-						GINT_TO_POINTER (ref_idx));
+					cfg->cfg_pool,
+					ccf->classify_conditions,
+					GINT_TO_POINTER(ref_idx));
 			}
 		}
 	}
 
-	ccf->opts = (ucl_object_t *)obj;
-	cfg->classifiers = g_list_prepend (cfg->classifiers, ccf);
+	ccf->opts = (ucl_object_t *) obj;
+	cfg->classifiers = g_list_prepend(cfg->classifiers, ccf);
 
 	return res;
 }
 
 static gboolean
-rspamd_rcl_composite_handler (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	const gchar *key,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_composite_handler(rspamd_mempool_t *pool,
+							 const ucl_object_t *obj,
+							 const gchar *key,
+							 gpointer ud,
+							 struct rspamd_rcl_section *section,
+							 GError **err)
 {
 	struct rspamd_config *cfg = ud;
 	void *composite;
 	const gchar *composite_name;
 
-	g_assert (key != NULL);
+	g_assert(key != NULL);
 
 	composite_name = key;
 
 	const ucl_object_t *val = ucl_object_lookup(obj, "enabled");
 	if (val != NULL && !ucl_object_toboolean(val)) {
-		msg_info_config ("composite %s is disabled", composite_name);
+		msg_info_config("composite %s is disabled", composite_name);
 		return TRUE;
 	}
 
 	if ((composite = rspamd_composites_manager_add_from_ucl(cfg->composites_manager,
-			composite_name, obj)) != NULL) {
-		rspamd_symcache_add_symbol (cfg->cache, composite_name, 0,
-				NULL, composite, SYMBOL_TYPE_COMPOSITE, -1);
+															composite_name, obj)) != NULL) {
+		rspamd_symcache_add_symbol(cfg->cache, composite_name, 0,
+								   NULL, composite, SYMBOL_TYPE_COMPOSITE, -1);
 	}
 
 	return composite != NULL;
 }
 
 static gboolean
-rspamd_rcl_composites_handler (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	const gchar *key,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_composites_handler(rspamd_mempool_t *pool,
+							  const ucl_object_t *obj,
+							  const gchar *key,
+							  gpointer ud,
+							  struct rspamd_rcl_section *section,
+							  GError **err)
 {
 	ucl_object_iter_t it = NULL;
 	const ucl_object_t *cur;
 	gboolean success = TRUE;
 
-	it = ucl_object_iterate_new (obj);
+	it = ucl_object_iterate_new(obj);
 
-	while ((cur = ucl_object_iterate_safe (it, true))) {
+	while ((cur = ucl_object_iterate_safe(it, true))) {
 		success = rspamd_rcl_composite_handler(pool, cur,
-				ucl_object_key(cur), ud, section, err);
+											   ucl_object_key(cur), ud, section, err);
 		if (!success) {
 			break;
 		}
 	}
 
-	ucl_object_iterate_free (it);
+	ucl_object_iterate_free(it);
 
 	return success;
 }
 
 static gboolean
-rspamd_rcl_neighbours_handler (rspamd_mempool_t *pool,
-		const ucl_object_t *obj,
-		const gchar *key,
-		gpointer ud,
-		struct rspamd_rcl_section *section,
-		GError **err)
+rspamd_rcl_neighbours_handler(rspamd_mempool_t *pool,
+							  const ucl_object_t *obj,
+							  const gchar *key,
+							  gpointer ud,
+							  struct rspamd_rcl_section *section,
+							  GError **err)
 {
 	struct rspamd_config *cfg = ud;
 	const ucl_object_t *hostval, *pathval;
@@ -1429,76 +1438,76 @@ rspamd_rcl_neighbours_handler (rspamd_mempool_t *pool,
 	const gchar *p;
 
 	if (key == NULL) {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"missing name for neighbour");
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"missing name for neighbour");
 		return FALSE;
 	}
 
-	hostval = ucl_object_lookup (obj, "host");
+	hostval = ucl_object_lookup(obj, "host");
 
-	if (hostval == NULL || ucl_object_type (hostval) != UCL_STRING) {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"missing host for neighbour: %s", ucl_object_key (obj));
+	if (hostval == NULL || ucl_object_type(hostval) != UCL_STRING) {
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"missing host for neighbour: %s", ucl_object_key(obj));
 		return FALSE;
 	}
 
-	neigh = ucl_object_typed_new (UCL_OBJECT);
-	ucl_object_insert_key (neigh, ucl_object_copy (hostval), "host", 0, false);
+	neigh = ucl_object_typed_new(UCL_OBJECT);
+	ucl_object_insert_key(neigh, ucl_object_copy(hostval), "host", 0, false);
 
-	if ((p = strrchr (ucl_object_tostring (hostval), ':')) != NULL) {
-		if (g_ascii_isdigit (p[1])) {
+	if ((p = strrchr(ucl_object_tostring(hostval), ':')) != NULL) {
+		if (g_ascii_isdigit(p[1])) {
 			has_port = TRUE;
 		}
 	}
 
-	if (strstr (ucl_object_tostring (hostval), "://") != NULL) {
+	if (strstr(ucl_object_tostring(hostval), "://") != NULL) {
 		has_proto = TRUE;
 	}
 
 	/* Now make url */
-	urlstr = g_string_sized_new (63);
-	pathval = ucl_object_lookup (obj, "path");
+	urlstr = g_string_sized_new(63);
+	pathval = ucl_object_lookup(obj, "path");
 
 	if (!has_proto) {
-		g_string_append_len (urlstr, "http://", sizeof ("http://") - 1);
+		g_string_append_len(urlstr, "http://", sizeof("http://") - 1);
 	}
 
-	g_string_append (urlstr, ucl_object_tostring (hostval));
+	g_string_append(urlstr, ucl_object_tostring(hostval));
 
 	if (!has_port) {
-		g_string_append (urlstr, ":11334");
+		g_string_append(urlstr, ":11334");
 	}
 
 	if (pathval == NULL) {
-		g_string_append (urlstr, "/");
+		g_string_append(urlstr, "/");
 	}
 	else {
-		g_string_append (urlstr,  ucl_object_tostring (pathval));
+		g_string_append(urlstr, ucl_object_tostring(pathval));
 	}
 
-	ucl_object_insert_key (neigh,
-			ucl_object_fromlstring (urlstr->str, urlstr->len),
-			"url", 0, false);
-	g_string_free (urlstr, TRUE);
-	ucl_object_insert_key (cfg->neighbours, neigh, key, 0, true);
+	ucl_object_insert_key(neigh,
+						  ucl_object_fromlstring(urlstr->str, urlstr->len),
+						  "url", 0, false);
+	g_string_free(urlstr, TRUE);
+	ucl_object_insert_key(cfg->neighbours, neigh, key, 0, true);
 
 	return TRUE;
 }
 
 
 struct rspamd_rcl_section *
-rspamd_rcl_add_section (struct rspamd_rcl_section **top,
-	const gchar *name, const gchar *key_attr, rspamd_rcl_handler_t handler,
-	enum ucl_type type, gboolean required, gboolean strict_type)
+rspamd_rcl_add_section(struct rspamd_rcl_section **top,
+					   const gchar *name, const gchar *key_attr, rspamd_rcl_handler_t handler,
+					   enum ucl_type type, gboolean required, gboolean strict_type)
 {
 	struct rspamd_rcl_section *new;
 	ucl_object_t *parent_doc;
 
-	new = g_malloc0 (sizeof (struct rspamd_rcl_section));
+	new = g_malloc0(sizeof(struct rspamd_rcl_section));
 	new->name = name;
 	new->key_attr = key_attr;
 	new->handler = handler;
@@ -1511,83 +1520,82 @@ rspamd_rcl_add_section (struct rspamd_rcl_section **top,
 	}
 	else {
 		parent_doc = (*top)->doc_ref;
-		new->doc_ref = ucl_object_ref (rspamd_rcl_add_doc_obj (parent_doc,
-				NULL,
-				name,
-				type,
-				NULL,
-				0,
-				NULL,
-				0));
+		new->doc_ref = ucl_object_ref(rspamd_rcl_add_doc_obj(parent_doc,
+															 NULL,
+															 name,
+															 type,
+															 NULL,
+															 0,
+															 NULL,
+															 0));
 	}
 
-	HASH_ADD_KEYPTR (hh, *top, new->name, strlen (new->name), new);
+	HASH_ADD_KEYPTR(hh, *top, new->name, strlen(new->name), new);
 	return new;
 }
 
 struct rspamd_rcl_section *
-rspamd_rcl_add_section_doc (struct rspamd_rcl_section **top,
-		const gchar *name, const gchar *key_attr, rspamd_rcl_handler_t handler,
-		enum ucl_type type, gboolean required, gboolean strict_type,
-		ucl_object_t *doc_target,
-		const gchar *doc_string)
+rspamd_rcl_add_section_doc(struct rspamd_rcl_section **top,
+						   const gchar *name, const gchar *key_attr, rspamd_rcl_handler_t handler,
+						   enum ucl_type type, gboolean required, gboolean strict_type,
+						   ucl_object_t *doc_target,
+						   const gchar *doc_string)
 {
 	struct rspamd_rcl_section *new_section;
 
-	new_section = g_malloc0 (sizeof (struct rspamd_rcl_section));
+	new_section = g_malloc0(sizeof(struct rspamd_rcl_section));
 	new_section->name = name;
 	new_section->key_attr = key_attr;
 	new_section->handler = handler;
 	new_section->type = type;
 	new_section->strict_type = strict_type;
 
-	new_section->doc_ref =  ucl_object_ref (rspamd_rcl_add_doc_obj (doc_target,
-			doc_string,
-			name,
-			type,
-			NULL,
-			0,
-			NULL,
-			0));
+	new_section->doc_ref = ucl_object_ref(rspamd_rcl_add_doc_obj(doc_target,
+																 doc_string,
+																 name,
+																 type,
+																 NULL,
+																 0,
+																 NULL,
+																 0));
 
-	HASH_ADD_KEYPTR (hh, *top, new_section->name, strlen (new_section->name), new_section);
+	HASH_ADD_KEYPTR(hh, *top, new_section->name, strlen(new_section->name), new_section);
 	return new_section;
 }
 
 struct rspamd_rcl_default_handler_data *
-rspamd_rcl_add_default_handler (struct rspamd_rcl_section *section,
-		const gchar *name,
-		rspamd_rcl_default_handler_t handler,
-		goffset offset,
-		gint flags,
-		const gchar *doc_string)
+rspamd_rcl_add_default_handler(struct rspamd_rcl_section *section,
+							   const gchar *name,
+							   rspamd_rcl_default_handler_t handler,
+							   goffset offset,
+							   gint flags,
+							   const gchar *doc_string)
 {
 	struct rspamd_rcl_default_handler_data *nhandler;
 
-	nhandler = g_malloc0 (sizeof (struct rspamd_rcl_default_handler_data));
-	nhandler->key = g_strdup (name);
+	nhandler = g_malloc0(sizeof(struct rspamd_rcl_default_handler_data));
+	nhandler->key = g_strdup(name);
 	nhandler->handler = handler;
 	nhandler->pd.offset = offset;
 	nhandler->pd.flags = flags;
 
 	if (section->doc_ref != NULL) {
-		rspamd_rcl_add_doc_obj (section->doc_ref,
-				doc_string,
-				name,
-				UCL_NULL,
-				handler,
-				flags,
-				NULL,
-				0);
-	}
-
-	HASH_ADD_KEYPTR (hh, section->default_parser, nhandler->key, strlen (
-			nhandler->key), nhandler);
+		rspamd_rcl_add_doc_obj(section->doc_ref,
+							   doc_string,
+							   name,
+							   UCL_NULL,
+							   handler,
+							   flags,
+							   NULL,
+							   0);
+	}
+
+	HASH_ADD_KEYPTR(hh, section->default_parser, nhandler->key, strlen(nhandler->key), nhandler);
 	return nhandler;
 }
 
 struct rspamd_rcl_section *
-rspamd_rcl_config_init (struct rspamd_config *cfg, GHashTable *skip_sections)
+rspamd_rcl_config_init(struct rspamd_config *cfg, GHashTable *skip_sections)
 {
 	struct rspamd_rcl_section *new = NULL, *sub, *ssub;
 
@@ -1600,895 +1608,895 @@ rspamd_rcl_config_init (struct rspamd_config *cfg, GHashTable *skip_sections)
 	/**
 	 * Logging section
 	 */
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "logging"))) {
-		sub = rspamd_rcl_add_section_doc (&new,
-				"logging", NULL,
-				rspamd_rcl_logging_handler,
-				UCL_OBJECT,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"Configure rspamd logging");
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "logging"))) {
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "logging", NULL,
+										 rspamd_rcl_logging_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "Configure rspamd logging");
 		/* Default handlers */
-		rspamd_rcl_add_default_handler (sub,
-				"log_buffer",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, log_buf_size),
-				RSPAMD_CL_FLAG_INT_32,
-				"Size of log buffer in bytes (for file logging)");
-		rspamd_rcl_add_default_handler (sub,
-				"log_urls",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, log_urls),
-				0,
-				"Write each URL found in a message to the log file");
-		rspamd_rcl_add_default_handler (sub,
-				"debug_ip",
-				rspamd_rcl_parse_struct_ucl,
-				G_STRUCT_OFFSET (struct rspamd_config, debug_ip_map),
-				0,
-				"Enable debugging log for the specified IP addresses");
-		rspamd_rcl_add_default_handler (sub,
-				"debug_modules",
-				rspamd_rcl_parse_struct_string_list,
-				G_STRUCT_OFFSET (struct rspamd_config, debug_modules),
-				RSPAMD_CL_FLAG_STRING_LIST_HASH,
-				"Enable debugging for the specified modules");
-		rspamd_rcl_add_default_handler (sub,
-				"log_format",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, log_format_str),
-				0,
-				"Specify format string for the task logging output "
-				"(https://rspamd.com/doc/configuration/logging.html "
-				"for details)");
-		rspamd_rcl_add_default_handler (sub,
-				"encryption_key",
-				rspamd_rcl_parse_struct_pubkey,
-				G_STRUCT_OFFSET (struct rspamd_config, log_encryption_key),
-				0,
-				"Encrypt sensitive information in logs using this pubkey");
-		rspamd_rcl_add_default_handler (sub,
-				"error_elts",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, log_error_elts),
-				RSPAMD_CL_FLAG_UINT,
-				"Size of circular buffer for last errors (10 by default)");
-		rspamd_rcl_add_default_handler (sub,
-				"error_maxlen",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, log_error_elt_maxlen),
-				RSPAMD_CL_FLAG_UINT,
-				"Size of each element in error log buffer (1000 by default)");
+		rspamd_rcl_add_default_handler(sub,
+									   "log_buffer",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, log_buf_size),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Size of log buffer in bytes (for file logging)");
+		rspamd_rcl_add_default_handler(sub,
+									   "log_urls",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, log_urls),
+									   0,
+									   "Write each URL found in a message to the log file");
+		rspamd_rcl_add_default_handler(sub,
+									   "debug_ip",
+									   rspamd_rcl_parse_struct_ucl,
+									   G_STRUCT_OFFSET(struct rspamd_config, debug_ip_map),
+									   0,
+									   "Enable debugging log for the specified IP addresses");
+		rspamd_rcl_add_default_handler(sub,
+									   "debug_modules",
+									   rspamd_rcl_parse_struct_string_list,
+									   G_STRUCT_OFFSET(struct rspamd_config, debug_modules),
+									   RSPAMD_CL_FLAG_STRING_LIST_HASH,
+									   "Enable debugging for the specified modules");
+		rspamd_rcl_add_default_handler(sub,
+									   "log_format",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, log_format_str),
+									   0,
+									   "Specify format string for the task logging output "
+									   "(https://rspamd.com/doc/configuration/logging.html "
+									   "for details)");
+		rspamd_rcl_add_default_handler(sub,
+									   "encryption_key",
+									   rspamd_rcl_parse_struct_pubkey,
+									   G_STRUCT_OFFSET(struct rspamd_config, log_encryption_key),
+									   0,
+									   "Encrypt sensitive information in logs using this pubkey");
+		rspamd_rcl_add_default_handler(sub,
+									   "error_elts",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, log_error_elts),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Size of circular buffer for last errors (10 by default)");
+		rspamd_rcl_add_default_handler(sub,
+									   "error_maxlen",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, log_error_elt_maxlen),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Size of each element in error log buffer (1000 by default)");
 
 		/* Documentation only options, handled in log_handler to map flags */
-		rspamd_rcl_add_doc_by_path (cfg,
-				"logging",
-				"Enable colored output (for console logging)",
-				"log_color",
-				UCL_BOOLEAN,
-				NULL,
-				0,
-				NULL,
-				0);
-		rspamd_rcl_add_doc_by_path (cfg,
-				"logging",
-				"Enable severity logging output (e.g. [error] or [warning])",
-				"log_severity",
-				UCL_BOOLEAN,
-				NULL,
-				0,
-				NULL,
-				0);
-		rspamd_rcl_add_doc_by_path (cfg,
-				"logging",
-				"Enable systemd compatible logging",
-				"systemd",
-				UCL_BOOLEAN,
-				NULL,
-				0,
-				NULL,
-				0);
-		rspamd_rcl_add_doc_by_path (cfg,
-				"logging",
-				"Write statistics of regexp processing to log (useful for hyperscan)",
-				"log_re_cache",
-				UCL_BOOLEAN,
-				NULL,
-				0,
-				NULL,
-				0);
-		rspamd_rcl_add_doc_by_path (cfg,
-				"logging",
-				"Use microseconds resolution for timestamps",
-				"log_usec",
-				UCL_BOOLEAN,
-				NULL,
-				0,
-				NULL,
-				0);
-	}
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "options"))) {
+		rspamd_rcl_add_doc_by_path(cfg,
+								   "logging",
+								   "Enable colored output (for console logging)",
+								   "log_color",
+								   UCL_BOOLEAN,
+								   NULL,
+								   0,
+								   NULL,
+								   0);
+		rspamd_rcl_add_doc_by_path(cfg,
+								   "logging",
+								   "Enable severity logging output (e.g. [error] or [warning])",
+								   "log_severity",
+								   UCL_BOOLEAN,
+								   NULL,
+								   0,
+								   NULL,
+								   0);
+		rspamd_rcl_add_doc_by_path(cfg,
+								   "logging",
+								   "Enable systemd compatible logging",
+								   "systemd",
+								   UCL_BOOLEAN,
+								   NULL,
+								   0,
+								   NULL,
+								   0);
+		rspamd_rcl_add_doc_by_path(cfg,
+								   "logging",
+								   "Write statistics of regexp processing to log (useful for hyperscan)",
+								   "log_re_cache",
+								   UCL_BOOLEAN,
+								   NULL,
+								   0,
+								   NULL,
+								   0);
+		rspamd_rcl_add_doc_by_path(cfg,
+								   "logging",
+								   "Use microseconds resolution for timestamps",
+								   "log_usec",
+								   UCL_BOOLEAN,
+								   NULL,
+								   0,
+								   NULL,
+								   0);
+	}
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "options"))) {
 		/**
 		 * Options section
 		 */
-		sub = rspamd_rcl_add_section_doc (&new,
-				"options", NULL,
-				rspamd_rcl_options_handler,
-				UCL_OBJECT,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"Global rspamd options");
-		rspamd_rcl_add_default_handler (sub,
-				"cache_file",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, cache_filename),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to the cache file");
-		rspamd_rcl_add_default_handler (sub,
-				"cache_reload",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, cache_reload_time),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"How often cache reload should be performed");
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "options", NULL,
+										 rspamd_rcl_options_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "Global rspamd options");
+		rspamd_rcl_add_default_handler(sub,
+									   "cache_file",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, cache_filename),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to the cache file");
+		rspamd_rcl_add_default_handler(sub,
+									   "cache_reload",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, cache_reload_time),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "How often cache reload should be performed");
 		/* Old DNS configuration */
-		rspamd_rcl_add_default_handler (sub,
-				"dns_nameserver",
-				rspamd_rcl_parse_struct_ucl,
-				G_STRUCT_OFFSET (struct rspamd_config, nameservers),
-				0,
-				"Legacy option for DNS servers used");
-		rspamd_rcl_add_default_handler (sub,
-				"dns_timeout",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, dns_timeout),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Legacy option for DNS request timeout");
-		rspamd_rcl_add_default_handler (sub,
-				"dns_retransmits",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, dns_retransmits),
-				RSPAMD_CL_FLAG_INT_32,
-				"Legacy option for DNS retransmits count");
-		rspamd_rcl_add_default_handler (sub,
-				"dns_sockets",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, dns_io_per_server),
-				RSPAMD_CL_FLAG_INT_32,
-				"Legacy option for DNS sockets per server count");
-		rspamd_rcl_add_default_handler (sub,
-				"dns_max_requests",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, dns_max_requests),
-				RSPAMD_CL_FLAG_INT_32,
-				"Maximum DNS requests per task (default: 64)");
-		rspamd_rcl_add_default_handler (sub,
-				"control_socket",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, control_socket_path),
-				0,
-				"Path to the control socket");
-		rspamd_rcl_add_default_handler (sub,
-				"explicit_modules",
-				rspamd_rcl_parse_struct_string_list,
-				G_STRUCT_OFFSET (struct rspamd_config, explicit_modules),
-				RSPAMD_CL_FLAG_STRING_LIST_HASH,
-				"Always load these modules even if they are not configured explicitly");
-		rspamd_rcl_add_default_handler (sub,
-				"allow_raw_input",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, allow_raw_input),
-				0,
-				"Allow non MIME input for rspamd");
-		rspamd_rcl_add_default_handler (sub,
-				"one_shot",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, one_shot_mode),
-				0,
-				"Add all symbols only once per message");
-		rspamd_rcl_add_default_handler (sub,
-				"check_attachements",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, check_text_attachements),
-				0,
-				"Treat text attachments as normal text parts");
-		rspamd_rcl_add_default_handler (sub,
-				"tempdir",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, temp_dir),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Directory for temporary files");
-		rspamd_rcl_add_default_handler (sub,
-				"pidfile",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, pid_file),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to the pid file");
-		rspamd_rcl_add_default_handler (sub,
-				"filters",
-				rspamd_rcl_parse_struct_string_list,
-				G_STRUCT_OFFSET (struct rspamd_config, filters),
-				0,
-				"List of internal filters enabled");
-		rspamd_rcl_add_default_handler (sub,
-				"map_watch_interval",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, map_timeout),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Interval for checking maps");
-		rspamd_rcl_add_default_handler (sub,
-				"map_file_watch_multiplier",
-				rspamd_rcl_parse_struct_double,
-				G_STRUCT_OFFSET (struct rspamd_config, map_file_watch_multiplier),
-				0,
-				"Multiplier for map watch interval when map is file");
-		rspamd_rcl_add_default_handler (sub,
-				"maps_cache_dir",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, maps_cache_dir),
-				0,
-				"Directory to save maps cached data (default: $DBDIR)");
-		rspamd_rcl_add_default_handler (sub,
-				"monitoring_watch_interval",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, monitored_interval),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Interval for checking monitored instances");
-		rspamd_rcl_add_default_handler (sub,
-				"disable_monitoring",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, disable_monitored),
-				0,
-				"Disable monitoring completely");
-		rspamd_rcl_add_default_handler (sub,
-				"fips_mode",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, fips_mode),
-				0,
-				"Enable FIPS 140-2 mode in OpenSSL");
-		rspamd_rcl_add_default_handler (sub,
-				"dynamic_conf",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, dynamic_conf),
-				0,
-				"Path to the dynamic configuration");
-		rspamd_rcl_add_default_handler (sub,
-				"rrd",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, rrd_file),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to RRD file");
-		rspamd_rcl_add_default_handler (sub,
-				"stats_file",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, stats_file),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to stats file");
-		rspamd_rcl_add_default_handler (sub,
-				"history_file",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, history_file),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to history file");
-		rspamd_rcl_add_default_handler (sub,
-				"check_all_filters",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, check_all_filters),
-				0,
-				"Always check all filters");
-		rspamd_rcl_add_default_handler (sub,
-				"public_groups_only",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, public_groups_only),
-				0,
-				"Output merely public groups everywhere");
-		rspamd_rcl_add_default_handler (sub,
-				"enable_test_patterns",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, enable_test_patterns),
-				0,
-				"Enable test GTUBE like patterns (not for production!)");
-		rspamd_rcl_add_default_handler (sub,
-				"enable_css_parser",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, enable_css_parser),
-				0,
-				"Enable CSS parser (experimental)");
-		rspamd_rcl_add_default_handler (sub,
-				"enable_experimental",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, enable_experimental),
-				0,
-				"Enable experimental plugins");
-		rspamd_rcl_add_default_handler (sub,
-				"disable_pcre_jit",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, disable_pcre_jit),
-				0,
-				"Disable PCRE JIT");
-		rspamd_rcl_add_default_handler (sub,
-				"min_word_len",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, min_word_len),
-				RSPAMD_CL_FLAG_UINT,
-				"Minimum length of the word to be considered in statistics/fuzzy");
-		rspamd_rcl_add_default_handler (sub,
-				"max_word_len",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_word_len),
-				RSPAMD_CL_FLAG_UINT,
-				"Maximum length of the word to be considered in statistics/fuzzy");
-		rspamd_rcl_add_default_handler (sub,
-			"max_html_len",
-			rspamd_rcl_parse_struct_integer,
-			G_STRUCT_OFFSET (struct rspamd_config, max_word_len),
-			RSPAMD_CL_FLAG_INT_SIZE,
-			"Maximum length of the html part to be parsed");
-		rspamd_rcl_add_default_handler (sub,
-				"words_decay",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, words_decay),
-				RSPAMD_CL_FLAG_UINT,
-				"Start skipping words at this amount");
-		rspamd_rcl_add_default_handler (sub,
-				"url_tld",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, tld_file),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to the TLD file for urls detector");
-		rspamd_rcl_add_default_handler (sub,
-				"tld",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, tld_file),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to the TLD file for urls detector");
-		rspamd_rcl_add_default_handler (sub,
-				"hs_cache_dir",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, hs_cache_dir),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path directory where rspamd would save hyperscan cache");
-		rspamd_rcl_add_default_handler (sub,
-				"history_rows",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, history_rows),
-				RSPAMD_CL_FLAG_UINT,
-				"Number of records in the history file");
-		rspamd_rcl_add_default_handler (sub,
-				"disable_hyperscan",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, disable_hyperscan),
-				0,
-				"Disable hyperscan optimizations for regular expressions");
-		rspamd_rcl_add_default_handler (sub,
-				"vectorized_hyperscan",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, vectorized_hyperscan),
-				0,
-				"Use hyperscan in vectorized mode (obsoleted, do not use)");
-		rspamd_rcl_add_default_handler (sub,
-				"cores_dir",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, cores_dir),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to the directory where rspamd core files are intended to be dumped");
-		rspamd_rcl_add_default_handler (sub,
-				"max_cores_size",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_cores_size),
-				RSPAMD_CL_FLAG_INT_SIZE,
-				"Limit of joint size of all files in `cores_dir`");
-		rspamd_rcl_add_default_handler (sub,
-				"max_cores_count",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_cores_count),
-				RSPAMD_CL_FLAG_INT_SIZE,
-				"Limit of files count in `cores_dir`");
-		rspamd_rcl_add_default_handler (sub,
-				"local_addrs",
-				rspamd_rcl_parse_struct_ucl,
-				G_STRUCT_OFFSET (struct rspamd_config, local_addrs),
-				0,
-				"Use the specified addresses as local ones");
-		rspamd_rcl_add_default_handler (sub,
-				"local_networks",
-				rspamd_rcl_parse_struct_ucl,
-				G_STRUCT_OFFSET (struct rspamd_config, local_addrs),
-				0,
-				"Use the specified addresses as local ones (alias for `local_addrs`)");
-		rspamd_rcl_add_default_handler (sub,
-				"trusted_keys",
-				rspamd_rcl_parse_struct_string_list,
-				G_STRUCT_OFFSET (struct rspamd_config, trusted_keys),
-				RSPAMD_CL_FLAG_STRING_LIST_HASH,
-				"List of trusted public keys used for signatures in base32 encoding");
-		rspamd_rcl_add_default_handler (sub,
-				"enable_shutdown_workaround",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, enable_shutdown_workaround),
-				0,
-				"Enable workaround for legacy clients");
-		rspamd_rcl_add_default_handler (sub,
-				"ignore_received",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, ignore_received),
-				0,
-				"Ignore data from the first received header");
-		rspamd_rcl_add_default_handler (sub,
-				"ssl_ca_path",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, ssl_ca_path),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Path to ssl CA file");
-		rspamd_rcl_add_default_handler (sub,
-				"ssl_ciphers",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, ssl_ciphers),
-				0,
-				"List of ssl ciphers (e.g. HIGH:!aNULL:!kRSA:!PSK:!SRP:!MD5:!RC4)");
-		rspamd_rcl_add_default_handler (sub,
-				"max_message",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_message),
-				RSPAMD_CL_FLAG_INT_SIZE,
-				"Maximum size of the message to be scanned (50Mb by default)");
-		rspamd_rcl_add_default_handler (sub,
-				"max_pic",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_pic_size),
-				RSPAMD_CL_FLAG_INT_SIZE,
-				"Maximum size of the picture to be normalized (1Mb by default)");
-		rspamd_rcl_add_default_handler (sub,
-				"images_cache",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_pic_size),
-				RSPAMD_CL_FLAG_INT_SIZE,
-				"Size of DCT data cache for images (256 elements by default)");
-		rspamd_rcl_add_default_handler (sub,
-				"zstd_input_dictionary",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, zstd_input_dictionary),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Dictionary for zstd inbound protocol compression");
-		rspamd_rcl_add_default_handler (sub,
-				"zstd_output_dictionary",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, zstd_output_dictionary),
-				RSPAMD_CL_FLAG_STRING_PATH,
-				"Dictionary for outbound zstd compression");
-		rspamd_rcl_add_default_handler (sub,
-				"compat_messages",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, compat_messages),
-				0,
-				"Use pre 1.4 style of messages in the protocol");
-		rspamd_rcl_add_default_handler (sub,
-				"max_shots",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, default_max_shots),
-				0,
-				"Maximum number of hits per a single symbol (default: 100)");
-		rspamd_rcl_add_default_handler (sub,
-				"sessions_cache",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, enable_sessions_cache),
-				0,
-				"Enable sessions cache to debug dangling sessions");
-		rspamd_rcl_add_default_handler (sub,
-				"max_sessions_cache",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_sessions_cache),
-				0,
-				"Maximum number of sessions in cache before warning (default: 100)");
-		rspamd_rcl_add_default_handler (sub,
-				"task_timeout",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, task_timeout),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Maximum time for checking a message");
-		rspamd_rcl_add_default_handler (sub,
-				"soft_reject_on_timeout",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, soft_reject_on_timeout),
-				0,
-				"Emit soft reject if task timeout takes place");
-		rspamd_rcl_add_default_handler (sub,
-				"check_timeout",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, task_timeout),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Maximum time for checking a message (alias for task_timeout)");
-		rspamd_rcl_add_default_handler (sub,
-				"lua_gc_step",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, lua_gc_step),
-				RSPAMD_CL_FLAG_UINT,
-				"Lua garbage-collector step (default: 200)");
-		rspamd_rcl_add_default_handler (sub,
-				"lua_gc_pause",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, lua_gc_pause),
-				RSPAMD_CL_FLAG_UINT,
-				"Lua garbage-collector pause (default: 200)");
-		rspamd_rcl_add_default_handler (sub,
-				"full_gc_iters",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, full_gc_iters),
-				RSPAMD_CL_FLAG_UINT,
-				"Task scanned before memory gc is performed (default: 0 - disabled)");
-		rspamd_rcl_add_default_handler (sub,
-				"heartbeat_interval",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, heartbeat_interval),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Time between workers heartbeats");
-		rspamd_rcl_add_default_handler (sub,
-				"heartbeats_loss_max",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, heartbeats_loss_max),
-				RSPAMD_CL_FLAG_INT_32,
-				"Maximum count of heartbeats to be lost before trying to "
-				"terminate a worker (default: 0 - disabled)");
-		rspamd_rcl_add_default_handler (sub,
-				"max_lua_urls",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_lua_urls),
-				RSPAMD_CL_FLAG_INT_32,
-				"Maximum count of URLs to pass to Lua to avoid DoS (default: 1024)");
-		rspamd_rcl_add_default_handler (sub,
-				"max_urls",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_urls),
-				RSPAMD_CL_FLAG_INT_32,
-				"Maximum count of URLs to process to avoid DoS (default: 10240)");
-		rspamd_rcl_add_default_handler (sub,
-				"max_recipients",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_recipients),
-				RSPAMD_CL_FLAG_INT_32,
-				"Maximum count of recipients to process to avoid DoS (default: 1024)");
-		rspamd_rcl_add_default_handler (sub,
-				"max_blas_threads",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_blas_threads),
-				RSPAMD_CL_FLAG_INT_32,
-				"Maximum number of Blas threads for learning neural networks (default: 1)");
-		rspamd_rcl_add_default_handler (sub,
-				"max_opts_len",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, max_opts_len),
-				RSPAMD_CL_FLAG_INT_32,
-				"Maximum size of all options for a single symbol (default: 4096)");
-		rspamd_rcl_add_default_handler (sub,
-				"events_backend",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, events_backend),
-				0,
-				"Events backend to use: kqueue, epoll, select, poll or auto (default: auto)");
+		rspamd_rcl_add_default_handler(sub,
+									   "dns_nameserver",
+									   rspamd_rcl_parse_struct_ucl,
+									   G_STRUCT_OFFSET(struct rspamd_config, nameservers),
+									   0,
+									   "Legacy option for DNS servers used");
+		rspamd_rcl_add_default_handler(sub,
+									   "dns_timeout",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, dns_timeout),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Legacy option for DNS request timeout");
+		rspamd_rcl_add_default_handler(sub,
+									   "dns_retransmits",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, dns_retransmits),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Legacy option for DNS retransmits count");
+		rspamd_rcl_add_default_handler(sub,
+									   "dns_sockets",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, dns_io_per_server),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Legacy option for DNS sockets per server count");
+		rspamd_rcl_add_default_handler(sub,
+									   "dns_max_requests",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, dns_max_requests),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Maximum DNS requests per task (default: 64)");
+		rspamd_rcl_add_default_handler(sub,
+									   "control_socket",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, control_socket_path),
+									   0,
+									   "Path to the control socket");
+		rspamd_rcl_add_default_handler(sub,
+									   "explicit_modules",
+									   rspamd_rcl_parse_struct_string_list,
+									   G_STRUCT_OFFSET(struct rspamd_config, explicit_modules),
+									   RSPAMD_CL_FLAG_STRING_LIST_HASH,
+									   "Always load these modules even if they are not configured explicitly");
+		rspamd_rcl_add_default_handler(sub,
+									   "allow_raw_input",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, allow_raw_input),
+									   0,
+									   "Allow non MIME input for rspamd");
+		rspamd_rcl_add_default_handler(sub,
+									   "one_shot",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, one_shot_mode),
+									   0,
+									   "Add all symbols only once per message");
+		rspamd_rcl_add_default_handler(sub,
+									   "check_attachements",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, check_text_attachements),
+									   0,
+									   "Treat text attachments as normal text parts");
+		rspamd_rcl_add_default_handler(sub,
+									   "tempdir",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, temp_dir),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Directory for temporary files");
+		rspamd_rcl_add_default_handler(sub,
+									   "pidfile",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, pid_file),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to the pid file");
+		rspamd_rcl_add_default_handler(sub,
+									   "filters",
+									   rspamd_rcl_parse_struct_string_list,
+									   G_STRUCT_OFFSET(struct rspamd_config, filters),
+									   0,
+									   "List of internal filters enabled");
+		rspamd_rcl_add_default_handler(sub,
+									   "map_watch_interval",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, map_timeout),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Interval for checking maps");
+		rspamd_rcl_add_default_handler(sub,
+									   "map_file_watch_multiplier",
+									   rspamd_rcl_parse_struct_double,
+									   G_STRUCT_OFFSET(struct rspamd_config, map_file_watch_multiplier),
+									   0,
+									   "Multiplier for map watch interval when map is file");
+		rspamd_rcl_add_default_handler(sub,
+									   "maps_cache_dir",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, maps_cache_dir),
+									   0,
+									   "Directory to save maps cached data (default: $DBDIR)");
+		rspamd_rcl_add_default_handler(sub,
+									   "monitoring_watch_interval",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, monitored_interval),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Interval for checking monitored instances");
+		rspamd_rcl_add_default_handler(sub,
+									   "disable_monitoring",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, disable_monitored),
+									   0,
+									   "Disable monitoring completely");
+		rspamd_rcl_add_default_handler(sub,
+									   "fips_mode",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, fips_mode),
+									   0,
+									   "Enable FIPS 140-2 mode in OpenSSL");
+		rspamd_rcl_add_default_handler(sub,
+									   "dynamic_conf",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, dynamic_conf),
+									   0,
+									   "Path to the dynamic configuration");
+		rspamd_rcl_add_default_handler(sub,
+									   "rrd",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, rrd_file),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to RRD file");
+		rspamd_rcl_add_default_handler(sub,
+									   "stats_file",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, stats_file),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to stats file");
+		rspamd_rcl_add_default_handler(sub,
+									   "history_file",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, history_file),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to history file");
+		rspamd_rcl_add_default_handler(sub,
+									   "check_all_filters",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, check_all_filters),
+									   0,
+									   "Always check all filters");
+		rspamd_rcl_add_default_handler(sub,
+									   "public_groups_only",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, public_groups_only),
+									   0,
+									   "Output merely public groups everywhere");
+		rspamd_rcl_add_default_handler(sub,
+									   "enable_test_patterns",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, enable_test_patterns),
+									   0,
+									   "Enable test GTUBE like patterns (not for production!)");
+		rspamd_rcl_add_default_handler(sub,
+									   "enable_css_parser",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, enable_css_parser),
+									   0,
+									   "Enable CSS parser (experimental)");
+		rspamd_rcl_add_default_handler(sub,
+									   "enable_experimental",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, enable_experimental),
+									   0,
+									   "Enable experimental plugins");
+		rspamd_rcl_add_default_handler(sub,
+									   "disable_pcre_jit",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, disable_pcre_jit),
+									   0,
+									   "Disable PCRE JIT");
+		rspamd_rcl_add_default_handler(sub,
+									   "min_word_len",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, min_word_len),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Minimum length of the word to be considered in statistics/fuzzy");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_word_len",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_word_len),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Maximum length of the word to be considered in statistics/fuzzy");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_html_len",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_word_len),
+									   RSPAMD_CL_FLAG_INT_SIZE,
+									   "Maximum length of the html part to be parsed");
+		rspamd_rcl_add_default_handler(sub,
+									   "words_decay",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, words_decay),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Start skipping words at this amount");
+		rspamd_rcl_add_default_handler(sub,
+									   "url_tld",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, tld_file),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to the TLD file for urls detector");
+		rspamd_rcl_add_default_handler(sub,
+									   "tld",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, tld_file),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to the TLD file for urls detector");
+		rspamd_rcl_add_default_handler(sub,
+									   "hs_cache_dir",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, hs_cache_dir),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path directory where rspamd would save hyperscan cache");
+		rspamd_rcl_add_default_handler(sub,
+									   "history_rows",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, history_rows),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Number of records in the history file");
+		rspamd_rcl_add_default_handler(sub,
+									   "disable_hyperscan",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, disable_hyperscan),
+									   0,
+									   "Disable hyperscan optimizations for regular expressions");
+		rspamd_rcl_add_default_handler(sub,
+									   "vectorized_hyperscan",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, vectorized_hyperscan),
+									   0,
+									   "Use hyperscan in vectorized mode (obsoleted, do not use)");
+		rspamd_rcl_add_default_handler(sub,
+									   "cores_dir",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, cores_dir),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to the directory where rspamd core files are intended to be dumped");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_cores_size",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_cores_size),
+									   RSPAMD_CL_FLAG_INT_SIZE,
+									   "Limit of joint size of all files in `cores_dir`");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_cores_count",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_cores_count),
+									   RSPAMD_CL_FLAG_INT_SIZE,
+									   "Limit of files count in `cores_dir`");
+		rspamd_rcl_add_default_handler(sub,
+									   "local_addrs",
+									   rspamd_rcl_parse_struct_ucl,
+									   G_STRUCT_OFFSET(struct rspamd_config, local_addrs),
+									   0,
+									   "Use the specified addresses as local ones");
+		rspamd_rcl_add_default_handler(sub,
+									   "local_networks",
+									   rspamd_rcl_parse_struct_ucl,
+									   G_STRUCT_OFFSET(struct rspamd_config, local_addrs),
+									   0,
+									   "Use the specified addresses as local ones (alias for `local_addrs`)");
+		rspamd_rcl_add_default_handler(sub,
+									   "trusted_keys",
+									   rspamd_rcl_parse_struct_string_list,
+									   G_STRUCT_OFFSET(struct rspamd_config, trusted_keys),
+									   RSPAMD_CL_FLAG_STRING_LIST_HASH,
+									   "List of trusted public keys used for signatures in base32 encoding");
+		rspamd_rcl_add_default_handler(sub,
+									   "enable_shutdown_workaround",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, enable_shutdown_workaround),
+									   0,
+									   "Enable workaround for legacy clients");
+		rspamd_rcl_add_default_handler(sub,
+									   "ignore_received",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, ignore_received),
+									   0,
+									   "Ignore data from the first received header");
+		rspamd_rcl_add_default_handler(sub,
+									   "ssl_ca_path",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, ssl_ca_path),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Path to ssl CA file");
+		rspamd_rcl_add_default_handler(sub,
+									   "ssl_ciphers",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, ssl_ciphers),
+									   0,
+									   "List of ssl ciphers (e.g. HIGH:!aNULL:!kRSA:!PSK:!SRP:!MD5:!RC4)");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_message",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_message),
+									   RSPAMD_CL_FLAG_INT_SIZE,
+									   "Maximum size of the message to be scanned (50Mb by default)");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_pic",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_pic_size),
+									   RSPAMD_CL_FLAG_INT_SIZE,
+									   "Maximum size of the picture to be normalized (1Mb by default)");
+		rspamd_rcl_add_default_handler(sub,
+									   "images_cache",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_pic_size),
+									   RSPAMD_CL_FLAG_INT_SIZE,
+									   "Size of DCT data cache for images (256 elements by default)");
+		rspamd_rcl_add_default_handler(sub,
+									   "zstd_input_dictionary",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, zstd_input_dictionary),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Dictionary for zstd inbound protocol compression");
+		rspamd_rcl_add_default_handler(sub,
+									   "zstd_output_dictionary",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, zstd_output_dictionary),
+									   RSPAMD_CL_FLAG_STRING_PATH,
+									   "Dictionary for outbound zstd compression");
+		rspamd_rcl_add_default_handler(sub,
+									   "compat_messages",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, compat_messages),
+									   0,
+									   "Use pre 1.4 style of messages in the protocol");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_shots",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, default_max_shots),
+									   0,
+									   "Maximum number of hits per a single symbol (default: 100)");
+		rspamd_rcl_add_default_handler(sub,
+									   "sessions_cache",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, enable_sessions_cache),
+									   0,
+									   "Enable sessions cache to debug dangling sessions");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_sessions_cache",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_sessions_cache),
+									   0,
+									   "Maximum number of sessions in cache before warning (default: 100)");
+		rspamd_rcl_add_default_handler(sub,
+									   "task_timeout",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, task_timeout),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Maximum time for checking a message");
+		rspamd_rcl_add_default_handler(sub,
+									   "soft_reject_on_timeout",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, soft_reject_on_timeout),
+									   0,
+									   "Emit soft reject if task timeout takes place");
+		rspamd_rcl_add_default_handler(sub,
+									   "check_timeout",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, task_timeout),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Maximum time for checking a message (alias for task_timeout)");
+		rspamd_rcl_add_default_handler(sub,
+									   "lua_gc_step",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, lua_gc_step),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Lua garbage-collector step (default: 200)");
+		rspamd_rcl_add_default_handler(sub,
+									   "lua_gc_pause",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, lua_gc_pause),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Lua garbage-collector pause (default: 200)");
+		rspamd_rcl_add_default_handler(sub,
+									   "full_gc_iters",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, full_gc_iters),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Task scanned before memory gc is performed (default: 0 - disabled)");
+		rspamd_rcl_add_default_handler(sub,
+									   "heartbeat_interval",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, heartbeat_interval),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Time between workers heartbeats");
+		rspamd_rcl_add_default_handler(sub,
+									   "heartbeats_loss_max",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, heartbeats_loss_max),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Maximum count of heartbeats to be lost before trying to "
+									   "terminate a worker (default: 0 - disabled)");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_lua_urls",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_lua_urls),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Maximum count of URLs to pass to Lua to avoid DoS (default: 1024)");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_urls",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_urls),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Maximum count of URLs to process to avoid DoS (default: 10240)");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_recipients",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_recipients),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Maximum count of recipients to process to avoid DoS (default: 1024)");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_blas_threads",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_blas_threads),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Maximum number of Blas threads for learning neural networks (default: 1)");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_opts_len",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, max_opts_len),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Maximum size of all options for a single symbol (default: 4096)");
+		rspamd_rcl_add_default_handler(sub,
+									   "events_backend",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, events_backend),
+									   0,
+									   "Events backend to use: kqueue, epoll, select, poll or auto (default: auto)");
 
 		/* Neighbours configuration */
-		rspamd_rcl_add_section_doc (&sub->subsections, "neighbours", "name",
-				rspamd_rcl_neighbours_handler,
-				UCL_OBJECT, FALSE, TRUE,
-				cfg->doc_strings,
-				"List of members of Rspamd cluster");
+		rspamd_rcl_add_section_doc(&sub->subsections, "neighbours", "name",
+								   rspamd_rcl_neighbours_handler,
+								   UCL_OBJECT, FALSE, TRUE,
+								   cfg->doc_strings,
+								   "List of members of Rspamd cluster");
 
 		/* New DNS configuration */
-		ssub = rspamd_rcl_add_section_doc (&sub->subsections, "dns", NULL, NULL,
-				UCL_OBJECT, FALSE, TRUE,
-				cfg->doc_strings,
-				"Options for DNS resolver");
-		rspamd_rcl_add_default_handler (ssub,
-				"nameserver",
-				rspamd_rcl_parse_struct_ucl,
-				G_STRUCT_OFFSET (struct rspamd_config, nameservers),
-				0,
-				"List of DNS servers");
-		rspamd_rcl_add_default_handler (ssub,
-				"server",
-				rspamd_rcl_parse_struct_ucl,
-				G_STRUCT_OFFSET (struct rspamd_config, nameservers),
-				0,
-				"List of DNS servers");
-		rspamd_rcl_add_default_handler (ssub,
-				"timeout",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, dns_timeout),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"DNS request timeout");
-		rspamd_rcl_add_default_handler (ssub,
-				"retransmits",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, dns_retransmits),
-				RSPAMD_CL_FLAG_INT_32,
-				"DNS request retransmits");
-		rspamd_rcl_add_default_handler (ssub,
-				"sockets",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, dns_io_per_server),
-				RSPAMD_CL_FLAG_INT_32,
-				"Number of sockets per DNS server");
-		rspamd_rcl_add_default_handler (ssub,
-				"connections",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, dns_io_per_server),
-				RSPAMD_CL_FLAG_INT_32,
-				"Number of sockets per DNS server");
-		rspamd_rcl_add_default_handler (ssub,
-				"enable_dnssec",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_config, enable_dnssec),
-				0,
-				"Enable DNSSEC support in Rspamd");
+		ssub = rspamd_rcl_add_section_doc(&sub->subsections, "dns", NULL, NULL,
+										  UCL_OBJECT, FALSE, TRUE,
+										  cfg->doc_strings,
+										  "Options for DNS resolver");
+		rspamd_rcl_add_default_handler(ssub,
+									   "nameserver",
+									   rspamd_rcl_parse_struct_ucl,
+									   G_STRUCT_OFFSET(struct rspamd_config, nameservers),
+									   0,
+									   "List of DNS servers");
+		rspamd_rcl_add_default_handler(ssub,
+									   "server",
+									   rspamd_rcl_parse_struct_ucl,
+									   G_STRUCT_OFFSET(struct rspamd_config, nameservers),
+									   0,
+									   "List of DNS servers");
+		rspamd_rcl_add_default_handler(ssub,
+									   "timeout",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, dns_timeout),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "DNS request timeout");
+		rspamd_rcl_add_default_handler(ssub,
+									   "retransmits",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, dns_retransmits),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "DNS request retransmits");
+		rspamd_rcl_add_default_handler(ssub,
+									   "sockets",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, dns_io_per_server),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Number of sockets per DNS server");
+		rspamd_rcl_add_default_handler(ssub,
+									   "connections",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, dns_io_per_server),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Number of sockets per DNS server");
+		rspamd_rcl_add_default_handler(ssub,
+									   "enable_dnssec",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_config, enable_dnssec),
+									   0,
+									   "Enable DNSSEC support in Rspamd");
 
 
 		/* New upstreams configuration */
-		ssub = rspamd_rcl_add_section_doc (&sub->subsections, "upstream", NULL, NULL,
-				UCL_OBJECT, FALSE, TRUE,
-				cfg->doc_strings,
-				"Upstreams configuration parameters");
-		rspamd_rcl_add_default_handler (ssub,
-				"max_errors",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_config, upstream_max_errors),
-				RSPAMD_CL_FLAG_UINT,
-				"Maximum number of errors during `error_time` to consider upstream down");
-		rspamd_rcl_add_default_handler (ssub,
-				"error_time",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, upstream_error_time),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Time frame to check errors");
-		rspamd_rcl_add_default_handler (ssub,
-				"revive_time",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, upstream_revive_time),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Time before attempting to recover upstream after an error");
-		rspamd_rcl_add_default_handler (ssub,
-				"lazy_resolve_time",
-				rspamd_rcl_parse_struct_time,
-				G_STRUCT_OFFSET (struct rspamd_config, upstream_lazy_resolve_time),
-				RSPAMD_CL_FLAG_TIME_FLOAT,
-				"Time to resolve upstreams addresses in lazy mode");
-	}
-
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "actions"))) {
+		ssub = rspamd_rcl_add_section_doc(&sub->subsections, "upstream", NULL, NULL,
+										  UCL_OBJECT, FALSE, TRUE,
+										  cfg->doc_strings,
+										  "Upstreams configuration parameters");
+		rspamd_rcl_add_default_handler(ssub,
+									   "max_errors",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_config, upstream_max_errors),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Maximum number of errors during `error_time` to consider upstream down");
+		rspamd_rcl_add_default_handler(ssub,
+									   "error_time",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, upstream_error_time),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Time frame to check errors");
+		rspamd_rcl_add_default_handler(ssub,
+									   "revive_time",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, upstream_revive_time),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Time before attempting to recover upstream after an error");
+		rspamd_rcl_add_default_handler(ssub,
+									   "lazy_resolve_time",
+									   rspamd_rcl_parse_struct_time,
+									   G_STRUCT_OFFSET(struct rspamd_config, upstream_lazy_resolve_time),
+									   RSPAMD_CL_FLAG_TIME_FLOAT,
+									   "Time to resolve upstreams addresses in lazy mode");
+	}
+
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "actions"))) {
 		/**
 		 * Symbols and actions sections
 		 */
-		sub = rspamd_rcl_add_section_doc (&new,
-				"actions", NULL,
-				rspamd_rcl_actions_handler,
-				UCL_OBJECT,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"Actions configuration");
-		rspamd_rcl_add_default_handler (sub,
-				"unknown_weight",
-				rspamd_rcl_parse_struct_double,
-				G_STRUCT_OFFSET (struct rspamd_config, unknown_weight),
-				0,
-				"Accept unknown symbols with the specified weight");
-		rspamd_rcl_add_default_handler (sub,
-				"grow_factor",
-				rspamd_rcl_parse_struct_double,
-				G_STRUCT_OFFSET (struct rspamd_config, grow_factor),
-				0,
-				"Multiply the subsequent symbols by this number "
-				"(does not affect symbols with score less or "
-				"equal to zero)");
-		rspamd_rcl_add_default_handler (sub,
-				"subject",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_config, subject),
-				0,
-				"Rewrite subject with this value");
-	}
-
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "group"))) {
-		sub = rspamd_rcl_add_section_doc (&new,
-				"group", "name",
-				rspamd_rcl_group_handler,
-				UCL_OBJECT,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"Symbol groups configuration");
-		ssub = rspamd_rcl_add_section_doc (&sub->subsections, "symbols", "name",
-				rspamd_rcl_symbol_handler,
-				UCL_OBJECT, FALSE, TRUE,
-				cfg->doc_strings,
-				"Symbols configuration");
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "actions", NULL,
+										 rspamd_rcl_actions_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "Actions configuration");
+		rspamd_rcl_add_default_handler(sub,
+									   "unknown_weight",
+									   rspamd_rcl_parse_struct_double,
+									   G_STRUCT_OFFSET(struct rspamd_config, unknown_weight),
+									   0,
+									   "Accept unknown symbols with the specified weight");
+		rspamd_rcl_add_default_handler(sub,
+									   "grow_factor",
+									   rspamd_rcl_parse_struct_double,
+									   G_STRUCT_OFFSET(struct rspamd_config, grow_factor),
+									   0,
+									   "Multiply the subsequent symbols by this number "
+									   "(does not affect symbols with score less or "
+									   "equal to zero)");
+		rspamd_rcl_add_default_handler(sub,
+									   "subject",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_config, subject),
+									   0,
+									   "Rewrite subject with this value");
+	}
+
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "group"))) {
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "group", "name",
+										 rspamd_rcl_group_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "Symbol groups configuration");
+		ssub = rspamd_rcl_add_section_doc(&sub->subsections, "symbols", "name",
+										  rspamd_rcl_symbol_handler,
+										  UCL_OBJECT, FALSE, TRUE,
+										  cfg->doc_strings,
+										  "Symbols configuration");
 
 		/* Group part */
-		rspamd_rcl_add_default_handler (sub,
-				"max_score",
-				rspamd_rcl_parse_struct_double,
-				G_STRUCT_OFFSET (struct rspamd_symbols_group, max_score),
-				0,
-				"Maximum score that could be reached by this symbols group");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_score",
+									   rspamd_rcl_parse_struct_double,
+									   G_STRUCT_OFFSET(struct rspamd_symbols_group, max_score),
+									   0,
+									   "Maximum score that could be reached by this symbols group");
 	}
 
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "worker"))) {
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "worker"))) {
 		/**
 		 * Worker section
 		 */
-		sub = rspamd_rcl_add_section_doc (&new,
-				"worker", "type",
-				rspamd_rcl_worker_handler,
-				UCL_OBJECT,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"Workers common options");
-		rspamd_rcl_add_default_handler (sub,
-				"count",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_worker_conf, count),
-				RSPAMD_CL_FLAG_INT_16,
-				"Number of workers to spawn");
-		rspamd_rcl_add_default_handler (sub,
-				"max_files",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_worker_conf, rlimit_nofile),
-				RSPAMD_CL_FLAG_INT_64,
-				"Maximum number of opened files per worker");
-		rspamd_rcl_add_default_handler (sub,
-				"max_core",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_worker_conf, rlimit_maxcore),
-				RSPAMD_CL_FLAG_INT_64,
-				"Max size of core file in bytes");
-		rspamd_rcl_add_default_handler (sub,
-				"enabled",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_worker_conf, enabled),
-				0,
-				"Enable or disable a worker (true by default)");
-	}
-
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "modules"))) {
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "worker", "type",
+										 rspamd_rcl_worker_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "Workers common options");
+		rspamd_rcl_add_default_handler(sub,
+									   "count",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_worker_conf, count),
+									   RSPAMD_CL_FLAG_INT_16,
+									   "Number of workers to spawn");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_files",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_worker_conf, rlimit_nofile),
+									   RSPAMD_CL_FLAG_INT_64,
+									   "Maximum number of opened files per worker");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_core",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_worker_conf, rlimit_maxcore),
+									   RSPAMD_CL_FLAG_INT_64,
+									   "Max size of core file in bytes");
+		rspamd_rcl_add_default_handler(sub,
+									   "enabled",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_worker_conf, enabled),
+									   0,
+									   "Enable or disable a worker (true by default)");
+	}
+
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "modules"))) {
 		/**
 		 * Modules handler
 		 */
-		sub = rspamd_rcl_add_section_doc (&new,
-				"modules", NULL,
-				rspamd_rcl_modules_handler,
-				UCL_OBJECT,
-				FALSE,
-				FALSE,
-				cfg->doc_strings,
-				"Lua plugins to load");
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "modules", NULL,
+										 rspamd_rcl_modules_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 FALSE,
+										 cfg->doc_strings,
+										 "Lua plugins to load");
 	}
 
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "classifier"))) {
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "classifier"))) {
 		/**
 		 * Classifiers handler
 		 */
-		sub = rspamd_rcl_add_section_doc (&new,
-				"classifier", "type",
-				rspamd_rcl_classifier_handler,
-				UCL_OBJECT,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"CLassifier options");
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "classifier", "type",
+										 rspamd_rcl_classifier_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "CLassifier options");
 		/* Default classifier is 'bayes' for now */
 		sub->default_key = "bayes";
 
-		rspamd_rcl_add_default_handler (sub,
-				"min_tokens",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_classifier_config, min_tokens),
-				RSPAMD_CL_FLAG_INT_32,
-				"Minimum count of tokens (words) to be considered for statistics");
-		rspamd_rcl_add_default_handler (sub,
-				"min_token_hits",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_classifier_config, min_token_hits),
-				RSPAMD_CL_FLAG_UINT,
-				"Minimum number of hits for a token to be considered");
-		rspamd_rcl_add_default_handler (sub,
-				"min_prob_strength",
-				rspamd_rcl_parse_struct_double,
-				G_STRUCT_OFFSET (struct rspamd_classifier_config, min_token_hits),
-				0,
-				"Use only tokens with probability in [0.5 - MPS, 0.5 + MPS]");
-		rspamd_rcl_add_default_handler (sub,
-				"max_tokens",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_classifier_config, max_tokens),
-				RSPAMD_CL_FLAG_INT_32,
-				"Maximum count of tokens (words) to be considered for statistics");
-		rspamd_rcl_add_default_handler (sub,
-				"min_learns",
-				rspamd_rcl_parse_struct_integer,
-				G_STRUCT_OFFSET (struct rspamd_classifier_config, min_learns),
-				RSPAMD_CL_FLAG_UINT,
-				"Minimum number of learns for each statfile to use this classifier");
-		rspamd_rcl_add_default_handler (sub,
-				"backend",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_classifier_config, backend),
-				0,
-				"Statfiles engine");
-		rspamd_rcl_add_default_handler (sub,
-				"name",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_classifier_config, name),
-				0,
-				"Name of classifier");
+		rspamd_rcl_add_default_handler(sub,
+									   "min_tokens",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_classifier_config, min_tokens),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Minimum count of tokens (words) to be considered for statistics");
+		rspamd_rcl_add_default_handler(sub,
+									   "min_token_hits",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_classifier_config, min_token_hits),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Minimum number of hits for a token to be considered");
+		rspamd_rcl_add_default_handler(sub,
+									   "min_prob_strength",
+									   rspamd_rcl_parse_struct_double,
+									   G_STRUCT_OFFSET(struct rspamd_classifier_config, min_token_hits),
+									   0,
+									   "Use only tokens with probability in [0.5 - MPS, 0.5 + MPS]");
+		rspamd_rcl_add_default_handler(sub,
+									   "max_tokens",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_classifier_config, max_tokens),
+									   RSPAMD_CL_FLAG_INT_32,
+									   "Maximum count of tokens (words) to be considered for statistics");
+		rspamd_rcl_add_default_handler(sub,
+									   "min_learns",
+									   rspamd_rcl_parse_struct_integer,
+									   G_STRUCT_OFFSET(struct rspamd_classifier_config, min_learns),
+									   RSPAMD_CL_FLAG_UINT,
+									   "Minimum number of learns for each statfile to use this classifier");
+		rspamd_rcl_add_default_handler(sub,
+									   "backend",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_classifier_config, backend),
+									   0,
+									   "Statfiles engine");
+		rspamd_rcl_add_default_handler(sub,
+									   "name",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_classifier_config, name),
+									   0,
+									   "Name of classifier");
 
 		/*
 		 * Statfile defaults
 		 */
-		ssub = rspamd_rcl_add_section_doc (&sub->subsections,
-				"statfile", "symbol",
-				rspamd_rcl_statfile_handler,
-				UCL_OBJECT,
-				TRUE,
-				TRUE,
-				sub->doc_ref,
-				"Statfiles options");
-		rspamd_rcl_add_default_handler (ssub,
-				"label",
-				rspamd_rcl_parse_struct_string,
-				G_STRUCT_OFFSET (struct rspamd_statfile_config, label),
-				0,
-				"Statfile unique label");
-		rspamd_rcl_add_default_handler (ssub,
-				"spam",
-				rspamd_rcl_parse_struct_boolean,
-				G_STRUCT_OFFSET (struct rspamd_statfile_config, is_spam),
-				0,
-				"Sets if this statfile contains spam samples");
-	}
-
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "composite"))) {
+		ssub = rspamd_rcl_add_section_doc(&sub->subsections,
+										  "statfile", "symbol",
+										  rspamd_rcl_statfile_handler,
+										  UCL_OBJECT,
+										  TRUE,
+										  TRUE,
+										  sub->doc_ref,
+										  "Statfiles options");
+		rspamd_rcl_add_default_handler(ssub,
+									   "label",
+									   rspamd_rcl_parse_struct_string,
+									   G_STRUCT_OFFSET(struct rspamd_statfile_config, label),
+									   0,
+									   "Statfile unique label");
+		rspamd_rcl_add_default_handler(ssub,
+									   "spam",
+									   rspamd_rcl_parse_struct_boolean,
+									   G_STRUCT_OFFSET(struct rspamd_statfile_config, is_spam),
+									   0,
+									   "Sets if this statfile contains spam samples");
+	}
+
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "composite"))) {
 		/**
 		 * Composites handlers
 		 */
-		sub = rspamd_rcl_add_section_doc (&new,
-				"composite", "name",
-				rspamd_rcl_composite_handler,
-				UCL_OBJECT,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"Rspamd composite symbols");
-		sub = rspamd_rcl_add_section_doc (&new,
-				"composites", NULL,
-				rspamd_rcl_composites_handler,
-				UCL_OBJECT,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"Rspamd composite symbols");
-	}
-
-	if (!(skip_sections && g_hash_table_lookup (skip_sections, "lua"))) {
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "composite", "name",
+										 rspamd_rcl_composite_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "Rspamd composite symbols");
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "composites", NULL,
+										 rspamd_rcl_composites_handler,
+										 UCL_OBJECT,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "Rspamd composite symbols");
+	}
+
+	if (!(skip_sections && g_hash_table_lookup(skip_sections, "lua"))) {
 		/**
 		 * Lua handler
 		 */
-		sub = rspamd_rcl_add_section_doc (&new,
-				"lua", NULL,
-				rspamd_rcl_lua_handler,
-				UCL_STRING,
-				FALSE,
-				TRUE,
-				cfg->doc_strings,
-				"Lua files to load");
+		sub = rspamd_rcl_add_section_doc(&new,
+										 "lua", NULL,
+										 rspamd_rcl_lua_handler,
+										 UCL_STRING,
+										 FALSE,
+										 TRUE,
+										 cfg->doc_strings,
+										 "Lua files to load");
 	}
 
 	return new;
 }
 
 struct rspamd_rcl_section *
-rspamd_rcl_config_get_section (struct rspamd_rcl_section *top,
-	const char *path)
+rspamd_rcl_config_get_section(struct rspamd_rcl_section *top,
+							  const char *path)
 {
 	struct rspamd_rcl_section *cur, *found = NULL;
 	char **path_components;
@@ -2499,52 +2507,52 @@ rspamd_rcl_config_get_section (struct rspamd_rcl_section *top,
 		return top;
 	}
 
-	path_components = g_strsplit_set (path, "/", -1);
-	ncomponents = g_strv_length (path_components);
+	path_components = g_strsplit_set(path, "/", -1);
+	ncomponents = g_strv_length(path_components);
 
 	cur = top;
 	for (i = 0; i < ncomponents; i++) {
 		if (cur == NULL) {
-			g_strfreev (path_components);
+			g_strfreev(path_components);
 			return NULL;
 		}
-		HASH_FIND_STR (cur, path_components[i], found);
+		HASH_FIND_STR(cur, path_components[i], found);
 		if (found == NULL) {
-			g_strfreev (path_components);
+			g_strfreev(path_components);
 			return NULL;
 		}
 		cur = found;
 	}
 
-	g_strfreev (path_components);
+	g_strfreev(path_components);
 	return found;
 }
 
 static gboolean
-rspamd_rcl_process_section (struct rspamd_config *cfg,
-		struct rspamd_rcl_section *sec,
-		gpointer ptr, const ucl_object_t *obj, rspamd_mempool_t *pool,
-		GError **err)
+rspamd_rcl_process_section(struct rspamd_config *cfg,
+						   struct rspamd_rcl_section *sec,
+						   gpointer ptr, const ucl_object_t *obj, rspamd_mempool_t *pool,
+						   GError **err)
 {
 	ucl_object_iter_t it;
 	const ucl_object_t *cur;
 	gboolean is_nested = TRUE;
 	const gchar *key = NULL;
 
-	g_assert (obj != NULL);
-	g_assert (sec->handler != NULL);
+	g_assert(obj != NULL);
+	g_assert(sec->handler != NULL);
 
 	if (sec->key_attr != NULL) {
-		it = ucl_object_iterate_new (obj);
+		it = ucl_object_iterate_new(obj);
 
-		while ((cur = ucl_object_iterate_full (it, UCL_ITERATE_EXPLICIT)) != NULL) {
-			if (ucl_object_type (cur) != UCL_OBJECT) {
+		while ((cur = ucl_object_iterate_full(it, UCL_ITERATE_EXPLICIT)) != NULL) {
+			if (ucl_object_type(cur) != UCL_OBJECT) {
 				is_nested = FALSE;
 				break;
 			}
 		}
 
-		ucl_object_iterate_free (it);
+		ucl_object_iterate_free(it);
 	}
 	else {
 		is_nested = FALSE;
@@ -2552,107 +2560,109 @@ rspamd_rcl_process_section (struct rspamd_config *cfg,
 
 	if (is_nested) {
 		/* Just reiterate on all subobjects */
-		it = ucl_object_iterate_new (obj);
+		it = ucl_object_iterate_new(obj);
 
-		while ((cur = ucl_object_iterate_full (it, UCL_ITERATE_EXPLICIT)) != NULL) {
-			if (!sec->handler (pool, cur, ucl_object_key (cur), ptr, sec, err)) {
-				ucl_object_iterate_free (it);
+		while ((cur = ucl_object_iterate_full(it, UCL_ITERATE_EXPLICIT)) != NULL) {
+			if (!sec->handler(pool, cur, ucl_object_key(cur), ptr, sec, err)) {
+				ucl_object_iterate_free(it);
 
 				return FALSE;
 			}
 		}
 
-		ucl_object_iterate_free (it);
+		ucl_object_iterate_free(it);
 
 		return TRUE;
 	}
 	else {
 		if (sec->key_attr != NULL) {
 			/* First of all search for required attribute and use it as a key */
-			cur = ucl_object_lookup (obj, sec->key_attr);
+			cur = ucl_object_lookup(obj, sec->key_attr);
 
 			if (cur == NULL) {
 				if (sec->default_key == NULL) {
-					g_set_error (err, CFG_RCL_ERROR, EINVAL, "required attribute "
-							"'%s' is missing for section '%s', current key: %s",
-							sec->key_attr,
-							sec->name,
-							ucl_object_emit (obj, UCL_EMIT_CONFIG));
+					g_set_error(err, CFG_RCL_ERROR, EINVAL, "required attribute "
+															"'%s' is missing for section '%s', current key: %s",
+								sec->key_attr,
+								sec->name,
+								ucl_object_emit(obj, UCL_EMIT_CONFIG));
 
 					return FALSE;
 				}
 				else {
-					msg_info ("using default key '%s' for mandatory field '%s' "
-							"for section '%s'", sec->default_key, sec->key_attr,
-							sec->name);
+					msg_info("using default key '%s' for mandatory field '%s' "
+							 "for section '%s'",
+							 sec->default_key, sec->key_attr,
+							 sec->name);
 					key = sec->default_key;
 				}
 			}
-			else if (ucl_object_type (cur) != UCL_STRING) {
-				g_set_error (err, CFG_RCL_ERROR, EINVAL, "required attribute %s"
-						" is not a string for section %s",
-						sec->key_attr, sec->name);
+			else if (ucl_object_type(cur) != UCL_STRING) {
+				g_set_error(err, CFG_RCL_ERROR, EINVAL, "required attribute %s"
+														" is not a string for section %s",
+							sec->key_attr, sec->name);
 
 				return FALSE;
 			}
 			else {
-				key = ucl_object_tostring (cur);
+				key = ucl_object_tostring(cur);
 			}
 		}
 	}
 
-	return sec->handler (pool, obj, key, ptr, sec, err);
+	return sec->handler(pool, obj, key, ptr, sec, err);
 }
 
 gboolean
-rspamd_rcl_parse (struct rspamd_rcl_section *top,
-		struct rspamd_config *cfg,
-		gpointer ptr, rspamd_mempool_t *pool,
-		const ucl_object_t *obj, GError **err)
+rspamd_rcl_parse(struct rspamd_rcl_section *top,
+				 struct rspamd_config *cfg,
+				 gpointer ptr, rspamd_mempool_t *pool,
+				 const ucl_object_t *obj, GError **err)
 {
 	const ucl_object_t *found, *cur_obj;
 	struct rspamd_rcl_section *cur, *tmp, *found_sec;
 
 	if (obj->type != UCL_OBJECT) {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"top configuration must be an object");
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"top configuration must be an object");
 		return FALSE;
 	}
 
 	/* Iterate over known sections and ignore unknown ones */
-	HASH_ITER (hh, top, cur, tmp)
+	HASH_ITER(hh, top, cur, tmp)
 	{
-		if (strcmp (cur->name, "*") == 0) {
+		if (strcmp(cur->name, "*") == 0) {
 			/* Default section handler */
-			LL_FOREACH (obj, cur_obj) {
-				HASH_FIND_STR (top, ucl_object_key (cur_obj), found_sec);
+			LL_FOREACH(obj, cur_obj)
+			{
+				HASH_FIND_STR(top, ucl_object_key(cur_obj), found_sec);
 
 				if (found_sec == NULL) {
 					if (cur->handler != NULL) {
-						if (!rspamd_rcl_process_section (cfg, cur, ptr, cur_obj,
-								pool, err)) {
+						if (!rspamd_rcl_process_section(cfg, cur, ptr, cur_obj,
+														pool, err)) {
 							return FALSE;
 						}
 					}
 					else {
-						rspamd_rcl_section_parse_defaults (cfg,
-								cur,
-								pool,
-								cur_obj,
-								ptr,
-								err);
+						rspamd_rcl_section_parse_defaults(cfg,
+														  cur,
+														  pool,
+														  cur_obj,
+														  ptr,
+														  err);
 					}
 				}
 			}
 		}
 		else {
-			found = ucl_object_lookup (obj, cur->name);
+			found = ucl_object_lookup(obj, cur->name);
 			if (found == NULL) {
 				if (cur->required) {
-					g_set_error (err, CFG_RCL_ERROR, ENOENT,
-							"required section %s is missing", cur->name);
+					g_set_error(err, CFG_RCL_ERROR, ENOENT,
+								"required section %s is missing", cur->name);
 					return FALSE;
 				}
 			}
@@ -2660,31 +2670,32 @@ rspamd_rcl_parse (struct rspamd_rcl_section *top,
 				/* Check type */
 				if (cur->strict_type) {
 					if (cur->type != found->type) {
-						g_set_error (err, CFG_RCL_ERROR, EINVAL,
-								"object in section %s has invalid type", cur->name);
+						g_set_error(err, CFG_RCL_ERROR, EINVAL,
+									"object in section %s has invalid type", cur->name);
 						return FALSE;
 					}
 				}
 
-				LL_FOREACH (found, cur_obj) {
+				LL_FOREACH(found, cur_obj)
+				{
 					if (cur->handler != NULL) {
-						if (!rspamd_rcl_process_section (cfg, cur, ptr, cur_obj,
-								pool, err)) {
+						if (!rspamd_rcl_process_section(cfg, cur, ptr, cur_obj,
+														pool, err)) {
 							return FALSE;
 						}
 					}
 					else {
-						rspamd_rcl_section_parse_defaults (cfg, cur,
-								pool,
-								cur_obj,
-								ptr,
-								err);
+						rspamd_rcl_section_parse_defaults(cfg, cur,
+														  pool,
+														  cur_obj,
+														  ptr,
+														  err);
 					}
 				}
 			}
 		}
 		if (cur->fin) {
-			cur->fin (pool, cur->fin_ud);
+			cur->fin(pool, cur->fin_ud);
 		}
 	}
 
@@ -2692,33 +2703,34 @@ rspamd_rcl_parse (struct rspamd_rcl_section *top,
 }
 
 gboolean
-rspamd_rcl_section_parse_defaults (struct rspamd_config *cfg,
-		struct rspamd_rcl_section *section,
-		rspamd_mempool_t *pool, const ucl_object_t *obj, gpointer ptr,
-		GError **err)
+rspamd_rcl_section_parse_defaults(struct rspamd_config *cfg,
+								  struct rspamd_rcl_section *section,
+								  rspamd_mempool_t *pool, const ucl_object_t *obj, gpointer ptr,
+								  GError **err)
 {
 	const ucl_object_t *found, *cur_obj;
 	struct rspamd_rcl_default_handler_data *cur, *tmp;
 
 	if (obj->type != UCL_OBJECT) {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"default configuration must be an object for section %s "
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"default configuration must be an object for section %s "
 					"(actual type is %s)",
-				section->name, ucl_object_type_to_string (obj->type));
+					section->name, ucl_object_type_to_string(obj->type));
 		return FALSE;
 	}
 
-	HASH_ITER (hh, section->default_parser, cur, tmp)
+	HASH_ITER(hh, section->default_parser, cur, tmp)
 	{
-		found = ucl_object_lookup (obj, cur->key);
+		found = ucl_object_lookup(obj, cur->key);
 		if (found != NULL) {
 			cur->pd.user_struct = ptr;
 			cur->pd.cfg = cfg;
 
-			LL_FOREACH (found, cur_obj) {
-				if (!cur->handler (pool, cur_obj, &cur->pd, section, err)) {
+			LL_FOREACH(found, cur_obj)
+			{
+				if (!cur->handler(pool, cur_obj, &cur->pd, section, err)) {
 					return FALSE;
 				}
 
@@ -2733,46 +2745,46 @@ rspamd_rcl_section_parse_defaults (struct rspamd_config *cfg,
 }
 
 gboolean
-rspamd_rcl_parse_struct_string (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_string(rspamd_mempool_t *pool,
+							   const ucl_object_t *obj,
+							   gpointer ud,
+							   struct rspamd_rcl_section *section,
+							   GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	gchar **target;
 	const gsize num_str_len = 32;
 
-	target = (gchar **)(((gchar *)pd->user_struct) + pd->offset);
+	target = (gchar **) (((gchar *) pd->user_struct) + pd->offset);
 	switch (obj->type) {
 	case UCL_STRING:
 		*target =
-			rspamd_mempool_strdup (pool, ucl_copy_value_trash (obj));
+			rspamd_mempool_strdup(pool, ucl_copy_value_trash(obj));
 		break;
 	case UCL_INT:
-		*target = rspamd_mempool_alloc (pool, num_str_len);
-		rspamd_snprintf (*target, num_str_len, "%L", obj->value.iv);
+		*target = rspamd_mempool_alloc(pool, num_str_len);
+		rspamd_snprintf(*target, num_str_len, "%L", obj->value.iv);
 		break;
 	case UCL_FLOAT:
-		*target = rspamd_mempool_alloc (pool, num_str_len);
-		rspamd_snprintf (*target, num_str_len, "%f", obj->value.dv);
+		*target = rspamd_mempool_alloc(pool, num_str_len);
+		rspamd_snprintf(*target, num_str_len, "%f", obj->value.dv);
 		break;
 	case UCL_BOOLEAN:
-		*target = rspamd_mempool_alloc (pool, num_str_len);
-		rspamd_snprintf (*target, num_str_len, "%s",
-				((gboolean)obj->value.iv) ? "true" : "false");
+		*target = rspamd_mempool_alloc(pool, num_str_len);
+		rspamd_snprintf(*target, num_str_len, "%s",
+						((gboolean) obj->value.iv) ? "true" : "false");
 		break;
 	case UCL_NULL:
 		/* String is enforced to be null */
 		*target = NULL;
 		break;
 	default:
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"cannot convert %s to string in option %s",
-			ucl_object_type_to_string (ucl_object_type (obj)),
-			ucl_object_key (obj));
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"cannot convert %s to string in option %s",
+					ucl_object_type_to_string(ucl_object_type(obj)),
+					ucl_object_key(obj));
 		return FALSE;
 	}
 
@@ -2780,11 +2792,11 @@ rspamd_rcl_parse_struct_string (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_rcl_parse_struct_integer (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_integer(rspamd_mempool_t *pool,
+								const ucl_object_t *obj,
+								gpointer ud,
+								struct rspamd_rcl_section *section,
+								GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	union {
@@ -2798,79 +2810,79 @@ rspamd_rcl_parse_struct_integer (rspamd_mempool_t *pool,
 	int64_t val;
 
 	if (pd->flags == RSPAMD_CL_FLAG_INT_32) {
-		target.i32p = (gint32 *)(((gchar *)pd->user_struct) + pd->offset);
-		if (!ucl_object_toint_safe (obj, &val)) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot convert %s to integer in option %s",
-					ucl_object_type_to_string (ucl_object_type (obj)),
-					ucl_object_key (obj));
+		target.i32p = (gint32 *) (((gchar *) pd->user_struct) + pd->offset);
+		if (!ucl_object_toint_safe(obj, &val)) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot convert %s to integer in option %s",
+						ucl_object_type_to_string(ucl_object_type(obj)),
+						ucl_object_key(obj));
 			return FALSE;
 		}
 		*target.i32p = val;
 	}
 	else if (pd->flags == RSPAMD_CL_FLAG_INT_64) {
-		target.i64p = (gint64 *)(((gchar *)pd->user_struct) + pd->offset);
-		if (!ucl_object_toint_safe (obj, &val)) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot convert %s to integer in option %s",
-					ucl_object_type_to_string (ucl_object_type (obj)),
-					ucl_object_key (obj));
+		target.i64p = (gint64 *) (((gchar *) pd->user_struct) + pd->offset);
+		if (!ucl_object_toint_safe(obj, &val)) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot convert %s to integer in option %s",
+						ucl_object_type_to_string(ucl_object_type(obj)),
+						ucl_object_key(obj));
 			return FALSE;
 		}
 		*target.i64p = val;
 	}
 	else if (pd->flags == RSPAMD_CL_FLAG_INT_SIZE) {
-		target.sp = (gsize *)(((gchar *)pd->user_struct) + pd->offset);
-		if (!ucl_object_toint_safe (obj, &val)) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot convert %s to integer in option %s",
-					ucl_object_type_to_string (ucl_object_type (obj)),
-					ucl_object_key (obj));
+		target.sp = (gsize *) (((gchar *) pd->user_struct) + pd->offset);
+		if (!ucl_object_toint_safe(obj, &val)) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot convert %s to integer in option %s",
+						ucl_object_type_to_string(ucl_object_type(obj)),
+						ucl_object_key(obj));
 			return FALSE;
 		}
 		*target.sp = val;
 	}
 	else if (pd->flags == RSPAMD_CL_FLAG_INT_16) {
-		target.i16p = (gint16 *)(((gchar *)pd->user_struct) + pd->offset);
-		if (!ucl_object_toint_safe (obj, &val)) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot convert %s to integer in option %s",
-					ucl_object_type_to_string (ucl_object_type (obj)),
-					ucl_object_key (obj));
+		target.i16p = (gint16 *) (((gchar *) pd->user_struct) + pd->offset);
+		if (!ucl_object_toint_safe(obj, &val)) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot convert %s to integer in option %s",
+						ucl_object_type_to_string(ucl_object_type(obj)),
+						ucl_object_key(obj));
 			return FALSE;
 		}
 		*target.i16p = val;
 	}
 	else if (pd->flags == RSPAMD_CL_FLAG_UINT) {
-		target.up = (guint *)(((gchar *)pd->user_struct) + pd->offset);
-		if (!ucl_object_toint_safe (obj, &val)) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot convert %s to integer in option %s",
-					ucl_object_type_to_string (ucl_object_type (obj)),
-					ucl_object_key (obj));
+		target.up = (guint *) (((gchar *) pd->user_struct) + pd->offset);
+		if (!ucl_object_toint_safe(obj, &val)) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot convert %s to integer in option %s",
+						ucl_object_type_to_string(ucl_object_type(obj)),
+						ucl_object_key(obj));
 			return FALSE;
 		}
 		*target.up = val;
 	}
 	else {
-		target.ip = (gint *)(((gchar *)pd->user_struct) + pd->offset);
-		if (!ucl_object_toint_safe (obj, &val)) {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot convert %s to integer in option %s",
-					ucl_object_type_to_string (ucl_object_type (obj)),
-					ucl_object_key (obj));
+		target.ip = (gint *) (((gchar *) pd->user_struct) + pd->offset);
+		if (!ucl_object_toint_safe(obj, &val)) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot convert %s to integer in option %s",
+						ucl_object_type_to_string(ucl_object_type(obj)),
+						ucl_object_key(obj));
 			return FALSE;
 		}
 		*target.ip = val;
@@ -2880,24 +2892,24 @@ rspamd_rcl_parse_struct_integer (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_rcl_parse_struct_double (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_double(rspamd_mempool_t *pool,
+							   const ucl_object_t *obj,
+							   gpointer ud,
+							   struct rspamd_rcl_section *section,
+							   GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	gdouble *target;
 
-	target = (gdouble *)(((gchar *)pd->user_struct) + pd->offset);
+	target = (gdouble *) (((gchar *) pd->user_struct) + pd->offset);
 
-	if (!ucl_object_todouble_safe (obj, target)) {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"cannot convert %s to double in option %s",
-				ucl_object_type_to_string (ucl_object_type (obj)),
-				ucl_object_key (obj));
+	if (!ucl_object_todouble_safe(obj, target)) {
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"cannot convert %s to double in option %s",
+					ucl_object_type_to_string(ucl_object_type(obj)),
+					ucl_object_key(obj));
 		return FALSE;
 	}
 
@@ -2905,11 +2917,11 @@ rspamd_rcl_parse_struct_double (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_rcl_parse_struct_time (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_time(rspamd_mempool_t *pool,
+							 const ucl_object_t *obj,
+							 gpointer ud,
+							 struct rspamd_rcl_section *section,
+							 GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	union {
@@ -2921,47 +2933,47 @@ rspamd_rcl_parse_struct_time (rspamd_mempool_t *pool,
 	} target;
 	gdouble val;
 
-	if (!ucl_object_todouble_safe (obj, &val)) {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"cannot convert %s to double in option %s",
-				ucl_object_type_to_string (ucl_object_type (obj)),
-				ucl_object_key (obj));
+	if (!ucl_object_todouble_safe(obj, &val)) {
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"cannot convert %s to double in option %s",
+					ucl_object_type_to_string(ucl_object_type(obj)),
+					ucl_object_key(obj));
 		return FALSE;
 	}
 
 	if (pd->flags == RSPAMD_CL_FLAG_TIME_TIMEVAL) {
 		target.ptv =
-			(struct timeval *)(((gchar *)pd->user_struct) + pd->offset);
-		target.ptv->tv_sec = (glong)val;
-		target.ptv->tv_usec = (val - (glong)val) * 1000000;
+			(struct timeval *) (((gchar *) pd->user_struct) + pd->offset);
+		target.ptv->tv_sec = (glong) val;
+		target.ptv->tv_usec = (val - (glong) val) * 1000000;
 	}
 	else if (pd->flags == RSPAMD_CL_FLAG_TIME_TIMESPEC) {
 		target.pts =
-			(struct timespec *)(((gchar *)pd->user_struct) + pd->offset);
-		target.pts->tv_sec = (glong)val;
-		target.pts->tv_nsec = (val - (glong)val) * 1000000000000LL;
+			(struct timespec *) (((gchar *) pd->user_struct) + pd->offset);
+		target.pts->tv_sec = (glong) val;
+		target.pts->tv_nsec = (val - (glong) val) * 1000000000000LL;
 	}
 	else if (pd->flags == RSPAMD_CL_FLAG_TIME_FLOAT) {
-		target.pdv = (double *)(((gchar *)pd->user_struct) + pd->offset);
+		target.pdv = (double *) (((gchar *) pd->user_struct) + pd->offset);
 		*target.pdv = val;
 	}
 	else if (pd->flags == RSPAMD_CL_FLAG_TIME_INTEGER) {
-		target.psec = (gint *)(((gchar *)pd->user_struct) + pd->offset);
+		target.psec = (gint *) (((gchar *) pd->user_struct) + pd->offset);
 		*target.psec = val * 1000;
 	}
 	else if (pd->flags == RSPAMD_CL_FLAG_TIME_UINT_32) {
-		target.pu32 = (guint32 *)(((gchar *)pd->user_struct) + pd->offset);
+		target.pu32 = (guint32 *) (((gchar *) pd->user_struct) + pd->offset);
 		*target.pu32 = val * 1000;
 	}
 	else {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"cannot convert %s to time in option %s",
-				ucl_object_type_to_string (ucl_object_type (obj)),
-				ucl_object_key (obj));
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"cannot convert %s to time in option %s",
+					ucl_object_type_to_string(ucl_object_type(obj)),
+					ucl_object_key(obj));
 		return FALSE;
 	}
 
@@ -2969,43 +2981,43 @@ rspamd_rcl_parse_struct_time (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_rcl_parse_struct_keypair (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_keypair(rspamd_mempool_t *pool,
+								const ucl_object_t *obj,
+								gpointer ud,
+								struct rspamd_rcl_section *section,
+								GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	struct rspamd_cryptobox_keypair **target, *kp;
 
-	target = (struct rspamd_cryptobox_keypair **)(((gchar *)pd->user_struct) +
-			pd->offset);
+	target = (struct rspamd_cryptobox_keypair **) (((gchar *) pd->user_struct) +
+												   pd->offset);
 	if (obj->type == UCL_OBJECT) {
-		kp = rspamd_keypair_from_ucl (obj);
+		kp = rspamd_keypair_from_ucl(obj);
 
 		if (kp != NULL) {
-			rspamd_mempool_add_destructor (pool,
-					(rspamd_mempool_destruct_t)rspamd_keypair_unref, kp);
+			rspamd_mempool_add_destructor(pool,
+										  (rspamd_mempool_destruct_t) rspamd_keypair_unref, kp);
 			*target = kp;
 		}
 		else {
-			gchar *dump = ucl_object_emit (obj, UCL_EMIT_JSON_COMPACT);
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot load the keypair specified: %s; section: %s; value: %s",
-					ucl_object_key (obj), section->name, dump);
-			free (dump);
+			gchar *dump = ucl_object_emit(obj, UCL_EMIT_JSON_COMPACT);
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot load the keypair specified: %s; section: %s; value: %s",
+						ucl_object_key(obj), section->name, dump);
+			free(dump);
 
 			return FALSE;
 		}
 	}
 	else {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"no sane pubkey or privkey found in the keypair: %s",
-				ucl_object_key (obj));
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"no sane pubkey or privkey found in the keypair: %s",
+					ucl_object_key(obj));
 		return FALSE;
 	}
 
@@ -3013,18 +3025,18 @@ rspamd_rcl_parse_struct_keypair (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_rcl_parse_struct_pubkey (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_pubkey(rspamd_mempool_t *pool,
+							   const ucl_object_t *obj,
+							   gpointer ud,
+							   struct rspamd_rcl_section *section,
+							   GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	struct rspamd_cryptobox_pubkey **target, *pk;
 	gsize len;
 	const gchar *str;
 	gint keypair_type = RSPAMD_KEYPAIR_KEX,
-			keypair_mode = RSPAMD_CRYPTOBOX_MODE_25519;
+		 keypair_mode = RSPAMD_CRYPTOBOX_MODE_25519;
 
 	if (pd->flags & RSPAMD_CL_FLAG_SIGNKEY) {
 		keypair_type = RSPAMD_KEYPAIR_SIGN;
@@ -3033,43 +3045,43 @@ rspamd_rcl_parse_struct_pubkey (rspamd_mempool_t *pool,
 		keypair_mode = RSPAMD_CRYPTOBOX_MODE_NIST;
 	}
 
-	target = (struct rspamd_cryptobox_pubkey **)(((gchar *)pd->user_struct) +
-			pd->offset);
+	target = (struct rspamd_cryptobox_pubkey **) (((gchar *) pd->user_struct) +
+												  pd->offset);
 	if (obj->type == UCL_STRING) {
-		str = ucl_object_tolstring (obj, &len);
-		pk = rspamd_pubkey_from_base32 (str, len, keypair_type,
-				keypair_mode);
+		str = ucl_object_tolstring(obj, &len);
+		pk = rspamd_pubkey_from_base32(str, len, keypair_type,
+									   keypair_mode);
 
 		if (pk != NULL) {
 			*target = pk;
 		}
 		else {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot load the pubkey specified: %s",
-					ucl_object_key (obj));
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot load the pubkey specified: %s",
+						ucl_object_key(obj));
 			return FALSE;
 		}
 	}
 	else {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"no sane pubkey found in the element: %s",
-				ucl_object_key (obj));
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"no sane pubkey found in the element: %s",
+					ucl_object_key(obj));
 		return FALSE;
 	}
 
-	rspamd_mempool_add_destructor (pool,
-			(rspamd_mempool_destruct_t)rspamd_pubkey_unref, pk);
+	rspamd_mempool_add_destructor(pool,
+								  (rspamd_mempool_destruct_t) rspamd_pubkey_unref, pk);
 
 	return TRUE;
 }
 
 static void
-rspamd_rcl_insert_string_list_item (gpointer *target, rspamd_mempool_t *pool,
-		const gchar *src, gboolean is_hash)
+rspamd_rcl_insert_string_list_item(gpointer *target, rspamd_mempool_t *pool,
+								   const gchar *src, gboolean is_hash)
 {
 	union {
 		GHashTable *hv;
@@ -3082,28 +3094,28 @@ rspamd_rcl_insert_string_list_item (gpointer *target, rspamd_mempool_t *pool,
 
 	if (is_hash) {
 		if (d.hv == NULL) {
-			d.hv = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
-			rspamd_mempool_add_destructor (pool,
-					(rspamd_mempool_destruct_t)g_hash_table_unref, d.hv);
+			d.hv = g_hash_table_new(rspamd_str_hash, rspamd_str_equal);
+			rspamd_mempool_add_destructor(pool,
+										  (rspamd_mempool_destruct_t) g_hash_table_unref, d.hv);
 		}
 
-		val = rspamd_mempool_strdup (pool, src);
-		g_hash_table_insert (d.hv, val, val);
+		val = rspamd_mempool_strdup(pool, src);
+		g_hash_table_insert(d.hv, val, val);
 	}
 	else {
-		val = rspamd_mempool_strdup (pool, src);
-		d.lv = g_list_prepend (d.lv, val);
+		val = rspamd_mempool_strdup(pool, src);
+		d.lv = g_list_prepend(d.lv, val);
 	}
 
 	*target = d.p;
 }
 
 gboolean
-rspamd_rcl_parse_struct_string_list (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_string_list(rspamd_mempool_t *pool,
+									const ucl_object_t *obj,
+									gpointer ud,
+									struct rspamd_rcl_section *section,
+									GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	gpointer *target;
@@ -3115,57 +3127,57 @@ rspamd_rcl_parse_struct_string_list (rspamd_mempool_t *pool,
 
 
 	is_hash = pd->flags & RSPAMD_CL_FLAG_STRING_LIST_HASH;
-	target = (gpointer *)(((gchar *)pd->user_struct) + pd->offset);
+	target = (gpointer *) (((gchar *) pd->user_struct) + pd->offset);
 
 	if (!is_hash && *target != NULL) {
 		need_destructor = FALSE;
 	}
 
-	iter = ucl_object_iterate_new (obj);
+	iter = ucl_object_iterate_new(obj);
 
-	while ((cur = ucl_object_iterate_safe (iter, true)) != NULL) {
+	while ((cur = ucl_object_iterate_safe(iter, true)) != NULL) {
 		switch (cur->type) {
 		case UCL_STRING:
-			strvec = g_strsplit_set (ucl_object_tostring (cur), ",", -1);
+			strvec = g_strsplit_set(ucl_object_tostring(cur), ",", -1);
 			cvec = strvec;
 
 			while (*cvec) {
-				rspamd_rcl_insert_string_list_item (target, pool, *cvec, is_hash);
-				cvec ++;
+				rspamd_rcl_insert_string_list_item(target, pool, *cvec, is_hash);
+				cvec++;
 			}
 
-			g_strfreev (strvec);
+			g_strfreev(strvec);
 			/* Go to the next object */
 			continue;
 		case UCL_INT:
-			val = rspamd_mempool_alloc (pool, num_str_len);
-			rspamd_snprintf (val, num_str_len, "%L", cur->value.iv);
+			val = rspamd_mempool_alloc(pool, num_str_len);
+			rspamd_snprintf(val, num_str_len, "%L", cur->value.iv);
 			break;
 		case UCL_FLOAT:
-			val = rspamd_mempool_alloc (pool, num_str_len);
-			rspamd_snprintf (val, num_str_len, "%f", cur->value.dv);
+			val = rspamd_mempool_alloc(pool, num_str_len);
+			rspamd_snprintf(val, num_str_len, "%f", cur->value.dv);
 			break;
 		case UCL_BOOLEAN:
-			val = rspamd_mempool_alloc (pool, num_str_len);
-			rspamd_snprintf (val, num_str_len, "%s",
-					((gboolean)cur->value.iv) ? "true" : "false");
+			val = rspamd_mempool_alloc(pool, num_str_len);
+			rspamd_snprintf(val, num_str_len, "%s",
+							((gboolean) cur->value.iv) ? "true" : "false");
 			break;
 		default:
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot convert %s to a string list in option %s",
-					ucl_object_type_to_string (ucl_object_type (obj)),
-					ucl_object_key (obj));
-			ucl_object_iterate_free (iter);
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot convert %s to a string list in option %s",
+						ucl_object_type_to_string(ucl_object_type(obj)),
+						ucl_object_key(obj));
+			ucl_object_iterate_free(iter);
 
 			return FALSE;
 		}
 
-		rspamd_rcl_insert_string_list_item (target, pool, val, is_hash);
+		rspamd_rcl_insert_string_list_item(target, pool, val, is_hash);
 	}
 
-	ucl_object_iterate_free (iter);
+	ucl_object_iterate_free(iter);
 
 #if 0
 	/* WTF: why don't we allow empty list here?? */
@@ -3182,12 +3194,12 @@ rspamd_rcl_parse_struct_string_list (rspamd_mempool_t *pool,
 #endif
 
 	if (!is_hash && *target != NULL) {
-		*target = g_list_reverse (*target);
+		*target = g_list_reverse(*target);
 
 		if (need_destructor) {
-			rspamd_mempool_add_destructor (pool,
-					(rspamd_mempool_destruct_t) g_list_free,
-					*target);
+			rspamd_mempool_add_destructor(pool,
+										  (rspamd_mempool_destruct_t) g_list_free,
+										  *target);
 		}
 	}
 
@@ -3195,16 +3207,16 @@ rspamd_rcl_parse_struct_string_list (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_rcl_parse_struct_ucl (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_ucl(rspamd_mempool_t *pool,
+							const ucl_object_t *obj,
+							gpointer ud,
+							struct rspamd_rcl_section *section,
+							GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	const ucl_object_t **target;
 
-	target = (const ucl_object_t **)(((gchar *)pd->user_struct) + pd->offset);
+	target = (const ucl_object_t **) (((gchar *) pd->user_struct) + pd->offset);
 
 	*target = obj;
 
@@ -3213,16 +3225,16 @@ rspamd_rcl_parse_struct_ucl (rspamd_mempool_t *pool,
 
 
 gboolean
-rspamd_rcl_parse_struct_boolean (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_boolean(rspamd_mempool_t *pool,
+								const ucl_object_t *obj,
+								gpointer ud,
+								struct rspamd_rcl_section *section,
+								GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	gboolean *target;
 
-	target = (gboolean *)(((gchar *)pd->user_struct) + pd->offset);
+	target = (gboolean *) (((gchar *) pd->user_struct) + pd->offset);
 
 	if (obj->type == UCL_BOOLEAN) {
 		*target = obj->value.iv;
@@ -3231,12 +3243,12 @@ rspamd_rcl_parse_struct_boolean (rspamd_mempool_t *pool,
 		*target = obj->value.iv;
 	}
 	else {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"cannot convert %s to boolean in option %s",
-				ucl_object_type_to_string (ucl_object_type (obj)),
-				ucl_object_key (obj));
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"cannot convert %s to boolean in option %s",
+					ucl_object_type_to_string(ucl_object_type(obj)),
+					ucl_object_key(obj));
 		return FALSE;
 	}
 
@@ -3248,38 +3260,38 @@ rspamd_rcl_parse_struct_boolean (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_rcl_parse_struct_addr (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_addr(rspamd_mempool_t *pool,
+							 const ucl_object_t *obj,
+							 gpointer ud,
+							 struct rspamd_rcl_section *section,
+							 GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	rspamd_inet_addr_t **target;
 	const gchar *val;
 	gsize size;
 
-	target = (rspamd_inet_addr_t **)(((gchar *)pd->user_struct) + pd->offset);
+	target = (rspamd_inet_addr_t **) (((gchar *) pd->user_struct) + pd->offset);
 
-	if (ucl_object_type (obj) == UCL_STRING) {
-		val = ucl_object_tolstring (obj, &size);
+	if (ucl_object_type(obj) == UCL_STRING) {
+		val = ucl_object_tolstring(obj, &size);
 
-		if (!rspamd_parse_inet_address (target, val, size,
-				RSPAMD_INET_ADDRESS_PARSE_DEFAULT)) {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"cannot parse inet address: %s", val);
+		if (!rspamd_parse_inet_address(target, val, size,
+									   RSPAMD_INET_ADDRESS_PARSE_DEFAULT)) {
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot parse inet address: %s", val);
 			return FALSE;
 		}
 	}
 	else {
-		g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"cannot convert %s to inet address in option %s",
-				ucl_object_type_to_string (ucl_object_type (obj)),
-				ucl_object_key (obj));
+		g_set_error(err,
+					CFG_RCL_ERROR,
+					EINVAL,
+					"cannot convert %s to inet address in option %s",
+					ucl_object_type_to_string(ucl_object_type(obj)),
+					ucl_object_key(obj));
 		return FALSE;
 	}
 
@@ -3287,11 +3299,11 @@ rspamd_rcl_parse_struct_addr (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_rcl_parse_struct_mime_addr (rspamd_mempool_t *pool,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_mime_addr(rspamd_mempool_t *pool,
+								  const ucl_object_t *obj,
+								  gpointer ud,
+								  struct rspamd_rcl_section *section,
+								  GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	GPtrArray **target, *tmp_addr = NULL;
@@ -3299,67 +3311,66 @@ rspamd_rcl_parse_struct_mime_addr (rspamd_mempool_t *pool,
 	ucl_object_iter_t it;
 	const ucl_object_t *cur;
 
-	target = (GPtrArray **)(((gchar *)pd->user_struct) + pd->offset);
-	it = ucl_object_iterate_new (obj);
+	target = (GPtrArray **) (((gchar *) pd->user_struct) + pd->offset);
+	it = ucl_object_iterate_new(obj);
 
-	while ((cur = ucl_object_iterate_safe (it, true)) != NULL) {
-		if (ucl_object_type (cur) == UCL_STRING) {
-			val = ucl_object_tostring (obj);
-			tmp_addr = rspamd_email_address_from_mime (pool, val,
-					strlen (val), tmp_addr, -1);
+	while ((cur = ucl_object_iterate_safe(it, true)) != NULL) {
+		if (ucl_object_type(cur) == UCL_STRING) {
+			val = ucl_object_tostring(obj);
+			tmp_addr = rspamd_email_address_from_mime(pool, val,
+													  strlen(val), tmp_addr, -1);
 		}
 		else {
-			g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot get inet address from ucl object in %s",
-					ucl_object_key (obj));
-			ucl_object_iterate_free (it);
+			g_set_error(err,
+						CFG_RCL_ERROR,
+						EINVAL,
+						"cannot get inet address from ucl object in %s",
+						ucl_object_key(obj));
+			ucl_object_iterate_free(it);
 
 			return FALSE;
 		}
 	}
 
-	ucl_object_iterate_free (it);
+	ucl_object_iterate_free(it);
 	*target = tmp_addr;
 
 	return TRUE;
 }
 
 static guint
-rspamd_worker_param_key_hash (gconstpointer p)
+rspamd_worker_param_key_hash(gconstpointer p)
 {
 	const struct rspamd_worker_param_key *k = p;
 	rspamd_cryptobox_fast_hash_state_t st;
 
-	rspamd_cryptobox_fast_hash_init (&st, rspamd_hash_seed ());
-	rspamd_cryptobox_fast_hash_update (&st, k->name, strlen (k->name));
-	rspamd_cryptobox_fast_hash_update (&st, &k->ptr, sizeof (gpointer));
+	rspamd_cryptobox_fast_hash_init(&st, rspamd_hash_seed());
+	rspamd_cryptobox_fast_hash_update(&st, k->name, strlen(k->name));
+	rspamd_cryptobox_fast_hash_update(&st, &k->ptr, sizeof(gpointer));
 
-	return rspamd_cryptobox_fast_hash_final (&st);
+	return rspamd_cryptobox_fast_hash_final(&st);
 }
 
 static gboolean
-rspamd_worker_param_key_equal (gconstpointer p1, gconstpointer p2)
+rspamd_worker_param_key_equal(gconstpointer p1, gconstpointer p2)
 {
 	const struct rspamd_worker_param_key *k1 = p1, *k2 = p2;
 
 	if (k1->ptr == k2->ptr) {
-		return strcmp (k1->name, k2->name) == 0;
+		return strcmp(k1->name, k2->name) == 0;
 	}
 
 	return FALSE;
 }
 
-void
-rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
-		GQuark type,
-		const gchar *name,
-		rspamd_rcl_default_handler_t handler,
-		gpointer target,
-		glong offset,
-		gint flags,
-		const gchar *doc_string)
+void rspamd_rcl_register_worker_option(struct rspamd_config *cfg,
+									   GQuark type,
+									   const gchar *name,
+									   rspamd_rcl_default_handler_t handler,
+									   gpointer target,
+									   glong offset,
+									   gint flags,
+									   const gchar *doc_string)
 {
 	struct rspamd_worker_param_parser *nhandler;
 	struct rspamd_worker_cfg_parser *nparser;
@@ -3367,30 +3378,30 @@ rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
 	const ucl_object_t *doc_workers, *doc_target;
 	ucl_object_t *doc_obj;
 
-	nparser = g_hash_table_lookup (cfg->wrk_parsers, &type);
+	nparser = g_hash_table_lookup(cfg->wrk_parsers, &type);
 
 	if (nparser == NULL) {
-		rspamd_rcl_register_worker_parser (cfg, type, NULL, NULL);
-		nparser = g_hash_table_lookup (cfg->wrk_parsers, &type);
+		rspamd_rcl_register_worker_parser(cfg, type, NULL, NULL);
+		nparser = g_hash_table_lookup(cfg->wrk_parsers, &type);
 
-		g_assert (nparser != NULL);
+		g_assert(nparser != NULL);
 	}
 
 	srch.name = name;
 	srch.ptr = target;
 
-	nhandler = g_hash_table_lookup (nparser->parsers, &srch);
+	nhandler = g_hash_table_lookup(nparser->parsers, &srch);
 	if (nhandler != NULL) {
-		msg_warn_config (
+		msg_warn_config(
 			"handler for parameter %s is already registered for worker type %s",
 			name,
-			g_quark_to_string (type));
+			g_quark_to_string(type));
 		return;
 	}
 
 	nhandler =
-		rspamd_mempool_alloc0 (cfg->cfg_pool,
-			sizeof (struct rspamd_worker_param_parser));
+		rspamd_mempool_alloc0(cfg->cfg_pool,
+							  sizeof(struct rspamd_worker_param_parser));
 	nhandler->key.name = name;
 	nhandler->key.ptr = target;
 	nhandler->parser.flags = flags;
@@ -3398,56 +3409,55 @@ rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
 	nhandler->parser.user_struct = target;
 	nhandler->handler = handler;
 
-	g_hash_table_insert (nparser->parsers, &nhandler->key, nhandler);
+	g_hash_table_insert(nparser->parsers, &nhandler->key, nhandler);
 
-	doc_workers = ucl_object_lookup (cfg->doc_strings, "workers");
+	doc_workers = ucl_object_lookup(cfg->doc_strings, "workers");
 
 	if (doc_workers == NULL) {
-		doc_obj = ucl_object_typed_new (UCL_OBJECT);
-		ucl_object_insert_key (cfg->doc_strings, doc_obj, "workers", 0, false);
+		doc_obj = ucl_object_typed_new(UCL_OBJECT);
+		ucl_object_insert_key(cfg->doc_strings, doc_obj, "workers", 0, false);
 		doc_workers = doc_obj;
 	}
 
-	doc_target = ucl_object_lookup (doc_workers, g_quark_to_string (type));
+	doc_target = ucl_object_lookup(doc_workers, g_quark_to_string(type));
 
 	if (doc_target == NULL) {
-		doc_obj = ucl_object_typed_new (UCL_OBJECT);
-		ucl_object_insert_key ((ucl_object_t *)doc_workers, doc_obj,
-				g_quark_to_string (type), 0, true);
+		doc_obj = ucl_object_typed_new(UCL_OBJECT);
+		ucl_object_insert_key((ucl_object_t *) doc_workers, doc_obj,
+							  g_quark_to_string(type), 0, true);
 		doc_target = doc_obj;
 	}
 
-	rspamd_rcl_add_doc_obj ((ucl_object_t *) doc_target,
-			doc_string,
-			name,
-			UCL_NULL,
-			handler,
-			flags,
-			NULL,
-			0);
+	rspamd_rcl_add_doc_obj((ucl_object_t *) doc_target,
+						   doc_string,
+						   name,
+						   UCL_NULL,
+						   handler,
+						   flags,
+						   NULL,
+						   0);
 }
 
 
-void
-rspamd_rcl_register_worker_parser (struct rspamd_config *cfg, gint type,
-	gboolean (*func)(ucl_object_t *, gpointer), gpointer ud)
+void rspamd_rcl_register_worker_parser(struct rspamd_config *cfg, gint type,
+									   gboolean (*func)(ucl_object_t *, gpointer), gpointer ud)
 {
 	struct rspamd_worker_cfg_parser *nparser;
 
-	nparser = g_hash_table_lookup (cfg->wrk_parsers, &type);
+	nparser = g_hash_table_lookup(cfg->wrk_parsers, &type);
 
 	if (nparser == NULL) {
 		/* Allocate new parser for this worker */
 		nparser =
-			rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (struct rspamd_worker_cfg_parser));
+			rspamd_mempool_alloc0(cfg->cfg_pool,
+								  sizeof(struct rspamd_worker_cfg_parser));
 		nparser->type = type;
-		nparser->parsers = g_hash_table_new (rspamd_worker_param_key_hash,
-				rspamd_worker_param_key_equal);
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-				(rspamd_mempool_destruct_t)g_hash_table_unref, nparser->parsers);
+		nparser->parsers = g_hash_table_new(rspamd_worker_param_key_hash,
+											rspamd_worker_param_key_equal);
+		rspamd_mempool_add_destructor(cfg->cfg_pool,
+									  (rspamd_mempool_destruct_t) g_hash_table_unref, nparser->parsers);
 
-		g_hash_table_insert (cfg->wrk_parsers, &nparser->type, nparser);
+		g_hash_table_insert(cfg->wrk_parsers, &nparser->type, nparser);
 	}
 
 	nparser->def_obj_parser = func;
@@ -3456,7 +3466,7 @@ rspamd_rcl_register_worker_parser (struct rspamd_config *cfg, gint type,
 
 /* Checksum functions */
 static int
-rspamd_rcl_emitter_append_c (unsigned char c, size_t nchars, void *ud)
+rspamd_rcl_emitter_append_c(unsigned char c, size_t nchars, void *ud)
 {
 	rspamd_cryptobox_hash_state_t *hs = ud;
 	guint64 d[2];
@@ -3464,61 +3474,62 @@ rspamd_rcl_emitter_append_c (unsigned char c, size_t nchars, void *ud)
 	d[0] = nchars;
 	d[1] = c;
 
-	rspamd_cryptobox_hash_update (hs, (const guchar *)d, sizeof (d));
+	rspamd_cryptobox_hash_update(hs, (const guchar *) d, sizeof(d));
 
 	return 0;
 }
 
 static int
-rspamd_rcl_emitter_append_len (unsigned const char *str, size_t len, void *ud)
+rspamd_rcl_emitter_append_len(unsigned const char *str, size_t len, void *ud)
 {
 	rspamd_cryptobox_hash_state_t *hs = ud;
 
-	rspamd_cryptobox_hash_update (hs, str, len);
+	rspamd_cryptobox_hash_update(hs, str, len);
 
 	return 0;
 }
 static int
-rspamd_rcl_emitter_append_int (int64_t elt, void *ud)
+rspamd_rcl_emitter_append_int(int64_t elt, void *ud)
 {
 	rspamd_cryptobox_hash_state_t *hs = ud;
 
-	rspamd_cryptobox_hash_update (hs, (const guchar *)&elt, sizeof (elt));
+	rspamd_cryptobox_hash_update(hs, (const guchar *) &elt, sizeof(elt));
 
 	return 0;
 }
 
 static int
-rspamd_rcl_emitter_append_double (double elt, void *ud)
+rspamd_rcl_emitter_append_double(double elt, void *ud)
 {
 	rspamd_cryptobox_hash_state_t *hs = ud;
 
-	rspamd_cryptobox_hash_update (hs, (const guchar *)&elt, sizeof (elt));
+	rspamd_cryptobox_hash_update(hs, (const guchar *) &elt, sizeof(elt));
 
 	return 0;
 }
 
-void
-rspamd_rcl_section_free (gpointer p)
+void rspamd_rcl_section_free(gpointer p)
 {
 	struct rspamd_rcl_section *top = p, *cur, *tmp;
 	struct rspamd_rcl_default_handler_data *dh, *dhtmp;
 
-	HASH_ITER (hh, top, cur, tmp) {
-		HASH_DEL (top, cur);
+	HASH_ITER(hh, top, cur, tmp)
+	{
+		HASH_DEL(top, cur);
 
 		if (cur->subsections) {
-			rspamd_rcl_section_free (cur->subsections);
+			rspamd_rcl_section_free(cur->subsections);
 		}
 
-		HASH_ITER (hh, cur->default_parser, dh, dhtmp) {
-			HASH_DEL (cur->default_parser, dh);
-			g_free (dh->key);
-			g_free (dh);
+		HASH_ITER(hh, cur->default_parser, dh, dhtmp)
+		{
+			HASH_DEL(cur->default_parser, dh);
+			g_free(dh->key);
+			g_free(dh);
 		}
 
-		ucl_object_unref (cur->doc_ref);
-		g_free (cur);
+		ucl_object_unref(cur->doc_ref);
+		g_free(cur);
 	}
 }
 
@@ -3541,79 +3552,78 @@ rspamd_rcl_section_free (gpointer p)
  * it is changed, then rcl_obj is imported from lua. Old config is dereferenced.
  * @param cfg
  */
-void
-rspamd_rcl_maybe_apply_lua_transform (struct rspamd_config *cfg)
+void rspamd_rcl_maybe_apply_lua_transform(struct rspamd_config *cfg)
 {
 	lua_State *L = cfg->lua_state;
 	gint err_idx, ret;
 	gchar str[PATH_MAX];
 	static const char *transform_script = "lua_cfg_transform";
 
-	g_assert (L != NULL);
+	g_assert(L != NULL);
 
-	rspamd_snprintf (str, sizeof (str), "return require \"%s\"",
-			transform_script);
+	rspamd_snprintf(str, sizeof(str), "return require \"%s\"",
+					transform_script);
 
-	if (luaL_dostring (L, str) != 0) {
-		msg_warn_config ("cannot execute lua script %s: %s",
-				str, lua_tostring (L, -1));
+	if (luaL_dostring(L, str) != 0) {
+		msg_warn_config("cannot execute lua script %s: %s",
+						str, lua_tostring(L, -1));
 		return;
 	}
 	else {
 #if LUA_VERSION_NUM >= 504
 		lua_settop(L, -2);
 #endif
-		if (lua_type (L, -1) != LUA_TFUNCTION) {
-			msg_warn_config ("lua script must return "
-					"function and not %s",
-					lua_typename (L, lua_type (L, -1)));
+		if (lua_type(L, -1) != LUA_TFUNCTION) {
+			msg_warn_config("lua script must return "
+							"function and not %s",
+							lua_typename(L, lua_type(L, -1)));
 
 			return;
 		}
 	}
 
-	lua_pushcfunction (L, &rspamd_lua_traceback);
-	err_idx = lua_gettop (L);
+	lua_pushcfunction(L, &rspamd_lua_traceback);
+	err_idx = lua_gettop(L);
 
 	/* Push function */
-	lua_pushvalue (L, -2);
+	lua_pushvalue(L, -2);
 
 	/* Push the existing config */
-	ucl_object_push_lua (L, cfg->rcl_obj, true);
+	ucl_object_push_lua(L, cfg->rcl_obj, true);
 
-	if ((ret = lua_pcall (L, 1, 2, err_idx)) != 0) {
-		msg_err ("call to rspamadm lua script failed (%d): %s", ret,
-				lua_tostring (L, -1));
-		lua_settop (L, 0);
+	if ((ret = lua_pcall(L, 1, 2, err_idx)) != 0) {
+		msg_err("call to rspamadm lua script failed (%d): %s", ret,
+				lua_tostring(L, -1));
+		lua_settop(L, 0);
 
 		return;
 	}
 
-	if (lua_toboolean (L, -2) && lua_type (L, -1) == LUA_TTABLE) {
+	if (lua_toboolean(L, -2) && lua_type(L, -1) == LUA_TTABLE) {
 		ucl_object_t *old_cfg = cfg->rcl_obj;
 
-		msg_info_config ("configuration has been transformed in Lua");
-		cfg->rcl_obj = ucl_object_lua_import (L, -1);
-		ucl_object_unref (old_cfg);
+		msg_info_config("configuration has been transformed in Lua");
+		cfg->rcl_obj = ucl_object_lua_import(L, -1);
+		ucl_object_unref(old_cfg);
 	}
 
 	/* error function */
-	lua_settop (L, 0);
+	lua_settop(L, 0);
 }
 
 static bool
-rspamd_rcl_decrypt_handler (struct ucl_parser *parser,
+rspamd_rcl_decrypt_handler(struct ucl_parser *parser,
 						   const unsigned char *source, size_t source_len,
 						   unsigned char **destination, size_t *dest_len,
 						   void *user_data)
 {
 	GError *err = NULL;
-	struct rspamd_cryptobox_keypair *kp = (struct rspamd_cryptobox_keypair *)user_data;
+	struct rspamd_cryptobox_keypair *kp = (struct rspamd_cryptobox_keypair *) user_data;
 
-	if (!rspamd_keypair_decrypt (kp, source, source_len,
-			destination, dest_len, &err)) {
-		msg_err ("cannot decrypt file: %e", err);
-		g_error_free (err);
+	if (!rspamd_keypair_decrypt(kp, source, source_len,
+								destination, dest_len, &err)) {
+		msg_err("cannot decrypt file: %e", err);
+		g_error_free(err);
 
 		return false;
 	}
@@ -3622,98 +3632,97 @@ rspamd_rcl_decrypt_handler (struct ucl_parser *parser,
 }
 
 static bool
-rspamd_rcl_jinja_handler (struct ucl_parser *parser,
-						   const unsigned char *source, size_t source_len,
-						   unsigned char **destination, size_t *dest_len,
-						   void *user_data)
+rspamd_rcl_jinja_handler(struct ucl_parser *parser,
+						 const unsigned char *source, size_t source_len,
+						 unsigned char **destination, size_t *dest_len,
+						 void *user_data)
 {
-	struct rspamd_config *cfg = (struct rspamd_config *)user_data;
+	struct rspamd_config *cfg = (struct rspamd_config *) user_data;
 	lua_State *L = cfg->lua_state;
 	gint err_idx;
 
-	lua_pushcfunction (L, &rspamd_lua_traceback);
-	err_idx = lua_gettop (L);
+	lua_pushcfunction(L, &rspamd_lua_traceback);
+	err_idx = lua_gettop(L);
 
 	/* Obtain function */
-	if (!rspamd_lua_require_function (L, "lua_util", "jinja_template")) {
-		msg_err_config ("cannot require lua_util.jinja_template");
-		lua_settop (L, err_idx - 1);
+	if (!rspamd_lua_require_function(L, "lua_util", "jinja_template")) {
+		msg_err_config("cannot require lua_util.jinja_template");
+		lua_settop(L, err_idx - 1);
 
 		return false;
 	}
 
-	lua_pushlstring (L, source, source_len);
-	lua_getglobal (L, "rspamd_env");
-	lua_pushboolean (L, false);
+	lua_pushlstring(L, source, source_len);
+	lua_getglobal(L, "rspamd_env");
+	lua_pushboolean(L, false);
 
-	if (lua_pcall (L, 3, 1, err_idx) != 0) {
-		msg_err_config ("cannot call lua jinja_template script: %s",
-				lua_tostring (L, -1));
-		lua_settop (L, err_idx - 1);
+	if (lua_pcall(L, 3, 1, err_idx) != 0) {
+		msg_err_config("cannot call lua jinja_template script: %s",
+					   lua_tostring(L, -1));
+		lua_settop(L, err_idx - 1);
 
 		return false;
 	}
 
-	if (lua_type (L, -1) == LUA_TSTRING) {
+	if (lua_type(L, -1) == LUA_TSTRING) {
 		const char *ndata;
 		gsize nsize;
 
-		ndata = lua_tolstring (L, -1, &nsize);
-		*destination = UCL_ALLOC (nsize);
-		memcpy (*destination, ndata, nsize);
+		ndata = lua_tolstring(L, -1, &nsize);
+		*destination = UCL_ALLOC(nsize);
+		memcpy(*destination, ndata, nsize);
 		*dest_len = nsize;
 	}
 	else {
-		msg_err_config ("invalid return type when templating jinja %s",
-				lua_typename (L, lua_type (L, -1)));
-		lua_settop (L, err_idx - 1);
+		msg_err_config("invalid return type when templating jinja %s",
+					   lua_typename(L, lua_type(L, -1)));
+		lua_settop(L, err_idx - 1);
 
 		return false;
 	}
 
-	lua_settop (L, err_idx - 1);
+	lua_settop(L, err_idx - 1);
 
 	return true;
 }
 
 static void
-rspamd_rcl_decrypt_free (unsigned char *data, size_t len, void *user_data)
+rspamd_rcl_decrypt_free(unsigned char *data, size_t len, void *user_data)
 {
-	g_free (data);
+	g_free(data);
 }
 
-void
-rspamd_config_calculate_cksum (struct rspamd_config *cfg)
+void rspamd_config_calculate_cksum(struct rspamd_config *cfg)
 {
 	rspamd_cryptobox_hash_state_t hs;
 	unsigned char cksumbuf[rspamd_cryptobox_HASHBYTES];
 	struct ucl_emitter_functions f;
 
 	/* Calculate checksum */
-	rspamd_cryptobox_hash_init (&hs, NULL, 0);
+	rspamd_cryptobox_hash_init(&hs, NULL, 0);
 	f.ucl_emitter_append_character = rspamd_rcl_emitter_append_c;
 	f.ucl_emitter_append_double = rspamd_rcl_emitter_append_double;
 	f.ucl_emitter_append_int = rspamd_rcl_emitter_append_int;
 	f.ucl_emitter_append_len = rspamd_rcl_emitter_append_len;
 	f.ucl_emitter_free_func = NULL;
 	f.ud = &hs;
-	ucl_object_emit_full (cfg->rcl_obj, UCL_EMIT_MSGPACK,
-			&f, cfg->config_comments);
-	rspamd_cryptobox_hash_final (&hs, cksumbuf);
-	cfg->checksum = rspamd_encode_base32 (cksumbuf, sizeof (cksumbuf), RSPAMD_BASE32_DEFAULT);
+	ucl_object_emit_full(cfg->rcl_obj, UCL_EMIT_MSGPACK,
+						 &f, cfg->config_comments);
+	rspamd_cryptobox_hash_final(&hs, cksumbuf);
+	cfg->checksum = rspamd_encode_base32(cksumbuf, sizeof(cksumbuf), RSPAMD_BASE32_DEFAULT);
 	/* Also change the tag of cfg pool to be equal to the checksum */
-	rspamd_strlcpy (cfg->cfg_pool->tag.uid, cfg->checksum,
-			MIN (sizeof (cfg->cfg_pool->tag.uid), strlen (cfg->checksum)));
+	rspamd_strlcpy(cfg->cfg_pool->tag.uid, cfg->checksum,
+				   MIN(sizeof(cfg->cfg_pool->tag.uid), strlen(cfg->checksum)));
 }
 
 gboolean
-rspamd_config_parse_ucl (struct rspamd_config *cfg,
-						 const gchar *filename,
-						 GHashTable *vars,
-						 ucl_include_trace_func_t inc_trace,
-						 void *trace_data,
-						 gboolean skip_jinja,
-						 GError **err)
+rspamd_config_parse_ucl(struct rspamd_config *cfg,
+						const gchar *filename,
+						GHashTable *vars,
+						ucl_include_trace_func_t inc_trace,
+						void *trace_data,
+						gboolean skip_jinja,
+						GError **err)
 {
 	struct stat st;
 	gint fd;
@@ -3722,175 +3731,175 @@ rspamd_config_parse_ucl (struct rspamd_config *cfg,
 	struct rspamd_cryptobox_keypair *decrypt_keypair = NULL;
 	gchar *data;
 
-	if ((fd = open (filename, O_RDONLY)) == -1) {
-		g_set_error (err, cfg_rcl_error_quark (), errno,
-				"cannot open %s: %s", filename, strerror (errno));
+	if ((fd = open(filename, O_RDONLY)) == -1) {
+		g_set_error(err, cfg_rcl_error_quark(), errno,
+					"cannot open %s: %s", filename, strerror(errno));
 		return FALSE;
-
 	}
-	if (fstat (fd, &st) == -1) {
-		g_set_error (err, cfg_rcl_error_quark (), errno,
-				"cannot stat %s: %s", filename, strerror (errno));
-		close (fd);
+	if (fstat(fd, &st) == -1) {
+		g_set_error(err, cfg_rcl_error_quark(), errno,
+					"cannot stat %s: %s", filename, strerror(errno));
+		close(fd);
 
 		return FALSE;
 	}
 	/* Now mmap this file to simplify reading process */
-	if ((data = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
-		g_set_error (err, cfg_rcl_error_quark (), errno,
-				"cannot mmap %s: %s", filename, strerror (errno));
-		close (fd);
+	if ((data = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+		g_set_error(err, cfg_rcl_error_quark(), errno,
+					"cannot mmap %s: %s", filename, strerror(errno));
+		close(fd);
 
 		return FALSE;
 	}
 
-	close (fd);
+	close(fd);
 
 	/* Try to load keyfile if available */
-	rspamd_snprintf (keypair_path, sizeof (keypair_path), "%s.key",
-			filename);
-	if ((fd = open (keypair_path, O_RDONLY)) != -1) {
+	rspamd_snprintf(keypair_path, sizeof(keypair_path), "%s.key",
+					filename);
+	if ((fd = open(keypair_path, O_RDONLY)) != -1) {
 		struct ucl_parser *kp_parser;
 
-		kp_parser = ucl_parser_new (0);
+		kp_parser = ucl_parser_new(0);
 
-		if (ucl_parser_add_fd (kp_parser, fd)) {
+		if (ucl_parser_add_fd(kp_parser, fd)) {
 			ucl_object_t *kp_obj;
 
-			kp_obj = ucl_parser_get_object (kp_parser);
+			kp_obj = ucl_parser_get_object(kp_parser);
 
-			g_assert (kp_obj != NULL);
-			decrypt_keypair = rspamd_keypair_from_ucl (kp_obj);
+			g_assert(kp_obj != NULL);
+			decrypt_keypair = rspamd_keypair_from_ucl(kp_obj);
 
 			if (decrypt_keypair == NULL) {
-				msg_err_config_forced ("cannot load keypair from %s: invalid keypair",
-						keypair_path);
+				msg_err_config_forced("cannot load keypair from %s: invalid keypair",
+									  keypair_path);
 			}
 			else {
 				/* Add decryption support to UCL */
-				rspamd_mempool_add_destructor (cfg->cfg_pool,
-						(rspamd_mempool_destruct_t)rspamd_keypair_unref,
-						decrypt_keypair);
+				rspamd_mempool_add_destructor(cfg->cfg_pool,
+											  (rspamd_mempool_destruct_t) rspamd_keypair_unref,
+											  decrypt_keypair);
 			}
 
-			ucl_object_unref (kp_obj);
+			ucl_object_unref(kp_obj);
 		}
 		else {
-			msg_err_config_forced ("cannot load keypair from %s: %s",
-					keypair_path, ucl_parser_get_error (kp_parser));
+			msg_err_config_forced("cannot load keypair from %s: %s",
+								  keypair_path, ucl_parser_get_error(kp_parser));
 		}
 
-		ucl_parser_free (kp_parser);
-		close (fd);
+		ucl_parser_free(kp_parser);
+		close(fd);
 	}
 
-	parser = ucl_parser_new (UCL_PARSER_SAVE_COMMENTS);
-	rspamd_ucl_add_conf_variables (parser, vars);
-	rspamd_ucl_add_conf_macros (parser, cfg);
-	ucl_parser_set_filevars (parser, filename, true);
+	parser = ucl_parser_new(UCL_PARSER_SAVE_COMMENTS);
+	rspamd_ucl_add_conf_variables(parser, vars);
+	rspamd_ucl_add_conf_macros(parser, cfg);
+	ucl_parser_set_filevars(parser, filename, true);
 
 	if (inc_trace) {
-		ucl_parser_set_include_tracer (parser, inc_trace, trace_data);
+		ucl_parser_set_include_tracer(parser, inc_trace, trace_data);
 	}
 
 	if (decrypt_keypair) {
 		struct ucl_parser_special_handler *decrypt_handler;
 
-		decrypt_handler = rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (*decrypt_handler));
+		decrypt_handler = rspamd_mempool_alloc0(cfg->cfg_pool,
+												sizeof(*decrypt_handler));
 		decrypt_handler->user_data = decrypt_keypair;
 		decrypt_handler->magic = encrypted_magic;
-		decrypt_handler->magic_len = sizeof (encrypted_magic);
+		decrypt_handler->magic_len = sizeof(encrypted_magic);
 		decrypt_handler->handler = rspamd_rcl_decrypt_handler;
 		decrypt_handler->free_function = rspamd_rcl_decrypt_free;
 
-		ucl_parser_add_special_handler (parser, decrypt_handler);
+		ucl_parser_add_special_handler(parser, decrypt_handler);
 	}
 
 	if (!skip_jinja) {
 		struct ucl_parser_special_handler *jinja_handler;
 
-		jinja_handler = rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (*jinja_handler));
+		jinja_handler = rspamd_mempool_alloc0(cfg->cfg_pool,
+											  sizeof(*jinja_handler));
 		jinja_handler->user_data = cfg;
 		jinja_handler->flags = UCL_SPECIAL_HANDLER_PREPROCESS_ALL;
 		jinja_handler->handler = rspamd_rcl_jinja_handler;
 
-		ucl_parser_add_special_handler (parser, jinja_handler);
+		ucl_parser_add_special_handler(parser, jinja_handler);
 	}
 
-	if (!ucl_parser_add_chunk (parser, data, st.st_size)) {
-		g_set_error (err, cfg_rcl_error_quark (), errno,
-				"ucl parser error: %s", ucl_parser_get_error (parser));
-		ucl_parser_free (parser);
-		munmap (data, st.st_size);
+	if (!ucl_parser_add_chunk(parser, data, st.st_size)) {
+		g_set_error(err, cfg_rcl_error_quark(), errno,
+					"ucl parser error: %s", ucl_parser_get_error(parser));
+		ucl_parser_free(parser);
+		munmap(data, st.st_size);
 
 		return FALSE;
 	}
 
-	munmap (data, st.st_size);
-	cfg->rcl_obj = ucl_parser_get_object (parser);
-	cfg->config_comments = ucl_object_ref (ucl_parser_get_comments (parser));
-	ucl_parser_free (parser);
+	munmap(data, st.st_size);
+	cfg->rcl_obj = ucl_parser_get_object(parser);
+	cfg->config_comments = ucl_object_ref(ucl_parser_get_comments(parser));
+	ucl_parser_free(parser);
 
 	return TRUE;
 }
 
 gboolean
-rspamd_config_read (struct rspamd_config *cfg,
-					const gchar *filename,
-					rspamd_rcl_section_fin_t logger_fin,
-					gpointer logger_ud,
-					GHashTable *vars,
-					gboolean skip_jinja,
-					gchar **lua_env)
+rspamd_config_read(struct rspamd_config *cfg,
+				   const gchar *filename,
+				   rspamd_rcl_section_fin_t logger_fin,
+				   gpointer logger_ud,
+				   GHashTable *vars,
+				   gboolean skip_jinja,
+				   gchar **lua_env)
 {
 	GError *err = NULL;
 	struct rspamd_rcl_section *top, *logger_section;
 	const ucl_object_t *logger_obj;
 
-	rspamd_lua_set_path (cfg->lua_state, NULL, vars);
+	rspamd_lua_set_path(cfg->lua_state, NULL, vars);
 
-	if (!rspamd_lua_set_env (cfg->lua_state, vars, lua_env, &err)) {
-		msg_err_config_forced ("failed to set up environment: %e", err);
-		g_error_free (err);
+	if (!rspamd_lua_set_env(cfg->lua_state, vars, lua_env, &err)) {
+		msg_err_config_forced("failed to set up environment: %e", err);
+		g_error_free(err);
 
 		return FALSE;
 	}
 
-	if (!rspamd_config_parse_ucl (cfg, filename, vars, NULL, NULL, skip_jinja, &err)) {
-		msg_err_config_forced ("failed to load config: %e", err);
-		g_error_free (err);
+	if (!rspamd_config_parse_ucl(cfg, filename, vars, NULL, NULL, skip_jinja, &err)) {
+		msg_err_config_forced("failed to load config: %e", err);
+		g_error_free(err);
 
 		return FALSE;
 	}
 
-	top = rspamd_rcl_config_init (cfg, NULL);
+	top = rspamd_rcl_config_init(cfg, NULL);
 	/* Add new paths if defined in options */
-	rspamd_lua_set_path (cfg->lua_state, cfg->rcl_obj, vars);
-	rspamd_lua_set_globals (cfg, cfg->lua_state);
-	rspamd_mempool_add_destructor (cfg->cfg_pool, rspamd_rcl_section_free, top);
+	rspamd_lua_set_path(cfg->lua_state, cfg->rcl_obj, vars);
+	rspamd_lua_set_globals(cfg, cfg->lua_state);
+	rspamd_mempool_add_destructor(cfg->cfg_pool, rspamd_rcl_section_free, top);
 	err = NULL;
 
 	if (logger_fin != NULL) {
-		HASH_FIND_STR (top, "logging", logger_section);
+		HASH_FIND_STR(top, "logging", logger_section);
 
 		if (logger_section != NULL) {
-			logger_obj = ucl_object_lookup_any (cfg->rcl_obj, "logging",
-					"logger", NULL);
+			logger_obj = ucl_object_lookup_any(cfg->rcl_obj, "logging",
+											   "logger", NULL);
 
 			if (logger_obj == NULL) {
-				logger_fin (cfg->cfg_pool, logger_ud);
+				logger_fin(cfg->cfg_pool, logger_ud);
 			}
 			else {
-				if (!rspamd_rcl_process_section (cfg, logger_section, cfg,
-						logger_obj, cfg->cfg_pool, &err)) {
-					msg_err_config_forced ("cannot init logger: %e", err);
-					g_error_free (err);
+				if (!rspamd_rcl_process_section(cfg, logger_section, cfg,
+												logger_obj, cfg->cfg_pool, &err)) {
+					msg_err_config_forced("cannot init logger: %e", err);
+					g_error_free(err);
 
 					return FALSE;
-				} else {
-					logger_fin (cfg->cfg_pool, logger_ud);
+				}
+				else {
+					logger_fin(cfg->cfg_pool, logger_ud);
 				}
 
 				/* Init lua logging */
@@ -3898,79 +3907,79 @@ rspamd_config_read (struct rspamd_config *cfg,
 				gint err_idx;
 				struct rspamd_config **pcfg;
 
-				lua_pushcfunction (L, &rspamd_lua_traceback);
-				err_idx = lua_gettop (L);
+				lua_pushcfunction(L, &rspamd_lua_traceback);
+				err_idx = lua_gettop(L);
 
 				/* Obtain function */
-				if (!rspamd_lua_require_function (L, "lua_util",
-						"init_debug_logging")) {
-					msg_err_config ("cannot require lua_util.init_debug_logging");
-					lua_settop (L, err_idx - 1);
+				if (!rspamd_lua_require_function(L, "lua_util",
+												 "init_debug_logging")) {
+					msg_err_config("cannot require lua_util.init_debug_logging");
+					lua_settop(L, err_idx - 1);
 
 					return FALSE;
 				}
 
-				pcfg = lua_newuserdata (L, sizeof (*pcfg));
+				pcfg = lua_newuserdata(L, sizeof(*pcfg));
 				*pcfg = cfg;
-				rspamd_lua_setclass (L, "rspamd{config}", -1);
+				rspamd_lua_setclass(L, "rspamd{config}", -1);
 
-				if (lua_pcall (L, 1, 0, err_idx) != 0) {
-					msg_err_config ("cannot call lua init_debug_logging script: %s",
-							lua_tostring (L, -1));
-					lua_settop (L, err_idx - 1);
+				if (lua_pcall(L, 1, 0, err_idx) != 0) {
+					msg_err_config("cannot call lua init_debug_logging script: %s",
+								   lua_tostring(L, -1));
+					lua_settop(L, err_idx - 1);
 
 					return FALSE;
 				}
 
-				lua_settop (L, err_idx - 1);
+				lua_settop(L, err_idx - 1);
 			}
 
-			HASH_DEL (top, logger_section);
+			HASH_DEL(top, logger_section);
 		}
 	}
 
 	/* Transform config if needed */
-	rspamd_rcl_maybe_apply_lua_transform (cfg);
-	rspamd_config_calculate_cksum (cfg);
+	rspamd_rcl_maybe_apply_lua_transform(cfg);
+	rspamd_config_calculate_cksum(cfg);
 
-	if (!rspamd_rcl_parse (top, cfg, cfg, cfg->cfg_pool, cfg->rcl_obj, &err)) {
-		msg_err_config ("rcl parse error: %e", err);
+	if (!rspamd_rcl_parse(top, cfg, cfg, cfg->cfg_pool, cfg->rcl_obj, &err)) {
+		msg_err_config("rcl parse error: %e", err);
 
 		if (err) {
-			g_error_free (err);
+			g_error_free(err);
 		}
 
 		return FALSE;
 	}
 
-	cfg->lang_det = rspamd_language_detector_init (cfg);
-	rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)rspamd_language_detector_unref,
-			cfg->lang_det);
+	cfg->lang_det = rspamd_language_detector_init(cfg);
+	rspamd_mempool_add_destructor(cfg->cfg_pool,
+								  (rspamd_mempool_destruct_t) rspamd_language_detector_unref,
+								  cfg->lang_det);
 
 	return TRUE;
 }
 
 static void
-rspamd_rcl_doc_obj_from_handler (ucl_object_t *doc_obj,
-		rspamd_rcl_default_handler_t handler,
-		gint flags)
+rspamd_rcl_doc_obj_from_handler(ucl_object_t *doc_obj,
+								rspamd_rcl_default_handler_t handler,
+								gint flags)
 {
 	gboolean has_example = FALSE, has_type = FALSE;
 	const gchar *type = NULL;
 
-	if (ucl_object_lookup (doc_obj, "example") != NULL) {
+	if (ucl_object_lookup(doc_obj, "example") != NULL) {
 		has_example = TRUE;
 	}
 
-	if (ucl_object_lookup (doc_obj, "type") != NULL) {
+	if (ucl_object_lookup(doc_obj, "type") != NULL) {
 		has_type = TRUE;
 	}
 
 	if (handler == rspamd_rcl_parse_struct_string) {
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj, ucl_object_fromstring ("string"),
-					"type", 0, false);
+			ucl_object_insert_key(doc_obj, ucl_object_fromstring("string"),
+								  "type", 0, false);
 		}
 	}
 	else if (handler == rspamd_rcl_parse_struct_integer) {
@@ -3993,95 +4002,96 @@ rspamd_rcl_doc_obj_from_handler (ucl_object_t *doc_obj,
 		}
 
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj, ucl_object_fromstring (type),
-					"type", 0, false);
+			ucl_object_insert_key(doc_obj, ucl_object_fromstring(type),
+								  "type", 0, false);
 		}
 	}
 	else if (handler == rspamd_rcl_parse_struct_double) {
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj, ucl_object_fromstring ("double"),
-					"type", 0, false);
+			ucl_object_insert_key(doc_obj, ucl_object_fromstring("double"),
+								  "type", 0, false);
 		}
 	}
 	else if (handler == rspamd_rcl_parse_struct_time) {
 		type = "time";
 
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj, ucl_object_fromstring (type),
-					"type", 0, false);
+			ucl_object_insert_key(doc_obj, ucl_object_fromstring(type),
+								  "type", 0, false);
 		}
 	}
 	else if (handler == rspamd_rcl_parse_struct_string_list) {
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj, ucl_object_fromstring ("string list"),
-					"type", 0, false);
+			ucl_object_insert_key(doc_obj, ucl_object_fromstring("string list"),
+								  "type", 0, false);
 		}
 		if (!has_example) {
-			ucl_object_insert_key (doc_obj,
-					ucl_object_fromstring_common ("param = \"str1, str2, str3\" OR "
-							"param = [\"str1\", \"str2\", \"str3\"]", 0, 0),
-					"example",
-					0,
-					false);
+			ucl_object_insert_key(doc_obj,
+								  ucl_object_fromstring_common("param = \"str1, str2, str3\" OR "
+															   "param = [\"str1\", \"str2\", \"str3\"]",
+															   0, 0),
+								  "example",
+								  0,
+								  false);
 		}
 	}
 	else if (handler == rspamd_rcl_parse_struct_boolean) {
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj,
-					ucl_object_fromstring ("bool"),
-					"type",
-					0,
-					false);
+			ucl_object_insert_key(doc_obj,
+								  ucl_object_fromstring("bool"),
+								  "type",
+								  0,
+								  false);
 		}
 	}
 	else if (handler == rspamd_rcl_parse_struct_keypair) {
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj,
-					ucl_object_fromstring ("keypair"),
-					"type",
-					0,
-					false);
+			ucl_object_insert_key(doc_obj,
+								  ucl_object_fromstring("keypair"),
+								  "type",
+								  0,
+								  false);
 		}
 		if (!has_example) {
-			ucl_object_insert_key (doc_obj,
-					ucl_object_fromstring ("keypair { "
-							"pubkey = <base32_string>;"
-							" privkey = <base32_string>; "
-							"}"),
-					"example",
-					0,
-					false);
+			ucl_object_insert_key(doc_obj,
+								  ucl_object_fromstring("keypair { "
+														"pubkey = <base32_string>;"
+														" privkey = <base32_string>; "
+														"}"),
+								  "example",
+								  0,
+								  false);
 		}
 	}
 	else if (handler == rspamd_rcl_parse_struct_addr) {
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj,
-					ucl_object_fromstring ("socket address"),
-					"type",
-					0,
-					false);
+			ucl_object_insert_key(doc_obj,
+								  ucl_object_fromstring("socket address"),
+								  "type",
+								  0,
+								  false);
 		}
 	}
 	else if (handler == rspamd_rcl_parse_struct_mime_addr) {
 		if (!has_type) {
-			ucl_object_insert_key (doc_obj,
-					ucl_object_fromstring ("email address"),
-					"type",
-					0,
-					false);
+			ucl_object_insert_key(doc_obj,
+								  ucl_object_fromstring("email address"),
+								  "type",
+								  0,
+								  false);
 		}
 	}
 }
 
 ucl_object_t *
-rspamd_rcl_add_doc_obj (ucl_object_t *doc_target,
-		const char *doc_string,
-		const char *doc_name,
-		ucl_type_t type,
-		rspamd_rcl_default_handler_t handler,
-		gint flags,
-		const char *default_value,
-		gboolean required)
+rspamd_rcl_add_doc_obj(ucl_object_t *doc_target,
+					   const char *doc_string,
+					   const char *doc_name,
+					   ucl_type_t type,
+					   rspamd_rcl_default_handler_t handler,
+					   gint flags,
+					   const char *default_value,
+					   gboolean required)
 {
 	ucl_object_t *doc_obj;
 
@@ -4089,52 +4099,52 @@ rspamd_rcl_add_doc_obj (ucl_object_t *doc_target,
 		return NULL;
 	}
 
-	doc_obj = ucl_object_typed_new (UCL_OBJECT);
+	doc_obj = ucl_object_typed_new(UCL_OBJECT);
 
 	/* Insert doc string itself */
 	if (doc_string) {
-		ucl_object_insert_key (doc_obj,
-				ucl_object_fromstring_common (doc_string, 0, 0),
-				"data", 0, false);
+		ucl_object_insert_key(doc_obj,
+							  ucl_object_fromstring_common(doc_string, 0, 0),
+							  "data", 0, false);
 	}
 	else {
-		ucl_object_insert_key (doc_obj, ucl_object_fromstring ("undocumented"),
-				"data", 0, false);
+		ucl_object_insert_key(doc_obj, ucl_object_fromstring("undocumented"),
+							  "data", 0, false);
 	}
 
 	if (type != UCL_NULL) {
-		ucl_object_insert_key (doc_obj,
-				ucl_object_fromstring (ucl_object_type_to_string (type)),
-				"type", 0, false);
+		ucl_object_insert_key(doc_obj,
+							  ucl_object_fromstring(ucl_object_type_to_string(type)),
+							  "type", 0, false);
 	}
 
-	rspamd_rcl_doc_obj_from_handler (doc_obj, handler, flags);
+	rspamd_rcl_doc_obj_from_handler(doc_obj, handler, flags);
 
-	ucl_object_insert_key (doc_obj,
-			ucl_object_frombool (required),
-			"required", 0, false);
+	ucl_object_insert_key(doc_obj,
+						  ucl_object_frombool(required),
+						  "required", 0, false);
 
 	if (default_value) {
-		ucl_object_insert_key (doc_obj,
-				ucl_object_fromstring_common (default_value, 0, 0),
-				"default", 0, false);
+		ucl_object_insert_key(doc_obj,
+							  ucl_object_fromstring_common(default_value, 0, 0),
+							  "default", 0, false);
 	}
 
-	ucl_object_insert_key (doc_target, doc_obj, doc_name, 0, true);
+	ucl_object_insert_key(doc_target, doc_obj, doc_name, 0, true);
 
 	return doc_obj;
 }
 
 ucl_object_t *
-rspamd_rcl_add_doc_by_path (struct rspamd_config *cfg,
-		const gchar *doc_path,
-		const char *doc_string,
-		const char *doc_name,
-		ucl_type_t type,
-		rspamd_rcl_default_handler_t handler,
-		gint flags,
-		const char *default_value,
-		gboolean required)
+rspamd_rcl_add_doc_by_path(struct rspamd_config *cfg,
+						   const gchar *doc_path,
+						   const char *doc_string,
+						   const char *doc_name,
+						   ucl_type_t type,
+						   rspamd_rcl_default_handler_t handler,
+						   gint flags,
+						   const char *default_value,
+						   gboolean required)
 {
 	const ucl_object_t *found, *cur;
 	ucl_object_t *obj;
@@ -4142,51 +4152,51 @@ rspamd_rcl_add_doc_by_path (struct rspamd_config *cfg,
 
 	if (doc_path == NULL) {
 		/* Assume top object */
-		return rspamd_rcl_add_doc_obj (cfg->doc_strings,
-				doc_string,
-				doc_name,
-				type,
-				handler,
-				flags,
-				default_value,
-				required);
+		return rspamd_rcl_add_doc_obj(cfg->doc_strings,
+									  doc_string,
+									  doc_name,
+									  type,
+									  handler,
+									  flags,
+									  default_value,
+									  required);
 	}
 	else {
-		found = ucl_object_lookup_path (cfg->doc_strings, doc_path);
+		found = ucl_object_lookup_path(cfg->doc_strings, doc_path);
 
 		if (found != NULL) {
-			return rspamd_rcl_add_doc_obj ((ucl_object_t *) found,
-					doc_string,
-					doc_name,
-					type,
-					handler,
-					flags,
-					default_value,
-					required);
+			return rspamd_rcl_add_doc_obj((ucl_object_t *) found,
+										  doc_string,
+										  doc_name,
+										  type,
+										  handler,
+										  flags,
+										  default_value,
+										  required);
 		}
 
 		/* Otherwise we need to insert all components of the path */
-		path_components = g_strsplit_set (doc_path, ".", -1);
+		path_components = g_strsplit_set(doc_path, ".", -1);
 		cur = cfg->doc_strings;
 
 		for (comp = path_components; *comp != NULL; comp++) {
-			if (ucl_object_type (cur) != UCL_OBJECT) {
-				msg_err_config ("Bad path while lookup for '%s' at %s",
-						doc_path, *comp);
-				g_strfreev (path_components);
+			if (ucl_object_type(cur) != UCL_OBJECT) {
+				msg_err_config("Bad path while lookup for '%s' at %s",
+							   doc_path, *comp);
+				g_strfreev(path_components);
 
 				return NULL;
 			}
 
-			found = ucl_object_lookup (cur, *comp);
+			found = ucl_object_lookup(cur, *comp);
 
 			if (found == NULL) {
-				obj = ucl_object_typed_new (UCL_OBJECT);
-				ucl_object_insert_key ((ucl_object_t *) cur,
-						obj,
-						*comp,
-						0,
-						true);
+				obj = ucl_object_typed_new(UCL_OBJECT);
+				ucl_object_insert_key((ucl_object_t *) cur,
+									  obj,
+									  *comp,
+									  0,
+									  true);
 				cur = obj;
 			}
 			else {
@@ -4194,94 +4204,93 @@ rspamd_rcl_add_doc_by_path (struct rspamd_config *cfg,
 			}
 		}
 
-		g_strfreev (path_components);
+		g_strfreev(path_components);
 	}
 
-	return rspamd_rcl_add_doc_obj (ucl_object_ref (cur),
-			doc_string,
-			doc_name,
-			type,
-			handler,
-			flags,
-			default_value,
-			required);
+	return rspamd_rcl_add_doc_obj(ucl_object_ref(cur),
+								  doc_string,
+								  doc_name,
+								  type,
+								  handler,
+								  flags,
+								  default_value,
+								  required);
 }
 
 static void
-rspamd_rcl_add_doc_from_comments (struct rspamd_config *cfg,
-		ucl_object_t *top_doc, const ucl_object_t *obj,
-		const ucl_object_t *comments, gboolean is_top)
+rspamd_rcl_add_doc_from_comments(struct rspamd_config *cfg,
+								 ucl_object_t *top_doc, const ucl_object_t *obj,
+								 const ucl_object_t *comments, gboolean is_top)
 {
 	ucl_object_iter_t it = NULL;
 	const ucl_object_t *cur, *cmt;
 	ucl_object_t *cur_doc;
 
-	if (ucl_object_type (obj) == UCL_OBJECT) {
-		while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) {
+	if (ucl_object_type(obj) == UCL_OBJECT) {
+		while ((cur = ucl_object_iterate(obj, &it, true)) != NULL) {
 			cur_doc = NULL;
 
-			if ((cmt = ucl_comments_find (comments, cur)) != NULL) {
-				cur_doc = rspamd_rcl_add_doc_obj (top_doc,
-						ucl_object_tostring (cmt), ucl_object_key (cur),
-						ucl_object_type (cur), NULL, 0, NULL, FALSE);
+			if ((cmt = ucl_comments_find(comments, cur)) != NULL) {
+				cur_doc = rspamd_rcl_add_doc_obj(top_doc,
+												 ucl_object_tostring(cmt), ucl_object_key(cur),
+												 ucl_object_type(cur), NULL, 0, NULL, FALSE);
 			}
 
-			if (ucl_object_type (cur) == UCL_OBJECT) {
+			if (ucl_object_type(cur) == UCL_OBJECT) {
 				if (cur_doc) {
-					rspamd_rcl_add_doc_from_comments (cfg, cur_doc, cur,
-							comments,
-							FALSE);
+					rspamd_rcl_add_doc_from_comments(cfg, cur_doc, cur,
+													 comments,
+													 FALSE);
 				}
 				else {
-					rspamd_rcl_add_doc_from_comments (cfg, top_doc, cur,
-							comments,
-							FALSE);
+					rspamd_rcl_add_doc_from_comments(cfg, top_doc, cur,
+													 comments,
+													 FALSE);
 				}
 			}
 		}
 	}
 	else if (!is_top) {
-		if ((cmt = ucl_comments_find (comments, obj)) != NULL) {
-			rspamd_rcl_add_doc_obj (top_doc,
-					ucl_object_tostring (cmt), ucl_object_key (obj),
-					ucl_object_type (obj), NULL, 0, NULL, FALSE);
+		if ((cmt = ucl_comments_find(comments, obj)) != NULL) {
+			rspamd_rcl_add_doc_obj(top_doc,
+								   ucl_object_tostring(cmt), ucl_object_key(obj),
+								   ucl_object_type(obj), NULL, 0, NULL, FALSE);
 		}
-
 	}
 }
 
 ucl_object_t *
-rspamd_rcl_add_doc_by_example (struct rspamd_config *cfg,
-		const gchar *root_path,
-		const gchar *doc_string,
-		const gchar *doc_name,
-		const gchar *example_data, gsize example_len)
+rspamd_rcl_add_doc_by_example(struct rspamd_config *cfg,
+							  const gchar *root_path,
+							  const gchar *doc_string,
+							  const gchar *doc_name,
+							  const gchar *example_data, gsize example_len)
 {
 	struct ucl_parser *parser;
 	ucl_object_t *top, *top_doc;
 	const ucl_object_t *comments;
 
-	parser = ucl_parser_new (UCL_PARSER_NO_FILEVARS|UCL_PARSER_SAVE_COMMENTS);
+	parser = ucl_parser_new(UCL_PARSER_NO_FILEVARS | UCL_PARSER_SAVE_COMMENTS);
 
-	if (!ucl_parser_add_chunk (parser, example_data, example_len)) {
-		msg_err_config ("cannot parse example: %s",
-				ucl_parser_get_error (parser));
-		ucl_parser_free (parser);
+	if (!ucl_parser_add_chunk(parser, example_data, example_len)) {
+		msg_err_config("cannot parse example: %s",
+					   ucl_parser_get_error(parser));
+		ucl_parser_free(parser);
 
 		return NULL;
 	}
 
-	top = ucl_parser_get_object (parser);
-	comments = ucl_parser_get_comments (parser);
+	top = ucl_parser_get_object(parser);
+	comments = ucl_parser_get_comments(parser);
 
 	/* Add top object */
-	top_doc = rspamd_rcl_add_doc_by_path (cfg, root_path, doc_string,
-			doc_name, ucl_object_type (top), NULL, 0, NULL, FALSE);
-	ucl_object_insert_key (top_doc,
-			ucl_object_fromstring_common (example_data, example_len, 0),
-			"example", 0, false);
+	top_doc = rspamd_rcl_add_doc_by_path(cfg, root_path, doc_string,
+										 doc_name, ucl_object_type(top), NULL, 0, NULL, FALSE);
+	ucl_object_insert_key(top_doc,
+						  ucl_object_fromstring_common(example_data, example_len, 0),
+						  "example", 0, false);
 
-	rspamd_rcl_add_doc_from_comments (cfg, top_doc, top, comments, TRUE);
+	rspamd_rcl_add_doc_from_comments(cfg, top_doc, top, comments, TRUE);
 
 	return top_doc;
 }