Revert "Unify code style."

This reverts commit e0483657ff6cf1adc828ccce457814d61fe90a0d.

145 files changed, 12410 insertions, 19611 deletions

diff --git a/src/classifiers/bayes.c b/src/classifiers/bayes.c
index 2d3fca084..a8a18f5ff 100644
--- a/src/classifiers/bayes.c
+++ b/src/classifiers/bayes.c
@@ -25,13 +25,13 @@
 /*
  * Bayesian classifier
  */
-#include "binlog.h"
-#include "cfg_file.h"
 #include "classifiers.h"
+#include "tokenizers/tokenizers.h"
+#include "main.h"
 #include "filter.h"
+#include "cfg_file.h"
+#include "binlog.h"
 #include "lua/lua_common.h"
-#include "main.h"
-#include "tokenizers/tokenizers.h"
 
 #define LOCAL_PROB_DENOM 16.0
 
@@ -42,68 +42,56 @@ bayes_error_quark (void)
 }
 
 struct bayes_statfile_data {
-	guint64 hits;
-	guint64 total_hits;
-	double value;
-	struct rspamd_statfile_config *st;
-	stat_file_t *file;
+	guint64                         hits;
+	guint64                         total_hits;
+	double                         value;
+	struct rspamd_statfile_config                *st;
+	stat_file_t                    *file;
 };
 
 struct bayes_callback_data {
-	statfile_pool_t *pool;
-	struct classifier_ctx *ctx;
-	gboolean in_class;
-	time_t now;
-	stat_file_t *file;
-	struct bayes_statfile_data *statfiles;
-	guint32 statfiles_num;
-	guint64 total_spam;
-	guint64 total_ham;
-	guint64 processed_tokens;
-	gsize max_tokens;
-	double spam_probability;
-	double ham_probability;
+	statfile_pool_t                *pool;
+	struct classifier_ctx          *ctx;
+	gboolean                        in_class;
+	time_t                          now;
+	stat_file_t                    *file;
+	struct bayes_statfile_data     *statfiles;
+	guint32                         statfiles_num;
+	guint64							total_spam;
+	guint64							total_ham;
+	guint64                         processed_tokens;
+	gsize                           max_tokens;
+	double                         spam_probability;
+	double                         ham_probability;
 };
 
-static gboolean
+static                          gboolean
 bayes_learn_callback (gpointer key, gpointer value, gpointer data)
 {
-	token_node_t *node = key;
-	struct bayes_callback_data *cd = data;
-	gint c;
-	guint64 v;
+	token_node_t                   *node = key;
+	struct bayes_callback_data     *cd = data;
+	gint                            c;
+	guint64                         v;
 
 	c = (cd->in_class) ? 1 : -1;
 
 	/* Consider that not found blocks have value 1 */
-	v =
-		statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2,
-			cd->now);
+	v = statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2, cd->now);
 	if (v == 0 && c > 0) {
-		statfile_pool_set_block (cd->pool,
-			cd->file,
-			node->h1,
-			node->h2,
-			cd->now,
-			c);
-		cd->processed_tokens++;
+		statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, c);
+		cd->processed_tokens ++;
 	}
 	else if (v != 0) {
 		if (G_LIKELY (c > 0)) {
-			v++;
+			v ++;
 		}
-		else if (c < 0) {
+		else if (c < 0){
 			if (v != 0) {
-				v--;
+				v --;
 			}
 		}
-		statfile_pool_set_block (cd->pool,
-			cd->file,
-			node->h1,
-			node->h2,
-			cd->now,
-			v);
-		cd->processed_tokens++;
+		statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, v);
+		cd->processed_tokens ++;
 	}
 
 	if (cd->max_tokens != 0 && cd->processed_tokens > cd->max_tokens) {
@@ -145,7 +133,7 @@ inv_chi_square (gdouble value, gint freedom_deg)
 		return 0;
 	}
 	sum = prob;
-	for (i = 1; i < freedom_deg / 2; i++) {
+	for (i = 1; i < freedom_deg / 2; i ++) {
 		prob *= value / (gdouble)i;
 		sum += prob;
 	}
@@ -160,20 +148,16 @@ static gboolean
 bayes_classify_callback (gpointer key, gpointer value, gpointer data)
 {
 
-	token_node_t *node = key;
-	struct bayes_callback_data *cd = data;
-	guint i;
-	struct bayes_statfile_data *cur;
-	guint64 spam_count = 0, ham_count = 0, total_count = 0;
-	double spam_prob, spam_freq, ham_freq, bayes_spam_prob;
+	token_node_t                    *node = key;
+	struct bayes_callback_data     *cd = data;
+	guint                            i;
+	struct bayes_statfile_data     *cur;
+	guint64							 spam_count = 0, ham_count = 0, total_count = 0;
+	double							 spam_prob, spam_freq, ham_freq, bayes_spam_prob;
 
-	for (i = 0; i < cd->statfiles_num; i++) {
+	for (i = 0; i < cd->statfiles_num; i ++) {
 		cur = &cd->statfiles[i];
-		cur->value = statfile_pool_get_block (cd->pool,
-				cur->file,
-				node->h1,
-				node->h2,
-				cd->now);
+		cur->value = statfile_pool_get_block (cd->pool, cur->file, node->h1, node->h2, cd->now);
 		if (cur->value > 0) {
 			cur->total_hits += cur->value;
 			if (cur->st->is_spam) {
@@ -194,7 +178,7 @@ bayes_classify_callback (gpointer key, gpointer value, gpointer data)
 		bayes_spam_prob = (0.5 + spam_prob * total_count) / (1. + total_count);
 		cd->spam_probability += log (bayes_spam_prob);
 		cd->ham_probability += log (1. - bayes_spam_prob);
-		cd->processed_tokens++;
+		cd->processed_tokens ++;
 	}
 
 	if (cd->max_tokens != 0 && cd->processed_tokens > cd->max_tokens) {
@@ -205,11 +189,10 @@ bayes_classify_callback (gpointer key, gpointer value, gpointer data)
 	return FALSE;
 }
 
-struct classifier_ctx *
+struct classifier_ctx*
 bayes_init (rspamd_mempool_t *pool, struct rspamd_classifier_config *cfg)
 {
-	struct classifier_ctx *ctx =
-		rspamd_mempool_alloc (pool, sizeof (struct classifier_ctx));
+	struct classifier_ctx          *ctx = rspamd_mempool_alloc (pool, sizeof (struct classifier_ctx));
 
 	ctx->pool = pool;
 	ctx->cfg = cfg;
@@ -219,28 +202,23 @@ bayes_init (rspamd_mempool_t *pool, struct rspamd_classifier_config *cfg)
 }
 
 gboolean
-bayes_classify (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task,
-	lua_State *L)
+bayes_classify (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task, lua_State *L)
 {
-	struct bayes_callback_data data;
-	gchar *value;
-	gint nodes, i = 0, selected_st = -1, cnt;
-	gint minnodes;
-	guint64 maxhits = 0, rev;
-	double final_prob, h, s;
-	struct rspamd_statfile_config *st;
-	stat_file_t *file;
-	GList *cur;
-	char *sumbuf;
+	struct bayes_callback_data      data;
+	gchar                           *value;
+	gint                             nodes, i = 0, selected_st = -1, cnt;
+	gint                             minnodes;
+	guint64                          maxhits = 0, rev;
+	double                          final_prob, h, s;
+	struct rspamd_statfile_config                *st;
+	stat_file_t                     *file;
+	GList                           *cur;
+	char                            *sumbuf;
 
 	g_assert (pool != NULL);
 	g_assert (ctx != NULL);
 
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
 		minnodes = strtol (value, NULL, 10);
 		nodes = g_tree_nnodes (input);
 		if (nodes > FEATURE_WINDOW_SIZE) {
@@ -253,8 +231,7 @@ bayes_classify (struct classifier_ctx * ctx,
 
 	cur = call_classifier_pre_callbacks (ctx->cfg, task, FALSE, FALSE, L);
 	if (cur) {
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t)g_list_free, cur);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
 	}
 	else {
 		cur = ctx->cfg->statfiles;
@@ -271,8 +248,7 @@ bayes_classify (struct classifier_ctx * ctx,
 	data.ham_probability = 0;
 	data.total_ham = 0;
 	data.total_spam = 0;
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
 		minnodes = rspamd_config_parse_limit (value, -1);
 		data.max_tokens = minnodes;
 	}
@@ -284,11 +260,10 @@ bayes_classify (struct classifier_ctx * ctx,
 		/* Select statfile to classify */
 		st = cur->data;
 		if ((file = statfile_pool_is_open (pool, st->path)) == NULL) {
-			if ((file =
-				statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+			if ((file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
 				msg_warn ("cannot open %s", st->path);
 				cur = g_list_next (cur);
-				data.statfiles_num--;
+				data.statfiles_num --;
 				continue;
 			}
 		}
@@ -303,7 +278,7 @@ bayes_classify (struct classifier_ctx * ctx,
 		}
 
 		cur = g_list_next (cur);
-		i++;
+		i ++;
 	}
 
 	cnt = i;
@@ -314,19 +289,17 @@ bayes_classify (struct classifier_ctx * ctx,
 		final_prob = 0;
 	}
 	else {
-		h = 1 - inv_chi_square (-2. * data.spam_probability,
-				2 * data.processed_tokens);
-		s = 1 - inv_chi_square (-2. * data.ham_probability,
-				2 * data.processed_tokens);
+		h = 1 - inv_chi_square (-2. * data.spam_probability, 2 * data.processed_tokens);
+		s = 1 - inv_chi_square (-2. * data.ham_probability, 2 * data.processed_tokens);
 		final_prob = (s + 1 - h) / 2.;
 	}
 
 	if (data.processed_tokens > 0 && fabs (final_prob - 0.5) > 0.05) {
 
 		sumbuf = rspamd_mempool_alloc (task->task_pool, 32);
-		for (i = 0; i < cnt; i++) {
+		for (i = 0; i < cnt; i ++) {
 			if ((final_prob > 0.5 && !data.statfiles[i].st->is_spam) ||
-				(final_prob < 0.5 && data.statfiles[i].st->is_spam)) {
+					(final_prob < 0.5 && data.statfiles[i].st->is_spam)) {
 				continue;
 			}
 			if (data.statfiles[i].total_hits > maxhits) {
@@ -335,8 +308,7 @@ bayes_classify (struct classifier_ctx * ctx,
 			}
 		}
 		if (selected_st == -1) {
-			msg_err (
-				"unexpected classifier error: cannot select desired statfile");
+			msg_err ("unexpected classifier error: cannot select desired statfile");
 		}
 		else {
 			/* Calculate ham probability correctly */
@@ -345,10 +317,7 @@ bayes_classify (struct classifier_ctx * ctx,
 			}
 			rspamd_snprintf (sumbuf, 32, "%.2f%%", final_prob * 100.);
 			cur = g_list_prepend (NULL, sumbuf);
-			insert_result (task,
-				data.statfiles[selected_st].st->symbol,
-				final_prob,
-				cur);
+			insert_result (task, data.statfiles[selected_st].st->symbol, final_prob, cur);
 		}
 	}
 
@@ -358,44 +327,34 @@ bayes_classify (struct classifier_ctx * ctx,
 }
 
 gboolean
-bayes_learn (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	const char *symbol,
-	GTree *input,
-	gboolean in_class,
-	double *sum,
-	double multiplier,
-	GError **err)
+bayes_learn (struct classifier_ctx* ctx, statfile_pool_t *pool, const char *symbol, GTree *input,
+				gboolean in_class, double *sum, double multiplier, GError **err)
 {
-	struct bayes_callback_data data;
-	gchar *value;
-	gint nodes;
-	gint minnodes;
-	struct rspamd_statfile_config *st, *sel_st = NULL;
-	stat_file_t *to_learn;
-	GList *cur;
+	struct bayes_callback_data      data;
+	gchar                          *value;
+	gint                            nodes;
+	gint                            minnodes;
+	struct rspamd_statfile_config                *st, *sel_st = NULL;
+	stat_file_t                    *to_learn;
+	GList                          *cur;
 
 	g_assert (pool != NULL);
 	g_assert (ctx != NULL);
 
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
 		minnodes = strtol (value, NULL, 10);
 		nodes = g_tree_nnodes (input);
 		if (nodes > FEATURE_WINDOW_SIZE) {
 			nodes = nodes / FEATURE_WINDOW_SIZE + FEATURE_WINDOW_SIZE;
 		}
 		if (nodes < minnodes) {
-			msg_info (
-				"do not learn message as it has too few tokens: %d, while %d min",
-				nodes,
-				minnodes);
+			msg_info ("do not learn message as it has too few tokens: %d, while %d min", nodes, minnodes);
 			*sum = 0;
 			g_set_error (err,
-				bayes_error_quark (),           /* error domain */
-				1,                                  /* error code */
-				"message contains too few tokens: %d, while min is %d",
-				nodes, (int)minnodes);
+	                   bayes_error_quark(),		/* error domain */
+	                   1,            				/* error code */
+	                   "message contains too few tokens: %d, while min is %d",
+	                   nodes, (int)minnodes);
 			return FALSE;
 		}
 	}
@@ -406,8 +365,7 @@ bayes_learn (struct classifier_ctx * ctx,
 	data.ctx = ctx;
 	data.processed_tokens = 0;
 	data.processed_tokens = 0;
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
 		minnodes = rspamd_config_parse_limit (value, -1);
 		data.max_tokens = minnodes;
 	}
@@ -426,36 +384,31 @@ bayes_learn (struct classifier_ctx * ctx,
 	}
 	if (sel_st == NULL) {
 		g_set_error (err,
-			bayes_error_quark (),           /* error domain */
-			1,                              /* error code */
-			"cannot find statfile for symbol: %s",
-			symbol);
+				bayes_error_quark(),		/* error domain */
+				1,            				/* error code */
+				"cannot find statfile for symbol: %s",
+				symbol);
 		return FALSE;
 	}
 	if ((to_learn = statfile_pool_is_open (pool, sel_st->path)) == NULL) {
-		if ((to_learn =
-			statfile_pool_open (pool, sel_st->path, sel_st->size,
-			FALSE)) == NULL) {
+		if ((to_learn = statfile_pool_open (pool, sel_st->path, sel_st->size, FALSE)) == NULL) {
 			msg_warn ("cannot open %s", sel_st->path);
 			if (statfile_pool_create (pool, sel_st->path, sel_st->size) == -1) {
 				msg_err ("cannot create statfile %s", sel_st->path);
 				g_set_error (err,
-					bayes_error_quark (),           /* error domain */
-					1,                              /* error code */
-					"cannot create statfile: %s",
-					sel_st->path);
+						bayes_error_quark(),		/* error domain */
+						1,            				/* error code */
+						"cannot create statfile: %s",
+						sel_st->path);
 				return FALSE;
 			}
-			if ((to_learn =
-				statfile_pool_open (pool, sel_st->path, sel_st->size,
-				FALSE)) == NULL) {
+			if ((to_learn = statfile_pool_open (pool, sel_st->path, sel_st->size, FALSE)) == NULL) {
 				g_set_error (err,
-					bayes_error_quark (),           /* error domain */
-					1,                              /* error code */
-					"cannot open statfile %s after creation",
-					sel_st->path);
-				msg_err ("cannot open statfile %s after creation",
-					sel_st->path);
+						bayes_error_quark(),		/* error domain */
+						1,            				/* error code */
+						"cannot open statfile %s after creation",
+						sel_st->path);
+				msg_err ("cannot open statfile %s after creation", sel_st->path);
 				return FALSE;
 			}
 		}
@@ -474,28 +427,22 @@ bayes_learn (struct classifier_ctx * ctx,
 }
 
 gboolean
-bayes_learn_spam (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task,
-	gboolean is_spam,
-	lua_State *L,
-	GError **err)
+bayes_learn_spam (struct classifier_ctx* ctx, statfile_pool_t *pool,
+		GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err)
 {
-	struct bayes_callback_data data;
-	gchar *value;
-	gint nodes;
-	gint minnodes;
-	struct rspamd_statfile_config *st;
-	stat_file_t *file;
-	GList *cur;
-	gboolean skip_labels;
+	struct bayes_callback_data      data;
+	gchar                          *value;
+	gint                            nodes;
+	gint                            minnodes;
+	struct rspamd_statfile_config                *st;
+	stat_file_t                    *file;
+	GList                          *cur;
+	gboolean						skip_labels;
 
 	g_assert (pool != NULL);
 	g_assert (ctx != NULL);
 
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
 		minnodes = strtol (value, NULL, 10);
 		nodes = g_tree_nnodes (input);
 		if (nodes > FEATURE_WINDOW_SIZE) {
@@ -503,10 +450,10 @@ bayes_learn_spam (struct classifier_ctx * ctx,
 		}
 		if (nodes < minnodes) {
 			g_set_error (err,
-				bayes_error_quark (),           /* error domain */
-				1,                              /* error code */
-				"message contains too few tokens: %d, while min is %d",
-				nodes, (int)minnodes);
+					bayes_error_quark(),		/* error domain */
+					1,            				/* error code */
+					"message contains too few tokens: %d, while min is %d",
+					nodes, (int)minnodes);
 			return FALSE;
 		}
 	}
@@ -514,8 +461,7 @@ bayes_learn_spam (struct classifier_ctx * ctx,
 	cur = call_classifier_pre_callbacks (ctx->cfg, task, TRUE, is_spam, L);
 	if (cur) {
 		skip_labels = FALSE;
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t)g_list_free, cur);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
 	}
 	else {
 		/* Do not try to learn specific statfiles if pre callback returned nil */
@@ -529,8 +475,7 @@ bayes_learn_spam (struct classifier_ctx * ctx,
 	data.in_class = TRUE;
 
 	data.processed_tokens = 0;
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "max_tokens")) != NULL) {
 		minnodes = rspamd_config_parse_limit (value, -1);
 		data.max_tokens = minnodes;
 	}
@@ -546,28 +491,24 @@ bayes_learn_spam (struct classifier_ctx * ctx,
 			continue;
 		}
 		if ((file = statfile_pool_is_open (pool, st->path)) == NULL) {
-			if ((file =
-				statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+			if ((file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
 				msg_warn ("cannot open %s", st->path);
 				if (statfile_pool_create (pool, st->path, st->size) == -1) {
 					msg_err ("cannot create statfile %s", st->path);
 					g_set_error (err,
-						bayes_error_quark (),           /* error domain */
-						1,                              /* error code */
-						"cannot create statfile: %s",
-						st->path);
+							bayes_error_quark(),		/* error domain */
+							1,            				/* error code */
+							"cannot create statfile: %s",
+							st->path);
 					return FALSE;
 				}
-				if ((file =
-					statfile_pool_open (pool, st->path, st->size,
-					FALSE)) == NULL) {
+				if ((file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
 					g_set_error (err,
-						bayes_error_quark (),           /* error domain */
-						1,                              /* error code */
-						"cannot open statfile %s after creation",
-						st->path);
-					msg_err ("cannot open statfile %s after creation",
-						st->path);
+							bayes_error_quark(),		/* error domain */
+							1,            				/* error code */
+							"cannot open statfile %s after creation",
+							st->path);
+					msg_err ("cannot open statfile %s after creation", st->path);
 					return FALSE;
 				}
 			}
@@ -587,10 +528,7 @@ bayes_learn_spam (struct classifier_ctx * ctx,
 }
 
 GList *
-bayes_weights (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task)
+bayes_weights (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task)
 {
 	/* This function is unimplemented with new normalizer */
 	return NULL;
diff --git a/src/classifiers/classifiers.c b/src/classifiers/classifiers.c
index 95dd52c44..fb294379c 100644
--- a/src/classifiers/classifiers.c
+++ b/src/classifiers/classifiers.c
@@ -28,29 +28,29 @@
 
 #include "classifiers.h"
 
-struct classifier classifiers[] = {
-	{
-		.name = "winnow",
-		.init_func = winnow_init,
-		.classify_func = winnow_classify,
-		.learn_func = winnow_learn,
-		.learn_spam_func = winnow_learn_spam,
-		.weights_func = winnow_weights
-	},
-	{
-		.name = "bayes",
-		.init_func = bayes_init,
-		.classify_func = bayes_classify,
-		.learn_func = bayes_learn,
-		.learn_spam_func = bayes_learn_spam,
-		.weights_func = bayes_weights
-	}
+struct classifier               classifiers[] = {
+		{
+			.name = "winnow",
+			.init_func = winnow_init,
+			.classify_func = winnow_classify,
+			.learn_func = winnow_learn,
+			.learn_spam_func = winnow_learn_spam,
+			.weights_func = winnow_weights
+		},
+		{
+			.name = "bayes",
+			.init_func = bayes_init,
+			.classify_func = bayes_classify,
+			.learn_func = bayes_learn,
+			.learn_spam_func = bayes_learn_spam,
+			.weights_func = bayes_weights
+		}
 };
 
-struct classifier *
+struct classifier              *
 get_classifier (const char *name)
 {
-	guint i;
+	guint                             i;
 
 	for (i = 0; i < sizeof (classifiers) / sizeof (classifiers[0]); i++) {
 		if (strcmp (classifiers[i].name, name) == 0) {
diff --git a/src/classifiers/classifiers.h b/src/classifiers/classifiers.h
index 8e59fc555..2b36d8c02 100644
--- a/src/classifiers/classifiers.h
+++ b/src/classifiers/classifiers.h
@@ -28,80 +28,36 @@ struct classify_weight {
 /* Common classifier structure */
 struct classifier {
 	char *name;
-	struct classifier_ctx * (*init_func)(rspamd_mempool_t *pool,
-		struct rspamd_classifier_config *cf);
-	gboolean (*classify_func)(struct classifier_ctx * ctx,
-		statfile_pool_t *pool, GTree *input, struct rspamd_task *task,
-		lua_State *L);
-	gboolean (*learn_func)(struct classifier_ctx * ctx, statfile_pool_t *pool,
-		const char *symbol, GTree *input, gboolean in_class,
-		double *sum, double multiplier, GError **err);
-	gboolean (*learn_spam_func)(struct classifier_ctx * ctx,
-		statfile_pool_t *pool,
-		GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L,
-		GError **err);
-	GList * (*weights_func)(struct classifier_ctx * ctx, statfile_pool_t *pool,
-		GTree *input, struct rspamd_task *task);
+	struct classifier_ctx* (*init_func)(rspamd_mempool_t *pool, struct rspamd_classifier_config *cf);
+	gboolean (*classify_func)(struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task, lua_State *L);
+	gboolean (*learn_func)(struct classifier_ctx* ctx, statfile_pool_t *pool,
+							const char *symbol, GTree *input, gboolean in_class,
+							double *sum, double multiplier, GError **err);
+	gboolean (*learn_spam_func)(struct classifier_ctx* ctx, statfile_pool_t *pool,
+								GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err);
+	GList* (*weights_func)(struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task);
 };
 
 /* Get classifier structure by name or return NULL if this name is not found */
-struct classifier * get_classifier (const char *name);
+struct classifier* get_classifier (const char *name);
 
 /* Winnow algorithm */
-struct classifier_ctx * winnow_init (rspamd_mempool_t *pool,
-	struct rspamd_classifier_config *cf);
-gboolean winnow_classify (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task,
-	lua_State *L);
-gboolean winnow_learn (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	const char *symbol,
-	GTree *input,
-	gboolean in_class,
-	double *sum,
-	double multiplier,
-	GError **err);
-gboolean winnow_learn_spam (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task,
-	gboolean is_spam,
-	lua_State *L,
-	GError **err);
-GList * winnow_weights (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task);
+struct classifier_ctx* winnow_init (rspamd_mempool_t *pool, struct rspamd_classifier_config *cf);
+gboolean winnow_classify (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task, lua_State *L);
+gboolean winnow_learn (struct classifier_ctx* ctx, statfile_pool_t *pool, const char *symbol, GTree *input,
+				gboolean in_class, double *sum, double multiplier, GError **err);
+gboolean winnow_learn_spam (struct classifier_ctx* ctx, statfile_pool_t *pool,
+			GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err);
+GList *winnow_weights (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task);
 
 /* Bayes algorithm */
-struct classifier_ctx * bayes_init (rspamd_mempool_t *pool,
-	struct rspamd_classifier_config *cf);
-gboolean bayes_classify (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task,
-	lua_State *L);
-gboolean bayes_learn (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	const char *symbol,
-	GTree *input,
-	gboolean in_class,
-	double *sum,
-	double multiplier,
-	GError **err);
-gboolean bayes_learn_spam (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task,
-	gboolean is_spam,
-	lua_State *L,
-	GError **err);
-GList * bayes_weights (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task);
+struct classifier_ctx* bayes_init (rspamd_mempool_t *pool, struct rspamd_classifier_config *cf);
+gboolean bayes_classify (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task, lua_State *L);
+gboolean bayes_learn (struct classifier_ctx* ctx, statfile_pool_t *pool, const char *symbol, GTree *input,
+				gboolean in_class, double *sum, double multiplier, GError **err);
+gboolean bayes_learn_spam (struct classifier_ctx* ctx, statfile_pool_t *pool,
+			GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err);
+GList *bayes_weights (struct classifier_ctx* ctx, statfile_pool_t *pool, GTree *input, struct rspamd_task *task);
 /* Array of all defined classifiers */
 extern struct classifier classifiers[];
 
diff --git a/src/classifiers/winnow.c b/src/classifiers/winnow.c
index 85d8cfa20..1fe8f16d2 100644
--- a/src/classifiers/winnow.c
+++ b/src/classifiers/winnow.c
@@ -26,12 +26,12 @@
  * Winnow classifier
  */
 
-#include "cfg_file.h"
 #include "classifiers.h"
+#include "tokenizers/tokenizers.h"
+#include "main.h"
 #include "filter.h"
+#include "cfg_file.h"
 #include "lua/lua_common.h"
-#include "main.h"
-#include "tokenizers/tokenizers.h"
 
 #define WINNOW_PROMOTION 1.23
 #define WINNOW_DEMOTION 0.83
@@ -51,42 +51,40 @@ winnow_error_quark (void)
 }
 
 struct winnow_callback_data {
-	statfile_pool_t *pool;
-	struct classifier_ctx *ctx;
-	stat_file_t *file;
-	stat_file_t *learn_file;
-	long double sum;
-	long double start;
-	double multiplier;
-	guint32 count;
-	guint32 new_blocks;
-	gboolean in_class;
-	gboolean do_demote;
-	gboolean fresh_run;
-	time_t now;
+	statfile_pool_t                *pool;
+	struct classifier_ctx          *ctx;
+	stat_file_t                    *file;
+	stat_file_t                    *learn_file;
+	long double                     sum;
+	long double 					start;
+	double                          multiplier;
+	guint32                         count;
+	guint32                         new_blocks;
+	gboolean                        in_class;
+	gboolean                        do_demote;
+	gboolean                        fresh_run;
+	time_t                          now;
 };
 
 static const double max_common_weight = MAX_WEIGHT * WINNOW_DEMOTION;
 
 
 
-static gboolean
+static                          gboolean
 winnow_classify_callback (gpointer key, gpointer value, gpointer data)
 {
-	token_node_t *node = key;
-	struct winnow_callback_data *cd = data;
-	double v;
+	token_node_t                   *node = key;
+	struct winnow_callback_data    *cd = data;
+	double                           v;
 
 	/* Consider that not found blocks have value 1 */
-	v =
-		statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2,
-			cd->now);
+	v = statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2, cd->now);
 	if (fabs (v) > ALPHA) {
 		cd->sum += v;
 	}
 	else {
 		cd->sum += 1.0;
-		cd->new_blocks++;
+		cd->new_blocks ++;
 	}
 
 	cd->count++;
@@ -94,32 +92,24 @@ winnow_classify_callback (gpointer key, gpointer value, gpointer data)
 	return FALSE;
 }
 
-static gboolean
+static                          gboolean
 winnow_learn_callback (gpointer key, gpointer value, gpointer data)
 {
-	token_node_t *node = key;
-	struct winnow_callback_data *cd = data;
-	double v, c;
-
-	c = (cd->in_class) ? WINNOW_PROMOTION * cd->multiplier : WINNOW_DEMOTION /
-		cd->multiplier;
+	token_node_t                   *node = key;
+	struct winnow_callback_data    *cd = data;
+	double                          v, c;
+	
+	c = (cd->in_class) ? WINNOW_PROMOTION * cd->multiplier : WINNOW_DEMOTION / cd->multiplier;
 
 	/* Consider that not found blocks have value 1 */
-	v =
-		statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2,
-			cd->now);
+	v = statfile_pool_get_block (cd->pool, cd->file, node->h1, node->h2, cd->now);
 	if (fabs (v) < ALPHA) {
 		/* Block not found, insert new */
 		cd->start += 1;
 		if (cd->file == cd->learn_file) {
-			statfile_pool_set_block (cd->pool,
-				cd->file,
-				node->h1,
-				node->h2,
-				cd->now,
-				c);
+			statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, c);
 			node->value = c;
-			cd->new_blocks++;
+			cd->new_blocks ++;
 		}
 	}
 	else {
@@ -129,23 +119,18 @@ winnow_learn_callback (gpointer key, gpointer value, gpointer data)
 			node->extra = 0;
 		}
 		else {
-			node->extra++;
+			node->extra ++;
 		}
 		node->value = v;
-
+		
 		if (node->extra > 1) {
-			/*
+			/* 
 			 * Assume that this node is common for several statfiles, so
 			 * decrease its weight proportianally
 			 */
 			if (node->value > max_common_weight) {
 				/* Static fluctuation */
-				statfile_pool_set_block (cd->pool,
-					cd->file,
-					node->h1,
-					node->h2,
-					cd->now,
-					0.);
+				statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, 0.);
 				node->value = 0.;
 			}
 			else if (node->value > WINNOW_PROMOTION * cd->multiplier) {
@@ -156,7 +141,7 @@ winnow_learn_callback (gpointer key, gpointer value, gpointer data)
 						node->value *= c;
 					}
 					else {
-						/*
+						/* 
 						 * Too high token value that exists also in other
 						 * statfiles, may be statistic error, so decrease it
 						 * slightly
@@ -167,13 +152,8 @@ winnow_learn_callback (gpointer key, gpointer value, gpointer data)
 				else {
 					node->value = WINNOW_DEMOTION / cd->multiplier;
 				}
-				statfile_pool_set_block (cd->pool,
-					cd->file,
-					node->h1,
-					node->h2,
-					cd->now,
-					node->value);
-			}
+				statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, node->value);
+			} 
 		}
 		else if (cd->file == cd->learn_file) {
 			/* New block or block that is in only one statfile */
@@ -184,22 +164,12 @@ winnow_learn_callback (gpointer key, gpointer value, gpointer data)
 			else {
 				node->value *= c;
 			}
-			statfile_pool_set_block (cd->pool,
-				cd->file,
-				node->h1,
-				node->h2,
-				cd->now,
-				node->value);
+			statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, node->value);
 		}
 		else if (cd->do_demote) {
 			/* Demote blocks in file */
 			node->value *= WINNOW_DEMOTION / cd->multiplier;
-			statfile_pool_set_block (cd->pool,
-				cd->file,
-				node->h1,
-				node->h2,
-				cd->now,
-				node->value);
+			statfile_pool_set_block (cd->pool, cd->file, node->h1, node->h2, cd->now, node->value);
 		}
 	}
 
@@ -211,11 +181,10 @@ winnow_learn_callback (gpointer key, gpointer value, gpointer data)
 	return FALSE;
 }
 
-struct classifier_ctx *
+struct classifier_ctx          *
 winnow_init (rspamd_mempool_t * pool, struct rspamd_classifier_config *cfg)
 {
-	struct classifier_ctx *ctx =
-		rspamd_mempool_alloc (pool, sizeof (struct classifier_ctx));
+	struct classifier_ctx          *ctx = rspamd_mempool_alloc (pool, sizeof (struct classifier_ctx));
 
 	ctx->pool = pool;
 	ctx->cfg = cfg;
@@ -224,18 +193,14 @@ winnow_init (rspamd_mempool_t * pool, struct rspamd_classifier_config *cfg)
 }
 
 gboolean
-winnow_classify (struct classifier_ctx *ctx,
-	statfile_pool_t * pool,
-	GTree * input,
-	struct rspamd_task *task,
-	lua_State *L)
+winnow_classify (struct classifier_ctx *ctx, statfile_pool_t * pool, GTree * input, struct rspamd_task *task, lua_State *L)
 {
-	struct winnow_callback_data data;
-	char *sumbuf, *value;
-	long double res = 0., max = 0.;
-	GList *cur;
-	struct rspamd_statfile_config *st, *sel = NULL;
-	int nodes, minnodes;
+	struct winnow_callback_data     data;
+	char                           *sumbuf, *value;
+	long double                     res = 0., max = 0.;
+	GList                          *cur;
+	struct rspamd_statfile_config                *st, *sel = NULL;
+	int                             nodes, minnodes;
 
 	g_assert (pool != NULL);
 	g_assert (ctx != NULL);
@@ -243,27 +208,22 @@ winnow_classify (struct classifier_ctx *ctx,
 	data.pool = pool;
 	data.now = time (NULL);
 	data.ctx = ctx;
-
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+    
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
 		minnodes = strtol (value, NULL, 10);
 		nodes = g_tree_nnodes (input);
 		if (nodes > FEATURE_WINDOW_SIZE) {
 			nodes = nodes / FEATURE_WINDOW_SIZE + FEATURE_WINDOW_SIZE;
 		}
 		if (nodes < minnodes) {
-			msg_info (
-				"do not classify message as it has too few tokens: %d, while %d min",
-				nodes,
-				minnodes);
+			msg_info ("do not classify message as it has too few tokens: %d, while %d min", nodes, minnodes);
 			return FALSE;
 		}
 	}
 
 	cur = call_classifier_pre_callbacks (ctx->cfg, task, FALSE, FALSE, L);
 	if (cur) {
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t)g_list_free, cur);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
 	}
 	else {
 		cur = ctx->cfg->statfiles;
@@ -275,8 +235,7 @@ winnow_classify (struct classifier_ctx *ctx,
 		data.count = 0;
 		data.new_blocks = 0;
 		if ((data.file = statfile_pool_is_open (pool, st->path)) == NULL) {
-			if ((data.file =
-				statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+			if ((data.file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
 				msg_warn ("cannot open %s, skip it", st->path);
 				cur = g_list_next (cur);
 				continue;
@@ -302,16 +261,16 @@ winnow_classify (struct classifier_ctx *ctx,
 
 	if (sel != NULL) {
 #ifdef WITH_LUA
-		max = call_classifier_post_callbacks (ctx->cfg, task, max, L);
+        max = call_classifier_post_callbacks (ctx->cfg, task, max, L);
 #endif
 #ifdef HAVE_TANHL
-		max = tanhl (max);
+        max = tanhl (max);
 #else
-		/*
-		 * As some implementations of libm does not support tanhl, try to use
-		 * tanh
-		 */
-		max = tanh ((double) max);
+        /*
+         * As some implementations of libm does not support tanhl, try to use
+         * tanh
+         */
+        max = tanh ((double) max);
 #endif
 		sumbuf = rspamd_mempool_alloc (task->task_pool, 32);
 		rspamd_snprintf (sumbuf, 32, "%.2F", max);
@@ -323,18 +282,15 @@ winnow_classify (struct classifier_ctx *ctx,
 }
 
 GList *
-winnow_weights (struct classifier_ctx *ctx,
-	statfile_pool_t * pool,
-	GTree * input,
-	struct rspamd_task *task)
+winnow_weights (struct classifier_ctx *ctx, statfile_pool_t * pool, GTree * input, struct rspamd_task *task)
 {
-	struct winnow_callback_data data;
-	long double res = 0.;
-	GList *cur, *resl = NULL;
-	struct rspamd_statfile_config *st;
-	struct classify_weight *w;
-	char *value;
-	int nodes, minnodes;
+	struct winnow_callback_data     data;
+	long double                     res = 0.;
+	GList                          *cur, *resl = NULL;
+	struct rspamd_statfile_config                *st;
+	struct classify_weight         *w;
+	char                           *value;
+	int                             nodes, minnodes;
 
 	g_assert (pool != NULL);
 	g_assert (ctx != NULL);
@@ -343,30 +299,25 @@ winnow_weights (struct classifier_ctx *ctx,
 	data.now = time (NULL);
 	data.ctx = ctx;
 
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
 		minnodes = strtol (value, NULL, 10);
 		nodes = g_tree_nnodes (input);
 		if (nodes > FEATURE_WINDOW_SIZE) {
 			nodes = nodes / FEATURE_WINDOW_SIZE + FEATURE_WINDOW_SIZE;
 		}
 		if (nodes < minnodes) {
-			msg_info (
-				"do not classify message as it has too few tokens: %d, while %d min",
-				nodes,
-				minnodes);
+			msg_info ("do not classify message as it has too few tokens: %d, while %d min", nodes, minnodes);
 			return NULL;
 		}
 	}
-
+    
 	cur = ctx->cfg->statfiles;
 	while (cur) {
 		st = cur->data;
 		data.sum = 0;
 		data.count = 0;
 		if ((data.file = statfile_pool_is_open (pool, st->path)) == NULL) {
-			if ((data.file =
-				statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+			if ((data.file = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
 				msg_warn ("cannot open %s, skip it", st->path);
 				cur = g_list_next (cur);
 				continue;
@@ -377,9 +328,7 @@ winnow_weights (struct classifier_ctx *ctx,
 			g_tree_foreach (input, winnow_classify_callback, &data);
 		}
 
-		w =
-			rspamd_mempool_alloc0 (task->task_pool,
-				sizeof (struct classify_weight));
+		w = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct classify_weight));
 		if (data.count != 0) {
 			res = data.sum / (double)data.count;
 		}
@@ -391,10 +340,9 @@ winnow_weights (struct classifier_ctx *ctx,
 		resl = g_list_prepend (resl, w);
 		cur = g_list_next (cur);
 	}
-
+	
 	if (resl != NULL) {
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t)g_list_free, resl);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, resl);
 	}
 
 	return resl;
@@ -403,27 +351,21 @@ winnow_weights (struct classifier_ctx *ctx,
 
 
 gboolean
-winnow_learn (struct classifier_ctx *ctx,
-	statfile_pool_t *pool,
-	const char *symbol,
-	GTree * input,
-	int in_class,
-	double *sum,
-	double multiplier,
-	GError **err)
+winnow_learn (struct classifier_ctx *ctx, statfile_pool_t *pool, const char *symbol,
+		GTree * input, int in_class, double *sum, double multiplier, GError **err)
 {
-	struct winnow_callback_data data = {
+	struct winnow_callback_data     data = {
 		.file = NULL,
 		.multiplier = multiplier
 	};
-	char *value;
-	int nodes, minnodes, iterations = 0;
-	struct rspamd_statfile_config *st, *sel_st = NULL;
-	stat_file_t *sel = NULL, *to_learn;
-	long double res = 0., max = 0., start_value = 0., end_value = 0.;
-	double learn_threshold = 0.0;
-	GList *cur, *to_demote = NULL;
-	gboolean force_learn = FALSE;
+	char                           *value;
+	int                             nodes, minnodes, iterations = 0;
+	struct rspamd_statfile_config                *st, *sel_st = NULL;
+	stat_file_t                    *sel = NULL, *to_learn;
+	long double                     res = 0., max = 0., start_value = 0., end_value = 0.;
+	double                          learn_threshold = 0.0;
+	GList                          *cur, *to_demote = NULL;
+	gboolean                        force_learn = FALSE;
 
 	g_assert (pool != NULL);
 	g_assert (ctx != NULL);
@@ -434,35 +376,29 @@ winnow_learn (struct classifier_ctx *ctx,
 	data.ctx = ctx;
 
 
-	if (ctx->cfg->opts &&
-		(value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "min_tokens")) != NULL) {
 		minnodes = strtol (value, NULL, 10);
 		nodes = g_tree_nnodes (input);
 		if (nodes > FEATURE_WINDOW_SIZE) {
 			nodes = nodes / FEATURE_WINDOW_SIZE + FEATURE_WINDOW_SIZE;
 		}
 		if (nodes < minnodes) {
-			msg_info (
-				"do not learn message as it has too few tokens: %d, while %d min",
-				nodes,
-				minnodes);
+			msg_info ("do not learn message as it has too few tokens: %d, while %d min", nodes, minnodes);
 			if (sum != NULL) {
 				*sum = 0;
 			}
 			g_set_error (err,
-				winnow_error_quark (),              /* error domain */
-				1,                                  /* error code */
-				"message contains too few tokens: %d, while min is %d",
-				nodes, minnodes);
+	                   winnow_error_quark(),		/* error domain */
+	                   1,            				/* error code */
+	                   "message contains too few tokens: %d, while min is %d",
+	                   nodes, minnodes);
 			return FALSE;
 		}
 	}
-	if (ctx->cfg->opts &&
-		(value =
-		g_hash_table_lookup (ctx->cfg->opts, "learn_threshold")) != NULL) {
+	if (ctx->cfg->opts && (value = g_hash_table_lookup (ctx->cfg->opts, "learn_threshold")) != NULL) {
 		learn_threshold = strtod (value, NULL);
 	}
-
+	
 	if (learn_threshold <= 1.0 && learn_threshold >= 0) {
 		/* Classify message and check target statfile score */
 		cur = ctx->cfg->statfiles;
@@ -470,27 +406,24 @@ winnow_learn (struct classifier_ctx *ctx,
 			/* Open or create all statfiles inside classifier */
 			st = cur->data;
 			if (statfile_pool_is_open (pool, st->path) == NULL) {
-				if (statfile_pool_open (pool, st->path, st->size,
-					FALSE) == NULL) {
+				if (statfile_pool_open (pool, st->path, st->size, FALSE) == NULL) {
 					msg_warn ("cannot open %s", st->path);
 					if (statfile_pool_create (pool, st->path, st->size) == -1) {
 						msg_err ("cannot create statfile %s", st->path);
 						g_set_error (err,
-							winnow_error_quark (),          /* error domain */
-							1,                              /* error code */
-							"cannot create statfile: %s",
-							st->path);
+								winnow_error_quark(),		/* error domain */
+								1,            				/* error code */
+								"cannot create statfile: %s",
+								st->path);
 						return FALSE;
 					}
-					if (statfile_pool_open (pool, st->path, st->size,
-						FALSE) == NULL) {
+					if (statfile_pool_open (pool, st->path, st->size, FALSE) == NULL) {
 						g_set_error (err,
-							winnow_error_quark (),          /* error domain */
-							1,                              /* error code */
-							"open statfile %s after creation",
-							st->path);
-						msg_err ("cannot open statfile %s after creation",
-							st->path);
+								winnow_error_quark(),		/* error domain */
+								1,            				/* error code */
+								"open statfile %s after creation",
+								st->path);
+						msg_err ("cannot open statfile %s after creation", st->path);
 						return FALSE;
 					}
 				}
@@ -504,10 +437,10 @@ winnow_learn (struct classifier_ctx *ctx,
 
 		if (sel_st == NULL) {
 			g_set_error (err,
-				winnow_error_quark (),          /* error domain */
-				1,                              /* error code */
-				"cannot find statfile for symbol %s",
-				symbol);
+					winnow_error_quark(),		/* error domain */
+					1,            				/* error code */
+					"cannot find statfile for symbol %s",
+					symbol);
 			msg_err ("cannot find statfile for symbol %s", symbol);
 			return FALSE;
 		}
@@ -515,10 +448,10 @@ winnow_learn (struct classifier_ctx *ctx,
 		to_learn = statfile_pool_is_open (pool, sel_st->path);
 		if (to_learn == NULL) {
 			g_set_error (err,
-				winnow_error_quark (),          /* error domain */
-				1,                              /* error code */
-				"statfile %s is not opened this maybe if your statfile pool is too small to handle all statfiles",
-				sel_st->path);
+					winnow_error_quark(),		/* error domain */
+					1,            				/* error code */
+					"statfile %s is not opened this maybe if your statfile pool is too small to handle all statfiles",
+					sel_st->path);
 			return FALSE;
 		}
 		/* Check target statfile */
@@ -544,10 +477,10 @@ winnow_learn (struct classifier_ctx *ctx,
 			data.count = 0;
 			if ((data.file = statfile_pool_is_open (pool, st->path)) == NULL) {
 				g_set_error (err,
-					winnow_error_quark (),          /* error domain */
-					1,                              /* error code */
-					"statfile %s is not opened this maybe if your statfile pool is too small to handle all statfiles",
-					st->path);
+						winnow_error_quark(),		/* error domain */
+						1,            				/* error code */
+						"statfile %s is not opened this maybe if your statfile pool is too small to handle all statfiles",
+						st->path);
 				return FALSE;
 			}
 			g_tree_foreach (input, winnow_classify_callback, &data);
@@ -565,22 +498,18 @@ winnow_learn (struct classifier_ctx *ctx,
 		}
 	}
 	else {
-		msg_err (
-			"learn threshold is more than 1 or less than 0, so cannot do learn, please check your configuration");
+		msg_err ("learn threshold is more than 1 or less than 0, so cannot do learn, please check your configuration");
 		g_set_error (err,
-			winnow_error_quark (),          /* error domain */
-			1,                              /* error code */
-			"bad learn_threshold setting: %.2f",
-			learn_threshold);
+				winnow_error_quark(),		/* error domain */
+				1,            				/* error code */
+				"bad learn_threshold setting: %.2f",
+				learn_threshold);
 		return FALSE;
 	}
 	/* If to_demote list is empty this message is already classified correctly */
 	if (max > WINNOW_PROMOTION && to_demote == NULL && !force_learn) {
-		msg_info (
-			"this message is already of class %s with threshold %.2f and weight %.2F",
-			sel_st->symbol,
-			learn_threshold,
-			max);
+		msg_info ("this message is already of class %s with threshold %.2f and weight %.2F",
+				sel_st->symbol, learn_threshold, max);
 		goto end;
 	}
 	data.learn_file = to_learn;
@@ -597,8 +526,7 @@ winnow_learn (struct classifier_ctx *ctx,
 			if ((data.file = statfile_pool_is_open (pool, st->path)) == NULL) {
 				return FALSE;
 			}
-			if (to_demote != NULL &&
-				g_list_find (to_demote, data.file) != NULL) {
+			if (to_demote != NULL && g_list_find (to_demote, data.file) != NULL) {
 				data.do_demote = TRUE;
 			}
 			else {
@@ -629,66 +557,48 @@ winnow_learn (struct classifier_ctx *ctx,
 		}
 
 		data.multiplier *= WINNOW_PROMOTION;
-		msg_info (
-			"learn iteration %d for statfile %s: %G -> %G, multiplier: %.2f",
-			iterations + 1,
-			symbol,
-			start_value,
-			end_value,
-			data.multiplier);
-	} while ((in_class ? sel != to_learn : sel ==
-		to_learn)  && iterations++ < MAX_LEARN_ITERATIONS);
-
+		msg_info ("learn iteration %d for statfile %s: %G -> %G, multiplier: %.2f", iterations + 1, symbol,
+				start_value, end_value, data.multiplier);
+	} while ((in_class ? sel != to_learn : sel == to_learn)  && iterations ++ < MAX_LEARN_ITERATIONS);
+	
 	if (iterations >= MAX_LEARN_ITERATIONS) {
-		msg_warn (
-			"learning statfile %s  was not fully successfull: iterations count is limited to %d, final sum is %G",
-			sel_st->symbol,
-			MAX_LEARN_ITERATIONS,
-			max);
+		msg_warn ("learning statfile %s  was not fully successfull: iterations count is limited to %d, final sum is %G", 
+				sel_st->symbol, MAX_LEARN_ITERATIONS, max);
 		g_set_error (err,
-			winnow_error_quark (),          /* error domain */
-			1,                              /* error code */
-			"learning statfile %s  was not fully successfull: iterations count is limited to %d",
-			sel_st->symbol, MAX_LEARN_ITERATIONS);
+				winnow_error_quark(),		/* error domain */
+				1,            				/* error code */
+				"learning statfile %s  was not fully successfull: iterations count is limited to %d",
+				sel_st->symbol, MAX_LEARN_ITERATIONS);
 		return FALSE;
 	}
 	else {
-		msg_info (
-			"learned statfile %s successfully with %d iterations and sum %G",
-			sel_st->symbol,
-			iterations + 1,
-			max);
+		msg_info ("learned statfile %s successfully with %d iterations and sum %G", sel_st->symbol, iterations + 1, max);
 	}
 
 
 end:
 	if (sum) {
 #ifdef HAVE_TANHL
-		*sum = (double)tanhl (max);
+        *sum = (double)tanhl (max);
 #else
-		/*
-		 * As some implementations of libm does not support tanhl, try to use
-		 * tanh
-		 */
-		*sum = tanh ((double) max);
+        /*
+         * As some implementations of libm does not support tanhl, try to use
+         * tanh
+         */
+        *sum = tanh ((double) max);
 #endif
 	}
 	return TRUE;
 }
 
 gboolean
-winnow_learn_spam (struct classifier_ctx * ctx,
-	statfile_pool_t *pool,
-	GTree *input,
-	struct rspamd_task *task,
-	gboolean is_spam,
-	lua_State *L,
-	GError **err)
+winnow_learn_spam (struct classifier_ctx* ctx, statfile_pool_t *pool,
+		GTree *input, struct rspamd_task *task, gboolean is_spam, lua_State *L, GError **err)
 {
 	g_set_error (err,
-		winnow_error_quark (),                  /* error domain */
-		1,                                      /* error code */
-		"learn spam is not supported for winnow"
-		);
+					winnow_error_quark(),		/* error domain */
+					1,            				/* error code */
+					"learn spam is not supported for winnow"
+					);
 	return FALSE;
 }
diff --git a/src/client/rspamc.c b/src/client/rspamc.c
index 61961ecba..e526850c4 100644
--- a/src/client/rspamc.c
+++ b/src/client/rspamc.c
@@ -23,82 +23,61 @@
  */
 
 #include "config.h"
+#include "util.h"
 #include "http.h"
 #include "rspamdclient.h"
-#include "util.h"
 #include "utlist.h"
 
 #define DEFAULT_PORT 11333
 #define DEFAULT_CONTROL_PORT 11334
 
-static gchar *connect_str = "localhost";
-static gchar *password = NULL;
-static gchar *ip = NULL;
-static gchar *from = NULL;
-static gchar *deliver_to = NULL;
-static gchar *rcpt = NULL;
-static gchar *user = NULL;
-static gchar *helo = NULL;
-static gchar *hostname = NULL;
-static gchar *classifier = "bayes";
-static gchar *local_addr = NULL;
-static gint weight = 0;
-static gint flag = 0;
-static gint max_requests = 1024;
-static gdouble timeout = 5.0;
-static gboolean pass_all;
-static gboolean tty = FALSE;
-static gboolean verbose = FALSE;
-static gboolean print_commands = FALSE;
-static gboolean json = FALSE;
-static gboolean headers = FALSE;
-static gboolean raw = FALSE;
+static gchar                   *connect_str = "localhost";
+static gchar                   *password = NULL;
+static gchar                   *ip = NULL;
+static gchar                   *from = NULL;
+static gchar                   *deliver_to = NULL;
+static gchar                   *rcpt = NULL;
+static gchar                   *user = NULL;
+static gchar                   *helo = NULL;
+static gchar                   *hostname = NULL;
+static gchar                   *classifier = "bayes";
+static gchar                   *local_addr = NULL;
+static gint                     weight = 0;
+static gint                     flag = 0;
+static gint                     max_requests = 1024;
+static gdouble                  timeout = 5.0;
+static gboolean                 pass_all;
+static gboolean                 tty = FALSE;
+static gboolean                 verbose = FALSE;
+static gboolean                 print_commands = FALSE;
+static gboolean                 json = FALSE;
+static gboolean                 headers = FALSE;
+static gboolean                 raw = FALSE;
 
 static GOptionEntry entries[] =
 {
-	{ "connect", 'h', 0, G_OPTION_ARG_STRING, &connect_str,
-	  "Specify host and port", NULL },
-	{ "password", 'P', 0, G_OPTION_ARG_STRING, &password,
-	  "Specify control password", NULL },
-	{ "classifier", 'c', 0, G_OPTION_ARG_STRING, &classifier,
-	  "Classifier to learn spam or ham", NULL },
-	{ "weight", 'w', 0, G_OPTION_ARG_INT, &weight,
-	  "Weight for fuzzy operations", NULL },
-	{ "flag", 'f', 0, G_OPTION_ARG_INT, &flag, "Flag for fuzzy operations",
-	  NULL },
-	{ "pass-all", 'p', 0, G_OPTION_ARG_NONE, &pass_all, "Pass all filters",
-	  NULL },
-	{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "More verbose output",
-	  NULL },
-	{ "ip", 'i', 0, G_OPTION_ARG_STRING, &ip,
-	  "Emulate that message was received from specified ip address",
-	  NULL },
-	{ "user", 'u', 0, G_OPTION_ARG_STRING, &user,
-	  "Emulate that message was from specified user", NULL },
-	{ "deliver", 'd', 0, G_OPTION_ARG_STRING, &deliver_to,
-	  "Emulate that message is delivered to specified user", NULL },
-	{ "from", 'F', 0, G_OPTION_ARG_STRING, &from,
-	  "Emulate that message is from specified user", NULL },
-	{ "rcpt", 'r', 0, G_OPTION_ARG_STRING, &rcpt,
-	  "Emulate that message is for specified user", NULL },
-	{ "helo", 0, 0, G_OPTION_ARG_STRING, &helo,
-	  "Imitate SMTP HELO passing from MTA", NULL },
-	{ "hostname", 0, 0, G_OPTION_ARG_STRING, &hostname,
-	  "Imitate hostname passing from MTA", NULL },
-	{ "timeout", 't', 0, G_OPTION_ARG_DOUBLE, &timeout,
-	  "Time in seconds to wait for a reply", NULL },
-	{ "bind", 'b', 0, G_OPTION_ARG_STRING, &local_addr,
-	  "Bind to specified ip address", NULL },
-	{ "commands", 0, 0, G_OPTION_ARG_NONE, &print_commands,
-	  "List available commands", NULL },
-	{ "json", 'j', 0, G_OPTION_ARG_NONE, &json, "Output json reply", NULL },
-	{ "headers", 0, 0, G_OPTION_ARG_NONE, &headers, "Output HTTP headers",
-	  NULL },
-	{ "raw", 0, 0, G_OPTION_ARG_NONE, &raw, "Output raw reply from rspamd",
-	  NULL },
-	{ "max-requests", 'n', 0, G_OPTION_ARG_INT, &max_requests,
-	  "Maximum count of parallel requests to rspamd", NULL },
-	{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
+		{ "connect", 'h', 0, G_OPTION_ARG_STRING, &connect_str, "Specify host and port", NULL },
+		{ "password", 'P', 0, G_OPTION_ARG_STRING, &password, "Specify control password", NULL },
+		{ "classifier", 'c', 0, G_OPTION_ARG_STRING, &classifier, "Classifier to learn spam or ham", NULL },
+		{ "weight", 'w', 0, G_OPTION_ARG_INT, &weight, "Weight for fuzzy operations", NULL },
+		{ "flag", 'f', 0, G_OPTION_ARG_INT, &flag, "Flag for fuzzy operations", NULL },
+		{ "pass-all", 'p', 0, G_OPTION_ARG_NONE, &pass_all, "Pass all filters", NULL },
+		{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "More verbose output", NULL },
+		{ "ip", 'i', 0, G_OPTION_ARG_STRING, &ip, "Emulate that message was received from specified ip address", NULL },
+		{ "user", 'u', 0, G_OPTION_ARG_STRING, &user, "Emulate that message was from specified user", NULL },
+		{ "deliver", 'd', 0, G_OPTION_ARG_STRING, &deliver_to, "Emulate that message is delivered to specified user", NULL },
+		{ "from", 'F', 0, G_OPTION_ARG_STRING, &from, "Emulate that message is from specified user", NULL },
+		{ "rcpt", 'r', 0, G_OPTION_ARG_STRING, &rcpt, "Emulate that message is for specified user", NULL },
+		{ "helo", 0, 0, G_OPTION_ARG_STRING, &helo, "Imitate SMTP HELO passing from MTA", NULL },
+		{ "hostname", 0, 0, G_OPTION_ARG_STRING, &hostname, "Imitate hostname passing from MTA", NULL },
+		{ "timeout", 't', 0, G_OPTION_ARG_DOUBLE, &timeout, "Time in seconds to wait for a reply", NULL },
+		{ "bind", 'b', 0, G_OPTION_ARG_STRING, &local_addr, "Bind to specified ip address", NULL },
+		{ "commands", 0, 0, G_OPTION_ARG_NONE, &print_commands, "List available commands", NULL },
+		{ "json", 'j', 0, G_OPTION_ARG_NONE, &json, "Output json reply", NULL },
+		{ "headers", 0, 0, G_OPTION_ARG_NONE, &headers, "Output HTTP headers", NULL },
+		{ "raw", 0, 0, G_OPTION_ARG_NONE, &raw, "Output raw reply from rspamd", NULL },
+		{ "max-requests", 'n', 0, G_OPTION_ARG_INT, &max_requests, "Maximum count of parallel requests to rspamd", NULL },
+		{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
 };
 
 static void rspamc_symbols_output (ucl_object_t *obj);
@@ -164,8 +143,7 @@ struct rspamc_command {
 		.cmd = RSPAMC_COMMAND_FUZZY_ADD,
 		.name = "fuzzy_add",
 		.path = "fuzzyadd",
-		.description =
-			"add message to fuzzy storage (check -f and -w options for this command)",
+		.description = "add message to fuzzy storage (check -f and -w options for this command)",
 		.is_controller = TRUE,
 		.is_privileged = TRUE,
 		.need_input = TRUE,
@@ -175,8 +153,7 @@ struct rspamc_command {
 		.cmd = RSPAMC_COMMAND_FUZZY_DEL,
 		.name = "fuzzy_del",
 		.path = "fuzzydel",
-		.description =
-			"delete message from fuzzy storage (check -f option for this command)",
+		.description = "delete message from fuzzy storage (check -f option for this command)",
 		.is_controller = TRUE,
 		.is_privileged = TRUE,
 		.need_input = TRUE,
@@ -255,13 +232,12 @@ struct rspamc_callback_data {
 static void
 read_cmd_line (gint *argc, gchar ***argv)
 {
-	GError *error = NULL;
-	GOptionContext *context;
+	GError                         *error = NULL;
+	GOptionContext                 *context;
 
 	/* Prepare parser */
 	context = g_option_context_new ("- run rspamc client");
-	g_option_context_set_summary (context,
-		"Summary:\n  Rspamd client version " RVERSION "\n  Release id: " RID);
+	g_option_context_set_summary (context, "Summary:\n  Rspamd client version " RVERSION "\n  Release id: " RID);
 	g_option_context_add_main_entries (context, entries, NULL);
 
 	/* Parse options */
@@ -322,7 +298,7 @@ check_rspamc_command (const gchar *cmd)
 		ct = RSPAMC_COMMAND_ADD_ACTION;
 	}
 
-	for (i = 0; i < G_N_ELEMENTS (rspamc_commands); i++) {
+	for (i = 0; i < G_N_ELEMENTS (rspamc_commands); i ++) {
 		if (rspamc_commands[i].cmd == ct) {
 			return &rspamc_commands[i];
 		}
@@ -334,21 +310,17 @@ check_rspamc_command (const gchar *cmd)
 static void
 print_commands_list (void)
 {
-	guint i;
+	guint                            i;
 
 	rspamd_fprintf (stdout, "Rspamc commands summary:\n");
-	for (i = 0; i < G_N_ELEMENTS (rspamc_commands); i++) {
-		rspamd_fprintf (stdout,
-			"  %10s (%7s%1s)\t%s\n",
-			rspamc_commands[i].name,
-			rspamc_commands[i].is_controller ? "control" : "normal",
-			rspamc_commands[i].is_privileged ? "*" : "",
-			rspamc_commands[i].description);
-	}
-	rspamd_fprintf (stdout,
-		"\n* is for privileged commands that may need password (see -P option)\n");
-	rspamd_fprintf (stdout,
-		"control commands use port 11334 while normal use 11333 by default (see -h option)\n");
+	for (i = 0; i < G_N_ELEMENTS (rspamc_commands); i ++) {
+			rspamd_fprintf (stdout, "  %10s (%7s%1s)\t%s\n", rspamc_commands[i].name,
+					rspamc_commands[i].is_controller ? "control" : "normal",
+					rspamc_commands[i].is_privileged ? "*" : "",
+					rspamc_commands[i].description);
+	}
+	rspamd_fprintf (stdout, "\n* is for privileged commands that may need password (see -P option)\n");
+	rspamd_fprintf (stdout, "control commands use port 11334 while normal use 11333 by default (see -h option)\n");
 }
 
 
@@ -438,28 +410,24 @@ rspamc_metric_output (const ucl_object_t *obj)
 	while ((cur = ucl_iterate_object (obj, &it, true)) != NULL) {
 		if (g_ascii_strcasecmp (ucl_object_key (cur), "is_spam") == 0) {
 			rspamd_fprintf (stdout, "Spam: %s\n", ucl_object_toboolean (cur) ?
-				"true" : "false");
+					"true" : "false");
 		}
 		else if (g_ascii_strcasecmp (ucl_object_key (cur), "score") == 0) {
 			score = ucl_object_todouble (cur);
-			got_scores++;
+			got_scores ++;
 		}
-		else if (g_ascii_strcasecmp (ucl_object_key (cur),
-			"required_score") == 0) {
+		else if (g_ascii_strcasecmp (ucl_object_key (cur), "required_score") == 0) {
 			required_score = ucl_object_todouble (cur);
-			got_scores++;
+			got_scores ++;
 		}
 		else if (g_ascii_strcasecmp (ucl_object_key (cur), "action") == 0) {
-			rspamd_fprintf (stdout, "Action: %s\n", ucl_object_tostring (cur));
+			rspamd_fprintf (stdout, "Action: %s\n", ucl_object_tostring(cur));
 		}
 		else if (cur->type == UCL_OBJECT) {
 			rspamc_symbol_output (cur);
 		}
 		if (got_scores == 2) {
-			rspamd_fprintf (stdout,
-				"Score: %.2f / %.2f\n",
-				score,
-				required_score);
+			rspamd_fprintf (stdout, "Score: %.2f / %.2f\n", score, required_score);
 			got_scores = 0;
 		}
 	}
@@ -474,12 +442,10 @@ rspamc_symbols_output (ucl_object_t *obj)
 
 	while ((cur = ucl_iterate_object (obj, &it, true)) != NULL) {
 		if (g_ascii_strcasecmp (ucl_object_key (cur), "message-id") == 0) {
-			rspamd_fprintf (stdout, "Message-ID: %s\n", ucl_object_tostring (
-					cur));
+			rspamd_fprintf (stdout, "Message-ID: %s\n", ucl_object_tostring (cur));
 		}
 		else if (g_ascii_strcasecmp (ucl_object_key (cur), "queue-id") == 0) {
-			rspamd_fprintf (stdout, "Queue-ID: %s\n",
-				ucl_object_tostring (cur));
+			rspamd_fprintf (stdout, "Queue-ID: %s\n", ucl_object_tostring (cur));
 		}
 		else if (g_ascii_strcasecmp (ucl_object_key (cur), "urls") == 0) {
 			emitted = ucl_object_emit (cur, UCL_EMIT_JSON_COMPACT);
@@ -492,8 +458,7 @@ rspamc_symbols_output (ucl_object_t *obj)
 			free (emitted);
 		}
 		else if (g_ascii_strcasecmp (ucl_object_key (cur), "error") == 0) {
-			rspamd_fprintf (stdout, "Scan error: %s\n", ucl_object_tostring (
-					cur));
+			rspamd_fprintf (stdout, "Scan error: %s\n", ucl_object_tostring (cur));
 		}
 		else if (cur->type == UCL_OBJECT) {
 			/* Parse metric */
@@ -510,8 +475,7 @@ rspamc_uptime_output (ucl_object_t *obj)
 
 	elt = ucl_object_find_key (obj, "version");
 	if (elt != NULL) {
-		rspamd_fprintf (stdout, "Rspamd version: %s\n", ucl_object_tostring (
-				elt));
+		rspamd_fprintf (stdout, "Rspamd version: %s\n", ucl_object_tostring (elt));
 	}
 
 	elt = ucl_object_find_key (obj, "uptime");
@@ -523,13 +487,13 @@ rspamc_uptime_output (ucl_object_t *obj)
 			hours = seconds / 3600 - days * 24;
 			minutes = seconds / 60 - hours * 60 - days * 1440;
 			rspamd_printf ("%L day%s %L hour%s %L minute%s\n", days,
-				days > 1 ? "s" : "", hours, hours > 1 ? "s" : "",
-				minutes, minutes > 1 ? "s" : "");
+					days > 1 ? "s" : "", hours, hours > 1 ? "s" : "",
+					minutes, minutes > 1 ? "s" : "");
 		}
 		/* If uptime is less than 1 minute print only seconds */
 		else if (seconds / 60 == 0) {
 			rspamd_printf ("%L second%s\n", (gint)seconds,
-				(gint)seconds > 1 ? "s" : "");
+					(gint)seconds > 1 ? "s" : "");
 		}
 		/* Else print the minutes and seconds. */
 		else {
@@ -537,9 +501,9 @@ rspamc_uptime_output (ucl_object_t *obj)
 			minutes = seconds / 60 - hours * 60;
 			seconds -= hours * 3600 + minutes * 60;
 			rspamd_printf ("%L hour%s %L minute%s %L second%s\n", hours,
-				hours > 1 ? "s" : "", minutes,
-				minutes > 1 ? "s" : "",
-				seconds, seconds > 1 ? "s" : "");
+					hours > 1 ? "s" : "", minutes,
+					minutes > 1 ? "s" : "",
+					seconds, seconds > 1 ? "s" : "");
 		}
 	}
 }
@@ -568,7 +532,7 @@ rspamc_counters_output (ucl_object_t *obj)
 	}
 
 	rspamd_snprintf (fmt_buf, sizeof (fmt_buf),
-		"| %%3s | %%%ds | %%6s | %%9s | %%9s |\n", max_len);
+			"| %%3s | %%%ds | %%6s | %%9s | %%9s |\n", max_len);
 	memset (dash_buf, '-', 40 + max_len);
 	dash_buf[40 + max_len] = '\0';
 
@@ -582,7 +546,7 @@ rspamc_counters_output (ucl_object_t *obj)
 		printf ("\033[0m");
 	}
 	rspamd_snprintf (fmt_buf, sizeof (fmt_buf),
-		"| %%3d | %%%ds | %%6.1f | %%9d | %%9.3f |\n", max_len);
+			"| %%3d | %%%ds | %%6.1f | %%9d | %%9.3f |\n", max_len);
 
 	iter = NULL;
 	i = 0;
@@ -599,7 +563,7 @@ rspamc_counters_output (ucl_object_t *obj)
 				(gint)ucl_object_toint (freq),
 				ucl_object_todouble (tim));
 		}
-		i++;
+		i ++;
 	}
 	printf (" %s \n", dash_buf);
 }
@@ -609,8 +573,7 @@ rspamc_output_headers (struct rspamd_http_message *msg)
 {
 	struct rspamd_http_header *h;
 
-	LL_FOREACH (msg->headers, h)
-	{
+	LL_FOREACH (msg->headers, h) {
 		rspamd_fprintf (stdout, "%v: %v\n", h->name, h->value);
 	}
 	rspamd_fprintf (stdout, "\n");
@@ -618,9 +581,9 @@ rspamc_output_headers (struct rspamd_http_message *msg)
 
 static void
 rspamc_client_cb (struct rspamd_client_connection *conn,
-	struct rspamd_http_message *msg,
-	const gchar *name, ucl_object_t *result,
-	gpointer ud, GError *err)
+		struct rspamd_http_message *msg,
+		const gchar *name, ucl_object_t *result,
+		gpointer ud, GError *err)
 {
 	gchar *out;
 	struct rspamc_callback_data *cbdata = (struct rspamc_callback_data *)ud;
@@ -665,13 +628,13 @@ rspamc_client_cb (struct rspamd_client_connection *conn,
 
 static void
 rspamc_process_input (struct event_base *ev_base, struct rspamc_command *cmd,
-	FILE *in, const gchar *name, GHashTable *attrs)
+		FILE *in, const gchar *name, GHashTable *attrs)
 {
 	struct rspamd_client_connection *conn;
 	gchar **connectv;
 	guint16 port;
 	GError *err = NULL;
-	struct rspamc_callback_data *cbdata;
+	struct rspamc_callback_data	 *cbdata;
 
 	connectv = g_strsplit_set (connect_str, ":", -1);
 
@@ -700,16 +663,11 @@ rspamc_process_input (struct event_base *ev_base, struct rspamc_command *cmd,
 		cbdata->filename = name;
 		if (cmd->need_input) {
 			rspamd_client_command (conn, cmd->path, attrs, in, rspamc_client_cb,
-				cbdata, &err);
+					cbdata, &err);
 		}
 		else {
-			rspamd_client_command (conn,
-				cmd->path,
-				attrs,
-				NULL,
-				rspamc_client_cb,
-				cbdata,
-				&err);
+			rspamd_client_command (conn, cmd->path, attrs, NULL, rspamc_client_cb,
+					cbdata, &err);
 		}
 	}
 }
@@ -717,11 +675,11 @@ rspamc_process_input (struct event_base *ev_base, struct rspamc_command *cmd,
 gint
 main (gint argc, gchar **argv, gchar **env)
 {
-	gint i, start_argc, cur_req = 0;
-	GHashTable *kwattrs;
-	struct rspamc_command *cmd;
-	FILE *in = NULL;
-	struct event_base *ev_base;
+	gint                             i, start_argc, cur_req = 0;
+	GHashTable						*kwattrs;
+	struct rspamc_command			*cmd;
+	FILE							*in = NULL;
+	struct event_base				*ev_base;
 
 	kwattrs = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 
@@ -761,19 +719,18 @@ main (gint argc, gchar **argv, gchar **env)
 	else {
 		if ((cmd = check_rspamc_command (argv[1])) != NULL) {
 			/* In case of command read arguments starting from 2 */
-			if (cmd->cmd == RSPAMC_COMMAND_ADD_SYMBOL || cmd->cmd ==
-				RSPAMC_COMMAND_ADD_ACTION) {
+			if (cmd->cmd == RSPAMC_COMMAND_ADD_SYMBOL || cmd->cmd == RSPAMC_COMMAND_ADD_ACTION) {
 				if (argc < 4 || argc > 5) {
 					fprintf (stderr, "invalid arguments\n");
 					exit (EXIT_FAILURE);
 				}
 				if (argc == 5) {
 					g_hash_table_insert (kwattrs, "metric", argv[2]);
-					g_hash_table_insert (kwattrs, "name",	argv[3]);
-					g_hash_table_insert (kwattrs, "value",	argv[4]);
+					g_hash_table_insert (kwattrs, "name", argv[3]);
+					g_hash_table_insert (kwattrs, "value", argv[4]);
 				}
 				else {
-					g_hash_table_insert (kwattrs, "name",  argv[2]);
+					g_hash_table_insert (kwattrs, "name", argv[2]);
 					g_hash_table_insert (kwattrs, "value", argv[3]);
 				}
 				start_argc = argc;
@@ -795,14 +752,14 @@ main (gint argc, gchar **argv, gchar **env)
 		rspamc_process_input (ev_base, cmd, in, "stdin", kwattrs);
 	}
 	else {
-		for (i = start_argc; i < argc; i++) {
+		for (i = start_argc; i < argc; i ++) {
 			in = fopen (argv[i], "r");
 			if (in == NULL) {
 				fprintf (stderr, "cannot open file %s\n", argv[i]);
 				exit (EXIT_FAILURE);
 			}
 			rspamc_process_input (ev_base, cmd, in, argv[i], kwattrs);
-			cur_req++;
+			cur_req ++;
 			fclose (in);
 			if (cur_req >= max_requests) {
 				cur_req = 0;
diff --git a/src/client/rspamdclient.c b/src/client/rspamdclient.c
index 7034b42fb..55f1a6e37 100644
--- a/src/client/rspamdclient.c
+++ b/src/client/rspamdclient.c
@@ -21,9 +21,9 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "http.h"
 #include "rspamdclient.h"
 #include "util.h"
+#include "http.h"
 
 #ifdef HAVE_FETCH_H
 #include <fetch.h>
@@ -62,8 +62,8 @@ rspamd_client_error_quark (void)
 
 static gint
 rspamd_client_body_handler (struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg,
-	const gchar *chunk, gsize len)
+		struct rspamd_http_message *msg,
+		const gchar *chunk, gsize len)
 {
 	/* Do nothing here */
 	return 0;
@@ -72,8 +72,7 @@ rspamd_client_body_handler (struct rspamd_http_connection *conn,
 static void
 rspamd_client_error_handler (struct rspamd_http_connection *conn, GError *err)
 {
-	struct rspamd_client_request *req =
-		(struct rspamd_client_request *)conn->ud;
+	struct rspamd_client_request *req = (struct rspamd_client_request *)conn->ud;
 	struct rspamd_client_connection *c;
 
 	c = req->conn;
@@ -82,10 +81,9 @@ rspamd_client_error_handler (struct rspamd_http_connection *conn, GError *err)
 
 static gint
 rspamd_client_finish_handler (struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_client_request *req =
-		(struct rspamd_client_request *)conn->ud;
+	struct rspamd_client_request *req = (struct rspamd_client_request *)conn->ud;
 	struct rspamd_client_connection *c;
 	struct ucl_parser *parser;
 	GError *err;
@@ -95,18 +93,13 @@ rspamd_client_finish_handler (struct rspamd_http_connection *conn,
 	if (!c->req_sent) {
 		c->req_sent = TRUE;
 		rspamd_http_connection_reset (c->http_conn);
-		rspamd_http_connection_read_message (c->http_conn,
-			c->req,
-			c->fd,
-			&c->timeout,
-			c->ev_base);
+		rspamd_http_connection_read_message (c->http_conn, c->req, c->fd, &c->timeout, c->ev_base);
 		return 0;
 	}
 	else {
 		if (msg->body == NULL || msg->body->len == 0 || msg->code != 200) {
 			err = g_error_new (RCLIENT_ERROR, msg->code, "HTTP error: %d, %s",
-					msg->code,
-					msg->status ? msg->status->str : "unknown error");
+					msg->code, msg->status ? msg->status->str : "unknown error");
 			req->cb (c, msg, c->server_name->str, NULL, req->ud, err);
 			g_error_free (err);
 			return -1;
@@ -122,8 +115,7 @@ rspamd_client_finish_handler (struct rspamd_http_connection *conn,
 			return -1;
 		}
 
-		req->cb (c, msg, c->server_name->str, ucl_parser_get_object (
-				parser), req->ud, NULL);
+		req->cb (c, msg, c->server_name->str, ucl_parser_get_object (parser), req->ud, NULL);
 		ucl_parser_free (parser);
 	}
 
@@ -132,7 +124,7 @@ rspamd_client_finish_handler (struct rspamd_http_connection *conn,
 
 struct rspamd_client_connection *
 rspamd_client_init (struct event_base *ev_base, const gchar *name,
-	guint16 port, gdouble timeout)
+		guint16 port, gdouble timeout)
 {
 	struct rspamd_client_connection *conn;
 	gint fd;
@@ -147,10 +139,7 @@ rspamd_client_init (struct event_base *ev_base, const gchar *name,
 	conn->fd = fd;
 	conn->req_sent = FALSE;
 	conn->http_conn = rspamd_http_connection_new (rspamd_client_body_handler,
-			rspamd_client_error_handler,
-			rspamd_client_finish_handler,
-			0,
-			RSPAMD_HTTP_CLIENT);
+			rspamd_client_error_handler, rspamd_client_finish_handler, 0, RSPAMD_HTTP_CLIENT);
 	conn->server_name = g_string_new (name);
 	if (port != 0) {
 		rspamd_printf_gstring (conn->server_name, ":%d", (int)port);
@@ -163,9 +152,9 @@ rspamd_client_init (struct event_base *ev_base, const gchar *name,
 
 gboolean
 rspamd_client_command (struct rspamd_client_connection *conn,
-	const gchar *command, GHashTable *attrs,
-	FILE *in, rspamd_client_callback cb,
-	gpointer ud, GError **err)
+		const gchar *command, GHashTable *attrs,
+		FILE *in, rspamd_client_callback cb,
+		gpointer ud, GError **err)
 {
 	struct rspamd_client_request *req;
 	gchar *p, *hn, *hv;
@@ -197,8 +186,7 @@ rspamd_client_command (struct rspamd_client_connection *conn,
 			}
 		}
 		if (ferror (in) != 0) {
-			g_set_error (err, RCLIENT_ERROR, ferror (
-					in), "input IO error: %s", strerror (ferror (in)));
+			g_set_error (err, RCLIENT_ERROR, ferror (in), "input IO error: %s", strerror (ferror (in)));
 			g_slice_free1 (sizeof (struct rspamd_client_request), req);
 			return FALSE;
 		}
@@ -219,7 +207,7 @@ rspamd_client_command (struct rspamd_client_connection *conn,
 	conn->req = req;
 
 	rspamd_http_connection_write_message (conn->http_conn, req->msg, NULL,
-		"text/plain", req, conn->fd, &conn->timeout, conn->ev_base);
+			"text/plain", req, conn->fd, &conn->timeout, conn->ev_base);
 
 	return TRUE;
 }
diff --git a/src/client/rspamdclient.h b/src/client/rspamdclient.h
index 6a41c35c1..85b57c376 100644
--- a/src/client/rspamdclient.h
+++ b/src/client/rspamdclient.h
@@ -39,12 +39,12 @@ struct rspamd_http_message;
  * @param err error pointer
  */
 typedef void (*rspamd_client_callback) (
-	struct rspamd_client_connection *conn,
-	struct rspamd_http_message *msg,
-	const gchar *name,
-	ucl_object_t *result,
-	gpointer ud,
-	GError *err);
+		struct rspamd_client_connection *conn,
+		struct rspamd_http_message *msg,
+		const gchar *name,
+		ucl_object_t *result,
+		gpointer ud,
+		GError *err);
 
 /**
  * Start rspamd worker or controller command
@@ -54,11 +54,11 @@ typedef void (*rspamd_client_callback) (
  * @param timeout timeout in seconds
  * @return
  */
-struct rspamd_client_connection * rspamd_client_init (
-	struct event_base *ev_base,
-	const gchar *name,
-	guint16 port,
-	gdouble timeout);
+struct rspamd_client_connection* rspamd_client_init (
+		struct event_base *ev_base,
+		const gchar *name,
+		guint16 port,
+		gdouble timeout);
 
 /**
  *
@@ -71,13 +71,13 @@ struct rspamd_client_connection * rspamd_client_init (
  * @return
  */
 gboolean rspamd_client_command (
-	struct rspamd_client_connection *conn,
-	const gchar *command,
-	GHashTable *attrs,
-	FILE *in,
-	rspamd_client_callback cb,
-	gpointer ud,
-	GError **err);
+		struct rspamd_client_connection *conn,
+		const gchar *command,
+		GHashTable *attrs,
+		FILE *in,
+		rspamd_client_callback cb,
+		gpointer ud,
+		GError **err);
 
 /**
  * Destroy a connection to rspamd
diff --git a/src/controller.c b/src/controller.c
index 55d62ca20..e3d82fa49 100644
--- a/src/controller.c
+++ b/src/controller.c
@@ -22,20 +22,20 @@
  */
 
 
-#include "cfg_file.h"
-#include "classifiers/classifiers.h"
 #include "config.h"
-#include "dns.h"
-#include "dynamic_cfg.h"
-#include "http.h"
+#include "util.h"
 #include "main.h"
-#include "map.h"
+#include "http.h"
 #include "message.h"
 #include "protocol.h"
-#include "rrd.h"
-#include "tokenizers/tokenizers.h"
 #include "upstream.h"
-#include "util.h"
+#include "cfg_file.h"
+#include "map.h"
+#include "dns.h"
+#include "tokenizers/tokenizers.h"
+#include "classifiers/classifiers.h"
+#include "dynamic_cfg.h"
+#include "rrd.h"
 
 #ifdef WITH_GPERF_TOOLS
 #   include <glib/gprintf.h>
@@ -75,25 +75,25 @@ gpointer init_controller_worker (struct rspamd_config *cfg);
 void start_controller_worker (struct rspamd_worker *worker);
 
 worker_t controller_worker = {
-	"controller",                   /* Name */
-	init_controller_worker,         /* Init function */
-	start_controller_worker,        /* Start function */
-	TRUE,                   /* Has socket */
-	TRUE,                   /* Non unique */
-	FALSE,                  /* Non threaded */
-	TRUE,                   /* Killable */
-	SOCK_STREAM             /* TCP socket */
+	"controller",					/* Name */
+	init_controller_worker,			/* Init function */
+	start_controller_worker,		/* Start function */
+	TRUE,					/* Has socket */
+	TRUE,					/* Non unique */
+	FALSE,					/* Non threaded */
+	TRUE,					/* Killable */
+	SOCK_STREAM				/* TCP socket */
 };
 /*
  * Worker's context
  */
 struct rspamd_controller_worker_ctx {
-	guint32 timeout;
-	struct timeval io_tv;
+	guint32                         timeout;
+	struct timeval                  io_tv;
 	/* DNS resolver */
-	struct rspamd_dns_resolver *resolver;
+	struct rspamd_dns_resolver     *resolver;
 	/* Events base */
-	struct event_base *ev_base;
+	struct event_base              *ev_base;
 	/* Whether we use ssl for this server */
 	gboolean use_ssl;
 	/* Webui password */
@@ -138,11 +138,11 @@ struct rspamd_controller_session {
 /* Check for password if it is required by configuration */
 static gboolean
 rspamd_controller_check_password (struct rspamd_http_connection_entry *entry,
-	struct rspamd_controller_session *session, struct rspamd_http_message *msg,
-	gboolean is_enable)
+		struct rspamd_controller_session *session, struct rspamd_http_message *msg,
+		gboolean is_enable)
 {
-	const gchar *password, *check;
-	struct rspamd_controller_worker_ctx *ctx = session->ctx;
+	const gchar								*password, *check;
+	struct rspamd_controller_worker_ctx			*ctx = session->ctx;
 	gboolean ret = TRUE;
 
 	/* Access list logic */
@@ -151,9 +151,9 @@ rspamd_controller_check_password (struct rspamd_http_connection_entry *entry,
 		return TRUE;
 	}
 	else if (ctx->secure_map && radix32_tree_find_addr (ctx->secure_map,
-		&session->from_addr) != RADIX_NO_VALUE) {
+			&session->from_addr) != RADIX_NO_VALUE) {
 		msg_info ("allow unauthorized connection from a trusted IP %s",
-			rspamd_inet_address_to_string (&session->from_addr));
+				rspamd_inet_address_to_string (&session->from_addr));
 		return TRUE;
 	}
 
@@ -163,8 +163,7 @@ rspamd_controller_check_password (struct rspamd_http_connection_entry *entry,
 		password = rspamd_http_message_find_header (msg, "Password");
 		if (ctx->enable_password == NULL) {
 			/* Use just a password (legacy mode) */
-			msg_info (
-				"using password as enable_password for a privileged command");
+			msg_info ("using password as enable_password for a privileged command");
 			check = ctx->password;
 		}
 		else {
@@ -177,8 +176,7 @@ rspamd_controller_check_password (struct rspamd_http_connection_entry *entry,
 			}
 		}
 		else {
-			msg_warn (
-				"no password to check while executing a privileged command");
+			msg_warn ("no password to check while executing a privileged command");
 			if (ctx->secure_map) {
 				msg_info ("deny unauthorized connection");
 				ret = FALSE;
@@ -229,13 +227,13 @@ rspamd_controller_check_password (struct rspamd_http_connection_entry *entry,
  */
 static int
 rspamd_controller_handle_auth (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct rspamd_stat *st;
-	int64_t uptime;
-	gulong data[4];
-	ucl_object_t *obj;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct rspamd_stat						*st;
+	int64_t									 uptime;
+	gulong									 data[4];
+	ucl_object_t							*obj;
 
 	if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
 		return 0;
@@ -244,32 +242,22 @@ rspamd_controller_handle_auth (struct rspamd_http_connection_entry *conn_ent,
 	obj = ucl_object_typed_new (UCL_OBJECT);
 	st = session->ctx->srv->stat;
 	data[0] = st->actions_stat[METRIC_ACTION_NOACTION];
-	data[1] = st->actions_stat[METRIC_ACTION_ADD_HEADER] +
-		st->actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
+	data[1] = st->actions_stat[METRIC_ACTION_ADD_HEADER] + st->actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
 	data[2] = st->actions_stat[METRIC_ACTION_GREYLIST];
 	data[3] = st->actions_stat[METRIC_ACTION_REJECT];
 
 	/* Get uptime */
 	uptime = time (NULL) - session->ctx->start_time;
 
-	ucl_object_insert_key (obj, ucl_object_fromstring (
-			RVERSION),			   "version",  0, false);
-	ucl_object_insert_key (obj, ucl_object_fromstring (
-			"ok"),				   "auth",	   0, false);
-	ucl_object_insert_key (obj,	   ucl_object_fromint (
-			uptime),			   "uptime",   0, false);
-	ucl_object_insert_key (obj,	   ucl_object_fromint (
-			data[0]),			   "clean",	   0, false);
-	ucl_object_insert_key (obj,	   ucl_object_fromint (
-			data[1]),			   "probable", 0, false);
-	ucl_object_insert_key (obj,	   ucl_object_fromint (
-			data[2]),			   "greylist", 0, false);
-	ucl_object_insert_key (obj,	   ucl_object_fromint (
-			data[3]),			   "reject",   0, false);
-	ucl_object_insert_key (obj,	   ucl_object_fromint (
-			st->messages_scanned), "scanned",  0, false);
-	ucl_object_insert_key (obj,	   ucl_object_fromint (
-			st->messages_learned), "learned",  0, false);
+	ucl_object_insert_key (obj, ucl_object_fromstring (RVERSION), "version", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromstring ("ok"), "auth", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromint (uptime), "uptime", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromint (data[0]), "clean", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromint (data[1]), "probable", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromint (data[2]), "greylist", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromint (data[3]), "reject", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromint (st->messages_scanned), "scanned", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromint (st->messages_learned), "learned", 0, false);
 
 	rspamd_controller_send_ucl (conn_ent, obj);
 	ucl_object_unref (obj);
@@ -281,26 +269,26 @@ rspamd_controller_handle_auth (struct rspamd_http_connection_entry *conn_ent,
  * Symbols command handler:
  * request: /symbols
  * reply: json [{
- *  "name": "group_name",
- *  "symbols": [
- *      {
- *      "name": "name",
- *      "weight": 0.1,
- *      "description": "description of symbol"
- *      },
- *      {...}
+ * 	"name": "group_name",
+ * 	"symbols": [
+ * 		{
+ * 		"name": "name",
+ * 		"weight": 0.1,
+ * 		"description": "description of symbol"
+ * 		},
+ * 		{...}
  * },
  * {...}]
  */
 static int
 rspamd_controller_handle_symbols (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	GList *cur_gr, *cur_sym;
-	struct rspamd_symbols_group *gr;
-	struct rspamd_symbol_def *sym;
-	ucl_object_t *obj, *top, *sym_obj;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	GList									*cur_gr, *cur_sym;
+	struct rspamd_symbols_group					*gr;
+	struct rspamd_symbol_def						*sym;
+	ucl_object_t							*obj, *top, *sym_obj;
 
 	if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
 		return 0;
@@ -313,8 +301,7 @@ rspamd_controller_handle_symbols (struct rspamd_http_connection_entry *conn_ent,
 	while (cur_gr) {
 		gr = cur_gr->data;
 		obj = ucl_object_typed_new (UCL_OBJECT);
-		ucl_object_insert_key (obj, ucl_object_fromstring (
-				gr->name), "group", 0, false);
+		ucl_object_insert_key (obj, ucl_object_fromstring (gr->name), "group", 0, false);
 		/* Iterate through all symbols */
 		cur_sym = gr->symbols;
 		while (cur_sym) {
@@ -322,13 +309,11 @@ rspamd_controller_handle_symbols (struct rspamd_http_connection_entry *conn_ent,
 			sym = cur_sym->data;
 
 			ucl_object_insert_key (sym_obj, ucl_object_fromstring (sym->name),
-				"symbol", 0, false);
-			ucl_object_insert_key (sym_obj,
-				ucl_object_fromdouble (*sym->weight_ptr),
-				"weight", 0, false);
+					"symbol", 0, false);
+			ucl_object_insert_key (sym_obj, ucl_object_fromdouble (*sym->weight_ptr),
+					"weight", 0, false);
 			if (sym->description) {
-				ucl_object_insert_key (sym_obj,
-					ucl_object_fromstring (sym->description),
+				ucl_object_insert_key (sym_obj, ucl_object_fromstring (sym->description),
 					"description", 0, false);
 			}
 
@@ -349,20 +334,20 @@ rspamd_controller_handle_symbols (struct rspamd_http_connection_entry *conn_ent,
  * Actions command handler:
  * request: /actions
  * reply: json [{
- *  "action": "no action",
- *  "value": 1.1
+ * 	"action": "no action",
+ * 	"value": 1.1
  * },
  * {...}]
  */
 static int
 rspamd_controller_handle_actions (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct metric *metric;
-	struct metric_action *act;
-	gint i;
-	ucl_object_t *obj, *top;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct metric							*metric;
+	struct metric_action					*act;
+	gint									 i;
+	ucl_object_t							*obj, *top;
 
 	if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
 		return 0;
@@ -373,15 +358,13 @@ rspamd_controller_handle_actions (struct rspamd_http_connection_entry *conn_ent,
 	/* Get actions for default metric */
 	metric = g_hash_table_lookup (session->ctx->cfg->metrics, DEFAULT_METRIC);
 	if (metric != NULL) {
-		for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
+		for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
 			act = &metric->actions[i];
 			if (act->score > 0) {
 				obj = ucl_object_typed_new (UCL_OBJECT);
 				ucl_object_insert_key (obj,
-					ucl_object_fromstring (str_action_metric (
-						act->action)), "action", 0, false);
-				ucl_object_insert_key (obj, ucl_object_fromdouble (
-						act->score), "value", 0, false);
+						ucl_object_fromstring (str_action_metric (act->action)), "action", 0, false);
+				ucl_object_insert_key (obj, ucl_object_fromdouble (act->score), "value", 0, false);
 				ucl_array_append (top, obj);
 			}
 		}
@@ -397,23 +380,23 @@ rspamd_controller_handle_actions (struct rspamd_http_connection_entry *conn_ent,
  * request: /maps
  * headers: Password
  * reply: json [
- *      {
- *      "map": "name",
- *      "description": "description",
- *      "editable": true
- *      },
- *      {...}
+ * 		{
+ * 		"map": "name",
+ * 		"description": "description",
+ * 		"editable": true
+ * 		},
+ * 		{...}
  * ]
  */
 static int
 rspamd_controller_handle_maps (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	GList *cur, *tmp = NULL;
-	struct rspamd_map *map;
-	gboolean editable;
-	ucl_object_t *obj, *top;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	GList									*cur, *tmp = NULL;
+	struct rspamd_map						*map;
+	gboolean								 editable;
+	ucl_object_t							*obj, *top;
 
 
 	if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
@@ -439,12 +422,12 @@ rspamd_controller_handle_maps (struct rspamd_http_connection_entry *conn_ent,
 		editable = (access (map->uri, W_OK) == 0);
 
 		obj = ucl_object_typed_new (UCL_OBJECT);
-		ucl_object_insert_key (obj,	   ucl_object_fromint (map->id),
-			"map", 0, false);
+		ucl_object_insert_key (obj, ucl_object_fromint (map->id),
+				"map", 0, false);
 		ucl_object_insert_key (obj, ucl_object_fromstring (map->description),
-			"description", 0, false);
-		ucl_object_insert_key (obj,	  ucl_object_frombool (editable),
-			"editable", 0, false);
+				"description", 0, false);
+		ucl_object_insert_key (obj, ucl_object_frombool (editable),
+				"editable", 0, false);
 		ucl_array_append (top, obj);
 
 		cur = g_list_next (cur);
@@ -468,18 +451,18 @@ rspamd_controller_handle_maps (struct rspamd_http_connection_entry *conn_ent,
  */
 static int
 rspamd_controller_handle_get_map (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	GList *cur;
-	struct rspamd_map *map;
-	const gchar *idstr;
-	gchar *errstr;
-	struct stat st;
-	gint fd;
-	guint32 id;
-	gboolean found = FALSE;
-	struct rspamd_http_message *reply;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	GList									*cur;
+	struct rspamd_map						*map;
+	const gchar								*idstr;
+	gchar									*errstr;
+	struct stat								 st;
+	gint									 fd;
+	guint32									 id;
+	gboolean								 found = FALSE;
+	struct rspamd_http_message				*reply;
 
 
 	if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
@@ -545,8 +528,8 @@ rspamd_controller_handle_get_map (struct rspamd_http_connection_entry *conn_ent,
 
 	rspamd_http_connection_reset (conn_ent->conn);
 	rspamd_http_connection_write_message (conn_ent->conn, reply, NULL,
-		"text/plain", conn_ent, conn_ent->conn->fd,
-		conn_ent->rt->ptv, conn_ent->rt->ev_base);
+			"text/plain", conn_ent, conn_ent->conn->fd,
+			conn_ent->rt->ptv, conn_ent->rt->ev_base);
 	conn_ent->is_reply = TRUE;
 
 	return 0;
@@ -558,20 +541,20 @@ rspamd_controller_handle_get_map (struct rspamd_http_connection_entry *conn_ent,
  * request: /graph
  * headers: Password
  * reply: json [
- *      { label: "Foo", data: [ [10, 1], [17, -14], [30, 5] ] },
- *      { label: "Bar", data: [ [10, 1], [17, -14], [30, 5] ] },
- *      {...}
+ * 		{ label: "Foo", data: [ [10, 1], [17, -14], [30, 5] ] },
+ * 		{ label: "Bar", data: [ [10, 1], [17, -14], [30, 5] ] },
+ * 		{...}
  * ]
  */
 /* XXX: now this function returns only random data */
 static void
 rspamd_controller_handle_graph (struct evhttp_request *req, gpointer arg)
 {
-	struct rspamd_controller_worker_ctx *ctx = arg;
-	struct evbuffer *evb;
-	gint i, seed;
-	time_t now, t;
-	double vals[5][100];
+	struct rspamd_controller_worker_ctx 			*ctx = arg;
+	struct evbuffer							*evb;
+	gint									 i, seed;
+	time_t									 now, t;
+	double									 vals[5][100];
 
 	if (!http_check_password (ctx, req)) {
 		return;
@@ -589,10 +572,8 @@ rspamd_controller_handle_graph (struct evhttp_request *req, gpointer arg)
 
 	/* XXX: simple and stupid set */
 	seed = g_random_int ();
-	for (i = 0; i < 100; i++, seed++) {
-		vals[0][i] =
-			fabs ((sin (seed * 0.1 *
-				M_PI_2) + 1) * 40. + ((gint)(g_random_int () % 2) - 1));
+	for (i = 0; i < 100; i ++, seed ++) {
+		vals[0][i] = fabs ((sin (seed * 0.1 * M_PI_2) + 1) * 40. + ((gint)(g_random_int () % 2) - 1));
 		vals[1][i] = vals[0][i] * 0.5;
 		vals[2][i] = vals[0][i] * 0.1;
 		vals[3][i] = vals[0][i] * 0.3;
@@ -603,75 +584,50 @@ rspamd_controller_handle_graph (struct evhttp_request *req, gpointer arg)
 
 	/* Ham label */
 	t = now - 6000;
-	evbuffer_add_printf (evb,
-		"{\"label\": \"Clean messages\", \"lines\": {\"fill\": false}, \"color\": \""
-		COLOR_CLEAN "\", \"data\":[");
-	for (i = 0; i < 100; i++, t += 60) {
-		evbuffer_add_printf (evb,
-			"[%llu,%.2f%s",
-			(long long unsigned)t * 1000,
-			vals[0][i],
-			i == 99 ? "]" : "],");
+	evbuffer_add_printf (evb, "{\"label\": \"Clean messages\", \"lines\": {\"fill\": false}, \"color\": \""
+			COLOR_CLEAN "\", \"data\":[");
+	for (i = 0; i < 100; i ++, t += 60) {
+		evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[0][i], i == 99 ? "]" : "],");
 	}
 	evbuffer_add (evb, "]},", 3);
 
 	/* Probable spam label */
 	t = now - 6000;
-	evbuffer_add_printf (evb,
-		"{\"label\": \"Probable spam messages\", \"lines\": {\"fill\": false}, \"color\": \""
-		COLOR_PROBABLE_SPAM "\", \"data\":[");
-	for (i = 0; i < 100; i++, t += 60) {
-		evbuffer_add_printf (evb,
-			"[%llu,%.2f%s",
-			(long long unsigned)t * 1000,
-			vals[1][i],
-			i == 99 ? "]" : "],");
+	evbuffer_add_printf (evb, "{\"label\": \"Probable spam messages\", \"lines\": {\"fill\": false}, \"color\": \""
+			COLOR_PROBABLE_SPAM "\", \"data\":[");
+	for (i = 0; i < 100; i ++, t += 60) {
+		evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[1][i], i == 99 ? "]" : "],");
 	}
 	evbuffer_add (evb, "]},", 3);
 
 	/* Greylist label */
 	t = now - 6000;
-	evbuffer_add_printf (evb,
-		"{\"label\": \"Greylisted messages\", \"lines\": {\"fill\": false}, \"color\": \""
-		COLOR_GREYLIST "\", \"data\":[");
-	for (i = 0; i < 100; i++, t += 60) {
-		evbuffer_add_printf (evb,
-			"[%llu,%.2f%s",
-			(long long unsigned)t * 1000,
-			vals[2][i],
-			i == 99 ? "]" : "],");
+	evbuffer_add_printf (evb, "{\"label\": \"Greylisted messages\", \"lines\": {\"fill\": false}, \"color\": \""
+			COLOR_GREYLIST "\", \"data\":[");
+	for (i = 0; i < 100; i ++, t += 60) {
+		evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[2][i], i == 99 ? "]" : "],");
 	}
 	evbuffer_add (evb, "]},", 3);
 
 	/* Reject label */
 	t = now - 6000;
-	evbuffer_add_printf (evb,
-		"{\"label\": \"Rejected messages\", \"lines\": {\"fill\": false}, \"color\": \""
-		COLOR_REJECT "\", \"data\":[");
-	for (i = 0; i < 100; i++, t += 60) {
-		evbuffer_add_printf (evb,
-			"[%llu,%.2f%s",
-			(long long unsigned)t * 1000,
-			vals[3][i],
-			i == 99 ? "]" : "],");
+	evbuffer_add_printf (evb, "{\"label\": \"Rejected messages\", \"lines\": {\"fill\": false}, \"color\": \""
+			COLOR_REJECT "\", \"data\":[");
+	for (i = 0; i < 100; i ++, t += 60) {
+		evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[3][i], i == 99 ? "]" : "],");
 	}
 	evbuffer_add (evb, "]},", 3);
 
 	/* Total label */
 	t = now - 6000;
-	evbuffer_add_printf (evb,
-		"{\"label\": \"Total messages\", \"lines\": {\"fill\": false}, \"color\": \""
-		COLOR_TOTAL "\", \"data\":[");
-	for (i = 0; i < 100; i++, t += 60) {
-		evbuffer_add_printf (evb,
-			"[%llu,%.2f%s",
-			(long long unsigned)t * 1000,
-			vals[4][i],
-			i == 99 ? "]" : "],");
+	evbuffer_add_printf (evb, "{\"label\": \"Total messages\", \"lines\": {\"fill\": false}, \"color\": \""
+			COLOR_TOTAL "\", \"data\":[");
+	for (i = 0; i < 100; i ++, t += 60) {
+		evbuffer_add_printf (evb, "[%llu,%.2f%s", (long long unsigned)t * 1000, vals[4][i], i == 99 ? "]" : "],");
 	}
-	evbuffer_add (evb, "]}",	  2);
+	evbuffer_add (evb, "]}", 2);
 
-	evbuffer_add (evb,	"]" CRLF, 3);
+	evbuffer_add (evb, "]" CRLF, 3);
 
 	evhttp_add_header (req->output_headers, "Connection", "close");
 	http_calculate_content_length (evb, req);
@@ -685,20 +641,19 @@ rspamd_controller_handle_graph (struct evhttp_request *req, gpointer arg)
  * request: /pie
  * headers: Password
  * reply: json [
- *      { label: "Foo", data: 11 },
- *      { label: "Bar", data: 20 },
- *      {...}
+ * 		{ label: "Foo", data: 11 },
+ * 		{ label: "Bar", data: 20 },
+ * 		{...}
  * ]
  */
 static int
-rspamd_controller_handle_pie_chart (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+rspamd_controller_handle_pie_chart (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct rspamd_controller_worker_ctx *ctx;
-	gdouble data[4], total;
-	ucl_object_t *top, *obj;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct rspamd_controller_worker_ctx			*ctx;
+	gdouble									 data[4], total;
+	ucl_object_t							*top, *obj;
 
 	ctx = session->ctx;
 
@@ -711,36 +666,31 @@ rspamd_controller_handle_pie_chart (
 	if (total != 0) {
 		obj = ucl_object_typed_new (UCL_ARRAY);
 
-		data[0] = ctx->srv->stat->actions_stat[METRIC_ACTION_NOACTION] / total *
-			100.;
+		data[0] = ctx->srv->stat->actions_stat[METRIC_ACTION_NOACTION] / total * 100.;
 		data[1] = (ctx->srv->stat->actions_stat[METRIC_ACTION_ADD_HEADER] +
-			ctx->srv->stat->actions_stat[METRIC_ACTION_REWRITE_SUBJECT]) /
-			total * 100.;
-		data[2] = ctx->srv->stat->actions_stat[METRIC_ACTION_GREYLIST] / total *
-			100.;
-		data[3] = ctx->srv->stat->actions_stat[METRIC_ACTION_REJECT] / total *
-			100.;
+				ctx->srv->stat->actions_stat[METRIC_ACTION_REWRITE_SUBJECT]) / total * 100.;
+		data[2] = ctx->srv->stat->actions_stat[METRIC_ACTION_GREYLIST] / total * 100.;
+		data[3] = ctx->srv->stat->actions_stat[METRIC_ACTION_REJECT] / total * 100.;
 
 		ucl_array_append (obj, ucl_object_fromstring ("Clean messages"));
 		ucl_array_append (obj, ucl_object_fromdouble (data[0]));
-		ucl_array_append (top,					 obj);
-		ucl_array_append (obj,
-			ucl_object_fromstring ("Probable spam messages"));
+		ucl_array_append (top, obj);
+		ucl_array_append (obj, ucl_object_fromstring ("Probable spam messages"));
 		ucl_array_append (obj, ucl_object_fromdouble (data[1]));
-		ucl_array_append (top,					 obj);
+		ucl_array_append (top, obj);
 		ucl_array_append (obj, ucl_object_fromstring ("Greylisted messages"));
 		ucl_array_append (obj, ucl_object_fromdouble (data[2]));
-		ucl_array_append (top,					 obj);
+		ucl_array_append (top, obj);
 		ucl_array_append (obj, ucl_object_fromstring ("Rejected messages"));
 		ucl_array_append (obj, ucl_object_fromdouble (data[3]));
-		ucl_array_append (top,					 obj);
+		ucl_array_append (top, obj);
 	}
 	else {
 		obj = ucl_object_typed_new (UCL_ARRAY);
 
 		ucl_array_append (obj, ucl_object_fromstring ("Scanned messages"));
 		ucl_array_append (obj, ucl_object_fromdouble (0));
-		ucl_array_append (top,					 obj);
+		ucl_array_append (top, obj);
 	}
 
 	rspamd_controller_send_ucl (conn_ent, top);
@@ -754,24 +704,24 @@ rspamd_controller_handle_pie_chart (
  * request: /history
  * headers: Password
  * reply: json [
- *      { label: "Foo", data: 11 },
- *      { label: "Bar", data: 20 },
- *      {...}
+ * 		{ label: "Foo", data: 11 },
+ * 		{ label: "Bar", data: 20 },
+ * 		{...}
  * ]
  */
 static int
 rspamd_controller_handle_history (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct rspamd_controller_worker_ctx *ctx;
-	struct roll_history_row *row;
-	struct roll_history copied_history;
-	gint i, rows_proc, row_num;
-	struct tm *tm;
-	gchar timebuf[32];
-	gchar ip_buf[INET6_ADDRSTRLEN];
-	ucl_object_t *top, *obj;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct rspamd_controller_worker_ctx			*ctx;
+	struct roll_history_row					*row;
+	struct roll_history						 copied_history;
+	gint									 i, rows_proc, row_num;
+	struct tm								*tm;
+	gchar									 timebuf[32];
+	gchar									 ip_buf[INET6_ADDRSTRLEN];
+	ucl_object_t							*top, *obj;
 
 	ctx = session->ctx;
 
@@ -790,7 +740,7 @@ rspamd_controller_handle_history (struct rspamd_http_connection_entry *conn_ent,
 
 	/* Go through all rows */
 	row_num = copied_history.cur_row;
-	for (i = 0, rows_proc = 0; i < HISTORY_MAX_ROWS; i++, row_num++) {
+	for (i = 0, rows_proc = 0; i < HISTORY_MAX_ROWS; i ++, row_num ++) {
 		if (row_num == HISTORY_MAX_ROWS) {
 			row_num = 0;
 		}
@@ -801,44 +751,30 @@ rspamd_controller_handle_history (struct rspamd_http_connection_entry *conn_ent,
 			strftime (timebuf, sizeof (timebuf), "%F %H:%M:%S", tm);
 #ifdef HAVE_INET_PTON
 			if (row->from_addr.ipv6) {
-				inet_ntop (AF_INET6, &row->from_addr.d.in6, ip_buf,
-					sizeof (ip_buf));
+				inet_ntop (AF_INET6, &row->from_addr.d.in6, ip_buf, sizeof (ip_buf));
 			}
 			else {
-				inet_ntop (AF_INET, &row->from_addr.d.in4, ip_buf,
-					sizeof (ip_buf));
+				inet_ntop (AF_INET, &row->from_addr.d.in4, ip_buf, sizeof (ip_buf));
 			}
 #else
-			rspamd_strlcpy (ip_buf, inet_ntoa (task->from_addr),
-				sizeof (ip_buf));
+			rspamd_strlcpy (ip_buf, inet_ntoa (task->from_addr), sizeof (ip_buf));
 #endif
 			obj = ucl_object_typed_new (UCL_OBJECT);
-			ucl_object_insert_key (obj, ucl_object_fromstring (
-					timebuf),		  "time", 0, false);
-			ucl_object_insert_key (obj, ucl_object_fromstring (
-					row->message_id), "id",	  0, false);
-			ucl_object_insert_key (obj, ucl_object_fromstring (
-					ip_buf),		  "ip",	  0, false);
-			ucl_object_insert_key (obj,
-				ucl_object_fromstring (str_action_metric (
-					row->action)), "action", 0, false);
-			ucl_object_insert_key (obj, ucl_object_fromdouble (
-					row->score),		  "score",			0, false);
+			ucl_object_insert_key (obj, ucl_object_fromstring (timebuf), "time", 0, false);
+			ucl_object_insert_key (obj, ucl_object_fromstring (row->message_id), "id", 0, false);
+			ucl_object_insert_key (obj, ucl_object_fromstring (ip_buf), "ip", 0, false);
 			ucl_object_insert_key (obj,
-				ucl_object_fromdouble (
-					row->required_score), "required_score", 0, false);
-			ucl_object_insert_key (obj, ucl_object_fromstring (
-					row->symbols),		  "symbols",		0, false);
-			ucl_object_insert_key (obj,	   ucl_object_fromint (
-					row->len),			  "size",			0, false);
-			ucl_object_insert_key (obj,	   ucl_object_fromint (
-					row->scan_time),	  "scan_time",		0, false);
+					ucl_object_fromstring (str_action_metric (row->action)), "action", 0, false);
+			ucl_object_insert_key (obj, ucl_object_fromdouble (row->score), "score", 0, false);
+			ucl_object_insert_key (obj, ucl_object_fromdouble (row->required_score), "required_score", 0, false);
+			ucl_object_insert_key (obj, ucl_object_fromstring (row->symbols), "symbols", 0, false);
+			ucl_object_insert_key (obj, ucl_object_fromint (row->len), "size", 0, false);
+			ucl_object_insert_key (obj, ucl_object_fromint (row->scan_time), "scan_time", 0, false);
 			if (row->user[0] != '\0') {
-				ucl_object_insert_key (obj, ucl_object_fromstring (
-						row->user), "user", 0, false);
+				ucl_object_insert_key (obj, ucl_object_fromstring (row->user), "user", 0, false);
 			}
 			ucl_array_append (top, obj);
-			rows_proc++;
+			rows_proc ++;
 		}
 	}
 
@@ -851,10 +787,10 @@ rspamd_controller_handle_history (struct rspamd_http_connection_entry *conn_ent,
 static gboolean
 rspamd_controller_learn_fin_task (void *ud)
 {
-	struct rspamd_task *task = ud;
-	struct rspamd_controller_session *session;
-	struct rspamd_http_connection_entry *conn_ent;
-	GError *err = NULL;
+	struct rspamd_task						*task = ud;
+	struct rspamd_controller_session 			*session;
+	struct rspamd_http_connection_entry		*conn_ent;
+	GError									*err = NULL;
 
 	conn_ent = task->fin_arg;
 	session = conn_ent->ud;
@@ -872,8 +808,8 @@ rspamd_controller_learn_fin_task (void *ud)
 static gboolean
 rspamd_controller_check_fin_task (void *ud)
 {
-	struct rspamd_task *task = ud;
-	struct rspamd_http_connection_entry *conn_ent;
+	struct rspamd_task						*task = ud;
+	struct rspamd_http_connection_entry		*conn_ent;
 	struct rspamd_http_message *msg;
 
 	conn_ent = task->fin_arg;
@@ -883,24 +819,22 @@ rspamd_controller_check_fin_task (void *ud)
 	rspamd_protocol_http_reply (msg, task);
 	rspamd_http_connection_reset (conn_ent->conn);
 	rspamd_http_connection_write_message (conn_ent->conn, msg, NULL,
-		"application/json", conn_ent, conn_ent->conn->fd, conn_ent->rt->ptv,
-		conn_ent->rt->ev_base);
+			"application/json", conn_ent, conn_ent->conn->fd, conn_ent->rt->ptv,
+			conn_ent->rt->ev_base);
 	conn_ent->is_reply = TRUE;
 
 	return TRUE;
 }
 
 static int
-rspamd_controller_handle_learn_common (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg,
-	gboolean is_spam)
+rspamd_controller_handle_learn_common (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg, gboolean is_spam)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct rspamd_controller_worker_ctx *ctx;
-	struct rspamd_classifier_config *cl;
-	struct rspamd_task *task;
-	const gchar *classifier;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct rspamd_controller_worker_ctx			*ctx;
+	struct rspamd_classifier_config				*cl;
+	struct rspamd_task						*task;
+	const gchar								*classifier;
 
 	ctx = session->ctx;
 
@@ -910,14 +844,11 @@ rspamd_controller_handle_learn_common (
 
 	if (msg->body == NULL || msg->body->len == 0) {
 		msg_err ("got zero length body, cannot continue");
-		rspamd_controller_send_error (conn_ent,
-			400,
-			"Empty body is not permitted");
+		rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
 		return 0;
 	}
 
-	if ((classifier =
-		rspamd_http_message_find_header (msg, "Classifier")) == NULL) {
+	if ((classifier = rspamd_http_message_find_header (msg, "Classifier")) == NULL) {
 		classifier = "bayes";
 	}
 
@@ -934,11 +865,8 @@ rspamd_controller_handle_learn_common (
 	task->ev_base = ctx->ev_base;
 
 
-	task->s = new_async_session (session->pool,
-			rspamd_controller_learn_fin_task,
-			NULL,
-			rspamd_task_free_hard,
-			task);
+	task->s = new_async_session (session->pool, rspamd_controller_learn_fin_task, NULL,
+			rspamd_task_free_hard, task);
 	task->s->wanna_die = TRUE;
 	task->fin_arg = conn_ent;
 	task->http_conn = rspamd_http_connection_ref (conn_ent->conn);;
@@ -967,9 +895,8 @@ rspamd_controller_handle_learn_common (
  * reply: json {"success":true} or {"error":"error message"}
  */
 static int
-rspamd_controller_handle_learnspam (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+rspamd_controller_handle_learnspam (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg)
 {
 	return rspamd_controller_handle_learn_common (conn_ent, msg, TRUE);
 }
@@ -981,9 +908,8 @@ rspamd_controller_handle_learnspam (
  * reply: json {"success":true} or {"error":"error message"}
  */
 static int
-rspamd_controller_handle_learnham (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+rspamd_controller_handle_learnham (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg)
 {
 	return rspamd_controller_handle_learn_common (conn_ent, msg, TRUE);
 }
@@ -997,11 +923,11 @@ rspamd_controller_handle_learnham (
  */
 static int
 rspamd_controller_handle_scan (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct rspamd_controller_worker_ctx *ctx;
-	struct rspamd_task *task;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct rspamd_controller_worker_ctx			*ctx;
+	struct rspamd_task						*task;
 
 	ctx = session->ctx;
 
@@ -1011,9 +937,7 @@ rspamd_controller_handle_scan (struct rspamd_http_connection_entry *conn_ent,
 
 	if (msg->body == NULL || msg->body->len == 0) {
 		msg_err ("got zero length body, cannot continue");
-		rspamd_controller_send_error (conn_ent,
-			400,
-			"Empty body is not permitted");
+		rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
 		return 0;
 	}
 
@@ -1024,11 +948,8 @@ rspamd_controller_handle_scan (struct rspamd_http_connection_entry *conn_ent,
 	task->resolver = ctx->resolver;
 	task->ev_base = ctx->ev_base;
 
-	task->s = new_async_session (session->pool,
-			rspamd_controller_check_fin_task,
-			NULL,
-			rspamd_task_free_hard,
-			task);
+	task->s = new_async_session (session->pool, rspamd_controller_check_fin_task, NULL,
+			rspamd_task_free_hard, task);
 	task->s->wanna_die = TRUE;
 	task->fin_arg = conn_ent;
 	task->http_conn = rspamd_http_connection_ref (conn_ent->conn);
@@ -1054,19 +975,18 @@ rspamd_controller_handle_scan (struct rspamd_http_connection_entry *conn_ent,
  * reply: json {"success":true} or {"error":"error message"}
  */
 static int
-rspamd_controller_handle_saveactions (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+rspamd_controller_handle_saveactions (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct ucl_parser *parser;
-	struct metric *metric;
-	ucl_object_t *obj, *cur;
-	struct rspamd_controller_worker_ctx *ctx;
-	const gchar *error;
-	gdouble score;
-	gint i;
-	enum rspamd_metric_action act;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct ucl_parser						*parser;
+	struct metric							*metric;
+	ucl_object_t							*obj, *cur;
+	struct rspamd_controller_worker_ctx 			*ctx;
+	const gchar								*error;
+	gdouble									 score;
+	gint									 i;
+	enum rspamd_metric_action				 act;
 
 	ctx = session->ctx;
 
@@ -1076,26 +996,21 @@ rspamd_controller_handle_saveactions (
 
 	if (msg->body == NULL || msg->body->len == 0) {
 		msg_err ("got zero length body, cannot continue");
-		rspamd_controller_send_error (conn_ent,
-			400,
-			"Empty body is not permitted");
+		rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
 		return 0;
 	}
 
 	metric = g_hash_table_lookup (ctx->cfg->metrics, DEFAULT_METRIC);
 	if (metric == NULL) {
 		msg_err ("cannot find default metric");
-		rspamd_controller_send_error (conn_ent, 500,
-			"Default metric is absent");
+		rspamd_controller_send_error (conn_ent, 500, "Default metric is absent");
 		return 0;
 	}
 
 	/* Now check for dynamic config */
 	if (!ctx->cfg->dynamic_conf) {
 		msg_err ("dynamic conf has not been defined");
-		rspamd_controller_send_error (conn_ent,
-			500,
-			"No dynamic_rules setting defined");
+		rspamd_controller_send_error (conn_ent, 500, "No dynamic_rules setting defined");
 		return 0;
 	}
 
@@ -1120,8 +1035,8 @@ rspamd_controller_handle_saveactions (
 	}
 
 	cur = obj->value.av;
-	for (i = 0; i < 3 && cur != NULL; i++, cur = cur->next) {
-		switch (i) {
+	for (i = 0; i < 3 && cur != NULL; i ++, cur = cur->next) {
+		switch(i) {
 		case 0:
 			act = METRIC_ACTION_REJECT;
 			break;
@@ -1153,20 +1068,19 @@ rspamd_controller_handle_saveactions (
  * reply: json {"success":true} or {"error":"error message"}
  */
 static int
-rspamd_controller_handle_savesymbols (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+rspamd_controller_handle_savesymbols (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct ucl_parser *parser;
-	struct metric *metric;
-	ucl_object_t *obj;
-	const ucl_object_t *cur, *jname, *jvalue;
-	ucl_object_iter_t iter = NULL;
-	struct rspamd_controller_worker_ctx *ctx;
-	const gchar *error;
-	gdouble val;
-	struct symbol *sym;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct ucl_parser						*parser;
+	struct metric							*metric;
+	ucl_object_t							*obj;
+	const ucl_object_t						*cur, *jname, *jvalue;
+	ucl_object_iter_t						 iter = NULL;
+	struct rspamd_controller_worker_ctx 			*ctx;
+	const gchar								*error;
+	gdouble									 val;
+	struct symbol							*sym;
 
 	ctx = session->ctx;
 
@@ -1176,26 +1090,21 @@ rspamd_controller_handle_savesymbols (
 
 	if (msg->body == NULL || msg->body->len == 0) {
 		msg_err ("got zero length body, cannot continue");
-		rspamd_controller_send_error (conn_ent,
-			400,
-			"Empty body is not permitted");
+		rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
 		return 0;
 	}
 
 	metric = g_hash_table_lookup (ctx->cfg->metrics, DEFAULT_METRIC);
 	if (metric == NULL) {
 		msg_err ("cannot find default metric");
-		rspamd_controller_send_error (conn_ent, 500,
-			"Default metric is absent");
+		rspamd_controller_send_error (conn_ent, 500, "Default metric is absent");
 		return 0;
 	}
 
 	/* Now check for dynamic config */
 	if (!ctx->cfg->dynamic_conf) {
 		msg_err ("dynamic conf has not been defined");
-		rspamd_controller_send_error (conn_ent,
-			500,
-			"No dynamic_rules setting defined");
+		rspamd_controller_send_error (conn_ent, 500, "No dynamic_rules setting defined");
 		return 0;
 	}
 
@@ -1229,15 +1138,12 @@ rspamd_controller_handle_savesymbols (
 		jname = ucl_object_find_key (cur, "name");
 		jvalue = ucl_object_find_key (cur, "value");
 		val = ucl_object_todouble (jvalue);
-		sym =
-			g_hash_table_lookup (metric->symbols, ucl_object_tostring (jname));
+		sym = g_hash_table_lookup (metric->symbols, ucl_object_tostring (jname));
 		if (sym && fabs (sym->score - val) > 0.01) {
 			if (!add_dynamic_symbol (ctx->cfg, DEFAULT_METRIC,
-				ucl_object_tostring (jname), val)) {
-				msg_err ("add symbol failed for %s",
-					ucl_object_tostring (jname));
-				rspamd_controller_send_error (conn_ent, 506,
-					"Add symbol failed");
+					ucl_object_tostring (jname), val)) {
+				msg_err ("add symbol failed for %s", ucl_object_tostring (jname));
+				rspamd_controller_send_error (conn_ent, 506, "Add symbol failed");
 				ucl_object_unref (obj);
 				return 0;
 			}
@@ -1260,17 +1166,17 @@ rspamd_controller_handle_savesymbols (
  */
 static int
 rspamd_controller_handle_savemap (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	GList *cur;
-	struct rspamd_map *map;
-	struct rspamd_controller_worker_ctx *ctx;
-	const gchar *idstr;
-	gchar *errstr;
-	guint32 id;
-	gboolean found = FALSE;
-	gint fd;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	GList									*cur;
+	struct rspamd_map						*map;
+	struct rspamd_controller_worker_ctx 			*ctx;
+	const gchar								*idstr;
+	gchar									*errstr;
+	guint32									 id;
+	gboolean								 found = FALSE;
+	gint									 fd;
 
 	ctx = session->ctx;
 
@@ -1280,9 +1186,7 @@ rspamd_controller_handle_savemap (struct rspamd_http_connection_entry *conn_ent,
 
 	if (msg->body == NULL || msg->body->len == 0) {
 		msg_err ("got zero length body, cannot continue");
-		rspamd_controller_send_error (conn_ent,
-			400,
-			"Empty body is not permitted");
+		rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
 		return 0;
 	}
 
@@ -1358,10 +1262,8 @@ rspamd_controller_handle_savemap (struct rspamd_http_connection_entry *conn_ent,
  * reply: json data
  */
 static int
-rspamd_controller_handle_stat_common (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg,
-	gboolean do_reset)
+rspamd_controller_handle_stat_common (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg, gboolean do_reset)
 {
 	struct rspamd_controller_session *session = conn_ent->ud;
 	ucl_object_t *top, *sub;
@@ -1380,14 +1282,13 @@ rspamd_controller_handle_stat_common (
 	stat = &stat_copy;
 	top = ucl_object_typed_new (UCL_OBJECT);
 
-	ucl_object_insert_key (top, ucl_object_fromint (
-			stat->messages_scanned), "scanned", 0, false);
+	ucl_object_insert_key (top, ucl_object_fromint (stat->messages_scanned), "scanned", 0, false);
 	if (stat->messages_scanned > 0) {
 		sub = ucl_object_typed_new (UCL_OBJECT);
-		for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
+		for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i ++) {
 			ucl_object_insert_key (sub,
-				ucl_object_fromint (stat->actions_stat[i]),
-				str_action_metric (i), 0, false);
+					ucl_object_fromint (stat->actions_stat[i]),
+					str_action_metric (i), 0, false);
 			if (i < METRIC_ACTION_GREYLIST) {
 				spam += stat->actions_stat[i];
 			}
@@ -1401,42 +1302,35 @@ rspamd_controller_handle_stat_common (
 		ucl_object_insert_key (top, sub, "actions", 0, false);
 	}
 
-	ucl_object_insert_key (top, ucl_object_fromint (
-			spam), "spam_count", 0, false);
-	ucl_object_insert_key (top, ucl_object_fromint (
-			ham),  "ham_count",	 0, false);
+	ucl_object_insert_key (top, ucl_object_fromint (spam), "spam_count", 0, false);
+	ucl_object_insert_key (top, ucl_object_fromint (ham), "ham_count", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (stat->messages_learned), "learned", 0, false);
+			ucl_object_fromint (stat->messages_learned), "learned", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (stat->connections_count), "connections", 0, false);
+			ucl_object_fromint (stat->connections_count), "connections", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (stat->control_connections_count),
-		"control_connections", 0, false);
+			ucl_object_fromint (stat->control_connections_count),
+			"control_connections", 0, false);
 
 	ucl_object_insert_key (top,
-		ucl_object_fromint (mem_st.pools_allocated), "pools_allocated", 0,
-		false);
+			ucl_object_fromint (mem_st.pools_allocated), "pools_allocated", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (mem_st.pools_freed), "pools_freed", 0, false);
+			ucl_object_fromint (mem_st.pools_freed), "pools_freed", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (mem_st.bytes_allocated), "bytes_allocated", 0,
-		false);
+			ucl_object_fromint (mem_st.bytes_allocated), "bytes_allocated", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (
-			mem_st.chunks_allocated), "chunks_allocated", 0, false);
+			ucl_object_fromint (mem_st.chunks_allocated), "chunks_allocated", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (mem_st.shared_chunks_allocated),
-		"shared_chunks_allocated", 0, false);
+			ucl_object_fromint (mem_st.shared_chunks_allocated),
+			"shared_chunks_allocated", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (mem_st.chunks_freed), "chunks_freed", 0, false);
+			ucl_object_fromint (mem_st.chunks_freed), "chunks_freed", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (
-			mem_st.oversized_chunks), "chunks_oversized", 0, false);
+			ucl_object_fromint (mem_st.oversized_chunks), "chunks_oversized", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (stat->fuzzy_hashes), "fuzzy_stored", 0, false);
+			ucl_object_fromint (stat->fuzzy_hashes), "fuzzy_stored", 0, false);
 	ucl_object_insert_key (top,
-		ucl_object_fromint (
-			stat->fuzzy_hashes_expired), "fuzzy_expired", 0, false);
+			ucl_object_fromint (stat->fuzzy_hashes_expired), "fuzzy_expired", 0, false);
 
 	/* Now write statistics for each statfile */
 	cur_cl = g_list_first (session->ctx->cfg->classifiers);
@@ -1446,9 +1340,8 @@ rspamd_controller_handle_stat_common (
 		cur_st = g_list_first (ccf->statfiles);
 		while (cur_st) {
 			st = cur_st->data;
-			if ((statfile =
-				statfile_pool_is_open (session->ctx->srv->statfile_pool,
-				st->path)) == NULL) {
+			if ((statfile = statfile_pool_is_open (session->ctx->srv->statfile_pool,
+					st->path)) == NULL) {
 				statfile = statfile_pool_open (session->ctx->srv->statfile_pool,
 						st->path, st->size, FALSE);
 			}
@@ -1459,17 +1352,14 @@ rspamd_controller_handle_stat_common (
 				total = statfile_get_total_blocks (statfile);
 				statfile_get_revision (statfile, &rev, &ti);
 				ucl_object_insert_key (obj,
-					ucl_object_fromstring (st->symbol), "symbol", 0, false);
+						ucl_object_fromstring (st->symbol), "symbol", 0, false);
 				if (st->label != NULL) {
 					ucl_object_insert_key (obj,
-						ucl_object_fromstring (st->label), "label", 0, false);
+							ucl_object_fromstring (st->label), "label", 0, false);
 				}
-				ucl_object_insert_key (obj, ucl_object_fromint (
-						rev),	"revision", 0, false);
-				ucl_object_insert_key (obj, ucl_object_fromint (
-						used),	"used",		0, false);
-				ucl_object_insert_key (obj, ucl_object_fromint (
-						total), "total",	0, false);
+				ucl_object_insert_key (obj, ucl_object_fromint (rev), "revision", 0, false);
+				ucl_object_insert_key (obj, ucl_object_fromint (used), "used", 0, false);
+				ucl_object_insert_key (obj, ucl_object_fromint (total), "total", 0, false);
 
 				ucl_array_append (sub, obj);
 			}
@@ -1496,9 +1386,9 @@ rspamd_controller_handle_stat_common (
 
 static int
 rspamd_controller_handle_stat (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
 
 	if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
 		return 0;
@@ -1508,11 +1398,10 @@ rspamd_controller_handle_stat (struct rspamd_http_connection_entry *conn_ent,
 }
 
 static int
-rspamd_controller_handle_statreset (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+rspamd_controller_handle_statreset (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
 
 	if (!rspamd_controller_check_password (conn_ent, session, msg, TRUE)) {
 		return 0;
@@ -1524,17 +1413,17 @@ rspamd_controller_handle_statreset (
 static ucl_object_t *
 rspamd_controller_cache_item_to_ucl (struct cache_item *item)
 {
-	ucl_object_t *obj;
+	ucl_object_t							*obj;
 
 	obj = ucl_object_typed_new (UCL_OBJECT);
 	ucl_object_insert_key (obj, ucl_object_fromstring (item->s->symbol),
-		"symbol", 0, false);
+			"symbol", 0, false);
 	ucl_object_insert_key (obj, ucl_object_fromdouble (item->s->weight),
-		"weight", 0, false);
-	ucl_object_insert_key (obj,	   ucl_object_fromint (item->s->frequency),
-		"frequency", 0, false);
+			"weight", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromint (item->s->frequency),
+			"frequency", 0, false);
 	ucl_object_insert_key (obj, ucl_object_fromdouble (item->s->avg_time),
-		"time", 0, false);
+			"time", 0, false);
 
 	return obj;
 }
@@ -1546,15 +1435,14 @@ rspamd_controller_cache_item_to_ucl (struct cache_item *item)
  * reply: json array of all counters
  */
 static int
-rspamd_controller_handle_counters (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+rspamd_controller_handle_counters (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	ucl_object_t *top;
-	GList *cur;
-	struct cache_item *item;
-	struct symbols_cache *cache;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	ucl_object_t							*top;
+	GList									*cur;
+	struct cache_item						*item;
+	struct symbols_cache					*cache;
 
 	if (!rspamd_controller_check_password (conn_ent, session, msg, FALSE)) {
 		return 0;
@@ -1567,8 +1455,7 @@ rspamd_controller_handle_counters (
 		while (cur) {
 			item = cur->data;
 			if (!item->is_callback) {
-				ucl_array_append (top, rspamd_controller_cache_item_to_ucl (
-						item));
+				ucl_array_append (top, rspamd_controller_cache_item_to_ucl (item));
 			}
 			cur = g_list_next (cur);
 		}
@@ -1576,8 +1463,7 @@ rspamd_controller_handle_counters (
 		while (cur) {
 			item = cur->data;
 			if (!item->is_callback) {
-				ucl_array_append (top, rspamd_controller_cache_item_to_ucl (
-						item));
+				ucl_array_append (top, rspamd_controller_cache_item_to_ucl (item));
 			}
 			cur = g_list_next (cur);
 		}
@@ -1590,10 +1476,10 @@ rspamd_controller_handle_counters (
 
 static int
 rspamd_controller_handle_custom (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
-	struct rspamd_custom_controller_command *cmd;
+	struct rspamd_controller_session 			*session = conn_ent->ud;
+	struct rspamd_custom_controller_command	*cmd;
 
 	cmd = g_hash_table_lookup (session->ctx->custom_commands, msg->url->str);
 	if (cmd == NULL || cmd->handler == NULL) {
@@ -1602,15 +1488,12 @@ rspamd_controller_handle_custom (struct rspamd_http_connection_entry *conn_ent,
 		return 0;
 	}
 
-	if (!rspamd_controller_check_password (conn_ent, session, msg,
-		cmd->privilleged)) {
+	if (!rspamd_controller_check_password (conn_ent, session, msg, cmd->privilleged)) {
 		return 0;
 	}
 	if (cmd->require_message && (msg->body == NULL || msg->body->len == 0)) {
 		msg_err ("got zero length body, cannot continue");
-		rspamd_controller_send_error (conn_ent,
-			400,
-			"Empty body is not permitted");
+		rspamd_controller_send_error (conn_ent, 400, "Empty body is not permitted");
 		return 0;
 	}
 
@@ -1618,8 +1501,7 @@ rspamd_controller_handle_custom (struct rspamd_http_connection_entry *conn_ent,
 }
 
 static void
-rspamd_controller_error_handler (struct rspamd_http_connection_entry *conn_ent,
-	GError *err)
+rspamd_controller_error_handler (struct rspamd_http_connection_entry *conn_ent, GError *err)
 {
 	msg_err ("http error occurred: %s", err->message);
 }
@@ -1627,7 +1509,7 @@ rspamd_controller_error_handler (struct rspamd_http_connection_entry *conn_ent,
 static void
 rspamd_controller_finish_handler (struct rspamd_http_connection_entry *conn_ent)
 {
-	struct rspamd_controller_session *session = conn_ent->ud;
+	struct rspamd_controller_session 		*session = conn_ent->ud;
 
 	if (session->task != NULL) {
 		destroy_session (session->task->s);
@@ -1642,16 +1524,16 @@ rspamd_controller_finish_handler (struct rspamd_http_connection_entry *conn_ent)
 static void
 rspamd_controller_accept_socket (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *) arg;
-	struct rspamd_controller_worker_ctx *ctx;
-	struct rspamd_controller_session *nsession;
-	rspamd_inet_addr_t addr;
-	gint nfd;
+	struct rspamd_worker				*worker = (struct rspamd_worker *) arg;
+	struct rspamd_controller_worker_ctx		*ctx;
+	struct rspamd_controller_session			*nsession;
+	rspamd_inet_addr_t					 addr;
+	gint								 nfd;
 
 	ctx = worker->ctx;
 
 	if ((nfd =
-		rspamd_accept_from_socket (fd, &addr)) == -1) {
+			rspamd_accept_from_socket (fd, &addr)) == -1) {
 		msg_warn ("accept failed: %s", strerror (errno));
 		return;
 	}
@@ -1661,8 +1543,8 @@ rspamd_controller_accept_socket (gint fd, short what, void *arg)
 	}
 
 	msg_info ("accepted connection from %s port %d",
-		rspamd_inet_address_to_string (&addr),
-		rspamd_inet_address_get_port (&addr));
+			rspamd_inet_address_to_string (&addr),
+			rspamd_inet_address_get_port (&addr));
 
 	nsession = g_slice_alloc0 (sizeof (struct rspamd_controller_session));
 	nsession->pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
@@ -1676,8 +1558,8 @@ rspamd_controller_accept_socket (gint fd, short what, void *arg)
 gpointer
 init_controller_worker (struct rspamd_config *cfg)
 {
-	struct rspamd_controller_worker_ctx *ctx;
-	GQuark type;
+	struct rspamd_controller_worker_ctx		*ctx;
+	GQuark								type;
 
 	type = g_quark_try_string ("controller");
 
@@ -1686,37 +1568,35 @@ init_controller_worker (struct rspamd_config *cfg)
 	ctx->timeout = DEFAULT_WORKER_IO_TIMEOUT;
 
 	rspamd_rcl_register_worker_option (cfg, type, "password",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, password), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, password), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "enable_password",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, password), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, password), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "ssl",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, use_ssl), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, use_ssl), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "ssl_cert",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, ssl_cert), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, ssl_cert), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "ssl_key",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, ssl_key), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, ssl_key), 0);
 	rspamd_rcl_register_worker_option (cfg, type, "timeout",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx,
-		timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
 
 	rspamd_rcl_register_worker_option (cfg, type, "secure_ip",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, secure_ip), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, secure_ip), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "static_dir",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx,
-		static_files_dir), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_worker_ctx, static_files_dir), 0);
 
 	return ctx;
 }
@@ -1735,9 +1615,7 @@ start_controller_worker (struct rspamd_worker *worker)
 	gpointer key, value;
 
 
-	ctx->ev_base = rspamd_prepare_worker (worker,
-			"controller",
-			rspamd_controller_accept_socket);
+	ctx->ev_base = rspamd_prepare_worker (worker, "controller", rspamd_controller_accept_socket);
 	msec_to_tv (ctx->timeout, &ctx->io_tv);
 
 	ctx->start_time = time (NULL);
@@ -1747,13 +1625,10 @@ start_controller_worker (struct rspamd_worker *worker)
 	ctx->custom_commands = g_hash_table_new (rspamd_strcase_hash,
 			rspamd_strcase_equal);
 	if (ctx->secure_ip != NULL) {
-		if (!add_map (worker->srv->cfg, ctx->secure_ip,
-			"Allow webui access from the specified IP",
-			read_radix_list, fin_radix_list, (void **)&ctx->secure_map)) {
-			if (!rspamd_config_parse_ip_list (ctx->secure_ip,
-				&ctx->secure_map)) {
-				msg_warn ("cannot load or parse ip list from '%s'",
-					ctx->secure_ip);
+		if (!add_map (worker->srv->cfg, ctx->secure_ip, "Allow webui access from the specified IP",
+				read_radix_list, fin_radix_list, (void **)&ctx->secure_map)) {
+			if (!rspamd_config_parse_ip_list (ctx->secure_ip, &ctx->secure_map)) {
+				msg_warn ("cannot load or parse ip list from '%s'", ctx->secure_ip);
 			}
 		}
 	}
@@ -1763,57 +1638,23 @@ start_controller_worker (struct rspamd_worker *worker)
 			ctx->static_files_dir);
 
 	/* Add callbacks for different methods */
-	rspamd_http_router_add_path (ctx->http,
-				PATH_AUTH,
-		rspamd_controller_handle_auth);
-	rspamd_http_router_add_path (ctx->http,
-			 PATH_SYMBOLS,
-		rspamd_controller_handle_symbols);
-	rspamd_http_router_add_path (ctx->http,
-			 PATH_ACTIONS,
-		rspamd_controller_handle_actions);
-	rspamd_http_router_add_path (ctx->http,
-				PATH_MAPS,
-		rspamd_controller_handle_maps);
-	rspamd_http_router_add_path (ctx->http,
-			 PATH_GET_MAP,
-		rspamd_controller_handle_get_map);
-	rspamd_http_router_add_path (ctx->http,
-		   PATH_PIE_CHART,
-		rspamd_controller_handle_pie_chart);
-	rspamd_http_router_add_path (ctx->http,
-			 PATH_HISTORY,
-		rspamd_controller_handle_history);
-	rspamd_http_router_add_path (ctx->http,
-		  PATH_LEARN_SPAM,
-		rspamd_controller_handle_learnspam);
-	rspamd_http_router_add_path (ctx->http,
-		   PATH_LEARN_HAM,
-		rspamd_controller_handle_learnham);
-	rspamd_http_router_add_path (ctx->http,
-		PATH_SAVE_ACTIONS,
-		rspamd_controller_handle_saveactions);
-	rspamd_http_router_add_path (ctx->http,
-		PATH_SAVE_SYMBOLS,
-		rspamd_controller_handle_savesymbols);
-	rspamd_http_router_add_path (ctx->http,
-			PATH_SAVE_MAP,
-		rspamd_controller_handle_savemap);
-	rspamd_http_router_add_path (ctx->http,
-				PATH_SCAN,
-		rspamd_controller_handle_scan);
-	rspamd_http_router_add_path (ctx->http,
-			   PATH_CHECK,
-		rspamd_controller_handle_scan);
-	rspamd_http_router_add_path (ctx->http,
-				PATH_STAT,
-		rspamd_controller_handle_stat);
-	rspamd_http_router_add_path (ctx->http,
-		  PATH_STAT_RESET,
-		rspamd_controller_handle_statreset);
-	rspamd_http_router_add_path (ctx->http,
-			PATH_COUNTERS,
-		rspamd_controller_handle_counters);
+	rspamd_http_router_add_path (ctx->http, PATH_AUTH, rspamd_controller_handle_auth);
+	rspamd_http_router_add_path (ctx->http, PATH_SYMBOLS, rspamd_controller_handle_symbols);
+	rspamd_http_router_add_path (ctx->http, PATH_ACTIONS, rspamd_controller_handle_actions);
+	rspamd_http_router_add_path (ctx->http, PATH_MAPS, rspamd_controller_handle_maps);
+	rspamd_http_router_add_path (ctx->http, PATH_GET_MAP, rspamd_controller_handle_get_map);
+	rspamd_http_router_add_path (ctx->http, PATH_PIE_CHART, rspamd_controller_handle_pie_chart);
+	rspamd_http_router_add_path (ctx->http, PATH_HISTORY, rspamd_controller_handle_history);
+	rspamd_http_router_add_path (ctx->http, PATH_LEARN_SPAM, rspamd_controller_handle_learnspam);
+	rspamd_http_router_add_path (ctx->http, PATH_LEARN_HAM, rspamd_controller_handle_learnham);
+	rspamd_http_router_add_path (ctx->http, PATH_SAVE_ACTIONS, rspamd_controller_handle_saveactions);
+	rspamd_http_router_add_path (ctx->http, PATH_SAVE_SYMBOLS, rspamd_controller_handle_savesymbols);
+	rspamd_http_router_add_path (ctx->http, PATH_SAVE_MAP, rspamd_controller_handle_savemap);
+	rspamd_http_router_add_path (ctx->http, PATH_SCAN, rspamd_controller_handle_scan);
+	rspamd_http_router_add_path (ctx->http, PATH_CHECK, rspamd_controller_handle_scan);
+	rspamd_http_router_add_path (ctx->http, PATH_STAT, rspamd_controller_handle_stat);
+	rspamd_http_router_add_path (ctx->http, PATH_STAT_RESET, rspamd_controller_handle_statreset);
+	rspamd_http_router_add_path (ctx->http, PATH_COUNTERS, rspamd_controller_handle_counters);
 
 	/* Attach plugins */
 	cur = g_list_first (ctx->cfg->filters);
@@ -1821,29 +1662,21 @@ start_controller_worker (struct rspamd_worker *worker)
 		f = cur->data;
 		mctx = g_hash_table_lookup (ctx->cfg->c_modules, f->module->name);
 		if (mctx != NULL && f->module->module_attach_controller_func != NULL) {
-			f->module->module_attach_controller_func (mctx,
-				ctx->custom_commands);
+			f->module->module_attach_controller_func (mctx, ctx->custom_commands);
 		}
 		cur = g_list_next (cur);
 	}
 
 	g_hash_table_iter_init (&iter, ctx->custom_commands);
 	while (g_hash_table_iter_next (&iter, &key, &value)) {
-		rspamd_http_router_add_path (ctx->http,
-			key,
-			rspamd_controller_handle_custom);
+		rspamd_http_router_add_path (ctx->http, key, rspamd_controller_handle_custom);
 	}
 
 #if 0
-	rspamd_http_router_add_path (ctx->http,
-		PATH_GRAPH,
-		rspamd_controller_handle_graph,
-		ctx);
+	rspamd_http_router_add_path (ctx->http, PATH_GRAPH, rspamd_controller_handle_graph, ctx);
 #endif
 
-	ctx->resolver = dns_resolver_init (worker->srv->logger,
-			ctx->ev_base,
-			worker->srv->cfg);
+	ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
 
 	/* Maps events */
 	start_map_watch (worker->srv->cfg, ctx->ev_base);
diff --git a/src/fuzzy_storage.c b/src/fuzzy_storage.c
index d007aed95..7fca37566 100644
--- a/src/fuzzy_storage.c
+++ b/src/fuzzy_storage.c
@@ -26,18 +26,18 @@
  * Rspamd fuzzy storage server
  */
 
-#include "bloom.h"
-#include "cfg_file.h"
 #include "config.h"
-#include "fuzzy.h"
-#include "fuzzy_storage.h"
+#include "util.h"
 #include "main.h"
-#include "map.h"
-#include "message.h"
 #include "protocol.h"
 #include "upstream.h"
+#include "cfg_file.h"
 #include "url.h"
-#include "util.h"
+#include "message.h"
+#include "fuzzy.h"
+#include "bloom.h"
+#include "map.h"
+#include "fuzzy_storage.h"
 
 /* This number is used as limit while comparing two fuzzy hashes, this value can vary from 0 to 100 */
 #define LEV_LIMIT 99
@@ -58,55 +58,55 @@
 /* Current version of fuzzy hash file format */
 #define CURRENT_FUZZY_VERSION 1
 
-#define INVALID_NODE_TIME (guint64) - 1
+#define INVALID_NODE_TIME (guint64)-1
 
 /* Init functions */
 gpointer init_fuzzy (struct rspamd_config *cfg);
 void start_fuzzy (struct rspamd_worker *worker);
 
 worker_t fuzzy_worker = {
-	"fuzzy",                    /* Name */
-	init_fuzzy,                 /* Init function */
-	start_fuzzy,                /* Start function */
-	TRUE,                       /* No socket */
-	TRUE,                       /* Unique */
-	TRUE,                       /* Threaded */
-	FALSE,                      /* Non killable */
-	SOCK_DGRAM                  /* UDP socket */
+	"fuzzy",					/* Name */
+	init_fuzzy,					/* Init function */
+	start_fuzzy,				/* Start function */
+	TRUE,						/* No socket */
+	TRUE,						/* Unique */
+	TRUE,						/* Threaded */
+	FALSE,						/* Non killable */
+	SOCK_DGRAM					/* UDP socket */
 };
 
-static GQueue *hashes[BUCKETS];
-static GQueue *frequent;
-static GHashTable *static_hash;
-static rspamd_bloom_filter_t *bf;
+static GQueue                  *hashes[BUCKETS];
+static GQueue                  *frequent;
+static GHashTable              *static_hash;
+static rspamd_bloom_filter_t   *bf;
 
 /* Number of cache modifications */
-static guint32 mods = 0;
+static guint32                 mods = 0;
 /* For evtimer */
-static struct timeval tmv;
-static struct event tev;
-static struct rspamd_stat *server_stat;
+static struct timeval           tmv;
+static struct event             tev;
+static struct rspamd_stat      *server_stat;
 
 struct rspamd_fuzzy_storage_ctx {
-	gboolean strict_hash;
-	char *hashfile;
-	gdouble expire;
-	guint32 frequent_score;
-	guint32 max_mods;
-	radix_tree_t *update_ips;
-	gchar *update_map;
-	struct event_base *ev_base;
-	rspamd_rwlock_t *tree_lock;
-	rspamd_mutex_t *update_mtx;
-	GCond *update_cond;
-	GThread *update_thread;
+	gboolean                        strict_hash;
+	char                           *hashfile;
+	gdouble                         expire;
+	guint32                         frequent_score;
+	guint32                         max_mods;
+	radix_tree_t                   *update_ips;
+	gchar                          *update_map;
+	struct event_base             *ev_base;
+	rspamd_rwlock_t                *tree_lock;
+	rspamd_mutex_t                 *update_mtx;
+	GCond                          *update_cond;
+	GThread                        *update_thread;
 };
 
 struct rspamd_fuzzy_node {
-	gint32 value;
-	gint32 flag;
-	guint64 time;
-	fuzzy_hash_t h;
+	gint32                          value;
+	gint32                          flag;
+	guint64                         time;
+	fuzzy_hash_t                    h;
 };
 
 struct fuzzy_session {
@@ -152,20 +152,20 @@ rspamd_fuzzy_free_node (gpointer n)
  */
 static void
 expire_nodes (gpointer *to_expire, gint expired_num,
-	struct rspamd_fuzzy_storage_ctx *ctx)
+		struct rspamd_fuzzy_storage_ctx *ctx)
 {
-	gint i;
-	struct rspamd_fuzzy_node *node;
-	GList *cur;
-	GQueue *head;
+	gint                            i;
+	struct rspamd_fuzzy_node      *node;
+	GList                          *cur;
+	GQueue                         *head;
 
-	for (i = 0; i < expired_num; i++) {
+	for (i = 0; i < expired_num; i ++) {
 		if (ctx->strict_hash) {
 			node = (struct rspamd_fuzzy_node *)to_expire[i];
 			if (node->time != INVALID_NODE_TIME) {
-				server_stat->fuzzy_hashes_expired++;
+				server_stat->fuzzy_hashes_expired ++;
 			}
-			server_stat->fuzzy_hashes--;
+			server_stat->fuzzy_hashes --;
 			rspamd_bloom_del (bf, node->h.hash_pipe);
 			g_hash_table_remove (static_hash, node->h.hash_pipe);
 		}
@@ -176,7 +176,7 @@ expire_nodes (gpointer *to_expire, gint expired_num,
 			g_queue_delete_link (head, cur);
 			rspamd_bloom_del (bf, node->h.hash_pipe);
 			if (node->time != INVALID_NODE_TIME) {
-				server_stat->fuzzy_hashes_expired++;
+				server_stat->fuzzy_hashes_expired ++;
 			}
 			server_stat->fuzzy_hashes--;
 			g_slice_free1 (sizeof(struct rspamd_fuzzy_node), node);
@@ -187,20 +187,20 @@ expire_nodes (gpointer *to_expire, gint expired_num,
 static gpointer
 sync_cache (gpointer ud)
 {
-	static const int max_expired = 8192;
-	struct rspamd_worker *wrk = ud;
-	gint fd, i, expired_num = 0;
-	gchar *filename, header[4];
-	GList *cur;
-	struct rspamd_fuzzy_node *node;
-	gpointer *nodes_expired = NULL;
-	guint64 expire, now;
+	static const int              max_expired = 8192;
+	struct rspamd_worker          *wrk = ud;
+	gint                            fd, i, expired_num = 0;
+	gchar                          *filename, header[4];
+	GList                          *cur;
+	struct rspamd_fuzzy_node      *node;
+	gpointer                       *nodes_expired = NULL;
+	guint64                         expire, now;
 	struct rspamd_fuzzy_storage_ctx *ctx;
-	GHashTableIter iter;
+	GHashTableIter                  iter;
 
 	ctx = wrk->ctx;
 
-	for (;; ) {
+	for (;;) {
 
 		rspamd_mutex_lock (ctx->update_mtx);
 
@@ -221,9 +221,9 @@ sync_cache (gpointer ud)
 		expire = ctx->expire;
 
 		if ((fd = open (filename, O_WRONLY | O_TRUNC | O_CREAT,
-			S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH)) == -1) {
-			msg_err (
-				"cannot create hash file %s: %s", filename, strerror (errno));
+				S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH)) == -1) {
+			msg_err(
+					"cannot create hash file %s: %s", filename, strerror (errno));
 			rspamd_mutex_unlock (ctx->update_mtx);
 			if (wanna_die) {
 				return NULL;
@@ -239,10 +239,8 @@ sync_cache (gpointer ud)
 		memcpy (header, FUZZY_FILE_MAGIC, 3);
 		header[3] = (gchar) CURRENT_FUZZY_VERSION;
 		if (write (fd, header, sizeof(header)) == -1) {
-			msg_err (
-				"cannot write file %s while writing header: %s",
-				filename,
-				strerror (errno));
+			msg_err(
+					"cannot write file %s while writing header: %s", filename, strerror (errno));
 			goto end;
 		}
 
@@ -251,21 +249,18 @@ sync_cache (gpointer ud)
 			g_hash_table_iter_init (&iter, static_hash);
 
 			while (g_hash_table_iter_next (&iter, NULL, (void **)&node)) {
-				if (node->time == INVALID_NODE_TIME || now - node->time >
-					expire) {
+				if (node->time == INVALID_NODE_TIME || now - node->time > expire) {
 					if (nodes_expired == NULL) {
-						nodes_expired = g_malloc (
-							max_expired * sizeof (gpointer));
+						nodes_expired = g_malloc (max_expired * sizeof (gpointer));
 					}
 
 					if (expired_num < max_expired) {
-						nodes_expired[expired_num++] = node;
+						nodes_expired[expired_num ++] = node;
 					}
 					continue;
 				}
 				if (write (fd, node, sizeof (struct rspamd_fuzzy_node)) == -1) {
-					msg_err ("cannot write file %s: %s", filename,
-						strerror (errno));
+					msg_err ("cannot write file %s: %s", filename, strerror (errno));
 					goto end;
 				}
 			}
@@ -277,8 +272,7 @@ sync_cache (gpointer ud)
 			while (cur) {
 				node = cur->data;
 				if (write (fd, node, sizeof(struct rspamd_fuzzy_node)) == -1) {
-					msg_err ("cannot write file %s: %s", filename,
-						strerror (errno));
+					msg_err("cannot write file %s: %s", filename, strerror (errno));
 				}
 				cur = g_list_next (cur);
 			}
@@ -288,21 +282,18 @@ sync_cache (gpointer ud)
 					node = cur->data;
 					if (now - node->time > expire) {
 						if (nodes_expired == NULL) {
-							nodes_expired =
-								g_malloc (max_expired * sizeof (gpointer));
+							nodes_expired = g_malloc (max_expired * sizeof (gpointer));
 						}
 
 						if (expired_num < max_expired) {
-							nodes_expired[expired_num++] = cur;
+							nodes_expired[expired_num ++] = cur;
 						}
 						cur = g_list_next (cur);
 						continue;
 					}
-					if (write (fd, node,
-						sizeof(struct rspamd_fuzzy_node)) == -1) {
-						msg_err (
-							"cannot write file %s: %s", filename,
-							strerror (errno));
+					if (write (fd, node, sizeof(struct rspamd_fuzzy_node)) == -1) {
+						msg_err(
+								"cannot write file %s: %s", filename, strerror (errno));
 						goto end;
 					}
 					cur = g_list_next (cur);
@@ -337,9 +328,9 @@ end:
 static void
 sigterm_handler (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+	struct rspamd_worker           *worker = (struct rspamd_worker *)arg;
 	struct rspamd_fuzzy_storage_ctx *ctx;
-	static struct timeval tv = {
+	static struct timeval           tv = {
 		.tv_sec = 0,
 		.tv_usec = 0
 	};
@@ -363,9 +354,9 @@ sigterm_handler (gint fd, short what, void *arg)
 static void
 sigusr2_handler (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+	struct rspamd_worker           *worker = (struct rspamd_worker *)arg;
 	/* Do not accept new connections, preparing to end worker's process */
-	struct timeval tv;
+	struct timeval                  tv;
 	struct rspamd_fuzzy_storage_ctx *ctx;
 
 	ctx = worker->ctx;
@@ -385,20 +376,20 @@ sigusr2_handler (gint fd, short what, void *arg)
 	return;
 }
 
-static gboolean
+static                          gboolean
 read_hashes_file (struct rspamd_worker *wrk)
 {
-	gint r, fd, i, version = 0;
-	struct stat st;
-	gchar *filename, header[4];
-	gboolean touch_stat = TRUE;
-	struct rspamd_fuzzy_node *node;
+	gint                            r, fd, i, version = 0;
+	struct stat                     st;
+	gchar                           *filename, header[4];
+	gboolean                        touch_stat = TRUE;
+	struct rspamd_fuzzy_node       *node;
 	struct rspamd_fuzzy_storage_ctx *ctx = wrk->ctx;
 	struct {
-		gint32 value;
-		guint64 time;
-		fuzzy_hash_t h;
-	}                               legacy_node;
+		gint32                          value;
+		guint64                         time;
+		fuzzy_hash_t                    h;
+	}								legacy_node;
 
 	if (server_stat->fuzzy_hashes != 0) {
 		touch_stat = FALSE;
@@ -428,24 +419,20 @@ read_hashes_file (struct rspamd_worker *wrk)
 				close (fd);
 				return FALSE;
 			}
-			msg_info (
-				"reading fuzzy hashes storage file of version %d of size %d",
-				version,
-				(gint)(st.st_size -
-				sizeof (header)) / sizeof (struct rspamd_fuzzy_node));
+			msg_info ("reading fuzzy hashes storage file of version %d of size %d",
+					version, (gint)(st.st_size - sizeof (header)) / sizeof (struct rspamd_fuzzy_node));
 		}
 		else {
 			/* Old version */
 			version = 0;
-			msg_info (
-				"got old version of fuzzy hashes storage, it would be converted to new version %d automatically",
-				CURRENT_FUZZY_VERSION);
+			msg_info ("got old version of fuzzy hashes storage, it would be converted to new version %d automatically",
+					CURRENT_FUZZY_VERSION);
 			/* Rewind file */
 			(void)lseek (fd, 0, SEEK_SET);
 		}
 	}
 
-	for (;; ) {
+	for (;;) {
 		node = g_slice_alloc (sizeof (struct rspamd_fuzzy_node));
 		if (version == 0) {
 			r = read (fd, &legacy_node, sizeof (legacy_node));
@@ -476,14 +463,14 @@ read_hashes_file (struct rspamd_worker *wrk)
 		}
 		rspamd_bloom_add (bf, node->h.hash_pipe);
 		if (touch_stat) {
-			server_stat->fuzzy_hashes++;
+			server_stat->fuzzy_hashes ++;
 		}
 	}
 
 	if (!ctx->strict_hash) {
 		/* Sort everything */
 		g_queue_sort (frequent, compare_nodes, NULL);
-		for (i = 0; i < BUCKETS; i++) {
+		for (i = 0; i < BUCKETS; i ++) {
 			g_queue_sort (hashes[i], compare_nodes, NULL);
 		}
 	}
@@ -492,8 +479,7 @@ read_hashes_file (struct rspamd_worker *wrk)
 	close (fd);
 
 	if (r > 0) {
-		msg_warn ("ignore garbage at the end of file, length of garbage: %d",
-			r);
+		msg_warn ("ignore garbage at the end of file, length of garbage: %d", r);
 	}
 	else if (r == -1) {
 		msg_err ("cannot open read file %s: %s", filename, strerror (errno));
@@ -505,11 +491,11 @@ read_hashes_file (struct rspamd_worker *wrk)
 
 static inline struct rspamd_fuzzy_node *
 check_hash_node (GQueue *hash, fuzzy_hash_t *s, gint update_value,
-	guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
+		guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
 {
-	GList *cur;
-	struct rspamd_fuzzy_node *h;
-	gint prob = 0;
+	GList                          *cur;
+	struct rspamd_fuzzy_node       *h;
+	gint                            prob = 0;
 
 	if (ctx->strict_hash) {
 		h = g_hash_table_lookup (static_hash, s->hash_pipe);
@@ -520,7 +506,7 @@ check_hash_node (GQueue *hash, fuzzy_hash_t *s, gint update_value,
 			}
 			else if (update_value == 0 && time - h->time > ctx->expire) {
 				h->time = INVALID_NODE_TIME;
-				server_stat->fuzzy_hashes_expired++;
+				server_stat->fuzzy_hashes_expired ++;
 				return NULL;
 			}
 			else if (h->h.block_size== s->block_size) {
@@ -547,7 +533,7 @@ check_hash_node (GQueue *hash, fuzzy_hash_t *s, gint update_value,
 				}
 				else if (time - h->time > ctx->expire) {
 					h->time = INVALID_NODE_TIME;
-					server_stat->fuzzy_hashes_expired++;
+					server_stat->fuzzy_hashes_expired ++;
 					return NULL;
 				}
 				return h;
@@ -569,7 +555,7 @@ check_hash_node (GQueue *hash, fuzzy_hash_t *s, gint update_value,
 				}
 				else if (time - h->time > ctx->expire) {
 					h->time = INVALID_NODE_TIME;
-					server_stat->fuzzy_hashes_expired++;
+					server_stat->fuzzy_hashes_expired ++;
 					return NULL;
 				}
 				if (h->value > (gint)ctx->frequent_score) {
@@ -586,14 +572,11 @@ check_hash_node (GQueue *hash, fuzzy_hash_t *s, gint update_value,
 	return NULL;
 }
 
-static gint
-process_check_command (struct fuzzy_cmd *cmd,
-	gint *flag,
-	guint64 time,
-	struct rspamd_fuzzy_storage_ctx *ctx)
+static                          gint
+process_check_command (struct fuzzy_cmd *cmd, gint *flag, guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
 {
-	fuzzy_hash_t s;
-	struct rspamd_fuzzy_node *h;
+	fuzzy_hash_t                    s;
+	struct rspamd_fuzzy_node       *h;
 
 
 	if (!rspamd_bloom_check (bf, cmd->hash)) {
@@ -608,9 +591,7 @@ process_check_command (struct fuzzy_cmd *cmd,
 		h = check_hash_node (NULL, &s, 0, time, ctx);
 	}
 	else {
-		h =
-			check_hash_node (hashes[cmd->blocksize % BUCKETS], &s, 0, time,
-				ctx);
+		h = check_hash_node (hashes[cmd->blocksize % BUCKETS], &s, 0, time, ctx);
 	}
 	rspamd_rwlock_reader_unlock (ctx->tree_lock);
 
@@ -623,28 +604,22 @@ process_check_command (struct fuzzy_cmd *cmd,
 	}
 }
 
-static gboolean
-update_hash (struct fuzzy_cmd *cmd,
-	guint64 time,
-	struct rspamd_fuzzy_storage_ctx *ctx)
+static                          gboolean
+update_hash (struct fuzzy_cmd *cmd, guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
 {
-	fuzzy_hash_t s;
-	struct rspamd_fuzzy_node *n;
+	fuzzy_hash_t                    s;
+	struct rspamd_fuzzy_node      *n;
 
 	memcpy (s.hash_pipe, cmd->hash, sizeof (s.hash_pipe));
 	s.block_size = cmd->blocksize;
-	mods++;
+	mods ++;
 
 	rspamd_rwlock_writer_lock (ctx->tree_lock);
 	if (ctx->strict_hash) {
 		n = check_hash_node (NULL, &s, cmd->value, time, ctx);
 	}
 	else {
-		n = check_hash_node (hashes[cmd->blocksize % BUCKETS],
-				&s,
-				cmd->value,
-				time,
-				ctx);
+		n = check_hash_node (hashes[cmd->blocksize % BUCKETS], &s, cmd->value, time, ctx);
 	}
 	rspamd_rwlock_writer_unlock (ctx->tree_lock);
 
@@ -655,12 +630,10 @@ update_hash (struct fuzzy_cmd *cmd,
 	return FALSE;
 }
 
-static gboolean
-process_write_command (struct fuzzy_cmd *cmd,
-	guint64 time,
-	struct rspamd_fuzzy_storage_ctx *ctx)
+static                          gboolean
+process_write_command (struct fuzzy_cmd *cmd, guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
 {
-	struct rspamd_fuzzy_node *h;
+	struct rspamd_fuzzy_node       *h;
 
 	if (rspamd_bloom_check (bf, cmd->hash)) {
 		if (update_hash (cmd, time, ctx)) {
@@ -686,26 +659,25 @@ process_write_command (struct fuzzy_cmd *cmd,
 	rspamd_rwlock_writer_unlock (ctx->tree_lock);
 
 	mods++;
-	server_stat->fuzzy_hashes++;
+	server_stat->fuzzy_hashes ++;
 	msg_info ("fuzzy hash was successfully added");
 
 	return TRUE;
 }
 
 static gboolean
-delete_hash (GQueue *hash, fuzzy_hash_t *s,
-	struct rspamd_fuzzy_storage_ctx *ctx)
+delete_hash (GQueue *hash, fuzzy_hash_t *s, struct rspamd_fuzzy_storage_ctx *ctx)
 {
-	GList *cur, *tmp;
-	struct rspamd_fuzzy_node *h;
-	gboolean res = FALSE;
+	GList                          *cur, *tmp;
+	struct rspamd_fuzzy_node       *h;
+	gboolean                        res = FALSE;
 
 	if (ctx->strict_hash) {
 		rspamd_rwlock_writer_lock (ctx->tree_lock);
 		if (g_hash_table_remove (static_hash, s->hash_pipe)) {
 			rspamd_bloom_del (bf, s->hash_pipe);
 			msg_info ("fuzzy hash was successfully deleted");
-			server_stat->fuzzy_hashes--;
+			server_stat->fuzzy_hashes --;
 			mods++;
 		}
 		rspamd_rwlock_writer_unlock (ctx->tree_lock);
@@ -724,7 +696,7 @@ delete_hash (GQueue *hash, fuzzy_hash_t *s,
 				g_queue_delete_link (hash, tmp);
 				rspamd_bloom_del (bf, s->hash_pipe);
 				msg_info ("fuzzy hash was successfully deleted");
-				server_stat->fuzzy_hashes--;
+				server_stat->fuzzy_hashes --;
 				mods++;
 				res = TRUE;
 				continue;
@@ -738,13 +710,11 @@ delete_hash (GQueue *hash, fuzzy_hash_t *s,
 
 }
 
-static gboolean
-process_delete_command (struct fuzzy_cmd *cmd,
-	guint64 time,
-	struct rspamd_fuzzy_storage_ctx *ctx)
+static                          gboolean
+process_delete_command (struct fuzzy_cmd *cmd, guint64 time, struct rspamd_fuzzy_storage_ctx *ctx)
 {
-	fuzzy_hash_t s;
-	gboolean res = FALSE;
+	fuzzy_hash_t                    s;
+	gboolean                        res = FALSE;
 
 	if (!rspamd_bloom_check (bf, cmd->hash)) {
 		return FALSE;
@@ -780,8 +750,7 @@ check_fuzzy_client (struct fuzzy_session *session)
 			return FALSE;
 		}
 		if (radix32tree_find (session->ctx->update_ips,
-			ntohl (session->client_addr.s4.sin_addr.s_addr)) ==
-			RADIX_NO_VALUE) {
+				ntohl (session->client_addr.s4.sin_addr.s_addr)) == RADIX_NO_VALUE) {
 			return FALSE;
 		}
 	}
@@ -789,45 +758,39 @@ check_fuzzy_client (struct fuzzy_session *session)
 	return TRUE;
 }
 
-#define CMD_PROCESS(x)                                                                          \
-	do {                                                                                            \
-		if (process_ ## x ## _command (&session->cmd, session->time, \
-			session->worker->ctx)) {               \
-			if (sendto (session->fd, "OK" CRLF, sizeof ("OK" CRLF) - 1, 0, \
-				&session->client_addr.ss, session->salen) == -1) {                           \
-				msg_err ("error while writing reply: %s", strerror (errno));        \
-			}                                                                                           \
-		}                                                                                               \
-		else {                                                                                          \
-			if (sendto (session->fd, "ERR" CRLF, sizeof ("ERR" CRLF) - 1, 0, \
-				&session->client_addr.ss, session->salen) == -1) {                     \
-				msg_err ("error while writing reply: %s", strerror (errno));        \
-			}                                                                                           \
-		}                                                                                               \
-	} while (0)
+#define CMD_PROCESS(x)																			\
+do {																							\
+if (process_##x##_command (&session->cmd, session->time, session->worker->ctx)) {				\
+	if (sendto (session->fd, "OK" CRLF, sizeof ("OK" CRLF) - 1, 0, &session->client_addr.ss, session->salen) == -1) {							\
+		msg_err ("error while writing reply: %s", strerror (errno));		\
+	}																							\
+}																								\
+else {																							\
+	if (sendto (session->fd, "ERR" CRLF, sizeof ("ERR" CRLF) - 1, 0, &session->client_addr.ss, session->salen) == -1) {						\
+		msg_err ("error while writing reply: %s", strerror (errno));		\
+	}																							\
+}																								\
+} while(0)
 
 static void
 process_fuzzy_command (struct fuzzy_session *session)
 {
-	gint r, flag = 0;
-	gchar buf[64];
+	gint                            r, flag = 0;
+	gchar                           buf[64];
 
 	switch (session->cmd.cmd) {
 	case FUZZY_CHECK:
-		r = process_check_command (&session->cmd,
-				&flag,
-				session->time,
-				session->worker->ctx);
+		r = process_check_command (&session->cmd, &flag, session->time, session->worker->ctx);
 		if (r != 0) {
 			r = rspamd_snprintf (buf, sizeof (buf), "OK %d %d" CRLF, r, flag);
 			if (sendto (session->fd, buf, r, 0,
-				&session->client_addr.ss, session->salen) == -1) {
+					&session->client_addr.ss, session->salen) == -1) {
 				msg_err ("error while writing reply: %s", strerror (errno));
 			}
 		}
 		else {
 			if (sendto (session->fd, "ERR" CRLF, sizeof ("ERR" CRLF) - 1, 0,
-				&session->client_addr.ss, session->salen) == -1) {
+					&session->client_addr.ss, session->salen) == -1) {
 				msg_err ("error while writing reply: %s", strerror (errno));
 			}
 		}
@@ -835,9 +798,8 @@ process_fuzzy_command (struct fuzzy_session *session)
 	case FUZZY_WRITE:
 		if (!check_fuzzy_client (session)) {
 			msg_info ("try to insert a hash from an untrusted address");
-			if (sendto (session->fd, "UNAUTH" CRLF, sizeof ("UNAUTH" CRLF) - 1,
-				0,
-				&session->client_addr.ss, session->salen) == -1) {
+			if (sendto (session->fd, "UNAUTH" CRLF, sizeof ("UNAUTH" CRLF) - 1, 0,
+					&session->client_addr.ss, session->salen) == -1) {
 				msg_err ("error while writing reply: %s", strerror (errno));
 			}
 		}
@@ -848,9 +810,8 @@ process_fuzzy_command (struct fuzzy_session *session)
 	case FUZZY_DEL:
 		if (!check_fuzzy_client (session)) {
 			msg_info ("try to delete a hash from an untrusted address");
-			if (sendto (session->fd, "UNAUTH" CRLF, sizeof ("UNAUTH" CRLF) - 1,
-				0,
-				&session->client_addr.ss, session->salen) == -1) {
+			if (sendto (session->fd, "UNAUTH" CRLF, sizeof ("UNAUTH" CRLF) - 1, 0,
+					&session->client_addr.ss, session->salen) == -1) {
 				msg_err ("error while writing reply: %s", strerror (errno));
 			}
 		}
@@ -860,7 +821,7 @@ process_fuzzy_command (struct fuzzy_session *session)
 		break;
 	default:
 		if (sendto (session->fd, "ERR" CRLF, sizeof ("ERR" CRLF) - 1, 0,
-			&session->client_addr.ss, session->salen) == -1) {
+				&session->client_addr.ss, session->salen) == -1) {
 			msg_err ("error while writing reply: %s", strerror (errno));
 		}
 		break;
@@ -876,20 +837,20 @@ process_fuzzy_command (struct fuzzy_session *session)
 static void
 accept_fuzzy_socket (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
-	struct fuzzy_session session;
-	ssize_t r;
+	struct rspamd_worker           *worker = (struct rspamd_worker *)arg;
+	struct fuzzy_session            session;
+	ssize_t                         r;
 	struct {
-		u_char cmd;
-		guint32 blocksize;
-		gint32 value;
-		u_char hash[FUZZY_HASHLEN];
-	}                               legacy_cmd;
+		u_char                      cmd;
+		guint32                     blocksize;
+		gint32                      value;
+		u_char                      hash[FUZZY_HASHLEN];
+	}								legacy_cmd;
 
 
 	session.worker = worker;
 	session.fd = fd;
-	session.pos = (u_char *) &session.cmd;
+	session.pos = (u_char *) & session.cmd;
 	session.salen = sizeof (session.client_addr);
 	session.ctx = worker->ctx;
 	session.time = (guint64)time (NULL);
@@ -897,13 +858,11 @@ accept_fuzzy_socket (gint fd, short what, void *arg)
 	/* Got some data */
 	if (what == EV_READ) {
 		while ((r = recvfrom (fd, session.pos, sizeof (struct fuzzy_cmd),
-			MSG_WAITALL, &session.client_addr.ss, &session.salen)) == -1) {
+				MSG_WAITALL, &session.client_addr.ss, &session.salen)) == -1) {
 			if (errno == EINTR) {
 				continue;
 			}
-			msg_err ("got error while reading from socket: %d, %s",
-				errno,
-				strerror (errno));
+			msg_err ("got error while reading from socket: %d, %s", errno, strerror (errno));
 			return;
 		}
 		if (r == sizeof (struct fuzzy_cmd)) {
@@ -917,14 +876,11 @@ accept_fuzzy_socket (gint fd, short what, void *arg)
 			session.cmd.blocksize = legacy_cmd.blocksize;
 			session.cmd.value = legacy_cmd.value;
 			session.cmd.flag = 0;
-			memcpy (session.cmd.hash, legacy_cmd.hash,
-				sizeof (legacy_cmd.hash));
+			memcpy (session.cmd.hash, legacy_cmd.hash, sizeof (legacy_cmd.hash));
 			process_fuzzy_command (&session);
 		}
 		else {
-			msg_err ("got incomplete data while reading from socket: %d, %s",
-				errno,
-				strerror (errno));
+			msg_err ("got incomplete data while reading from socket: %d, %s", errno, strerror (errno));
 			return;
 		}
 	}
@@ -933,8 +889,8 @@ accept_fuzzy_socket (gint fd, short what, void *arg)
 static void
 sync_callback (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
-	struct rspamd_fuzzy_storage_ctx *ctx;
+	struct rspamd_worker                  *worker = (struct rspamd_worker *)arg;
+	struct rspamd_fuzzy_storage_ctx       *ctx;
 
 	ctx = worker->ctx;
 	/* Timer event */
@@ -953,8 +909,8 @@ sync_callback (gint fd, short what, void *arg)
 gpointer
 init_fuzzy (struct rspamd_config *cfg)
 {
-	struct rspamd_fuzzy_storage_ctx *ctx;
-	GQuark type;
+	struct rspamd_fuzzy_storage_ctx       *ctx;
+	GQuark							       type;
 
 	type = g_quark_try_string ("fuzzy");
 
@@ -973,31 +929,28 @@ init_fuzzy (struct rspamd_config *cfg)
 #endif
 
 	rspamd_rcl_register_worker_option (cfg, type, "hashfile",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, hashfile), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, hashfile), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "max_mods",
-		rspamd_rcl_parse_struct_integer, ctx,
-		G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx,
-		max_mods), RSPAMD_CL_FLAG_INT_32);
+			rspamd_rcl_parse_struct_integer, ctx,
+			G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, max_mods), RSPAMD_CL_FLAG_INT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "frequent_score",
-		rspamd_rcl_parse_struct_integer, ctx,
-		G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx,
-		frequent_score), RSPAMD_CL_FLAG_INT_32);
+			rspamd_rcl_parse_struct_integer, ctx,
+			G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, frequent_score), RSPAMD_CL_FLAG_INT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "expire",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx,
-		expire), RSPAMD_CL_FLAG_TIME_FLOAT);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, expire), RSPAMD_CL_FLAG_TIME_FLOAT);
 
 	rspamd_rcl_register_worker_option (cfg, type, "strict_hash",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, strict_hash), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, strict_hash), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "allow_update",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, update_map), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_fuzzy_storage_ctx, update_map), 0);
 
 
 	return ctx;
@@ -1009,20 +962,17 @@ init_fuzzy (struct rspamd_config *cfg)
 void
 start_fuzzy (struct rspamd_worker *worker)
 {
-	struct event sev;
+	struct event                     sev;
 	struct rspamd_fuzzy_storage_ctx *ctx = worker->ctx;
-	GError *err = NULL;
+	GError                          *err = NULL;
 	gint i;
 
-	ctx->ev_base = rspamd_prepare_worker (worker,
-			"controller",
-			accept_fuzzy_socket);
+	ctx->ev_base = rspamd_prepare_worker (worker, "controller", accept_fuzzy_socket);
 	server_stat = worker->srv->stat;
 
 	/* Custom SIGUSR2 handler */
 	event_del (&worker->sig_ev_usr2);
-	signal_set (&worker->sig_ev_usr2, SIGUSR2, sigusr2_handler,
-		(void *) worker);
+	signal_set (&worker->sig_ev_usr2, SIGUSR2, sigusr2_handler, (void *) worker);
 	event_base_set (ctx->ev_base, &worker->sig_ev_usr2);
 	signal_add (&worker->sig_ev_usr2, NULL);
 
@@ -1047,8 +997,7 @@ start_fuzzy (struct rspamd_worker *worker)
 	bf = rspamd_bloom_create (2000000L, RSPAMD_DEFAULT_BLOOM_HASHES);
 	/* Try to read hashes from file */
 	if (!read_hashes_file (worker)) {
-		msg_err (
-			"cannot read hashes file, it can be created after save procedure");
+		msg_err ("cannot read hashes file, it can be created after save procedure");
 	}
 
 	/* Timer event */
@@ -1061,13 +1010,10 @@ start_fuzzy (struct rspamd_worker *worker)
 
 	/* Create radix tree */
 	if (ctx->update_map != NULL) {
-		if (!add_map (worker->srv->cfg, ctx->update_map,
-			"Allow fuzzy updates from specified addresses",
-			read_radix_list, fin_radix_list, (void **)&ctx->update_ips)) {
-			if (!rspamd_config_parse_ip_list (ctx->update_map,
-				&ctx->update_ips)) {
-				msg_warn ("cannot load or parse ip list from '%s'",
-					ctx->update_map);
+		if (!add_map (worker->srv->cfg, ctx->update_map, "Allow fuzzy updates from specified addresses",
+				read_radix_list, fin_radix_list, (void **)&ctx->update_ips)) {
+			if (!rspamd_config_parse_ip_list (ctx->update_map, &ctx->update_ips)) {
+				msg_warn ("cannot load or parse ip list from '%s'", ctx->update_map);
 			}
 		}
 	}
@@ -1075,10 +1021,7 @@ start_fuzzy (struct rspamd_worker *worker)
 	/* Maps events */
 	start_map_watch (worker->srv->cfg, ctx->ev_base);
 
-	ctx->update_thread = rspamd_create_thread ("fuzzy update",
-			sync_cache,
-			worker,
-			&err);
+	ctx->update_thread = rspamd_create_thread ("fuzzy update", sync_cache, worker, &err);
 	if (ctx->update_thread == NULL) {
 		msg_err ("error creating update thread: %s", err->message);
 	}
diff --git a/src/fuzzy_storage.h b/src/fuzzy_storage.h
index 41a368fe3..3e6bcd818 100644
--- a/src/fuzzy_storage.h
+++ b/src/fuzzy_storage.h
@@ -2,8 +2,8 @@
 #define RSPAMD_FUZZY_STORAGE_H
 
 #include "config.h"
-#include "fuzzy.h"
 #include "main.h"
+#include "fuzzy.h"
 
 /* Commands for fuzzy storage */
 #define FUZZY_CHECK 0
diff --git a/src/kvstorage.c b/src/kvstorage.c
index caa131afe..9cb921d7e 100644
--- a/src/kvstorage.c
+++ b/src/kvstorage.c
@@ -33,16 +33,10 @@
 
 /** Create new kv storage */
 struct rspamd_kv_storage *
-rspamd_kv_storage_new (gint id,
-	const gchar *name,
-	struct rspamd_kv_cache *cache,
-	struct rspamd_kv_backend *backend,
-	struct rspamd_kv_expire *expire,
-	gsize max_elts,
-	gsize max_memory,
-	gboolean no_overwrite)
+rspamd_kv_storage_new (gint id, const gchar *name, struct rspamd_kv_cache *cache, struct rspamd_kv_backend *backend, struct rspamd_kv_expire *expire,
+		gsize max_elts, gsize max_memory, gboolean no_overwrite)
 {
-	struct rspamd_kv_storage *new;
+	struct rspamd_kv_storage 			*new;
 
 	new = g_slice_alloc (sizeof (struct rspamd_kv_storage));
 	new->elts = 0;
@@ -90,27 +84,18 @@ rspamd_kv_storage_new (gint id,
 
 /** Internal insertion to the kv storage from backend */
 gboolean
-rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	gpointer data,
-	gsize len,
-	gint flags,
-	guint expire,
-	struct rspamd_kv_element **pelt)
+rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
+		gpointer data, gsize len, gint flags, guint expire, struct rspamd_kv_element **pelt)
 {
-	gint steps = 0;
-	struct rspamd_kv_element *elt;
+	gint 								steps = 0;
+	struct rspamd_kv_element		 	*elt;
 
 	RW_W_LOCK (&storage->rwlock);
 	/* Hard limit */
 	if (storage->max_memory > 0) {
 		if (len > storage->max_memory) {
-			msg_info (
-				"<%s>: trying to insert value of length %z while limit is %z",
-				storage->name,
-				len,
-				storage->max_memory);
+			msg_info ("<%s>: trying to insert value of length %z while limit is %z", storage->name,
+					len, storage->max_memory);
 			RW_W_UNLOCK (&storage->rwlock);
 			return FALSE;
 		}
@@ -118,18 +103,14 @@ rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage,
 		/* Now check limits */
 		while (storage->memory + len > storage->max_memory) {
 			if (storage->expire) {
-				storage->expire->step_func (storage->expire, storage, time (
-						NULL), steps);
+				storage->expire->step_func (storage->expire, storage, time (NULL), steps);
 			}
 			else {
-				msg_warn (
-					"<%s>: storage is full and no expire function is defined",
-					storage->name);
+				msg_warn ("<%s>: storage is full and no expire function is defined", storage->name);
 			}
 			if (++steps > MAX_EXPIRE_STEPS) {
 				RW_W_UNLOCK (&storage->rwlock);
-				msg_warn ("<%s>: cannot expire enough keys in storage",
-					storage->name);
+				msg_warn ("<%s>: cannot expire enough keys in storage", storage->name);
 				return FALSE;
 			}
 		}
@@ -153,7 +134,7 @@ rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage,
 		storage->expire->insert_func (storage->expire, elt);
 	}
 
-	storage->elts++;
+	storage->elts ++;
 	storage->memory += ELT_SIZE (elt);
 	RW_W_UNLOCK (&storage->rwlock);
 
@@ -162,29 +143,20 @@ rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage,
 
 /** Insert new element to the kv storage */
 gboolean
-rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	gpointer data,
-	gsize len,
-	gint flags,
-	guint expire)
+rspamd_kv_storage_insert (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
+		gpointer data, gsize len, gint flags, guint expire)
 {
-	gint steps = 0;
-	struct rspamd_kv_element *elt;
-	gboolean res = TRUE;
-	glong longval;
+	gint 								steps = 0;
+	struct rspamd_kv_element           *elt;
+	gboolean							res = TRUE;
+	glong								longval;
 
 	/* Hard limit */
 	RW_W_LOCK (&storage->rwlock);
 	if (storage->max_memory > 0) {
-		if (len + sizeof (struct rspamd_kv_element) + keylen >=
-			storage->max_memory) {
-			msg_warn (
-				"<%s>: trying to insert value of length %z while limit is %z",
-				storage->name,
-				len,
-				storage->max_memory);
+		if (len + sizeof (struct rspamd_kv_element) + keylen >= storage->max_memory) {
+			msg_warn ("<%s>: trying to insert value of length %z while limit is %z", storage->name,
+					len, storage->max_memory);
 			RW_W_UNLOCK (&storage->rwlock);
 			return FALSE;
 		}
@@ -192,18 +164,14 @@ rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
 		/* Now check limits */
 		while (storage->memory + len + keylen > storage->max_memory) {
 			if (storage->expire) {
-				storage->expire->step_func (storage->expire, storage, time (
-						NULL), steps);
+				storage->expire->step_func (storage->expire, storage, time (NULL), steps);
 			}
 			else {
-				msg_warn (
-					"<%s>: storage is full and no expire function is defined",
-					storage->name);
+				msg_warn ("<%s>: storage is full and no expire function is defined", storage->name);
 			}
 			if (++steps > MAX_EXPIRE_STEPS) {
 				RW_W_UNLOCK (&storage->rwlock);
-				msg_warn ("<%s>: cannot expire enough keys in storage",
-					storage->name);
+				msg_warn ("<%s>: cannot expire enough keys in storage", storage->name);
 				return FALSE;
 			}
 		}
@@ -213,18 +181,14 @@ rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
 		steps = 0;
 		while (storage->elts > storage->max_elts) {
 			if (storage->expire) {
-				storage->expire->step_func (storage->expire, storage, time (
-						NULL), steps);
+				storage->expire->step_func (storage->expire, storage, time (NULL), steps);
 			}
 			else {
-				msg_warn (
-					"<%s>: storage is full and no expire function is defined",
-					storage->name);
+				msg_warn ("<%s>: storage is full and no expire function is defined", storage->name);
 			}
 			if (++steps > MAX_EXPIRE_STEPS) {
 				RW_W_UNLOCK (&storage->rwlock);
-				msg_warn ("<%s>: cannot expire enough keys in storage",
-					storage->name);
+				msg_warn ("<%s>: cannot expire enough keys in storage", storage->name);
 				return FALSE;
 			}
 		}
@@ -252,8 +216,7 @@ rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
 		else {
 			/* Just do incref and nothing more */
 			if (storage->backend && storage->backend->incref_func) {
-				if (storage->backend->incref_func (storage->backend, key,
-					keylen)) {
+				if (storage->backend->incref_func (storage->backend, key, keylen)) {
 					RW_W_UNLOCK (&storage->rwlock);
 					return TRUE;
 				}
@@ -269,11 +232,7 @@ rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
 
 	/* First of all check element for integer */
 	if (rspamd_strtol (data, len, &longval)) {
-		elt = storage->cache->insert_func (storage->cache,
-				key,
-				keylen,
-				&longval,
-				sizeof (glong));
+		elt = storage->cache->insert_func (storage->cache, key, keylen, &longval, sizeof (glong));
 		if (elt == NULL) {
 			return FALSE;
 		}
@@ -282,11 +241,7 @@ rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
 		}
 	}
 	else {
-		elt = storage->cache->insert_func (storage->cache,
-				key,
-				keylen,
-				data,
-				len);
+		elt = storage->cache->insert_func (storage->cache, key, keylen, data, len);
 		if (elt == NULL) {
 			RW_W_UNLOCK (&storage->rwlock);
 			return FALSE;
@@ -301,8 +256,7 @@ rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
 
 	/* Place to the backend */
 	if (storage->backend) {
-		res =
-			storage->backend->insert_func (storage->backend, key, keylen, elt);
+		res = storage->backend->insert_func (storage->backend, key, keylen, elt);
 	}
 
 	/* Insert to the expire */
@@ -310,7 +264,7 @@ rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
 		storage->expire->insert_func (storage->expire, elt);
 	}
 
-	storage->elts++;
+	storage->elts ++;
 	storage->memory += ELT_SIZE (elt);
 	RW_W_UNLOCK (&storage->rwlock);
 
@@ -319,22 +273,16 @@ rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
 
 /** Replace an element in the kv storage */
 gboolean
-rspamd_kv_storage_replace (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_kv_storage_replace (struct rspamd_kv_storage *storage, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	gboolean res = TRUE;
-	gint steps = 0;
+	gboolean						res = TRUE;
+	gint							steps = 0;
 
 	/* Hard limit */
 	if (storage->max_memory > 0) {
 		if (elt->size > storage->max_memory) {
-			msg_info (
-				"<%s>: trying to replace value of length %z while limit is %z",
-				storage->name,
-				elt->size,
-				storage->max_memory);
+			msg_info ("<%s>: trying to replace value of length %z while limit is %z", storage->name,
+					elt->size, storage->max_memory);
 			return FALSE;
 		}
 
@@ -342,18 +290,14 @@ rspamd_kv_storage_replace (struct rspamd_kv_storage *storage,
 		while (storage->memory + ELT_SIZE (elt) > storage->max_memory) {
 			if (storage->expire) {
 				RW_W_LOCK (&storage->rwlock);
-				storage->expire->step_func (storage->expire, storage, time (
-						NULL), steps);
+				storage->expire->step_func (storage->expire, storage, time (NULL), steps);
 				RW_W_UNLOCK (&storage->rwlock);
 			}
 			else {
-				msg_warn (
-					"<%s>: storage is full and no expire function is defined",
-					storage->name);
+				msg_warn ("<%s>: storage is full and no expire function is defined", storage->name);
 			}
 			if (++steps > MAX_EXPIRE_STEPS) {
-				msg_warn ("<%s>: cannot expire enough keys in storage",
-					storage->name);
+				msg_warn ("<%s>: cannot expire enough keys in storage", storage->name);
 				return FALSE;
 			}
 		}
@@ -365,8 +309,7 @@ rspamd_kv_storage_replace (struct rspamd_kv_storage *storage,
 
 	/* Place to the backend */
 	if (res && storage->backend) {
-		res =
-			storage->backend->replace_func (storage->backend, key, keylen, elt);
+		res = storage->backend->replace_func (storage->backend, key, keylen, elt);
 	}
 	RW_W_UNLOCK (&storage->rwlock);
 
@@ -375,13 +318,10 @@ rspamd_kv_storage_replace (struct rspamd_kv_storage *storage,
 
 /** Increment value in kvstorage */
 gboolean
-rspamd_kv_storage_increment (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	glong *value)
+rspamd_kv_storage_increment (struct rspamd_kv_storage *storage, gpointer key, guint keylen, glong *value)
 {
-	struct rspamd_kv_element *elt = NULL, *belt;
-	glong *lp;
+	struct rspamd_kv_element			*elt = NULL, *belt;
+	glong								*lp;
 
 	/* First try to look at cache */
 	RW_W_LOCK (&storage->rwlock);
@@ -393,8 +333,7 @@ rspamd_kv_storage_increment (struct rspamd_kv_storage *storage,
 			/* Put this element into cache */
 			if ((belt->flags & KV_ELT_INTEGER) != 0) {
 				RW_W_UNLOCK (&storage->rwlock);
-				rspamd_kv_storage_insert_cache (storage, ELT_KEY (
-						belt), keylen, ELT_DATA (belt),
+				rspamd_kv_storage_insert_cache (storage, ELT_KEY (belt), keylen, ELT_DATA (belt),
 					belt->size, belt->flags,
 					belt->expire, &elt);
 				RW_W_LOCK (&storage->rwlock);
@@ -416,8 +355,7 @@ rspamd_kv_storage_increment (struct rspamd_kv_storage *storage,
 		}
 		elt->age = time (NULL);
 		if (storage->backend) {
-			if (storage->backend->replace_func (storage->backend, key, keylen,
-				elt)) {
+			if (storage->backend->replace_func (storage->backend, key, keylen, elt)) {
 				RW_W_UNLOCK (&storage->rwlock);
 				return TRUE;
 			}
@@ -438,13 +376,10 @@ rspamd_kv_storage_increment (struct rspamd_kv_storage *storage,
 }
 
 /** Lookup an element inside kv storage */
-struct rspamd_kv_element *
-rspamd_kv_storage_lookup (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	time_t now)
+struct rspamd_kv_element*
+rspamd_kv_storage_lookup (struct rspamd_kv_storage *storage, gpointer key, guint keylen, time_t now)
 {
-	struct rspamd_kv_element *elt = NULL, *belt;
+	struct rspamd_kv_element			*elt = NULL, *belt;
 
 	/* First try to look at cache */
 	RW_R_LOCK (&storage->rwlock);
@@ -481,11 +416,9 @@ rspamd_kv_storage_lookup (struct rspamd_kv_storage *storage,
 
 /** Expire an element from kv storage */
 struct rspamd_kv_element *
-rspamd_kv_storage_delete (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen)
+rspamd_kv_storage_delete (struct rspamd_kv_storage *storage, gpointer key, guint keylen)
 {
-	struct rspamd_kv_element *elt;
+	struct rspamd_kv_element           *elt;
 
 	/* First delete key from cache */
 	RW_W_LOCK (&storage->rwlock);
@@ -500,7 +433,7 @@ rspamd_kv_storage_delete (struct rspamd_kv_storage *storage,
 		if (storage->expire) {
 			storage->expire->delete_func (storage->expire, elt);
 		}
-		storage->elts--;
+		storage->elts --;
 		storage->memory -= elt->size;
 		if ((elt->flags & KV_ELT_DIRTY) != 0) {
 			elt->flags |= KV_ELT_NEED_FREE;
@@ -538,27 +471,20 @@ rspamd_kv_storage_destroy (struct rspamd_kv_storage *storage)
 
 /** Insert array */
 gboolean
-rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	guint elt_size,
-	gpointer data,
-	gsize len,
-	gint flags,
-	guint expire)
+rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
+		guint elt_size, gpointer data, gsize len, gint flags, guint expire)
 {
-	struct rspamd_kv_element *elt;
-	guint *es;
-	gpointer arr_data;
+	struct rspamd_kv_element			*elt;
+	guint								*es;
+	gpointer 							 arr_data;
 
 	/* Make temporary copy */
 	arr_data = g_slice_alloc (len + sizeof (guint));
 	es = arr_data;
 	*es = elt_size;
 	memcpy (arr_data, (gchar *)data + sizeof (guint), len);
-	if (!rspamd_kv_storage_insert_cache (storage, key, keylen, arr_data, len +
-		sizeof (guint),
-		flags, expire, &elt)) {
+	if (!rspamd_kv_storage_insert_cache (storage, key, keylen, arr_data, len + sizeof (guint),
+			flags, expire, &elt)) {
 		g_slice_free1 (len + sizeof (guint), arr_data);
 		return FALSE;
 	}
@@ -568,8 +494,7 @@ rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage,
 	/* Place to the backend */
 
 	if (storage->backend) {
-		return storage->backend->insert_func (storage->backend, key, keylen,
-				   elt);
+		return storage->backend->insert_func (storage->backend, key, keylen, elt);
 	}
 
 	return TRUE;
@@ -577,17 +502,12 @@ rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage,
 
 /** Set element inside array */
 gboolean
-rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	guint elt_num,
-	gpointer data,
-	gsize len,
-	time_t now)
+rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
+		guint elt_num, gpointer data, gsize len, time_t now)
 {
-	struct rspamd_kv_element *elt;
-	guint *es;
-	gpointer target;
+	struct rspamd_kv_element			*elt;
+	guint								*es;
+	gpointer							 target;
 
 	elt = rspamd_kv_storage_lookup (storage, key, keylen, now);
 	if (elt == NULL) {
@@ -611,10 +531,7 @@ rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage,
 	memcpy (target, data, len);
 	/* Place to the backend */
 	if (storage->backend) {
-		return storage->backend->replace_func (storage->backend,
-				   key,
-				   keylen,
-				   elt);
+		return storage->backend->replace_func (storage->backend, key, keylen, elt);
 	}
 
 	return TRUE;
@@ -622,17 +539,12 @@ rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage,
 
 /** Get element inside array */
 gboolean
-rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	guint elt_num,
-	gpointer *data,
-	gsize *len,
-	time_t now)
+rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
+		guint elt_num, gpointer *data, gsize *len, time_t now)
 {
-	struct rspamd_kv_element *elt;
-	guint *es;
-	gpointer target;
+	struct rspamd_kv_element			*elt;
+	guint								*es;
+	gpointer							 target;
 
 	elt = rspamd_kv_storage_lookup (storage, key, keylen, now);
 	if (elt == NULL) {
@@ -661,11 +573,11 @@ rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage,
  */
 
 struct rspamd_kv_lru_expire {
-	expire_init init_func;                      /*< this callback is called on kv storage initialization */
-	expire_insert insert_func;                  /*< this callback is called when element is inserted */
-	expire_step step_func;                      /*< this callback is used when cache is full */
-	expire_delete delete_func;                  /*< this callback is called when an element is deleted */
-	expire_destroy destroy_func;                /*< this callback is used for destroying all elements inside expire */
+	expire_init init_func;						/*< this callback is called on kv storage initialization */
+	expire_insert insert_func;					/*< this callback is called when element is inserted */
+	expire_step step_func;						/*< this callback is used when cache is full */
+	expire_delete delete_func;					/*< this callback is called when an element is deleted */
+	expire_destroy destroy_func;				/*< this callback is used for destroying all elements inside expire */
 
 	TAILQ_HEAD (eltq, rspamd_kv_element) head;
 };
@@ -676,7 +588,7 @@ struct rspamd_kv_lru_expire {
 static void
 rspamd_lru_insert (struct rspamd_kv_expire *e, struct rspamd_kv_element *elt)
 {
-	struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
+	struct rspamd_kv_lru_expire			*expire = (struct rspamd_kv_lru_expire *)e;
 
 	/* Get a proper queue */
 	TAILQ_INSERT_TAIL (&expire->head, elt, entry);
@@ -687,7 +599,7 @@ rspamd_lru_insert (struct rspamd_kv_expire *e, struct rspamd_kv_element *elt)
 static void
 rspamd_lru_delete (struct rspamd_kv_expire *e, struct rspamd_kv_element *elt)
 {
-	struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
+	struct rspamd_kv_lru_expire			*expire = (struct rspamd_kv_lru_expire *)e;
 
 	/* Unlink element */
 	TAILQ_REMOVE (&expire->head, elt, entry);
@@ -697,19 +609,15 @@ rspamd_lru_delete (struct rspamd_kv_expire *e, struct rspamd_kv_element *elt)
  * Expire elements
  */
 static gboolean
-rspamd_lru_expire_step (struct rspamd_kv_expire *e,
-	struct rspamd_kv_storage *storage,
-	time_t now,
-	gboolean forced)
+rspamd_lru_expire_step (struct rspamd_kv_expire *e, struct rspamd_kv_storage *storage, time_t now, gboolean forced)
 {
-	struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
-	struct rspamd_kv_element *elt, *oldest_elt = NULL, *temp;
-	time_t diff;
-	gboolean res = FALSE;
+	struct rspamd_kv_lru_expire			*expire = (struct rspamd_kv_lru_expire *)e;
+	struct rspamd_kv_element            *elt, *oldest_elt = NULL, *temp;
+	time_t                               diff;
+	gboolean                             res = FALSE;
 
 	elt = TAILQ_FIRST (&expire->head);
-	if (elt &&
-		(forced || (elt->flags & (KV_ELT_PERSISTENT | KV_ELT_DIRTY)) == 0)) {
+	if (elt && (forced || (elt->flags & (KV_ELT_PERSISTENT|KV_ELT_DIRTY)) == 0)) {
 		diff = elt->expire - (now - elt->age);
 		if (diff > 0 || (forced && elt->expire == 0)) {
 			oldest_elt = elt;
@@ -718,10 +626,10 @@ rspamd_lru_expire_step (struct rspamd_kv_expire *e,
 			/* This element is already expired */
 			storage->cache->steal_func (storage->cache, elt);
 			storage->memory -= ELT_SIZE (elt);
-			storage->elts--;
+			storage->elts --;
 			TAILQ_REMOVE (&expire->head, elt, entry);
 			/* Free memory */
-			if ((elt->flags & (KV_ELT_DIRTY | KV_ELT_NEED_INSERT)) != 0) {
+			if ((elt->flags & (KV_ELT_DIRTY|KV_ELT_NEED_INSERT)) != 0) {
 				elt->flags |= KV_ELT_NEED_FREE;
 			}
 			else {
@@ -729,19 +637,17 @@ rspamd_lru_expire_step (struct rspamd_kv_expire *e,
 			}
 			res = TRUE;
 			/* Check other elements in this queue */
-			TAILQ_FOREACH_SAFE (elt, &expire->head, entry, temp)
-			{
+			TAILQ_FOREACH_SAFE (elt, &expire->head, entry, temp) {
 				if ((!forced &&
-					(elt->flags & (KV_ELT_PERSISTENT | KV_ELT_DIRTY)) != 0) ||
-					(gint)elt->expire < (now - elt->age)) {
+					(elt->flags & (KV_ELT_PERSISTENT|KV_ELT_DIRTY)) != 0) || (gint)elt->expire < (now - elt->age)) {
 					break;
 				}
 				storage->memory -= ELT_SIZE (elt);
-				storage->elts--;
+				storage->elts --;
 				storage->cache->steal_func (storage->cache, elt);
 				TAILQ_REMOVE (&expire->head, elt, entry);
 				/* Free memory */
-				if ((elt->flags & (KV_ELT_DIRTY | KV_ELT_NEED_INSERT)) != 0) {
+				if ((elt->flags & (KV_ELT_DIRTY|KV_ELT_NEED_INSERT)) != 0) {
 					elt->flags |= KV_ELT_NEED_FREE;
 				}
 				else {
@@ -754,11 +660,11 @@ rspamd_lru_expire_step (struct rspamd_kv_expire *e,
 
 	if (!res && oldest_elt != NULL) {
 		storage->memory -= ELT_SIZE (oldest_elt);
-		storage->elts--;
+		storage->elts --;
 		storage->cache->steal_func (storage->cache, oldest_elt);
 		TAILQ_REMOVE (&expire->head, oldest_elt, entry);
 		/* Free memory */
-		if ((oldest_elt->flags & (KV_ELT_DIRTY | KV_ELT_NEED_INSERT)) != 0) {
+		if ((oldest_elt->flags & (KV_ELT_DIRTY|KV_ELT_NEED_INSERT)) != 0) {
 			oldest_elt->flags |= KV_ELT_NEED_FREE;
 		}
 		else {
@@ -775,7 +681,7 @@ rspamd_lru_expire_step (struct rspamd_kv_expire *e,
 static void
 rspamd_lru_destroy (struct rspamd_kv_expire *e)
 {
-	struct rspamd_kv_lru_expire *expire = (struct rspamd_kv_lru_expire *)e;
+	struct rspamd_kv_lru_expire			*expire = (struct rspamd_kv_lru_expire *)e;
 
 	g_slice_free1 (sizeof (struct rspamd_kv_lru_expire), expire);
 }
@@ -783,10 +689,10 @@ rspamd_lru_destroy (struct rspamd_kv_expire *e)
 /**
  * Create new LRU cache
  */
-struct rspamd_kv_expire *
+struct rspamd_kv_expire*
 rspamd_lru_expire_new (void)
 {
-	struct rspamd_kv_lru_expire *new;
+	struct rspamd_kv_lru_expire			*new;
 
 	new = g_slice_alloc (sizeof (struct rspamd_kv_lru_expire));
 	TAILQ_INIT (&new->head);
@@ -805,41 +711,36 @@ rspamd_lru_expire_new (void)
  * KV cache hash table
  */
 struct rspamd_kv_hash_cache {
-	cache_init init_func;                       /*< this callback is called on kv storage initialization */
-	cache_insert insert_func;                   /*< this callback is called when element is inserted */
-	cache_replace replace_func;                 /*< this callback is called when element is replace */
-	cache_lookup lookup_func;                   /*< this callback is used for lookup of element */
-	cache_delete delete_func;                   /*< this callback is called when an element is deleted */
-	cache_steal steal_func;                     /*< this callback is used to replace duplicates in cache */
-	cache_destroy destroy_func;                 /*< this callback is used for destroying all elements inside cache */
+	cache_init init_func;						/*< this callback is called on kv storage initialization */
+	cache_insert insert_func;					/*< this callback is called when element is inserted */
+	cache_replace replace_func;					/*< this callback is called when element is replace */
+	cache_lookup lookup_func;					/*< this callback is used for lookup of element */
+	cache_delete delete_func;					/*< this callback is called when an element is deleted */
+	cache_steal steal_func;						/*< this callback is used to replace duplicates in cache */
+	cache_destroy destroy_func;					/*< this callback is used for destroying all elements inside cache */
 	GHashTable *hash;
 };
 
 /**
  * Insert an element inside cache
  */
-static struct rspamd_kv_element *
-rspamd_kv_hash_insert (struct rspamd_kv_cache *c,
-	gpointer key,
-	guint keylen,
-	gpointer value,
-	gsize len)
+static struct rspamd_kv_element*
+rspamd_kv_hash_insert (struct rspamd_kv_cache *c, gpointer key, guint keylen, gpointer value, gsize len)
 {
-	struct rspamd_kv_element *elt;
-	struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_kv_element 			*elt;
+	struct rspamd_kv_hash_cache			*cache = (struct rspamd_kv_hash_cache *)c;
+	struct rspamd_kv_element			 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
 
 	if ((elt = g_hash_table_lookup (cache->hash, &search_elt)) == NULL) {
-		elt = g_slice_alloc (
-			sizeof (struct rspamd_kv_element) + len + keylen + 1);
+		elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
 		elt->age = time (NULL);
 		elt->keylen = keylen;
 		elt->size = len;
 		elt->flags = 0;
-		memcpy (ELT_KEY (elt),	key,   keylen + 1);
+		memcpy (ELT_KEY (elt), key, keylen + 1);
 		memcpy (ELT_DATA (elt), value, len);
 		elt->p = &elt->data;
 		g_hash_table_insert (cache->hash, elt, elt);
@@ -853,13 +754,12 @@ rspamd_kv_hash_insert (struct rspamd_kv_cache *c,
 			/* Free it by self */
 			g_slice_free1 (ELT_SIZE (elt), elt);
 		}
-		elt = g_slice_alloc (
-			sizeof (struct rspamd_kv_element) + len + keylen + 1);
+		elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
 		elt->age = time (NULL);
 		elt->keylen = keylen;
 		elt->size = len;
 		elt->flags = 0;
-		memcpy (ELT_KEY (elt),	key,   keylen + 1);
+		memcpy (ELT_KEY (elt), key, keylen + 1);
 		memcpy (ELT_DATA (elt), value, len);
 		elt->p = &elt->data;
 		g_hash_table_insert (cache->hash, elt, elt);
@@ -871,11 +771,11 @@ rspamd_kv_hash_insert (struct rspamd_kv_cache *c,
 /**
  * Lookup an item inside hash
  */
-static struct rspamd_kv_element *
+static struct rspamd_kv_element*
 rspamd_kv_hash_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 {
-	struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_kv_hash_cache			*cache = (struct rspamd_kv_hash_cache *)c;
+	struct rspamd_kv_element			 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -887,13 +787,10 @@ rspamd_kv_hash_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
  * Replace an element inside cache
  */
 static gboolean
-rspamd_kv_hash_replace (struct rspamd_kv_cache *c,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_kv_hash_replace (struct rspamd_kv_cache *c, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
-	struct rspamd_kv_element *oldelt, search_elt;
+	struct rspamd_kv_hash_cache			*cache = (struct rspamd_kv_hash_cache *)c;
+	struct rspamd_kv_element 			*oldelt, search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -921,9 +818,9 @@ rspamd_kv_hash_replace (struct rspamd_kv_cache *c,
 static struct rspamd_kv_element *
 rspamd_kv_hash_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 {
-	struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
-	struct rspamd_kv_element *elt;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_kv_hash_cache			*cache = (struct rspamd_kv_hash_cache *)c;
+	struct rspamd_kv_element            *elt;
+	struct rspamd_kv_element			 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -941,7 +838,7 @@ rspamd_kv_hash_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 static void
 rspamd_kv_hash_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
 {
-	struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
+	struct rspamd_kv_hash_cache			*cache = (struct rspamd_kv_hash_cache *)c;
 
 	g_hash_table_steal (cache->hash, elt);
 }
@@ -953,7 +850,7 @@ rspamd_kv_hash_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
 static void
 rspamd_kv_hash_destroy_cb (gpointer key, gpointer value, gpointer unused)
 {
-	struct rspamd_kv_element *elt = value;
+	struct rspamd_kv_element 			*elt = value;
 
 	g_slice_free1 (ELT_SIZE (elt), elt);
 }
@@ -961,7 +858,7 @@ rspamd_kv_hash_destroy_cb (gpointer key, gpointer value, gpointer unused)
 static void
 rspamd_kv_hash_destroy (struct rspamd_kv_cache *c)
 {
-	struct rspamd_kv_hash_cache *cache = (struct rspamd_kv_hash_cache *)c;
+	struct rspamd_kv_hash_cache			*cache = (struct rspamd_kv_hash_cache *)c;
 
 	g_hash_table_foreach (cache->hash, rspamd_kv_hash_destroy_cb, NULL);
 	g_hash_table_destroy (cache->hash);
@@ -971,26 +868,26 @@ rspamd_kv_hash_destroy (struct rspamd_kv_cache *c)
 /**
  * Make hash for element
  */
-#define rot(x,k) (((x) << (k)) ^ ((x) >> (32 - (k))))
+#define rot(x,k) (((x)<<(k)) ^ ((x)>>(32-(k))))
 #define mix(a,b,c) \
-	{ \
-		a -= c;  a ^= rot (c, 4);  c += b; \
-		b -= a;  b ^= rot (a, 6);  a += c; \
-		c -= b;  c ^= rot (b, 8);  b += a; \
-		a -= c;  a ^= rot (c,16);  c += b; \
-		b -= a;  b ^= rot (a,19);  a += c; \
-		c -= b;  c ^= rot (b, 4);  b += a; \
-	}
+{ \
+  a -= c;  a ^= rot(c, 4);  c += b; \
+  b -= a;  b ^= rot(a, 6);  a += c; \
+  c -= b;  c ^= rot(b, 8);  b += a; \
+  a -= c;  a ^= rot(c,16);  c += b; \
+  b -= a;  b ^= rot(a,19);  a += c; \
+  c -= b;  c ^= rot(b, 4);  b += a; \
+}
 #define final(a,b,c) \
-	{ \
-		c ^= b; c -= rot (b,14); \
-		a ^= c; a -= rot (c,11); \
-		b ^= a; b -= rot (a,25); \
-		c ^= b; c -= rot (b,16); \
-		a ^= c; a -= rot (c,4);  \
-		b ^= a; b -= rot (a,14); \
-		c ^= b; c -= rot (b,24); \
-	}
+{ \
+  c ^= b; c -= rot(b,14); \
+  a ^= c; a -= rot(c,11); \
+  b ^= a; b -= rot(a,25); \
+  c ^= b; c -= rot(b,16); \
+  a ^= c; a -= rot(c,4);  \
+  b ^= a; b -= rot(a,14); \
+  c ^= b; c -= rot(b,24); \
+}
 /*
  *    The hash function used here is by Bob Jenkins, 1996:
  *    <http://burtleburtle.net/bob/hash/doobs.html>
@@ -1002,10 +899,10 @@ rspamd_kv_hash_destroy (struct rspamd_kv_cache *c)
 guint
 kv_elt_hash_func (gconstpointer e)
 {
-	struct rspamd_kv_element *elt = (struct rspamd_kv_element *)e;
-	guint32 a, b, c;
+	struct rspamd_kv_element 			*elt = (struct rspamd_kv_element *)e;
+	guint32 							 a, b, c;
 	union { const void *ptr; size_t i; } u;
-	guint length;
+	guint								 length;
 
 	/* Set up the internal state */
 	length = elt->keylen;
@@ -1037,30 +934,30 @@ kv_elt_hash_func (gconstpointer e)
 		 */
 		switch (length)
 		{
-		case 12: c += k[2]; b += k[1]; a += k[0]; break;
-		case 11: c += k[2] & 0xffffff; b += k[1]; a += k[0]; break;
-		case 10: c += k[2] & 0xffff; b += k[1]; a += k[0]; break;
-		case 9: c += k[2] & 0xff; b += k[1]; a += k[0]; break;
-		case 8: b += k[1]; a += k[0]; break;
-		case 7: b += k[1] & 0xffffff; a += k[0]; break;
-		case 6: b += k[1] & 0xffff; a += k[0]; break;
-		case 5: b += k[1] & 0xff; a += k[0]; break;
-		case 4: a += k[0]; break;
-		case 3: a += k[0] & 0xffffff; break;
-		case 2: a += k[0] & 0xffff; break;
-		case 1: a += k[0] & 0xff; break;
-		case 0: return c;   /* zero length strings require no mixing */
+		case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+		case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+		case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+		case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+		case 8 : b+=k[1]; a+=k[0]; break;
+		case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+		case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+		case 5 : b+=k[1]&0xff; a+=k[0]; break;
+		case 4 : a+=k[0]; break;
+		case 3 : a+=k[0]&0xffffff; break;
+		case 2 : a+=k[0]&0xffff; break;
+		case 1 : a+=k[0]&0xff; break;
+		case 0 : return c;  /* zero length strings require no mixing */
 		}
 
 	} else if (((u.i & 0x1) == 0)) {
 		const guint16 *k = (const guint16 *)elt->p;                           /* read 16-bit chunks */
-		const guint8 *k8;
+		const guint8  *k8;
 
 		/*--------------- all but last block: aligned reads and different mixing */
 		while (length > 12) {
-			a += k[0] + (((guint32)k[1]) << 16);
-			b += k[2] + (((guint32)k[3]) << 16);
-			c += k[4] + (((guint32)k[5]) << 16);
+			a += k[0] + (((guint32)k[1])<<16);
+			b += k[2] + (((guint32)k[3])<<16);
+			c += k[4] + (((guint32)k[5])<<16);
 			mix (a,b,c);
 			length -= 12;
 			k += 6;
@@ -1070,32 +967,32 @@ kv_elt_hash_func (gconstpointer e)
 		k8 = (const guint8 *)k;
 		switch (length)
 		{
-		case 12: c += k[4] + (((guint32)k[5]) << 16);
-			b += k[2] + (((guint32)k[3]) << 16);
-			a += k[0] + (((guint32)k[1]) << 16);
-			break;
-		case 11: c += ((guint32)k8[10]) << 16;     /* @fallthrough */
-		case 10: c += k[4];                       /* @fallthrough@ */
-			b += k[2] + (((guint32)k[3]) << 16);
-			a += k[0] + (((guint32)k[1]) << 16);
-			break;
-		case 9: c += k8[8];                      /* @fallthrough */
-		case 8: b += k[2] + (((guint32)k[3]) << 16);
-			a += k[0] + (((guint32)k[1]) << 16);
-			break;
-		case 7: b += ((guint32)k8[6]) << 16;      /* @fallthrough */
-		case 6: b += k[2];
-			a += k[0] + (((guint32)k[1]) << 16);
-			break;
-		case 5: b += k8[4];                      /* @fallthrough */
-		case 4: a += k[0] + (((guint32)k[1]) << 16);
-			break;
-		case 3: a += ((guint32)k8[2]) << 16;      /* @fallthrough */
-		case 2: a += k[0];
-			break;
-		case 1: a += k8[0];
-			break;
-		case 0: return c;   /* zero length strings require no mixing */
+		case 12: c+=k[4]+(((guint32)k[5])<<16);
+		b+=k[2]+(((guint32)k[3])<<16);
+		a+=k[0]+(((guint32)k[1])<<16);
+		break;
+		case 11: c+=((guint32)k8[10])<<16;     /* @fallthrough */
+		case 10: c+=k[4];                       /* @fallthrough@ */
+		b+=k[2]+(((guint32)k[3])<<16);
+		a+=k[0]+(((guint32)k[1])<<16);
+		break;
+		case 9 : c+=k8[8];                      /* @fallthrough */
+		case 8 : b+=k[2]+(((guint32)k[3])<<16);
+		a+=k[0]+(((guint32)k[1])<<16);
+		break;
+		case 7 : b+=((guint32)k8[6])<<16;      /* @fallthrough */
+		case 6 : b+=k[2];
+		a+=k[0]+(((guint32)k[1])<<16);
+		break;
+		case 5 : b+=k8[4];                      /* @fallthrough */
+		case 4 : a+=k[0]+(((guint32)k[1])<<16);
+		break;
+		case 3 : a+=((guint32)k8[2])<<16;      /* @fallthrough */
+		case 2 : a+=k[0];
+		break;
+		case 1 : a+=k8[0];
+		break;
+		case 0 : return c;  /* zero length strings require no mixing */
 		}
 
 	} else {                        /* need to read the key one byte at a time */
@@ -1105,18 +1002,18 @@ kv_elt_hash_func (gconstpointer e)
 		while (length > 12)
 		{
 			a += k[0];
-			a += ((guint32)k[1]) << 8;
-			a += ((guint32)k[2]) << 16;
-			a += ((guint32)k[3]) << 24;
+			a += ((guint32)k[1])<<8;
+			a += ((guint32)k[2])<<16;
+			a += ((guint32)k[3])<<24;
 			b += k[4];
-			b += ((guint32)k[5]) << 8;
-			b += ((guint32)k[6]) << 16;
-			b += ((guint32)k[7]) << 24;
+			b += ((guint32)k[5])<<8;
+			b += ((guint32)k[6])<<16;
+			b += ((guint32)k[7])<<24;
 			c += k[8];
-			c += ((guint32)k[9]) << 8;
-			c += ((guint32)k[10]) << 16;
-			c += ((guint32)k[11]) << 24;
-			mix (a,b,c);
+			c += ((guint32)k[9])<<8;
+			c += ((guint32)k[10])<<16;
+			c += ((guint32)k[11])<<24;
+			mix(a,b,c);
 			length -= 12;
 			k += 12;
 		}
@@ -1124,20 +1021,20 @@ kv_elt_hash_func (gconstpointer e)
 		/*-------------------------------- last block: affect all 32 bits of (c) */
 		switch (length)                   /* all the case statements fall through */
 		{
-		case 12: c += ((guint32)k[11]) << 24;
-		case 11: c += ((guint32)k[10]) << 16;
-		case 10: c += ((guint32)k[9]) << 8;
-		case 9: c += k[8];
-		case 8: b += ((guint32)k[7]) << 24;
-		case 7: b += ((guint32)k[6]) << 16;
-		case 6: b += ((guint32)k[5]) << 8;
-		case 5: b += k[4];
-		case 4: a += ((guint32)k[3]) << 24;
-		case 3: a += ((guint32)k[2]) << 16;
-		case 2: a += ((guint32)k[1]) << 8;
-		case 1: a += k[0];
-			break;
-		case 0: return c;   /* zero length strings require no mixing */
+		case 12: c+=((guint32)k[11])<<24;
+		case 11: c+=((guint32)k[10])<<16;
+		case 10: c+=((guint32)k[9])<<8;
+		case 9 : c+=k[8];
+		case 8 : b+=((guint32)k[7])<<24;
+		case 7 : b+=((guint32)k[6])<<16;
+		case 6 : b+=((guint32)k[5])<<8;
+		case 5 : b+=k[4];
+		case 4 : a+=((guint32)k[3])<<24;
+		case 3 : a+=((guint32)k[2])<<16;
+		case 2 : a+=((guint32)k[1])<<8;
+		case 1 : a+=k[0];
+		break;
+		case 0 : return c;  /* zero length strings require no mixing */
 		}
 	}
 
@@ -1148,8 +1045,8 @@ kv_elt_hash_func (gconstpointer e)
 gboolean
 kv_elt_compare_func (gconstpointer e1, gconstpointer e2)
 {
-	struct rspamd_kv_element *elt1 = (struct rspamd_kv_element *) e1,
-	*elt2 = (struct rspamd_kv_element *) e2;
+	struct rspamd_kv_element 			*elt1 = (struct rspamd_kv_element *) e1,
+										*elt2 = (struct rspamd_kv_element *) e2;
 
 	if (elt1->keylen == elt2->keylen) {
 		return memcmp (elt1->p, elt2->p, elt1->keylen) == 0;
@@ -1161,16 +1058,13 @@ kv_elt_compare_func (gconstpointer e1, gconstpointer e2)
 /**
  * Create new hash kv cache
  */
-struct rspamd_kv_cache *
+struct rspamd_kv_cache*
 rspamd_kv_hash_new (void)
 {
-	struct rspamd_kv_hash_cache *new;
+	struct rspamd_kv_hash_cache			*new;
 
 	new = g_slice_alloc (sizeof (struct rspamd_kv_hash_cache));
-	new->hash = g_hash_table_new_full (kv_elt_hash_func,
-			kv_elt_compare_func,
-			NULL,
-			NULL);
+	new->hash = g_hash_table_new_full (kv_elt_hash_func, kv_elt_compare_func, NULL, NULL);
 	new->init_func = NULL;
 	new->insert_func = rspamd_kv_hash_insert;
 	new->lookup_func = rspamd_kv_hash_lookup;
@@ -1186,13 +1080,13 @@ rspamd_kv_hash_new (void)
  * Radix cache hash table
  */
 struct rspamd_kv_radix_cache {
-	cache_init init_func;                       /*< this callback is called on kv storage initialization */
-	cache_insert insert_func;                   /*< this callback is called when element is inserted */
-	cache_replace replace_func;                 /*< this callback is called when element is replace */
-	cache_lookup lookup_func;                   /*< this callback is used for lookup of element */
-	cache_delete delete_func;                   /*< this callback is called when an element is deleted */
-	cache_steal steal_func;                     /*< this callback is used to replace duplicates in cache */
-	cache_destroy destroy_func;                 /*< this callback is used for destroying all elements inside cache */
+	cache_init init_func;						/*< this callback is called on kv storage initialization */
+	cache_insert insert_func;					/*< this callback is called when element is inserted */
+	cache_replace replace_func;					/*< this callback is called when element is replace */
+	cache_lookup lookup_func;					/*< this callback is used for lookup of element */
+	cache_delete delete_func;					/*< this callback is called when an element is deleted */
+	cache_steal steal_func;						/*< this callback is used to replace duplicates in cache */
+	cache_destroy destroy_func;					/*< this callback is used for destroying all elements inside cache */
 	radix_tree_t *tree;
 };
 
@@ -1202,7 +1096,7 @@ struct rspamd_kv_radix_cache {
 static guint32
 rspamd_kv_radix_validate (gpointer key, guint keylen)
 {
-	struct in_addr addr;
+	struct in_addr				addr;
 
 	if (inet_aton (key, &addr) == 0) {
 		return 0;
@@ -1214,16 +1108,12 @@ rspamd_kv_radix_validate (gpointer key, guint keylen)
 /**
  * Insert an element inside cache
  */
-static struct rspamd_kv_element *
-rspamd_kv_radix_insert (struct rspamd_kv_cache *c,
-	gpointer key,
-	guint keylen,
-	gpointer value,
-	gsize len)
+static struct rspamd_kv_element*
+rspamd_kv_radix_insert (struct rspamd_kv_cache *c, gpointer key, guint keylen, gpointer value, gsize len)
 {
-	struct rspamd_kv_element *elt;
-	struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
-	guint32 rkey = rspamd_kv_radix_validate (key, keylen);
+	struct rspamd_kv_element 			*elt;
+	struct rspamd_kv_radix_cache		*cache = (struct rspamd_kv_radix_cache *)c;
+	guint32								 rkey = rspamd_kv_radix_validate (key, keylen);
 
 	if (rkey == 0) {
 		return NULL;
@@ -1231,13 +1121,12 @@ rspamd_kv_radix_insert (struct rspamd_kv_cache *c,
 
 	elt = (struct rspamd_kv_element *)radix32tree_find (cache->tree, rkey);
 	if ((uintptr_t)elt == RADIX_NO_VALUE) {
-		elt = g_slice_alloc (
-			sizeof (struct rspamd_kv_element) + len + keylen + 1);
+		elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
 		elt->age = time (NULL);
 		elt->keylen = keylen;
 		elt->size = len;
 		elt->flags = 0;
-		memcpy (ELT_KEY (elt),	key,   keylen + 1);
+		memcpy (ELT_KEY (elt), key, keylen + 1);
 		memcpy (ELT_DATA (elt), value, len);
 		elt->p = &elt->data;
 		radix32tree_insert (cache->tree, rkey, 0xffffffff, (uintptr_t)elt);
@@ -1251,13 +1140,12 @@ rspamd_kv_radix_insert (struct rspamd_kv_cache *c,
 			/* Free it by self */
 			g_slice_free1 (ELT_SIZE (elt), elt);
 		}
-		elt = g_slice_alloc (
-			sizeof (struct rspamd_kv_element) + len + keylen + 1);
+		elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
 		elt->age = time (NULL);
 		elt->keylen = keylen;
 		elt->size = len;
 		elt->flags = 0;
-		memcpy (ELT_KEY (elt),	key,   keylen + 1);
+		memcpy (ELT_KEY (elt), key, keylen + 1);
 		memcpy (ELT_DATA (elt), value, len);
 		elt->p = &elt->data;
 		radix32tree_insert (cache->tree, rkey, 0xffffffff, (uintptr_t)elt);
@@ -1269,12 +1157,12 @@ rspamd_kv_radix_insert (struct rspamd_kv_cache *c,
 /**
  * Lookup an item inside radix
  */
-static struct rspamd_kv_element *
+static struct rspamd_kv_element*
 rspamd_kv_radix_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 {
-	struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
-	guint32 rkey = rspamd_kv_radix_validate (key, keylen);
-	struct rspamd_kv_element *elt;
+	struct rspamd_kv_radix_cache		*cache = (struct rspamd_kv_radix_cache *)c;
+	guint32								 rkey = rspamd_kv_radix_validate (key, keylen);
+	struct rspamd_kv_element 			*elt;
 
 	elt = (struct rspamd_kv_element *)radix32tree_find (cache->tree, rkey);
 	if ((uintptr_t)elt == RADIX_NO_VALUE) {
@@ -1288,14 +1176,11 @@ rspamd_kv_radix_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
  * Replace an element inside cache
  */
 static gboolean
-rspamd_kv_radix_replace (struct rspamd_kv_cache *c,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_kv_radix_replace (struct rspamd_kv_cache *c, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
-	guint32 rkey = rspamd_kv_radix_validate (key, keylen);
-	struct rspamd_kv_element *oldelt;
+	struct rspamd_kv_radix_cache		*cache = (struct rspamd_kv_radix_cache *)c;
+	guint32								 rkey = rspamd_kv_radix_validate (key, keylen);
+	struct rspamd_kv_element 			*oldelt;
 
 	oldelt = (struct rspamd_kv_element *)radix32tree_find (cache->tree, rkey);
 	if ((uintptr_t)oldelt != RADIX_NO_VALUE) {
@@ -1321,9 +1206,9 @@ rspamd_kv_radix_replace (struct rspamd_kv_cache *c,
 static struct rspamd_kv_element *
 rspamd_kv_radix_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 {
-	struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
-	struct rspamd_kv_element *elt;
-	guint32 rkey = rspamd_kv_radix_validate (key, keylen);
+	struct rspamd_kv_radix_cache		*cache = (struct rspamd_kv_radix_cache *)c;
+	struct rspamd_kv_element            *elt;
+	guint32								 rkey = rspamd_kv_radix_validate (key, keylen);
 
 	elt = (struct rspamd_kv_element *)radix32tree_find (cache->tree, rkey);
 	if ((uintptr_t)elt != RADIX_NO_VALUE) {
@@ -1341,8 +1226,8 @@ rspamd_kv_radix_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 static void
 rspamd_kv_radix_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
 {
-	struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
-	guint32 rkey = rspamd_kv_radix_validate (ELT_KEY (elt), elt->keylen);
+	struct rspamd_kv_radix_cache		*cache = (struct rspamd_kv_radix_cache *)c;
+	guint32								 rkey = rspamd_kv_radix_validate (ELT_KEY (elt), elt->keylen);
 
 
 	radix32tree_delete (cache->tree, rkey, 0xffffffff);
@@ -1354,7 +1239,7 @@ rspamd_kv_radix_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
 static void
 rspamd_kv_radix_destroy (struct rspamd_kv_cache *c)
 {
-	struct rspamd_kv_radix_cache *cache = (struct rspamd_kv_radix_cache *)c;
+	struct rspamd_kv_radix_cache			*cache = (struct rspamd_kv_radix_cache *)c;
 
 	radix_tree_free (cache->tree);
 	g_slice_free1 (sizeof (struct rspamd_kv_radix_cache), cache);
@@ -1363,10 +1248,10 @@ rspamd_kv_radix_destroy (struct rspamd_kv_cache *c)
 /**
  * Create new radix kv cache
  */
-struct rspamd_kv_cache *
+struct rspamd_kv_cache*
 rspamd_kv_radix_new (void)
 {
-	struct rspamd_kv_radix_cache *new;
+	struct rspamd_kv_radix_cache			*new;
 
 	new = g_slice_alloc (sizeof (struct rspamd_kv_radix_cache));
 	new->tree = radix_tree_create ();
@@ -1387,13 +1272,13 @@ rspamd_kv_radix_new (void)
  * KV cache hash table
  */
 struct rspamd_kv_judy_cache {
-	cache_init init_func;                       /*< this callback is called on kv storage initialization */
-	cache_insert insert_func;                   /*< this callback is called when element is inserted */
-	cache_replace replace_func;                 /*< this callback is called when element is replace */
-	cache_lookup lookup_func;                   /*< this callback is used for lookup of element */
-	cache_delete delete_func;                   /*< this callback is called when an element is deleted */
-	cache_steal steal_func;                     /*< this callback is used to replace duplicates in cache */
-	cache_destroy destroy_func;                 /*< this callback is used for destroying all elements inside cache */
+	cache_init init_func;						/*< this callback is called on kv storage initialization */
+	cache_insert insert_func;					/*< this callback is called when element is inserted */
+	cache_replace replace_func;					/*< this callback is called when element is replace */
+	cache_lookup lookup_func;					/*< this callback is used for lookup of element */
+	cache_delete delete_func;					/*< this callback is called when an element is deleted */
+	cache_steal steal_func;						/*< this callback is used to replace duplicates in cache */
+	cache_destroy destroy_func;					/*< this callback is used for destroying all elements inside cache */
 	Pvoid_t judy;
 };
 
@@ -1401,11 +1286,11 @@ struct rspamd_kv_judy_cache {
 /**
  * Lookup an item inside judy
  */
-static struct rspamd_kv_element *
+static struct rspamd_kv_element*
 rspamd_kv_judy_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 {
-	struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
-	struct rspamd_kv_element *elt = NULL, **pelt;
+	struct rspamd_kv_judy_cache			*cache = (struct rspamd_kv_judy_cache *)c;
+	struct rspamd_kv_element			*elt = NULL, **pelt;
 
 	JHSG (pelt, cache->judy, key, keylen);
 	if (pelt != NULL) {
@@ -1420,9 +1305,9 @@ rspamd_kv_judy_lookup (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 static struct rspamd_kv_element *
 rspamd_kv_judy_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 {
-	struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
-	struct rspamd_kv_element *elt;
-	gint rc;
+	struct rspamd_kv_judy_cache			*cache = (struct rspamd_kv_judy_cache *)c;
+	struct rspamd_kv_element            *elt;
+	gint								 rc;
 
 	elt = rspamd_kv_judy_lookup (c, key, keylen);
 	if (elt) {
@@ -1437,8 +1322,8 @@ rspamd_kv_judy_delete (struct rspamd_kv_cache *c, gpointer key, guint keylen)
 static void
 rspamd_kv_judy_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
 {
-	struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
-	gint rc;
+	struct rspamd_kv_judy_cache			*cache = (struct rspamd_kv_judy_cache *)c;
+	gint								 rc;
 
 	JHSD (rc, cache->judy, ELT_KEY (elt), elt->keylen);
 }
@@ -1446,24 +1331,19 @@ rspamd_kv_judy_steal (struct rspamd_kv_cache *c, struct rspamd_kv_element *elt)
 /**
  * Insert an element inside cache
  */
-static struct rspamd_kv_element *
-rspamd_kv_judy_insert (struct rspamd_kv_cache *c,
-	gpointer key,
-	guint keylen,
-	gpointer value,
-	gsize len)
+static struct rspamd_kv_element*
+rspamd_kv_judy_insert (struct rspamd_kv_cache *c, gpointer key, guint keylen, gpointer value, gsize len)
 {
-	struct rspamd_kv_element *elt, **pelt;
-	struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
+	struct rspamd_kv_element 			*elt, **pelt;
+	struct rspamd_kv_judy_cache			*cache = (struct rspamd_kv_judy_cache *)c;
 
 	if ((elt = rspamd_kv_judy_lookup (c, key, keylen)) == NULL) {
-		elt = g_slice_alloc (
-			sizeof (struct rspamd_kv_element) + len + keylen + 1);
+		elt = g_slice_alloc (sizeof (struct rspamd_kv_element) + len + keylen + 1);
 		elt->age = time (NULL);
 		elt->keylen = keylen;
 		elt->size = len;
 		elt->flags = 0;
-		memcpy (ELT_KEY (elt),	key,   keylen);
+		memcpy (ELT_KEY (elt), key, keylen);
 		memcpy (ELT_DATA (elt), value, len);
 		JHSI (pelt, cache->judy, ELT_KEY (elt), elt->keylen);
 		elt->p = &elt->data;
@@ -1478,13 +1358,12 @@ rspamd_kv_judy_insert (struct rspamd_kv_cache *c,
 			/* Free it by self */
 			g_slice_free1 (ELT_SIZE (elt), elt);
 		}
-		elt = g_slice_alloc0 (
-			sizeof (struct rspamd_kv_element) + len + keylen + 1);
+		elt = g_slice_alloc0 (sizeof (struct rspamd_kv_element) + len + keylen + 1);
 		elt->age = time (NULL);
 		elt->keylen = keylen;
 		elt->size = len;
 		elt->flags = 0;
-		memcpy (ELT_KEY (elt),	key,   keylen);
+		memcpy (ELT_KEY (elt), key, keylen);
 		memcpy (ELT_DATA (elt), value, len);
 		elt->p = &elt->data;
 		JHSI (pelt, cache->judy, ELT_KEY (elt), elt->keylen);
@@ -1498,13 +1377,10 @@ rspamd_kv_judy_insert (struct rspamd_kv_cache *c,
  * Replace an element inside cache
  */
 static gboolean
-rspamd_kv_judy_replace (struct rspamd_kv_cache *c,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_kv_judy_replace (struct rspamd_kv_cache *c, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
-	struct rspamd_kv_element *oldelt, **pelt;
+	struct rspamd_kv_judy_cache			*cache = (struct rspamd_kv_judy_cache *)c;
+	struct rspamd_kv_element 			*oldelt, **pelt;
 
 	if ((oldelt = rspamd_kv_judy_lookup (c, key, keylen)) != NULL) {
 		rspamd_kv_judy_steal (c, elt);
@@ -1530,8 +1406,8 @@ rspamd_kv_judy_replace (struct rspamd_kv_cache *c,
 static void
 rspamd_kv_judy_destroy (struct rspamd_kv_cache *c)
 {
-	struct rspamd_kv_judy_cache *cache = (struct rspamd_kv_judy_cache *)c;
-	glong bytes;
+	struct rspamd_kv_judy_cache			*cache = (struct rspamd_kv_judy_cache *)c;
+	glong								 bytes;
 
 	JHSFA (bytes, cache->judy);
 	g_slice_free1 (sizeof (struct rspamd_kv_judy_cache), cache);
@@ -1540,10 +1416,10 @@ rspamd_kv_judy_destroy (struct rspamd_kv_cache *c)
 /**
  * Judy tree
  */
-struct rspamd_kv_cache *
+struct rspamd_kv_cache*
 rspamd_kv_judy_new (void)
 {
-	struct rspamd_kv_judy_cache *new;
+	struct rspamd_kv_judy_cache			*new;
 
 	new = g_slice_alloc (sizeof (struct rspamd_kv_judy_cache));
 	new->judy = NULL;
diff --git a/src/kvstorage.h b/src/kvstorage.h
index 91db10df3..05ff866e6 100644
--- a/src/kvstorage.h
+++ b/src/kvstorage.h
@@ -47,46 +47,34 @@ struct rspamd_kv_element;
 
 /* Callbacks for cache */
 typedef void (*cache_init)(struct rspamd_kv_cache *cache);
-typedef struct rspamd_kv_element * (*cache_insert)(struct rspamd_kv_cache *cache,
-	gpointer key, guint keylen, gpointer value, gsize len);
-typedef gboolean (*cache_replace)(struct rspamd_kv_cache *cache, gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt);
-typedef struct rspamd_kv_element * (*cache_lookup)(struct rspamd_kv_cache *cache,
-	gpointer key, guint keylen);
-typedef struct rspamd_kv_element * (*cache_delete)(struct rspamd_kv_cache *cache,
-	gpointer key, guint keylen);
-typedef void (*cache_steal)(struct rspamd_kv_cache *cache,
-	struct rspamd_kv_element * elt);
+typedef struct rspamd_kv_element* (*cache_insert)(struct rspamd_kv_cache *cache,
+		gpointer key, guint keylen, gpointer value, gsize len);
+typedef gboolean (*cache_replace)(struct rspamd_kv_cache *cache, gpointer key, guint keylen,
+		struct rspamd_kv_element *elt);
+typedef struct rspamd_kv_element* (*cache_lookup)(struct rspamd_kv_cache *cache, gpointer key, guint keylen);
+typedef struct rspamd_kv_element* (*cache_delete)(struct rspamd_kv_cache *cache, gpointer key, guint keylen);
+typedef void (*cache_steal)(struct rspamd_kv_cache *cache, struct rspamd_kv_element* elt);
 typedef void (*cache_destroy)(struct rspamd_kv_cache *cache);
 
 /* Callbacks for backend */
 typedef void (*backend_init)(struct rspamd_kv_backend *backend);
-typedef gboolean (*backend_insert)(struct rspamd_kv_backend *backend,
-	gpointer key, guint keylen,
-	struct rspamd_kv_element *elt);
-typedef gboolean (*backend_replace)(struct rspamd_kv_backend *backend,
-	gpointer key, guint keylen,
-	struct rspamd_kv_element *elt);
-typedef struct rspamd_kv_element * (*backend_lookup)(struct rspamd_kv_backend *
-	backend, gpointer key,
-	guint keylen);
-typedef void (*backend_delete)(struct rspamd_kv_backend *backend, gpointer key,
-	guint keylen);
+typedef gboolean (*backend_insert)(struct rspamd_kv_backend *backend, gpointer key, guint keylen,
+		struct rspamd_kv_element *elt);
+typedef gboolean (*backend_replace)(struct rspamd_kv_backend *backend, gpointer key, guint keylen,
+		struct rspamd_kv_element *elt);
+typedef struct rspamd_kv_element* (*backend_lookup)(struct rspamd_kv_backend *backend, gpointer key,
+		guint keylen);
+typedef void (*backend_delete)(struct rspamd_kv_backend *backend, gpointer key, guint keylen);
 typedef gboolean (*backend_sync)(struct rspamd_kv_backend *backend);
-typedef gboolean (*backend_incref)(struct rspamd_kv_backend *backend,
-	gpointer key, guint keylen);
+typedef gboolean (*backend_incref)(struct rspamd_kv_backend *backend, gpointer key, guint keylen);
 typedef void (*backend_destroy)(struct rspamd_kv_backend *backend);
 
 /* Callbacks for expire */
 typedef void (*expire_init)(struct rspamd_kv_expire *expire);
-typedef void (*expire_insert)(struct rspamd_kv_expire *expire,
-	struct rspamd_kv_element *elt);
-typedef void (*expire_delete)(struct rspamd_kv_expire *expire,
-	struct rspamd_kv_element *elt);
-typedef gboolean (*expire_step)(struct rspamd_kv_expire *expire,
-	struct rspamd_kv_storage *storage,
-	time_t now, gboolean forced);
+typedef void (*expire_insert)(struct rspamd_kv_expire *expire, struct rspamd_kv_element *elt);
+typedef void (*expire_delete)(struct rspamd_kv_expire *expire, struct rspamd_kv_element *elt);
+typedef gboolean (*expire_step)(struct rspamd_kv_expire *expire, struct rspamd_kv_storage *storage,
+		time_t now, gboolean forced);
 typedef void (*expire_destroy)(struct rspamd_kv_expire *expire);
 
 
@@ -105,48 +93,47 @@ enum rspamd_kv_flags {
 #define ELT_DATA(elt) (gchar *)(elt)->data + (elt)->keylen + 1
 #define ELT_LONG(elt) *((glong *)((elt)->data + (elt)->keylen + 1))
 #define ELT_KEY(elt) (gchar *)(elt)->data
-#define ELT_SIZE(elt) elt->size + sizeof(struct rspamd_kv_element) + \
-	elt->keylen + 1
+#define ELT_SIZE(elt) elt->size + sizeof(struct rspamd_kv_element) + elt->keylen + 1
 
 /* Common structures description */
 
 struct rspamd_kv_element {
-	time_t age;                                 /*< age of element */
-	guint32 expire;                             /*< expire of element */
-	gint flags;                                 /*< element flags  */
-	gsize size;                                 /*< size of element */
-	TAILQ_ENTRY (rspamd_kv_element) entry;      /*< list entry */
-	guint keylen;                               /*< length of key */
-
-	gpointer p;                                 /*< pointer to data */
-	gchar data[1];                              /*< expandable data */
+	time_t age;									/*< age of element */
+	guint32 expire;								/*< expire of element */
+	gint flags;									/*< element flags  */
+	gsize size;									/*< size of element */
+	TAILQ_ENTRY (rspamd_kv_element) entry;		/*< list entry */
+	guint keylen;								/*< length of key */
+
+	gpointer p;									/*< pointer to data */
+	gchar data[1];								/*< expandable data */
 };
 
 struct rspamd_kv_cache {
-	cache_init init_func;                       /*< this callback is called on kv storage initialization */
-	cache_insert insert_func;                   /*< this callback is called when element is inserted */
-	cache_replace replace_func;                 /*< this callback is called when element is replace */
-	cache_lookup lookup_func;                   /*< this callback is used for lookup of element */
-	cache_delete delete_func;                   /*< this callback is called when an element is deleted */
-	cache_steal steal_func;                     /*< this callback is used to replace duplicates in cache */
-	cache_destroy destroy_func;                 /*< this callback is used for destroying all elements inside cache */
+	cache_init init_func;						/*< this callback is called on kv storage initialization */
+	cache_insert insert_func;					/*< this callback is called when element is inserted */
+	cache_replace replace_func;					/*< this callback is called when element is replace */
+	cache_lookup lookup_func;					/*< this callback is used for lookup of element */
+	cache_delete delete_func;					/*< this callback is called when an element is deleted */
+	cache_steal steal_func;						/*< this callback is used to replace duplicates in cache */
+	cache_destroy destroy_func;					/*< this callback is used for destroying all elements inside cache */
 };
 struct rspamd_kv_backend {
-	backend_init init_func;                     /*< this callback is called on kv storage initialization */
-	backend_insert insert_func;                 /*< this callback is called when element is inserted */
-	backend_replace replace_func;               /*< this callback is called when element is replaced */
-	backend_lookup lookup_func;                 /*< this callback is used for lookup of element */
-	backend_delete delete_func;                 /*< this callback is called when an element is deleted */
-	backend_sync sync_func;                     /*< this callback is called when backend need to be synced */
-	backend_incref incref_func;                 /*< this callback is called when element must be ref'd */
-	backend_destroy destroy_func;               /*< this callback is used for destroying all elements inside backend */
+	backend_init init_func;						/*< this callback is called on kv storage initialization */
+	backend_insert insert_func;					/*< this callback is called when element is inserted */
+	backend_replace replace_func;				/*< this callback is called when element is replaced */
+	backend_lookup lookup_func;					/*< this callback is used for lookup of element */
+	backend_delete delete_func;					/*< this callback is called when an element is deleted */
+	backend_sync sync_func;						/*< this callback is called when backend need to be synced */
+	backend_incref incref_func;					/*< this callback is called when element must be ref'd */
+	backend_destroy destroy_func;				/*< this callback is used for destroying all elements inside backend */
 };
 struct rspamd_kv_expire {
-	expire_init init_func;                      /*< this callback is called on kv storage initialization */
-	expire_insert insert_func;                  /*< this callback is called when element is inserted */
-	expire_step step_func;                      /*< this callback is used when cache is full */
-	expire_delete delete_func;                  /*< this callback is called when an element is deleted */
-	expire_destroy destroy_func;                /*< this callback is used for destroying all elements inside expire */
+	expire_init init_func;						/*< this callback is called on kv storage initialization */
+	expire_insert insert_func;					/*< this callback is called when element is inserted */
+	expire_step step_func;						/*< this callback is used when cache is full */
+	expire_delete delete_func;					/*< this callback is called when an element is deleted */
+	expire_destroy destroy_func;				/*< this callback is used for destroying all elements inside expire */
 };
 
 /* Main kv storage structure */
@@ -156,103 +143,61 @@ struct rspamd_kv_storage {
 	struct rspamd_kv_backend *backend;
 	struct rspamd_kv_expire *expire;
 
-	gsize elts;                                 /*< current elements count in a storage */
-	gsize max_elts;                             /*< maximum number of elements in a storage */
+	gsize elts;									/*< current elements count in a storage */
+	gsize max_elts;								/*< maximum number of elements in a storage */
 
-	gsize memory;                               /*< memory eaten */
-	gsize max_memory;                           /*< memory limit */
+	gsize memory;								/*< memory eaten */
+	gsize max_memory;							/*< memory limit */
 
-	gint id;                                    /* char ID */
-	gchar *name;                                /* numeric ID */
+	gint id;									/* char ID */
+	gchar *name;								/* numeric ID */
 
-	gboolean no_overwrite;                      /* do not overwrite data with the same keys */
+	gboolean no_overwrite;						/* do not overwrite data with the same keys */
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION > 30))
-	GRWLock rwlock;                             /* rwlock in new glib */
+	GRWLock rwlock;								/* rwlock in new glib */
 #else
-	GStaticRWLock rwlock;                       /* rwlock for threaded access */
+	GStaticRWLock rwlock;						/* rwlock for threaded access */
 #endif
 };
 
 /** Create new kv storage */
-struct rspamd_kv_storage * rspamd_kv_storage_new (gint id, const gchar *name,
-	struct rspamd_kv_cache *cache, struct rspamd_kv_backend *backend,
-	struct rspamd_kv_expire *expire,
-	gsize max_elts, gsize max_memory, gboolean no_overwrite);
+struct rspamd_kv_storage *rspamd_kv_storage_new (gint id, const gchar *name,
+		struct rspamd_kv_cache *cache, struct rspamd_kv_backend *backend,
+		struct rspamd_kv_expire *expire,
+		gsize max_elts, gsize max_memory, gboolean no_overwrite);
 
 /** Insert new element to the kv storage */
-gboolean rspamd_kv_storage_insert (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	gpointer data,
-	gsize len,
-	gint flags,
-	guint expire);
+gboolean rspamd_kv_storage_insert (struct rspamd_kv_storage *storage, gpointer key, guint keylen, gpointer data, gsize len, gint flags, guint expire);
 
 /** Insert element only in cache */
-gboolean rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	gpointer data,
-	gsize len,
-	gint flags,
-	guint expire,
-	struct rspamd_kv_element **pelt);
+gboolean rspamd_kv_storage_insert_cache (struct rspamd_kv_storage *storage, gpointer key, guint keylen,
+		gpointer data, gsize len, gint flags, guint expire, struct rspamd_kv_element **pelt);
 
 /** Replace an element in the kv storage */
-gboolean rspamd_kv_storage_replace (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt);
+gboolean rspamd_kv_storage_replace (struct rspamd_kv_storage *storage, gpointer key, guint keylen, struct rspamd_kv_element *elt);
 
 /** Increment value in kvstorage */
-gboolean rspamd_kv_storage_increment (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	glong *value);
+gboolean rspamd_kv_storage_increment (struct rspamd_kv_storage *storage, gpointer key, guint keylen, glong *value);
 
 /** Lookup an element inside kv storage */
-struct rspamd_kv_element * rspamd_kv_storage_lookup (
-	struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	time_t now);
+struct rspamd_kv_element* rspamd_kv_storage_lookup (struct rspamd_kv_storage *storage, gpointer key, guint keylen, time_t now);
 
 /** Expire an element from kv storage */
-struct rspamd_kv_element * rspamd_kv_storage_delete (
-	struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen);
+struct rspamd_kv_element* rspamd_kv_storage_delete (struct rspamd_kv_storage *storage, gpointer key, guint keylen);
 
 /** Destroy kv storage */
 void rspamd_kv_storage_destroy (struct rspamd_kv_storage *storage);
 
 /** Insert array */
-gboolean rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	guint elt_size,
-	gpointer data,
-	gsize len,
-	gint flags,
-	guint expire);
+gboolean rspamd_kv_storage_insert_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen, guint elt_size, gpointer data, gsize len, gint flags, guint expire);
 
 /** Set element inside array */
-gboolean rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	guint elt_num,
-	gpointer data,
-	gsize len,
-	time_t now);
+gboolean rspamd_kv_storage_set_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen, guint elt_num,
+		gpointer data, gsize len, time_t now);
 
 /** Get element inside array */
-gboolean rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage,
-	gpointer key,
-	guint keylen,
-	guint elt_num,
-	gpointer *data,
-	gsize *len,
-	time_t now);
+gboolean rspamd_kv_storage_get_array (struct rspamd_kv_storage *storage, gpointer key, guint keylen, guint elt_num,
+		gpointer *data, gsize *len, time_t now);
 
 /* Hash table functions */
 guint kv_elt_hash_func (gconstpointer e);
@@ -261,23 +206,23 @@ gboolean kv_elt_compare_func (gconstpointer e1, gconstpointer e2);
 /**
  * LRU expire
  */
-struct rspamd_kv_expire * rspamd_lru_expire_new (void);
+struct rspamd_kv_expire* rspamd_lru_expire_new (void);
 
 /**
  * Ordinary hash
  */
-struct rspamd_kv_cache * rspamd_kv_hash_new (void);
+struct rspamd_kv_cache* rspamd_kv_hash_new (void);
 
 /**
  * Radix tree
  */
-struct rspamd_kv_cache * rspamd_kv_radix_new (void);
+struct rspamd_kv_cache* rspamd_kv_radix_new (void);
 
 #ifdef WITH_JUDY
 /**
  * Judy tree
  */
-struct rspamd_kv_cache * rspamd_kv_judy_new (void);
+struct rspamd_kv_cache* rspamd_kv_judy_new (void);
 #endif
 
 #endif /* KVSTORAGE_H_ */
diff --git a/src/kvstorage_bdb.c b/src/kvstorage_bdb.c
index 67143c3b4..7970291f6 100644
--- a/src/kvstorage_bdb.c
+++ b/src/kvstorage_bdb.c
@@ -25,8 +25,8 @@
 #include "config.h"
 #include "kvstorage.h"
 #include "kvstorage_bdb.h"
-#include "main.h"
 #include "util.h"
+#include "main.h"
 #include <db.h>
 
 struct bdb_op {
@@ -40,15 +40,15 @@ struct bdb_op {
 
 /* Main bdb structure */
 struct rspamd_bdb_backend {
-	backend_init init_func;                     /*< this callback is called on kv storage initialization */
-	backend_insert insert_func;                 /*< this callback is called when element is inserted */
-	backend_replace replace_func;               /*< this callback is called when element is replaced */
-	backend_lookup lookup_func;                 /*< this callback is used for lookup of element */
-	backend_delete delete_func;                 /*< this callback is called when an element is deleted */
-	backend_sync sync_func;                     /*< this callback is called when backend need to be synced */
-	backend_destroy destroy_func;               /*< this callback is used for destroying all elements inside backend */
-	DB_ENV *envp;                               /*< db environment */
-	DB *dbp;                                    /*< db pointer */
+	backend_init init_func;						/*< this callback is called on kv storage initialization */
+	backend_insert insert_func;					/*< this callback is called when element is inserted */
+	backend_replace replace_func;				/*< this callback is called when element is replaced */
+	backend_lookup lookup_func;					/*< this callback is used for lookup of element */
+	backend_delete delete_func;					/*< this callback is called when an element is deleted */
+	backend_sync sync_func;						/*< this callback is called when backend need to be synced */
+	backend_destroy destroy_func;				/*< this callback is used for destroying all elements inside backend */
+	DB_ENV *envp;								/*< db environment */
+	DB *dbp;									/*< db pointer */
 	gchar *filename;
 	gchar *dirname;
 	guint sync_ops;
@@ -59,19 +59,16 @@ struct rspamd_bdb_backend {
 
 /* Process single bdb operation */
 static gboolean
-bdb_process_single_op (struct rspamd_bdb_backend *db,
-	DB_TXN *txn,
-	struct bdb_op *op)
+bdb_process_single_op (struct rspamd_bdb_backend *db, DB_TXN *txn, struct bdb_op *op)
 {
-	DBT db_key, db_data;
+	DBT 										 db_key, db_data;
 
-	memset (&db_key,  0, sizeof(DBT));
+	memset (&db_key, 0, sizeof(DBT));
 	memset (&db_data, 0, sizeof(DBT));
 
 	db_key.size = op->elt->keylen;
 	db_key.data = ELT_KEY (op->elt);
-	db_data.size = op->elt->size + sizeof (struct rspamd_kv_element) +
-		op->elt->keylen + 1;
+	db_data.size = op->elt->size + sizeof (struct rspamd_kv_element) + op->elt->keylen + 1;
 	db_data.data = op->elt;
 
 	switch (op->op) {
@@ -99,14 +96,14 @@ bdb_process_single_op (struct rspamd_bdb_backend *db,
 static gboolean
 bdb_process_queue (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
-	struct bdb_op *op;
-	GList *cur;
+	struct rspamd_bdb_backend					*db = (struct rspamd_bdb_backend *)backend;
+	struct bdb_op								*op;
+	GList										*cur;
 
 	cur = db->ops_queue->head;
 	while (cur) {
 		op = cur->data;
-		if (!bdb_process_single_op (db, NULL, op)) {
+		if (! bdb_process_single_op (db, NULL, op)) {
 			return FALSE;
 		}
 		cur = g_list_next (cur);
@@ -116,8 +113,7 @@ bdb_process_queue (struct rspamd_kv_backend *backend)
 	cur = db->ops_queue->head;
 	while (cur) {
 		op = cur->data;
-		if (op->op == BDB_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
-			0) {
+		if (op->op == BDB_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
 			/* Also clean memory */
 			g_slice_free1 (ELT_SIZE (op->elt), op->elt);
 		}
@@ -136,9 +132,9 @@ bdb_process_queue (struct rspamd_kv_backend *backend)
 static void
 rspamd_bdb_init (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
-	guint32 flags;
-	gint ret;
+	struct rspamd_bdb_backend					*db = (struct rspamd_bdb_backend *)backend;
+	guint32										 flags;
+	gint										 ret;
 
 	if ((ret = db_env_create (&db->envp, 0)) != 0) {
 		/* Cannot create environment */
@@ -146,9 +142,9 @@ rspamd_bdb_init (struct rspamd_kv_backend *backend)
 	}
 
 	flags = DB_INIT_MPOOL |
-		DB_CREATE |            /* Create the environment if it does not already exist. */
-		DB_INIT_LOCK |         /* Initialize locking. */
-		DB_THREAD;             /* Use threads */
+			DB_CREATE     |    /* Create the environment if it does not already exist. */
+			DB_INIT_LOCK  |    /* Initialize locking. */
+			DB_THREAD;         /* Use threads */
 
 	if ((ret = db->envp->open (db->envp, db->dirname, flags, 0)) != 0) {
 		/* Cannot open environment */
@@ -172,9 +168,7 @@ rspamd_bdb_init (struct rspamd_kv_backend *backend)
 		goto err;
 	}
 
-	if ((ret =
-		db->dbp->open (db->dbp, NULL, db->filename, NULL, DB_HASH, flags,
-		0)) != 0) {
+	if ((ret = db->dbp->open (db->dbp, NULL, db->filename, NULL, DB_HASH, flags, 0)) != 0) {
 		goto err;
 	}
 
@@ -193,13 +187,10 @@ err:
 }
 
 static gboolean
-rspamd_bdb_insert (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_bdb_insert (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
-	struct bdb_op *op;
+	struct rspamd_bdb_backend					*db = (struct rspamd_bdb_backend *)backend;
+	struct bdb_op								*op;
 
 	if (!db->initialized) {
 		return FALSE;
@@ -213,8 +204,7 @@ rspamd_bdb_insert (struct rspamd_kv_backend *backend,
 	g_queue_push_head (db->ops_queue, op);
 	g_hash_table_insert (db->ops_hash, elt, op);
 
-	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
-		db->sync_ops) {
+	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
 		return bdb_process_queue (backend);
 	}
 
@@ -222,13 +212,10 @@ rspamd_bdb_insert (struct rspamd_kv_backend *backend,
 }
 
 static gboolean
-rspamd_bdb_replace (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_bdb_replace (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
-	struct bdb_op *op;
+	struct rspamd_bdb_backend					*db = (struct rspamd_bdb_backend *)backend;
+	struct bdb_op								*op;
 
 	if (!db->initialized) {
 		return FALSE;
@@ -242,23 +229,21 @@ rspamd_bdb_replace (struct rspamd_kv_backend *backend,
 	g_queue_push_head (db->ops_queue, op);
 	g_hash_table_insert (db->ops_hash, elt, op);
 
-	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
-		db->sync_ops) {
+	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
 		return bdb_process_queue (backend);
 	}
 
 	return TRUE;
 }
 
-static struct rspamd_kv_element *
-rspamd_bdb_lookup (struct rspamd_kv_backend *backend, gpointer key,
-	guint keylen)
+static struct rspamd_kv_element*
+rspamd_bdb_lookup (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
 {
-	struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
-	struct bdb_op *op;
-	DBT db_key, db_data;
-	struct rspamd_kv_element *elt = NULL;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_bdb_backend					*db = (struct rspamd_bdb_backend *)backend;
+	struct bdb_op								*op;
+	DBT 										 db_key, db_data;
+	struct rspamd_kv_element					*elt = NULL;
+	struct rspamd_kv_element			 		 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -275,7 +260,7 @@ rspamd_bdb_lookup (struct rspamd_kv_backend *backend, gpointer key,
 		return op->elt;
 	}
 
-	memset (&db_key,  0, sizeof(DBT));
+	memset (&db_key, 0, sizeof(DBT));
 	memset (&db_data, 0, sizeof(DBT));
 	db_key.size = keylen;
 	db_key.data = key;
@@ -290,13 +275,12 @@ rspamd_bdb_lookup (struct rspamd_kv_backend *backend, gpointer key,
 }
 
 static void
-rspamd_bdb_delete (struct rspamd_kv_backend *backend, gpointer key,
-	guint keylen)
+rspamd_bdb_delete (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
 {
-	struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
-	struct bdb_op *op;
-	struct rspamd_kv_element *elt;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_bdb_backend					*db = (struct rspamd_bdb_backend *)backend;
+	struct bdb_op								*op;
+	struct rspamd_kv_element					*elt;
+	struct rspamd_kv_element			 		 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -322,8 +306,7 @@ rspamd_bdb_delete (struct rspamd_kv_backend *backend, gpointer key,
 	g_queue_push_head (db->ops_queue, op);
 	g_hash_table_insert (db->ops_hash, elt, op);
 
-	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
-		db->sync_ops) {
+	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
 		bdb_process_queue (backend);
 	}
 
@@ -333,7 +316,7 @@ rspamd_bdb_delete (struct rspamd_kv_backend *backend, gpointer key,
 static void
 rspamd_bdb_destroy (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_bdb_backend *db = (struct rspamd_bdb_backend *)backend;
+	struct rspamd_bdb_backend					*db = (struct rspamd_bdb_backend *)backend;
 
 	if (db->initialized) {
 		bdb_process_queue (backend);
@@ -355,9 +338,9 @@ rspamd_bdb_destroy (struct rspamd_kv_backend *backend)
 struct rspamd_kv_backend *
 rspamd_kv_bdb_new (const gchar *filename, guint sync_ops)
 {
-	struct rspamd_bdb_backend *new;
-	struct stat st;
-	gchar *dirname;
+	struct rspamd_bdb_backend					*new;
+	struct stat 								 st;
+	gchar										*dirname;
 
 	if (filename == NULL) {
 		return NULL;
diff --git a/src/kvstorage_bdb.h b/src/kvstorage_bdb.h
index d71f1f65f..c6dd925b5 100644
--- a/src/kvstorage_bdb.h
+++ b/src/kvstorage_bdb.h
@@ -31,8 +31,7 @@
 #ifdef WITH_DB
 
 /* Create new bdb backend */
-struct rspamd_kv_backend * rspamd_kv_bdb_new (const gchar *filename,
-	guint sync_ops);
+struct rspamd_kv_backend* rspamd_kv_bdb_new (const gchar *filename, guint sync_ops);
 
 #endif
 
diff --git a/src/kvstorage_config.c b/src/kvstorage_config.c
index a29ae2454..362a47f49 100644
--- a/src/kvstorage_config.c
+++ b/src/kvstorage_config.c
@@ -21,9 +21,9 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_xml.h"
 #include "kvstorage_config.h"
 #include "main.h"
+#include "cfg_xml.h"
 #ifdef WITH_DB
 #include "kvstorage_bdb.h"
 #endif
@@ -68,7 +68,7 @@ struct kvstorage_config_parser {
 static void
 kvstorage_config_destroy (gpointer k)
 {
-	struct kvstorage_config *kconf = k;
+	struct kvstorage_config				*kconf = k;
 
 	if (kconf->name) {
 		g_free (kconf->name);
@@ -83,14 +83,12 @@ kvstorage_config_destroy (gpointer k)
 
 /* Init kvstorage */
 static void
-kvstorage_init_callback (const gpointer key,
-	const gpointer value,
-	gpointer unused)
+kvstorage_init_callback (const gpointer key, const gpointer value, gpointer unused)
 {
-	struct kvstorage_config *kconf = value;
-	struct rspamd_kv_cache *cache;
-	struct rspamd_kv_backend *backend = NULL;
-	struct rspamd_kv_expire *expire = NULL;
+	struct kvstorage_config				*kconf = value;
+	struct rspamd_kv_cache				*cache;
+	struct rspamd_kv_backend			*backend = NULL;
+	struct rspamd_kv_expire				*expire = NULL;
 
 	switch (kconf->cache.type) {
 	case KVSTORAGE_TYPE_CACHE_HASH:
@@ -115,22 +113,17 @@ kvstorage_init_callback (const gpointer key,
 		backend = NULL;
 		break;
 	case KVSTORAGE_TYPE_BACKEND_FILE:
-		backend = rspamd_kv_file_new (kconf->backend.filename,
-				kconf->backend.sync_ops,
-				FILE_STORAGE_LEVELS,
-				kconf->backend.do_fsync,
-				kconf->backend.do_ref);
+		backend = rspamd_kv_file_new (kconf->backend.filename, kconf->backend.sync_ops,
+				FILE_STORAGE_LEVELS, kconf->backend.do_fsync, kconf->backend.do_ref);
 		break;
 #ifdef WITH_DB
 	case KVSTORAGE_TYPE_BACKEND_BDB:
-		backend = rspamd_kv_bdb_new (kconf->backend.filename,
-				kconf->backend.sync_ops);
+		backend = rspamd_kv_bdb_new (kconf->backend.filename, kconf->backend.sync_ops);
 		break;
 #endif
 #ifdef WITH_SQLITE
 	case KVSTORAGE_TYPE_BACKEND_SQLITE:
-		backend = rspamd_kv_sqlite_new (kconf->backend.filename,
-				kconf->backend.sync_ops);
+		backend = rspamd_kv_sqlite_new (kconf->backend.filename, kconf->backend.sync_ops);
 		break;
 #endif
 	}
@@ -141,27 +134,20 @@ kvstorage_init_callback (const gpointer key,
 		break;
 	}
 
-	kconf->storage = rspamd_kv_storage_new (kconf->id,
-			kconf->name,
-			cache,
-			backend,
-			expire,
-			kconf->cache.max_elements,
-			kconf->cache.max_memory,
-			kconf->cache.no_overwrite);
+	kconf->storage = rspamd_kv_storage_new (kconf->id, kconf->name, cache, backend, expire,
+			kconf->cache.max_elements, kconf->cache.max_memory, kconf->cache.no_overwrite);
 }
 
 /* XML parse callbacks */
 /* Called for open tags <foo bar="baz"> */
-void
-kvstorage_xml_start_element (GMarkupParseContext *context,
-	const gchar *element_name,
-	const gchar **attribute_names,
-	const gchar **attribute_values,
-	gpointer user_data,
-	GError **error)
+void kvstorage_xml_start_element (GMarkupParseContext	*context,
+								const gchar         *element_name,
+								const gchar        **attribute_names,
+								const gchar        **attribute_values,
+								gpointer             user_data,
+								GError             **error)
 {
-	struct kvstorage_config_parser *kv_parser = user_data;
+	struct kvstorage_config_parser 	*kv_parser = user_data;
 
 	switch (kv_parser->state) {
 	case KVSTORAGE_STATE_INIT:
@@ -173,12 +159,10 @@ kvstorage_xml_start_element (GMarkupParseContext *context,
 			if (kv_parser->pool != NULL) {
 				rspamd_mempool_delete (kv_parser->pool);
 			}
-			kv_parser->pool =
-				rspamd_mempool_new (rspamd_mempool_suggest_size ());
+			kv_parser->pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 			/* Create new kvstorage_config */
-			kv_parser->current_storage =
-				g_malloc0 (sizeof (struct kvstorage_config));
+			kv_parser->current_storage = g_malloc0 (sizeof (struct kvstorage_config));
 			kv_parser->current_storage->id = last_id++;
 		}
 		if (g_ascii_strcasecmp (element_name, "type") == 0) {
@@ -215,9 +199,8 @@ kvstorage_xml_start_element (GMarkupParseContext *context,
 		}
 		else {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
-					element_name);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
+						element_name);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
@@ -245,9 +228,8 @@ kvstorage_xml_start_element (GMarkupParseContext *context,
 		}
 		else {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected in backend definition",
-					element_name);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected in backend definition",
+						element_name);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
@@ -259,9 +241,8 @@ kvstorage_xml_start_element (GMarkupParseContext *context,
 		}
 		else {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected in expire definition",
-					element_name);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected in expire definition",
+						element_name);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
@@ -273,27 +254,24 @@ kvstorage_xml_start_element (GMarkupParseContext *context,
 
 }
 
-#define CHECK_TAG(s)                                                                                                                    \
-	do {                                                                                                                                    \
-		if (g_ascii_strcasecmp (element_name, kv_parser->cur_elt) == 0) {                                                                       \
-			kv_parser->state = (s);                                                                                                             \
-		}                                                                                                                                       \
-		else {                                                                                                                                  \
-			if (*error == NULL) *error = g_error_new ( \
-					xml_error_quark (), XML_UNMATCHED_TAG, "element %s is unexpected in this state, expected %s", element_name, \
-					kv_parser->cur_elt);  \
-			kv_parser->state = KVSTORAGE_STATE_ERROR;                                                                                           \
-		}                                                                                                                                       \
-	} while (0)
+#define CHECK_TAG(s)																													\
+do {																																	\
+if (g_ascii_strcasecmp (element_name, kv_parser->cur_elt) == 0) {																		\
+	kv_parser->state = (s);																												\
+}																																		\
+else {																																	\
+	if (*error == NULL) *error = g_error_new (xml_error_quark (), XML_UNMATCHED_TAG, "element %s is unexpected in this state, expected %s", element_name, kv_parser->cur_elt);	\
+	kv_parser->state = KVSTORAGE_STATE_ERROR;																							\
+}																																		\
+} while (0)
 
 /* Called for close tags </foo> */
-void
-kvstorage_xml_end_element (GMarkupParseContext *context,
-	const gchar *element_name,
-	gpointer user_data,
-	GError **error)
+void kvstorage_xml_end_element (GMarkupParseContext	*context,
+								const gchar         *element_name,
+								gpointer             user_data,
+								GError             **error)
 {
-	struct kvstorage_config_parser *kv_parser = user_data;
+	struct kvstorage_config_parser 	*kv_parser = user_data;
 
 	switch (kv_parser->state) {
 	case KVSTORAGE_STATE_INIT:
@@ -303,9 +281,8 @@ kvstorage_xml_end_element (GMarkupParseContext *context,
 			return;
 		}
 		if (*error == NULL) {
-			*error = g_error_new (
-				xml_error_quark (), XML_EXTRA_ELEMENT, "end element %s is unexpected, expected start element",
-				element_name);
+			*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "end element %s is unexpected, expected start element",
+					element_name);
 		}
 		kv_parser->state = KVSTORAGE_STATE_ERROR;
 		break;
@@ -333,9 +310,8 @@ kvstorage_xml_end_element (GMarkupParseContext *context,
 		}
 		else {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
-					element_name);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
+						element_name);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
@@ -346,9 +322,8 @@ kvstorage_xml_end_element (GMarkupParseContext *context,
 		}
 		else {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
-					element_name);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "element %s is unexpected",
+						element_name);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
@@ -361,19 +336,18 @@ kvstorage_xml_end_element (GMarkupParseContext *context,
 #undef CHECK_TAG
 
 /* text is not nul-terminated */
-void
-kvstorage_xml_text (GMarkupParseContext *context,
-	const gchar *text,
-	gsize text_len,
-	gpointer user_data,
-	GError **error)
+void kvstorage_xml_text       (GMarkupParseContext		*context,
+								const gchar         *text,
+								gsize                text_len,
+								gpointer             user_data,
+								GError             **error)
 {
-	struct kvstorage_config_parser *kv_parser = user_data;
-	gchar *err_str;
+	struct kvstorage_config_parser 	*kv_parser = user_data;
+	gchar                           *err_str;
 
 	/* Strip space symbols */
 	while (*text && g_ascii_isspace (*text)) {
-		text++;
+		text ++;
 	}
 	if (*text == '\0') {
 		/* Skip empty text */
@@ -384,9 +358,7 @@ kvstorage_xml_text (GMarkupParseContext *context,
 	case KVSTORAGE_STATE_INIT:
 	case KVSTORAGE_STATE_PARAM:
 		if (*error == NULL) {
-			*error = g_error_new (
-				xml_error_quark (), XML_EXTRA_ELEMENT,
-				"text is unexpected, expected start element");
+			*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "text is unexpected, expected start element");
 		}
 		kv_parser->state = KVSTORAGE_STATE_ERROR;
 		break;
@@ -394,14 +366,12 @@ kvstorage_xml_text (GMarkupParseContext *context,
 		kv_parser->current_storage->id = strtoul (text, &err_str, 10);
 		if ((gsize)(err_str - text) != text_len) {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "invalid number: %*s",
-					(int)text_len, text);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "invalid number: %*s", (int)text_len, text);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
 		else {
-			last_id++;
+			last_id ++;
 			last_id = MAX (kv_parser->current_storage->id, last_id);
 		}
 		break;
@@ -410,103 +380,77 @@ kvstorage_xml_text (GMarkupParseContext *context,
 		rspamd_strlcpy (kv_parser->current_storage->name, text, text_len + 1);
 		break;
 	case KVSTORAGE_STATE_CACHE_MAX_ELTS:
-		kv_parser->current_storage->cache.max_elements =
-			rspamd_config_parse_limit (text, text_len);
+		kv_parser->current_storage->cache.max_elements = rspamd_config_parse_limit (text, text_len);
 		break;
 	case KVSTORAGE_STATE_CACHE_MAX_MEM:
-		kv_parser->current_storage->cache.max_memory =
-			rspamd_config_parse_limit (text, text_len);
+		kv_parser->current_storage->cache.max_memory = rspamd_config_parse_limit (text, text_len);
 		break;
 	case KVSTORAGE_STATE_CACHE_NO_OVERWRITE:
-		kv_parser->current_storage->cache.no_overwrite =
-			rspamd_config_parse_flag (text);
+		kv_parser->current_storage->cache.no_overwrite = rspamd_config_parse_flag (text);
 		break;
 	case KVSTORAGE_STATE_CACHE_TYPE:
-		if (g_ascii_strncasecmp (text, "hash",
-			MIN (text_len, sizeof ("hash") - 1)) == 0) {
+		if (g_ascii_strncasecmp (text, "hash", MIN (text_len, sizeof ("hash") - 1)) == 0) {
 			kv_parser->current_storage->cache.type = KVSTORAGE_TYPE_CACHE_HASH;
 		}
-		else if (g_ascii_strncasecmp (text, "radix",
-			MIN (text_len, sizeof ("radix") - 1)) == 0) {
+		else if (g_ascii_strncasecmp (text, "radix", MIN (text_len, sizeof ("radix") - 1)) == 0) {
 			kv_parser->current_storage->cache.type = KVSTORAGE_TYPE_CACHE_RADIX;
 		}
 #ifdef WITH_JUDY
-		else if (g_ascii_strncasecmp (text, "judy",
-			MIN (text_len, sizeof ("judy") - 1)) == 0) {
+		else if (g_ascii_strncasecmp (text, "judy", MIN (text_len, sizeof ("judy") - 1)) == 0) {
 			kv_parser->current_storage->cache.type = KVSTORAGE_TYPE_CACHE_JUDY;
 		}
 #endif
 		else {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "invalid cache type: %*s",
-					(int)text_len, text);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "invalid cache type: %*s", (int)text_len, text);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
 		break;
 	case KVSTORAGE_STATE_BACKEND_TYPE:
-		if (g_ascii_strncasecmp (text, "null",
-			MIN (text_len, sizeof ("null") - 1)) == 0) {
-			kv_parser->current_storage->backend.type =
-				KVSTORAGE_TYPE_BACKEND_NULL;
+		if (g_ascii_strncasecmp (text, "null", MIN (text_len, sizeof ("null") - 1)) == 0) {
+			kv_parser->current_storage->backend.type = KVSTORAGE_TYPE_BACKEND_NULL;
 		}
-		else if (g_ascii_strncasecmp (text, "file",
-			MIN (text_len, sizeof ("file") - 1)) == 0) {
-			kv_parser->current_storage->backend.type =
-				KVSTORAGE_TYPE_BACKEND_FILE;
+		else if (g_ascii_strncasecmp (text, "file", MIN (text_len, sizeof ("file") - 1)) == 0) {
+			kv_parser->current_storage->backend.type = KVSTORAGE_TYPE_BACKEND_FILE;
 		}
 #ifdef WITH_DB
-		else if (g_ascii_strncasecmp (text, "bdb",
-			MIN (text_len, sizeof ("bdb") - 1)) == 0) {
-			kv_parser->current_storage->backend.type =
-				KVSTORAGE_TYPE_BACKEND_BDB;
+		else if (g_ascii_strncasecmp (text, "bdb", MIN (text_len, sizeof ("bdb") - 1)) == 0) {
+			kv_parser->current_storage->backend.type = KVSTORAGE_TYPE_BACKEND_BDB;
 		}
 #endif
 #ifdef WITH_SQLITE
-		else if (g_ascii_strncasecmp (text, "sqlite",
-			MIN (text_len, sizeof ("sqlite") - 1)) == 0) {
-			kv_parser->current_storage->backend.type =
-				KVSTORAGE_TYPE_BACKEND_SQLITE;
+		else if (g_ascii_strncasecmp (text, "sqlite", MIN (text_len, sizeof ("sqlite") - 1)) == 0) {
+			kv_parser->current_storage->backend.type = KVSTORAGE_TYPE_BACKEND_SQLITE;
 		}
 #endif
 		else {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "invalid backend type: %*s",
-					(int)text_len, text);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "invalid backend type: %*s", (int)text_len, text);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
 		break;
 	case KVSTORAGE_STATE_BACKEND_FILENAME:
 		kv_parser->current_storage->backend.filename = g_malloc (text_len + 1);
-		rspamd_strlcpy (kv_parser->current_storage->backend.filename,
-			text,
-			text_len + 1);
+		rspamd_strlcpy (kv_parser->current_storage->backend.filename, text, text_len + 1);
 		break;
 	case KVSTORAGE_STATE_BACKEND_SYNC_OPS:
-		kv_parser->current_storage->backend.sync_ops =
-			rspamd_config_parse_limit (text, text_len);
+		kv_parser->current_storage->backend.sync_ops = rspamd_config_parse_limit (text, text_len);
 		break;
 	case KVSTORAGE_STATE_BACKEND_DO_FSYNC:
-		kv_parser->current_storage->backend.do_fsync =
-			rspamd_config_parse_flag (text);
+		kv_parser->current_storage->backend.do_fsync = rspamd_config_parse_flag (text);
 		break;
 	case KVSTORAGE_STATE_BACKEND_DO_REF:
-		kv_parser->current_storage->backend.do_ref = rspamd_config_parse_flag (
-			text);
+		kv_parser->current_storage->backend.do_ref = rspamd_config_parse_flag (text);
 		break;
 	case KVSTORAGE_STATE_EXPIRE_TYPE:
-		if (g_ascii_strncasecmp (text, "lru",
-			MIN (text_len, sizeof ("lru") - 1)) == 0) {
+		if (g_ascii_strncasecmp (text, "lru", MIN (text_len, sizeof ("lru") - 1)) == 0) {
 			kv_parser->current_storage->expire.type = KVSTORAGE_TYPE_EXPIRE_LRU;
 		}
 		else {
 			if (*error == NULL) {
-				*error = g_error_new (
-					xml_error_quark (), XML_EXTRA_ELEMENT, "invalid expire type: %*s",
-					(int)text_len, text);
+				*error = g_error_new (xml_error_quark (), XML_EXTRA_ELEMENT, "invalid expire type: %*s", (int)text_len, text);
 			}
 			kv_parser->state = KVSTORAGE_STATE_ERROR;
 		}
@@ -519,12 +463,12 @@ kvstorage_xml_text (GMarkupParseContext *context,
 }
 
 /* Called on error, including one set by other
- * methods in the vtable. The GError should not be freed.
- */
+* methods in the vtable. The GError should not be freed.
+*/
 void
-kvstorage_xml_error (GMarkupParseContext *context,
-	GError *error,
-	gpointer user_data)
+kvstorage_xml_error	(GMarkupParseContext		*context,
+								GError              *error,
+								gpointer             user_data)
 {
 	msg_err ("kvstorage xml parser error: %s", error->message);
 }
@@ -535,11 +479,9 @@ kvstorage_xml_error (GMarkupParseContext *context,
 static void
 kvstorage_cleanup (gpointer ud)
 {
-	struct kvstorage_config_parser *kv_parser = ud;
+	struct kvstorage_config_parser 	*kv_parser = ud;
 
-	g_hash_table_insert (storages,
-		&kv_parser->current_storage->id,
-		kv_parser->current_storage);
+	g_hash_table_insert (storages, &kv_parser->current_storage->id, kv_parser->current_storage);
 	kv_parser->state = KVSTORAGE_STATE_INIT;
 	g_hash_table_foreach (storages, kvstorage_init_callback, NULL);
 	kv_parser->current_storage = NULL;
@@ -551,22 +493,16 @@ kvstorage_cleanup (gpointer ud)
 void
 init_kvstorage_config (void)
 {
-	GMarkupParser *parser;
-	struct kvstorage_config_parser *kv_parser;
+	GMarkupParser					*parser;
+	struct kvstorage_config_parser 	*kv_parser;
 
 	if (storages == NULL) {
-		storages = g_hash_table_new_full (g_int_hash,
-				g_int_equal,
-				NULL,
-				kvstorage_config_destroy);
+		storages = g_hash_table_new_full (g_int_hash, g_int_equal, NULL, kvstorage_config_destroy);
 	}
 	else {
 		/* Create new global table */
 		g_hash_table_destroy (storages);
-		storages = g_hash_table_new_full (g_int_hash,
-				g_int_equal,
-				NULL,
-				kvstorage_config_destroy);
+		storages = g_hash_table_new_full (g_int_hash, g_int_equal, NULL, kvstorage_config_destroy);
 	}
 
 	/* Create and register subparser */
@@ -584,7 +520,7 @@ init_kvstorage_config (void)
 }
 
 /* Get configuration for kvstorage with specified ID */
-struct kvstorage_config *
+struct kvstorage_config*
 get_kvstorage_config (gint id)
 {
 	if (storages == NULL) {
diff --git a/src/kvstorage_config.h b/src/kvstorage_config.h
index f94d934b3..095ae3ab2 100644
--- a/src/kvstorage_config.h
+++ b/src/kvstorage_config.h
@@ -93,7 +93,7 @@ struct kvstorage_config {
 void init_kvstorage_config (void);
 
 /* Get configuration for kvstorage with specified ID */
-struct kvstorage_config * get_kvstorage_config (gint id);
+struct kvstorage_config* get_kvstorage_config (gint id);
 
 void destroy_kvstorage_config (void);
 
diff --git a/src/kvstorage_file.c b/src/kvstorage_file.c
index 99d130b55..2857e680b 100644
--- a/src/kvstorage_file.c
+++ b/src/kvstorage_file.c
@@ -25,8 +25,8 @@
 #include "config.h"
 #include "kvstorage.h"
 #include "kvstorage_file.h"
-#include "main.h"
 #include "util.h"
+#include "main.h"
 
 struct file_op {
 	struct rspamd_kv_element *elt;
@@ -40,14 +40,14 @@ struct file_op {
 
 /* Main file structure */
 struct rspamd_file_backend {
-	backend_init init_func;                     /*< this callback is called on kv storage initialization */
-	backend_insert insert_func;                 /*< this callback is called when element is inserted */
-	backend_replace replace_func;               /*< this callback is called when element is replaced */
-	backend_lookup lookup_func;                 /*< this callback is used for lookup of element */
-	backend_delete delete_func;                 /*< this callback is called when an element is deleted */
-	backend_sync sync_func;                     /*< this callback is called when backend need to be synced */
-	backend_incref incref_func;                 /*< this callback is called when element must be ref'd */
-	backend_destroy destroy_func;               /*< this callback is used for destroying all elements inside backend */
+	backend_init init_func;						/*< this callback is called on kv storage initialization */
+	backend_insert insert_func;					/*< this callback is called when element is inserted */
+	backend_replace replace_func;				/*< this callback is called when element is replaced */
+	backend_lookup lookup_func;					/*< this callback is used for lookup of element */
+	backend_delete delete_func;					/*< this callback is called when an element is deleted */
+	backend_sync sync_func;						/*< this callback is called when backend need to be synced */
+	backend_incref incref_func;					/*< this callback is called when element must be ref'd */
+	backend_destroy destroy_func;				/*< this callback is used for destroying all elements inside backend */
 	gchar *filename;
 	gchar *dirname;
 	guint dirlen;
@@ -60,21 +60,15 @@ struct rspamd_file_backend {
 	gboolean initialized;
 };
 
-static const gchar hexdigits[] =
-{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
-	 'f'};
+static const gchar hexdigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
 /* Generate file name for operation */
 static gboolean
-get_file_name (struct rspamd_file_backend *db,
-	gchar *key,
-	guint keylen,
-	gchar *filebuf,
-	guint buflen)
+get_file_name (struct rspamd_file_backend *db, gchar *key, guint keylen, gchar *filebuf, guint buflen)
 {
-	gchar *p = filebuf, *end = filebuf + buflen,
-	*k = key, t;
-	guint i;
+	gchar										*p = filebuf, *end = filebuf + buflen,
+												*k = key, t;
+	guint										 i;
 
 	/* First copy backend dirname to file buf */
 	if (buflen <= db->dirlen) {
@@ -83,7 +77,7 @@ get_file_name (struct rspamd_file_backend *db,
 	memcpy (p, db->dirname, db->dirlen);
 	p += db->dirlen;
 	*p++ = G_DIR_SEPARATOR;
-	for (i = 0; i < MIN (keylen, db->levels); i++) {
+	for (i = 0; i < MIN (keylen, db->levels); i ++) {
 		if (p == end) {
 			/* Filebuf is not large enough */
 			return FALSE;
@@ -91,7 +85,7 @@ get_file_name (struct rspamd_file_backend *db,
 		t = *k;
 		*p++ = hexdigits[(t & 0xf) ^ ((t & 0xf0) >> 4)];
 		*p++ = G_DIR_SEPARATOR;
-		k++;
+		k ++;
 	}
 	/* Now we have directory, append base64 encoded filename */
 	k = key;
@@ -105,7 +99,7 @@ get_file_name (struct rspamd_file_backend *db,
 		t = *k;
 		*p++ = hexdigits[(t >> 4) & 0xf];
 		*p++ = hexdigits[t & 0xf];
-		k++;
+		k ++;
 	}
 	*p = '\0';
 
@@ -116,7 +110,7 @@ get_file_name (struct rspamd_file_backend *db,
 static guint32
 file_get_ref (gint fd)
 {
-	guint32 target;
+	guint32										 target;
 
 	if (read (fd, &target, sizeof (guint32)) != sizeof (guint32)) {
 		return 0;
@@ -142,12 +136,12 @@ file_set_ref (gint fd, guint32 ref)
 static gint
 file_open_fd (const gchar *path, gsize *len, gint flags)
 {
-	gint fd;
-	struct stat st;
+	gint										 fd;
+	struct stat									 st;
 
 	if ((flags & O_CREAT) != 0) {
 		/* Open file */
-		if ((fd = open (path, flags, S_IRUSR | S_IWUSR | S_IRGRP)) != -1) {
+		if ((fd = open (path, flags, S_IRUSR|S_IWUSR|S_IRGRP)) != -1) {
 			rspamd_fallocate (fd, 0, *len);
 #ifdef HAVE_FADVISE
 			posix_fadvise (fd, 0, *len, POSIX_FADV_SEQUENTIAL);
@@ -176,19 +170,16 @@ file_open_fd (const gchar *path, gsize *len, gint flags)
 
 /* Process single file operation */
 static gboolean
-file_process_single_op (struct rspamd_file_backend *db,
-	struct file_op *op,
-	gint *pfd)
+file_process_single_op (struct rspamd_file_backend *db, struct file_op *op, gint *pfd)
 {
-	gchar filebuf[PATH_MAX];
-	gint fd;
-	gsize len;
-	struct iovec iov[2];
-	guint32 ref;
+	gchar										 filebuf[PATH_MAX];
+	gint										 fd;
+	gsize										 len;
+	struct iovec								 iov[2];
+	guint32										 ref;
 
 	/* Get filename */
-	if (!get_file_name (db, ELT_KEY (op->elt), op->elt->keylen, filebuf,
-		sizeof (filebuf))) {
+	if (!get_file_name (db, ELT_KEY (op->elt), op->elt->keylen, filebuf, sizeof (filebuf))) {
 		return FALSE;
 	}
 
@@ -214,7 +205,7 @@ file_process_single_op (struct rspamd_file_backend *db,
 			else {
 				/* Decrease ref */
 				lseek (fd, 0, SEEK_SET);
-				if (!file_set_ref (fd, --ref)) {
+				if (! file_set_ref (fd, --ref)) {
 					*pfd = fd;
 					return FALSE;
 				}
@@ -226,8 +217,7 @@ file_process_single_op (struct rspamd_file_backend *db,
 		}
 	}
 	else {
-		if ((fd =
-			file_open_fd (filebuf, &len, O_CREAT | O_WRONLY | O_TRUNC)) == -1) {
+		if ((fd = file_open_fd (filebuf, &len, O_CREAT|O_WRONLY|O_TRUNC)) == -1) {
 			*pfd = -1;
 			return FALSE;
 		}
@@ -259,9 +249,9 @@ file_process_single_op (struct rspamd_file_backend *db,
 static void
 file_sync_fds (gint *fds, gint len, gboolean do_fsync)
 {
-	gint i, fd;
+	gint										 i, fd;
 
-	for (i = 0; i < len; i++) {
+	for (i = 0; i < len; i ++) {
 		fd = fds[i];
 		if (fd != -1) {
 			if (do_fsync) {
@@ -280,10 +270,10 @@ file_sync_fds (gint *fds, gint len, gboolean do_fsync)
 static gboolean
 file_process_queue (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
-	struct file_op *op;
-	GList *cur;
-	gint *fds, i = 0, len;
+	struct rspamd_file_backend					*db = (struct rspamd_file_backend *)backend;
+	struct file_op								*op;
+	GList										*cur;
+	gint										*fds, i = 0, len;
 
 	len = g_queue_get_length (db->ops_queue);
 	if (len == 0) {
@@ -295,12 +285,12 @@ file_process_queue (struct rspamd_kv_backend *backend)
 	cur = db->ops_queue->head;
 	while (cur) {
 		op = cur->data;
-		if (!file_process_single_op (db, op, &fds[i])) {
+		if (! file_process_single_op (db, op, &fds[i])) {
 			file_sync_fds (fds, i, db->do_fsync);
 			g_slice_free1 (len * sizeof (gint), fds);
 			return FALSE;
 		}
-		i++;
+		i ++;
 		cur = g_list_next (cur);
 	}
 
@@ -312,9 +302,8 @@ file_process_queue (struct rspamd_kv_backend *backend)
 	cur = db->ops_queue->head;
 	while (cur) {
 		op = cur->data;
-		if (op->op == FILE_OP_DELETE ||
-			((op->elt->flags & KV_ELT_NEED_FREE) != 0 &&
-			(op->elt->flags & KV_ELT_NEED_INSERT) == 0)) {
+		if (op->op == FILE_OP_DELETE || ((op->elt->flags & KV_ELT_NEED_FREE) != 0 &&
+				(op->elt->flags & KV_ELT_NEED_INSERT) == 0)) {
 			/* Also clean memory */
 			g_slice_free1 (ELT_SIZE (op->elt), op->elt);
 		}
@@ -337,17 +326,16 @@ file_process_queue (struct rspamd_kv_backend *backend)
 static gboolean
 rspamd_recursive_mkdir (guint levels)
 {
-	guint i;
-	gchar nbuf[5];
+	guint									i;
+	gchar									nbuf[5];
 
 	/* Create directories for backend */
 	if (levels > 0) {
 		/* Create 16 directories */
-		for (i = 0; i < 16; i++) {
+		for (i = 0; i < 16; i ++) {
 			rspamd_snprintf (nbuf, sizeof (nbuf), "./%c", hexdigits[i]);
 			if (mkdir (nbuf, 0755) != 0 && errno != EEXIST) {
-				msg_info ("cannot create directory %s: %s", nbuf,
-					strerror (errno));
+				msg_info ("cannot create directory %s: %s", nbuf, strerror (errno));
 				return FALSE;
 			}
 			else if (levels > 1) {
@@ -355,7 +343,7 @@ rspamd_recursive_mkdir (guint levels)
 					msg_err ("chdir to %s failed: %s", nbuf, strerror (errno));
 					return FALSE;
 				}
-				if (!rspamd_recursive_mkdir (levels - 1)) {
+				if (! rspamd_recursive_mkdir (levels - 1)) {
 					return FALSE;
 				}
 				if (chdir ("../") == -1) {
@@ -373,8 +361,8 @@ rspamd_recursive_mkdir (guint levels)
 static void
 rspamd_file_init (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
-	gchar pathbuf[PATH_MAX];
+	struct rspamd_file_backend				*db = (struct rspamd_file_backend *)backend;
+	gchar									 pathbuf[PATH_MAX];
 
 	/* Save current directory */
 	if (getcwd (pathbuf, sizeof (pathbuf) - 1) == NULL) {
@@ -409,14 +397,11 @@ err:
 }
 
 static gboolean
-rspamd_file_insert (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_file_insert (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
-	struct file_op *op;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_file_backend					*db = (struct rspamd_file_backend *)backend;
+	struct file_op								*op;
+	struct rspamd_kv_element			 		 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -427,14 +412,13 @@ rspamd_file_insert (struct rspamd_kv_backend *backend,
 
 	if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
 		/* We found another op with such key in this queue */
-		if (op->op == FILE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
-			0) {
+		if (op->op == FILE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
 			/* Also clean memory */
 			g_hash_table_steal (db->ops_hash, &search_elt);
 			g_slice_free1 (ELT_SIZE (op->elt), op->elt);
 		}
 		op->op = FILE_OP_INSERT;
-		op->ref++;
+		op->ref ++;
 		op->elt = elt;
 		elt->flags |= KV_ELT_DIRTY;
 		g_hash_table_insert (db->ops_hash, elt, op);
@@ -450,8 +434,7 @@ rspamd_file_insert (struct rspamd_kv_backend *backend,
 		g_hash_table_insert (db->ops_hash, elt, op);
 	}
 
-	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
-		db->sync_ops) {
+	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
 		return file_process_queue (backend);
 	}
 
@@ -459,14 +442,11 @@ rspamd_file_insert (struct rspamd_kv_backend *backend,
 }
 
 static gboolean
-rspamd_file_replace (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_file_replace (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
-	struct file_op *op;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_file_backend					*db = (struct rspamd_file_backend *)backend;
+	struct file_op								*op;
+	struct rspamd_kv_element			 		 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -476,8 +456,7 @@ rspamd_file_replace (struct rspamd_kv_backend *backend,
 	}
 	if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
 		/* We found another op with such key in this queue */
-		if (op->op == FILE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
-			0) {
+		if (op->op == FILE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
 			/* Also clean memory */
 			g_hash_table_steal (db->ops_hash, &search_elt);
 			g_slice_free1 (ELT_SIZE (op->elt), op->elt);
@@ -498,26 +477,23 @@ rspamd_file_replace (struct rspamd_kv_backend *backend,
 		g_hash_table_insert (db->ops_hash, elt, op);
 	}
 
-	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
-		db->sync_ops) {
+	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
 		return file_process_queue (backend);
 	}
 
 	return TRUE;
 }
 
-static struct rspamd_kv_element *
-rspamd_file_lookup (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen)
+static struct rspamd_kv_element*
+rspamd_file_lookup (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
 {
-	struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
-	struct file_op *op;
-	struct rspamd_kv_element *elt = NULL;
-	gchar filebuf[PATH_MAX];
-	gint fd;
-	struct rspamd_kv_element search_elt;
-	gsize len;
+	struct rspamd_file_backend					*db = (struct rspamd_file_backend *)backend;
+	struct file_op								*op;
+	struct rspamd_kv_element					*elt = NULL;
+	gchar										 filebuf[PATH_MAX];
+	gint										 fd;
+	struct rspamd_kv_element			 		 search_elt;
+	gsize										 len;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -557,23 +533,21 @@ rspamd_file_lookup (struct rspamd_kv_backend *backend,
 
 	close (fd);
 
-	elt->flags &= ~(KV_ELT_DIRTY | KV_ELT_NEED_FREE);
+	elt->flags &= ~(KV_ELT_DIRTY|KV_ELT_NEED_FREE);
 
 	return elt;
 }
 
 static void
-rspamd_file_delete (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen)
+rspamd_file_delete (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
 {
-	struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
-	gchar filebuf[PATH_MAX];
-	struct rspamd_kv_element search_elt;
-	struct file_op *op;
-	gsize len;
-	gint fd;
-	guint32 ref;
+	struct rspamd_file_backend					*db = (struct rspamd_file_backend *)backend;
+	gchar										 filebuf[PATH_MAX];
+	struct rspamd_kv_element			 		 search_elt;
+	struct file_op								*op;
+	gsize										 len;
+	gint										 fd;
+	guint32										 ref;
 
 	if (!db->initialized) {
 		return;
@@ -585,7 +559,7 @@ rspamd_file_delete (struct rspamd_kv_backend *backend,
 	if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
 		op->op = FILE_OP_DELETE;
 		if (op->ref > 0) {
-			op->ref--;
+			op->ref --;
 		}
 		return;
 	}
@@ -615,17 +589,15 @@ rspamd_file_delete (struct rspamd_kv_backend *backend,
 }
 
 static gboolean
-rspamd_file_incref (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen)
+rspamd_file_incref (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
 {
-	struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
-	gchar filebuf[PATH_MAX];
-	struct rspamd_kv_element search_elt;
-	struct file_op *op;
-	gsize len;
-	gint fd;
-	guint32 ref;
+	struct rspamd_file_backend					*db = (struct rspamd_file_backend *)backend;
+	gchar										 filebuf[PATH_MAX];
+	struct rspamd_kv_element			 		 search_elt;
+	struct file_op								*op;
+	gsize										 len;
+	gint										 fd;
+	guint32										 ref;
 
 	if (!db->initialized) {
 		return FALSE;
@@ -638,7 +610,7 @@ rspamd_file_incref (struct rspamd_kv_backend *backend,
 	search_elt.p = key;
 	/* First search in ops queue */
 	if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
-		op->ref++;
+		op->ref ++;
 		if (op->op == FILE_OP_DELETE) {
 			op->op = FILE_OP_INSERT;
 		}
@@ -672,7 +644,7 @@ rspamd_file_incref (struct rspamd_kv_backend *backend,
 static void
 rspamd_file_destroy (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_file_backend *db = (struct rspamd_file_backend *)backend;
+	struct rspamd_file_backend					*db = (struct rspamd_file_backend *)backend;
 
 	if (db->initialized) {
 		file_process_queue (backend);
@@ -689,15 +661,11 @@ rspamd_file_destroy (struct rspamd_kv_backend *backend)
 
 /* Create new file backend */
 struct rspamd_kv_backend *
-rspamd_kv_file_new (const gchar *filename,
-	guint sync_ops,
-	guint levels,
-	gboolean do_fsync,
-	gboolean do_ref)
+rspamd_kv_file_new (const gchar *filename, guint sync_ops, guint levels, gboolean do_fsync, gboolean do_ref)
 {
-	struct rspamd_file_backend *new;
-	struct stat st;
-	gchar *dirname;
+	struct rspamd_file_backend			 		*new;
+	struct stat 								 st;
+	gchar										*dirname;
 
 	if (filename == NULL) {
 		return NULL;
diff --git a/src/kvstorage_file.h b/src/kvstorage_file.h
index 4e97f467b..2b4c0f33d 100644
--- a/src/kvstorage_file.h
+++ b/src/kvstorage_file.h
@@ -29,11 +29,8 @@
 #include "kvstorage.h"
 
 /* Create new file backend */
-struct rspamd_kv_backend * rspamd_kv_file_new (const gchar *filename,
-	guint sync_ops,
-	guint levels,
-	gboolean do_fsync,
-	gboolean do_ref);
+struct rspamd_kv_backend* rspamd_kv_file_new (const gchar *filename, guint sync_ops,
+		guint levels, gboolean do_fsync, gboolean do_ref);
 
 
 #endif /* KVSTORAGE_FILE_H_ */
diff --git a/src/kvstorage_server.c b/src/kvstorage_server.c
index 34a8ff8ce..75ada2c77 100644
--- a/src/kvstorage_server.c
+++ b/src/kvstorage_server.c
@@ -22,12 +22,12 @@
  */
 
 
-#include "cfg_file.h"
-#include "cfg_xml.h"
 #include "config.h"
 #include "kvstorage.h"
 #include "kvstorage_config.h"
 #include "kvstorage_server.h"
+#include "cfg_file.h"
+#include "cfg_xml.h"
 #include "main.h"
 
 #define ERROR_COMMON "ERROR" CRLF
@@ -45,31 +45,22 @@ static sig_atomic_t do_reopen_log = 0;
 static sig_atomic_t soft_wanna_die = 0;
 
 /* Logging functions */
-#define thr_err(...)    do {                                                                            \
-		g_mutex_lock (thr->log_mtx);                                                                \
-		rspamd_common_log_function (rspamd_main->logger, \
-			G_LOG_LEVEL_CRITICAL, \
-			__FUNCTION__, \
-			__VA_ARGS__);   \
-		g_mutex_unlock (thr->log_mtx);                                                              \
+#define thr_err(...)	do {																			\
+	g_mutex_lock (thr->log_mtx);																\
+	rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_CRITICAL, __FUNCTION__, __VA_ARGS__);	\
+	g_mutex_unlock (thr->log_mtx);																\
 } while (0)
 
-#define thr_warn(...)   do {                                                                            \
-		g_mutex_lock (thr->log_mtx);                                                                \
-		rspamd_common_log_function (rspamd_main->logger, \
-			G_LOG_LEVEL_WARNING, \
-			__FUNCTION__, \
-			__VA_ARGS__);    \
-		g_mutex_unlock (thr->log_mtx);                                                              \
+#define thr_warn(...)	do {																			\
+	g_mutex_lock (thr->log_mtx);																\
+	rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_WARNING, __FUNCTION__, __VA_ARGS__);	\
+	g_mutex_unlock (thr->log_mtx);																\
 } while (0)
 
-#define thr_info(...)   do {                                                                            \
-		g_mutex_lock (thr->log_mtx);                                                                \
-		rspamd_common_log_function (rspamd_main->logger, \
-			G_LOG_LEVEL_INFO, \
-			__FUNCTION__, \
-			__VA_ARGS__);   \
-		g_mutex_unlock (thr->log_mtx);                                                              \
+#define thr_info(...)	do {																			\
+	g_mutex_lock (thr->log_mtx);																\
+	rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_INFO, __FUNCTION__, __VA_ARGS__);	\
+	g_mutex_unlock (thr->log_mtx);																\
 } while (0)
 
 /* Init functions */
@@ -77,14 +68,14 @@ gpointer init_keystorage (void);
 void start_keystorage (struct rspamd_worker *worker);
 
 worker_t keystorage_worker = {
-	"keystorage",               /* Name */
-	init_keystorage,            /* Init function */
-	start_keystorage,           /* Start function */
-	TRUE,                       /* Has socket */
-	FALSE,                      /* Non unique */
-	TRUE,                       /* Non threaded */
-	FALSE,                      /* Non killable */
-	SOCK_STREAM                 /* TCP socket */
+	"keystorage",				/* Name */
+	init_keystorage,			/* Init function */
+	start_keystorage,			/* Start function */
+	TRUE,						/* Has socket */
+	FALSE,						/* Non unique */
+	TRUE,						/* Non threaded */
+	FALSE,						/* Non killable */
+	SOCK_STREAM					/* TCP socket */
 };
 
 #ifndef HAVE_SA_SIGINFO
@@ -112,8 +103,8 @@ sig_handler (gint signo, siginfo_t *info, void *unused)
 gpointer
 init_keystorage (void)
 {
-	struct kvstorage_worker_ctx *ctx;
-	GQuark type;
+	struct kvstorage_worker_ctx         *ctx;
+	GQuark								type;
 
 	type = g_quark_try_string ("keystorage");
 	ctx = g_malloc0 (sizeof (struct kvstorage_worker_ctx));
@@ -123,9 +114,9 @@ init_keystorage (void)
 	ctx->timeout_raw = 300000;
 
 	register_worker_opt (type, "timeout", xml_handle_seconds, ctx,
-		G_STRUCT_OFFSET (struct kvstorage_worker_ctx, timeout_raw));
+					G_STRUCT_OFFSET (struct kvstorage_worker_ctx, timeout_raw));
 	register_worker_opt (type, "redis", xml_handle_boolean, ctx,
-		G_STRUCT_OFFSET (struct kvstorage_worker_ctx, is_redis));
+						G_STRUCT_OFFSET (struct kvstorage_worker_ctx, is_redis));
 	return ctx;
 }
 
@@ -133,7 +124,7 @@ init_keystorage (void)
 static gboolean
 config_kvstorage_worker (struct rspamd_worker *worker)
 {
-	struct kvstorage_worker_ctx *ctx = worker->ctx;
+	struct kvstorage_worker_ctx         *ctx = worker->ctx;
 
 	/* Init timeval */
 	msec_to_tv (ctx->timeout_raw, &ctx->io_timeout);
@@ -162,18 +153,18 @@ parse_kvstorage_command (struct kvstorage_session *session, gchar *c, guint len)
 	if (len == 3) {
 		/* Set or get command */
 		if ((c[0] == 'g' || c[0] == 'G') &&
-			(c[1] == 'e' || c[1] == 'E') &&
-			(c[2] == 't' || c[2] == 'T')) {
+				(c[1] == 'e' || c[1] == 'E') &&
+				(c[2] == 't' || c[2] == 'T')) {
 			session->command = KVSTORAGE_CMD_GET;
 		}
 		else if ((c[0] == 's' || c[0] == 'S') &&
-			(c[1] == 'e' || c[1] == 'E') &&
-			(c[2] == 't' || c[2] == 'T')) {
+				(c[1] == 'e' || c[1] == 'E') &&
+				(c[2] == 't' || c[2] == 'T')) {
 			session->command = KVSTORAGE_CMD_SET;
 		}
 		else if ((c[0] == 'd' || c[0] == 'D') &&
-			(c[1] == 'e' || c[1] == 'E') &&
-			(c[2] == 'l' || c[2] == 'L')) {
+				(c[1] == 'e' || c[1] == 'E') &&
+				(c[2] == 'l' || c[2] == 'L')) {
 			session->command = KVSTORAGE_CMD_DELETE;
 		}
 		else {
@@ -183,52 +174,51 @@ parse_kvstorage_command (struct kvstorage_session *session, gchar *c, guint len)
 	}
 	else if (len == 4) {
 		if ((c[0] == 'i' || c[0] == 'I')     &&
-			(c[1] == 'n' || c[1] == 'N') &&
-			(c[2] == 'c' || c[2] == 'C') &&
-			(c[3] == 'r' || c[3] == 'R')) {
+				(c[1] == 'n' || c[1] == 'N') &&
+				(c[2] == 'c' || c[2] == 'C') &&
+				(c[3] == 'r' || c[3] == 'R')) {
 			session->command = KVSTORAGE_CMD_INCR;
 			session->arg_data.value = 1;
 		}
 		else if ((c[0] == 'd' || c[0] == 'D') &&
-			(c[1] == 'e' || c[1] == 'E')  &&
-			(c[2] == 'c' || c[2] == 'C')  &&
-			(c[3] == 'r' || c[3] == 'R')) {
+				(c[1] == 'e' || c[1] == 'E')  &&
+				(c[2] == 'c' || c[2] == 'C')  &&
+				(c[3] == 'r' || c[3] == 'R')) {
 			session->command = KVSTORAGE_CMD_DECR;
 			session->arg_data.value = -1;
 		}
 		else if (g_ascii_strncasecmp (c, "quit", 4) == 0) {
 			session->command = KVSTORAGE_CMD_QUIT;
 		}
-		else if (g_ascii_strncasecmp (c, "sync",
-			4) == 0 || g_ascii_strncasecmp (c, "save", 4) == 0) {
+		else if (g_ascii_strncasecmp (c, "sync", 4) == 0 || g_ascii_strncasecmp (c, "save", 4) == 0) {
 			session->command = KVSTORAGE_CMD_SYNC;
 		}
 	}
 	else if (len == 6) {
 		if ((c[0] == 'i' || c[0] == 'I')     &&
-			(c[1] == 'n' || c[1] == 'N') &&
-			(c[2] == 'c' || c[2] == 'C') &&
-			(c[3] == 'r' || c[3] == 'R') &&
-			(c[4] == 'b' || c[4] == 'B') &&
-			(c[5] == 'y' || c[5] == 'Y')) {
+				(c[1] == 'n' || c[1] == 'N') &&
+				(c[2] == 'c' || c[2] == 'C') &&
+				(c[3] == 'r' || c[3] == 'R') &&
+				(c[4] == 'b' || c[4] == 'B') &&
+				(c[5] == 'y' || c[5] == 'Y')) {
 			session->command = KVSTORAGE_CMD_INCR;
 			session->arg_data.value = 1;
 		}
 		else if ((c[0] == 'd' || c[0] == 'D') &&
-			(c[1] == 'e' || c[1] == 'E')  &&
-			(c[2] == 'c' || c[2] == 'C')  &&
-			(c[3] == 'r' || c[3] == 'R')  &&
-			(c[4] == 'b' || c[4] == 'B')  &&
-			(c[5] == 'y' || c[5] == 'Y')) {
+				(c[1] == 'e' || c[1] == 'E')  &&
+				(c[2] == 'c' || c[2] == 'C')  &&
+				(c[3] == 'r' || c[3] == 'R')  &&
+				(c[4] == 'b' || c[4] == 'B')  &&
+				(c[5] == 'y' || c[5] == 'Y')) {
 			session->command = KVSTORAGE_CMD_DECR;
 			session->arg_data.value = -1;
 		}
 		else if ((c[0] == 'd' || c[0] == 'D') &&
-			(c[1] == 'e' || c[1] == 'E')  &&
-			(c[2] == 'l' || c[2] == 'L')  &&
-			(c[3] == 'e' || c[3] == 'E')  &&
-			(c[4] == 't' || c[4] == 'T')  &&
-			(c[5] == 'e' || c[5] == 'E')) {
+				(c[1] == 'e' || c[1] == 'E')  &&
+				(c[2] == 'l' || c[2] == 'L')  &&
+				(c[3] == 'e' || c[3] == 'E')  &&
+				(c[4] == 't' || c[4] == 'T')  &&
+				(c[5] == 'e' || c[5] == 'E')) {
 			session->command = KVSTORAGE_CMD_DELETE;
 		}
 		else if (g_ascii_strncasecmp (c, "select", 6) == 0) {
@@ -248,9 +238,9 @@ parse_kvstorage_command (struct kvstorage_session *session, gchar *c, guint len)
 static gboolean
 parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 {
-	gchar *p, *c, *end;
-	gint state = 0, next_state = 0;
-	gboolean is_redis;
+	gchar								*p, *c, *end;
+	gint								 state = 0, next_state = 0;
+	gboolean							 is_redis;
 
 	p = in->begin;
 	end = in->begin + in->len;
@@ -263,7 +253,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 0:
 			/* At this state we try to read identifier of storage */
 			if (g_ascii_isdigit (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				if (g_ascii_isspace (*p) && p != c) {
@@ -294,7 +284,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 1:
 			/* At this state we parse command */
 			if (g_ascii_isalpha (*p) && p != end) {
-				p++;
+				p ++;
 			}
 			else {
 				if (parse_kvstorage_command (session, c, p - c)) {
@@ -325,21 +315,20 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 2:
 			/* Read and store key */
 			if (!g_ascii_isspace (*p) && end != p) {
-				p++;
+				p ++;
 			}
 			else {
 				if (p == c) {
 					return FALSE;
 				}
 				else {
-					session->key = rspamd_mempool_alloc (session->pool,
-							p - c + 1);
+					session->key = rspamd_mempool_alloc (session->pool, p - c + 1);
 					rspamd_strlcpy (session->key, c, p - c + 1);
 					session->keylen = p - c;
 					/* Now we must select next state based on command */
 					if (session->command == KVSTORAGE_CMD_SET ||
-						session->command == KVSTORAGE_CMD_INCR ||
-						session->command == KVSTORAGE_CMD_DECR) {
+							session->command == KVSTORAGE_CMD_INCR ||
+							session->command == KVSTORAGE_CMD_DECR) {
 						/* Read flags */
 						state = 99;
 						if (is_redis) {
@@ -366,7 +355,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 3:
 			/* Read flags */
 			if (g_ascii_isdigit (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				if (g_ascii_isspace (*p)) {
@@ -388,7 +377,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 4:
 			/* Read exptime */
 			if (g_ascii_isdigit (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				if (g_ascii_isspace (*p)) {
@@ -404,7 +393,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 5:
 			/* Read size or incr/decr values */
 			if (g_ascii_isdigit (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				if (g_ascii_isspace (*p) || p >= end - 1) {
@@ -415,8 +404,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 						if (p != c) {
 							session->arg_data.value = strtoul (c, NULL, 10);
 							if (session->command == KVSTORAGE_CMD_DECR) {
-								session->arg_data.value =
-									-session->arg_data.value;
+								session->arg_data.value = -session->arg_data.value;
 							}
 						}
 						else if (session->command == KVSTORAGE_CMD_INCR) {
@@ -436,7 +424,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 6:
 			/* Read index of storage */
 			if (g_ascii_isdigit (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				if (g_ascii_isspace (*p) || end == p) {
@@ -451,7 +439,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 7:
 			/* Read arguments count */
 			if (g_ascii_isdigit (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				if (g_ascii_isspace (*p) || end == p) {
@@ -469,7 +457,7 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 		case 99:
 			/* Skip spaces state */
 			if (g_ascii_isspace (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				c = p;
@@ -490,44 +478,33 @@ parse_kvstorage_line (struct kvstorage_session *session, f_str_t *in)
 static gboolean
 kvstorage_process_command (struct kvstorage_session *session, gboolean is_redis)
 {
-	gint r;
-	gchar outbuf[BUFSIZ], intbuf[sizeof ("9223372036854775807")];
-	gboolean res;
-	struct rspamd_kv_element *elt;
-	guint eltlen;
-	glong longval;
+	gint								 r;
+	gchar								 outbuf[BUFSIZ], intbuf[sizeof ("9223372036854775807")];
+	gboolean							 res;
+	struct rspamd_kv_element			*elt;
+	guint								 eltlen;
+	glong								 longval;
 
 	if (session->command == KVSTORAGE_CMD_SET) {
 		session->state = KVSTORAGE_STATE_READ_DATA;
-		rspamd_set_dispatcher_policy (session->dispather,
-			BUFFER_CHARACTER,
-			session->arg_data.length);
+		rspamd_set_dispatcher_policy (session->dispather, BUFFER_CHARACTER, session->arg_data.length);
 	}
 	else if (session->command == KVSTORAGE_CMD_GET) {
-		elt = rspamd_kv_storage_lookup (session->cf->storage,
-				session->key,
-				session->keylen,
-				session->now);
+		elt = rspamd_kv_storage_lookup (session->cf->storage, session->key, session->keylen, session->now);
 		if (elt == NULL) {
 			RW_R_UNLOCK (&session->cf->storage->rwlock);
 			if (!is_redis) {
-				return rspamd_dispatcher_write (session->dispather,
-						   ERROR_NOT_FOUND,
-						   sizeof (ERROR_NOT_FOUND) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, ERROR_NOT_FOUND,
+						sizeof (ERROR_NOT_FOUND) - 1, FALSE, TRUE);
 			}
 			else {
 				return rspamd_dispatcher_write (session->dispather, "$-1" CRLF,
-						   sizeof ("$-1" CRLF) - 1, FALSE, TRUE);
+						sizeof ("$-1" CRLF) - 1, FALSE, TRUE);
 			}
 		}
 		else {
 			if (elt->flags & KV_ELT_INTEGER) {
-				eltlen = rspamd_snprintf (intbuf,
-						sizeof (intbuf),
-						"%l",
-						ELT_LONG (elt));
+				eltlen = rspamd_snprintf (intbuf, sizeof (intbuf), "%l", ELT_LONG (elt));
 
 			}
 			else {
@@ -535,43 +512,34 @@ kvstorage_process_command (struct kvstorage_session *session, gboolean is_redis)
 			}
 
 			if (!is_redis) {
-				r = rspamd_snprintf (outbuf,
-						sizeof (outbuf),
-						"VALUE %s %ud %ud" CRLF,
-						ELT_KEY (elt),
-						elt->flags,
-						eltlen);
+				r = rspamd_snprintf (outbuf, sizeof (outbuf), "VALUE %s %ud %ud" CRLF,
+						ELT_KEY (elt), elt->flags, eltlen);
 			}
 			else {
 				r = rspamd_snprintf (outbuf, sizeof (outbuf), "$%ud" CRLF,
 						eltlen);
 			}
 			if (!rspamd_dispatcher_write (session->dispather, outbuf,
-				r, TRUE, FALSE)) {
+					r, TRUE, FALSE)) {
 				RW_R_UNLOCK (&session->cf->storage->rwlock);
 				return FALSE;
 			}
 			if (elt->flags & KV_ELT_INTEGER) {
-				if (!rspamd_dispatcher_write (session->dispather, intbuf,
-					eltlen, TRUE, TRUE)) {
+				if (!rspamd_dispatcher_write (session->dispather, intbuf, eltlen, TRUE, TRUE)) {
 					RW_R_UNLOCK (&session->cf->storage->rwlock);
 					return FALSE;
 				}
 			}
 			else {
-				if (!rspamd_dispatcher_write (session->dispather,
-					ELT_DATA (elt), eltlen, TRUE, TRUE)) {
+				if (!rspamd_dispatcher_write (session->dispather, ELT_DATA(elt), eltlen, TRUE, TRUE)) {
 					RW_R_UNLOCK (&session->cf->storage->rwlock);
 					return FALSE;
 				}
 			}
 			session->elt = elt;
 			if (!is_redis) {
-				res = rspamd_dispatcher_write (session->dispather,
-						CRLF "END" CRLF,
-						sizeof (CRLF "END" CRLF) - 1,
-						FALSE,
-						TRUE);
+				res = rspamd_dispatcher_write (session->dispather, CRLF "END" CRLF,
+						sizeof (CRLF "END" CRLF) - 1, FALSE, TRUE);
 			}
 			else {
 				res = rspamd_dispatcher_write (session->dispather, CRLF,
@@ -585,58 +553,42 @@ kvstorage_process_command (struct kvstorage_session *session, gboolean is_redis)
 		}
 	}
 	else if (session->command == KVSTORAGE_CMD_DELETE) {
-		elt = rspamd_kv_storage_delete (session->cf->storage,
-				session->key,
-				session->keylen);
+		elt = rspamd_kv_storage_delete (session->cf->storage, session->key, session->keylen);
 		if (elt != NULL) {
 			if ((elt->flags & KV_ELT_DIRTY) == 0) {
 				/* Free memory if backend has deleted this element */
 				g_slice_free1 (ELT_SIZE (elt), elt);
 			}
 			if (!is_redis) {
-				return rspamd_dispatcher_write (session->dispather,
-						   "DELETED" CRLF,
-						   sizeof ("DELETED" CRLF) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, "DELETED" CRLF,
+						sizeof ("DELETED" CRLF) - 1, FALSE, TRUE);
 			}
 			else {
 				return rspamd_dispatcher_write (session->dispather, ":1" CRLF,
-						   sizeof (":1" CRLF) - 1, FALSE, TRUE);
+						sizeof (":1" CRLF) - 1, FALSE, TRUE);
 			}
 		}
 		else {
 			if (!is_redis) {
-				return rspamd_dispatcher_write (session->dispather,
-						   ERROR_NOT_FOUND,
-						   sizeof (ERROR_NOT_FOUND) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, ERROR_NOT_FOUND,
+						sizeof (ERROR_NOT_FOUND) - 1, FALSE, TRUE);
 			}
 			else {
 				return rspamd_dispatcher_write (session->dispather, ":0" CRLF,
-						   sizeof (":0" CRLF) - 1, FALSE, TRUE);
+						sizeof (":0" CRLF) - 1, FALSE, TRUE);
 			}
 		}
 	}
-	else if (session->command == KVSTORAGE_CMD_INCR || session->command ==
-		KVSTORAGE_CMD_DECR) {
+	else if (session->command == KVSTORAGE_CMD_INCR || session->command == KVSTORAGE_CMD_DECR) {
 		longval = session->arg_data.value;
-		if (!rspamd_kv_storage_increment (session->cf->storage, session->key,
-			session->keylen, &longval)) {
+		if (!rspamd_kv_storage_increment (session->cf->storage, session->key, session->keylen, &longval)) {
 			if (!is_redis) {
-				return rspamd_dispatcher_write (session->dispather,
-						   ERROR_NOT_FOUND,
-						   sizeof (ERROR_NOT_FOUND) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, ERROR_NOT_FOUND,
+						sizeof (ERROR_NOT_FOUND) - 1, FALSE, TRUE);
 			}
 			else {
-				return rspamd_dispatcher_write (session->dispather,
-						   "-ERR not found" CRLF,
-						   sizeof ("-ERR not found" CRLF) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, "-ERR not found" CRLF,
+						sizeof ("-ERR not found" CRLF) - 1, FALSE, TRUE);
 			}
 		}
 		else {
@@ -649,61 +601,41 @@ kvstorage_process_command (struct kvstorage_session *session, gboolean is_redis)
 						longval);
 			}
 			if (!rspamd_dispatcher_write (session->dispather, outbuf,
-				r, FALSE, FALSE)) {
+					r, FALSE, FALSE)) {
 				return FALSE;
 			}
 		}
 	}
 	else if (session->command == KVSTORAGE_CMD_SYNC) {
-		if (session->cf->storage->backend == NULL ||
-			session->cf->storage->backend->sync_func == NULL) {
+		if (session->cf->storage->backend == NULL || session->cf->storage->backend->sync_func == NULL) {
 			if (!is_redis) {
-				return rspamd_dispatcher_write (session->dispather,
-						   ERROR_COMMON,
-						   sizeof (ERROR_COMMON) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, ERROR_COMMON,
+						sizeof (ERROR_COMMON) - 1, FALSE, TRUE);
 			}
 			else {
-				return rspamd_dispatcher_write (session->dispather,
-						   "-ERR unsupported" CRLF,
-						   sizeof ("-ERR unsupported" CRLF) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, "-ERR unsupported" CRLF,
+						sizeof ("-ERR unsupported" CRLF) - 1, FALSE, TRUE);
 			}
 		}
 		else {
-			if (session->cf->storage->backend->sync_func (session->cf->storage->
-				backend)) {
+			if (session->cf->storage->backend->sync_func (session->cf->storage->backend)) {
 				if (!is_redis) {
-					return rspamd_dispatcher_write (session->dispather,
-							   "SYNCED" CRLF,
-							   sizeof ("SYNCED" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+					return rspamd_dispatcher_write (session->dispather, "SYNCED" CRLF,
+							sizeof ("SYNCED" CRLF) - 1, FALSE, TRUE);
 				}
 				else {
-					return rspamd_dispatcher_write (session->dispather,
-							   "+OK" CRLF,
-							   sizeof ("+OK" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+					return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
+							sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
 				}
 			}
 			else {
 				if (!is_redis) {
-					return rspamd_dispatcher_write (session->dispather,
-							   "NOT_SYNCED" CRLF,
-							   sizeof ("NOT_SYNCED" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+					return rspamd_dispatcher_write (session->dispather, "NOT_SYNCED" CRLF,
+							sizeof ("NOT_SYNCED" CRLF) - 1, FALSE, TRUE);
 				}
 				else {
-					return rspamd_dispatcher_write (session->dispather,
-							   "-ERR not synced" CRLF,
-							   sizeof ("-ERR not synced" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+					return rspamd_dispatcher_write (session->dispather, "-ERR not synced" CRLF,
+							sizeof ("-ERR not synced" CRLF) - 1, FALSE, TRUE);
 				}
 			}
 		}
@@ -711,11 +643,11 @@ kvstorage_process_command (struct kvstorage_session *session, gboolean is_redis)
 	else if (session->command == KVSTORAGE_CMD_SELECT) {
 		if (!is_redis) {
 			return rspamd_dispatcher_write (session->dispather, "SELECTED" CRLF,
-					   sizeof ("SELECTED" CRLF) - 1, FALSE, TRUE);
+					sizeof ("SELECTED" CRLF) - 1, FALSE, TRUE);
 		}
 		else {
 			return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
-					   sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
+					sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
 		}
 	}
 	else if (session->command == KVSTORAGE_CMD_QUIT) {
@@ -730,8 +662,8 @@ kvstorage_process_command (struct kvstorage_session *session, gboolean is_redis)
 static gboolean
 kvstorage_read_arglen (f_str_t *in, guint *len)
 {
-	gchar *p = in->begin, *end = in->begin + in->len, *c;
-	gint state = 0;
+	gchar								*p = in->begin, *end = in->begin + in->len, *c;
+	gint								 state = 0;
 
 	c = p;
 	while (p < end) {
@@ -741,14 +673,14 @@ kvstorage_read_arglen (f_str_t *in, guint *len)
 				return FALSE;
 			}
 			else {
-				p++;
+				p ++;
 				c = p;
 				state = 1;
 			}
 			break;
 		case 1:
 			if (g_ascii_isdigit (*p) && p != end - 1) {
-				p++;
+				p ++;
 			}
 			else {
 				if (p != end - 1) {
@@ -799,12 +731,12 @@ kvstorage_check_argnum (struct kvstorage_session *session)
 static gboolean
 kvstorage_read_socket (f_str_t * in, void *arg)
 {
-	struct kvstorage_session *session = (struct kvstorage_session *) arg;
-	struct kvstorage_worker_thread *thr;
-	gint r;
-	guint arglen = 0;
-	gchar outbuf[BUFSIZ];
-	gboolean is_redis;
+	struct kvstorage_session			*session = (struct kvstorage_session *) arg;
+	struct kvstorage_worker_thread		*thr;
+	gint								 r;
+	guint								 arglen = 0;
+	gchar								 outbuf[BUFSIZ];
+	gboolean							 is_redis;
 
 	if (in->len == 0) {
 		/* Skip empty commands */
@@ -817,22 +749,16 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 	case KVSTORAGE_STATE_READ_CMD:
 		/* Update timestamp */
 		session->now = time (NULL);
-		if (!parse_kvstorage_line (session, in)) {
+		if (! parse_kvstorage_line (session, in)) {
 			thr_info ("%ud: unknown command: %V", thr->id, in);
 			if (!is_redis) {
-				return rspamd_dispatcher_write (session->dispather,
-						   ERROR_UNKNOWN_COMMAND,
-						   sizeof (ERROR_UNKNOWN_COMMAND) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, ERROR_UNKNOWN_COMMAND,
+						sizeof (ERROR_UNKNOWN_COMMAND) - 1, FALSE, TRUE);
 			}
 			else {
-				r = rspamd_snprintf (outbuf,
-						sizeof (outbuf),
-						"-ERR unknown command '%V'" CRLF,
-						in);
+				r = rspamd_snprintf (outbuf, sizeof (outbuf), "-ERR unknown command '%V'" CRLF, in);
 				return rspamd_dispatcher_write (session->dispather, outbuf,
-						   r, FALSE, TRUE);
+								r, FALSE, TRUE);
 			}
 		}
 		else {
@@ -840,18 +766,12 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 			if (session->cf == NULL) {
 				thr_info ("%ud: bad keystorage: %ud", thr->id, session->id);
 				if (!is_redis) {
-					return rspamd_dispatcher_write (session->dispather,
-							   ERROR_INVALID_KEYSTORAGE,
-							   sizeof (ERROR_INVALID_KEYSTORAGE) - 1,
-							   FALSE,
-							   TRUE);
+					return rspamd_dispatcher_write (session->dispather, ERROR_INVALID_KEYSTORAGE,
+						sizeof (ERROR_INVALID_KEYSTORAGE) - 1, FALSE, TRUE);
 				}
 				else {
-					return rspamd_dispatcher_write (session->dispather,
-							   "-ERR unknown keystorage" CRLF,
-							   sizeof ("-ERR unknown keystorage" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+					return rspamd_dispatcher_write (session->dispather, "-ERR unknown keystorage" CRLF,
+						sizeof ("-ERR unknown keystorage" CRLF) - 1, FALSE, TRUE);
 				}
 			}
 			if (session->state != KVSTORAGE_STATE_READ_ARGLEN) {
@@ -860,59 +780,44 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 		}
 		break;
 	case KVSTORAGE_STATE_READ_ARGLEN:
-		if (!kvstorage_read_arglen (in, &arglen)) {
+		if (! kvstorage_read_arglen (in, &arglen)) {
 			session->state = KVSTORAGE_STATE_READ_CMD;
-			r = rspamd_snprintf (outbuf,
-					sizeof (outbuf),
-					"-ERR unknown arglen '%V'" CRLF,
-					in);
+			r = rspamd_snprintf (outbuf, sizeof (outbuf), "-ERR unknown arglen '%V'" CRLF, in);
 			return rspamd_dispatcher_write (session->dispather, outbuf,
-					   r, FALSE, TRUE);
+					r, FALSE, TRUE);
 		}
 		else {
 			session->state = KVSTORAGE_STATE_READ_ARG;
-			rspamd_set_dispatcher_policy (session->dispather,
-				BUFFER_CHARACTER,
-				arglen);
+			rspamd_set_dispatcher_policy (session->dispather, BUFFER_CHARACTER, arglen);
 		}
 		break;
 	case KVSTORAGE_STATE_READ_ARG:
 		if (session->argnum == 0) {
 			/* Read command */
-			if (!parse_kvstorage_command (session, in->begin, in->len)) {
+			if (! parse_kvstorage_command (session, in->begin, in->len)) {
 				session->state = KVSTORAGE_STATE_READ_CMD;
-				r = rspamd_snprintf (outbuf,
-						sizeof (outbuf),
-						"-ERR unknown command '%V'" CRLF,
-						in);
+				r = rspamd_snprintf (outbuf, sizeof (outbuf), "-ERR unknown command '%V'" CRLF, in);
 				return rspamd_dispatcher_write (session->dispather, outbuf,
-						   r, FALSE, TRUE);
+						r, FALSE, TRUE);
 			}
 			else {
-				if (!kvstorage_check_argnum (session)) {
+				if (! kvstorage_check_argnum (session)) {
 					session->state = KVSTORAGE_STATE_READ_CMD;
-					r = rspamd_snprintf (outbuf,
-							sizeof (outbuf),
-							"-ERR invalid argnum for command '%V': %ud" CRLF,
-							in,
-							session->argc);
+					r = rspamd_snprintf (outbuf, sizeof (outbuf), "-ERR invalid argnum for command '%V': %ud" CRLF,
+							in, session->argc);
 					return rspamd_dispatcher_write (session->dispather, outbuf,
-							   r, FALSE, TRUE);
+							r, FALSE, TRUE);
 				}
 				else {
 					if (session->argnum == session->argc - 1) {
 						session->state = KVSTORAGE_STATE_READ_CMD;
-						rspamd_set_dispatcher_policy (session->dispather,
-							BUFFER_LINE,
-							-1);
+						rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
 						return kvstorage_process_command (session, TRUE);
 					}
 					else {
-						session->argnum++;
+						session->argnum ++;
 						session->state = KVSTORAGE_STATE_READ_ARGLEN;
-						rspamd_set_dispatcher_policy (session->dispather,
-							BUFFER_LINE,
-							-1);
+						rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
 					}
 				}
 			}
@@ -924,28 +829,21 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 				session->keylen = in->len;
 				if (session->argnum == session->argc - 1) {
 					session->state = KVSTORAGE_STATE_READ_CMD;
-					rspamd_set_dispatcher_policy (session->dispather,
-						BUFFER_LINE,
-						-1);
+					rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
 					return kvstorage_process_command (session, TRUE);
 				}
 				else {
-					session->argnum++;
+					session->argnum ++;
 					session->state = KVSTORAGE_STATE_READ_ARGLEN;
-					rspamd_set_dispatcher_policy (session->dispather,
-						BUFFER_LINE,
-						-1);
+					rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
 				}
 			}
 			else {
 				/* Special case for select command */
 				session->state = KVSTORAGE_STATE_READ_CMD;
-				rspamd_strlcpy (outbuf, in->begin, MIN (sizeof (outbuf),
-					in->len));
+				rspamd_strlcpy (outbuf, in->begin, MIN (sizeof (outbuf), in->len));
 				session->id = strtoul (outbuf, NULL, 10);
-				rspamd_set_dispatcher_policy (session->dispather,
-					BUFFER_LINE,
-					-1);
+				rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
 				return kvstorage_process_command (session, TRUE);
 			}
 		}
@@ -953,37 +851,25 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 			/* We get datablock for set command */
 			if (session->command == KVSTORAGE_CMD_SET && session->argc == 3) {
 				session->state = KVSTORAGE_STATE_READ_CMD;
-				rspamd_set_dispatcher_policy (session->dispather,
-					BUFFER_LINE,
-					-1);
-				if (rspamd_kv_storage_insert (session->cf->storage,
-					session->key, session->keylen,
-					in->begin, in->len,
-					session->flags, session->expire)) {
-					return rspamd_dispatcher_write (session->dispather,
-							   "+OK" CRLF,
-							   sizeof ("+OK" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+				rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+				if (rspamd_kv_storage_insert (session->cf->storage, session->key, session->keylen,
+						in->begin, in->len,
+						session->flags, session->expire)) {
+					return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
+							sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
 				}
 				else {
-					return rspamd_dispatcher_write (session->dispather,
-							   "-ERR not stored" CRLF,
-							   sizeof ("-ERR not stored" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+					return rspamd_dispatcher_write (session->dispather, "-ERR not stored" CRLF,
+							sizeof ("-ERR not stored" CRLF) - 1, FALSE, TRUE);
 				}
 			}
-			else if (session->command == KVSTORAGE_CMD_SET && session->argc ==
-				4) {
+			else if (session->command == KVSTORAGE_CMD_SET && session->argc == 4) {
 				/* It is expire argument */
 				session->state = KVSTORAGE_STATE_READ_CMD;
 				rspamd_strtol (in->begin, in->len, (glong *)&session->expire);
-				session->argnum++;
+				session->argnum ++;
 				session->state = KVSTORAGE_STATE_READ_ARGLEN;
-				rspamd_set_dispatcher_policy (session->dispather,
-					BUFFER_LINE,
-					-1);
+				rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
 			}
 			else {
 				session->state = KVSTORAGE_STATE_READ_CMD;
@@ -991,9 +877,7 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 				if (session->command == KVSTORAGE_CMD_DECR) {
 					session->arg_data.value = -session->arg_data.value;
 				}
-				rspamd_set_dispatcher_policy (session->dispather,
-					BUFFER_LINE,
-					-1);
+				rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
 				return kvstorage_process_command (session, TRUE);
 			}
 		}
@@ -1001,25 +885,16 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 			/* We get datablock for set command */
 			if (session->command == KVSTORAGE_CMD_SET && session->argc == 4) {
 				session->state = KVSTORAGE_STATE_READ_CMD;
-				rspamd_set_dispatcher_policy (session->dispather,
-					BUFFER_LINE,
-					-1);
-				if (rspamd_kv_storage_insert (session->cf->storage,
-					session->key, session->keylen,
-					in->begin, in->len,
-					session->flags, session->expire)) {
-					return rspamd_dispatcher_write (session->dispather,
-							   "+OK" CRLF,
-							   sizeof ("+OK" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+				rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
+				if (rspamd_kv_storage_insert (session->cf->storage, session->key, session->keylen,
+						in->begin, in->len,
+						session->flags, session->expire)) {
+					return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
+							sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
 				}
 				else {
-					return rspamd_dispatcher_write (session->dispather,
-							   "-ERR not stored" CRLF,
-							   sizeof ("-ERR not stored" CRLF) - 1,
-							   FALSE,
-							   TRUE);
+					return rspamd_dispatcher_write (session->dispather, "-ERR not stored" CRLF,
+							sizeof ("-ERR not stored" CRLF) - 1, FALSE, TRUE);
 				}
 			}
 		}
@@ -1027,36 +902,26 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 	case KVSTORAGE_STATE_READ_DATA:
 		session->state = KVSTORAGE_STATE_READ_CMD;
 		rspamd_set_dispatcher_policy (session->dispather, BUFFER_LINE, -1);
-		if (rspamd_kv_storage_insert (session->cf->storage, session->key,
-			session->keylen,
-			in->begin, in->len,
-			session->flags, session->expire)) {
+		if (rspamd_kv_storage_insert (session->cf->storage, session->key, session->keylen,
+				in->begin, in->len,
+				session->flags, session->expire)) {
 			if (!is_redis) {
-				return rspamd_dispatcher_write (session->dispather,
-						   "STORED" CRLF,
-						   sizeof ("STORED" CRLF) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, "STORED" CRLF,
+						sizeof ("STORED" CRLF) - 1, FALSE, TRUE);
 			}
 			else {
 				return rspamd_dispatcher_write (session->dispather, "+OK" CRLF,
-						   sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
+						sizeof ("+OK" CRLF) - 1, FALSE, TRUE);
 			}
 		}
 		else {
 			if (!is_redis) {
-				return rspamd_dispatcher_write (session->dispather,
-						   ERROR_NOT_STORED,
-						   sizeof (ERROR_NOT_STORED) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, ERROR_NOT_STORED,
+						sizeof (ERROR_NOT_STORED) - 1, FALSE, TRUE);
 			}
 			else {
-				return rspamd_dispatcher_write (session->dispather,
-						   "-ERR not stored" CRLF,
-						   sizeof ("-ERR not stored" CRLF) - 1,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispather, "-ERR not stored" CRLF,
+						sizeof ("-ERR not stored" CRLF) - 1, FALSE, TRUE);
 			}
 		}
 
@@ -1072,18 +937,17 @@ kvstorage_read_socket (f_str_t * in, void *arg)
 static gboolean
 kvstorage_write_socket (void *arg)
 {
-	struct kvstorage_session *session = (struct kvstorage_session *) arg;
+	struct kvstorage_session			*session = (struct kvstorage_session *) arg;
 
 	if (session->elt) {
 		if ((session->elt->flags & KV_ELT_NEED_INSERT) != 0) {
 			/* Insert to cache and free element */
 			session->elt->flags &= ~KV_ELT_NEED_INSERT;
 			RW_R_UNLOCK (&session->cf->storage->rwlock);
-			rspamd_kv_storage_insert_cache (session->cf->storage,
-				ELT_KEY (session->elt),
-				session->elt->keylen, ELT_DATA (session->elt),
-				session->elt->size, session->elt->flags,
-				session->elt->expire, NULL);
+			rspamd_kv_storage_insert_cache (session->cf->storage, ELT_KEY (session->elt),
+							session->elt->keylen, ELT_DATA (session->elt),
+							session->elt->size, session->elt->flags,
+							session->elt->expire, NULL);
 			g_free (session->elt);
 			session->elt = NULL;
 			return TRUE;
@@ -1102,8 +966,8 @@ kvstorage_write_socket (void *arg)
 static void
 kvstorage_err_socket (GError * err, void *arg)
 {
-	struct kvstorage_session *session = (struct kvstorage_session *) arg;
-	struct kvstorage_worker_thread *thr;
+	struct kvstorage_session			*session = (struct kvstorage_session *) arg;
+	struct kvstorage_worker_thread		*thr;
 
 	thr = session->thr;
 	if (err->code != -1) {
@@ -1126,15 +990,14 @@ kvstorage_err_socket (GError * err, void *arg)
 static void
 thr_accept_socket (gint fd, short what, void *arg)
 {
-	struct kvstorage_worker_thread *thr = (struct kvstorage_worker_thread *)arg;
-	union sa_union su;
-	socklen_t addrlen = sizeof (su.ss);
-	gint nfd;
-	struct kvstorage_session *session;
+	struct kvstorage_worker_thread		*thr = (struct kvstorage_worker_thread *)arg;
+	union sa_union                 		 su;
+	socklen_t                       	 addrlen = sizeof (su.ss);
+	gint                            	 nfd;
+	struct kvstorage_session			*session;
 
 	g_mutex_lock (thr->accept_mtx);
-	if ((nfd =
-		accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
+	if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
 		thr_warn ("%ud: accept failed: %s", thr->id, strerror (errno));
 		g_mutex_unlock (thr->accept_mtx);
 		return;
@@ -1151,14 +1014,9 @@ thr_accept_socket (gint fd, short what, void *arg)
 	session->state = KVSTORAGE_STATE_READ_CMD;
 	session->thr = thr;
 	session->sock = nfd;
-	session->dispather = rspamd_create_dispatcher (thr->ev_base,
-			nfd,
-			BUFFER_LINE,
-			kvstorage_read_socket,
-			kvstorage_write_socket,
-			kvstorage_err_socket,
-			thr->tv,
-			session);
+	session->dispather = rspamd_create_dispatcher (thr->ev_base, nfd, BUFFER_LINE,
+			kvstorage_read_socket, kvstorage_write_socket,
+			kvstorage_err_socket, thr->tv, session);
 
 	g_mutex_unlock (thr->accept_mtx);
 	session->elt = NULL;
@@ -1168,7 +1026,7 @@ thr_accept_socket (gint fd, short what, void *arg)
 	}
 	else if (su.ss.ss_family == AF_INET) {
 		memcpy (&session->client_addr, &su.s4.sin_addr,
-			sizeof (struct in_addr));
+						sizeof (struct in_addr));
 	}
 }
 
@@ -1178,8 +1036,8 @@ thr_accept_socket (gint fd, short what, void *arg)
 static void
 thr_term_socket (gint fd, short what, void *arg)
 {
-	struct kvstorage_worker_thread *thr = (struct kvstorage_worker_thread *)arg;
-	struct timeval tv;
+	struct kvstorage_worker_thread		*thr = (struct kvstorage_worker_thread *)arg;
+	struct timeval						 tv;
 
 	if (read (fd, &tv, sizeof (struct timeval)) != sizeof (struct timeval)) {
 		thr_err ("cannot read data from socket: %s", strerror (errno));
@@ -1197,26 +1055,18 @@ thr_term_socket (gint fd, short what, void *arg)
 static gpointer
 kvstorage_thread (gpointer ud)
 {
-	struct kvstorage_worker_thread *thr = ud;
+	struct kvstorage_worker_thread		*thr = ud;
 
 	/* Block signals as it is dispatcher deity */
 	sigprocmask (SIG_BLOCK, thr->signals, NULL);
 	/* Init thread specific events */
 	thr->ev_base = event_init ();
 
-	event_set (&thr->bind_ev,
-		thr->worker->cf->listen_sock,
-		EV_READ | EV_PERSIST,
-		thr_accept_socket,
-		(void *)thr);
+	event_set (&thr->bind_ev, thr->worker->cf->listen_sock, EV_READ | EV_PERSIST, thr_accept_socket, (void *)thr);
 	event_base_set (thr->ev_base, &thr->bind_ev);
 	event_add (&thr->bind_ev, NULL);
 
-	event_set (&thr->term_ev,
-		thr->term_sock[0],
-		EV_READ | EV_PERSIST,
-		thr_term_socket,
-		(void *)thr);
+	event_set (&thr->term_ev, thr->term_sock[0], EV_READ | EV_PERSIST, thr_term_socket, (void *)thr);
 	event_base_set (thr->ev_base, &thr->term_ev);
 	event_add (&thr->term_ev, NULL);
 
@@ -1229,17 +1079,12 @@ kvstorage_thread (gpointer ud)
  * Create new thread, set it detached
  */
 static struct kvstorage_worker_thread *
-create_kvstorage_thread (struct rspamd_worker *worker,
-	struct kvstorage_worker_ctx *ctx,
-	guint id,
-	sigset_t *signals)
+create_kvstorage_thread (struct rspamd_worker *worker, struct kvstorage_worker_ctx *ctx, guint id, sigset_t *signals)
 {
-	struct kvstorage_worker_thread *new;
-	GError *err = NULL;
+	struct kvstorage_worker_thread 		*new;
+	GError								*err = NULL;
 
-	new =
-		rspamd_mempool_alloc (ctx->pool,
-			sizeof (struct kvstorage_worker_thread));
+	new = rspamd_mempool_alloc (ctx->pool, sizeof (struct kvstorage_worker_thread));
 	new->ctx = ctx;
 	new->worker = worker;
 	new->tv = &ctx->io_timeout;
@@ -1257,14 +1102,10 @@ create_kvstorage_thread (struct rspamd_worker *worker,
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
 	new->thr = g_thread_create (kvstorage_thread, new, FALSE, &err);
 #else
-	gchar *name;
+	gchar								*name;
 
-	name = rspamd_mempool_alloc (ctx->pool,
-			sizeof ("kvstorage_thread") + sizeof ("4294967296") - 1);
-	rspamd_snprintf (name,
-		sizeof ("kvstorage_thread") + sizeof ("4294967296") - 1,
-		"kvstorage_thread%d",
-		id);
+	name = rspamd_mempool_alloc (ctx->pool, sizeof ("kvstorage_thread") + sizeof ("4294967296") - 1);
+	rspamd_snprintf (name, sizeof ("kvstorage_thread") + sizeof ("4294967296") - 1, "kvstorage_thread%d", id);
 
 	new->thr = g_thread_new (name, kvstorage_thread, new);
 #endif
@@ -1284,18 +1125,17 @@ create_kvstorage_thread (struct rspamd_worker *worker,
 void
 start_keystorage (struct rspamd_worker *worker)
 {
-	struct sigaction signals;
-	struct kvstorage_worker_ctx *ctx = worker->ctx;
-	guint i;
-	struct kvstorage_worker_thread *thr;
-	struct timeval tv;
-	GList *cur;
+	struct sigaction                	 signals;
+	struct kvstorage_worker_ctx         *ctx = worker->ctx;
+	guint								 i;
+	struct kvstorage_worker_thread 		*thr;
+	struct timeval						 tv;
+	GList								*cur;
 
 	gperf_profiler_init (worker->srv->cfg, "kvstorage");
 
 	if (!g_thread_supported ()) {
-		msg_err (
-			"threads support is not supported on your system so kvstorage is not functionable");
+		msg_err ("threads support is not supported on your system so kvstorage is not functionable");
 		exit (EXIT_SUCCESS);
 	}
 	/* Create socketpair */
@@ -1308,8 +1148,7 @@ start_keystorage (struct rspamd_worker *worker)
 
 #if _EVENT_NUMERIC_VERSION > 0x02000000
 	if (evthread_use_pthreads () == -1) {
-		msg_err (
-			"threads support is not supported in your libevent so kvstorage is not functionable");
+		msg_err ("threads support is not supported in your libevent so kvstorage is not functionable");
 		exit (EXIT_SUCCESS);
 	}
 #endif
@@ -1337,7 +1176,7 @@ start_keystorage (struct rspamd_worker *worker)
 #endif
 
 	/* Start workers threads */
-	for (i = 0; i < worker->cf->count; i++) {
+	for (i = 0; i < worker->cf->count; i ++) {
 		thr = create_kvstorage_thread (worker, ctx, i, &signals.sa_mask);
 		if (thr != NULL) {
 			ctx->threads = g_list_prepend (ctx->threads, thr);
@@ -1346,7 +1185,7 @@ start_keystorage (struct rspamd_worker *worker)
 
 	sigprocmask (SIG_BLOCK, &signals.sa_mask, NULL);
 	/* Signal processing cycle */
-	for (;; ) {
+	for (;;) {
 		msg_debug ("calling sigsuspend");
 		sigemptyset (&signals.sa_mask);
 		sigsuspend (&signals.sa_mask);
@@ -1358,11 +1197,9 @@ start_keystorage (struct rspamd_worker *worker)
 			cur = ctx->threads;
 			while (cur) {
 				thr = cur->data;
-				while (write (thr->term_sock[1], &tv,
-					sizeof (struct timeval)) == -1) {
+				while (write (thr->term_sock[1], &tv, sizeof (struct timeval)) == -1) {
 					if (errno != EAGAIN) {
-						msg_err ("write to term socket failed: %s",
-							strerror (errno));
+						msg_err ("write to term socket failed: %s", strerror (errno));
 						abort ();
 					}
 				}
@@ -1374,16 +1211,13 @@ start_keystorage (struct rspamd_worker *worker)
 			soft_wanna_die = 0;
 			tv.tv_sec = SOFT_SHUTDOWN_TIME;
 			tv.tv_usec = 0;
-			msg_info ("worker's shutdown is pending in %d sec",
-				SOFT_SHUTDOWN_TIME);
+			msg_info ("worker's shutdown is pending in %d sec", SOFT_SHUTDOWN_TIME);
 			cur = ctx->threads;
 			while (cur) {
 				thr = cur->data;
-				while (write (thr->term_sock[1], &tv,
-					sizeof (struct timeval)) == -1) {
+				while (write (thr->term_sock[1], &tv, sizeof (struct timeval)) == -1) {
 					if (errno != EAGAIN) {
-						msg_err ("write to term socket failed: %s",
-							strerror (errno));
+						msg_err ("write to term socket failed: %s", strerror (errno));
 						abort ();
 					}
 				}
diff --git a/src/kvstorage_server.h b/src/kvstorage_server.h
index c5752ed86..7af9d79ba 100644
--- a/src/kvstorage_server.h
+++ b/src/kvstorage_server.h
@@ -25,9 +25,9 @@
 #ifndef KVSTORAGE_SERVER_H_
 #define KVSTORAGE_SERVER_H_
 
-#include "buffer.h"
 #include "config.h"
 #include "mem_pool.h"
+#include "buffer.h"
 
 /* Configuration context for kvstorage worker */
 struct kvstorage_worker_ctx {
diff --git a/src/kvstorage_sqlite.c b/src/kvstorage_sqlite.c
index a18185849..7a3a25fcf 100644
--- a/src/kvstorage_sqlite.c
+++ b/src/kvstorage_sqlite.c
@@ -25,15 +25,13 @@
 #include "config.h"
 #include "kvstorage.h"
 #include "kvstorage_sqlite.h"
-#include "main.h"
 #include "util.h"
+#include "main.h"
 #include <sqlite3.h>
 
 #define TABLE_NAME "kvstorage"
-#define CREATE_TABLE_SQL "CREATE TABLE " TABLE_NAME \
-	" (key TEXT CONSTRAINT _key PRIMARY KEY, data BLOB)"
-#define SET_SQL "INSERT OR REPLACE INTO " TABLE_NAME \
-	" (key, data) VALUES (?1, ?2)"
+#define CREATE_TABLE_SQL "CREATE TABLE " TABLE_NAME " (key TEXT CONSTRAINT _key PRIMARY KEY, data BLOB)"
+#define SET_SQL "INSERT OR REPLACE INTO " TABLE_NAME " (key, data) VALUES (?1, ?2)"
 #define GET_SQL "SELECT data FROM " TABLE_NAME " WHERE key = ?1"
 #define DELETE_SQL "DELETE FROM " TABLE_NAME " WHERE key = ?1"
 
@@ -48,13 +46,13 @@ struct sqlite_op {
 
 /* Main sqlite structure */
 struct rspamd_sqlite_backend {
-	backend_init init_func;                     /*< this callback is called on kv storage initialization */
-	backend_insert insert_func;                 /*< this callback is called when element is inserted */
-	backend_replace replace_func;               /*< this callback is called when element is replaced */
-	backend_lookup lookup_func;                 /*< this callback is used for lookup of element */
-	backend_delete delete_func;                 /*< this callback is called when an element is deleted */
-	backend_sync sync_func;                     /*< this callback is called when backend need to be synced */
-	backend_destroy destroy_func;               /*< this callback is used for destroying all elements inside backend */
+	backend_init init_func;						/*< this callback is called on kv storage initialization */
+	backend_insert insert_func;					/*< this callback is called when element is inserted */
+	backend_replace replace_func;				/*< this callback is called when element is replaced */
+	backend_lookup lookup_func;					/*< this callback is used for lookup of element */
+	backend_delete delete_func;					/*< this callback is called when an element is deleted */
+	backend_sync sync_func;						/*< this callback is called when backend need to be synced */
+	backend_destroy destroy_func;				/*< this callback is used for destroying all elements inside backend */
 	sqlite3 *dbp;
 	gchar *filename;
 	gchar *dirname;
@@ -69,19 +67,16 @@ struct rspamd_sqlite_backend {
 
 /* Process single sqlite operation */
 static gboolean
-sqlite_process_single_op (struct rspamd_sqlite_backend *db,
-	struct sqlite_op *op)
+sqlite_process_single_op (struct rspamd_sqlite_backend *db, struct sqlite_op *op)
 {
-	gboolean res = FALSE;
+	gboolean									 res = FALSE;
 
 	op->elt->flags &= ~KV_ELT_DIRTY;
 	switch (op->op) {
 	case SQLITE_OP_INSERT:
 	case SQLITE_OP_REPLACE:
-		if (sqlite3_bind_text (db->set_stmt, 1, ELT_KEY (op->elt),
-			op->elt->keylen, SQLITE_STATIC) == SQLITE_OK &&
-			sqlite3_bind_blob (db->set_stmt, 2, op->elt, ELT_SIZE (op->elt),
-			SQLITE_STATIC) == SQLITE_OK) {
+		if (sqlite3_bind_text (db->set_stmt, 1, ELT_KEY (op->elt), op->elt->keylen, SQLITE_STATIC) == SQLITE_OK &&
+				sqlite3_bind_blob (db->set_stmt, 2, op->elt, ELT_SIZE (op->elt), SQLITE_STATIC) == SQLITE_OK) {
 			if (sqlite3_step (db->set_stmt) == SQLITE_DONE) {
 				res = TRUE;
 			}
@@ -89,8 +84,7 @@ sqlite_process_single_op (struct rspamd_sqlite_backend *db,
 		sqlite3_reset (db->set_stmt);
 		break;
 	case SQLITE_OP_DELETE:
-		if (sqlite3_bind_text (db->delete_stmt, 1, ELT_KEY (op->elt),
-			op->elt->keylen, SQLITE_STATIC) == SQLITE_OK) {
+		if (sqlite3_bind_text (db->delete_stmt, 1, ELT_KEY (op->elt), op->elt->keylen, SQLITE_STATIC) == SQLITE_OK) {
 			if (sqlite3_step (db->delete_stmt) == SQLITE_DONE) {
 				res = TRUE;
 			}
@@ -109,14 +103,14 @@ sqlite_process_single_op (struct rspamd_sqlite_backend *db,
 static gboolean
 sqlite_process_queue (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
-	struct sqlite_op *op;
-	GList *cur;
+	struct rspamd_sqlite_backend				*db = (struct rspamd_sqlite_backend *)backend;
+	struct sqlite_op							*op;
+	GList										*cur;
 
 	cur = db->ops_queue->head;
 	while (cur) {
 		op = cur->data;
-		if (!sqlite_process_single_op (db, op)) {
+		if (! sqlite_process_single_op (db, op)) {
 			return FALSE;
 		}
 		cur = g_list_next (cur);
@@ -126,8 +120,7 @@ sqlite_process_queue (struct rspamd_kv_backend *backend)
 	cur = db->ops_queue->head;
 	while (cur) {
 		op = cur->data;
-		if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
-			0) {
+		if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
 			/* Also clean memory */
 			g_slice_free1 (ELT_SIZE (op->elt), op->elt);
 		}
@@ -146,15 +139,10 @@ sqlite_process_queue (struct rspamd_kv_backend *backend)
 static gboolean
 rspamd_sqlite_create_table (struct rspamd_sqlite_backend *db)
 {
-	gint ret;
-	sqlite3_stmt *stmt = NULL;
-
-	ret =
-		sqlite3_prepare_v2 (db->dbp,
-			CREATE_TABLE_SQL,
-			sizeof (CREATE_TABLE_SQL) - 1,
-			&stmt,
-			NULL);
+	gint										 ret;
+	sqlite3_stmt								*stmt = NULL;
+
+	ret = sqlite3_prepare_v2 (db->dbp, CREATE_TABLE_SQL, sizeof (CREATE_TABLE_SQL) - 1, &stmt, NULL);
 	if (ret != SQLITE_OK) {
 		if (stmt != NULL) {
 			sqlite3_finalize (stmt);
@@ -176,11 +164,11 @@ rspamd_sqlite_create_table (struct rspamd_sqlite_backend *db)
 static void
 rspamd_sqlite_init (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
-	guint32 flags;
-	gint ret, r;
-	gchar sqlbuf[BUFSIZ];
-	sqlite3_stmt *stmt = NULL;
+	struct rspamd_sqlite_backend				*db = (struct rspamd_sqlite_backend *)backend;
+	guint32										 flags;
+	gint										 ret, r;
+	gchar										 sqlbuf[BUFSIZ];
+	sqlite3_stmt								*stmt = NULL;
 
 	/* Set multi-threaded mode */
 	if (sqlite3_config (SQLITE_CONFIG_MULTITHREAD) != SQLITE_OK) {
@@ -188,8 +176,8 @@ rspamd_sqlite_init (struct rspamd_kv_backend *backend)
 	}
 
 	flags = SQLITE_OPEN_READWRITE |
-		SQLITE_OPEN_CREATE |
-		SQLITE_OPEN_NOMUTEX;
+			SQLITE_OPEN_CREATE    |
+			SQLITE_OPEN_NOMUTEX;
 
 	ret = sqlite3_open_v2 (db->filename, &db->dbp, flags, NULL);
 
@@ -197,9 +185,7 @@ rspamd_sqlite_init (struct rspamd_kv_backend *backend)
 		goto err;
 	}
 	/* Now check if we have table */
-	r = rspamd_snprintf (sqlbuf,
-			sizeof (sqlbuf),
-			"SELECT * FROM " TABLE_NAME " LIMIT 1");
+	r = rspamd_snprintf (sqlbuf, sizeof (sqlbuf), "SELECT * FROM " TABLE_NAME " LIMIT 1");
 	ret = sqlite3_prepare_v2 (db->dbp, sqlbuf, r, &stmt, NULL);
 
 	if (ret == SQLITE_ERROR) {
@@ -223,27 +209,15 @@ rspamd_sqlite_init (struct rspamd_kv_backend *backend)
 	sqlite3_finalize (stmt);
 
 	/* Prepare required statements */
-	ret = sqlite3_prepare_v2 (db->dbp,
-			GET_SQL,
-			sizeof (GET_SQL) - 1,
-			&db->get_stmt,
-			NULL);
+	ret = sqlite3_prepare_v2 (db->dbp, GET_SQL, sizeof (GET_SQL) - 1, &db->get_stmt, NULL);
 	if (ret != SQLITE_OK) {
 		goto err;
 	}
-	ret = sqlite3_prepare_v2 (db->dbp,
-			SET_SQL,
-			sizeof (SET_SQL) - 1,
-			&db->set_stmt,
-			NULL);
+	ret = sqlite3_prepare_v2 (db->dbp, SET_SQL, sizeof (SET_SQL) - 1, &db->set_stmt, NULL);
 	if (ret != SQLITE_OK) {
 		goto err;
 	}
-	ret = sqlite3_prepare_v2 (db->dbp,
-			DELETE_SQL,
-			sizeof (DELETE_SQL) - 1,
-			&db->delete_stmt,
-			NULL);
+	ret = sqlite3_prepare_v2 (db->dbp, DELETE_SQL, sizeof (DELETE_SQL) - 1, &db->delete_stmt, NULL);
 	if (ret != SQLITE_OK) {
 		goto err;
 	}
@@ -271,14 +245,11 @@ err:
 }
 
 static gboolean
-rspamd_sqlite_insert (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_sqlite_insert (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
-	struct sqlite_op *op;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_sqlite_backend				*db = (struct rspamd_sqlite_backend *)backend;
+	struct sqlite_op							*op;
+	struct rspamd_kv_element			 		 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -289,8 +260,7 @@ rspamd_sqlite_insert (struct rspamd_kv_backend *backend,
 
 	if ((op = g_hash_table_lookup (db->ops_hash, &search_elt)) != NULL) {
 		/* We found another op with such key in this queue */
-		if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
-			0) {
+		if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
 			/* Also clean memory */
 			g_slice_free1 (ELT_SIZE (op->elt), op->elt);
 		}
@@ -307,8 +277,7 @@ rspamd_sqlite_insert (struct rspamd_kv_backend *backend,
 		g_hash_table_insert (db->ops_hash, elt, op);
 	}
 
-	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
-		db->sync_ops) {
+	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
 		return sqlite_process_queue (backend);
 	}
 
@@ -316,21 +285,17 @@ rspamd_sqlite_insert (struct rspamd_kv_backend *backend,
 }
 
 static gboolean
-rspamd_sqlite_replace (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen,
-	struct rspamd_kv_element *elt)
+rspamd_sqlite_replace (struct rspamd_kv_backend *backend, gpointer key, guint keylen, struct rspamd_kv_element *elt)
 {
-	struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
-	struct sqlite_op *op;
+	struct rspamd_sqlite_backend				*db = (struct rspamd_sqlite_backend *)backend;
+	struct sqlite_op							*op;
 
 	if (!db->initialized) {
 		return FALSE;
 	}
 	if ((op = g_hash_table_lookup (db->ops_hash, elt)) != NULL) {
 		/* We found another op with such key in this queue */
-		if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) !=
-			0) {
+		if (op->op == SQLITE_OP_DELETE || (op->elt->flags & KV_ELT_NEED_FREE) != 0) {
 			/* Also clean memory */
 			g_slice_free1 (ELT_SIZE (op->elt), op->elt);
 		}
@@ -347,25 +312,22 @@ rspamd_sqlite_replace (struct rspamd_kv_backend *backend,
 		g_hash_table_insert (db->ops_hash, elt, op);
 	}
 
-	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
-		db->sync_ops) {
+	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
 		return sqlite_process_queue (backend);
 	}
 
 	return TRUE;
 }
 
-static struct rspamd_kv_element *
-rspamd_sqlite_lookup (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen)
+static struct rspamd_kv_element*
+rspamd_sqlite_lookup (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
 {
-	struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
-	struct sqlite_op *op;
-	struct rspamd_kv_element *elt = NULL;
-	gint l;
-	gconstpointer d;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_sqlite_backend				*db = (struct rspamd_sqlite_backend *)backend;
+	struct sqlite_op							*op;
+	struct rspamd_kv_element					*elt = NULL;
+	gint										 l;
+	gconstpointer								 d;
+	struct rspamd_kv_element			 		 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -382,8 +344,7 @@ rspamd_sqlite_lookup (struct rspamd_kv_backend *backend,
 		return op->elt;
 	}
 
-	if (sqlite3_bind_text (db->get_stmt, 1, key, keylen,
-		SQLITE_STATIC) == SQLITE_OK) {
+	if (sqlite3_bind_text (db->get_stmt, 1, key, keylen, SQLITE_STATIC) == SQLITE_OK) {
 		if (sqlite3_step (db->get_stmt) == SQLITE_ROW) {
 			l = sqlite3_column_bytes (db->get_stmt, 0);
 			elt = g_malloc (l);
@@ -398,14 +359,12 @@ rspamd_sqlite_lookup (struct rspamd_kv_backend *backend,
 }
 
 static void
-rspamd_sqlite_delete (struct rspamd_kv_backend *backend,
-	gpointer key,
-	guint keylen)
+rspamd_sqlite_delete (struct rspamd_kv_backend *backend, gpointer key, guint keylen)
 {
-	struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
-	struct sqlite_op *op;
-	struct rspamd_kv_element *elt;
-	struct rspamd_kv_element search_elt;
+	struct rspamd_sqlite_backend				*db = (struct rspamd_sqlite_backend *)backend;
+	struct sqlite_op							*op;
+	struct rspamd_kv_element					*elt;
+	struct rspamd_kv_element			 		 search_elt;
 
 	search_elt.keylen = keylen;
 	search_elt.p = key;
@@ -431,8 +390,7 @@ rspamd_sqlite_delete (struct rspamd_kv_backend *backend,
 	g_queue_push_head (db->ops_queue, op);
 	g_hash_table_insert (db->ops_hash, elt, op);
 
-	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >=
-		db->sync_ops) {
+	if (db->sync_ops > 0 && g_queue_get_length (db->ops_queue) >= db->sync_ops) {
 		sqlite_process_queue (backend);
 	}
 
@@ -442,7 +400,7 @@ rspamd_sqlite_delete (struct rspamd_kv_backend *backend,
 static void
 rspamd_sqlite_destroy (struct rspamd_kv_backend *backend)
 {
-	struct rspamd_sqlite_backend *db = (struct rspamd_sqlite_backend *)backend;
+	struct rspamd_sqlite_backend				*db = (struct rspamd_sqlite_backend *)backend;
 
 	if (db->initialized) {
 		sqlite_process_queue (backend);
@@ -468,9 +426,9 @@ rspamd_sqlite_destroy (struct rspamd_kv_backend *backend)
 struct rspamd_kv_backend *
 rspamd_kv_sqlite_new (const gchar *filename, guint sync_ops)
 {
-	struct rspamd_sqlite_backend *new;
-	struct stat st;
-	gchar *dirname;
+	struct rspamd_sqlite_backend			 	*new;
+	struct stat 								 st;
+	gchar										*dirname;
 
 	if (filename == NULL) {
 		return NULL;
diff --git a/src/kvstorage_sqlite.h b/src/kvstorage_sqlite.h
index 0ed0fd1ea..cea14df26 100644
--- a/src/kvstorage_sqlite.h
+++ b/src/kvstorage_sqlite.h
@@ -31,8 +31,7 @@
 #ifdef WITH_SQLITE
 
 /* Create new sqlite backend */
-struct rspamd_kv_backend * rspamd_kv_sqlite_new (const gchar *filename,
-	guint sync_ops);
+struct rspamd_kv_backend* rspamd_kv_sqlite_new (const gchar *filename, guint sync_ops);
 
 #endif
 
diff --git a/src/legacy_controller.c b/src/legacy_controller.c
index 725bd0bb2..05b1794cd 100644
--- a/src/legacy_controller.c
+++ b/src/legacy_controller.c
@@ -22,22 +22,22 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "binlog.h"
-#include "cfg_file.h"
-#include "classifiers/classifiers.h"
 #include "config.h"
-#include "dns.h"
-#include "dynamic_cfg.h"
-#include "lua/lua_common.h"
+#include "util.h"
 #include "main.h"
-#include "map.h"
 #include "message.h"
 #include "protocol.h"
-#include "rrd.h"
-#include "statfile_sync.h"
-#include "tokenizers/tokenizers.h"
 #include "upstream.h"
-#include "util.h"
+#include "cfg_file.h"
+#include "map.h"
+#include "dns.h"
+#include "tokenizers/tokenizers.h"
+#include "classifiers/classifiers.h"
+#include "binlog.h"
+#include "statfile_sync.h"
+#include "lua/lua_common.h"
+#include "dynamic_cfg.h"
+#include "rrd.h"
 
 #define END "END" CRLF
 
@@ -53,14 +53,14 @@ gpointer init_controller (struct rspamd_config *cfg);
 void start_controller (struct rspamd_worker *worker);
 
 worker_t controller_worker = {
-	"controller",               /* Name */
-	init_controller,            /* Init function */
-	start_controller,           /* Start function */
-	TRUE,                       /* Has socket */
-	FALSE,                      /* Non unique */
-	FALSE,                      /* Non threaded */
-	TRUE,                       /* Killable */
-	SOCK_STREAM                 /* TCP socket */
+	"controller",				/* Name */
+	init_controller,			/* Init function */
+	start_controller,			/* Start function */
+	TRUE,						/* Has socket */
+	FALSE,						/* Non unique */
+	FALSE,						/* Non threaded */
+	TRUE,						/* Killable */
+	SOCK_STREAM					/* TCP socket */
 };
 
 enum command_type {
@@ -85,26 +85,26 @@ enum command_type {
 };
 
 struct controller_command {
-	gchar *command;
-	gboolean privilleged;
-	enum command_type type;
+	gchar                           *command;
+	gboolean                        privilleged;
+	enum command_type               type;
 };
 
 struct custom_controller_command {
-	const gchar *command;
-	gboolean privilleged;
-	gboolean require_message;
-	controller_func_t handler;
+	const gchar                     *command;
+	gboolean                        privilleged;
+	gboolean                        require_message;
+	controller_func_t               handler;
 };
 
 struct rspamd_controller_ctx {
-	char *password;
-	guint32 timeout;
-	struct rspamd_dns_resolver *resolver;
-	struct event_base *ev_base;
-	struct event rrd_event;
-	struct rspamd_rrd_file *rrd_file;
-	struct rspamd_main *srv;
+	char 						   *password;
+	guint32							timeout;
+	struct rspamd_dns_resolver     *resolver;
+	struct event_base              *ev_base;
+	struct event				    rrd_event;
+	struct rspamd_rrd_file         *rrd_file;
+	struct rspamd_main			   *srv;
 };
 
 static struct controller_command commands[] = {
@@ -128,20 +128,20 @@ static struct controller_command commands[] = {
 	{"add_action", TRUE, COMMAND_ADD_ACTION}
 };
 
-static GList *custom_commands = NULL;
+static GList                   *custom_commands = NULL;
 
-static time_t start_time;
+static time_t                   start_time;
 
-static gchar greetingbuf[1024];
+static gchar                    greetingbuf[1024];
 
-static gboolean controller_write_socket (void *arg);
+static gboolean                 controller_write_socket (void *arg);
 
 static void
 free_session (void *ud)
 {
-	GList *part;
-	struct mime_part *p;
-	struct controller_session *session = ud;
+	GList                          *part;
+	struct mime_part               *p;
+	struct controller_session      *session = ud;
 
 	msg_debug ("freeing session %p", session);
 
@@ -165,19 +165,16 @@ free_session (void *ud)
 
 static gboolean
 restful_write_reply (gint error_code, const gchar *err_message,
-	const gchar *buf, gsize buflen, rspamd_io_dispatcher_t *d)
+		const gchar *buf, gsize buflen, rspamd_io_dispatcher_t *d)
 {
-	static gchar hbuf[256];
-	gint r;
+	static gchar					 hbuf[256];
+	gint							 r;
 
 	r = rspamd_snprintf (hbuf, sizeof (hbuf),
 			"HTTP/1.0 %d %s" CRLF "Version: " RVERSION CRLF,
 			error_code, err_message ? err_message : "OK");
 	if (buflen > 0) {
-		r += rspamd_snprintf (hbuf + r,
-				sizeof (hbuf) - r,
-				"Content-Length: %z" CRLF,
-				buflen);
+		r += rspamd_snprintf (hbuf + r, sizeof (hbuf) - r, "Content-Length: %z" CRLF, buflen);
 	}
 	r += rspamd_snprintf (hbuf + r, sizeof (hbuf) - r, CRLF);
 
@@ -198,19 +195,16 @@ restful_write_reply (gint error_code, const gchar *err_message,
 
 static gboolean
 restful_write_reply_string (gint error_code, const gchar *err_message,
-	GString *buf, rspamd_io_dispatcher_t *d)
+		GString *buf, rspamd_io_dispatcher_t *d)
 {
-	static gchar hbuf[256];
-	gint r;
+	static gchar					 hbuf[256];
+	gint							 r;
 
 	r = rspamd_snprintf (hbuf, sizeof (hbuf),
 			"HTTP/1.0 %d %s" CRLF "Version: " RVERSION CRLF,
 			error_code, err_message ? err_message : "OK");
 	if (buf->len > 0) {
-		r += rspamd_snprintf (hbuf + r,
-				sizeof (hbuf) - r,
-				"Content-Length: %z" CRLF,
-				buf->len);
+		r += rspamd_snprintf (hbuf + r, sizeof (hbuf) - r, "Content-Length: %z" CRLF, buf->len);
 	}
 	r += rspamd_snprintf (hbuf + r, sizeof (hbuf) - r, CRLF);
 
@@ -232,25 +226,18 @@ restful_write_reply_string (gint error_code, const gchar *err_message,
 static gint
 check_auth (struct controller_command *cmd, struct controller_session *session)
 {
-	gchar out_buf[128];
-	gint r;
+	gchar                           out_buf[128];
+	gint                            r;
 
 	if (cmd->privilleged && !session->authorized) {
 		if (!session->restful) {
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"not authorized" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "not authorized" CRLF);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return 0;
 			}
 		}
 		else {
-			(void)restful_write_reply (403,
-				"Not authorized",
-				NULL,
-				0,
-				session->dispatcher);
+			(void)restful_write_reply (403, "Not authorized", NULL, 0, session->dispatcher);
 		}
 		return 0;
 	}
@@ -259,21 +246,19 @@ check_auth (struct controller_command *cmd, struct controller_session *session)
 }
 
 static gboolean
-write_whole_statfile (struct controller_session *session,
-	gchar *symbol,
-	struct rspamd_classifier_config *ccf)
+write_whole_statfile (struct controller_session *session, gchar *symbol, struct rspamd_classifier_config *ccf)
 {
-	stat_file_t *statfile;
-	struct rspamd_statfile_config *st;
-	gchar out_buf[BUFSIZ];
-	guint i;
-	guint64 rev, ti, len, pos, blocks;
-	gchar *out;
-	struct rspamd_binlog_element log_elt;
-	struct stat_file_block *stat_elt;
+	stat_file_t                    *statfile;
+	struct rspamd_statfile_config                *st;
+	gchar                           out_buf[BUFSIZ];
+	guint                           i;
+	guint64                         rev, ti, len, pos, blocks;
+	gchar                           *out;
+	struct rspamd_binlog_element    log_elt;
+	struct stat_file_block         *stat_elt;
 
 	statfile = get_statfile_by_symbol (session->worker->srv->statfile_pool, ccf,
-			symbol, &st, FALSE);
+						symbol, &st, FALSE);
 	if (statfile == NULL) {
 		return FALSE;
 	}
@@ -285,17 +270,14 @@ write_whole_statfile (struct controller_session *session,
 		ti = time (NULL);
 		statfile_set_revision (statfile, rev, ti);
 	}
-	msg_info ("send a whole statfile %s with version %uL to slave", symbol,
-		rev);
+	msg_info ("send a whole statfile %s with version %uL to slave", symbol, rev);
 
 	blocks = statfile_get_total_blocks (statfile);
 	len = blocks * sizeof (struct rspamd_binlog_element);
 	out = rspamd_mempool_alloc (session->session_pool, len);
 
-	for (i = 0, pos = 0; i < blocks; i++) {
-		stat_elt =
-			(struct stat_file_block *)((u_char *)statfile->map +
-			statfile->seek_pos + i * sizeof (struct stat_file_block));
+	for (i = 0, pos = 0; i < blocks; i ++) {
+		stat_elt = (struct stat_file_block *)((u_char *)statfile->map + statfile->seek_pos + i * sizeof (struct stat_file_block));
 		if (fabs (stat_elt->value) > 0.001) {
 			/* Write only those values which value is not 0 */
 			log_elt.h1 = stat_elt->hash1;
@@ -307,35 +289,29 @@ write_whole_statfile (struct controller_session *session,
 		}
 	}
 
-	i = rspamd_snprintf (out_buf,
-			sizeof (out_buf),
-			"%uL %uL %uL" CRLF,
-			rev,
-			ti,
-			pos);
-	if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, TRUE,
-		FALSE)) {
+	i = rspamd_snprintf (out_buf, sizeof (out_buf), "%uL %uL %uL" CRLF, rev, ti, pos);
+	if (! rspamd_dispatcher_write (session->dispatcher, out_buf, i, TRUE, FALSE)) {
 		return FALSE;
 	}
 
 	if (!rspamd_dispatcher_write (session->dispatcher, out, pos, TRUE, TRUE)) {
 		return FALSE;
 	}
-
+	
 	return TRUE;
 }
 
 static gboolean
 process_sync_command (struct controller_session *session, gchar **args)
 {
-	gchar out_buf[BUFSIZ], *arg, *err_str, *symbol;
-	gint r;
-	guint64 rev, time;
-	struct rspamd_statfile_config *st = NULL;
-	struct rspamd_classifier_config *ccf;
-	GList *cur;
-	struct rspamd_binlog *binlog;
-	GByteArray *data = NULL;
+	gchar                           out_buf[BUFSIZ], *arg, *err_str, *symbol;
+	gint                            r;
+	guint64                         rev, time;
+	struct rspamd_statfile_config                *st = NULL;
+	struct rspamd_classifier_config       *ccf;
+	GList                          *cur;
+	struct rspamd_binlog           *binlog;
+	GByteArray                     *data = NULL;
 
 	arg = *args;
 	if (!arg || *arg == '\0') {
@@ -369,7 +345,7 @@ process_sync_command (struct controller_session *session, gchar **args)
 		msg_info ("bad symbol: %s", symbol);
 		return FALSE;
 	}
-
+	
 	cur = g_list_first (ccf->statfiles);
 	while (cur) {
 		st = cur->data;
@@ -379,35 +355,28 @@ process_sync_command (struct controller_session *session, gchar **args)
 		st = NULL;
 		cur = g_list_next (cur);
 	}
-	if (st == NULL) {
+    if (st == NULL) {
 		msg_info ("bad symbol: %s", symbol);
-		return FALSE;
-	}
-
+        return FALSE;
+    }
+	
 	binlog = get_binlog_by_statfile (st);
 	if (binlog == NULL) {
 		msg_info ("cannot open binlog: %s", symbol);
-		return FALSE;
+        return FALSE;
 	}
-
+	
 	while (binlog_sync (binlog, rev, &time, &data)) {
-		rev++;
-		r = rspamd_snprintf (out_buf,
-				sizeof (out_buf),
-				"%uL %uL %z" CRLF,
-				rev,
-				time,
-				data->len);
-		if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE,
-			FALSE)) {
+		rev ++;
+		r = rspamd_snprintf (out_buf, sizeof (out_buf), "%uL %uL %z" CRLF, rev, time, data->len);
+		if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 			if (data != NULL) {
 				g_free (data);
 			}
 			return FALSE;
 		}
 		if (data->data != NULL) {
-			if (!rspamd_dispatcher_write (session->dispatcher, data->data,
-				data->len, TRUE, FALSE)) {
+			if (!rspamd_dispatcher_write (session->dispatcher, data->data, data->len, TRUE, FALSE)) {
 				if (data != NULL) {
 					g_free (data);
 				}
@@ -433,10 +402,10 @@ process_sync_command (struct controller_session *session, gchar **args)
 static gboolean
 process_counters_command (struct controller_session *session)
 {
-	GList *cur;
-	struct cache_item *item;
-	struct symbols_cache *cache;
-	GString *out;
+	GList                          *cur;
+	struct cache_item             *item;
+	struct symbols_cache          *cache;
+	GString                        *out;
 
 	cache = session->cfg->cache;
 	out = g_string_sized_new (BUFSIZ);
@@ -451,8 +420,8 @@ process_counters_command (struct controller_session *session)
 			item = cur->data;
 			if (!item->is_callback) {
 				rspamd_printf_gstring (out, "%s %.2f %d %.3f" CRLF,
-					item->s->symbol, item->s->weight,
-					item->s->frequency, item->s->avg_time);
+						item->s->symbol, item->s->weight,
+						item->s->frequency, item->s->avg_time);
 			}
 			cur = g_list_next (cur);
 		}
@@ -461,18 +430,15 @@ process_counters_command (struct controller_session *session)
 			item = cur->data;
 			if (!item->is_callback) {
 				rspamd_printf_gstring (out, "%s %.2f %d %.3f" CRLF,
-					item->s->symbol, item->s->weight,
-					item->s->frequency, item->s->avg_time);
+						item->s->symbol, item->s->weight,
+						item->s->frequency, item->s->avg_time);
 			}
 			cur = g_list_next (cur);
 		}
 	}
 
 	if (!session->restful) {
-		return rspamd_dispatcher_write_string (session->dispatcher,
-				   out,
-				   FALSE,
-				   TRUE);
+		return rspamd_dispatcher_write_string (session->dispatcher, out, FALSE, TRUE);
 	}
 	else {
 		return restful_write_reply_string (200, NULL, out, session->dispatcher);
@@ -482,33 +448,27 @@ process_counters_command (struct controller_session *session)
 static gboolean
 process_stat_command (struct controller_session *session, gboolean do_reset)
 {
-	GString *out;
-	gint i;
-	guint64 used, total, rev, ham = 0, spam = 0;
-	time_t ti;
-	rspamd_mempool_stat_t mem_st;
-	struct rspamd_classifier_config *ccf;
-	stat_file_t *statfile;
-	struct rspamd_statfile_config *st;
-	GList *cur_cl, *cur_st;
-	struct rspamd_stat *stat, stat_copy;
+	GString                        *out;
+	gint                            i;
+	guint64                         used, total, rev, ham = 0, spam = 0;
+	time_t                          ti;
+	rspamd_mempool_stat_t              mem_st;
+	struct rspamd_classifier_config       *ccf;
+	stat_file_t                    *statfile;
+	struct rspamd_statfile_config                *st;
+	GList                          *cur_cl, *cur_st;
+	struct rspamd_stat            *stat, stat_copy;
 
 	rspamd_mempool_stat (&mem_st);
 	memcpy (&stat_copy, session->worker->srv->stat, sizeof (stat_copy));
 	stat = &stat_copy;
 	out = g_string_sized_new (BUFSIZ);
-	rspamd_printf_gstring (out,
-		"Messages scanned: %ud" CRLF,
-		stat->messages_scanned);
+	rspamd_printf_gstring (out, "Messages scanned: %ud" CRLF, stat->messages_scanned);
 	if (stat->messages_scanned > 0) {
-		for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
-			rspamd_printf_gstring (out,
-				"Messages with action %s: %ud, %.2f%%" CRLF,
-				str_action_metric (
-					i),
-				stat->actions_stat[i],
-				(double)stat->actions_stat[i] / (double)stat->messages_scanned *
-				100.);
+		for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i ++) {
+			rspamd_printf_gstring (out, "Messages with action %s: %ud, %.2f%%" CRLF,
+					str_action_metric (i), stat->actions_stat[i],
+					(double)stat->actions_stat[i] / (double)stat->messages_scanned * 100.);
 			if (i < METRIC_ACTION_GREYLIST) {
 				spam += stat->actions_stat[i];
 			}
@@ -519,51 +479,23 @@ process_stat_command (struct controller_session *session, gboolean do_reset)
 				session->worker->srv->stat->actions_stat[i] = 0;
 			}
 		}
-		rspamd_printf_gstring (out,
-			"Messages treated as spam: %ud, %.2f%%" CRLF,
-			spam,
-			(double)spam / (double)stat->messages_scanned * 100.);
-		rspamd_printf_gstring (out,
-			"Messages treated as ham: %ud, %.2f%%" CRLF,
-			ham,
-			(double)ham / (double)stat->messages_scanned * 100.);
-	}
-	rspamd_printf_gstring (out,
-		"Messages learned: %ud" CRLF,
-		stat->messages_learned);
-	rspamd_printf_gstring (out,
-		"Connections count: %ud" CRLF,
-		stat->connections_count);
-	rspamd_printf_gstring (out,
-		"Control connections count: %ud" CRLF,
-		stat->control_connections_count);
-	rspamd_printf_gstring (out,
-		"Pools allocated: %z" CRLF,
-		mem_st.pools_allocated);
-	rspamd_printf_gstring (out,
-		"Pools freed: %z" CRLF,
-		mem_st.pools_freed);
-	rspamd_printf_gstring (out,
-		"Bytes allocated: %z" CRLF,
-		mem_st.bytes_allocated);
-	rspamd_printf_gstring (out,
-		"Memory chunks allocated: %z" CRLF,
-		mem_st.chunks_allocated);
-	rspamd_printf_gstring (out,
-		"Shared chunks allocated: %z" CRLF,
-		mem_st.shared_chunks_allocated);
-	rspamd_printf_gstring (out,
-		"Chunks freed: %z" CRLF,
-		mem_st.chunks_freed);
-	rspamd_printf_gstring (out,
-		"Oversized chunks: %z" CRLF,
-		mem_st.oversized_chunks);
-	rspamd_printf_gstring (out,
-		"Fuzzy hashes stored: %ud" CRLF,
-		stat->fuzzy_hashes);
-	rspamd_printf_gstring (out,
-		"Fuzzy hashes expired: %ud" CRLF,
-		stat->fuzzy_hashes_expired);
+		rspamd_printf_gstring (out, "Messages treated as spam: %ud, %.2f%%" CRLF, spam,
+								(double)spam / (double)stat->messages_scanned * 100.);
+		rspamd_printf_gstring (out, "Messages treated as ham: %ud, %.2f%%" CRLF, ham,
+								(double)ham / (double)stat->messages_scanned * 100.);
+	}
+	rspamd_printf_gstring (out, "Messages learned: %ud" CRLF, stat->messages_learned);
+	rspamd_printf_gstring (out, "Connections count: %ud" CRLF, stat->connections_count);
+	rspamd_printf_gstring (out, "Control connections count: %ud" CRLF, stat->control_connections_count);
+	rspamd_printf_gstring (out, "Pools allocated: %z" CRLF, mem_st.pools_allocated);
+	rspamd_printf_gstring (out, "Pools freed: %z" CRLF, mem_st.pools_freed);
+	rspamd_printf_gstring (out, "Bytes allocated: %z" CRLF, mem_st.bytes_allocated);
+	rspamd_printf_gstring (out, "Memory chunks allocated: %z" CRLF, mem_st.chunks_allocated);
+	rspamd_printf_gstring (out, "Shared chunks allocated: %z" CRLF, mem_st.shared_chunks_allocated);
+	rspamd_printf_gstring (out, "Chunks freed: %z" CRLF, mem_st.chunks_freed);
+	rspamd_printf_gstring (out, "Oversized chunks: %z" CRLF, mem_st.oversized_chunks);
+	rspamd_printf_gstring (out, "Fuzzy hashes stored: %ud" CRLF, stat->fuzzy_hashes);
+	rspamd_printf_gstring (out, "Fuzzy hashes expired: %ud" CRLF, stat->fuzzy_hashes_expired);
 	/* Now write statistics for each statfile */
 	cur_cl = g_list_first (session->cfg->classifiers);
 	while (cur_cl) {
@@ -571,42 +503,27 @@ process_stat_command (struct controller_session *session, gboolean do_reset)
 		cur_st = g_list_first (ccf->statfiles);
 		while (cur_st) {
 			st = cur_st->data;
-			if ((statfile =
-				statfile_pool_is_open (session->worker->srv->statfile_pool,
-				st->path)) == NULL) {
-				statfile = statfile_pool_open (
-					session->worker->srv->statfile_pool,
-					st->path,
-					st->size,
-					FALSE);
+			if ((statfile = statfile_pool_is_open (session->worker->srv->statfile_pool, st->path)) == NULL) {
+				statfile = statfile_pool_open (session->worker->srv->statfile_pool, st->path, st->size, FALSE);
 			}
 			if (statfile) {
 				used = statfile_get_used_blocks (statfile);
 				total = statfile_get_total_blocks (statfile);
 				statfile_get_revision (statfile, &rev, &ti);
-				if (total != (guint64) - 1 && used != (guint64) - 1) {
+				if (total != (guint64)-1 && used != (guint64)-1) {
 					if (st->label) {
 						rspamd_printf_gstring (out,
-							"Statfile: %s <%s> (version %uL); length: %Hz; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
-							st->symbol,
-							st->label,
-							rev,
-							st->size,
-							(total - used),
-							total,
-							(double)((double)(total -
-							used) / (double)total) * 100.);
+								"Statfile: %s <%s> (version %uL); length: %Hz; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
+								st->symbol, st->label, rev, st->size,
+								(total - used), total,
+								(double)((double)(total - used) / (double)total) * 100.);
 					}
 					else {
 						rspamd_printf_gstring (out,
-							"Statfile: %s (version %uL); length: %Hz; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
-							st->symbol,
-							rev,
-							st->size,
-							(total - used),
-							total,
-							(double)((double)(total -
-							used) / (double)total) * 100.);
+								"Statfile: %s (version %uL); length: %Hz; free blocks: %uL; total blocks: %uL; free: %.2f%%" CRLF,
+								st->symbol, rev, st->size,
+								(total - used), total,
+								(double)((double)(total - used) / (double)total) * 100.);
 					}
 				}
 			}
@@ -623,10 +540,7 @@ process_stat_command (struct controller_session *session, gboolean do_reset)
 	}
 
 	if (!session->restful) {
-		return rspamd_dispatcher_write_string (session->dispatcher,
-				   out,
-				   FALSE,
-				   TRUE);
+		return rspamd_dispatcher_write_string (session->dispatcher, out, FALSE, TRUE);
 	}
 	else {
 		return restful_write_reply_string (200, NULL, out, session->dispatcher);
@@ -634,30 +548,20 @@ process_stat_command (struct controller_session *session, gboolean do_reset)
 }
 
 static gboolean
-process_dynamic_conf_command (gchar **cmd_args,
-	struct controller_session *session,
-	gboolean is_action)
+process_dynamic_conf_command (gchar **cmd_args, struct controller_session *session, gboolean is_action)
 {
-	struct rspamd_config *cfg = session->cfg;
-	gchar *arg, *metric, *name, *err_str;
-	gdouble value;
-	gboolean res;
-	guint real_act;
+	struct rspamd_config			   *cfg = session->cfg;
+	gchar						   *arg, *metric, *name, *err_str;
+	gdouble						    value;
+	gboolean						res;
+	guint							real_act;
 
 	if (cfg->dynamic_conf == NULL) {
 		if (!session->restful) {
-			return rspamd_dispatcher_write (session->dispatcher,
-					   "dynamic config is not specified" CRLF,
-					   0,
-					   FALSE,
-					   TRUE);
+			return rspamd_dispatcher_write (session->dispatcher, "dynamic config is not specified" CRLF, 0, FALSE, TRUE);
 		}
 		else {
-			return restful_write_reply (500,
-					   "dynamic config is not specified",
-					   NULL,
-					   0,
-					   session->dispatcher);
+			return restful_write_reply (500, "dynamic config is not specified", NULL, 0, session->dispatcher);
 		}
 	}
 
@@ -725,131 +629,84 @@ process_dynamic_conf_command (gchar **cmd_args,
 		res = dump_dynamic_config (cfg);
 		if (res) {
 			if (!session->restful) {
-				return rspamd_dispatcher_write (session->dispatcher,
-						   "OK" CRLF,
-						   0,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispatcher, "OK" CRLF, 0, FALSE, TRUE);
 			}
 			else {
-				return restful_write_reply (200,
-						   "OK",
-						   NULL,
-						   0,
-						   session->dispatcher);
+				return restful_write_reply (200, "OK", NULL, 0, session->dispatcher);
 			}
 		}
 		else {
 			if (!session->restful) {
-				return rspamd_dispatcher_write (session->dispatcher,
-						   "Error dumping dynamic config" CRLF,
-						   0,
-						   FALSE,
-						   TRUE);
+				return rspamd_dispatcher_write (session->dispatcher, "Error dumping dynamic config" CRLF, 0, FALSE, TRUE);
 			}
 			else {
-				return restful_write_reply (500,
-						   "Error dumping dynamic config",
-						   NULL,
-						   0,
-						   session->dispatcher);
+				return restful_write_reply (500, "Error dumping dynamic config", NULL, 0, session->dispatcher);
 			}
 		}
 	}
 	else {
 		if (!session->restful) {
-			return rspamd_dispatcher_write (session->dispatcher,
-					   "Cannot add dynamic rule" CRLF,
-					   0,
-					   FALSE,
-					   TRUE);
+			return rspamd_dispatcher_write (session->dispatcher, "Cannot add dynamic rule" CRLF, 0, FALSE, TRUE);
 		}
 		else {
-			return restful_write_reply (500,
-					   "Cannot add dynamic rule",
-					   NULL,
-					   0,
-					   session->dispatcher);
+			return restful_write_reply (500, "Cannot add dynamic rule", NULL, 0, session->dispatcher);
 		}
 	}
 
 invalid_arguments:
 	if (!session->restful) {
-		return rspamd_dispatcher_write (session->dispatcher,
-				   "Invalid arguments" CRLF,
-				   0,
-				   FALSE,
-				   TRUE);
+		return rspamd_dispatcher_write (session->dispatcher, "Invalid arguments" CRLF, 0, FALSE, TRUE);
 	}
 	else {
-		return restful_write_reply (500,
-				   "Invalid arguments",
-				   NULL,
-				   0,
-				   session->dispatcher);
+		return restful_write_reply (500, "Invalid arguments", NULL, 0, session->dispatcher);
 	}
 }
 
 static gboolean
-process_command (struct controller_command *cmd,
-	gchar **cmd_args,
-	struct controller_session *session)
+process_command (struct controller_command *cmd, gchar **cmd_args, struct controller_session *session)
 {
-	gchar out_buf[BUFSIZ], *arg, *err_str;
-	gint r = 0, days, hours, minutes;
-	time_t uptime;
-	guint32 size = 0;
-	struct rspamd_classifier_config *cl;
-	struct rspamd_controller_ctx *ctx = session->worker->ctx;
+	gchar                           out_buf[BUFSIZ], *arg, *err_str;
+	gint                            r = 0, days, hours, minutes;
+	time_t                          uptime;
+	guint32                   		size = 0;
+	struct rspamd_classifier_config       *cl;
+	struct rspamd_controller_ctx   *ctx = session->worker->ctx;
 
 	switch (cmd->type) {
 	case COMMAND_GET:
 	case COMMAND_POST:
 		session->restful = TRUE;
 		session->state = STATE_HEADER;
-		session->kwargs = g_hash_table_new (rspamd_strcase_hash,
-				rspamd_strcase_equal);
+		session->kwargs = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
 		break;
 	case COMMAND_PASSWORD:
 		arg = *cmd_args;
 		if (!arg || *arg == '\0') {
 			msg_debug ("empty password passed");
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"password command requires one argument" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "password command requires one argument" CRLF);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 			return TRUE;
 		}
 		if (ctx->password == NULL) {
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"password command disabled in config, authorized access granted" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "password command disabled in config, authorized access granted" CRLF);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 			return TRUE;
 		}
 		if (strncmp (arg, ctx->password, strlen (arg)) == 0) {
 			session->authorized = 1;
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"password accepted" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "password accepted" CRLF);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 		}
 		else {
 			session->authorized = 0;
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"password NOT accepted" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "password NOT accepted" CRLF);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 		}
@@ -859,18 +716,14 @@ process_command (struct controller_command *cmd,
 		break;
 	case COMMAND_RELOAD:
 		if (check_auth (cmd, session)) {
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"reload request sent" CRLF);
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "reload request sent" CRLF);
 			if (!session->restful) {
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 			}
 			else {
-				if (!restful_write_reply (200, out_buf, NULL, 0,
-					session->dispatcher)) {
+				if (! restful_write_reply (200, out_buf, NULL, 0, session->dispatcher)) {
 					return FALSE;
 				}
 			}
@@ -889,18 +742,14 @@ process_command (struct controller_command *cmd,
 		break;
 	case COMMAND_SHUTDOWN:
 		if (check_auth (cmd, session)) {
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"shutdown request sent" CRLF);
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "shutdown request sent" CRLF);
 			if (!session->restful) {
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 			}
 			else {
-				if (!restful_write_reply (200, out_buf, NULL, 0,
-					session->dispatcher)) {
+				if (! restful_write_reply (200, out_buf, NULL, 0, session->dispatcher)) {
 					return FALSE;
 				}
 			}
@@ -915,48 +764,26 @@ process_command (struct controller_command *cmd,
 				days = uptime / 86400;
 				hours = uptime / 3600 - days * 24;
 				minutes = uptime / 60 - hours * 60 - days * 1440;
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"%d day%s %d hour%s %d minute%s" CRLF,
-						days,
-						days > 1 ? "s" : " ",
-						hours,
-						hours > 1 ? "s" : " ",
-						minutes,
-						minutes > 1 ? "s" : " ");
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "%d day%s %d hour%s %d minute%s" CRLF, days, days > 1 ? "s" : " ", hours, hours > 1 ? "s" : " ", minutes, minutes > 1 ? "s" : " ");
 			}
 			/* If uptime is less than 1 minute print only seconds */
 			else if (uptime / 60 == 0) {
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"%d second%s" CRLF,
-						(gint)uptime,
-						(gint)uptime > 1 ? "s" : " ");
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "%d second%s" CRLF, (gint)uptime, (gint)uptime > 1 ? "s" : " ");
 			}
 			/* Else print the minutes and seconds. */
 			else {
 				hours = uptime / 3600;
 				minutes = uptime / 60 - hours * 60;
 				uptime -= hours * 3600 + minutes * 60;
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"%d hour%s %d minute%s %d second%s" CRLF,
-						hours,
-						hours > 1 ? "s" : " ",
-						minutes,
-						minutes > 1 ? "s" : " ",
-						(gint)uptime,
-						uptime > 1 ? "s" : " ");
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "%d hour%s %d minute%s %d second%s" CRLF, hours, hours > 1 ? "s" : " ", minutes, minutes > 1 ? "s" : " ", (gint)uptime, uptime > 1 ? "s" : " ");
 			}
 			if (!session->restful) {
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 			}
 			else {
-				if (!restful_write_reply (200, NULL, out_buf, r,
-					session->dispatcher)) {
+				if (! restful_write_reply (200, NULL, out_buf, r, session->dispatcher)) {
 					return FALSE;
 				}
 			}
@@ -968,11 +795,8 @@ process_command (struct controller_command *cmd,
 				arg = *cmd_args;
 				if (!arg || *arg == '\0') {
 					msg_debug ("no statfile specified in learn command");
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
-					if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
-						r, FALSE, FALSE)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+					if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 						return FALSE;
 					}
 					return TRUE;
@@ -980,11 +804,8 @@ process_command (struct controller_command *cmd,
 				arg = *(cmd_args + 1);
 				if (arg == NULL || *arg == '\0') {
 					msg_debug ("no message size specified in learn command");
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
-					if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
-						r, FALSE, FALSE)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+					if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 						return FALSE;
 					}
 					return TRUE;
@@ -992,11 +813,8 @@ process_command (struct controller_command *cmd,
 				size = strtoul (arg, &err_str, 10);
 				if (err_str && *err_str != '\0') {
 					msg_debug ("message size is invalid: %s", arg);
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn size is invalid" CRLF);
-					if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
-						r, FALSE, FALSE)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
+					if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 						return FALSE;
 					}
 					return TRUE;
@@ -1004,15 +822,10 @@ process_command (struct controller_command *cmd,
 				cl = rspamd_config_find_classifier (session->cfg, *cmd_args);
 			}
 			else {
-				if ((arg =
-					g_hash_table_lookup (session->kwargs,
-					"classifier")) == NULL) {
+				if ((arg = g_hash_table_lookup (session->kwargs, "classifier")) == NULL) {
 					msg_debug ("no classifier specified in learn command");
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
-					if (!restful_write_reply (500, out_buf, NULL, 0,
-						session->dispatcher)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+					if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 						return FALSE;
 					}
 					return TRUE;
@@ -1020,15 +833,10 @@ process_command (struct controller_command *cmd,
 				else {
 					cl = rspamd_config_find_classifier (session->cfg, arg);
 				}
-				if ((arg =
-					g_hash_table_lookup (session->kwargs,
-					"content-length")) == NULL) {
+				if ((arg = g_hash_table_lookup (session->kwargs, "content-length")) == NULL) {
 					msg_debug ("no size specified in learn command");
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
-					if (!restful_write_reply (500, out_buf, NULL, 0,
-						session->dispatcher)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+					if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 						return FALSE;
 					}
 				}
@@ -1036,11 +844,8 @@ process_command (struct controller_command *cmd,
 					size = strtoul (arg, &err_str, 10);
 					if (err_str && *err_str != '\0') {
 						msg_debug ("message size is invalid: %s", arg);
-						r = rspamd_snprintf (out_buf,
-								sizeof (out_buf),
-								"learn size is invalid" CRLF);
-						if (!restful_write_reply (500, out_buf, NULL, 0,
-							session->dispatcher)) {
+						r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
+						if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 							return FALSE;
 						}
 						return TRUE;
@@ -1052,9 +857,7 @@ process_command (struct controller_command *cmd,
 
 			/* By default learn positive */
 			session->in_class = TRUE;
-			rspamd_set_dispatcher_policy (session->dispatcher,
-				BUFFER_CHARACTER,
-				size);
+			rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
 			session->state = STATE_LEARN_SPAM_PRE;
 		}
 		break;
@@ -1064,11 +867,8 @@ process_command (struct controller_command *cmd,
 				arg = *cmd_args;
 				if (!arg || *arg == '\0') {
 					msg_debug ("no statfile specified in learn command");
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
-					if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
-						r, FALSE, FALSE)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+					if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 						return FALSE;
 					}
 					return TRUE;
@@ -1076,11 +876,8 @@ process_command (struct controller_command *cmd,
 				arg = *(cmd_args + 1);
 				if (arg == NULL || *arg == '\0') {
 					msg_debug ("no message size specified in learn command");
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
-					if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
-						r, FALSE, FALSE)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+					if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 						return FALSE;
 					}
 					return TRUE;
@@ -1088,11 +885,8 @@ process_command (struct controller_command *cmd,
 				size = strtoul (arg, &err_str, 10);
 				if (err_str && *err_str != '\0') {
 					msg_debug ("message size is invalid: %s", arg);
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn size is invalid" CRLF);
-					if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
-						r, FALSE, FALSE)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
+					if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 						return FALSE;
 					}
 					return TRUE;
@@ -1100,15 +894,10 @@ process_command (struct controller_command *cmd,
 				cl = rspamd_config_find_classifier (session->cfg, *cmd_args);
 			}
 			else {
-				if ((arg =
-					g_hash_table_lookup (session->kwargs,
-					"classifier")) == NULL) {
+				if ((arg = g_hash_table_lookup (session->kwargs, "classifier")) == NULL) {
 					msg_debug ("no classifier specified in learn command");
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
-					if (!restful_write_reply (500, out_buf, NULL, 0,
-						session->dispatcher)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+					if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 						return FALSE;
 					}
 					return TRUE;
@@ -1116,15 +905,10 @@ process_command (struct controller_command *cmd,
 				else {
 					cl = rspamd_config_find_classifier (session->cfg, arg);
 				}
-				if ((arg =
-					g_hash_table_lookup (session->kwargs,
-					"content-length")) == NULL) {
+				if ((arg = g_hash_table_lookup (session->kwargs, "content-length")) == NULL) {
 					msg_debug ("no size specified in learn command");
-					r = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
-					if (!restful_write_reply (500, out_buf, NULL, 0,
-						session->dispatcher)) {
+					r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn_spam command requires at least two arguments: classifier name and a message's size" CRLF);
+					if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 						return FALSE;
 					}
 				}
@@ -1132,11 +916,8 @@ process_command (struct controller_command *cmd,
 					size = strtoul (arg, &err_str, 10);
 					if (err_str && *err_str != '\0') {
 						msg_debug ("message size is invalid: %s", arg);
-						r = rspamd_snprintf (out_buf,
-								sizeof (out_buf),
-								"learn size is invalid" CRLF);
-						if (!restful_write_reply (500, out_buf, NULL, 0,
-							session->dispatcher)) {
+						r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
+						if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 							return FALSE;
 						}
 						return TRUE;
@@ -1148,9 +929,7 @@ process_command (struct controller_command *cmd,
 
 			/* By default learn positive */
 			session->in_class = FALSE;
-			rspamd_set_dispatcher_policy (session->dispatcher,
-				BUFFER_CHARACTER,
-				size);
+			rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
 			session->state = STATE_LEARN_SPAM_PRE;
 		}
 		break;
@@ -1160,11 +939,8 @@ process_command (struct controller_command *cmd,
 			arg = *cmd_args;
 			if (!arg || *arg == '\0') {
 				msg_debug ("no statfile specified in learn command");
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"learn command requires at least two arguments: stat filename and its size" CRLF);
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn command requires at least two arguments: stat filename and its size" CRLF);
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 				return TRUE;
@@ -1172,11 +948,8 @@ process_command (struct controller_command *cmd,
 			arg = *(cmd_args + 1);
 			if (arg == NULL || *arg == '\0') {
 				msg_debug ("no message size specified in learn command");
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"learn command requires at least two arguments: symbol and message size" CRLF);
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn command requires at least two arguments: symbol and message size" CRLF);
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 				return TRUE;
@@ -1184,21 +957,15 @@ process_command (struct controller_command *cmd,
 			size = strtoul (arg, &err_str, 10);
 			if (err_str && *err_str != '\0') {
 				msg_debug ("message size is invalid: %s", arg);
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"learn size is invalid" CRLF);
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "learn size is invalid" CRLF);
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 				return TRUE;
 			}
 
-			session->learn_symbol = rspamd_mempool_strdup (
-				session->session_pool,
-				*cmd_args);
-			cl = g_hash_table_lookup (session->cfg->classifiers_symbols,
-					*cmd_args);
+			session->learn_symbol = rspamd_mempool_strdup (session->session_pool, *cmd_args);
+			cl = g_hash_table_lookup (session->cfg->classifiers_symbols, *cmd_args);
 
 			session->learn_classifier = cl;
 
@@ -1213,32 +980,22 @@ process_command (struct controller_command *cmd,
 					case 'r':
 						arg = *(cmd_args + 1);
 						if (!arg || *arg == '\0') {
-							r = rspamd_snprintf (out_buf,
-									sizeof (out_buf),
-									"recipient is not defined" CRLF);
-							if (!rspamd_dispatcher_write (session->dispatcher,
-								out_buf, r, FALSE, FALSE)) {
+							r = rspamd_snprintf (out_buf, sizeof (out_buf), "recipient is not defined" CRLF);
+							if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 								return FALSE;
 							}
 						}
-						session->learn_rcpt = rspamd_mempool_strdup (
-							session->session_pool,
-							arg);
+						session->learn_rcpt = rspamd_mempool_strdup (session->session_pool, arg);
 						break;
 					case 'f':
 						arg = *(cmd_args + 1);
 						if (!arg || *arg == '\0') {
-							r = rspamd_snprintf (out_buf,
-									sizeof (out_buf),
-									"from is not defined" CRLF);
-							if (!rspamd_dispatcher_write (session->dispatcher,
-								out_buf, r, FALSE, FALSE)) {
+							r = rspamd_snprintf (out_buf, sizeof (out_buf), "from is not defined" CRLF);
+							if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 								return FALSE;
 							}
 						}
-						session->learn_from = rspamd_mempool_strdup (
-							session->session_pool,
-							arg);
+						session->learn_from = rspamd_mempool_strdup (session->session_pool, arg);
 						break;
 					case 'n':
 						session->in_class = 0;
@@ -1246,11 +1003,8 @@ process_command (struct controller_command *cmd,
 					case 'm':
 						arg = *(cmd_args + 1);
 						if (!arg || *arg == '\0') {
-							r = rspamd_snprintf (out_buf,
-									sizeof (out_buf),
-									"multiplier is not defined" CRLF);
-							if (!rspamd_dispatcher_write (session->dispatcher,
-								out_buf, r, FALSE, FALSE)) {
+							r = rspamd_snprintf (out_buf, sizeof (out_buf), "multiplier is not defined" CRLF);
+							if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 								return FALSE;
 							}
 						}
@@ -1259,20 +1013,15 @@ process_command (struct controller_command *cmd,
 						}
 						break;
 					default:
-						r = rspamd_snprintf (out_buf,
-								sizeof (out_buf),
-								"tokenizer is not defined" CRLF);
-						if (!rspamd_dispatcher_write (session->dispatcher,
-							out_buf, r, FALSE, FALSE)) {
+						r = rspamd_snprintf (out_buf, sizeof (out_buf), "tokenizer is not defined" CRLF);
+						if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 							return FALSE;
 						}
 						return TRUE;
 					}
 				}
 			}
-			rspamd_set_dispatcher_policy (session->dispatcher,
-				BUFFER_CHARACTER,
-				size);
+			rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
 			session->state = STATE_LEARN;
 		}
 		break;
@@ -1282,11 +1031,8 @@ process_command (struct controller_command *cmd,
 		arg = *cmd_args;
 		if (!arg || *arg == '\0') {
 			msg_debug ("no statfile specified in weights command");
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"weights command requires two arguments: statfile and message size" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "weights command requires two arguments: statfile and message size" CRLF);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 			return TRUE;
@@ -1294,11 +1040,8 @@ process_command (struct controller_command *cmd,
 		arg = *(cmd_args + 1);
 		if (arg == NULL || *arg == '\0') {
 			msg_debug ("no message size specified in weights command");
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"weights command requires two arguments: statfile and message size" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "weights command requires two arguments: statfile and message size" CRLF);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 			return TRUE;
@@ -1306,11 +1049,8 @@ process_command (struct controller_command *cmd,
 		size = strtoul (arg, &err_str, 10);
 		if (err_str && *err_str != '\0') {
 			msg_debug ("message size is invalid: %s", arg);
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"message size is invalid" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "message size is invalid" CRLF);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 			return TRUE;
@@ -1318,12 +1058,8 @@ process_command (struct controller_command *cmd,
 
 		cl = g_hash_table_lookup (session->cfg->classifiers_symbols, *cmd_args);
 		if (cl == NULL) {
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"statfile %s is not defined" CRLF,
-					*cmd_args);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "statfile %s is not defined" CRLF, *cmd_args);
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 			return TRUE;
@@ -1331,45 +1067,39 @@ process_command (struct controller_command *cmd,
 		}
 		session->learn_classifier = cl;
 
-		rspamd_set_dispatcher_policy (session->dispatcher,
-			BUFFER_CHARACTER,
-			size);
+		rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_CHARACTER, size);
 		session->state = STATE_WEIGHTS;
 		break;
 	case COMMAND_SYNC:
 		if (!process_sync_command (session, cmd_args)) {
 			r = rspamd_snprintf (out_buf, sizeof (out_buf), "FAIL" CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 			return TRUE;
 		}
 		break;
 	case COMMAND_HELP:
-		r = rspamd_snprintf (out_buf,
-				sizeof (out_buf),
-				"Rspamd CLI commands (* - privileged command):" CRLF
-				"    help - this help message" CRLF
-				"(*) learn <statfile> <size> [-r recipient] [-m multiplier] [-f from] [-n] - learn message to specified statfile" CRLF
-				"    quit - quit CLI session" CRLF
-				"    password <password> - authenticate yourself for privileged commands" CRLF
-				"(*) reload - reload rspamd" CRLF
-				"(*) shutdown - shutdown rspamd" CRLF
-				"    stat - show different rspamd stat" CRLF
-				"    sync - run synchronization of statfiles" CRLF
-				"    counters - show rspamd counters" CRLF
-				"    uptime - rspamd uptime" CRLF
-				"    weights <statfile> <size> - weight of message in all statfiles" CRLF);
+		r = rspamd_snprintf (out_buf, sizeof (out_buf),
+			"Rspamd CLI commands (* - privileged command):" CRLF
+			"    help - this help message" CRLF
+			"(*) learn <statfile> <size> [-r recipient] [-m multiplier] [-f from] [-n] - learn message to specified statfile" CRLF
+			"    quit - quit CLI session" CRLF
+			"    password <password> - authenticate yourself for privileged commands" CRLF
+			"(*) reload - reload rspamd" CRLF
+			"(*) shutdown - shutdown rspamd" CRLF 
+			"    stat - show different rspamd stat" CRLF
+			"    sync - run synchronization of statfiles" CRLF
+			"    counters - show rspamd counters" CRLF 
+			"    uptime - rspamd uptime" CRLF
+			"    weights <statfile> <size> - weight of message in all statfiles" CRLF);
 		if (!session->restful) {
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 		}
 		else {
-			if (!restful_write_reply (200, NULL, out_buf, r,
-				session->dispatcher)) {
+			if (! restful_write_reply (200, NULL, out_buf, r, session->dispatcher)) {
 				return FALSE;
 			}
 		}
@@ -1392,12 +1122,9 @@ process_command (struct controller_command *cmd,
 }
 
 static controller_func_t
-parse_custom_command (gchar *line,
-	gchar **cmd_args,
-	struct controller_session *session,
-	gsize len)
+parse_custom_command (gchar *line, gchar **cmd_args, struct controller_session *session, gsize len)
 {
-	GList *cur;
+	GList                          *cur;
 	struct custom_controller_command *cmd;
 
 	if (len == 0) {
@@ -1418,13 +1145,13 @@ parse_custom_command (gchar *line,
 static struct controller_command *
 parse_normal_command (const gchar *line, gsize len)
 {
-	guint i;
-	struct controller_command *c;
+	guint                           i;
+	struct controller_command      *c;
 
 	if (len == 0) {
 		len = strlen (line);
 	}
-	for (i = 0; i < G_N_ELEMENTS (commands); i++) {
+	for (i = 0; i < G_N_ELEMENTS (commands); i ++) {
 		c = &commands[i];
 		if (g_ascii_strncasecmp (line, c->command, len) == 0) {
 			return c;
@@ -1437,10 +1164,10 @@ parse_normal_command (const gchar *line, gsize len)
 static gboolean
 process_header (f_str_t *line, struct controller_session *session)
 {
-	gchar *headern;
-	struct controller_command *command;
-	struct rspamd_controller_ctx *ctx = session->worker->ctx;
-	controller_func_t custom_handler;
+	gchar							*headern;
+	struct controller_command		*command;
+	struct rspamd_controller_ctx	*ctx = session->worker->ctx;
+	controller_func_t				 custom_handler;
 
 	/* XXX: temporary workaround */
 	headern = NULL;
@@ -1458,9 +1185,7 @@ process_header (f_str_t *line, struct controller_session *session)
 			/* This header is actually command */
 			command = parse_normal_command (line->begin, line->len);
 			if (command == NULL) {
-				if ((custom_handler =
-					parse_custom_command (line->begin, NULL, session,
-					line->len)) == NULL) {
+				if ((custom_handler = parse_custom_command (line->begin, NULL, session, line->len)) == NULL) {
 					msg_info ("bad command header: %V", line);
 					return FALSE;
 				}
@@ -1476,8 +1201,8 @@ process_header (f_str_t *line, struct controller_session *session)
 		/* Password header */
 		if (g_ascii_strcasecmp (headern, "password") == 0) {
 			if (ctx->password == NULL ||
-				(line->len == strlen (ctx->password)
-				&& memcmp (line->begin, ctx->password, line->len) == 0)) {
+					(line->len == strlen (ctx->password)
+					&& memcmp (line->begin, ctx->password, line->len) == 0)) {
 				session->authorized = TRUE;
 			}
 			else {
@@ -1487,8 +1212,7 @@ process_header (f_str_t *line, struct controller_session *session)
 		}
 	}
 
-	g_hash_table_insert (session->kwargs, headern,
-		fstrcstr (line, session->session_pool));
+	g_hash_table_insert (session->kwargs, headern, fstrcstr (line, session->session_pool));
 
 	return TRUE;
 }
@@ -1499,7 +1223,7 @@ process_header (f_str_t *line, struct controller_session *session)
 static gboolean
 fin_learn_task (void *arg)
 {
-	struct rspamd_task *task = (struct rspamd_task *) arg;
+	struct rspamd_task             *task = (struct rspamd_task *) arg;
 
 	/* XXX: needs to be reworked */
 
@@ -1512,34 +1236,33 @@ fin_learn_task (void *arg)
 static void
 restore_learn_task (void *arg)
 {
-	struct rspamd_task *task = (struct rspamd_task *) arg;
+	struct rspamd_task             *task = (struct rspamd_task *) arg;
 
 	/* Special state */
 }
 
-static gboolean
+static                          gboolean
 controller_read_socket (f_str_t * in, void *arg)
 {
-	struct controller_session *session = (struct controller_session *)arg;
-	struct classifier_ctx *cls_ctx;
-	gint len, i, r;
-	gchar *s, **params, *cmd, out_buf[128];
-	struct controller_command *command;
-	struct rspamd_task *task;
-	struct mime_text_part *part;
-	GList *cur = NULL;
-	GTree *tokens = NULL;
-	GError *err = NULL;
-	f_str_t c;
-	controller_func_t custom_handler;
+	struct controller_session      *session = (struct controller_session *)arg;
+	struct classifier_ctx          *cls_ctx;
+	gint                            len, i, r;
+	gchar                          *s, **params, *cmd, out_buf[128];
+	struct controller_command      *command;
+	struct rspamd_task             *task;
+	struct mime_text_part          *part;
+	GList                          *cur = NULL;
+	GTree                          *tokens = NULL;
+	GError                         *err = NULL;
+	f_str_t                         c;
+	controller_func_t				custom_handler;
 
 	switch (session->state) {
 	case STATE_COMMAND:
 		s = fstrcstr (in, session->session_pool);
 		params = g_strsplit_set (s, " ", -1);
 
-		rspamd_mempool_add_destructor (session->session_pool,
-			(rspamd_mempool_destruct_t) g_strfreev, params);
+		rspamd_mempool_add_destructor (session->session_pool, (rspamd_mempool_destruct_t) g_strfreev, params);
 
 		len = g_strv_length (params);
 		if (len > 0) {
@@ -1547,20 +1270,15 @@ controller_read_socket (f_str_t * in, void *arg)
 
 			command = parse_normal_command (cmd, 0);
 			if (command != NULL) {
-				if (!process_command (command, &params[1], session)) {
+				if (! process_command (command, &params[1], session)) {
 					return FALSE;
 				}
 			}
 			else {
-				if ((custom_handler =
-					parse_custom_command (cmd, &params[1], session,
-					0)) == NULL) {
+				if ((custom_handler = parse_custom_command (cmd, &params[1], session, 0)) == NULL) {
 					msg_debug ("'%s'", cmd);
-					i = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"Unknown command" CRLF);
-					if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
-						i, FALSE, FALSE)) {
+					i = rspamd_snprintf (out_buf, sizeof (out_buf), "Unknown command" CRLF);
+					if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
 						return FALSE;
 					}
 				}
@@ -1569,12 +1287,9 @@ controller_read_socket (f_str_t * in, void *arg)
 				}
 			}
 		}
-		if (session->state != STATE_LEARN && session->state !=
-			STATE_LEARN_SPAM_PRE
-			&& session->state != STATE_WEIGHTS && session->state !=
-			STATE_OTHER && session->state != STATE_HEADER) {
-			if (!rspamd_dispatcher_write (session->dispatcher, END,
-				sizeof (END) - 1, FALSE, TRUE)) {
+		if (session->state != STATE_LEARN && session->state != STATE_LEARN_SPAM_PRE
+				&& session->state != STATE_WEIGHTS && session->state != STATE_OTHER && session->state != STATE_HEADER) {
+			if (!rspamd_dispatcher_write (session->dispatcher, END, sizeof (END) - 1, FALSE, TRUE)) {
 				return FALSE;
 			}
 			if (session->state == STATE_QUIT) {
@@ -1588,11 +1303,8 @@ controller_read_socket (f_str_t * in, void *arg)
 		if (in->len == 0) {
 			/* End of headers */
 			if (session->cmd == NULL && session->custom_handler == NULL) {
-				i = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"HTTP/1.0 500 Bad command" CRLF CRLF);
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
-					FALSE, FALSE)) {
+				i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Bad command" CRLF CRLF);
+				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
 					return FALSE;
 				}
 				destroy_session (session->s);
@@ -1600,7 +1312,7 @@ controller_read_socket (f_str_t * in, void *arg)
 			}
 			/* Perform command */
 			else if (session->cmd != NULL) {
-				if (!process_command (session->cmd, NULL, session)) {
+				if (! process_command (session->cmd, NULL, session)) {
 					msg_debug ("process command failed");
 					return FALSE;
 				}
@@ -1608,21 +1320,16 @@ controller_read_socket (f_str_t * in, void *arg)
 			else {
 				session->custom_handler (NULL, session);
 			}
-			if (session->state != STATE_LEARN && session->state !=
-				STATE_LEARN_SPAM_PRE
-				&& session->state != STATE_WEIGHTS && session->state !=
-				STATE_OTHER) {
+			if (session->state != STATE_LEARN && session->state != STATE_LEARN_SPAM_PRE
+					&& session->state != STATE_WEIGHTS && session->state != STATE_OTHER) {
 				msg_debug ("closing restful connection");
 				destroy_session (session->s);
 				return FALSE;
 			}
 		}
 		else if (!process_header (in, session)) {
-			i = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"HTTP/1.0 500 Bad header" CRLF CRLF);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
-				FALSE, FALSE)) {
+			i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Bad header" CRLF CRLF);
+			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
 				return FALSE;
 			}
 			destroy_session (session->s);
@@ -1642,17 +1349,12 @@ controller_read_socket (f_str_t * in, void *arg)
 			rspamd_task_free (task, FALSE);
 			session->state = STATE_REPLY;
 			if (session->restful) {
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"HTTP/1.0 500 Cannot process message" CRLF CRLF);
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Cannot process message" CRLF CRLF);
 			}
 			else {
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"cannot process message" CRLF);
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "cannot process message" CRLF);
 			}
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-				FALSE, FALSE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 				return FALSE;
 			}
 			return FALSE;
@@ -1662,34 +1364,23 @@ controller_read_socket (f_str_t * in, void *arg)
 			rspamd_task_free (task, FALSE);
 			if (err) {
 				if (session->restful) {
-					i = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF,
-							err->message);
+					i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF, err->message);
 				}
 				else {
-					i = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn failed, learn classifier error: %s" CRLF END,
-							err->message);
+					i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, learn classifier error: %s" CRLF END, err->message);
 				}
 				g_error_free (err);
 			}
 			else {
 				if (session->restful) {
-					i = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"HTTP/1.0 500 Learn classifier error: unknown" CRLF CRLF);
+					i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: unknown" CRLF CRLF);
 				}
 				else {
-					i = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn failed, unknown learn classifier error" CRLF END);
+					i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, unknown learn classifier error" CRLF END);
 				}
 			}
 
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
-				FALSE, FALSE)) {
+			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
 				return FALSE;
 			}
 			session->state = STATE_REPLY;
@@ -1698,18 +1389,13 @@ controller_read_socket (f_str_t * in, void *arg)
 
 		rspamd_task_free (task, FALSE);
 		if (session->restful) {
-			i = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"HTTP/1.0 200 Learn OK" CRLF CRLF);
+			i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 200 Learn OK" CRLF CRLF);
 		}
 		else {
-			i =
-				rspamd_snprintf (out_buf, sizeof (out_buf),
-					"learn ok" CRLF END);
+			i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn ok" CRLF END);
 		}
 		session->state = STATE_REPLY;
-		if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE,
-			FALSE)) {
+		if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
 			return FALSE;
 		}
 		break;
@@ -1727,35 +1413,25 @@ controller_read_socket (f_str_t * in, void *arg)
 			msg_warn ("processing of message failed");
 			session->state = STATE_REPLY;
 			if (session->restful) {
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"HTTP/1.0 500 Cannot process message" CRLF CRLF);
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Cannot process message" CRLF CRLF);
 			}
 			else {
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"cannot process message" CRLF);
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "cannot process message" CRLF);
 			}
 			if (!session->restful) {
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 			}
 			else {
-				if (!restful_write_reply (500, out_buf, NULL, 0,
-					session->dispatcher)) {
+				if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 					return FALSE;
 				}
 			}
 			return FALSE;
 		}
 		/* Set up async session */
-		task->s = new_async_session (task->task_pool,
-				fin_learn_task,
-				restore_learn_task,
-				rspamd_task_free_hard,
-				task);
+		task->s = new_async_session (task->task_pool, fin_learn_task, restore_learn_task, rspamd_task_free_hard, task);
 		session->learn_task = task;
 		session->state = STATE_LEARN_SPAM;
 		rspamd_dispatcher_pause (session->dispatcher);
@@ -1764,25 +1440,19 @@ controller_read_socket (f_str_t * in, void *arg)
 			rspamd_dispatcher_restore (session->dispatcher);
 			session->state = STATE_REPLY;
 			if (session->restful) {
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"HTTP/1.0 500 Cannot process message" CRLF CRLF);
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Cannot process message" CRLF CRLF);
 			}
 			else {
-				r = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"cannot process message" CRLF);
+				r = rspamd_snprintf (out_buf, sizeof (out_buf), "cannot process message" CRLF);
 			}
 			destroy_session (task->s);
 			if (!session->restful) {
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 			}
 			else {
-				if (!restful_write_reply (500, out_buf, NULL, 0,
-					session->dispatcher)) {
+				if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 					return FALSE;
 				}
 			}
@@ -1800,18 +1470,14 @@ controller_read_socket (f_str_t * in, void *arg)
 			msg_warn ("processing of message failed");
 			rspamd_task_free (task, FALSE);
 			session->state = STATE_REPLY;
-			r = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"cannot process message" CRLF END);
+			r = rspamd_snprintf (out_buf, sizeof (out_buf), "cannot process message" CRLF END);
 			if (!session->restful) {
-				if (!rspamd_dispatcher_write (session->dispatcher, out_buf, r,
-					FALSE, FALSE)) {
+				if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 					return FALSE;
 				}
 			}
 			else {
-				if (!restful_write_reply (500, out_buf, NULL, 0,
-					session->dispatcher)) {
+				if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 					return FALSE;
 				}
 			}
@@ -1828,23 +1494,17 @@ controller_read_socket (f_str_t * in, void *arg)
 
 			c.begin = part->content->data;
 			c.len = part->content->len;
-			if (!session->learn_classifier->tokenizer->tokenize_func (session->
-				learn_classifier->tokenizer,
-				session->session_pool, &c, &tokens, FALSE, part->is_utf,
-				part->urls_offset)) {
-				i = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"weights failed, tokenizer error" CRLF END);
+			if (!session->learn_classifier->tokenizer->tokenize_func (session->learn_classifier->tokenizer,
+					session->session_pool, &c, &tokens, FALSE, part->is_utf, part->urls_offset)) {
+				i = rspamd_snprintf (out_buf, sizeof (out_buf), "weights failed, tokenizer error" CRLF END);
 				rspamd_task_free (task, FALSE);
 				if (!session->restful) {
-					if (!rspamd_dispatcher_write (session->dispatcher, out_buf,
-						r, FALSE, FALSE)) {
+					if (! rspamd_dispatcher_write (session->dispatcher, out_buf, r, FALSE, FALSE)) {
 						return FALSE;
 					}
 				}
 				else {
-					if (!restful_write_reply (500, out_buf, NULL, 0,
-						session->dispatcher)) {
+					if (! restful_write_reply (500, out_buf, NULL, 0, session->dispatcher)) {
 						return FALSE;
 					}
 				}
@@ -1853,53 +1513,40 @@ controller_read_socket (f_str_t * in, void *arg)
 			}
 			cur = g_list_next (cur);
 		}
-
+		
 		/* Handle messages without text */
 		if (tokens == NULL) {
-			i = rspamd_snprintf (out_buf,
-					sizeof (out_buf),
-					"weights failed, no tokens can be extracted (no text data)" CRLF END);
+			i = rspamd_snprintf (out_buf, sizeof (out_buf), "weights failed, no tokens can be extracted (no text data)" CRLF END);
 			rspamd_task_free (task, FALSE);
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
-				FALSE, FALSE)) {
+			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
 				return FALSE;
 			}
 			session->state = STATE_REPLY;
 			return TRUE;
 		}
-
-
+	
+		
 		/* Init classifier */
-		cls_ctx = session->learn_classifier->classifier->init_func (
-			session->session_pool,
-			session->learn_classifier);
-
-		cur = session->learn_classifier->classifier->weights_func (cls_ctx,
-				session->worker->srv->statfile_pool,
-				tokens,
-				task);
+		cls_ctx = session->learn_classifier->classifier->init_func (session->session_pool, session->learn_classifier);
+		
+		cur = session->learn_classifier->classifier->weights_func (cls_ctx, session->worker->srv->statfile_pool, 
+																	tokens, task);
 		i = 0;
 		struct classify_weight *w;
 
 		while (cur) {
 			w = cur->data;
-			i += rspamd_snprintf (out_buf + i,
-					sizeof (out_buf) - i,
-					"%s: %G" CRLF,
-					w->name,
-					w->weight);
+			i += rspamd_snprintf (out_buf + i, sizeof (out_buf) - i, "%s: %G" CRLF, w->name, w->weight);
 			cur = g_list_next (cur);
 		}
 		i += rspamd_snprintf (out_buf + i, sizeof (out_buf) - i, END);
 		if (i != 0) {
-			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i,
-				FALSE, FALSE)) {
+			if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
 				return FALSE;
 			}
 		}
 		else {
-			if (!rspamd_dispatcher_write (session->dispatcher,
-				"weights failed: classifier error" CRLF END, 0, FALSE, TRUE)) {
+			if (!rspamd_dispatcher_write (session->dispatcher, "weights failed: classifier error" CRLF END, 0, FALSE, TRUE)) {
 				return FALSE;
 			}
 		}
@@ -1936,13 +1583,13 @@ controller_read_socket (f_str_t * in, void *arg)
 	return TRUE;
 }
 
-static gboolean
+static                          gboolean
 controller_write_socket (void *arg)
 {
-	struct controller_session *session = (struct controller_session *)arg;
-	gint i;
-	gchar out_buf[1024];
-	GError *err = NULL;
+	struct controller_session      *session = (struct controller_session *)arg;
+	gint                            i;
+	gchar                           out_buf[1024];
+	GError                         *err = NULL;
 
 	if (session->state == STATE_QUIT) {
 		/* Free buffers */
@@ -1953,66 +1600,44 @@ controller_write_socket (void *arg)
 		/* Perform actual learn here */
 		if (session->learn_classifier == NULL) {
 			if (session->restful) {
-				i = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF,
-						"unknown classifier");
+				i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF, "unknown classifier");
 			}
 			else {
-				i = rspamd_snprintf (out_buf,
-						sizeof (out_buf),
-						"learn failed, learn classifier error: %s" CRLF END,
-						"unknown classifier");
+				i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, learn classifier error: %s" CRLF END, "unknown classifier");
 			}
 		}
 		else {
-			if (!learn_task_spam (session->learn_classifier,
-				session->learn_task, session->in_class, &err)) {
+			if (! learn_task_spam (session->learn_classifier, session->learn_task, session->in_class, &err)) {
 				if (err) {
 					if (session->restful) {
-						i = rspamd_snprintf (out_buf,
-								sizeof (out_buf),
-								"HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF,
-								err->message);
+						i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: %s" CRLF CRLF, err->message);
 					}
 					else {
-						i = rspamd_snprintf (out_buf,
-								sizeof (out_buf),
-								"learn failed, learn classifier error: %s" CRLF END,
-								err->message);
+						i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, learn classifier error: %s" CRLF END, err->message);
 					}
 					g_error_free (err);
 				}
 				else {
 					if (session->restful) {
-						i = rspamd_snprintf (out_buf,
-								sizeof (out_buf),
-								"HTTP/1.0 500 Learn classifier error: unknown" CRLF CRLF);
+						i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 500 Learn classifier error: unknown" CRLF CRLF);
 					}
 					else {
-						i = rspamd_snprintf (out_buf,
-								sizeof (out_buf),
-								"learn failed, learn classifier error: unknown" CRLF END);
+						i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn failed, learn classifier error: unknown" CRLF END);
 					}
 				}
 			}
 			else {
 				if (session->restful) {
-					i = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"HTTP/1.0 200 Learn OK" CRLF CRLF);
+					i = rspamd_snprintf (out_buf, sizeof (out_buf), "HTTP/1.0 200 Learn OK" CRLF CRLF);
 				}
 				else {
-					i = rspamd_snprintf (out_buf,
-							sizeof (out_buf),
-							"learn ok" CRLF END);
+					i = rspamd_snprintf (out_buf, sizeof (out_buf), "learn ok" CRLF END);
 				}
 			}
 		}
 		destroy_session (session->learn_task->s);
 		session->state = STATE_REPLY;
-		if (!rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE,
-			FALSE)) {
+		if (! rspamd_dispatcher_write (session->dispatcher, out_buf, i, FALSE, FALSE)) {
 			return FALSE;
 		}
 		if (session->restful) {
@@ -2028,9 +1653,7 @@ controller_write_socket (void *arg)
 		}
 		else {
 			session->state = STATE_COMMAND;
-			rspamd_set_dispatcher_policy (session->dispatcher,
-				BUFFER_LINE,
-				BUFSIZ);
+			rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, BUFSIZ);
 		}
 	}
 	rspamd_dispatcher_restore (session->dispatcher);
@@ -2040,11 +1663,10 @@ controller_write_socket (void *arg)
 static void
 controller_err_socket (GError * err, void *arg)
 {
-	struct controller_session *session = (struct controller_session *)arg;
+	struct controller_session      *session = (struct controller_session *)arg;
 
 	if (err->code != EOF) {
-		msg_info ("abnormally closing control connection, error: %s",
-			err->message);
+		msg_info ("abnormally closing control connection, error: %s", err->message);
 	}
 	g_error_free (err);
 	/* Free buffers */
@@ -2054,12 +1676,12 @@ controller_err_socket (GError * err, void *arg)
 static void
 accept_socket (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
-	union sa_union su;
-	struct controller_session *new_session;
-	struct timeval *io_tv;
-	gint nfd;
-	struct rspamd_controller_ctx *ctx;
+	struct rspamd_worker           *worker = (struct rspamd_worker *)arg;
+	union sa_union                  su;
+	struct controller_session      *new_session;
+	struct timeval                 *io_tv;
+	gint                            nfd;
+	struct rspamd_controller_ctx   *ctx;
 	rspamd_inet_addr_t addr;
 
 	ctx = worker->ctx;
@@ -2078,8 +1700,7 @@ accept_socket (gint fd, short what, void *arg)
 	new_session->sock = nfd;
 	new_session->cfg = worker->srv->cfg;
 	new_session->state = STATE_COMMAND;
-	new_session->session_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size () - 1);
+	new_session->session_pool = rspamd_mempool_new (rspamd_mempool_suggest_size () - 1);
 	new_session->resolver = ctx->resolver;
 	new_session->ev_base = ctx->ev_base;
 	if (ctx->password == NULL) {
@@ -2088,26 +1709,14 @@ accept_socket (gint fd, short what, void *arg)
 	worker->srv->stat->control_connections_count++;
 
 	/* Set up dispatcher */
-	io_tv =
-		rspamd_mempool_alloc (new_session->session_pool,
-			sizeof (struct timeval));
+	io_tv = rspamd_mempool_alloc (new_session->session_pool, sizeof (struct timeval));
 	io_tv->tv_sec = ctx->timeout / 1000;
 	io_tv->tv_usec = ctx->timeout - io_tv->tv_sec * 1000;
 
-	new_session->s = new_async_session (new_session->session_pool,
-			NULL,
-			NULL,
-			free_session,
-			new_session);
-
-	new_session->dispatcher = rspamd_create_dispatcher (ctx->ev_base,
-			nfd,
-			BUFFER_LINE,
-			controller_read_socket,
-			controller_write_socket,
-			controller_err_socket,
-			io_tv,
-			(void *)new_session);
+	new_session->s = new_async_session (new_session->session_pool, NULL, NULL, free_session, new_session);
+
+	new_session->dispatcher = rspamd_create_dispatcher (ctx->ev_base, nfd, BUFFER_LINE, controller_read_socket,
+			controller_write_socket, controller_err_socket, io_tv, (void *)new_session);
 
 	if (su.ss.ss_family == AF_UNIX) {
 		msg_info ("accepted connection from unix socket");
@@ -2115,14 +1724,13 @@ accept_socket (gint fd, short what, void *arg)
 	}
 	else if (su.ss.ss_family == AF_INET) {
 		msg_info ("accepted connection from %s port %d",
-			inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
+				inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
 		memcpy (&new_session->dispatcher->peer_addr, &su.s4.sin_addr,
-			sizeof (guint32));
+				sizeof (guint32));
 	}
 #if 0
 	/* As we support now restful HTTP like connections, this should not be printed anymore */
-	if (!rspamd_dispatcher_write (new_session->dispatcher, greetingbuf,
-		strlen (greetingbuf), FALSE, FALSE)) {
+	if (! rspamd_dispatcher_write (new_session->dispatcher, greetingbuf, strlen (greetingbuf), FALSE, FALSE)) {
 		msg_warn ("cannot write greeting");
 	}
 #endif
@@ -2131,10 +1739,10 @@ accept_socket (gint fd, short what, void *arg)
 static gboolean
 create_rrd_file (const gchar *filename, struct rspamd_controller_ctx *ctx)
 {
-	GError *err = NULL;
-	GArray ar;
-	struct rrd_rra_def rra[5];
-	struct rrd_ds_def ds[4];
+	GError								*err = NULL;
+	GArray								 ar;
+	struct rrd_rra_def					 rra[5];
+	struct rrd_ds_def					 ds[4];
 
 	/*
 	 * DS:
@@ -2151,32 +1759,29 @@ create_rrd_file (const gchar *filename, struct rspamd_controller_ctx *ctx)
 	 * 4) per 2 hours AVERAGE
 	 * 5) per day AVERAGE
 	 */
-	ctx->rrd_file =
-		rspamd_rrd_create (filename, 4, 5, CONTROLLER_RRD_STEP, &err);
+	ctx->rrd_file = rspamd_rrd_create (filename, 4, 5, CONTROLLER_RRD_STEP, &err);
 	if (ctx->rrd_file == NULL) {
-		msg_err ("cannot create rrd file %s, error: %s", filename,
-			err->message);
+		msg_err ("cannot create rrd file %s, error: %s", filename, err->message);
 		g_error_free (err);
 		return FALSE;
 	}
 
 	/* Add all ds and rra */
-	rrd_make_default_ds ("spam",		  CONTROLLER_RRD_STEP, &ds[0]);
+	rrd_make_default_ds ("spam", CONTROLLER_RRD_STEP, &ds[0]);
 	rrd_make_default_ds ("possible spam", CONTROLLER_RRD_STEP, &ds[1]);
-	rrd_make_default_ds ("greylist",	  CONTROLLER_RRD_STEP, &ds[2]);
-	rrd_make_default_ds ("ham",			  CONTROLLER_RRD_STEP, &ds[3]);
+	rrd_make_default_ds ("greylist", CONTROLLER_RRD_STEP, &ds[2]);
+	rrd_make_default_ds ("ham", CONTROLLER_RRD_STEP, &ds[3]);
 
-	rrd_make_default_rra ("AVERAGE", 1,	   600, &rra[0]);
-	rrd_make_default_rra ("AVERAGE", 5,	   600, &rra[1]);
-	rrd_make_default_rra ("AVERAGE", 30,   700, &rra[2]);
-	rrd_make_default_rra ("AVERAGE", 120,  775, &rra[3]);
+	rrd_make_default_rra ("AVERAGE", 1, 600, &rra[0]);
+	rrd_make_default_rra ("AVERAGE", 5, 600, &rra[1]);
+	rrd_make_default_rra ("AVERAGE", 30, 700, &rra[2]);
+	rrd_make_default_rra ("AVERAGE", 120, 775, &rra[3]);
 	rrd_make_default_rra ("AVERAGE", 1440, 797, &rra[4]);
 
 	ar.data = (gchar *)ds;
 	ar.len = sizeof (ds);
 	if (!rspamd_rrd_add_ds (ctx->rrd_file, &ar, &err)) {
-		msg_err ("cannot create rrd file %s, error: %s", filename,
-			err->message);
+		msg_err ("cannot create rrd file %s, error: %s", filename, err->message);
 		g_error_free (err);
 		rspamd_rrd_close (ctx->rrd_file);
 		return FALSE;
@@ -2185,8 +1790,7 @@ create_rrd_file (const gchar *filename, struct rspamd_controller_ctx *ctx)
 	ar.data = (gchar *)rra;
 	ar.len = sizeof (rra);
 	if (!rspamd_rrd_add_rra (ctx->rrd_file, &ar, &err)) {
-		msg_err ("cannot create rrd file %s, error: %s", filename,
-			err->message);
+		msg_err ("cannot create rrd file %s, error: %s", filename, err->message);
 		g_error_free (err);
 		rspamd_rrd_close (ctx->rrd_file);
 		return FALSE;
@@ -2194,8 +1798,7 @@ create_rrd_file (const gchar *filename, struct rspamd_controller_ctx *ctx)
 
 	/* Finalize */
 	if (!rspamd_rrd_finalize (ctx->rrd_file, &err)) {
-		msg_err ("cannot create rrd file %s, error: %s", filename,
-			err->message);
+		msg_err ("cannot create rrd file %s, error: %s", filename, err->message);
 		g_error_free (err);
 		rspamd_rrd_close (ctx->rrd_file);
 		return FALSE;
@@ -2207,11 +1810,11 @@ create_rrd_file (const gchar *filename, struct rspamd_controller_ctx *ctx)
 static void
 controller_update_rrd (gint fd, short what, void *arg)
 {
-	struct rspamd_controller_ctx *ctx = arg;
-	struct timeval tv;
-	GArray ar;
-	gdouble data[4];
-	GError *err = NULL;
+	struct rspamd_controller_ctx       *ctx = arg;
+	struct timeval                      tv;
+	GArray                              ar;
+	gdouble                             data[4];
+	GError                             *err = NULL;
 
 	/*
 	 * Data:
@@ -2226,16 +1829,14 @@ controller_update_rrd (gint fd, short what, void *arg)
 
 	/* Fill data */
 	data[0] = ctx->srv->stat->actions_stat[METRIC_ACTION_REJECT];
-	data[1] = ctx->srv->stat->actions_stat[METRIC_ACTION_ADD_HEADER] +
-		ctx->srv->stat->actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
+	data[1] = ctx->srv->stat->actions_stat[METRIC_ACTION_ADD_HEADER] + ctx->srv->stat->actions_stat[METRIC_ACTION_REWRITE_SUBJECT];
 	data[2] = ctx->srv->stat->actions_stat[METRIC_ACTION_GREYLIST];
 	data[3] = ctx->srv->stat->actions_stat[METRIC_ACTION_NOACTION];
 
 	ar.data = (gchar *)data;
 	ar.len = sizeof (data);
 	if (!rspamd_rrd_add_record (ctx->rrd_file, &ar, &err)) {
-		msg_err ("cannot add record to rrd database: %s, stop rrd update",
-			err->message);
+		msg_err ("cannot add record to rrd database: %s, stop rrd update", err->message);
 		g_error_free (err);
 	}
 	else {
@@ -2246,8 +1847,8 @@ controller_update_rrd (gint fd, short what, void *arg)
 gpointer
 init_controller (struct rspamd_config *cfg)
 {
-	struct rspamd_controller_ctx *ctx;
-	GQuark type;
+	struct rspamd_controller_ctx       *ctx;
+	GQuark								type;
 
 	type = g_quark_try_string ("controller");
 	ctx = g_malloc0 (sizeof (struct rspamd_controller_ctx));
@@ -2255,13 +1856,12 @@ init_controller (struct rspamd_config *cfg)
 	ctx->timeout = CONTROLLER_IO_TIMEOUT * 1000;
 
 	rspamd_rcl_register_worker_option (cfg, type, "password",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_ctx, password), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_ctx, password), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "timeout",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct rspamd_controller_ctx,
-		timeout), RSPAMD_CL_FLAG_TIME_UINT_32);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct rspamd_controller_ctx, timeout), RSPAMD_CL_FLAG_TIME_UINT_32);
 
 	return ctx;
 }
@@ -2269,11 +1869,11 @@ init_controller (struct rspamd_config *cfg)
 void
 start_controller (struct rspamd_worker *worker)
 {
-	gchar *hostbuf;
-	gsize hostmax;
-	struct rspamd_controller_ctx *ctx = worker->ctx;
-	GError *err = NULL;
-	struct timeval tv;
+	gchar                          *hostbuf;
+	gsize                           hostmax;
+	struct rspamd_controller_ctx   *ctx = worker->ctx;
+	GError                         *err = NULL;
+	struct timeval                  tv;
 
 	ctx->ev_base = rspamd_prepare_worker (worker, "controller", accept_socket);
 	g_mime_init (0);
@@ -2281,10 +1881,8 @@ start_controller (struct rspamd_worker *worker)
 	start_time = time (NULL);
 
 	/* Start statfile synchronization */
-	if (!start_statfile_sync (worker->srv->statfile_pool, worker->srv->cfg,
-		ctx->ev_base)) {
-		msg_info (
-			"cannot start statfile synchronization, statfiles would not be synchronized");
+	if (!start_statfile_sync (worker->srv->statfile_pool, worker->srv->cfg, ctx->ev_base)) {
+		msg_info ("cannot start statfile synchronization, statfiles would not be synchronized");
 	}
 
 	/* Check for rrd */
@@ -2294,9 +1892,7 @@ start_controller (struct rspamd_worker *worker)
 	if (worker->srv->cfg->rrd_file) {
 		ctx->rrd_file = rspamd_rrd_open (worker->srv->cfg->rrd_file, &err);
 		if (ctx->rrd_file == NULL) {
-			msg_info ("cannot open rrd file: %s, error: %s, trying to create",
-				worker->srv->cfg->rrd_file,
-				err->message);
+			msg_info ("cannot open rrd file: %s, error: %s, trying to create", worker->srv->cfg->rrd_file, err->message);
 			g_error_free (err);
 			/* Try to create rrd file */
 			if (create_rrd_file (worker->srv->cfg->rrd_file, ctx)) {
@@ -2317,16 +1913,10 @@ start_controller (struct rspamd_worker *worker)
 	hostbuf = alloca (hostmax);
 	gethostname (hostbuf, hostmax);
 	hostbuf[hostmax - 1] = '\0';
-	rspamd_snprintf (greetingbuf,
-		sizeof (greetingbuf),
-		"Rspamd version %s is running on %s" CRLF,
-		RVERSION,
-		hostbuf);
+	rspamd_snprintf (greetingbuf, sizeof (greetingbuf), "Rspamd version %s is running on %s" CRLF, RVERSION, hostbuf);
 
 	start_map_watch (worker->srv->cfg, ctx->ev_base);
-	ctx->resolver = dns_resolver_init (worker->srv->logger,
-			ctx->ev_base,
-			worker->srv->cfg);
+	ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
 
 	event_base_loop (ctx->ev_base, 0);
 
@@ -2339,10 +1929,7 @@ start_controller (struct rspamd_worker *worker)
 }
 
 void
-register_custom_controller_command (const gchar *name,
-	controller_func_t handler,
-	gboolean privilleged,
-	gboolean require_message)
+register_custom_controller_command (const gchar *name, controller_func_t handler, gboolean privilleged, gboolean require_message)
 {
 	struct custom_controller_command *cmd;
 
@@ -2355,6 +1942,6 @@ register_custom_controller_command (const gchar *name,
 	custom_commands = g_list_prepend (custom_commands, cmd);
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libmime/expressions.c b/src/libmime/expressions.c
index c17388315..5d19626bb 100644
--- a/src/libmime/expressions.c
+++ b/src/libmime/expressions.c
@@ -22,56 +22,36 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "diff.h"
-#include "expressions.h"
+#include "util.h"
+#include "cfg_file.h"
+#include "main.h"
+#include "message.h"
 #include "fuzzy.h"
+#include "expressions.h"
 #include "html.h"
 #include "lua/lua_common.h"
-#include "main.h"
-#include "message.h"
-#include "util.h"
+#include "diff.h"
 
-gboolean rspamd_compare_encoding (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_header_exists (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_parts_distance (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_recipients_distance (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_has_only_html_part (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_is_recipients_sorted (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_compare_transfer_encoding (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_is_html_balanced (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_has_html_tag (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-gboolean rspamd_has_fake_html (struct rspamd_task *task,
-	GList * args,
-	void *unused);
+gboolean                        rspamd_compare_encoding (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_header_exists (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_parts_distance (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_recipients_distance (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_has_only_html_part (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_is_recipients_sorted (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_compare_transfer_encoding (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_is_html_balanced (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_has_html_tag (struct rspamd_task *task, GList * args, void *unused);
+gboolean                        rspamd_has_fake_html (struct rspamd_task *task, GList * args, void *unused);
 
 /*
  * List of internal functions of rspamd
  * Sorted by name to use bsearch
  */
 static struct _fl {
-	const gchar *name;
-	rspamd_internal_func_t func;
-	void *user_data;
+	const gchar                     *name;
+	rspamd_internal_func_t          func;
+	void                           *user_data;
 } rspamd_functions_list[] = {
 	{"compare_encoding", rspamd_compare_encoding, NULL},
 	{"compare_parts_distance", rspamd_parts_distance, NULL},
@@ -85,32 +65,30 @@ static struct _fl {
 	{"is_recipients_sorted", rspamd_is_recipients_sorted, NULL}
 };
 
-static struct _fl *list_ptr = &rspamd_functions_list[0];
-static guint32 functions_number = sizeof (rspamd_functions_list) /
-	sizeof (struct _fl);
-static gboolean list_allocated = FALSE;
+static struct _fl              *list_ptr = &rspamd_functions_list[0];
+static guint32                  functions_number = sizeof (rspamd_functions_list) / sizeof (struct _fl);
+static gboolean                 list_allocated = FALSE;
 
 /* Bsearch routine */
 static gint
 fl_cmp (const void *s1, const void *s2)
 {
-	struct _fl *fl1 = (struct _fl *)s1;
-	struct _fl *fl2 = (struct _fl *)s2;
+	struct _fl                     *fl1 = (struct _fl *)s1;
+	struct _fl                     *fl2 = (struct _fl *)s2;
 	return strcmp (fl1->name, fl2->name);
 }
 
 /* Cache for regular expressions that are used in functions */
-void *
+void                           *
 re_cache_check (const gchar *line, rspamd_mempool_t *pool)
 {
-	GHashTable *re_cache;
-
+	GHashTable              *re_cache;
+	
 	re_cache = rspamd_mempool_get_variable (pool, "re_cache");
 
 	if (re_cache == NULL) {
 		re_cache = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
-		rspamd_mempool_set_variable (pool, "re_cache", re_cache,
-			(rspamd_mempool_destruct_t)g_hash_table_destroy);
+		rspamd_mempool_set_variable (pool, "re_cache", re_cache, (rspamd_mempool_destruct_t)g_hash_table_destroy);
 		return NULL;
 	}
 	return g_hash_table_lookup (re_cache, line);
@@ -119,14 +97,13 @@ re_cache_check (const gchar *line, rspamd_mempool_t *pool)
 void
 re_cache_add (const gchar *line, void *pointer, rspamd_mempool_t *pool)
 {
-	GHashTable *re_cache;
-
+	GHashTable              *re_cache;
+	
 	re_cache = rspamd_mempool_get_variable (pool, "re_cache");
 
 	if (re_cache == NULL) {
 		re_cache = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
-		rspamd_mempool_set_variable (pool, "re_cache", re_cache,
-			(rspamd_mempool_destruct_t)g_hash_table_destroy);
+		rspamd_mempool_set_variable (pool, "re_cache", re_cache, (rspamd_mempool_destruct_t)g_hash_table_destroy);
 	}
 
 	g_hash_table_insert (re_cache, (gpointer)line, pointer);
@@ -135,7 +112,7 @@ re_cache_add (const gchar *line, void *pointer, rspamd_mempool_t *pool)
 void
 re_cache_del (const gchar *line, rspamd_mempool_t *pool)
 {
-	GHashTable *re_cache;
+	GHashTable              *re_cache;
 
 	re_cache = rspamd_mempool_get_variable (pool, "re_cache");
 
@@ -149,19 +126,17 @@ re_cache_del (const gchar *line, rspamd_mempool_t *pool)
  * Functions for parsing expressions
  */
 struct expression_stack {
-	gchar op;
-	struct expression_stack *next;
+	gchar                           op;
+	struct expression_stack        *next;
 };
 
 /*
- * Push operand or operator to stack
+ * Push operand or operator to stack  
  */
 static struct expression_stack *
-push_expression_stack (rspamd_mempool_t * pool,
-	struct expression_stack *head,
-	gchar op)
+push_expression_stack (rspamd_mempool_t * pool, struct expression_stack *head, gchar op)
 {
-	struct expression_stack *new;
+	struct expression_stack        *new;
 	new = rspamd_mempool_alloc (pool, sizeof (struct expression_stack));
 	new->op = op;
 	new->next = head;
@@ -174,8 +149,8 @@ push_expression_stack (rspamd_mempool_t * pool,
 static gchar
 delete_expression_stack (struct expression_stack **head)
 {
-	struct expression_stack *cur;
-	gchar res;
+	struct expression_stack        *cur;
+	gchar                           res;
 
 	if (*head == NULL)
 		return 0;
@@ -210,7 +185,7 @@ logic_priority (gchar a)
  * Return FALSE if symbol is not operation symbol (operand)
  * Return TRUE if symbol is operation symbol
  */
-static gboolean
+static                          gboolean
 is_operation_symbol (gchar *a)
 {
 	switch (*a) {
@@ -222,22 +197,19 @@ is_operation_symbol (gchar *a)
 		return TRUE;
 	case 'O':
 	case 'o':
-		if (g_ascii_strncasecmp (a, "or",
-			sizeof ("or") - 1) == 0 && g_ascii_isspace (a[2])) {
+		if (g_ascii_strncasecmp (a, "or", sizeof ("or") - 1) == 0&& g_ascii_isspace (a[2])) {
 			return TRUE;
 		}
 		break;
 	case 'A':
 	case 'a':
-		if (g_ascii_strncasecmp (a, "and",
-			sizeof ("and") - 1) == 0 && g_ascii_isspace (a[3])) {
+		if (g_ascii_strncasecmp (a, "and", sizeof ("and") - 1) == 0&& g_ascii_isspace (a[3])) {
 			return TRUE;
 		}
 		break;
 	case 'N':
 	case 'n':
-		if (g_ascii_strncasecmp (a, "not",
-			sizeof ("not") - 1) == 0 && g_ascii_isspace (a[3])) {
+		if (g_ascii_strncasecmp (a, "not", sizeof ("not") - 1) == 0 && g_ascii_isspace (a[3])) {
 			return TRUE;
 		}
 		break;
@@ -287,7 +259,7 @@ op_to_char (gchar *a, gchar **next)
 /*
  * Return TRUE if symbol can be regexp flag
  */
-static gboolean
+static                          gboolean
 is_regexp_flag (gchar a)
 {
 	switch (a) {
@@ -312,14 +284,9 @@ is_regexp_flag (gchar a)
 }
 
 static void
-insert_expression (rspamd_mempool_t * pool,
-	struct expression **head,
-	gint type,
-	gchar op,
-	void *operand,
-	const gchar *orig)
+insert_expression (rspamd_mempool_t * pool, struct expression **head, gint type, gchar op, void *operand, const gchar *orig)
 {
-	struct expression *new, *cur;
+	struct expression              *new, *cur;
 
 	new = rspamd_mempool_alloc (pool, sizeof (struct expression));
 	new->type = type;
@@ -344,11 +311,11 @@ insert_expression (rspamd_mempool_t * pool,
 	}
 }
 
-static struct expression *
+static struct expression       *
 maybe_parse_expression (rspamd_mempool_t * pool, gchar *line)
 {
-	struct expression *expr;
-	gchar *p = line;
+	struct expression              *expr;
+	gchar                           *p = line;
 
 	while (*p) {
 		if (is_operation_symbol (p)) {
@@ -369,17 +336,17 @@ maybe_parse_expression (rspamd_mempool_t * pool, gchar *line)
  * Make inverse polish record for specified expression
  * Memory is allocated from given pool
  */
-struct expression *
+struct expression              *
 parse_expression (rspamd_mempool_t * pool, gchar *line)
 {
-	struct expression *expr = NULL;
-	struct expression_stack *stack = NULL;
-	struct expression_function *func = NULL;
-	struct expression *arg;
-	GQueue *function_stack;
-	gchar *p, *c, *str, op, newop, *copy, *next;
-	gboolean in_regexp = FALSE;
-	gint brackets = 0;
+	struct expression              *expr = NULL;
+	struct expression_stack        *stack = NULL;
+	struct expression_function     *func = NULL;
+	struct expression              *arg;
+	GQueue                         *function_stack;
+	gchar                           *p, *c, *str, op, newop, *copy, *next;
+	gboolean                        in_regexp = FALSE;
+	gint                            brackets = 0;
 
 	enum {
 		SKIP_SPACES,
@@ -429,12 +396,7 @@ parse_expression (rspamd_mempool_t * pool, gchar *line)
 				while (stack && stack->op != '(') {
 					op = delete_expression_stack (&stack);
 					if (op != '(') {
-						insert_expression (pool,
-							&expr,
-							EXPR_OPERATION,
-							op,
-							NULL,
-							copy);
+						insert_expression (pool, &expr, EXPR_OPERATION, op, NULL, copy);
 					}
 				}
 				if (stack) {
@@ -459,23 +421,15 @@ parse_expression (rspamd_mempool_t * pool, gchar *line)
 				else {
 					newop = op_to_char (p, &next);
 					if (newop != '\0') {
-						if (logic_priority (stack->op) <
-							logic_priority (newop)) {
+						if (logic_priority (stack->op) < logic_priority (newop)) {
 							stack = push_expression_stack (pool, stack, newop);
 						}
 						else {
 							/* Pop all operations that have higher priority than this one */
-							while ((stack != NULL) &&
-								(logic_priority (stack->op) >=
-								logic_priority (newop))) {
+							while ((stack != NULL) && (logic_priority (stack->op) >= logic_priority (newop))) {
 								op = delete_expression_stack (&stack);
 								if (op != '(') {
-									insert_expression (pool,
-										&expr,
-										EXPR_OPERATION,
-										op,
-										NULL,
-										copy);
+									insert_expression (pool, &expr, EXPR_OPERATION, op, NULL, copy);
 								}
 							}
 							stack = push_expression_stack (pool, stack, newop);
@@ -505,8 +459,7 @@ parse_expression (rspamd_mempool_t * pool, gchar *line)
 		case READ_REGEXP_FLAGS:
 			if (!is_regexp_flag (*p) || *(p + 1) == '\0') {
 				if (c != p) {
-					if ((is_regexp_flag (*p) || *p ==
-						'/') && *(p + 1) == '\0') {
+					if ((is_regexp_flag (*p) || *p == '/') && *(p + 1) == '\0') {
 						p++;
 					}
 					str = rspamd_mempool_alloc (pool, p - c + 2);
@@ -514,12 +467,7 @@ parse_expression (rspamd_mempool_t * pool, gchar *line)
 					g_strstrip (str);
 					msg_debug ("found regexp: %s", str);
 					if (strlen (str) > 0) {
-						insert_expression (pool,
-							&expr,
-							EXPR_REGEXP,
-							0,
-							str,
-							copy);
+						insert_expression (pool, &expr, EXPR_REGEXP, 0, str, copy);
 					}
 				}
 				c = p;
@@ -538,9 +486,7 @@ parse_expression (rspamd_mempool_t * pool, gchar *line)
 				p++;
 			}
 			else if (*p == '(') {
-				func =
-					rspamd_mempool_alloc (pool,
-						sizeof (struct expression_function));
+				func = rspamd_mempool_alloc (pool, sizeof (struct expression_function));
 				func->name = rspamd_mempool_alloc (pool, p - c + 1);
 				func->args = NULL;
 				rspamd_strlcpy (func->name, c, (p - c + 1));
@@ -640,14 +586,14 @@ parse_expression (rspamd_mempool_t * pool, gchar *line)
 /*
  * Rspamd regexp utility functions
  */
-struct rspamd_regexp *
+struct rspamd_regexp           *
 parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
 {
-	const gchar *begin, *end, *p, *src, *start;
-	gchar *dbegin, *dend;
-	struct rspamd_regexp *result, *check;
-	gint regexp_flags = G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE;
-	GError *err = NULL;
+	const gchar                    *begin, *end, *p, *src, *start;
+	gchar                          *dbegin, *dend;
+	struct rspamd_regexp           *result, *check;
+	gint                            regexp_flags = G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE;
+	GError                         *err = NULL;
 
 	if (line == NULL) {
 		msg_err ("cannot parse NULL line");
@@ -675,7 +621,7 @@ parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
 				end = p;
 				break;
 			}
-			p--;
+			p --;
 		}
 		if (end) {
 			result->header = rspamd_mempool_alloc (pool, end - line + 1);
@@ -704,9 +650,7 @@ parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
 	}
 	else {
 		/* We got header name earlier but have not found // expression, so it is invalid regexp */
-		msg_warn (
-			"got no header name (eg. header=) but without corresponding regexp, %s",
-			src);
+		msg_warn ("got no header name (eg. header=) but without corresponding regexp, %s", src);
 		return NULL;
 	}
 	/* Find end */
@@ -751,7 +695,7 @@ parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
 			result->is_raw = TRUE;
 			p++;
 			break;
-		/* Type flags */
+			/* Type flags */
 		case 'H':
 			if (result->type == REGEXP_NONE) {
 				result->type = REGEXP_HEADER;
@@ -784,13 +728,13 @@ parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
 			break;
 		case 'T':
 			result->is_test = TRUE;
-			p++;
+			p ++;
 			break;
 		case 'S':
 			result->is_strong = TRUE;
-			p++;
+			p ++;
 			break;
-		/* Stop flags parsing */
+			/* Stop flags parsing */
 		default:
 			p = NULL;
 			break;
@@ -807,12 +751,9 @@ parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
 	}
 
 	/* Avoid multiply regexp structures for similar regexps */
-	if ((check =
-		(struct rspamd_regexp *)re_cache_check (result->regexp_text,
-		pool)) != NULL) {
+	if ((check = (struct rspamd_regexp *)re_cache_check (result->regexp_text, pool)) != NULL) {
 		/* Additional check for headers */
-		if (result->type == REGEXP_HEADER || result->type ==
-			REGEXP_RAW_HEADER) {
+		if (result->type == REGEXP_HEADER || result->type == REGEXP_RAW_HEADER) {
 			if (result->header && check->header) {
 				if (strcmp (result->header, check->header) == 0) {
 					return check;
@@ -828,31 +769,20 @@ parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
 		result->raw_regexp = result->regexp;
 	}
 	else {
-		result->raw_regexp = g_regex_new (dbegin,
-				regexp_flags | G_REGEX_RAW,
-				0,
-				&err);
-		rspamd_mempool_add_destructor (pool,
-			(rspamd_mempool_destruct_t) g_regex_unref,
-			(void *)result->raw_regexp);
-	}
-	rspamd_mempool_add_destructor (pool,
-		(rspamd_mempool_destruct_t) g_regex_unref,
-		(void *)result->regexp);
+		result->raw_regexp = g_regex_new (dbegin, regexp_flags | G_REGEX_RAW, 0, &err);
+		rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_regex_unref, (void *)result->raw_regexp);
+	}
+	rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_regex_unref, (void *)result->regexp);
 
 	*dend = '/';
 
 	if (result->regexp == NULL || err != NULL) {
-		msg_warn ("could not read regexp: %s while reading regexp %s",
-			err->message,
-			src);
+		msg_warn ("could not read regexp: %s while reading regexp %s", err->message, src);
 		return NULL;
 	}
 
 	if (result->raw_regexp == NULL || err != NULL) {
-		msg_warn ("could not read raw regexp: %s while reading regexp %s",
-			err->message,
-			src);
+		msg_warn ("could not read raw regexp: %s while reading regexp %s", err->message, src);
 		return NULL;
 	}
 
@@ -862,19 +792,13 @@ parse_regexp (rspamd_mempool_t * pool, const gchar *line, gboolean raw_mode)
 }
 
 gboolean
-call_expression_function (struct expression_function * func,
-	struct rspamd_task * task,
-	lua_State *L)
+call_expression_function (struct expression_function * func, struct rspamd_task * task, lua_State *L)
 {
-	struct _fl *selected, key;
+	struct _fl                     *selected, key;
 
 	key.name = func->name;
 
-	selected = bsearch (&key,
-			list_ptr,
-			functions_number,
-			sizeof (struct _fl),
-			fl_cmp);
+	selected = bsearch (&key, list_ptr, functions_number, sizeof (struct _fl), fl_cmp);
 	if (selected == NULL) {
 		/* Try to check lua function */
 		return FALSE;
@@ -883,26 +807,21 @@ call_expression_function (struct expression_function * func,
 	return selected->func (task, func->args, selected->user_data);
 }
 
-struct expression_argument *
-get_function_arg (struct expression *expr,
-	struct rspamd_task *task,
-	gboolean want_string)
+struct expression_argument     *
+get_function_arg (struct expression *expr, struct rspamd_task *task, gboolean want_string)
 {
-	GQueue *stack;
-	gsize cur, op1, op2;
-	struct expression_argument *res;
-	struct expression *it;
+	GQueue                         *stack;
+	gsize                           cur, op1, op2;
+	struct expression_argument     *res;
+	struct expression              *it;
 
 	if (expr == NULL) {
 		msg_warn ("NULL expression passed");
 		return NULL;
 	}
 	if (expr->next == NULL) {
-		res =
-			rspamd_mempool_alloc (task->task_pool,
-				sizeof (struct expression_argument));
-		if (expr->type == EXPR_REGEXP || expr->type == EXPR_STR || expr->type ==
-			EXPR_REGEXP_PARSED) {
+		res = rspamd_mempool_alloc (task->task_pool, sizeof (struct expression_argument));
+		if (expr->type == EXPR_REGEXP || expr->type == EXPR_STR || expr->type == EXPR_REGEXP_PARSED) {
 			res->type = EXPRESSION_ARGUMENT_NORMAL;
 			res->data = expr->content.operand;
 		}
@@ -912,36 +831,27 @@ get_function_arg (struct expression *expr,
 			res->data = GSIZE_TO_POINTER (cur);
 		}
 		else {
-			msg_warn (
-				"cannot parse argument: it contains operator or bool expression that is not wanted");
+			msg_warn ("cannot parse argument: it contains operator or bool expression that is not wanted");
 			return NULL;
 		}
 		return res;
 	}
 	else if (!want_string) {
-		res =
-			rspamd_mempool_alloc (task->task_pool,
-				sizeof (struct expression_argument));
+		res = rspamd_mempool_alloc (task->task_pool, sizeof (struct expression_argument));
 		res->type = EXPRESSION_ARGUMENT_BOOL;
 		stack = g_queue_new ();
 		it = expr;
 
 		while (it) {
-			if (it->type == EXPR_REGEXP || it->type == EXPR_REGEXP_PARSED ||
-				it->type == EXPR_STR) {
+			if (it->type == EXPR_REGEXP || it->type == EXPR_REGEXP_PARSED || it->type == EXPR_STR) {
 				g_queue_free (stack);
 				res->type = EXPRESSION_ARGUMENT_EXPR;
 				res->data = expr;
 				return res;
 			}
 			else if (it->type == EXPR_FUNCTION) {
-				cur =
-					(gsize) call_expression_function ((struct
-						expression_function
-						*)it->content.operand, task, NULL);
-				debug_task ("function %s returned %s",
-					((struct expression_function *)it->content.operand)->name,
-					cur ? "true" : "false");
+				cur = (gsize) call_expression_function ((struct expression_function *)it->content.operand, task, NULL);
+				debug_task ("function %s returned %s", ((struct expression_function *)it->content.operand)->name, cur ? "true" : "false");
 			}
 			else if (it->type == EXPR_OPERATION) {
 				if (g_queue_is_empty (stack)) {
@@ -991,11 +901,9 @@ get_function_arg (struct expression *expr,
 }
 
 void
-register_expression_function (const gchar *name,
-	rspamd_internal_func_t func,
-	void *user_data)
+register_expression_function (const gchar *name, rspamd_internal_func_t func, void *user_data)
 {
-	static struct _fl *new;
+	static struct _fl              *new;
 
 	functions_number++;
 
@@ -1016,7 +924,7 @@ register_expression_function (const gchar *name,
 gboolean
 rspamd_compare_encoding (struct rspamd_task *task, GList * args, void *unused)
 {
-	struct expression_argument *arg;
+	struct expression_argument     *arg;
 
 	if (args == NULL || task == NULL) {
 		return FALSE;
@@ -1035,8 +943,8 @@ rspamd_compare_encoding (struct rspamd_task *task, GList * args, void *unused)
 gboolean
 rspamd_header_exists (struct rspamd_task * task, GList * args, void *unused)
 {
-	struct expression_argument *arg;
-	GList *headerlist;
+	struct expression_argument     *arg;
+	GList                          *headerlist;
 
 	if (args == NULL || task == NULL) {
 		return FALSE;
@@ -1049,10 +957,7 @@ rspamd_header_exists (struct rspamd_task * task, GList * args, void *unused)
 	}
 
 	debug_task ("try to get header %s", (gchar *)arg->data);
-	headerlist = message_get_header (task->task_pool,
-			task->message,
-			(gchar *)arg->data,
-			FALSE);
+	headerlist = message_get_header (task->task_pool, task->message, (gchar *)arg->data, FALSE);
 	if (headerlist) {
 		g_list_free (headerlist);
 		return TRUE;
@@ -1062,20 +967,20 @@ rspamd_header_exists (struct rspamd_task * task, GList * args, void *unused)
 
 /*
  * This function is designed to find difference between text/html and text/plain parts
- * It takes one argument: difference threshold, if we have two text parts, compare
+ * It takes one argument: difference threshold, if we have two text parts, compare 
  * its hashes and check for threshold, if value is greater than threshold, return TRUE
  * and return FALSE otherwise.
  */
 gboolean
 rspamd_parts_distance (struct rspamd_task * task, GList * args, void *unused)
 {
-	gint threshold, threshold2 = -1, diff;
-	struct mime_text_part *p1, *p2;
-	GList *cur;
-	struct expression_argument *arg;
-	GMimeObject *parent;
-	const GMimeContentType *ct;
-	gint *pdiff;
+	gint                            threshold, threshold2 = -1, diff;
+	struct mime_text_part          *p1, *p2;
+	GList                          *cur;
+	struct expression_argument     *arg;
+	GMimeObject                    *parent;
+	const GMimeContentType         *ct;
+	gint                           *pdiff;
 
 	if (args == NULL) {
 		debug_task ("no threshold is specified, assume it 100");
@@ -1086,8 +991,7 @@ rspamd_parts_distance (struct rspamd_task * task, GList * args, void *unused)
 		arg = get_function_arg (args->data, task, TRUE);
 		threshold = strtoul ((gchar *)arg->data, NULL, 10);
 		if (errno != 0) {
-			msg_info ("bad numeric value for threshold \"%s\", assume it 100",
-				(gchar *)args->data);
+			msg_info ("bad numeric value for threshold \"%s\", assume it 100", (gchar *)args->data);
 			threshold = 100;
 		}
 		if (args->next) {
@@ -1095,22 +999,17 @@ rspamd_parts_distance (struct rspamd_task * task, GList * args, void *unused)
 			errno = 0;
 			threshold2 = strtoul ((gchar *)arg->data, NULL, 10);
 			if (errno != 0) {
-				msg_info ("bad numeric value for threshold \"%s\", ignore it",
-					(gchar *)arg->data);
+				msg_info ("bad numeric value for threshold \"%s\", ignore it", (gchar *)arg->data);
 				threshold2 = -1;
 			}
 		}
 	}
 
-	if ((pdiff =
-		rspamd_mempool_get_variable (task->task_pool,
-		"parts_distance")) != NULL) {
+	if ((pdiff = rspamd_mempool_get_variable (task->task_pool, "parts_distance")) != NULL) {
 		diff = *pdiff;
 		if (diff != -1) {
 			if (threshold2 > 0) {
-				if (diff >=
-					MIN (threshold,
-					threshold2) && diff < MAX (threshold, threshold2)) {
+				if (diff >= MIN (threshold, threshold2) && diff < MAX (threshold, threshold2)) {
 					return TRUE;
 				}
 			}
@@ -1143,52 +1042,32 @@ rspamd_parts_distance (struct rspamd_task * task, GList * args, void *unused)
 			parent = p1->parent;
 			ct = g_mime_object_get_content_type (parent);
 #ifndef GMIME24
-			if (ct == NULL ||
-				!g_mime_content_type_is_type (ct, "multipart", "alternative")) {
+			if (ct == NULL || ! g_mime_content_type_is_type (ct, "multipart", "alternative")) {
 #else
-			if (ct == NULL ||
-				!g_mime_content_type_is_type ((GMimeContentType *)ct,
-				"multipart", "alternative")) {
+			if (ct == NULL || ! g_mime_content_type_is_type ((GMimeContentType *)ct, "multipart", "alternative")) {
 #endif
-				debug_task (
-					"two parts are not belong to multipart/alternative container, skip check");
-				rspamd_mempool_set_variable (task->task_pool,
-					"parts_distance",
-					pdiff,
-					NULL);
+				debug_task ("two parts are not belong to multipart/alternative container, skip check");
+				rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
 				return FALSE;
 			}
 		}
 		else {
-			debug_task (
-				"message contains two parts but they are in different multi-parts");
-			rspamd_mempool_set_variable (task->task_pool,
-				"parts_distance",
-				pdiff,
-				NULL);
+			debug_task ("message contains two parts but they are in different multi-parts");
+			rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
 			return FALSE;
 		}
 		if (!p1->is_empty && !p2->is_empty) {
 			if (p1->diff_str != NULL && p2->diff_str != NULL) {
-				diff = compare_diff_distance_normalized (p1->diff_str,
-						p2->diff_str);
+				diff = compare_diff_distance_normalized (p1->diff_str, p2->diff_str);
 			}
 			else {
 				diff = fuzzy_compare_parts (p1, p2);
 			}
-			debug_task (
-				"got likeliness between parts of %d%%, threshold is %d%%",
-				diff,
-				threshold);
+			debug_task ("got likeliness between parts of %d%%, threshold is %d%%", diff, threshold);
 			*pdiff = diff;
-			rspamd_mempool_set_variable (task->task_pool,
-				"parts_distance",
-				pdiff,
-				NULL);
+			rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
 			if (threshold2 > 0) {
-				if (diff >=
-					MIN (threshold,
-					threshold2) && diff < MAX (threshold, threshold2)) {
+				if (diff >= MIN (threshold, threshold2) && diff < MAX (threshold, threshold2)) {
 					return TRUE;
 				}
 			}
@@ -1198,51 +1077,41 @@ rspamd_parts_distance (struct rspamd_task * task, GList * args, void *unused)
 				}
 			}
 		}
-		else if ((p1->is_empty &&
-			!p2->is_empty) || (!p1->is_empty && p2->is_empty)) {
+		else if ((p1->is_empty && !p2->is_empty) || (!p1->is_empty && p2->is_empty)) {
 			/* Empty and non empty parts are different */
 			*pdiff = 0;
-			rspamd_mempool_set_variable (task->task_pool,
-				"parts_distance",
-				pdiff,
-				NULL);
+			rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
 			return TRUE;
 		}
 	}
 	else {
-		debug_task (
-			"message has too many text parts, so do not try to compare them with each other");
-		rspamd_mempool_set_variable (task->task_pool,
-			"parts_distance",
-			pdiff,
-			NULL);
+		debug_task ("message has too many text parts, so do not try to compare them with each other");
+		rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
 		return FALSE;
 	}
 
-	rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff,
-		NULL);
+	rspamd_mempool_set_variable (task->task_pool, "parts_distance", pdiff, NULL);
 	return FALSE;
 }
 
 struct addr_list {
-	const gchar *name;
-	const gchar *addr;
+	const gchar                     *name;
+	const gchar                     *addr;
 };
 
 #define COMPARE_RCPT_LEN 3
 #define MIN_RCPT_TO_COMPARE 7
 
 gboolean
-rspamd_recipients_distance (struct rspamd_task *task, GList * args,
-	void *unused)
+rspamd_recipients_distance (struct rspamd_task *task, GList * args, void *unused)
 {
-	struct expression_argument *arg;
-	InternetAddressList *cur;
-	InternetAddress *addr;
-	double threshold;
-	struct addr_list *ar;
-	gchar *c;
-	gint num, i, j, hits = 0, total = 0;
+	struct expression_argument     *arg;
+	InternetAddressList            *cur;
+	InternetAddress                *addr;
+	double                          threshold;
+	struct addr_list               *ar;
+	gchar                           *c;
+	gint                            num, i, j, hits = 0, total = 0;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -1253,9 +1122,7 @@ rspamd_recipients_distance (struct rspamd_task *task, GList * args,
 	errno = 0;
 	threshold = strtod ((gchar *)arg->data, NULL);
 	if (errno != 0) {
-		msg_warn ("invalid numeric value '%s': %s",
-			(gchar *)arg->data,
-			strerror (errno));
+		msg_warn ("invalid numeric value '%s': %s", (gchar *)arg->data, strerror (errno));
 		return FALSE;
 	}
 
@@ -1266,17 +1133,14 @@ rspamd_recipients_distance (struct rspamd_task *task, GList * args,
 	if (num < MIN_RCPT_TO_COMPARE) {
 		return FALSE;
 	}
-	ar =
-		rspamd_mempool_alloc0 (task->task_pool, num *
-			sizeof (struct addr_list));
+	ar = rspamd_mempool_alloc0 (task->task_pool, num * sizeof (struct addr_list));
 
 	/* Fill array */
 	cur = task->rcpts;
 #ifdef GMIME24
-	for (i = 0; i < num; i++) {
+	for (i = 0; i < num; i ++) {
 		addr = internet_address_list_get_address (cur, i);
-		ar[i].name = rspamd_mempool_strdup (task->task_pool,
-				internet_address_get_name (addr));
+		ar[i].name = rspamd_mempool_strdup (task->task_pool, internet_address_get_name (addr));
 		if (ar[i].name != NULL && (c = strchr (ar[i].name, '@')) != NULL) {
 			*c = '\0';
 			ar[i].addr = c + 1;
@@ -1287,8 +1151,7 @@ rspamd_recipients_distance (struct rspamd_task *task, GList * args,
 	while (cur) {
 		addr = internet_address_list_get_address (cur);
 		if (addr && internet_address_get_type (addr) == INTERNET_ADDRESS_NAME) {
-			ar[i].name = rspamd_mempool_strdup (task->task_pool,
-					internet_address_get_addr (addr));
+			ar[i].name = rspamd_mempool_strdup (task->task_pool, internet_address_get_addr (addr));
 			if (ar[i].name != NULL && (c = strchr (ar[i].name, '@')) != NULL) {
 				*c = '\0';
 				ar[i].addr = c + 1;
@@ -1305,14 +1168,11 @@ rspamd_recipients_distance (struct rspamd_task *task, GList * args,
 	/* Cycle all elements in array */
 	for (i = 0; i < num; i++) {
 		for (j = i + 1; j < num; j++) {
-			if (ar[i].name && ar[j].name &&
-				g_ascii_strncasecmp (ar[i].name, ar[j].name,
-				COMPARE_RCPT_LEN) == 0) {
+			if (ar[i].name && ar[j].name && g_ascii_strncasecmp (ar[i].name, ar[j].name, COMPARE_RCPT_LEN) == 0) {
 				/* Common name part */
 				hits++;
 			}
-			else if (ar[i].addr && ar[j].addr &&
-				g_ascii_strcasecmp (ar[i].addr, ar[j].addr) == 0) {
+			else if (ar[i].addr && ar[j].addr && g_ascii_strcasecmp (ar[i].addr, ar[j].addr) == 0) {
 				/* Common address part, but different name */
 				hits++;
 			}
@@ -1328,12 +1188,11 @@ rspamd_recipients_distance (struct rspamd_task *task, GList * args,
 }
 
 gboolean
-rspamd_has_only_html_part (struct rspamd_task * task, GList * args,
-	void *unused)
+rspamd_has_only_html_part (struct rspamd_task * task, GList * args, void *unused)
 {
-	struct mime_text_part *p;
-	GList *cur;
-	gboolean res = FALSE;
+	struct mime_text_part          *p;
+	GList                          *cur;
+	gboolean                        res = FALSE;
 
 	cur = g_list_first (task->text_parts);
 	while (cur) {
@@ -1351,34 +1210,30 @@ rspamd_has_only_html_part (struct rspamd_task * task, GList * args,
 	return res;
 }
 
-static gboolean
+static                          gboolean
 is_recipient_list_sorted (const InternetAddressList * ia)
 {
-	const InternetAddressList *cur;
-	InternetAddress *addr;
-	gboolean res = TRUE;
-	struct addr_list current = { NULL, NULL }, previous = {
-		NULL, NULL
-	};
+	const InternetAddressList      *cur;
+	InternetAddress                *addr;
+	gboolean                        res = TRUE;
+	struct addr_list                current = { NULL, NULL }, previous = {
+	NULL, NULL};
 #ifdef GMIME24
-	gint num, i;
+	gint                            num, i;
 #endif
 
 	/* Do not check to short address lists */
-	if (internet_address_list_length ((InternetAddressList *)ia) <
-		MIN_RCPT_TO_COMPARE) {
+	if (internet_address_list_length ((InternetAddressList *)ia) < MIN_RCPT_TO_COMPARE) {
 		return FALSE;
 	}
 #ifdef GMIME24
 	num = internet_address_list_length ((InternetAddressList *)ia);
 	cur = ia;
-	for (i = 0; i < num; i++) {
-		addr =
-			internet_address_list_get_address ((InternetAddressList *)cur, i);
+	for (i = 0; i < num; i ++) {
+		addr = internet_address_list_get_address ((InternetAddressList *)cur, i);
 		current.addr = (gchar *)internet_address_get_name (addr);
 		if (previous.addr != NULL) {
-			if (current.addr &&
-				g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
+			if (current.addr && g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
 				res = FALSE;
 				break;
 			}
@@ -1392,8 +1247,7 @@ is_recipient_list_sorted (const InternetAddressList * ia)
 		if (internet_address_get_type (addr) == INTERNET_ADDRESS_NAME) {
 			current.addr = internet_address_get_addr (addr);
 			if (previous.addr != NULL) {
-				if (current.addr &&
-					g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
+				if (current.addr && g_ascii_strcasecmp (current.addr, previous.addr) < 0) {
 					res = FALSE;
 					break;
 				}
@@ -1408,21 +1262,16 @@ is_recipient_list_sorted (const InternetAddressList * ia)
 }
 
 gboolean
-rspamd_is_recipients_sorted (struct rspamd_task * task,
-	GList * args,
-	void *unused)
+rspamd_is_recipients_sorted (struct rspamd_task * task, GList * args, void *unused)
 {
 	/* Check all types of addresses */
-	if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
-		GMIME_RECIPIENT_TYPE_TO)) == TRUE) {
+	if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message, GMIME_RECIPIENT_TYPE_TO)) == TRUE) {
 		return TRUE;
 	}
-	if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
-		GMIME_RECIPIENT_TYPE_BCC)) == TRUE) {
+	if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message, GMIME_RECIPIENT_TYPE_BCC)) == TRUE) {
 		return TRUE;
 	}
-	if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
-		GMIME_RECIPIENT_TYPE_CC)) == TRUE) {
+	if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message, GMIME_RECIPIENT_TYPE_CC)) == TRUE) {
 		return TRUE;
 	}
 
@@ -1430,17 +1279,15 @@ rspamd_is_recipients_sorted (struct rspamd_task * task,
 }
 
 gboolean
-rspamd_compare_transfer_encoding (struct rspamd_task * task,
-	GList * args,
-	void *unused)
+rspamd_compare_transfer_encoding (struct rspamd_task * task, GList * args, void *unused)
 {
-	GMimeObject *part;
+	GMimeObject                    *part;
 #ifndef GMIME24
-	GMimePartEncodingType enc_req, part_enc;
+	GMimePartEncodingType           enc_req, part_enc;
 #else
-	GMimeContentEncoding enc_req, part_enc;
+	GMimeContentEncoding            enc_req, part_enc;
 #endif
-	struct expression_argument *arg;
+	struct expression_argument     *arg;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -1477,9 +1324,7 @@ rspamd_compare_transfer_encoding (struct rspamd_task * task,
 #endif
 
 
-			debug_task ("got encoding in part: %d and compare with %d",
-				(gint)part_enc,
-				(gint)enc_req);
+			debug_task ("got encoding in part: %d and compare with %d", (gint)part_enc, (gint)enc_req);
 #ifndef GMIME24
 			g_object_unref (part);
 #endif
@@ -1497,9 +1342,9 @@ rspamd_compare_transfer_encoding (struct rspamd_task * task,
 gboolean
 rspamd_is_html_balanced (struct rspamd_task * task, GList * args, void *unused)
 {
-	struct mime_text_part *p;
-	GList *cur;
-	gboolean res = TRUE;
+	struct mime_text_part          *p;
+	GList                          *cur;
+	gboolean                        res = TRUE;
 
 	cur = g_list_first (task->text_parts);
 	while (cur) {
@@ -1521,15 +1366,15 @@ rspamd_is_html_balanced (struct rspamd_task * task, GList * args, void *unused)
 }
 
 struct html_callback_data {
-	struct html_tag *tag;
-	gboolean *res;
+	struct html_tag                *tag;
+	gboolean                       *res;
 };
 
-static gboolean
+static                          gboolean
 search_html_node_callback (GNode * node, gpointer data)
 {
-	struct html_callback_data *cd = data;
-	struct html_node *nd;
+	struct html_callback_data      *cd = data;
+	struct html_node               *nd;
 
 	nd = node->data;
 	if (nd) {
@@ -1545,12 +1390,12 @@ search_html_node_callback (GNode * node, gpointer data)
 gboolean
 rspamd_has_html_tag (struct rspamd_task * task, GList * args, void *unused)
 {
-	struct mime_text_part *p;
-	GList *cur;
-	struct expression_argument *arg;
-	struct html_tag *tag;
-	gboolean res = FALSE;
-	struct html_callback_data cd;
+	struct mime_text_part          *p;
+	GList                          *cur;
+	struct expression_argument     *arg;
+	struct html_tag                *tag;
+	gboolean                        res = FALSE;
+	struct html_callback_data       cd;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -1560,8 +1405,7 @@ rspamd_has_html_tag (struct rspamd_task * task, GList * args, void *unused)
 	arg = get_function_arg (args->data, task, TRUE);
 	tag = get_tag_by_name (arg->data);
 	if (tag == NULL) {
-		msg_warn ("unknown tag type passed as argument: %s",
-			(gchar *)arg->data);
+		msg_warn ("unknown tag type passed as argument: %s", (gchar *)arg->data);
 		return FALSE;
 	}
 
@@ -1572,12 +1416,7 @@ rspamd_has_html_tag (struct rspamd_task * task, GList * args, void *unused)
 	while (cur && res == FALSE) {
 		p = cur->data;
 		if (!p->is_empty && p->is_html && p->html_nodes) {
-			g_node_traverse (p->html_nodes,
-				G_PRE_ORDER,
-				G_TRAVERSE_ALL,
-				-1,
-				search_html_node_callback,
-				&cd);
+			g_node_traverse (p->html_nodes, G_PRE_ORDER, G_TRAVERSE_ALL, -1, search_html_node_callback, &cd);
 		}
 		cur = g_list_next (cur);
 	}
@@ -1589,9 +1428,9 @@ rspamd_has_html_tag (struct rspamd_task * task, GList * args, void *unused)
 gboolean
 rspamd_has_fake_html (struct rspamd_task * task, GList * args, void *unused)
 {
-	struct mime_text_part *p;
-	GList *cur;
-	gboolean res = FALSE;
+	struct mime_text_part          *p;
+	GList                          *cur;
+	gboolean                        res = FALSE;
 
 	cur = g_list_first (task->text_parts);
 
diff --git a/src/libmime/expressions.h b/src/libmime/expressions.h
index 1ba02d956..954cc74f7 100644
--- a/src/libmime/expressions.h
+++ b/src/libmime/expressions.h
@@ -16,8 +16,8 @@ struct rspamd_regexp;
  * Rspamd expression function
  */
 struct expression_function {
-	gchar *name;                                                    /**< name of function								*/
-	GList *args;                                                /**< its args										*/
+	gchar *name;													/**< name of function								*/
+	GList *args;												/**< its args										*/
 };
 
 /**
@@ -28,31 +28,30 @@ struct expression_argument {
 		EXPRESSION_ARGUMENT_NORMAL,
 		EXPRESSION_ARGUMENT_BOOL,
 		EXPRESSION_ARGUMENT_EXPR,
-	} type;                                                     /**< type of argument (text or other function)		*/
-	void *data;                                                 /**< pointer to its data							*/
+	} type;														/**< type of argument (text or other function)		*/
+	void *data;													/**< pointer to its data							*/
 };
 
-/**
- * Logic expression
+/** 
+ * Logic expression 
  */
 struct expression {
-	enum {
+	enum { 
 		EXPR_REGEXP,
-		EXPR_OPERATION,
-		EXPR_FUNCTION,
-		EXPR_STR,
+		EXPR_OPERATION, 
+		EXPR_FUNCTION, 
+		EXPR_STR, 
 		EXPR_REGEXP_PARSED,
-	} type;                                                     /**< expression type								*/
+	} type;														/**< expression type								*/
 	union {
 		void *operand;
 		gchar operation;
-	} content;                                                  /**< union for storing operand or operation code    */
-	const gchar *orig;                                          /**< original line									*/
-	struct expression *next;                                    /**< chain link										*/
+	} content;													/**< union for storing operand or operation code 	*/
+	const gchar *orig;											/**< original line									*/
+	struct expression *next;									/**< chain link										*/
 };
 
-typedef gboolean (*rspamd_internal_func_t)(struct rspamd_task *, GList *args,
-	void *user_data);
+typedef gboolean (*rspamd_internal_func_t)(struct rspamd_task *, GList *args, void *user_data);
 
 /**
  * Parse regexp line to regexp structure
@@ -60,9 +59,7 @@ typedef gboolean (*rspamd_internal_func_t)(struct rspamd_task *, GList *args,
  * @param line incoming line
  * @return regexp structure or NULL in case of error
  */
-struct rspamd_regexp * parse_regexp (rspamd_mempool_t *pool,
-	const gchar *line,
-	gboolean raw_mode);
+struct rspamd_regexp* parse_regexp (rspamd_mempool_t *pool, const gchar *line, gboolean raw_mode);
 
 /**
  * Parse composites line to composites structure (eg. "SYMBOL1&SYMBOL2|!SYMBOL3")
@@ -70,7 +67,7 @@ struct rspamd_regexp * parse_regexp (rspamd_mempool_t *pool,
  * @param line incoming line
  * @return expression structure or NULL in case of error
  */
-struct expression * parse_expression (rspamd_mempool_t *pool, gchar *line);
+struct expression* parse_expression (rspamd_mempool_t *pool, gchar *line);
 
 /**
  * Call specified fucntion and return boolean result
@@ -79,18 +76,14 @@ struct expression * parse_expression (rspamd_mempool_t *pool, gchar *line);
  * @param L lua specific state
  * @return TRUE or FALSE depending on function result
  */
-gboolean call_expression_function (struct expression_function *func,
-	struct rspamd_task *task,
-	lua_State *L);
+gboolean call_expression_function (struct expression_function *func, struct rspamd_task *task, lua_State *L);
 
 /**
  * Register specified function to rspamd internal functions list
  * @param name name of function
  * @param func pointer to function
  */
-void register_expression_function (const gchar *name,
-	rspamd_internal_func_t func,
-	void *user_data);
+void register_expression_function (const gchar *name, rspamd_internal_func_t func, void *user_data);
 
 /**
  * Add regexp to regexp cache
@@ -118,9 +111,7 @@ void re_cache_del (const gchar *line, rspamd_mempool_t *pool);
  * @param pointer regexp data
  * @param result numeric result of this regexp
  */
-void task_cache_add (struct rspamd_task *task,
-	struct rspamd_regexp *re,
-	gint32 result);
+void task_cache_add (struct rspamd_task *task, struct rspamd_regexp *re, gint32 result);
 
 /**
  * Check regexp in cache
@@ -137,8 +128,6 @@ gint32 task_cache_check (struct rspamd_task *task, struct rspamd_regexp *re);
  * @param want_string return NULL if argument is not a string
  * @return expression argument structure or NULL if failed
  */
-struct expression_argument * get_function_arg (struct expression *expr,
-	struct rspamd_task *task,
-	gboolean want_string);
+struct expression_argument *get_function_arg (struct expression *expr, struct rspamd_task *task, gboolean want_string);
 
 #endif
diff --git a/src/libmime/filter.c b/src/libmime/filter.c
index f296617cf..2068c79e3 100644
--- a/src/libmime/filter.c
+++ b/src/libmime/filter.c
@@ -22,18 +22,18 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "binlog.h"
-#include "cfg_file.h"
-#include "classifiers/classifiers.h"
 #include "config.h"
-#include "diff.h"
-#include "expressions.h"
+#include "mem_pool.h"
 #include "filter.h"
 #include "main.h"
-#include "mem_pool.h"
 #include "message.h"
-#include "tokenizers/tokenizers.h"
+#include "cfg_file.h"
 #include "util.h"
+#include "expressions.h"
+#include "binlog.h"
+#include "diff.h"
+#include "classifiers/classifiers.h"
+#include "tokenizers/tokenizers.h"
 
 #ifdef WITH_LUA
 #   include "lua/lua_common.h"
@@ -44,56 +44,44 @@
 #ifndef PARAM_H_HAS_BITSET
 /* Bit map related macros. */
 #define NBBY    8               /* number of bits in a byte */
-#define setbit(a, \
-		i)     (((unsigned char *)(a))[(i) / NBBY] |= 1 << ((i) % NBBY))
-#define clrbit(a, \
-		i)     (((unsigned char *)(a))[(i) / NBBY] &= ~(1 << ((i) % NBBY)))
+#define setbit(a,i)     (((unsigned char *)(a))[(i)/NBBY] |= 1<<((i)%NBBY))
+#define clrbit(a,i)     (((unsigned char *)(a))[(i)/NBBY] &= ~(1<<((i)%NBBY)))
 #define isset(a,i)                                                      \
-	(((const unsigned char *)(a))[(i) / NBBY] & (1 << ((i) % NBBY)))
+        (((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY)))
 #define isclr(a,i)                                                      \
-	((((const unsigned char *)(a))[(i) / NBBY] & (1 << ((i) % NBBY))) == 0)
+        ((((const unsigned char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
 #endif
-#define BITSPERBYTE (8 * sizeof (gchar))
-#define NBYTES(nbits)   (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE)
+#define BITSPERBYTE	(8*sizeof (gchar))
+#define NBYTES(nbits)	(((nbits) + BITSPERBYTE - 1) / BITSPERBYTE)
 
-static inline GQuark
+static inline                   GQuark
 filter_error_quark (void)
 {
 	return g_quark_from_static_string ("g-filter-error-quark");
 }
 
 static void
-insert_metric_result (struct rspamd_task *task,
-	struct metric *metric,
-	const gchar *symbol,
-	double flag,
-	GList * opts,
-	gboolean single)
+insert_metric_result (struct rspamd_task *task, struct metric *metric, const gchar *symbol,
+		double flag, GList * opts, gboolean single)
 {
-	struct metric_result *metric_res;
-	struct symbol *s;
-	gdouble *weight, w;
+	struct metric_result           *metric_res;
+	struct symbol                  *s;
+	gdouble                        *weight, w;
 
 	metric_res = g_hash_table_lookup (task->results, metric->name);
 
 	if (metric_res == NULL) {
 		/* Create new metric chain */
-		metric_res =
-			rspamd_mempool_alloc (task->task_pool,
-				sizeof (struct metric_result));
-		metric_res->symbols = g_hash_table_new (rspamd_str_hash,
-				rspamd_str_equal);
+		metric_res = rspamd_mempool_alloc (task->task_pool, sizeof (struct metric_result));
+		metric_res->symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 		metric_res->checked = FALSE;
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t) g_hash_table_unref,
-			metric_res->symbols);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_hash_table_unref, metric_res->symbols);
 		metric_res->metric = metric;
 		metric_res->grow_factor = 0;
 		metric_res->score = 0;
-		g_hash_table_insert (task->results, (gpointer) metric->name,
-			metric_res);
+		g_hash_table_insert (task->results, (gpointer) metric->name, metric_res);
 	}
-
+	
 	weight = g_hash_table_lookup (metric->symbols, symbol);
 	if (weight == NULL) {
 		w = 0.0;
@@ -106,7 +94,7 @@ insert_metric_result (struct rspamd_task *task,
 	if ((s = g_hash_table_lookup (metric_res->symbols, symbol)) != NULL) {
 		if (s->options && opts && opts != s->options) {
 			/* Append new options */
-			s->options = g_list_concat (s->options, g_list_copy (opts));
+			s->options = g_list_concat (s->options, g_list_copy(opts));
 			/*
 			 * Note that there is no need to add new destructor of GList as elements of appended
 			 * GList are used directly, so just free initial GList
@@ -114,8 +102,7 @@ insert_metric_result (struct rspamd_task *task,
 		}
 		else if (opts) {
 			s->options = g_list_copy (opts);
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t) g_list_free, s->options);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_list_free, s->options);
 		}
 		if (!single) {
 			/* Handle grow factor */
@@ -152,8 +139,7 @@ insert_metric_result (struct rspamd_task *task,
 
 		if (opts) {
 			s->options = g_list_copy (opts);
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t) g_list_free, s->options);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_list_free, s->options);
 		}
 		else {
 			s->options = NULL;
@@ -161,30 +147,22 @@ insert_metric_result (struct rspamd_task *task,
 
 		g_hash_table_insert (metric_res->symbols, (gpointer) symbol, s);
 	}
-	debug_task ("symbol %s, score %.2f, metric %s, factor: %f",
-		symbol,
-		s->score,
-		metric->name,
-		w);
-
+	debug_task ("symbol %s, score %.2f, metric %s, factor: %f", symbol, s->score, metric->name, w);
+	
 }
 
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
-static GStaticMutex result_mtx = G_STATIC_MUTEX_INIT;
+static GStaticMutex result_mtx =  G_STATIC_MUTEX_INIT;
 #else
 G_LOCK_DEFINE (result_mtx);
 #endif
 
 static void
-insert_result_common (struct rspamd_task *task,
-	const gchar *symbol,
-	double flag,
-	GList * opts,
-	gboolean single)
+insert_result_common (struct rspamd_task *task, const gchar *symbol, double flag, GList * opts, gboolean single)
 {
-	struct metric *metric;
-	struct cache_item *item;
-	GList *cur, *metric_list;
+	struct metric                  *metric;
+	struct cache_item              *item;
+	GList                          *cur, *metric_list;
 
 	/* Avoid concurrenting inserting of results */
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
@@ -195,7 +173,7 @@ insert_result_common (struct rspamd_task *task,
 	metric_list = g_hash_table_lookup (task->cfg->metrics_symbols, symbol);
 	if (metric_list) {
 		cur = metric_list;
-
+		
 		while (cur) {
 			metric = cur->data;
 			insert_metric_result (task, metric, symbol, flag, opts, single);
@@ -204,12 +182,7 @@ insert_result_common (struct rspamd_task *task,
 	}
 	else {
 		/* Insert symbol to default metric */
-		insert_metric_result (task,
-			task->cfg->default_metric,
-			symbol,
-			flag,
-			opts,
-			single);
+		insert_metric_result (task, task->cfg->default_metric, symbol, flag, opts, single);
 	}
 
 	/* Process cache item */
@@ -233,27 +206,21 @@ insert_result_common (struct rspamd_task *task,
 
 /* Insert result that may be increased on next insertions */
 void
-insert_result (struct rspamd_task *task,
-	const gchar *symbol,
-	double flag,
-	GList * opts)
+insert_result (struct rspamd_task *task, const gchar *symbol, double flag, GList * opts)
 {
 	insert_result_common (task, symbol, flag, opts, task->cfg->one_shot_mode);
 }
 
 /* Insert result as a single option */
 void
-insert_result_single (struct rspamd_task *task,
-	const gchar *symbol,
-	double flag,
-	GList * opts)
+insert_result_single (struct rspamd_task *task, const gchar *symbol, double flag, GList * opts)
 {
 	insert_result_common (task, symbol, flag, opts, TRUE);
 }
 
 static gboolean
 check_metric_settings (struct rspamd_task *task, struct metric *metric,
-	double *score)
+		double *score)
 {
 	const ucl_object_t *mobj, *reject;
 	double val;
@@ -276,11 +243,11 @@ check_metric_settings (struct rspamd_task *task, struct metric *metric,
 }
 
 /* Return true if metric has score that is more than spam score for it */
-static gboolean
+static                          gboolean
 check_metric_is_spam (struct rspamd_task *task, struct metric *metric)
 {
-	struct metric_result *res;
-	double ms;
+	struct metric_result           *res;
+	double                          ms;
 
 	/* Avoid concurrency while checking results */
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
@@ -313,9 +280,9 @@ check_metric_is_spam (struct rspamd_task *task, struct metric *metric)
 gint
 process_filters (struct rspamd_task *task)
 {
-	GList *cur;
-	struct metric *metric;
-	gpointer item = NULL;
+	GList                          *cur;
+	struct metric                  *metric;
+	gpointer                        item = NULL;
 
 	/* Process metrics symbols */
 	while (call_symbol_callback (task, task->cfg->cache, &item)) {
@@ -324,8 +291,8 @@ process_filters (struct rspamd_task *task)
 		while (cur) {
 			metric = cur->data;
 			if (!task->pass_all_filters &&
-				metric->actions[METRIC_ACTION_REJECT].score > 0 &&
-				check_metric_is_spam (task, metric)) {
+						metric->actions[METRIC_ACTION_REJECT].score > 0 &&
+						check_metric_is_spam (task, metric)) {
 				task->state = WRITE_REPLY;
 				return 1;
 			}
@@ -340,22 +307,22 @@ process_filters (struct rspamd_task *task)
 
 
 struct composites_data {
-	struct rspamd_task *task;
-	struct metric_result *metric_res;
-	GTree *symbols_to_remove;
-	guint8 *checked;
+	struct rspamd_task             *task;
+	struct metric_result           *metric_res;
+	GTree                          *symbols_to_remove;
+	guint8						   *checked;
 };
 
 struct symbol_remove_data {
-	struct symbol *ms;
-	gboolean remove_weight;
-	gboolean remove_symbol;
+	struct symbol                  *ms;
+	gboolean                        remove_weight;
+	gboolean                        remove_symbol;
 };
 
 static gint
 remove_compare_data (gconstpointer a, gconstpointer b)
 {
-	const gchar *ca = a, *cb = b;
+	const gchar                    *ca = a, *cb = b;
 
 	return strcmp (ca, cb);
 }
@@ -363,16 +330,16 @@ remove_compare_data (gconstpointer a, gconstpointer b)
 static void
 composites_foreach_callback (gpointer key, gpointer value, void *data)
 {
-	struct composites_data *cd = (struct composites_data *)data;
-	struct rspamd_composite *composite = value, *ncomp;
-	struct expression *expr;
-	GQueue *stack;
-	GList *symbols = NULL, *s;
-	gsize cur, op1, op2;
-	gchar logbuf[256], *sym, *check_sym;
-	gint r;
-	struct symbol *ms;
-	struct symbol_remove_data *rd;
+	struct composites_data         *cd = (struct composites_data *)data;
+	struct rspamd_composite        *composite = value, *ncomp;
+	struct expression              *expr;
+	GQueue                         *stack;
+	GList                          *symbols = NULL, *s;
+	gsize                           cur, op1, op2;
+	gchar                           logbuf[256], *sym, *check_sym;
+	gint                            r;
+	struct symbol                  *ms;
+	struct symbol_remove_data      *rd;
 
 
 	expr = composite->expr;
@@ -388,19 +355,16 @@ composites_foreach_callback (gpointer key, gpointer value, void *data)
 			/* Find corresponding symbol */
 			sym = expr->content.operand;
 			if (*sym == '~' || *sym == '-') {
-				sym++;
+				sym ++;
 			}
 			if (g_hash_table_lookup (cd->metric_res->symbols, sym) == NULL) {
 				cur = 0;
-				if ((ncomp =
-					g_hash_table_lookup (cd->task->cfg->composite_symbols,
-					sym)) != NULL) {
+				if ((ncomp = g_hash_table_lookup (cd->task->cfg->composite_symbols, sym)) != NULL) {
 					/* Set checked for this symbol to avoid cyclic references */
 					if (isclr (cd->checked, ncomp->id)) {
 						setbit (cd->checked, composite->id);
 						composites_foreach_callback (sym, ncomp, cd);
-						if (g_hash_table_lookup (cd->metric_res->symbols,
-							sym) != NULL) {
+						if (g_hash_table_lookup (cd->metric_res->symbols, sym) != NULL) {
 							cur = 1;
 						}
 					}
@@ -448,11 +412,7 @@ composites_foreach_callback (gpointer key, gpointer value, void *data)
 		if (op1) {
 			/* Remove all symbols that are in composite symbol */
 			s = g_list_first (symbols);
-			r = rspamd_snprintf (logbuf,
-					sizeof (logbuf),
-					"<%s>, insert symbol %s instead of symbols: ",
-					cd->task->message_id,
-					key);
+			r = rspamd_snprintf (logbuf, sizeof (logbuf), "<%s>, insert symbol %s instead of symbols: ", cd->task->message_id, key);
 			while (s) {
 				sym = s->data;
 				if (*sym == '~' || *sym == '-') {
@@ -465,23 +425,18 @@ composites_foreach_callback (gpointer key, gpointer value, void *data)
 
 				if (ms == NULL) {
 					/* Try to process other composites */
-					if ((ncomp =
-						g_hash_table_lookup (cd->task->cfg->composite_symbols,
-						check_sym)) != NULL) {
+					if ((ncomp = g_hash_table_lookup (cd->task->cfg->composite_symbols, check_sym)) != NULL) {
 						/* Set checked for this symbol to avoid cyclic references */
 						if (isclr (cd->checked, ncomp->id)) {
 							setbit (cd->checked, composite->id);
 							composites_foreach_callback (check_sym, ncomp, cd);
-							ms = g_hash_table_lookup (cd->metric_res->symbols,
-									check_sym);
+							ms = g_hash_table_lookup (cd->metric_res->symbols, check_sym);
 						}
 					}
 				}
 
 				if (ms != NULL) {
-					rd =
-						rspamd_mempool_alloc (cd->task->task_pool,
-							sizeof (struct symbol_remove_data));
+					rd = rspamd_mempool_alloc (cd->task->task_pool, sizeof (struct symbol_remove_data));
 					rd->ms = ms;
 					if (G_UNLIKELY (*sym == '~')) {
 						rd->remove_weight = FALSE;
@@ -496,9 +451,7 @@ composites_foreach_callback (gpointer key, gpointer value, void *data)
 						rd->remove_weight = TRUE;
 					}
 					if (!g_tree_lookup (cd->symbols_to_remove, rd)) {
-						g_tree_insert (cd->symbols_to_remove,
-							(gpointer)ms->name,
-							rd);
+						g_tree_insert (cd->symbols_to_remove, (gpointer)ms->name, rd);
 					}
 				}
 				else {
@@ -506,16 +459,10 @@ composites_foreach_callback (gpointer key, gpointer value, void *data)
 				}
 
 				if (s->next) {
-					r += rspamd_snprintf (logbuf + r,
-							sizeof (logbuf) - r,
-							"%s, ",
-							s->data);
+					r += rspamd_snprintf (logbuf + r, sizeof (logbuf) -r, "%s, ", s->data);
 				}
 				else {
-					r += rspamd_snprintf (logbuf + r,
-							sizeof (logbuf) - r,
-							"%s",
-							s->data);
+					r += rspamd_snprintf (logbuf + r, sizeof (logbuf) -r, "%s", s->data);
 				}
 				s = g_list_next (s);
 			}
@@ -532,13 +479,12 @@ composites_foreach_callback (gpointer key, gpointer value, void *data)
 	return;
 }
 
-static gboolean
-check_autolearn (struct statfile_autolearn_params *params,
-	struct rspamd_task *task)
+static                          gboolean
+check_autolearn (struct statfile_autolearn_params *params, struct rspamd_task *task)
 {
-	gchar *metric_name = DEFAULT_METRIC;
-	struct metric_result *metric_res;
-	GList *cur;
+	gchar                          *metric_name = DEFAULT_METRIC;
+	struct metric_result           *metric_res;
+	GList                          *cur;
 
 	if (params->metric != NULL) {
 		metric_name = (gchar *)params->metric;
@@ -556,16 +502,12 @@ check_autolearn (struct statfile_autolearn_params *params,
 	}
 	else {
 		/* Process score of metric */
-		if ((params->threshold_min != 0 && metric_res->score >
-			params->threshold_min) ||
-			(params->threshold_max != 0 && metric_res->score <
-			params->threshold_max)) {
+		if ((params->threshold_min != 0 && metric_res->score > params->threshold_min) || (params->threshold_max != 0 && metric_res->score < params->threshold_max)) {
 			/* Now check for specific symbols */
 			if (params->symbols) {
 				cur = params->symbols;
 				while (cur) {
-					if (g_hash_table_lookup (metric_res->symbols,
-						cur->data) == NULL) {
+					if (g_hash_table_lookup (metric_res->symbols, cur->data) == NULL) {
 						return FALSE;
 					}
 					cur = g_list_next (cur);
@@ -580,47 +522,28 @@ check_autolearn (struct statfile_autolearn_params *params,
 }
 
 void
-process_autolearn (struct rspamd_statfile_config *st,
-	struct rspamd_task *task,
-	GTree * tokens,
-	struct classifier *classifier,
-	gchar *filename,
-	struct classifier_ctx *ctx)
+process_autolearn (struct rspamd_statfile_config *st, struct rspamd_task *task, GTree * tokens, struct classifier *classifier, gchar *filename, struct classifier_ctx *ctx)
 {
-	stat_file_t *statfile;
-	struct rspamd_statfile_config *unused;
+	stat_file_t                    *statfile;
+	struct rspamd_statfile_config                *unused;
 
 	if (check_autolearn (st->autolearn, task)) {
 		if (tokens) {
 			/* Take care of subject */
 			tokenize_subject (task, &tokens);
-			msg_info ("message with id <%s> autolearned statfile '%s'",
-				task->message_id,
-				filename);
-
+			msg_info ("message with id <%s> autolearned statfile '%s'", task->message_id, filename);
+			
 			/* Get or create statfile */
-			statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool,
-					ctx->cfg,
-					st->symbol,
-					&unused,
-					TRUE);
-
+			statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool, ctx->cfg,
+						st->symbol, &unused, TRUE);
+			
 			if (statfile == NULL) {
 				return;
 			}
 
-			classifier->learn_func (ctx,
-				task->worker->srv->statfile_pool,
-				st->symbol,
-				tokens,
-				TRUE,
-				NULL,
-				1.,
-				NULL);
+			classifier->learn_func (ctx, task->worker->srv->statfile_pool, st->symbol, tokens, TRUE, NULL, 1., NULL);
 			maybe_write_binlog (ctx->cfg, st, statfile, tokens);
-			statfile_pool_plan_invalidate (task->worker->srv->statfile_pool,
-				DEFAULT_STATFILE_INVALIDATE_TIME,
-				DEFAULT_STATFILE_INVALIDATE_JITTER);
+			statfile_pool_plan_invalidate (task->worker->srv->statfile_pool, DEFAULT_STATFILE_INVALIDATE_TIME, DEFAULT_STATFILE_INVALIDATE_JITTER);
 		}
 	}
 }
@@ -628,8 +551,8 @@ process_autolearn (struct rspamd_statfile_config *st,
 static gboolean
 composites_remove_symbols (gpointer key, gpointer value, gpointer data)
 {
-	struct composites_data *cd = data;
-	struct symbol_remove_data *rd = value;
+	struct composites_data         *cd = data;
+	struct symbol_remove_data      *rd = value;
 
 	if (rd->remove_symbol) {
 		g_hash_table_remove (cd->metric_res->symbols, key);
@@ -644,22 +567,17 @@ composites_remove_symbols (gpointer key, gpointer value, gpointer data)
 static void
 composites_metric_callback (gpointer key, gpointer value, gpointer data)
 {
-	struct rspamd_task *task = (struct rspamd_task *)data;
-	struct composites_data *cd =
-		rspamd_mempool_alloc (task->task_pool, sizeof (struct composites_data));
-	struct metric_result *metric_res = (struct metric_result *)value;
+	struct rspamd_task             *task = (struct rspamd_task *)data;
+	struct composites_data         *cd = rspamd_mempool_alloc (task->task_pool, sizeof (struct composites_data));
+	struct metric_result           *metric_res = (struct metric_result *)value;
 
 	cd->task = task;
 	cd->metric_res = (struct metric_result *)metric_res;
 	cd->symbols_to_remove = g_tree_new (remove_compare_data);
-	cd->checked =
-		rspamd_mempool_alloc0 (task->task_pool,
-			NBYTES (g_hash_table_size (task->cfg->composite_symbols)));
+	cd->checked = rspamd_mempool_alloc0 (task->task_pool, NBYTES (g_hash_table_size (task->cfg->composite_symbols)));
 
 	/* Process hash table */
-	g_hash_table_foreach (task->cfg->composite_symbols,
-		composites_foreach_callback,
-		cd);
+	g_hash_table_foreach (task->cfg->composite_symbols, composites_foreach_callback, cd);
 
 	/* Remove symbols that are in composites */
 	g_tree_foreach (cd->symbols_to_remove, composites_remove_symbols, cd);
@@ -681,32 +599,30 @@ struct classifiers_cbdata {
 static void
 classifiers_callback (gpointer value, void *arg)
 {
-	struct classifiers_cbdata *cbdata = arg;
-	struct rspamd_task *task;
-	struct rspamd_classifier_config *cl = value;
-	struct classifier_ctx *ctx;
-	struct mime_text_part *text_part, *p1, *p2;
-	struct rspamd_statfile_config *st;
-	GTree *tokens = NULL;
-	GList *cur;
-	f_str_t c;
-	gchar *header = NULL;
-	gint *dist = NULL, diff;
-	gboolean is_twopart = FALSE;
-
+	struct classifiers_cbdata	   *cbdata = arg;
+	struct rspamd_task             *task;
+	struct rspamd_classifier_config       *cl = value;
+	struct classifier_ctx          *ctx;
+	struct mime_text_part          *text_part, *p1, *p2;
+	struct rspamd_statfile_config                *st;
+	GTree                          *tokens = NULL;
+	GList                          *cur;
+	f_str_t                         c;
+	gchar                          *header = NULL;
+	gint                           *dist = NULL, diff;
+	gboolean                        is_twopart = FALSE;
+	
 	task = cbdata->task;
 
 	if ((header = g_hash_table_lookup (cl->opts, "header")) != NULL) {
-		cur =
-			message_get_header (task->task_pool, task->message, header, FALSE);
+		cur = message_get_header (task->task_pool, task->message, header, FALSE);
 		if (cur) {
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t)g_list_free, cur);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
 		}
 	}
 	else {
 		cur = g_list_first (task->text_parts);
-		dist = rspamd_mempool_get_variable (task->task_pool, "parts_distance");
+		dist =  rspamd_mempool_get_variable (task->task_pool, "parts_distance");
 		if (cur != NULL && cur->next != NULL && cur->next->next == NULL) {
 			is_twopart = TRUE;
 		}
@@ -719,8 +635,7 @@ classifiers_callback (gpointer value, void *arg)
 				c.len = strlen (cur->data);
 				if (c.len > 0) {
 					c.begin = cur->data;
-					if (!cl->tokenizer->tokenize_func (cl->tokenizer,
-						task->task_pool, &c, &tokens, FALSE, FALSE, NULL)) {
+					if (!cl->tokenizer->tokenize_func (cl->tokenizer, task->task_pool, &c, &tokens, FALSE, FALSE, NULL)) {
 						msg_info ("cannot tokenize input");
 						return;
 					}
@@ -736,9 +651,7 @@ classifiers_callback (gpointer value, void *arg)
 					/* Compare part's content */
 
 					if (*dist >= COMMON_PART_FACTOR) {
-						msg_info (
-							"message <%s> has two common text parts, ignore the last one",
-							task->message_id);
+						msg_info ("message <%s> has two common text parts, ignore the last one", task->message_id);
 						break;
 					}
 				}
@@ -746,25 +659,21 @@ classifiers_callback (gpointer value, void *arg)
 					p1 = cur->prev->data;
 					p2 = text_part;
 					if (p1->diff_str != NULL && p2->diff_str != NULL) {
-						diff =
-							compare_diff_distance (p1->diff_str, p2->diff_str);
+						diff = compare_diff_distance (p1->diff_str, p2->diff_str);
 					}
 					else {
 						diff = fuzzy_compare_parts (p1, p2);
 					}
 					if (diff >= COMMON_PART_FACTOR) {
-						msg_info (
-							"message <%s> has two common text parts, ignore the last one",
-							task->message_id);
+						msg_info ("message <%s> has two common text parts, ignore the last one", task->message_id);
 						break;
 					}
 				}
 				c.begin = (gchar *)text_part->content->data;
 				c.len = text_part->content->len;
 				/* Tree would be freed at task pool freeing */
-				if (!cl->tokenizer->tokenize_func (cl->tokenizer,
-					task->task_pool, &c, &tokens,
-					FALSE, text_part->is_utf, text_part->urls_offset)) {
+				if (!cl->tokenizer->tokenize_func (cl->tokenizer, task->task_pool, &c, &tokens,
+						FALSE, text_part->is_utf, text_part->urls_offset)) {
 					msg_info ("cannot tokenize input");
 					return;
 				}
@@ -783,20 +692,12 @@ classifiers_callback (gpointer value, void *arg)
 
 	if (cbdata->nL != NULL) {
 		rspamd_mutex_lock (cbdata->nL->m);
-		cl->classifier->classify_func (ctx,
-			task->worker->srv->statfile_pool,
-			tokens,
-			task,
-			cbdata->nL->L);
+		cl->classifier->classify_func (ctx, task->worker->srv->statfile_pool, tokens, task, cbdata->nL->L);
 		rspamd_mutex_unlock (cbdata->nL->m);
 	}
 	else {
 		/* Non-threaded case */
-		cl->classifier->classify_func (ctx,
-			task->worker->srv->statfile_pool,
-			tokens,
-			task,
-			task->cfg->lua_state);
+		cl->classifier->classify_func (ctx, task->worker->srv->statfile_pool, tokens, task, task->cfg->lua_state);
 	}
 
 	/* Autolearning */
@@ -806,12 +707,7 @@ classifiers_callback (gpointer value, void *arg)
 		if (st->autolearn) {
 			if (check_autolearn (st->autolearn, task)) {
 				/* Process autolearn */
-				process_autolearn (st,
-					task,
-					tokens,
-					cl->classifier,
-					st->path,
-					ctx);
+				process_autolearn (st, task, tokens, cl->classifier, st->path, ctx);
 			}
 		}
 		cur = g_list_next (cur);
@@ -822,7 +718,7 @@ classifiers_callback (gpointer value, void *arg)
 void
 process_statfiles (struct rspamd_task *task)
 {
-	struct classifiers_cbdata cbdata;
+	struct classifiers_cbdata		cbdata;
 
 	if (task->is_skipped) {
 		return;
@@ -830,8 +726,7 @@ process_statfiles (struct rspamd_task *task)
 
 	if (task->tokens == NULL) {
 		task->tokens = g_hash_table_new (g_direct_hash, g_direct_equal);
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t)g_hash_table_unref, task->tokens);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_hash_table_unref, task->tokens);
 	}
 	cbdata.task = task;
 	cbdata.nL = NULL;
@@ -844,9 +739,9 @@ process_statfiles (struct rspamd_task *task)
 void
 process_statfiles_threaded (gpointer data, gpointer user_data)
 {
-	struct rspamd_task *task = (struct rspamd_task *)data;
-	struct lua_locked_state *nL = user_data;
-	struct classifiers_cbdata cbdata;
+	struct rspamd_task             *task = (struct rspamd_task *)data;
+	struct lua_locked_state 	   *nL = user_data;
+	struct classifiers_cbdata		cbdata;
 
 	if (task->is_skipped) {
 		remove_async_thread (task->s);
@@ -855,8 +750,7 @@ process_statfiles_threaded (gpointer data, gpointer user_data)
 
 	if (task->tokens == NULL) {
 		task->tokens = g_hash_table_new (g_direct_hash, g_direct_equal);
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t)g_hash_table_unref, task->tokens);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_hash_table_unref, task->tokens);
 	}
 
 	cbdata.task = task;
@@ -866,22 +760,18 @@ process_statfiles_threaded (gpointer data, gpointer user_data)
 }
 
 static void
-insert_metric_header (gpointer metric_name, gpointer metric_value,
-	gpointer data)
+insert_metric_header (gpointer metric_name, gpointer metric_value, gpointer data)
 {
 #ifndef GLIB_HASH_COMPAT
-	struct rspamd_task *task = (struct rspamd_task *)data;
-	gint r = 0;
+	struct rspamd_task             *task = (struct rspamd_task *)data;
+	gint                            r = 0;
 	/* Try to be rfc2822 compatible and avoid long headers with folding */
-	gchar header_name[128], outbuf[1000];
-	GList *symbols = NULL, *cur;
-	struct metric_result *metric_res = (struct metric_result *)metric_value;
-	double ms;
+	gchar                           header_name[128], outbuf[1000];
+	GList                          *symbols = NULL, *cur;
+	struct metric_result           *metric_res = (struct metric_result *)metric_value;
+	double                          ms;
 
-	rspamd_snprintf (header_name,
-		sizeof (header_name),
-		"X-Spam-%s",
-		metric_res->metric->name);
+	rspamd_snprintf (header_name, sizeof (header_name), "X-Spam-%s", metric_res->metric->name);
 
 	if (!check_metric_settings (task, metric_res->metric, &ms)) {
 		ms = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
@@ -910,8 +800,7 @@ insert_metric_header (gpointer metric_name, gpointer metric_value,
 	}
 	g_list_free (symbols);
 #ifdef GMIME24
-	g_mime_object_append_header (GMIME_OBJECT (
-			task->message), header_name, outbuf);
+	g_mime_object_append_header (GMIME_OBJECT (task->message), header_name, outbuf);
 #else
 	g_mime_message_add_header (task->message, header_name, outbuf);
 #endif
@@ -931,16 +820,13 @@ check_action_str (const gchar *data, gint *result)
 	if (g_ascii_strncasecmp (data, "reject", sizeof ("reject") - 1) == 0) {
 		*result = METRIC_ACTION_REJECT;
 	}
-	else if (g_ascii_strncasecmp (data, "greylist",
-		sizeof ("greylist") - 1) == 0) {
+	else if (g_ascii_strncasecmp (data, "greylist", sizeof ("greylist") - 1) == 0) {
 		*result = METRIC_ACTION_GREYLIST;
 	}
-	else if (g_ascii_strncasecmp (data, "add_header", sizeof ("add_header") -
-		1) == 0) {
+	else if (g_ascii_strncasecmp (data, "add_header", sizeof ("add_header") - 1) == 0) {
 		*result = METRIC_ACTION_ADD_HEADER;
 	}
-	else if (g_ascii_strncasecmp (data, "rewrite_subject",
-		sizeof ("rewrite_subject") - 1) == 0) {
+	else if (g_ascii_strncasecmp (data, "rewrite_subject", sizeof ("rewrite_subject") - 1) == 0) {
 		*result = METRIC_ACTION_REWRITE_SUBJECT;
 	}
 	else {
@@ -975,9 +861,9 @@ str_action_metric (enum rspamd_metric_action action)
 gint
 check_metric_action (double score, double required_score, struct metric *metric)
 {
-	struct metric_action *action, *selected_action = NULL;
-	double max_score = 0;
-	int i;
+	struct metric_action           *action, *selected_action = NULL;
+	double                          max_score = 0;
+	int                             i;
 
 	if (score >= required_score) {
 		return METRIC_ACTION_REJECT;
@@ -986,7 +872,7 @@ check_metric_action (double score, double required_score, struct metric *metric)
 		return METRIC_ACTION_NOACTION;
 	}
 	else {
-		for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
+		for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
 			action = &metric->actions[i];
 			if (action->score < 0) {
 				continue;
@@ -1008,26 +894,24 @@ check_metric_action (double score, double required_score, struct metric *metric)
 gboolean
 learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
 {
-	GList *cur, *ex;
-	struct rspamd_classifier_config *cl;
-	struct classifier_ctx *cls_ctx;
-	gchar *s;
-	f_str_t c;
-	GTree *tokens = NULL;
-	struct rspamd_statfile_config *st;
-	stat_file_t *stf;
-	gdouble sum;
-	struct mime_text_part *part, *p1, *p2;
-	gboolean is_utf = FALSE, is_twopart = FALSE;
-	gint diff;
+	GList                          *cur, *ex;
+	struct rspamd_classifier_config       *cl;
+	struct classifier_ctx          *cls_ctx;
+	gchar                          *s;
+	f_str_t                         c;
+	GTree                          *tokens = NULL;
+	struct rspamd_statfile_config                *st;
+	stat_file_t                    *stf;
+	gdouble                         sum;
+	struct mime_text_part          *part, *p1, *p2;
+	gboolean                        is_utf = FALSE, is_twopart = FALSE;
+	gint                            diff;
 
 
 	/* Load classifier by symbol */
 	cl = g_hash_table_lookup (task->cfg->classifiers_symbols, statfile);
 	if (cl == NULL) {
-		g_set_error (err,
-			filter_error_quark (), 1, "Statfile %s is not configured in any classifier",
-			statfile);
+		g_set_error (err, filter_error_quark(), 1, "Statfile %s is not configured in any classifier", statfile);
 		return FALSE;
 	}
 
@@ -1035,8 +919,7 @@ learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
 	if ((s = g_hash_table_lookup (cl->opts, "header")) != NULL) {
 		cur = message_get_header (task->task_pool, task->message, s, FALSE);
 		if (cur) {
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t)g_list_free, cur);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, cur);
 		}
 	}
 	else {
@@ -1076,9 +959,7 @@ learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
 					diff = fuzzy_compare_parts (p1, p2);
 				}
 				if (diff >= COMMON_PART_FACTOR) {
-					msg_info (
-						"message <%s> has two common text parts, ignore the last one",
-						task->message_id);
+					msg_info ("message <%s> has two common text parts, ignore the last one", task->message_id);
 					break;
 				}
 			}
@@ -1087,8 +968,7 @@ learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
 		if (!cl->tokenizer->tokenize_func (
 				cl->tokenizer, task->task_pool,
 				&c, &tokens, FALSE, is_utf, ex)) {
-			g_set_error (err,
-				filter_error_quark (), 2, "Cannot tokenize message");
+			g_set_error (err, filter_error_quark(), 2, "Cannot tokenize message");
 			return FALSE;
 		}
 		cur = g_list_next (cur);
@@ -1096,10 +976,8 @@ learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
 
 	/* Handle messages without text */
 	if (tokens == NULL) {
-		g_set_error (err,
-			filter_error_quark (), 3, "Cannot tokenize message, no text data");
-		msg_info ("learn failed for message <%s>, no tokens to extract",
-			task->message_id);
+		g_set_error (err, filter_error_quark(), 3, "Cannot tokenize message, no text data");
+		msg_info ("learn failed for message <%s>, no tokens to extract", task->message_id);
 		return FALSE;
 	}
 
@@ -1108,7 +986,7 @@ learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
 
 	/* Init classifier */
 	cls_ctx = cl->classifier->init_func (
-		task->task_pool, cl);
+			task->task_pool, cl);
 	/* Get or create statfile */
 	stf = get_statfile_by_symbol (task->worker->srv->statfile_pool,
 			cl, statfile, &st, TRUE);
@@ -1119,17 +997,12 @@ learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
 			statfile, tokens, TRUE, &sum,
 			1.0, err)) {
 		if (*err) {
-			msg_info ("learn failed for message <%s>, learn error: %s",
-				task->message_id,
-				(*err)->message);
+			msg_info ("learn failed for message <%s>, learn error: %s", task->message_id, (*err)->message);
 			return FALSE;
 		}
 		else {
-			g_set_error (err,
-				filter_error_quark (), 4,
-				"Learn failed, unknown learn classifier error");
-			msg_info ("learn failed for message <%s>, unknown learn error",
-				task->message_id);
+			g_set_error (err, filter_error_quark(), 4, "Learn failed, unknown learn classifier error");
+			msg_info ("learn failed for message <%s>, unknown learn error", task->message_id);
 			return FALSE;
 		}
 	}
@@ -1137,31 +1010,25 @@ learn_task (const gchar *statfile, struct rspamd_task *task, GError **err)
 	task->worker->srv->stat->messages_learned++;
 
 	maybe_write_binlog (cl, st, stf, tokens);
-	msg_info (
-		"learn success for message <%s>, for statfile: %s, sum weight: %.2f",
-		task->message_id,
-		statfile,
-		sum);
+	msg_info ("learn success for message <%s>, for statfile: %s, sum weight: %.2f",
+			task->message_id, statfile, sum);
 	statfile_pool_plan_invalidate (task->worker->srv->statfile_pool,
-		DEFAULT_STATFILE_INVALIDATE_TIME,
-		DEFAULT_STATFILE_INVALIDATE_JITTER);
+			DEFAULT_STATFILE_INVALIDATE_TIME,
+			DEFAULT_STATFILE_INVALIDATE_JITTER);
 
 	return TRUE;
 }
 
 gboolean
-learn_task_spam (struct rspamd_classifier_config *cl,
-	struct rspamd_task *task,
-	gboolean is_spam,
-	GError **err)
+learn_task_spam (struct rspamd_classifier_config *cl, struct rspamd_task *task, gboolean is_spam, GError **err)
 {
-	GList *cur, *ex;
-	struct classifier_ctx *cls_ctx;
-	f_str_t c;
-	GTree *tokens = NULL;
-	struct mime_text_part *part, *p1, *p2;
-	gboolean is_utf = FALSE, is_twopart = FALSE;
-	gint diff;
+	GList                          *cur, *ex;
+	struct classifier_ctx          *cls_ctx;
+	f_str_t                         c;
+	GTree                          *tokens = NULL;
+	struct mime_text_part          *part, *p1, *p2;
+	gboolean                        is_utf = FALSE, is_twopart = FALSE;
+	gint                            diff;
 
 	cur = g_list_first (task->text_parts);
 	if (cur != NULL && cur->next != NULL && cur->next->next == NULL) {
@@ -1194,9 +1061,7 @@ learn_task_spam (struct rspamd_classifier_config *cl,
 				diff = fuzzy_compare_parts (p1, p2);
 			}
 			if (diff >= COMMON_PART_FACTOR) {
-				msg_info (
-					"message <%s> has two common text parts, ignore the last one",
-					task->message_id);
+				msg_info ("message <%s> has two common text parts, ignore the last one", task->message_id);
 				break;
 			}
 		}
@@ -1204,8 +1069,7 @@ learn_task_spam (struct rspamd_classifier_config *cl,
 		if (!cl->tokenizer->tokenize_func (
 				cl->tokenizer, task->task_pool,
 				&c, &tokens, FALSE, is_utf, ex)) {
-			g_set_error (err,
-				filter_error_quark (), 2, "Cannot tokenize message");
+			g_set_error (err, filter_error_quark(), 2, "Cannot tokenize message");
 			return FALSE;
 		}
 		cur = g_list_next (cur);
@@ -1213,10 +1077,8 @@ learn_task_spam (struct rspamd_classifier_config *cl,
 
 	/* Handle messages without text */
 	if (tokens == NULL) {
-		g_set_error (err,
-			filter_error_quark (), 3, "Cannot tokenize message, no text data");
-		msg_info ("learn failed for message <%s>, no tokens to extract",
-			task->message_id);
+		g_set_error (err, filter_error_quark(), 3, "Cannot tokenize message, no text data");
+		msg_info ("learn failed for message <%s>, no tokens to extract", task->message_id);
 		return FALSE;
 	}
 
@@ -1225,23 +1087,18 @@ learn_task_spam (struct rspamd_classifier_config *cl,
 
 	/* Init classifier */
 	cls_ctx = cl->classifier->init_func (
-		task->task_pool, cl);
+			task->task_pool, cl);
 	/* Learn */
 	if (!cl->classifier->learn_spam_func (
 			cls_ctx, task->worker->srv->statfile_pool,
 			tokens, task, is_spam, task->cfg->lua_state, err)) {
 		if (*err) {
-			msg_info ("learn failed for message <%s>, learn error: %s",
-				task->message_id,
-				(*err)->message);
+			msg_info ("learn failed for message <%s>, learn error: %s", task->message_id, (*err)->message);
 			return FALSE;
 		}
 		else {
-			g_set_error (err,
-				filter_error_quark (), 4,
-				"Learn failed, unknown learn classifier error");
-			msg_info ("learn failed for message <%s>, unknown learn error",
-				task->message_id);
+			g_set_error (err, filter_error_quark(), 4, "Learn failed, unknown learn classifier error");
+			msg_info ("learn failed for message <%s>, unknown learn error", task->message_id);
 			return FALSE;
 		}
 	}
@@ -1249,14 +1106,14 @@ learn_task_spam (struct rspamd_classifier_config *cl,
 	task->worker->srv->stat->messages_learned++;
 
 	msg_info ("learn success for message <%s>",
-		task->message_id);
+			task->message_id);
 	statfile_pool_plan_invalidate (task->worker->srv->statfile_pool,
-		DEFAULT_STATFILE_INVALIDATE_TIME,
-		DEFAULT_STATFILE_INVALIDATE_JITTER);
+			DEFAULT_STATFILE_INVALIDATE_TIME,
+			DEFAULT_STATFILE_INVALIDATE_JITTER);
 
 	return TRUE;
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libmime/filter.h b/src/libmime/filter.h
index f0a343483..2891ebd00 100644
--- a/src/libmime/filter.h
+++ b/src/libmime/filter.h
@@ -14,8 +14,7 @@ struct rspamd_task;
 struct rspamd_settings;
 struct rspamd_classifier_config;
 
-typedef double (*metric_cons_func)(struct rspamd_task *task,
-	const gchar *metric_name, const gchar *func_name);
+typedef double (*metric_cons_func)(struct rspamd_task *task, const gchar *metric_name, const gchar *func_name);
 typedef void (*filter_func)(struct rspamd_task *task);
 
 enum filter_type { C_FILTER, PERL_FILTER };
@@ -24,17 +23,17 @@ enum filter_type { C_FILTER, PERL_FILTER };
  * Filter structure
  */
 struct filter {
-	gchar *func_name;                               /**< function name							*/
-	enum filter_type type;                          /**< filter type (c or perl)				*/
-	module_t *module;
+	gchar *func_name;								/**< function name							*/
+	enum filter_type type;							/**< filter type (c or perl)				*/
+    module_t *module;
 };
 
 /**
  * Rspamd symbol
  */
 struct symbol {
-	double score;                                   /**< symbol's score							*/
-	GList *options;                                 /**< list of symbol's options				*/
+	double score;									/**< symbol's score							*/
+	GList *options;									/**< list of symbol's options				*/
 	const gchar *name;
 };
 
@@ -47,25 +46,25 @@ struct metric_action {
  * Common definition of metric
  */
 struct metric {
-	const gchar *name;                              /**< name of metric									*/
-	gchar *func_name;                               /**< name of consolidation function					*/
-	metric_cons_func func;                          /**< c consolidation function						*/
-	double grow_factor;                             /**< grow factor for metric							*/
-	GHashTable *symbols;                            /**< weights of symbols in metric					*/
-	GHashTable *descriptions;                       /**< descriptions of symbols in metric				*/
+	const gchar *name;								/**< name of metric									*/
+	gchar *func_name;								/**< name of consolidation function					*/
+	metric_cons_func func;							/**< c consolidation function						*/
+	double grow_factor;								/**< grow factor for metric							*/
+	GHashTable *symbols;							/**< weights of symbols in metric					*/
+	GHashTable *descriptions;						/**< descriptions of symbols in metric				*/
 	struct metric_action actions[METRIC_ACTION_MAX]; /**< all actions of the metric					*/
-	gchar *subject;                                 /**< subject rewrite string							*/
+	gchar *subject;									/**< subject rewrite string							*/
 };
 
 /**
  * Result of metric processing
  */
 struct metric_result {
-	struct metric *metric;                          /**< pointer to metric structure			*/
-	double score;                                   /**< total score							*/
-	GHashTable *symbols;                            /**< symbols of metric						*/
-	gboolean checked;                               /**< whether metric result is consolidated  */
-	double grow_factor;                             /**< current grow factor					*/
+	struct metric *metric;							/**< pointer to metric structure			*/
+	double score;									/**< total score							*/
+	GHashTable *symbols;							/**< symbols of metric						*/
+	gboolean checked;								/**< whether metric result is consolidated  */
+	double grow_factor;								/**< current grow factor					*/
 };
 
 /**
@@ -103,10 +102,7 @@ void process_statfiles_threaded (gpointer data, gpointer user_data);
  * @param flag numeric weight for symbol
  * @param opts list of symbol's options
  */
-void insert_result (struct rspamd_task *task,
-	const gchar *symbol,
-	double flag,
-	GList *opts);
+void insert_result (struct rspamd_task *task, const gchar *symbol, double flag, GList *opts);
 
 /**
  * Insert a single result to task
@@ -116,10 +112,7 @@ void insert_result (struct rspamd_task *task,
  * @param flag numeric weight for symbol
  * @param opts list of symbol's options
  */
-void insert_result_single (struct rspamd_task *task,
-	const gchar *symbol,
-	double flag,
-	GList *opts);
+void insert_result_single (struct rspamd_task *task, const gchar *symbol, double flag, GList *opts);
 
 /**
  * Process all results and form composite metrics from existent metrics as it is defined in config
@@ -128,15 +121,13 @@ void insert_result_single (struct rspamd_task *task,
 void make_composites (struct rspamd_task *task);
 
 /**
- * Default consolidation function for metric, it get all symbols and multiply symbol
+ * Default consolidation function for metric, it get all symbols and multiply symbol 
  * weight by some factor that is specified in config. Default factor is 1.
  * @param task worker's task that present message from user
  * @param metric_name name of metric
  * @return result metric weight
  */
-double factor_consolidation_func (struct rspamd_task *task,
-	const gchar *metric_name,
-	const gchar *unused);
+double factor_consolidation_func (struct rspamd_task *task, const gchar *metric_name, const gchar *unused);
 
 /*
  * Learn specified statfile with message in a task
@@ -145,9 +136,7 @@ double factor_consolidation_func (struct rspamd_task *task,
  * @param err pointer to GError
  * @return true if learn succeed
  */
-gboolean learn_task (const gchar *statfile,
-	struct rspamd_task *task,
-	GError **err);
+gboolean learn_task (const gchar *statfile, struct rspamd_task *task, GError **err);
 
 /*
  * Learn specified statfile with message in a task
@@ -156,10 +145,7 @@ gboolean learn_task (const gchar *statfile,
  * @param err pointer to GError
  * @return true if learn succeed
  */
-gboolean learn_task_spam (struct rspamd_classifier_config *cl,
-	struct rspamd_task *task,
-	gboolean is_spam,
-	GError **err);
+gboolean learn_task_spam (struct rspamd_classifier_config *cl, struct rspamd_task *task, gboolean is_spam, GError **err);
 
 /*
  * Get action from a string
@@ -169,13 +155,11 @@ gboolean check_action_str (const gchar *data, gint *result);
 /*
  * Return textual representation of action enumeration
  */
-const gchar * str_action_metric (enum rspamd_metric_action action);
+const gchar *str_action_metric (enum rspamd_metric_action action);
 
 /*
  * Get action for specific metric
  */
-gint check_metric_action (double score,
-	double required_score,
-	struct metric *metric);
+gint check_metric_action (double score, double required_score, struct metric *metric);
 
 #endif
diff --git a/src/libmime/images.c b/src/libmime/images.c
index 3b2ceecd1..ff07bbd72 100644
--- a/src/libmime/images.c
+++ b/src/libmime/images.c
@@ -32,20 +32,19 @@ static const guint8 jpg_sig2[] = {'J', 'F', 'I', 'F'};
 static const guint8 gif_signature[] = {'G', 'I', 'F', '8'};
 static const guint8 bmp_signature[] = {'B', 'M'};
 
-static void process_image (struct rspamd_task *task, struct mime_part *part);
+static void                     process_image (struct rspamd_task *task, struct mime_part *part);
 
 
 void
 process_images (struct rspamd_task *task)
 {
-	GList *cur;
-	struct mime_part *part;
+	GList                          *cur;
+	struct mime_part			   *part;
 
 	cur = task->parts;
 	while (cur) {
 		part = cur->data;
-		if (g_mime_content_type_is_type (part->type, "image",
-			"*") && part->content->len > 0) {
+		if (g_mime_content_type_is_type (part->type, "image", "*") && part->content->len > 0) {
 			process_image (task, part);
 		}
 		cur = g_list_next (cur);
@@ -86,9 +85,9 @@ detect_image_type (GByteArray *data)
 static struct rspamd_image *
 process_png_image (struct rspamd_task *task, GByteArray *data)
 {
-	struct rspamd_image *img;
-	guint32 t;
-	guint8 *p;
+	struct rspamd_image             *img;
+	guint32                          t;
+	guint8                          *p;
 
 	if (data->len < 24) {
 		msg_info ("bad png detected (maybe striped): <%s>", task->message_id);
@@ -120,10 +119,10 @@ process_png_image (struct rspamd_task *task, GByteArray *data)
 static struct rspamd_image *
 process_jpg_image (struct rspamd_task *task, GByteArray *data)
 {
-	guint8 *p;
-	guint16 t;
-	gsize remain;
-	struct rspamd_image *img;
+	guint8                          *p;
+	guint16                          t;
+	gsize                            remain;
+	struct rspamd_image             *img;
 
 	img = rspamd_mempool_alloc (task->task_pool, sizeof (struct rspamd_image));
 	img->type = IMAGE_TYPE_JPG;
@@ -132,16 +131,15 @@ process_jpg_image (struct rspamd_task *task, GByteArray *data)
 	p = data->data;
 	remain = data->len;
 	/* In jpeg we should find any data stream (ff c0 .. ff c3) and extract its height and width */
-	while (remain--) {
-		if (*p == 0xFF && remain > 8 &&
-			(*(p + 1) >= 0xC0 && *(p + 1) <= 0xC3)) {
+	while (remain --) {
+		if (*p == 0xFF && remain > 8 && (*(p + 1) >= 0xC0 && *(p + 1) <= 0xC3)) {
 			memcpy (&t, p + 5, sizeof (guint16));
 			img->height = ntohs (t);
 			memcpy (&t, p + 7, sizeof (guint16));
 			img->width = ntohs (t);
 			return img;
 		}
-		p++;
+		p ++;
 	}
 
 	return NULL;
@@ -150,9 +148,9 @@ process_jpg_image (struct rspamd_task *task, GByteArray *data)
 static struct rspamd_image *
 process_gif_image (struct rspamd_task *task, GByteArray *data)
 {
-	struct rspamd_image *img;
-	guint8 *p;
-	guint16 t;
+	struct rspamd_image             *img;
+	guint8                          *p;
+	guint16                          t;
 
 	if (data->len < 10) {
 		msg_info ("bad gif detected (maybe striped): <%s>", task->message_id);
@@ -164,7 +162,7 @@ process_gif_image (struct rspamd_task *task, GByteArray *data)
 	img->data = data;
 
 	p = data->data + 6;
-	memcpy (&t, p,	   sizeof (guint16));
+	memcpy (&t, p, sizeof (guint16));
 	img->width = GUINT16_FROM_LE (t);
 	memcpy (&t, p + 2, sizeof (guint16));
 	img->height = GUINT16_FROM_LE (t);
@@ -175,9 +173,9 @@ process_gif_image (struct rspamd_task *task, GByteArray *data)
 static struct rspamd_image *
 process_bmp_image (struct rspamd_task *task, GByteArray *data)
 {
-	struct rspamd_image *img;
-	gint32 t;
-	guint8 *p;
+	struct rspamd_image             *img;
+	gint32                           t;
+	guint8                          *p;
 
 
 
@@ -190,7 +188,7 @@ process_bmp_image (struct rspamd_task *task, GByteArray *data)
 	img->type = IMAGE_TYPE_BMP;
 	img->data = data;
 	p = data->data + 18;
-	memcpy (&t, p,	   sizeof (gint32));
+	memcpy (&t, p, sizeof (gint32));
 	img->width = abs (GINT32_FROM_LE (t));
 	memcpy (&t, p + 4, sizeof (gint32));
 	img->height = abs (GINT32_FROM_LE (t));
@@ -201,8 +199,8 @@ process_bmp_image (struct rspamd_task *task, GByteArray *data)
 static void
 process_image (struct rspamd_task *task, struct mime_part *part)
 {
-	enum known_image_types type;
-	struct rspamd_image *img = NULL;
+	enum known_image_types          type;
+	struct rspamd_image            *img = NULL;
 	if ((type = detect_image_type (part->content)) != IMAGE_TYPE_UNKNOWN) {
 		switch (type) {
 		case IMAGE_TYPE_PNG:
@@ -225,9 +223,9 @@ process_image (struct rspamd_task *task, struct mime_part *part)
 
 	if (img != NULL) {
 		debug_task ("detected %s image of size %ud x %ud in message <%s>",
-			image_type_str (img->type),
-			img->width, img->height,
-			task->message_id);
+				image_type_str (img->type),
+				img->width, img->height,
+				task->message_id);
 		img->filename = part->filename;
 		task->images = g_list_prepend (task->images, img);
 	}
diff --git a/src/libmime/images.h b/src/libmime/images.h
index 5648f030f..c43941ebc 100644
--- a/src/libmime/images.h
+++ b/src/libmime/images.h
@@ -28,6 +28,6 @@ void process_images (struct rspamd_task *task);
 /*
  * Get textual representation of an image's type
  */
-const gchar * image_type_str (enum known_image_types type);
+const gchar *image_type_str (enum known_image_types type);
 
 #endif /* IMAGES_H_ */
diff --git a/src/libmime/message.c b/src/libmime/message.c
index c6de73782..4567869e9 100644
--- a/src/libmime/message.c
+++ b/src/libmime/message.c
@@ -22,30 +22,26 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "html.h"
-#include "images.h"
+#include "util.h"
 #include "main.h"
 #include "message.h"
-#include "util.h"
+#include "cfg_file.h"
+#include "html.h"
+#include "images.h"
 
 #define RECURSION_LIMIT 30
 #define UTF8_CHARSET "UTF-8"
 
-GByteArray *
-strip_html_tags (struct rspamd_task *task,
-	rspamd_mempool_t * pool,
-	struct mime_text_part *part,
-	GByteArray * src,
-	gint *stateptr)
+GByteArray                     *
+strip_html_tags (struct rspamd_task *task, rspamd_mempool_t * pool, struct mime_text_part *part, GByteArray * src, gint *stateptr)
 {
-	uint8_t *p, *rp, *tbegin = NULL, *end, c, lc;
-	gint br, i = 0, depth = 0, in_q = 0;
-	gint state = 0;
-	GByteArray *buf;
-	GNode *level_ptr = NULL;
-	gboolean erase = FALSE;
+	uint8_t                        *p, *rp, *tbegin = NULL, *end, c, lc;
+	gint                            br, i = 0, depth = 0, in_q = 0;
+	gint                            state = 0;
+	GByteArray                     *buf;
+	GNode                          *level_ptr = NULL;
+	gboolean                        erase = FALSE;
 
 	if (stateptr)
 		state = *stateptr;
@@ -75,11 +71,11 @@ strip_html_tags (struct rspamd_task *task,
 			}
 			else if (state == 1) {
 				/* Opening bracket without closing one */
-				p--;
+				p --;
 				while (g_ascii_isspace (*p) && p > src->data) {
-					p--;
+					p --;
 				}
-				p++;
+				p ++;
 				goto unbreak_tag;
 			}
 			break;
@@ -119,19 +115,13 @@ strip_html_tags (struct rspamd_task *task,
 			}
 unbreak_tag:
 			switch (state) {
-			case 1:         /* HTML/XML */
+			case 1:			/* HTML/XML */
 				lc = '>';
 				in_q = state = 0;
-				erase = !add_html_node (task,
-						pool,
-						part,
-						tbegin,
-						p - tbegin,
-						end - tbegin,
-						&level_ptr);
+				erase = !add_html_node (task, pool, part, tbegin, p - tbegin, end - tbegin, &level_ptr);
 				break;
 
-			case 2:         /* PHP */
+			case 2:			/* PHP */
 				if (!br && lc != '\"' && *(p - 1) == '?') {
 					in_q = state = 0;
 				}
@@ -141,7 +131,7 @@ unbreak_tag:
 				in_q = state = 0;
 				break;
 
-			case 4:         /* JavaScript/CSS/etc... */
+			case 4:			/* JavaScript/CSS/etc... */
 				if (p >= src->data + 2 && *(p - 1) == '-' && *(p - 2) == '-') {
 					in_q = state = 0;
 				}
@@ -168,8 +158,7 @@ unbreak_tag:
 			else if (state == 0 && !erase) {
 				*(rp++) = c;
 			}
-			if (state && p != src->data && *(p - 1) != '\\' &&
-				(!in_q || *p == in_q)) {
+			if (state && p != src->data && *(p - 1) != '\\' && (!in_q || *p == in_q)) {
 				if (in_q) {
 					in_q = 0;
 				}
@@ -193,8 +182,7 @@ unbreak_tag:
 			break;
 
 		case '-':
-			if (state == 3 && p >= src->data + 2 && *(p - 1) == '-' &&
-				*(p - 2) == '!') {
+			if (state == 3 && p >= src->data + 2 && *(p - 1) == '-' && *(p - 2) == '!') {
 				state = 4;
 			}
 			else {
@@ -216,14 +204,11 @@ unbreak_tag:
 			if (state == 3 && p > src->data + 6
 				&& g_ascii_tolower (*(p - 1)) == 'p'
 				&& g_ascii_tolower (*(p - 2)) == 'y'
-				&& g_ascii_tolower (*(p - 3)) == 't' &&
-				g_ascii_tolower (*(p - 4)) == 'c' &&
-				g_ascii_tolower (*(p - 5)) == 'o' &&
-				g_ascii_tolower (*(p - 6)) == 'd') {
+				&& g_ascii_tolower (*(p - 3)) == 't' && g_ascii_tolower (*(p - 4)) == 'c' && g_ascii_tolower (*(p - 5)) == 'o' && g_ascii_tolower (*(p - 6)) == 'd') {
 				state = 1;
 				break;
 			}
-		/* fall-through */
+			/* fall-through */
 
 		case 'l':
 
@@ -231,15 +216,14 @@ unbreak_tag:
 			 * state == 2 (PHP). Switch back to HTML.
 			 */
 
-			if (state == 2 && p > src->data + 2 && *(p - 1) == 'm' &&
-				*(p - 2) == 'x') {
+			if (state == 2 && p > src->data + 2 && *(p - 1) == 'm' && *(p - 2) == 'x') {
 				state = 1;
 				break;
 			}
 
-		/* fall-through */
+			/* fall-through */
 		default:
-reg_char:
+		  reg_char:
 			if (state == 0 && !erase) {
 				*(rp++) = c;
 			}
@@ -268,11 +252,9 @@ reg_char:
 }
 
 static void
-parse_qmail_recv (rspamd_mempool_t * pool,
-	gchar *line,
-	struct received_header *r)
+parse_qmail_recv (rspamd_mempool_t * pool, gchar *line, struct received_header *r)
 {
-	gchar *s, *p, t;
+	gchar                           *s, *p, t;
 
 	/* We are interested only with received from network headers */
 	if ((p = strstr (line, "from network")) == NULL) {
@@ -287,7 +269,7 @@ parse_qmail_recv (rspamd_mempool_t * pool,
 	/* format is ip/host */
 	s = p;
 	if (*p) {
-		while (g_ascii_isdigit (*++p) || *p == '.') ;
+		while (g_ascii_isdigit (*++p) || *p == '.');
 		if (*p != '/') {
 			r->is_error = 1;
 			return;
@@ -298,8 +280,7 @@ parse_qmail_recv (rspamd_mempool_t * pool,
 			*p = '/';
 			/* Now try to parse hostname */
 			s = ++p;
-			while (g_ascii_isalnum (*p) || *p == '.' || *p == '-' || *p ==
-				'_') {
+			while (g_ascii_isalnum (*p) || *p == '.' || *p == '-' || *p == '_') {
 				p++;
 			}
 			t = *p;
@@ -311,11 +292,9 @@ parse_qmail_recv (rspamd_mempool_t * pool,
 }
 
 static void
-parse_recv_header (rspamd_mempool_t * pool,
-	gchar *line,
-	struct received_header *r)
+parse_recv_header (rspamd_mempool_t * pool, gchar *line, struct received_header *r)
 {
-	gchar *p, *s, t, **res = NULL;
+	gchar                           *p, *s, t, **res = NULL;
 	enum {
 		RSPAMD_RECV_STATE_INIT = 0,
 		RSPAMD_RECV_STATE_FROM,
@@ -326,8 +305,8 @@ parse_recv_header (rspamd_mempool_t * pool,
 		RSPAMD_RECV_STATE_SKIP_SPACES,
 		RSPAMD_RECV_STATE_ERROR
 	}                               state = RSPAMD_RECV_STATE_INIT,
-		next_state = RSPAMD_RECV_STATE_INIT;
-	gboolean is_exim = FALSE;
+	                                next_state = RSPAMD_RECV_STATE_INIT;
+	gboolean                        is_exim = FALSE;
 
 	g_strstrip (line);
 	p = line;
@@ -335,18 +314,16 @@ parse_recv_header (rspamd_mempool_t * pool,
 
 	while (*p) {
 		switch (state) {
-		/* Initial state, search for from */
+			/* Initial state, search for from */
 		case RSPAMD_RECV_STATE_INIT:
 			if (*p == 'f' || *p == 'F') {
-				if (g_ascii_tolower (*++p) == 'r' && g_ascii_tolower (*++p) ==
-					'o' && g_ascii_tolower (*++p) == 'm') {
+				if (g_ascii_tolower (*++p) == 'r' && g_ascii_tolower (*++p) == 'o' && g_ascii_tolower (*++p) == 'm') {
 					p++;
 					state = RSPAMD_RECV_STATE_SKIP_SPACES;
 					next_state = RSPAMD_RECV_STATE_FROM;
 				}
 			}
-			else if (g_ascii_tolower (*p) == 'b' &&
-				g_ascii_tolower (*(p + 1)) == 'y') {
+			else if (g_ascii_tolower (*p) == 'b' && g_ascii_tolower (*(p + 1)) == 'y') {
 				state = RSPAMD_RECV_STATE_IP_BLOCK;
 			}
 			else {
@@ -355,7 +332,7 @@ parse_recv_header (rspamd_mempool_t * pool,
 				return;
 			}
 			break;
-		/* Read hostname */
+			/* Read hostname */
 		case RSPAMD_RECV_STATE_FROM:
 			if (*p == '[') {
 				/* This should be IP address */
@@ -364,8 +341,7 @@ parse_recv_header (rspamd_mempool_t * pool,
 				next_state = RSPAMD_RECV_STATE_IP_BLOCK;
 				s = ++p;
 			}
-			else if (g_ascii_isalnum (*p) || *p == '.' || *p == '-' || *p ==
-				'_') {
+			else if (g_ascii_isalnum (*p) || *p == '.' || *p == '-' || *p == '_') {
 				p++;
 			}
 			else {
@@ -377,11 +353,10 @@ parse_recv_header (rspamd_mempool_t * pool,
 				next_state = RSPAMD_RECV_STATE_IP_BLOCK;
 			}
 			break;
-		/* Try to extract additional info */
+			/* Try to extract additional info */
 		case RSPAMD_RECV_STATE_IP_BLOCK:
 			/* Try to extract ip or () info or by */
-			if (g_ascii_tolower (*p) == 'b' && g_ascii_tolower (*(p + 1)) ==
-				'y') {
+			if (g_ascii_tolower (*p) == 'b' && g_ascii_tolower (*(p + 1)) == 'y') {
 				p += 2;
 				/* Skip spaces after by */
 				state = RSPAMD_RECV_STATE_SKIP_SPACES;
@@ -403,11 +378,11 @@ parse_recv_header (rspamd_mempool_t * pool,
 				p++;
 			}
 			break;
-		/* We are in () block. Here can be found real hostname and real ip, this is written by some MTA */
+			/* We are in () block. Here can be found real hostname and real ip, this is written by some MTA */
 		case RSPAMD_RECV_STATE_BRACES_BLOCK:
 			/* End of block */
 			if (g_ascii_isalnum (*p) || *p == '.' || *p == '-' ||
-				*p == '_' || *p == ':') {
+					*p == '_' || *p == ':') {
 				p++;
 			}
 			else if (*p == '[') {
@@ -429,45 +404,41 @@ parse_recv_header (rspamd_mempool_t * pool,
 							next_state = RSPAMD_RECV_STATE_BRACES_BLOCK;
 						}
 						else if (p - s == 4 && memcmp (s, "helo=", 5) == 0) {
-							p++;
+							p ++;
 							is_exim = TRUE;
-							if (r->real_hostname == NULL && r->from_hostname !=
-								NULL) {
+							if (r->real_hostname == NULL && r->from_hostname != NULL) {
 								r->real_hostname = r->from_hostname;
 							}
 							s = p;
-							while (*p != ')' && !g_ascii_isspace (*p) && *p !=
-								'\0') {
-								p++;
+							while (*p != ')' && !g_ascii_isspace (*p) && *p != '\0') {
+								p ++;
 							}
 							if (p > s) {
-								r->from_hostname = rspamd_mempool_alloc (pool,
-										p - s + 1);
+								r->from_hostname = rspamd_mempool_alloc (pool, p - s + 1);
 								rspamd_strlcpy (r->from_hostname, s, p - s + 1);
 							}
 						}
 						else if (p - s == 4 && memcmp (s, "port=", 5) == 0) {
-							p++;
+							p ++;
 							is_exim = TRUE;
 							while (g_ascii_isdigit (*p)) {
-								p++;
+								p ++;
 							}
 							state = RSPAMD_RECV_STATE_SKIP_SPACES;
 							next_state = RSPAMD_RECV_STATE_BRACES_BLOCK;
 						}
 						else if (*p == '=' && is_exim) {
 							/* Just skip unknown pairs */
-							p++;
-							while (!g_ascii_isspace (*p) && *p != ')' && *p !=
-								'\0') {
-								p++;
+							p ++;
+							while (!g_ascii_isspace (*p) && *p != ')' && *p != '\0') {
+								p ++;
 							}
 							state = RSPAMD_RECV_STATE_SKIP_SPACES;
 							next_state = RSPAMD_RECV_STATE_BRACES_BLOCK;
 						}
 						else {
 							/* skip all  */
-							while (*p++ != ')' && *p != '\0') ;
+							while (*p++ != ')' && *p != '\0');
 							state = RSPAMD_RECV_STATE_IP_BLOCK;
 						}
 					}
@@ -486,13 +457,13 @@ parse_recv_header (rspamd_mempool_t * pool,
 						continue;
 					}
 					if (*p == ')') {
-						p++;
+						p ++;
 						state = RSPAMD_RECV_STATE_SKIP_SPACES;
 						next_state = RSPAMD_RECV_STATE_IP_BLOCK;
 					}
 				}
 				else if (*p == ')') {
-					p++;
+					p ++;
 					state = RSPAMD_RECV_STATE_SKIP_SPACES;
 					next_state = RSPAMD_RECV_STATE_IP_BLOCK;
 				}
@@ -502,11 +473,11 @@ parse_recv_header (rspamd_mempool_t * pool,
 				}
 			}
 			break;
-		/* Got by word */
+			/* Got by word */
 		case RSPAMD_RECV_STATE_BY_BLOCK:
 			/* Here can be only hostname */
 			if ((g_ascii_isalnum (*p) || *p == '.' || *p == '-'
-				|| *p == '_') && p[1] != '\0') {
+					|| *p == '_') && p[1] != '\0') {
 				p++;
 			}
 			else {
@@ -528,8 +499,7 @@ parse_recv_header (rspamd_mempool_t * pool,
 					}
 					else if (r->from_ip == NULL && r->real_ip != NULL) {
 						r->from_ip = r->real_ip;
-						if (r->real_hostname == NULL && r->from_hostname !=
-							NULL) {
+						if (r->real_hostname == NULL && r->from_hostname != NULL) {
 							r->real_hostname = r->from_hostname;
 						}
 					}
@@ -538,10 +508,10 @@ parse_recv_header (rspamd_mempool_t * pool,
 			}
 			break;
 
-		/* Extract ip */
+			/* Extract ip */
 		case RSPAMD_RECV_STATE_PARSE_IP:
 			while (g_ascii_isxdigit (*p) || *p == '.' || *p == ':') {
-				p++;
+				p ++;
 			}
 			if (*p != ']') {
 				/* Not an ip in fact */
@@ -557,7 +527,7 @@ parse_recv_header (rspamd_mempool_t * pool,
 			}
 			break;
 
-		/* Skip spaces */
+			/* Skip spaces */
 		case RSPAMD_RECV_STATE_SKIP_SPACES:
 			if (!g_ascii_isspace (*p)) {
 				state = next_state;
@@ -582,10 +552,10 @@ parse_recv_header (rspamd_mempool_t * pool,
 static void
 process_raw_headers (struct rspamd_task *task)
 {
-	struct raw_header *new = NULL, *lp;
-	gchar *p, *c, *tmp, *tp;
-	gint state = 0, l, next_state = 100, err_state = 100, t_state;
-	gboolean valid_folding = FALSE;
+	struct raw_header              *new = NULL, *lp;
+	gchar                          *p, *c, *tmp, *tp;
+	gint                            state = 0, l, next_state = 100, err_state = 100, t_state;
+	gboolean                        valid_folding = FALSE;
 
 	p = task->raw_headers_str;
 	c = p;
@@ -607,15 +577,13 @@ process_raw_headers (struct rspamd_task *task)
 		case 1:
 			/* We got something like header's name */
 			if (*p == ':') {
-				new =
-					rspamd_mempool_alloc0 (task->task_pool,
-						sizeof (struct raw_header));
+				new = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct raw_header));
 				l = p - c;
 				tmp = rspamd_mempool_alloc (task->task_pool, l + 1);
 				rspamd_strlcpy (tmp, c, l + 1);
 				new->name = tmp;
 				new->empty_separator = TRUE;
-				p++;
+				p ++;
 				state = 2;
 				c = p;
 			}
@@ -625,7 +593,7 @@ process_raw_headers (struct rspamd_task *task)
 				next_state = 0;
 			}
 			else {
-				p++;
+				p ++;
 			}
 			break;
 		case 2:
@@ -633,11 +601,11 @@ process_raw_headers (struct rspamd_task *task)
 			if (*p == '\t') {
 				new->tab_separated = TRUE;
 				new->empty_separator = FALSE;
-				p++;
+				p ++;
 			}
 			else if (*p == ' ') {
 				new->empty_separator = FALSE;
-				p++;
+				p ++;
 			}
 			else if (*p == '\n' || *p == '\r') {
 				/* Process folding */
@@ -675,7 +643,7 @@ process_raw_headers (struct rspamd_task *task)
 				state = 4;
 			}
 			else {
-				p++;
+				p ++;
 			}
 			break;
 		case 4:
@@ -684,16 +652,16 @@ process_raw_headers (struct rspamd_task *task)
 			tmp = rspamd_mempool_alloc (task->task_pool, l + 1);
 			tp = tmp;
 			t_state = 0;
-			while (l--) {
+			while (l --) {
 				if (t_state == 0) {
 					/* Before folding */
 					if (*c == '\n' || *c == '\r') {
 						t_state = 1;
-						c++;
-						*tp++ = ' ';
+						c ++;
+						*tp ++ = ' ';
 					}
 					else {
-						*tp++ = *c++;
+						*tp ++ = *c ++;
 					}
 				}
 				else if (t_state == 1) {
@@ -703,19 +671,18 @@ process_raw_headers (struct rspamd_task *task)
 					}
 					else {
 						t_state = 0;
-						*tp++ = *c++;
+						*tp ++ = *c ++;
 					}
 				}
 			}
 			/* Strip last space that can be added by \r\n parsing */
 			if (*(tp - 1) == ' ') {
-				tp--;
+				tp --;
 			}
 			*tp = '\0';
 			new->value = tmp;
 			new->next = NULL;
-			if ((lp =
-				g_hash_table_lookup (task->raw_headers, new->name)) != NULL) {
+			if ((lp = g_hash_table_lookup (task->raw_headers, new->name)) != NULL) {
 				while (lp->next != NULL) {
 					lp = lp->next;
 				}
@@ -731,8 +698,7 @@ process_raw_headers (struct rspamd_task *task)
 			/* Header has only name, no value */
 			new->next = NULL;
 			new->value = "";
-			if ((lp =
-				g_hash_table_lookup (task->raw_headers, new->name)) != NULL) {
+			if ((lp = g_hash_table_lookup (task->raw_headers, new->name)) != NULL) {
 				while (lp->next != NULL) {
 					lp = lp->next;
 				}
@@ -751,12 +717,12 @@ process_raw_headers (struct rspamd_task *task)
 			}
 			else {
 				if (*p == '\r' || *p == '\n') {
-					p++;
+					p ++;
 					valid_folding = FALSE;
 				}
 				else if (*p == '\t' || *p == ' ') {
 					/* Valid folding */
-					p++;
+					p ++;
 					valid_folding = TRUE;
 				}
 				else {
@@ -776,24 +742,24 @@ process_raw_headers (struct rspamd_task *task)
 			/* Fail state, skip line */
 			if (*p == '\r') {
 				if (*(p + 1) == '\n') {
-					p++;
+					p ++;
 				}
-				p++;
+				p ++;
 				state = next_state;
 			}
 			else if (*p == '\n') {
 				if (*(p + 1) == '\r') {
-					p++;
+					p ++;
 				}
-				p++;
+				p ++;
 				state = next_state;
 			}
 			else if (*(p + 1) == '\0') {
 				state = next_state;
-				p++;
+				p ++;
 			}
 			else {
-				p++;
+				p ++;
 			}
 			break;
 		}
@@ -803,62 +769,45 @@ process_raw_headers (struct rspamd_task *task)
 static void
 free_byte_array_callback (void *pointer)
 {
-	GByteArray *arr = (GByteArray *) pointer;
+	GByteArray                     *arr = (GByteArray *) pointer;
 	g_byte_array_free (arr, TRUE);
 }
 
-static GByteArray *
-convert_text_to_utf (struct rspamd_task *task,
-	GByteArray * part_content,
-	GMimeContentType * type,
-	struct mime_text_part *text_part)
+static GByteArray              *
+convert_text_to_utf (struct rspamd_task *task, GByteArray * part_content, GMimeContentType * type, struct mime_text_part *text_part)
 {
-	GError *err = NULL;
-	gsize read_bytes, write_bytes;
-	const gchar *charset;
-	gchar *res_str;
-	GByteArray *result_array;
+	GError                         *err = NULL;
+	gsize                           read_bytes, write_bytes;
+	const gchar                     *charset;
+	gchar                          *res_str;
+	GByteArray                     *result_array;
 
 	if (task->cfg->raw_mode) {
 		text_part->is_raw = TRUE;
 		return part_content;
 	}
 
-	if ((charset =
-		g_mime_content_type_get_parameter (type, "charset")) == NULL) {
+	if ((charset = g_mime_content_type_get_parameter (type, "charset")) == NULL) {
 		text_part->is_raw = TRUE;
 		return part_content;
 	}
 
-	if (g_ascii_strcasecmp (charset,
-		"utf-8") == 0 || g_ascii_strcasecmp (charset, "utf8") == 0) {
+	if (g_ascii_strcasecmp (charset, "utf-8") == 0 || g_ascii_strcasecmp (charset, "utf8") == 0) {
 		if (g_utf8_validate (part_content->data, part_content->len, NULL)) {
 			text_part->is_raw = FALSE;
 			text_part->is_utf = TRUE;
 			return part_content;
 		}
 		else {
-			msg_info (
-				"<%s>: contains invalid utf8 characters, assume it as raw",
-				task->message_id);
+			msg_info ("<%s>: contains invalid utf8 characters, assume it as raw", task->message_id);
 			text_part->is_raw = TRUE;
 			return part_content;
 		}
 	}
 
-	res_str = g_convert_with_fallback (part_content->data,
-			part_content->len,
-			UTF8_CHARSET,
-			charset,
-			NULL,
-			&read_bytes,
-			&write_bytes,
-			&err);
+	res_str = g_convert_with_fallback (part_content->data, part_content->len, UTF8_CHARSET, charset, NULL, &read_bytes, &write_bytes, &err);
 	if (res_str == NULL) {
-		msg_warn ("<%s>: cannot convert from %s to utf8: %s",
-			task->message_id,
-			charset,
-			err ? err->message : "unknown problem");
+		msg_warn ("<%s>: cannot convert from %s to utf8: %s", task->message_id, charset, err ? err->message : "unknown problem");
 		text_part->is_raw = TRUE;
 		return part_content;
 	}
@@ -866,9 +815,7 @@ convert_text_to_utf (struct rspamd_task *task,
 	result_array = rspamd_mempool_alloc (task->task_pool, sizeof (GByteArray));
 	result_array->data = res_str;
 	result_array->len = write_bytes;
-	rspamd_mempool_add_destructor (task->task_pool,
-		(rspamd_mempool_destruct_t) g_free,
-		res_str);
+	rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_free, res_str);
 	text_part->is_raw = FALSE;
 	text_part->is_utf = TRUE;
 
@@ -876,43 +823,31 @@ convert_text_to_utf (struct rspamd_task *task,
 }
 
 static void
-process_text_part (struct rspamd_task *task,
-	GByteArray *part_content,
-	GMimeContentType *type,
-	GMimeObject *part,
-	GMimeObject *parent,
-	gboolean is_empty)
+process_text_part (struct rspamd_task *task, GByteArray *part_content, GMimeContentType *type,
+		GMimeObject *part, GMimeObject *parent, gboolean is_empty)
 {
-	struct mime_text_part *text_part;
-	const gchar *cd;
+	struct mime_text_part          *text_part;
+	const gchar                     *cd;
 
 	/* Skip attachements */
 #ifndef GMIME24
 	cd = g_mime_part_get_content_disposition (GMIME_PART (part));
-	if (cd &&
-		g_ascii_strcasecmp (cd,
-		"attachment") == 0 && !task->cfg->check_text_attachements) {
+	if (cd && g_ascii_strcasecmp (cd, "attachment") == 0 && !task->cfg->check_text_attachements) {
 		debug_task ("skip attachments for checking as text parts");
 		return;
 	}
 #else
 	cd = g_mime_object_get_disposition (GMIME_OBJECT (part));
-	if (cd &&
-		g_ascii_strcasecmp (cd,
-		GMIME_DISPOSITION_ATTACHMENT) == 0 &&
-		!task->cfg->check_text_attachements) {
+	if (cd && g_ascii_strcasecmp (cd, GMIME_DISPOSITION_ATTACHMENT) == 0 && !task->cfg->check_text_attachements) {
 		debug_task ("skip attachments for checking as text parts");
 		return;
 	}
 #endif
 
-	if (g_mime_content_type_is_type (type, "text",
-		"html") || g_mime_content_type_is_type (type, "text", "xhtml")) {
+	if (g_mime_content_type_is_type (type, "text", "html") || g_mime_content_type_is_type (type, "text", "xhtml")) {
 		debug_task ("got urls from text/html part");
 
-		text_part =
-			rspamd_mempool_alloc0 (task->task_pool,
-				sizeof (struct mime_text_part));
+		text_part = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct mime_text_part));
 		text_part->is_html = TRUE;
 		if (is_empty) {
 			text_part->is_empty = TRUE;
@@ -921,26 +856,18 @@ process_text_part (struct rspamd_task *task,
 			task->text_parts = g_list_prepend (task->text_parts, text_part);
 			return;
 		}
-		text_part->orig = convert_text_to_utf (task,
-				part_content,
-				type,
-				text_part);
+		text_part->orig = convert_text_to_utf (task, part_content, type, text_part);
 		text_part->is_balanced = TRUE;
 		text_part->html_nodes = NULL;
 		text_part->parent = parent;
 
-		text_part->content = strip_html_tags (task,
-				task->task_pool,
-				text_part,
-				text_part->orig,
-				NULL);
+		text_part->content = strip_html_tags (task, task->task_pool, text_part, text_part->orig, NULL);
 
 		if (text_part->html_nodes == NULL) {
 			url_parse_text (task->task_pool, task, text_part, FALSE);
 		}
 		else {
-			decode_entitles (text_part->content->data,
-				&text_part->content->len);
+			decode_entitles (text_part->content->data, &text_part->content->len);
 			url_parse_text (task->task_pool, task, text_part, FALSE);
 #if 0
 			url_parse_text (task->task_pool, task, text_part, TRUE);
@@ -948,17 +875,13 @@ process_text_part (struct rspamd_task *task,
 		}
 
 		fuzzy_init_part (text_part, task->task_pool, task->cfg->max_diff);
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t) free_byte_array_callback,
-			text_part->content);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) free_byte_array_callback, text_part->content);
 		task->text_parts = g_list_prepend (task->text_parts, text_part);
 	}
 	else if (g_mime_content_type_is_type (type, "text", "*")) {
 		debug_task ("got urls from text/plain part");
 
-		text_part =
-			rspamd_mempool_alloc0 (task->task_pool,
-				sizeof (struct mime_text_part));
+		text_part = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct mime_text_part));
 		text_part->is_html = FALSE;
 		text_part->parent = parent;
 		if (is_empty) {
@@ -968,10 +891,7 @@ process_text_part (struct rspamd_task *task,
 			task->text_parts = g_list_prepend (task->text_parts, text_part);
 			return;
 		}
-		text_part->orig = convert_text_to_utf (task,
-				part_content,
-				type,
-				text_part);
+		text_part->orig = convert_text_to_utf (task, part_content, type, text_part);
 		text_part->content = text_part->orig;
 		url_parse_text (task->task_pool, task, text_part, FALSE);
 		fuzzy_init_part (text_part, task->task_pool, task->cfg->max_diff);
@@ -981,20 +901,18 @@ process_text_part (struct rspamd_task *task,
 
 #ifdef GMIME24
 static void
-mime_foreach_callback (GMimeObject * parent,
-	GMimeObject * part,
-	gpointer user_data)
+mime_foreach_callback (GMimeObject * parent, GMimeObject * part, gpointer user_data)
 #else
 static void
 mime_foreach_callback (GMimeObject * part, gpointer user_data)
 #endif
 {
-	struct rspamd_task *task = (struct rspamd_task *)user_data;
-	struct mime_part *mime_part;
-	GMimeContentType *type;
-	GMimeDataWrapper *wrapper;
-	GMimeStream *part_stream;
-	GByteArray *part_content;
+	struct rspamd_task             *task = (struct rspamd_task *)user_data;
+	struct mime_part               *mime_part;
+	GMimeContentType               *type;
+	GMimeDataWrapper               *wrapper;
+	GMimeStream                    *part_stream;
+	GByteArray                     *part_content;
 
 	task->parts_count++;
 
@@ -1003,7 +921,7 @@ mime_foreach_callback (GMimeObject * part, gpointer user_data)
 	/* find out what class 'part' is... */
 	if (GMIME_IS_MESSAGE_PART (part)) {
 		/* message/rfc822 or message/news */
-		GMimeMessage *message;
+		GMimeMessage                   *message;
 
 		/* g_mime_message_foreach_part() won't descend into
 		   child message parts, so if we want to count any
@@ -1039,13 +957,11 @@ mime_foreach_callback (GMimeObject * part, gpointer user_data)
 	else if (GMIME_IS_MULTIPART (part)) {
 		/* multipart/mixed, multipart/alternative, multipart/related, multipart/signed, multipart/encrypted, etc... */
 		task->parser_parent_part = part;
-#ifndef GMIME24
+#ifndef GMIME24	
 		debug_task ("detected multipart part");
 		/* we'll get to finding out if this is a signed/encrypted multipart later... */
 		if (task->parser_recursion++ < RECURSION_LIMIT) {
-			g_mime_multipart_foreach ((GMimeMultipart *) part,
-				mime_foreach_callback,
-				task);
+			g_mime_multipart_foreach ((GMimeMultipart *) part, mime_foreach_callback, task);
 		}
 		else {
 			msg_err ("endless recursion detected: %d", task->parser_recursion);
@@ -1056,21 +972,17 @@ mime_foreach_callback (GMimeObject * part, gpointer user_data)
 	else if (GMIME_IS_PART (part)) {
 		/* a normal leaf part, could be text/plain or image/jpeg etc */
 #ifdef GMIME24
-		type = (GMimeContentType *) g_mime_object_get_content_type (GMIME_OBJECT (
-					part));
+		type = (GMimeContentType *) g_mime_object_get_content_type (GMIME_OBJECT (part));
 #else
-		type =
-			(GMimeContentType *) g_mime_part_get_content_type (GMIME_PART (part));
+		type = (GMimeContentType *) g_mime_part_get_content_type (GMIME_PART (part));
 #endif
 		if (type == NULL) {
 			msg_warn ("type of part is unknown, assume text/plain");
 			type = g_mime_content_type_new ("text", "plain");
 #ifdef GMIME24
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t) g_object_unref,				 type);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_object_unref, type);
 #else
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t) g_mime_content_type_destroy, type);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_mime_content_type_destroy, type);
 #endif
 		}
 		wrapper = g_mime_part_get_content_object (GMIME_PART (part));
@@ -1080,45 +992,29 @@ mime_foreach_callback (GMimeObject * part, gpointer user_data)
 		if (wrapper != NULL) {
 #endif
 			part_stream = g_mime_stream_mem_new ();
-			if (g_mime_data_wrapper_write_to_stream (wrapper,
-				part_stream) != -1) {
-				g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (
-						part_stream), FALSE);
-				part_content = g_mime_stream_mem_get_byte_array (GMIME_STREAM_MEM (
-							part_stream));
+			if (g_mime_data_wrapper_write_to_stream (wrapper, part_stream) != -1) {
+				g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (part_stream), FALSE);
+				part_content = g_mime_stream_mem_get_byte_array (GMIME_STREAM_MEM (part_stream));
 				g_object_unref (part_stream);
-				mime_part =
-					rspamd_mempool_alloc (task->task_pool,
-						sizeof (struct mime_part));
+				mime_part = rspamd_mempool_alloc (task->task_pool, sizeof (struct mime_part));
 				mime_part->type = type;
 				mime_part->content = part_content;
 				mime_part->parent = task->parser_parent_part;
-				mime_part->filename = g_mime_part_get_filename (GMIME_PART (
-							part));
-				debug_task ("found part with content-type: %s/%s",
-					type->type,
-					type->subtype);
+				mime_part->filename = g_mime_part_get_filename (GMIME_PART (part));
+				debug_task ("found part with content-type: %s/%s", type->type, type->subtype);
 				task->parts = g_list_prepend (task->parts, mime_part);
 				/* Skip empty parts */
-				process_text_part (task,
-					part_content,
-					type,
-					part,
-					task->parser_parent_part,
-					(part_content->len <= 0));
+				process_text_part (task, part_content, type, part, task->parser_parent_part, (part_content->len <= 0));
 			}
 			else {
-				msg_warn ("write to stream failed: %d, %s", errno,
-					strerror (errno));
+				msg_warn ("write to stream failed: %d, %s", errno, strerror (errno));
 			}
 #ifndef GMIME24
 			g_object_unref (wrapper);
 #endif
 		}
 		else {
-			msg_warn ("cannot get wrapper for mime part, type of part: %s/%s",
-				type->type,
-				type->subtype);
+			msg_warn ("cannot get wrapper for mime part, type of part: %s/%s", type->type, type->subtype);
 		}
 	}
 	else {
@@ -1129,7 +1025,7 @@ mime_foreach_callback (GMimeObject * part, gpointer user_data)
 static void
 destroy_message (void *pointer)
 {
-	GMimeMessage *msg = pointer;
+	GMimeMessage                   *msg = pointer;
 
 	msg_debug ("freeing pointer %p", msg);
 	g_object_unref (msg);
@@ -1138,34 +1034,33 @@ destroy_message (void *pointer)
 gint
 process_message (struct rspamd_task *task)
 {
-	GMimeMessage *message;
-	GMimeParser *parser;
-	GMimeStream *stream;
-	GByteArray *tmp;
-	GList *first, *cur;
-	GMimePart *part;
-	GMimeDataWrapper *wrapper;
-	struct received_header *recv;
-	gchar *mid, *url_str, *p, *end, *url_end;
-	struct uri *subject_url;
-	gsize len;
-	gint rc;
+	GMimeMessage                   *message;
+	GMimeParser                    *parser;
+	GMimeStream                    *stream;
+	GByteArray                     *tmp;
+	GList                          *first, *cur;
+	GMimePart                      *part;
+	GMimeDataWrapper               *wrapper;
+	struct received_header         *recv;
+	gchar                          *mid, *url_str, *p, *end, *url_end;
+	struct uri                     *subject_url;
+	gsize                           len;
+	gint                            rc;
 
 	tmp = rspamd_mempool_alloc (task->task_pool, sizeof (GByteArray));
 	tmp->data = task->msg->str;
 	tmp->len = task->msg->len;
 
 	stream = g_mime_stream_mem_new_with_byte_array (tmp);
-	/*
-	 * This causes g_mime_stream not to free memory by itself as it is memory allocated by
-	 * pool allocator
-	 */
+	/* 
+	* This causes g_mime_stream not to free memory by itself as it is memory allocated by
+	* pool allocator
+	*/
 	g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (stream), FALSE);
 
 	if (task->is_mime) {
 
-		debug_task ("construct mime parser from string length %d",
-			(gint)task->msg->len);
+		debug_task ("construct mime parser from string length %d", (gint)task->msg->len);
 		/* create a new parser object to parse the stream */
 		parser = g_mime_parser_new_with_stream (stream);
 		g_object_unref (stream);
@@ -1179,8 +1074,7 @@ process_message (struct rspamd_task *task)
 		}
 
 		task->message = message;
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t) destroy_message, task->message);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) destroy_message, task->message);
 
 		/* Save message id for future use */
 		task->message_id = g_mime_message_get_message_id (task->message);
@@ -1207,8 +1101,7 @@ process_message (struct rspamd_task *task)
 		}
 
 #ifdef GMIME24
-		task->raw_headers_str =
-			g_mime_object_get_headers (GMIME_OBJECT (task->message));
+		task->raw_headers_str = g_mime_object_get_headers (GMIME_OBJECT (task->message));
 #else
 		task->raw_headers_str = g_mime_message_get_headers (task->message);
 #endif
@@ -1216,13 +1109,10 @@ process_message (struct rspamd_task *task)
 		process_images (task);
 
 		/* Parse received headers */
-		first =
-			message_get_header (task->task_pool, message, "Received", FALSE);
+		first = message_get_header (task->task_pool, message, "Received", FALSE);
 		cur = first;
 		while (cur) {
-			recv =
-				rspamd_mempool_alloc0 (task->task_pool,
-					sizeof (struct received_header));
+			recv = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct received_header));
 			parse_recv_header (task->task_pool, cur->data, recv);
 			task->received = g_list_prepend (task->received, recv);
 			cur = g_list_next (cur);
@@ -1232,21 +1122,16 @@ process_message (struct rspamd_task *task)
 		}
 
 		if (task->raw_headers_str) {
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t) g_free, task->raw_headers_str);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_free, task->raw_headers_str);
 			process_raw_headers (task);
 		}
 
 		task->rcpts = g_mime_message_get_all_recipients (message);
 		if (task->rcpts) {
 #ifdef GMIME24
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t) g_object_unref,
-				task->rcpts);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_object_unref, task->rcpts);
 #else
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t) internet_address_list_destroy,
-				task->rcpts);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) internet_address_list_destroy, task->rcpts);
 #endif
 		}
 
@@ -1264,33 +1149,26 @@ process_message (struct rspamd_task *task)
 		/* Construct part for it */
 		part = g_mime_part_new_with_type ("text", "html");
 #ifdef GMIME24
-		wrapper = g_mime_data_wrapper_new_with_stream (stream,
-				GMIME_CONTENT_ENCODING_8BIT);
+		wrapper = g_mime_data_wrapper_new_with_stream (stream, GMIME_CONTENT_ENCODING_8BIT);
 #else
-		wrapper = g_mime_data_wrapper_new_with_stream (stream,
-				GMIME_PART_ENCODING_8BIT);
+		wrapper = g_mime_data_wrapper_new_with_stream (stream, GMIME_PART_ENCODING_8BIT);
 #endif
 		g_mime_part_set_content_object (part, wrapper);
 		g_mime_message_set_mime_part (task->message, GMIME_OBJECT (part));
 		/* Register destructors */
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t) g_object_unref,	 wrapper);
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t) g_object_unref,	 part);
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t) destroy_message, task->message);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_object_unref, wrapper);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_object_unref, part);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) destroy_message, task->message);
 		/* Now parse in a normal way */
 		task->parser_recursion = 0;
 #ifdef GMIME24
 		g_mime_message_foreach (task->message, mime_foreach_callback, task);
 #else
-		g_mime_message_foreach_part (task->message, mime_foreach_callback,
-			task);
+		g_mime_message_foreach_part (task->message, mime_foreach_callback, task);
 #endif
 		/* Generate message ID */
 		mid = g_mime_utils_generate_message_id ("localhost.localdomain");
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t) g_free, mid);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_free, mid);
 		g_mime_message_set_message_id (task->message, mid);
 		task->message_id = mid;
 		task->queue_id = mid;
@@ -1304,10 +1182,7 @@ process_message (struct rspamd_task *task)
 		if (task->rcpt) {
 			cur = task->rcpt;
 			while (cur) {
-				g_mime_message_add_recipient (task->message,
-					GMIME_RECIPIENT_TYPE_TO,
-					NULL,
-					(gchar *)cur->data);
+				g_mime_message_add_recipient (task->message, GMIME_RECIPIENT_TYPE_TO, NULL, (gchar *)cur->data);
 				cur = g_list_next (cur);
 			}
 		}
@@ -1323,29 +1198,22 @@ process_message (struct rspamd_task *task)
 
 		while (p < end) {
 			/* Search to the end of url */
-			if (url_try_text (task->task_pool, p, end - p, NULL, &url_end,
-				&url_str, FALSE)) {
+			if (url_try_text (task->task_pool, p, end - p, NULL, &url_end, &url_str, FALSE)) {
 				if (url_str != NULL) {
-					subject_url = rspamd_mempool_alloc0 (task->task_pool,
-							sizeof (struct uri));
+					subject_url = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct uri));
 					if (subject_url != NULL) {
 						/* Try to parse url */
 						rc = parse_uri (subject_url, url_str, task->task_pool);
-						if ((rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES ||
-							rc == URI_ERRNO_NO_HOST_SLASH) &&
-							subject_url->hostlen > 0) {
+						if ((rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES || rc == URI_ERRNO_NO_HOST_SLASH) &&
+								subject_url->hostlen > 0) {
 							if (subject_url->protocol != PROTOCOL_MAILTO) {
 								if (!g_tree_lookup (task->urls, subject_url)) {
-									g_tree_insert (task->urls,
-										subject_url,
-										subject_url);
+									g_tree_insert (task->urls, subject_url, subject_url);
 								}
 							}
 						}
 						else if (rc != URI_ERRNO_OK) {
-							msg_info ("extract of url '%s' failed: %s",
-								url_str,
-								url_strerror (rc));
+							msg_info ("extract of url '%s' failed: %s", url_str, url_strerror (rc));
 						}
 					}
 				}
@@ -1363,15 +1231,15 @@ process_message (struct rspamd_task *task)
 }
 
 struct gmime_raw_header {
-	struct raw_header *next;
-	gchar *name;
-	gchar *value;
+	struct raw_header              *next;
+	gchar                           *name;
+	gchar                           *value;
 };
 
 typedef struct _GMimeHeader {
-	GHashTable *hash;
-	GHashTable *writers;
-	struct raw_header *headers;
+	GHashTable                     *hash;
+	GHashTable                     *writers;
+	struct raw_header              *headers;
 } local_GMimeHeader;
 
 
@@ -1393,20 +1261,13 @@ enum {
  */
 #ifndef GMIME24
 static void
-header_iterate (rspamd_mempool_t * pool,
-	struct gmime_raw_header *h,
-	GList ** ret,
-	const gchar *field,
-	gboolean strong)
+header_iterate (rspamd_mempool_t * pool, struct gmime_raw_header *h, GList ** ret, const gchar *field, gboolean strong)
 {
 	while (h) {
 		if (G_LIKELY (!strong)) {
-			if (h->value &&
-				!g_ascii_strncasecmp (field, h->name, strlen (field))) {
+			if (h->value && !g_ascii_strncasecmp (field, h->name, strlen (field))) {
 				if (pool != NULL) {
-					*ret =
-						g_list_prepend (*ret,
-							rspamd_mempool_strdup (pool, h->value));
+					*ret = g_list_prepend (*ret, rspamd_mempool_strdup (pool, h->value));
 				}
 				else {
 					*ret = g_list_prepend (*ret, g_strdup (h->value));
@@ -1416,9 +1277,7 @@ header_iterate (rspamd_mempool_t * pool,
 		else {
 			if (h->value && !strncmp (field, h->name, strlen (field))) {
 				if (pool != NULL) {
-					*ret =
-						g_list_prepend (*ret,
-							rspamd_mempool_strdup (pool, h->value));
+					*ret = g_list_prepend (*ret, rspamd_mempool_strdup (pool, h->value));
 				}
 				else {
 					*ret = g_list_prepend (*ret, g_strdup (h->value));
@@ -1430,15 +1289,11 @@ header_iterate (rspamd_mempool_t * pool,
 }
 #else
 static void
-header_iterate (rspamd_mempool_t * pool,
-	GMimeHeaderList * ls,
-	GList ** ret,
-	const gchar *field,
-	gboolean strong)
+header_iterate (rspamd_mempool_t * pool, GMimeHeaderList * ls, GList ** ret, const gchar *field, gboolean strong)
 {
 	/* Use iterator in case of gmime 2.4 */
-	GMimeHeaderIter *iter;
-	const gchar *name;
+	GMimeHeaderIter                *iter;
+	const gchar                     *name;
 
 	if (ls == NULL) {
 		*ret = NULL;
@@ -1446,38 +1301,27 @@ header_iterate (rspamd_mempool_t * pool,
 	}
 
 	iter = g_mime_header_iter_new ();
-	if (g_mime_header_list_get_iter (ls,
-		iter) && g_mime_header_iter_first (iter)) {
+	if (g_mime_header_list_get_iter (ls, iter) && g_mime_header_iter_first (iter)) {
 		/* Iterate throught headers */
 		while (g_mime_header_iter_is_valid (iter)) {
 			name = g_mime_header_iter_get_name (iter);
 			if (G_LIKELY (!strong)) {
 				if (!g_ascii_strncasecmp (field, name, strlen (name))) {
 					if (pool != NULL) {
-						*ret =
-							g_list_prepend (*ret,
-								rspamd_mempool_strdup (pool,
-								g_mime_header_iter_get_value (iter)));
+						*ret = g_list_prepend (*ret, rspamd_mempool_strdup (pool, g_mime_header_iter_get_value (iter)));
 					}
 					else {
-						*ret =
-							g_list_prepend (*ret,
-								g_strdup (g_mime_header_iter_get_value (iter)));
+						*ret = g_list_prepend (*ret, g_strdup (g_mime_header_iter_get_value (iter)));
 					}
 				}
 			}
 			else {
 				if (!strncmp (field, name, strlen (name))) {
 					if (pool != NULL) {
-						*ret =
-							g_list_prepend (*ret,
-								rspamd_mempool_strdup (pool,
-								g_mime_header_iter_get_value (iter)));
+						*ret = g_list_prepend (*ret, rspamd_mempool_strdup (pool, g_mime_header_iter_get_value (iter)));
 					}
 					else {
-						*ret =
-							g_list_prepend (*ret,
-								g_strdup (g_mime_header_iter_get_value (iter)));
+						*ret = g_list_prepend (*ret, g_strdup (g_mime_header_iter_get_value (iter)));
 					}
 				}
 			}
@@ -1492,12 +1336,12 @@ header_iterate (rspamd_mempool_t * pool,
 
 
 struct multipart_cb_data {
-	GList *ret;
-	rspamd_mempool_t *pool;
-	const gchar *field;
-	gboolean try_search;
-	gboolean strong;
-	gint rec;
+	GList                          *ret;
+	rspamd_mempool_t                  *pool;
+	const gchar                     *field;
+	gboolean                        try_search;
+	gboolean                        strong;
+	gint                            rec;
 };
 
 #define MAX_REC 10
@@ -1509,21 +1353,21 @@ multipart_iterate (GMimeObject * parent, GMimeObject * part, gpointer user_data)
 multipart_iterate (GMimeObject * part, gpointer user_data)
 #endif
 {
-	struct multipart_cb_data *data = user_data;
+	struct multipart_cb_data       *data = user_data;
 #ifndef GMIME24
-	struct gmime_raw_header *h;
+	struct gmime_raw_header              *h;
 #endif
-	GList *l = NULL;
+	GList                          *l = NULL;
 
 	if (data->try_search && part != NULL && GMIME_IS_PART (part)) {
 #ifdef GMIME24
-		GMimeHeaderList *ls;
+		GMimeHeaderList                *ls;
 
 		ls = g_mime_object_get_header_list (GMIME_OBJECT (part));
 		header_iterate (data->pool, ls, &l, data->field, data->strong);
 #else
 		h = (struct gmime_raw_header *)part->headers->headers;
-		header_iterate (data->pool, h,	&l, data->field, data->strong);
+		header_iterate (data->pool, h, &l, data->field, data->strong);
 #endif
 		if (l == NULL) {
 			/* Header not found, abandon search results */
@@ -1538,26 +1382,21 @@ multipart_iterate (GMimeObject * part, gpointer user_data)
 	else if (data->try_search && GMIME_IS_MULTIPART (part)) {
 		/* Maybe endless recursion here ? */
 		if (data->rec++ < MAX_REC) {
-			g_mime_multipart_foreach (GMIME_MULTIPART (
-					part), multipart_iterate, data);
+			g_mime_multipart_foreach (GMIME_MULTIPART (part), multipart_iterate, data);
 		}
 		else {
-			msg_info ("maximum recurse limit is over, stop recursing, %d",
-				data->rec);
+			msg_info ("maximum recurse limit is over, stop recursing, %d", data->rec);
 			data->try_search = FALSE;
 		}
 	}
 }
 
-static GList *
-local_message_get_header (rspamd_mempool_t * pool,
-	GMimeMessage * message,
-	const gchar *field,
-	gboolean strong)
+static GList                   *
+local_message_get_header (rspamd_mempool_t * pool, GMimeMessage * message, const gchar *field, gboolean strong)
 {
-	GList *gret = NULL;
-	GMimeObject *part;
-	struct multipart_cb_data cb = {
+	GList                          *gret = NULL;
+	GMimeObject                    *part;
+	struct multipart_cb_data        cb = {
 		.try_search = TRUE,
 		.rec = 0,
 		.ret = NULL,
@@ -1567,7 +1406,7 @@ local_message_get_header (rspamd_mempool_t * pool,
 	cb.strong = strong;
 
 #ifndef GMIME24
-	struct gmime_raw_header *h;
+	struct gmime_raw_header       *h;
 
 	if (field == NULL) {
 		return NULL;
@@ -1579,18 +1418,14 @@ local_message_get_header (rspamd_mempool_t * pool,
 
 	if (gret == NULL) {
 		/* Try to iterate with mime part headers */
-		msg_debug ("iterate over headers of mime part to find header %s",
-			field);
+		msg_debug ("iterate over headers of mime part to find header %s", field);
 		part = g_mime_message_get_mime_part (message);
 		if (part) {
 			h = (struct gmime_raw_header *)part->headers->headers;
 			header_iterate (pool, h, &gret, field, strong);
 			if (gret == NULL && GMIME_IS_MULTIPART (part)) {
-				msg_debug (
-					"iterate over headers of each multipart's subparts %s",
-					field);
-				g_mime_multipart_foreach (GMIME_MULTIPART (
-						part), multipart_iterate, &cb);
+				msg_debug ("iterate over headers of each multipart's subparts %s", field);
+				g_mime_multipart_foreach (GMIME_MULTIPART (part), multipart_iterate, &cb);
 				if (cb.ret != NULL) {
 					gret = cb.ret;
 				}
@@ -1603,7 +1438,7 @@ local_message_get_header (rspamd_mempool_t * pool,
 
 	return gret;
 #else
-	GMimeHeaderList *ls;
+	GMimeHeaderList                *ls;
 
 	ls = g_mime_object_get_header_list (GMIME_OBJECT (message));
 	header_iterate (pool, ls, &gret, field, strong);
@@ -1614,8 +1449,7 @@ local_message_get_header (rspamd_mempool_t * pool,
 			ls = g_mime_object_get_header_list (GMIME_OBJECT (part));
 			header_iterate (pool, ls, &gret, field, strong);
 			if (gret == NULL && GMIME_IS_MULTIPART (part)) {
-				g_mime_multipart_foreach (GMIME_MULTIPART (
-						part), multipart_iterate, &cb);
+				g_mime_multipart_foreach (GMIME_MULTIPART (part), multipart_iterate, &cb);
 				if (cb.ret != NULL) {
 					gret = cb.ret;
 				}
@@ -1632,18 +1466,17 @@ local_message_get_header (rspamd_mempool_t * pool,
 }
 
 /**
- * g_mime_message_set_date_from_string: Set the message sent-date
- * @message: MIME Message
- * @string: A string of date
- *
- * Set the sent-date on a MIME Message.
- **/
+* g_mime_message_set_date_from_string: Set the message sent-date
+* @message: MIME Message
+* @string: A string of date
+* 
+* Set the sent-date on a MIME Message.
+**/
 void
-local_mime_message_set_date_from_string (GMimeMessage * message,
-	const gchar * string)
+local_mime_message_set_date_from_string (GMimeMessage * message, const gchar * string)
 {
-	time_t date;
-	gint offset = 0;
+	time_t                          date;
+	gint                            offset = 0;
 
 	date = g_mime_utils_header_decode_date (string, &offset);
 	g_mime_message_set_date (message, date, offset);
@@ -1652,14 +1485,14 @@ local_mime_message_set_date_from_string (GMimeMessage * message,
 /*
  * Replacements for standart gmime functions but converting adresses to IA
  */
-static const gchar *
+static const gchar              *
 local_message_get_sender (GMimeMessage * message)
 {
-	gchar *res;
-	const gchar *from = g_mime_message_get_sender (message);
-	InternetAddressList *ia;
+	gchar                           *res;
+	const gchar                     *from = g_mime_message_get_sender (message);
+	InternetAddressList            *ia;
 
-#ifndef GMIME24
+#ifndef	GMIME24
 	ia = internet_address_parse_string (from);
 #else
 	ia = internet_address_list_parse_string (from);
@@ -1668,7 +1501,7 @@ local_message_get_sender (GMimeMessage * message)
 		return NULL;
 	}
 	res = internet_address_list_to_string (ia, FALSE);
-#ifndef GMIME24
+#ifndef	GMIME24
 	internet_address_list_destroy (ia);
 #else
 	g_object_unref (ia);
@@ -1677,14 +1510,14 @@ local_message_get_sender (GMimeMessage * message)
 	return res;
 }
 
-static const gchar *
+static const gchar              *
 local_message_get_reply_to (GMimeMessage * message)
 {
-	gchar *res;
-	const gchar *from = g_mime_message_get_reply_to (message);
-	InternetAddressList *ia;
+	gchar                           *res;
+	const gchar                     *from = g_mime_message_get_reply_to (message);
+	InternetAddressList            *ia;
 
-#ifndef GMIME24
+#ifndef	GMIME24
 	ia = internet_address_parse_string (from);
 #else
 	ia = internet_address_list_parse_string (from);
@@ -1693,7 +1526,7 @@ local_message_get_reply_to (GMimeMessage * message)
 		return NULL;
 	}
 	res = internet_address_list_to_string (ia, FALSE);
-#ifndef GMIME24
+#ifndef	GMIME24
 	internet_address_list_destroy (ia);
 #else
 	g_object_unref (ia);
@@ -1704,161 +1537,122 @@ local_message_get_reply_to (GMimeMessage * message)
 
 #ifdef GMIME24
 
-#   define ADD_RECIPIENT_TEMPLATE(type,def)                                                     \
-	static void                                                                                     \
-	local_message_add_recipients_from_string_ ## type (GMimeMessage * message, \
-		const gchar * string, \
-		const gchar * value)    \
-	{                                                                                               \
-		InternetAddressList *il, *new;                                                              \
-                                                                                                \
-		il = g_mime_message_get_recipients (message, (def));                                        \
-		new = internet_address_list_parse_string (string);                                          \
-		internet_address_list_append (il, new);                                                     \
-	}                                                                                               \
-
-ADD_RECIPIENT_TEMPLATE (to,	 GMIME_RECIPIENT_TYPE_TO)
-ADD_RECIPIENT_TEMPLATE (cc,	 GMIME_RECIPIENT_TYPE_CC)
-ADD_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
-#   define GET_RECIPIENT_TEMPLATE(type,def)                                                     \
-	static InternetAddressList *                                                                     \
-	local_message_get_recipients_ ## type (GMimeMessage * message, \
-		const gchar * unused)                    \
-	{                                                                                               \
-		return g_mime_message_get_recipients (message, (def));                                      \
-	}
-GET_RECIPIENT_TEMPLATE (to,	 GMIME_RECIPIENT_TYPE_TO)
-GET_RECIPIENT_TEMPLATE (cc,	 GMIME_RECIPIENT_TYPE_CC)
-GET_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
+#   define ADD_RECIPIENT_TEMPLATE(type,def)														\
+static void																						\
+local_message_add_recipients_from_string_##type (GMimeMessage *message, const gchar *string, const gchar *value)	\
+{																								\
+	InternetAddressList *il, *new;																\
+																								\
+	il = g_mime_message_get_recipients (message, (def));										\
+	new = internet_address_list_parse_string (string);											\
+	internet_address_list_append (il, new);														\
+}																								\
+
+ADD_RECIPIENT_TEMPLATE (to, GMIME_RECIPIENT_TYPE_TO)
+	ADD_RECIPIENT_TEMPLATE (cc, GMIME_RECIPIENT_TYPE_CC)
+	ADD_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
+#   define GET_RECIPIENT_TEMPLATE(type,def)														\
+static InternetAddressList*																		\
+local_message_get_recipients_##type (GMimeMessage *message, const gchar *unused)					\
+{																								\
+	return g_mime_message_get_recipients (message, (def));										\
+}
+	GET_RECIPIENT_TEMPLATE (to, GMIME_RECIPIENT_TYPE_TO)
+	GET_RECIPIENT_TEMPLATE (cc, GMIME_RECIPIENT_TYPE_CC)
+	GET_RECIPIENT_TEMPLATE (bcc, GMIME_RECIPIENT_TYPE_BCC)
 #endif
 /* different declarations for different types of set and get functions */
-typedef const gchar *(*GetFunc) (GMimeMessage * message);
-typedef InternetAddressList *(*GetRcptFunc) (GMimeMessage * message,
-	const gchar *type);
-typedef GList *(*GetListFunc) (rspamd_mempool_t * pool, GMimeMessage * message,
-	const gchar *type, gboolean strong);
-typedef void (*SetFunc) (GMimeMessage * message, const gchar *value);
-typedef void (*SetListFunc) (GMimeMessage * message, const gchar *field,
-	const gchar *value);
+  typedef const gchar             *(*GetFunc) (GMimeMessage * message);
+  typedef InternetAddressList    *(*GetRcptFunc) (GMimeMessage * message, const gchar *type);
+  typedef GList                  *(*GetListFunc) (rspamd_mempool_t * pool, GMimeMessage * message, const gchar *type, gboolean strong);
+  typedef void                    (*SetFunc) (GMimeMessage * message, const gchar *value);
+  typedef void                    (*SetListFunc) (GMimeMessage * message, const gchar *field, const gchar *value);
 
 /** different types of functions
- *
- * FUNC_CHARPTR
- *	- function with no arguments
- *	- get returns gchar*
- *
- * FUNC_IA (from Internet Address)
- *	- function with additional "field" argument from the fieldfunc table,
- *	- get returns Glist*
- *
- * FUNC_LIST
- *	- function with additional "field" argument (given arbitrary header field name)
- *	- get returns Glist*
- **/
-enum {
-	FUNC_CHARPTR = 0,
-	FUNC_CHARFREEPTR,
-	FUNC_IA,
-	FUNC_LIST
-};
+*
+* FUNC_CHARPTR
+*	- function with no arguments
+*	- get returns gchar*
+*
+* FUNC_IA (from Internet Address)
+*	- function with additional "field" argument from the fieldfunc table,
+*	- get returns Glist*
+*
+* FUNC_LIST
+*	- function with additional "field" argument (given arbitrary header field name)
+*	- get returns Glist*
+**/
+  enum {
+	  FUNC_CHARPTR = 0,
+	  FUNC_CHARFREEPTR,
+	  FUNC_IA,
+	  FUNC_LIST
+  };
 
 /**
- * fieldfunc struct: structure of MIME fields and corresponding get and set
- * functions.
- **/
-static struct {
-	gchar *name;
-	GetFunc func;
-	GetRcptFunc rcptfunc;
-	GetListFunc getlistfunc;
-	SetFunc setfunc;
-	SetListFunc setlfunc;
-	gint functype;
-} fieldfunc[] =
+* fieldfunc struct: structure of MIME fields and corresponding get and set
+* functions.
+**/
+  static struct {
+	  gchar                           *name;
+	  GetFunc                         func;
+	  GetRcptFunc                     rcptfunc;
+	  GetListFunc                     getlistfunc;
+	  SetFunc                         setfunc;
+	  SetListFunc                     setlfunc;
+	  gint                            functype;
+  } fieldfunc[] =
 {
 	{
-		"From", local_message_get_sender, NULL, NULL, g_mime_message_set_sender,
-		NULL, FUNC_CHARFREEPTR
-	}, {
-		"Reply-To", local_message_get_reply_to, NULL, NULL,
-		g_mime_message_set_reply_to, NULL, FUNC_CHARFREEPTR
-	},
+	"From", local_message_get_sender, NULL, NULL, g_mime_message_set_sender, NULL, FUNC_CHARFREEPTR}, {
+	"Reply-To", local_message_get_reply_to, NULL, NULL, g_mime_message_set_reply_to, NULL, FUNC_CHARFREEPTR},
 #ifndef GMIME24
 	{
-		"To", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL,
-		(SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA
-	}, {
-		"Cc", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL,
-		(SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA
-	}, {
-		"Bcc", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL,
-		(SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA
-	}, {
-		"Date", (GetFunc) g_mime_message_get_date_string, NULL, NULL,
-		local_mime_message_set_date_from_string, NULL, FUNC_CHARFREEPTR
-	},
+	"To", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL, (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA}, {
+	"Cc", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL, (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA}, {
+	"Bcc", NULL, (GetRcptFunc) g_mime_message_get_recipients, NULL, NULL, (SetListFunc) g_mime_message_add_recipients_from_string, FUNC_IA}, {
+	"Date", (GetFunc) g_mime_message_get_date_string, NULL, NULL, local_mime_message_set_date_from_string, NULL, FUNC_CHARFREEPTR},
 #else
 	{
-		"To", NULL, local_message_get_recipients_to, NULL, NULL,
-		local_message_add_recipients_from_string_to, FUNC_IA
-	}, {
-		"Cc", NULL, local_message_get_recipients_cc, NULL, NULL,
-		local_message_add_recipients_from_string_cc, FUNC_IA
-	}, {
-		"Bcc", NULL, local_message_get_recipients_bcc, NULL, NULL,
-		local_message_add_recipients_from_string_bcc, FUNC_IA
-	}, {
-		"Date", (GetFunc)g_mime_message_get_date_as_string, NULL, NULL,
-		local_mime_message_set_date_from_string, NULL, FUNC_CHARFREEPTR
-	},
+	"To", NULL, local_message_get_recipients_to, NULL, NULL, local_message_add_recipients_from_string_to, FUNC_IA}, {
+	"Cc", NULL, local_message_get_recipients_cc, NULL, NULL, local_message_add_recipients_from_string_cc, FUNC_IA}, {
+	"Bcc", NULL, local_message_get_recipients_bcc, NULL, NULL, local_message_add_recipients_from_string_bcc, FUNC_IA}, {
+	"Date", (GetFunc)g_mime_message_get_date_as_string, NULL, NULL, local_mime_message_set_date_from_string, NULL, FUNC_CHARFREEPTR},
 #endif
 	{
-		"Subject", g_mime_message_get_subject, NULL, NULL,
-		g_mime_message_set_subject, NULL, FUNC_CHARPTR
-	}, {
-		"Message-Id", g_mime_message_get_message_id, NULL, NULL,
-		g_mime_message_set_message_id, NULL, FUNC_CHARPTR
-	},
+	"Subject", g_mime_message_get_subject, NULL, NULL, g_mime_message_set_subject, NULL, FUNC_CHARPTR}, {
+	"Message-Id", g_mime_message_get_message_id, NULL, NULL, g_mime_message_set_message_id, NULL, FUNC_CHARPTR},
 #ifndef GMIME24
 	{
-		NULL, NULL, NULL, local_message_get_header, NULL,
-		g_mime_message_add_header, FUNC_LIST
-	}
+	NULL, NULL, NULL, local_message_get_header, NULL, g_mime_message_add_header, FUNC_LIST}
 #else
 	{
-		NULL, NULL, NULL, local_message_get_header, NULL,
-		(SetListFunc)g_mime_object_append_header, FUNC_LIST
-	}
+	NULL, NULL, NULL, local_message_get_header, NULL, (SetListFunc)g_mime_object_append_header, FUNC_LIST}
 #endif
 };
 
 /**
- * message_set_header: set header of any type excluding special (Content- and MIME-Version:)
- **/
+* message_set_header: set header of any type excluding special (Content- and MIME-Version:)
+**/
 void
-message_set_header (GMimeMessage * message,
-	const gchar *field,
-	const gchar *value)
+message_set_header (GMimeMessage * message, const gchar *field, const gchar *value)
 {
-	gint i;
+	gint                            i;
 
-	if (!g_ascii_strcasecmp (field,
-		"MIME-Version:") || !g_ascii_strncasecmp (field, "Content-", 8)) {
+	if (!g_ascii_strcasecmp (field, "MIME-Version:") || !g_ascii_strncasecmp (field, "Content-", 8)) {
 		return;
 	}
 	for (i = 0; i <= HEADER_UNKNOWN; ++i) {
-		if (!fieldfunc[i].name ||
-			!g_ascii_strncasecmp (field, fieldfunc[i].name,
-			strlen (fieldfunc[i].name))) {
+		if (!fieldfunc[i].name || !g_ascii_strncasecmp (field, fieldfunc[i].name, strlen (fieldfunc[i].name))) {
 			switch (fieldfunc[i].functype) {
 			case FUNC_CHARPTR:
-				(*(fieldfunc[i].setfunc))(message, value);
+				(*(fieldfunc[i].setfunc)) (message, value);
 				break;
 			case FUNC_IA:
-				(*(fieldfunc[i].setlfunc))(message, fieldfunc[i].name, value);
+				(*(fieldfunc[i].setlfunc)) (message, fieldfunc[i].name, value);
 				break;
 			case FUNC_LIST:
-				(*(fieldfunc[i].setlfunc))(message, field, value);
+				(*(fieldfunc[i].setlfunc)) (message, field, value);
 				break;
 			}
 			break;
@@ -1868,45 +1662,37 @@ message_set_header (GMimeMessage * message,
 
 
 /**
- * message_get_header: returns the list of 'any header' values
- * (except of unsupported yet Content- and MIME-Version special headers)
- *
- * You should free the GList list by yourself.
- **/
-GList *
-message_get_header (rspamd_mempool_t * pool,
-	GMimeMessage * message,
-	const gchar *field,
-	gboolean strong)
+* message_get_header: returns the list of 'any header' values
+* (except of unsupported yet Content- and MIME-Version special headers)
+*
+* You should free the GList list by yourself.
+**/
+GList                          *
+message_get_header (rspamd_mempool_t * pool, GMimeMessage * message, const gchar *field, gboolean strong)
 {
-	gint i;
-	gchar *ret = NULL, *ia_string;
-	GList *gret = NULL;
-	InternetAddressList *ia_list = NULL, *ia;
+	gint                            i;
+	gchar                           *ret = NULL, *ia_string;
+	GList                          *gret = NULL;
+	InternetAddressList            *ia_list = NULL, *ia;
 
 	for (i = 0; i <= HEADER_UNKNOWN; ++i) {
-		if (!fieldfunc[i].name ||
-			!g_ascii_strncasecmp (field, fieldfunc[i].name,
-			strlen (fieldfunc[i].name))) {
+		if (!fieldfunc[i].name || !g_ascii_strncasecmp (field, fieldfunc[i].name, strlen (fieldfunc[i].name))) {
 			switch (fieldfunc[i].functype) {
 			case FUNC_CHARFREEPTR:
-				ret = (gchar *)(*(fieldfunc[i].func))(message);
+				ret = (gchar *)(*(fieldfunc[i].func)) (message);
 				break;
 			case FUNC_CHARPTR:
-				ret = (gchar *)(*(fieldfunc[i].func))(message);
+				ret = (gchar *)(*(fieldfunc[i].func)) (message);
 				break;
 			case FUNC_IA:
-				ia_list = (*(fieldfunc[i].rcptfunc))(message, field);
+				ia_list = (*(fieldfunc[i].rcptfunc)) (message, field);
 				ia = ia_list;
 #ifndef GMIME24
 				while (ia && ia->address) {
 
-					ia_string = internet_address_to_string (
-						(InternetAddress *) ia->address,
-						FALSE);
+					ia_string = internet_address_to_string ((InternetAddress *) ia->address, FALSE);
 					if (pool != NULL) {
-						rspamd_mempool_add_destructor (pool,
-							(rspamd_mempool_destruct_t) g_free, ia_string);
+						rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_free, ia_string);
 					}
 					gret = g_list_prepend (gret, ia_string);
 					ia = ia->next;
@@ -1914,21 +1700,16 @@ message_get_header (rspamd_mempool_t * pool,
 #else
 				i = internet_address_list_length (ia);
 				while (--i >= 0) {
-					ia_string = internet_address_to_string (internet_address_list_get_address (
-								ia,
-								i),
-							FALSE);
+					ia_string = internet_address_to_string (internet_address_list_get_address (ia, i), FALSE);
 					if (pool != NULL) {
-						rspamd_mempool_add_destructor (pool,
-							(rspamd_mempool_destruct_t) g_free, ia_string);
+						rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_free, ia_string);
 					}
 					gret = g_list_prepend (gret, ia_string);
 				}
 #endif
 				break;
 			case FUNC_LIST:
-				gret =
-					(*(fieldfunc[i].getlistfunc))(pool, message, field, strong);
+				gret = (*(fieldfunc[i].getlistfunc)) (pool, message, field, strong);
 				break;
 			}
 			break;
@@ -1949,13 +1730,11 @@ message_get_header (rspamd_mempool_t * pool,
 	return gret;
 }
 
-GList *
-message_get_raw_header (struct rspamd_task *task,
-	const gchar *field,
-	gboolean strong)
+GList*
+message_get_raw_header (struct rspamd_task *task, const gchar *field, gboolean strong)
 {
-	GList *gret = NULL;
-	struct raw_header *rh;
+	GList                               *gret = NULL;
+	struct raw_header                   *rh;
 
 	rh = g_hash_table_lookup (task->raw_headers, field);
 
@@ -1978,8 +1757,7 @@ message_get_raw_header (struct rspamd_task *task,
 	}
 
 	if (gret != NULL) {
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t)g_list_free, gret);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, gret);
 	}
 
 	return gret;
diff --git a/src/libmime/message.h b/src/libmime/message.h
index fdb987c8c..5e27579d1 100644
--- a/src/libmime/message.h
+++ b/src/libmime/message.h
@@ -30,7 +30,7 @@ struct mime_text_part {
 	GByteArray *orig;
 	GByteArray *content;
 	GNode *html_nodes;
-	GList *urls_offset;                                         /**< list of offsets of urls						*/
+	GList *urls_offset;										    /**< list of offsets of urls						*/
 	fuzzy_hash_t *fuzzy;
 	fuzzy_hash_t *double_fuzzy;
 	GMimeObject *parent;
@@ -57,7 +57,7 @@ struct raw_header {
 };
 
 /**
- * Process message with all filters/statfiles, extract mime parts, urls and
+ * Process message with all filters/statfiles, extract mime parts, urls and 
  * call metrics consolidation functions
  * @param task worker_task object
  * @return 0 if we have delayed filters to process and 1 if we have finished with processing
@@ -67,9 +67,7 @@ gint process_message (struct rspamd_task *task);
 /*
  * Set header with specified name and value
  */
-void message_set_header (GMimeMessage *message,
-	const gchar *field,
-	const gchar *value);
+void message_set_header (GMimeMessage *message, const gchar *field, const gchar *value);
 
 /*
  * Get a list of header's values with specified header's name
@@ -79,10 +77,7 @@ void message_set_header (GMimeMessage *message,
  * @param strong if this flag is TRUE header's name is case sensitive, otherwise it is not
  * @return A list of header's values or NULL. If list is not NULL it MUST be freed. If pool is NULL elements must be freed as well.
  */
-GList * message_get_header (rspamd_mempool_t *pool,
-	GMimeMessage *message,
-	const gchar *field,
-	gboolean strong);
+GList* message_get_header (rspamd_mempool_t *pool, GMimeMessage *message, const gchar *field, gboolean strong);
 
 /*
  * Get a list of header's values with specified header's name using raw headers
@@ -91,8 +86,6 @@ GList * message_get_header (rspamd_mempool_t *pool,
  * @param strong if this flag is TRUE header's name is case sensitive, otherwise it is not
  * @return A list of header's values or NULL. Unlike previous function it is NOT required to free list or values. I should rework one of these functions some time.
  */
-GList * message_get_raw_header (struct rspamd_task *task,
-	const gchar *field,
-	gboolean strong);
+GList* message_get_raw_header (struct rspamd_task *task, const gchar *field, gboolean strong);
 
 #endif
diff --git a/src/libmime/smtp_proto.c b/src/libmime/smtp_proto.c
index 3c8395784..3af1c3910 100644
--- a/src/libmime/smtp_proto.c
+++ b/src/libmime/smtp_proto.c
@@ -22,24 +22,21 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
 #include "main.h"
+#include "cfg_file.h"
+#include "util.h"
 #include "smtp.h"
 #include "smtp_proto.h"
 #include "smtp_utils.h"
-#include "util.h"
 
-gchar *
-make_smtp_error (rspamd_mempool_t *pool,
-	gint error_code,
-	const gchar *format,
-	...)
+gchar                           *
+make_smtp_error (rspamd_mempool_t *pool, gint error_code, const gchar *format, ...)
 {
-	va_list vp;
-	gchar *result = NULL, *p;
-	size_t len;
-
+	va_list                         vp;
+	gchar                           *result = NULL, *p;
+	size_t                          len;
+	
 	va_start (vp, format);
 	len = g_printf_string_upper_bound (format, vp);
 	va_end (vp);
@@ -56,9 +53,7 @@ make_smtp_error (rspamd_mempool_t *pool,
 
 
 gboolean
-parse_smtp_command (struct smtp_session *session,
-	f_str_t *line,
-	struct smtp_command **cmd)
+parse_smtp_command (struct smtp_session *session, f_str_t *line, struct smtp_command **cmd)
 {
 	enum {
 		SMTP_PARSE_START = 0,
@@ -66,11 +61,11 @@ parse_smtp_command (struct smtp_session *session,
 		SMTP_PARSE_ARGUMENT,
 		SMTP_PARSE_DONE
 	}                              state;
-	gchar *p, *c, ch, cmd_buf[4];
-	guint i;
-	f_str_t *arg = NULL;
-	struct smtp_command *pcmd;
-
+	gchar                         *p, *c, ch, cmd_buf[4];
+	guint                          i;
+	f_str_t                       *arg = NULL;
+	struct smtp_command           *pcmd;
+	
 	if (line->len == 0) {
 		return FALSE;
 	}
@@ -81,129 +76,125 @@ parse_smtp_command (struct smtp_session *session,
 	*cmd = rspamd_mempool_alloc0 (session->pool, sizeof (struct smtp_command));
 	pcmd = *cmd;
 
-	for (i = 0; i < line->len; i++, p++) {
+	for (i = 0; i < line->len; i ++, p ++) {
 		ch = *p;
 		switch (state) {
-		case SMTP_PARSE_START:
-			if (ch == ' ' || ch == ':' || ch == CR || ch == LF || i ==
-				line->len - 1) {
-				if (i == line->len - 1) {
-					p++;
-				}
-				if (p - c == 4) {
-					cmd_buf[0] = g_ascii_toupper (c[0]);
-					cmd_buf[1] = g_ascii_toupper (c[1]);
-					cmd_buf[2] = g_ascii_toupper (c[2]);
-					cmd_buf[3] = g_ascii_toupper (c[3]);
-
-					if (memcmp (cmd_buf, "HELO", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_HELO;
-					}
-					else if (memcmp (cmd_buf, "EHLO", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_EHLO;
-					}
-					else if (memcmp (cmd_buf, "MAIL", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_MAIL;
+			case SMTP_PARSE_START:
+				if (ch == ' ' || ch == ':' || ch == CR || ch == LF || i == line->len - 1) {
+					if (i == line->len - 1) {
+						p ++;
 					}
-					else if (memcmp (cmd_buf, "RCPT", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_RCPT;
+					if (p - c == 4) {
+						cmd_buf[0] = g_ascii_toupper (c[0]);
+						cmd_buf[1] = g_ascii_toupper (c[1]);
+						cmd_buf[2] = g_ascii_toupper (c[2]);
+						cmd_buf[3] = g_ascii_toupper (c[3]);
+
+						if (memcmp (cmd_buf, "HELO", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_HELO;
+						}
+						else if (memcmp (cmd_buf, "EHLO", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_EHLO;
+						}
+						else if (memcmp (cmd_buf, "MAIL", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_MAIL;
+						}
+						else if (memcmp (cmd_buf, "RCPT", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_RCPT;
+						}
+						else if (memcmp (cmd_buf, "DATA", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_DATA;
+						}
+						else if (memcmp (cmd_buf, "QUIT", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_QUIT;
+						}
+						else if (memcmp (cmd_buf, "NOOP", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_NOOP;
+						}
+						else if (memcmp (cmd_buf, "EXPN", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_EXPN;
+						}
+						else if (memcmp (cmd_buf, "RSET", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_RSET;
+						}
+						else if (memcmp (cmd_buf, "HELP", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_HELP;
+						}
+						else if (memcmp (cmd_buf, "VRFY", 4) == 0) {
+							pcmd->command = SMTP_COMMAND_VRFY;
+						}
+						else {
+							msg_info ("invalid command: %*s", 4, cmd_buf);
+							return FALSE;
+						}
 					}
-					else if (memcmp (cmd_buf, "DATA", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_DATA;
-					}
-					else if (memcmp (cmd_buf, "QUIT", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_QUIT;
-					}
-					else if (memcmp (cmd_buf, "NOOP", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_NOOP;
-					}
-					else if (memcmp (cmd_buf, "EXPN", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_EXPN;
+					else {
+						/* Invalid command */
+						msg_info ("invalid command: %*s", 4, c);
+						return FALSE;
 					}
-					else if (memcmp (cmd_buf, "RSET", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_RSET;
+					/* Now check what we have */
+					if (ch == ' ' || ch == ':') {
+						state = SMTP_PARSE_SPACES;
 					}
-					else if (memcmp (cmd_buf, "HELP", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_HELP;
+					else if (ch == CR) {
+						state = SMTP_PARSE_DONE;
 					}
-					else if (memcmp (cmd_buf, "VRFY", 4) == 0) {
-						pcmd->command = SMTP_COMMAND_VRFY;
-					}
-					else {
-						msg_info ("invalid command: %*s", 4, cmd_buf);
-						return FALSE;
+					else if (ch == LF) {
+						return TRUE;
 					}
 				}
-				else {
-					/* Invalid command */
-					msg_info ("invalid command: %*s", 4, c);
+				else if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
+					msg_info ("invalid letter code in SMTP command: %d", (gint)ch);
 					return FALSE;
 				}
-				/* Now check what we have */
-				if (ch == ' ' || ch == ':') {
-					state = SMTP_PARSE_SPACES;
-				}
-				else if (ch == CR) {
+				break;
+			case SMTP_PARSE_SPACES:
+				if (ch == CR) {
 					state = SMTP_PARSE_DONE;
 				}
 				else if (ch == LF) {
-					return TRUE;
+					goto end;
 				}
-			}
-			else if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
-				msg_info ("invalid letter code in SMTP command: %d", (gint)ch);
-				return FALSE;
-			}
-			break;
-		case SMTP_PARSE_SPACES:
-			if (ch == CR) {
-				state = SMTP_PARSE_DONE;
-			}
-			else if (ch == LF) {
-				goto end;
-			}
-			else if (ch != ' ' && ch != ':') {
-				state = SMTP_PARSE_ARGUMENT;
-				arg = rspamd_mempool_alloc (session->pool, sizeof (f_str_t));
-				c = p;
-			}
-			break;
-		case SMTP_PARSE_ARGUMENT:
-			if (ch == ' ' || ch == ':' || ch == CR || ch == LF || i ==
-				line->len - 1) {
-				if (i == line->len - 1 && (ch != ' ' && ch != CR && ch != LF)) {
-					p++;
-				}
-				arg->len = p - c;
-				arg->begin = rspamd_mempool_alloc (session->pool, arg->len);
-				memcpy (arg->begin, c, arg->len);
-				pcmd->args = g_list_prepend (pcmd->args, arg);
-				if (ch == ' ' || ch == ':') {
-					state = SMTP_PARSE_SPACES;
-				}
-				else if (ch == CR) {
-					state = SMTP_PARSE_DONE;
+				else if (ch != ' ' && ch != ':') {
+					state = SMTP_PARSE_ARGUMENT;
+					arg = rspamd_mempool_alloc (session->pool, sizeof (f_str_t));
+					c = p;
 				}
-				else {
+				break;
+			case SMTP_PARSE_ARGUMENT:
+				if (ch == ' ' || ch == ':' || ch == CR || ch == LF || i == line->len - 1) {
+					if (i == line->len - 1 && (ch != ' ' && ch != CR && ch != LF)) {
+						p ++;
+					}
+					arg->len = p - c;
+					arg->begin = rspamd_mempool_alloc (session->pool, arg->len);
+					memcpy (arg->begin, c, arg->len);
+					pcmd->args = g_list_prepend (pcmd->args, arg);
+					if (ch == ' ' || ch == ':') {
+						state = SMTP_PARSE_SPACES;
+					}
+					else if (ch == CR) {
+						state = SMTP_PARSE_DONE;
+					}
+					else {
+						goto end;
+					}
+				}
+				break;
+			case SMTP_PARSE_DONE:
+				if (ch == LF) {
 					goto end;
 				}
-			}
-			break;
-		case SMTP_PARSE_DONE:
-			if (ch == LF) {
-				goto end;
-			}
-			msg_info ("CR without LF in SMTP command");
-			return FALSE;
+				msg_info ("CR without LF in SMTP command");
+				return FALSE;
 		}
 	}
 
 end:
 	if (pcmd->args) {
 		pcmd->args = g_list_reverse (pcmd->args);
-		rspamd_mempool_add_destructor (session->pool,
-			(rspamd_mempool_destruct_t)g_list_free,
-			pcmd->args);
+		rspamd_mempool_add_destructor (session->pool, (rspamd_mempool_destruct_t)g_list_free, pcmd->args);
 	}
 	return TRUE;
 }
@@ -211,14 +202,14 @@ end:
 static gboolean
 check_smtp_path (f_str_t *path)
 {
-	guint i;
-	gchar *p;
+	guint                            i;
+	gchar                           *p;
 
 	p = path->begin;
 	if (*p != '<' || path->len < 2) {
 		return FALSE;
 	}
-	for (i = 0; i < path->len; i++, p++) {
+	for (i = 0; i < path->len; i++, p ++) {
 		if (*p == '>' && i != path->len - 1) {
 			return FALSE;
 		}
@@ -230,7 +221,7 @@ check_smtp_path (f_str_t *path)
 gboolean
 parse_smtp_helo (struct smtp_session *session, struct smtp_command *cmd)
 {
-	f_str_t *arg;
+	f_str_t                       *arg;
 
 	if (cmd->args == NULL) {
 		session->error = SMTP_ERROR_BAD_ARGUMENTS;
@@ -265,8 +256,8 @@ parse_smtp_helo (struct smtp_session *session, struct smtp_command *cmd)
 gboolean
 parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd)
 {
-	f_str_t *arg;
-	GList *cur = cmd->args;
+	f_str_t                       *arg;
+	GList                         *cur = cmd->args;
 
 	if (cmd->args == NULL) {
 		session->error = SMTP_ERROR_BAD_ARGUMENTS;
@@ -275,10 +266,10 @@ parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd)
 	arg = cur->data;
 	/* First argument MUST be FROM */
 	if (arg->len != 4 || (
-			g_ascii_toupper (arg->begin[0]) != 'F' ||
-			g_ascii_toupper (arg->begin[1]) != 'R' ||
-			g_ascii_toupper (arg->begin[2]) != 'O' ||
-			g_ascii_toupper (arg->begin[3]) != 'M')) {
+		g_ascii_toupper (arg->begin[0]) != 'F' ||
+		g_ascii_toupper (arg->begin[1]) != 'R' ||
+		g_ascii_toupper (arg->begin[2]) != 'O' ||
+		g_ascii_toupper (arg->begin[3]) != 'M')) {
 		session->error = SMTP_ERROR_BAD_ARGUMENTS;
 		return FALSE;
 	}
@@ -303,8 +294,8 @@ parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd)
 gboolean
 parse_smtp_rcpt (struct smtp_session *session, struct smtp_command *cmd)
 {
-	f_str_t *arg;
-	GList *cur = cmd->args;
+	f_str_t                       *arg;
+	GList                         *cur = cmd->args;
 
 	if (cmd->args == NULL) {
 		session->error = SMTP_ERROR_BAD_ARGUMENTS;
@@ -313,8 +304,8 @@ parse_smtp_rcpt (struct smtp_session *session, struct smtp_command *cmd)
 	arg = cur->data;
 	/* First argument MUST be FROM */
 	if (arg->len != 2 || (
-			g_ascii_toupper (arg->begin[0]) != 'T' ||
-			g_ascii_toupper (arg->begin[1]) != 'O')) {
+		g_ascii_toupper (arg->begin[0]) != 'T' ||
+		g_ascii_toupper (arg->begin[1]) != 'O')) {
 		session->error = SMTP_ERROR_BAD_ARGUMENTS;
 		return FALSE;
 	}
@@ -341,7 +332,7 @@ parse_smtp_rcpt (struct smtp_session *session, struct smtp_command *cmd)
 static gint
 check_smtp_ustream_reply (f_str_t *in, gchar success_code)
 {
-	gchar *p;
+	gchar                           *p;
 
 	/* Check for 250 at the begin of line */
 	if (in->len >= sizeof ("220 ") - 1) {
@@ -366,13 +357,13 @@ check_smtp_ustream_reply (f_str_t *in, gchar success_code)
 size_t
 smtp_upstream_write_list (GList *args, gchar *buf, size_t buflen)
 {
-	GList *cur = args;
-	size_t r = 0;
-	f_str_t *arg;
+	GList                          *cur = args;
+	size_t                          r = 0;
+	f_str_t                        *arg;
 
 	while (cur && r < buflen - 3) {
 		arg = cur->data;
-		r += rspamd_snprintf (buf + r, buflen - r, " %V", arg);
+		r += rspamd_snprintf (buf + r, buflen - r, " %V", arg); 
 		cur = g_list_next (cur);
 	}
 
@@ -383,351 +374,288 @@ smtp_upstream_write_list (GList *args, gchar *buf, size_t buflen)
 	return r;
 }
 
-gboolean
+gboolean 
 smtp_upstream_write_socket (void *arg)
 {
-	struct smtp_session *session = arg;
-
+	struct smtp_session            *session = arg;
+	
 	if (session->upstream_state == SMTP_STATE_IN_SENDFILE) {
 		session->upstream_state = SMTP_STATE_AFTER_DATA;
-		return rspamd_dispatcher_write (session->upstream_dispatcher,
-				   CRLF DATA_END_TRAILER,
-				   sizeof (CRLF DATA_END_TRAILER) - 1,
-				   FALSE,
-				   TRUE);
+		return rspamd_dispatcher_write (session->upstream_dispatcher, CRLF DATA_END_TRAILER, sizeof (CRLF DATA_END_TRAILER) - 1, FALSE, TRUE);
 	}
 
 	return TRUE;
 }
 
-gboolean
+gboolean 
 smtp_upstream_read_socket (f_str_t * in, void *arg)
 {
-	struct smtp_session *session = arg;
-	gchar outbuf[BUFSIZ];
-	gint r;
-
+	struct smtp_session            *session = arg;
+	gchar                           outbuf[BUFSIZ];
+	gint                            r;
+	
 	msg_debug ("in: %V, state: %d", in, session->upstream_state);
 	switch (session->upstream_state) {
-	case SMTP_STATE_GREETING:
-		r = check_smtp_ustream_reply (in, '2');
-		if (r == -1) {
-			session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
-			rspamd_strlcpy (session->error, in->begin, in->len + 1);
-			/* XXX: assume upstream errors as critical errors */
-			session->state = SMTP_STATE_CRITICAL_ERROR;
-			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				in->len, FALSE, TRUE)) {
-				goto err;
+		case SMTP_STATE_GREETING:
+			r = check_smtp_ustream_reply (in, '2');
+			if (r == -1) {
+				session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+				rspamd_strlcpy (session->error, in->begin, in->len + 1);
+				/* XXX: assume upstream errors as critical errors */
+				session->state = SMTP_STATE_CRITICAL_ERROR;
+				rspamd_dispatcher_restore (session->dispatcher);
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
+					goto err;
+				}
+				if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+					goto err;
+				}
+				destroy_session (session->s);
+				return FALSE;
 			}
-			if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
-				sizeof (CRLF) - 1, FALSE, TRUE)) {
-				goto err;
+			else if (r == 1) {
+				if (session->ctx->use_xclient) {
+					r = rspamd_snprintf (outbuf, sizeof (outbuf), "XCLIENT NAME=%s ADDR=%s" CRLF, 
+							session->resolved ? session->hostname : "[UNDEFINED]",
+							inet_ntoa (session->client_addr));
+					session->upstream_state = SMTP_STATE_HELO;
+					return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
+				}
+				else {
+					session->upstream_state = SMTP_STATE_FROM;
+					if (session->helo) {
+						r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF, 
+							session->esmtp ? "EHLO" : "HELO",
+							session->helo);
+					}
+					else {
+						return smtp_upstream_read_socket (in, arg);
+					}
+					return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
+				}
 			}
-			destroy_session (session->s);
-			return FALSE;
-		}
-		else if (r == 1) {
-			if (session->ctx->use_xclient) {
-				r = rspamd_snprintf (outbuf,
-						sizeof (outbuf),
-						"XCLIENT NAME=%s ADDR=%s" CRLF,
-						session->resolved ? session->hostname : "[UNDEFINED]",
-						inet_ntoa (session->client_addr));
-				session->upstream_state = SMTP_STATE_HELO;
-				return rspamd_dispatcher_write (session->upstream_dispatcher,
-						   outbuf,
-						   r,
-						   FALSE,
-						   FALSE);
+			break;
+		case SMTP_STATE_HELO:
+			r = check_smtp_ustream_reply (in, '2');
+			if (r == -1) {
+				session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+				rspamd_strlcpy (session->error, in->begin, in->len + 1);
+				/* XXX: assume upstream errors as critical errors */
+				session->state = SMTP_STATE_CRITICAL_ERROR;
+				rspamd_dispatcher_restore (session->dispatcher);
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
+					goto err;
+				}
+				if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+					goto err;
+				}
+				destroy_session (session->s);
+				return FALSE;
 			}
-			else {
+			else if (r == 1) {
 				session->upstream_state = SMTP_STATE_FROM;
 				if (session->helo) {
-					r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF,
-							session->esmtp ? "EHLO" : "HELO",
-							session->helo);
+					r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF, 
+						session->esmtp ? "EHLO" : "HELO",
+						session->helo);
 				}
 				else {
 					return smtp_upstream_read_socket (in, arg);
 				}
-				return rspamd_dispatcher_write (session->upstream_dispatcher,
-						   outbuf,
-						   r,
-						   FALSE,
-						   FALSE);
+				return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
 			}
-		}
-		break;
-	case SMTP_STATE_HELO:
-		r = check_smtp_ustream_reply (in, '2');
-		if (r == -1) {
-			session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
-			rspamd_strlcpy (session->error, in->begin, in->len + 1);
-			/* XXX: assume upstream errors as critical errors */
-			session->state = SMTP_STATE_CRITICAL_ERROR;
-			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				in->len, FALSE, TRUE)) {
-				goto err;
-			}
-			if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
-				sizeof (CRLF) - 1, FALSE, TRUE)) {
-				goto err;
-			}
-			destroy_session (session->s);
-			return FALSE;
-		}
-		else if (r == 1) {
-			session->upstream_state = SMTP_STATE_FROM;
-			if (session->helo) {
-				r = rspamd_snprintf (outbuf, sizeof (outbuf), "%s %s" CRLF,
-						session->esmtp ? "EHLO" : "HELO",
-						session->helo);
-			}
-			else {
-				return smtp_upstream_read_socket (in, arg);
-			}
-			return rspamd_dispatcher_write (session->upstream_dispatcher,
-					   outbuf,
-					   r,
-					   FALSE,
-					   FALSE);
-		}
-		break;
-	case SMTP_STATE_FROM:
-		r = check_smtp_ustream_reply (in, '2');
-		if (r == -1) {
-			session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
-			rspamd_strlcpy (session->error, in->begin, in->len + 1);
-			/* XXX: assume upstream errors as critical errors */
-			session->state = SMTP_STATE_CRITICAL_ERROR;
-			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				in->len, FALSE, TRUE)) {
-				goto err;
-			}
-			if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
-				sizeof (CRLF) - 1, FALSE, TRUE)) {
-				goto err;
-			}
-			destroy_session (session->s);
-			return FALSE;
-		}
-		else if (r == 1) {
-			r = rspamd_snprintf (outbuf, sizeof (outbuf), "MAIL FROM: ");
-			r +=
-				smtp_upstream_write_list (session->from,
-					outbuf + r,
-					sizeof (outbuf) - r);
-			session->upstream_state = SMTP_STATE_RCPT;
-			return rspamd_dispatcher_write (session->upstream_dispatcher,
-					   outbuf,
-					   r,
-					   FALSE,
-					   FALSE);
-		}
-		break;
-	case SMTP_STATE_RCPT:
-		r = check_smtp_ustream_reply (in, '2');
-		if (r == -1) {
-			session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
-			rspamd_strlcpy (session->error, in->begin, in->len + 1);
-			/* XXX: assume upstream errors as critical errors */
-			session->state = SMTP_STATE_CRITICAL_ERROR;
-			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				in->len, FALSE, TRUE)) {
-				goto err;
-			}
-			if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
-				sizeof (CRLF) - 1, FALSE, TRUE)) {
-				goto err;
-			}
-			destroy_session (session->s);
-			return FALSE;
-		}
-		else if (r == 1) {
-			r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
-			session->cur_rcpt = g_list_first (session->rcpt);
-			r += smtp_upstream_write_list (session->cur_rcpt->data,
-					outbuf + r,
-					sizeof (outbuf) - r);
-			session->cur_rcpt = g_list_next (session->cur_rcpt);
-			session->upstream_state = SMTP_STATE_BEFORE_DATA;
-			return rspamd_dispatcher_write (session->upstream_dispatcher,
-					   outbuf,
-					   r,
-					   FALSE,
-					   FALSE);
-		}
-		break;
-	case SMTP_STATE_BEFORE_DATA:
-		r = check_smtp_ustream_reply (in, '2');
-		if (r == -1) {
-			session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
-			rspamd_strlcpy (session->error, in->begin, in->len + 1);
-			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				in->len, FALSE, TRUE)) {
-				goto err;
-			}
-			if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
-				sizeof (CRLF) - 1, FALSE, TRUE)) {
-				goto err;
+			break;
+		case SMTP_STATE_FROM:
+			r = check_smtp_ustream_reply (in, '2');
+			if (r == -1) {
+				session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+				rspamd_strlcpy (session->error, in->begin, in->len + 1);
+				/* XXX: assume upstream errors as critical errors */
+				session->state = SMTP_STATE_CRITICAL_ERROR;
+				rspamd_dispatcher_restore (session->dispatcher);
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
+					goto err;
+				}
+				if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+					goto err;
+				}
+				destroy_session (session->s);
+				return FALSE;
 			}
-			if (session->cur_rcpt) {
-				session->rcpt = g_list_delete_link (session->rcpt,
-						session->cur_rcpt);
+			else if (r == 1) {
+				r = rspamd_snprintf (outbuf, sizeof (outbuf), "MAIL FROM: ");
+				r += smtp_upstream_write_list (session->from, outbuf + r, sizeof (outbuf) - r);
+				session->upstream_state = SMTP_STATE_RCPT;
+				return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
 			}
-			else {
-				session->rcpt =
-					g_list_delete_link (session->rcpt, session->rcpt);
+			break;
+		case SMTP_STATE_RCPT:
+			r = check_smtp_ustream_reply (in, '2');
+			if (r == -1) {
+				session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+				rspamd_strlcpy (session->error, in->begin, in->len + 1);
+				/* XXX: assume upstream errors as critical errors */
+				session->state = SMTP_STATE_CRITICAL_ERROR;
+				rspamd_dispatcher_restore (session->dispatcher);
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
+					goto err;
+				}
+				if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+					goto err;
+				}
+				destroy_session (session->s);
+				return FALSE;
 			}
-			session->errors++;
-			session->state = SMTP_STATE_RCPT;
-			return TRUE;
-		}
-		else if (r == 1) {
-			if (session->cur_rcpt != NULL) {
+			else if (r == 1) {
 				r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
-				r += smtp_upstream_write_list (session->cur_rcpt,
-						outbuf + r,
-						sizeof (outbuf) - r);
+				session->cur_rcpt = g_list_first (session->rcpt);
+				r += smtp_upstream_write_list (session->cur_rcpt->data, outbuf + r, sizeof (outbuf) - r);
 				session->cur_rcpt = g_list_next (session->cur_rcpt);
-				if (!rspamd_dispatcher_write (session->upstream_dispatcher,
-					outbuf, r, FALSE, FALSE)) {
+				session->upstream_state = SMTP_STATE_BEFORE_DATA;
+				return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
+			}
+			break;
+		case SMTP_STATE_BEFORE_DATA:
+			r = check_smtp_ustream_reply (in, '2');
+			if (r == -1) {
+				session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+				rspamd_strlcpy (session->error, in->begin, in->len + 1);
+				rspamd_dispatcher_restore (session->dispatcher);
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
 					goto err;
 				}
+				if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+					goto err;
+				}
+				if (session->cur_rcpt) {
+					session->rcpt = g_list_delete_link (session->rcpt, session->cur_rcpt);
+				}
+				else {
+					session->rcpt = g_list_delete_link (session->rcpt, session->rcpt);
+				}
+				session->errors ++;
+				session->state = SMTP_STATE_RCPT;
+				return TRUE;
+			}
+			else if (r == 1) {
+				if (session->cur_rcpt != NULL) {
+					r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
+					r += smtp_upstream_write_list (session->cur_rcpt, outbuf + r, sizeof (outbuf) - r);
+					session->cur_rcpt = g_list_next (session->cur_rcpt);
+					if (! rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE)) {
+						goto err;
+					}
+				}
+				else {
+					session->upstream_state = SMTP_STATE_DATA;
+					rspamd_dispatcher_pause (session->upstream_dispatcher);
+				}
+				session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+				rspamd_strlcpy (session->error, in->begin, in->len + 1);
+				/* Write to client */
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, in->len, FALSE, TRUE)) {
+					goto err;
+				} 
+				if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+					goto err;
+				}
+				if (session->state == SMTP_STATE_WAIT_UPSTREAM) {
+					rspamd_dispatcher_restore (session->dispatcher);
+					session->state = SMTP_STATE_RCPT;
+				}
 			}
-			else {
-				session->upstream_state = SMTP_STATE_DATA;
-				rspamd_dispatcher_pause (session->upstream_dispatcher);
-			}
-			session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
-			rspamd_strlcpy (session->error, in->begin, in->len + 1);
-			/* Write to client */
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				in->len, FALSE, TRUE)) {
-				goto err;
-			}
-			if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
-				sizeof (CRLF) - 1, FALSE, TRUE)) {
-				goto err;
+			break;
+		case SMTP_STATE_DATA:
+			r = check_smtp_ustream_reply (in, '3');
+			if (r == -1) {
+				session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+				rspamd_strlcpy (session->error, in->begin, in->len + 1);
+				/* XXX: assume upstream errors as critical errors */
+				session->state = SMTP_STATE_CRITICAL_ERROR;
+				rspamd_dispatcher_restore (session->dispatcher);
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+					goto err;
+				}
+				if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
+					goto err;
+				}
+				destroy_session (session->s);
+				return FALSE;
 			}
-			if (session->state == SMTP_STATE_WAIT_UPSTREAM) {
+			else if (r == 1) {
+				if (! make_smtp_tempfile (session)) {
+					session->error = SMTP_ERROR_FILE;
+					session->state = SMTP_STATE_CRITICAL_ERROR;
+					rspamd_dispatcher_restore (session->dispatcher);
+					if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+						goto err;
+					}
+					destroy_session (session->s);
+					return FALSE;
+				}
+				session->state = SMTP_STATE_AFTER_DATA;
+				session->error = SMTP_ERROR_DATA_OK;
 				rspamd_dispatcher_restore (session->dispatcher);
-				session->state = SMTP_STATE_RCPT;
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+					goto err;
+				}
+				rspamd_dispatcher_pause (session->upstream_dispatcher);
+				rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, 0);
+				session->dispatcher->strip_eol = FALSE;
+				return TRUE;
 			}
-		}
-		break;
-	case SMTP_STATE_DATA:
-		r = check_smtp_ustream_reply (in, '3');
-		if (r == -1) {
+			break;
+		case SMTP_STATE_AFTER_DATA:
 			session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
 			rspamd_strlcpy (session->error, in->begin, in->len + 1);
-			/* XXX: assume upstream errors as critical errors */
-			session->state = SMTP_STATE_CRITICAL_ERROR;
+			session->state = SMTP_STATE_DATA;
 			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				0, FALSE, TRUE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 				goto err;
 			}
-			if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
-				sizeof (CRLF) - 1, FALSE, TRUE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
 				goto err;
 			}
-			destroy_session (session->s);
-			return FALSE;
-		}
-		else if (r == 1) {
-			if (!make_smtp_tempfile (session)) {
-				session->error = SMTP_ERROR_FILE;
+			if (! rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF, sizeof ("QUIT" CRLF) - 1, FALSE, TRUE)) {
+				goto err;
+			}
+			session->upstream_state = SMTP_STATE_END;
+			return TRUE;
+			break;
+		case SMTP_STATE_END:
+			r = check_smtp_ustream_reply (in, '5');
+			if (r == -1) {
+				session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
+				rspamd_strlcpy (session->error, in->begin, in->len + 1);
+				/* XXX: assume upstream errors as critical errors */
 				session->state = SMTP_STATE_CRITICAL_ERROR;
 				rspamd_dispatcher_restore (session->dispatcher);
-				if (!rspamd_dispatcher_write (session->dispatcher,
-					session->error, 0, FALSE, TRUE)) {
+				if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+					goto err;
+				}
+				if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
 					goto err;
 				}
 				destroy_session (session->s);
 				return FALSE;
 			}
-			session->state = SMTP_STATE_AFTER_DATA;
-			session->error = SMTP_ERROR_DATA_OK;
-			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				0, FALSE, TRUE)) {
-				goto err;
+			else {
+				remove_normal_event (session->s,  (event_finalizer_t)smtp_upstream_finalize_connection, session);
 			}
-			rspamd_dispatcher_pause (session->upstream_dispatcher);
-			rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, 0);
-			session->dispatcher->strip_eol = FALSE;
-			return TRUE;
-		}
-		break;
-	case SMTP_STATE_AFTER_DATA:
-		session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
-		rspamd_strlcpy (session->error, in->begin, in->len + 1);
-		session->state = SMTP_STATE_DATA;
-		rspamd_dispatcher_restore (session->dispatcher);
-		if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0,
-			FALSE, TRUE)) {
-			goto err;
-		}
-		if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) -
-			1, FALSE, TRUE)) {
-			goto err;
-		}
-		if (!rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF,
-			sizeof ("QUIT" CRLF) - 1, FALSE, TRUE)) {
-			goto err;
-		}
-		session->upstream_state = SMTP_STATE_END;
-		return TRUE;
-		break;
-	case SMTP_STATE_END:
-		r = check_smtp_ustream_reply (in, '5');
-		if (r == -1) {
-			session->error = rspamd_mempool_alloc (session->pool, in->len + 1);
-			rspamd_strlcpy (session->error, in->begin, in->len + 1);
-			/* XXX: assume upstream errors as critical errors */
+			return FALSE;
+			break;
+		default:
+			msg_err ("got upstream reply at unexpected state: %d, reply: %V", session->upstream_state, in);
 			session->state = SMTP_STATE_CRITICAL_ERROR;
 			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				0, FALSE, TRUE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 				goto err;
 			}
-			if (!rspamd_dispatcher_write (session->dispatcher, CRLF,
-				sizeof (CRLF) - 1, FALSE, TRUE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
 				goto err;
 			}
 			destroy_session (session->s);
 			return FALSE;
-		}
-		else {
-			remove_normal_event (session->s,
-				(event_finalizer_t)smtp_upstream_finalize_connection,
-				session);
-		}
-		return FALSE;
-		break;
-	default:
-		msg_err ("got upstream reply at unexpected state: %d, reply: %V",
-			session->upstream_state,
-			in);
-		session->state = SMTP_STATE_CRITICAL_ERROR;
-		rspamd_dispatcher_restore (session->dispatcher);
-		if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0,
-			FALSE, TRUE)) {
-			goto err;
-		}
-		if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) -
-			1, FALSE, TRUE)) {
-			goto err;
-		}
-		destroy_session (session->s);
-		return FALSE;
 	}
 
 	return TRUE;
@@ -736,24 +664,20 @@ err:
 	return FALSE;
 }
 
-void
+void 
 smtp_upstream_err_socket (GError *err, void *arg)
 {
-	struct smtp_session *session = arg;
+	struct smtp_session            *session = arg;
 
-	msg_info ("abnormally closing connection with upstream %s, error: %s",
-		session->upstream->name,
-		err->message);
+	msg_info ("abnormally closing connection with upstream %s, error: %s", session->upstream->name, err->message);
 	session->error = SMTP_ERROR_UPSTREAM;
 	session->state = SMTP_STATE_CRITICAL_ERROR;
 	/* XXX: assume upstream errors as critical errors */
 	rspamd_dispatcher_restore (session->dispatcher);
-	if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE,
-		TRUE)) {
+	if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 		return;
 	}
-	if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1,
-		FALSE, TRUE)) {
+	if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
 		return;
 	}
 	upstream_fail (&session->upstream->up, session->session_time);
@@ -763,11 +687,10 @@ smtp_upstream_err_socket (GError *err, void *arg)
 void
 smtp_upstream_finalize_connection (gpointer data)
 {
-	struct smtp_session *session = data;
-
+	struct smtp_session            *session = data;
+	
 	if (session->state != SMTP_STATE_CRITICAL_ERROR) {
-		if (!rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF,
-			0, FALSE, TRUE)) {
+		if (! rspamd_dispatcher_write (session->upstream_dispatcher, "QUIT" CRLF, 0, FALSE, TRUE)) {
 			msg_warn ("cannot send correctly closing message to upstream");
 		}
 	}
diff --git a/src/libmime/smtp_proto.h b/src/libmime/smtp_proto.h
index 7c5787926..42fecd255 100644
--- a/src/libmime/smtp_proto.h
+++ b/src/libmime/smtp_proto.h
@@ -6,14 +6,12 @@
 
 /* SMTP errors */
 #define SMTP_ERROR_BAD_COMMAND "500 Syntax error, command unrecognized" CRLF
-#define SMTP_ERROR_BAD_ARGUMENTS "501 Syntax error in parameters or arguments" \
-	CRLF
+#define SMTP_ERROR_BAD_ARGUMENTS "501 Syntax error in parameters or arguments" CRLF
 #define SMTP_ERROR_SEQUENCE "503 Bad sequence of commands" CRLF
 #define SMTP_ERROR_RECIPIENTS "554 No valid recipients" CRLF
 #define SMTP_ERROR_UNIMPLIMENTED "502 Command not implemented" CRLF
 #define SMTP_ERROR_LIMIT "505 Too many errors. Aborting." CRLF
-#define SMTP_ERROR_UPSTREAM \
-	"421 Service not available, closing transmission channel" CRLF
+#define SMTP_ERROR_UPSTREAM "421 Service not available, closing transmission channel" CRLF
 #define SMTP_ERROR_FILE "420 Service not available, filesystem error" CRLF
 #define SMTP_ERROR_OK "250 Requested mail action okay, completed" CRLF
 #define SMTP_ERROR_DATA_OK "354 Start mail input; end with <CRLF>.<CRLF>" CRLF
@@ -45,35 +43,27 @@ struct smtp_command {
 /*
  * Generate SMTP error message
  */
-gchar * make_smtp_error (rspamd_mempool_t *pool,
-	gint error_code,
-	const gchar *format,
-	...);
+gchar * make_smtp_error (rspamd_mempool_t *pool, gint error_code, const gchar *format, ...);
 
 /*
  * Parse a single SMTP command
  */
-gboolean parse_smtp_command (struct smtp_session *session,
-	f_str_t *line,
-	struct smtp_command **cmd);
+gboolean parse_smtp_command (struct smtp_session *session, f_str_t *line, struct smtp_command **cmd);
 
 /*
  * Parse HELO command
  */
-gboolean parse_smtp_helo (struct smtp_session *session,
-	struct smtp_command *cmd);
+gboolean parse_smtp_helo (struct smtp_session *session, struct smtp_command *cmd);
 
 /*
  * Parse MAIL command
  */
-gboolean parse_smtp_from (struct smtp_session *session,
-	struct smtp_command *cmd);
+gboolean parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd);
 
 /*
  * Parse RCPT command
  */
-gboolean parse_smtp_rcpt (struct smtp_session *session,
-	struct smtp_command *cmd);
+gboolean parse_smtp_rcpt (struct smtp_session *session, struct smtp_command *cmd);
 
 /* Upstream SMTP */
 
diff --git a/src/libmime/smtp_utils.c b/src/libmime/smtp_utils.c
index a4fb4582e..8ed169fa7 100644
--- a/src/libmime/smtp_utils.c
+++ b/src/libmime/smtp_utils.c
@@ -22,15 +22,15 @@
  */
 
 #include "config.h"
-#include "filter.h"
 #include "main.h"
+#include "filter.h"
 #include "smtp.h"
 #include "smtp_proto.h"
 
 void
 free_smtp_session (gpointer arg)
 {
-	struct smtp_session *session = arg;
+	struct smtp_session            *session = arg;
 
 	if (session) {
 		if (session->task) {
@@ -60,17 +60,12 @@ free_smtp_session (gpointer arg)
 gboolean
 create_smtp_upstream_connection (struct smtp_session *session)
 {
-	struct smtp_upstream *selected;
+	struct smtp_upstream              *selected;
 
 	/* Try to select upstream */
-	selected = (struct smtp_upstream *)get_upstream_round_robin (
-		session->ctx->upstreams,
-		session->ctx->upstream_num,
-		sizeof (struct smtp_upstream),
-		session->session_time,
-		DEFAULT_UPSTREAM_ERROR_TIME,
-		DEFAULT_UPSTREAM_DEAD_TIME,
-		DEFAULT_UPSTREAM_MAXERRORS);
+	selected = (struct smtp_upstream *)get_upstream_round_robin (session->ctx->upstreams,
+			session->ctx->upstream_num, sizeof (struct smtp_upstream),
+			session->session_time, DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
 	if (selected == NULL) {
 		msg_err ("no upstreams suitable found");
 		return FALSE;
@@ -79,32 +74,19 @@ create_smtp_upstream_connection (struct smtp_session *session)
 	session->upstream = selected;
 
 	/* Now try to create socket */
-	session->upstream_sock = make_universal_socket (selected->addr,
-			selected->port,
-			SOCK_STREAM,
-			TRUE,
-			FALSE,
-			FALSE);
+	session->upstream_sock = make_universal_socket (selected->addr, selected->port, SOCK_STREAM, TRUE, FALSE, FALSE);
 	if (session->upstream_sock == -1) {
 		msg_err ("cannot make a connection to %s", selected->name);
 		upstream_fail (&selected->up, session->session_time);
 		return FALSE;
 	}
 	/* Create a dispatcher for upstream connection */
-	session->upstream_dispatcher = rspamd_create_dispatcher (session->ev_base,
-			session->upstream_sock,
-			BUFFER_LINE,
-			smtp_upstream_read_socket,
-			smtp_upstream_write_socket,
-			smtp_upstream_err_socket,
-			&session->ctx->smtp_timeout,
-			session);
+	session->upstream_dispatcher = rspamd_create_dispatcher (session->ev_base, session->upstream_sock, BUFFER_LINE,
+							smtp_upstream_read_socket, smtp_upstream_write_socket, smtp_upstream_err_socket,
+							&session->ctx->smtp_timeout, session);
 	session->state = SMTP_STATE_WAIT_UPSTREAM;
 	session->upstream_state = SMTP_STATE_GREETING;
-	register_async_event (session->s,
-		(event_finalizer_t)smtp_upstream_finalize_connection,
-		session,
-		g_quark_from_static_string ("smtp proxy"));
+	register_async_event (session->s, (event_finalizer_t)smtp_upstream_finalize_connection, session, g_quark_from_static_string ("smtp proxy"));
 	return TRUE;
 }
 
@@ -116,8 +98,7 @@ smtp_send_upstream_message (struct smtp_session *session)
 
 	session->upstream_state = SMTP_STATE_IN_SENDFILE;
 	session->state = SMTP_STATE_WAIT_UPSTREAM;
-	if (!rspamd_dispatcher_sendfile (session->upstream_dispatcher,
-		session->temp_fd, session->temp_size)) {
+	if (! rspamd_dispatcher_sendfile (session->upstream_dispatcher, session->temp_fd, session->temp_size)) {
 		msg_err ("sendfile failed: %s", strerror (errno));
 		goto err;
 	}
@@ -126,8 +107,7 @@ smtp_send_upstream_message (struct smtp_session *session)
 err:
 	session->error = SMTP_ERROR_FILE;
 	session->state = SMTP_STATE_CRITICAL_ERROR;
-	if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE,
-		TRUE)) {
+	if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 		return FALSE;
 	}
 	destroy_session (session->s);
@@ -135,35 +115,32 @@ err:
 }
 
 struct smtp_metric_callback_data {
-	struct smtp_session *session;
-	enum rspamd_metric_action action;
-	struct metric_result *res;
-	gchar *log_buf;
-	gint log_offset;
-	gint log_size;
-	gboolean alive;
+	struct smtp_session            *session;
+	enum rspamd_metric_action       action;
+	struct metric_result           *res;
+	gchar                          *log_buf;
+	gint                            log_offset;
+	gint                            log_size;
+	gboolean                        alive;
 };
 
 static void
 smtp_metric_symbols_callback (gpointer key, gpointer value, void *user_data)
 {
-	struct smtp_metric_callback_data *cd = user_data;
+	struct smtp_metric_callback_data    *cd = user_data;
 
-	cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
-			cd->log_size - cd->log_offset,
-			"%s,",
-			(gchar *)key);
+	cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "%s,", (gchar *)key);
 }
 
 static void
 smtp_metric_callback (gpointer key, gpointer value, gpointer ud)
 {
 	struct smtp_metric_callback_data *cd = ud;
-	struct metric_result *metric_res = value;
-	enum rspamd_metric_action action = METRIC_ACTION_NOACTION;
-	double ms = 0, rs = 0;
-	gboolean is_spam = FALSE;
-	struct rspamd_task *task;
+	struct metric_result           *metric_res = value;
+	enum rspamd_metric_action       action = METRIC_ACTION_NOACTION;
+	double                          ms = 0, rs = 0;
+	gboolean                        is_spam = FALSE;
+	struct rspamd_task             *task;
 
 	task = cd->session->task;
 
@@ -175,10 +152,8 @@ smtp_metric_callback (gpointer key, gpointer value, gpointer ud)
 		ms = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
 		rs = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
 	}
-	if (!check_metric_action_settings (task, metric_res, metric_res->score,
-		&action)) {
-		action =
-			check_metric_action (metric_res->score, ms, metric_res->metric);
+	if (! check_metric_action_settings (task, metric_res, metric_res->score, &action)) {
+		action = check_metric_action (metric_res->score, ms, metric_res->metric);
 	}
 #endif
 	if (metric_res->score >= ms) {
@@ -190,70 +165,42 @@ smtp_metric_callback (gpointer key, gpointer value, gpointer ud)
 	}
 
 	if (!task->is_skipped) {
-		cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
-				cd->log_size - cd->log_offset,
-				"(%s: %c (%s): [%.2f/%.2f/%.2f] [",
-				(gchar *)key,
-				is_spam ? 'T' : 'F',
-				str_action_metric (action),
-				metric_res->score,
-				ms,
-				rs);
+		cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "(%s: %c (%s): [%.2f/%.2f/%.2f] [",
+				(gchar *)key, is_spam ? 'T' : 'F', str_action_metric (action), metric_res->score, ms, rs);
 	}
 	else {
-		cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
-				cd->log_size - cd->log_offset,
-				"(%s: %c (default): [%.2f/%.2f/%.2f] [",
-				(gchar *)key,
-				'S',
-				metric_res->score,
-				ms,
-				rs);
+		cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "(%s: %c (default): [%.2f/%.2f/%.2f] [",
+				(gchar *)key, 'S', metric_res->score, ms, rs);
 
 	}
-	g_hash_table_foreach (metric_res->symbols, smtp_metric_symbols_callback,
-		cd);
+	g_hash_table_foreach (metric_res->symbols, smtp_metric_symbols_callback, cd);
 	/* Remove last , from log buf */
 	if (cd->log_buf[cd->log_offset - 1] == ',') {
 		cd->log_buf[--cd->log_offset] = '\0';
 	}
 
 #ifdef HAVE_CLOCK_GETTIME
-	cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
-			cd->log_size - cd->log_offset,
-			"]), len: %z, time: %s,",
-			task->msg->len,
-			calculate_check_time (&task->tv, &task->ts, task->cfg->clock_res,
-			&task->scan_milliseconds));
+	cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "]), len: %z, time: %s,",
+		task->msg->len, calculate_check_time (&task->tv, &task->ts, task->cfg->clock_res, &task->scan_milliseconds));
 #else
-	cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset,
-			cd->log_size - cd->log_offset,
-			"]), len: %z, time: %s,",
-			task->msg->len,
-			calculate_check_time (&task->tv, task->cfg->clock_res,
-			&task->scan_milliseconds));
+	cd->log_offset += rspamd_snprintf (cd->log_buf + cd->log_offset, cd->log_size - cd->log_offset, "]), len: %z, time: %s,",
+		task->msg->len, calculate_check_time (&task->tv, task->cfg->clock_res, &task->scan_milliseconds));
 #endif
 }
 
 gboolean
 make_smtp_tempfile (struct smtp_session *session)
 {
-	gsize r;
+	gsize                            r;
 
 	r = strlen (session->cfg->temp_dir) + sizeof ("/rspamd-XXXXXX");
 	session->temp_name = rspamd_mempool_alloc (session->pool, r);
-	rspamd_snprintf (session->temp_name,
-		r,
-		"%s%crspamd-XXXXXX",
-		session->cfg->temp_dir,
-		G_DIR_SEPARATOR);
+	rspamd_snprintf (session->temp_name, r, "%s%crspamd-XXXXXX", session->cfg->temp_dir, G_DIR_SEPARATOR);
 #ifdef HAVE_MKSTEMP
 	/* Umask is set before */
 	session->temp_fd = mkstemp (session->temp_name);
 #else
-	session->temp_fd = g_mkstemp_full (session->temp_name,
-			O_RDWR,
-			S_IWUSR | S_IRUSR);
+	session->temp_fd = g_mkstemp_full (session->temp_name, O_RDWR, S_IWUSR | S_IRUSR);
 #endif
 	if (session->temp_fd == -1) {
 		msg_err ("mkstemp error: %s", strerror (errno));
@@ -267,28 +214,23 @@ make_smtp_tempfile (struct smtp_session *session)
 gboolean
 write_smtp_reply (struct smtp_session *session)
 {
-	gchar logbuf[1024], *new_subject;
-	const gchar *old_subject;
+	gchar                           logbuf[1024], *new_subject;
+	const gchar                    *old_subject;
 	struct smtp_metric_callback_data cd;
-	GMimeStream *stream;
-	gint old_fd, sublen;
+	GMimeStream                    *stream;
+	gint                            old_fd, sublen;
 
 	/* Check metrics */
 	cd.session = session;
 	cd.action = METRIC_ACTION_NOACTION;
 	cd.res = NULL;
 	cd.log_buf = logbuf;
-	cd.log_offset = rspamd_snprintf (logbuf,
-			sizeof (logbuf),
-			"id: <%s>, qid: <%s>, ",
-			session->task->message_id,
-			session->task->queue_id);
+	cd.log_offset = rspamd_snprintf (logbuf, sizeof (logbuf), "id: <%s>, qid: <%s>, ",
+			session->task->message_id, session->task->queue_id);
 	cd.log_size = sizeof (logbuf);
 	if (session->task->user) {
-		cd.log_offset += rspamd_snprintf (logbuf + cd.log_offset,
-				sizeof (logbuf) - cd.log_offset,
-				"user: %s, ",
-				session->task->user);
+		cd.log_offset += rspamd_snprintf (logbuf + cd.log_offset, sizeof (logbuf) - cd.log_offset,
+				"user: %s, ", session->task->user);
 	}
 
 	g_hash_table_foreach (session->task->results, smtp_metric_callback, &cd);
@@ -296,26 +238,22 @@ write_smtp_reply (struct smtp_session *session)
 	msg_info ("%s", logbuf);
 
 	if (cd.action <= METRIC_ACTION_REJECT) {
-		if (!rspamd_dispatcher_write (session->dispatcher,
-			session->ctx->reject_message, 0, FALSE, TRUE)) {
+		if (! rspamd_dispatcher_write (session->dispatcher, session->ctx->reject_message, 0, FALSE, TRUE)) {
 			return FALSE;
 		}
-		if (!rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) -
-			1, FALSE, TRUE)) {
+		if (! rspamd_dispatcher_write (session->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
 			return FALSE;
 		}
 		destroy_session (session->s);
 		return FALSE;
 	}
-	else if (cd.action <= METRIC_ACTION_ADD_HEADER || cd.action <=
-		METRIC_ACTION_REWRITE_SUBJECT) {
+	else if (cd.action <= METRIC_ACTION_ADD_HEADER || cd.action <= METRIC_ACTION_REWRITE_SUBJECT) {
 		old_fd = session->temp_fd;
-		if (!make_smtp_tempfile (session)) {
+		if (! make_smtp_tempfile (session)) {
 			session->error = SMTP_ERROR_FILE;
 			session->state = SMTP_STATE_CRITICAL_ERROR;
 			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				0, FALSE, TRUE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 				goto err;
 			}
 			destroy_session (session->s);
@@ -328,11 +266,7 @@ write_smtp_reply (struct smtp_session *session)
 			if (old_subject != NULL) {
 				sublen = strlen (old_subject) + sizeof (SPAM_SUBJECT);
 				new_subject = rspamd_mempool_alloc (session->pool, sublen);
-				rspamd_snprintf (new_subject,
-					sublen,
-					"%s%s",
-					SPAM_SUBJECT,
-					old_subject);
+				rspamd_snprintf (new_subject, sublen, "%s%s", SPAM_SUBJECT, old_subject);
 			}
 			else {
 				new_subject = SPAM_SUBJECT;
@@ -341,26 +275,21 @@ write_smtp_reply (struct smtp_session *session)
 		}
 		else if (cd.action <= METRIC_ACTION_ADD_HEADER) {
 #ifndef GMIME24
-			g_mime_message_add_header (session->task->message, "X-Spam",
-				"true");
+			g_mime_message_add_header (session->task->message, "X-Spam", "true");
 #else
-			g_mime_object_append_header (GMIME_OBJECT (
-					session->task->message), "X-Spam", "true");
+			g_mime_object_append_header (GMIME_OBJECT (session->task->message), "X-Spam", "true");
 #endif
 		}
 		stream = g_mime_stream_fs_new (session->temp_fd);
 		g_mime_stream_fs_set_owner (GMIME_STREAM_FS (stream), FALSE);
 		close (old_fd);
 
-		if (g_mime_object_write_to_stream (GMIME_OBJECT (session->task->message),
-			stream) == -1) {
-			msg_err ("cannot write MIME object to stream: %s",
-				strerror (errno));
+		if (g_mime_object_write_to_stream (GMIME_OBJECT (session->task->message), stream) == -1) {
+			msg_err ("cannot write MIME object to stream: %s", strerror (errno));
 			session->error = SMTP_ERROR_FILE;
 			session->state = SMTP_STATE_CRITICAL_ERROR;
 			rspamd_dispatcher_restore (session->dispatcher);
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				0, FALSE, TRUE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 				goto err;
 			}
 			destroy_session (session->s);
@@ -373,8 +302,7 @@ write_smtp_reply (struct smtp_session *session)
 err:
 	session->error = SMTP_ERROR_FILE;
 	session->state = SMTP_STATE_CRITICAL_ERROR;
-	if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE,
-		TRUE)) {
+	if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 		return FALSE;
 	}
 	destroy_session (session->s);
@@ -382,33 +310,29 @@ err:
 }
 
 gboolean
-parse_upstreams_line (rspamd_mempool_t *pool,
-	struct smtp_upstream *upstreams,
-	const gchar *line,
-	gsize *count)
+parse_upstreams_line (rspamd_mempool_t *pool, struct smtp_upstream *upstreams, const gchar *line, gsize *count)
 {
-	gchar **strv, *p, *t, *tt, *err_str;
-	guint32 num, i;
-	struct smtp_upstream *cur;
-	gchar resolved_path[PATH_MAX];
+	gchar                           **strv, *p, *t, *tt, *err_str;
+	guint32                         num, i;
+	struct smtp_upstream           *cur;
+	gchar                           resolved_path[PATH_MAX];
 
 	strv = g_strsplit_set (line, ",; ", -1);
 	num = g_strv_length (strv);
 
 	if (num >= MAX_SMTP_UPSTREAMS) {
-		msg_err ("cannot define %d upstreams %d is max", num,
-			MAX_SMTP_UPSTREAMS);
+		msg_err ("cannot define %d upstreams %d is max", num, MAX_SMTP_UPSTREAMS);
 		return FALSE;
 	}
 	*count = 0;
 
-	for (i = 0; i < num; i++) {
+	for (i = 0; i < num; i ++) {
 		p = strv[i];
 		cur = &upstreams[*count];
 		if ((t = strrchr (p, ':')) != NULL && (tt = strchr (p, ':')) != t) {
 			/* Assume that after last `:' we have weigth */
 			*t = '\0';
-			t++;
+			t ++;
 			errno = 0;
 			cur->up.priority = strtoul (t, &err_str, 10);
 			if (errno != 0 || (err_str && *err_str != '\0')) {
@@ -425,15 +349,15 @@ parse_upstreams_line (rspamd_mempool_t *pool,
 				return FALSE;
 			}
 			cur->name = rspamd_mempool_strdup (pool, resolved_path);
-			(*count)++;
+			(*count) ++;
 		}
 		else {
-			if (!rspamd_parse_host_port (pool, p, &cur->addr, &cur->port)) {
+			if (! rspamd_parse_host_port (pool, p, &cur->addr, &cur->port)) {
 				g_strfreev (strv);
 				return FALSE;
 			}
 			cur->name = rspamd_mempool_strdup (pool, p);
-			(*count)++;
+			(*count) ++;
 		}
 	}
 
diff --git a/src/libmime/smtp_utils.h b/src/libmime/smtp_utils.h
index c09729180..652b6759f 100644
--- a/src/libmime/smtp_utils.h
+++ b/src/libmime/smtp_utils.h
@@ -58,9 +58,6 @@ void free_smtp_session (gpointer arg);
  * @param count targeted count
  * @return
  */
-gboolean parse_upstreams_line (rspamd_mempool_t *pool,
-	struct smtp_upstream *upstreams,
-	const gchar *line,
-	gsize *count);
+gboolean parse_upstreams_line (rspamd_mempool_t *pool, struct smtp_upstream *upstreams, const gchar *line, gsize *count);
 
 #endif /* SMTP_UTILS_H_ */
diff --git a/src/libserver/binlog.c b/src/libserver/binlog.c
index ee0bf86bc..ec191eac7 100644
--- a/src/libserver/binlog.c
+++ b/src/libserver/binlog.c
@@ -22,9 +22,9 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "config.h"
 #include "binlog.h"
 #include "cfg_file.h"
-#include "config.h"
 #include "tokenizers/tokenizers.h"
 
 #define BINLOG_SUFFIX ".binlog"
@@ -35,7 +35,7 @@
 static GHashTable *binlog_opened = NULL;
 static rspamd_mempool_t *binlog_pool = NULL;
 
-static gboolean
+static gboolean 
 binlog_write_header (struct rspamd_binlog *log)
 {
 	struct rspamd_binlog_header header = {
@@ -43,35 +43,27 @@ binlog_write_header (struct rspamd_binlog *log)
 		.version = VALID_VERSION,
 		.padding = { '\0', '\0' },
 	};
-
+	
 	header.create_time = time (NULL);
 	lock_file (log->fd, FALSE);
-
+	
 	if (write (log->fd, &header, sizeof (struct rspamd_binlog_header)) == -1) {
-		msg_warn ("cannot write file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+		msg_warn ("cannot write file %s, error %d, %s", log->filename, errno, strerror (errno));
 		return FALSE;
 	}
 
 
 	memcpy (&log->header, &header, sizeof (struct rspamd_binlog_header));
-
+	
 	/* Metaindex */
 	log->metaindex = g_malloc (sizeof (struct rspamd_binlog_metaindex));
 	bzero (log->metaindex, sizeof (struct rspamd_binlog_metaindex));
 	/* Offset to metaindex */
-	log->metaindex->indexes[0] = sizeof (struct rspamd_binlog_metaindex) +
-		sizeof (struct rspamd_binlog_header);
+	log->metaindex->indexes[0] = sizeof (struct rspamd_binlog_metaindex) + sizeof (struct rspamd_binlog_header);
 
-	if (write (log->fd, log->metaindex,
-		sizeof (struct rspamd_binlog_metaindex))  == -1) {
+	if (write (log->fd, log->metaindex, sizeof (struct rspamd_binlog_metaindex))  == -1) {
 		g_free (log->metaindex);
-		msg_warn ("cannot write file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+		msg_warn ("cannot write file %s, error %d, %s", log->filename, errno, strerror (errno));
 		unlock_file (log->fd, FALSE);
 		return FALSE;
 	}
@@ -79,13 +71,9 @@ binlog_write_header (struct rspamd_binlog *log)
 	/* Alloc, write, mmap */
 	log->cur_idx = g_malloc (sizeof (struct rspamd_index_block));
 	bzero (log->cur_idx, sizeof (struct rspamd_index_block));
-	if (write (log->fd, log->cur_idx,
-		sizeof (struct rspamd_index_block))  == -1) {
+	if (write (log->fd, log->cur_idx, sizeof (struct rspamd_index_block))  == -1) {
 		g_free (log->cur_idx);
-		msg_warn ("cannot write file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+		msg_warn ("cannot write file %s, error %d, %s", log->filename, errno, strerror (errno));
 		unlock_file (log->fd, FALSE);
 		return FALSE;
 	}
@@ -100,20 +88,14 @@ binlog_check_file (struct rspamd_binlog *log)
 {
 	static gchar valid_magic[] = VALID_MAGIC, valid_version[] = VALID_VERSION;
 
-	if (read (log->fd, &log->header,
-		sizeof (struct rspamd_binlog_header)) !=
-		sizeof (struct rspamd_binlog_header)) {
-		msg_warn ("cannot read file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+	if (read (log->fd, &log->header, sizeof (struct rspamd_binlog_header)) != sizeof (struct rspamd_binlog_header)) {
+		msg_warn ("cannot read file %s, error %d, %s", log->filename, errno, strerror (errno));
 		return FALSE;
 	}
 
 	/* Now check all fields */
-	if (memcmp (&log->header.magic, valid_magic, sizeof (valid_magic)) != 0 ||
-		memcmp (&log->header.version, valid_version,
-		sizeof (valid_version)) != 0) {
+	if (memcmp (&log->header.magic, valid_magic, sizeof (valid_magic)) != 0 || 
+			memcmp (&log->header.version, valid_version, sizeof (valid_version)) != 0) {
 		msg_warn ("cannot validate file %s");
 		return FALSE;
 	}
@@ -121,38 +103,24 @@ binlog_check_file (struct rspamd_binlog *log)
 	if (log->metaindex == NULL) {
 		log->metaindex = g_malloc (sizeof (struct rspamd_binlog_metaindex));
 	}
-	if ((read (log->fd, log->metaindex,
-		sizeof (struct rspamd_binlog_metaindex))) !=
-		sizeof (struct rspamd_binlog_metaindex)) {
-		msg_warn ("cannot read metaindex of file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+	if ((read (log->fd, log->metaindex, sizeof (struct rspamd_binlog_metaindex))) != sizeof (struct rspamd_binlog_metaindex)) {
+		msg_warn ("cannot read metaindex of file %s, error %d, %s", log->filename, errno, strerror (errno));
 		return FALSE;
 	}
 	/* Current index */
 	if (log->cur_idx == NULL) {
 		log->cur_idx = g_malloc (sizeof (struct rspamd_index_block));
 	}
-	if (lseek (log->fd, log->metaindex->indexes[log->metaindex->last_index],
-		SEEK_SET) == -1) {
-		msg_info ("cannot seek in file: %s, error: %s",
-			log->filename,
-			strerror (errno));
+	if (lseek (log->fd, log->metaindex->indexes[log->metaindex->last_index], SEEK_SET) == -1) {
+		msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
 		return FALSE;
 	}
-	if ((read (log->fd, log->cur_idx,
-		sizeof (struct rspamd_index_block))) !=
-		sizeof (struct rspamd_index_block)) {
-		msg_warn ("cannot read index in file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+	if ((read (log->fd, log->cur_idx, sizeof (struct rspamd_index_block))) != sizeof (struct rspamd_index_block)) {
+		msg_warn ("cannot read index in file %s, error %d, %s", log->filename, errno, strerror (errno));
 		return FALSE;
 	}
 
-	log->cur_seq = log->metaindex->last_index * BINLOG_IDX_LEN +
-		log->cur_idx->last_index;
+	log->cur_seq = log->metaindex->last_index * BINLOG_IDX_LEN + log->cur_idx->last_index;
 	log->cur_time = log->cur_idx->indexes[log->cur_idx->last_index].time;
 
 	return TRUE;
@@ -162,13 +130,8 @@ binlog_check_file (struct rspamd_binlog *log)
 static gboolean
 binlog_create (struct rspamd_binlog *log)
 {
-	if ((log->fd =
-		open (log->filename, O_RDWR | O_TRUNC | O_CREAT,
-		S_IWUSR | S_IRUSR)) == -1) {
-		msg_info ("cannot create file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+	if ((log->fd = open (log->filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
+		msg_info ("cannot create file %s, error %d, %s", log->filename, errno, strerror (errno));
 		return FALSE;
 	}
 
@@ -179,25 +142,19 @@ static gboolean
 binlog_open_real (struct rspamd_binlog *log)
 {
 	if ((log->fd = open (log->filename, O_RDWR)) == -1) {
-		msg_info ("cannot open file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot open file %s, error %d, %s", log->filename, errno, strerror (errno));
 		return FALSE;
 	}
-
+	
 	return binlog_check_file (log);
 }
 
 
-struct rspamd_binlog *
-binlog_open (rspamd_mempool_t *pool,
-	const gchar *path,
-	time_t rotate_time,
-	gint rotate_jitter)
+struct rspamd_binlog* 
+binlog_open (rspamd_mempool_t *pool, const gchar *path, time_t rotate_time, gint rotate_jitter)
 {
 	struct rspamd_binlog *new;
-	gint len = strlen (path);
+	gint                            len = strlen (path);
 	struct stat st;
 
 	new = rspamd_mempool_alloc0 (pool, sizeof (struct rspamd_binlog));
@@ -208,16 +165,15 @@ binlog_open (rspamd_mempool_t *pool,
 	if (rotate_time) {
 		new->rotate_jitter = g_random_int_range (0, rotate_jitter);
 	}
-
+	
 	new->filename = rspamd_mempool_alloc (pool, len + sizeof (BINLOG_SUFFIX));
-	rspamd_strlcpy (new->filename,		 path,			len + 1);
+	rspamd_strlcpy (new->filename, path, len + 1);
 	rspamd_strlcpy (new->filename + len, BINLOG_SUFFIX, sizeof (BINLOG_SUFFIX));
 
 	if (stat (new->filename, &st) == -1) {
 		/* Check errno to check whether we should create this file */
 		if (errno != ENOENT) {
-			msg_err ("cannot stat file: %s, error %s", new->filename,
-				strerror (errno));
+			msg_err ("cannot stat file: %s, error %s", new->filename, strerror (errno));
 			return NULL;
 		}
 		else {
@@ -237,7 +193,7 @@ binlog_open (rspamd_mempool_t *pool,
 	return new;
 }
 
-void
+void 
 binlog_close (struct rspamd_binlog *log)
 {
 	if (log) {
@@ -254,18 +210,16 @@ binlog_close (struct rspamd_binlog *log)
 static gboolean
 binlog_tree_callback (gpointer key, gpointer value, gpointer data)
 {
-	token_node_t *node = key;
-	struct rspamd_binlog *log = data;
-	struct rspamd_binlog_element elt;
+	token_node_t                   *node = key;
+	struct rspamd_binlog           *log = data;
+	struct rspamd_binlog_element    elt;
 
 	elt.h1 = node->h1;
 	elt.h2 = node->h2;
 	elt.value = node->value;
-
+	
 	if (write (log->fd, &elt, sizeof (elt)) == -1) {
-		msg_info ("cannot write token to file: %s, error: %s",
-			log->filename,
-			strerror (errno));
+		msg_info ("cannot write token to file: %s, error: %s", log->filename, strerror (errno));
 		return TRUE;
 	}
 
@@ -279,14 +233,12 @@ write_binlog_tree (struct rspamd_binlog *log, GTree *nodes)
 	struct rspamd_binlog_index *idx;
 
 	lock_file (log->fd, FALSE);
-	log->cur_seq++;
+	log->cur_seq ++;	
 
 	/* Seek to end of file */
 	if ((seek = lseek (log->fd, 0, SEEK_END)) == -1) {
 		unlock_file (log->fd, FALSE);
-		msg_info ("cannot seek in file: %s, error: %s",
-			log->filename,
-			strerror (errno));
+		msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
 		return FALSE;
 	}
 
@@ -299,28 +251,21 @@ write_binlog_tree (struct rspamd_binlog *log, GTree *nodes)
 	idx->time = (guint64)time (NULL);
 	log->cur_time = idx->time;
 	idx->len = g_tree_nnodes (nodes) * sizeof (struct rspamd_binlog_element);
-	if (lseek (log->fd, log->metaindex->indexes[log->metaindex->last_index],
-		SEEK_SET) == -1) {
+	if (lseek (log->fd, log->metaindex->indexes[log->metaindex->last_index], SEEK_SET) == -1) {
 		unlock_file (log->fd, FALSE);
-		msg_info (
-			"cannot seek in file: %s, error: %s, seek: %L, op: insert index",
-			log->filename,
-			strerror (errno),
-			log->metaindex->indexes[log->metaindex->last_index]);
+		msg_info ("cannot seek in file: %s, error: %s, seek: %L, op: insert index", log->filename, 
+				strerror (errno), log->metaindex->indexes[log->metaindex->last_index]);
 		return FALSE;
 	}
-	log->cur_idx->last_index++;
-	if (write (log->fd, log->cur_idx,
-		sizeof (struct rspamd_index_block)) == -1) {
+	log->cur_idx->last_index ++;
+	if (write (log->fd, log->cur_idx, sizeof (struct rspamd_index_block)) == -1) {
 		unlock_file (log->fd, FALSE);
-		msg_info ("cannot write index to file: %s, error: %s",
-			log->filename,
-			strerror (errno));
+		msg_info ("cannot write index to file: %s, error: %s", log->filename, strerror (errno));
 		return FALSE;
 	}
 
 	unlock_file (log->fd, FALSE);
-
+	
 	return TRUE;
 }
 
@@ -330,24 +275,18 @@ create_new_metaindex_block (struct rspamd_binlog *log)
 	off_t seek;
 
 	lock_file (log->fd, FALSE);
-
-	log->metaindex->last_index++;
+	
+	log->metaindex->last_index ++;
 	/* Seek to end of file */
 	if ((seek = lseek (log->fd, 0, SEEK_END)) == -1) {
 		unlock_file (log->fd, FALSE);
-		msg_info ("cannot seek in file: %s, error: %s",
-			log->filename,
-			strerror (errno));
+		msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
 		return FALSE;
 	}
-	if (write (log->fd, log->cur_idx,
-		sizeof (struct rspamd_index_block))  == -1) {
+	if (write (log->fd, log->cur_idx, sizeof (struct rspamd_index_block))  == -1) {
 		unlock_file (log->fd, FALSE);
 		g_free (log->cur_idx);
-		msg_warn ("cannot write file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+		msg_warn ("cannot write file %s, error %d, %s", log->filename, errno, strerror (errno));
 		return FALSE;
 	}
 	/* Offset to metaindex */
@@ -355,17 +294,12 @@ create_new_metaindex_block (struct rspamd_binlog *log)
 	/* Overwrite all metaindexes */
 	if (lseek (log->fd, sizeof (struct rspamd_binlog_header), SEEK_SET) == -1) {
 		unlock_file (log->fd, FALSE);
-		msg_info ("cannot seek in file: %s, error: %s",
-			log->filename,
-			strerror (errno));
+		msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
 		return FALSE;
 	}
-	if (write (log->fd, log->metaindex,
-		sizeof (struct rspamd_binlog_metaindex)) == -1) {
+	if (write (log->fd, log->metaindex, sizeof (struct rspamd_binlog_metaindex)) == -1) {
 		unlock_file (log->fd, FALSE);
-		msg_info ("cannot write metaindex in file: %s, error: %s",
-			log->filename,
-			strerror (errno));
+		msg_info ("cannot write metaindex in file: %s, error: %s", log->filename, strerror (errno));
 		return FALSE;
 	}
 	bzero (log->cur_idx, sizeof (struct rspamd_index_block));
@@ -377,11 +311,9 @@ create_new_metaindex_block (struct rspamd_binlog *log)
 static gboolean
 maybe_rotate_binlog (struct rspamd_binlog *log)
 {
-	guint64 now = time (NULL);
+	guint64                         now = time (NULL);
 
-	if (log->rotate_time &&
-		((now - log->header.create_time) >
-		(guint)(log->rotate_time + log->rotate_jitter))) {
+	if (log->rotate_time && ((now - log->header.create_time) > (guint)(log->rotate_time + log->rotate_jitter))) {
 		return TRUE;
 	}
 	return FALSE;
@@ -390,7 +322,7 @@ maybe_rotate_binlog (struct rspamd_binlog *log)
 static gboolean
 rotate_binlog (struct rspamd_binlog *log)
 {
-	gchar *backup_name;
+	gchar                           *backup_name;
 	struct stat st;
 
 	lock_file (log->fd, FALSE);
@@ -423,14 +355,13 @@ rotate_binlog (struct rspamd_binlog *log)
 
 }
 
-gboolean
+gboolean 
 binlog_insert (struct rspamd_binlog *log, GTree *nodes)
 {
 	off_t seek;
 
 	if (!log || !log->metaindex || !log->cur_idx || !nodes) {
-		msg_info ("improperly opened binlog: %s",
-			log != NULL ? log->filename : "unknown");
+		msg_info ("improperly opened binlog: %s", log != NULL ? log->filename : "unknown");
 		return FALSE;
 	}
 
@@ -450,9 +381,7 @@ binlog_insert (struct rspamd_binlog *log, GTree *nodes)
 	if (log->metaindex->last_index < METAINDEX_LEN) {
 		/* Create new index block */
 		if ((seek = lseek (log->fd, 0, SEEK_END)) == (off_t)-1) {
-			msg_info ("cannot seek in file: %s, error: %s",
-				log->filename,
-				strerror (errno));
+			msg_info ("cannot seek in file: %s, error: %s", log->filename, strerror (errno));
 			return FALSE;
 		}
 		if (!create_new_metaindex_block (log)) {
@@ -460,7 +389,7 @@ binlog_insert (struct rspamd_binlog *log, GTree *nodes)
 		}
 		return write_binlog_tree (log, nodes);
 	}
-
+	
 	/* All binlog is filled, we need to rotate it forcefully */
 	if (!rotate_binlog (log)) {
 		return FALSE;
@@ -469,20 +398,16 @@ binlog_insert (struct rspamd_binlog *log, GTree *nodes)
 	return write_binlog_tree (log, nodes);
 }
 
-gboolean
-binlog_sync (struct rspamd_binlog *log,
-	guint64 from_rev,
-	guint64 *from_time,
-	GByteArray **rep)
+gboolean 
+binlog_sync (struct rspamd_binlog *log, guint64 from_rev, guint64 *from_time, GByteArray **rep)
 {
-	guint32 metaindex_num;
+	guint32                         metaindex_num;
 	struct rspamd_index_block *idxb;
 	struct rspamd_binlog_index *idx;
 	gboolean idx_mapped = FALSE, res = TRUE, is_first = FALSE;
 
 	if (!log || !log->metaindex || !log->cur_idx) {
-		msg_info ("improperly opened binlog: %s",
-			log != NULL ? log->filename : "unknown");
+		msg_info ("improperly opened binlog: %s", log != NULL ? log->filename : "unknown");
 		return FALSE;
 	}
 
@@ -494,7 +419,7 @@ binlog_sync (struct rspamd_binlog *log,
 		/* Unmap old fragment */
 		g_free ((*rep)->data);
 	}
-
+	
 	if (from_rev == log->cur_seq) {
 		/* Last record */
 		*rep = NULL;
@@ -502,11 +427,7 @@ binlog_sync (struct rspamd_binlog *log,
 	}
 	else if (from_rev > log->cur_seq) {
 		/* Slave has more actual copy, write this to log and abort sync */
-		msg_warn (
-			"slave has more recent revision of statfile %s: %uL and our is: %uL",
-			log->filename,
-			from_rev,
-			log->cur_seq);
+		msg_warn ("slave has more recent revision of statfile %s: %uL and our is: %uL", log->filename, from_rev, log->cur_seq);
 		*rep = NULL;
 		*from_time = 0;
 		return FALSE;
@@ -522,24 +443,15 @@ binlog_sync (struct rspamd_binlog *log,
 		lock_file (log->fd, FALSE);
 		idxb = g_malloc (sizeof (struct rspamd_index_block));
 		idx_mapped = TRUE;
-		if (lseek (log->fd, log->metaindex->indexes[metaindex_num],
-			SEEK_SET) == -1) {
+		if (lseek (log->fd, log->metaindex->indexes[metaindex_num], SEEK_SET) == -1) {
 			unlock_file (log->fd, FALSE);
-			msg_warn ("cannot seek file %s, error %d, %s",
-				log->filename,
-				errno,
-				strerror (errno));
+			msg_warn ("cannot seek file %s, error %d, %s", log->filename, errno, strerror (errno));
 			res = FALSE;
 			goto end;
 		}
-		if ((read (log->fd, idxb,
-			sizeof (struct rspamd_index_block))) !=
-			sizeof (struct rspamd_index_block)) {
+		if ((read (log->fd, idxb, sizeof (struct rspamd_index_block))) != sizeof (struct rspamd_index_block)) {
 			unlock_file (log->fd, FALSE);
-			msg_warn ("cannot read index from file %s, error %d, %s",
-				log->filename,
-				errno,
-				strerror (errno));
+			msg_warn ("cannot read index from file %s, error %d, %s", log->filename, errno, strerror (errno));
 			res = FALSE;
 			goto end;
 		}
@@ -562,27 +474,17 @@ binlog_sync (struct rspamd_binlog *log,
 	/* Now fill reply structure */
 	(*rep)->len = idx->len;
 	/* Read result */
-	msg_info (
-		"update from binlog '%s' from revision: %uL to revision %uL size is %uL",
-		log->filename,
-		from_rev,
-		log->cur_seq,
-		idx->len);
+	msg_info ("update from binlog '%s' from revision: %uL to revision %uL size is %uL",
+			log->filename, from_rev, log->cur_seq, idx->len);
 	if (lseek (log->fd, idx->seek, SEEK_SET) == -1) {
-		msg_warn ("cannot seek file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+		msg_warn ("cannot seek file %s, error %d, %s", log->filename, errno, strerror (errno));
 		res = FALSE;
 		goto end;
 	}
-
+	
 	(*rep)->data = g_malloc (idx->len);
 	if ((read (log->fd, (*rep)->data, idx->len)) != (ssize_t)idx->len) {
-		msg_warn ("cannot read file %s, error %d, %s",
-			log->filename,
-			errno,
-			strerror (errno));
+		msg_warn ("cannot read file %s, error %d, %s", log->filename, errno, strerror (errno));
 		res = FALSE;
 		goto end;
 	}
@@ -615,11 +517,8 @@ maybe_init_static (void)
 	return TRUE;
 }
 
-gboolean
-maybe_write_binlog (struct rspamd_classifier_config *ccf,
-	struct rspamd_statfile_config *st,
-	stat_file_t *file,
-	GTree *nodes)
+gboolean 
+maybe_write_binlog (struct rspamd_classifier_config *ccf, struct rspamd_statfile_config *st, stat_file_t *file, GTree *nodes)
 {
 	struct rspamd_binlog *log;
 
@@ -627,9 +526,8 @@ maybe_write_binlog (struct rspamd_classifier_config *ccf,
 		return FALSE;
 	}
 
-
-	if (st == NULL || nodes == NULL || st->binlog == NULL ||
-		st->binlog->affinity != AFFINITY_MASTER) {
+	
+	if (st == NULL || nodes == NULL || st->binlog == NULL || st->binlog->affinity != AFFINITY_MASTER) {
 		return FALSE;
 	}
 
@@ -638,9 +536,7 @@ maybe_write_binlog (struct rspamd_classifier_config *ccf,
 	}
 
 	if ((log = g_hash_table_lookup (binlog_opened, st)) == NULL) {
-		if ((log =
-			binlog_open (binlog_pool, st->path, st->binlog->rotate_time,
-			st->binlog->rotate_time / 2)) != NULL) {
+		if ((log = binlog_open (binlog_pool, st->path, st->binlog->rotate_time, st->binlog->rotate_time / 2)) != NULL) {
 			g_hash_table_insert (binlog_opened, st, log);
 		}
 		else {
@@ -649,9 +545,7 @@ maybe_write_binlog (struct rspamd_classifier_config *ccf,
 	}
 
 	if (binlog_insert (log, nodes)) {
-		msg_info ("set new revision of statfile %s: %uL",
-			st->symbol,
-			log->cur_seq);
+		msg_info ("set new revision of statfile %s: %uL", st->symbol, log->cur_seq);
 		(void)statfile_set_revision (file, log->cur_seq, log->cur_time);
 		return TRUE;
 	}
@@ -659,13 +553,12 @@ maybe_write_binlog (struct rspamd_classifier_config *ccf,
 	return FALSE;
 }
 
-struct rspamd_binlog *
+struct rspamd_binlog* 
 get_binlog_by_statfile (struct rspamd_statfile_config *st)
 {
 	struct rspamd_binlog *log;
 
-	if (st == NULL || st->binlog == NULL || st->binlog->affinity !=
-		AFFINITY_MASTER) {
+	if (st == NULL || st->binlog == NULL || st->binlog->affinity != AFFINITY_MASTER) {
 		return NULL;
 	}
 
@@ -674,15 +567,13 @@ get_binlog_by_statfile (struct rspamd_statfile_config *st)
 	}
 
 	if ((log = g_hash_table_lookup (binlog_opened, st)) == NULL) {
-		if ((log =
-			binlog_open (binlog_pool, st->path, st->binlog->rotate_time,
-			st->binlog->rotate_time / 2)) != NULL) {
+		if ((log = binlog_open (binlog_pool, st->path, st->binlog->rotate_time, st->binlog->rotate_time / 2)) != NULL) {
 			g_hash_table_insert (binlog_opened, st, log);
 		}
 		else {
 			return NULL;
 		}
 	}
-
+	
 	return log;
 }
diff --git a/src/libserver/binlog.h b/src/libserver/binlog.h
index c18a201f2..6b77a7613 100644
--- a/src/libserver/binlog.h
+++ b/src/libserver/binlog.h
@@ -58,15 +58,12 @@ struct rspamd_classifier_config;
 /*
  * Open binlog at specified path with specified rotate params
  */
-struct rspamd_binlog * binlog_open (rspamd_mempool_t *pool,
-	const gchar *path,
-	time_t rotate_time,
-	gint rotate_jitter);
+struct rspamd_binlog* binlog_open (rspamd_mempool_t *pool, const gchar *path, time_t rotate_time, gint rotate_jitter);
 
 /*
  * Get and open binlog for specified statfile
  */
-struct rspamd_binlog * get_binlog_by_statfile (struct rspamd_statfile_config *st);
+struct rspamd_binlog* get_binlog_by_statfile (struct rspamd_statfile_config *st);
 
 /*
  * Close binlog
@@ -86,17 +83,11 @@ gboolean binlog_insert (struct rspamd_binlog *log, GTree *nodes);
  * @param rep a portion of changes for revision is stored here
  * @return TRUE if there are more revisions to get and FALSE if synchronization is complete
  */
-gboolean binlog_sync (struct rspamd_binlog *log,
-	guint64 from_rev,
-	guint64 *from_time,
-	GByteArray **rep);
+gboolean binlog_sync (struct rspamd_binlog *log, guint64 from_rev, guint64 *from_time, GByteArray **rep);
 
 /*
  * Conditional write to a binlog for specified statfile
  */
-gboolean maybe_write_binlog (struct rspamd_classifier_config *ccf,
-	struct rspamd_statfile_config *st,
-	stat_file_t *file,
-	GTree *nodes);
+gboolean maybe_write_binlog (struct rspamd_classifier_config *ccf, struct rspamd_statfile_config *st, stat_file_t *file, GTree *nodes);
 
 #endif
diff --git a/src/libserver/buffer.c b/src/libserver/buffer.c
index 4f684caed..864f2fad6 100644
--- a/src/libserver/buffer.c
+++ b/src/libserver/buffer.c
@@ -22,22 +22,19 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "buffer.h"
 #include "config.h"
+#include "buffer.h"
 #include "main.h"
 #ifdef HAVE_SYS_SENDFILE_H
 #include <sys/sendfile.h>
 #endif
 
-#define G_DISPATCHER_ERROR dispatcher_error_quark ()
-#define debug_ip(...) rspamd_conditional_debug (rspamd_main->logger, \
-		NULL, \
-		__FUNCTION__, \
-		__VA_ARGS__)
+#define G_DISPATCHER_ERROR dispatcher_error_quark()
+#define debug_ip(...) rspamd_conditional_debug(rspamd_main->logger, NULL, __FUNCTION__, __VA_ARGS__)
 
-static void dispatcher_cb (gint fd, short what, void *arg);
+static void                     dispatcher_cb (gint fd, short what, void *arg);
 
-static inline GQuark
+static inline                   GQuark
 dispatcher_error_quark (void)
 {
 	return g_quark_from_static_string ("g-dispatcher-error-quark");
@@ -47,11 +44,11 @@ static gboolean
 sendfile_callback (rspamd_io_dispatcher_t *d)
 {
 
-	GError *err;
+	GError                         *err;
 
 #ifdef HAVE_SENDFILE
 # if defined(FREEBSD) || defined(DARWIN)
-	off_t off = 0;
+	off_t                           off = 0;
 	#if defined(FREEBSD)
 	/* FreeBSD version */
 	if (sendfile (d->sendfile_fd, d->fd, d->offset, 0, NULL, &off, 0) != 0) {
@@ -61,15 +58,13 @@ sendfile_callback (rspamd_io_dispatcher_t *d)
 	#endif
 		if (errno != EAGAIN) {
 			if (d->err_callback) {
-				err =
-					g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
-							errno));
+				err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
 				d->err_callback (err, d->user_data);
 				return FALSE;
 			}
 		}
 		else {
-			debug_ip ("partially write data, retry");
+			debug_ip("partially write data, retry");
 			/* Wait for other event */
 			d->offset += off;
 			event_del (d->ev);
@@ -81,33 +76,30 @@ sendfile_callback (rspamd_io_dispatcher_t *d)
 	else {
 		if (d->write_callback) {
 			if (!d->write_callback (d->user_data)) {
-				debug_ip ("callback set wanna_die flag, terminating");
+				debug_ip("callback set wanna_die flag, terminating");
 				return FALSE;
 			}
 		}
 		event_del (d->ev);
-		event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb,
-			(void *)d);
+		event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb, (void *)d);
 		event_base_set (d->ev_base, d->ev);
 		event_add (d->ev, d->tv);
 		d->in_sendfile = FALSE;
 	}
 # else
-	ssize_t r;
+	ssize_t                         r;
 	/* Linux version */
 	r = sendfile (d->fd, d->sendfile_fd, &d->offset, d->file_size);
 	if (r == -1) {
 		if (errno != EAGAIN) {
 			if (d->err_callback) {
-				err =
-					g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
-							errno));
+				err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
 				d->err_callback (err, d->user_data);
 				return FALSE;
 			}
 		}
 		else {
-			debug_ip ("partially write data, retry");
+			debug_ip("partially write data, retry");
 			/* Wait for other event */
 			event_del (d->ev);
 			event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
@@ -116,7 +108,7 @@ sendfile_callback (rspamd_io_dispatcher_t *d)
 		}
 	}
 	else if (r + d->offset < (ssize_t)d->file_size) {
-		debug_ip ("partially write data, retry");
+		debug_ip("partially write data, retry");
 		/* Wait for other event */
 		event_del (d->ev);
 		event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
@@ -126,33 +118,30 @@ sendfile_callback (rspamd_io_dispatcher_t *d)
 	else {
 		if (d->write_callback) {
 			if (!d->write_callback (d->user_data)) {
-				debug_ip ("callback set wanna_die flag, terminating");
+				debug_ip("callback set wanna_die flag, terminating");
 				return FALSE;
 			}
 		}
 		event_del (d->ev);
-		event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb,
-			(void *)d);
+		event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb, (void *)d);
 		event_base_set (d->ev_base, d->ev);
 		event_add (d->ev, d->tv);
 		d->in_sendfile = FALSE;
 	}
 # endif
 #else
-	ssize_t r;
+	ssize_t                         r;
 	r = write (d->fd, d->map, d->file_size - d->offset);
 	if (r == -1) {
 		if (errno != EAGAIN) {
 			if (d->err_callback) {
-				err =
-					g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
-							errno));
+				err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
 				d->err_callback (err, d->user_data);
 				return FALSE;
 			}
 		}
 		else {
-			debug_ip ("partially write data, retry");
+			debug_ip("partially write data, retry");
 			/* Wait for other event */
 			event_del (d->ev);
 			event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
@@ -162,7 +151,7 @@ sendfile_callback (rspamd_io_dispatcher_t *d)
 	}
 	else if (r + d->offset < d->file_size) {
 		d->offset += r;
-		debug_ip ("partially write data, retry");
+		debug_ip("partially write data, retry");
 		/* Wait for other event */
 		event_del (d->ev);
 		event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
@@ -172,13 +161,12 @@ sendfile_callback (rspamd_io_dispatcher_t *d)
 	else {
 		if (d->write_callback) {
 			if (!d->write_callback (d->user_data)) {
-				debug_ip ("callback set wanna_die flag, terminating");
+				debug_ip("callback set wanna_die flag, terminating");
 				return FALSE;
 			}
 		}
 		event_del (d->ev);
-		event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb,
-			(void *)d);
+		event_set (d->ev, d->fd, EV_READ | EV_PERSIST, dispatcher_cb, (void *)d);
 		event_base_set (d->ev_base, d->ev);
 		event_add (d->ev, d->tv);
 		d->in_sendfile = FALSE;
@@ -189,25 +177,25 @@ sendfile_callback (rspamd_io_dispatcher_t *d)
 
 #define BUFREMAIN(x) (x)->data->size - ((x)->pos - (x)->data->begin)
 
-#define APPEND_OUT_BUFFER(d, buf) do {                  \
-		DL_APPEND ((d)->out_buffers.buffers, buf);           \
-		(d)->out_buffers.pending++;                        \
-} while (0)
-#define DELETE_OUT_BUFFER(d, buf) do {                  \
-		DL_DELETE ((d)->out_buffers.buffers, (buf));         \
-		g_string_free ((buf->data), (buf)->allocated);       \
-		g_slice_free1 (sizeof (struct rspamd_out_buffer_s), (buf)); \
-		(d)->out_buffers.pending--;                        \
-} while (0)
-
-static gboolean
+#define APPEND_OUT_BUFFER(d, buf) do {					\
+	DL_APPEND((d)->out_buffers.buffers, buf);			\
+	(d)->out_buffers.pending ++;						\
+	} while (0)
+#define DELETE_OUT_BUFFER(d, buf) do {					\
+	DL_DELETE((d)->out_buffers.buffers, (buf));			\
+	g_string_free((buf->data), (buf)->allocated);		\
+	g_slice_free1(sizeof (struct rspamd_out_buffer_s), (buf)); \
+	(d)->out_buffers.pending --;						\
+	} while (0)
+
+static                          gboolean
 write_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
 {
-	GError *err = NULL;
-	struct rspamd_out_buffer_s *cur = NULL, *tmp;
-	ssize_t r;
-	struct iovec *iov;
-	guint i, len;
+	GError                         *err = NULL;
+	struct rspamd_out_buffer_s    *cur = NULL, *tmp;
+	ssize_t                         r;
+	struct iovec                  *iov;
+	guint                           i, len;
 
 	len = d->out_buffers.pending;
 	while (len > 0) {
@@ -215,28 +203,24 @@ write_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
 		is_delayed = TRUE;
 		iov = g_slice_alloc (len * sizeof (struct iovec));
 		i = 0;
-		DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp)
-		{
+		DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp) {
 			iov[i].iov_base = cur->data->str;
 			iov[i].iov_len = cur->data->len;
-			i++;
+			i ++;
 		}
 		/* Now try to write the whole vector */
 		r = writev (fd, iov, len);
 		if (r == -1 && errno != EAGAIN) {
 			g_slice_free1 (len * sizeof (struct iovec), iov);
 			if (d->err_callback) {
-				err =
-					g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
-							errno));
+				err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
 				d->err_callback (err, d->user_data);
 				return FALSE;
 			}
 		}
 		else if (r > 0) {
 			/* Find pos inside buffers */
-			DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp)
-			{
+			DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp) {
 				if (r >= (ssize_t)cur->data->len) {
 					/* Mark this buffer as read */
 					r -= cur->data->len;
@@ -269,7 +253,7 @@ write_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
 		}
 		else if (r == -1 && errno == EAGAIN) {
 			g_slice_free1 (len * sizeof (struct iovec), iov);
-			debug_ip ("partially write data, retry");
+			debug_ip("partially write data, retry");
 			/* Wait for other event */
 			event_del (d->ev);
 			event_set (d->ev, fd, EV_WRITE, dispatcher_cb, (void *)d);
@@ -287,7 +271,7 @@ write_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
 
 		if (is_delayed && d->write_callback) {
 			if (!d->write_callback (d->user_data)) {
-				debug_ip ("callback set wanna_die flag, terminating");
+				debug_ip("callback set wanna_die flag, terminating");
 				return FALSE;
 			}
 		}
@@ -311,13 +295,13 @@ write_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
 static void
 read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 {
-	ssize_t r;
-	GError *err = NULL;
-	f_str_t res;
-	gchar *c, *b;
-	gchar *end;
-	size_t len;
-	enum io_policy saved_policy;
+	ssize_t                         r;
+	GError                         *err = NULL;
+	f_str_t                         res;
+	gchar                           *c, *b;
+	gchar                           *end;
+	size_t                          len;
+	enum io_policy                  saved_policy;
 
 	if (d->wanna_die) {
 		rspamd_remove_dispatcher (d);
@@ -325,8 +309,7 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 	}
 
 	if (d->in_buf == NULL) {
-		d->in_buf =
-			rspamd_mempool_alloc_tmp (d->pool, sizeof (rspamd_buffer_t));
+		d->in_buf = rspamd_mempool_alloc_tmp (d->pool, sizeof (rspamd_buffer_t));
 		if (d->policy == BUFFER_LINE || d->policy == BUFFER_ANY) {
 			d->in_buf->data = fstralloc_tmp (d->pool, d->default_buf_size);
 		}
@@ -352,9 +335,7 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 		r = read (fd, end, BUFREMAIN (d->in_buf));
 		if (r == -1 && errno != EAGAIN) {
 			if (d->err_callback) {
-				err =
-					g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (
-							errno));
+				err = g_error_new (G_DISPATCHER_ERROR, errno, "%s", strerror (errno));
 				d->err_callback (err, d->user_data);
 				return;
 			}
@@ -383,7 +364,7 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 			}
 		}
 		else if (r == -1 && errno == EAGAIN) {
-			debug_ip ("partially read data, retry");
+			debug_ip("partially read data, retry");
 			return;
 		}
 		else {
@@ -391,12 +372,8 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 			d->in_buf->pos += r;
 			d->in_buf->data->len += r;
 		}
-		debug_ip (
-			"read %z characters, policy is %s, watermark is: %z, buffer has %z bytes",
-			r,
-			d->policy == BUFFER_LINE ? "LINE" : "CHARACTER",
-			d->nchars,
-			d->in_buf->data->len);
+		debug_ip("read %z characters, policy is %s, watermark is: %z, buffer has %z bytes", r,
+				d->policy == BUFFER_LINE ? "LINE" : "CHARACTER", d->nchars, d->in_buf->data->len);
 	}
 
 	saved_policy = d->policy;
@@ -405,16 +382,16 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 	len = d->in_buf->data->len;
 	b = c;
 	r = 0;
-
+	
 	switch (d->policy) {
 	case BUFFER_LINE:
 		/** Variables:
-		 * b - begin of line
-		 * r - current position in buffer
-		 * *len - length of remaining buffer
-		 * c - pointer to current position (buffer->begin + r)
-		 * res - result string
-		 */
+		* b - begin of line
+		* r - current position in buffer
+		* *len - length of remaining buffer
+		* c - pointer to current position (buffer->begin + r)
+		* res - result string 
+		*/
 		while (r < (ssize_t)len) {
 			if (*c == '\n') {
 				res.begin = b;
@@ -427,7 +404,7 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 				}
 				else {
 					/* Include EOL in reply */
-					res.len++;
+					res.len ++;
 				}
 				/* Call callback for a line */
 				if (d->read_callback) {
@@ -491,8 +468,7 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 					d->in_buf->pos = d->in_buf->data->begin;
 				}
 				if (d->policy != saved_policy && (ssize_t)len != r) {
-					debug_ip (
-						"policy changed during callback, restart buffer's processing");
+					debug_ip("policy changed during callback, restart buffer's processing");
 					read_buffers (fd, d, TRUE);
 					return;
 				}
@@ -508,14 +484,13 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 			 * Actually we do not want to send zero sized
 			 * buffers to a read callback
 			 */
-			if (!(d->want_read && res.len == 0)) {
+			if (! (d->want_read && res.len == 0)) {
 				if (!d->read_callback (&res, d->user_data)) {
 					return;
 				}
 			}
 			if (d->policy != saved_policy) {
-				debug_ip (
-					"policy changed during callback, restart buffer's processing");
+				debug_ip("policy changed during callback, restart buffer's processing");
 				read_buffers (fd, d, TRUE);
 				return;
 			}
@@ -531,10 +506,10 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 static void
 dispatcher_cb (gint fd, short what, void *arg)
 {
-	rspamd_io_dispatcher_t *d = (rspamd_io_dispatcher_t *) arg;
-	GError *err = NULL;
+	rspamd_io_dispatcher_t         *d = (rspamd_io_dispatcher_t *) arg;
+	GError                         *err = NULL;
 
-	debug_ip ("in dispatcher callback, what: %d, fd: %d", (gint)what, fd);
+	debug_ip("in dispatcher callback, what: %d, fd: %d", (gint)what, fd);
 
 	if ((what & EV_TIMEOUT) != 0) {
 		if (d->err_callback) {
@@ -563,8 +538,7 @@ dispatcher_cb (gint fd, short what, void *arg)
 				else {
 					/* Want read again */
 					event_del (d->ev);
-					event_set (d->ev, fd, EV_READ | EV_PERSIST, dispatcher_cb,
-						(void *)d);
+					event_set (d->ev, fd, EV_READ | EV_PERSIST, dispatcher_cb, (void *)d);
 					event_base_set (d->ev_base, d->ev);
 					event_add (d->ev, d->tv);
 					if (d->is_restored && d->write_callback) {
@@ -584,17 +558,11 @@ dispatcher_cb (gint fd, short what, void *arg)
 }
 
 
-rspamd_io_dispatcher_t *
-rspamd_create_dispatcher (struct event_base *base,
-	gint fd,
-	enum io_policy policy,
-	dispatcher_read_callback_t read_cb,
-	dispatcher_write_callback_t write_cb,
-	dispatcher_err_callback_t err_cb,
-	struct timeval *tv,
-	void *user_data)
+rspamd_io_dispatcher_t         *
+rspamd_create_dispatcher (struct event_base *base, gint fd, enum io_policy policy,
+	dispatcher_read_callback_t read_cb, dispatcher_write_callback_t write_cb, dispatcher_err_callback_t err_cb, struct timeval *tv, void *user_data)
 {
-	rspamd_io_dispatcher_t *new;
+	rspamd_io_dispatcher_t         *new;
 
 	if (fd == -1) {
 		return NULL;
@@ -640,8 +608,7 @@ rspamd_remove_dispatcher (rspamd_io_dispatcher_t * d)
 	struct rspamd_out_buffer_s *cur, *tmp;
 
 	if (d != NULL) {
-		DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp)
-		{
+		DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp) {
 			DELETE_OUT_BUFFER (d, cur);
 		}
 		event_del (d->ev);
@@ -651,12 +618,10 @@ rspamd_remove_dispatcher (rspamd_io_dispatcher_t * d)
 }
 
 void
-rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d,
-	enum io_policy policy,
-	size_t nchars)
+rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d, enum io_policy policy, size_t nchars)
 {
-	f_str_t *tmp;
-	gint t;
+	f_str_t                        *tmp;
+	gint                            t;
 
 	if (d->policy != policy || nchars != d->nchars) {
 		d->policy = policy;
@@ -665,8 +630,7 @@ rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d,
 		if (policy == BUFFER_CHARACTER && nchars != 0) {
 			if (d->in_buf && d->in_buf->data->size < nchars) {
 				tmp = fstralloc_tmp (d->pool, d->nchars + 1);
-				memcpy (tmp->begin, d->in_buf->data->begin,
-					d->in_buf->data->len);
+				memcpy (tmp->begin, d->in_buf->data->begin, d->in_buf->data->len);
 				t = d->in_buf->pos - d->in_buf->data->begin;
 				tmp->len = d->in_buf->data->len;
 				d->in_buf->data = tmp;
@@ -676,8 +640,7 @@ rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d,
 		else if (policy == BUFFER_LINE || policy == BUFFER_ANY) {
 			if (d->in_buf && d->nchars < d->default_buf_size) {
 				tmp = fstralloc_tmp (d->pool, d->default_buf_size);
-				memcpy (tmp->begin, d->in_buf->data->begin,
-					d->in_buf->data->len);
+				memcpy (tmp->begin, d->in_buf->data->begin, d->in_buf->data->len);
 				t = d->in_buf->pos - d->in_buf->data->begin;
 				tmp->len = d->in_buf->data->len;
 				d->in_buf->data = tmp;
@@ -687,14 +650,14 @@ rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d,
 		}
 	}
 
-	debug_ip ("new input length watermark is %uz", d->nchars);
+	debug_ip("new input length watermark is %uz", d->nchars);
 }
 
 gboolean
 rspamd_dispatcher_write (rspamd_io_dispatcher_t * d,
-	const void *data, size_t len, gboolean delayed, gboolean allocated)
+		const void *data, size_t len, gboolean delayed, gboolean allocated)
 {
-	struct rspamd_out_buffer_s *newbuf;
+	struct rspamd_out_buffer_s                *newbuf;
 
 	newbuf = g_slice_alloc (sizeof (struct rspamd_out_buffer_s));
 	if (len == 0) {
@@ -717,7 +680,7 @@ rspamd_dispatcher_write (rspamd_io_dispatcher_t * d,
 	APPEND_OUT_BUFFER (d, newbuf);
 
 	if (!delayed) {
-		debug_ip ("plan write event");
+		debug_ip("plan write event");
 		return write_buffers (d->fd, d, FALSE);
 	}
 	/* Otherwise plan write event */
@@ -729,13 +692,12 @@ rspamd_dispatcher_write (rspamd_io_dispatcher_t * d,
 	return TRUE;
 }
 
-gboolean
-rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
-	GString *str,
-	gboolean delayed,
-	gboolean free_on_write)
+gboolean rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
+		GString *str,
+		gboolean delayed,
+		gboolean free_on_write)
 {
-	struct rspamd_out_buffer_s *newbuf;
+	struct rspamd_out_buffer_s                *newbuf;
 
 	newbuf = g_slice_alloc (sizeof (struct rspamd_out_buffer_s));
 	newbuf->data = str;
@@ -744,7 +706,7 @@ rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
 	APPEND_OUT_BUFFER (d, newbuf);
 
 	if (!delayed) {
-		debug_ip ("plan write event");
+		debug_ip("plan write event");
 		return write_buffers (d->fd, d, FALSE);
 	}
 	/* Otherwise plan write event */
@@ -756,7 +718,7 @@ rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
 	return TRUE;
 }
 
-gboolean
+gboolean 
 rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, gint fd, size_t len)
 {
 	if (lseek (fd, 0, SEEK_SET) == -1) {
@@ -771,12 +733,9 @@ rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, gint fd, size_t len)
 
 #ifndef HAVE_SENDFILE
 	#ifdef HAVE_MMAP_NOCORE
-	if ((d->map =
-		mmap (NULL, len, PROT_READ, MAP_SHARED | MAP_NOCORE, fd,
-		0)) == MAP_FAILED) {
+	if ((d->map = mmap (NULL, len, PROT_READ, MAP_SHARED | MAP_NOCORE, fd, 0)) == MAP_FAILED) {
 	#else
-	if ((d->map =
-		mmap (NULL, len, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+	if ((d->map = mmap (NULL, len, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 	#endif
 		msg_warn ("mmap failed: %s", strerror (errno));
 		return FALSE;
@@ -812,8 +771,7 @@ rspamd_dispacther_cleanup (rspamd_io_dispatcher_t *d)
 {
 	struct rspamd_out_buffer_s *cur, *tmp;
 
-	DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp)
-	{
+	DL_FOREACH_SAFE (d->out_buffers.buffers, cur, tmp) {
 		DELETE_OUT_BUFFER (d, cur);
 	}
 	/* Cleanup temporary data */
@@ -823,6 +781,6 @@ rspamd_dispacther_cleanup (rspamd_io_dispatcher_t *d)
 
 #undef debug_ip
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libserver/buffer.h b/src/libserver/buffer.h
index 0a4c54462..5ed42bfb3 100644
--- a/src/libserver/buffer.h
+++ b/src/libserver/buffer.h
@@ -7,8 +7,8 @@
 #define RSPAMD_BUFFER_H
 
 #include "config.h"
-#include "fstring.h"
 #include "mem_pool.h"
+#include "fstring.h"
 
 typedef gboolean (*dispatcher_read_callback_t)(f_str_t *in, void *user_data);
 typedef gboolean (*dispatcher_write_callback_t)(void *user_data);
@@ -18,17 +18,17 @@ typedef void (*dispatcher_err_callback_t)(GError *err, void *user_data);
  * Types of IO handling
  */
 enum io_policy {
-	BUFFER_LINE,                                                    /**< call handler when we have line ready */
-	BUFFER_CHARACTER,                                               /**< call handler when we have some characters */
-	BUFFER_ANY                                                      /**< call handler whenever we got data in buffer */
+	BUFFER_LINE,													/**< call handler when we have line ready */
+	BUFFER_CHARACTER,												/**< call handler when we have some characters */
+	BUFFER_ANY														/**< call handler whenever we got data in buffer */
 };
 
 /**
  * Buffer structure
  */
 typedef struct rspamd_buffer_s {
-	f_str_t *data;                                                  /**< buffer logic			*/
-	gchar *pos;                                                     /**< current position		*/
+	f_str_t *data;													/**< buffer logic			*/
+	gchar *pos;														/**< current position		*/
 } rspamd_buffer_t;
 
 struct rspamd_out_buffer_s {
@@ -38,33 +38,33 @@ struct rspamd_out_buffer_s {
 };
 
 typedef struct rspamd_io_dispatcher_s {
-	rspamd_buffer_t *in_buf;                                        /**< input buffer			*/
+	rspamd_buffer_t *in_buf;										/**< input buffer			*/
 	struct {
 		guint pending;
 		struct rspamd_out_buffer_s *buffers;
-	} out_buffers;                                                  /**< output buffers chain	*/
-	struct timeval *tv;                                             /**< io timeout				*/
-	struct event *ev;                                               /**< libevent io event		*/
-	rspamd_mempool_t *pool;                                         /**< where to store data	*/
-	enum io_policy policy;                                          /**< IO policy				*/
-	size_t nchars;                                                  /**< how many chars to read	*/
-	gint fd;                                                            /**< descriptor				*/
-	guint32 peer_addr;                                              /**< address of peer for debugging */
-	gboolean wanna_die;                                             /**< if dispatcher should be stopped */
-	dispatcher_read_callback_t read_callback;                       /**< read callback			*/
-	dispatcher_write_callback_t write_callback;                     /**< write callback			*/
-	dispatcher_err_callback_t err_callback;                         /**< error callback			*/
-	void *user_data;                                                /**< user's data for callbacks */
-	gulong default_buf_size;                                        /**< default size for buffering */
-	off_t offset;                                                   /**< for sendfile use		*/
+	} out_buffers;													/**< output buffers chain	*/
+	struct timeval *tv;												/**< io timeout				*/
+	struct event *ev;												/**< libevent io event		*/
+	rspamd_mempool_t *pool;											/**< where to store data	*/
+	enum io_policy policy;											/**< IO policy				*/
+	size_t nchars;													/**< how many chars to read	*/
+	gint fd;															/**< descriptor				*/
+	guint32 peer_addr;												/**< address of peer for debugging */
+	gboolean wanna_die;												/**< if dispatcher should be stopped */
+	dispatcher_read_callback_t read_callback;						/**< read callback			*/
+	dispatcher_write_callback_t write_callback;						/**< write callback			*/
+	dispatcher_err_callback_t err_callback;							/**< error callback			*/
+	void *user_data;												/**< user's data for callbacks */
+	gulong default_buf_size;										/**< default size for buffering */
+	off_t offset;													/**< for sendfile use		*/
 	size_t file_size;
 	gint sendfile_fd;
-	gboolean in_sendfile;                                           /**< whether buffer is in sendfile mode */
-	gboolean strip_eol;                                             /**< strip or not line ends in BUFFER_LINE policy */
-	gboolean is_restored;                                           /**< call a callback when dispatcher is restored */
-	gboolean half_closed;                                           /**< connection is half closed */
-	gboolean want_read;                                             /**< whether we want to read more data */
-	struct event_base *ev_base;                                     /**< event base for io operations */
+	gboolean in_sendfile;											/**< whether buffer is in sendfile mode */
+	gboolean strip_eol;												/**< strip or not line ends in BUFFER_LINE policy */
+	gboolean is_restored;											/**< call a callback when dispatcher is restored */
+	gboolean half_closed;											/**< connection is half closed */
+	gboolean want_read;												/**< whether we want to read more data */
+	struct event_base *ev_base;										/**< event base for io operations */
 #ifndef HAVE_SENDFILE
 	void *map;
 #endif
@@ -81,14 +81,13 @@ typedef struct rspamd_io_dispatcher_s {
  * @param user_data pointer to user's data
  * @return new dispatcher object or NULL in case of failure
  */
-rspamd_io_dispatcher_t * rspamd_create_dispatcher (struct event_base *base,
-	gint fd,
-	enum io_policy policy,
-	dispatcher_read_callback_t read_cb,
-	dispatcher_write_callback_t write_cb,
-	dispatcher_err_callback_t err_cb,
-	struct timeval *tv,
-	void *user_data);
+rspamd_io_dispatcher_t* rspamd_create_dispatcher (struct event_base *base, gint fd,
+												  enum io_policy policy,
+												  dispatcher_read_callback_t read_cb,
+												  dispatcher_write_callback_t write_cb,
+												  dispatcher_err_callback_t err_cb,
+												  struct timeval *tv,
+												  void *user_data);
 
 /**
  * Set new policy for dispatcher
@@ -96,9 +95,9 @@ rspamd_io_dispatcher_t * rspamd_create_dispatcher (struct event_base *base,
  * @param policy IO policy
  * @param nchars number of characters in buffer for character policy
  */
-void rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t *d,
-	enum io_policy policy,
-	size_t nchars);
+void rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t *d, 
+												  enum io_policy policy,
+												  size_t nchars);
 
 /**
  * Write data when it would be possible
@@ -107,9 +106,9 @@ void rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t *d,
  * @param len length of data
  */
 gboolean rspamd_dispatcher_write (rspamd_io_dispatcher_t *d,
-	const void *data,
-	size_t len, gboolean delayed,
-	gboolean allocated) G_GNUC_WARN_UNUSED_RESULT;
+												  const void *data,
+												  size_t len, gboolean delayed,
+												  gboolean allocated) G_GNUC_WARN_UNUSED_RESULT;
 
 /**
  * Write a GString to dispatcher
@@ -120,9 +119,9 @@ gboolean rspamd_dispatcher_write (rspamd_io_dispatcher_t *d,
  * @return TRUE if write has been queued successfully
  */
 gboolean rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
-	GString *str,
-	gboolean delayed,
-	gboolean free_on_write) G_GNUC_WARN_UNUSED_RESULT;
+												  GString *str,
+												  gboolean delayed,
+												  gboolean free_on_write) G_GNUC_WARN_UNUSED_RESULT;
 
 /**
  * Send specified descriptor to dispatcher
@@ -130,9 +129,7 @@ gboolean rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
  * @param fd descriptor of file
  * @param len length of data
  */
-gboolean rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d,
-	gint fd,
-	size_t len) G_GNUC_WARN_UNUSED_RESULT;
+gboolean rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, gint fd, size_t len) G_GNUC_WARN_UNUSED_RESULT;
 
 /**
  * Pause IO events on dispatcher
diff --git a/src/libserver/cfg_file.h b/src/libserver/cfg_file.h
index 6626ecf35..f502d5775 100644
--- a/src/libserver/cfg_file.h
+++ b/src/libserver/cfg_file.h
@@ -6,13 +6,13 @@
 #ifndef CFG_FILE_H
 #define CFG_FILE_H
 
-#include "cfg_rcl.h"
 #include "config.h"
 #include "mem_pool.h"
-#include "symbols_cache.h"
-#include "ucl.h"
 #include "upstream.h"
+#include "symbols_cache.h"
+#include "cfg_rcl.h"
 #include "utlist.h"
+#include "ucl.h"
 
 #define DEFAULT_BIND_PORT 11333
 #define DEFAULT_CONTROL_PORT 11334
@@ -72,22 +72,22 @@ enum rspamd_log_type {
  * Regexp structure
  */
 struct rspamd_regexp {
-	enum rspamd_regexp_type type;                   /**< regexp type										*/
-	gchar *regexp_text;                             /**< regexp text representation							*/
-	GRegex *regexp;                                 /**< glib regexp structure								*/
-	GRegex *raw_regexp;                             /**< glib regexp structure for raw matching				*/
-	gchar *header;                                  /**< header name for header regexps						*/
-	gboolean is_test;                               /**< true if this expression must be tested				*/
-	gboolean is_raw;                                /**< true if this regexp is done by raw matching		*/
-	gboolean is_strong;                             /**< true if headers search must be case sensitive		*/
+	enum rspamd_regexp_type type;					/**< regexp type										*/
+	gchar *regexp_text;								/**< regexp text representation							*/
+	GRegex *regexp;									/**< glib regexp structure								*/
+	GRegex *raw_regexp;								/**< glib regexp structure for raw matching				*/
+	gchar *header;									/**< header name for header regexps						*/
+	gboolean is_test;								/**< true if this expression must be tested				*/
+	gboolean is_raw;								/**< true if this regexp is done by raw matching		*/
+	gboolean is_strong;								/**< true if headers search must be case sensitive		*/
 };
 
 /**
  * script module list item
  */
 struct script_module {
-	gchar *name;                                    /**< name of module                                     */
-	gchar *path;                                    /**< path to module										*/
+    gchar *name;									/**< name of module                                     */
+	gchar *path;									/**< path to module										*/
 };
 
 /**
@@ -104,13 +104,13 @@ enum lua_var_type {
  * Module option
  */
 struct rspamd_module_opt {
-	gchar *param;                                   /**< parameter name										*/
-	gchar *value;                                   /**< parameter value									*/
-	gchar *description;                             /**< parameter description								*/
-	gchar *group;                                   /**< parameter group									*/
-	gpointer actual_data;                           /**< parsed data										*/
-	gboolean is_lua;                                /**< actually this is lua variable						*/
-	enum lua_var_type lua_type;                     /**< type of lua variable								*/
+	gchar *param;									/**< parameter name										*/
+	gchar *value;									/**< parameter value									*/
+	gchar *description;								/**< parameter description								*/
+	gchar *group;									/**< parameter group									*/
+	gpointer actual_data;							/**< parsed data										*/
+	gboolean is_lua;								/**< actually this is lua variable						*/
+	enum lua_var_type lua_type;						/**< type of lua variable								*/
 };
 
 /**
@@ -134,22 +134,22 @@ struct rspamd_symbols_group {
  * Statfile section definition
  */
 struct rspamd_statfile_section {
-	guint32 code;                                   /**< section's code										*/
-	guint64 size;                                   /**< size of section									*/
-	double weight;                                  /**< weight coefficient for section						*/
+	guint32 code;									/**< section's code										*/
+	guint64 size;									/**< size of section									*/
+	double weight;									/**< weight coefficient for section						*/
 };
 
 /**
  * Statfile autolearn parameters
  */
 struct statfile_autolearn_params {
-	const gchar *metric;                            /**< metric name for autolearn triggering               */
-	double threshold_min;                           /**< threshold mark										*/
-	double threshold_max;                           /**< threshold mark										*/
-	GList *symbols;                                 /**< list of symbols									*/
+	const gchar *metric;							/**< metric name for autolearn triggering 				*/
+	double threshold_min;							/**< threshold mark										*/
+	double threshold_max;							/**< threshold mark										*/
+	GList *symbols;									/**< list of symbols									*/
 };
 
-/**
+/** 
  * Sync affinity
  */
 enum sync_affinity {
@@ -168,39 +168,38 @@ struct statfile_binlog_params {
 	guint16 master_port;
 };
 
-typedef double (*statfile_normalize_func)(struct rspamd_config *cfg,
-	long double score, void *params);
+typedef double (*statfile_normalize_func)(struct rspamd_config *cfg, long double score, void *params);
 
 /**
  * Statfile config definition
  */
 struct rspamd_statfile_config {
-	gchar *symbol;                                  /**< symbol of statfile									*/
-	gchar *path;                                    /**< filesystem pattern (with %r or %f)					*/
-	gchar *label;                                   /**< label of this statfile								*/
-	gsize size;                                     /**< size of statfile									*/
-	GList *sections;                                /**< list of sections in statfile						*/
-	struct statfile_autolearn_params *autolearn;    /**< autolearn params									*/
-	struct statfile_binlog_params *binlog;          /**< binlog params										*/
-	statfile_normalize_func normalizer;             /**< function that is used as normaliser                */
-	void *normalizer_data;                          /**< normalizer function params                         */
-	gchar *normalizer_str;                          /**< source string (for dump)							*/
-	ucl_object_t *opts;                             /**< other options										*/
-	gboolean is_spam;                               /**< spam flag											*/
+	gchar *symbol;									/**< symbol of statfile									*/
+	gchar *path; 									/**< filesystem pattern (with %r or %f)					*/
+	gchar *label;									/**< label of this statfile								*/
+	gsize size;										/**< size of statfile									*/
+	GList *sections;								/**< list of sections in statfile						*/
+	struct statfile_autolearn_params *autolearn;	/**< autolearn params									*/
+	struct statfile_binlog_params *binlog;			/**< binlog params										*/
+    statfile_normalize_func normalizer;             /**< function that is used as normaliser                */
+    void *normalizer_data;                          /**< normalizer function params                         */
+	gchar *normalizer_str;							/**< source string (for dump)							*/
+	ucl_object_t *opts;								/**< other options										*/
+	gboolean is_spam;								/**< spam flag											*/
 };
 
 /**
  * Classifier config definition
  */
 struct rspamd_classifier_config {
-	GList *statfiles;                               /**< statfiles list                                     */
-	GHashTable *labels;                             /**< statfiles with labels								*/
-	gchar *metric;                                  /**< metric of this classifier                          */
-	struct classifier *classifier;                  /**< classifier interface                               */
-	struct tokenizer *tokenizer;                    /**< tokenizer used for classifier						*/
-	GHashTable *opts;                               /**< other options                                      */
-	GList *pre_callbacks;                           /**< list of callbacks that are called before classification */
-	GList *post_callbacks;                          /**< list of callbacks that are called after classification */
+    GList *statfiles;                               /**< statfiles list                                     */
+    GHashTable *labels;								/**< statfiles with labels								*/
+    gchar *metric;                                  /**< metric of this classifier                          */
+    struct classifier *classifier;                  /**< classifier interface                               */
+	struct tokenizer *tokenizer;					/**< tokenizer used for classifier						*/
+    GHashTable *opts;                               /**< other options                                      */
+	GList *pre_callbacks;							/**< list of callbacks that are called before classification */
+	GList *post_callbacks;							/**< list of callbacks that are called after classification */
 };
 
 struct rspamd_worker_bind_conf {
@@ -212,135 +211,135 @@ struct rspamd_worker_bind_conf {
 };
 
 struct rspamd_worker_param_parser {
-	rspamd_rcl_handler_t handler;                   /**< handler function									*/
-	struct rspamd_rcl_struct_parser parser;         /**< parser attributes									*/
-	const gchar *name;                              /**< parameter's name									*/
-	UT_hash_handle hh;                              /**< hash by name										*/
+	rspamd_rcl_handler_t handler;					/**< handler function									*/
+	struct rspamd_rcl_struct_parser parser;			/**< parser attributes									*/
+	const gchar *name;								/**< parameter's name									*/
+	UT_hash_handle hh;								/**< hash by name										*/
 };
 
 struct rspamd_worker_cfg_parser {
-	struct rspamd_worker_param_parser *parsers;     /**< parsers hash										*/
-	gint type;                                      /**< workers quark										*/
-	gboolean (*def_obj_parser)(const ucl_object_t *obj, gpointer ud);   /**< default object parser								*/
+	struct rspamd_worker_param_parser *parsers;		/**< parsers hash										*/
+	gint type;										/**< workers quark										*/
+	gboolean (*def_obj_parser)(const ucl_object_t *obj, gpointer ud);	/**< default object parser								*/
 	gpointer def_ud;
-	UT_hash_handle hh;                              /**< hash by type										*/
+	UT_hash_handle hh;								/**< hash by type										*/
 };
 
 /**
  * Config params for rspamd worker
  */
 struct rspamd_worker_conf {
-	worker_t *worker;                               /**< pointer to worker type								*/
-	GQuark type;                                    /**< type of worker										*/
-	struct rspamd_worker_bind_conf *bind_conf;      /**< bind configuration									*/
-	guint16 count;                                  /**< number of workers									*/
-	GList *listen_socks;                            /**< listening sockets desctiptors						*/
-	guint32 rlimit_nofile;                          /**< max files limit									*/
-	guint32 rlimit_maxcore;                         /**< maximum core file size								*/
-	GHashTable *params;                             /**< params for worker									*/
-	GQueue *active_workers;                         /**< linked list of spawned workers						*/
-	gboolean has_socket;                            /**< whether we should make listening socket in main process */
-	gpointer *ctx;                                  /**< worker's context									*/
-	ucl_object_t *options;                  /**< other worker's options								*/
+	worker_t *worker;								/**< pointer to worker type								*/
+	GQuark type;									/**< type of worker										*/
+	struct rspamd_worker_bind_conf *bind_conf;		/**< bind configuration									*/
+	guint16 count;									/**< number of workers									*/
+	GList *listen_socks;							/**< listening sockets desctiptors						*/
+	guint32 rlimit_nofile;							/**< max files limit									*/
+	guint32 rlimit_maxcore;							/**< maximum core file size								*/
+	GHashTable *params;								/**< params for worker									*/
+	GQueue *active_workers;							/**< linked list of spawned workers						*/
+	gboolean has_socket;							/**< whether we should make listening socket in main process */
+	gpointer *ctx;									/**< worker's context									*/
+	ucl_object_t *options;					/**< other worker's options								*/
 };
 
 /**
  * Structure that stores all config data
  */
 struct rspamd_config {
-	gchar *rspamd_user;                             /**< user to run as										*/
-	gchar *rspamd_group;                            /**< group to run as									*/
-	rspamd_mempool_t *cfg_pool;                     /**< memory pool for config								*/
-	gchar *cfg_name;                                /**< name of config file								*/
-	gchar *pid_file;                                /**< name of pid file									*/
-	gchar *temp_dir;                                /**< dir for temp files									*/
+	gchar *rspamd_user;								/**< user to run as										*/
+	gchar *rspamd_group;							/**< group to run as									*/
+	rspamd_mempool_t *cfg_pool;						/**< memory pool for config								*/
+	gchar *cfg_name;								/**< name of config file								*/
+	gchar *pid_file;								/**< name of pid file									*/
+	gchar *temp_dir;								/**< dir for temp files									*/
 #ifdef WITH_GPERF_TOOLS
 	gchar *profile_path;
 #endif
 
-	gboolean no_fork;                               /**< if 1 do not call daemon()							*/
-	gboolean config_test;                           /**< if TRUE do only config file test					*/
-	gboolean raw_mode;                              /**< work in raw mode instead of utf one				*/
-	gboolean one_shot_mode;                         /**< rules add only one symbol							*/
-	gboolean check_text_attachements;               /**< check text attachements as text					*/
-	gboolean convert_config;                        /**< convert config to XML format						*/
-	gboolean strict_protocol_headers;               /**< strictly check protocol headers					*/
-
-	gsize max_diff;                                 /**< maximum diff size for text parts					*/
-
-	enum rspamd_log_type log_type;                  /**< log type											*/
-	gint log_facility;                              /**< log facility in case of syslog						*/
-	gint log_level;                                 /**< log level trigger									*/
-	gchar *log_file;                                /**< path to logfile in case of file logging			*/
-	gboolean log_buffered;                          /**< whether logging is buffered						*/
-	guint32 log_buf_size;                           /**< length of log buffer								*/
-	gchar *debug_ip_map;                            /**< turn on debugging for specified ip addresses       */
-	gboolean log_urls;                              /**< whether we should log URLs                         */
-	GList *debug_symbols;                           /**< symbols to debug									*/
-	gboolean log_color;                             /**< output colors for console output                   */
-	gboolean log_extended;                          /**< log extended information							*/
-
-	guint32 statfile_sync_interval;                 /**< synchronization interval							*/
-	guint32 statfile_sync_timeout;                  /**< synchronization timeout							*/
-	gboolean mlock_statfile_pool;                   /**< use mlock (2) for locking statfiles				*/
-
-	gboolean delivery_enable;                       /**< is delivery agent is enabled						*/
-	gchar *deliver_host;                            /**< host for mail deliviring							*/
-	struct in_addr deliver_addr;                    /**< its address										*/
-	guint16 deliver_port;                           /**< port for deliviring								*/
-	guint16 deliver_family;                         /**< socket family for delivirnig						*/
-	gchar *deliver_agent_path;                      /**< deliver to pipe instead of socket					*/
-	gboolean deliver_lmtp;                          /**< use LMTP instead of SMTP							*/
-
-	GList *script_modules;                          /**< linked list of script modules to load				*/
-
-	GList *filters;                                 /**< linked list of all filters							*/
-	GList *workers;                                 /**< linked list of all workers params					*/
-	struct rspamd_worker_cfg_parser *wrk_parsers;   /**< hash for worker config parsers, indexed by worker quarks */
-	gchar *filters_str;                             /**< string of filters									*/
-	ucl_object_t *rcl_obj;                  /**< rcl object											*/
-	GHashTable * metrics;                            /**< hash of metrics indexed by metric name				*/
-	GList * symbols_groups;                          /**< groups of symbols									*/
-	GList * metrics_list;                            /**< linked list of metrics								*/
-	GHashTable * metrics_symbols;                    /**< hash table of metrics indexed by symbol			*/
-	GHashTable * c_modules;                          /**< hash of c modules indexed by module name			*/
-	GHashTable * composite_symbols;                  /**< hash of composite symbols indexed by its name		*/
+	gboolean no_fork;								/**< if 1 do not call daemon()							*/
+	gboolean config_test;							/**< if TRUE do only config file test					*/
+	gboolean raw_mode;								/**< work in raw mode instead of utf one				*/
+	gboolean one_shot_mode;							/**< rules add only one symbol							*/
+	gboolean check_text_attachements;				/**< check text attachements as text					*/
+	gboolean convert_config;						/**< convert config to XML format						*/
+	gboolean strict_protocol_headers;				/**< strictly check protocol headers					*/
+
+	gsize max_diff;									/**< maximum diff size for text parts					*/
+
+	enum rspamd_log_type log_type;					/**< log type											*/
+	gint log_facility;								/**< log facility in case of syslog						*/
+	gint log_level;									/**< log level trigger									*/
+	gchar *log_file;								/**< path to logfile in case of file logging			*/
+	gboolean log_buffered;							/**< whether logging is buffered						*/
+	guint32 log_buf_size;							/**< length of log buffer								*/
+	gchar *debug_ip_map;						    /**< turn on debugging for specified ip addresses       */
+	gboolean log_urls;								/**< whether we should log URLs                         */
+	GList *debug_symbols;							/**< symbols to debug									*/
+	gboolean log_color; 							/**< output colors for console output 					*/
+	gboolean log_extended;							/**< log extended information							*/
+
+	guint32 statfile_sync_interval;					/**< synchronization interval							*/
+	guint32 statfile_sync_timeout;					/**< synchronization timeout							*/
+	gboolean mlock_statfile_pool;					/**< use mlock (2) for locking statfiles				*/
+
+	gboolean delivery_enable;						/**< is delivery agent is enabled						*/
+	gchar *deliver_host;							/**< host for mail deliviring							*/
+	struct in_addr deliver_addr;					/**< its address										*/
+	guint16 deliver_port;							/**< port for deliviring								*/
+	guint16 deliver_family;							/**< socket family for delivirnig						*/
+	gchar *deliver_agent_path;						/**< deliver to pipe instead of socket					*/
+	gboolean deliver_lmtp;							/**< use LMTP instead of SMTP							*/
+
+	GList *script_modules;							/**< linked list of script modules to load				*/
+
+	GList *filters;									/**< linked list of all filters							*/
+	GList *workers;									/**< linked list of all workers params					*/
+	struct rspamd_worker_cfg_parser *wrk_parsers;	/**< hash for worker config parsers, indexed by worker quarks */
+	gchar *filters_str;								/**< string of filters									*/
+	ucl_object_t *rcl_obj;					/**< rcl object											*/
+	GHashTable* metrics;							/**< hash of metrics indexed by metric name				*/
+	GList* symbols_groups;							/**< groups of symbols									*/
+	GList* metrics_list;	 						/**< linked list of metrics								*/
+	GHashTable* metrics_symbols;					/**< hash table of metrics indexed by symbol			*/
+	GHashTable* c_modules;							/**< hash of c modules indexed by module name			*/
+	GHashTable* composite_symbols;					/**< hash of composite symbols indexed by its name		*/
 	GList *classifiers;                             /**< list of all classifiers defined                    */
 	GList *statfiles;                               /**< list of all statfiles in config file order         */
 	GHashTable *classifiers_symbols;                /**< hashtable indexed by symbol name of classifiers    */
-	GHashTable * cfg_params;                         /**< all cfg params indexed by its name in this structure */
-	GList *pre_filters;                             /**< list of pre-processing lua filters					*/
-	GList *post_filters;                            /**< list of post-processing lua filters				*/
-	gchar *dynamic_conf;                            /**< path to dynamic configuration						*/
-	GList *current_dynamic_conf;                    /**< currently loaded dynamic configuration				*/
-	GHashTable * domain_settings;                    /**< settings per-domains                               */
-	GHashTable * user_settings;                      /**< settings per-user                                  */
-	gchar * domain_settings_str;                     /**< string representation of settings					*/
-	gchar * user_settings_str;
-	gint clock_res;                                 /**< resolution of clock used							*/
-
-	GList *maps;                                    /**< maps active										*/
-	rspamd_mempool_t *map_pool;                     /**< static maps pool									*/
-	gdouble map_timeout;                            /**< maps watch timeout									*/
-
-	struct symbols_cache *cache;                    /**< symbols cache object								*/
-	gchar *cache_filename;                          /**< filename of cache file								*/
-	struct metric *default_metric;                  /**< default metric										*/
-
-	gchar * checksum;                                /**< real checksum of config file						*/
-	gchar * dump_checksum;                           /**< dump checksum of config file						*/
-	gpointer lua_state;                             /**< pointer to lua state								*/
-
-	gchar * rrd_file;                                /**< rrd file to store statistics						*/
-
-	gchar * history_file;                            /**< file to save rolling history						*/
-
-	gdouble dns_timeout;                            /**< timeout in milliseconds for waiting for dns reply	*/
-	guint32 dns_retransmits;                        /**< maximum retransmits count							*/
-	guint32 dns_throttling_errors;                  /**< maximum errors for starting resolver throttling	*/
-	guint32 dns_throttling_time;                    /**< time in seconds for DNS throttling					*/
-	guint32 dns_io_per_server;                      /**< number of sockets per DNS server					*/
-	GList *nameservers;                             /**< list of nameservers or NULL to parse resolv.conf	*/
+	GHashTable* cfg_params;							/**< all cfg params indexed by its name in this structure */
+	GList *pre_filters;								/**< list of pre-processing lua filters					*/
+	GList *post_filters;							/**< list of post-processing lua filters				*/
+	gchar *dynamic_conf;							/**< path to dynamic configuration						*/
+	GList *current_dynamic_conf;					/**< currently loaded dynamic configuration				*/
+	GHashTable* domain_settings;                    /**< settings per-domains                               */
+	GHashTable* user_settings;                      /**< settings per-user                                  */
+	gchar* domain_settings_str;						/**< string representation of settings					*/
+	gchar* user_settings_str;
+	gint clock_res;									/**< resolution of clock used							*/
+
+	GList *maps;									/**< maps active										*/
+	rspamd_mempool_t *map_pool;						/**< static maps pool									*/
+	gdouble map_timeout;							/**< maps watch timeout									*/
+
+	struct symbols_cache *cache;					/**< symbols cache object								*/ 
+	gchar *cache_filename;							/**< filename of cache file								*/
+	struct metric *default_metric;					/**< default metric										*/
+	
+	gchar* checksum;								/**< real checksum of config file						*/ 
+	gchar* dump_checksum;							/**< dump checksum of config file						*/ 
+	gpointer lua_state;								/**< pointer to lua state								*/
+
+	gchar* rrd_file;								/**< rrd file to store statistics						*/
+
+	gchar* history_file;							/**< file to save rolling history						*/
+
+	gdouble dns_timeout;							/**< timeout in milliseconds for waiting for dns reply	*/
+	guint32 dns_retransmits;						/**< maximum retransmits count							*/
+	guint32 dns_throttling_errors;					/**< maximum errors for starting resolver throttling	*/
+	guint32 dns_throttling_time;					/**< time in seconds for DNS throttling					*/
+	guint32 dns_io_per_server;						/**< number of sockets per DNS server					*/
+	GList *nameservers;								/**< list of nameservers or NULL to parse resolv.conf	*/
 };
 
 
@@ -352,7 +351,7 @@ struct rspamd_config {
  * @return TRUE if string was parsed
  */
 gboolean rspamd_parse_host_port_priority (rspamd_mempool_t *pool,
-	const gchar *str, gchar **addr, guint16 *port, guint *priority);
+		const gchar *str, gchar **addr, guint16 *port, guint *priority);
 
 /**
  * Parse host:port line
@@ -361,7 +360,7 @@ gboolean rspamd_parse_host_port_priority (rspamd_mempool_t *pool,
  * @return TRUE if string was parsed
  */
 gboolean rspamd_parse_host_port (rspamd_mempool_t *pool, const gchar *str,
-	gchar **addr, guint16 *port);
+		gchar **addr, guint16 *port);
 
 /**
  * Parse host:priority line
@@ -370,7 +369,7 @@ gboolean rspamd_parse_host_port (rspamd_mempool_t *pool, const gchar *str,
  * @return TRUE if string was parsed
  */
 gboolean rspamd_parse_host_priority (rspamd_mempool_t *pool, const gchar *str,
-	gchar **addr, guint *priority);
+		gchar **addr, guint *priority);
 
 /**
  * Parse bind credits
@@ -380,7 +379,7 @@ gboolean rspamd_parse_host_priority (rspamd_mempool_t *pool, const gchar *str,
  * @return 1 if line was successfully parsed and 0 in case of error
  */
 gboolean rspamd_parse_bind_line (struct rspamd_config *cfg,
-	struct rspamd_worker_conf *cf, const gchar *str);
+		struct rspamd_worker_conf *cf, const gchar *str);
 
 /**
  * Init default values
@@ -401,9 +400,9 @@ void rspamd_config_free (struct rspamd_config *cfg);
  * @param opt_name name of option to get
  * @return module value or NULL if option does not defined
  */
-const ucl_object_t * rspamd_config_get_module_opt (struct rspamd_config *cfg,
-	const gchar *module_name,
-	const gchar *opt_name);
+const ucl_object_t* rspamd_config_get_module_opt (struct rspamd_config *cfg,
+		const gchar *module_name,
+		const gchar *opt_name);
 
 /**
  * Parse limit
@@ -441,38 +440,36 @@ void rspamd_config_unescape_quotes (gchar *line);
 /*
  * Convert comma separated string to a list of strings
  */
-GList * rspamd_config_parse_comma_list (rspamd_mempool_t *pool,
-	const gchar *line);
+GList* rspamd_config_parse_comma_list (rspamd_mempool_t *pool,
+		const gchar *line);
 
 /*
  * Return a new classifier_config structure, setting default and non-conflicting attributes
  */
-struct rspamd_classifier_config * rspamd_config_new_classifier (
-	struct rspamd_config *cfg,
-	struct rspamd_classifier_config *c);
+struct rspamd_classifier_config* rspamd_config_new_classifier (struct rspamd_config *cfg,
+		struct rspamd_classifier_config *c);
 /*
  * Return a new worker_conf structure, setting default and non-conflicting attributes
  */
-struct rspamd_worker_conf * rspamd_config_new_worker (struct rspamd_config *cfg,
-	struct rspamd_worker_conf *c);
+struct rspamd_worker_conf* rspamd_config_new_worker (struct rspamd_config *cfg,
+		struct rspamd_worker_conf *c);
 /*
  * Return a new metric structure, setting default and non-conflicting attributes
  */
-struct metric * rspamd_config_new_metric (struct rspamd_config *cfg,
-	struct metric *c);
+struct metric* rspamd_config_new_metric (struct rspamd_config *cfg,
+		struct metric *c);
 /*
  * Return a new statfile structure, setting default and non-conflicting attributes
  */
-struct rspamd_statfile_config * rspamd_config_new_statfile (
-	struct rspamd_config *cfg,
-	struct rspamd_statfile_config *c);
+struct rspamd_statfile_config* rspamd_config_new_statfile (struct rspamd_config *cfg,
+		struct rspamd_statfile_config *c);
 
 /*
  * Read XML configuration file
  */
 gboolean rspamd_config_read (struct rspamd_config *cfg,
-	const gchar *filename, const gchar *convert_to,
-	rspamd_rcl_section_fin_t logger_fin, gpointer logger_ud);
+		const gchar *filename, const gchar *convert_to,
+		rspamd_rcl_section_fin_t logger_fin, gpointer logger_ud);
 
 /*
  * Register symbols of classifiers inside metrics
@@ -487,17 +484,17 @@ gboolean rspamd_config_check_statfiles (struct rspamd_classifier_config *cf);
 /*
  * Find classifier config by name
  */
-struct rspamd_classifier_config * rspamd_config_find_classifier (
-	struct rspamd_config *cfg,
-	const gchar *name);
+struct rspamd_classifier_config* rspamd_config_find_classifier (
+		struct rspamd_config *cfg,
+		const gchar *name);
 
 /*
  * Parse input `ip_list` to radix tree `tree`. Now supports only IPv4 addresses.
  */
 gboolean rspamd_config_parse_ip_list (const gchar *ip_list,
-	radix_tree_t **tree);
+		radix_tree_t **tree);
 
 #endif /* ifdef CFG_FILE_H */
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libserver/cfg_rcl.c b/src/libserver/cfg_rcl.c
index 5021acfb2..f9524fd62 100644
--- a/src/libserver/cfg_rcl.c
+++ b/src/libserver/cfg_rcl.c
@@ -21,12 +21,12 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "cfg_rcl.h"
-#include "classifiers/classifiers.h"
-#include "expressions.h"
-#include "lua/lua_common.h"
 #include "main.h"
+#include "cfg_file.h"
+#include "lua/lua_common.h"
+#include "expressions.h"
+#include "classifiers/classifiers.h"
 #include "tokenizers/tokenizers.h"
 
 /*
@@ -34,7 +34,7 @@
  */
 static gboolean
 rspamd_rcl_logging_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err)
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *val;
 	const gchar *facility, *log_type, *log_level;
@@ -45,15 +45,11 @@ rspamd_rcl_logging_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			/* Need to get filename */
 			val = ucl_object_find_key (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) {
 			/* Need to get facility */
@@ -62,84 +58,74 @@ rspamd_rcl_logging_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			val = ucl_object_find_key (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 ) {
+						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 ) {
+						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 ) {
+						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) {
+						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 ) {
+						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) {
+						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) {
+						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) {
+						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) {
+						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) {
+						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) {
+						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) {
+						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) {
+						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;
 				}
 			}
 		}
-		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 (
-			"logging type is not specified correctly, log output to the console");
+		msg_warn ("logging type is not specified correctly, log output to the console");
 	}
 
 	/* Handle log level */
@@ -158,11 +144,7 @@ rspamd_rcl_logging_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			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;
 		}
 	}
@@ -172,7 +154,7 @@ rspamd_rcl_logging_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 
 static gboolean
 rspamd_rcl_options_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err)
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *dns;
 	struct rspamd_rcl_section *dns_section;
@@ -181,8 +163,7 @@ rspamd_rcl_options_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 
 	dns = ucl_object_find_key (obj, "dns");
 	if (dns_section != NULL && dns != NULL) {
-		if (!rspamd_rcl_section_parse_defaults (dns_section, cfg, dns, cfg,
-			err)) {
+		if (!rspamd_rcl_section_parse_defaults (dns_section, cfg, dns, cfg, err)) {
 			return FALSE;
 		}
 	}
@@ -193,8 +174,8 @@ rspamd_rcl_options_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 static gint
 rspamd_symbols_group_find_func (gconstpointer a, gconstpointer b)
 {
-	const struct rspamd_symbols_group *gr = a;
-	const gchar *uv = b;
+	const struct rspamd_symbols_group		*gr = a;
+	const gchar						*uv = b;
 
 	return g_ascii_strcasecmp (gr->name, uv);
 }
@@ -209,7 +190,7 @@ rspamd_symbols_group_find_func (gconstpointer a, gconstpointer b)
  */
 static gboolean
 rspamd_rcl_insert_symbol (struct rspamd_config *cfg, struct metric *metric,
-	const ucl_object_t *obj, gboolean is_legacy, GError **err)
+		const ucl_object_t *obj, gboolean is_legacy, GError **err)
 {
 	const gchar *group = "ungrouped", *description = NULL, *sym_name;
 	gdouble symbol_score, *score_ptr;
@@ -245,11 +226,7 @@ rspamd_rcl_insert_symbol (struct rspamd_config *cfg, struct metric *metric,
 	else if (obj->type == UCL_OBJECT) {
 		val = ucl_object_find_key (obj, "weight");
 		if (val == NULL || !ucl_object_todouble_safe (val, &symbol_score)) {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"invalid symbol score: %s",
-				sym_name);
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid symbol score: %s", sym_name);
 			return FALSE;
 		}
 		val = ucl_object_find_key (obj, "description");
@@ -262,16 +239,11 @@ rspamd_rcl_insert_symbol (struct rspamd_config *cfg, struct metric *metric,
 		}
 	}
 	else {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"invalid symbol type: %s",
-			sym_name);
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid symbol type: %s", sym_name);
 		return FALSE;
 	}
 
-	sym_def =
-		rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_symbol_def));
+	sym_def = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_symbol_def));
 	score_ptr = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (gdouble));
 
 	*score_ptr = symbol_score;
@@ -281,12 +253,9 @@ rspamd_rcl_insert_symbol (struct rspamd_config *cfg, struct metric *metric,
 
 	g_hash_table_insert (metric->symbols, sym_def->name, score_ptr);
 
-	if ((metric_list =
-		g_hash_table_lookup (cfg->metrics_symbols, sym_def->name)) == NULL) {
+	if ((metric_list = g_hash_table_lookup (cfg->metrics_symbols, sym_def->name)) == NULL) {
 		metric_list = g_list_prepend (NULL, metric);
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)g_list_free,
-			metric_list);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_list_free, metric_list);
 		g_hash_table_insert (cfg->metrics_symbols, sym_def->name, metric_list);
 	}
 	else {
@@ -297,14 +266,10 @@ rspamd_rcl_insert_symbol (struct rspamd_config *cfg, struct metric *metric,
 	}
 
 	/* Search for symbol group */
-	group_list = g_list_find_custom (cfg->symbols_groups,
-			group,
-			rspamd_symbols_group_find_func);
+	group_list = g_list_find_custom (cfg->symbols_groups, group, rspamd_symbols_group_find_func);
 	if (group_list == NULL) {
 		/* Create new group */
-		sym_group =
-			rspamd_mempool_alloc (cfg->cfg_pool,
-				sizeof (struct rspamd_symbols_group));
+		sym_group = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_symbols_group));
 		sym_group->name = rspamd_mempool_strdup (cfg->cfg_pool, group);
 		sym_group->symbols = NULL;
 		cfg->symbols_groups = g_list_prepend (cfg->symbols_groups, sym_group);
@@ -320,7 +285,7 @@ rspamd_rcl_insert_symbol (struct rspamd_config *cfg, struct metric *metric,
 
 static gboolean
 rspamd_rcl_metric_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err)
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *val, *cur;
 	const gchar *metric_name, *subject_name, *semicolon, *act_str;
@@ -349,18 +314,13 @@ rspamd_rcl_metric_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 	val = ucl_object_find_key (obj, "actions");
 	if (val != NULL) {
 		if (val->type != UCL_OBJECT) {
-			g_set_error (err, CFG_RCL_ERROR, EINVAL,
-				"actions must be an object");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "actions must be an object");
 			return FALSE;
 		}
 		while ((cur = ucl_iterate_object (val, &it, true)) != NULL) {
 			if (!check_action_str (ucl_object_key (cur), &action_value) ||
-				!ucl_object_todouble_safe (cur, &action_score)) {
-				g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"invalid action definition: %s",
-					ucl_object_key (cur));
+					!ucl_object_todouble_safe (cur, &action_score)) {
+				g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid action definition: %s", ucl_object_key (cur));
 				return FALSE;
 			}
 			action = &metric->actions[action_value];
@@ -378,8 +338,7 @@ rspamd_rcl_metric_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			have_actions = TRUE;
 		}
 		val = ucl_object_find_key (obj, "action");
-		LL_FOREACH (val, cur)
-		{
+		LL_FOREACH (val, cur) {
 			if (cur->type == UCL_STRING) {
 				act_str = ucl_object_tostring (cur);
 				semicolon = strchr (act_str, ':');
@@ -395,11 +354,7 @@ rspamd_rcl_metric_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			}
 		}
 		if (new && !have_actions) {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"metric %s has no actions",
-				metric_name);
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "metric %s has no actions", metric_name);
 			return FALSE;
 		}
 	}
@@ -411,8 +366,7 @@ rspamd_rcl_metric_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			val = val->value.ov;
 		}
 		if (val->type != UCL_OBJECT) {
-			g_set_error (err, CFG_RCL_ERROR, EINVAL,
-				"symbols must be an object");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "symbols must be an object");
 			return FALSE;
 		}
 		it = NULL;
@@ -430,25 +384,17 @@ rspamd_rcl_metric_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 				val = val->value.ov;
 			}
 			if (val->type != UCL_OBJECT) {
-				g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"symbols must be an object");
+				g_set_error (err, CFG_RCL_ERROR, EINVAL, "symbols must be an object");
 				return FALSE;
 			}
-			LL_FOREACH (val, cur)
-			{
+			LL_FOREACH (val, cur) {
 				if (!rspamd_rcl_insert_symbol (cfg, metric, cur, TRUE, err)) {
 					return FALSE;
 				}
 			}
 		}
 		else if (new) {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"metric %s has no symbols",
-				metric_name);
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "metric %s has no symbols", metric_name);
 			return FALSE;
 		}
 	}
@@ -474,7 +420,7 @@ rspamd_rcl_metric_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 
 static gboolean
 rspamd_rcl_worker_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err)
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *val, *cur;
 	ucl_object_iter_t it = NULL;
@@ -491,11 +437,7 @@ rspamd_rcl_worker_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			wrk = rspamd_config_new_worker (cfg, NULL);
 			wrk->worker = rspamd_get_worker_by_type (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;
@@ -504,11 +446,7 @@ rspamd_rcl_worker_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			}
 		}
 		else {
-			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;
 		}
 	}
@@ -522,17 +460,12 @@ rspamd_rcl_worker_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 		if (val->type == UCL_ARRAY) {
 			val = val->value.ov;
 		}
-		LL_FOREACH (val, cur)
-		{
+		LL_FOREACH (val, cur) {
 			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);
+				g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot parse bind line: %s", worker_bind);
 				return FALSE;
 			}
 		}
@@ -550,14 +483,13 @@ rspamd_rcl_worker_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 		while ((cur = ucl_iterate_object (obj, &it, true)) != NULL) {
 			HASH_FIND_STR (wparser->parsers, ucl_object_key (cur), whandler);
 			if (whandler != NULL) {
-				if (!whandler->handler (cfg, cur, &whandler->parser, section,
-					err)) {
+				if (!whandler->handler (cfg, cur, &whandler->parser, section, err)) {
 					return FALSE;
 				}
 			}
 		}
 		if (wparser->def_obj_parser != NULL) {
-			if (!wparser->def_obj_parser (obj, wparser->def_ud)) {
+			if (! wparser->def_obj_parser (obj, wparser->def_ud)) {
 				return FALSE;
 			}
 		}
@@ -571,7 +503,7 @@ rspamd_rcl_worker_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 static void
 rspamd_rcl_set_lua_globals (struct rspamd_config *cfg, lua_State *L)
 {
-	struct rspamd_config **pcfg;
+	struct rspamd_config           **pcfg;
 
 	/* First check for global variable 'config' */
 	lua_getglobal (L, "config");
@@ -610,10 +542,9 @@ rspamd_rcl_set_lua_globals (struct rspamd_config *cfg, lua_State *L)
 
 static gboolean
 rspamd_rcl_lua_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err)
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
-	const gchar *lua_src = rspamd_mempool_strdup (cfg->cfg_pool,
-			ucl_object_tostring (obj));
+	const gchar *lua_src = rspamd_mempool_strdup (cfg->cfg_pool, ucl_object_tostring (obj));
 	gchar *cur_dir, *lua_dir, *lua_file, *tmp1, *tmp2;
 	lua_State *L = cfg->lua_state;
 
@@ -626,15 +557,10 @@ rspamd_rcl_lua_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 		if (getcwd (cur_dir, PATH_MAX) != NULL && chdir (lua_dir) != -1) {
 			/* 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));
+				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 ("cannot chdir to %s: %s", cur_dir,
-						strerror (errno));;
+					msg_err ("cannot chdir to %s: %s", cur_dir, strerror (errno));;
 				}
 				g_free (cur_dir);
 				g_free (tmp1);
@@ -644,15 +570,10 @@ rspamd_rcl_lua_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 			rspamd_rcl_set_lua_globals (cfg, L);
 			/* Now do it */
 			if (lua_pcall (L, 0, LUA_MULTRET, 0) != 0) {
-				g_set_error (err,
-					CFG_RCL_ERROR,
-					EINVAL,
-					"cannot init lua file %s: %s",
-					lua_src,
-					lua_tostring (L, -1));
+				g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot init lua file %s: %s",
+						lua_src, lua_tostring (L, -1));
 				if (chdir (cur_dir) == -1) {
-					msg_err ("cannot chdir to %s: %s", cur_dir,
-						strerror (errno));;
+					msg_err ("cannot chdir to %s: %s", cur_dir, strerror (errno));;
 				}
 				g_free (cur_dir);
 				g_free (tmp1);
@@ -662,7 +583,7 @@ rspamd_rcl_lua_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 		}
 		else {
 			g_set_error (err, CFG_RCL_ERROR, ENOENT, "cannot chdir to %s: %s",
-				lua_src, strerror (errno));
+					lua_src, strerror (errno));
 			if (chdir (cur_dir) == -1) {
 				msg_err ("cannot chdir to %s: %s", cur_dir, strerror (errno));;
 			}
@@ -681,7 +602,7 @@ rspamd_rcl_lua_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 	}
 	else {
 		g_set_error (err, CFG_RCL_ERROR, ENOENT, "cannot find to %s: %s",
-			lua_src, strerror (errno));
+							lua_src, strerror (errno));
 		return FALSE;
 	}
 
@@ -689,9 +610,7 @@ rspamd_rcl_lua_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 }
 
 static gboolean
-rspamd_rcl_add_module_path (struct rspamd_config *cfg,
-	const gchar *path,
-	GError **err)
+rspamd_rcl_add_module_path (struct rspamd_config *cfg, const gchar *path, GError **err)
 {
 	struct stat st;
 	struct script_module *cur_mod;
@@ -701,12 +620,7 @@ rspamd_rcl_add_module_path (struct rspamd_config *cfg,
 	guint i;
 
 	if (stat (path, &st) == -1) {
-		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;
 	}
 
@@ -718,33 +632,23 @@ rspamd_rcl_add_module_path (struct rspamd_config *cfg,
 		snprintf (pattern, len, "%s%s", path, "*.lua");
 
 		if (glob (pattern, GLOB_DOOFFS, NULL, &globbuf) == 0) {
-			for (i = 0; i < globbuf.gl_pathc; i++) {
-				cur_mod =
-					rspamd_mempool_alloc (cfg->cfg_pool,
-						sizeof (struct script_module));
-				cur_mod->path = rspamd_mempool_strdup (cfg->cfg_pool,
-						globbuf.gl_pathv[i]);
-				cfg->script_modules = g_list_prepend (cfg->script_modules,
-						cur_mod);
+			for (i = 0; i < globbuf.gl_pathc; i ++) {
+				cur_mod = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct script_module));
+				cur_mod->path = rspamd_mempool_strdup (cfg->cfg_pool, globbuf.gl_pathv[i]);
+				cfg->script_modules = g_list_prepend (cfg->script_modules, cur_mod);
 			}
 			globfree (&globbuf);
 			g_free (pattern);
 		}
 		else {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				errno,
-				"glob failed for %s, %s",
-				pattern,
-				strerror (errno));
+			g_set_error (err, CFG_RCL_ERROR, errno, "glob failed for %s, %s", pattern, strerror (errno));
 			g_free (pattern);
 			return FALSE;
 		}
 	}
 	else {
 		/* Handle single file */
-		cur_mod =
-			rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct script_module));
+		cur_mod = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct script_module));
 		cur_mod->path = rspamd_mempool_strdup (cfg->cfg_pool, path);
 		cfg->script_modules = g_list_prepend (cfg->script_modules, cur_mod);
 	}
@@ -754,7 +658,7 @@ rspamd_rcl_add_module_path (struct rspamd_config *cfg,
 
 static gboolean
 rspamd_rcl_modules_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err)
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *val, *cur;
 	const gchar *data;
@@ -762,27 +666,21 @@ rspamd_rcl_modules_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 	if (obj->type == UCL_OBJECT) {
 		val = ucl_object_find_key (obj, "path");
 
-		LL_FOREACH (val, cur)
-		{
+		LL_FOREACH (val, cur) {
 			if (ucl_object_tostring_safe (cur, &data)) {
-				if (!rspamd_rcl_add_module_path (cfg,
-					rspamd_mempool_strdup (cfg->cfg_pool, data), err)) {
+				if (!rspamd_rcl_add_module_path (cfg, rspamd_mempool_strdup (cfg->cfg_pool, data), err)) {
 					return FALSE;
 				}
 			}
 		}
 	}
 	else if (ucl_object_tostring_safe (obj, &data)) {
-		if (!rspamd_rcl_add_module_path (cfg,
-			rspamd_mempool_strdup (cfg->cfg_pool, data), err)) {
+		if (!rspamd_rcl_add_module_path (cfg, rspamd_mempool_strdup (cfg->cfg_pool, data), 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;
 	}
 
@@ -791,7 +689,7 @@ rspamd_rcl_modules_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 
 static gboolean
 rspamd_rcl_statfile_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err)
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_classifier_config *ccf = ud;
 	const ucl_object_t *val;
@@ -805,9 +703,7 @@ rspamd_rcl_statfile_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 	val = ucl_object_find_key (obj, "binlog");
 	if (val != NULL && ucl_object_tostring_safe (val, &data)) {
 		if (st->binlog == NULL) {
-			st->binlog =
-				rspamd_mempool_alloc0 (cfg->cfg_pool,
-					sizeof (struct statfile_binlog_params));
+			st->binlog = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct statfile_binlog_params));
 		}
 		if (g_ascii_strcasecmp (data, "master") == 0) {
 			st->binlog->affinity = AFFINITY_MASTER;
@@ -825,8 +721,7 @@ rspamd_rcl_statfile_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 		}
 		val = ucl_object_find_key (obj, "binlog_master");
 		if (val != NULL && ucl_object_tostring_safe (val, &data)) {
-			if (!rspamd_parse_host_port (cfg->cfg_pool, data,
-				&st->binlog->master_addr, &st->binlog->master_port)) {
+			if (!rspamd_parse_host_port (cfg->cfg_pool, data, &st->binlog->master_addr, &st->binlog->master_port)) {
 				msg_err ("cannot parse master address: %s", data);
 				return FALSE;
 			}
@@ -842,26 +737,19 @@ rspamd_rcl_statfile_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 				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);
 		}
 		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;
 		}
 
 		if (st->path == NULL) {
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"statfile must have a path defined");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "statfile must have a path defined");
 			return FALSE;
 		}
 
@@ -869,29 +757,19 @@ rspamd_rcl_statfile_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 
 		val = ucl_object_find_key (obj, "spam");
 		if (val == NULL) {
-			msg_info (
-				"statfile %s has no explicit 'spam' setting, trying to guess by symbol",
-				st->symbol);
-			if (rspamd_strncasestr (st->symbol, "spam",
-				strlen (st->symbol)) != NULL) {
+			msg_info ("statfile %s has no explicit 'spam' setting, trying to guess by symbol", st->symbol);
+			if (rspamd_strncasestr (st->symbol, "spam", strlen (st->symbol)) != NULL) {
 				st->is_spam = TRUE;
 			}
-			else if (rspamd_strncasestr (st->symbol, "ham",
-				strlen (st->symbol)) != NULL) {
+			else if (rspamd_strncasestr (st->symbol, "ham", strlen (st->symbol)) != NULL) {
 				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 ("guessed that statfile with symbol %s is %s",
-				st->symbol,
-				st->is_spam ?
-				"spam" : "ham");
+			msg_info ("guessed that statfile with symbol %s is %s", st->symbol, st->is_spam ?
+					"spam" : "ham");
 		}
 		return TRUE;
 	}
@@ -900,11 +778,8 @@ rspamd_rcl_statfile_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
 }
 
 static gboolean
-rspamd_rcl_classifier_handler (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_classifier_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *val, *cur;
 	ucl_object_iter_t it = NULL;
@@ -916,10 +791,7 @@ rspamd_rcl_classifier_handler (struct rspamd_config *cfg,
 
 	val = ucl_object_find_key (obj, "type");
 	if (val == NULL || !ucl_object_tostring_safe (val, &type)) {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"classifier should have type defined");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "classifier should have type defined");
 		return FALSE;
 	}
 
@@ -947,31 +819,22 @@ rspamd_rcl_classifier_handler (struct rspamd_config *cfg,
 		key = ucl_object_key (val);
 		if (key != NULL) {
 			if (g_ascii_strcasecmp (key, "statfile") == 0) {
-				LL_FOREACH (val, cur)
-				{
-					res = rspamd_rcl_statfile_handler (cfg,
-							cur,
-							ccf,
-							stat_section,
-							err);
+				LL_FOREACH (val, cur) {
+					res = rspamd_rcl_statfile_handler (cfg, cur, ccf, stat_section, err);
 					if (!res) {
 						return FALSE;
 					}
 				}
 			}
-			else if (g_ascii_strcasecmp (key,
-				"type") == 0 && val->type == UCL_STRING) {
+			else if (g_ascii_strcasecmp (key, "type") == 0 && val->type == UCL_STRING) {
 				continue;
 			}
-			else if (g_ascii_strcasecmp (key,
-				"tokenizer") == 0 && val->type == UCL_STRING) {
+			else if (g_ascii_strcasecmp (key, "tokenizer") == 0 && val->type == UCL_STRING) {
 				ccf->tokenizer = get_tokenizer (ucl_object_tostring (val));
 			}
 			else {
 				/* Just insert a value of option to the hash */
-				g_hash_table_insert (ccf->opts,
-					(gpointer)key,
-					(gpointer)ucl_object_tostring_forced (val));
+				g_hash_table_insert (ccf->opts, (gpointer)key, (gpointer)ucl_object_tostring_forced (val));
 			}
 		}
 	}
@@ -985,11 +848,8 @@ rspamd_rcl_classifier_handler (struct rspamd_config *cfg,
 }
 
 static gboolean
-rspamd_rcl_composite_handler (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_composite_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	const ucl_object_t *val;
 	struct expression *expr;
@@ -999,10 +859,7 @@ rspamd_rcl_composite_handler (struct rspamd_config *cfg,
 
 	val = ucl_object_find_key (obj, "name");
 	if (val == NULL || !ucl_object_tostring_safe (val, &composite_name)) {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"composite must have a name defined");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "composite must have a name defined");
 		return FALSE;
 	}
 
@@ -1013,31 +870,19 @@ rspamd_rcl_composite_handler (struct rspamd_config *cfg,
 
 	val = ucl_object_find_key (obj, "expression");
 	if (val == NULL || !ucl_object_tostring_safe (val, &composite_expression)) {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"composite must have an expression defined");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "composite must have an expression defined");
 		return FALSE;
 	}
 
-	if ((expr =
-		parse_expression (cfg->cfg_pool,
-		(gchar *)composite_expression)) == NULL) {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"cannot parse composite expression: %s",
-			composite_expression);
+	if ((expr = parse_expression (cfg->cfg_pool, (gchar *)composite_expression)) == NULL) {
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot parse composite expression: %s", composite_expression);
 		return FALSE;
 	}
 
-	composite =
-		rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_composite));
+	composite = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct rspamd_composite));
 	composite->expr = expr;
 	composite->id = g_hash_table_size (cfg->composite_symbols) + 1;
-	g_hash_table_insert (cfg->composite_symbols,
-		(gpointer)composite_name,
-		composite);
+	g_hash_table_insert (cfg->composite_symbols, (gpointer)composite_name, composite);
 
 	if (new) {
 		register_virtual_symbol (&cfg->cache, composite_name, 1);
@@ -1052,7 +897,7 @@ rspamd_rcl_composite_handler (struct rspamd_config *cfg,
  */
 static gboolean
 rspamd_rcl_empty_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err)
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	return rspamd_rcl_section_parse_defaults (section, cfg, obj, cfg, err);
 }
@@ -1067,10 +912,10 @@ rspamd_rcl_empty_handler (struct rspamd_config *cfg, const ucl_object_t *obj,
  * @param strict_type turn on strict check for types for this section
  * @return newly created structure
  */
-static inline struct rspamd_rcl_section *
+static inline struct rspamd_rcl_section*
 rspamd_rcl_add_section (struct rspamd_rcl_section **top,
-	const gchar *name, rspamd_rcl_handler_t handler,
-	enum ucl_type type, gboolean required, gboolean strict_type)
+		const gchar *name, rspamd_rcl_handler_t handler,
+		enum ucl_type type, gboolean required, gboolean strict_type)
 {
 	struct rspamd_rcl_section *new;
 
@@ -1094,11 +939,8 @@ rspamd_rcl_add_section (struct rspamd_rcl_section **top,
  * @return newly created structure
  */
 static inline struct rspamd_rcl_default_handler_data *
-rspamd_rcl_add_default_handler (struct rspamd_rcl_section *section,
-	const gchar *name,
-	rspamd_rcl_handler_t handler,
-	gsize offset,
-	gint flags)
+rspamd_rcl_add_default_handler (struct rspamd_rcl_section *section, const gchar *name,
+		rspamd_rcl_handler_t handler, gsize offset, gint flags)
 {
 	struct rspamd_rcl_default_handler_data *new;
 
@@ -1108,12 +950,11 @@ rspamd_rcl_add_default_handler (struct rspamd_rcl_section *section,
 	new->pd.offset = offset;
 	new->pd.flags = flags;
 
-	HASH_ADD_KEYPTR (hh, section->default_parser, new->key, strlen (
-			new->key), new);
+	HASH_ADD_KEYPTR (hh, section->default_parser, new->key, strlen (new->key), new);
 	return new;
 }
 
-struct rspamd_rcl_section *
+struct rspamd_rcl_section*
 rspamd_rcl_config_init (void)
 {
 	struct rspamd_rcl_section *new = NULL, *sub, *ssub;
@@ -1122,283 +963,138 @@ rspamd_rcl_config_init (void)
 	/**
 	 * Logging section
 	 */
-	sub = rspamd_rcl_add_section (&new,
-			"logging",
-			rspamd_rcl_logging_handler,
-			UCL_OBJECT,
-			FALSE,
-			TRUE);
+	sub = rspamd_rcl_add_section (&new, "logging", rspamd_rcl_logging_handler, UCL_OBJECT,
+			FALSE, TRUE);
 	/* Default handlers */
-	rspamd_rcl_add_default_handler (sub,
-		"log_buffer",
-		rspamd_rcl_parse_struct_integer,
-		G_STRUCT_OFFSET (struct rspamd_config, log_buf_size),
-		0);
-	rspamd_rcl_add_default_handler (sub,
-		"log_urls",
-		rspamd_rcl_parse_struct_boolean,
-		G_STRUCT_OFFSET (struct rspamd_config, log_urls),
-		0);
-	rspamd_rcl_add_default_handler (sub,
-		"debug_ip",
-		rspamd_rcl_parse_struct_string,
-		G_STRUCT_OFFSET (struct rspamd_config, debug_ip_map),
-		0);
-	rspamd_rcl_add_default_handler (sub,
-		"debug_symbols",
-		rspamd_rcl_parse_struct_string_list,
-		G_STRUCT_OFFSET (struct rspamd_config, debug_symbols),
-		0);
-	rspamd_rcl_add_default_handler (sub,
-		"log_color",
-		rspamd_rcl_parse_struct_boolean,
-		G_STRUCT_OFFSET (struct rspamd_config, log_color),
-		0);
+	rspamd_rcl_add_default_handler (sub, "log_buffer", rspamd_rcl_parse_struct_integer,
+			G_STRUCT_OFFSET (struct rspamd_config, log_buf_size), 0);
+	rspamd_rcl_add_default_handler (sub, "log_urls", rspamd_rcl_parse_struct_boolean,
+			G_STRUCT_OFFSET (struct rspamd_config, log_urls), 0);
+	rspamd_rcl_add_default_handler (sub, "debug_ip", rspamd_rcl_parse_struct_string,
+			G_STRUCT_OFFSET (struct rspamd_config, debug_ip_map), 0);
+	rspamd_rcl_add_default_handler (sub, "debug_symbols", rspamd_rcl_parse_struct_string_list,
+			G_STRUCT_OFFSET (struct rspamd_config, debug_symbols), 0);
+	rspamd_rcl_add_default_handler (sub, "log_color", rspamd_rcl_parse_struct_boolean,
+			G_STRUCT_OFFSET (struct rspamd_config, log_color), 0);
 	/**
 	 * Options section
 	 */
-	sub = rspamd_rcl_add_section (&new,
-			"options",
-			rspamd_rcl_options_handler,
-			UCL_OBJECT,
-			FALSE,
-			TRUE);
-	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);
+	sub = rspamd_rcl_add_section (&new, "options", rspamd_rcl_options_handler, UCL_OBJECT,
+			FALSE, TRUE);
+	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);
 	/* Old DNS configuration */
-	rspamd_rcl_add_default_handler (sub,
-		"dns_nameserver",
-		rspamd_rcl_parse_struct_string_list,
-		G_STRUCT_OFFSET (struct rspamd_config, nameservers),
-		0);
-	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);
-	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);
-	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);
+	rspamd_rcl_add_default_handler (sub, "dns_nameserver", rspamd_rcl_parse_struct_string_list,
+			G_STRUCT_OFFSET (struct rspamd_config, nameservers), 0);
+	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);
+	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);
+	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);
 	/* New DNS configiration */
 	ssub = rspamd_rcl_add_section (&sub->subsections, "dns", NULL,
-			UCL_OBJECT, FALSE, TRUE);
-	rspamd_rcl_add_default_handler (ssub,
-		"nameserver",
-		rspamd_rcl_parse_struct_string_list,
-		G_STRUCT_OFFSET (struct rspamd_config, nameservers),
-		0);
-	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);
-	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);
-	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);
-
-	rspamd_rcl_add_default_handler (sub,
-		"raw_mode",
-		rspamd_rcl_parse_struct_boolean,
-		G_STRUCT_OFFSET (struct rspamd_config, raw_mode),
-		0);
-	rspamd_rcl_add_default_handler (sub,
-		"one_shot",
-		rspamd_rcl_parse_struct_boolean,
-		G_STRUCT_OFFSET (struct rspamd_config, one_shot_mode),
-		0);
-	rspamd_rcl_add_default_handler (sub,
-		"check_attachements",
-		rspamd_rcl_parse_struct_boolean,
-		G_STRUCT_OFFSET (struct rspamd_config, check_text_attachements),
-		0);
-	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);
-	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);
-	rspamd_rcl_add_default_handler (sub,
-		"filters",
-		rspamd_rcl_parse_struct_string,
-		G_STRUCT_OFFSET (struct rspamd_config, filters_str),
-		0);
-	rspamd_rcl_add_default_handler (sub,
-		"sync_interval",
-		rspamd_rcl_parse_struct_time,
-		G_STRUCT_OFFSET (struct rspamd_config, statfile_sync_interval),
-		RSPAMD_CL_FLAG_TIME_INTEGER);
-	rspamd_rcl_add_default_handler (sub,
-		"sync_timeout",
-		rspamd_rcl_parse_struct_time,
-		G_STRUCT_OFFSET (struct rspamd_config, statfile_sync_timeout),
-		RSPAMD_CL_FLAG_TIME_INTEGER);
-	rspamd_rcl_add_default_handler (sub,
-		"max_diff",
-		rspamd_rcl_parse_struct_integer,
-		G_STRUCT_OFFSET (struct rspamd_config, max_diff),
-		RSPAMD_CL_FLAG_INT_SIZE);
-	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);
-	rspamd_rcl_add_default_handler (sub,
-		"dynamic_conf",
-		rspamd_rcl_parse_struct_string,
-		G_STRUCT_OFFSET (struct rspamd_config, dynamic_conf),
-		0);
+				UCL_OBJECT, FALSE, TRUE);
+	rspamd_rcl_add_default_handler (ssub, "nameserver", rspamd_rcl_parse_struct_string_list,
+			G_STRUCT_OFFSET (struct rspamd_config, nameservers), 0);
+	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);
+	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);
+	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);
+
+	rspamd_rcl_add_default_handler (sub, "raw_mode", rspamd_rcl_parse_struct_boolean,
+			G_STRUCT_OFFSET (struct rspamd_config, raw_mode), 0);
+	rspamd_rcl_add_default_handler (sub, "one_shot", rspamd_rcl_parse_struct_boolean,
+			G_STRUCT_OFFSET (struct rspamd_config, one_shot_mode), 0);
+	rspamd_rcl_add_default_handler (sub, "check_attachements", rspamd_rcl_parse_struct_boolean,
+			G_STRUCT_OFFSET (struct rspamd_config, check_text_attachements), 0);
+	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);
+	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);
+	rspamd_rcl_add_default_handler (sub, "filters", rspamd_rcl_parse_struct_string,
+			G_STRUCT_OFFSET (struct rspamd_config, filters_str), 0);
+	rspamd_rcl_add_default_handler (sub, "sync_interval", rspamd_rcl_parse_struct_time,
+			G_STRUCT_OFFSET (struct rspamd_config, statfile_sync_interval), RSPAMD_CL_FLAG_TIME_INTEGER);
+	rspamd_rcl_add_default_handler (sub, "sync_timeout", rspamd_rcl_parse_struct_time,
+			G_STRUCT_OFFSET (struct rspamd_config, statfile_sync_timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
+	rspamd_rcl_add_default_handler (sub, "max_diff", rspamd_rcl_parse_struct_integer,
+			G_STRUCT_OFFSET (struct rspamd_config, max_diff), RSPAMD_CL_FLAG_INT_SIZE);
+	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);
+	rspamd_rcl_add_default_handler (sub, "dynamic_conf", rspamd_rcl_parse_struct_string,
+			G_STRUCT_OFFSET (struct rspamd_config, dynamic_conf), 0);
 	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);
-	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);
-	rspamd_rcl_add_default_handler (sub,
-		"use_mlock",
-		rspamd_rcl_parse_struct_boolean,
-		G_STRUCT_OFFSET (struct rspamd_config, mlock_statfile_pool),
-		0);
-	rspamd_rcl_add_default_handler (sub,
-		"strict_protocol_headers",
-		rspamd_rcl_parse_struct_boolean,
-		G_STRUCT_OFFSET (struct rspamd_config, strict_protocol_headers),
-		0);
+			G_STRUCT_OFFSET (struct rspamd_config, rrd_file), RSPAMD_CL_FLAG_STRING_PATH);
+	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);
+	rspamd_rcl_add_default_handler (sub, "use_mlock", rspamd_rcl_parse_struct_boolean,
+			G_STRUCT_OFFSET (struct rspamd_config, mlock_statfile_pool), 0);
+	rspamd_rcl_add_default_handler (sub, "strict_protocol_headers", rspamd_rcl_parse_struct_boolean,
+			G_STRUCT_OFFSET (struct rspamd_config, strict_protocol_headers), 0);
 
 	/**
 	 * Metric section
 	 */
-	sub = rspamd_rcl_add_section (&new,
-			"metric",
-			rspamd_rcl_metric_handler,
-			UCL_OBJECT,
-			FALSE,
-			TRUE);
+	sub = rspamd_rcl_add_section (&new, "metric", rspamd_rcl_metric_handler, UCL_OBJECT,
+			FALSE, TRUE);
 
 	/**
 	 * Worker section
 	 */
-	sub = rspamd_rcl_add_section (&new,
-			"worker",
-			rspamd_rcl_worker_handler,
-			UCL_OBJECT,
-			FALSE,
-			TRUE);
-	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);
-	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_32);
-	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_32);
+	sub = rspamd_rcl_add_section (&new, "worker", rspamd_rcl_worker_handler, UCL_OBJECT,
+			FALSE, TRUE);
+	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);
+	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_32);
+	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_32);
 
 	/**
 	 * Lua handler
 	 */
-	sub = rspamd_rcl_add_section (&new,
-			"lua",
-			rspamd_rcl_lua_handler,
-			UCL_STRING,
-			FALSE,
-			TRUE);
+	sub = rspamd_rcl_add_section (&new, "lua", rspamd_rcl_lua_handler, UCL_STRING,
+			FALSE, TRUE);
 
 	/**
 	 * Modules handler
 	 */
-	sub = rspamd_rcl_add_section (&new,
-			"modules",
-			rspamd_rcl_modules_handler,
-			UCL_OBJECT,
-			FALSE,
-			FALSE);
+	sub = rspamd_rcl_add_section (&new, "modules", rspamd_rcl_modules_handler, UCL_OBJECT,
+			FALSE, FALSE);
 
 	/**
 	 * Classifiers handler
 	 */
-	sub = rspamd_rcl_add_section (&new,
-			"classifier",
-			rspamd_rcl_classifier_handler,
-			UCL_OBJECT,
-			FALSE,
-			TRUE);
-	ssub = rspamd_rcl_add_section (&sub->subsections,
-			"statfile",
-			rspamd_rcl_statfile_handler,
-			UCL_OBJECT,
-			TRUE,
-			TRUE);
-	rspamd_rcl_add_default_handler (ssub,
-		"symbol",
-		rspamd_rcl_parse_struct_string,
-		G_STRUCT_OFFSET (struct rspamd_statfile_config, symbol),
-		0);
-	rspamd_rcl_add_default_handler (ssub,
-		"path",
-		rspamd_rcl_parse_struct_string,
-		G_STRUCT_OFFSET (struct rspamd_statfile_config, path),
-		RSPAMD_CL_FLAG_STRING_PATH);
-	rspamd_rcl_add_default_handler (ssub,
-		"label",
-		rspamd_rcl_parse_struct_string,
-		G_STRUCT_OFFSET (struct rspamd_statfile_config, label),
-		0);
-	rspamd_rcl_add_default_handler (ssub,
-		"size",
-		rspamd_rcl_parse_struct_integer,
-		G_STRUCT_OFFSET (struct rspamd_statfile_config, size),
-		RSPAMD_CL_FLAG_INT_SIZE);
-	rspamd_rcl_add_default_handler (ssub,
-		"spam",
-		rspamd_rcl_parse_struct_boolean,
-		G_STRUCT_OFFSET (struct rspamd_statfile_config, is_spam),
-		0);
+	sub = rspamd_rcl_add_section (&new, "classifier", rspamd_rcl_classifier_handler, UCL_OBJECT,
+			FALSE, TRUE);
+	ssub = rspamd_rcl_add_section (&sub->subsections, "statfile", rspamd_rcl_statfile_handler,
+			UCL_OBJECT, TRUE, TRUE);
+	rspamd_rcl_add_default_handler (ssub, "symbol", rspamd_rcl_parse_struct_string,
+			G_STRUCT_OFFSET (struct rspamd_statfile_config, symbol), 0);
+	rspamd_rcl_add_default_handler (ssub, "path", rspamd_rcl_parse_struct_string,
+			G_STRUCT_OFFSET (struct rspamd_statfile_config, path), RSPAMD_CL_FLAG_STRING_PATH);
+	rspamd_rcl_add_default_handler (ssub, "label", rspamd_rcl_parse_struct_string,
+				G_STRUCT_OFFSET (struct rspamd_statfile_config, label), 0);
+	rspamd_rcl_add_default_handler (ssub, "size", rspamd_rcl_parse_struct_integer,
+			G_STRUCT_OFFSET (struct rspamd_statfile_config, size), RSPAMD_CL_FLAG_INT_SIZE);
+	rspamd_rcl_add_default_handler (ssub, "spam", rspamd_rcl_parse_struct_boolean,
+			G_STRUCT_OFFSET (struct rspamd_statfile_config, is_spam), 0);
 
 	/**
 	 * Composites handler
 	 */
-	sub = rspamd_rcl_add_section (&new,
-			"composite",
-			rspamd_rcl_composite_handler,
-			UCL_OBJECT,
-			FALSE,
-			TRUE);
+	sub = rspamd_rcl_add_section (&new, "composite", rspamd_rcl_composite_handler, UCL_OBJECT,
+			FALSE, TRUE);
 
 	return new;
 }
 
 struct rspamd_rcl_section *
 rspamd_rcl_config_get_section (struct rspamd_rcl_section *top,
-	const char *path)
+		const char *path)
 {
 	struct rspamd_rcl_section *cur, *found;
 	char **path_components;
@@ -1413,7 +1109,7 @@ rspamd_rcl_config_get_section (struct rspamd_rcl_section *top,
 	ncomponents = g_strv_length (path_components);
 
 	cur = top;
-	for (i = 0; i < ncomponents; i++) {
+	for (i = 0; i < ncomponents; i ++) {
 		if (cur == NULL) {
 			g_strfreev (path_components);
 			return NULL;
@@ -1432,27 +1128,23 @@ rspamd_rcl_config_get_section (struct rspamd_rcl_section *top,
 
 gboolean
 rspamd_read_rcl_config (struct rspamd_rcl_section *top,
-	struct rspamd_config *cfg, const ucl_object_t *obj, GError **err)
+		struct rspamd_config *cfg, const ucl_object_t *obj, GError **err)
 {
 	const ucl_object_t *found, *cur_obj;
 	struct rspamd_rcl_section *cur, *tmp;
 
 	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) {
 		found = ucl_object_find_key (obj, cur->name);
 		if (found == NULL) {
 			if (cur->required) {
 				g_set_error (err, CFG_RCL_ERROR, ENOENT,
-					"required section %s is missing", cur->name);
+						"required section %s is missing", cur->name);
 				return FALSE;
 			}
 		}
@@ -1461,23 +1153,18 @@ rspamd_read_rcl_config (struct rspamd_rcl_section *top,
 			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);
+							"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 (!cur->handler (cfg, cur_obj, NULL, cur, err)) {
 						return FALSE;
 					}
 				}
 				else {
-					rspamd_rcl_section_parse_defaults (cur,
-						cfg,
-						cur_obj,
-						cfg,
-						err);
+					rspamd_rcl_section_parse_defaults (cur, cfg, cur_obj, cfg, err);
 				}
 			}
 		}
@@ -1491,24 +1178,19 @@ rspamd_read_rcl_config (struct rspamd_rcl_section *top,
 	return TRUE;
 }
 
-gboolean
-rspamd_rcl_section_parse_defaults (struct rspamd_rcl_section *section,
-	struct rspamd_config *cfg, const ucl_object_t *obj, gpointer ptr,
-	GError **err)
+gboolean rspamd_rcl_section_parse_defaults (struct rspamd_rcl_section *section,
+		struct rspamd_config *cfg, const ucl_object_t *obj, gpointer ptr,
+		GError **err)
 {
 	const ucl_object_t *found;
 	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");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "default configuration must be an object");
 		return FALSE;
 	}
 
-	HASH_ITER (hh, section->default_parser, cur, tmp)
-	{
+	HASH_ITER (hh, section->default_parser, cur, tmp) {
 		found = ucl_object_find_key (obj, cur->key);
 		if (found != NULL) {
 			cur->pd.user_struct = ptr;
@@ -1522,11 +1204,8 @@ rspamd_rcl_section_parse_defaults (struct rspamd_rcl_section *section,
 }
 
 gboolean
-rspamd_rcl_parse_struct_string (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_string (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	gchar **target;
@@ -1535,8 +1214,7 @@ rspamd_rcl_parse_struct_string (struct rspamd_config *cfg,
 	target = (gchar **)(((gchar *)pd->user_struct) + pd->offset);
 	switch (obj->type) {
 	case UCL_STRING:
-		*target =
-			rspamd_mempool_strdup (cfg->cfg_pool, ucl_copy_value_trash (obj));
+		*target = rspamd_mempool_strdup (cfg->cfg_pool, ucl_copy_value_trash (obj));
 		break;
 	case UCL_INT:
 		*target = rspamd_mempool_alloc (cfg->cfg_pool, num_str_len);
@@ -1551,10 +1229,7 @@ rspamd_rcl_parse_struct_string (struct rspamd_config *cfg,
 		rspamd_snprintf (*target, num_str_len, "%b", (gboolean)obj->value.iv);
 		break;
 	default:
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"cannot convert object or array to string");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert object or array to string");
 		return FALSE;
 	}
 
@@ -1562,11 +1237,8 @@ rspamd_rcl_parse_struct_string (struct rspamd_config *cfg,
 }
 
 gboolean
-rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	union {
@@ -1581,10 +1253,7 @@ rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
 	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 param to integer");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
 			return FALSE;
 		}
 		*target.i32p = val;
@@ -1592,10 +1261,7 @@ rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
 	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 param to integer");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
 			return FALSE;
 		}
 		*target.i64p = val;
@@ -1603,10 +1269,7 @@ rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
 	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 param to integer");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
 			return FALSE;
 		}
 		*target.sp = val;
@@ -1614,10 +1277,7 @@ rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
 	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 param to integer");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
 			return FALSE;
 		}
 		*target.i16p = val;
@@ -1625,10 +1285,7 @@ rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
 	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 param to integer");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to integer");
 			return FALSE;
 		}
 		*target.ip = val;
@@ -1638,11 +1295,8 @@ rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
 }
 
 gboolean
-rspamd_rcl_parse_struct_double (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_double (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	gdouble *target;
@@ -1650,10 +1304,7 @@ rspamd_rcl_parse_struct_double (struct rspamd_config *cfg,
 	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 param to double");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to double");
 		return FALSE;
 	}
 
@@ -1661,11 +1312,8 @@ rspamd_rcl_parse_struct_double (struct rspamd_config *cfg,
 }
 
 gboolean
-rspamd_rcl_parse_struct_time (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_time (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	union {
@@ -1678,22 +1326,17 @@ rspamd_rcl_parse_struct_time (struct rspamd_config *cfg,
 	gdouble val;
 
 	if (!ucl_object_todouble_safe (obj, &val)) {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"cannot convert param to double");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert param to double");
 		return FALSE;
 	}
 
 	if (pd->flags == RSPAMD_CL_FLAG_TIME_TIMEVAL) {
-		target.ptv =
-			(struct timeval *)(((gchar *)pd->user_struct) + pd->offset);
+		target.ptv = (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 = (struct timespec *)(((gchar *)pd->user_struct) + pd->offset);
 		target.pts->tv_sec = (glong)val;
 		target.pts->tv_nsec = (val - (glong)val) * 1000000000000LL;
 	}
@@ -1710,10 +1353,7 @@ rspamd_rcl_parse_struct_time (struct rspamd_config *cfg,
 		*target.pu32 = val * 1000;
 	}
 	else {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"invalid flags to parse time value");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "invalid flags to parse time value");
 		return FALSE;
 	}
 
@@ -1721,11 +1361,8 @@ rspamd_rcl_parse_struct_time (struct rspamd_config *cfg,
 }
 
 gboolean
-rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	GList **target;
@@ -1737,19 +1374,14 @@ rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg,
 	target = (GList **)(((gchar *)pd->user_struct) + pd->offset);
 
 	if (obj->type != UCL_ARRAY) {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"an array of strings is expected");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "an array of strings is expected");
 		return FALSE;
 	}
 
 	while ((cur = ucl_iterate_object (obj, &iter, true)) != NULL) {
 		switch (cur->type) {
 		case UCL_STRING:
-			val =
-				rspamd_mempool_strdup (cfg->cfg_pool,
-					ucl_copy_value_trash (cur));
+			val = rspamd_mempool_strdup (cfg->cfg_pool, ucl_copy_value_trash (cur));
 			break;
 		case UCL_INT:
 			val = rspamd_mempool_alloc (cfg->cfg_pool, num_str_len);
@@ -1764,29 +1396,21 @@ rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg,
 			rspamd_snprintf (val, num_str_len, "%b", (gboolean)cur->value.iv);
 			break;
 		default:
-			g_set_error (err,
-				CFG_RCL_ERROR,
-				EINVAL,
-				"cannot convert an object or array to string");
+			g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert an object or array to string");
 			return FALSE;
 		}
 		*target = g_list_prepend (*target, val);
 	}
 
 	/* Add a destructor */
-	rspamd_mempool_add_destructor (cfg->cfg_pool,
-		(rspamd_mempool_destruct_t)g_list_free,
-		*target);
+	rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_list_free, *target);
 
 	return TRUE;
 }
 
 gboolean
-rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err)
+rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err)
 {
 	struct rspamd_rcl_struct_parser *pd = ud;
 	gboolean *target;
@@ -1800,10 +1424,7 @@ rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg,
 		*target = obj->value.iv;
 	}
 	else {
-		g_set_error (err,
-			CFG_RCL_ERROR,
-			EINVAL,
-			"cannot convert an object to boolean");
+		g_set_error (err, CFG_RCL_ERROR, EINVAL, "cannot convert an object to boolean");
 		return FALSE;
 	}
 
@@ -1811,13 +1432,8 @@ rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg,
 }
 
 void
-rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
-	gint type,
-	const gchar *name,
-	rspamd_rcl_handler_t handler,
-	gpointer target,
-	gsize offset,
-	gint flags)
+rspamd_rcl_register_worker_option (struct rspamd_config *cfg, gint type, const gchar *name,
+		rspamd_rcl_handler_t handler, gpointer target, gsize offset, gint flags)
 {
 	struct rspamd_worker_param_parser *nhandler;
 	struct rspamd_worker_cfg_parser *nparser;
@@ -1825,24 +1441,18 @@ rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
 	HASH_FIND_INT (cfg->wrk_parsers, &type, nparser);
 	if (nparser == NULL) {
 		/* Allocate new parser for this worker */
-		nparser =
-			rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (struct rspamd_worker_cfg_parser));
+		nparser = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_cfg_parser));
 		nparser->type = type;
 		HASH_ADD_INT (cfg->wrk_parsers, type, nparser);
 	}
 
 	HASH_FIND_STR (nparser->parsers, name, nhandler);
 	if (nhandler != NULL) {
-		msg_warn (
-			"handler for parameter %s is already registered for worker type %s",
-			name,
-			g_quark_to_string (type));
+		msg_warn ("handler for parameter %s is already registered for worker type %s",
+				name, g_quark_to_string (type));
 		return;
 	}
-	nhandler =
-		rspamd_mempool_alloc0 (cfg->cfg_pool,
-			sizeof (struct rspamd_worker_param_parser));
+	nhandler = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_param_parser));
 	nhandler->name = name;
 	nhandler->parser.flags = flags;
 	nhandler->parser.offset = offset;
@@ -1854,15 +1464,13 @@ rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
 
 void
 rspamd_rcl_register_worker_parser (struct rspamd_config *cfg, gint type,
-	gboolean (*func)(ucl_object_t *, gpointer), gpointer ud)
+		gboolean (*func)(ucl_object_t *, gpointer), gpointer ud)
 {
 	struct rspamd_worker_cfg_parser *nparser;
 	HASH_FIND_INT (cfg->wrk_parsers, &type, nparser);
 	if (nparser == NULL) {
 		/* Allocate new parser for this worker */
-		nparser =
-			rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (struct rspamd_worker_cfg_parser));
+		nparser = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_cfg_parser));
 		nparser->type = type;
 		HASH_ADD_INT (cfg->wrk_parsers, type, nparser);
 	}
diff --git a/src/libserver/cfg_rcl.h b/src/libserver/cfg_rcl.h
index 6ba197be8..6db0b0d81 100644
--- a/src/libserver/cfg_rcl.h
+++ b/src/libserver/cfg_rcl.h
@@ -63,17 +63,15 @@ struct rspamd_rcl_struct_parser {
  * @param err error object
  * @return TRUE if a section has been parsed
  */
-typedef gboolean (*rspamd_rcl_handler_t) (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud, struct rspamd_rcl_section *section, GError **err);
+typedef gboolean (*rspamd_rcl_handler_t) (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err);
 
 /**
  * A handler type that is called at the end of section parsing
  * @param cfg configuration
  * @param ud user data
  */
-typedef void (*rspamd_rcl_section_fin_t)(struct rspamd_config *cfg,
-	gpointer ud);
+typedef void (*rspamd_rcl_section_fin_t)(struct rspamd_config *cfg, gpointer ud);
 
 struct rspamd_rcl_default_handler_data {
 	struct rspamd_rcl_struct_parser pd;
@@ -83,12 +81,12 @@ struct rspamd_rcl_default_handler_data {
 };
 
 struct rspamd_rcl_section {
-	const gchar *name;                  /**< name of section */
-	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 */
+	const gchar *name;					/**< name of section */
+	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 */
@@ -99,7 +97,7 @@ struct rspamd_rcl_section {
  * Init common sections known to rspamd
  * @return top section
  */
-struct rspamd_rcl_section * rspamd_rcl_config_init (void);
+struct rspamd_rcl_section* rspamd_rcl_config_init (void);
 
 /**
  * Get a section specified by path, it understand paths separated by '/' character
@@ -107,9 +105,8 @@ struct rspamd_rcl_section * rspamd_rcl_config_init (void);
  * @param path '/' divided path
  * @return
  */
-struct rspamd_rcl_section * rspamd_rcl_config_get_section (
-	struct rspamd_rcl_section *top,
-	const char *path);
+struct rspamd_rcl_section *rspamd_rcl_config_get_section (struct rspamd_rcl_section *top,
+		const char *path);
 
 /**
  * Read RCL configuration and parse it to a config file
@@ -119,7 +116,7 @@ struct rspamd_rcl_section * rspamd_rcl_config_get_section (
  * @return TRUE if an object can be parsed
  */
 gboolean rspamd_read_rcl_config (struct rspamd_rcl_section *top,
-	struct rspamd_config *cfg, const ucl_object_t *obj, GError **err);
+		struct rspamd_config *cfg, const ucl_object_t *obj, GError **err);
 
 
 /**
@@ -132,8 +129,8 @@ gboolean rspamd_read_rcl_config (struct rspamd_rcl_section *top,
  * @return TRUE if the object has been parsed
  */
 gboolean rspamd_rcl_section_parse_defaults (struct rspamd_rcl_section *section,
-	struct rspamd_config *cfg, const ucl_object_t *obj, gpointer ptr,
-	GError **err);
+		struct rspamd_config *cfg, const ucl_object_t *obj, gpointer ptr,
+		GError **err);
 /**
  * Here is a section of common handlers that accepts rcl_struct_parser
  * which itself contains a struct pointer and the offset of a member in a
@@ -149,11 +146,8 @@ gboolean rspamd_rcl_section_parse_defaults (struct rspamd_rcl_section *section,
  * @param err error pointer
  * @return TRUE if a string value has been successfully parsed
  */
-gboolean rspamd_rcl_parse_struct_string (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err);
+gboolean rspamd_rcl_parse_struct_string (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err);
 
 /**
  * Parse an integer field of a structure
@@ -164,11 +158,8 @@ gboolean rspamd_rcl_parse_struct_string (struct rspamd_config *cfg,
  * @param err error pointer
  * @return TRUE if a value has been successfully parsed
  */
-gboolean rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err);
+gboolean rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err);
 
 
 /**
@@ -180,11 +171,8 @@ gboolean rspamd_rcl_parse_struct_integer (struct rspamd_config *cfg,
  * @param err error pointer
  * @return TRUE if a value has been successfully parsed
  */
-gboolean rspamd_rcl_parse_struct_double (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err);
+gboolean rspamd_rcl_parse_struct_double (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err);
 
 /**
  * Parse a time field of a structure
@@ -195,11 +183,8 @@ gboolean rspamd_rcl_parse_struct_double (struct rspamd_config *cfg,
  * @param err error pointer
  * @return TRUE if a value has been successfully parsed
  */
-gboolean rspamd_rcl_parse_struct_time (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err);
+gboolean rspamd_rcl_parse_struct_time (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err);
 
 /**
  * Parse a string list field of a structure presented by a GList* object
@@ -210,11 +195,8 @@ gboolean rspamd_rcl_parse_struct_time (struct rspamd_config *cfg,
  * @param err error pointer
  * @return TRUE if a value has been successfully parsed
  */
-gboolean rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err);
+gboolean rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err);
 
 /**
  * Parse a boolean field of a structure
@@ -225,11 +207,8 @@ gboolean rspamd_rcl_parse_struct_string_list (struct rspamd_config *cfg,
  * @param err error pointer
  * @return TRUE if a value has been successfully parsed
  */
-gboolean rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg,
-	const ucl_object_t *obj,
-	gpointer ud,
-	struct rspamd_rcl_section *section,
-	GError **err);
+gboolean rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg, const ucl_object_t *obj,
+		gpointer ud, struct rspamd_rcl_section *section, GError **err);
 
 /**
  * Utility functions
@@ -244,13 +223,8 @@ gboolean rspamd_rcl_parse_struct_boolean (struct rspamd_config *cfg,
  * @param target opaque target structure
  * @param offset offset inside a structure
  */
-void rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
-	gint type,
-	const gchar *name,
-	rspamd_rcl_handler_t handler,
-	gpointer target,
-	gsize offset,
-	gint flags);
+void rspamd_rcl_register_worker_option (struct rspamd_config *cfg, gint type, const gchar *name,
+		rspamd_rcl_handler_t handler, gpointer target, gsize offset, gint flags);
 
 /**
  * Regiester a default parser for a worker
@@ -260,5 +234,5 @@ void rspamd_rcl_register_worker_option (struct rspamd_config *cfg,
  * @param ud userdata for handler function
  */
 void rspamd_rcl_register_worker_parser (struct rspamd_config *cfg, gint type,
-	gboolean (*func)(ucl_object_t *, gpointer), gpointer ud);
+		gboolean (*func)(ucl_object_t *, gpointer), gpointer ud);
 #endif /* CFG_RCL_H_ */
diff --git a/src/libserver/cfg_utils.c b/src/libserver/cfg_utils.c
index 15afb9945..e1652ac55 100644
--- a/src/libserver/cfg_utils.c
+++ b/src/libserver/cfg_utils.c
@@ -26,13 +26,13 @@
 #include "config.h"
 
 #include "cfg_file.h"
-#include "classifiers/classifiers.h"
-#include "dynamic_cfg.h"
+#include "main.h"
 #include "filter.h"
-#include "kvstorage_config.h"
+#include "classifiers/classifiers.h"
 #include "lua/lua_common.h"
-#include "main.h"
+#include "kvstorage_config.h"
 #include "map.h"
+#include "dynamic_cfg.h"
 
 #define DEFAULT_SCORE 10.0
 
@@ -44,22 +44,18 @@ struct rspamd_ucl_map_cbdata {
 	struct rspamd_config *cfg;
 	GString *buf;
 };
-static gchar * rspamd_ucl_read_cb (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data);
-static void rspamd_ucl_fin_cb (rspamd_mempool_t * pool,
-	struct map_cb_data *data);
+static gchar* rspamd_ucl_read_cb (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data);
+static void rspamd_ucl_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data);
 
 static gboolean
 parse_host_port_priority_strv (rspamd_mempool_t *pool, gchar **tokens,
-	gchar **addr, guint16 *port, guint *priority, guint default_port)
+		gchar **addr, guint16 *port, guint *priority, guint default_port)
 {
-	gchar *err_str, portbuf[8];
-	const gchar *cur_tok, *cur_port;
-	struct addrinfo hints, *res;
-	guint port_parsed, priority_parsed, saved_errno = errno;
-	gint r;
+	gchar                          *err_str, portbuf[8];
+	const gchar                    *cur_tok, *cur_port;
+	struct addrinfo                hints, *res;
+	guint                           port_parsed, priority_parsed, saved_errno = errno;
+	gint							r;
 	union {
 		struct sockaddr_in v4;
 		struct sockaddr_in6 v6;
@@ -94,18 +90,12 @@ parse_host_port_priority_strv (rspamd_mempool_t *pool, gchar **tokens,
 			errno = 0;
 			port_parsed = strtoul (tokens[1], &err_str, 10);
 			if (*err_str != '\0' || errno != 0) {
-				msg_warn ("cannot parse port: %s, at symbol %c, error: %s",
-					tokens[1],
-					*err_str,
-					strerror (errno));
+				msg_warn ("cannot parse port: %s, at symbol %c, error: %s", tokens[1], *err_str, strerror (errno));
 				hints.ai_flags ^= AI_NUMERICSERV;
 			}
 			else if (port_parsed > G_MAXUINT16) {
 				errno = ERANGE;
-				msg_warn ("cannot parse port: %s, error: %s",
-					tokens[1],
-					*err_str,
-					strerror (errno));
+				msg_warn ("cannot parse port: %s, error: %s", tokens[1], *err_str, strerror (errno));
 				hints.ai_flags ^= AI_NUMERICSERV;
 			}
 			else {
@@ -124,11 +114,7 @@ parse_host_port_priority_strv (rspamd_mempool_t *pool, gchar **tokens,
 				errno = 0;
 				priority_parsed = strtoul (cur_tok, &err_str, 10);
 				if (*err_str != '\0' || errno != 0) {
-					msg_warn (
-						"cannot parse priority: %s, at symbol %c, error: %s",
-						tokens[1],
-						*err_str,
-						strerror (errno));
+					msg_warn ("cannot parse priority: %s, at symbol %c, error: %s", tokens[1], *err_str, strerror (errno));
 				}
 				else {
 					*priority = priority_parsed;
@@ -145,32 +131,23 @@ parse_host_port_priority_strv (rspamd_mempool_t *pool, gchar **tokens,
 	}
 
 	if ((r = getaddrinfo (cur_tok, cur_port, &hints, &res)) == 0) {
-		memcpy (&addr_holder, res->ai_addr,
-			MIN (sizeof (addr_holder), res->ai_addrlen));
+		memcpy (&addr_holder, res->ai_addr, MIN (sizeof (addr_holder), res->ai_addrlen));
 		if (res->ai_family == AF_INET) {
 			if (pool != NULL) {
 				*addr = rspamd_mempool_alloc (pool, INET_ADDRSTRLEN + 1);
 			}
-			inet_ntop (res->ai_family,
-				&addr_holder.v4.sin_addr,
-				*addr,
-				INET_ADDRSTRLEN + 1);
+			inet_ntop (res->ai_family, &addr_holder.v4.sin_addr, *addr, INET_ADDRSTRLEN + 1);
 		}
 		else {
 			if (pool != NULL) {
 				*addr = rspamd_mempool_alloc (pool, INET6_ADDRSTRLEN + 1);
 			}
-			inet_ntop (res->ai_family,
-				&addr_holder.v6.sin6_addr,
-				*addr,
-				INET6_ADDRSTRLEN + 1);
+			inet_ntop (res->ai_family, &addr_holder.v6.sin6_addr, *addr, INET6_ADDRSTRLEN + 1);
 		}
 		freeaddrinfo (res);
 	}
 	else {
-		msg_err ("address resolution for %s failed: %s",
-			tokens[0],
-			gai_strerror (r));
+		msg_err ("address resolution for %s failed: %s", tokens[0], gai_strerror (r));
 		goto err;
 	}
 
@@ -184,14 +161,10 @@ err:
 }
 
 gboolean
-rspamd_parse_host_port_priority (rspamd_mempool_t *pool,
-	const gchar *str,
-	gchar **addr,
-	guint16 *port,
-	guint *priority)
+rspamd_parse_host_port_priority (rspamd_mempool_t *pool, const gchar *str, gchar **addr, guint16 *port, guint *priority)
 {
-	gchar **tokens;
-	gboolean ret;
+	gchar                          **tokens;
+	gboolean                         ret;
 
 	tokens = g_strsplit_set (str, ":", 0);
 	if (!tokens || !tokens[0]) {
@@ -206,27 +179,19 @@ rspamd_parse_host_port_priority (rspamd_mempool_t *pool,
 }
 
 gboolean
-rspamd_parse_host_port (rspamd_mempool_t *pool,
-	const gchar *str,
-	gchar **addr,
-	guint16 *port)
+rspamd_parse_host_port (rspamd_mempool_t *pool, const gchar *str, gchar **addr, guint16 *port)
 {
 	return rspamd_parse_host_port_priority (pool, str, addr, port, NULL);
 }
 
 gboolean
-rspamd_parse_host_priority (rspamd_mempool_t *pool,
-	const gchar *str,
-	gchar **addr,
-	guint *priority)
+rspamd_parse_host_priority (rspamd_mempool_t *pool, const gchar *str, gchar **addr, guint *priority)
 {
 	return rspamd_parse_host_port_priority (pool, str, addr, NULL, priority);
 }
 
 gboolean
-rspamd_parse_bind_line (struct rspamd_config *cfg,
-	struct rspamd_worker_conf *cf,
-	const gchar *str)
+rspamd_parse_bind_line (struct rspamd_config *cfg, struct rspamd_worker_conf *cf, const gchar *str)
 {
 	struct rspamd_worker_bind_conf *cnf;
 	gchar **tokens, *tmp, *err;
@@ -241,9 +206,7 @@ rspamd_parse_bind_line (struct rspamd_config *cfg,
 		return FALSE;
 	}
 
-	cnf =
-		rspamd_mempool_alloc0 (cfg->cfg_pool,
-			sizeof (struct rspamd_worker_bind_conf));
+	cnf = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_bind_conf));
 	cnf->bind_port = DEFAULT_BIND_PORT;
 	cnf->bind_host = rspamd_mempool_strdup (cfg->cfg_pool, str);
 	cnf->ai = AF_UNSPEC;
@@ -258,18 +221,16 @@ rspamd_parse_bind_line (struct rspamd_config *cfg,
 		tokens[0] = "*v4";
 		cnf->ai = AF_INET;
 		if ((ret = parse_host_port_priority_strv (cfg->cfg_pool, tokens,
-			&cnf->bind_host, &cnf->bind_port, NULL, DEFAULT_BIND_PORT))) {
+				&cnf->bind_host, &cnf->bind_port, NULL, DEFAULT_BIND_PORT))) {
 			LL_PREPEND (cf->bind_conf, cnf);
 		}
-		cnf =
-			rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (struct rspamd_worker_bind_conf));
+		cnf = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_bind_conf));
 		cnf->bind_port = DEFAULT_BIND_PORT;
 		cnf->bind_host = rspamd_mempool_strdup (cfg->cfg_pool, str);
 		cnf->ai = AF_INET6;
 		tokens[0] = "*v6";
 		if ((ret &= parse_host_port_priority_strv (cfg->cfg_pool, tokens,
-			&cnf->bind_host, &cnf->bind_port, NULL, DEFAULT_BIND_PORT))) {
+				&cnf->bind_host, &cnf->bind_port, NULL, DEFAULT_BIND_PORT))) {
 			LL_PREPEND (cf->bind_conf, cnf);
 		}
 		tokens[0] = tmp;
@@ -326,10 +287,8 @@ rspamd_config_defaults (struct rspamd_config *cfg)
 
 	cfg->metrics = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	cfg->c_modules = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
-	cfg->composite_symbols =
-		g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
-	cfg->classifiers_symbols = g_hash_table_new (rspamd_str_hash,
-			rspamd_str_equal);
+	cfg->composite_symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
+	cfg->classifiers_symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	cfg->cfg_params = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	cfg->metrics_symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 
@@ -342,8 +301,8 @@ rspamd_config_defaults (struct rspamd_config *cfg)
 void
 rspamd_config_free (struct rspamd_config *cfg)
 {
-	GList *cur;
-	struct rspamd_symbols_group *gr;
+	GList							*cur;
+	struct rspamd_symbols_group			*gr;
 
 	remove_all_maps (cfg);
 	ucl_obj_unref (cfg->rcl_obj);
@@ -378,10 +337,8 @@ rspamd_config_free (struct rspamd_config *cfg)
 	rspamd_mempool_delete (cfg->cfg_pool);
 }
 
-const ucl_object_t *
-rspamd_config_get_module_opt (struct rspamd_config *cfg,
-	const gchar *module_name,
-	const gchar *opt_name)
+const ucl_object_t        *
+rspamd_config_get_module_opt (struct rspamd_config *cfg, const gchar *module_name, const gchar *opt_name)
 {
 	const ucl_object_t *res = NULL, *sec;
 
@@ -396,8 +353,8 @@ rspamd_config_get_module_opt (struct rspamd_config *cfg,
 guint64
 rspamd_config_parse_limit (const gchar *limit, guint len)
 {
-	guint64 result = 0;
-	const gchar *err_str;
+	guint64                        result = 0;
+	const gchar                   *err_str;
 
 	if (!limit || *limit == '\0' || len == 0) {
 		return 0;
@@ -420,9 +377,7 @@ rspamd_config_parse_limit (const gchar *limit, guint len)
 			result *= 1073741824L;
 		}
 		else if (len > 0 && err_str - limit != (gint)len) {
-			msg_warn ("invalid limit value '%s' at position '%s'",
-				limit,
-				err_str);
+			msg_warn ("invalid limit value '%s' at position '%s'", limit, err_str);
 			result = 0;
 		}
 	}
@@ -433,8 +388,8 @@ rspamd_config_parse_limit (const gchar *limit, guint len)
 gchar
 rspamd_config_parse_flag (const gchar *str)
 {
-	guint len;
-	gchar c;
+	guint							 len;
+	gchar							 c;
 
 	if (!str || !*str) {
 		return -1;
@@ -484,16 +439,15 @@ rspamd_config_parse_flag (const gchar *str)
 }
 
 gboolean
-rspamd_config_calculate_checksum (struct rspamd_config *cfg)
+rspamd_config_calculate_checksum (struct rspamd_config *cfg) 
 {
-	gint fd;
-	void *map;
-	struct stat st;
+	gint                            fd;
+	void                           *map;
+	struct stat                     st;
 
 	/* Compute checksum for config file that should be used by xml dumper */
 	if ((fd = open (cfg->cfg_name, O_RDONLY)) == -1) {
-		msg_err (
-			"config file %s is no longer available, cannot calculate checksum");
+		msg_err ("config file %s is no longer available, cannot calculate checksum");
 		return FALSE;
 	}
 	if (stat (cfg->cfg_name, &st) == -1) {
@@ -502,40 +456,37 @@ rspamd_config_calculate_checksum (struct rspamd_config *cfg)
 	}
 
 	/* Now mmap this file to simplify reading process */
-	if ((map =
-		mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+	if ((map = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 		msg_err ("cannot mmap %s: %s", cfg->cfg_name, strerror (errno));
 		close (fd);
 		return FALSE;
 	}
 	close (fd);
-
+	
 	/* Get checksum for a file */
-	cfg->checksum = g_compute_checksum_for_string (G_CHECKSUM_MD5,
-			map,
-			st.st_size);
+	cfg->checksum = g_compute_checksum_for_string (G_CHECKSUM_MD5, map, st.st_size);
 	munmap (map, st.st_size);
-
+	
 	return TRUE;
 }
-/*
+/* 
  * Perform post load actions
  */
 void
 rspamd_config_post_load (struct rspamd_config *cfg)
 {
 #ifdef HAVE_CLOCK_GETTIME
-	struct timespec ts;
+	struct timespec                 ts;
 #endif
-	struct metric *def_metric;
+	struct metric                  *def_metric;
 
 #ifdef HAVE_CLOCK_GETTIME
 #ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
 	clock_getres (CLOCK_PROCESS_CPUTIME_ID, &ts);
 # elif defined(HAVE_CLOCK_VIRTUAL)
-	clock_getres (CLOCK_VIRTUAL,			&ts);
+	clock_getres (CLOCK_VIRTUAL, &ts);
 # else
-	clock_getres (CLOCK_REALTIME,			&ts);
+	clock_getres (CLOCK_REALTIME, &ts);
 # endif
 
 	cfg->clock_res = (gint)log10 (1000000 / ts.tv_nsec);
@@ -545,13 +496,12 @@ rspamd_config_post_load (struct rspamd_config *cfg)
 	if (cfg->clock_res > 3) {
 		cfg->clock_res = 3;
 	}
-#else
+#else 
 	/* For gettimeofday */
 	cfg->clock_res = 1;
 #endif
 
-	if ((def_metric =
-		g_hash_table_lookup (cfg->metrics, DEFAULT_METRIC)) == NULL) {
+	if ((def_metric = g_hash_table_lookup (cfg->metrics, DEFAULT_METRIC)) == NULL) {
 		def_metric = rspamd_config_new_metric (cfg, NULL);
 		def_metric->name = DEFAULT_METRIC;
 		def_metric->actions[METRIC_ACTION_REJECT].score = DEFAULT_SCORE;
@@ -570,18 +520,14 @@ rspamd_config_post_load (struct rspamd_config *cfg)
 void
 parse_err (const gchar *fmt, ...)
 {
-	va_list aq;
-	gchar logbuf[BUFSIZ], readbuf[32];
-	gint r;
+	va_list                         aq;
+	gchar                            logbuf[BUFSIZ], readbuf[32];
+	gint                            r;
 
 	va_start (aq, fmt);
 	rspamd_strlcpy (readbuf, yytext, sizeof (readbuf));
 
-	r = snprintf (logbuf,
-			sizeof (logbuf),
-			"config file parse error! line: %d, text: %s, reason: ",
-			yylineno,
-			readbuf);
+	r = snprintf (logbuf, sizeof (logbuf), "config file parse error! line: %d, text: %s, reason: ", yylineno, readbuf);
 	r += vsnprintf (logbuf + r, sizeof (logbuf) - r, fmt, aq);
 
 	va_end (aq);
@@ -591,18 +537,14 @@ parse_err (const gchar *fmt, ...)
 void
 parse_warn (const gchar *fmt, ...)
 {
-	va_list aq;
-	gchar logbuf[BUFSIZ], readbuf[32];
-	gint r;
+	va_list                         aq;
+	gchar                            logbuf[BUFSIZ], readbuf[32];
+	gint                            r;
 
 	va_start (aq, fmt);
 	rspamd_strlcpy (readbuf, yytext, sizeof (readbuf));
 
-	r = snprintf (logbuf,
-			sizeof (logbuf),
-			"config file parse warning! line: %d, text: %s, reason: ",
-			yylineno,
-			readbuf);
+	r = snprintf (logbuf, sizeof (logbuf), "config file parse warning! line: %d, text: %s, reason: ", yylineno, readbuf);
 	r += vsnprintf (logbuf + r, sizeof (logbuf) - r, fmt, aq);
 
 	va_end (aq);
@@ -613,7 +555,7 @@ parse_warn (const gchar *fmt, ...)
 void
 rspamd_config_unescape_quotes (gchar *line)
 {
-	gchar *c = line, *t;
+	gchar                           *c = line, *t;
 
 	while (*c) {
 		if (*c == '\\' && *(c + 1) == '"') {
@@ -627,12 +569,12 @@ rspamd_config_unescape_quotes (gchar *line)
 	}
 }
 
-GList *
+GList                          *
 rspamd_config_parse_comma_list (rspamd_mempool_t * pool, const gchar *line)
 {
-	GList *res = NULL;
-	const gchar *c, *p;
-	gchar *str;
+	GList                          *res = NULL;
+	const gchar                    *c, *p;
+	gchar                          *str;
 
 	c = line;
 	p = c;
@@ -643,57 +585,42 @@ rspamd_config_parse_comma_list (rspamd_mempool_t * pool, const gchar *line)
 			rspamd_strlcpy (str, c, p - c + 1);
 			res = g_list_prepend (res, str);
 			/* Skip spaces */
-			while (g_ascii_isspace (*(++p))) ;
+			while (g_ascii_isspace (*(++p)));
 			c = p;
 			continue;
 		}
 		p++;
 	}
 	if (res != NULL) {
-		rspamd_mempool_add_destructor (pool,
-			(rspamd_mempool_destruct_t) g_list_free,
-			res);
+		rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_list_free, res);
 	}
 
 	return res;
 }
 
-struct rspamd_classifier_config *
-rspamd_config_new_classifier (struct rspamd_config *cfg,
-	struct rspamd_classifier_config *c)
+struct rspamd_classifier_config       *
+rspamd_config_new_classifier (struct rspamd_config *cfg, struct rspamd_classifier_config *c)
 {
 	if (c == NULL) {
-		c =
-			rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (struct rspamd_classifier_config));
+		c = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_classifier_config));
 	}
 	if (c->opts == NULL) {
 		c->opts = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t) g_hash_table_destroy,
-			c->opts);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, c->opts);
 	}
 	if (c->labels == NULL) {
-		c->labels = g_hash_table_new_full (rspamd_str_hash,
-				rspamd_str_equal,
-				NULL,
-				(GDestroyNotify)g_list_free);
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t) g_hash_table_destroy,
-			c->labels);
+		c->labels = g_hash_table_new_full (rspamd_str_hash, rspamd_str_equal, NULL, (GDestroyNotify)g_list_free);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, c->labels);
 	}
 
 	return c;
 }
 
-struct rspamd_statfile_config *
-rspamd_config_new_statfile (struct rspamd_config *cfg,
-	struct rspamd_statfile_config *c)
+struct rspamd_statfile_config*
+rspamd_config_new_statfile (struct rspamd_config *cfg, struct rspamd_statfile_config *c)
 {
 	if (c == NULL) {
-		c =
-			rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (struct rspamd_statfile_config));
+		c = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_statfile_config));
 	}
 
 	return c;
@@ -708,36 +635,25 @@ rspamd_config_new_metric (struct rspamd_config *cfg, struct metric *c)
 		c->grow_factor = 1.0;
 		c->symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 		c->descriptions = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
-		for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
+		for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
 			c->actions[i].score = -1.0;
 		}
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t) g_hash_table_destroy,
-			c->symbols);
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t) g_hash_table_destroy,
-			c->descriptions);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, c->symbols);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, c->descriptions);
 	}
 
 	return c;
 }
 
 struct rspamd_worker_conf *
-rspamd_config_new_worker (struct rspamd_config *cfg,
-	struct rspamd_worker_conf *c)
+rspamd_config_new_worker (struct rspamd_config *cfg, struct rspamd_worker_conf *c)
 {
 	if (c == NULL) {
-		c =
-			rspamd_mempool_alloc0 (cfg->cfg_pool,
-				sizeof (struct rspamd_worker_conf));
+		c = rspamd_mempool_alloc0 (cfg->cfg_pool, sizeof (struct rspamd_worker_conf));
 		c->params = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 		c->active_workers = g_queue_new ();
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)g_hash_table_destroy,
-			c->params);
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)g_queue_free,
-			c->active_workers);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_hash_table_destroy, c->params);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_queue_free, c->active_workers);
 #ifdef HAVE_SC_NPROCESSORS_ONLN
 		c->count = sysconf (_SC_NPROCESSORS_ONLN);
 #else
@@ -746,13 +662,13 @@ rspamd_config_new_worker (struct rspamd_config *cfg,
 		c->rlimit_nofile = DEFAULT_RLIMIT_NOFILE;
 		c->rlimit_maxcore = DEFAULT_RLIMIT_MAXCORE;
 	}
-
+	
 	return c;
 }
 
 
 static bool
-rspamd_include_map_handler (const guchar *data, gsize len, void * ud)
+rspamd_include_map_handler (const guchar *data, gsize len, void* ud)
 {
 	struct rspamd_config *cfg = (struct rspamd_config *)ud;
 	struct rspamd_ucl_map_cbdata *cbdata, **pcbdata;
@@ -767,12 +683,7 @@ rspamd_include_map_handler (const guchar *data, gsize len, void * ud)
 	cbdata->cfg = cfg;
 	*pcbdata = cbdata;
 
-	return add_map (cfg,
-			   map_line,
-			   "ucl include",
-			   rspamd_ucl_read_cb,
-			   rspamd_ucl_fin_cb,
-			   (void **)pcbdata);
+	return add_map (cfg, map_line, "ucl include", rspamd_ucl_read_cb, rspamd_ucl_fin_cb, (void **)pcbdata);
 }
 
 /*
@@ -798,45 +709,32 @@ rspamd_include_map_handler (const guchar *data, gsize len, void * ud)
 static void
 rspamd_ucl_add_conf_variables (struct ucl_parser *parser)
 {
-	ucl_parser_register_variable (parser,
-										 RSPAMD_CONFDIR_MACRO,
-																RSPAMD_CONFDIR);
-	ucl_parser_register_variable (parser, RSPAMD_RUNDIR_MACRO,
-																RSPAMD_RUNDIR);
-	ucl_parser_register_variable (parser,  RSPAMD_DBDIR_MACRO,
-																RSPAMD_DBDIR);
-	ucl_parser_register_variable (parser, RSPAMD_LOGDIR_MACRO,
-																RSPAMD_LOGDIR);
-	ucl_parser_register_variable (parser,
-		RSPAMD_PLUGINSDIR_MACRO,
-																RSPAMD_PLUGINSDIR);
-	ucl_parser_register_variable (parser,  RSPAMD_WWWDIR_MACRO,
-																RSPAMD_WWWDIR);
-	ucl_parser_register_variable (parser,  RSPAMD_PREFIX_MACRO,
-																RSPAMD_PREFIX);
+	ucl_parser_register_variable (parser, RSPAMD_CONFDIR_MACRO, RSPAMD_CONFDIR);
+	ucl_parser_register_variable (parser, RSPAMD_RUNDIR_MACRO, RSPAMD_RUNDIR);
+	ucl_parser_register_variable (parser, RSPAMD_DBDIR_MACRO, RSPAMD_DBDIR);
+	ucl_parser_register_variable (parser, RSPAMD_LOGDIR_MACRO, RSPAMD_LOGDIR);
+	ucl_parser_register_variable (parser, RSPAMD_PLUGINSDIR_MACRO, RSPAMD_PLUGINSDIR);
+	ucl_parser_register_variable (parser, RSPAMD_WWWDIR_MACRO, RSPAMD_WWWDIR);
+	ucl_parser_register_variable (parser, RSPAMD_PREFIX_MACRO, RSPAMD_PREFIX);
 	ucl_parser_register_variable (parser, RSPAMD_VERSION_MACRO, RVERSION);
 }
 
 static void
-rspamd_ucl_add_conf_macros (struct ucl_parser *parser,
-	struct rspamd_config *cfg)
+rspamd_ucl_add_conf_macros (struct ucl_parser *parser, struct rspamd_config *cfg)
 {
-	ucl_parser_register_macro (parser,
-		"include_map",
-		rspamd_include_map_handler,
-		cfg);
+	ucl_parser_register_macro (parser, "include_map", rspamd_include_map_handler, cfg);
 }
 
 gboolean
 rspamd_config_read (struct rspamd_config *cfg, const gchar *filename,
-	const gchar *convert_to, rspamd_rcl_section_fin_t logger_fin,
-	gpointer logger_ud)
+		const gchar *convert_to, rspamd_rcl_section_fin_t logger_fin,
+		gpointer logger_ud)
 {
-	struct stat st;
-	gint fd;
-	gchar *data;
-	GError *err = NULL;
-	struct rspamd_rcl_section *top, *logger;
+	struct stat                     st;
+	gint                            fd;
+	gchar                          *data;
+	GError                         *err = NULL;
+	struct rspamd_rcl_section     *top, *logger;
 	gboolean res;
 	struct ucl_parser *parser;
 
@@ -847,11 +745,10 @@ rspamd_config_read (struct rspamd_config *cfg, const gchar *filename,
 	if ((fd = open (filename, O_RDONLY)) == -1) {
 		msg_err ("cannot open %s: %s", filename, strerror (errno));
 		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) {
+	if ((data = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 		msg_err ("cannot mmap %s: %s", filename, strerror (errno));
 		close (fd);
 		return FALSE;
@@ -879,7 +776,7 @@ rspamd_config_read (struct rspamd_config *cfg, const gchar *filename,
 	top = rspamd_rcl_config_init ();
 	err = NULL;
 
-	HASH_FIND_STR (top, "logging", logger);
+	HASH_FIND_STR(top, "logging", logger);
 	if (logger != NULL) {
 		logger->fin = logger_fin;
 		logger->fin_ud = logger_ud;
@@ -896,7 +793,7 @@ rspamd_config_read (struct rspamd_config *cfg, const gchar *filename,
 static void
 symbols_classifiers_callback (gpointer key, gpointer value, gpointer ud)
 {
-	struct rspamd_config *cfg = ud;
+	struct rspamd_config             *cfg = ud;
 
 	register_virtual_symbol (&cfg->cache, key, 1.0);
 }
@@ -904,16 +801,14 @@ symbols_classifiers_callback (gpointer key, gpointer value, gpointer ud)
 void
 rspamd_config_insert_classify_symbols (struct rspamd_config *cfg)
 {
-	g_hash_table_foreach (cfg->classifiers_symbols,
-		symbols_classifiers_callback,
-		cfg);
+	g_hash_table_foreach (cfg->classifiers_symbols, symbols_classifiers_callback, cfg);
 }
 
-struct rspamd_classifier_config *
+struct rspamd_classifier_config*
 rspamd_config_find_classifier (struct rspamd_config *cfg, const gchar *name)
 {
-	GList *cur;
-	struct rspamd_classifier_config *cf;
+	GList                          *cur;
+	struct rspamd_classifier_config       *cf;
 
 	if (name == NULL) {
 		return NULL;
@@ -936,9 +831,9 @@ rspamd_config_find_classifier (struct rspamd_config *cfg, const gchar *name)
 gboolean
 rspamd_config_check_statfiles (struct rspamd_classifier_config *cf)
 {
-	struct rspamd_statfile_config *st;
-	gboolean has_other = FALSE, res = FALSE, cur_class;
-	GList *cur;
+	struct rspamd_statfile_config                *st;
+	gboolean                        has_other = FALSE, res = FALSE, cur_class;
+	GList                          *cur;
 
 	/* First check classes directly */
 	cur = cf->statfiles;
@@ -989,11 +884,8 @@ rspamd_config_check_statfiles (struct rspamd_classifier_config *cf)
 	return res;
 }
 
-static gchar *
-rspamd_ucl_read_cb (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data)
+static gchar*
+rspamd_ucl_read_cb (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
 {
 	struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev;
 
@@ -1013,8 +905,7 @@ rspamd_ucl_read_cb (rspamd_mempool_t * pool,
 static void
 rspamd_ucl_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 {
-	struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev =
-		data->prev_data;
+	struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev = data->prev_data;
 	ucl_object_t *obj;
 	struct ucl_parser *parser;
 	guint32 checksum;
@@ -1035,11 +926,8 @@ rspamd_ucl_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 	if (data->map->checksum != checksum) {
 		/* New data available */
 		parser = ucl_parser_new (0);
-		if (!ucl_parser_add_chunk (parser, cbdata->buf->str,
-			cbdata->buf->len)) {
-			msg_err ("cannot parse map %s: %s",
-				data->map->uri,
-				ucl_parser_get_error (parser));
+		if (!ucl_parser_add_chunk (parser, cbdata->buf->str, cbdata->buf->len)) {
+			msg_err ("cannot parse map %s: %s", data->map->uri, ucl_parser_get_error (parser));
 			ucl_parser_free (parser);
 		}
 		else {
@@ -1051,18 +939,16 @@ rspamd_ucl_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 		}
 	}
 	else {
-		msg_info ("do not reload map %s, checksum is the same: %d",
-			data->map->uri,
-			checksum);
+		msg_info ("do not reload map %s, checksum is the same: %d", data->map->uri, checksum);
 	}
 }
 
 gboolean
 rspamd_config_parse_ip_list (const gchar *ip_list, radix_tree_t **tree)
 {
-	gchar **strvec, **cur;
-	struct in_addr ina;
-	guint32 mask;
+	gchar                           **strvec, **cur;
+	struct in_addr                   ina;
+	guint32                           mask;
 
 	strvec = g_strsplit_set (ip_list, ",", 0);
 	cur = strvec;
@@ -1075,7 +961,7 @@ rspamd_config_parse_ip_list (const gchar *ip_list, radix_tree_t **tree)
 			}
 			radix32tree_add (*tree, htonl (ina.s_addr), mask, 1);
 		}
-		cur++;
+		cur ++;
 	}
 
 	return (*tree != NULL);
diff --git a/src/libserver/dkim.c b/src/libserver/dkim.c
index 2498b4003..abc8ddc05 100644
--- a/src/libserver/dkim.c
+++ b/src/libserver/dkim.c
@@ -22,63 +22,26 @@
  */
 
 #include "config.h"
-#include "dkim.h"
-#include "dns.h"
 #include "main.h"
 #include "message.h"
+#include "dkim.h"
+#include "dns.h"
 
 /* Parser of dkim params */
-typedef gboolean (*dkim_parse_param_f) (rspamd_dkim_context_t * ctx,
-	const gchar *param, gsize len, GError **err);
-
-static gboolean rspamd_dkim_parse_signature (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_signalg (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_domain (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_canonalg (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_ignore (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_selector (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_version (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_timestamp (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_expiration (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
-static gboolean rspamd_dkim_parse_bodylength (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err);
+typedef gboolean (*dkim_parse_param_f) (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+
+static gboolean rspamd_dkim_parse_signature (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_signalg (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_domain (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_canonalg (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_ignore (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_selector (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_version (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_timestamp (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_expiration (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
+static gboolean rspamd_dkim_parse_bodylength (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err);
 
 
 static const dkim_parse_param_f parser_funcs[] = {
@@ -112,10 +75,7 @@ dkim_error_quark (void)
 
 /* Parsers implementation */
 static gboolean
-rspamd_dkim_parse_signature (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_signature (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
 	ctx->b = rspamd_mempool_alloc (ctx->pool, len + 1);
 	rspamd_strlcpy (ctx->b, param, len + 1);
@@ -133,10 +93,7 @@ rspamd_dkim_parse_signature (rspamd_dkim_context_t * ctx,
 }
 
 static gboolean
-rspamd_dkim_parse_signalg (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_signalg (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
 	if (len == 8) {
 		if (memcmp (param, "rsa-sha1", len) == 0) {
@@ -151,18 +108,12 @@ rspamd_dkim_parse_signalg (rspamd_dkim_context_t * ctx,
 		}
 	}
 
-	g_set_error (err,
-		DKIM_ERROR,
-		DKIM_SIGERROR_INVALID_A,
-		"invalid dkim sign algorithm");
+	g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_A, "invalid dkim sign algorithm");
 	return FALSE;
 }
 
 static gboolean
-rspamd_dkim_parse_domain (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_domain (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
 	ctx->domain = rspamd_mempool_alloc (ctx->pool, len + 1);
 	rspamd_strlcpy (ctx->domain, param, len + 1);
@@ -170,13 +121,10 @@ rspamd_dkim_parse_domain (rspamd_dkim_context_t * ctx,
 }
 
 static gboolean
-rspamd_dkim_parse_canonalg (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_canonalg (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
-	const gchar *p, *slash = NULL, *end = param + len;
-	gsize sl = 0;
+	const gchar						*p, *slash = NULL, *end = param + len;
+	gsize							 sl = 0;
 
 	p = param;
 	while (p != end) {
@@ -184,8 +132,8 @@ rspamd_dkim_parse_canonalg (rspamd_dkim_context_t * ctx,
 			slash = p;
 			break;
 		}
-		p++;
-		sl++;
+		p ++;
+		sl ++;
 	}
 
 	if (slash == NULL) {
@@ -212,7 +160,7 @@ rspamd_dkim_parse_canonalg (rspamd_dkim_context_t * ctx,
 		}
 		/* Check body */
 		len -= sl + 1;
-		slash++;
+		slash ++;
 		if (len == 6 && memcmp (slash, "simple", len) == 0) {
 			ctx->body_canon_type = DKIM_CANON_SIMPLE;
 			return TRUE;
@@ -224,41 +172,32 @@ rspamd_dkim_parse_canonalg (rspamd_dkim_context_t * ctx,
 	}
 
 err:
-	g_set_error (err,
-		DKIM_ERROR,
-		DKIM_SIGERROR_INVALID_A,
-		"invalid dkim canonization algorithm");
+	g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_A, "invalid dkim canonization algorithm");
 	return FALSE;
 }
 
 static gboolean
-rspamd_dkim_parse_ignore (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_ignore (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
 	/* Just ignore unused params */
 	return TRUE;
 }
 
 static gboolean
-rspamd_dkim_parse_selector (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_selector (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
 	ctx->selector = rspamd_mempool_alloc (ctx->pool, len + 1);
 	rspamd_strlcpy (ctx->selector, param, len + 1);
 	return TRUE;
 }
 
-static struct rspamd_dkim_header *
+static struct rspamd_dkim_header*
 rspamd_dkim_find_header (GPtrArray *arr, const gchar *name, gsize len)
 {
-	guint i;
-	struct rspamd_dkim_header *h;
+	guint							 i;
+	struct rspamd_dkim_header		*h;
 
-	for (i = 0; i < arr->len; i++) {
+	for (i = 0; i < arr->len; i ++) {
 		h = g_ptr_array_index (arr, i);
 		if (g_ascii_strncasecmp (h->name, name, len) == 0) {
 			return h;
@@ -271,29 +210,26 @@ rspamd_dkim_find_header (GPtrArray *arr, const gchar *name, gsize len)
 static void
 rspamd_dkim_hlist_free (void *ud)
 {
-	GPtrArray *a = ud;
+	GPtrArray						*a = ud;
 
 	g_ptr_array_free (a, TRUE);
 }
 
 static gboolean
-rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
-	const gchar *c, *p, *end = param + len;
-	gchar *h;
-	gboolean from_found = FALSE;
-	guint count = 0;
-	struct rspamd_dkim_header *new;
+	const gchar						*c, *p, *end = param + len;
+	gchar							*h;
+	gboolean						 from_found = FALSE;
+	guint							 count = 0;
+	struct rspamd_dkim_header		*new;
 
 	p = param;
 	while (p <= end) {
 		if ((*p == ':' || p == end)) {
-			count++;
+			count ++;
 		}
-		p++;
+		p ++;
 	}
 
 	if (count > 0) {
@@ -307,15 +243,12 @@ rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t * ctx,
 	p = param;
 	while (p <= end) {
 		if ((*p == ':' || p == end) && p - c > 0) {
-			if ((new =
-				rspamd_dkim_find_header (ctx->hlist, c, p - c)) != NULL) {
-				new->count++;
+			if ((new = rspamd_dkim_find_header (ctx->hlist, c, p - c)) != NULL) {
+				new->count ++;
 			}
 			else {
 				/* Insert new header to the list */
-				new =
-					rspamd_mempool_alloc (ctx->pool,
-						sizeof (struct rspamd_dkim_header));
+				new = rspamd_mempool_alloc (ctx->pool, sizeof (struct rspamd_dkim_header));
 				h = rspamd_mempool_alloc (ctx->pool, p - c + 1);
 				rspamd_strlcpy (h, c, p - c + 1);
 				g_strstrip (h);
@@ -328,49 +261,35 @@ rspamd_dkim_parse_hdrlist (rspamd_dkim_context_t * ctx,
 				g_ptr_array_add (ctx->hlist, new);
 			}
 			c = p + 1;
-			p++;
+			p ++;
 		}
 		else {
-			p++;
+			p ++;
 		}
 	}
 
 	if (!ctx->hlist) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_INVALID_H,
-			"invalid dkim header list");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_H, "invalid dkim header list");
 		return FALSE;
 	}
 	else {
 		if (!from_found) {
 			g_ptr_array_free (ctx->hlist, TRUE);
-			g_set_error (err,
-				DKIM_ERROR,
-				DKIM_SIGERROR_INVALID_H,
-				"invalid dkim header list, from header is missing");
+			g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_H, "invalid dkim header list, from header is missing");
 			return FALSE;
 		}
 		/* Reverse list */
-		rspamd_mempool_add_destructor (ctx->pool,
-			(rspamd_mempool_destruct_t)rspamd_dkim_hlist_free,
-			ctx->hlist);
+		rspamd_mempool_add_destructor (ctx->pool, (rspamd_mempool_destruct_t)rspamd_dkim_hlist_free, ctx->hlist);
 	}
 
 	return TRUE;
 }
 
 static gboolean
-rspamd_dkim_parse_version (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_version (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
 	if (len != 1 || *param != '1') {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_VERSION,
-			"invalid dkim version");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_VERSION, "invalid dkim version");
 		return FALSE;
 	}
 
@@ -379,18 +298,12 @@ rspamd_dkim_parse_version (rspamd_dkim_context_t * ctx,
 }
 
 static gboolean
-rspamd_dkim_parse_timestamp (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_timestamp (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
-	gulong val;
+	gulong							 val;
 
 	if (!rspamd_strtoul (param, len, &val)) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_UNKNOWN,
-			"invalid dkim timestamp");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim timestamp");
 		return FALSE;
 	}
 	ctx->timestamp = val;
@@ -399,18 +312,12 @@ rspamd_dkim_parse_timestamp (rspamd_dkim_context_t * ctx,
 }
 
 static gboolean
-rspamd_dkim_parse_expiration (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_expiration (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
-	gulong val;
+	gulong							 val;
 
 	if (!rspamd_strtoul (param, len, &val)) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_UNKNOWN,
-			"invalid dkim expiration");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim expiration");
 		return FALSE;
 	}
 	ctx->expiration = val;
@@ -419,10 +326,7 @@ rspamd_dkim_parse_expiration (rspamd_dkim_context_t * ctx,
 }
 
 static gboolean
-rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
 	ctx->bh = rspamd_mempool_alloc (ctx->pool, len + 1);
 	rspamd_strlcpy (ctx->bh, param, len + 1);
@@ -440,18 +344,12 @@ rspamd_dkim_parse_bodyhash (rspamd_dkim_context_t * ctx,
 }
 
 static gboolean
-rspamd_dkim_parse_bodylength (rspamd_dkim_context_t * ctx,
-	const gchar *param,
-	gsize len,
-	GError **err)
+rspamd_dkim_parse_bodylength (rspamd_dkim_context_t* ctx, const gchar *param, gsize len, GError **err)
 {
-	gulong val;
+	gulong							 val;
 
 	if (!rspamd_strtoul (param, len, &val)) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_INVALID_L,
-			"invalid dkim body length");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_INVALID_L, "invalid dkim body length");
 		return FALSE;
 	}
 	ctx->len = val;
@@ -466,24 +364,21 @@ rspamd_dkim_parse_bodylength (rspamd_dkim_context_t * ctx,
  * @param err pointer to error object
  * @return new context or NULL
  */
-rspamd_dkim_context_t *
-rspamd_create_dkim_context (const gchar *sig,
-	rspamd_mempool_t *pool,
-	guint time_jitter,
-	GError **err)
+rspamd_dkim_context_t*
+rspamd_create_dkim_context (const gchar *sig, rspamd_mempool_t *pool, guint time_jitter, GError **err)
 {
-	const gchar *p, *c, *tag = NULL, *end;
-	gsize taglen;
-	gint param = DKIM_PARAM_UNKNOWN;
-	time_t now;
-	rspamd_dkim_context_t *new;
+	const gchar						*p, *c, *tag = NULL, *end;
+	gsize							 taglen;
+	gint							 param = DKIM_PARAM_UNKNOWN;
+	time_t							 now;
+	rspamd_dkim_context_t			*new;
 	enum {
 		DKIM_STATE_TAG = 0,
 		DKIM_STATE_AFTER_TAG,
 		DKIM_STATE_VALUE,
 		DKIM_STATE_SKIP_SPACES = 99,
 		DKIM_STATE_ERROR = 100
-	}                                state, next_state;
+	}								 state, next_state;
 
 
 	new = rspamd_mempool_alloc0 (pool, sizeof (rspamd_dkim_context_t));
@@ -505,20 +400,17 @@ rspamd_create_dkim_context (const gchar *sig,
 				taglen = p - c;
 				while (*p && g_ascii_isspace (*p)) {
 					/* Skip spaces before '=' sign */
-					p++;
+					p ++;
 				}
 				if (*p != '=') {
-					g_set_error (err,
-						DKIM_ERROR,
-						DKIM_SIGERROR_UNKNOWN,
-						"invalid dkim param");
+					g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim param");
 					state = DKIM_STATE_ERROR;
 				}
 				else {
 					state = DKIM_STATE_SKIP_SPACES;
 					next_state = DKIM_STATE_AFTER_TAG;
 					param = DKIM_PARAM_UNKNOWN;
-					p++;
+					p ++;
 					tag = c;
 				}
 			}
@@ -526,22 +418,19 @@ rspamd_create_dkim_context (const gchar *sig,
 				state = DKIM_STATE_SKIP_SPACES;
 				next_state = DKIM_STATE_AFTER_TAG;
 				param = DKIM_PARAM_UNKNOWN;
-				p++;
+				p ++;
 				tag = c;
 			}
 			else {
-				taglen++;
-				p++;
+				taglen ++;
+				p ++;
 			}
 			break;
 		case DKIM_STATE_AFTER_TAG:
 			/* We got tag at tag and len at taglen */
 			switch (taglen) {
 			case 0:
-				g_set_error (err,
-					DKIM_ERROR,
-					DKIM_SIGERROR_UNKNOWN,
-					"zero length dkim param");
+				g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "zero length dkim param");
 				state = DKIM_STATE_ERROR;
 				break;
 			case 1:
@@ -587,11 +476,7 @@ rspamd_create_dkim_context (const gchar *sig,
 					param = DKIM_PARAM_COPIEDHDRS;
 					break;
 				default:
-					g_set_error (err,
-						DKIM_ERROR,
-						DKIM_SIGERROR_UNKNOWN,
-						"invalid dkim param: %c",
-						*tag);
+					g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim param: %c", *tag);
 					state = DKIM_STATE_ERROR;
 					break;
 				}
@@ -601,21 +486,12 @@ rspamd_create_dkim_context (const gchar *sig,
 					param = DKIM_PARAM_BODYHASH;
 				}
 				else {
-					g_set_error (err,
-						DKIM_ERROR,
-						DKIM_SIGERROR_UNKNOWN,
-						"invalid dkim param: %c%c",
-						tag[0],
-						tag[1]);
+					g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim param: %c%c", tag[0], tag[1]);
 					state = DKIM_STATE_ERROR;
 				}
 				break;
 			default:
-				g_set_error (err,
-					DKIM_ERROR,
-					DKIM_SIGERROR_UNKNOWN,
-					"invalid dkim param length: %zd",
-					taglen);
+				g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_UNKNOWN, "invalid dkim param length: %zd", taglen);
 				state = DKIM_STATE_ERROR;
 				break;
 			}
@@ -627,34 +503,32 @@ rspamd_create_dkim_context (const gchar *sig,
 			break;
 		case DKIM_STATE_VALUE:
 			if (*p == ';') {
-				if (param == DKIM_PARAM_UNKNOWN ||
-					!parser_funcs[param](new, c, p - c, err)) {
+				if (param == DKIM_PARAM_UNKNOWN || !parser_funcs[param](new, c, p - c, err)) {
 					state = DKIM_STATE_ERROR;
 				}
 				else {
 					state = DKIM_STATE_SKIP_SPACES;
 					next_state = DKIM_STATE_TAG;
-					p++;
+					p ++;
 					taglen = 0;
 				}
 			}
 			else if (p == end) {
-				if (param == DKIM_PARAM_UNKNOWN ||
-					!parser_funcs[param](new, c, p - c + 1, err)) {
+				if (param == DKIM_PARAM_UNKNOWN || !parser_funcs[param](new, c, p - c + 1, err)) {
 					state = DKIM_STATE_ERROR;
 				}
 				else {
 					/* Finish processing */
-					p++;
+					p ++;
 				}
 			}
 			else {
-				p++;
+				p ++;
 			}
 			break;
 		case DKIM_STATE_SKIP_SPACES:
 			if (g_ascii_isspace (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				c = p;
@@ -676,105 +550,62 @@ rspamd_create_dkim_context (const gchar *sig,
 
 	/* Now check validity of signature */
 	if (new->b == NULL) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_EMPTY_B,
-			"b parameter missing");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_B, "b parameter missing");
 		return NULL;
 	}
 	if (new->bh == NULL) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_EMPTY_BH,
-			"bh parameter missing");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_BH, "bh parameter missing");
 		return NULL;
 	}
 	if (new->domain == NULL) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_EMPTY_D,
-			"domain parameter missing");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_D, "domain parameter missing");
 		return NULL;
 	}
 	if (new->selector == NULL) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_EMPTY_S,
-			"selector parameter missing");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_S, "selector parameter missing");
 		return NULL;
 	}
 	if (new->ver == 0) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_EMPTY_V,
-			"v parameter missing");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_V, "v parameter missing");
 		return NULL;
 	}
 	if (new->hlist == NULL) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_EMPTY_H,
-			"h parameter missing");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_H, "h parameter missing");
 		return NULL;
 	}
 	if (new->sig_alg == DKIM_SIGN_UNKNOWN) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_EMPTY_S,
-			"s parameter missing");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EMPTY_S, "s parameter missing");
 		return NULL;
 	}
 	if (new->sig_alg == DKIM_SIGN_RSASHA1) {
 		/* Check bh length */
 		if (new->bhlen != (guint)g_checksum_type_get_length (G_CHECKSUM_SHA1)) {
-			g_set_error (err,
-				DKIM_ERROR,
-				DKIM_SIGERROR_BADSIG,
-				"signature has incorrect length: %ud",
-				new->bhlen);
+			g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_BADSIG, "signature has incorrect length: %ud", new->bhlen);
 			return NULL;
 		}
 
 	}
 	else if (new->sig_alg == DKIM_SIGN_RSASHA256) {
-		if (new->bhlen !=
-			(guint)g_checksum_type_get_length (G_CHECKSUM_SHA256)) {
-			g_set_error (err,
-				DKIM_ERROR,
-				DKIM_SIGERROR_BADSIG,
-				"signature has incorrect length: %ud",
-				new->bhlen);
+		if (new->bhlen != (guint)g_checksum_type_get_length (G_CHECKSUM_SHA256)) {
+			g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_BADSIG, "signature has incorrect length: %ud", new->bhlen);
 			return NULL;
 		}
 	}
 	/* Check expiration */
 	now = time (NULL);
-	if (new->timestamp && now < new->timestamp && new->timestamp - now >
-		(gint)time_jitter) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_FUTURE,
-			"signature was made in future, ignoring");
+	if (new->timestamp && now < new->timestamp && new->timestamp - now > (gint)time_jitter) {
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_FUTURE, "signature was made in future, ignoring");
 		return NULL;
 	}
 	if (new->expiration && new->expiration < now) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_EXPIRED,
-			"signature has expired");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_EXPIRED, "signature has expired");
 		return NULL;
 	}
 
 	/* Now create dns key to request further */
-	taglen = strlen (new->domain) + strlen (new->selector) +
-		sizeof (DKIM_DNSKEYNAME) + 2;
+	taglen = strlen (new->domain) + strlen (new->selector) + sizeof (DKIM_DNSKEYNAME) + 2;
 	new->dns_key = rspamd_mempool_alloc (new->pool, taglen);
-	rspamd_snprintf (new->dns_key,
-		taglen,
-		"%s.%s.%s",
-		new->selector,
-		DKIM_DNSKEYNAME,
-		new->domain);
+	rspamd_snprintf (new->dns_key, taglen, "%s.%s.%s", new->selector, DKIM_DNSKEYNAME, new->domain);
 
 	/* Create checksums for further operations */
 	if (new->sig_alg == DKIM_SIGN_RSASHA1) {
@@ -786,19 +617,12 @@ rspamd_create_dkim_context (const gchar *sig,
 		new->headers_hash = g_checksum_new (G_CHECKSUM_SHA256);
 	}
 	else {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_BADSIG,
-			"signature has unsupported signature algorithm");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_BADSIG, "signature has unsupported signature algorithm");
 		return NULL;
 	}
 
-	rspamd_mempool_add_destructor (new->pool,
-		(rspamd_mempool_destruct_t)g_checksum_free,
-		new->body_hash);
-	rspamd_mempool_add_destructor (new->pool,
-		(rspamd_mempool_destruct_t)g_checksum_free,
-		new->headers_hash);
+	rspamd_mempool_add_destructor (new->pool, (rspamd_mempool_destruct_t)g_checksum_free, new->body_hash);
+	rspamd_mempool_add_destructor (new->pool, (rspamd_mempool_destruct_t)g_checksum_free, new->headers_hash);
 
 	return new;
 }
@@ -809,10 +633,10 @@ struct rspamd_dkim_key_cbdata {
 	gpointer ud;
 };
 
-static rspamd_dkim_key_t *
+static rspamd_dkim_key_t*
 rspamd_dkim_make_key (const gchar *keydata, guint keylen, GError **err)
 {
-	rspamd_dkim_key_t *key = NULL;
+	rspamd_dkim_key_t							*key = NULL;
 
 	if (keylen < 3) {
 		msg_err ("DKIM key is too short to be valid");
@@ -836,30 +660,21 @@ rspamd_dkim_make_key (const gchar *keydata, guint keylen, GError **err)
 #ifdef HAVE_OPENSSL
 	key->key_bio = BIO_new_mem_buf (key->keydata, key->decoded_len);
 	if (key->key_bio == NULL) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_KEYFAIL,
-			"cannot make ssl bio from key");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL, "cannot make ssl bio from key");
 		rspamd_dkim_key_free (key);
 		return NULL;
 	}
 
 	key->key_evp = d2i_PUBKEY_bio (key->key_bio, NULL);
 	if (key->key_evp == NULL) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_KEYFAIL,
-			"cannot extract pubkey from bio");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL, "cannot extract pubkey from bio");
 		rspamd_dkim_key_free (key);
 		return NULL;
 	}
 
 	key->key_rsa = EVP_PKEY_get1_RSA (key->key_evp);
 	if (key->key_rsa == NULL) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_KEYFAIL,
-			"cannot extract rsa key from evp key");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL, "cannot extract rsa key from evp key");
 		rspamd_dkim_key_free (key);
 		return NULL;
 	}
@@ -884,16 +699,16 @@ rspamd_dkim_key_free (rspamd_dkim_key_t *key)
 		BIO_free (key->key_bio);
 	}
 #endif
-	g_slice_free1 (key->keylen,				   key->keydata);
+	g_slice_free1 (key->keylen, key->keydata);
 	g_slice_free1 (sizeof (rspamd_dkim_key_t), key);
 }
 
-static rspamd_dkim_key_t *
+static rspamd_dkim_key_t*
 rspamd_dkim_parse_key (const gchar *txt, gsize *keylen, GError **err)
 {
-	const gchar *c, *p, *end;
-	gint state = 0;
-	gsize len;
+	const gchar									*c, *p, *end;
+	gint										 state = 0;
+	gsize										 len;
 
 	c = txt;
 	p = txt;
@@ -910,7 +725,7 @@ rspamd_dkim_parse_key (const gchar *txt, gsize *keylen, GError **err)
 			}
 			else {
 				/* Ignore everything */
-				p++;
+				p ++;
 			}
 			break;
 		case 1:
@@ -920,21 +735,17 @@ rspamd_dkim_parse_key (const gchar *txt, gsize *keylen, GError **err)
 				return rspamd_dkim_make_key (c, len, err);
 			}
 			else {
-				p++;
+				p ++;
 			}
 			break;
 		}
 	}
 
 	if (p - c == 0) {
-		g_set_error (err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_KEYREVOKED,
-			"key was revoked");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYREVOKED, "key was revoked");
 	}
 	else {
-		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL,
-			"key was not found");
+		g_set_error (err, DKIM_ERROR, DKIM_SIGERROR_KEYFAIL, "key was not found");
 	}
 
 	return NULL;
@@ -944,28 +755,21 @@ rspamd_dkim_parse_key (const gchar *txt, gsize *keylen, GError **err)
 static void
 rspamd_dkim_dns_cb (struct rdns_reply *reply, gpointer arg)
 {
-	struct rspamd_dkim_key_cbdata *cbdata = arg;
-	rspamd_dkim_key_t *key = NULL;
-	GError *err = NULL;
-	struct rdns_reply_entry *elt;
-	gsize keylen = 0;
+	struct rspamd_dkim_key_cbdata				*cbdata = arg;
+	rspamd_dkim_key_t							*key = NULL;
+	GError										*err = NULL;
+	struct rdns_reply_entry					*elt;
+	gsize										 keylen = 0;
 
 	if (reply->code != RDNS_RC_NOERROR) {
-		g_set_error (&err,
-			DKIM_ERROR,
-			DKIM_SIGERROR_NOKEY,
-			"dns request to %s failed: %s",
-			cbdata->ctx->dns_key,
-			rdns_strerror (reply->code));
+		g_set_error (&err, DKIM_ERROR, DKIM_SIGERROR_NOKEY, "dns request to %s failed: %s", cbdata->ctx->dns_key,
+				rdns_strerror (reply->code));
 		cbdata->handler (NULL, 0, cbdata->ctx, cbdata->ud, err);
 	}
 	else {
-		LL_FOREACH (reply->entries, elt)
-		{
+		LL_FOREACH (reply->entries, elt) {
 			if (elt->type == RDNS_REQUEST_TXT) {
-				key = rspamd_dkim_parse_key (elt->content.txt.data,
-						&keylen,
-						&err);
+				key = rspamd_dkim_parse_key (elt->content.txt.data, &keylen, &err);
 				if (key) {
 					key->ttl = elt->ttl;
 					break;
@@ -989,41 +793,30 @@ rspamd_dkim_dns_cb (struct rdns_reply *reply, gpointer arg)
  * @return
  */
 gboolean
-rspamd_get_dkim_key (rspamd_dkim_context_t *ctx,
-	struct rspamd_dns_resolver *resolver,
-	struct rspamd_async_session *s,
-	dkim_key_handler_f handler,
-	gpointer ud)
+rspamd_get_dkim_key (rspamd_dkim_context_t *ctx, struct rspamd_dns_resolver *resolver,
+		struct rspamd_async_session *s, dkim_key_handler_f handler, gpointer ud)
 {
-	struct rspamd_dkim_key_cbdata *cbdata;
+	struct rspamd_dkim_key_cbdata				*cbdata;
 
-	g_return_val_if_fail (ctx != NULL,			FALSE);
+	g_return_val_if_fail (ctx != NULL, FALSE);
 	g_return_val_if_fail (ctx->dns_key != NULL, FALSE);
 
-	cbdata =
-		rspamd_mempool_alloc (ctx->pool,
-			sizeof (struct rspamd_dkim_key_cbdata));
+	cbdata = rspamd_mempool_alloc (ctx->pool, sizeof (struct rspamd_dkim_key_cbdata));
 	cbdata->ctx = ctx;
 	cbdata->handler = handler;
 	cbdata->ud = ud;
 
-	return make_dns_request (resolver,
-			   s,
-			   ctx->pool,
-			   rspamd_dkim_dns_cb,
-			   cbdata,
-			   RDNS_REQUEST_TXT,
-			   ctx->dns_key);
+	return make_dns_request (resolver, s, ctx->pool, rspamd_dkim_dns_cb, cbdata, RDNS_REQUEST_TXT, ctx->dns_key);
 }
 
 static gboolean
 rspamd_dkim_relaxed_body_step (GChecksum *ck, const gchar **start, guint remain)
 {
-	const gchar *h;
-	static gchar buf[BUFSIZ];
-	gchar *t;
-	guint len, inlen;
-	gboolean got_sp, finished = FALSE;
+	const gchar									*h;
+	static gchar								 buf[BUFSIZ];
+	gchar										*t;
+	guint										 len, inlen;
+	gboolean									 got_sp, finished = FALSE;
 
 	if (remain > sizeof (buf)) {
 		len = sizeof (buf);
@@ -1042,16 +835,16 @@ rspamd_dkim_relaxed_body_step (GChecksum *ck, const gchar **start, guint remain)
 			/* Ignore spaces at the end of line */
 			if (got_sp) {
 				got_sp = FALSE;
-				t--;
+				t --;
 			}
 			/* Replace a single \n or \r with \r\n */
 			if (*h == '\n' && *(h - 1) != '\r') {
-				*t++ = '\r';
-				inlen--;
+				*t ++ = '\r';
+				inlen --;
 			}
 			else if (*h == '\r' && *(h + 1) != '\n') {
-				*t++ = *h++;
-				*t++ = '\n';
+				*t ++ = *h ++;
+				*t ++ = '\n';
 				if (inlen > 1) {
 					inlen -= 2;
 				}
@@ -1059,22 +852,22 @@ rspamd_dkim_relaxed_body_step (GChecksum *ck, const gchar **start, guint remain)
 					/* It is safe as inlen = sizeof (buf) - 1 */
 					inlen = 0;
 				}
-				len--;
+				len --;
 				continue;
 			}
 		}
 		else if (g_ascii_isspace (*h)) {
 			if (got_sp) {
 				/* Ignore multiply spaces */
-				h++;
-				len--;
+				h ++;
+				len --;
 				continue;
 			}
 			else {
 				*t++ = ' ';
-				h++;
-				inlen--;
-				len--;
+				h ++;
+				inlen --;
+				len --;
 				got_sp = TRUE;
 				continue;
 			}
@@ -1083,15 +876,15 @@ rspamd_dkim_relaxed_body_step (GChecksum *ck, const gchar **start, guint remain)
 			got_sp = FALSE;
 		}
 		*t++ = *h++;
-		inlen--;
-		len--;
+		inlen --;
+		len --;
 	}
 
 	*start = h;
 
 	if (!finished && *(t - 1) == ' ' && g_ascii_isspace (*h)) {
 		/* Avoid border problems */
-		t--;
+		t --;
 	}
 #if 0
 	msg_debug ("update signature with buffer: %*s", t - buf, buf);
@@ -1104,11 +897,11 @@ rspamd_dkim_relaxed_body_step (GChecksum *ck, const gchar **start, guint remain)
 static gboolean
 rspamd_dkim_simple_body_step (GChecksum *ck, const gchar **start, guint remain)
 {
-	const gchar *h;
-	static gchar buf[BUFSIZ];
-	gchar *t;
-	guint len, inlen;
-	gboolean finished = FALSE;
+	const gchar									*h;
+	static gchar								 buf[BUFSIZ];
+	gchar										*t;
+	guint										 len, inlen;
+	gboolean									 finished = FALSE;
 
 	if (remain > sizeof (buf)) {
 		len = sizeof (buf);
@@ -1125,12 +918,12 @@ rspamd_dkim_simple_body_step (GChecksum *ck, const gchar **start, guint remain)
 		if (*h == '\r' || *h == '\n') {
 			/* Replace a single \n or \r with \r\n */
 			if (*h == '\n' && *(h - 1) != '\r') {
-				*t++ = '\r';
-				inlen--;
+				*t ++ = '\r';
+				inlen --;
 			}
 			else if (*h == '\r' && *(h + 1) != '\n') {
-				*t++ = *h++;
-				*t++ = '\n';
+				*t ++ = *h ++;
+				*t ++ = '\n';
 				if (inlen > 1) {
 					inlen -= 2;
 				}
@@ -1138,13 +931,13 @@ rspamd_dkim_simple_body_step (GChecksum *ck, const gchar **start, guint remain)
 					/* It is safe as inlen = sizeof (buf) - 1 */
 					inlen = 0;
 				}
-				len--;
+				len --;
 				continue;
 			}
 		}
 		*t++ = *h++;
-		inlen--;
-		len--;
+		inlen --;
+		len --;
 	}
 
 	*start = h;
@@ -1158,9 +951,7 @@ rspamd_dkim_simple_body_step (GChecksum *ck, const gchar **start, guint remain)
 }
 
 static gboolean
-rspamd_dkim_canonize_body (rspamd_dkim_context_t *ctx,
-	const gchar *start,
-	const gchar *end)
+rspamd_dkim_canonize_body (rspamd_dkim_context_t *ctx, const gchar *start, const gchar *end)
 {
 	const gchar *p;
 
@@ -1181,10 +972,10 @@ rspamd_dkim_canonize_body (rspamd_dkim_context_t *ctx,
 				p -= 2;
 			}
 			else if (*p == '\n' && *(p - 1) == '\n') {
-				p--;
+				p --;
 			}
 			else if (*p == '\r' && *(p - 1) == '\r') {
-				p--;
+				p --;
 			}
 			else {
 				break;
@@ -1203,12 +994,10 @@ rspamd_dkim_canonize_body (rspamd_dkim_context_t *ctx,
 		else {
 			if (ctx->body_canon_type == DKIM_CANON_SIMPLE) {
 				/* Simple canonization */
-				while (rspamd_dkim_simple_body_step (ctx->body_hash, &start,
-					end - start)) ;
+				while (rspamd_dkim_simple_body_step (ctx->body_hash, &start, end - start));
 			}
 			else {
-				while (rspamd_dkim_relaxed_body_step (ctx->body_hash, &start,
-					end - start)) ;
+				while (rspamd_dkim_relaxed_body_step (ctx->body_hash, &start, end - start));
 			}
 		}
 		return TRUE;
@@ -1222,29 +1011,29 @@ rspamd_dkim_canonize_body (rspamd_dkim_context_t *ctx,
 static void
 rspamd_dkim_hash_update (GChecksum *ck, const gchar *begin, gsize len)
 {
-	const gchar *p, *c, *end;
+	const gchar									*p, *c, *end;
 
 	end = begin + len;
 	p = begin;
 	c = p;
 	while (p != end) {
 		if (*p == '\r') {
-			g_checksum_update (ck, c,	 p - c);
+			g_checksum_update (ck, c, p - c);
 			g_checksum_update (ck, CRLF, sizeof (CRLF) - 1);
-			p++;
+			p ++;
 			if (*p == '\n') {
-				p++;
+				p ++;
 			}
 			c = p;
 		}
 		else if (*p == '\n') {
-			g_checksum_update (ck, c,	 p - c);
+			g_checksum_update (ck, c, p - c);
 			g_checksum_update (ck, CRLF, sizeof (CRLF) - 1);
-			p++;
+			p ++;
 			c = p;
 		}
 		else {
-			p++;
+			p ++;
 		}
 	}
 	if (p != c) {
@@ -1254,12 +1043,10 @@ rspamd_dkim_hash_update (GChecksum *ck, const gchar *begin, gsize len)
 
 /* Update hash by signature value (ignoring b= tag) */
 static void
-rspamd_dkim_signature_update (rspamd_dkim_context_t *ctx,
-	const gchar *begin,
-	guint len)
+rspamd_dkim_signature_update (rspamd_dkim_context_t *ctx, const gchar *begin, guint len)
 {
-	const gchar *p, *c, *end;
-	gboolean tag, skip;
+	const gchar									*p, *c, *end;
+	gboolean									 tag, skip;
 
 	end = begin + len;
 	p = begin;
@@ -1270,9 +1057,7 @@ rspamd_dkim_signature_update (rspamd_dkim_context_t *ctx,
 	while (p < end) {
 		if (tag && p[0] == 'b' && p[1] == '=') {
 			/* Add to signature */
-			msg_debug ("initial update hash with signature part: %*s",
-				p - c + 2,
-				c);
+			msg_debug ("initial update hash with signature part: %*s", p - c + 2, c);
 			rspamd_dkim_hash_update (ctx->headers_hash, c, p - c + 2);
 			skip = TRUE;
 		}
@@ -1286,13 +1071,13 @@ rspamd_dkim_signature_update (rspamd_dkim_context_t *ctx,
 		else if (tag && *p == '=') {
 			tag = FALSE;
 		}
-		p++;
+		p ++;
 	}
 
-	p--;
+	p --;
 	/* Skip \r\n at the end */
 	while ((*p == '\r' || *p == '\n') && p >= c) {
-		p--;
+		p --;
 	}
 
 	if (p - c + 1 > 0) {
@@ -1302,15 +1087,12 @@ rspamd_dkim_signature_update (rspamd_dkim_context_t *ctx,
 }
 
 static gboolean
-rspamd_dkim_canonize_header_relaxed (rspamd_dkim_context_t *ctx,
-	const gchar *header,
-	const gchar *header_name,
-	gboolean is_sign)
+rspamd_dkim_canonize_header_relaxed (rspamd_dkim_context_t *ctx, const gchar *header, const gchar *header_name, gboolean is_sign)
 {
-	const gchar *h;
-	gchar *t, *buf;
-	guint inlen;
-	gboolean got_sp, allocated = FALSE;
+	const gchar									*h;
+	gchar										*t, *buf;
+	guint										 inlen;
+	gboolean									 got_sp, allocated = FALSE;
 
 	inlen = strlen (header) + strlen (header_name) + sizeof (":" CRLF);
 	if (inlen > BUFSIZ) {
@@ -1326,7 +1108,7 @@ rspamd_dkim_canonize_header_relaxed (rspamd_dkim_context_t *ctx,
 	t = buf;
 	h = header_name;
 	while (*h) {
-		*t++ = g_ascii_tolower (*h++);
+		*t ++ = g_ascii_tolower (*h++);
 	}
 	*t++ = ':';
 
@@ -1334,30 +1116,30 @@ rspamd_dkim_canonize_header_relaxed (rspamd_dkim_context_t *ctx,
 	h = header;
 	/* Skip spaces at the beginning */
 	while (g_ascii_isspace (*h)) {
-		h++;
+		h ++;
 	}
 	got_sp = FALSE;
 
 	while (*h) {
 		if (g_ascii_isspace (*h)) {
 			if (got_sp) {
-				h++;
+				h ++;
 				continue;
 			}
 			else {
 				got_sp = TRUE;
-				*t++ = ' ';
-				h++;
+				*t ++ = ' ';
+				h ++;
 				continue;
 			}
 		}
 		else {
 			got_sp = FALSE;
 		}
-		*t++ = *h++;
+		*t ++ = *h ++;
 	}
 	if (g_ascii_isspace (*(t - 1))) {
-		t--;
+		t --;
 	}
 	*t++ = '\r';
 	*t++ = '\n';
@@ -1385,25 +1167,18 @@ struct rspamd_dkim_sign_chunk {
 };
 
 static gboolean
-rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx,
-	const gchar *headers,
-	const gchar *header_name,
-	guint count,
-	gboolean is_sign)
+rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx, const gchar *headers,
+		const gchar *header_name, guint count, gboolean is_sign)
 {
-	const gchar *p, *c;
-	gint state = 0, hlen;
-	gboolean found = FALSE;
-	GArray *to_sign;
-	struct rspamd_dkim_sign_chunk chunk, *elt;
-	gint i;
+	const gchar									*p, *c;
+	gint										 state = 0, hlen;
+	gboolean									 found = FALSE;
+	GArray										*to_sign;
+	struct rspamd_dkim_sign_chunk				 chunk, *elt;
+	gint										 i;
 
 	/* This process is very similar to raw headers processing */
-	to_sign =
-		g_array_sized_new (FALSE,
-			FALSE,
-			sizeof (struct rspamd_dkim_sign_chunk),
-			count);
+	to_sign = g_array_sized_new (FALSE, FALSE, sizeof (struct rspamd_dkim_sign_chunk), count);
 	p = headers;
 	c = p;
 	hlen = strlen (header_name);
@@ -1429,7 +1204,7 @@ rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx,
 					state = 1;
 				}
 			}
-			p++;
+			p ++;
 			break;
 		case 1:
 			/* Skip header state */
@@ -1438,7 +1213,7 @@ rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx,
 				state = 0;
 				c = p + 1;
 			}
-			p++;
+			p ++;
 			break;
 		case 2:
 			/* c contains the beginning of header */
@@ -1458,7 +1233,7 @@ rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx,
 				state = 0;
 				found = TRUE;
 			}
-			p++;
+			p ++;
 			break;
 		}
 	}
@@ -1466,25 +1241,16 @@ rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx,
 	if (found) {
 		if (!is_sign) {
 
-			for (i = to_sign->len - 1; i >= 0 && count > 0; i--, count--) {
-				elt =
-					&g_array_index (to_sign, struct rspamd_dkim_sign_chunk, i);
+			for (i = to_sign->len - 1; i >= 0 && count > 0; i --, count --) {
+				elt = &g_array_index (to_sign, struct rspamd_dkim_sign_chunk, i);
 
 				if (!chunk.append_crlf) {
-					msg_debug ("update signature with header: %*s",
-						elt->len,
-						elt->begin);
-					rspamd_dkim_hash_update (ctx->headers_hash,
-						elt->begin,
-						elt->len);
+					msg_debug ("update signature with header: %*s", elt->len, elt->begin);
+					rspamd_dkim_hash_update (ctx->headers_hash, elt->begin, elt->len);
 				}
 				else {
-					msg_debug ("update signature with header: %*s",
-						elt->len + 1,
-						elt->begin);
-					rspamd_dkim_hash_update (ctx->headers_hash,
-						elt->begin,
-						elt->len + 1);
+					msg_debug ("update signature with header: %*s", elt->len + 1, elt->begin);
+					rspamd_dkim_hash_update (ctx->headers_hash, elt->begin, elt->len + 1);
 				}
 			}
 		}
@@ -1505,22 +1271,15 @@ rspamd_dkim_canonize_header_simple (rspamd_dkim_context_t *ctx,
 }
 
 static gboolean
-rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx,
-	struct rspamd_task *task,
-	const gchar *header_name,
-	guint count,
-	gboolean is_sig)
+rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx, struct rspamd_task *task, const gchar *header_name,
+		guint count, gboolean is_sig)
 {
-	struct raw_header *rh, *rh_iter;
-	guint rh_num = 0;
-	GList *nh = NULL, *cur;
+	struct raw_header 							*rh, *rh_iter;
+	guint										 rh_num = 0;
+	GList										*nh = NULL, *cur;
 
 	if (ctx->header_canon_type == DKIM_CANON_SIMPLE) {
-		return rspamd_dkim_canonize_header_simple (ctx,
-				   task->raw_headers_str,
-				   header_name,
-				   count,
-				   is_sig);
+		return rspamd_dkim_canonize_header_simple (ctx, task->raw_headers_str, header_name, count, is_sig);
 	}
 	else {
 		rh = g_hash_table_lookup (task->raw_headers, header_name);
@@ -1528,7 +1287,7 @@ rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx,
 			if (!is_sig) {
 				rh_iter = rh;
 				while (rh_iter) {
-					rh_num++;
+					rh_num ++;
 					rh_iter = rh_iter->next;
 				}
 
@@ -1542,7 +1301,7 @@ rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx,
 				rh_iter = rh;
 				while (rh_num) {
 					rh_iter = rh_iter->next;
-					rh_num--;
+					rh_num --;
 				}
 				/* Now insert required headers */
 				while (rh_iter) {
@@ -1552,8 +1311,7 @@ rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx,
 				cur = nh;
 				while (cur) {
 					rh = cur->data;
-					if (!rspamd_dkim_canonize_header_relaxed (ctx, rh->value,
-						header_name, is_sig)) {
+					if (! rspamd_dkim_canonize_header_relaxed (ctx, rh->value, header_name, is_sig)) {
 						g_list_free (nh);
 						return FALSE;
 					}
@@ -1565,10 +1323,7 @@ rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx,
 			}
 			else {
 				/* For signature check just use the first dkim header */
-				rspamd_dkim_canonize_header_relaxed (ctx,
-					rh->value,
-					header_name,
-					is_sig);
+				rspamd_dkim_canonize_header_relaxed (ctx, rh->value, header_name, is_sig);
 			}
 			return TRUE;
 		}
@@ -1586,23 +1341,21 @@ rspamd_dkim_canonize_header (rspamd_dkim_context_t *ctx,
  * @return
  */
 gint
-rspamd_dkim_check (rspamd_dkim_context_t *ctx,
-	rspamd_dkim_key_t *key,
-	struct rspamd_task *task)
+rspamd_dkim_check (rspamd_dkim_context_t *ctx, rspamd_dkim_key_t *key, struct rspamd_task *task)
 {
-	const gchar *p, *headers_end = NULL, *end, *body_end;
-	gboolean got_cr = FALSE, got_crlf = FALSE, got_lf = FALSE;
-	gchar *digest;
-	gsize dlen;
-	gint res = DKIM_CONTINUE;
-	guint i;
-	struct rspamd_dkim_header *dh;
+	const gchar									*p, *headers_end = NULL, *end, *body_end;
+	gboolean									 got_cr = FALSE, got_crlf = FALSE, got_lf = FALSE;
+	gchar										*digest;
+	gsize										 dlen;
+	gint										 res = DKIM_CONTINUE;
+	guint										 i;
+	struct rspamd_dkim_header					*dh;
 #ifdef HAVE_OPENSSL
-	gint nid;
+	gint										 nid;
 #endif
 
-	g_return_val_if_fail (ctx != NULL,		 DKIM_ERROR);
-	g_return_val_if_fail (key != NULL,		 DKIM_ERROR);
+	g_return_val_if_fail (ctx != NULL, DKIM_ERROR);
+	g_return_val_if_fail (key != NULL, DKIM_ERROR);
 	g_return_val_if_fail (task->msg != NULL, DKIM_ERROR);
 
 	/* First of all find place of body */
@@ -1669,7 +1422,7 @@ rspamd_dkim_check (rspamd_dkim_context_t *ctx,
 			got_cr = FALSE;
 			got_crlf = FALSE;
 		}
-		p++;
+		p ++;
 	}
 
 	/* Start canonization of body part */
@@ -1689,7 +1442,7 @@ rspamd_dkim_check (rspamd_dkim_context_t *ctx,
 		return DKIM_RECORD_ERROR;
 	}
 	/* Now canonize headers */
-	for (i = 0; i < ctx->hlist->len; i++) {
+	for (i = 0; i < ctx->hlist->len; i ++) {
 		dh = g_ptr_array_index (ctx->hlist, i);
 		rspamd_dkim_canonize_header (ctx, task, dh->name, dh->count, FALSE);
 	}
diff --git a/src/libserver/dkim.h b/src/libserver/dkim.h
index 3340c2432..29ec479b7 100644
--- a/src/libserver/dkim.h
+++ b/src/libserver/dkim.h
@@ -26,109 +26,109 @@
 #define DKIM_H_
 
 #include "config.h"
-#include "dns.h"
 #include "event.h"
+#include "dns.h"
 #ifdef HAVE_OPENSSL
-#include <openssl/engine.h>
 #include <openssl/rsa.h>
+#include <openssl/engine.h>
 #endif
 
 /* Main types and definitions */
 
-#define DKIM_SIGNHEADER     "DKIM-Signature"
-/* DKIM signature header */
+#define	DKIM_SIGNHEADER		"DKIM-Signature"
+					/* DKIM signature header */
 
 /* special DNS tokens */
-#define DKIM_DNSKEYNAME     "_domainkey"
-/* reserved DNS sub-zone */
-#define DKIM_DNSPOLICYNAME  "_adsp" /* reserved DNS sub-zone */
+#define	DKIM_DNSKEYNAME		"_domainkey"
+					/* reserved DNS sub-zone */
+#define	DKIM_DNSPOLICYNAME	"_adsp"	/* reserved DNS sub-zone */
 
 /* Canonization methods */
-#define DKIM_CANON_UNKNOWN  (-1)    /* unknown method */
-#define DKIM_CANON_SIMPLE   0   /* as specified in DKIM spec */
-#define DKIM_CANON_RELAXED  1   /* as specified in DKIM spec */
+#define DKIM_CANON_UNKNOWN	(-1)	/* unknown method */
+#define DKIM_CANON_SIMPLE	0	/* as specified in DKIM spec */
+#define DKIM_CANON_RELAXED	1	/* as specified in DKIM spec */
 
-#define DKIM_CANON_DEFAULT  DKIM_CANON_SIMPLE
+#define DKIM_CANON_DEFAULT	DKIM_CANON_SIMPLE
 
 /* Signature methods */
-#define DKIM_SIGN_UNKNOWN   (-2)    /* unknown method */
-#define DKIM_SIGN_DEFAULT   (-1)    /* use internal default */
-#define DKIM_SIGN_RSASHA1   0   /* an RSA-signed SHA1 digest */
-#define DKIM_SIGN_RSASHA256 1   /* an RSA-signed SHA256 digest */
+#define DKIM_SIGN_UNKNOWN	(-2)	/* unknown method */
+#define DKIM_SIGN_DEFAULT	(-1)	/* use internal default */
+#define DKIM_SIGN_RSASHA1	0	/* an RSA-signed SHA1 digest */
+#define DKIM_SIGN_RSASHA256	1	/* an RSA-signed SHA256 digest */
 
 /* Params */
-#define DKIM_PARAM_UNKNOWN  (-1)    /* unknown */
-#define DKIM_PARAM_SIGNATURE    0   /* b */
-#define DKIM_PARAM_SIGNALG  1   /* a */
-#define DKIM_PARAM_DOMAIN   2   /* d */
-#define DKIM_PARAM_CANONALG 3   /* c */
-#define DKIM_PARAM_QUERYMETHOD  4   /* q */
-#define DKIM_PARAM_SELECTOR 5   /* s */
-#define DKIM_PARAM_HDRLIST  6   /* h */
-#define DKIM_PARAM_VERSION  7   /* v */
-#define DKIM_PARAM_IDENTITY 8   /* i */
-#define DKIM_PARAM_TIMESTAMP    9   /* t */
-#define DKIM_PARAM_EXPIRATION   10  /* x */
-#define DKIM_PARAM_COPIEDHDRS   11  /* z */
-#define DKIM_PARAM_BODYHASH 12  /* bh */
-#define DKIM_PARAM_BODYLENGTH   13  /* l */
+#define DKIM_PARAM_UNKNOWN	(-1)	/* unknown */
+#define DKIM_PARAM_SIGNATURE	0	/* b */
+#define DKIM_PARAM_SIGNALG	1	/* a */
+#define DKIM_PARAM_DOMAIN	2	/* d */
+#define DKIM_PARAM_CANONALG	3	/* c */
+#define DKIM_PARAM_QUERYMETHOD	4	/* q */
+#define DKIM_PARAM_SELECTOR	5	/* s */
+#define DKIM_PARAM_HDRLIST	6	/* h */
+#define DKIM_PARAM_VERSION	7	/* v */
+#define DKIM_PARAM_IDENTITY	8	/* i */
+#define DKIM_PARAM_TIMESTAMP	9	/* t */
+#define DKIM_PARAM_EXPIRATION	10	/* x */
+#define DKIM_PARAM_COPIEDHDRS	11	/* z */
+#define DKIM_PARAM_BODYHASH	12	/* bh */
+#define DKIM_PARAM_BODYLENGTH	13	/* l */
 
 /* Errors (from OpenDKIM) */
 
-#define DKIM_SIGERROR_UNKNOWN       (-1)    /* unknown error */
-#define DKIM_SIGERROR_OK        0   /* no error */
-#define DKIM_SIGERROR_VERSION       1   /* unsupported version */
-#define DKIM_SIGERROR_DOMAIN        2   /* invalid domain (d=/i=) */
-#define DKIM_SIGERROR_EXPIRED       3   /* signature expired */
-#define DKIM_SIGERROR_FUTURE        4   /* signature in the future */
-#define DKIM_SIGERROR_TIMESTAMPS    5   /* x= < t= */
-#define DKIM_SIGERROR_UNUSED        6   /* OBSOLETE */
-#define DKIM_SIGERROR_INVALID_HC    7   /* c= invalid (header) */
-#define DKIM_SIGERROR_INVALID_BC    8   /* c= invalid (body) */
-#define DKIM_SIGERROR_MISSING_A     9   /* a= missing */
-#define DKIM_SIGERROR_INVALID_A     10  /* a= invalid */
-#define DKIM_SIGERROR_MISSING_H     11  /* h= missing */
-#define DKIM_SIGERROR_INVALID_L     12  /* l= invalid */
-#define DKIM_SIGERROR_INVALID_Q     13  /* q= invalid */
-#define DKIM_SIGERROR_INVALID_QO    14  /* q= option invalid */
-#define DKIM_SIGERROR_MISSING_D     15  /* d= missing */
-#define DKIM_SIGERROR_EMPTY_D       16  /* d= empty */
-#define DKIM_SIGERROR_MISSING_S     17  /* s= missing */
-#define DKIM_SIGERROR_EMPTY_S       18  /* s= empty */
-#define DKIM_SIGERROR_MISSING_B     19  /* b= missing */
-#define DKIM_SIGERROR_EMPTY_B       20  /* b= empty */
-#define DKIM_SIGERROR_CORRUPT_B     21  /* b= corrupt */
-#define DKIM_SIGERROR_NOKEY     22  /* no key found in DNS */
-#define DKIM_SIGERROR_DNSSYNTAX     23  /* DNS reply corrupt */
-#define DKIM_SIGERROR_KEYFAIL       24  /* DNS query failed */
-#define DKIM_SIGERROR_MISSING_BH    25  /* bh= missing */
-#define DKIM_SIGERROR_EMPTY_BH      26  /* bh= empty */
-#define DKIM_SIGERROR_CORRUPT_BH    27  /* bh= corrupt */
-#define DKIM_SIGERROR_BADSIG        28  /* signature mismatch */
-#define DKIM_SIGERROR_SUBDOMAIN     29  /* unauthorized subdomain */
-#define DKIM_SIGERROR_MULTIREPLY    30  /* multiple records returned */
-#define DKIM_SIGERROR_EMPTY_H       31  /* h= empty */
-#define DKIM_SIGERROR_INVALID_H     32  /* h= missing req'd entries */
-#define DKIM_SIGERROR_TOOLARGE_L    33  /* l= value exceeds body size */
-#define DKIM_SIGERROR_MBSFAILED     34  /* "must be signed" failure */
-#define DKIM_SIGERROR_KEYVERSION    35  /* unknown key version */
-#define DKIM_SIGERROR_KEYUNKNOWNHASH    36  /* unknown key hash */
-#define DKIM_SIGERROR_KEYHASHMISMATCH   37  /* sig-key hash mismatch */
-#define DKIM_SIGERROR_NOTEMAILKEY   38  /* not an e-mail key */
-#define DKIM_SIGERROR_UNUSED2       39  /* OBSOLETE */
-#define DKIM_SIGERROR_KEYTYPEMISSING    40  /* key type missing */
-#define DKIM_SIGERROR_KEYTYPEUNKNOWN    41  /* key type unknown */
-#define DKIM_SIGERROR_KEYREVOKED    42  /* key revoked */
-#define DKIM_SIGERROR_KEYDECODE     43  /* key couldn't be decoded */
-#define DKIM_SIGERROR_MISSING_V     44  /* v= tag missing */
-#define DKIM_SIGERROR_EMPTY_V       45  /* v= tag empty */
+#define DKIM_SIGERROR_UNKNOWN		(-1)	/* unknown error */
+#define DKIM_SIGERROR_OK		0	/* no error */
+#define DKIM_SIGERROR_VERSION		1	/* unsupported version */
+#define DKIM_SIGERROR_DOMAIN		2	/* invalid domain (d=/i=) */
+#define DKIM_SIGERROR_EXPIRED		3	/* signature expired */
+#define DKIM_SIGERROR_FUTURE		4	/* signature in the future */
+#define DKIM_SIGERROR_TIMESTAMPS	5	/* x= < t= */
+#define DKIM_SIGERROR_UNUSED		6	/* OBSOLETE */
+#define DKIM_SIGERROR_INVALID_HC	7	/* c= invalid (header) */
+#define DKIM_SIGERROR_INVALID_BC	8	/* c= invalid (body) */
+#define DKIM_SIGERROR_MISSING_A		9	/* a= missing */
+#define DKIM_SIGERROR_INVALID_A		10	/* a= invalid */
+#define DKIM_SIGERROR_MISSING_H		11	/* h= missing */
+#define DKIM_SIGERROR_INVALID_L		12	/* l= invalid */
+#define DKIM_SIGERROR_INVALID_Q		13	/* q= invalid */
+#define DKIM_SIGERROR_INVALID_QO	14	/* q= option invalid */
+#define DKIM_SIGERROR_MISSING_D		15	/* d= missing */
+#define DKIM_SIGERROR_EMPTY_D		16	/* d= empty */
+#define DKIM_SIGERROR_MISSING_S		17	/* s= missing */
+#define DKIM_SIGERROR_EMPTY_S		18	/* s= empty */
+#define DKIM_SIGERROR_MISSING_B		19	/* b= missing */
+#define DKIM_SIGERROR_EMPTY_B		20	/* b= empty */
+#define DKIM_SIGERROR_CORRUPT_B		21	/* b= corrupt */
+#define DKIM_SIGERROR_NOKEY		22	/* no key found in DNS */
+#define DKIM_SIGERROR_DNSSYNTAX		23	/* DNS reply corrupt */
+#define DKIM_SIGERROR_KEYFAIL		24	/* DNS query failed */
+#define DKIM_SIGERROR_MISSING_BH	25	/* bh= missing */
+#define DKIM_SIGERROR_EMPTY_BH		26	/* bh= empty */
+#define DKIM_SIGERROR_CORRUPT_BH	27	/* bh= corrupt */
+#define DKIM_SIGERROR_BADSIG		28	/* signature mismatch */
+#define DKIM_SIGERROR_SUBDOMAIN		29	/* unauthorized subdomain */
+#define DKIM_SIGERROR_MULTIREPLY	30	/* multiple records returned */
+#define DKIM_SIGERROR_EMPTY_H		31	/* h= empty */
+#define DKIM_SIGERROR_INVALID_H		32	/* h= missing req'd entries */
+#define DKIM_SIGERROR_TOOLARGE_L	33	/* l= value exceeds body size */
+#define DKIM_SIGERROR_MBSFAILED		34	/* "must be signed" failure */
+#define	DKIM_SIGERROR_KEYVERSION	35	/* unknown key version */
+#define	DKIM_SIGERROR_KEYUNKNOWNHASH	36	/* unknown key hash */
+#define	DKIM_SIGERROR_KEYHASHMISMATCH	37	/* sig-key hash mismatch */
+#define	DKIM_SIGERROR_NOTEMAILKEY	38	/* not an e-mail key */
+#define	DKIM_SIGERROR_UNUSED2		39	/* OBSOLETE */
+#define	DKIM_SIGERROR_KEYTYPEMISSING	40	/* key type missing */
+#define	DKIM_SIGERROR_KEYTYPEUNKNOWN	41	/* key type unknown */
+#define	DKIM_SIGERROR_KEYREVOKED	42	/* key revoked */
+#define	DKIM_SIGERROR_KEYDECODE		43	/* key couldn't be decoded */
+#define	DKIM_SIGERROR_MISSING_V		44	/* v= tag missing */
+#define	DKIM_SIGERROR_EMPTY_V		45	/* v= tag empty */
 
 /* Check results */
-#define DKIM_CONTINUE   0   /* continue */
-#define DKIM_REJECT 1   /* reject */
-#define DKIM_TRYAGAIN   2   /* try again later */
-#define DKIM_NOTFOUND   3   /* requested record not found */
-#define DKIM_RECORD_ERROR   4   /* error requesting record */
+#define	DKIM_CONTINUE	0	/* continue */
+#define	DKIM_REJECT	1	/* reject */
+#define	DKIM_TRYAGAIN	2	/* try again later */
+#define	DKIM_NOTFOUND	3	/* requested record not found */
+#define	DKIM_RECORD_ERROR	4	/* error requesting record */
 
 typedef struct rspamd_dkim_context_s {
 	rspamd_mempool_t *pool;
@@ -167,8 +167,7 @@ rspamd_dkim_key_t;
 struct rspamd_task;
 
 /* Err MUST be freed if it is not NULL, key is allocated by slice allocator */
-typedef void (*dkim_key_handler_f)(rspamd_dkim_key_t *key, gsize keylen,
-	rspamd_dkim_context_t *ctx, gpointer ud, GError *err);
+typedef void (*dkim_key_handler_f)(rspamd_dkim_key_t *key, gsize keylen, rspamd_dkim_context_t *ctx, gpointer ud, GError *err);
 
 /**
  * Create new dkim context from signature
@@ -178,10 +177,7 @@ typedef void (*dkim_key_handler_f)(rspamd_dkim_key_t *key, gsize keylen,
  * @param err pointer to error object
  * @return new context or NULL
  */
-rspamd_dkim_context_t * rspamd_create_dkim_context (const gchar *sig,
-	rspamd_mempool_t *pool,
-	guint time_jitter,
-	GError **err);
+rspamd_dkim_context_t* rspamd_create_dkim_context (const gchar *sig, rspamd_mempool_t *pool,  guint time_jitter, GError **err);
 
 /**
  * Make DNS request for specified context and obtain and parse key
@@ -190,11 +186,8 @@ rspamd_dkim_context_t * rspamd_create_dkim_context (const gchar *sig,
  * @param s async session to make request
  * @return
  */
-gboolean rspamd_get_dkim_key (rspamd_dkim_context_t *ctx,
-	struct rspamd_dns_resolver *resolver,
-	struct rspamd_async_session *s,
-	dkim_key_handler_f handler,
-	gpointer ud);
+gboolean rspamd_get_dkim_key (rspamd_dkim_context_t *ctx, struct rspamd_dns_resolver *resolver,
+		struct rspamd_async_session *s, dkim_key_handler_f handler, gpointer ud);
 
 /**
  * Check task for dkim context using dkim key
@@ -203,9 +196,7 @@ gboolean rspamd_get_dkim_key (rspamd_dkim_context_t *ctx,
  * @param task task to check
  * @return
  */
-gint rspamd_dkim_check (rspamd_dkim_context_t *ctx,
-	rspamd_dkim_key_t *key,
-	struct rspamd_task *task);
+gint rspamd_dkim_check (rspamd_dkim_context_t *ctx, rspamd_dkim_key_t *key, struct rspamd_task *task);
 
 /**
  * Free DKIM key
diff --git a/src/libserver/dns.c b/src/libserver/dns.c
index a95232fca..c1303e3ea 100644
--- a/src/libserver/dns.c
+++ b/src/libserver/dns.c
@@ -26,9 +26,9 @@
 #include "config.h"
 #include "dns.h"
 #include "main.h"
-#include "rdns_event.h"
-#include "uthash.h"
 #include "utlist.h"
+#include "uthash.h"
+#include "rdns_event.h"
 
 struct rspamd_dns_resolver {
 	struct rdns_resolver *r;
@@ -48,7 +48,7 @@ static void
 rspamd_dns_fin_cb (gpointer arg)
 {
 	struct rdns_request *req = arg;
-
+	
 	rdns_request_release (req);
 }
 
@@ -67,33 +67,25 @@ rspamd_dns_callback (struct rdns_reply *reply, gpointer ud)
 	remove_normal_event (reqdata->session, rspamd_dns_fin_cb, reqdata->req);
 }
 
-gboolean
+gboolean 
 make_dns_request (struct rspamd_dns_resolver *resolver,
-	struct rspamd_async_session *session,
-	rspamd_mempool_t *pool,
-	dns_callback_type cb,
-	gpointer ud,
-	enum rdns_request_type type,
-	const char *name)
+		struct rspamd_async_session *session, rspamd_mempool_t *pool, dns_callback_type cb,
+		gpointer ud, enum rdns_request_type type, const char *name)
 {
 	struct rdns_request *req;
 	struct rspamd_dns_request_ud *reqdata;
-
-	reqdata =
-		rspamd_mempool_alloc (pool, sizeof (struct rspamd_dns_request_ud));
+	
+	reqdata = rspamd_mempool_alloc (pool, sizeof (struct rspamd_dns_request_ud));
 	reqdata->session = session;
 	reqdata->cb = cb;
 	reqdata->ud = ud;
 
 	req = rdns_make_request_full (resolver->r, rspamd_dns_callback, reqdata,
-			resolver->request_timeout, resolver->max_retransmits, 1, name,
-			type);
+			resolver->request_timeout, resolver->max_retransmits, 1, name, type);
 
 	if (req != NULL) {
-		register_async_event (session,
-			(event_finalizer_t)rspamd_dns_fin_cb,
-			req,
-			g_quark_from_static_string ("dns resolver"));
+		register_async_event (session, (event_finalizer_t)rspamd_dns_fin_cb, req,
+				g_quark_from_static_string ("dns resolver"));
 		reqdata->req = req;
 	}
 	else {
@@ -105,15 +97,13 @@ make_dns_request (struct rspamd_dns_resolver *resolver,
 
 
 struct rspamd_dns_resolver *
-dns_resolver_init (rspamd_logger_t *logger,
-	struct event_base *ev_base,
-	struct rspamd_config *cfg)
+dns_resolver_init (rspamd_logger_t *logger, struct event_base *ev_base, struct rspamd_config *cfg)
 {
-	GList *cur;
-	struct rspamd_dns_resolver *new;
-	gchar *begin, *p, *err;
-	gint priority;
-
+	GList                          *cur;
+	struct rspamd_dns_resolver     *new;
+	gchar                          *begin, *p, *err;
+	gint                            priority;
+	
 	new = g_slice_alloc0 (sizeof (struct rspamd_dns_resolver));
 	new->ev_base = ev_base;
 	new->request_timeout = cfg->dns_timeout;
@@ -122,15 +112,12 @@ dns_resolver_init (rspamd_logger_t *logger,
 	new->r = rdns_resolver_new ();
 	rdns_bind_libevent (new->r, new->ev_base);
 	rdns_resolver_set_log_level (new->r, cfg->log_level);
-	rdns_resolver_set_logger (new->r,
-		(rdns_log_function)rspamd_common_logv,
-		logger);
+	rdns_resolver_set_logger (new->r, (rdns_log_function)rspamd_common_logv, logger);
 
 	if (cfg->nameservers == NULL) {
 		/* Parse resolv.conf */
 		if (!rdns_resolver_parse_resolv_conf (new->r, "/etc/resolv.conf")) {
-			msg_err (
-				"cannot parse resolv.conf and no nameservers defined, so no ways to resolve addresses");
+			msg_err ("cannot parse resolv.conf and no nameservers defined, so no ways to resolve addresses");
 			return new;
 		}
 	}
@@ -141,19 +128,16 @@ dns_resolver_init (rspamd_logger_t *logger,
 			p = strchr (begin, ':');
 			if (p != NULL) {
 				*p = '\0';
-				p++;
+				p ++;
 				priority = strtoul (p, &err, 10);
 				if (err != NULL && *err != '\0') {
-					msg_info (
-						"bad character '%x', must be 'm' or 's' or a numeric priority",
-						*err);
+					msg_info ("bad character '%x', must be 'm' or 's' or a numeric priority", *err);
 				}
 			}
 			else {
 				priority = 0;
 			}
-			if (!rdns_resolver_add_server (new->r, begin, 53, priority,
-				cfg->dns_io_per_server)) {
+			if (!rdns_resolver_add_server (new->r, begin, 53, priority, cfg->dns_io_per_server)) {
 				msg_warn ("cannot parse ip address of nameserver: %s", begin);
 				cur = g_list_next (cur);
 				continue;
diff --git a/src/libserver/dns.h b/src/libserver/dns.h
index 147a641d3..7b3bbd208 100644
--- a/src/libserver/dns.h
+++ b/src/libserver/dns.h
@@ -27,9 +27,9 @@
 #define RSPAMD_DNS_H
 
 #include "config.h"
+#include "mem_pool.h"
 #include "events.h"
 #include "logger.h"
-#include "mem_pool.h"
 #include "rdns.h"
 
 struct rspamd_dns_resolver;
@@ -39,8 +39,8 @@ struct rspamd_dns_resolver;
 /**
  * Init DNS resolver, params are obtained from a config file or system file /etc/resolv.conf
  */
-struct rspamd_dns_resolver * dns_resolver_init (rspamd_logger_t *logger,
-	struct event_base *ev_base, struct rspamd_config *cfg);
+struct rspamd_dns_resolver *dns_resolver_init (rspamd_logger_t *logger,
+		struct event_base *ev_base, struct rspamd_config *cfg);
 
 /**
  * Make a DNS request
@@ -53,12 +53,8 @@ struct rspamd_dns_resolver * dns_resolver_init (rspamd_logger_t *logger,
  * @param ... string or ip address based on a request type
  * @return TRUE if request was sent.
  */
-gboolean make_dns_request (struct rspamd_dns_resolver *resolver,
-	struct rspamd_async_session *session,
-	rspamd_mempool_t *pool,
-	dns_callback_type cb,
-	gpointer ud,
-	enum rdns_request_type type,
-	const char *name);
+gboolean make_dns_request (struct rspamd_dns_resolver *resolver, 
+		struct rspamd_async_session *session, rspamd_mempool_t *pool,
+		dns_callback_type cb, gpointer ud, enum rdns_request_type type, const char *name);
 
 #endif
diff --git a/src/libserver/dynamic_cfg.c b/src/libserver/dynamic_cfg.c
index 1ba2b2baf..d0dabef67 100644
--- a/src/libserver/dynamic_cfg.c
+++ b/src/libserver/dynamic_cfg.c
@@ -22,34 +22,34 @@
  */
 
 #include "config.h"
-#include "dynamic_cfg.h"
-#include "filter.h"
-#include "json/jansson.h"
 #include "main.h"
 #include "map.h"
+#include "filter.h"
+#include "dynamic_cfg.h"
+#include "json/jansson.h"
 
 struct dynamic_cfg_symbol {
-	gchar *name;
-	gdouble value;
+	gchar						   *name;
+	gdouble						    value;
 };
 
 struct dynamic_cfg_action {
-	enum rspamd_metric_action action;
-	gdouble value;
+	enum rspamd_metric_action	    action;
+	gdouble						    value;
 };
 
 struct dynamic_cfg_metric {
-	GList *symbols;
-	struct dynamic_cfg_action actions[METRIC_ACTION_MAX];
-	gchar *name;
+	GList 						   *symbols;
+	struct dynamic_cfg_action       actions[METRIC_ACTION_MAX];
+	gchar						   *name;
 };
 
 struct config_json_buf {
-	gchar *buf;
-	gchar *pos;
-	size_t buflen;
-	struct rspamd_config *cfg;
-	GList *config_metrics;
+	gchar                          *buf;
+	gchar                          *pos;
+	size_t                          buflen;
+	struct rspamd_config             *cfg;
+	GList						   *config_metrics;
 };
 
 /**
@@ -59,9 +59,9 @@ struct config_json_buf {
 static void
 dynamic_cfg_free (GList *conf_metrics)
 {
-	GList *cur, *cur_elt;
-	struct dynamic_cfg_metric *metric;
-	struct dynamic_cfg_symbol *sym;
+	GList								*cur, *cur_elt;
+	struct dynamic_cfg_metric			*metric;
+	struct dynamic_cfg_symbol			*sym;
 
 	if (conf_metrics) {
 		cur = conf_metrics;
@@ -91,50 +91,44 @@ dynamic_cfg_free (GList *conf_metrics)
 static void
 apply_dynamic_conf (GList *conf_metrics, struct rspamd_config *cfg)
 {
-	GList *cur, *cur_elt;
-	struct dynamic_cfg_metric *metric;
-	struct dynamic_cfg_symbol *sym;
-	struct dynamic_cfg_action *act;
-	struct metric *real_metric;
-	struct metric_action *real_act;
-	gdouble *w;
-	gint i, j;
+	GList								*cur, *cur_elt;
+	struct dynamic_cfg_metric			*metric;
+	struct dynamic_cfg_symbol			*sym;
+	struct dynamic_cfg_action			*act;
+	struct metric						*real_metric;
+	struct metric_action				*real_act;
+	gdouble								*w;
+	gint                                 i, j;
 
 	cur = conf_metrics;
 	while (cur) {
 		metric = cur->data;
-		if ((real_metric =
-			g_hash_table_lookup (cfg->metrics, metric->name)) != NULL) {
+		if ((real_metric = g_hash_table_lookup (cfg->metrics, metric->name)) != NULL) {
 			cur_elt = metric->symbols;
 			while (cur_elt) {
 				sym = cur_elt->data;
-				if ((w =
-					g_hash_table_lookup (real_metric->symbols,
-					sym->name)) != NULL) {
+				if ((w = g_hash_table_lookup (real_metric->symbols, sym->name)) != NULL) {
 					*w = sym->value;
 				}
 				else {
-					msg_info (
-						"symbol %s is not found in the main configuration",
-						sym->name);
+					msg_info ("symbol %s is not found in the main configuration", sym->name);
 				}
 				cur_elt = g_list_next (cur_elt);
 			}
 
-			for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
+			for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
 				act = &metric->actions[i];
 				if (act->value < 0) {
 					continue;
 				}
-				for (j = METRIC_ACTION_REJECT; j < METRIC_ACTION_MAX; j++) {
+				for (j = METRIC_ACTION_REJECT; j < METRIC_ACTION_MAX; j ++) {
 					real_act = &real_metric->actions[j];
 					if (real_act->action == act->action) {
 						real_act->score = act->value;
 					}
 					/* Update required score accordingly to metric's action */
 					if (act->action == METRIC_ACTION_REJECT) {
-						real_metric->actions[METRIC_ACTION_REJECT].score =
-							act->value;
+						real_metric->actions[METRIC_ACTION_REJECT].score = act->value;
 					}
 				}
 			}
@@ -144,14 +138,11 @@ apply_dynamic_conf (GList *conf_metrics, struct rspamd_config *cfg)
 }
 
 /* Callbacks for reading json dynamic rules */
-gchar *
-json_config_read_cb (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data)
+gchar                         *
+json_config_read_cb (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
 {
-	struct config_json_buf *jb;
-	gint free, off;
+	struct config_json_buf				*jb;
+	gint								 free, off;
 
 	if (data->cur_data == NULL) {
 		jb = g_malloc (sizeof (struct config_json_buf));
@@ -191,14 +182,14 @@ json_config_read_cb (rspamd_mempool_t * pool,
 void
 json_config_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 {
-	struct config_json_buf *jb;
-	guint nelts, i, j, selts;
-	gint test_act;
-	json_t *js, *cur_elt, *cur_nm, *it_val;
-	json_error_t je;
-	struct dynamic_cfg_metric *cur_metric;
-	struct dynamic_cfg_symbol *cur_symbol;
-	struct dynamic_cfg_action *cur_action;
+	struct config_json_buf				*jb;
+	guint								 nelts, i, j, selts;
+	gint								 test_act;
+	json_t								*js, *cur_elt, *cur_nm, *it_val;
+	json_error_t						 je;
+	struct dynamic_cfg_metric			*cur_metric;
+	struct dynamic_cfg_symbol			*cur_symbol;
+	struct dynamic_cfg_action			*cur_action;
 
 	if (data->prev_data) {
 		jb = data->prev_data;
@@ -226,9 +217,7 @@ json_config_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 
 	js = json_loads (jb->buf, &je);
 	if (!js) {
-		msg_err ("cannot load json data: parse error %s, on line %d",
-			je.text,
-			je.line);
+		msg_err ("cannot load json data: parse error %s, on line %d", je.text, je.line);
 		return;
 	}
 
@@ -253,12 +242,11 @@ json_config_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 
 		cur_nm = json_object_get (cur_elt, "metric");
 		if (!cur_nm || !json_is_string (cur_nm)) {
-			msg_err (
-				"loaded json metric object element has no 'metric' attribute");
+			msg_err ("loaded json metric object element has no 'metric' attribute");
 			continue;
 		}
 		cur_metric = g_slice_alloc0 (sizeof (struct dynamic_cfg_metric));
-		for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
+		for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
 			cur_metric->actions[i].value = -1.0;
 		}
 		cur_metric->name = g_strdup (json_string_value (cur_nm));
@@ -266,27 +254,18 @@ json_config_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 		/* Parse symbols */
 		if (cur_nm && json_is_array (cur_nm)) {
 			selts = json_array_size (cur_nm);
-			for (j = 0; j < selts; j++) {
+			for (j = 0; j < selts; j ++) {
 				it_val = json_array_get (cur_nm, j);
 				if (it_val && json_is_object (it_val)) {
-					if (json_object_get (it_val,
-						"name") && json_object_get (it_val, "value")) {
-						cur_symbol =
-							g_slice_alloc0 (sizeof (struct dynamic_cfg_symbol));
-						cur_symbol->name =
-							g_strdup (json_string_value (json_object_get (it_val,
-								"name")));
-						cur_symbol->value =
-							json_number_value (json_object_get (it_val,
-								"value"));
+					if (json_object_get (it_val, "name") && json_object_get (it_val, "value")) {
+						cur_symbol = g_slice_alloc0 (sizeof (struct dynamic_cfg_symbol));
+						cur_symbol->name = g_strdup (json_string_value (json_object_get (it_val, "name")));
+						cur_symbol->value = json_number_value (json_object_get (it_val, "value"));
 						/* Insert symbol */
-						cur_metric->symbols = g_list_prepend (
-							cur_metric->symbols,
-							cur_symbol);
+						cur_metric->symbols = g_list_prepend (cur_metric->symbols, cur_symbol);
 					}
 					else {
-						msg_info (
-							"json symbol object has no mandatory 'name' and 'value' attributes");
+						msg_info ("json symbol object has no mandatory 'name' and 'value' attributes");
 					}
 				}
 			}
@@ -295,29 +274,21 @@ json_config_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 		/* Parse actions */
 		if (cur_nm && json_is_array (cur_nm)) {
 			selts = json_array_size (cur_nm);
-			for (j = 0; j < selts; j++) {
+			for (j = 0; j < selts; j ++) {
 				it_val = json_array_get (cur_nm, j);
 				if (it_val && json_is_object (it_val)) {
-					if (json_object_get (it_val,
-						"name") && json_object_get (it_val, "value")) {
-						if (!check_action_str (json_string_value (
-								json_object_get (it_val, "name")), &test_act)) {
-							msg_err ("unknown action: %s",
-								json_string_value (json_object_get (it_val,
-								"name")));
-							g_slice_free1 (sizeof (struct dynamic_cfg_action),
-								cur_action);
+					if (json_object_get (it_val, "name") && json_object_get (it_val, "value")) {
+						if (!check_action_str (json_string_value (json_object_get (it_val, "name")), &test_act)) {
+							msg_err ("unknown action: %s", json_string_value (json_object_get (it_val, "name")));
+							g_slice_free1 (sizeof (struct dynamic_cfg_action), cur_action);
 							continue;
 						}
 						cur_action = &cur_metric->actions[test_act];
 						cur_action->action = test_act;
-						cur_action->value =
-							json_number_value (json_object_get (it_val,
-								"value"));
+						cur_action->value = json_number_value (json_object_get (it_val, "value"));
 					}
 					else {
-						msg_info (
-							"json symbol object has no mandatory 'name' and 'value' attributes");
+						msg_info ("json symbol object has no mandatory 'name' and 'value' attributes");
 					}
 				}
 			}
@@ -343,7 +314,7 @@ json_config_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 void
 init_dynamic_config (struct rspamd_config *cfg)
 {
-	struct config_json_buf *jb, **pjb;
+	struct config_json_buf				*jb, **pjb;
 
 	if (cfg->dynamic_conf == NULL) {
 		/* No dynamic conf has been specified, so do not try to load it */
@@ -356,8 +327,7 @@ init_dynamic_config (struct rspamd_config *cfg)
 	jb->buf = NULL;
 	jb->cfg = cfg;
 	*pjb = jb;
-	if (!add_map (cfg, cfg->dynamic_conf, "Dynamic configuration map",
-		json_config_read_cb, json_config_fin_cb, (void **)pjb)) {
+	if (!add_map (cfg, cfg->dynamic_conf, "Dynamic configuration map", json_config_read_cb, json_config_fin_cb, (void **)pjb)) {
 		msg_err ("cannot add map for configuration %s", cfg->dynamic_conf);
 	}
 }
@@ -365,13 +335,13 @@ init_dynamic_config (struct rspamd_config *cfg)
 static gboolean
 dump_dynamic_list (gint fd, GList *rules)
 {
-	GList *cur, *cur_elt;
-	struct dynamic_cfg_metric *metric;
-	struct dynamic_cfg_symbol *sym;
-	struct dynamic_cfg_action *act;
-	FILE *f;
-	gint i;
-	gboolean start = TRUE;
+	GList								*cur, *cur_elt;
+	struct dynamic_cfg_metric			*metric;
+	struct dynamic_cfg_symbol			*sym;
+	struct dynamic_cfg_action			*act;
+	FILE								*f;
+	gint                                 i;
+	gboolean                             start = TRUE;
 
 	/* Open buffered stream for the descriptor */
 	if ((f = fdopen (fd, "a+")) == NULL) {
@@ -393,16 +363,10 @@ dump_dynamic_list (gint fd, GList *rules)
 					sym = cur_elt->data;
 					cur_elt = g_list_next (cur_elt);
 					if (cur_elt) {
-						fprintf (f,
-							"    {\"name\": \"%s\",\"value\": %.2f},\n",
-							sym->name,
-							sym->value);
+						fprintf (f, "    {\"name\": \"%s\",\"value\": %.2f},\n", sym->name, sym->value);
 					}
 					else {
-						fprintf (f,
-							"    {\"name\": \"%s\",\"value\": %.2f}\n",
-							sym->name,
-							sym->value);
+						fprintf (f, "    {\"name\": \"%s\",\"value\": %.2f}\n", sym->name, sym->value);
 					}
 				}
 				if (metric->actions) {
@@ -415,14 +379,13 @@ dump_dynamic_list (gint fd, GList *rules)
 
 			if (metric->actions) {
 				fprintf (f, "  \"actions\": [\n");
-				for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
+				for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i ++) {
 					act = &metric->actions[i];
 					if (act->value < 0) {
 						continue;
 					}
 					fprintf (f, "    %s{\"name\": \"%s\",\"value\": %.2f}\n",
-						(start ? "" : ","), str_action_metric (
-							act->action), act->value);
+							(start ? "" : ","), str_action_metric (act->action), act->value);
 					if (start) {
 						start = FALSE;
 					}
@@ -451,9 +414,9 @@ dump_dynamic_list (gint fd, GList *rules)
 gboolean
 dump_dynamic_config (struct rspamd_config *cfg)
 {
-	struct stat st;
-	gchar *dir, pathbuf[PATH_MAX];
-	gint fd;
+	struct stat							 st;
+	gchar								*dir, pathbuf[PATH_MAX];
+	gint								 fd;
 
 	if (cfg->dynamic_conf == NULL || cfg->current_dynamic_conf == NULL) {
 		/* No dynamic conf has been specified, so do not try to dump it */
@@ -471,20 +434,15 @@ dump_dynamic_config (struct rspamd_config *cfg)
 	}
 
 	if (stat (cfg->dynamic_conf, &st) == -1) {
-		msg_debug ("%s is unavailable: %s", cfg->dynamic_conf,
-			strerror (errno));
-		st.st_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+		msg_debug ("%s is unavailable: %s", cfg->dynamic_conf, strerror (errno));
+		st.st_mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
 	}
 	if (access (dir, W_OK | R_OK) == -1) {
 		msg_warn ("%s is inaccessible: %s", dir, strerror (errno));
 		g_free (dir);
 		return FALSE;
 	}
-	rspamd_snprintf (pathbuf,
-		sizeof (pathbuf),
-		"%s%crconf-XXXXXX",
-		dir,
-		G_DIR_SEPARATOR);
+	rspamd_snprintf (pathbuf, sizeof (pathbuf), "%s%crconf-XXXXXX", dir, G_DIR_SEPARATOR);
 	g_free (dir);
 #ifdef HAVE_MKSTEMP
 	/* Umask is set before */
@@ -532,14 +490,11 @@ dump_dynamic_config (struct rspamd_config *cfg)
  * @return
  */
 gboolean
-add_dynamic_symbol (struct rspamd_config *cfg,
-	const gchar *metric_name,
-	const gchar *symbol,
-	gdouble value)
+add_dynamic_symbol (struct rspamd_config *cfg, const gchar *metric_name, const gchar *symbol, gdouble value)
 {
-	GList *cur;
-	struct dynamic_cfg_metric *metric = NULL;
-	struct dynamic_cfg_symbol *sym = NULL;
+	GList								*cur;
+	struct dynamic_cfg_metric			*metric = NULL;
+	struct dynamic_cfg_symbol			*sym = NULL;
 
 	if (cfg->dynamic_conf == NULL) {
 		msg_info ("dynamic conf is disabled");
@@ -586,8 +541,7 @@ add_dynamic_symbol (struct rspamd_config *cfg,
 		sym->value = value;
 		metric->symbols = g_list_prepend (metric->symbols, sym);
 		metric->name = g_strdup (metric_name);
-		cfg->current_dynamic_conf = g_list_prepend (cfg->current_dynamic_conf,
-				metric);
+		cfg->current_dynamic_conf = g_list_prepend (cfg->current_dynamic_conf, metric);
 		msg_debug ("create metric %s for symbol %s", metric_name, symbol);
 	}
 
@@ -606,13 +560,10 @@ add_dynamic_symbol (struct rspamd_config *cfg,
  * @return
  */
 gboolean
-add_dynamic_action (struct rspamd_config *cfg,
-	const gchar *metric_name,
-	guint action,
-	gdouble value)
+add_dynamic_action (struct rspamd_config *cfg, const gchar *metric_name, guint action, gdouble value)
 {
-	GList *cur;
-	struct dynamic_cfg_metric *metric = NULL;
+	GList								*cur;
+	struct dynamic_cfg_metric			*metric = NULL;
 
 	if (cfg->dynamic_conf == NULL) {
 		msg_info ("dynamic conf is disabled");
@@ -638,8 +589,7 @@ add_dynamic_action (struct rspamd_config *cfg,
 		metric = g_slice_alloc0 (sizeof (struct dynamic_cfg_metric));
 		metric->actions[action].value = value;
 		metric->name = g_strdup (metric_name);
-		cfg->current_dynamic_conf = g_list_prepend (cfg->current_dynamic_conf,
-				metric);
+		cfg->current_dynamic_conf = g_list_prepend (cfg->current_dynamic_conf, metric);
 		msg_debug ("create metric %s for action %d", metric_name, action);
 	}
 
diff --git a/src/libserver/dynamic_cfg.h b/src/libserver/dynamic_cfg.h
index d69ee30f5..a8cb02ae5 100644
--- a/src/libserver/dynamic_cfg.h
+++ b/src/libserver/dynamic_cfg.h
@@ -25,8 +25,8 @@
 #ifndef DYNAMIC_CFG_H_
 #define DYNAMIC_CFG_H_
 
-#include "cfg_file.h"
 #include "config.h"
+#include "cfg_file.h"
 
 /**
  * Init dynamic configuration using map logic and specific configuration
@@ -49,10 +49,7 @@ gboolean dump_dynamic_config (struct rspamd_config *cfg);
  * @param value value of symbol
  * @return
  */
-gboolean add_dynamic_symbol (struct rspamd_config *cfg,
-	const gchar *metric,
-	const gchar *symbol,
-	gdouble value);
+gboolean add_dynamic_symbol (struct rspamd_config *cfg, const gchar *metric, const gchar *symbol, gdouble value);
 
 
 /**
@@ -63,10 +60,7 @@ gboolean add_dynamic_symbol (struct rspamd_config *cfg,
  * @param value value of symbol
  * @return
  */
-gboolean add_dynamic_action (struct rspamd_config *cfg,
-	const gchar *metric,
-	guint action,
-	gdouble value);
+gboolean add_dynamic_action (struct rspamd_config *cfg, const gchar *metric, guint action, gdouble value);
 
 
 #endif /* DYNAMIC_CFG_H_ */
diff --git a/src/libserver/events.c b/src/libserver/events.c
index f265de3fe..48dcb3444 100644
--- a/src/libserver/events.c
+++ b/src/libserver/events.c
@@ -23,13 +23,13 @@
  */
 
 #include "config.h"
-#include "events.h"
 #include "main.h"
+#include "events.h"
 
 static gboolean
 rspamd_event_equal (gconstpointer a, gconstpointer b)
 {
-	const struct rspamd_async_event *ev1 = a, *ev2 = b;
+	const struct rspamd_async_event  *ev1 = a, *ev2 = b;
 
 	if (ev1->fin == ev2->fin) {
 		return ev1->user_data == ev2->user_data;
@@ -41,7 +41,7 @@ rspamd_event_equal (gconstpointer a, gconstpointer b)
 static guint
 rspamd_event_hash (gconstpointer a)
 {
-	const struct rspamd_async_event *ev = a;
+	const struct rspamd_async_event  *ev = a;
 
 	return GPOINTER_TO_UINT (ev->user_data);
 }
@@ -50,7 +50,7 @@ rspamd_event_hash (gconstpointer a)
 static void
 event_mutex_free (gpointer data)
 {
-	GMutex *mtx = data;
+	GMutex						   *mtx = data;
 
 	g_mutex_free (mtx);
 }
@@ -58,17 +58,17 @@ event_mutex_free (gpointer data)
 static void
 event_cond_free (gpointer data)
 {
-	GCond *cond = data;
+	GCond						   *cond = data;
 
 	g_cond_free (cond);
 }
 #endif
 
-struct rspamd_async_session *
+struct rspamd_async_session    *
 new_async_session (rspamd_mempool_t * pool, session_finalizer_t fin,
-	event_finalizer_t restore, event_finalizer_t cleanup, void *user_data)
+		event_finalizer_t restore, event_finalizer_t cleanup, void *user_data)
 {
-	struct rspamd_async_session *new;
+	struct rspamd_async_session    *new;
 
 	new = rspamd_mempool_alloc (pool, sizeof (struct rspamd_async_session));
 	new->pool = pool;
@@ -81,40 +81,27 @@ new_async_session (rspamd_mempool_t * pool, session_finalizer_t fin,
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
 	new->mtx = g_mutex_new ();
 	new->cond = g_cond_new ();
-	rspamd_mempool_add_destructor (pool,
-		(rspamd_mempool_destruct_t) event_mutex_free,
-		new->mtx);
-	rspamd_mempool_add_destructor (pool,
-		(rspamd_mempool_destruct_t) event_cond_free,
-		new->cond);
+	rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) event_mutex_free, new->mtx);
+	rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) event_cond_free, new->cond);
 #else
 	new->mtx = rspamd_mempool_alloc (pool, sizeof (GMutex));
 	g_mutex_init (new->mtx);
 	new->cond = rspamd_mempool_alloc (pool, sizeof (GCond));
 	g_cond_init (new->cond);
-	rspamd_mempool_add_destructor (pool,
-		(rspamd_mempool_destruct_t) g_mutex_clear,
-		new->mtx);
-	rspamd_mempool_add_destructor (pool,
-		(rspamd_mempool_destruct_t) g_cond_clear,
-		new->cond);
+	rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_mutex_clear, new->mtx);
+	rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_cond_clear, new->cond);
 #endif
 	new->threads = 0;
 
-	rspamd_mempool_add_destructor (pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy,
-		new->events);
+	rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, new->events);
 
 	return new;
 }
 
 void
-register_async_event (struct rspamd_async_session *session,
-	event_finalizer_t fin,
-	void *user_data,
-	GQuark subsystem)
+register_async_event (struct rspamd_async_session *session, event_finalizer_t fin, void *user_data, GQuark subsystem)
 {
-	struct rspamd_async_event *new;
+	struct rspamd_async_event      *new;
 
 	if (session == NULL) {
 		msg_info ("session is NULL");
@@ -122,28 +109,23 @@ register_async_event (struct rspamd_async_session *session,
 	}
 
 	g_mutex_lock (session->mtx);
-	new = rspamd_mempool_alloc (session->pool,
-			sizeof (struct rspamd_async_event));
+	new = rspamd_mempool_alloc (session->pool, sizeof (struct rspamd_async_event));
 	new->fin = fin;
 	new->user_data = user_data;
 	new->subsystem = subsystem;
 
 	g_hash_table_insert (session->events, new, new);
 
-	msg_debug ("added event: %p, pending %d events, subsystem: %s",
-		user_data,
-		g_hash_table_size (session->events),
-		g_quark_to_string (subsystem));
+	msg_debug ("added event: %p, pending %d events, subsystem: %s", user_data, g_hash_table_size (session->events),
+			g_quark_to_string (subsystem));
 
 	g_mutex_unlock (session->mtx);
 }
 
 void
-remove_normal_event (struct rspamd_async_session *session,
-	event_finalizer_t fin,
-	void *ud)
+remove_normal_event (struct rspamd_async_session *session, event_finalizer_t fin, void *ud)
 {
-	struct rspamd_async_event search_ev, *found_ev;
+	struct rspamd_async_event       search_ev, *found_ev;
 
 	if (session == NULL) {
 		msg_info ("session is NULL");
@@ -154,12 +136,10 @@ remove_normal_event (struct rspamd_async_session *session,
 	/* Search for event */
 	search_ev.fin = fin;
 	search_ev.user_data = ud;
-	if ((found_ev =
-		g_hash_table_lookup (session->events, &search_ev)) != NULL) {
+	if ((found_ev = g_hash_table_lookup (session->events, &search_ev)) != NULL) {
 		g_hash_table_remove (session->events, found_ev);
 		msg_debug ("removed event: %p, subsystem: %s, pending %d events", ud,
-			g_quark_to_string (found_ev->subsystem),
-			g_hash_table_size (session->events));
+			g_quark_to_string (found_ev->subsystem), g_hash_table_size (session->events));
 		/* Remove event */
 		fin (ud);
 	}
@@ -171,11 +151,11 @@ remove_normal_event (struct rspamd_async_session *session,
 static gboolean
 rspamd_session_destroy (gpointer k, gpointer v, gpointer unused)
 {
-	struct rspamd_async_event *ev = v;
+	struct rspamd_async_event      *ev = v;
 
 	/* Call event's finalizer */
 	msg_debug ("removed event on destroy: %p, subsystem: %s", ev->user_data,
-		g_quark_to_string (ev->subsystem));
+			g_quark_to_string (ev->subsystem));
 
 	if (ev->fin != NULL) {
 		ev->fin (ev->user_data);
@@ -194,16 +174,14 @@ destroy_session (struct rspamd_async_session *session)
 
 	g_mutex_lock (session->mtx);
 	if (session->threads > 0) {
-		/* Wait for conditional variable to finish processing */
+	/* Wait for conditional variable to finish processing */
 		g_mutex_unlock (session->mtx);
 		g_cond_wait (session->cond, session->mtx);
 	}
 
 	session->wanna_die = TRUE;
 
-	g_hash_table_foreach_remove (session->events,
-		rspamd_session_destroy,
-		session);
+	g_hash_table_foreach_remove (session->events, rspamd_session_destroy, session);
 
 	/* Mutex can be destroyed here */
 	g_mutex_unlock (session->mtx);
@@ -226,7 +204,7 @@ check_session_pending (struct rspamd_async_session *session)
 		}
 		if (session->fin != NULL) {
 			g_mutex_unlock (session->mtx);
-			if (!session->fin (session->user_data)) {
+			if (! session->fin (session->user_data)) {
 				/* Session finished incompletely, perform restoration */
 				if (session->restore != NULL) {
 					session->restore (session->user_data);
diff --git a/src/libserver/events.h b/src/libserver/events.h
index 166cd7138..6728288eb 100644
--- a/src/libserver/events.h
+++ b/src/libserver/events.h
@@ -38,9 +38,9 @@ struct rspamd_async_session {
  * @param user_data abstract user data
  * @return
  */
-struct rspamd_async_session * new_async_session (rspamd_mempool_t *pool,
-	session_finalizer_t fin, event_finalizer_t restore,
-	event_finalizer_t cleanup, void *user_data);
+struct rspamd_async_session *new_async_session (rspamd_mempool_t *pool,
+		session_finalizer_t fin, event_finalizer_t restore,
+		event_finalizer_t cleanup, void *user_data);
 
 /**
  * Insert new event to the session
@@ -50,7 +50,7 @@ struct rspamd_async_session * new_async_session (rspamd_mempool_t *pool,
  * @param forced unused
  */
 void register_async_event (struct rspamd_async_session *session,
-	event_finalizer_t fin, void *user_data, GQuark subsystem);
+		event_finalizer_t fin, void *user_data, GQuark subsystem);
 
 /**
  * Remove normal event
@@ -58,13 +58,11 @@ void register_async_event (struct rspamd_async_session *session,
  * @param fin final callback
  * @param ud user data object
  */
-void remove_normal_event (struct rspamd_async_session *session,
-	event_finalizer_t fin,
-	void *ud);
+void remove_normal_event (struct rspamd_async_session *session, event_finalizer_t fin, void *ud); 
 
 /**
  * Must be called at the end of session, it calls fin functions for all non-forced callbacks
- * @return true if the whole session was destroyed and false if there are forced events
+ * @return true if the whole session was destroyed and false if there are forced events 
  */
 gboolean destroy_session (struct rspamd_async_session *session);
 
diff --git a/src/libserver/html.c b/src/libserver/html.c
index 0b7b584f5..028c54f6c 100644
--- a/src/libserver/html.c
+++ b/src/libserver/html.c
@@ -23,15 +23,15 @@
  */
 
 #include "config.h"
-#include "html.h"
+#include "util.h"
 #include "main.h"
 #include "message.h"
+#include "html.h"
 #include "url.h"
-#include "util.h"
 
-static sig_atomic_t tags_sorted = 0;
+static sig_atomic_t                    tags_sorted = 0;
 
-static struct html_tag tag_defs[] = {
+static struct html_tag          tag_defs[] = {
 	/* W3C defined elements */
 	{Tag_A, "a", (CM_INLINE)},
 	{Tag_ABBR, "abbr", (CM_INLINE)},
@@ -93,8 +93,7 @@ static struct html_tag tag_defs[] = {
 	{Tag_META, "meta", (CM_HEAD | CM_EMPTY)},
 	{Tag_NOFRAMES, "noframes", (CM_BLOCK | CM_FRAMES)},
 	{Tag_NOSCRIPT, "noscript", (CM_BLOCK | CM_INLINE | CM_MIXED)},
-	{Tag_OBJECT, "object",
-	 (CM_OBJECT | CM_HEAD | CM_IMG | CM_INLINE | CM_PARAM)},
+	{Tag_OBJECT, "object", (CM_OBJECT | CM_HEAD | CM_IMG | CM_INLINE | CM_PARAM)},
 	{Tag_OL, "ol", (CM_BLOCK)},
 	{Tag_OPTGROUP, "optgroup", (CM_FIELD | CM_OPT)},
 	{Tag_OPTION, "option", (CM_FIELD | CM_OPT)},
@@ -157,21 +156,21 @@ static struct html_tag tag_defs[] = {
 	{Tag_WBR, "wbr", (CM_INLINE | CM_EMPTY)},
 };
 
-static sig_atomic_t entities_sorted = 0;
+static sig_atomic_t                    entities_sorted = 0;
 struct _entity;
-typedef struct _entity entity;
+typedef struct _entity          entity;
 
 struct _entity {
-	gchar *name;
-	uint code;
-	gchar *replacement;
+	gchar                           *name;
+	uint                            code;
+	gchar                           *replacement;
 };
 
 
-static entity entities_defs[] = {
+static entity                   entities_defs[] = {
 	/*
-	** Markup pre-defined character entities
-	*/
+	 ** Markup pre-defined character entities
+	 */
 	{"quot", 34, "\""},
 	{"amp", 38, "&"},
 	{"apos", 39, "'"},
@@ -179,8 +178,8 @@ static entity entities_defs[] = {
 	{"gt", 62, ">"},
 
 	/*
-	** Latin-1 character entities
-	*/
+	 ** Latin-1 character entities
+	 */
 	{"nbsp", 160, " "},
 	{"iexcl", 161, "!"},
 	{"cent", 162, "cent"},
@@ -279,8 +278,8 @@ static entity entities_defs[] = {
 	{"yuml", 255, "y"},
 
 	/*
-	** Extended Entities defined in HTML 4: Symbols
-	*/
+	 ** Extended Entities defined in HTML 4: Symbols 
+	 */
 	{"fnof", 402, "f"},
 	{"Alpha", 913, "alpha"},
 	{"Beta", 914, "beta"},
@@ -407,8 +406,8 @@ static entity entities_defs[] = {
 	{"diams", 9830, NULL},
 
 	/*
-	** Extended Entities defined in HTML 4: Special (less Markup at top)
-	*/
+	 ** Extended Entities defined in HTML 4: Special (less Markup at top)
+	 */
 	{"OElig", 338, NULL},
 	{"oelig", 339, NULL},
 	{"Scaron", 352, NULL},
@@ -444,8 +443,8 @@ static entity entities_defs_num[ (G_N_ELEMENTS (entities_defs)) ];
 static gint
 tag_cmp (const void *m1, const void *m2)
 {
-	const struct html_tag *p1 = m1;
-	const struct html_tag *p2 = m2;
+	const struct html_tag          *p1 = m1;
+	const struct html_tag          *p2 = m2;
 
 	return g_ascii_strcasecmp (p1->name, p2->name);
 }
@@ -453,8 +452,8 @@ tag_cmp (const void *m1, const void *m2)
 static gint
 entity_cmp (const void *m1, const void *m2)
 {
-	const entity *p1 = m1;
-	const entity *p2 = m2;
+	const entity                   *p1 = m1;
+	const entity                   *p2 = m2;
 
 	return g_ascii_strcasecmp (p1->name, p2->name);
 }
@@ -462,19 +461,19 @@ entity_cmp (const void *m1, const void *m2)
 static gint
 entity_cmp_num (const void *m1, const void *m2)
 {
-	const entity *p1 = m1;
-	const entity *p2 = m2;
+	const entity                   *p1 = m1;
+	const entity                   *p2 = m2;
 
 	return p1->code - p2->code;
 }
 
-static GNode *
+static GNode                   *
 construct_html_node (rspamd_mempool_t * pool, gchar *text, gsize tag_len)
 {
-	struct html_node *html;
-	GNode *n = NULL;
-	struct html_tag key, *found;
-	gchar t;
+	struct html_node               *html;
+	GNode                          *n = NULL;
+	struct html_tag                 key, *found;
+	gchar                           t;
 
 	if (text == NULL || *text == '\0') {
 		return NULL;
@@ -488,8 +487,7 @@ construct_html_node (rspamd_mempool_t * pool, gchar *text, gsize tag_len)
 	}
 
 	/* Check xml tag */
-	if (*text == '?' &&
-		g_ascii_strncasecmp (text + 1, "xml", sizeof ("xml") - 1) == 0) {
+	if (*text == '?' && g_ascii_strncasecmp (text + 1, "xml", sizeof ("xml") - 1) == 0) {
 		html->flags |= FL_XML;
 		html->tag = NULL;
 	}
@@ -501,15 +499,13 @@ construct_html_node (rspamd_mempool_t * pool, gchar *text, gsize tag_len)
 
 		/* Find end of tag name */
 		key.name = text;
-		while (*text && g_ascii_isalnum (*(++text))) ;
+		while (*text && g_ascii_isalnum (*(++text)));
 
 		t = *text;
 		*text = '\0';
 
 		/* Match tag id by tag name */
-		if ((found =
-			bsearch (&key, tag_defs, G_N_ELEMENTS (tag_defs),
-			sizeof (struct html_tag), tag_cmp)) != NULL) {
+		if ((found = bsearch (&key, tag_defs, G_N_ELEMENTS (tag_defs), sizeof (struct html_tag), tag_cmp)) != NULL) {
 			*text = t;
 			html->tag = found;
 		}
@@ -524,20 +520,18 @@ construct_html_node (rspamd_mempool_t * pool, gchar *text, gsize tag_len)
 	return n;
 }
 
-static gboolean
+static                          gboolean
 check_balance (GNode * node, GNode ** cur_level)
 {
-	struct html_node *arg = node->data, *tmp;
-	GNode *cur;
+	struct html_node               *arg = node->data, *tmp;
+	GNode                          *cur;
 
 	if (arg->flags & FL_CLOSING) {
 		/* First of all check whether this tag is closing tag for parent node */
 		cur = node->parent;
 		while (cur && cur->data) {
 			tmp = cur->data;
-			if ((tmp->tag &&
-				arg->tag) && tmp->tag->id == arg->tag->id &&
-				(tmp->flags & FL_CLOSED) == 0) {
+			if ((tmp->tag && arg->tag) && tmp->tag->id == arg->tag->id && (tmp->flags & FL_CLOSED) == 0) {
 				tmp->flags |= FL_CLOSED;
 				/* Destroy current node as we find corresponding parent node */
 				g_node_destroy (node);
@@ -555,28 +549,27 @@ check_balance (GNode * node, GNode ** cur_level)
 	return FALSE;
 }
 
-struct html_tag *
+struct html_tag                *
 get_tag_by_name (const gchar *name)
 {
-	struct html_tag key;
+	struct html_tag                 key;
 
 	key.name = name;
 
-	return bsearch (&key, tag_defs, G_N_ELEMENTS (tag_defs),
-			   sizeof (struct html_tag), tag_cmp);
+	return bsearch (&key, tag_defs, G_N_ELEMENTS (tag_defs), sizeof (struct html_tag), tag_cmp);
 }
 
 /* Decode HTML entitles in text */
 void
 decode_entitles (gchar *s, guint * len)
 {
-	guint l, rep_len;
-	gchar *t = s;                           /* t - tortoise */
-	gchar *h = s;                           /* h - hare     */
-	gchar *e = s;
-	gchar *end_ptr;
-	gint state = 0, val, base;
-	entity *found, key;
+	guint                           l, rep_len;
+	gchar                           *t = s;	/* t - tortoise */
+	gchar                           *h = s;	/* h - hare     */
+	gchar                           *e = s;
+	gchar                           *end_ptr;
+	gint                            state = 0, val, base;
+	entity                         *found, key;
 
 	if (len == NULL || *len == 0) {
 		l = strlen (s);
@@ -587,7 +580,7 @@ decode_entitles (gchar *s, guint * len)
 
 	while (h - s < (gint)l) {
 		switch (state) {
-		/* Out of entitle */
+			/* Out of entitle */
 		case 0:
 			if (*h == '&') {
 				state = 1;
@@ -608,10 +601,7 @@ decode_entitles (gchar *s, guint * len)
 
 				key.name = e + 1;
 				*h = '\0';
-				if (*(e + 1) != '#' &&
-					(found =
-					bsearch (&key, entities_defs, G_N_ELEMENTS (entities_defs),
-					sizeof (entity), entity_cmp)) != NULL) {
+				if (*(e + 1) != '#' && (found = bsearch (&key, entities_defs, G_N_ELEMENTS (entities_defs), sizeof (entity), entity_cmp)) != NULL) {
 					if (found->replacement) {
 						rep_len = strlen (found->replacement);
 						memcpy (t, found->replacement, rep_len);
@@ -641,10 +631,7 @@ decode_entitles (gchar *s, guint * len)
 					else {
 						/* Search for a replacement */
 						key.code = val;
-						found =
-							bsearch (&key, entities_defs_num, G_N_ELEMENTS (
-									entities_defs), sizeof (entity),
-								entity_cmp_num);
+						found = bsearch (&key, entities_defs_num, G_N_ELEMENTS (entities_defs), sizeof (entity), entity_cmp_num);
 						if (found) {
 							if (found->replacement) {
 								rep_len = strlen (found->replacement);
@@ -669,19 +656,15 @@ decode_entitles (gchar *s, guint * len)
 }
 
 static void
-check_phishing (struct rspamd_task *task,
-	struct uri *href_url,
-	const gchar *url_text,
-	gsize remain,
-	tag_id_t id)
+check_phishing (struct rspamd_task *task, struct uri *href_url, const gchar *url_text, gsize remain, tag_id_t id)
 {
-	struct uri *new;
-	gchar *url_str;
-	const gchar *p, *c;
-	gchar tagbuf[128];
-	struct html_tag *tag;
-	gsize len = 0;
-	gint rc;
+	struct uri                     *new;
+	gchar                          *url_str;
+	const gchar                    *p, *c;
+	gchar                           tagbuf[128];
+	struct html_tag                *tag;
+	gsize                           len = 0;
+	gint                            rc;
 
 	p = url_text;
 	while (len < remain) {
@@ -695,8 +678,8 @@ check_phishing (struct rspamd_task *task,
 			}
 			while (len < remain) {
 				if (!g_ascii_isspace (*p) && *p != '>') {
-					p++;
-					len++;
+					p ++;
+					len ++;
 				}
 				else {
 					break;
@@ -710,11 +693,11 @@ check_phishing (struct rspamd_task *task,
 				else if (tag->id == Tag_IMG) {
 					/* We should ignore IMG tag here */
 					while (len < remain && *p != '>' && *p != '<') {
-						p++;
-						len++;
+						p ++;
+						len ++;
 					}
 					if (*p == '>' && len < remain) {
-						p++;
+						p ++;
 					}
 
 					remain -= p - url_text;
@@ -724,21 +707,19 @@ check_phishing (struct rspamd_task *task,
 				}
 			}
 		}
-		len++;
-		p++;
+		len ++;
+		p ++;
 	}
 
-	if (url_try_text (task->task_pool, url_text, len, NULL, NULL, &url_str,
-		TRUE) && url_str != NULL) {
+	if (url_try_text (task->task_pool, url_text, len, NULL, NULL, &url_str, TRUE) && url_str != NULL) {
 		new = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct uri));
 		if (new != NULL) {
 			g_strstrip (url_str);
 			rc = parse_uri (new, url_str, task->task_pool);
 
-			if (rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES || rc ==
-				URI_ERRNO_NO_HOST_SLASH) {
+			if (rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES || rc == URI_ERRNO_NO_HOST_SLASH) {
 				if (g_ascii_strncasecmp (href_url->host, new->host,
-					MAX (href_url->hostlen, new->hostlen)) != 0) {
+						MAX (href_url->hostlen, new->hostlen)) != 0) {
 					/* Special check for urls beginning with 'www' */
 					if (new->hostlen > 4 && href_url->hostlen > 4) {
 						p = new->host;
@@ -781,9 +762,7 @@ check_phishing (struct rspamd_task *task,
 				}
 			}
 			else {
-				msg_info ("extract of url '%s' failed: %s",
-					url_str,
-					url_strerror (rc));
+				msg_info ("extract of url '%s' failed: %s", url_str, url_strerror (rc));
 			}
 		}
 	}
@@ -791,17 +770,13 @@ check_phishing (struct rspamd_task *task,
 }
 
 static void
-parse_tag_url (struct rspamd_task *task,
-	struct mime_text_part *part,
-	tag_id_t id,
-	gchar *tag_text,
-	gsize tag_len,
-	gsize remain)
+parse_tag_url (struct rspamd_task *task, struct mime_text_part *part, tag_id_t id,
+		gchar *tag_text, gsize tag_len, gsize remain)
 {
-	gchar *c = NULL, *p, *url_text;
-	gint len, rc;
-	struct uri *url;
-	gboolean got_single_quote = FALSE, got_double_quote = FALSE;
+	gchar                           *c = NULL, *p, *url_text;
+	gint                            len, rc;
+	struct uri                     *url;
+	gboolean                        got_single_quote = FALSE, got_double_quote = FALSE;
 
 	/* For A tags search for href= and for IMG tags search for src= */
 	if (id == Tag_A) {
@@ -839,8 +814,7 @@ parse_tag_url (struct rspamd_task *task,
 					len++;
 				}
 			}
-			else if (g_ascii_isspace (*p) || *p == '>' ||
-				(*p == '/' && *(p + 1) == '>') || *p == '\r' || *p == '\n') {
+			else if (g_ascii_isspace (*p) || *p == '>' || (*p == '/' && *(p + 1) == '>') || *p == '\r' || *p == '\n') {
 				break;
 			}
 			else {
@@ -869,27 +843,22 @@ parse_tag_url (struct rspamd_task *task,
 		rspamd_strlcpy (url_text, c, len + 1);
 		decode_entitles (url_text, NULL);
 
-		if (g_ascii_strncasecmp (url_text, "http://",
-			sizeof ("http://") - 1) != 0 &&
-			g_ascii_strncasecmp (url_text, "www",
-			sizeof ("www") - 1) != 0 &&
-			g_ascii_strncasecmp (url_text, "ftp://",
-			sizeof ("ftp://") - 1) != 0 &&
-			g_ascii_strncasecmp (url_text, "mailto:",
-			sizeof ("mailto:") - 1) != 0) {
+		if (g_ascii_strncasecmp (url_text, "http://", sizeof ("http://") - 1) != 0 &&
+				g_ascii_strncasecmp (url_text, "www", sizeof ("www") - 1) != 0 &&
+				g_ascii_strncasecmp (url_text, "ftp://", sizeof ("ftp://") - 1) != 0 &&
+				g_ascii_strncasecmp (url_text, "mailto:", sizeof ("mailto:") - 1) != 0) {
 			return;
 		}
 
 		url = rspamd_mempool_alloc (task->task_pool, sizeof (struct uri));
 		rc = parse_uri (url, url_text, task->task_pool);
 
-		if (rc != URI_ERRNO_EMPTY && rc != URI_ERRNO_NO_HOST && url->hostlen !=
-			0) {
+		if (rc != URI_ERRNO_EMPTY && rc != URI_ERRNO_NO_HOST && url->hostlen != 0) {
 			/*
 			 * Check for phishing
 			 */
 			if ((p = strchr (c, '>')) != NULL && id == Tag_A) {
-				p++;
+				p ++;
 				check_phishing (task, url, p, remain - (p - tag_text), id);
 			}
 			if (g_tree_lookup (task->urls, url) == NULL) {
@@ -900,28 +869,20 @@ parse_tag_url (struct rspamd_task *task,
 }
 
 gboolean
-add_html_node (struct rspamd_task *task,
-	rspamd_mempool_t * pool,
-	struct mime_text_part *part,
-	gchar *tag_text,
-	gsize tag_len,
-	gsize remain,
-	GNode ** cur_level)
+add_html_node (struct rspamd_task *task, rspamd_mempool_t * pool, struct mime_text_part *part,
+		gchar *tag_text, gsize tag_len, gsize remain, GNode ** cur_level)
 {
-	GNode *new;
-	struct html_node *data;
+	GNode                          *new;
+	struct html_node               *data;
 
 	if (!tags_sorted) {
-		qsort (tag_defs, G_N_ELEMENTS (
-				tag_defs), sizeof (struct html_tag), tag_cmp);
+		qsort (tag_defs, G_N_ELEMENTS (tag_defs), sizeof (struct html_tag), tag_cmp);
 		tags_sorted = 1;
 	}
 	if (!entities_sorted) {
-		qsort (entities_defs, G_N_ELEMENTS (
-				entities_defs), sizeof (entity), entity_cmp);
+		qsort (entities_defs, G_N_ELEMENTS (entities_defs), sizeof (entity), entity_cmp);
 		memcpy (entities_defs_num, entities_defs, sizeof (entities_defs));
-		qsort (entities_defs_num, G_N_ELEMENTS (
-				entities_defs), sizeof (entity), entity_cmp_num);
+		qsort (entities_defs_num, G_N_ELEMENTS (entities_defs), sizeof (entity), entity_cmp_num);
 		entities_sorted = 1;
 	}
 
@@ -931,32 +892,19 @@ add_html_node (struct rspamd_task *task,
 		new = g_node_new (NULL);
 		*cur_level = new;
 		part->html_nodes = new;
-		rspamd_mempool_add_destructor (pool,
-			(rspamd_mempool_destruct_t) g_node_destroy,
-			part->html_nodes);
+		rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_node_destroy, part->html_nodes);
 		/* Call once again with root node */
-		return add_html_node (task,
-				   pool,
-				   part,
-				   tag_text,
-				   tag_len,
-				   remain,
-				   cur_level);
+		return add_html_node (task, pool, part, tag_text, tag_len, remain, cur_level);
 	}
 	else {
 		new = construct_html_node (pool, tag_text, tag_len);
 		if (new == NULL) {
-			debug_task ("cannot construct HTML node for text '%*s'",
-				tag_len,
-				tag_text);
+			debug_task ("cannot construct HTML node for text '%*s'", tag_len, tag_text);
 			return FALSE;
 		}
 		data = new->data;
-		if (data->tag &&
-			(data->tag->id == Tag_A ||
-			data->tag->id == Tag_IMG) && ((data->flags & FL_CLOSING) == 0)) {
-			parse_tag_url (task, part, data->tag->id, tag_text, tag_len,
-				remain);
+		if (data->tag && (data->tag->id == Tag_A || data->tag->id == Tag_IMG) && ((data->flags & FL_CLOSING) == 0)) {
+			parse_tag_url (task, part, data->tag->id, tag_text, tag_len, remain);
 		}
 
 		if (data->flags & FL_CLOSING) {
@@ -966,8 +914,7 @@ add_html_node (struct rspamd_task *task,
 			}
 			g_node_append (*cur_level, new);
 			if (!check_balance (new, cur_level)) {
-				debug_task (
-					"mark part as unbalanced as it has not pairable closing tags");
+				debug_task ("mark part as unbalanced as it has not pairable closing tags");
 				part->is_balanced = FALSE;
 			}
 		}
@@ -979,9 +926,9 @@ add_html_node (struct rspamd_task *task,
 			}
 			/* Skip some tags */
 			if (data->tag && (data->tag->id == Tag_STYLE ||
-				data->tag->id == Tag_SCRIPT ||
-				data->tag->id == Tag_OBJECT ||
-				data->tag->id == Tag_TITLE)) {
+							  data->tag->id == Tag_SCRIPT ||
+							  data->tag->id == Tag_OBJECT ||
+							  data->tag->id == Tag_TITLE)) {
 				return FALSE;
 			}
 		}
diff --git a/src/libserver/html.h b/src/libserver/html.h
index 6709ed151..3ea758e60 100644
--- a/src/libserver/html.h
+++ b/src/libserver/html.h
@@ -11,129 +11,129 @@
 /* Known HTML tags */
 typedef enum
 {
-	Tag_UNKNOWN, /**< Unknown tag! */
-	Tag_A,      /**< A */
-	Tag_ABBR,   /**< ABBR */
-	Tag_ACRONYM, /**< ACRONYM */
-	Tag_ADDRESS, /**< ADDRESS */
-	Tag_ALIGN,  /**< ALIGN */
-	Tag_APPLET, /**< APPLET */
-	Tag_AREA,   /**< AREA */
-	Tag_B,      /**< B */
-	Tag_BASE,   /**< BASE */
-	Tag_BASEFONT, /**< BASEFONT */
-	Tag_BDO,    /**< BDO */
-	Tag_BGSOUND, /**< BGSOUND */
-	Tag_BIG,    /**< BIG */
-	Tag_BLINK,  /**< BLINK */
-	Tag_BLOCKQUOTE, /**< BLOCKQUOTE */
-	Tag_BODY,   /**< BODY */
-	Tag_BR,     /**< BR */
-	Tag_BUTTON, /**< BUTTON */
-	Tag_CAPTION, /**< CAPTION */
-	Tag_CENTER, /**< CENTER */
-	Tag_CITE,   /**< CITE */
-	Tag_CODE,   /**< CODE */
-	Tag_COL,    /**< COL */
-	Tag_COLGROUP, /**< COLGROUP */
-	Tag_COMMENT, /**< COMMENT */
-	Tag_DD,     /**< DD */
-	Tag_DEL,    /**< DEL */
-	Tag_DFN,    /**< DFN */
-	Tag_DIR,    /**< DIR */
-	Tag_DIV,    /**< DIF */
-	Tag_DL,     /**< DL */
-	Tag_DT,     /**< DT */
-	Tag_EM,     /**< EM */
-	Tag_EMBED,  /**< EMBED */
-	Tag_FIELDSET, /**< FIELDSET */
-	Tag_FONT,   /**< FONT */
-	Tag_FORM,   /**< FORM */
-	Tag_FRAME,  /**< FRAME */
-	Tag_FRAMESET, /**< FRAMESET */
-	Tag_H1,     /**< H1 */
-	Tag_H2,     /**< H2 */
-	Tag_H3,     /**< H3 */
-	Tag_H4,     /**< H4 */
-	Tag_H5,     /**< H5 */
-	Tag_H6,     /**< H6 */
-	Tag_HEAD,   /**< HEAD */
-	Tag_HR,     /**< HR */
-	Tag_HTML,   /**< HTML */
-	Tag_I,      /**< I */
-	Tag_IFRAME, /**< IFRAME */
-	Tag_ILAYER, /**< ILAYER */
-	Tag_IMG,    /**< IMG */
-	Tag_INPUT,  /**< INPUT */
-	Tag_INS,    /**< INS */
-	Tag_ISINDEX, /**< ISINDEX */
-	Tag_KBD,    /**< KBD */
-	Tag_KEYGEN, /**< KEYGEN */
-	Tag_LABEL,  /**< LABEL */
-	Tag_LAYER,  /**< LAYER */
-	Tag_LEGEND, /**< LEGEND */
-	Tag_LI,     /**< LI */
-	Tag_LINK,   /**< LINK */
-	Tag_LISTING, /**< LISTING */
-	Tag_MAP,    /**< MAP */
-	Tag_MARQUEE, /**< MARQUEE */
-	Tag_MENU,   /**< MENU */
-	Tag_META,   /**< META */
-	Tag_MULTICOL, /**< MULTICOL */
-	Tag_NOBR,   /**< NOBR */
-	Tag_NOEMBED, /**< NOEMBED */
-	Tag_NOFRAMES, /**< NOFRAMES */
-	Tag_NOLAYER, /**< NOLAYER */
-	Tag_NOSAVE, /**< NOSAVE */
-	Tag_NOSCRIPT, /**< NOSCRIPT */
-	Tag_OBJECT, /**< OBJECT */
-	Tag_OL,     /**< OL */
-	Tag_OPTGROUP, /**< OPTGROUP */
-	Tag_OPTION, /**< OPTION */
-	Tag_P,      /**< P */
-	Tag_PARAM,  /**< PARAM */
-	Tag_PLAINTEXT, /**< PLAINTEXT */
-	Tag_PRE,    /**< PRE */
-	Tag_Q,      /**< Q */
-	Tag_RB,     /**< RB */
-	Tag_RBC,    /**< RBC */
-	Tag_RP,     /**< RP */
-	Tag_RT,     /**< RT */
-	Tag_RTC,    /**< RTC */
-	Tag_RUBY,   /**< RUBY */
-	Tag_S,      /**< S */
-	Tag_SAMP,   /**< SAMP */
-	Tag_SCRIPT, /**< SCRIPT */
-	Tag_SELECT, /**< SELECT */
-	Tag_SERVER, /**< SERVER */
-	Tag_SERVLET, /**< SERVLET */
-	Tag_SMALL,  /**< SMALL */
-	Tag_SPACER, /**< SPACER */
-	Tag_SPAN,   /**< SPAN */
-	Tag_STRIKE, /**< STRIKE */
-	Tag_STRONG, /**< STRONG */
-	Tag_STYLE,  /**< STYLE */
-	Tag_SUB,    /**< SUB */
-	Tag_SUP,    /**< SUP */
-	Tag_TABLE,  /**< TABLE */
-	Tag_TBODY,  /**< TBODY */
-	Tag_TD,     /**< TD */
-	Tag_TEXTAREA, /**< TEXTAREA */
-	Tag_TFOOT,  /**< TFOOT */
-	Tag_TH,     /**< TH */
-	Tag_THEAD,  /**< THEAD */
-	Tag_TITLE,  /**< TITLE */
-	Tag_TR,     /**< TR */
-	Tag_TT,     /**< TT */
-	Tag_U,      /**< U */
-	Tag_UL,     /**< UL */
-	Tag_VAR,    /**< VAR */
-	Tag_WBR,    /**< WBR */
-	Tag_XMP,    /**< XMP */
-	Tag_XML,    /**< XML */
-	Tag_NEXTID, /**< NEXTID */
+  Tag_UNKNOWN,  /**< Unknown tag! */
+  Tag_A,        /**< A */
+  Tag_ABBR,     /**< ABBR */
+  Tag_ACRONYM,  /**< ACRONYM */
+  Tag_ADDRESS,  /**< ADDRESS */
+  Tag_ALIGN,    /**< ALIGN */
+  Tag_APPLET,   /**< APPLET */
+  Tag_AREA,     /**< AREA */
+  Tag_B,        /**< B */
+  Tag_BASE,     /**< BASE */
+  Tag_BASEFONT, /**< BASEFONT */
+  Tag_BDO,      /**< BDO */
+  Tag_BGSOUND,  /**< BGSOUND */
+  Tag_BIG,      /**< BIG */
+  Tag_BLINK,    /**< BLINK */
+  Tag_BLOCKQUOTE,   /**< BLOCKQUOTE */
+  Tag_BODY,     /**< BODY */
+  Tag_BR,       /**< BR */
+  Tag_BUTTON,   /**< BUTTON */
+  Tag_CAPTION,  /**< CAPTION */
+  Tag_CENTER,   /**< CENTER */
+  Tag_CITE,     /**< CITE */
+  Tag_CODE,     /**< CODE */
+  Tag_COL,      /**< COL */
+  Tag_COLGROUP, /**< COLGROUP */
+  Tag_COMMENT,  /**< COMMENT */
+  Tag_DD,       /**< DD */
+  Tag_DEL,      /**< DEL */
+  Tag_DFN,      /**< DFN */
+  Tag_DIR,      /**< DIR */
+  Tag_DIV,      /**< DIF */
+  Tag_DL,       /**< DL */
+  Tag_DT,       /**< DT */
+  Tag_EM,       /**< EM */
+  Tag_EMBED,    /**< EMBED */
+  Tag_FIELDSET, /**< FIELDSET */
+  Tag_FONT,     /**< FONT */
+  Tag_FORM,     /**< FORM */
+  Tag_FRAME,    /**< FRAME */
+  Tag_FRAMESET, /**< FRAMESET */
+  Tag_H1,       /**< H1 */
+  Tag_H2,       /**< H2 */
+  Tag_H3,       /**< H3 */
+  Tag_H4,       /**< H4 */
+  Tag_H5,       /**< H5 */
+  Tag_H6,       /**< H6 */
+  Tag_HEAD,     /**< HEAD */
+  Tag_HR,       /**< HR */
+  Tag_HTML,     /**< HTML */
+  Tag_I,        /**< I */
+  Tag_IFRAME,   /**< IFRAME */
+  Tag_ILAYER,   /**< ILAYER */
+  Tag_IMG,      /**< IMG */
+  Tag_INPUT,    /**< INPUT */
+  Tag_INS,      /**< INS */
+  Tag_ISINDEX,  /**< ISINDEX */
+  Tag_KBD,      /**< KBD */
+  Tag_KEYGEN,   /**< KEYGEN */
+  Tag_LABEL,    /**< LABEL */
+  Tag_LAYER,    /**< LAYER */
+  Tag_LEGEND,   /**< LEGEND */
+  Tag_LI,       /**< LI */
+  Tag_LINK,     /**< LINK */
+  Tag_LISTING,  /**< LISTING */
+  Tag_MAP,      /**< MAP */
+  Tag_MARQUEE,  /**< MARQUEE */
+  Tag_MENU,     /**< MENU */
+  Tag_META,     /**< META */
+  Tag_MULTICOL, /**< MULTICOL */
+  Tag_NOBR,     /**< NOBR */
+  Tag_NOEMBED,  /**< NOEMBED */
+  Tag_NOFRAMES, /**< NOFRAMES */
+  Tag_NOLAYER,  /**< NOLAYER */
+  Tag_NOSAVE,   /**< NOSAVE */
+  Tag_NOSCRIPT, /**< NOSCRIPT */
+  Tag_OBJECT,   /**< OBJECT */
+  Tag_OL,       /**< OL */
+  Tag_OPTGROUP, /**< OPTGROUP */
+  Tag_OPTION,   /**< OPTION */
+  Tag_P,        /**< P */
+  Tag_PARAM,    /**< PARAM */
+  Tag_PLAINTEXT,/**< PLAINTEXT */
+  Tag_PRE,      /**< PRE */
+  Tag_Q,        /**< Q */
+  Tag_RB,       /**< RB */
+  Tag_RBC,      /**< RBC */
+  Tag_RP,       /**< RP */
+  Tag_RT,       /**< RT */
+  Tag_RTC,      /**< RTC */
+  Tag_RUBY,     /**< RUBY */
+  Tag_S,        /**< S */
+  Tag_SAMP,     /**< SAMP */
+  Tag_SCRIPT,   /**< SCRIPT */
+  Tag_SELECT,   /**< SELECT */
+  Tag_SERVER,   /**< SERVER */
+  Tag_SERVLET,  /**< SERVLET */
+  Tag_SMALL,    /**< SMALL */
+  Tag_SPACER,   /**< SPACER */
+  Tag_SPAN,     /**< SPAN */
+  Tag_STRIKE,   /**< STRIKE */
+  Tag_STRONG,   /**< STRONG */
+  Tag_STYLE,    /**< STYLE */
+  Tag_SUB,      /**< SUB */
+  Tag_SUP,      /**< SUP */
+  Tag_TABLE,    /**< TABLE */
+  Tag_TBODY,    /**< TBODY */
+  Tag_TD,       /**< TD */
+  Tag_TEXTAREA, /**< TEXTAREA */
+  Tag_TFOOT,    /**< TFOOT */
+  Tag_TH,       /**< TH */
+  Tag_THEAD,    /**< THEAD */
+  Tag_TITLE,    /**< TITLE */
+  Tag_TR,       /**< TR */
+  Tag_TT,       /**< TT */
+  Tag_U,        /**< U */
+  Tag_UL,       /**< UL */
+  Tag_VAR,      /**< VAR */
+  Tag_WBR,      /**< WBR */
+  Tag_XMP,      /**< XMP */
+  Tag_XML,		/**< XML */
+  Tag_NEXTID,   /**< NEXTID */
 
-	N_TAGS      /**< Must be last */
+  N_TAGS        /**< Must be last */
 } tag_id_t;
 
 #define CM_UNKNOWN      0
@@ -175,7 +175,7 @@ typedef enum
 #define CM_IMG          (1 << 16)
 /* Elements with inline and block model. Used to avoid calling InlineDup. */
 #define CM_MIXED        (1 << 17)
-/* Elements whose content needs to be indented only if containing one
+/* Elements whose content needs to be indented only if containing one 
    CM_BLOCK element. */
 #define CM_NO_INDENT    (1 << 18)
 /* Elements that are obsolete (such as "dir", "menu"). */
@@ -187,11 +187,11 @@ typedef enum
 #define CM_OMITST       (1 << 21)
 
 /* XML tag */
-#define FL_XML          (1 << 0)
+#define FL_XML			(1 << 0)
 /* Closing tag */
-#define FL_CLOSING      (1 << 1)
+#define FL_CLOSING		(1 << 1)
 /* Fully closed tag (e.g. <a attrs />) */
-#define FL_CLOSED       (1 << 2)
+#define FL_CLOSED		(1 << 2)
 
 struct html_tag {
 	tag_id_t id;
@@ -210,13 +210,8 @@ struct rspamd_task;
 /*
  * Add a single node to the tags tree
  */
-gboolean add_html_node (struct rspamd_task *task,
-	rspamd_mempool_t *pool,
-	struct mime_text_part *part,
-	gchar *tag_text,
-	gsize tag_len,
-	gsize remain,
-	GNode **cur_level);
+gboolean add_html_node (struct rspamd_task *task, rspamd_mempool_t *pool,
+		struct mime_text_part *part, gchar *tag_text, gsize tag_len, gsize remain, GNode **cur_level);
 
 /*
  * Get tag structure by its name (binary search is used)
diff --git a/src/libserver/protocol.c b/src/libserver/protocol.c
index 30a155229..fc4096f8c 100644
--- a/src/libserver/protocol.c
+++ b/src/libserver/protocol.c
@@ -22,11 +22,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
 #include "main.h"
-#include "message.h"
 #include "util.h"
+#include "cfg_file.h"
+#include "message.h"
 
 /* Max line size */
 #define OUTBUFSIZ BUFSIZ
@@ -35,7 +35,7 @@
  * described below
  */
 #define MSG_CMD_CHECK "check"
-/*
+/* 
  * Check if message is spam or not, and return score plus list
  * of symbols hit
  */
@@ -95,7 +95,7 @@
 #define DELIVER_TO_HEADER "Deliver-To"
 #define NO_LOG_HEADER "Log"
 
-static GList *custom_commands = NULL;
+static GList                   *custom_commands = NULL;
 
 
 /*
@@ -104,22 +104,20 @@ static GList *custom_commands = NULL;
 static gchar *
 rspamd_protocol_escape_braces (GString *in)
 {
-	gint len = 0;
-	gchar *orig, *p;
+	gint                          len = 0;
+	gchar                        *orig, *p;
 
 	orig = in->str;
-	while ((g_ascii_isspace (*orig) || *orig ==
-		'<') && orig - in->str < (gint)in->len) {
-		orig++;
+	while ((g_ascii_isspace (*orig) || *orig == '<') && orig - in->str < (gint)in->len) {
+		orig ++;
 	}
 
 	g_string_erase (in, 0, orig - in->str);
 
 	p = in->str;
-	while ((!g_ascii_isspace (*p) && *p !=
-		'>') && p - in->str < (gint)in->len) {
-		p++;
-		len++;
+	while ((!g_ascii_isspace (*p) && *p != '>') && p - in->str < (gint)in->len) {
+		p ++;
+		len ++;
 	}
 
 	g_string_truncate (in, len);
@@ -128,11 +126,10 @@ rspamd_protocol_escape_braces (GString *in)
 }
 
 static gboolean
-rspamd_protocol_handle_url (struct rspamd_task *task,
-	struct rspamd_http_message *msg)
+rspamd_protocol_handle_url (struct rspamd_task *task, struct rspamd_http_message *msg)
 {
-	GList *cur;
-	struct custom_command *cmd;
+	GList                          *cur;
+	struct custom_command          *cmd;
 	const gchar *p;
 
 	if (msg->url == NULL || msg->url->len == 0) {
@@ -227,14 +224,13 @@ err:
 
 gboolean
 rspamd_protocol_handle_headers (struct rspamd_task *task,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	gchar *headern, *err, *tmp;
-	gboolean res = TRUE;
-	struct rspamd_http_header *h;
+	gchar                           *headern, *err, *tmp;
+	gboolean                         res = TRUE;
+	struct rspamd_http_header      *h;
 
-	LL_FOREACH (msg->headers, h)
-	{
+	LL_FOREACH (msg->headers, h) {
 		headern = h->name->str;
 
 		switch (headern[0]) {
@@ -242,8 +238,7 @@ rspamd_protocol_handle_headers (struct rspamd_task *task,
 		case 'D':
 			if (g_ascii_strcasecmp (headern, DELIVER_TO_HEADER) == 0) {
 				task->deliver_to = rspamd_protocol_escape_braces (h->value);
-				debug_task ("read deliver-to header, value: %s",
-					task->deliver_to);
+				debug_task ("read deliver-to header, value: %s", task->deliver_to);
 			}
 			else {
 				debug_task ("wrong header: %s", headern);
@@ -332,7 +327,7 @@ rspamd_protocol_handle_headers (struct rspamd_task *task,
 		case 'P':
 			if (g_ascii_strcasecmp (headern, PASS_HEADER) == 0) {
 				if (h->value->len == sizeof ("all") - 1 &&
-					g_ascii_strcasecmp (h->value->str, "all") == 0) {
+						g_ascii_strcasecmp (h->value->str, "all") == 0) {
 					task->pass_all_filters = TRUE;
 					debug_task ("pass all filters");
 				}
@@ -378,8 +373,7 @@ rspamd_protocol_handle_headers (struct rspamd_task *task,
 	}
 
 	if (!res && task->cfg->strict_protocol_headers) {
-		msg_err (
-			"deny processing of a request with incorrect or unknown headers");
+		msg_err ("deny processing of a request with incorrect or unknown headers");
 		task->last_error = "invalid header";
 		task->error_code = 400;
 		return FALSE;
@@ -390,7 +384,7 @@ rspamd_protocol_handle_headers (struct rspamd_task *task,
 
 gboolean
 rspamd_protocol_handle_request (struct rspamd_task *task,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
 	gboolean ret = TRUE;
 
@@ -413,22 +407,19 @@ rspamd_protocol_handle_request (struct rspamd_task *task,
 static void
 write_hashes_to_log (struct rspamd_task *task, GString *logbuf)
 {
-	GList *cur;
-	struct mime_text_part *text_part;
-
+	GList                          *cur;
+	struct mime_text_part          *text_part;
+	
 	cur = task->text_parts;
 
 	while (cur) {
 		text_part = cur->data;
 		if (text_part->fuzzy) {
 			if (cur->next != NULL) {
-				rspamd_printf_gstring (logbuf,
-					" part: %Xd,",
-					text_part->fuzzy->h);
+				rspamd_printf_gstring (logbuf, " part: %Xd,", text_part->fuzzy->h);
 			}
 			else {
-				rspamd_printf_gstring (logbuf, " part: %Xd",
-					text_part->fuzzy->h);
+				rspamd_printf_gstring (logbuf, " part: %Xd", text_part->fuzzy->h);
 			}
 		}
 		cur = g_list_next (cur);
@@ -448,20 +439,18 @@ struct tree_cb_data {
 static gboolean
 urls_protocol_cb (gpointer key, gpointer value, gpointer ud)
 {
-	struct tree_cb_data *cb = ud;
-	struct uri *url = value;
-	ucl_object_t *obj;
+	struct tree_cb_data             *cb = ud;
+	struct uri                      *url = value;
+	ucl_object_t                     *obj;
 
 	obj = ucl_object_fromlstring (url->host, url->hostlen);
 	DL_APPEND (cb->top->value.av, obj);
 
 	if (cb->task->cfg->log_urls) {
-		msg_info ("<%s> URL: %s - %s: %s",
-			cb->task->message_id,
-			cb->task->user ?
-			cb->task->user : (cb->task->from ? cb->task->from : "unknown"),
-			rspamd_inet_address_to_string (&cb->task->from_addr),
-			struri (url));
+		msg_info ("<%s> URL: %s - %s: %s", cb->task->message_id, cb->task->user ?
+				cb->task->user : (cb->task->from ? cb->task->from : "unknown"),
+				rspamd_inet_address_to_string (&cb->task->from_addr),
+				struri (url));
 	}
 
 	return FALSE;
@@ -470,8 +459,8 @@ urls_protocol_cb (gpointer key, gpointer value, gpointer ud)
 static ucl_object_t *
 rspamd_urls_tree_ucl (GTree *input, struct rspamd_task *task)
 {
-	struct tree_cb_data cb;
-	ucl_object_t *obj;
+	struct tree_cb_data             cb;
+	ucl_object_t                    *obj;
 
 	obj = ucl_object_typed_new (UCL_ARRAY);
 	cb.top = obj;
@@ -485,9 +474,9 @@ rspamd_urls_tree_ucl (GTree *input, struct rspamd_task *task)
 static gboolean
 emails_protocol_cb (gpointer key, gpointer value, gpointer ud)
 {
-	struct tree_cb_data *cb = ud;
-	struct uri *url = value;
-	ucl_object_t *obj;
+	struct tree_cb_data             *cb = ud;
+	struct uri                      *url = value;
+	ucl_object_t                     *obj;
 
 	obj = ucl_object_fromlstring (url->user, url->userlen + url->hostlen + 1);
 	DL_APPEND (cb->top->value.av, obj);
@@ -498,8 +487,8 @@ emails_protocol_cb (gpointer key, gpointer value, gpointer ud)
 static ucl_object_t *
 rspamd_emails_tree_ucl (GTree *input, struct rspamd_task *task)
 {
-	struct tree_cb_data cb;
-	ucl_object_t *obj;
+	struct tree_cb_data             cb;
+	ucl_object_t                    *obj;
 
 	obj = ucl_object_typed_new (UCL_ARRAY);
 	cb.top = obj;
@@ -515,9 +504,9 @@ rspamd_emails_tree_ucl (GTree *input, struct rspamd_task *task)
 static const gchar *
 make_rewritten_subject (struct metric *metric, struct rspamd_task *task)
 {
-	static gchar subj_buf[1024];
-	gchar *p = subj_buf, *end, *c, *res;
-	const gchar *s;
+	static gchar                    subj_buf[1024];
+	gchar                          *p = subj_buf, *end, *c, *res;
+	const gchar                    *s;
 
 	end = p + sizeof(subj_buf);
 	c = metric->subject;
@@ -533,15 +522,13 @@ make_rewritten_subject (struct metric *metric, struct rspamd_task *task)
 			c += 2;
 		}
 		else {
-			*p = *c++;
+			*p = *c ++;
 		}
-		p++;
+		p ++;
 	}
 	res = g_mime_utils_header_encode_text (subj_buf);
 
-	rspamd_mempool_add_destructor (task->task_pool,
-		(rspamd_mempool_destruct_t)g_free,
-		res);
+	rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_free, res);
 
 	return res;
 }
@@ -549,8 +536,8 @@ make_rewritten_subject (struct metric *metric, struct rspamd_task *task)
 static ucl_object_t *
 rspamd_str_list_ucl (GList *str_list)
 {
-	ucl_object_t *top = NULL, *obj;
-	GList *cur;
+	ucl_object_t                    *top = NULL, *obj;
+	GList                           *cur;
 
 	top = ucl_object_typed_new (UCL_ARRAY);
 	cur = str_list;
@@ -565,46 +552,40 @@ rspamd_str_list_ucl (GList *str_list)
 
 static ucl_object_t *
 rspamd_metric_symbol_ucl (struct rspamd_task *task, struct metric *m,
-	struct symbol *sym, GString *logbuf)
+		struct symbol *sym, GString *logbuf)
 {
-	ucl_object_t *obj = NULL;
-	const gchar *description = NULL;
+	ucl_object_t                    *obj = NULL;
+	const gchar                     *description = NULL;
 
 	rspamd_printf_gstring (logbuf, "%s,", sym->name);
 	description = g_hash_table_lookup (m->descriptions, sym->name);
 
 	obj = ucl_object_typed_new (UCL_OBJECT);
-	ucl_object_insert_key (obj, ucl_object_fromstring (
-			sym->name),	 "name",  0, false);
-	ucl_object_insert_key (obj, ucl_object_fromdouble (
-			sym->score), "score", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromstring (sym->name), "name", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromdouble (sym->score), "score", 0, false);
 	if (description) {
-		ucl_object_insert_key (obj, ucl_object_fromstring (
-				description), "description", 0, false);
+		ucl_object_insert_key (obj, ucl_object_fromstring (description), "description", 0, false);
 	}
 	if (sym->options != NULL) {
-		ucl_object_insert_key (obj, rspamd_str_list_ucl (
-				sym->options), "options", 0, false);
+		ucl_object_insert_key (obj, rspamd_str_list_ucl (sym->options), "options", 0, false);
 	}
 
 	return obj;
 }
 
 static ucl_object_t *
-rspamd_metric_result_ucl (struct rspamd_task *task,
-	struct metric_result *mres,
-	GString *logbuf)
+rspamd_metric_result_ucl (struct rspamd_task *task, struct metric_result *mres, GString *logbuf)
 {
-	GHashTableIter hiter;
-	struct symbol *sym;
-	struct metric *m;
-	gboolean is_spam;
-	enum rspamd_metric_action action = METRIC_ACTION_NOACTION;
-	ucl_object_t *obj = NULL, *sobj;
-	gdouble required_score;
-	gpointer h, v;
-	const gchar *subject;
-	gchar action_char;
+	GHashTableIter                   hiter;
+	struct symbol                  *sym;
+	struct metric                  *m;
+	gboolean                         is_spam;
+	enum rspamd_metric_action        action = METRIC_ACTION_NOACTION;
+	ucl_object_t                    *obj = NULL, *sobj;
+	gdouble                          required_score;
+	gpointer                         h, v;
+	const gchar                     *subject;
+	gchar                            action_char;
 
 	m = mres->metric;
 
@@ -622,27 +603,26 @@ rspamd_metric_result_ucl (struct rspamd_task *task,
 		action_char = 'F';
 	}
 	rspamd_printf_gstring (logbuf, "(%s: %c (%s): [%.2f/%.2f] [",
-		m->name, action_char,
-		str_action_metric (action),
-		mres->score, required_score);
+			m->name, action_char,
+			str_action_metric (action),
+			mres->score, required_score);
 
 	obj = ucl_object_typed_new (UCL_OBJECT);
-	ucl_object_insert_key (obj,	  ucl_object_frombool (is_spam),
-		"is_spam", 0, false);
-	ucl_object_insert_key (obj,	  ucl_object_frombool (task->is_skipped),
-		"is_skipped", 0, false);
+	ucl_object_insert_key (obj, ucl_object_frombool (is_spam),
+			"is_spam", 0, false);
+	ucl_object_insert_key (obj, ucl_object_frombool (task->is_skipped),
+			"is_skipped", 0, false);
 	ucl_object_insert_key (obj, ucl_object_fromdouble (mres->score),
-		"score", 0, false);
+			"score", 0, false);
 	ucl_object_insert_key (obj, ucl_object_fromdouble (required_score),
-		"required_score", 0, false);
-	ucl_object_insert_key (obj,
-		ucl_object_fromstring (str_action_metric (action)),
-		"action", 0, false);
+			"required_score", 0, false);
+	ucl_object_insert_key (obj, ucl_object_fromstring (str_action_metric (action)),
+			"action", 0, false);
 
 	if (action == METRIC_ACTION_REWRITE_SUBJECT) {
 		subject = make_rewritten_subject (m, task);
 		ucl_object_insert_key (obj, ucl_object_fromstring (subject),
-			"subject", 0, false);
+					"subject", 0, false);
 	}
 	/* Now handle symbols */
 	g_hash_table_iter_init (&hiter, mres->symbols);
@@ -654,31 +634,28 @@ rspamd_metric_result_ucl (struct rspamd_task *task,
 
 	/* Cut the trailing comma if needed */
 	if (logbuf->str[logbuf->len - 1] == ',') {
-		logbuf->len--;
+		logbuf->len --;
 	}
 
 #ifdef HAVE_CLOCK_GETTIME
 	rspamd_printf_gstring (logbuf, "]), len: %z, time: %s, dns req: %d,",
-		task->msg->len, calculate_check_time (&task->tv, &task->ts,
-		task->cfg->clock_res, &task->scan_milliseconds), task->dns_requests);
+			task->msg->len, calculate_check_time (&task->tv, &task->ts,
+			task->cfg->clock_res, &task->scan_milliseconds), task->dns_requests);
 #else
 	rspamd_printf_gstring (logbuf, "]), len: %z, time: %s, dns req: %d,",
-		task->msg->len,
-		calculate_check_time (&task->tv, task->cfg->clock_res,
-		&task->scan_milliseconds),
-		task->dns_requests);
+			task->msg->len,
+			calculate_check_time (&task->tv, task->cfg->clock_res, &task->scan_milliseconds),
+			task->dns_requests);
 #endif
 
 	return obj;
 }
 
 static void
-rspamd_ucl_tolegacy_output (struct rspamd_task *task,
-	ucl_object_t *top,
-	GString *out)
+rspamd_ucl_tolegacy_output (struct rspamd_task *task, ucl_object_t *top, GString *out)
 {
 	const ucl_object_t *metric, *score,
-	*required_score, *is_spam, *elt;
+		*required_score, *is_spam, *elt;
 	ucl_object_iter_t iter = NULL;
 
 	metric = ucl_object_find_key (top, DEFAULT_METRIC);
@@ -686,11 +663,10 @@ rspamd_ucl_tolegacy_output (struct rspamd_task *task,
 		score = ucl_object_find_key (metric, "score");
 		required_score = ucl_object_find_key (metric, "required_score");
 		is_spam = ucl_object_find_key (metric, "is_spam");
-		g_string_append_printf (out,
-			"Metric: default; %s; %.2f / %.2f / 0.0\r\n",
-			ucl_object_toboolean (is_spam) ? "True" : "False",
-			ucl_object_todouble (score),
-			ucl_object_todouble (required_score));
+		g_string_append_printf (out, "Metric: default; %s; %.2f / %.2f / 0.0\r\n",
+				ucl_object_toboolean (is_spam) ? "True" : "False",
+				ucl_object_todouble (score),
+				ucl_object_todouble (required_score));
 		elt = ucl_object_find_key (metric, "action");
 		if (elt != NULL) {
 			g_string_append_printf (out, "Action: %s\r\n",
@@ -703,38 +679,34 @@ rspamd_ucl_tolegacy_output (struct rspamd_task *task,
 				const ucl_object_t *sym_score;
 				sym_score = ucl_object_find_key (elt, "score");
 				g_string_append_printf (out, "Symbol: %s(%.2f)\r\n",
-					ucl_object_key (elt),
-					ucl_object_todouble (sym_score));
+						ucl_object_key (elt),
+						ucl_object_todouble (sym_score));
 			}
 		}
 
 		elt = ucl_object_find_key (metric, "subject");
 		if (elt != NULL) {
 			g_string_append_printf (out, "Subject: %s\r\n",
-				ucl_object_tostring (elt));
+					ucl_object_tostring (elt));
 		}
 	}
 	g_string_append_printf (out, "Message-ID: %s\r\n", task->message_id);
 }
 
 void
-rspamd_protocol_http_reply (struct rspamd_http_message *msg,
-	struct rspamd_task *task)
+rspamd_protocol_http_reply (struct rspamd_http_message *msg, struct rspamd_task *task)
 {
-	GString *logbuf;
-	struct metric_result *metric_res;
-	GHashTableIter hiter;
-	gpointer h, v;
-	ucl_object_t *top = NULL, *obj;
-	gdouble required_score;
-	gint action;
+	GString                         *logbuf;
+	struct metric_result           *metric_res;
+	GHashTableIter                   hiter;
+	gpointer                         h, v;
+	ucl_object_t                    *top = NULL, *obj;
+	gdouble                          required_score;
+	gint                             action;
 
 	/* Output the first line - check status */
 	logbuf = g_string_sized_new (BUFSIZ);
-	rspamd_printf_gstring (logbuf,
-		"id: <%s>, qid: <%s>, ",
-		task->message_id,
-		task->queue_id);
+	rspamd_printf_gstring (logbuf, "id: <%s>, qid: <%s>, ", task->message_id, task->queue_id);
 
 	if (task->user) {
 		rspamd_printf_gstring (logbuf, "user: %s, ", task->user);
@@ -754,20 +726,18 @@ rspamd_protocol_http_reply (struct rspamd_http_message *msg,
 	}
 
 	if (task->messages != NULL) {
-		ucl_object_insert_key (top, rspamd_str_list_ucl (
-				task->messages), "messages", 0, false);
+		ucl_object_insert_key (top, rspamd_str_list_ucl (task->messages), "messages", 0, false);
 	}
 	if (g_tree_nnodes (task->urls) > 0) {
-		ucl_object_insert_key (top, rspamd_urls_tree_ucl (task->urls,
-			task), "urls", 0, false);
+		ucl_object_insert_key (top, rspamd_urls_tree_ucl (task->urls, task), "urls", 0, false);
 	}
 	if (g_tree_nnodes (task->emails) > 0) {
 		ucl_object_insert_key (top, rspamd_emails_tree_ucl (task->emails, task),
-			"emails", 0, false);
+				"emails", 0, false);
 	}
-
+	
 	ucl_object_insert_key (top, ucl_object_fromstring (task->message_id),
-		"message-id", 0, false);
+			"message-id", 0, false);
 
 	write_hashes_to_log (task, logbuf);
 	if (!task->no_log) {
@@ -788,12 +758,11 @@ rspamd_protocol_http_reply (struct rspamd_http_message *msg,
 	/* Update stat for default metric */
 	metric_res = g_hash_table_lookup (task->results, DEFAULT_METRIC);
 	if (metric_res != NULL) {
-		required_score =
-			metric_res->metric->actions[METRIC_ACTION_REJECT].score;
+		required_score = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
 		action = check_metric_action (metric_res->score, required_score,
 				metric_res->metric);
 		if (action <= METRIC_ACTION_NOACTION) {
-			task->worker->srv->stat->actions_stat[action]++;
+			task->worker->srv->stat->actions_stat[action] ++;
 		}
 	}
 
@@ -804,9 +773,9 @@ rspamd_protocol_http_reply (struct rspamd_http_message *msg,
 void
 rspamd_protocol_write_reply (struct rspamd_task *task)
 {
-	struct rspamd_http_message *msg;
-	const gchar *ctype = "application/json";
-	ucl_object_t *top = NULL;
+	struct rspamd_http_message    *msg;
+	const gchar                   *ctype = "application/json";
+	ucl_object_t                   *top = NULL;
 
 	msg = rspamd_http_new_message (HTTP_RESPONSE);
 	if (!task->is_json) {
@@ -823,7 +792,7 @@ rspamd_protocol_write_reply (struct rspamd_task *task)
 		msg->code = 500 + task->error_code % 100;
 		msg->status = g_string_new (task->last_error);
 		ucl_object_insert_key (top, ucl_object_fromstring (task->last_error),
-			"error", 0, false);
+				"error", 0, false);
 		msg->body = g_string_sized_new (256);
 		rspamd_ucl_emit_gstring (top, UCL_EMIT_JSON_COMPACT, msg->body);
 		ucl_object_unref (top);
@@ -849,13 +818,13 @@ rspamd_protocol_write_reply (struct rspamd_task *task)
 
 	rspamd_http_connection_reset (task->http_conn);
 	rspamd_http_connection_write_message (task->http_conn, msg, NULL,
-		ctype, task, task->sock, &task->tv, task->ev_base);
+					ctype, task, task->sock, &task->tv, task->ev_base);
 }
 
 void
 register_protocol_command (const gchar *name, protocol_reply_func func)
 {
-	struct custom_command *cmd;
+	struct custom_command          *cmd;
 
 	cmd = g_malloc (sizeof (struct custom_command));
 	cmd->name = name;
diff --git a/src/libserver/protocol.h b/src/libserver/protocol.h
index 8fdd7e56f..aed45752c 100644
--- a/src/libserver/protocol.h
+++ b/src/libserver/protocol.h
@@ -27,7 +27,7 @@ struct metric;
  * @return
  */
 gboolean rspamd_protocol_handle_headers (struct rspamd_task *task,
-	struct rspamd_http_message *msg);
+		struct rspamd_http_message *msg);
 
 /**
  * Process HTTP request to the task structure
@@ -36,7 +36,7 @@ gboolean rspamd_protocol_handle_headers (struct rspamd_task *task,
  * @return
  */
 gboolean rspamd_protocol_handle_request (struct rspamd_task *task,
-	struct rspamd_http_message *msg);
+		struct rspamd_http_message *msg);
 
 /**
  * Write task results to http message
@@ -44,7 +44,7 @@ gboolean rspamd_protocol_handle_request (struct rspamd_task *task,
  * @param task
  */
 void rspamd_protocol_http_reply (struct rspamd_http_message *msg,
-	struct rspamd_task *task);
+		struct rspamd_task *task);
 
 /**
  * Write reply for specified task command
diff --git a/src/libserver/proxy.c b/src/libserver/proxy.c
index a4076954b..67c7665b8 100644
--- a/src/libserver/proxy.c
+++ b/src/libserver/proxy.c
@@ -28,7 +28,7 @@
 static void rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data);
 static void rspamd_proxy_client_handler (gint fd, gshort what, gpointer data);
 
-static inline GQuark
+static inline                   GQuark
 proxy_error_quark (void)
 {
 	return g_quark_from_static_string ("proxy-error");
@@ -50,9 +50,9 @@ rspamd_proxy_close (rspamd_proxy_t *proxy)
 static void
 rspamd_proxy_client_handler (gint fd, gshort what, gpointer data)
 {
-	rspamd_proxy_t *proxy = data;
-	gint r;
-	GError *err = NULL;
+	rspamd_proxy_t						*proxy = data;
+	gint								 r;
+	GError								*err = NULL;
 
 	if (what == EV_READ) {
 		/* Got data from client */
@@ -63,20 +63,14 @@ rspamd_proxy_client_handler (gint fd, gshort what, gpointer data)
 			proxy->read_len = r;
 			proxy->buf_offset = 0;
 			event_del (&proxy->backend_ev);
-			event_set (&proxy->backend_ev,
-				proxy->bfd,
-				EV_WRITE,
-				rspamd_proxy_backend_handler,
-				proxy);
+			event_set (&proxy->backend_ev, proxy->bfd, EV_WRITE, rspamd_proxy_backend_handler, proxy);
 			event_add (&proxy->backend_ev, proxy->tv);
 		}
 		else {
 			/* Error case or zero reply */
 			if (r < 0) {
 				/* Error case */
-				g_set_error (&err,
-					proxy_error_quark (), r, "Client read error: %s",
-					strerror (errno));
+				g_set_error (&err, proxy_error_quark(), r, "Client read error: %s", strerror (errno));
 				rspamd_proxy_close (proxy);
 				proxy->err_cb (err, proxy->user_data);
 			}
@@ -89,27 +83,17 @@ rspamd_proxy_client_handler (gint fd, gshort what, gpointer data)
 	}
 	else if (what == EV_WRITE) {
 		/* Can write to client */
-		r = write (proxy->cfd,
-				proxy->buf + proxy->buf_offset,
-				proxy->read_len - proxy->buf_offset);
+		r = write (proxy->cfd, proxy->buf + proxy->buf_offset, proxy->read_len - proxy->buf_offset);
 		if (r > 0) {
 			/* We wrote something */
-			proxy->buf_offset += r;
+			proxy->buf_offset +=r;
 			if (proxy->buf_offset == proxy->read_len) {
 				/* We wrote everything */
 				event_del (&proxy->client_ev);
-				event_set (&proxy->client_ev,
-					proxy->cfd,
-					EV_READ,
-					rspamd_proxy_client_handler,
-					proxy);
+				event_set (&proxy->client_ev, proxy->cfd, EV_READ, rspamd_proxy_client_handler, proxy);
 				event_add (&proxy->client_ev, proxy->tv);
 				event_del (&proxy->backend_ev);
-				event_set (&proxy->backend_ev,
-					proxy->bfd,
-					EV_READ,
-					rspamd_proxy_backend_handler,
-					proxy);
+				event_set (&proxy->backend_ev, proxy->bfd, EV_READ, rspamd_proxy_backend_handler, proxy);
 				event_add (&proxy->backend_ev, proxy->tv);
 			}
 			else {
@@ -121,9 +105,7 @@ rspamd_proxy_client_handler (gint fd, gshort what, gpointer data)
 			/* Error case or zero reply */
 			if (r < 0) {
 				/* Error case */
-				g_set_error (&err,
-					proxy_error_quark (), r, "Client write error: %s",
-					strerror (errno));
+				g_set_error (&err, proxy_error_quark(), r, "Client write error: %s", strerror (errno));
 				rspamd_proxy_close (proxy);
 				proxy->err_cb (err, proxy->user_data);
 			}
@@ -136,7 +118,7 @@ rspamd_proxy_client_handler (gint fd, gshort what, gpointer data)
 	}
 	else {
 		/* Got timeout */
-		g_set_error (&err, proxy_error_quark (), ETIMEDOUT, "Client timeout");
+		g_set_error (&err, proxy_error_quark(), ETIMEDOUT, "Client timeout");
 		rspamd_proxy_close (proxy);
 		proxy->err_cb (err, proxy->user_data);
 	}
@@ -145,9 +127,9 @@ rspamd_proxy_client_handler (gint fd, gshort what, gpointer data)
 static void
 rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data)
 {
-	rspamd_proxy_t *proxy = data;
-	gint r;
-	GError *err = NULL;
+	rspamd_proxy_t						*proxy = data;
+	gint								 r;
+	GError								*err = NULL;
 
 	if (what == EV_READ) {
 		/* Got data from backend */
@@ -158,20 +140,14 @@ rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data)
 			proxy->read_len = r;
 			proxy->buf_offset = 0;
 			event_del (&proxy->client_ev);
-			event_set (&proxy->client_ev,
-				proxy->bfd,
-				EV_WRITE,
-				rspamd_proxy_client_handler,
-				proxy);
+			event_set (&proxy->client_ev, proxy->bfd, EV_WRITE, rspamd_proxy_client_handler, proxy);
 			event_add (&proxy->client_ev, proxy->tv);
 		}
 		else {
 			/* Error case or zero reply */
 			if (r < 0) {
 				/* Error case */
-				g_set_error (&err,
-					proxy_error_quark (), r, "Backend read error: %s",
-					strerror (errno));
+				g_set_error (&err, proxy_error_quark(), r, "Backend read error: %s", strerror (errno));
 				rspamd_proxy_close (proxy);
 				proxy->err_cb (err, proxy->user_data);
 			}
@@ -184,27 +160,17 @@ rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data)
 	}
 	else if (what == EV_WRITE) {
 		/* Can write to backend */
-		r = write (proxy->bfd,
-				proxy->buf + proxy->buf_offset,
-				proxy->read_len - proxy->buf_offset);
+		r = write (proxy->bfd, proxy->buf + proxy->buf_offset, proxy->read_len - proxy->buf_offset);
 		if (r > 0) {
 			/* We wrote something */
-			proxy->buf_offset += r;
+			proxy->buf_offset +=r;
 			if (proxy->buf_offset == proxy->read_len) {
 				/* We wrote everything */
 				event_del (&proxy->backend_ev);
-				event_set (&proxy->backend_ev,
-					proxy->bfd,
-					EV_READ,
-					rspamd_proxy_backend_handler,
-					proxy);
+				event_set (&proxy->backend_ev, proxy->bfd, EV_READ, rspamd_proxy_backend_handler, proxy);
 				event_add (&proxy->backend_ev, proxy->tv);
 				event_del (&proxy->client_ev);
-				event_set (&proxy->client_ev,
-					proxy->cfd,
-					EV_READ,
-					rspamd_proxy_client_handler,
-					proxy);
+				event_set (&proxy->client_ev, proxy->cfd, EV_READ, rspamd_proxy_client_handler, proxy);
 				event_add (&proxy->client_ev, proxy->tv);
 			}
 			else {
@@ -216,9 +182,7 @@ rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data)
 			/* Error case or zero reply */
 			if (r < 0) {
 				/* Error case */
-				g_set_error (&err,
-					proxy_error_quark (), r, "Backend write error: %s",
-					strerror (errno));
+				g_set_error (&err, proxy_error_quark(), r, "Backend write error: %s", strerror (errno));
 				rspamd_proxy_close (proxy);
 				proxy->err_cb (err, proxy->user_data);
 			}
@@ -231,7 +195,7 @@ rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data)
 	}
 	else {
 		/* Got timeout */
-		g_set_error (&err, proxy_error_quark (), ETIMEDOUT, "Client timeout");
+		g_set_error (&err, proxy_error_quark(), ETIMEDOUT, "Client timeout");
 		rspamd_proxy_close (proxy);
 		proxy->err_cb (err, proxy->user_data);
 	}
@@ -246,17 +210,11 @@ rspamd_proxy_backend_handler (gint fd, gshort what, gpointer data)
  * @param ud user data for callback
  * @return new proxy object
  */
-rspamd_proxy_t *
-rspamd_create_proxy (gint cfd,
-	gint bfd,
-	rspamd_mempool_t *pool,
-	struct event_base *base,
-	gsize bufsize,
-	struct timeval *tv,
-	dispatcher_err_callback_t err_cb,
-	gpointer ud)
+rspamd_proxy_t*
+rspamd_create_proxy (gint cfd, gint bfd, rspamd_mempool_t *pool, struct event_base *base,
+		gsize bufsize, struct timeval *tv, dispatcher_err_callback_t err_cb, gpointer ud)
 {
-	rspamd_proxy_t *new;
+	rspamd_proxy_t						*new;
 
 	new = rspamd_mempool_alloc0 (pool, sizeof (rspamd_proxy_t));
 
@@ -271,19 +229,11 @@ rspamd_create_proxy (gint cfd,
 	new->tv = tv;
 
 	/* Set client's and backend's interfaces to read events */
-	event_set (&new->client_ev,
-		new->cfd,
-		EV_READ,
-		rspamd_proxy_client_handler,
-		new);
+	event_set (&new->client_ev, new->cfd, EV_READ, rspamd_proxy_client_handler, new);
 	event_base_set (new->base, &new->client_ev);
 	event_add (&new->client_ev, new->tv);
 
-	event_set (&new->backend_ev,
-		new->bfd,
-		EV_READ,
-		rspamd_proxy_backend_handler,
-		new);
+	event_set (&new->backend_ev, new->bfd, EV_READ, rspamd_proxy_backend_handler, new);
 	event_base_set (new->base, &new->backend_ev);
 	event_add (&new->backend_ev, new->tv);
 
diff --git a/src/libserver/proxy.h b/src/libserver/proxy.h
index 199da765f..c505fe83d 100644
--- a/src/libserver/proxy.h
+++ b/src/libserver/proxy.h
@@ -25,8 +25,8 @@
 #ifndef PROXY_H_
 #define PROXY_H_
 
-#include "buffer.h"
 #include "config.h"
+#include "buffer.h"
 
 /**
  * @file proxy.h
@@ -34,21 +34,21 @@
  */
 
 typedef struct rspamd_proxy_s {
-	struct event client_ev;                 /**< event for client's communication */
-	struct event backend_ev;                /**< event for backend communication */
-	struct event_base *base;                /**< base for event operations */
-	rspamd_mempool_t *pool;                 /**< memory pool */
-	dispatcher_err_callback_t err_cb;       /**< error callback	*/
-	struct event_base *ev_base;             /**< event base */
-	gint cfd;                               /**< client's socket */
-	gint bfd;                               /**< backend's socket */
-	guint8 *buf;                            /**< exchange buffer */
-	gsize bufsize;                          /**< buffer size */
-	gint read_len;                          /**< read length */
-	gint buf_offset;                        /**< offset to write */
-	gpointer user_data;                     /**< user's data for callbacks */
-	struct timeval *tv;                     /**< timeout for communications */
-	gboolean closed;                        /**< whether descriptors are closed */
+	struct event client_ev;					/**< event for client's communication */
+	struct event backend_ev; 				/**< event for backend communication */
+	struct event_base *base;				/**< base for event operations */
+	rspamd_mempool_t *pool;					/**< memory pool */
+	dispatcher_err_callback_t err_cb;		/**< error callback	*/
+	struct event_base *ev_base;				/**< event base */
+	gint cfd;								/**< client's socket */
+	gint bfd;								/**< backend's socket */
+	guint8 *buf;							/**< exchange buffer */
+	gsize bufsize;							/**< buffer size */
+	gint read_len;							/**< read length */
+	gint buf_offset;						/**< offset to write */
+	gpointer user_data;						/**< user's data for callbacks */
+	struct timeval *tv;						/**< timeout for communications */
+	gboolean closed;						/**< whether descriptors are closed */
 } rspamd_proxy_t;
 
 /**
@@ -60,14 +60,9 @@ typedef struct rspamd_proxy_s {
  * @param ud user data for callback
  * @return new proxy object
  */
-rspamd_proxy_t * rspamd_create_proxy (gint cfd,
-	gint bfd,
-	rspamd_mempool_t *pool,
-	struct event_base *base,
-	gsize bufsize,
-	struct timeval *tv,
-	dispatcher_err_callback_t err_cb,
-	gpointer ud);
+rspamd_proxy_t* rspamd_create_proxy (gint cfd, gint bfd, rspamd_mempool_t *pool,
+		struct event_base *base, gsize bufsize, struct timeval *tv,
+		dispatcher_err_callback_t err_cb, gpointer ud);
 
 void rspamd_proxy_close (rspamd_proxy_t *proxy);
 
diff --git a/src/libserver/roll_history.c b/src/libserver/roll_history.c
index d9553fa93..504f8ae3b 100644
--- a/src/libserver/roll_history.c
+++ b/src/libserver/roll_history.c
@@ -33,10 +33,10 @@
  * @param pool pool for shared memory
  * @return new structure
  */
-struct roll_history *
+struct roll_history*
 rspamd_roll_history_new (rspamd_mempool_t *pool)
 {
-	struct roll_history *new;
+	struct roll_history						*new;
 
 	if (pool == NULL) {
 		return NULL;
@@ -57,9 +57,9 @@ struct history_metric_callback_data {
 static void
 roll_history_symbols_callback (gpointer key, gpointer value, void *user_data)
 {
-	struct history_metric_callback_data *cb = user_data;
-	struct symbol *s = value;
-	guint wr;
+	struct history_metric_callback_data		*cb = user_data;
+	struct symbol							*s = value;
+	guint									 wr;
 
 	if (cb->remain > 0) {
 		wr = rspamd_snprintf (cb->pos, cb->remain, "%s, ", s->name);
@@ -74,13 +74,12 @@ roll_history_symbols_callback (gpointer key, gpointer value, void *user_data)
  * @param task task object
  */
 void
-rspamd_roll_history_update (struct roll_history *history,
-	struct rspamd_task *task)
+rspamd_roll_history_update (struct roll_history *history, struct rspamd_task *task)
 {
-	gint row_num;
-	struct roll_history_row *row;
-	struct metric_result *metric_res;
-	struct history_metric_callback_data cbdata;
+	gint									 row_num;
+	struct roll_history_row					*row;
+	struct metric_result					*metric_res;
+	struct history_metric_callback_data		 cbdata;
 
 	if (history->need_lock) {
 		/* Some process is getting history, so wait on a mutex */
@@ -109,11 +108,10 @@ rspamd_roll_history_update (struct roll_history *history,
 
 	/* Add information from task to roll history */
 	memcpy (&row->from_addr, &task->from_addr, sizeof (row->from_addr));
-	memcpy (&row->tv,		 &task->tv,		   sizeof (row->tv));
+	memcpy (&row->tv, &task->tv, sizeof (row->tv));
 
 	/* Strings */
-	rspamd_strlcpy (row->message_id, task->message_id,
-		sizeof (row->message_id));
+	rspamd_strlcpy (row->message_id, task->message_id, sizeof (row->message_id));
 	if (task->user) {
 		rspamd_strlcpy (row->user, task->user, sizeof (row->message_id));
 	}
@@ -122,23 +120,19 @@ rspamd_roll_history_update (struct roll_history *history,
 	}
 
 	/* Get default metric */
-	metric_res = g_hash_table_lookup (task->results, DEFAULT_METRIC);
+	metric_res =  g_hash_table_lookup (task->results, DEFAULT_METRIC);
 	if (metric_res == NULL) {
 		row->symbols[0] = '\0';
 		row->action = METRIC_ACTION_NOACTION;
 	}
 	else {
 		row->score = metric_res->score;
-		row->required_score =
-			metric_res->metric->actions[METRIC_ACTION_REJECT].score;
+		row->required_score = metric_res->metric->actions[METRIC_ACTION_REJECT].score;
 		row->action = check_metric_action (metric_res->score,
-				metric_res->metric->actions[METRIC_ACTION_REJECT].score,
-				metric_res->metric);
+				metric_res->metric->actions[METRIC_ACTION_REJECT].score, metric_res->metric);
 		cbdata.pos = row->symbols;
 		cbdata.remain = sizeof (row->symbols);
-		g_hash_table_foreach (metric_res->symbols,
-			roll_history_symbols_callback,
-			&cbdata);
+		g_hash_table_foreach (metric_res->symbols, roll_history_symbols_callback, &cbdata);
 		if (cbdata.remain > 0) {
 			/* Remove last whitespace and comma */
 			*cbdata.pos-- = '\0';
@@ -161,12 +155,11 @@ rspamd_roll_history_update (struct roll_history *history,
 gboolean
 rspamd_roll_history_load (struct roll_history *history, const gchar *filename)
 {
-	gint fd;
-	struct stat st;
+	gint									 fd;
+	struct stat								 st;
 
 	if (stat (filename, &st) == -1) {
-		msg_info ("cannot load history from %s: %s", filename,
-			strerror (errno));
+		msg_info ("cannot load history from %s: %s", filename, strerror (errno));
 		return FALSE;
 	}
 
@@ -176,15 +169,13 @@ rspamd_roll_history_load (struct roll_history *history, const gchar *filename)
 	}
 
 	if ((fd = open (filename, O_RDONLY)) == -1) {
-		msg_info ("cannot load history from %s: %s", filename,
-			strerror (errno));
+		msg_info ("cannot load history from %s: %s", filename, strerror (errno));
 		return FALSE;
 	}
 
 	if (read (fd, history->rows, sizeof (history->rows)) == -1) {
 		close (fd);
-		msg_info ("cannot read history from %s: %s", filename,
-			strerror (errno));
+		msg_info ("cannot read history from %s: %s", filename, strerror (errno));
 		return FALSE;
 	}
 
@@ -202,7 +193,7 @@ rspamd_roll_history_load (struct roll_history *history, const gchar *filename)
 gboolean
 rspamd_roll_history_save (struct roll_history *history, const gchar *filename)
 {
-	gint fd;
+	gint									 fd;
 
 	if ((fd = open (filename, O_WRONLY | O_CREAT | O_TRUNC, 00600)) == -1) {
 		msg_info ("cannot save history to %s: %s", filename, strerror (errno));
diff --git a/src/libserver/roll_history.h b/src/libserver/roll_history.h
index 85a8f2ddc..1dff93a4f 100644
--- a/src/libserver/roll_history.h
+++ b/src/libserver/roll_history.h
@@ -78,15 +78,14 @@ struct roll_history {
  * @param pool pool for shared memory
  * @return new structure
  */
-struct roll_history * rspamd_roll_history_new (rspamd_mempool_t *pool);
+struct roll_history* rspamd_roll_history_new (rspamd_mempool_t *pool);
 
 /**
  * Update roll history with data from task
  * @param history roll history object
  * @param task task object
  */
-void rspamd_roll_history_update (struct roll_history *history,
-	struct rspamd_task *task);
+void rspamd_roll_history_update (struct roll_history *history, struct rspamd_task *task);
 
 /**
  * Load previously saved history from file
@@ -94,8 +93,7 @@ void rspamd_roll_history_update (struct roll_history *history,
  * @param filename filename to load from
  * @return TRUE if history has been loaded
  */
-gboolean rspamd_roll_history_load (struct roll_history *history,
-	const gchar *filename);
+gboolean rspamd_roll_history_load (struct roll_history *history, const gchar *filename);
 
 /**
  * Save history to file
@@ -103,7 +101,6 @@ gboolean rspamd_roll_history_load (struct roll_history *history,
  * @param filename filename to load from
  * @return TRUE if history has been saved
  */
-gboolean rspamd_roll_history_save (struct roll_history *history,
-	const gchar *filename);
+gboolean rspamd_roll_history_save (struct roll_history *history, const gchar *filename);
 
 #endif /* ROLL_HISTORY_H_ */
diff --git a/src/libserver/spf.c b/src/libserver/spf.c
index 908b10ac6..d7811b4b6 100644
--- a/src/libserver/spf.c
+++ b/src/libserver/spf.c
@@ -24,10 +24,10 @@
 
 #include "config.h"
 #include "dns.h"
-#include "filter.h"
+#include "spf.h"
 #include "main.h"
 #include "message.h"
-#include "spf.h"
+#include "filter.h"
 
 #define SPF_VER1_STR "v=spf1"
 #define SPF_VER2_STR "spf2."
@@ -79,42 +79,40 @@ struct spf_dns_cb {
 	gboolean in_include;
 };
 
-#define CHECK_REC(rec)                                      \
-	do {                                                        \
-		if ((rec)->nested > SPF_MAX_NESTING ||                  \
-			(rec)->dns_requests > SPF_MAX_DNS_REQUESTS) {       \
-			msg_info ("<%s> spf recursion limit %d is reached, domain: %s", \
-				(rec)->task->message_id, (rec)->dns_requests,   \
-				(rec)->sender_domain);                          \
-			return FALSE;                                       \
-		}                                                       \
-	} while (0)                                                 \
-
-static gboolean parse_spf_record (struct rspamd_task *task,
-	struct spf_record *rec);
-static gboolean start_spf_parse (struct spf_record *rec, gchar *begin,
-	guint ttl);
+#define CHECK_REC(rec)										\
+do {														\
+	if ((rec)->nested > SPF_MAX_NESTING ||					\
+		(rec)->dns_requests > SPF_MAX_DNS_REQUESTS) {		\
+		msg_info ("<%s> spf recursion limit %d is reached, domain: %s",	\
+			(rec)->task->message_id, (rec)->dns_requests,	\
+			(rec)->sender_domain);							\
+		return FALSE;										\
+	}														\
+} while (0)													\
+
+static gboolean parse_spf_record (struct rspamd_task *task, struct spf_record *rec);
+static gboolean start_spf_parse (struct spf_record *rec, gchar *begin, guint ttl);
 
 /* Determine spf mech */
 static spf_mech_t
 check_spf_mech (const gchar *elt, gboolean *need_shift)
 {
 	g_assert (elt != NULL);
-
+	
 	*need_shift = TRUE;
 
 	switch (*elt) {
-	case '-':
-		return SPF_FAIL;
-	case '~':
-		return SPF_SOFT_FAIL;
-	case '+':
-		return SPF_PASS;
-	case '?':
-		return SPF_NEUTRAL;
-	default:
-		*need_shift = FALSE;
-		return SPF_PASS;
+		case '-':
+			return SPF_FAIL;
+		case '~':
+			return SPF_SOFT_FAIL;
+		case '+':
+			return SPF_PASS;
+		case '?':
+			return SPF_NEUTRAL;
+		default:
+			*need_shift = FALSE;
+			return SPF_PASS;	
 	}
 }
 
@@ -122,14 +120,14 @@ check_spf_mech (const gchar *elt, gboolean *need_shift)
 static void
 dump_spf_record (GList *addrs)
 {
-	struct spf_addr *addr;
-	GList *cur;
-	gint r = 0;
-	gchar logbuf[BUFSIZ], c;
+	struct spf_addr                *addr;
+	GList                          *cur;
+	gint                            r = 0;
+	gchar                           logbuf[BUFSIZ], c;
 #ifdef HAVE_INET_PTON
-	gchar ipbuf[INET6_ADDRSTRLEN];
+	gchar							ipbuf[INET6_ADDRSTRLEN];
 #else
-	struct in_addr ina;
+	struct in_addr                  ina;
 #endif
 
 	cur = addrs;
@@ -151,35 +149,20 @@ dump_spf_record (GList *addrs)
 			}
 #ifdef HAVE_INET_PTON
 			if (addr->data.normal.ipv6) {
-				inet_ntop (AF_INET6, &addr->data.normal.d.in6, ipbuf,
-					sizeof (ipbuf));
+				inet_ntop (AF_INET6, &addr->data.normal.d.in6, ipbuf, sizeof (ipbuf));
 
 			}
 			else {
-				inet_ntop (AF_INET, &addr->data.normal.d.in4, ipbuf,
-					sizeof (ipbuf));
+				inet_ntop (AF_INET, &addr->data.normal.d.in4, ipbuf, sizeof (ipbuf));
 			}
-			r += snprintf (logbuf + r,
-					sizeof (logbuf) - r,
-					"%c%s/%d; ",
-					c,
-					ipbuf,
-					addr->data.normal.mask);
+			r += snprintf (logbuf + r, sizeof (logbuf) - r, "%c%s/%d; ", c, ipbuf, addr->data.normal.mask);
 #else
 			ina.s_addr = addr->data.normal.d.in4.s_addr;
-			r += snprintf (logbuf + r,
-					sizeof (logbuf) - r,
-					"%c%s/%d; ",
-					c,
-					inet_ntoa (ina),
-					addr->data.normal.mask);
+			r += snprintf (logbuf + r, sizeof (logbuf) - r, "%c%s/%d; ", c, inet_ntoa (ina), addr->data.normal.mask);
 #endif
 		}
 		else {
-			r += snprintf (logbuf + r,
-					sizeof (logbuf) - r,
-					"%s; ",
-					addr->spf_string);
+			r += snprintf (logbuf + r, sizeof (logbuf) - r, "%s; ", addr->spf_string);
 			dump_spf_record (addr->data.list);
 		}
 		cur = g_list_next (cur);
@@ -191,8 +174,8 @@ dump_spf_record (GList *addrs)
 static GList *
 spf_addr_find (GList *addrs, gpointer to_find)
 {
-	struct spf_addr *addr;
-	GList *cur, *res = NULL;
+	struct spf_addr                *addr;
+	GList                          *cur, *res = NULL;
 
 	cur = addrs;
 	while (cur) {
@@ -219,9 +202,9 @@ spf_addr_find (GList *addrs, gpointer to_find)
 static void
 spf_record_destructor (gpointer r)
 {
-	struct spf_record *rec = r;
-	GList *cur;
-	struct spf_addr *addr;
+	struct spf_record              *rec = r;
+	GList                          *cur;
+	struct spf_addr                *addr;
 
 	if (rec->addrs) {
 		cur = rec->addrs;
@@ -237,89 +220,87 @@ spf_record_destructor (gpointer r)
 }
 
 static gboolean
-parse_spf_ipmask (const gchar *begin,
-	struct spf_addr *addr,
-	struct spf_record *rec)
+parse_spf_ipmask (const gchar *begin, struct spf_addr *addr, struct spf_record *rec)
 {
-	const gchar *pos;
-	gchar mask_buf[5] = {'\0'}, *p;
-	gint state = 0, dots = 0;
+	const gchar                    *pos;
+	gchar                           mask_buf[5] = {'\0'}, *p;
+	gint                            state = 0, dots = 0;
 #ifdef HAVE_INET_PTON
-	gchar ip_buf[INET6_ADDRSTRLEN];
+	gchar                           ip_buf[INET6_ADDRSTRLEN];
 #else
-	gchar ip_buf[INET_ADDRSTRLEN];
+	gchar                           ip_buf[INET_ADDRSTRLEN];
 #endif
-
-	bzero (ip_buf,	 sizeof (ip_buf));
+	
+	bzero (ip_buf, sizeof (ip_buf));
 	bzero (mask_buf, sizeof (mask_buf));
 	pos = begin;
 	p = ip_buf;
 
 	while (*pos) {
 		switch (state) {
-		case 0:
-			/* Require ':' */
-			if (*pos != ':') {
-				msg_info ("<%s>: spf error for domain %s: semicolon missing",
-					rec->task->message_id, rec->sender_domain);
-				return FALSE;
-			}
-			state = 1;
-			pos++;
-			p = ip_buf;
-			dots = 0;
-			break;
-		case 1:
+			case 0:
+				/* Require ':' */
+				if (*pos != ':') {
+					msg_info ("<%s>: spf error for domain %s: semicolon missing",
+							rec->task->message_id, rec->sender_domain);
+					return FALSE;
+				}
+				state = 1;
+				pos ++;
+				p = ip_buf;
+				dots = 0;
+				break;
+			case 1:
 #ifdef HAVE_INET_PTON
-			if (p - ip_buf >= (gint)sizeof (ip_buf)) {
-				return FALSE;
-			}
-			if (g_ascii_isxdigit (*pos)) {
-				*p++ = *pos++;
-			}
-			else if (*pos == '.' || *pos == ':') {
-				*p++ = *pos++;
-				dots++;
-			}
+				if (p - ip_buf >= (gint)sizeof (ip_buf)) {
+					return FALSE;
+				}
+				if (g_ascii_isxdigit (*pos)) {
+					*p ++ = *pos ++;
+				}
+				else if (*pos == '.' || *pos == ':') {
+					*p ++ = *pos ++;
+					dots ++;
+				}
 #else
-			/* Begin parse ip */
-			if (p - ip_buf >= (gint)sizeof (ip_buf) || dots > 3) {
-				return FALSE;
-			}
-			if (g_ascii_isdigit (*pos)) {
-				*p++ = *pos++;
-			}
-			else if (*pos == '.') {
-				*p++ = *pos++;
-				dots++;
-			}
+				/* Begin parse ip */
+				if (p - ip_buf >= (gint)sizeof (ip_buf) || dots > 3) {
+					return FALSE;
+				}
+				if (g_ascii_isdigit (*pos)) {
+					*p ++ = *pos ++;
+				}
+				else if (*pos == '.') {
+					*p ++ = *pos ++;
+					dots ++;
+				}
 #endif
-			else if (*pos == '/') {
-				pos++;
-				p = mask_buf;
-				state = 2;
-			}
-			else {
-				/* Invalid character */
-				msg_info ("<%s>: spf error for domain %s: invalid ip address",
-					rec->task->message_id, rec->sender_domain);
-				return FALSE;
-			}
-			break;
-		case 2:
-			/* Parse mask */
-			if (p - mask_buf >= (gint)sizeof (mask_buf)) {
-				msg_info ("<%s>: spf error for domain %s: too long mask",
-					rec->task->message_id, rec->sender_domain);
-				return FALSE;
-			}
-			if (g_ascii_isdigit (*pos)) {
-				*p++ = *pos++;
-			}
-			else {
-				return FALSE;
-			}
-			break;
+				else if (*pos == '/') {
+					pos ++;
+					p = mask_buf;
+					state = 2;
+				}
+				else {
+					/* Invalid character */
+					msg_info ("<%s>: spf error for domain %s: invalid ip address",
+						rec->task->message_id, rec->sender_domain);
+					return FALSE;
+				}
+				break;
+			case 2:
+				/* Parse mask */
+				if (p - mask_buf >= (gint)sizeof (mask_buf)) {
+					msg_info ("<%s>: spf error for domain %s: too long mask",
+							rec->task->message_id, rec->sender_domain);
+					return FALSE;
+				}
+				if (g_ascii_isdigit (*pos)) {
+					*p ++ = *pos ++;
+				}
+				else {
+					return FALSE;
+				}
+				break;
 		}
 	}
 
@@ -330,7 +311,7 @@ parse_spf_ipmask (const gchar *begin,
 		}
 		else {
 			msg_info ("<%s>: spf error for domain %s: invalid ip address",
-				rec->task->message_id, rec->sender_domain);
+					rec->task->message_id, rec->sender_domain);
 			return FALSE;
 		}
 	}
@@ -347,22 +328,16 @@ parse_spf_ipmask (const gchar *begin,
 		if (!addr->data.normal.ipv6) {
 			addr->data.normal.mask = strtoul (mask_buf, NULL, 10);
 			if (addr->data.normal.mask > 32) {
-				msg_info (
-					"<%s>: spf error for domain %s: bad ipmask value: '%s'",
-					rec->task->message_id,
-					rec->sender_domain,
-					begin);
+				msg_info ("<%s>: spf error for domain %s: bad ipmask value: '%s'",
+						rec->task->message_id, rec->sender_domain, begin);
 				return FALSE;
 			}
 		}
 		else {
 			addr->data.normal.mask = strtoul (mask_buf, NULL, 10);
 			if (addr->data.normal.mask > 128) {
-				msg_info (
-					"<%s>: spf error for domain %s: bad ipmask value: '%s'",
-					rec->task->message_id,
-					rec->sender_domain,
-					begin);
+				msg_info ("<%s>: spf error for domain %s: bad ipmask value: '%s'",
+						rec->task->message_id, rec->sender_domain, begin);
 				return FALSE;
 			}
 		}
@@ -376,13 +351,10 @@ parse_spf_ipmask (const gchar *begin,
 }
 
 static gchar *
-parse_spf_hostmask (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_addr *addr,
-	struct spf_record *rec)
+parse_spf_hostmask (struct rspamd_task *task, const gchar *begin, struct spf_addr *addr, struct spf_record *rec)
 {
-	gchar *host = NULL, *p,  mask_buf[3];
-	gint hostlen;
+	gchar                           *host = NULL, *p,  mask_buf[3];
+	gint                            hostlen;
 
 	bzero (mask_buf, sizeof (mask_buf));
 	if (*begin == '\0' || *begin == '/') {
@@ -396,7 +368,7 @@ parse_spf_hostmask (struct rspamd_task *task,
 		addr->data.normal.mask = strtoul (mask_buf, NULL, 10);
 		if (addr->data.normal.mask > 32) {
 			msg_info ("<%s>: spf error for domain %s: too long mask",
-				rec->task->message_id, rec->sender_domain);
+					rec->task->message_id, rec->sender_domain);
 			return FALSE;
 		}
 		if (host == NULL) {
@@ -417,7 +389,7 @@ parse_spf_hostmask (struct rspamd_task *task,
 
 static void
 spf_record_process_addr (struct rdns_reply_entry *elt,
-	struct spf_dns_cb *cb, struct rspamd_task *task)
+		struct spf_dns_cb *cb, struct rspamd_task *task)
 {
 	struct spf_addr *addr = cb->addr, *new_addr;
 	GList *tmp = NULL;
@@ -436,13 +408,11 @@ spf_record_process_addr (struct rdns_reply_entry *elt,
 				memcpy (new_addr, addr, sizeof (struct spf_addr));
 				new_addr->data.normal.d.in4.s_addr = elt->content.a.addr.s_addr;
 				new_addr->data.normal.parsed = TRUE;
-				cb->rec->addrs = g_list_insert_before (cb->rec->addrs,
-						tmp,
-						new_addr);
+				cb->rec->addrs = g_list_insert_before (cb->rec->addrs, tmp, new_addr);
 			}
 			else {
 				msg_info ("<%s>: spf error for domain %s: addresses mismatch",
-					task->message_id, cb->rec->sender_domain);
+						task->message_id, cb->rec->sender_domain);
 			}
 		}
 
@@ -450,7 +420,7 @@ spf_record_process_addr (struct rdns_reply_entry *elt,
 	else if (elt->type == RDNS_REQUEST_AAAA) {
 		if (!addr->data.normal.parsed) {
 			memcpy (&addr->data.normal.d.in6,
-				&elt->content.aaa.addr, sizeof (struct in6_addr));
+					&elt->content.aaa.addr, sizeof (struct in6_addr));
 			addr->data.normal.mask = 32;
 			addr->data.normal.parsed = TRUE;
 			addr->data.normal.ipv6 = TRUE;
@@ -459,21 +429,17 @@ spf_record_process_addr (struct rdns_reply_entry *elt,
 			/* Insert one more address */
 			tmp = spf_addr_find (cb->rec->addrs, addr);
 			if (tmp) {
-				new_addr =
-					rspamd_mempool_alloc (task->task_pool,
-						sizeof (struct spf_addr));
+				new_addr = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_addr));
 				memcpy (new_addr, addr, sizeof (struct spf_addr));
 				memcpy (&new_addr->data.normal.d.in6,
-					&elt->content.aaa.addr, sizeof (struct in6_addr));
+						&elt->content.aaa.addr, sizeof (struct in6_addr));
 				new_addr->data.normal.parsed = TRUE;
 				new_addr->data.normal.ipv6 = TRUE;
-				cb->rec->addrs = g_list_insert_before (cb->rec->addrs,
-						tmp,
-						new_addr);
+				cb->rec->addrs = g_list_insert_before (cb->rec->addrs, tmp, new_addr);
 			}
 			else {
 				msg_info ("<%s>: spf error for domain %s: addresses mismatch",
-					task->message_id, cb->rec->sender_domain);
+						task->message_id, cb->rec->sender_domain);
 			}
 		}
 	}
@@ -482,37 +448,34 @@ spf_record_process_addr (struct rdns_reply_entry *elt,
 static void
 spf_record_dns_callback (struct rdns_reply *reply, gpointer arg)
 {
-	struct spf_dns_cb *cb = arg;
-	gchar *begin;
-	struct rdns_reply_entry *elt_data;
-	GList *tmp = NULL;
-	struct rspamd_task *task;
+	struct spf_dns_cb               *cb = arg;
+	gchar                           *begin;
+	struct rdns_reply_entry      *elt_data;
+	GList                           *tmp = NULL;
+	struct rspamd_task              *task;
 
 	task = cb->rec->task;
 
-	cb->rec->requests_inflight--;
+	cb->rec->requests_inflight --;
 
 	if (reply->code == RDNS_RC_NOERROR) {
 		/* Add all logic for all DNS states here */
-		LL_FOREACH (reply->entries, elt_data)
-		{
+		LL_FOREACH (reply->entries, elt_data) {
 			switch (cb->cur_action) {
 			case SPF_RESOLVE_MX:
 				if (elt_data->type == RDNS_REQUEST_MX) {
 					/* Now resolve A record for this MX */
-					if (make_dns_request (task->resolver, task->s,
-						task->task_pool,
-						spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A,
-						elt_data->content.mx.name)) {
-						task->dns_requests++;
-						cb->rec->requests_inflight++;
+					if (make_dns_request (task->resolver, task->s, task->task_pool,
+							spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A,
+							elt_data->content.mx.name)) {
+						task->dns_requests ++;
+						cb->rec->requests_inflight ++;
 					}
-					if (make_dns_request (task->resolver, task->s,
-						task->task_pool,
-						spf_record_dns_callback, (void *)cb, RDNS_REQUEST_AAAA,
-						elt_data->content.mx.name)) {
-						task->dns_requests++;
-						cb->rec->requests_inflight++;
+					if (make_dns_request (task->resolver, task->s, task->task_pool,
+							spf_record_dns_callback, (void *)cb, RDNS_REQUEST_AAAA,
+							elt_data->content.mx.name)) {
+						task->dns_requests ++;
+						cb->rec->requests_inflight ++;
 					}
 				}
 				else {
@@ -525,19 +488,17 @@ spf_record_dns_callback (struct rdns_reply *reply, gpointer arg)
 				break;
 			case SPF_RESOLVE_PTR:
 				if (elt_data->type == RDNS_REQUEST_PTR) {
-					if (make_dns_request (task->resolver, task->s,
-						task->task_pool,
-						spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A,
-						elt_data->content.ptr.name)) {
-						task->dns_requests++;
-						cb->rec->requests_inflight++;
+					if (make_dns_request (task->resolver, task->s, task->task_pool,
+							spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A,
+							elt_data->content.ptr.name)) {
+						task->dns_requests ++;
+						cb->rec->requests_inflight ++;
 					}
-					if (make_dns_request (task->resolver, task->s,
-						task->task_pool,
-						spf_record_dns_callback, (void *)cb, RDNS_REQUEST_AAAA,
-						elt_data->content.ptr.name)) {
-						task->dns_requests++;
-						cb->rec->requests_inflight++;
+					if (make_dns_request (task->resolver, task->s, task->task_pool,
+							spf_record_dns_callback, (void *)cb, RDNS_REQUEST_AAAA,
+							elt_data->content.ptr.name)) {
+						task->dns_requests ++;
+						cb->rec->requests_inflight ++;
 					}
 				}
 				else {
@@ -582,8 +543,7 @@ spf_record_dns_callback (struct rdns_reply *reply, gpointer arg)
 			case SPF_RESOLVE_EXP:
 				break;
 			case SPF_RESOLVE_EXISTS:
-				if (elt_data->type == RDNS_REQUEST_A || elt_data->type ==
-					RDNS_REQUEST_AAAA) {
+				if (elt_data->type == RDNS_REQUEST_A || elt_data->type == RDNS_REQUEST_AAAA) {
 					/* If specified address resolves, we can accept connection from every IP */
 					cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
 					cb->addr->data.normal.mask = 0;
@@ -594,63 +554,50 @@ spf_record_dns_callback (struct rdns_reply *reply, gpointer arg)
 	}
 	else if (reply->code == RDNS_RC_NXDOMAIN) {
 		switch (cb->cur_action) {
-		case SPF_RESOLVE_MX:
-			if (rdns_request_has_type (reply->request, RDNS_REQUEST_MX)) {
-				msg_info (
-					"<%s>: spf error for domain %s: cannot find MX record for %s",
-					task->message_id,
-					cb->rec->sender_domain,
-					cb->rec->cur_domain);
-				cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
-				cb->addr->data.normal.mask = 32;
-			}
-			else {
-				msg_info (
-					"<%s>: spf error for domain %s: cannot resolve MX record for %s",
-					task->message_id,
-					cb->rec->sender_domain,
-					cb->rec->cur_domain);
-				cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
-				cb->addr->data.normal.mask = 32;
-			}
-			break;
-		case SPF_RESOLVE_A:
-			if (rdns_request_has_type (reply->request, RDNS_REQUEST_A)) {
-				cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
-				cb->addr->data.normal.mask = 32;
-			}
-			break;
+				case SPF_RESOLVE_MX:
+					if (rdns_request_has_type (reply->request, RDNS_REQUEST_MX)) {
+						msg_info ("<%s>: spf error for domain %s: cannot find MX record for %s",
+								task->message_id, cb->rec->sender_domain, cb->rec->cur_domain);
+						cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
+						cb->addr->data.normal.mask = 32;
+					}
+					else {
+						msg_info ("<%s>: spf error for domain %s: cannot resolve MX record for %s",
+								task->message_id, cb->rec->sender_domain, cb->rec->cur_domain);
+						cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
+						cb->addr->data.normal.mask = 32;
+					}
+					break;
+				case SPF_RESOLVE_A:
+					if (rdns_request_has_type (reply->request, RDNS_REQUEST_A)) {
+						cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
+						cb->addr->data.normal.mask = 32;
+					}
+					break;
 #ifdef HAVE_INET_PTON
-		case SPF_RESOLVE_AAA:
-			if (rdns_request_has_type (reply->request, RDNS_REQUEST_AAAA)) {
-				memset (&cb->addr->data.normal.d.in6, 0xff,
-					sizeof (struct in6_addr));
-				cb->addr->data.normal.mask = 32;
-			}
-			break;
+				case SPF_RESOLVE_AAA:
+					if (rdns_request_has_type (reply->request, RDNS_REQUEST_AAAA)) {
+						memset (&cb->addr->data.normal.d.in6, 0xff, sizeof (struct in6_addr));
+						cb->addr->data.normal.mask = 32;
+					}
+					break;
 #endif
-		case SPF_RESOLVE_PTR:
-			break;
-		case SPF_RESOLVE_REDIRECT:
-			msg_info (
-				"<%s>: spf error for domain %s: cannot resolve TXT record for %s",
-				task->message_id,
-				cb->rec->sender_domain,
-				cb->rec->cur_domain);
-			break;
-		case SPF_RESOLVE_INCLUDE:
-			msg_info (
-				"<%s>: spf error for domain %s: cannot resolve TXT record for %s",
-				task->message_id,
-				cb->rec->sender_domain,
-				cb->rec->cur_domain);
-			break;
-		case SPF_RESOLVE_EXP:
-			break;
-		case SPF_RESOLVE_EXISTS:
-			cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
-			cb->addr->data.normal.mask = 32;
-			break;
+				case SPF_RESOLVE_PTR:
+					break;
+				case SPF_RESOLVE_REDIRECT:
+					msg_info ("<%s>: spf error for domain %s: cannot resolve TXT record for %s",
+							task->message_id, cb->rec->sender_domain, cb->rec->cur_domain);
+					break;
+				case SPF_RESOLVE_INCLUDE:
+					msg_info ("<%s>: spf error for domain %s: cannot resolve TXT record for %s",
+							task->message_id, cb->rec->sender_domain, cb->rec->cur_domain);
+					break;
+				case SPF_RESOLVE_EXP:
+					break;
+				case SPF_RESOLVE_EXISTS:
+					cb->addr->data.normal.d.in4.s_addr = INADDR_NONE;
+					cb->addr->data.normal.mask = 32;
+					break;
 		}
 	}
 
@@ -660,16 +607,13 @@ spf_record_dns_callback (struct rdns_reply *reply, gpointer arg)
 }
 
 static gboolean
-parse_spf_a (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_a (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	struct spf_dns_cb *cb;
-	gchar *host = NULL;
-
+	gchar                           *host = NULL;
+	
 	CHECK_REC (rec);
-
+	
 	/*
 	 * a
 	 * a/<prefix-length>
@@ -685,31 +629,31 @@ parse_spf_a (struct rspamd_task *task,
 		addr->data.normal.mask = 32;
 	}
 	else if (*begin == ':') {
-		begin++;
+		begin ++;
 	}
 	else if (*begin != '/') {
 		/* Invalid A record */
 		return FALSE;
 	}
-
+	
 	if (host == NULL) {
 		host = parse_spf_hostmask (task, begin, addr, rec);
 	}
-
+	
 	if (host == NULL) {
 		return FALSE;
 	}
 
-	rec->dns_requests++;
+	rec->dns_requests ++;
 	cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
 	cb->rec = rec;
 	cb->addr = addr;
 	cb->cur_action = SPF_RESOLVE_A;
 	cb->in_include = rec->in_include;
 	if (make_dns_request (task->resolver, task->s, task->task_pool,
-		spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A, host)) {
-		task->dns_requests++;
-		rec->requests_inflight++;
+			spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A, host)) {
+		task->dns_requests ++;
+		rec->requests_inflight ++;
 		return TRUE;
 	}
 
@@ -718,13 +662,10 @@ parse_spf_a (struct rspamd_task *task,
 }
 
 static gboolean
-parse_spf_ptr (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_ptr (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	struct spf_dns_cb *cb;
-	gchar *host, *ptr;
+	gchar                           *host, *ptr;
 
 	CHECK_REC (rec);
 
@@ -732,7 +673,7 @@ parse_spf_ptr (struct rspamd_task *task,
 		return FALSE;
 	}
 	if (*begin == ':') {
-		begin++;
+		begin ++;
 		host = rspamd_mempool_strdup (task->task_pool, begin);
 	}
 	else if (*begin == '\0') {
@@ -742,7 +683,7 @@ parse_spf_ptr (struct rspamd_task *task,
 		return FALSE;
 	}
 
-	rec->dns_requests++;
+	rec->dns_requests ++;
 	cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
 	cb->rec = rec;
 	cb->addr = addr;
@@ -750,17 +691,15 @@ parse_spf_ptr (struct rspamd_task *task,
 	cb->cur_action = SPF_RESOLVE_PTR;
 	cb->in_include = rec->in_include;
 	cb->ptr_host = host;
-	ptr =
-		rdns_generate_ptr_from_str (rspamd_inet_address_to_string (
-				&task->from_addr));
+	ptr = rdns_generate_ptr_from_str (rspamd_inet_address_to_string (&task->from_addr));
 	if (ptr == NULL) {
 		return FALSE;
 	}
 	rspamd_mempool_add_destructor (task->task_pool, free, ptr);
 	if (make_dns_request (task->resolver, task->s, task->task_pool,
-		spf_record_dns_callback, (void *)cb, RDNS_REQUEST_PTR, ptr)) {
-		task->dns_requests++;
-		rec->requests_inflight++;
+			spf_record_dns_callback, (void *)cb, RDNS_REQUEST_PTR, ptr)) {
+		task->dns_requests ++;
+		rec->requests_inflight ++;
 
 		return TRUE;
 	}
@@ -770,29 +709,26 @@ parse_spf_ptr (struct rspamd_task *task,
 }
 
 static gboolean
-parse_spf_mx (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_mx (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	struct spf_dns_cb *cb;
-	gchar *host;
-
+	gchar                           *host;
+	
 	CHECK_REC (rec);
-
+	
 	if (begin == NULL) {
 		return FALSE;
 	}
 	if (*begin == ':') {
-		begin++;
+		begin ++;
 	}
-
+	
 	host = parse_spf_hostmask (task, begin, addr, rec);
-
+	
 	if (host == NULL) {
 		return FALSE;
 	}
-	rec->dns_requests++;
+	rec->dns_requests ++;
 	cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
 	cb->rec = rec;
 	cb->addr = addr;
@@ -800,10 +736,10 @@ parse_spf_mx (struct rspamd_task *task,
 	cb->cur_action = SPF_RESOLVE_MX;
 	cb->in_include = rec->in_include;
 	if (make_dns_request (task->resolver, task->s, task->task_pool,
-		spf_record_dns_callback, (void *)cb, RDNS_REQUEST_MX, host)) {
-		task->dns_requests++;
-		rec->requests_inflight++;
-
+			spf_record_dns_callback, (void *)cb, RDNS_REQUEST_MX, host)) {
+		task->dns_requests ++;
+		rec->requests_inflight ++;
+		
 		return TRUE;
 	}
 
@@ -811,10 +747,7 @@ parse_spf_mx (struct rspamd_task *task,
 }
 
 static gboolean
-parse_spf_all (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_all (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	/* All is 0/0 */
 	memset (&addr->data.normal.d, 0, sizeof (addr->data.normal.d));
@@ -831,10 +764,7 @@ parse_spf_all (struct rspamd_task *task,
 }
 
 static gboolean
-parse_spf_ip4 (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_ip4 (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	/* ip4:addr[/mask] */
 
@@ -844,10 +774,7 @@ parse_spf_ip4 (struct rspamd_task *task,
 
 #ifdef HAVE_INET_PTON
 static gboolean
-parse_spf_ip6 (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_ip6 (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	/* ip6:addr[/mask] */
 
@@ -857,21 +784,18 @@ parse_spf_ip6 (struct rspamd_task *task,
 #endif
 
 static gboolean
-parse_spf_include (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_include (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	struct spf_dns_cb *cb;
-	gchar *domain;
+	gchar                           *domain;
 
 	CHECK_REC (rec);
 
 	if (begin == NULL || *begin != ':') {
 		return FALSE;
 	}
-	begin++;
-	rec->dns_requests++;
+	begin ++;
+	rec->dns_requests ++;
 
 	cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
 	cb->rec = rec;
@@ -882,9 +806,9 @@ parse_spf_include (struct rspamd_task *task,
 	addr->data.list = NULL;
 	domain = rspamd_mempool_strdup (task->task_pool, begin);
 	if (make_dns_request (task->resolver, task->s, task->task_pool,
-		spf_record_dns_callback, (void *)cb, RDNS_REQUEST_TXT, domain)) {
-		task->dns_requests++;
-		rec->requests_inflight++;
+			spf_record_dns_callback, (void *)cb, RDNS_REQUEST_TXT, domain)) {
+		task->dns_requests ++;
+		rec->requests_inflight ++;
 
 		return TRUE;
 	}
@@ -894,10 +818,7 @@ parse_spf_include (struct rspamd_task *task,
 }
 
 static gboolean
-parse_spf_exp (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_exp (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	CHECK_REC (rec);
 
@@ -906,21 +827,18 @@ parse_spf_exp (struct rspamd_task *task,
 }
 
 static gboolean
-parse_spf_redirect (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_redirect (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	struct spf_dns_cb *cb;
-	gchar *domain;
+	gchar                           *domain;
 
 	CHECK_REC (rec);
 
 	if (begin == NULL || *begin != '=') {
 		return FALSE;
 	}
-	begin++;
-	rec->dns_requests++;
+	begin ++;
+	rec->dns_requests ++;
 
 	cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
 	cb->rec = rec;
@@ -929,10 +847,10 @@ parse_spf_redirect (struct rspamd_task *task,
 	cb->in_include = rec->in_include;
 	domain = rspamd_mempool_strdup (task->task_pool, begin);
 	if (make_dns_request (task->resolver, task->s, task->task_pool,
-		spf_record_dns_callback, (void *)cb, RDNS_REQUEST_TXT, domain)) {
-		task->dns_requests++;
-		rec->requests_inflight++;
-
+			spf_record_dns_callback, (void *)cb, RDNS_REQUEST_TXT, domain)) {
+		task->dns_requests ++;
+		rec->requests_inflight ++;
+		
 		return TRUE;
 	}
 
@@ -940,21 +858,18 @@ parse_spf_redirect (struct rspamd_task *task,
 }
 
 static gboolean
-parse_spf_exists (struct rspamd_task *task,
-	const gchar *begin,
-	struct spf_record *rec,
-	struct spf_addr *addr)
+parse_spf_exists (struct rspamd_task *task, const gchar *begin, struct spf_record *rec, struct spf_addr *addr)
 {
 	struct spf_dns_cb *cb;
-	gchar *host;
+	gchar                           *host;
 
 	CHECK_REC (rec);
-
+	
 	if (begin == NULL || *begin != ':') {
 		return FALSE;
 	}
-	begin++;
-	rec->dns_requests++;
+	begin ++;
+	rec->dns_requests ++;
 
 	addr->data.normal.mask = 32;
 	cb = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_dns_cb));
@@ -965,10 +880,10 @@ parse_spf_exists (struct rspamd_task *task,
 	host = rspamd_mempool_strdup (task->task_pool, begin);
 
 	if (make_dns_request (task->resolver, task->s, task->task_pool,
-		spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A, host)) {
-		task->dns_requests++;
-		rec->requests_inflight++;
-
+			spf_record_dns_callback, (void *)cb, RDNS_REQUEST_A, host)) {
+		task->dns_requests ++;
+		rec->requests_inflight ++;
+		
 		return TRUE;
 	}
 
@@ -978,8 +893,8 @@ parse_spf_exists (struct rspamd_task *task,
 static void
 reverse_spf_ip (gchar *ip, gint len)
 {
-	gchar ipbuf[sizeof("255.255.255.255") - 1], *p, *c;
-	gint t = 0, l = len;
+	gchar                           ipbuf[sizeof("255.255.255.255") - 1], *p, *c;
+	gint                            t = 0, l = len;
 
 	if (len > (gint)sizeof (ipbuf)) {
 		msg_info ("cannot reverse string of length %d", len);
@@ -987,136 +902,127 @@ reverse_spf_ip (gchar *ip, gint len)
 	}
 
 	p = ipbuf + len;
-	c = ip;
-	while (--l) {
+	c = ip; 
+	while (-- l) {
 		if (*c == '.') {
 			memcpy (p, c - t, t);
 			*--p = '.';
-			c++;
+			c ++;
 			t = 0;
 			continue;
 		}
 
-		t++;
-		c++;
-		p--;
+		t ++;
+		c ++;
+		p --;
 	}
 
 	memcpy (p - 1, c - t, t + 1);
 
-	memcpy (ip,	   ipbuf, len);
+	memcpy (ip, ipbuf, len);
 }
 
 static gchar *
-expand_spf_macro (struct rspamd_task *task, struct spf_record *rec,
-	gchar *begin)
+expand_spf_macro (struct rspamd_task *task, struct spf_record *rec, gchar *begin)
 {
-	gchar *p, *c, *new, *tmp;
-	gint len = 0, slen = 0, state = 0;
+	gchar                           *p, *c, *new, *tmp;
+	gint                            len = 0, slen = 0, state = 0;
 #ifdef HAVE_INET_PTON
-	gchar ip_buf[INET6_ADDRSTRLEN];
+	gchar                           ip_buf[INET6_ADDRSTRLEN];
 #endif
-	gboolean need_expand = FALSE;
+	gboolean                        need_expand = FALSE;
 
 	p = begin;
 	/* Calculate length */
 	while (*p) {
 		switch (state) {
-		case 0:
-			/* Skip any character and wait for % in input */
-			if (*p == '%') {
-				state = 1;
-			}
-			else {
-				len++;
-			}
+			case 0:
+				/* Skip any character and wait for % in input */
+				if (*p == '%') {
+					state = 1;
+				}
+				else {
+					len ++;
+				}
 
-			slen++;
-			p++;
-			break;
-		case 1:
-			/* We got % sign, so we should whether wait for { or for - or for _ or for % */
-			if (*p == '%' || *p == '-') {
-				/* Just a single % sign or space */
-				len++;
-			}
-			else if (*p == '_') {
-				/* %20 */
-				len += sizeof ("%20") - 1;
-			}
-			else if (*p == '{') {
-				state = 2;
-			}
-			else {
-				/* Something unknown */
-				msg_info ("<%s>: spf error for domain %s: unknown spf element",
-					task->message_id, rec->sender_domain);
-				return begin;
-			}
-			p++;
-			slen++;
-			break;
-		case 2:
-			/* Read macro name */
-			switch (g_ascii_tolower (*p)) {
-			case 'i':
+				slen ++;
+				p ++;
+				break;
+			case 1:
+				/* We got % sign, so we should whether wait for { or for - or for _ or for % */
+				if (*p == '%' || *p == '-') {
+					/* Just a single % sign or space */
+					len ++;
+				}
+				else if (*p == '_') {
+					/* %20 */
+					len += sizeof ("%20") - 1;
+				}
+				else if (*p == '{') {
+					state = 2;
+				}
+				else {
+					/* Something unknown */
+					msg_info ("<%s>: spf error for domain %s: unknown spf element",
+							task->message_id, rec->sender_domain);
+					return begin;
+				}
+				p ++;
+				slen ++;
+				break;
+			case 2:
+				/* Read macro name */
+				switch (g_ascii_tolower (*p)) {
+					case 'i':
 #ifdef HAVE_INET_PTON
-				len += sizeof (INET6_ADDRSTRLEN) - 1;
+						len += sizeof (INET6_ADDRSTRLEN) - 1;
 #else
-				len += sizeof (INET_ADDRSTRLEN) - 1;
+						len += sizeof (INET_ADDRSTRLEN) - 1;
 #endif
+						break;
+					case 's':
+						len += strlen (rec->sender);
+						break;
+					case 'l':
+						len += strlen (rec->local_part);
+						break;
+					case 'o':
+						len += strlen (rec->sender_domain);
+						break;
+					case 'd':
+						len += strlen (rec->cur_domain);
+						break;
+					case 'v':
+						len += sizeof ("in-addr") - 1;
+						break;
+					case 'h':
+						if (task->helo) {
+							len += strlen (task->helo);
+						}
+						break;
+					default:
+						msg_info ("<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
+								task->message_id, rec->sender_domain, *p, begin);
+						return begin;
+				}
+				p ++;
+				slen ++;
+				state = 3;
 				break;
-			case 's':
-				len += strlen (rec->sender);
-				break;
-			case 'l':
-				len += strlen (rec->local_part);
-				break;
-			case 'o':
-				len += strlen (rec->sender_domain);
-				break;
-			case 'd':
-				len += strlen (rec->cur_domain);
-				break;
-			case 'v':
-				len += sizeof ("in-addr") - 1;
-				break;
-			case 'h':
-				if (task->helo) {
-					len += strlen (task->helo);
+			case 3:
+				/* Read modifier */
+				if (*p == '}') {
+					state = 0;
+					need_expand = TRUE;
 				}
+				else if (*p != 'r' && !g_ascii_isdigit (*p)) {
+					msg_info ("<%s>: spf error for domain %s: unknown or unsupported spf modifier %c in %s",
+							task->message_id, rec->sender_domain, *p, begin);
+					return begin;
+				} 
+				p ++;
+				slen ++;
 				break;
-			default:
-				msg_info (
-					"<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
-					task->message_id,
-					rec->sender_domain,
-					*p,
-					begin);
-				return begin;
-			}
-			p++;
-			slen++;
-			state = 3;
-			break;
-		case 3:
-			/* Read modifier */
-			if (*p == '}') {
-				state = 0;
-				need_expand = TRUE;
-			}
-			else if (*p != 'r' && !g_ascii_isdigit (*p)) {
-				msg_info (
-					"<%s>: spf error for domain %s: unknown or unsupported spf modifier %c in %s",
-					task->message_id,
-					rec->sender_domain,
-					*p,
-					begin);
-				return begin;
-			}
-			p++;
-			slen++;
-			break;
 		}
 	}
 
@@ -1124,7 +1030,7 @@ expand_spf_macro (struct rspamd_task *task, struct spf_record *rec,
 		/* No expansion needed */
 		return begin;
 	}
-
+	
 	new = rspamd_mempool_alloc (task->task_pool, len + 1);
 
 	c = new;
@@ -1134,146 +1040,138 @@ expand_spf_macro (struct rspamd_task *task, struct spf_record *rec,
 
 	while (*p) {
 		switch (state) {
-		case 0:
-			/* Skip any character and wait for % in input */
-			if (*p == '%') {
-				state = 1;
-			}
-			else {
-				*c = *p;
-				c++;
-			}
+			case 0:
+				/* Skip any character and wait for % in input */
+				if (*p == '%') {
+					state = 1;
+				}
+				else {
+					*c = *p;
+					c ++;
+				}
 
-			p++;
-			break;
-		case 1:
-			/* We got % sign, so we should whether wait for { or for - or for _ or for % */
-			if (*p == '%') {
-				/* Just a single % sign or space */
-				*c++ = '%';
-			}
-			else if (*p == '-') {
-				*c++ = ' ';
-			}
-			else if (*p == '_') {
-				/* %20 */
-				*c++ = '%';
-				*c++ = '2';
-				*c++ = '0';
-			}
-			else if (*p == '{') {
-				state = 2;
-			}
-			else {
-				/* Something unknown */
-				msg_info ("<%s>: spf error for domain %s: unknown spf element",
-					task->message_id, rec->sender_domain);
-				return begin;
-			}
-			p++;
-			break;
-		case 2:
-			/* Read macro name */
-			switch (g_ascii_tolower (*p)) {
-			case 'i':
+				p ++;
+				break;
+			case 1:
+				/* We got % sign, so we should whether wait for { or for - or for _ or for % */
+				if (*p == '%') {
+					/* Just a single % sign or space */
+					*c++ = '%';
+				}
+				else if (*p == '-') {
+					*c++ = ' ';
+				}
+				else if (*p == '_') {
+					/* %20 */
+					*c++ = '%';
+					*c++ = '2';
+					*c++ = '0';
+				}
+				else if (*p == '{') {
+					state = 2;
+				}
+				else {
+					/* Something unknown */
+					msg_info ("<%s>: spf error for domain %s: unknown spf element",
+						task->message_id, rec->sender_domain);
+					return begin;
+				}
+				p ++;
+				break;
+			case 2:
+				/* Read macro name */
+				switch (g_ascii_tolower (*p)) {
+					case 'i':
 #ifdef HAVE_INET_PTON
-				len = rspamd_strlcpy (ip_buf,
-						rspamd_inet_address_to_string (&task->from_addr),
-						sizeof (ip_buf));
-				memcpy (c, ip_buf, len);
+						len = rspamd_strlcpy (ip_buf,
+								rspamd_inet_address_to_string (&task->from_addr),
+								sizeof (ip_buf));
+						memcpy (c, ip_buf, len);
 #else
-				tmp = inet_ntoa (task->from_addr);
-				len = strlen (tmp);
-				memcpy (c, tmp, len);
+						tmp = inet_ntoa (task->from_addr);
+						len = strlen (tmp);
+						memcpy (c, tmp, len);
 #endif
-				c += len;
-				break;
-			case 's':
-				len = strlen (rec->sender);
-				memcpy (c, rec->sender, len);
-				c += len;
-				break;
-			case 'l':
-				len = strlen (rec->local_part);
-				memcpy (c, rec->local_part, len);
-				c += len;
-				break;
-			case 'o':
-				len = strlen (rec->sender_domain);
-				memcpy (c, rec->sender_domain, len);
-				c += len;
-				break;
-			case 'd':
-				len = strlen (rec->cur_domain);
-				memcpy (c, rec->cur_domain, len);
-				c += len;
-				break;
-			case 'v':
-				len = sizeof ("in-addr") - 1;
-				memcpy (c, "in-addr", len);
-				c += len;
-				break;
-			case 'h':
-				if (task->helo) {
-					tmp = strchr (task->helo, '@');
-					if (tmp) {
-						len = strlen (tmp + 1);
-						memcpy (c, tmp + 1, len);
 						c += len;
-					}
+						break;
+					case 's':
+						len = strlen (rec->sender);
+						memcpy (c, rec->sender, len);
+						c += len;
+						break;
+					case 'l':
+						len = strlen (rec->local_part);
+						memcpy (c, rec->local_part, len);
+						c += len;
+						break;
+					case 'o':
+						len = strlen (rec->sender_domain);
+						memcpy (c, rec->sender_domain, len);
+						c += len;
+						break;
+					case 'd':
+						len = strlen (rec->cur_domain);
+						memcpy (c, rec->cur_domain, len);
+						c += len;
+						break;
+					case 'v':
+						len = sizeof ("in-addr") - 1;
+						memcpy (c, "in-addr", len);
+						c += len;
+						break;
+					case 'h':
+						if (task->helo) {
+							tmp = strchr (task->helo, '@');
+							if (tmp) {
+								len = strlen (tmp + 1);
+								memcpy (c, tmp + 1, len);
+								c += len;
+							}
+						}
+						break;
+					default:
+						msg_info ("<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
+							task->message_id, rec->sender_domain, *p, begin);
+						return begin;
 				}
+				p ++;
+				state = 3;
+				break;
+			case 3:
+				/* Read modifier */
+				if (*p == '}') {
+					state = 0;
+				}
+				else if (*p == 'r' && len != 0) {
+					reverse_spf_ip (c - len, len);
+					len = 0;
+				} 
+				else if (g_ascii_isdigit (*p)) {
+					/*XXX: try to implement domain strimming */
+				}
+				else {
+					msg_info ("<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
+						task->message_id, rec->sender_domain, *p, begin);
+					return begin;
+				} 
+				p ++;
 				break;
-			default:
-				msg_info (
-					"<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
-					task->message_id,
-					rec->sender_domain,
-					*p,
-					begin);
-				return begin;
-			}
-			p++;
-			state = 3;
-			break;
-		case 3:
-			/* Read modifier */
-			if (*p == '}') {
-				state = 0;
-			}
-			else if (*p == 'r' && len != 0) {
-				reverse_spf_ip (c - len, len);
-				len = 0;
-			}
-			else if (g_ascii_isdigit (*p)) {
-				/*XXX: try to implement domain strimming */
-			}
-			else {
-				msg_info (
-					"<%s>: spf error for domain %s: unknown or unsupported spf macro %c in %s",
-					task->message_id,
-					rec->sender_domain,
-					*p,
-					begin);
-				return begin;
-			}
-			p++;
-			break;
 		}
 	}
 	/* Null terminate */
 	*c = '\0';
 
 	return new;
-
+	
 }
 
-#define NEW_ADDR(x) do {                                                        \
-		(x) = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_addr));     \
-		(x)->mech = check_spf_mech (rec->cur_elt, &need_shift);                     \
-		(x)->spf_string = rspamd_mempool_strdup (task->task_pool, begin);               \
-		memset (&(x)->data.normal, 0, sizeof ((x)->data.normal));                   \
-		(x)->data.normal.mask = 32;                                                 \
-		(x)->is_list = FALSE;                                                       \
+#define NEW_ADDR(x) do {														\
+	(x) = rspamd_mempool_alloc (task->task_pool, sizeof (struct spf_addr));		\
+	(x)->mech = check_spf_mech (rec->cur_elt, &need_shift);						\
+	(x)->spf_string = rspamd_mempool_strdup (task->task_pool, begin);				\
+	memset (&(x)->data.normal, 0, sizeof ((x)->data.normal));					\
+	(x)->data.normal.mask = 32;													\
+	(x)->is_list = FALSE;														\
 } while (0);
 
 /* Read current element and try to parse record */
@@ -1282,153 +1180,141 @@ parse_spf_record (struct rspamd_task *task, struct spf_record *rec)
 {
 	struct spf_addr *new = NULL;
 	gboolean need_shift, res = FALSE;
-	gchar *begin;
-
+	gchar                           *begin;
+	
 	rec->cur_elt = rec->elts[rec->elt_num];
 	if (rec->cur_elt == NULL) {
 		return FALSE;
 	}
 	else if (*rec->cur_elt == '\0') {
 		/* Silently skip empty elements */
-		rec->elt_num++;
+		rec->elt_num ++;
 		return TRUE;
 	}
 	else {
 		begin = expand_spf_macro (task, rec, rec->cur_elt);
 		if (*begin == '?' || *begin == '+' || *begin == '-' || *begin == '~') {
-			begin++;
+			begin ++;
 		}
 
 
 		/* Now check what we have */
 		switch (g_ascii_tolower (*begin)) {
-		case 'a':
-			/* all or a */
-			if (g_ascii_strncasecmp (begin, SPF_ALL,
-				sizeof (SPF_ALL) - 1) == 0) {
-				NEW_ADDR (new);
-				begin += sizeof (SPF_ALL) - 1;
-				res = parse_spf_all (task, begin, rec, new);
-			}
-			else if (g_ascii_strncasecmp (begin, SPF_A,
-				sizeof (SPF_A) - 1) == 0) {
-				NEW_ADDR (new);
-				begin += sizeof (SPF_A) - 1;
-				res = parse_spf_a (task, begin, rec, new);
-			}
-			else {
-				msg_info ("<%s>: spf error for domain %s: bad spf command %s",
-					task->message_id, rec->sender_domain, begin);
-			}
-			break;
-		case 'i':
-			/* include or ip4 */
-			if (g_ascii_strncasecmp (begin, SPF_IP4,
-				sizeof (SPF_IP4) - 1) == 0) {
-				NEW_ADDR (new);
-				begin += sizeof (SPF_IP4) - 1;
-				res = parse_spf_ip4 (task, begin, rec, new);
-			}
-			else if (g_ascii_strncasecmp (begin, SPF_INCLUDE,
-				sizeof (SPF_INCLUDE) - 1) == 0) {
-				NEW_ADDR (new);
-				begin += sizeof (SPF_INCLUDE) - 1;
-				res = parse_spf_include (task, begin, rec, new);
-			}
-			else if (g_ascii_strncasecmp (begin, SPF_IP6, sizeof (SPF_IP6) -
-				1) == 0) {
+			case 'a':
+				/* all or a */
+				if (g_ascii_strncasecmp (begin, SPF_ALL, sizeof (SPF_ALL) - 1) == 0) {
+					NEW_ADDR (new);
+					begin += sizeof (SPF_ALL) - 1;
+					res = parse_spf_all (task, begin, rec, new);
+				}
+				else if (g_ascii_strncasecmp (begin, SPF_A, sizeof (SPF_A) - 1) == 0) {
+					NEW_ADDR (new);
+					begin += sizeof (SPF_A) - 1;
+					res = parse_spf_a (task, begin, rec, new);
+				}
+				else {
+					msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+							task->message_id, rec->sender_domain, begin);
+				}
+				break;
+			case 'i':
+				/* include or ip4 */
+				if (g_ascii_strncasecmp (begin, SPF_IP4, sizeof (SPF_IP4) - 1) == 0) {
+					NEW_ADDR (new);
+					begin += sizeof (SPF_IP4) - 1;
+					res = parse_spf_ip4 (task, begin, rec, new);
+				}
+				else if (g_ascii_strncasecmp (begin, SPF_INCLUDE, sizeof (SPF_INCLUDE) - 1) == 0) {
+					NEW_ADDR (new);
+					begin += sizeof (SPF_INCLUDE) - 1;
+					res = parse_spf_include (task, begin, rec, new);
+				}
+				else if (g_ascii_strncasecmp (begin, SPF_IP6, sizeof (SPF_IP6) - 1) == 0) {
 #ifdef HAVE_INET_PTON
-				NEW_ADDR (new);
-				begin += sizeof (SPF_IP6) - 1;
-				res = parse_spf_ip6 (task, begin, rec, new);
+					NEW_ADDR (new);
+					begin += sizeof (SPF_IP6) - 1;
+					res = parse_spf_ip6 (task, begin, rec, new);
 #else
-				msg_info (
-					"ignoring ip6 spf command as IPv6 is not supported: %s",
-					begin);
-				new = NULL;
-				res = TRUE;
-				begin += sizeof (SPF_IP6) - 1;
+					msg_info ("ignoring ip6 spf command as IPv6 is not supported: %s", begin);
+					new = NULL;
+					res = TRUE;
+					begin += sizeof (SPF_IP6) - 1;
 #endif
-			}
-			else {
-				msg_info ("<%s>: spf error for domain %s: bad spf command %s",
-					task->message_id, rec->sender_domain, begin);
-			}
-			break;
-		case 'm':
-			/* mx */
-			if (g_ascii_strncasecmp (begin, SPF_MX, sizeof (SPF_MX) - 1) == 0) {
-				NEW_ADDR (new);
-				begin += sizeof (SPF_MX) - 1;
-				res = parse_spf_mx (task, begin, rec, new);
-			}
-			else {
-				msg_info ("<%s>: spf error for domain %s: bad spf command %s",
-					task->message_id, rec->sender_domain, begin);
-			}
-			break;
-		case 'p':
-			/* ptr */
-			if (g_ascii_strncasecmp (begin, SPF_PTR,
-				sizeof (SPF_PTR) - 1) == 0) {
-				NEW_ADDR (new);
-				begin += sizeof (SPF_PTR) - 1;
-				res = parse_spf_ptr (task, begin, rec, new);
-			}
-			else {
-				msg_info ("<%s>: spf error for domain %s: bad spf command %s",
-					task->message_id, rec->sender_domain, begin);
-			}
-			break;
-		case 'e':
-			/* exp or exists */
-			if (g_ascii_strncasecmp (begin, SPF_EXP,
-				sizeof (SPF_EXP) - 1) == 0) {
-				begin += sizeof (SPF_EXP) - 1;
-				res = parse_spf_exp (task, begin, rec, NULL);
-			}
-			else if (g_ascii_strncasecmp (begin, SPF_EXISTS,
-				sizeof (SPF_EXISTS) - 1) == 0) {
-				NEW_ADDR (new);
-				begin += sizeof (SPF_EXISTS) - 1;
-				res = parse_spf_exists (task, begin, rec, new);
-			}
-			else {
-				msg_info ("<%s>: spf error for domain %s: bad spf command %s",
-					task->message_id, rec->sender_domain, begin);
-			}
-			break;
-		case 'r':
-			/* redirect */
-			if (g_ascii_strncasecmp (begin, SPF_REDIRECT,
-				sizeof (SPF_REDIRECT) - 1) == 0) {
-				begin += sizeof (SPF_REDIRECT) - 1;
-				res = parse_spf_redirect (task, begin, rec, NULL);
-			}
-			else {
-				msg_info ("<%s>: spf error for domain %s: bad spf command %s",
-					task->message_id, rec->sender_domain, begin);
-			}
-			break;
-		case 'v':
-			if (g_ascii_strncasecmp (begin, "v=spf",
-				sizeof ("v=spf") - 1) == 0) {
-				/* Skip this element till the end of record */
-				while (*begin && !g_ascii_isspace (*begin)) {
-					begin++;
 				}
-			}
-			break;
-		default:
-			msg_info ("<%s>: spf error for domain %s: bad spf command %s",
-				task->message_id, rec->sender_domain, begin);
-			break;
+				else {
+					msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+							task->message_id, rec->sender_domain, begin);
+				}
+				break;
+			case 'm':
+				/* mx */
+				if (g_ascii_strncasecmp (begin, SPF_MX, sizeof (SPF_MX) - 1) == 0) {
+					NEW_ADDR (new);
+					begin += sizeof (SPF_MX) - 1;
+					res = parse_spf_mx (task, begin, rec, new);
+				}
+				else {
+					msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+							task->message_id, rec->sender_domain, begin);
+				}
+				break;
+			case 'p':
+				/* ptr */
+				if (g_ascii_strncasecmp (begin, SPF_PTR, sizeof (SPF_PTR) - 1) == 0) {
+					NEW_ADDR (new);
+					begin += sizeof (SPF_PTR) - 1;
+					res = parse_spf_ptr (task, begin, rec, new);
+				}
+				else {
+					msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+							task->message_id, rec->sender_domain, begin);
+				}
+				break;
+			case 'e':
+				/* exp or exists */
+				if (g_ascii_strncasecmp (begin, SPF_EXP, sizeof (SPF_EXP) - 1) == 0) {
+					begin += sizeof (SPF_EXP) - 1;
+					res = parse_spf_exp (task, begin, rec, NULL);
+				}
+				else if (g_ascii_strncasecmp (begin, SPF_EXISTS, sizeof (SPF_EXISTS) - 1) == 0) {
+					NEW_ADDR (new);
+					begin += sizeof (SPF_EXISTS) - 1;
+					res = parse_spf_exists (task, begin, rec, new);
+				}
+				else {
+					msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+							task->message_id, rec->sender_domain, begin);
+				}
+				break;
+			case 'r':
+				/* redirect */
+				if (g_ascii_strncasecmp (begin, SPF_REDIRECT, sizeof (SPF_REDIRECT) - 1) == 0) {
+					begin += sizeof (SPF_REDIRECT) - 1;
+					res = parse_spf_redirect (task, begin, rec, NULL);
+				}
+				else {
+					msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+							task->message_id, rec->sender_domain, begin);
+				}
+				break;
+			case 'v':
+				if (g_ascii_strncasecmp (begin, "v=spf", sizeof ("v=spf") - 1) == 0) {
+					/* Skip this element till the end of record */
+					while (*begin && !g_ascii_isspace (*begin)) {
+						begin ++;
+					}
+				}
+				break;
+			default:
+				msg_info ("<%s>: spf error for domain %s: bad spf command %s",
+						task->message_id, rec->sender_domain, begin);
+				break;
 		}
 		if (res) {
 			if (new != NULL) {
 				rec->addrs = g_list_prepend (rec->addrs, new);
 			}
-			rec->elt_num++;
+			rec->elt_num ++;
 		}
 	}
 
@@ -1439,16 +1325,14 @@ parse_spf_record (struct rspamd_task *task, struct spf_record *rec)
 static void
 parse_spf_scopes (struct spf_record *rec, gchar **begin)
 {
-	for (;; ) {
-		if (g_ascii_strncasecmp (*begin, SPF_SCOPE_PRA, sizeof (SPF_SCOPE_PRA) -
-			1) == 0) {
+	for (;;) {
+		if (g_ascii_strncasecmp (*begin, SPF_SCOPE_PRA, sizeof (SPF_SCOPE_PRA) - 1) == 0) {
 			*begin += sizeof (SPF_SCOPE_PRA) - 1;
 			/* XXX: Implement actual PRA check */
 			/* extract_pra_info (rec); */
 			continue;
 		}
-		else if (g_ascii_strncasecmp (*begin, SPF_SCOPE_MFROM,
-			sizeof (SPF_SCOPE_MFROM) - 1) == 0) {
+		else if (g_ascii_strncasecmp (*begin, SPF_SCOPE_MFROM, sizeof (SPF_SCOPE_MFROM) - 1) == 0) {
 			/* mfrom is standart spf1 check */
 			*begin += sizeof (SPF_SCOPE_MFROM) - 1;
 			continue;
@@ -1456,7 +1340,7 @@ parse_spf_scopes (struct spf_record *rec, gchar **begin)
 		else if (**begin != ',') {
 			break;
 		}
-		(*begin)++;
+		(*begin) ++;
 	}
 }
 
@@ -1465,51 +1349,47 @@ start_spf_parse (struct spf_record *rec, gchar *begin, guint ttl)
 {
 	/* Skip spaces */
 	while (g_ascii_isspace (*begin)) {
-		begin++;
+		begin ++;
 	}
 
-	if (g_ascii_strncasecmp (begin, SPF_VER1_STR,
-		sizeof (SPF_VER1_STR) - 1) == 0) {
+	if (g_ascii_strncasecmp (begin, SPF_VER1_STR, sizeof (SPF_VER1_STR) - 1) == 0) {
 		begin += sizeof (SPF_VER1_STR) - 1;
 		while (g_ascii_isspace (*begin) && *begin) {
-			begin++;
+			begin ++;
 		}
 		rec->elts = g_strsplit_set (begin, " ", 0);
 		rec->elt_num = 0;
 		if (rec->elts) {
-			rspamd_mempool_add_destructor (rec->task->task_pool,
-				(rspamd_mempool_destruct_t)g_strfreev, rec->elts);
+			rspamd_mempool_add_destructor (rec->task->task_pool, (rspamd_mempool_destruct_t)g_strfreev, rec->elts);
 			rec->cur_elt = rec->elts[0];
-			while (parse_spf_record (rec->task, rec)) ;
+			while (parse_spf_record (rec->task, rec));
 			if (ttl != 0) {
 				rec->ttl = ttl;
 			}
 			return TRUE;
 		}
 	}
-	else if (g_ascii_strncasecmp (begin, SPF_VER2_STR, sizeof (SPF_VER2_STR) -
-		1) == 0) {
+	else if (g_ascii_strncasecmp (begin, SPF_VER2_STR, sizeof (SPF_VER2_STR) - 1) == 0) {
 		/* Skip one number of record, so no we are here spf2.0/ */
 		begin += sizeof (SPF_VER2_STR);
 		if (*begin != '/') {
 			msg_info ("<%s>: spf error for domain %s: sender id is invalid",
-				rec->task->message_id, rec->sender_domain);
+					rec->task->message_id, rec->sender_domain);
 		}
 		else {
-			begin++;
+			begin ++;
 			parse_spf_scopes (rec, &begin);
 		}
 		/* Now common spf record */
 		while (g_ascii_isspace (*begin) && *begin) {
-			begin++;
+			begin ++;
 		}
 		rec->elts = g_strsplit_set (begin, " ", 0);
 		rec->elt_num = 0;
 		if (rec->elts) {
-			rspamd_mempool_add_destructor (rec->task->task_pool,
-				(rspamd_mempool_destruct_t)g_strfreev, rec->elts);
+			rspamd_mempool_add_destructor (rec->task->task_pool, (rspamd_mempool_destruct_t)g_strfreev, rec->elts);
 			rec->cur_elt = rec->elts[0];
-			while (parse_spf_record (rec->task, rec)) ;
+			while (parse_spf_record (rec->task, rec));
 			if (ttl != 0) {
 				rec->ttl = ttl;
 			}
@@ -1518,10 +1398,7 @@ start_spf_parse (struct spf_record *rec, gchar *begin, guint ttl)
 	}
 	else {
 		msg_debug ("<%s>: spf error for domain %s: bad spf record version: %*s",
-			rec->task->message_id,
-			rec->sender_domain,
-			sizeof (SPF_VER1_STR) - 1,
-			begin);
+				rec->task->message_id, rec->sender_domain, sizeof (SPF_VER1_STR) - 1, begin);
 	}
 	return FALSE;
 }
@@ -1532,10 +1409,9 @@ spf_dns_callback (struct rdns_reply *reply, gpointer arg)
 	struct spf_record *rec = arg;
 	struct rdns_reply_entry *elt;
 
-	rec->requests_inflight--;
+	rec->requests_inflight --;
 	if (reply->code == RDNS_RC_NOERROR) {
-		LL_FOREACH (reply->entries, elt)
-		{
+		LL_FOREACH (reply->entries, elt) {
 			if (start_spf_parse (rec, elt->content.txt.data, elt->ttl)) {
 				break;
 			}
@@ -1550,11 +1426,10 @@ spf_dns_callback (struct rdns_reply *reply, gpointer arg)
 gchar *
 get_spf_domain (struct rspamd_task *task)
 {
-	gchar *domain, *res = NULL;
-	GList *domains;
+	gchar                           *domain, *res = NULL;
+	GList                           *domains;
 
-	if (task->from &&
-		(domain = strchr (task->from, '@')) != NULL && *domain == '@') {
+	if (task->from && (domain = strchr (task->from, '@')) != NULL && *domain == '@') {
 		res = rspamd_mempool_strdup (task->task_pool, domain + 1);
 		if ((domain = strchr (res, '>')) != NULL) {
 			*domain = '\0';
@@ -1562,10 +1437,7 @@ get_spf_domain (struct rspamd_task *task)
 	}
 	else {
 		/* Extract from header */
-		domains = message_get_header (task->task_pool,
-				task->message,
-				"From",
-				FALSE);
+		domains = message_get_header (task->task_pool, task->message, "From", FALSE);
 
 		if (domains != NULL) {
 			res = rspamd_mempool_strdup (task->task_pool, domains->data);
@@ -1589,28 +1461,24 @@ get_spf_domain (struct rspamd_task *task)
 gboolean
 resolve_spf (struct rspamd_task *task, spf_cb_t callback)
 {
-	struct spf_record *rec;
-	gchar *domain;
-	GList *domains;
+	struct spf_record               *rec;
+	gchar                           *domain;
+	GList                           *domains;
 
 	rec = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct spf_record));
 	rec->task = task;
 	rec->callback = callback;
 	/* Add destructor */
-	rspamd_mempool_add_destructor (task->task_pool,
-		(rspamd_mempool_destruct_t)spf_record_destructor,
-		rec);
+	rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)spf_record_destructor, rec);
 
 	/* Extract from data */
-	if (task->from &&
-		(domain = strchr (task->from, '@')) != NULL && *domain == '@') {
+	if (task->from && (domain = strchr (task->from, '@')) != NULL && *domain == '@') {
 		rec->sender = task->from;
 
 		rec->local_part = rspamd_mempool_strdup (task->task_pool, task->from);
 		*(rec->local_part + (domain - task->from)) = '\0';
 		if (*rec->local_part == '<') {
-			memmove (rec->local_part, rec->local_part + 1,
-				strlen (rec->local_part));
+			memmove (rec->local_part, rec->local_part + 1, strlen (rec->local_part));
 		}
 		rec->cur_domain = rspamd_mempool_strdup (task->task_pool, domain + 1);
 		if ((domain = strchr (rec->cur_domain, '>')) != NULL) {
@@ -1618,31 +1486,25 @@ resolve_spf (struct rspamd_task *task, spf_cb_t callback)
 		}
 		rec->sender_domain = rec->cur_domain;
 
-		if (make_dns_request (task->resolver, task->s, task->task_pool,
-			spf_dns_callback,
-			(void *)rec, RDNS_REQUEST_TXT, rec->cur_domain)) {
-			task->dns_requests++;
-			rec->requests_inflight++;
+		if (make_dns_request (task->resolver, task->s, task->task_pool, spf_dns_callback,
+				(void *)rec, RDNS_REQUEST_TXT, rec->cur_domain)) {
+			task->dns_requests ++;
+			rec->requests_inflight ++;
 			return TRUE;
 		}
 	}
 	else {
 		/* Extract from header */
-		domains = message_get_header (task->task_pool,
-				task->message,
-				"From",
-				FALSE);
+		domains = message_get_header (task->task_pool, task->message, "From", FALSE);
 
 		if (domains != NULL) {
-			rec->cur_domain = rspamd_mempool_strdup (task->task_pool,
-					domains->data);
+			rec->cur_domain = rspamd_mempool_strdup (task->task_pool, domains->data);
 			g_list_free (domains);
 
 			if ((domain = strrchr (rec->cur_domain, '@')) == NULL) {
 				return FALSE;
 			}
-			rec->sender = rspamd_mempool_strdup (task->task_pool,
-					rec->cur_domain);
+			rec->sender = rspamd_mempool_strdup (task->task_pool, rec->cur_domain);
 			rec->local_part = rec->cur_domain;
 			*domain = '\0';
 			rec->cur_domain = domain + 1;
@@ -1656,10 +1518,9 @@ resolve_spf (struct rspamd_task *task, spf_cb_t callback)
 			}
 			rec->sender_domain = rec->cur_domain;
 			if (make_dns_request (task->resolver, task->s, task->task_pool,
-				spf_dns_callback, (void *)rec, RDNS_REQUEST_TXT,
-				rec->cur_domain)) {
-				task->dns_requests++;
-				rec->requests_inflight++;
+					spf_dns_callback, (void *)rec, RDNS_REQUEST_TXT, rec->cur_domain)) {
+				task->dns_requests ++;
+				rec->requests_inflight ++;
 				return TRUE;
 			}
 		}
@@ -1668,6 +1529,6 @@ resolve_spf (struct rspamd_task *task, spf_cb_t callback)
 	return FALSE;
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libserver/spf.h b/src/libserver/spf.h
index 18d8229f8..94c613e42 100644
--- a/src/libserver/spf.h
+++ b/src/libserver/spf.h
@@ -78,7 +78,7 @@ gboolean resolve_spf (struct rspamd_task *task, spf_cb_t callback);
 /*
  * Get a domain for spf for specified task
  */
-gchar * get_spf_domain (struct rspamd_task *task);
+gchar *get_spf_domain (struct rspamd_task *task);
 
 
 #endif
diff --git a/src/libserver/statfile.c b/src/libserver/statfile.c
index b0db2bc4c..a993fd116 100644
--- a/src/libserver/statfile.c
+++ b/src/libserver/statfile.c
@@ -24,8 +24,8 @@
 
 #include "config.h"
 
-#include "main.h"
 #include "statfile.h"
+#include "main.h"
 
 #define RSPAMD_STATFILE_VERSION {'1', '2'}
 #define BACKUP_SUFFIX ".old"
@@ -33,33 +33,33 @@
 /* Maximum number of statistics files */
 #define STATFILES_MAX 255
 static void statfile_pool_set_block_common (
-	statfile_pool_t * pool, stat_file_t * file,
-	guint32 h1, guint32 h2,
-	time_t t, double value,
-	gboolean from_now);
+				statfile_pool_t * pool, stat_file_t * file, 
+				guint32                         h1, guint32 h2, 
+				time_t t, double value, 
+				gboolean from_now);
 
 static gint
 cmpstatfile (const void *a, const void *b)
 {
-	const stat_file_t *s1 = a, *s2 = b;
+	const stat_file_t              *s1 = a, *s2 = b;
 
 	return g_ascii_strcasecmp (s1->filename, s2->filename);
 }
 
 /* Convert statfile version 1.0 to statfile version 1.2, saving backup */
 struct stat_file_header_10 {
-	u_char magic[3];                        /**< magic signature ('r' 's' 'd')      */
-	u_char version[2];                      /**< version of statfile				*/
-	u_char padding[3];                      /**< padding							*/
-	guint64 create_time;                                            /**< create time (time_t->guint64)		*/
+	u_char magic[3];						/**< magic signature ('r' 's' 'd') 		*/
+	u_char version[2];						/**< version of statfile				*/
+	u_char padding[3];						/**< padding							*/
+	guint64                         create_time;					/**< create time (time_t->guint64)		*/
 };
 
 static gboolean
 convert_statfile_10 (stat_file_t * file)
 {
-	gchar *backup_name;
+	gchar                           *backup_name;
 	struct stat st;
-	struct stat_file_header header = {
+	struct stat_file_header         header = {
 		.magic = {'r', 's', 'd'},
 		.version = RSPAMD_STATFILE_VERSION,
 		.padding = {0, 0, 0},
@@ -70,12 +70,9 @@ convert_statfile_10 (stat_file_t * file)
 
 	/* Format backup name */
 	backup_name = g_strdup_printf ("%s.%s", file->filename, BACKUP_SUFFIX);
-
-	msg_info ("convert old statfile %s to version %c.%c, backup in %s",
-		file->filename,
-		header.version[0],
-		header.version[1],
-		backup_name);
+	
+	msg_info ("convert old statfile %s to version %c.%c, backup in %s", file->filename, 
+			header.version[0], header.version[1], backup_name);
 
 	if (stat (backup_name, &st) != -1) {
 		msg_info ("replace old %s", backup_name);
@@ -88,51 +85,31 @@ convert_statfile_10 (stat_file_t * file)
 	/* XXX: maybe race condition here */
 	unlock_file (file->fd, FALSE);
 	close (file->fd);
-	if ((file->fd =
-		open (file->filename, O_RDWR | O_TRUNC | O_CREAT,
-		S_IWUSR | S_IRUSR)) == -1) {
-		msg_info ("cannot create file %s, error %d, %s",
-			file->filename,
-			errno,
-			strerror (errno));
+	if ((file->fd = open (file->filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
+		msg_info ("cannot create file %s, error %d, %s", file->filename, errno, strerror (errno));
 		return FALSE;
 	}
 	lock_file (file->fd, FALSE);
 	/* Now make new header and copy it to new file */
 	if (write (file->fd, &header, sizeof (header)) == -1) {
-		msg_info ("cannot write to file %s, error %d, %s",
-			file->filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot write to file %s, error %d, %s", file->filename, errno, strerror (errno));
 		return FALSE;
 	}
 	/* Now write old map to new file */
-	if (write (file->fd,
-		((u_char *)file->map + sizeof (struct stat_file_header_10)),
-		file->len - sizeof (struct stat_file_header_10)) == -1) {
-		msg_info ("cannot write to file %s, error %d, %s",
-			file->filename,
-			errno,
-			strerror (errno));
+	if (write (file->fd, ((u_char *)file->map + sizeof (struct stat_file_header_10)),
+						file->len - sizeof (struct stat_file_header_10)) == -1) {
+		msg_info ("cannot write to file %s, error %d, %s", file->filename, errno, strerror (errno));
 		return FALSE;
 	}
 	/* Unmap old memory and map new */
 	munmap (file->map, file->len);
-	file->len = file->len + sizeof (struct stat_file_header) -
-		sizeof (struct stat_file_header_10);
+	file->len = file->len + sizeof (struct stat_file_header) - sizeof (struct stat_file_header_10);
 #ifdef HAVE_MMAP_NOCORE
-	if ((file->map =
-		mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE,
-		file->fd, 0)) == MAP_FAILED) {
+	if ((file->map = mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE, file->fd, 0)) == MAP_FAILED) {
 #else
-	if ((file->map =
-		mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd,
-		0)) == MAP_FAILED) {
+	if ((file->map = mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd, 0)) == MAP_FAILED) {
 #endif
-		msg_info ("cannot mmap file %s, error %d, %s",
-			file->filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot mmap file %s, error %d, %s", file->filename, errno, strerror (errno));
 		return FALSE;
 	}
 
@@ -143,9 +120,9 @@ convert_statfile_10 (stat_file_t * file)
 static gint
 statfile_pool_check (stat_file_t * file)
 {
-	struct stat_file *f;
-	gchar *c;
-	static gchar valid_version[] = RSPAMD_STATFILE_VERSION;
+	struct stat_file               *f;
+	gchar                           *c;
+	static gchar                     valid_version[] = RSPAMD_STATFILE_VERSION;
 
 
 	if (!file || !file->map) {
@@ -153,9 +130,7 @@ statfile_pool_check (stat_file_t * file)
 	}
 
 	if (file->len < sizeof (struct stat_file)) {
-		msg_info ("file %s is too short to be stat file: %z",
-			file->filename,
-			file->len);
+		msg_info ("file %s is too short to be stat file: %z", file->filename, file->len);
 		return -1;
 	}
 
@@ -175,40 +150,31 @@ statfile_pool_check (stat_file_t * file)
 	}
 	else if (memcmp (c, valid_version, sizeof (valid_version)) != 0) {
 		/* Unknown version */
-		msg_info ("file %s has invalid version %c.%c",
-			file->filename,
-			'0' + *c,
-			'0' + *(c + 1));
+		msg_info ("file %s has invalid version %c.%c", file->filename, '0' + *c, '0' + *(c + 1));
 		return -1;
 	}
 
 	/* Check first section and set new offset */
 	file->cur_section.code = f->section.code;
 	file->cur_section.length = f->section.length;
-	if (file->cur_section.length * sizeof (struct stat_file_block) >
-		file->len) {
-		msg_info ("file %s is truncated: %z, must be %z",
-			file->filename,
-			file->len,
-			file->cur_section.length * sizeof (struct stat_file_block));
+	if (file->cur_section.length * sizeof (struct stat_file_block) > file->len) {
+		msg_info ("file %s is truncated: %z, must be %z", file->filename, file->len, file->cur_section.length * sizeof (struct stat_file_block));
 		return -1;
 	}
-	file->seek_pos = sizeof (struct stat_file) -
-		sizeof (struct stat_file_block);
+	file->seek_pos = sizeof (struct stat_file) - sizeof (struct stat_file_block);
 
 	return 0;
 }
 
 
-statfile_pool_t *
+statfile_pool_t                *
 statfile_pool_new (rspamd_mempool_t *pool, gboolean use_mlock)
 {
-	statfile_pool_t *new;
+	statfile_pool_t                *new;
 
 	new = rspamd_mempool_alloc0 (pool, sizeof (statfile_pool_t));
 	new->pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
-	new->files =
-		rspamd_mempool_alloc0 (new->pool, STATFILES_MAX * sizeof (stat_file_t));
+	new->files = rspamd_mempool_alloc0 (new->pool, STATFILES_MAX * sizeof (stat_file_t));
 	new->lock = rspamd_mempool_get_mutex (new->pool);
 	new->mlock_ok = use_mlock;
 
@@ -216,24 +182,18 @@ statfile_pool_new (rspamd_mempool_t *pool, gboolean use_mlock)
 }
 
 static stat_file_t *
-statfile_pool_reindex (statfile_pool_t * pool,
-	gchar *filename,
-	size_t old_size,
-	size_t size)
+statfile_pool_reindex (statfile_pool_t * pool, gchar *filename, size_t old_size, size_t size)
 {
-	gchar *backup;
-	gint fd;
-	stat_file_t *new;
-	u_char *map, *pos;
-	struct stat_file_block *block;
-	struct stat_file_header *header;
+	gchar                           *backup;
+	gint                            fd;
+	stat_file_t                    *new;
+	u_char                         *map, *pos;
+	struct stat_file_block         *block;
+	struct stat_file_header        *header;
 
 	if (size <
-		sizeof (struct stat_file_header) + sizeof (struct stat_file_section) +
-		sizeof (block)) {
-		msg_err ("file %s is too small to carry any statistic: %z",
-			filename,
-			size);
+			sizeof (struct stat_file_header) + sizeof (struct stat_file_section) + sizeof (block)) {
+		msg_err ("file %s is too small to carry any statistic: %z", filename, size);
 		return NULL;
 	}
 
@@ -242,8 +202,7 @@ statfile_pool_reindex (statfile_pool_t * pool,
 
 	backup = g_strconcat (filename, ".old", NULL);
 	if (rename (filename, backup) == -1) {
-		msg_err ("cannot rename %s to %s: %s", filename, backup, strerror (
-				errno));
+		msg_err ("cannot rename %s to %s: %s", filename, backup, strerror (errno));
 		g_free (backup);
 		rspamd_mempool_unlock_mutex (pool->lock);
 		return NULL;
@@ -268,8 +227,7 @@ statfile_pool_reindex (statfile_pool_t * pool,
 	}
 
 	/* Now start reading blocks from old statfile */
-	if ((map =
-		mmap (NULL, old_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
+	if ((map = mmap (NULL, old_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 		msg_err ("cannot mmap file: %s", strerror (errno));
 		close (fd);
 		g_free (backup);
@@ -280,20 +238,14 @@ statfile_pool_reindex (statfile_pool_t * pool,
 	while (old_size - (pos - map) >= sizeof (struct stat_file_block)) {
 		block = (struct stat_file_block *)pos;
 		if (block->hash1 != 0 && block->value != 0) {
-			statfile_pool_set_block_common (pool,
-				new,
-				block->hash1,
-				block->hash2,
-				0,
-				block->value,
-				FALSE);
+			statfile_pool_set_block_common (pool, new, block->hash1, block->hash2, 0, block->value, FALSE);
 		}
 		pos += sizeof (block);
 	}
 
 	header = (struct stat_file_header *)map;
 	statfile_set_revision (new, header->revision, header->rev_time);
-
+	
 	munmap (map, old_size);
 	close (fd);
 	unlink (backup);
@@ -309,9 +261,9 @@ statfile_pool_reindex (statfile_pool_t * pool,
 static void
 statfile_preload (stat_file_t *file)
 {
-	guint8 *pos, *end;
-	volatile guint8 t;
-	gsize size;
+	guint8                         *pos, *end;
+	volatile guint8					t;
+	gsize                           size;
 
 	pos = (guint8 *)file->map;
 	end = (guint8 *)file->map + file->len;
@@ -334,66 +286,50 @@ statfile_preload (stat_file_t *file)
 	}
 }
 
-stat_file_t *
-statfile_pool_open (statfile_pool_t * pool,
-	gchar *filename,
-	size_t size,
-	gboolean forced)
+stat_file_t                    *
+statfile_pool_open (statfile_pool_t * pool, gchar *filename, size_t size, gboolean forced)
 {
-	struct stat st;
-	stat_file_t *new_file;
+	struct stat                     st;
+	stat_file_t                    *new_file;
 
 	if ((new_file = statfile_pool_is_open (pool, filename)) != NULL) {
 		return new_file;
 	}
 
 	if (pool->opened >= STATFILES_MAX - 1) {
-		msg_err ("reached hard coded limit of statfiles opened: %d",
-			STATFILES_MAX);
+		msg_err ("reached hard coded limit of statfiles opened: %d", STATFILES_MAX);
 		return NULL;
 	}
 
 	if (stat (filename, &st) == -1) {
-		msg_info ("cannot stat file %s, error %s, %d", filename, strerror (
-				errno), errno);
+		msg_info ("cannot stat file %s, error %s, %d", filename, strerror (errno), errno);
 		return NULL;
 	}
 
 	rspamd_mempool_lock_mutex (pool->lock);
-	if (!forced &&
-		labs (size - st.st_size) > (long)sizeof (struct stat_file) * 2
-		&& size > sizeof (struct stat_file)) {
+	if (!forced && labs (size - st.st_size) > (long)sizeof (struct stat_file) * 2
+			&& size > sizeof (struct stat_file)) {
 		rspamd_mempool_unlock_mutex (pool->lock);
-		msg_warn ("need to reindex statfile old size: %Hz, new size: %Hz",
-			(size_t)st.st_size, size);
+		msg_warn ("need to reindex statfile old size: %Hz, new size: %Hz", (size_t)st.st_size, size);
 		return statfile_pool_reindex (pool, filename, st.st_size, size);
 	}
 	else if (size < sizeof (struct stat_file)) {
-		msg_err ("requested to shrink statfile to %Hz but it is too small",
-			size);
+		msg_err ("requested to shrink statfile to %Hz but it is too small", size);
 	}
 
 	new_file = &pool->files[pool->opened++];
 	bzero (new_file, sizeof (stat_file_t));
 	if ((new_file->fd = open (filename, O_RDWR)) == -1) {
-		msg_info ("cannot open file %s, error %d, %s",
-			filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot open file %s, error %d, %s", filename, errno, strerror (errno));
 		rspamd_mempool_unlock_mutex (pool->lock);
 		pool->opened--;
 		return NULL;
 	}
 
-	if ((new_file->map =
-		mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED,
-		new_file->fd, 0)) == MAP_FAILED) {
+	if ((new_file->map = mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, new_file->fd, 0)) == MAP_FAILED) {
 		close (new_file->fd);
 		rspamd_mempool_unlock_mutex (pool->lock);
-		msg_info ("cannot mmap file %s, error %d, %s",
-			filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot mmap file %s, error %d, %s", filename, errno, strerror (errno));
 		pool->opened--;
 		return NULL;
 
@@ -404,9 +340,7 @@ statfile_pool_open (statfile_pool_t * pool,
 	/* Try to lock pages in RAM */
 	if (pool->mlock_ok) {
 		if (mlock (new_file->map, new_file->len) == -1) {
-			msg_warn (
-				"mlock of statfile failed, maybe you need to increase RLIMIT_MEMLOCK limit for a process: %s",
-				strerror (errno));
+			msg_warn ("mlock of statfile failed, maybe you need to increase RLIMIT_MEMLOCK limit for a process: %s", strerror (errno));
 			pool->mlock_ok = FALSE;
 		}
 	}
@@ -416,7 +350,7 @@ statfile_pool_open (statfile_pool_t * pool,
 		pool->opened--;
 		rspamd_mempool_unlock_mutex (pool->lock);
 		unlock_file (new_file->fd, FALSE);
-		munmap (new_file->map, st.st_size);
+        munmap (new_file->map, st.st_size);
 		return NULL;
 	}
 	unlock_file (new_file->fd, FALSE);
@@ -433,11 +367,9 @@ statfile_pool_open (statfile_pool_t * pool,
 }
 
 gint
-statfile_pool_close (statfile_pool_t * pool,
-	stat_file_t * file,
-	gboolean keep_sorted)
+statfile_pool_close (statfile_pool_t * pool, stat_file_t * file, gboolean keep_sorted)
 {
-	stat_file_t *pos;
+	stat_file_t                    *pos;
 
 	if ((pos = statfile_pool_is_open (pool, file->filename)) == NULL) {
 		msg_info ("file %s is not opened", file->filename);
@@ -456,7 +388,7 @@ statfile_pool_close (statfile_pool_t * pool,
 	}
 	/* Move the remain statfiles */
 	memmove (pos, ((guint8 *)pos) + sizeof (stat_file_t),
-		(--pool->opened - (pos - pool->files)) * sizeof (stat_file_t));
+			(--pool->opened - (pos - pool->files)) * sizeof (stat_file_t));
 
 	rspamd_mempool_unlock_mutex (pool->lock);
 
@@ -466,7 +398,7 @@ statfile_pool_close (statfile_pool_t * pool,
 gint
 statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
 {
-	struct stat_file_header header = {
+	struct stat_file_header         header = {
 		.magic = {'r', 's', 'd'},
 		.version = RSPAMD_STATFILE_VERSION,
 		.padding = {0, 0, 0},
@@ -474,13 +406,13 @@ statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
 		.rev_time = 0,
 		.used_blocks = 0
 	};
-	struct stat_file_section section = {
+	struct stat_file_section        section = {
 		.code = STATFILE_SECTION_COMMON,
 	};
-	struct stat_file_block block = { 0, 0, 0 };
-	gint fd;
-	guint buflen = 0, nblocks;
-	gchar *buf = NULL;
+	struct stat_file_block          block = { 0, 0, 0 };
+	gint                            fd;
+	guint                           buflen = 0, nblocks;
+	gchar                           *buf = NULL;
 
 	if (statfile_pool_is_open (pool, filename) != NULL) {
 		msg_info ("file %s is already opened", filename);
@@ -488,40 +420,26 @@ statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
 	}
 
 	if (size <
-		sizeof (struct stat_file_header) + sizeof (struct stat_file_section) +
-		sizeof (block)) {
-		msg_err ("file %s is too small to carry any statistic: %z",
-			filename,
-			size);
+			sizeof (struct stat_file_header) + sizeof (struct stat_file_section) + sizeof (block)) {
+		msg_err ("file %s is too small to carry any statistic: %z", filename, size);
 		return -1;
 	}
 
 	rspamd_mempool_lock_mutex (pool->lock);
-	nblocks =
-		(size - sizeof (struct stat_file_header) -
-		sizeof (struct stat_file_section)) / sizeof (struct stat_file_block);
+	nblocks = (size - sizeof (struct stat_file_header) - sizeof (struct stat_file_section)) / sizeof (struct stat_file_block);
 	header.total_blocks = nblocks;
 
-	if ((fd =
-		open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
-		msg_info ("cannot create file %s, error %d, %s",
-			filename,
-			errno,
-			strerror (errno));
+	if ((fd = open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
+		msg_info ("cannot create file %s, error %d, %s", filename, errno, strerror (errno));
 		rspamd_mempool_unlock_mutex (pool->lock);
 		return -1;
 	}
 
-	rspamd_fallocate (fd,
-		0,
-		sizeof (header) + sizeof (section) + sizeof (block) * nblocks);
+	rspamd_fallocate (fd, 0, sizeof (header) + sizeof (section) + sizeof (block) * nblocks);
 
 	header.create_time = (guint64) time (NULL);
 	if (write (fd, &header, sizeof (header)) == -1) {
-		msg_info ("cannot write header to file %s, error %d, %s",
-			filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot write header to file %s, error %d, %s", filename, errno, strerror (errno));
 		close (fd);
 		rspamd_mempool_unlock_mutex (pool->lock);
 		return -1;
@@ -529,15 +447,12 @@ statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
 
 	section.length = (guint64) nblocks;
 	if (write (fd, &section, sizeof (section)) == -1) {
-		msg_info ("cannot write section header to file %s, error %d, %s",
-			filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot write section header to file %s, error %d, %s", filename, errno, strerror (errno));
 		close (fd);
 		rspamd_mempool_unlock_mutex (pool->lock);
 		return -1;
 	}
-
+	
 	/* Buffer for write 256 blocks at once */
 	if (nblocks > 256) {
 		buflen = sizeof (block) * 256;
@@ -548,10 +463,7 @@ statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
 		if (nblocks > 256) {
 			/* Just write buffer */
 			if (write (fd, buf, buflen) == -1) {
-				msg_info ("cannot write blocks buffer to file %s, error %d, %s",
-					filename,
-					errno,
-					strerror (errno));
+				msg_info ("cannot write blocks buffer to file %s, error %d, %s", filename, errno, strerror (errno));
 				close (fd);
 				rspamd_mempool_unlock_mutex (pool->lock);
 				g_free (buf);
@@ -561,10 +473,7 @@ statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
 		}
 		else {
 			if (write (fd, &block, sizeof (block)) == -1) {
-				msg_info ("cannot write block to file %s, error %d, %s",
-					filename,
-					errno,
-					strerror (errno));
+				msg_info ("cannot write block to file %s, error %d, %s", filename, errno, strerror (errno));
 				close (fd);
 				if (buf) {
 					g_free (buf);
@@ -572,7 +481,7 @@ statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
 				rspamd_mempool_unlock_mutex (pool->lock);
 				return -1;
 			}
-			nblocks--;
+			nblocks --;
 		}
 	}
 
@@ -589,7 +498,7 @@ statfile_pool_create (statfile_pool_t * pool, gchar *filename, size_t size)
 void
 statfile_pool_delete (statfile_pool_t * pool)
 {
-	gint i;
+	gint                            i;
 
 	for (i = 0; i < pool->opened; i++) {
 		statfile_pool_close (pool, &pool->files[i], FALSE);
@@ -612,15 +521,11 @@ statfile_pool_unlock_file (statfile_pool_t * pool, stat_file_t * file)
 }
 
 double
-statfile_pool_get_block (statfile_pool_t * pool,
-	stat_file_t * file,
-	guint32 h1,
-	guint32 h2,
-	time_t now)
+statfile_pool_get_block (statfile_pool_t * pool, stat_file_t * file, guint32 h1, guint32 h2, time_t now)
 {
-	struct stat_file_block *block;
-	guint i, blocknum;
-	u_char *c;
+	struct stat_file_block         *block;
+	guint                           i, blocknum;
+	u_char                         *c;
 
 
 	file->access_time = now;
@@ -629,8 +534,7 @@ statfile_pool_get_block (statfile_pool_t * pool,
 	}
 
 	blocknum = h1 % file->cur_section.length;
-	c = (u_char *) file->map + file->seek_pos + blocknum *
-		sizeof (struct stat_file_block);
+	c = (u_char *) file->map + file->seek_pos + blocknum * sizeof (struct stat_file_block);
 	block = (struct stat_file_block *)c;
 
 	for (i = 0; i < CHAIN_LENGTH; i++) {
@@ -649,19 +553,13 @@ statfile_pool_get_block (statfile_pool_t * pool,
 }
 
 static void
-statfile_pool_set_block_common (statfile_pool_t * pool,
-	stat_file_t * file,
-	guint32 h1,
-	guint32 h2,
-	time_t t,
-	double value,
-	gboolean from_now)
+statfile_pool_set_block_common (statfile_pool_t * pool, stat_file_t * file, guint32 h1, guint32 h2, time_t t, double value, gboolean from_now)
 {
-	struct stat_file_block *block, *to_expire = NULL;
-	struct stat_file_header *header;
-	guint i, blocknum;
-	u_char *c;
-	double min = G_MAXDOUBLE;
+	struct stat_file_block         *block, *to_expire = NULL;
+	struct stat_file_header        *header;
+	guint                           i, blocknum;
+	u_char                         *c;
+    double                          min = G_MAXDOUBLE;
 
 	if (from_now) {
 		file->access_time = t;
@@ -672,16 +570,13 @@ statfile_pool_set_block_common (statfile_pool_t * pool,
 
 	blocknum = h1 % file->cur_section.length;
 	header = (struct stat_file_header *)file->map;
-	c = (u_char *) file->map + file->seek_pos + blocknum *
-		sizeof (struct stat_file_block);
+	c = (u_char *) file->map + file->seek_pos + blocknum * sizeof (struct stat_file_block);
 	block = (struct stat_file_block *)c;
 
 	for (i = 0; i < CHAIN_LENGTH; i++) {
 		if (i + blocknum >= file->cur_section.length) {
 			/* Need to expire some block in chain */
-			msg_info ("chain %ud is full in statfile %s, starting expire",
-				blocknum,
-				file->filename);
+			msg_info ("chain %ud is full in statfile %s, starting expire", blocknum, file->filename);
 			break;
 		}
 		/* First try to find block in chain */
@@ -692,19 +587,15 @@ statfile_pool_set_block_common (statfile_pool_t * pool,
 		/* Check whether we have a free block in chain */
 		if (block->hash1 == 0 && block->hash2 == 0) {
 			/* Write new block here */
-			msg_debug ("found free block %ud in chain %ud, set h1=%ud, h2=%ud",
-				i,
-				blocknum,
-				h1,
-				h2);
+			msg_debug ("found free block %ud in chain %ud, set h1=%ud, h2=%ud", i, blocknum, h1, h2);
 			block->hash1 = h1;
 			block->hash2 = h2;
 			block->value = value;
-			header->used_blocks++;
+			header->used_blocks ++;
 
 			return;
 		}
-
+		
 		/* Expire block with minimum value otherwise */
 		if (block->value < min) {
 			to_expire = block;
@@ -720,8 +611,7 @@ statfile_pool_set_block_common (statfile_pool_t * pool,
 	}
 	else {
 		/* Expire first block in chain */
-		c = (u_char *) file->map + file->seek_pos + blocknum *
-			sizeof (struct stat_file_block);
+		c = (u_char *) file->map + file->seek_pos + blocknum * sizeof (struct stat_file_block);
 		block = (struct stat_file_block *)c;
 	}
 
@@ -731,26 +621,17 @@ statfile_pool_set_block_common (statfile_pool_t * pool,
 }
 
 void
-statfile_pool_set_block (statfile_pool_t * pool,
-	stat_file_t * file,
-	guint32 h1,
-	guint32 h2,
-	time_t now,
-	double value)
+statfile_pool_set_block (statfile_pool_t * pool, stat_file_t * file, guint32 h1, guint32 h2, time_t now, double value)
 {
 	statfile_pool_set_block_common (pool, file, h1, h2, now, value, TRUE);
 }
 
-stat_file_t *
+stat_file_t                    *
 statfile_pool_is_open (statfile_pool_t * pool, gchar *filename)
 {
-	static stat_file_t f, *ret;
+	static stat_file_t              f, *ret;
 	rspamd_strlcpy (f.filename, filename, sizeof (f.filename));
-	ret = lfind (&f,
-			pool->files,
-			(size_t *)&pool->opened,
-			sizeof (stat_file_t),
-			cmpstatfile);
+	ret = lfind (&f, pool->files, (size_t *)&pool->opened, sizeof (stat_file_t), cmpstatfile);
 	return ret;
 }
 
@@ -762,13 +643,10 @@ statfile_pool_get_section (statfile_pool_t * pool, stat_file_t * file)
 }
 
 gboolean
-statfile_pool_set_section (statfile_pool_t * pool,
-	stat_file_t * file,
-	guint32 code,
-	gboolean from_begin)
+statfile_pool_set_section (statfile_pool_t * pool, stat_file_t * file, guint32 code, gboolean from_begin)
 {
-	struct stat_file_section *sec;
-	off_t cur_offset;
+	struct stat_file_section       *sec;
+	off_t                           cur_offset;
 
 
 	/* Try to find section */
@@ -793,19 +671,13 @@ statfile_pool_set_section (statfile_pool_t * pool,
 }
 
 gboolean
-statfile_pool_add_section (statfile_pool_t * pool,
-	stat_file_t * file,
-	guint32 code,
-	guint64 length)
+statfile_pool_add_section (statfile_pool_t * pool, stat_file_t * file, guint32 code, guint64 length)
 {
-	struct stat_file_section sect;
-	struct stat_file_block block = { 0, 0, 0 };
+	struct stat_file_section        sect;
+	struct stat_file_block          block = { 0, 0, 0 };
 
 	if (lseek (file->fd, 0, SEEK_END) == -1) {
-		msg_info ("cannot lseek file %s, error %d, %s",
-			file->filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot lseek file %s, error %d, %s", file->filename, errno, strerror (errno));
 		return FALSE;
 	}
 
@@ -813,19 +685,13 @@ statfile_pool_add_section (statfile_pool_t * pool,
 	sect.length = length;
 
 	if (write (file->fd, &sect, sizeof (sect)) == -1) {
-		msg_info ("cannot write block to file %s, error %d, %s",
-			file->filename,
-			errno,
-			strerror (errno));
+		msg_info ("cannot write block to file %s, error %d, %s", file->filename, errno, strerror (errno));
 		return FALSE;
 	}
 
 	while (length--) {
 		if (write (file->fd, &block, sizeof (block)) == -1) {
-			msg_info ("cannot write block to file %s, error %d, %s",
-				file->filename,
-				errno,
-				strerror (errno));
+			msg_info ("cannot write block to file %s, error %d, %s", file->filename, errno, strerror (errno));
 			return FALSE;
 		}
 	}
@@ -836,13 +702,8 @@ statfile_pool_add_section (statfile_pool_t * pool,
 	fsync (file->fd);
 	file->len += length;
 
-	if ((file->map =
-		mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd,
-		0)) == NULL) {
-		msg_info ("cannot mmap file %s, error %d, %s",
-			file->filename,
-			errno,
-			strerror (errno));
+	if ((file->map = mmap (NULL, file->len, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd, 0)) == NULL) {
+		msg_info ("cannot mmap file %s, error %d, %s", file->filename, errno, strerror (errno));
 		return FALSE;
 	}
 	statfile_pool_unlock_file (pool, file);
@@ -870,15 +731,15 @@ statfile_get_section_by_name (const gchar *name)
 	return 0;
 }
 
-gboolean
+gboolean 
 statfile_set_revision (stat_file_t *file, guint64 rev, time_t time)
 {
-	struct stat_file_header *header;
+	struct stat_file_header        *header;
 
 	if (file == NULL || file->map == NULL) {
 		return FALSE;
 	}
-
+	
 	header = (struct stat_file_header *)file->map;
 
 	header->revision = rev;
@@ -887,10 +748,10 @@ statfile_set_revision (stat_file_t *file, guint64 rev, time_t time)
 	return TRUE;
 }
 
-gboolean
+gboolean 
 statfile_inc_revision (stat_file_t *file)
 {
-	struct stat_file_header *header;
+	struct stat_file_header        *header;
 
 	if (file == NULL || file->map == NULL) {
 		return FALSE;
@@ -898,7 +759,7 @@ statfile_inc_revision (stat_file_t *file)
 
 	header = (struct stat_file_header *)file->map;
 
-	header->revision++;
+	header->revision ++;
 
 	return TRUE;
 }
@@ -906,12 +767,12 @@ statfile_inc_revision (stat_file_t *file)
 gboolean
 statfile_get_revision (stat_file_t *file, guint64 *rev, time_t *time)
 {
-	struct stat_file_header *header;
+	struct stat_file_header        *header;
 
 	if (file == NULL || file->map == NULL) {
 		return FALSE;
 	}
-
+	
 	header = (struct stat_file_header *)file->map;
 
 	if (rev != NULL) {
@@ -924,29 +785,29 @@ statfile_get_revision (stat_file_t *file, guint64 *rev, time_t *time)
 	return TRUE;
 }
 
-guint64
+guint64 
 statfile_get_used_blocks (stat_file_t *file)
 {
-	struct stat_file_header *header;
+	struct stat_file_header        *header;
 
 	if (file == NULL || file->map == NULL) {
-		return (guint64) - 1;
+		return (guint64)-1;
 	}
-
+	
 	header = (struct stat_file_header *)file->map;
 
 	return header->used_blocks;
 }
 
-guint64
+guint64 
 statfile_get_total_blocks (stat_file_t *file)
 {
-	struct stat_file_header *header;
+	struct stat_file_header        *header;
 
 	if (file == NULL || file->map == NULL) {
-		return (guint64) - 1;
+		return (guint64)-1;
 	}
-
+	
 	header = (struct stat_file_header *)file->map;
 
 	/* If total blocks is 0 we have old version of header, so set total blocks correctly */
@@ -960,13 +821,13 @@ statfile_get_total_blocks (stat_file_t *file)
 static void
 statfile_pool_invalidate_callback (gint fd, short what, void *ud)
 {
-	statfile_pool_t *pool = ud;
-	stat_file_t *file;
-	gint i;
+	statfile_pool_t                *pool = ud;
+	stat_file_t                    *file;
+	gint                            i;
 
 	msg_info ("invalidating %d statfiles", pool->opened);
 
-	for (i = 0; i < pool->opened; i++) {
+	for (i = 0; i < pool->opened; i ++) {
 		file = &pool->files[i];
 		msync (file->map, file->len, MS_ASYNC);
 	}
@@ -975,54 +836,44 @@ statfile_pool_invalidate_callback (gint fd, short what, void *ud)
 
 
 void
-statfile_pool_plan_invalidate (statfile_pool_t *pool,
-	time_t seconds,
-	time_t jitter)
+statfile_pool_plan_invalidate (statfile_pool_t *pool, time_t seconds, time_t jitter)
 {
-	gboolean pending;
+	gboolean                        pending;
 
 
 	if (pool->invalidate_event != NULL) {
 		pending = evtimer_pending (pool->invalidate_event, NULL);
 		if (pending) {
 			/* Replan event */
-			pool->invalidate_tv.tv_sec = seconds +
-				g_random_int_range (0, jitter);
+			pool->invalidate_tv.tv_sec = seconds + g_random_int_range (0, jitter);
 			pool->invalidate_tv.tv_usec = 0;
 			evtimer_add (pool->invalidate_event, &pool->invalidate_tv);
 		}
 	}
 	else {
-		pool->invalidate_event =
-			rspamd_mempool_alloc (pool->pool, sizeof (struct event));
+		pool->invalidate_event = rspamd_mempool_alloc (pool->pool, sizeof (struct event));
 		pool->invalidate_tv.tv_sec = seconds + g_random_int_range (0, jitter);
 		pool->invalidate_tv.tv_usec = 0;
-		evtimer_set (pool->invalidate_event,
-			statfile_pool_invalidate_callback,
-			pool);
+		evtimer_set (pool->invalidate_event, statfile_pool_invalidate_callback, pool);
 		evtimer_add (pool->invalidate_event, &pool->invalidate_tv);
-		msg_info ("invalidate of statfile pool is planned in %d seconds",
-			(gint)pool->invalidate_tv.tv_sec);
+		msg_info ("invalidate of statfile pool is planned in %d seconds", (gint)pool->invalidate_tv.tv_sec);
 	}
 }
 
 
 stat_file_t *
-get_statfile_by_symbol (statfile_pool_t *pool,
-	struct rspamd_classifier_config *ccf,
-	const gchar *symbol,
-	struct rspamd_statfile_config **st,
-	gboolean try_create)
+get_statfile_by_symbol (statfile_pool_t *pool, struct rspamd_classifier_config *ccf,
+        const gchar *symbol, struct rspamd_statfile_config **st, gboolean try_create)
 {
-	stat_file_t *res = NULL;
-	GList *cur;
+    stat_file_t *res = NULL;
+    GList *cur;
 
-	if (pool == NULL || ccf == NULL || symbol == NULL) {
+    if (pool == NULL || ccf == NULL || symbol == NULL) {
 		msg_err ("invalid input arguments");
-		return NULL;
-	}
+        return NULL;
+    }
 
-	cur = g_list_first (ccf->statfiles);
+    cur = g_list_first (ccf->statfiles);
 	while (cur) {
 		*st = cur->data;
 		if (strcmp (symbol, (*st)->symbol) == 0) {
@@ -1031,33 +882,28 @@ get_statfile_by_symbol (statfile_pool_t *pool,
 		*st = NULL;
 		cur = g_list_next (cur);
 	}
-	if (*st == NULL) {
+    if (*st == NULL) {
 		msg_info ("cannot find statfile with symbol %s", symbol);
-		return NULL;
-	}
+        return NULL;
+    }
 
-	if ((res = statfile_pool_is_open (pool, (*st)->path)) == NULL) {
-		if ((res =
-			statfile_pool_open (pool, (*st)->path, (*st)->size,
-			FALSE)) == NULL) {
+    if ((res = statfile_pool_is_open (pool, (*st)->path)) == NULL) {
+		if ((res = statfile_pool_open (pool, (*st)->path, (*st)->size, FALSE)) == NULL) {
 			msg_warn ("cannot open %s", (*st)->path);
-			if (try_create) {
-				if (statfile_pool_create (pool, (*st)->path,
-					(*st)->size) == -1) {
+            if (try_create) {
+                if (statfile_pool_create (pool, (*st)->path, (*st)->size) == -1) {
 					msg_err ("cannot create statfile %s", (*st)->path);
 					return NULL;
 				}
-				res =
-					statfile_pool_open (pool, (*st)->path, (*st)->size, FALSE);
+                res = statfile_pool_open (pool, (*st)->path, (*st)->size, FALSE);
 				if (res == NULL) {
-					msg_err ("cannot open statfile %s after creation",
-						(*st)->path);
+					msg_err ("cannot open statfile %s after creation", (*st)->path);
 				}
-			}
+            }
 		}
 	}
 
-	return res;
+    return res;
 }
 
 void
@@ -1067,12 +913,10 @@ statfile_pool_lockall (statfile_pool_t *pool)
 	gint i;
 
 	if (pool->mlock_ok) {
-		for (i = 0; i < pool->opened; i++) {
+		for (i = 0; i < pool->opened; i ++) {
 			file = &pool->files[i];
 			if (mlock (file->map, file->len) == -1) {
-				msg_warn (
-					"mlock of statfile failed, maybe you need to increase RLIMIT_MEMLOCK limit for a process: %s",
-					strerror (errno));
+				msg_warn ("mlock of statfile failed, maybe you need to increase RLIMIT_MEMLOCK limit for a process: %s", strerror (errno));
 				pool->mlock_ok = FALSE;
 				return;
 			}
diff --git a/src/libserver/statfile.h b/src/libserver/statfile.h
index b85fc87a5..3ad5f1321 100644
--- a/src/libserver/statfile.h
+++ b/src/libserver/statfile.h
@@ -7,8 +7,8 @@
 #define RSPAMD_STATFILE_H
 
 #include "config.h"
-#include "hash.h"
 #include "mem_pool.h"
+#include "hash.h"
 
 #define CHAIN_LENGTH 128
 
@@ -25,41 +25,41 @@
  * Common statfile header
  */
 struct stat_file_header {
-	u_char magic[3];                        /**< magic signature ('r' 's' 'd')      */
-	u_char version[2];                      /**< version of statfile				*/
-	u_char padding[3];                      /**< padding							*/
-	guint64 create_time;                    /**< create time (time_t->guint64)		*/
-	guint64 revision;                       /**< revision number					*/
-	guint64 rev_time;                       /**< revision time						*/
-	guint64 used_blocks;                    /**< used blocks number					*/
-	guint64 total_blocks;                   /**< total number of blocks				*/
-	u_char unused[239];                     /**< some bytes that can be used in future */
+	u_char magic[3];						/**< magic signature ('r' 's' 'd') 		*/
+	u_char version[2];						/**< version of statfile				*/
+	u_char padding[3];						/**< padding							*/
+	guint64 create_time;					/**< create time (time_t->guint64)		*/
+	guint64 revision;						/**< revision number					*/
+	guint64 rev_time;						/**< revision time						*/
+	guint64 used_blocks;					/**< used blocks number					*/
+	guint64 total_blocks;					/**< total number of blocks				*/
+	u_char unused[239];						/**< some bytes that can be used in future */
 };
 
 /**
  * Section header
  */
 struct stat_file_section {
-	guint64 code;                           /**< section's code						*/
-	guint64 length;                     /**< section's length in blocks			*/
+	guint64 code;							/**< section's code						*/
+	guint64 length;						/**< section's length in blocks			*/
 };
 
 /**
  * Block of data in statfile
  */
 struct stat_file_block {
-	guint32 hash1;                          /**< hash1 (also acts as index)			*/
-	guint32 hash2;                          /**< hash2								*/
-	double value;                           /**< double value                       */
+	guint32 hash1;							/**< hash1 (also acts as index)			*/				
+	guint32 hash2;							/**< hash2								*/
+	double value; 							/**< double value 						*/
 };
 
 /**
  * Statistic file
  */
 struct stat_file {
-	struct stat_file_header header;         /**< header								*/
-	struct stat_file_section section;       /**< first section						*/
-	struct stat_file_block blocks[1];       /**< first block of data				*/
+	struct stat_file_header header;			/**< header								*/
+	struct stat_file_section section;		/**< first section						*/
+	struct stat_file_block blocks[1];		/**< first block of data				*/
 };
 
 /**
@@ -67,32 +67,32 @@ struct stat_file {
  */
 typedef struct stat_file_s {
 #ifdef HAVE_PATH_MAX
-	gchar filename[PATH_MAX];               /**< name of file						*/
+	gchar filename[PATH_MAX];				/**< name of file						*/
 #else
-	gchar filename[MAXPATHLEN];             /**< name of file						*/
+	gchar filename[MAXPATHLEN];				/**< name of file						*/
 #endif
-	gint fd;                                    /**< descriptor							*/
-	void *map;                              /**< mmaped area						*/
-	off_t seek_pos;                         /**< current seek position				*/
-	struct stat_file_section cur_section;   /**< current section					*/
-	time_t open_time;                       /**< time when file was opened			*/
-	time_t access_time;                     /**< last access time					*/
-	size_t len;                             /**< length of file(in bytes)			*/
-	rspamd_mempool_mutex_t *lock;               /**< mutex								*/
+	gint fd;									/**< descriptor							*/
+	void *map;								/**< mmaped area						*/
+	off_t seek_pos;							/**< current seek position				*/
+	struct stat_file_section cur_section;	/**< current section					*/
+	time_t open_time;						/**< time when file was opened			*/
+	time_t access_time;						/**< last access time					*/
+	size_t len;								/**< length of file(in bytes)			*/
+	rspamd_mempool_mutex_t *lock;				/**< mutex								*/
 } stat_file_t;
 
 /**
  * Statfiles pool
  */
 typedef struct statfile_pool_s {
-	stat_file_t *files;                     /**< hash table of opened files indexed by name	*/
-	void **maps;                            /**< shared hash table of mmaped areas indexed by name	*/
-	gint opened;                                /**< number of opened files				*/
-	rspamd_mempool_t *pool;                 /**< memory pool object					*/
-	rspamd_mempool_mutex_t *lock;               /**< mutex								*/
-	struct event *invalidate_event;         /**< event for pool invalidation        */
+	stat_file_t *files;						/**< hash table of opened files indexed by name	*/
+	void **maps;							/**< shared hash table of mmaped areas indexed by name	*/
+	gint opened;								/**< number of opened files				*/
+	rspamd_mempool_t *pool;					/**< memory pool object					*/
+	rspamd_mempool_mutex_t *lock;				/**< mutex								*/
+	struct event  *invalidate_event;        /**< event for pool invalidation        */
 	struct timeval invalidate_tv;
-	gboolean mlock_ok;                      /**< whether it is possible to use mlock (2) to avoid statfiles unloading */
+	gboolean mlock_ok;						/**< whether it is possible to use mlock (2) to avoid statfiles unloading */
 } statfile_pool_t;
 
 /* Forwarded declarations */
@@ -104,8 +104,7 @@ struct rspamd_statfile_config;
  * @param max_size maximum size
  * @return statfile pool object
  */
-statfile_pool_t * statfile_pool_new (rspamd_mempool_t *pool,
-	gboolean use_mlock);
+statfile_pool_t* statfile_pool_new (rspamd_mempool_t *pool, gboolean use_mlock);
 
 /**
  * Open statfile and attach it to pool
@@ -113,10 +112,7 @@ statfile_pool_t * statfile_pool_new (rspamd_mempool_t *pool,
  * @param filename name of statfile to open
  * @return 0 if specified statfile is attached and -1 in case of error
  */
-stat_file_t * statfile_pool_open (statfile_pool_t *pool,
-	gchar *filename,
-	size_t len,
-	gboolean forced);
+stat_file_t* statfile_pool_open (statfile_pool_t *pool, gchar *filename, size_t len, gboolean forced);
 
 /**
  * Create new statfile but DOES NOT attach it to pool, use @see statfile_pool_open for attaching
@@ -134,9 +130,7 @@ gint statfile_pool_create (statfile_pool_t *pool, gchar *filename, size_t len);
  * @param remove_hash remove filename from opened files hash also
  * @return 0 if file was closed and -1 if statfile was not opened
  */
-gint statfile_pool_close (statfile_pool_t *pool,
-	stat_file_t *file,
-	gboolean keep_sorted);
+gint statfile_pool_close (statfile_pool_t *pool, stat_file_t *file, gboolean keep_sorted);
 
 /**
  * Delete statfile pool and close all attached statfiles
@@ -173,11 +167,7 @@ void statfile_pool_unlock_file (statfile_pool_t *pool, stat_file_t *file);
  * @param now current time
  * @return block value or 0 if block is not found
  */
-double statfile_pool_get_block (statfile_pool_t *pool,
-	stat_file_t *file,
-	guint32 h1,
-	guint32 h2,
-	time_t now);
+double statfile_pool_get_block (statfile_pool_t *pool, stat_file_t *file, guint32 h1, guint32 h2, time_t now);
 
 /**
  * Set specified block in statfile
@@ -188,12 +178,7 @@ double statfile_pool_get_block (statfile_pool_t *pool,
  * @param now current time
  * @param value value of block
  */
-void statfile_pool_set_block (statfile_pool_t *pool,
-	stat_file_t *file,
-	guint32 h1,
-	guint32 h2,
-	time_t now,
-	double value);
+void statfile_pool_set_block (statfile_pool_t *pool, stat_file_t *file, guint32 h1, guint32 h2, time_t now, double value);
 
 /**
  * Check whether statfile is opened
@@ -201,7 +186,7 @@ void statfile_pool_set_block (statfile_pool_t *pool,
  * @param filename name of statfile
  * @return TRUE if specified statfile is opened and FALSE otherwise
  */
-stat_file_t * statfile_pool_is_open (statfile_pool_t *pool, gchar *filename);
+stat_file_t* statfile_pool_is_open (statfile_pool_t *pool, gchar *filename);
 
 /**
  * Returns current statfile section
@@ -219,10 +204,7 @@ guint32 statfile_pool_get_section (statfile_pool_t *pool, stat_file_t *file);
  * @param from_begin search for section from begin of file if true
  * @return TRUE if section was set and FALSE otherwise
  */
-gboolean statfile_pool_set_section (statfile_pool_t *pool,
-	stat_file_t *file,
-	guint32 code,
-	gboolean from_begin);
+gboolean statfile_pool_set_section (statfile_pool_t *pool, stat_file_t *file, guint32 code, gboolean from_begin);
 
 /**
  * Add new section to statfile
@@ -232,10 +214,7 @@ gboolean statfile_pool_set_section (statfile_pool_t *pool,
  * @param length length in blocks of new section
  * @return TRUE if section was successfully added and FALSE in case of error
  */
-gboolean statfile_pool_add_section (statfile_pool_t *pool,
-	stat_file_t *file,
-	guint32 code,
-	guint64 length);
+gboolean statfile_pool_add_section (statfile_pool_t *pool, stat_file_t *file, guint32 code, guint64 length);
 
 
 /**
@@ -289,9 +268,7 @@ guint64 statfile_get_total_blocks (stat_file_t *file);
 /**
  * Plan statfile pool invalidation
  */
-void statfile_pool_plan_invalidate (statfile_pool_t *pool,
-	time_t seconds,
-	time_t jitter);
+void statfile_pool_plan_invalidate (statfile_pool_t *pool, time_t seconds, time_t jitter);
 
 /**
  * Get a statfile by symbol
@@ -301,10 +278,7 @@ void statfile_pool_plan_invalidate (statfile_pool_t *pool,
  * @param st statfile to get
  * @param try_create whether we need to create statfile if it is absent
  */
-stat_file_t * get_statfile_by_symbol (statfile_pool_t *pool,
-	struct rspamd_classifier_config *ccf,
-	const gchar *symbol,
-	struct rspamd_statfile_config **st,
-	gboolean try_create);
+stat_file_t* get_statfile_by_symbol (statfile_pool_t *pool, struct rspamd_classifier_config *ccf,
+		const gchar *symbol, struct rspamd_statfile_config **st, gboolean try_create);
 
 #endif
diff --git a/src/libserver/statfile_sync.c b/src/libserver/statfile_sync.c
index 55c08f879..1121658fa 100644
--- a/src/libserver/statfile_sync.c
+++ b/src/libserver/statfile_sync.c
@@ -22,14 +22,14 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "binlog.h"
-#include "buffer.h"
+#include "config.h"
 #include "cfg_file.h"
+#include "tokenizers/tokenizers.h"
 #include "classifiers/classifiers.h"
-#include "config.h"
 #include "statfile.h"
+#include "binlog.h"
+#include "buffer.h"
 #include "statfile_sync.h"
-#include "tokenizers/tokenizers.h"
 
 enum rspamd_sync_state {
 	SYNC_STATE_GREETING,
@@ -56,69 +56,63 @@ struct rspamd_sync_ctx {
 	enum rspamd_sync_state state;
 	gboolean is_busy;
 
-	guint64 new_rev;
-	guint64 new_time;
-	guint64 new_len;
+	guint64                         new_rev;
+	guint64                         new_time;
+	guint64                         new_len;
 };
 
 static void
 log_next_sync (const gchar *symbol, time_t delay)
 {
-	gchar outstr[200];
-	time_t t;
+	gchar                           outstr[200];
+    time_t t;
 	struct tm *tmp;
-	gint r;
+	gint                            r;
 
-	t = time (NULL);
+	t = time(NULL);
 	t += delay;
-	tmp = localtime (&t);
+    tmp = localtime(&t);
 
 	if (tmp) {
-		r = rspamd_snprintf (outstr,
-				sizeof (outstr),
-				"statfile_sync: next sync of %s at ",
-				symbol);
-		if ((r = strftime (outstr + r, sizeof(outstr) - r, "%T", tmp)) != 0) {
+		r = rspamd_snprintf (outstr, sizeof (outstr), "statfile_sync: next sync of %s at ", symbol);
+		if ((r = strftime(outstr + r, sizeof(outstr) - r, "%T", tmp)) != 0) {
 			msg_info (outstr);
 		}
 	}
 }
 
-static gboolean
+static                          gboolean
 parse_revision_line (struct rspamd_sync_ctx *ctx, f_str_t *in)
 {
-	guint i, state = 0;
-	gchar *p, *c, numbuf[sizeof("18446744073709551615")];
-	guint64 *val;
+	guint                           i, state = 0;
+	gchar                           *p, *c, numbuf[sizeof("18446744073709551615")];
+	guint64                         *val;
 
 	/* First of all try to find END line */
-	if (in->len >= sizeof ("END") - 1 &&
-		memcmp (in->begin, "END", sizeof ("END") - 1) == 0) {
+	if (in->len >= sizeof ("END") - 1 && memcmp (in->begin, "END", sizeof ("END") - 1) == 0) {
 		ctx->state = SYNC_STATE_QUIT;
 		ctx->is_busy = FALSE;
 		return TRUE;
 	}
 
 	/* Next check for error line */
-	if (in->len >= sizeof ("FAIL") - 1 &&
-		memcmp (in->begin, "FAIL", sizeof ("FAIL") - 1) == 0) {
+	if (in->len >= sizeof ("FAIL") - 1 && memcmp (in->begin, "FAIL", sizeof ("FAIL") - 1) == 0) {
 		ctx->state = SYNC_STATE_QUIT;
 		ctx->is_busy = FALSE;
 		return TRUE;
 	}
-
+	
 	/* Now try to extract 3 numbers from string: revision, time and length */
 	p = in->begin;
 	val = &ctx->new_rev;
-	for (i = 0; i < in->len; i++, p++) {
+	for (i = 0; i < in->len; i ++, p ++) {
 		if (g_ascii_isspace (*p) || i == in->len - 1) {
 			if (state == 1) {
 				if (i == in->len - 1) {
 					/* One more character */
-					p++;
+					p ++;
 				}
-				rspamd_strlcpy (numbuf, c, MIN (p - c + 1,
-					(gint)sizeof (numbuf)));
+				rspamd_strlcpy (numbuf, c, MIN (p - c + 1, (gint)sizeof (numbuf)));
 				errno = 0;
 				*val = strtoull (numbuf, NULL, 10);
 				if (errno != 0) {
@@ -150,113 +144,94 @@ parse_revision_line (struct rspamd_sync_ctx *ctx, f_str_t *in)
 	return ((val == &ctx->new_len));
 }
 
-static gboolean
+static                          gboolean
 read_blocks (struct rspamd_sync_ctx *ctx, f_str_t *in)
 {
 	struct rspamd_binlog_element *elt;
-	guint i;
-
+	guint                         i;
+	
 	statfile_pool_lock_file (ctx->pool, ctx->real_statfile);
 	elt = (struct rspamd_binlog_element *)in->begin;
-	for (i = 0; i < in->len / sizeof (struct rspamd_binlog_element); i++,
-		elt++) {
-		statfile_pool_set_block (ctx->pool,
-			ctx->real_statfile,
-			elt->h1,
-			elt->h2,
-			ctx->new_time,
-			elt->value);
+	for (i = 0; i < in->len / sizeof (struct rspamd_binlog_element); i ++, elt ++) {
+		statfile_pool_set_block (ctx->pool, ctx->real_statfile, elt->h1, elt->h2, ctx->new_time, elt->value);
 	}
 	statfile_pool_unlock_file (ctx->pool, ctx->real_statfile);
 
 	return TRUE;
 }
 
-static gboolean
+static                          gboolean
 sync_read (f_str_t * in, void *arg)
 {
 	struct rspamd_sync_ctx *ctx = arg;
-	gchar buf[256];
-	guint64 rev = 0;
-	time_t ti = 0;
+	gchar                           buf[256];
+	guint64                         rev = 0;
+	time_t                  ti = 0;
 
 	if (in->len == 0) {
 		/* Skip empty lines */
 		return TRUE;
 	}
 	switch (ctx->state) {
-	case SYNC_STATE_GREETING:
-		/* Skip greeting line and write sync command */
-		/* Write initial data */
-		statfile_get_revision (ctx->real_statfile, &rev, &ti);
-		rev = rspamd_snprintf (buf,
-				sizeof (buf),
-				"sync %s %uL %T" CRLF,
-				ctx->st->symbol,
-				rev,
-				ti);
-		ctx->state = SYNC_STATE_READ_LINE;
-		return rspamd_dispatcher_write (ctx->dispatcher, buf, rev, FALSE,
-				   FALSE);
-		break;
-	case SYNC_STATE_READ_LINE:
-		/* Try to parse line from server */
-		if (!parse_revision_line (ctx, in)) {
-			msg_info ("cannot parse line of length %z: '%*s'",
-				in->len,
-				(gint)in->len,
-				in->begin);
-			close (ctx->sock);
-			rspamd_remove_dispatcher (ctx->dispatcher);
-			ctx->is_busy = FALSE;
-			return FALSE;
-		}
-		else if (ctx->state != SYNC_STATE_QUIT) {
-			if (ctx->new_len > 0) {
-				ctx->state = SYNC_STATE_READ_REV;
-				rspamd_set_dispatcher_policy (ctx->dispatcher,
-					BUFFER_CHARACTER,
-					ctx->new_len);
+		case SYNC_STATE_GREETING:
+			/* Skip greeting line and write sync command */
+			/* Write initial data */
+			statfile_get_revision (ctx->real_statfile, &rev, &ti);
+			rev = rspamd_snprintf (buf, sizeof (buf), "sync %s %uL %T" CRLF, ctx->st->symbol, rev, ti);
+			ctx->state = SYNC_STATE_READ_LINE;
+			return rspamd_dispatcher_write (ctx->dispatcher, buf, rev, FALSE, FALSE);	
+			break;
+		case SYNC_STATE_READ_LINE:
+			/* Try to parse line from server */
+			if (!parse_revision_line (ctx, in)) {
+				msg_info ("cannot parse line of length %z: '%*s'", in->len, (gint)in->len, in->begin);
+				close (ctx->sock);
+				rspamd_remove_dispatcher (ctx->dispatcher);
+				ctx->is_busy = FALSE;
+				return FALSE;
 			}
-		}
-		else {
-			/* Quit this session */
-			msg_info ("sync ended for: %s", ctx->st->symbol);
-			close (ctx->sock);
-			rspamd_remove_dispatcher (ctx->dispatcher);
-			ctx->is_busy = FALSE;
-			/* Immediately return from callback */
-			return FALSE;
-		}
-		break;
-	case SYNC_STATE_READ_REV:
-		/* In now contains all blocks of specified revision, so we can read them directly */
-		if (!read_blocks (ctx, in)) {
-			msg_info ("cannot read blocks");
+			else if (ctx->state != SYNC_STATE_QUIT) {
+				if (ctx->new_len > 0) {
+					ctx->state = SYNC_STATE_READ_REV;
+					rspamd_set_dispatcher_policy (ctx->dispatcher, BUFFER_CHARACTER, ctx->new_len);
+				}
+			}
+			else {
+				/* Quit this session */
+				msg_info ("sync ended for: %s", ctx->st->symbol);
+				close (ctx->sock);
+				rspamd_remove_dispatcher (ctx->dispatcher);
+				ctx->is_busy = FALSE;
+				/* Immediately return from callback */
+				return FALSE;
+			}
+			break;
+		case SYNC_STATE_READ_REV:
+			/* In now contains all blocks of specified revision, so we can read them directly */
+			if (!read_blocks (ctx, in)) {
+				msg_info ("cannot read blocks");
+				close (ctx->sock);
+				rspamd_remove_dispatcher (ctx->dispatcher);
+				ctx->is_busy = FALSE;
+				return FALSE;
+			}
+			statfile_set_revision (ctx->real_statfile, ctx->new_rev, ctx->new_time);
+			msg_info ("set new revision: %uL, readed %z bytes", ctx->new_rev, in->len);
+			/* Now try to read other revision or END line */
+			ctx->state = SYNC_STATE_READ_LINE;
+			rspamd_set_dispatcher_policy (ctx->dispatcher, BUFFER_LINE, 0);
+			break;
+		case SYNC_STATE_QUIT:
 			close (ctx->sock);
 			rspamd_remove_dispatcher (ctx->dispatcher);
 			ctx->is_busy = FALSE;
 			return FALSE;
-		}
-		statfile_set_revision (ctx->real_statfile, ctx->new_rev, ctx->new_time);
-		msg_info ("set new revision: %uL, readed %z bytes",
-			ctx->new_rev,
-			in->len);
-		/* Now try to read other revision or END line */
-		ctx->state = SYNC_STATE_READ_LINE;
-		rspamd_set_dispatcher_policy (ctx->dispatcher, BUFFER_LINE, 0);
-		break;
-	case SYNC_STATE_QUIT:
-		close (ctx->sock);
-		rspamd_remove_dispatcher (ctx->dispatcher);
-		ctx->is_busy = FALSE;
-		return FALSE;
 	}
 
 	return TRUE;
 }
 
-static void
+static                         void 
 sync_err (GError *err, void *arg)
 {
 	struct rspamd_sync_ctx *ctx = arg;
@@ -273,40 +248,30 @@ sync_timer_callback (gint fd, short what, void *ud)
 {
 	struct rspamd_sync_ctx *ctx = ud;
 	guint32 jittered_interval;
-
+	
 	/* Plan new event */
 	evtimer_del (&ctx->tm_ev);
 	/* Add some jittering for synchronization */
-	jittered_interval = g_random_int_range (ctx->sync_interval,
-			ctx->sync_interval * 2);
+	jittered_interval = g_random_int_range (ctx->sync_interval, ctx->sync_interval * 2);
 	msec_to_tv (jittered_interval, &ctx->interval);
 	evtimer_add (&ctx->tm_ev, &ctx->interval);
 	log_next_sync (ctx->st->symbol, ctx->interval.tv_sec);
-
+	
 	if (ctx->is_busy) {
 		/* Sync is in progress */
 		msg_info ("syncronization process is in progress, do not start new one");
 		return;
 	}
 
-	if ((ctx->sock =
-		make_universal_socket (ctx->st->binlog->master_addr,
-		ctx->st->binlog->master_port,
-		SOCK_STREAM, TRUE, FALSE, TRUE)) == -1) {
+	if ((ctx->sock = make_universal_socket (ctx->st->binlog->master_addr, ctx->st->binlog->master_port,
+			SOCK_STREAM, TRUE, FALSE, TRUE)) == -1) {
 		msg_info ("cannot connect to %s", ctx->st->binlog->master_addr);
 		return;
 	}
 	/* Now create and activate dispatcher */
 	msec_to_tv (ctx->timeout, &ctx->io_tv);
-	ctx->dispatcher = rspamd_create_dispatcher (ctx->ev_base,
-			ctx->sock,
-			BUFFER_LINE,
-			sync_read,
-			NULL,
-			sync_err,
-			&ctx->io_tv,
-			ctx);
-
+	ctx->dispatcher = rspamd_create_dispatcher (ctx->ev_base, ctx->sock, BUFFER_LINE, sync_read, NULL, sync_err, &ctx->io_tv, ctx);
+	
 	ctx->state = SYNC_STATE_GREETING;
 	ctx->is_busy = TRUE;
 
@@ -315,39 +280,29 @@ sync_timer_callback (gint fd, short what, void *ud)
 }
 
 static gboolean
-add_statfile_watch (statfile_pool_t *pool,
-	struct rspamd_statfile_config *st,
-	struct rspamd_config *cfg,
-	struct event_base *ev_base)
+add_statfile_watch (statfile_pool_t *pool, struct rspamd_statfile_config *st, struct rspamd_config *cfg, struct event_base *ev_base)
 {
 	struct rspamd_sync_ctx *ctx;
 	guint32 jittered_interval;
-
+	
 	if (st->binlog->master_addr != NULL) {
-		ctx =
-			rspamd_mempool_alloc (pool->pool, sizeof (struct rspamd_sync_ctx));
+		ctx = rspamd_mempool_alloc (pool->pool, sizeof (struct rspamd_sync_ctx));
 		ctx->st = st;
 		ctx->timeout = cfg->statfile_sync_timeout;
 		ctx->sync_interval = cfg->statfile_sync_interval;
 		ctx->ev_base = ev_base;
 		/* Add some jittering for synchronization */
-		jittered_interval = g_random_int_range (ctx->sync_interval,
-				ctx->sync_interval * 2);
+		jittered_interval = g_random_int_range (ctx->sync_interval, ctx->sync_interval * 2);
 		msec_to_tv (jittered_interval, &ctx->interval);
 		/* Open statfile and attach it to pool */
-		if ((ctx->real_statfile =
-			statfile_pool_is_open (pool, st->path)) == NULL) {
-			if ((ctx->real_statfile =
-				statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
+		if ((ctx->real_statfile = statfile_pool_is_open (pool, st->path)) == NULL) {
+			if ((ctx->real_statfile = statfile_pool_open (pool, st->path, st->size, FALSE)) == NULL) {
 				msg_warn ("cannot open %s", st->path);
 				if (statfile_pool_create (pool, st->path, st->size) == -1) {
 					msg_err ("cannot create statfile %s", st->path);
 					return FALSE;
 				}
-				ctx->real_statfile = statfile_pool_open (pool,
-						st->path,
-						st->size,
-						FALSE);
+				ctx->real_statfile = statfile_pool_open (pool, st->path, st->size, FALSE);
 			}
 		}
 		/* Now plan event for it's future executing */
@@ -357,24 +312,21 @@ add_statfile_watch (statfile_pool_t *pool,
 		log_next_sync (st->symbol, ctx->interval.tv_sec);
 	}
 	else {
-		msg_err ("cannot add statfile watch for statfile %s: no master defined",
-			st->symbol);
+		msg_err ("cannot add statfile watch for statfile %s: no master defined", st->symbol);
 		return FALSE;
 	}
 
 	return TRUE;
 }
 
-gboolean
-start_statfile_sync (statfile_pool_t *pool,
-	struct rspamd_config *cfg,
-	struct event_base *ev_base)
+gboolean 
+start_statfile_sync (statfile_pool_t *pool, struct rspamd_config *cfg, struct event_base *ev_base)
 {
 	GList *cur, *l;
 	struct rspamd_classifier_config *cl;
 	struct rspamd_statfile_config *st;
 
-	/*
+	/* 
 	 * First of all walk through all classifiers and find those statfiles
 	 * for which we should do sync (slave affinity)
 	 */
diff --git a/src/libserver/statfile_sync.h b/src/libserver/statfile_sync.h
index 37a0ddb78..bcaeb3bb5 100644
--- a/src/libserver/statfile_sync.h
+++ b/src/libserver/statfile_sync.h
@@ -1,16 +1,14 @@
 #ifndef RSPAMD_STATFILE_SYNC_H
 #define RSPAMD_STATFILE_SYNC_H
 
-#include "cfg_file.h"
 #include "config.h"
 #include "main.h"
 #include "statfile.h"
+#include "cfg_file.h"
 
 /*
  * Start synchronization of statfiles. Must be called after event_init as it adds events
  */
-gboolean start_statfile_sync (statfile_pool_t *pool,
-	struct rspamd_config *cfg,
-	struct event_base *ev_base);
+gboolean start_statfile_sync (statfile_pool_t *pool, struct rspamd_config *cfg, struct event_base *ev_base);
 
 #endif
diff --git a/src/libserver/symbols_cache.c b/src/libserver/symbols_cache.c
index 6ffd8b103..b0ce7d872 100644
--- a/src/libserver/symbols_cache.c
+++ b/src/libserver/symbols_cache.c
@@ -22,12 +22,12 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
+#include "util.h"
 #include "main.h"
 #include "message.h"
 #include "symbols_cache.h"
-#include "util.h"
+#include "cfg_file.h"
 
 #define WEIGHT_MULT 4.0
 #define FREQUENCY_MULT 10.0
@@ -41,13 +41,13 @@
 
 #define MIN_CACHE 17
 
-static guint64 total_frequency = 0;
-static guint32 nsymbols = 0;
+static guint64                 total_frequency = 0;
+static guint32                 nsymbols = 0;
 
 gint
 cache_cmp (const void *p1, const void *p2)
 {
-	const struct cache_item *i1 = p1, *i2 = p2;
+	const struct cache_item        *i1 = p1, *i2 = p2;
 
 	return strcmp (i1->s->symbol, i2->s->symbol);
 }
@@ -55,24 +55,20 @@ cache_cmp (const void *p1, const void *p2)
 gint
 cache_logic_cmp (const void *p1, const void *p2)
 {
-	const struct cache_item *i1 = p1, *i2 = p2;
-	double w1, w2;
-	double weight1, weight2;
-	double f1 = 0, f2 = 0;
+	const struct cache_item        *i1 = p1, *i2 = p2;
+	double                          w1, w2;
+	double                          weight1, weight2;
+	double                          f1 = 0, f2 = 0;
 
 	if (i1->priority == 0 && i2->priority == 0) {
 		if (total_frequency > 0) {
-			f1 =
-				((double)i1->s->frequency * nsymbols) / (double)total_frequency;
-			f2 =
-				((double)i2->s->frequency * nsymbols) / (double)total_frequency;
+			f1 = ((double)i1->s->frequency * nsymbols) / (double)total_frequency;
+			f2 = ((double)i2->s->frequency * nsymbols) / (double)total_frequency;
 		}
 		weight1 = i1->metric_weight == 0 ? i1->s->weight : i1->metric_weight;
 		weight2 = i2->metric_weight == 0 ? i2->s->weight : i2->metric_weight;
-		w1 = abs (weight1) * WEIGHT_MULT + f1 * FREQUENCY_MULT +
-			i1->s->avg_time * TIME_MULT;
-		w2 = abs (weight2) * WEIGHT_MULT + f2 * FREQUENCY_MULT +
-			i2->s->avg_time * TIME_MULT;
+		w1 = abs (weight1) * WEIGHT_MULT + f1 * FREQUENCY_MULT + i1->s->avg_time * TIME_MULT;
+		w2 = abs (weight2) * WEIGHT_MULT + f2 * FREQUENCY_MULT + i2->s->avg_time * TIME_MULT;
 	}
 	else {
 		/* Strict sorting */
@@ -83,12 +79,12 @@ cache_logic_cmp (const void *p1, const void *p2)
 	return (gint)w2 - w1;
 }
 
-static GChecksum *
+static GChecksum               *
 get_mem_cksum (struct symbols_cache *cache)
 {
-	GChecksum *result;
-	GList *cur, *l;
-	struct cache_item *item;
+	GChecksum                      *result;
+	GList                          *cur, *l;
+	struct cache_item              *item;
 
 	result = g_checksum_new (G_CHECKSUM_SHA1);
 
@@ -98,8 +94,7 @@ get_mem_cksum (struct symbols_cache *cache)
 	while (cur) {
 		item = cur->data;
 		if (item->s->symbol[0] != '\0') {
-			g_checksum_update (result, item->s->symbol,
-				strlen (item->s->symbol));
+			g_checksum_update (result, item->s->symbol, strlen (item->s->symbol));
 		}
 		cur = g_list_next (cur);
 	}
@@ -112,8 +107,7 @@ get_mem_cksum (struct symbols_cache *cache)
 	while (cur) {
 		item = cur->data;
 		if (item->s->symbol[0] != '\0') {
-			g_checksum_update (result, item->s->symbol,
-				strlen (item->s->symbol));
+			g_checksum_update (result, item->s->symbol, strlen (item->s->symbol));
 		}
 		total_frequency += item->s->frequency;
 		cur = g_list_next (cur);
@@ -127,8 +121,8 @@ get_mem_cksum (struct symbols_cache *cache)
 static void
 post_cache_init (struct symbols_cache *cache)
 {
-	GList *cur;
-	struct cache_item *item;
+	GList                          *cur;
+	struct cache_item              *item;
 
 	total_frequency = 0;
 	nsymbols = cache->used_items;
@@ -145,8 +139,7 @@ post_cache_init (struct symbols_cache *cache)
 		cur = g_list_next (cur);
 	}
 
-	cache->negative_items =
-		g_list_sort (cache->negative_items, cache_logic_cmp);
+	cache->negative_items = g_list_sort (cache->negative_items, cache_logic_cmp);
 	cache->static_items = g_list_sort (cache->static_items, cache_logic_cmp);
 }
 
@@ -154,27 +147,22 @@ post_cache_init (struct symbols_cache *cache)
 static void
 unmap_cache_file (gpointer arg)
 {
-	struct symbols_cache *cache = arg;
-
+	struct symbols_cache           *cache = arg;
+	
 	/* A bit ugly usage */
 	munmap (cache->map, cache->used_items * sizeof (struct saved_cache_item));
 }
 
-static gboolean
+static                          gboolean
 mmap_cache_file (struct symbols_cache *cache, gint fd, rspamd_mempool_t *pool)
 {
-	guint8 *map;
-	gint i;
-	GList *cur;
-	struct cache_item *item;
+	guint8                         *map;
+	gint                            i;
+	GList                          *cur;
+	struct cache_item              *item;
 
 	if (cache->used_items > 0) {
-		map = mmap (NULL,
-				cache->used_items * sizeof (struct saved_cache_item),
-				PROT_READ | PROT_WRITE,
-				MAP_SHARED,
-				fd,
-				0);
+		map = mmap (NULL, cache->used_items * sizeof (struct saved_cache_item), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 		if (map == MAP_FAILED) {
 			msg_err ("cannot mmap cache file: %d, %s", errno, strerror (errno));
 			close (fd);
@@ -188,20 +176,16 @@ mmap_cache_file (struct symbols_cache *cache, gint fd, rspamd_mempool_t *pool)
 		cur = g_list_first (cache->negative_items);
 		while (cur) {
 			item = cur->data;
-			item->s =
-				(struct saved_cache_item *)(map + i *
-				sizeof (struct saved_cache_item));
+			item->s = (struct saved_cache_item *)(map + i * sizeof (struct saved_cache_item));
 			cur = g_list_next (cur);
-			i++;
+			i ++;
 		}
 		cur = g_list_first (cache->static_items);
 		while (cur) {
 			item = cur->data;
-			item->s =
-				(struct saved_cache_item *)(map + i *
-				sizeof (struct saved_cache_item));
+			item->s = (struct saved_cache_item *)(map + i * sizeof (struct saved_cache_item));
 			cur = g_list_next (cur);
-			i++;
+			i ++;
 		}
 
 		post_cache_init (cache);
@@ -211,17 +195,14 @@ mmap_cache_file (struct symbols_cache *cache, gint fd, rspamd_mempool_t *pool)
 }
 
 /* Fd must be opened for writing, after creating file is mmapped */
-static gboolean
-create_cache_file (struct symbols_cache *cache,
-	const gchar *filename,
-	gint fd,
-	rspamd_mempool_t *pool)
+static                          gboolean
+create_cache_file (struct symbols_cache *cache, const gchar *filename, gint fd, rspamd_mempool_t *pool)
 {
-	GChecksum *cksum;
-	u_char *digest;
-	gsize cklen;
-	GList *cur;
-	struct cache_item *item;
+	GChecksum                      *cksum;
+	u_char                         *digest;
+	gsize                           cklen;
+	GList                          *cur;
+	struct cache_item              *item;
 
 	/* Calculate checksum */
 	cksum = get_mem_cksum (cache);
@@ -288,33 +269,23 @@ enum rspamd_symbol_type {
 };
 
 static void
-register_symbol_common (struct symbols_cache **cache,
-	const gchar *name,
-	double weight,
-	gint priority,
-	symbol_func_t func,
-	gpointer user_data,
-	enum rspamd_symbol_type type)
+register_symbol_common (struct symbols_cache **cache, const gchar *name, double weight, gint priority,
+		symbol_func_t func, gpointer user_data, enum rspamd_symbol_type type)
 {
-	struct cache_item *item = NULL;
-	struct symbols_cache *pcache = *cache;
-	GList **target;
-	double *w;
+	struct cache_item              *item = NULL;
+	struct symbols_cache           *pcache = *cache;
+	GList                         **target;
+	double                         *w;  
 
 	if (*cache == NULL) {
 		pcache = g_new0 (struct symbols_cache, 1);
 		*cache = pcache;
-		pcache->static_pool =
-			rspamd_mempool_new (rspamd_mempool_suggest_size ());
-		pcache->items_by_symbol = g_hash_table_new (rspamd_str_hash,
-				rspamd_str_equal);
+		pcache->static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+		pcache->items_by_symbol = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	}
-
-	item = rspamd_mempool_alloc0 (pcache->static_pool,
-			sizeof (struct cache_item));
-	item->s =
-		rspamd_mempool_alloc0 (pcache->static_pool,
-			sizeof (struct saved_cache_item));
+	
+	item = rspamd_mempool_alloc0 (pcache->static_pool, sizeof (struct cache_item));
+	item->s = rspamd_mempool_alloc0 (pcache->static_pool, sizeof (struct saved_cache_item));
 	rspamd_strlcpy (item->s->symbol, name, sizeof (item->s->symbol));
 	item->func = func;
 	item->user_data = user_data;
@@ -332,10 +303,7 @@ register_symbol_common (struct symbols_cache **cache,
 	}
 
 	/* Handle weight using default metric */
-	if (pcache->cfg && pcache->cfg->default_metric &&
-		(w =
-		g_hash_table_lookup (pcache->cfg->default_metric->symbols,
-		name)) != NULL) {
+	if (pcache->cfg && pcache->cfg->default_metric && (w = g_hash_table_lookup (pcache->cfg->default_metric->symbols, name)) != NULL) {
 		item->s->weight = weight * (*w);
 	}
 	else {
@@ -371,100 +339,58 @@ register_symbol_common (struct symbols_cache **cache,
 
 void
 register_symbol (struct symbols_cache **cache, const gchar *name, double weight,
-	symbol_func_t func, gpointer user_data)
+		symbol_func_t func, gpointer user_data)
 {
-	register_symbol_common (cache,
-		name,
-		weight,
-		0,
-		func,
-		user_data,
-		SYMBOL_TYPE_NORMAL);
+	register_symbol_common (cache, name, weight, 0, func, user_data, SYMBOL_TYPE_NORMAL);
 }
 
 void
-register_virtual_symbol (struct symbols_cache **cache,
-	const gchar *name,
-	double weight)
+register_virtual_symbol (struct symbols_cache **cache, const gchar *name, double weight)
 {
-	register_symbol_common (cache,
-		name,
-		weight,
-		0,
-		NULL,
-		NULL,
-		SYMBOL_TYPE_VIRTUAL);
+	register_symbol_common (cache, name, weight, 0, NULL, NULL, SYMBOL_TYPE_VIRTUAL);
 }
 
 void
-register_callback_symbol (struct symbols_cache **cache,
-	const gchar *name,
-	double weight,
-	symbol_func_t func,
-	gpointer user_data)
+register_callback_symbol (struct symbols_cache **cache, const gchar *name, double weight,
+		symbol_func_t func, gpointer user_data)
 {
-	register_symbol_common (cache,
-		name,
-		weight,
-		0,
-		func,
-		user_data,
-		SYMBOL_TYPE_CALLBACK);
+	register_symbol_common (cache, name, weight, 0, func, user_data, SYMBOL_TYPE_CALLBACK);
 }
 
 void
-register_callback_symbol_priority (struct symbols_cache **cache,
-	const gchar *name,
-	double weight,
-	gint priority,
-	symbol_func_t func,
-	gpointer user_data)
+register_callback_symbol_priority (struct symbols_cache **cache, const gchar *name, double weight, gint priority,
+		symbol_func_t func, gpointer user_data)
 {
-	register_symbol_common (cache,
-		name,
-		weight,
-		priority,
-		func,
-		user_data,
-		SYMBOL_TYPE_CALLBACK);
+	register_symbol_common (cache, name, weight, priority, func, user_data, SYMBOL_TYPE_CALLBACK);
 }
 
 void
-register_dynamic_symbol (rspamd_mempool_t *dynamic_pool,
-	struct symbols_cache **cache,
-	const gchar *name,
-	double weight,
-	symbol_func_t func,
-	gpointer user_data,
-	GList *networks)
+register_dynamic_symbol (rspamd_mempool_t *dynamic_pool, struct symbols_cache **cache,
+		const gchar *name, double weight, symbol_func_t func, 
+		gpointer user_data, GList *networks)
 {
-	struct cache_item *item = NULL;
-	struct symbols_cache *pcache = *cache;
-	GList *t, *cur;
-	uintptr_t r;
-	double *w;
-	guint32 mask = 0xFFFFFFFF;
-	struct dynamic_map_item *it;
-	gint rr;
+	struct cache_item              *item = NULL;
+	struct symbols_cache           *pcache = *cache;
+	GList                          *t, *cur;
+	uintptr_t                       r;
+	double                         *w;  
+	guint32                         mask = 0xFFFFFFFF;
+	struct dynamic_map_item        *it;
+	gint                            rr;
 
 	if (*cache == NULL) {
 		pcache = g_new0 (struct symbols_cache, 1);
 		*cache = pcache;
-		pcache->static_pool =
-			rspamd_mempool_new (rspamd_mempool_suggest_size ());
+		pcache->static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 	}
-
+	
 	item = rspamd_mempool_alloc0 (dynamic_pool, sizeof (struct cache_item));
-	item->s =
-		rspamd_mempool_alloc (dynamic_pool, sizeof (struct saved_cache_item));
+	item->s = rspamd_mempool_alloc (dynamic_pool, sizeof (struct saved_cache_item));
 	rspamd_strlcpy (item->s->symbol, name, sizeof (item->s->symbol));
 	item->func = func;
 	item->user_data = user_data;
 	/* Handle weight using default metric */
-	if (pcache->cfg && pcache->cfg->default_metric &&
-		(w =
-		g_hash_table_lookup (pcache->cfg->default_metric->symbols,
-		name)) != NULL) {
+	if (pcache->cfg && pcache->cfg->default_metric && (w = g_hash_table_lookup (pcache->cfg->default_metric->symbols, name)) != NULL) {
 		item->s->weight = weight * (*w);
 	}
 	else {
@@ -476,7 +402,7 @@ register_dynamic_symbol (rspamd_mempool_t *dynamic_pool,
 	pcache->used_items++;
 	msg_debug ("used items: %d, added symbol: %s", (*cache)->used_items, name);
 	rspamd_set_counter (item->s->symbol, 0);
-
+	
 	g_hash_table_insert (pcache->items_by_symbol, item->s->symbol, item);
 
 	if (networks == NULL) {
@@ -494,81 +420,50 @@ register_dynamic_symbol (rspamd_mempool_t *dynamic_pool,
 			r = ntohl (it->addr.s_addr & mask);
 			if (it->negative) {
 				/* For negatve items insert into list and into negative cache map */
-				if ((r =
-					radix32tree_find (pcache->negative_dynamic_map,
-					r)) != RADIX_NO_VALUE) {
+				if ((r = radix32tree_find (pcache->negative_dynamic_map, r)) != RADIX_NO_VALUE) {
 					t = (GList *)((gpointer)r);
 					t = g_list_prepend (t, item);
 					/* Replace pointers in radix tree and in destructor function */
-					rspamd_mempool_replace_destructor (dynamic_pool,
-						(rspamd_mempool_destruct_t)g_list_free, (gpointer)r, t);
-					rr = radix32tree_replace (pcache->negative_dynamic_map,
-							ntohl (it->addr.s_addr),
-							mask,
-							(uintptr_t)t);
+					rspamd_mempool_replace_destructor (dynamic_pool, (rspamd_mempool_destruct_t)g_list_free, (gpointer)r, t);
+					rr = radix32tree_replace (pcache->negative_dynamic_map, ntohl (it->addr.s_addr), mask, (uintptr_t)t);
 					if (rr == -1) {
-						msg_warn ("cannot replace ip to tree: %s, mask %X",
-							inet_ntoa (it->addr),
-							mask);
+						msg_warn ("cannot replace ip to tree: %s, mask %X", inet_ntoa (it->addr), mask);
 					}
 				}
 				else {
 					t = g_list_prepend (NULL, item);
-					rspamd_mempool_add_destructor (dynamic_pool,
-						(rspamd_mempool_destruct_t)g_list_free, t);
-					rr = radix32tree_insert (pcache->negative_dynamic_map,
-							ntohl (it->addr.s_addr),
-							mask,
-							(uintptr_t)t);
+					rspamd_mempool_add_destructor (dynamic_pool, (rspamd_mempool_destruct_t)g_list_free, t);
+					rr = radix32tree_insert (pcache->negative_dynamic_map, ntohl (it->addr.s_addr), mask, (uintptr_t)t);
 					if (rr == -1) {
-						msg_warn ("cannot insert ip to tree: %s, mask %X",
-							inet_ntoa (it->addr),
-							mask);
+						msg_warn ("cannot insert ip to tree: %s, mask %X", inet_ntoa (it->addr), mask);
 					}
 					else if (rr == 1) {
-						msg_warn ("ip %s, mask %X, value already exists",
-							inet_ntoa (it->addr),
-							mask);
+						msg_warn ("ip %s, mask %X, value already exists", inet_ntoa (it->addr), mask);
 					}
 				}
 				/* Insert into list */
-				pcache->dynamic_items = g_list_prepend (pcache->dynamic_items,
-						item);
+				pcache->dynamic_items = g_list_prepend (pcache->dynamic_items, item);
 			}
 			else {
-				if ((r =
-					radix32tree_find (pcache->dynamic_map,
-					r)) != RADIX_NO_VALUE) {
+				if ((r = radix32tree_find (pcache->dynamic_map, r)) != RADIX_NO_VALUE) {
 					t = (GList *)((gpointer)r);
 					t = g_list_prepend (t, item);
 					/* Replace pointers in radix tree and in destructor function */
-					rspamd_mempool_replace_destructor (dynamic_pool,
-						(rspamd_mempool_destruct_t)g_list_free, (gpointer)r, t);
-					rr =
-						radix32tree_replace (pcache->dynamic_map,
-							ntohl (it->addr.s_addr), mask, (uintptr_t)t);
+					rspamd_mempool_replace_destructor (dynamic_pool, (rspamd_mempool_destruct_t)g_list_free, (gpointer)r, t);
+					rr = radix32tree_replace (pcache->dynamic_map, ntohl (it->addr.s_addr), mask, (uintptr_t)t);
 					if (rr == -1) {
-						msg_warn ("cannot replace ip to tree: %s, mask %X",
-							inet_ntoa (it->addr),
-							mask);
+						msg_warn ("cannot replace ip to tree: %s, mask %X", inet_ntoa (it->addr), mask);
 					}
 				}
 				else {
 					t = g_list_prepend (NULL, item);
-					rspamd_mempool_add_destructor (dynamic_pool,
-						(rspamd_mempool_destruct_t)g_list_free, t);
-					rr =
-						radix32tree_insert (pcache->dynamic_map,
-							ntohl (it->addr.s_addr), mask, (uintptr_t)t);
+					rspamd_mempool_add_destructor (dynamic_pool, (rspamd_mempool_destruct_t)g_list_free, t);
+					rr = radix32tree_insert (pcache->dynamic_map, ntohl (it->addr.s_addr), mask, (uintptr_t)t);
 					if (rr == -1) {
-						msg_warn ("cannot insert ip to tree: %s, mask %X",
-							inet_ntoa (it->addr),
-							mask);
+						msg_warn ("cannot insert ip to tree: %s, mask %X", inet_ntoa (it->addr), mask);
 					}
 					else if (rr == 1) {
-						msg_warn ("ip %s, mask %X, value already exists",
-							inet_ntoa (it->addr),
-							mask);
+						msg_warn ("ip %s, mask %X, value already exists", inet_ntoa (it->addr), mask);
 					}
 				}
 			}
@@ -598,8 +493,8 @@ remove_dynamic_rules (struct symbols_cache *cache)
 static void
 free_cache (gpointer arg)
 {
-	struct symbols_cache *cache = arg;
-
+	struct symbols_cache           *cache = arg;
+	
 	if (cache->map != NULL) {
 		unmap_cache_file (cache);
 	}
@@ -626,18 +521,15 @@ free_cache (gpointer arg)
 }
 
 gboolean
-init_symbols_cache (rspamd_mempool_t * pool,
-	struct symbols_cache *cache,
-	struct rspamd_config *cfg,
-	const gchar *filename,
-	gboolean ignore_checksum)
+init_symbols_cache (rspamd_mempool_t * pool, struct symbols_cache *cache, struct rspamd_config *cfg,
+		const gchar *filename, gboolean ignore_checksum)
 {
-	struct stat st;
-	gint fd;
-	GChecksum *cksum;
-	u_char *mem_sum, *file_sum;
-	gsize cklen;
-	gboolean res;
+	struct stat                     st;
+	gint                            fd;
+	GChecksum                      *cksum;
+	u_char                         *mem_sum, *file_sum;
+	gsize                           cklen;
+	gboolean                        res;
 
 	if (cache == NULL) {
 		return FALSE;
@@ -653,19 +545,14 @@ init_symbols_cache (rspamd_mempool_t * pool,
 		post_cache_init (cache);
 		return TRUE;
 	}
-
+	
 	/* First of all try to stat file */
 	if (stat (filename, &st) == -1) {
 		/* Check errno */
 		if (errno == ENOENT) {
 			/* Try to create file */
-			if ((fd =
-				open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR |
-				S_IRUSR)) == -1) {
-				msg_info ("cannot create file %s, error %d, %s",
-					filename,
-					errno,
-					strerror (errno));
+			if ((fd = open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
+				msg_info ("cannot create file %s, error %d, %s", filename, errno, strerror (errno));
 				return FALSE;
 			}
 			else {
@@ -673,19 +560,13 @@ init_symbols_cache (rspamd_mempool_t * pool,
 			}
 		}
 		else {
-			msg_info ("cannot stat file %s, error %d, %s",
-				filename,
-				errno,
-				strerror (errno));
+			msg_info ("cannot stat file %s, error %d, %s", filename, errno, strerror (errno));
 			return FALSE;
 		}
 	}
 	else {
 		if ((fd = open (filename, O_RDWR)) == -1) {
-			msg_info ("cannot open file %s, error %d, %s",
-				filename,
-				errno,
-				strerror (errno));
+			msg_info ("cannot open file %s, error %d, %s", filename, errno, strerror (errno));
 			return FALSE;
 		}
 	}
@@ -708,13 +589,8 @@ init_symbols_cache (rspamd_mempool_t * pool,
 			if (errno == EINVAL) {
 				/* Try to create file */
 				msg_info ("recreate cache file");
-				if ((fd =
-					open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR |
-					S_IRUSR)) == -1) {
-					msg_info ("cannot create file %s, error %d, %s",
-						filename,
-						errno,
-						strerror (errno));
+				if ((fd = open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
+					msg_info ("cannot create file %s, error %d, %s", filename, errno, strerror (errno));
 					return FALSE;
 				}
 				else {
@@ -724,8 +600,7 @@ init_symbols_cache (rspamd_mempool_t * pool,
 			close (fd);
 			g_free (mem_sum);
 			g_checksum_free (cksum);
-			msg_err ("cannot seek to read checksum, %d, %s", errno,
-				strerror (errno));
+			msg_err ("cannot seek to read checksum, %d, %s", errno, strerror (errno));
 			return FALSE;
 		}
 		file_sum = g_malloc (cklen);
@@ -745,13 +620,8 @@ init_symbols_cache (rspamd_mempool_t * pool,
 			g_checksum_free (cksum);
 			msg_info ("checksum mismatch, recreating file");
 			/* Reopen with rw permissions */
-			if ((fd =
-				open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR |
-				S_IRUSR)) == -1) {
-				msg_info ("cannot create file %s, error %d, %s",
-					filename,
-					errno,
-					strerror (errno));
+			if ((fd = open (filename, O_RDWR | O_TRUNC | O_CREAT, S_IWUSR | S_IRUSR)) == -1) {
+				msg_info ("cannot create file %s, error %d, %s", filename, errno, strerror (errno));
 				return FALSE;
 			}
 			else {
@@ -766,9 +636,7 @@ init_symbols_cache (rspamd_mempool_t * pool,
 	/* MMap cache file and copy saved_cache structures */
 	res = mmap_cache_file (cache, fd, pool);
 
-	rspamd_mempool_add_destructor (pool,
-		(rspamd_mempool_destruct_t)free_cache,
-		cache);
+	rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t)free_cache, cache);
 
 	return res;
 }
@@ -780,12 +648,10 @@ check_dynamic_item (struct rspamd_task *task, struct symbols_cache *cache)
 	/* TODO: radix doesn't support ipv6 addrs */
 	return NULL;
 #else
-	GList *res = NULL;
-	uintptr_t r;
+	GList                          *res = NULL;
+	uintptr_t                       r;
 	if (cache->dynamic_map != NULL && task->from_addr.s_addr != INADDR_NONE) {
-		if ((r =
-			radix32tree_find (cache->dynamic_map,
-			ntohl (task->from_addr.s_addr))) != RADIX_NO_VALUE) {
+		if ((r = radix32tree_find (cache->dynamic_map, ntohl (task->from_addr.s_addr))) != RADIX_NO_VALUE) {
 			res = (GList *)((gpointer)r);
 			return res;
 		}
@@ -798,23 +664,18 @@ check_dynamic_item (struct rspamd_task *task, struct symbols_cache *cache)
 }
 
 static gboolean
-check_negative_dynamic_item (struct rspamd_task *task,
-	struct symbols_cache *cache,
-	struct cache_item *item)
+check_negative_dynamic_item (struct rspamd_task *task, struct symbols_cache *cache, struct cache_item *item)
 {
 
 #ifdef HAVE_INET_PTON
 	/* TODO: radix doesn't support ipv6 addrs */
 	return FALSE;
 #else
-	GList *res = NULL;
-	uintptr_t r;
-
-	if (cache->negative_dynamic_map != NULL && task->from_addr.s_addr !=
-		INADDR_NONE) {
-		if ((r =
-			radix32tree_find (cache->negative_dynamic_map,
-			ntohl (task->from_addr.s_addr))) != RADIX_NO_VALUE) {
+	GList                          *res = NULL;
+	uintptr_t                       r;
+
+	if (cache->negative_dynamic_map != NULL && task->from_addr.s_addr != INADDR_NONE) {
+		if ((r = radix32tree_find (cache->negative_dynamic_map, ntohl (task->from_addr.s_addr))) != RADIX_NO_VALUE) {
 			res = (GList *)((gpointer)r);
 			while (res) {
 				if (res->data == (gpointer)item) {
@@ -832,7 +693,7 @@ check_negative_dynamic_item (struct rspamd_task *task,
 static gboolean
 check_debug_symbol (struct rspamd_config *cfg, const gchar *symbol)
 {
-	GList *cur;
+	GList                         *cur;
 
 	cur = cfg->debug_symbols;
 	while (cur) {
@@ -875,13 +736,11 @@ rspamd_symbols_cache_metric_cb (gpointer k, gpointer v, gpointer ud)
 }
 
 gboolean
-validate_cache (struct symbols_cache *cache,
-	struct rspamd_config *cfg,
-	gboolean strict)
+validate_cache (struct symbols_cache *cache, struct rspamd_config *cfg, gboolean strict)
 {
-	struct cache_item *item;
-	GList *cur, *p, *metric_symbols;
-	gboolean res;
+	struct cache_item              *item;
+	GList                          *cur, *p, *metric_symbols;
+	gboolean                        res;
 
 	if (cache == NULL) {
 		msg_err ("empty cache is invalid");
@@ -893,16 +752,13 @@ validate_cache (struct symbols_cache *cache,
 	while (cur) {
 		item = cur->data;
 		if (!item->is_callback) {
-			if (g_hash_table_lookup (cfg->metrics_symbols,
-				item->s->symbol) == NULL) {
+			if (g_hash_table_lookup (cfg->metrics_symbols, item->s->symbol) == NULL) {
 				if (strict) {
-					msg_warn ("no weight registered for symbol %s",
-						item->s->symbol);
+					msg_warn ("no weight registered for symbol %s", item->s->symbol);
 					return FALSE;
 				}
 				else {
-					msg_info ("no weight registered for symbol %s",
-						item->s->symbol);
+					msg_info ("no weight registered for symbol %s", item->s->symbol);
 				}
 			}
 		}
@@ -912,16 +768,13 @@ validate_cache (struct symbols_cache *cache,
 	while (cur) {
 		item = cur->data;
 		if (!item->is_callback) {
-			if (g_hash_table_lookup (cfg->metrics_symbols,
-				item->s->symbol) == NULL) {
+			if (g_hash_table_lookup (cfg->metrics_symbols, item->s->symbol) == NULL) {
 				if (strict) {
-					msg_warn ("no weight registered for symbol %s",
-						item->s->symbol);
+					msg_warn ("no weight registered for symbol %s", item->s->symbol);
 					return FALSE;
 				}
 				else {
-					msg_info ("no weight registered for symbol %s",
-						item->s->symbol);
+					msg_info ("no weight registered for symbol %s", item->s->symbol);
 				}
 			}
 		}
@@ -954,9 +807,7 @@ validate_cache (struct symbols_cache *cache,
 			}
 		}
 		if (!res) {
-			msg_warn (
-				"symbol '%s' is registered in metric but not found in cache",
-				cur->data);
+			msg_warn ("symbol '%s' is registered in metric but not found in cache", cur->data);
 			if (strict) {
 				return FALSE;
 			}
@@ -968,14 +819,10 @@ validate_cache (struct symbols_cache *cache,
 
 	/* Now adjust symbol weights according to default metric */
 	if (cfg->default_metric != NULL) {
-		g_hash_table_foreach (cfg->default_metric->symbols,
-			rspamd_symbols_cache_metric_cb,
-			cache);
+		g_hash_table_foreach (cfg->default_metric->symbols, rspamd_symbols_cache_metric_cb, cache);
 		/* Resort caches */
-		cache->negative_items = g_list_sort (cache->negative_items,
-				cache_logic_cmp);
-		cache->static_items =
-			g_list_sort (cache->static_items, cache_logic_cmp);
+		cache->negative_items = g_list_sort (cache->negative_items, cache_logic_cmp);
+		cache->static_items = g_list_sort (cache->static_items, cache_logic_cmp);
 	}
 
 	return TRUE;
@@ -993,18 +840,16 @@ struct symbol_callback_data {
 };
 
 gboolean
-call_symbol_callback (struct rspamd_task * task,
-	struct symbols_cache * cache,
-	gpointer *save)
+call_symbol_callback (struct rspamd_task * task, struct symbols_cache * cache, gpointer *save)
 {
 #ifdef HAVE_CLOCK_GETTIME
-	struct timespec ts1, ts2;
+	struct timespec                 ts1, ts2;
 #else
-	struct timeval tv1, tv2;
+	struct timeval                  tv1, tv2;
 #endif
-	guint64 diff;
-	struct cache_item *item = NULL;
-	struct symbol_callback_data *s = *save;
+	guint64                         diff;
+	struct cache_item              *item = NULL;
+	struct symbol_callback_data    *s = *save;
 
 	if (s == NULL) {
 		if (cache == NULL) {
@@ -1018,17 +863,14 @@ call_symbol_callback (struct rspamd_task * task,
 			post_cache_init (cache);
 			rspamd_mempool_wunlock_rwlock (cache->lock);
 		}
-		s =
-			rspamd_mempool_alloc0 (task->task_pool,
-				sizeof (struct symbol_callback_data));
+		s = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct symbol_callback_data));
 		*save = s;
 		if (cache->negative_items != NULL) {
 			s->list_pointer = g_list_first (cache->negative_items);
 			s->saved_item = s->list_pointer->data;
 			s->state = CACHE_STATE_NEGATIVE;
 		}
-		else if ((s->list_pointer =
-			check_dynamic_item (task, cache)) || cache->dynamic_items != NULL) {
+		else if ((s->list_pointer = check_dynamic_item (task, cache)) || cache->dynamic_items != NULL) {
 			if (s->list_pointer == NULL) {
 				s->list_pointer = g_list_first (cache->dynamic_items);
 				s->saved_item = s->list_pointer->data;
@@ -1056,47 +898,63 @@ call_symbol_callback (struct rspamd_task * task,
 			return FALSE;
 		}
 		switch (s->state) {
-		case CACHE_STATE_NEGATIVE:
-			s->list_pointer = g_list_next (s->list_pointer);
-			if (s->list_pointer == NULL) {
-				if ((s->list_pointer =
-					check_dynamic_item (task,
-					cache)) || cache->dynamic_items != NULL) {
-					if (s->list_pointer == NULL) {
-						s->list_pointer = g_list_first (cache->dynamic_items);
-						s->saved_item = s->list_pointer->data;
-						s->state = CACHE_STATE_DYNAMIC;
+			case CACHE_STATE_NEGATIVE:
+				s->list_pointer = g_list_next (s->list_pointer);
+				if (s->list_pointer == NULL) {
+					if ((s->list_pointer = check_dynamic_item (task, cache)) || cache->dynamic_items != NULL) {
+						if (s->list_pointer == NULL) {
+							s->list_pointer = g_list_first (cache->dynamic_items);
+							s->saved_item = s->list_pointer->data;
+							s->state = CACHE_STATE_DYNAMIC;
+						}
+						else {
+							s->saved_item = s->list_pointer->data;
+							s->state = CACHE_STATE_DYNAMIC_MAP;
+						}
 					}
 					else {
-						s->saved_item = s->list_pointer->data;
-						s->state = CACHE_STATE_DYNAMIC_MAP;
+						s->state = CACHE_STATE_STATIC;
+						s->list_pointer = g_list_first (cache->static_items);
+						if (s->list_pointer) {
+							s->saved_item = s->list_pointer->data;
+						}
+						else {
+							return FALSE;
+						}
 					}
 				}
 				else {
-					s->state = CACHE_STATE_STATIC;
-					s->list_pointer = g_list_first (cache->static_items);
+					s->saved_item = s->list_pointer->data;
+				}
+				item = s->saved_item;
+				break;
+			case CACHE_STATE_DYNAMIC_MAP:
+				s->list_pointer = g_list_next (s->list_pointer);
+				if (s->list_pointer == NULL) {
+					s->list_pointer = g_list_first (cache->dynamic_items);
 					if (s->list_pointer) {
 						s->saved_item = s->list_pointer->data;
+						s->state = CACHE_STATE_DYNAMIC;
 					}
 					else {
-						return FALSE;
+						s->state = CACHE_STATE_STATIC;
+						s->list_pointer = g_list_first (cache->static_items);
+						if (s->list_pointer) {
+							s->saved_item = s->list_pointer->data;
+						}
+						else {
+							return FALSE;
+						}
 					}
 				}
-			}
-			else {
-				s->saved_item = s->list_pointer->data;
-			}
-			item = s->saved_item;
-			break;
-		case CACHE_STATE_DYNAMIC_MAP:
-			s->list_pointer = g_list_next (s->list_pointer);
-			if (s->list_pointer == NULL) {
-				s->list_pointer = g_list_first (cache->dynamic_items);
-				if (s->list_pointer) {
+				else {
 					s->saved_item = s->list_pointer->data;
-					s->state = CACHE_STATE_DYNAMIC;
 				}
-				else {
+				item = s->saved_item;
+				break;
+			case CACHE_STATE_DYNAMIC:
+				s->list_pointer = g_list_next (s->list_pointer);
+				if (s->list_pointer == NULL) {
 					s->state = CACHE_STATE_STATIC;
 					s->list_pointer = g_list_first (cache->static_items);
 					if (s->list_pointer) {
@@ -1106,58 +964,39 @@ call_symbol_callback (struct rspamd_task * task,
 						return FALSE;
 					}
 				}
-			}
-			else {
-				s->saved_item = s->list_pointer->data;
-			}
-			item = s->saved_item;
-			break;
-		case CACHE_STATE_DYNAMIC:
-			s->list_pointer = g_list_next (s->list_pointer);
-			if (s->list_pointer == NULL) {
-				s->state = CACHE_STATE_STATIC;
-				s->list_pointer = g_list_first (cache->static_items);
+				else {
+					s->saved_item = s->list_pointer->data;
+					/* Skip items that are in negative map */
+					while (s->list_pointer != NULL && check_negative_dynamic_item (task, cache, s->saved_item)) {
+						s->list_pointer = g_list_next (s->list_pointer);
+						if (s->list_pointer != NULL) {
+							s->saved_item = s->list_pointer->data;
+						}
+					}
+					if (s->list_pointer == NULL) {
+						s->state = CACHE_STATE_STATIC;
+						s->list_pointer = g_list_first (cache->static_items);
+						if (s->list_pointer) {
+							s->saved_item = s->list_pointer->data;
+						}
+						else {
+							return FALSE;
+						}
+					}
+				}
+				item = s->saved_item;
+				break;
+			case CACHE_STATE_STATIC:
+				/* Next pointer */
+				s->list_pointer = g_list_next (s->list_pointer);
 				if (s->list_pointer) {
 					s->saved_item = s->list_pointer->data;
 				}
 				else {
 					return FALSE;
 				}
-			}
-			else {
-				s->saved_item = s->list_pointer->data;
-				/* Skip items that are in negative map */
-				while (s->list_pointer != NULL &&
-					check_negative_dynamic_item (task, cache, s->saved_item)) {
-					s->list_pointer = g_list_next (s->list_pointer);
-					if (s->list_pointer != NULL) {
-						s->saved_item = s->list_pointer->data;
-					}
-				}
-				if (s->list_pointer == NULL) {
-					s->state = CACHE_STATE_STATIC;
-					s->list_pointer = g_list_first (cache->static_items);
-					if (s->list_pointer) {
-						s->saved_item = s->list_pointer->data;
-					}
-					else {
-						return FALSE;
-					}
-				}
-			}
-			item = s->saved_item;
-			break;
-		case CACHE_STATE_STATIC:
-			/* Next pointer */
-			s->list_pointer = g_list_next (s->list_pointer);
-			if (s->list_pointer) {
-				s->saved_item = s->list_pointer->data;
-			}
-			else {
-				return FALSE;
-			}
-			item = s->saved_item;
-			break;
+				item = s->saved_item;
+				break;
 		}
 	}
 	if (!item) {
@@ -1168,9 +1007,9 @@ call_symbol_callback (struct rspamd_task * task,
 # ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
 		clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &ts1);
 # elif defined(HAVE_CLOCK_VIRTUAL)
-		clock_gettime (CLOCK_VIRTUAL,			 &ts1);
+		clock_gettime (CLOCK_VIRTUAL, &ts1);
 # else
-		clock_gettime (CLOCK_REALTIME,			 &ts1);
+		clock_gettime (CLOCK_REALTIME, &ts1);
 # endif
 #else
 		if (gettimeofday (&tv1, NULL) == -1) {
@@ -1191,9 +1030,9 @@ call_symbol_callback (struct rspamd_task * task,
 # ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
 		clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &ts2);
 # elif defined(HAVE_CLOCK_VIRTUAL)
-		clock_gettime (CLOCK_VIRTUAL,			 &ts2);
+		clock_gettime (CLOCK_VIRTUAL, &ts2);
 # else
-		clock_gettime (CLOCK_REALTIME,			 &ts2);
+		clock_gettime (CLOCK_REALTIME, &ts2);
 # endif
 #else
 		if (gettimeofday (&tv2, NULL) == -1) {
@@ -1202,12 +1041,9 @@ call_symbol_callback (struct rspamd_task * task,
 #endif
 
 #ifdef HAVE_CLOCK_GETTIME
-		diff =
-			(ts2.tv_sec -
-			ts1.tv_sec) * 1000000 + (ts2.tv_nsec - ts1.tv_nsec) / 1000;
+		diff = (ts2.tv_sec - ts1.tv_sec) * 1000000 + (ts2.tv_nsec - ts1.tv_nsec) / 1000;
 #else
-		diff =
-			(tv2.tv_sec - tv1.tv_sec) * 1000000 + (tv2.tv_usec - tv1.tv_usec);
+		diff = (tv2.tv_sec - tv1.tv_sec) * 1000000 + (tv2.tv_usec - tv1.tv_usec);
 #endif
 		item->s->avg_time = rspamd_set_counter (item->s->symbol, diff);
 	}
diff --git a/src/libserver/symbols_cache.h b/src/libserver/symbols_cache.h
index e1fd3286f..b3835824d 100644
--- a/src/libserver/symbols_cache.h
+++ b/src/libserver/symbols_cache.h
@@ -32,7 +32,7 @@ struct cache_item {
 	struct dynamic_map_item *networks;
 	guint32 networks_number;
 	gboolean is_dynamic;
-
+	
 	/* Callback data */
 	symbol_func_t func;
 	gpointer user_data;
@@ -53,7 +53,7 @@ struct symbols_cache {
 
 	/* Items that have negative weights */
 	GList *negative_items;
-
+	
 	/* Radix map of dynamic rules with ip mappings */
 	radix_tree_t *dynamic_map;
 	radix_tree_t *negative_dynamic_map;
@@ -77,11 +77,8 @@ struct symbols_cache {
 /**
  * Load symbols cache from file, must be called _after_ init_symbols_cache
  */
-gboolean init_symbols_cache (rspamd_mempool_t *pool,
-	struct symbols_cache *cache,
-	struct rspamd_config *cfg,
-	const gchar *filename,
-	gboolean ignore_checksum);
+gboolean init_symbols_cache (rspamd_mempool_t *pool, struct symbols_cache *cache, struct rspamd_config *cfg,
+		const gchar *filename, gboolean ignore_checksum);
 
 /**
  * Register function for symbols parsing
@@ -89,20 +86,15 @@ gboolean init_symbols_cache (rspamd_mempool_t *pool,
  * @param func pointer to handler
  * @param user_data pointer to user_data
  */
-void register_symbol (struct symbols_cache **cache,
-	const gchar *name,
-	double weight,
-	symbol_func_t func,
-	gpointer user_data);
+void register_symbol (struct symbols_cache **cache, const gchar *name, double weight,
+		symbol_func_t func, gpointer user_data);
 
 
 /**
  * Register virtual symbol
  * @param name name of symbol
  */
-void register_virtual_symbol (struct symbols_cache **cache,
-	const gchar *name,
-	double weight);
+void register_virtual_symbol (struct symbols_cache **cache, const gchar *name, double weight);
 
 /**
  * Register callback function for symbols parsing
@@ -110,11 +102,8 @@ void register_virtual_symbol (struct symbols_cache **cache,
  * @param func pointer to handler
  * @param user_data pointer to user_data
  */
-void register_callback_symbol (struct symbols_cache **cache,
-	const gchar *name,
-	double weight,
-	symbol_func_t func,
-	gpointer user_data);
+void register_callback_symbol (struct symbols_cache **cache, const gchar *name, double weight,
+		symbol_func_t func, gpointer user_data);
 
 /**
  * Register function for symbols parsing with strict priority
@@ -122,12 +111,8 @@ void register_callback_symbol (struct symbols_cache **cache,
  * @param func pointer to handler
  * @param user_data pointer to user_data
  */
-void register_callback_symbol_priority (struct symbols_cache **cache,
-	const gchar *name,
-	double weight,
-	gint priority,
-	symbol_func_t func,
-	gpointer user_data);
+void register_callback_symbol_priority (struct symbols_cache **cache, const gchar *name, double weight,
+		gint priority, symbol_func_t func, gpointer user_data);
 
 /**
  * Register function for dynamic symbols parsing
@@ -135,13 +120,9 @@ void register_callback_symbol_priority (struct symbols_cache **cache,
  * @param func pointer to handler
  * @param user_data pointer to user_data
  */
-void register_dynamic_symbol (rspamd_mempool_t *pool,
-	struct symbols_cache **cache,
-	const gchar *name,
-	double weight,
-	symbol_func_t func,
-	gpointer user_data,
-	GList *networks);
+void register_dynamic_symbol (rspamd_mempool_t *pool, struct symbols_cache **cache, const gchar *name, 
+						double weight, symbol_func_t func, 
+						gpointer user_data, GList *networks);
 
 /**
  * Call function for cached symbol using saved callback
@@ -149,9 +130,7 @@ void register_dynamic_symbol (rspamd_mempool_t *pool,
  * @param cache symbols cache
  * @param saved_item pointer to currently saved item
  */
-gboolean call_symbol_callback (struct rspamd_task *task,
-	struct symbols_cache *cache,
-	gpointer *save);
+gboolean call_symbol_callback (struct rspamd_task *task, struct symbols_cache *cache, gpointer *save);
 
 /**
  * Remove all dynamic rules from cache
@@ -165,9 +144,7 @@ void remove_dynamic_rules (struct symbols_cache *cache);
  * @param cfg configuration
  * @param strict do strict checks - symbols MUST be described in metrics
  */
-gboolean validate_cache (struct symbols_cache *cache,
-	struct rspamd_config *cfg,
-	gboolean strict);
+gboolean validate_cache (struct symbols_cache *cache, struct rspamd_config *cfg, gboolean strict);
 
 
 #endif
diff --git a/src/libserver/task.c b/src/libserver/task.c
index 4e71a1710..a46a70604 100644
--- a/src/libserver/task.c
+++ b/src/libserver/task.c
@@ -21,12 +21,12 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "filter.h"
-#include "lua/lua_common.h"
+#include "task.h"
 #include "main.h"
-#include "message.h"
+#include "filter.h"
 #include "protocol.h"
-#include "task.h"
+#include "message.h"
+#include "lua/lua_common.h"
 
 /*
  * Destructor for recipients list in a task
@@ -34,7 +34,7 @@
 static void
 rcpt_destruct (void *pointer)
 {
-	struct rspamd_task *task = (struct rspamd_task *) pointer;
+	struct rspamd_task             *task = (struct rspamd_task *) pointer;
 
 	if (task->rcpt) {
 		g_list_free (task->rcpt);
@@ -44,10 +44,10 @@ rcpt_destruct (void *pointer)
 /*
  * Create new task
  */
-struct rspamd_task *
+struct rspamd_task             *
 rspamd_task_new (struct rspamd_worker *worker)
 {
-	struct rspamd_task *new_task;
+	struct rspamd_task             *new_task;
 
 	new_task = g_slice_alloc0 (sizeof (struct rspamd_task));
 
@@ -60,9 +60,9 @@ rspamd_task_new (struct rspamd_worker *worker)
 # ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
 	clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &new_task->ts);
 # elif defined(HAVE_CLOCK_VIRTUAL)
-	clock_gettime (CLOCK_VIRTUAL,			 &new_task->ts);
+	clock_gettime (CLOCK_VIRTUAL, &new_task->ts);
 # else
-	clock_gettime (CLOCK_REALTIME,			 &new_task->ts);
+	clock_gettime (CLOCK_REALTIME, &new_task->ts);
 # endif
 #endif
 	if (gettimeofday (&new_task->tv, NULL) == -1) {
@@ -73,28 +73,27 @@ rspamd_task_new (struct rspamd_worker *worker)
 
 	/* Add destructor for recipients list (it would be better to use anonymous function here */
 	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t) rcpt_destruct, new_task);
+			(rspamd_mempool_destruct_t) rcpt_destruct, new_task);
 	new_task->results = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy,
-		new_task->results);
+			(rspamd_mempool_destruct_t) g_hash_table_destroy,
+			new_task->results);
 	new_task->re_cache = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy,
-		new_task->re_cache);
-	new_task->raw_headers = g_hash_table_new (rspamd_strcase_hash,
-			rspamd_strcase_equal);
+			(rspamd_mempool_destruct_t) g_hash_table_destroy,
+			new_task->re_cache);
+	new_task->raw_headers = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
 	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy,
-		new_task->raw_headers);
+				(rspamd_mempool_destruct_t) g_hash_table_destroy,
+				new_task->raw_headers);
 	new_task->emails = g_tree_new (compare_email_func);
 	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t) g_tree_destroy,
-		new_task->emails);
+				(rspamd_mempool_destruct_t) g_tree_destroy,
+				new_task->emails);
 	new_task->urls = g_tree_new (compare_url_func);
 	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t) g_tree_destroy,
-		new_task->urls);
+					(rspamd_mempool_destruct_t) g_tree_destroy,
+					new_task->urls);
 	new_task->sock = -1;
 	new_task->is_mime = TRUE;
 	new_task->is_json = TRUE;
@@ -124,7 +123,7 @@ rspamd_task_reply (struct rspamd_task *task)
 gboolean
 rspamd_task_fin (void *arg)
 {
-	struct rspamd_task *task = (struct rspamd_task *) arg;
+	struct rspamd_task              *task = (struct rspamd_task *) arg;
 	gint r;
 	GError *err = NULL;
 
@@ -206,7 +205,7 @@ rspamd_task_fin (void *arg)
 void
 rspamd_task_restore (void *arg)
 {
-	struct rspamd_task *task = (struct rspamd_task *) arg;
+	struct rspamd_task             *task = (struct rspamd_task *) arg;
 
 	/* Call post filters */
 	if (task->state == WAIT_POST_FILTER && !task->skip_extra_filters) {
@@ -221,8 +220,8 @@ rspamd_task_restore (void *arg)
 void
 rspamd_task_free (struct rspamd_task *task, gboolean is_soft)
 {
-	GList *part;
-	struct mime_part *p;
+	GList                          *part;
+	struct mime_part               *p;
 
 	if (task) {
 		debug_task ("free pointer %p", task);
@@ -258,16 +257,14 @@ rspamd_task_free (struct rspamd_task *task, gboolean is_soft)
 	}
 }
 
-void
-rspamd_task_free_hard (gpointer ud)
+void rspamd_task_free_hard (gpointer ud)
 {
 	struct rspamd_task *task = ud;
 
 	rspamd_task_free (task, FALSE);
 }
 
-void
-rspamd_task_free_soft (gpointer ud)
+void rspamd_task_free_soft (gpointer ud)
 {
 	struct rspamd_task *task = ud;
 
@@ -277,8 +274,8 @@ rspamd_task_free_soft (gpointer ud)
 
 gboolean
 rspamd_task_process (struct rspamd_task *task,
-	struct rspamd_http_message *msg, GThreadPool *classify_pool,
-	gboolean process_extra_filters)
+		struct rspamd_http_message *msg, GThreadPool *classify_pool,
+		gboolean process_extra_filters)
 {
 	gint r;
 	GError *err = NULL;
diff --git a/src/libserver/task.h b/src/libserver/task.h
index 0f782b657..4c3462d9a 100644
--- a/src/libserver/task.h
+++ b/src/libserver/task.h
@@ -24,11 +24,11 @@
 #define TASK_H_
 
 #include "config.h"
-#include "dns.h"
-#include "events.h"
 #include "http.h"
-#include "mem_pool.h"
+#include "events.h"
 #include "util.h"
+#include "mem_pool.h"
+#include "dns.h"
 
 enum rspamd_command {
 	CMD_CHECK,
@@ -62,7 +62,7 @@ struct custom_command {
  * Worker task structure
  */
 struct rspamd_task {
-	struct rspamd_worker *worker;                               /**< pointer to worker object						*/
+	struct rspamd_worker *worker;								/**< pointer to worker object						*/
 	enum {
 		READ_MESSAGE,
 		WAIT_PRE_FILTER,
@@ -70,82 +70,82 @@ struct rspamd_task {
 		WAIT_POST_FILTER,
 		WRITE_REPLY,
 		CLOSING_CONNECTION
-	} state;                                                    /**< current session state							*/
-	enum rspamd_command cmd;                                    /**< command										*/
-	struct custom_command *custom_cmd;                          /**< custom command if any							*/
-	gint sock;                                                  /**< socket descriptor								*/
+	} state;													/**< current session state							*/
+	enum rspamd_command cmd;									/**< command										*/
+	struct custom_command *custom_cmd;							/**< custom command if any							*/
+	gint sock;													/**< socket descriptor								*/
 	gboolean is_mime;                                           /**< if this task is mime task                      */
-	gboolean is_json;                                           /**< output is JSON									*/
-	gboolean skip_extra_filters;                                /**< skip pre and post filters						*/
+	gboolean is_json;											/**< output is JSON									*/
+	gboolean skip_extra_filters;								/**< skip pre and post filters						*/
 	gboolean is_skipped;                                        /**< whether message was skipped by configuration   */
 
-	gchar *helo;                                                    /**< helo header value								*/
-	gchar *from;                                                    /**< from header value								*/
-	gchar *queue_id;                                                /**< queue id if specified							*/
-	const gchar *message_id;                                        /**< message id										*/
-	GList *rcpt;                                                    /**< recipients list								*/
-	guint nrcpt;                                            /**< number of recipients							*/
-	rspamd_inet_addr_t from_addr;                               /**< from addr for a task							*/
-	rspamd_inet_addr_t client_addr;                             /**< address of connected socket					*/
-	gchar *deliver_to;                                          /**< address to deliver								*/
-	gchar *user;                                                    /**< user to deliver								*/
-	gchar *subject;                                             /**< subject (for non-mime)							*/
-	gchar *hostname;                                            /**< hostname reported by MTA						*/
-	GString *msg;                                               /**< message buffer									*/
-	struct rspamd_http_connection *http_conn;                   /**< HTTP server connection							*/
-	struct rspamd_async_session * s;                             /**< async session object							*/
-	gint parts_count;                                           /**< mime parts count								*/
-	GMimeMessage *message;                                      /**< message, parsed with GMime						*/
-	GMimeObject *parser_parent_part;                            /**< current parent part							*/
-	InternetAddressList *rcpts;                                 /**< list of all recipients                         */
-	GList *parts;                                               /**< list of parsed parts							*/
-	GList *text_parts;                                          /**< list of text parts								*/
-	gchar *raw_headers_str;                                         /**< list of raw headers							*/
-	GList *received;                                            /**< list of received headers						*/
-	GTree *urls;                                                /**< list of parsed urls							*/
-	GTree *emails;                                              /**< list of parsed emails							*/
-	GList *images;                                              /**< list of images									*/
-	GHashTable *raw_headers;                                    /**< list of raw headers							*/
-	GHashTable *results;                                        /**< hash table of metric_result indexed by
-	                                                             *    metric's name									*/
-	GHashTable *tokens;                                         /**< hash table of tokens indexed by tokenizer
-	                                                             *    pointer                                       */
-	GList *messages;                                            /**< list of messages that would be reported		*/
-	GHashTable *re_cache;                                       /**< cache for matched or not matched regexps		*/
-	struct rspamd_config *cfg;                                  /**< pointer to config object						*/
-	gchar *last_error;                                          /**< last error										*/
-	gint error_code;                                                /**< code of last error								*/
-	rspamd_mempool_t *task_pool;                                    /**< memory pool for task							*/
+	gchar *helo;													/**< helo header value								*/
+	gchar *from;													/**< from header value								*/
+	gchar *queue_id;												/**< queue id if specified							*/
+	const gchar *message_id;										/**< message id										*/
+	GList *rcpt;													/**< recipients list								*/
+	guint nrcpt;											/**< number of recipients							*/
+	rspamd_inet_addr_t from_addr;								/**< from addr for a task							*/
+	rspamd_inet_addr_t client_addr;								/**< address of connected socket					*/
+	gchar *deliver_to;											/**< address to deliver								*/
+	gchar *user;													/**< user to deliver								*/
+	gchar *subject;												/**< subject (for non-mime)							*/
+	gchar *hostname;											/**< hostname reported by MTA						*/
+	GString *msg;												/**< message buffer									*/
+	struct rspamd_http_connection *http_conn;					/**< HTTP server connection							*/
+	struct rspamd_async_session* s;								/**< async session object							*/
+	gint parts_count;											/**< mime parts count								*/
+	GMimeMessage *message;										/**< message, parsed with GMime						*/
+	GMimeObject *parser_parent_part;							/**< current parent part							*/
+	InternetAddressList *rcpts;									/**< list of all recipients 						*/
+	GList *parts;												/**< list of parsed parts							*/
+	GList *text_parts;											/**< list of text parts								*/
+	gchar *raw_headers_str;											/**< list of raw headers							*/
+	GList *received;											/**< list of received headers						*/
+	GTree *urls;												/**< list of parsed urls							*/
+	GTree *emails;												/**< list of parsed emails							*/
+	GList *images;												/**< list of images									*/
+	GHashTable *raw_headers;									/**< list of raw headers							*/
+	GHashTable *results;										/**< hash table of metric_result indexed by
+	 *    metric's name									*/
+	GHashTable *tokens;											/**< hash table of tokens indexed by tokenizer
+	 *    pointer 										*/
+	GList *messages;											/**< list of messages that would be reported		*/
+	GHashTable *re_cache;										/**< cache for matched or not matched regexps		*/
+	struct rspamd_config *cfg;									/**< pointer to config object						*/
+	gchar *last_error;											/**< last error										*/
+	gint error_code;												/**< code of last error								*/
+	rspamd_mempool_t *task_pool;									/**< memory pool for task							*/
 #ifdef HAVE_CLOCK_GETTIME
-	struct timespec ts;                                         /**< time of connection								*/
+	struct timespec ts;											/**< time of connection								*/
 #endif
-	struct timeval tv;                                          /**< time of connection								*/
-	guint32 scan_milliseconds;                                  /**< how much milliseconds passed					*/
-	gboolean pass_all_filters;                                  /**< pass task throught every rule					*/
-	gboolean no_log;                                            /**< do not log or write this task to the history	*/
-	guint32 parser_recursion;                                   /**< for avoiding recursion stack overflow			*/
-	gboolean (*fin_callback)(void *arg);                        /**< calback for filters finalizing					*/
-	void *fin_arg;                                              /**< argument for fin callback						*/
+	struct timeval tv;											/**< time of connection								*/
+	guint32 scan_milliseconds;									/**< how much milliseconds passed					*/
+	gboolean pass_all_filters;									/**< pass task throught every rule					*/
+	gboolean no_log;											/**< do not log or write this task to the history	*/
+	guint32 parser_recursion;									/**< for avoiding recursion stack overflow			*/
+	gboolean (*fin_callback)(void *arg);						/**< calback for filters finalizing					*/
+	void *fin_arg;												/**< argument for fin callback						*/
 
-	guint32 dns_requests;                                       /**< number of DNS requests per this task			*/
+	guint32 dns_requests;										/**< number of DNS requests per this task			*/
 
-	struct rspamd_dns_resolver *resolver;                       /**< DNS resolver									*/
-	struct event_base *ev_base;                                 /**< Event base										*/
+	struct rspamd_dns_resolver *resolver;						/**< DNS resolver									*/
+	struct event_base *ev_base;									/**< Event base										*/
 
-	GThreadPool *classify_pool;                                 /**< A pool of classify threads                     */
+	GThreadPool *classify_pool;									/**< A pool of classify threads 					*/
 
 	struct {
-		enum rspamd_metric_action action;                       /**< Action of pre filters							*/
-		gchar *str;                                             /**< String describing action						*/
-	} pre_result;                                               /**< Result of pre-filters							*/
+		enum rspamd_metric_action action;						/**< Action of pre filters							*/
+		gchar *str;												/**< String describing action						*/
+	} pre_result;												/**< Result of pre-filters							*/
 
-	ucl_object_t *settings;                                     /**< Settings applied to task						*/
+	ucl_object_t *settings;										/**< Settings applied to task						*/
 };
 
 /**
  * Construct new task for worker
  */
-struct rspamd_task * rspamd_task_new (struct rspamd_worker *worker);
+struct rspamd_task* rspamd_task_new (struct rspamd_worker *worker);
 /**
  * Destroy task object and remove its IO dispatcher if it exists
  */
@@ -173,7 +173,7 @@ gboolean rspamd_task_fin (void *arg);
  * @return task has been successfully parsed and processed
  */
 gboolean rspamd_task_process (struct rspamd_task *task,
-	struct rspamd_http_message *msg, GThreadPool *classify_pool,
-	gboolean process_extra_filters);
+		struct rspamd_http_message *msg, GThreadPool *classify_pool,
+		gboolean process_extra_filters);
 
 #endif /* TASK_H_ */
diff --git a/src/libserver/url.c b/src/libserver/url.c
index b481f6e2b..c4313e8a9 100644
--- a/src/libserver/url.c
+++ b/src/libserver/url.c
@@ -23,12 +23,12 @@
  */
 
 #include "config.h"
+#include "url.h"
+#include "util.h"
 #include "fstring.h"
 #include "main.h"
 #include "message.h"
 #include "trie.h"
-#include "url.h"
-#include "util.h"
 
 #define POST_CHAR 1
 #define POST_CHAR_S "\001"
@@ -38,16 +38,16 @@
 #define HIGHEST_PORT    65535
 
 #define uri_port_is_valid(port) \
-	(LOWEST_PORT <= (port) && (port) <= HIGHEST_PORT)
+    (LOWEST_PORT <= (port) && (port) <= HIGHEST_PORT)
 
 struct _proto {
-	guchar *name;
-	gint port;
-	uintptr_t *unused;
-	guint need_slashes : 1;
-	guint need_slash_after_host : 1;
-	guint free_syntax : 1;
-	guint need_ssl : 1;
+	guchar                         *name;
+	gint                            port;
+	uintptr_t                      *unused;
+	guint                           need_slashes:1;
+	guint                           need_slash_after_host:1;
+	guint                           free_syntax:1;
+	guint                           need_ssl:1;
 };
 
 typedef struct url_match_s {
@@ -64,627 +64,314 @@ typedef struct url_match_s {
 struct url_matcher {
 	const gchar *pattern;
 	const gchar *prefix;
-	gboolean (*start)(const gchar *begin, const gchar *end, const gchar *pos,
-		url_match_t *match);
-	gboolean (*end)(const gchar *begin, const gchar *end, const gchar *pos,
-		url_match_t *match);
+	gboolean (*start)(const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+	gboolean (*end)(const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
 	gint flags;
 };
 
-static gboolean url_file_start (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match);
-static gboolean url_file_end (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match);
-
-static gboolean url_web_start (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match);
-static gboolean url_web_end (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match);
-
-static gboolean url_tld_start (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match);
-static gboolean url_tld_end (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match);
-
-static gboolean url_email_start (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match);
-static gboolean url_email_end (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match);
+static gboolean url_file_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+static gboolean url_file_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+
+static gboolean url_web_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+static gboolean url_web_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+
+static gboolean url_tld_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+static gboolean url_tld_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+
+static gboolean url_email_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
+static gboolean url_email_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match);
 
 struct url_matcher matchers[] = {
-	/* Common prefixes */
-	{ "file://",        "",         url_file_start,         url_file_end,
-	  0                   },
-	{ "ftp://",         "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "sftp://",        "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "http://",        "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "https://",       "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "news://",        "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "nntp://",        "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "telnet://",      "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "webcal://",      "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "mailto://",      "",         url_email_start,        url_email_end,
-	  0                   },
-	{ "callto://",      "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "h323:",          "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "sip:",           "",         url_web_start,          url_web_end,
-	  0                   },
-	{ "www.",           "http://",  url_web_start,          url_web_end,
-	  0                   },
-	{ "ftp.",           "ftp://",   url_web_start,          url_web_end,
-	  URL_FLAG_NOHTML     },
-	/* TLD domains parts */
-	{ ".ac",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ad",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ae",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".aero",          "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".af",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ag",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ai",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".al",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".am",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".an",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ao",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".aq",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ar",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".arpa",          "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".as",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".asia",          "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".at",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".au",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".aw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ax",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".az",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ba",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bb",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bd",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".be",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bf",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bh",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bi",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".biz",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bj",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bo",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".br",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bs",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bt",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bv",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".by",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".bz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ca",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cat",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cc",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cd",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cf",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ch",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ci",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ck",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cl",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".co",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".com",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".coop",          "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cu",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cv",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cx",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cy",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".cz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".de",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".dj",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".dk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".dm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".do",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".dz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ec",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".edu",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ee",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".eg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".er",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".es",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".et",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".eu",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".fi",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".fj",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".fk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".fm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".fo",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".fr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ga",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gb",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gd",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ge",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gf",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gh",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gi",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gl",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gov",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gp",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gq",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gs",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gt",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gu",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".gy",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".hk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".hm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".hn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".hr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ht",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".hu",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".id",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ie",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".il",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".im",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".in",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".info",          "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".int",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".io",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".iq",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ir",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".is",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".it",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".je",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".jm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".jo",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".jobs",          "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".jp",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ke",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".kg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".kh",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ki",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".km",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".kn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".kp",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".kr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".kw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ky",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".kz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".la",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".lb",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".lc",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".li",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".lk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".lr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ls",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".lt",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".lu",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".lv",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ly",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ma",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mc",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".md",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".me",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mh",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mil",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ml",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mo",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mobi",          "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mp",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mq",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ms",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mt",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mu",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".museum",        "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mv",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mx",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".my",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".mz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".na",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".name",          "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".nc",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ne",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".net",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".nf",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ng",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ni",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".nl",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".no",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".np",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".nr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".nu",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".nz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".om",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".org",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pa",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pe",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pf",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ph",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pl",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pro",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ps",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pt",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".pw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".py",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".qa",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".re",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ro",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".rs",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ru",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".rw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sa",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sb",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sc",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sd",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".se",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sh",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".si",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sj",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sl",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".so",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".st",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".su",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sv",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sx",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sy",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".sz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tc",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".td",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tel",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tf",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".th",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tj",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tl",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".to",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tp",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tr",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".travel",        "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tt",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tv",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".tz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ua",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ug",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".uk",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".us",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".uy",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".uz",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".va",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".vc",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ve",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".vg",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".vi",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".vn",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".vu",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".wf",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ws",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".xxx",           "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".ye",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".yt",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".za",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".zm",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	{ ".zw",            "http://",  url_tld_start,          url_tld_end,
-	  URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
-	/* Likely emails */
-	{ "@",              "mailto://",url_email_start,        url_email_end,
-	  URL_FLAG_NOHTML }
+		/* Common prefixes */
+		{ "file://",		"",			url_file_start, 		url_file_end,	0					},
+		{ "ftp://",			"",			url_web_start,	 		url_web_end,	0					},
+		{ "sftp://",		"",			url_web_start,	 		url_web_end,	0					},
+		{ "http://",		"",			url_web_start,	 		url_web_end,	0					},
+		{ "https://",		"",			url_web_start,	 		url_web_end,	0					},
+		{ "news://",		"",			url_web_start,	 		url_web_end,	0					},
+		{ "nntp://",		"",			url_web_start,	 		url_web_end,	0					},
+		{ "telnet://",		"",			url_web_start,	 		url_web_end,	0					},
+		{ "webcal://",		"",			url_web_start,	 		url_web_end,	0					},
+		{ "mailto://",		"",			url_email_start,	 	url_email_end,	0					},
+		{ "callto://",		"",			url_web_start,	 		url_web_end,	0					},
+		{ "h323:",			"",			url_web_start,	 		url_web_end,	0					},
+		{ "sip:",			"",			url_web_start,	 		url_web_end,	0					},
+		{ "www.",			"http://",	url_web_start,			url_web_end,	0					},
+		{ "ftp.",			"ftp://", 	url_web_start,	 		url_web_end,	URL_FLAG_NOHTML		},
+		/* TLD domains parts */
+		{ ".ac",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH },
+		{ ".ad",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ae",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".aero",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".af",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ag",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ai",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".al",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".am",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".an",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ao",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".aq",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ar",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".arpa",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".as",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".asia",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".at",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".au",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".aw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ax",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".az",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ba",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bb",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bd",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".be",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bf",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bh",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bi",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".biz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bj",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bo",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".br",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bs",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bt",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bv",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".by",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".bz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ca",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cat",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cc",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cd",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cf",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ch",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ci",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ck",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cl",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".co",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".com",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".coop",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cv",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cx",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cy",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".cz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".de",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".dj",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".dk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".dm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".do",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".dz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ec",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".edu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ee",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".eg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".er",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".es",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".et",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".eu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".fi",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".fj",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".fk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".fm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".fo",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".fr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ga",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gb",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gd",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ge",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gf",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gh",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gi",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gl",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gov",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gp",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gq",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gs",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gt",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".gy",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".hk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".hm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".hn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".hr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ht",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".hu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".id",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ie",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".il",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".im",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".in",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".info",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".int",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".io",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".iq",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ir",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".is",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".it",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".je",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".jm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".jo",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".jobs",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".jp",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ke",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".kg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".kh",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ki",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".km",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".kn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".kp",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".kr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".kw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ky",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".kz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".la",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".lb",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".lc",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".li",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".lk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".lr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ls",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".lt",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".lu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".lv",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ly",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ma",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mc",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".md",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".me",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mh",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mil",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ml",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mo",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mobi",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mp",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mq",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ms",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mt",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".museum",		"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mv",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mx",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".my",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".mz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".na",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".name",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".nc",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ne",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".net",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".nf",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ng",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ni",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".nl",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".no",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".np",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".nr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".nu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".nz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".om",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".org",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pa",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pe",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pf",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ph",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pl",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pro",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ps",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pt",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".pw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".py",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".qa",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".re",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ro",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".rs",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ru",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".rw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sa",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sb",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sc",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sd",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".se",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sh",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".si",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sj",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sl",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".so",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".st",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".su",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sv",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sx",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sy",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".sz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tc",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".td",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tel",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tf",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".th",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tj",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tl",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".to",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tp",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tr",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".travel",		"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tt",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tv",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".tz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ua",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ug",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".uk",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".us",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".uy",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".uz",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".va",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".vc",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ve",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".vg",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".vi",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".vn",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".vu",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".wf",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ws",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".xxx",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".ye",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".yt",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".za",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".zm",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		{ ".zw",			"http://",	url_tld_start,			url_tld_end,	URL_FLAG_NOHTML | URL_FLAG_STRICT_MATCH	},
+		/* Likely emails */
+		{ "@",				"mailto://",url_email_start,	 	url_email_end,	URL_FLAG_NOHTML	}
 };
 
 struct url_match_scanner {
@@ -695,7 +382,7 @@ struct url_match_scanner {
 
 struct url_match_scanner *url_scanner = NULL;
 
-static const struct _proto protocol_backends[] = {
+static const struct _proto      protocol_backends[] = {
 	{"file", 0, NULL, 1, 0, 0, 0},
 	{"ftp", 21, NULL, 1, 0, 0, 0},
 	{"http", 80, NULL, 1, 0, 0, 0},
@@ -708,8 +395,7 @@ static const struct _proto protocol_backends[] = {
 /* Convert an ASCII hex digit to the corresponding number between 0
    and 15.  H should be a hexadecimal digit that satisfies isxdigit;
    otherwise, the result is undefined.  */
-#define XDIGIT_TO_NUM(h) ((h) < 'A' ? (h) - '0' : g_ascii_toupper (h) - 'A' + \
-	10)
+#define XDIGIT_TO_NUM(h) ((h) < 'A' ? (h) - '0' : g_ascii_toupper (h) - 'A' + 10)
 #define X2DIGITS_TO_NUM(h1, h2) ((XDIGIT_TO_NUM (h1) << 4) + XDIGIT_TO_NUM (h2))
 /* The reverse of the above: convert a number in the [0, 16) range to
    the ASCII representation of the corresponding hexadecimal digit.
@@ -718,47 +404,45 @@ static const struct _proto protocol_backends[] = {
 #define XNUM_TO_digit(x) ("0123456789abcdef"[x] + 0)
 
 static guchar url_scanner_table[256] = {
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  9,  9,  1,  1,  9,  1,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-	24,128,160,128,128,128,128,128,160,160,128,128,160,192,160,160,
-	68, 68, 68, 68, 68, 68, 68, 68, 68, 68,160,160, 32,128, 32,128,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  9,  9,  1,  1,  9,  1,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+	 24,128,160,128,128,128,128,128,160,160,128,128,160,192,160,160,
+	 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,160,160, 32,128, 32,128,
 	160, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-	66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,160,160,160,128,192,
+	 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,160,160,160,128,192,
 	128, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-	66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,128,128,128,128,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1
+	 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,128,128,128,128,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+	  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1
 };
 
 enum {
-	IS_CTRL     = (1 << 0),
-	IS_ALPHA        = (1 << 1),
-	IS_DIGIT        = (1 << 2),
-	IS_LWSP     = (1 << 3),
-	IS_SPACE        = (1 << 4),
-	IS_SPECIAL      = (1 << 5),
-	IS_DOMAIN       = (1 << 6),
-	IS_URLSAFE      = (1 << 7)
+	IS_CTRL		= (1 << 0),
+	IS_ALPHA		= (1 << 1),
+	IS_DIGIT		= (1 << 2),
+	IS_LWSP		= (1 << 3),
+	IS_SPACE		= (1 << 4),
+	IS_SPECIAL		= (1 << 5),
+	IS_DOMAIN		= (1 << 6),
+	IS_URLSAFE		= (1 << 7)
 };
 
 #define is_ctrl(x) ((url_scanner_table[(guchar)(x)] & IS_CTRL) != 0)
 #define is_lwsp(x) ((url_scanner_table[(guchar)(x)] & IS_LWSP) != 0)
-#define is_atom(x) ((url_scanner_table[(guchar)(x)] & (IS_SPECIAL | IS_SPACE | \
-	IS_CTRL)) == 0)
+#define is_atom(x) ((url_scanner_table[(guchar)(x)] & (IS_SPECIAL|IS_SPACE|IS_CTRL)) == 0)
 #define is_alpha(x) ((url_scanner_table[(guchar)(x)] & IS_ALPHA) != 0)
 #define is_digit(x) ((url_scanner_table[(guchar)(x)] & IS_DIGIT) != 0)
 #define is_domain(x) ((url_scanner_table[(guchar)(x)] & IS_DOMAIN) != 0)
-#define is_urlsafe(x) ((url_scanner_table[(guchar)(x)] & (IS_ALPHA | IS_DIGIT | \
-	IS_URLSAFE)) != 0)
+#define is_urlsafe(x) ((url_scanner_table[(guchar)(x)] & (IS_ALPHA|IS_DIGIT|IS_URLSAFE)) != 0)
 
 
-const gchar *
+const gchar              *
 url_strerror (enum uri_errno err)
 {
 	switch (err) {
@@ -793,7 +477,7 @@ url_strerror (enum uri_errno err)
 static gint
 check_uri_file (gchar *name)
 {
-	static const gchar chars[] = POST_CHAR_S "#?";
+	static const gchar      chars[] = POST_CHAR_S "#?";
 
 	return strcspn (name, chars);
 }
@@ -801,41 +485,30 @@ check_uri_file (gchar *name)
 static gint
 url_init (void)
 {
-	guint i;
-	gchar patbuf[128];
+	guint                            i;
+	gchar                            patbuf[128];
 
 	if (url_scanner == NULL) {
 		url_scanner = g_malloc (sizeof (struct url_match_scanner));
 		url_scanner->matchers = matchers;
 		url_scanner->matchers_count = G_N_ELEMENTS (matchers);
 		url_scanner->patterns = rspamd_trie_create (TRUE);
-		for (i = 0; i < url_scanner->matchers_count; i++) {
+		for (i = 0; i < url_scanner->matchers_count; i ++) {
 			if (matchers[i].flags & URL_FLAG_STRICT_MATCH) {
 				/* Insert more specific patterns */
 
 				/* some.tld/ */
-				rspamd_snprintf (patbuf,
-					sizeof (patbuf),
-					"%s/",
-					matchers[i].pattern);
+				rspamd_snprintf (patbuf, sizeof (patbuf), "%s/", matchers[i].pattern);
 				rspamd_trie_insert (url_scanner->patterns, patbuf, i);
 				/* some.tld  */
-				rspamd_snprintf (patbuf,
-					sizeof (patbuf),
-					"%s ",
-					matchers[i].pattern);
+				rspamd_snprintf (patbuf, sizeof (patbuf), "%s ", matchers[i].pattern);
 				rspamd_trie_insert (url_scanner->patterns, patbuf, i);
 				/* some.tld: */
-				rspamd_snprintf (patbuf,
-					sizeof (patbuf),
-					"%s:",
-					matchers[i].pattern);
+				rspamd_snprintf (patbuf, sizeof (patbuf), "%s:", matchers[i].pattern);
 				rspamd_trie_insert (url_scanner->patterns, patbuf, i);
 			}
 			else {
-				rspamd_trie_insert (url_scanner->patterns,
-					matchers[i].pattern,
-					i);
+				rspamd_trie_insert (url_scanner->patterns, matchers[i].pattern, i);
 			}
 		}
 	}
@@ -849,10 +522,10 @@ get_protocol (gchar *name, gint namelen)
 	/* These are really enum protocol values but can take on negative
 	 * values and since 0 <= -1 for enum values it's better to use clean
 	 * integer type. */
-	gint start, end;
-	enum protocol protocol;
-	guchar *pname;
-	gint pnamelen, minlen, compare;
+	gint                            start, end;
+	enum protocol                   protocol;
+	guchar                          *pname;
+	gint                            pnamelen, minlen, compare;
 
 	/* Almost dichotomic search is used here */
 	/* Starting at the HTTP entry which is the most common that will make
@@ -917,7 +590,7 @@ get_protocol_free_syntax (enum protocol protocol)
 static gint
 get_protocol_length (const gchar *url)
 {
-	gchar *end = (gchar *)url;
+	gchar                          *end = (gchar *)url;
 
 	/* Seek the end of the protocol name if any. */
 	/* RFC1738:
@@ -937,12 +610,11 @@ get_protocol_length (const gchar *url)
 static guint
 url_calculate_escaped_hostlen (gchar *host, guint hostlen)
 {
-	guint i, result = hostlen;
-	gchar *p = host, c;
+	guint                           i, result = hostlen;
+	gchar                           *p = host, c;
 
 	for (i = 0; i < hostlen; i++, p++) {
-		if (*p == '%' && g_ascii_isxdigit (*(p + 1)) &&
-			g_ascii_isxdigit (*(p + 2)) && i < hostlen - 2) {
+		if (*p == '%' && g_ascii_isxdigit (*(p + 1)) && g_ascii_isxdigit (*(p + 2)) && i < hostlen - 2) {
 			c = X2DIGITS_TO_NUM (*(p + 1), *(p + 2));
 			if (c != '\0') {
 				result -= 2;
@@ -965,19 +637,18 @@ url_calculate_escaped_hostlen (gchar *host, guint hostlen)
 static void
 url_unescape (gchar *s)
 {
-	gchar *t = s;                           /* t - tortoise */
-	gchar *h = s;                           /* h - hare     */
+	gchar                           *t = s;	/* t - tortoise */
+	gchar                           *h = s;	/* h - hare     */
 
 	for (; *h; h++, t++) {
 		if (*h != '%') {
-copychar:
+		  copychar:
 			*t = *h;
 		}
 		else {
-			gchar c;
+			gchar                           c;
 			/* Do nothing if '%' is not followed by two hex digits. */
-			if (!h[1] || !h[2] ||
-				!(g_ascii_isxdigit (h[1]) && g_ascii_isxdigit (h[2])))
+			if (!h[1] || !h[2] || !(g_ascii_isxdigit (h[1]) && g_ascii_isxdigit (h[2])))
 				goto copychar;
 			c = X2DIGITS_TO_NUM (h[1], h[2]);
 			/* Don't unescape %00 because there is no way to insert it
@@ -994,8 +665,8 @@ copychar:
 static void
 url_strip (gchar *s)
 {
-	gchar *t = s;                           /* t - tortoise */
-	gchar *h = s;                           /* h - hare     */
+	gchar                           *t = s;	/* t - tortoise */
+	gchar                           *h = s;	/* h - hare     */
 
 	while (*h) {
 		if (g_ascii_isgraph (*h)) {
@@ -1007,17 +678,17 @@ url_strip (gchar *s)
 	*t = '\0';
 }
 
-static gchar *
+static gchar                    *
 url_escape_1 (const gchar *s, gint allow_passthrough, rspamd_mempool_t * pool)
 {
-	const gchar *p1;
-	gchar *p2, *newstr;
-	gint newlen;
-	gint addition = 0;
+	const gchar                     *p1;
+	gchar                           *p2, *newstr;
+	gint                            newlen;
+	gint                            addition = 0;
 
 	for (p1 = s; *p1; p1++)
 		if (!is_urlsafe (*p1)) {
-			addition += 2;      /* Two more characters (hex digits) */
+			addition += 2;		/* Two more characters (hex digits) */
 		}
 
 	if (!addition) {
@@ -1037,7 +708,7 @@ url_escape_1 (const gchar *s, gint allow_passthrough, rspamd_mempool_t * pool)
 	while (*p1) {
 		/* Quote the characters that match the test mask. */
 		if (!is_urlsafe (*p1)) {
-			guchar c = *p1++;
+			guchar                          c = *p1++;
 			*p2++ = '%';
 			*p2++ = XNUM_TO_DIGIT (c >> 4);
 			*p2++ = XNUM_TO_DIGIT (c & 0xf);
@@ -1053,7 +724,7 @@ url_escape_1 (const gchar *s, gint allow_passthrough, rspamd_mempool_t * pool)
 /* URL-escape the unsafe characters (see urlchr_table) in a given
    string, returning a freshly allocated string.  */
 
-gchar *
+gchar                           *
 url_escape (const gchar *s, rspamd_mempool_t * pool)
 {
 	return url_escape_1 (s, 0, pool);
@@ -1076,7 +747,7 @@ char_needs_escaping (const gchar *p)
 			return TRUE;
 		}
 	}
-	else if (!is_urlsafe (*p)) {
+	else if (! is_urlsafe (*p)) {
 		return TRUE;
 	}
 	return FALSE;
@@ -1084,16 +755,16 @@ char_needs_escaping (const gchar *p)
 
 /* Translate a %-escaped (but possibly non-conformant) input string S
    into a %-escaped (and conformant) output string.
- */
+*/
 
-static gchar *
+static gchar                    *
 reencode_escapes (gchar *s, rspamd_mempool_t * pool)
 {
-	const gchar *p1;
-	gchar *newstr, *p2;
-	gint oldlen, newlen;
+	const gchar                     *p1;
+	gchar                           *newstr, *p2;
+	gint                            oldlen, newlen;
 
-	gint encode_count = 0;
+	gint                            encode_count = 0;
 
 	/* First pass: inspect the string to see if there's anything to do,
 	   and to calculate the new length.  */
@@ -1118,7 +789,7 @@ reencode_escapes (gchar *s, rspamd_mempool_t * pool)
 
 	while (*p1)
 		if (char_needs_escaping (p1)) {
-			guchar c = *p1++;
+			guchar                          c = *p1++;
 			*p2++ = '%';
 			*p2++ = XNUM_TO_DIGIT (c >> 4);
 			*p2++ = XNUM_TO_DIGIT (c & 0xf);
@@ -1138,10 +809,10 @@ reencode_escapes (gchar *s, rspamd_mempool_t * pool)
 static void
 unescape_single_char (gchar *str, gchar chr)
 {
-	const gchar c1 = XNUM_TO_DIGIT (chr >> 4);
-	const gchar c2 = XNUM_TO_DIGIT (chr & 0xf);
-	gchar *h = str;                             /* hare */
-	gchar *t = str;                             /* tortoise */
+	const gchar                      c1 = XNUM_TO_DIGIT (chr >> 4);
+	const gchar                      c2 = XNUM_TO_DIGIT (chr & 0xf);
+	gchar                           *h = str;	/* hare */
+	gchar                           *t = str;	/* tortoise */
 
 	for (; *h; h++, t++) {
 		if (h[0] == '%' && h[1] == c1 && h[2] == c2) {
@@ -1164,10 +835,10 @@ unescape_single_char (gchar *str, gchar chr)
 static gboolean
 path_simplify (gchar *path)
 {
-	gchar *h = path;                            /* hare */
-	gchar *t = path;                            /* tortoise */
-	gchar *beg = path;                              /* boundary for backing the tortoise */
-	gchar *end = path + strlen (path);
+	gchar                           *h = path;	/* hare */
+	gchar                           *t = path;	/* tortoise */
+	gchar                           *beg = path;	/* boundary for backing the tortoise */
+	gchar                           *end = path + strlen (path);
 
 	while (h < end) {
 		/* Hare should be at the beginning of a path element. */
@@ -1181,7 +852,7 @@ path_simplify (gchar *path)
 			if (t > beg) {
 				/* Move backwards until T hits the beginning of the
 				   previous path element or the beginning of path. */
-				for (--t; t > beg && t[-1] != '/'; t--) ;
+				for (--t; t > beg && t[-1] != '/'; t--);
 			}
 			else {
 				/* If we're at the beginning, copy the "../" literally
@@ -1193,7 +864,7 @@ path_simplify (gchar *path)
 			h += 3;
 		}
 		else {
-regular:
+		  regular:
 			/* A regular path element.  If H hasn't advanced past T,
 			   simply skip to the next path element.  Otherwise, copy
 			   the path element until the next slash.  */
@@ -1223,10 +894,10 @@ regular:
 enum uri_errno
 parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
 {
-	guchar *prefix_end, *host_end, *p;
-	guchar *lbracket, *rbracket;
-	gint datalen, n, addrlen;
-	guchar *frag_or_post, *user_end, *port_end;
+	guchar                          *prefix_end, *host_end, *p;
+	guchar                          *lbracket, *rbracket;
+	gint                            datalen, n, addrlen;
+	guchar                          *frag_or_post, *user_end, *port_end;
 
 	memset (uri, 0, sizeof (*uri));
 
@@ -1239,13 +910,11 @@ parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
 	uri->protocollen = get_protocol_length (struri (uri));
 
 	/* Assume http as default protocol */
-	if (!uri->protocollen ||
-		(uri->protocol =
-		get_protocol (struri (uri), uri->protocollen)) == PROTOCOL_UNKNOWN) {
+	if (!uri->protocollen || (uri->protocol = get_protocol (struri (uri), uri->protocollen)) == PROTOCOL_UNKNOWN) {
 		/* Make exception for numeric urls */
 		p = uri->string;
 		while (*p && (g_ascii_isalnum (*p) || *p == ':')) {
-			p++;
+			p ++;
 		}
 		if (*p == '\0') {
 			return URI_ERRNO_INVALID_PROTOCOL;
@@ -1260,7 +929,7 @@ parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
 		/* Figure out whether the protocol is known */
 		msg_debug ("getting protocol from url: %d", uri->protocol);
 
-		prefix_end = struri (uri) + uri->protocollen;   /* ':' */
+		prefix_end = struri (uri) + uri->protocollen;	/* ':' */
 
 		/* Check if there's a digit after the protocol name. */
 		if (g_ascii_isdigit (*prefix_end)) {
@@ -1341,7 +1010,7 @@ parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
 	/* Possibly skip auth part */
 	host_end = prefix_end + strcspn (prefix_end, "@");
 
-	if (prefix_end + strcspn (prefix_end, "/?") > host_end && *host_end) {  /* we have auth info here */
+	if (prefix_end + strcspn (prefix_end, "/?") > host_end && *host_end) {	/* we have auth info here */
 
 		/* Allow '@' in the password component */
 		while (strcspn (host_end + 1, "@") < strcspn (host_end + 1, "/?"))
@@ -1385,7 +1054,7 @@ parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
 			return URI_ERRNO_TRAILING_DOTS;
 	}
 
-	if (*host_end == ':') {     /* we have port here */
+	if (*host_end == ':') {		/* we have port here */
 		port_end = host_end + 1 + strcspn (host_end + 1, "/");
 
 		host_end++;
@@ -1420,8 +1089,7 @@ parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
 		host_end++;
 
 	}
-	else if (get_protocol_need_slash_after_host (uri->protocol) && *host_end !=
-		'?') {
+	else if (get_protocol_need_slash_after_host (uri->protocol) && *host_end != '?') {
 		/* The need for slash after the host component depends on the
 		 * need for a host component. -- The dangerous mind of Jonah */
 		if (!uri->hostlen)
@@ -1446,7 +1114,7 @@ parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
 	}
 
 	convert_to_lowercase (uri->string, uri->protocollen);
-	convert_to_lowercase (uri->host,   uri->hostlen);
+	convert_to_lowercase (uri->host, uri->hostlen);
 	/* Decode %HH sequences in host name.  This is important not so much
 	   to support %HH sequences in host names (which other browser
 	   don't), but to support binary characters (which will have been
@@ -1464,12 +1132,12 @@ parse_uri (struct uri *uri, gchar *uristring, rspamd_mempool_t * pool)
 }
 
 static const gchar url_braces[] = {
-	'(', ')',
-	'{', '}',
-	'[', ']',
-	'<', '>',
-	'|', '|',
-	'\'', '\''
+	 '(', ')' ,
+	 '{', '}' ,
+	 '[', ']' ,
+	 '<', '>' ,
+	 '|', '|' ,
+	 '\'', '\''
 };
 
 static gboolean
@@ -1488,28 +1156,22 @@ is_open_brace (gchar c)
 }
 
 static gboolean
-url_file_start (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match)
+url_file_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
 {
 	match->m_begin = pos;
 	return TRUE;
 }
 static gboolean
-url_file_end (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match)
+url_file_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
 {
-	const gchar *p;
-	gchar stop;
-	guint i;
+	const gchar                    *p;
+	gchar                           stop;
+	guint                           i;
 
 	p = pos + strlen (match->pattern);
 	stop = *p;
 	if (*p == '/') {
-		p++;
+		p ++;
 	}
 
 	for (i = 0; i < G_N_ELEMENTS (url_braces) / 2; i += 2) {
@@ -1520,7 +1182,7 @@ url_file_end (const gchar *begin,
 	}
 
 	while (p < end && *p != stop && is_urlsafe (*p)) {
-		p++;
+		p ++;
 	}
 
 	if (p == begin) {
@@ -1533,18 +1195,14 @@ url_file_end (const gchar *begin,
 }
 
 static gboolean
-url_tld_start (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match)
+url_tld_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
 {
-	const gchar *p = pos;
+	const gchar						*p = pos;
 
 	/* Try to find the start of the url by finding any non-urlsafe character or whitespace/punctuation */
 	while (p >= begin) {
-		if ((!is_domain (*p) && *p != '.' &&
-			*p != '/') || g_ascii_isspace (*p)) {
-			p++;
+		if ((!is_domain (*p) && *p != '.' && *p != '/') || g_ascii_isspace (*p)) {
+			p ++;
 			if (!g_ascii_isalnum (*p)) {
 				/* Urls cannot start with strange symbols */
 				return FALSE;
@@ -1570,19 +1228,16 @@ url_tld_start (const gchar *begin,
 			/* Urls cannot contain '/' in their body */
 			return FALSE;
 		}
-		p--;
+		p --;
 	}
 
 	return FALSE;
 }
 
 static gboolean
-url_tld_end (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match)
+url_tld_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
 {
-	const gchar *p;
+	const gchar						*p;
 
 	/* A url must be finished by tld, so it must be followed by space character */
 	p = pos + strlen (match->pattern);
@@ -1595,10 +1250,7 @@ url_tld_end (const gchar *begin,
 		p = match->m_begin;
 		/* Check common prefix */
 		if (g_ascii_strncasecmp (p, "http://", sizeof ("http://") - 1) == 0) {
-			return url_web_end (begin,
-					   end,
-					   match->m_begin + sizeof ("http://") - 1,
-					   match);
+			return url_web_end (begin, end, match->m_begin + sizeof ("http://") - 1, match);
 		}
 		else {
 			return url_web_end (begin, end, match->m_begin, match);
@@ -1609,15 +1261,10 @@ url_tld_end (const gchar *begin,
 }
 
 static gboolean
-url_web_start (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match)
+url_web_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
 {
 	/* Check what we have found */
-	if (pos > begin &&
-		(g_ascii_strncasecmp (pos, "www",
-		3) == 0 || g_ascii_strncasecmp (pos, "ftp", 3) == 0)) {
+	if (pos > begin && (g_ascii_strncasecmp (pos, "www", 3) == 0 || g_ascii_strncasecmp (pos, "ftp", 3) == 0)) {
 		if (!is_open_brace (*(pos - 1)) && !g_ascii_isspace (*(pos - 1))) {
 			return FALSE;
 		}
@@ -1632,16 +1279,13 @@ url_web_start (const gchar *begin,
 }
 
 static gboolean
-url_web_end (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match)
+url_web_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
 {
-	const gchar *p, *c;
-	gchar open_brace = '\0', close_brace = '\0';
-	gint brace_stack = 0;
-	gboolean passwd = FALSE;
-	guint port, i;
+	const gchar                    *p, *c;
+	gchar                           open_brace = '\0', close_brace = '\0';
+	gint                            brace_stack = 0;
+	gboolean                        passwd = FALSE;
+	guint                           port, i;
 
 	p = pos + strlen (match->pattern);
 	for (i = 0; i < G_N_ELEMENTS (url_braces) / 2; i += 2) {
@@ -1667,8 +1311,7 @@ url_web_end (const gchar *begin,
 				p++;
 			}
 
-			if ((p + 1) < end && *p == '.' &&
-				(is_atom (*(p + 1)) || *(p + 1) == '/')) {
+			if ((p + 1) < end && *p == '.' && (is_atom (*(p + 1)) || *(p + 1) == '/')) {
 				p++;
 			}
 		}
@@ -1695,9 +1338,7 @@ domain:
 				p++;
 			}
 
-			if ((p + 1) < end && *p == '.' &&
-				(is_domain (*(p + 1)) || *(p + 1) == '/' ||
-				(*(p + 1) & 0x80))) {
+			if ((p + 1) < end && *p == '.' && (is_domain (*(p + 1)) || *(p + 1) == '/' || (*(p + 1) & 0x80))) {
 				p++;
 			}
 		}
@@ -1731,7 +1372,7 @@ domain:
 				}
 			}
 			else {
-passwd:
+				passwd:
 				passwd = TRUE;
 				c = p;
 
@@ -1755,7 +1396,7 @@ passwd:
 				break;
 			}
 
-		/* we have a '/' so there could be a path - fall through */
+			/* we have a '/' so there could be a path - fall through */
 		case '/': /* we've detected a path component to our url */
 			p++;
 		case '?':
@@ -1793,18 +1434,15 @@ passwd:
 
 
 static gboolean
-url_email_start (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match)
+url_email_start (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
 {
-	const gchar *p;
+	const gchar                    *p;
 	/* Check what we have found */
 	if (pos > begin && *pos == '@') {
 		/* Try to extract it with username */
 		p = pos - 1;
 		while (p > begin && (is_domain (*p) || *p == '.' || *p == '_')) {
-			p--;
+			p --;
 		}
 		if (!is_domain (*p) && p != pos - 1) {
 			match->m_begin = p + 1;
@@ -1826,13 +1464,10 @@ url_email_start (const gchar *begin,
 }
 
 static gboolean
-url_email_end (const gchar *begin,
-	const gchar *end,
-	const gchar *pos,
-	url_match_t *match)
+url_email_end (const gchar *begin, const gchar *end, const gchar *pos, url_match_t *match)
 {
-	const gchar *p;
-	gboolean got_at = FALSE;
+	const gchar                    *p;
+	gboolean                         got_at = FALSE;
 
 	p = pos + strlen (match->pattern);
 	if (*pos == '@') {
@@ -1840,12 +1475,12 @@ url_email_end (const gchar *begin,
 	}
 
 	while (p < end && (is_domain (*p) || *p == '_'
-		|| (*p == '@' && !got_at) ||
-		(*p == '.' && p + 1 < end && is_domain (*(p + 1))))) {
+			|| (*p == '@' && !got_at) ||
+			(*p == '.' && p + 1 < end && is_domain (*(p + 1))))) {
 		if (*p == '@') {
 			got_at = TRUE;
 		}
-		p++;
+		p ++;
 	}
 	match->m_len = p - match->m_begin;
 	match->add_prefix = TRUE;
@@ -1853,16 +1488,13 @@ url_email_end (const gchar *begin,
 }
 
 void
-url_parse_text (rspamd_mempool_t * pool,
-	struct rspamd_task *task,
-	struct mime_text_part *part,
-	gboolean is_html)
+url_parse_text (rspamd_mempool_t * pool, struct rspamd_task *task, struct mime_text_part *part, gboolean is_html)
 {
-	gint rc;
-	gchar *url_str = NULL, *url_start, *url_end;
-	struct uri *new;
-	struct process_exception *ex;
-	gchar *p, *end, *begin;
+	gint                            rc;
+	gchar                          *url_str = NULL, *url_start, *url_end;
+	struct uri                     *new;
+	struct process_exception       *ex;
+	gchar                          *p, *end, *begin;
 
 
 	if (!part->orig->data || part->orig->len == 0) {
@@ -1882,19 +1514,15 @@ url_parse_text (rspamd_mempool_t * pool,
 			p = begin;
 		}
 		while (p < end) {
-			if (url_try_text (pool, p, end - p, &url_start, &url_end, &url_str,
-				is_html)) {
+			if (url_try_text (pool, p, end - p, &url_start, &url_end, &url_str, is_html)) {
 				if (url_str != NULL) {
 					new = rspamd_mempool_alloc0 (pool, sizeof (struct uri));
-					ex =
-						rspamd_mempool_alloc0 (pool,
-							sizeof (struct process_exception));
+					ex = rspamd_mempool_alloc0 (pool, sizeof (struct process_exception));
 					if (new != NULL) {
 						g_strstrip (url_str);
 						rc = parse_uri (new, url_str, pool);
-						if ((rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES ||
-							rc == URI_ERRNO_NO_HOST_SLASH) &&
-							new->hostlen > 0) {
+						if ((rc == URI_ERRNO_OK || rc == URI_ERRNO_NO_SLASHES || rc == URI_ERRNO_NO_HOST_SLASH) &&
+								new->hostlen > 0) {
 							ex->pos = url_start - begin;
 							ex->len = url_end - url_start;
 							if (new->protocol == PROTOCOL_MAILTO) {
@@ -1909,14 +1537,10 @@ url_parse_text (rspamd_mempool_t * pool,
 									g_tree_insert (task->urls, new, new);
 								}
 							}
-							part->urls_offset = g_list_prepend (
-								part->urls_offset,
-								ex);
+							part->urls_offset = g_list_prepend (part->urls_offset, ex);
 						}
 						else if (rc != URI_ERRNO_OK) {
-							msg_info ("extract of url '%s' failed: %s",
-								url_str,
-								url_strerror (rc));
+							msg_info ("extract of url '%s' failed: %s", url_str, url_strerror (rc));
 						}
 					}
 				}
@@ -1930,30 +1554,21 @@ url_parse_text (rspamd_mempool_t * pool,
 	/* Handle offsets of this part */
 	if (part->urls_offset != NULL) {
 		part->urls_offset = g_list_reverse (part->urls_offset);
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t)g_list_free, part->urls_offset);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, part->urls_offset);
 	}
 }
 
 gboolean
-url_try_text (rspamd_mempool_t *pool,
-	const gchar *begin,
-	gsize len,
-	gchar **start,
-	gchar **fin,
-	gchar **url_str,
-	gboolean is_html)
+url_try_text (rspamd_mempool_t *pool, const gchar *begin, gsize len, gchar **start, gchar **fin, gchar **url_str, gboolean is_html)
 {
-	const gchar *end, *pos;
-	gint idx, l;
-	struct url_matcher *matcher;
-	url_match_t m;
+	const gchar                    *end, *pos;
+	gint                            idx, l;
+	struct url_matcher             *matcher;
+	url_match_t                     m;
 
 	end = begin + len;
 	if (url_init () == 0) {
-		if ((pos =
-			rspamd_trie_lookup (url_scanner->patterns, begin, len,
-			&idx)) == NULL) {
+		if ((pos = rspamd_trie_lookup (url_scanner->patterns, begin, len, &idx)) == NULL) {
 			return FALSE;
 		}
 		else {
@@ -1965,17 +1580,11 @@ url_try_text (rspamd_mempool_t *pool,
 			m.pattern = matcher->pattern;
 			m.prefix = matcher->prefix;
 			m.add_prefix = FALSE;
-			if (matcher->start (begin, end, pos,
-				&m) && matcher->end (begin, end, pos, &m)) {
+			if (matcher->start (begin, end, pos, &m) && matcher->end (begin, end, pos, &m)) {
 				if (m.add_prefix) {
 					l = m.m_len + 1 + strlen (m.prefix);
 					*url_str = rspamd_mempool_alloc (pool, l);
-					rspamd_snprintf (*url_str,
-						l,
-						"%s%*s",
-						m.prefix,
-						m.m_len,
-						m.m_begin);
+					rspamd_snprintf (*url_str, l, "%s%*s", m.prefix, m.m_len, m.m_begin);
 				}
 				else {
 					*url_str = rspamd_mempool_alloc (pool, m.m_len + 1);
diff --git a/src/libserver/url.h b/src/libserver/url.h
index d8877f279..60535ba5c 100644
--- a/src/libserver/url.h
+++ b/src/libserver/url.h
@@ -43,24 +43,24 @@ struct uri {
 	guint fragmentlen;
 
 	/* Flags */
-	gboolean ipv6;  /* URI contains IPv6 host */
-	gboolean form;  /* URI originated from form */
+	gboolean ipv6;	/* URI contains IPv6 host */
+	gboolean form;	/* URI originated from form */
 	gboolean is_phished; /* URI maybe phishing */
 };
 
 enum uri_errno {
-	URI_ERRNO_OK,           /* Parsing went well */
-	URI_ERRNO_EMPTY,        /* The URI string was empty */
-	URI_ERRNO_INVALID_PROTOCOL, /* No protocol was found */
-	URI_ERRNO_NO_SLASHES,       /* Slashes after protocol missing */
-	URI_ERRNO_TOO_MANY_SLASHES, /* Too many slashes after protocol */
-	URI_ERRNO_TRAILING_DOTS,    /* '.' after host */
-	URI_ERRNO_NO_HOST,      /* Host part is missing */
-	URI_ERRNO_NO_PORT_COLON,    /* ':' after host without port */
-	URI_ERRNO_NO_HOST_SLASH,    /* Slash after host missing */
-	URI_ERRNO_IPV6_SECURITY,    /* IPv6 security bug detected */
-	URI_ERRNO_INVALID_PORT,     /* Port number is bad */
-	URI_ERRNO_INVALID_PORT_RANGE    /* Port number is not within 0-65535 */
+	URI_ERRNO_OK,			/* Parsing went well */
+	URI_ERRNO_EMPTY,		/* The URI string was empty */
+	URI_ERRNO_INVALID_PROTOCOL,	/* No protocol was found */
+	URI_ERRNO_NO_SLASHES,		/* Slashes after protocol missing */
+	URI_ERRNO_TOO_MANY_SLASHES,	/* Too many slashes after protocol */
+	URI_ERRNO_TRAILING_DOTS,	/* '.' after host */
+	URI_ERRNO_NO_HOST,		/* Host part is missing */
+	URI_ERRNO_NO_PORT_COLON,	/* ':' after host without port */
+	URI_ERRNO_NO_HOST_SLASH,	/* Slash after host missing */
+	URI_ERRNO_IPV6_SECURITY,	/* IPv6 security bug detected */
+	URI_ERRNO_INVALID_PORT,		/* Port number is bad */
+	URI_ERRNO_INVALID_PORT_RANGE	/* Port number is not within 0-65535 */
 };
 
 enum protocol {
@@ -81,10 +81,7 @@ enum protocol {
  * @param part current text part
  * @param is_html turn on html euristic
  */
-void url_parse_text (rspamd_mempool_t *pool,
-	struct rspamd_task *task,
-	struct mime_text_part *part,
-	gboolean is_html);
+void url_parse_text (rspamd_mempool_t *pool, struct rspamd_task *task, struct mime_text_part *part, gboolean is_html);
 
 /*
  * Parse a single url into an uri structure
@@ -92,9 +89,7 @@ void url_parse_text (rspamd_mempool_t *pool,
  * @param uristring text form of url
  * @param uri url object, must be pre allocated
  */
-enum uri_errno parse_uri (struct uri *uri,
-	gchar *uristring,
-	rspamd_mempool_t *pool);
+enum uri_errno parse_uri(struct uri *uri, gchar *uristring, rspamd_mempool_t *pool);
 
 /*
  * Try to extract url from a text
@@ -106,17 +101,11 @@ enum uri_errno parse_uri (struct uri *uri,
  * @param url_str storage for url string(or NULL)
  * @return TRUE if url is found in specified text
  */
-gboolean url_try_text (rspamd_mempool_t *pool,
-	const gchar *begin,
-	gsize len,
-	gchar **start,
-	gchar **end,
-	gchar **url_str,
-	gboolean is_html);
+gboolean url_try_text (rspamd_mempool_t *pool, const gchar *begin, gsize len, gchar **start, gchar **end, gchar **url_str, gboolean is_html);
 
 /*
  * Return text representation of url parsing error
  */
-const gchar * url_strerror (enum uri_errno err);
+const gchar* url_strerror (enum uri_errno err);
 
 #endif
diff --git a/src/libserver/worker_util.c b/src/libserver/worker_util.c
index 075e499ec..74a83cb70 100644
--- a/src/libserver/worker_util.c
+++ b/src/libserver/worker_util.c
@@ -22,28 +22,28 @@
  */
 
 #include "config.h"
-#include "lua/lua_common.h"
 #include "main.h"
 #include "message.h"
+#include "lua/lua_common.h"
 
-extern struct rspamd_main *rspamd_main;
+extern struct rspamd_main			*rspamd_main;
 
 /**
  * Return worker's control structure by its type
  * @param type
  * @return worker's control structure or NULL
  */
-worker_t *
+worker_t*
 rspamd_get_worker_by_type (GQuark type)
 {
-	worker_t **cur;
+	worker_t						**cur;
 
 	cur = &workers[0];
 	while (*cur) {
 		if (g_quark_from_string ((*cur)->name) == type) {
 			return *cur;
 		}
-		cur++;
+		cur ++;
 	}
 
 	return NULL;
@@ -52,21 +52,18 @@ rspamd_get_worker_by_type (GQuark type)
 double
 rspamd_set_counter (const gchar *name, guint32 value)
 {
-	struct counter_data *cd;
-	double alpha;
-	gchar *key;
+	struct counter_data            *cd;
+	double                          alpha;
+	gchar                           *key;
 
 	cd = rspamd_hash_lookup (rspamd_main->counters, (gpointer) name);
 
 	if (cd == NULL) {
-		cd =
-			rspamd_mempool_alloc_shared (rspamd_main->counters->pool,
-				sizeof (struct counter_data));
+		cd = rspamd_mempool_alloc_shared (rspamd_main->counters->pool, sizeof (struct counter_data));
 		cd->value = value;
 		cd->number = 0;
 		key = rspamd_mempool_strdup_shared (rspamd_main->counters->pool, name);
-		rspamd_hash_insert (rspamd_main->counters, (gpointer) key,
-			(gpointer) cd);
+		rspamd_hash_insert (rspamd_main->counters, (gpointer) key, (gpointer) cd);
 	}
 	else {
 		/* Calculate new value */
@@ -91,7 +88,7 @@ static void
 worker_sig_handler (gint signo, siginfo_t * info, void *unused)
 #endif
 {
-	struct timeval tv;
+	struct timeval                  tv;
 
 	switch (signo) {
 	case SIGINT:
@@ -116,9 +113,9 @@ worker_sig_handler (gint signo, siginfo_t * info, void *unused)
 static void
 worker_sigusr2_handler (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+	struct rspamd_worker           *worker = (struct rspamd_worker *) arg;
 	/* Do not accept new connections, preparing to end worker's process */
-	struct timeval tv;
+	struct timeval                  tv;
 
 	if (!wanna_die) {
 		tv.tv_sec = SOFT_SHUTDOWN_TIME;
@@ -138,7 +135,7 @@ worker_sigusr2_handler (gint fd, short what, void *arg)
 static void
 worker_sigusr1_handler (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+	struct rspamd_worker           *worker = (struct rspamd_worker *) arg;
 
 	reopen_log (worker->srv->logger);
 
@@ -147,16 +144,16 @@ worker_sigusr1_handler (gint fd, short what, void *arg)
 
 struct event_base *
 rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
-	void (*accept_handler)(int, short, void *))
+		void (*accept_handler)(int, short, void *))
 {
-	struct event_base *ev_base;
-	struct event *accept_event;
-	struct sigaction signals;
-	GList *cur;
-	gint listen_socket;
+	struct event_base                *ev_base;
+	struct event                     *accept_event;
+	struct sigaction                  signals;
+	GList                             *cur;
+	gint                               listen_socket;
 
 #ifdef WITH_PROFILER
-	extern void _start (void), etext (void);
+	extern void                     _start (void), etext (void);
 	monstartup ((u_long) & _start, (u_long) & etext);
 #endif
 
@@ -176,24 +173,23 @@ rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
 		if (listen_socket != -1) {
 			accept_event = g_slice_alloc0 (sizeof (struct event));
 			event_set (accept_event, listen_socket, EV_READ | EV_PERSIST,
-				accept_handler, worker);
+					accept_handler, worker);
 			event_base_set (ev_base, accept_event);
 			event_add (accept_event, NULL);
-			worker->accept_events = g_list_prepend (worker->accept_events,
-					accept_event);
+			worker->accept_events = g_list_prepend (worker->accept_events, accept_event);
 		}
 		cur = g_list_next (cur);
 	}
 
 	/* SIGUSR2 handler */
 	signal_set (&worker->sig_ev_usr2, SIGUSR2, worker_sigusr2_handler,
-		(void *) worker);
+			(void *) worker);
 	event_base_set (ev_base, &worker->sig_ev_usr2);
 	signal_add (&worker->sig_ev_usr2, NULL);
 
 	/* SIGUSR1 handler */
 	signal_set (&worker->sig_ev_usr1, SIGUSR1, worker_sigusr1_handler,
-		(void *) worker);
+			(void *) worker);
 	event_base_set (ev_base, &worker->sig_ev_usr1);
 	signal_add (&worker->sig_ev_usr1, NULL);
 
@@ -203,8 +199,8 @@ rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
 void
 rspamd_worker_stop_accept (struct rspamd_worker *worker)
 {
-	GList *cur;
-	struct event *event;
+	GList                             *cur;
+	struct event                     *event;
 
 	/* Remove all events */
 	cur = worker->accept_events;
@@ -222,8 +218,8 @@ rspamd_worker_stop_accept (struct rspamd_worker *worker)
 
 void
 rspamd_controller_send_error (struct rspamd_http_connection_entry *entry,
-	gint code,
-	const gchar *error_msg)
+		gint code,
+		const gchar *error_msg)
 {
 	struct rspamd_http_message *msg;
 
@@ -234,20 +230,14 @@ rspamd_controller_send_error (struct rspamd_http_connection_entry *entry,
 	msg->status = g_string_new (error_msg);
 	rspamd_printf_gstring (msg->body, "{\"error\":\"%s\"}", error_msg);
 	rspamd_http_connection_reset (entry->conn);
-	rspamd_http_connection_write_message (entry->conn,
-		msg,
-		NULL,
-		"application/json",
-		entry,
-		entry->conn->fd,
-		entry->rt->ptv,
-		entry->rt->ev_base);
+	rspamd_http_connection_write_message (entry->conn, msg, NULL,
+			"application/json", entry, entry->conn->fd, entry->rt->ptv, entry->rt->ev_base);
 	entry->is_reply = TRUE;
 }
 
 void
 rspamd_controller_send_string (struct rspamd_http_connection_entry *entry,
-	const gchar *str)
+		const gchar *str)
 {
 	struct rspamd_http_message *msg;
 
@@ -256,20 +246,14 @@ rspamd_controller_send_string (struct rspamd_http_connection_entry *entry,
 	msg->code = 200;
 	msg->body = g_string_new (str);
 	rspamd_http_connection_reset (entry->conn);
-	rspamd_http_connection_write_message (entry->conn,
-		msg,
-		NULL,
-		"application/json",
-		entry,
-		entry->conn->fd,
-		entry->rt->ptv,
-		entry->rt->ev_base);
+	rspamd_http_connection_write_message (entry->conn, msg, NULL,
+			"application/json", entry, entry->conn->fd, entry->rt->ptv, entry->rt->ev_base);
 	entry->is_reply = TRUE;
 }
 
 void
 rspamd_controller_send_ucl (struct rspamd_http_connection_entry *entry,
-	ucl_object_t *obj)
+		ucl_object_t *obj)
 {
 	struct rspamd_http_message *msg;
 
@@ -279,13 +263,7 @@ rspamd_controller_send_ucl (struct rspamd_http_connection_entry *entry,
 	msg->body = g_string_sized_new (BUFSIZ);
 	rspamd_ucl_emit_gstring (obj, UCL_EMIT_JSON_COMPACT, msg->body);
 	rspamd_http_connection_reset (entry->conn);
-	rspamd_http_connection_write_message (entry->conn,
-		msg,
-		NULL,
-		"application/json",
-		entry,
-		entry->conn->fd,
-		entry->rt->ptv,
-		entry->rt->ev_base);
+	rspamd_http_connection_write_message (entry->conn, msg, NULL,
+			"application/json", entry, entry->conn->fd, entry->rt->ptv, entry->rt->ev_base);
 	entry->is_reply = TRUE;
 }
diff --git a/src/libserver/worker_util.h b/src/libserver/worker_util.h
index e0b92be60..2af32d1e8 100644
--- a/src/libserver/worker_util.h
+++ b/src/libserver/worker_util.h
@@ -24,15 +24,15 @@
 #define WORKER_UTIL_H_
 
 #include "config.h"
-#include "http.h"
 #include "util.h"
+#include "http.h"
 
 /**
  * Return worker's control structure by its type
  * @param type
  * @return worker's control structure or NULL
  */
-worker_t * rspamd_get_worker_by_type (GQuark type);
+worker_t* rspamd_get_worker_by_type (GQuark type);
 
 /**
  * Set counter for a symbol
@@ -57,7 +57,7 @@ struct rspamd_worker;
  */
 struct event_base *
 rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
-	void (*accept_handler)(int, short, void *));
+		void (*accept_handler)(int, short, void *));
 
 /**
  * Stop accepting new connections for a worker
@@ -66,9 +66,9 @@ rspamd_prepare_worker (struct rspamd_worker *worker, const char *name,
 void rspamd_worker_stop_accept (struct rspamd_worker *worker);
 
 typedef gint (*rspamd_controller_func_t) (
-	struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg,
-	struct module_ctx *ctx);
+		struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg,
+		struct module_ctx *ctx);
 
 struct rspamd_custom_controller_command {
 	const gchar *command;
@@ -85,8 +85,8 @@ struct rspamd_custom_controller_command {
  * @param error_msg error message
  */
 void rspamd_controller_send_error (struct rspamd_http_connection_entry *entry,
-	gint code,
-	const gchar *error_msg);
+		gint code,
+		const gchar *error_msg);
 
 /**
  * Send a custom string using HTTP
@@ -94,7 +94,7 @@ void rspamd_controller_send_error (struct rspamd_http_connection_entry *entry,
  * @param str string to send
  */
 void rspamd_controller_send_string (struct rspamd_http_connection_entry *entry,
-	const gchar *str);
+		const gchar *str);
 
 /**
  * Send UCL using HTTP and JSON serialization
@@ -102,6 +102,6 @@ void rspamd_controller_send_string (struct rspamd_http_connection_entry *entry,
  * @param obj object to send
  */
 void rspamd_controller_send_ucl (struct rspamd_http_connection_entry *entry,
-	ucl_object_t *obj);
+		ucl_object_t *obj);
 
 #endif /* WORKER_UTIL_H_ */
diff --git a/src/libutil/aio_event.c b/src/libutil/aio_event.c
index e2edb8a8c..ccda37083 100644
--- a/src/libutil/aio_event.c
+++ b/src/libutil/aio_event.c
@@ -21,8 +21,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "aio_event.h"
 #include "config.h"
+#include "aio_event.h"
 #include "main.h"
 
 #ifdef HAVE_SYS_EVENTFD_H
@@ -47,8 +47,7 @@
 # define SYS_io_submit      209
 # define SYS_io_cancel      210
 #else
-# warning \
-	"aio is not supported on this platform, please contact author for details"
+# warning "aio is not supported on this platform, please contact author for details"
 # define SYS_io_setup       0
 # define SYS_io_destroy     0
 # define SYS_io_getevents   0
@@ -102,7 +101,7 @@ typedef enum io_iocb_cmd {
 struct iocb {
 	/* these are internal to the kernel/libc. */
 	guint64 aio_data; /* data to be returned in event's data */
-	guint32 PADDED (aio_key, aio_reserved1);
+	guint32 PADDED(aio_key, aio_reserved1);
 	/* the kernel sets aio_key to the req # */
 
 	/* common fields */
@@ -128,31 +127,27 @@ struct iocb {
 };
 
 struct io_event {
-	guint64 data;   /* the data field from the iocb */
-	guint64 obj;    /* what iocb this event came from */
-	gint64 res;     /* result code for this event */
-	gint64 res2;    /* secondary result */
+	guint64  data;  /* the data field from the iocb */
+	guint64  obj;   /* what iocb this event came from */
+	gint64   res;   /* result code for this event */
+	gint64   res2;  /* secondary result */
 };
 
 /* Linux specific io calls */
 static int
 io_setup (guint nr_reqs, aio_context_t *ctx)
 {
-	return syscall (SYS_io_setup, nr_reqs, ctx);
+    return syscall (SYS_io_setup, nr_reqs, ctx);
 }
 
 static int
 io_destroy (aio_context_t ctx)
 {
-	return syscall (SYS_io_destroy, ctx);
+    return syscall (SYS_io_destroy, ctx);
 }
 
 static int
-io_getevents (aio_context_t ctx,
-	long min_nr,
-	long nr,
-	struct io_event *events,
-	struct timespec *tmo)
+io_getevents (aio_context_t ctx, long min_nr, long nr, struct io_event *events, struct timespec *tmo)
 {
 	return syscall (SYS_io_getevents, ctx, min_nr, nr, events, tmo);
 }
@@ -160,13 +155,13 @@ io_getevents (aio_context_t ctx,
 static int
 io_submit (aio_context_t ctx, long n, struct iocb **paiocb)
 {
-	return syscall (SYS_io_submit, ctx, n, paiocb);
+    return syscall (SYS_io_submit, ctx, n, paiocb);
 }
 
 static int
 io_cancel (aio_context_t ctx, struct iocb *iocb, struct io_event *result)
 {
-	return syscall (SYS_io_cancel, ctx, iocb, result);
+    return syscall (SYS_io_cancel, ctx, iocb, result);
 }
 
 # ifndef HAVE_SYS_EVENTFD_H
@@ -184,7 +179,7 @@ eventfd (guint initval, guint flags)
  */
 struct aio_context {
 	struct event_base *base;
-	gboolean has_aio;       /**< Whether we have aio support on a system */
+	gboolean has_aio;		/**< Whether we have aio support on a system */
 #ifdef LINUX
 	/* Eventfd variant */
 	gint event_fd;
@@ -201,12 +196,12 @@ struct aio_context {
 static void
 rspamd_eventfdcb (gint fd, gshort what, gpointer ud)
 {
-	struct aio_context *ctx = ud;
-	guint64 ready;
-	gint done, i;
-	struct io_event event[32];
-	struct timespec ts;
-	struct io_cbdata *ev_data;
+	struct aio_context					*ctx = ud;
+	guint64								 ready;
+	gint								 done, i;
+	struct io_event   					 event[32];
+	struct timespec   					 ts;
+	struct io_cbdata					*ev_data;
 
 	/* Eventfd returns number of events ready got from kernel */
 	if (read (fd, &ready, 8) != 8) {
@@ -226,14 +221,10 @@ rspamd_eventfdcb (gint fd, gshort what, gpointer ud)
 		if (done > 0) {
 			ready -= done;
 
-			for (i = 0; i < done; i++) {
+			for (i = 0; i < done; i ++) {
 				ev_data = (struct io_cbdata *) (uintptr_t) event[i].data;
 				/* Call this callback */
-				ev_data->cb (ev_data->fd,
-					event[i].res,
-					ev_data->len,
-					ev_data->buf,
-					ev_data->ud);
+				ev_data->cb (ev_data->fd, event[i].res, ev_data->len, ev_data->buf, ev_data->ud);
 				if (ev_data->io_buf) {
 					free (ev_data->io_buf);
 				}
@@ -256,10 +247,10 @@ rspamd_eventfdcb (gint fd, gshort what, gpointer ud)
 /**
  * Initialize aio with specified event base
  */
-struct aio_context *
+struct aio_context*
 rspamd_aio_init (struct event_base *base)
 {
-	struct aio_context *new;
+	struct aio_context					*new;
 
 	/* First of all we need to detect which type of aio we can try to use */
 	new = g_malloc0 (sizeof (struct aio_context));
@@ -278,11 +269,7 @@ rspamd_aio_init (struct event_base *base)
 			close (new->event_fd);
 		}
 		else {
-			event_set (&new->eventfd_ev,
-				new->event_fd,
-				EV_READ | EV_PERSIST,
-				rspamd_eventfdcb,
-				new);
+			event_set (&new->eventfd_ev, new->event_fd, EV_READ|EV_PERSIST, rspamd_eventfdcb, new);
 			event_base_set (new->base, &new->eventfd_ev);
 			event_add (&new->eventfd_ev, NULL);
 			if (io_setup (MAX_AIO_EV, &new->io_ctx) == -1) {
@@ -307,7 +294,7 @@ rspamd_aio_init (struct event_base *base)
 gint
 rspamd_aio_open (struct aio_context *ctx, const gchar *path, int flags)
 {
-	gint fd = -1;
+	gint										fd = -1;
 	/* Fallback */
 	if (!ctx->has_aio) {
 		return open (path, flags);
@@ -328,20 +315,14 @@ rspamd_aio_open (struct aio_context *ctx, const gchar *path, int flags)
  * Asynchronous read of file
  */
 gint
-rspamd_aio_read (gint fd,
-	gpointer buf,
-	guint64 len,
-	guint64 offset,
-	struct aio_context *ctx,
-	rspamd_aio_cb cb,
-	gpointer ud)
+rspamd_aio_read (gint fd, gpointer buf, guint64 len, guint64 offset, struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud)
 {
-	struct io_cbdata *cbdata;
-	gint r = -1;
+	struct io_cbdata							*cbdata;
+	gint										 r = -1;
 
 	if (ctx->has_aio) {
 #ifdef LINUX
-		struct iocb *iocb[1];
+		struct iocb								*iocb[1];
 
 		cbdata = g_slice_alloc (sizeof (struct io_cbdata));
 		cbdata->cb = cb;
@@ -404,20 +385,14 @@ blocking:
  * Asynchronous write of file
  */
 gint
-rspamd_aio_write (gint fd,
-	gpointer buf,
-	guint64 len,
-	guint64 offset,
-	struct aio_context *ctx,
-	rspamd_aio_cb cb,
-	gpointer ud)
+rspamd_aio_write (gint fd, gpointer buf, guint64 len, guint64 offset, struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud)
 {
-	struct io_cbdata *cbdata;
-	gint r = -1;
+	struct io_cbdata							*cbdata;
+	gint										 r = -1;
 
 	if (ctx->has_aio) {
 #ifdef LINUX
-		struct iocb *iocb[1];
+		struct iocb								 *iocb[1];
 
 		cbdata = g_slice_alloc (sizeof (struct io_cbdata));
 		cbdata->cb = cb;
@@ -486,12 +461,12 @@ blocking:
 gint
 rspamd_aio_close (gint fd, struct aio_context *ctx)
 {
-	gint r = -1;
+	gint										 r = -1;
 
 	if (ctx->has_aio) {
 #ifdef LINUX
-		struct iocb iocb;
-		struct io_event ev;
+		struct iocb								 iocb;
+		struct io_event							 ev;
 
 		memset (&iocb, 0, sizeof (struct iocb));
 		iocb.aio_fildes = fd;
diff --git a/src/libutil/aio_event.h b/src/libutil/aio_event.h
index 7eaf95c2b..45f6015de 100644
--- a/src/libutil/aio_event.h
+++ b/src/libutil/aio_event.h
@@ -35,13 +35,12 @@ struct aio_context;
 /**
  * Callback for notifying
  */
-typedef void (*rspamd_aio_cb) (gint fd, gint res, guint64 len, gpointer data,
-	gpointer ud);
+typedef void (*rspamd_aio_cb) (gint fd, gint res, guint64 len, gpointer data, gpointer ud);
 
 /**
  * Initialize aio with specified event base
  */
-struct aio_context * rspamd_aio_init (struct event_base *base);
+struct aio_context* rspamd_aio_init (struct event_base *base);
 
 /**
  * Open file for aio
@@ -52,13 +51,13 @@ gint rspamd_aio_open (struct aio_context *ctx, const gchar *path, int flags);
  * Asynchronous read of file
  */
 gint rspamd_aio_read (gint fd, gpointer buf, guint64 len, guint64 offset,
-	struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud);
+		struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud);
 
 /**
  * Asynchronous write of file
  */
 gint rspamd_aio_write (gint fd, gpointer buf, guint64 len, guint64 offset,
-	struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud);
+		struct aio_context *ctx, rspamd_aio_cb cb, gpointer ud);
 
 /**
  * Close of aio operations
diff --git a/src/libutil/bloom.c b/src/libutil/bloom.c
index a77346d5c..f857d2e49 100644
--- a/src/libutil/bloom.c
+++ b/src/libutil/bloom.c
@@ -22,59 +22,48 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "bloom.h"
 #include "config.h"
+#include "bloom.h"
 #include "xxhash.h"
 
 /* 4 bits are used for counting (implementing delete operation) */
 #define SIZE_BIT 4
 
 /* These macroes are for 4 bits for counting element */
-#define INCBIT(a, n, acc) do {                                                              \
-		acc = \
-			a[n * SIZE_BIT / CHAR_BIT] & (0xF << \
-			(n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT));     \
-		acc ++;                                                                                 \
-		acc &= 0xF;                                                                             \
-                                                                                            \
-		a[n * SIZE_BIT / \
-		CHAR_BIT] &= (0xF << (4 - (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)));      \
-		a[n * SIZE_BIT / \
-		CHAR_BIT] |= (acc << (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT));            \
+#define INCBIT(a, n, acc) do {																\
+	acc = a[n * SIZE_BIT / CHAR_BIT] & (0xF << (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT));		\
+	acc ++;																					\
+	acc &= 0xF;																				\
+																							\
+	a[n * SIZE_BIT / CHAR_BIT] &= (0xF << (4 - (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT)));		\
+	a[n * SIZE_BIT / CHAR_BIT] |= (acc << (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT));			\
 } while (0);
 
-#define DECBIT(a, n, acc) do {                                                              \
-		acc = \
-			a[n * SIZE_BIT / CHAR_BIT] & (0xF << \
-			(n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT));     \
-		acc --;                                                                                 \
-		acc &= 0xF;                                                                             \
-                                                                                            \
-		a[n * SIZE_BIT / \
-		CHAR_BIT] &= (0xF << (4 - (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)));      \
-		a[n * SIZE_BIT / \
-		CHAR_BIT] |= (acc << (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT));            \
+#define DECBIT(a, n, acc) do {																\
+	acc = a[n * SIZE_BIT / CHAR_BIT] & (0xF << (n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT));		\
+	acc --;																					\
+	acc &= 0xF;																				\
+																							\
+	a[n * SIZE_BIT / CHAR_BIT] &= (0xF << (4 - (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT)));		\
+	a[n * SIZE_BIT / CHAR_BIT] |= (acc << (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT));			\
 } while (0);
 
-#define GETBIT(a, \
-		n) (a[n * SIZE_BIT / CHAR_BIT] & (0xF << \
-	(n % (CHAR_BIT / SIZE_BIT) * SIZE_BIT)))
+#define GETBIT(a, n) (a[n * SIZE_BIT / CHAR_BIT] & (0xF << (n % (CHAR_BIT/SIZE_BIT) * SIZE_BIT)))
 
 /* Common hash functions */
 
 
-rspamd_bloom_filter_t *
+rspamd_bloom_filter_t                 *
 rspamd_bloom_create (size_t size, size_t nfuncs, ...)
 {
-	rspamd_bloom_filter_t *bloom;
-	va_list l;
-	gsize n;
+	rspamd_bloom_filter_t                 *bloom;
+	va_list                         l;
+	gsize                           n;
 
 	if (!(bloom = g_malloc (sizeof (rspamd_bloom_filter_t)))) {
 		return NULL;
 	}
-	if (!(bloom->a =
-		g_new0 (gchar, (size + CHAR_BIT - 1) / CHAR_BIT * SIZE_BIT))) {
+	if (!(bloom->a = g_new0 (gchar,  (size + CHAR_BIT - 1) / CHAR_BIT * SIZE_BIT))) {
 		g_free (bloom);
 		return NULL;
 	}
@@ -107,9 +96,9 @@ rspamd_bloom_destroy (rspamd_bloom_filter_t * bloom)
 gboolean
 rspamd_bloom_add (rspamd_bloom_filter_t * bloom, const gchar *s)
 {
-	size_t n, len;
-	u_char t;
-	guint v;
+	size_t                          n, len;
+	u_char                          t;
+	guint                           v;
 
 	if (s == NULL) {
 		return FALSE;
@@ -126,9 +115,9 @@ rspamd_bloom_add (rspamd_bloom_filter_t * bloom, const gchar *s)
 gboolean
 rspamd_bloom_del (rspamd_bloom_filter_t * bloom, const gchar *s)
 {
-	size_t n, len;
-	u_char t;
-	guint v;
+	size_t                          n, len;
+	u_char                          t;
+	guint                           v;
 
 	if (s == NULL) {
 		return FALSE;
@@ -146,8 +135,8 @@ rspamd_bloom_del (rspamd_bloom_filter_t * bloom, const gchar *s)
 gboolean
 rspamd_bloom_check (rspamd_bloom_filter_t * bloom, const gchar *s)
 {
-	size_t n, len;
-	guint v;
+	size_t                          n, len;
+	guint                           v;
 
 	if (s == NULL) {
 		return FALSE;
diff --git a/src/libutil/bloom.h b/src/libutil/bloom.h
index 9866e9988..380143c80 100644
--- a/src/libutil/bloom.h
+++ b/src/libutil/bloom.h
@@ -4,10 +4,10 @@
 #include "config.h"
 
 typedef struct rspamd_bloom_filter_s {
-	size_t asize;
-	gchar *a;
-	size_t nfuncs;
-	guint32 *seeds;
+	size_t          asize;
+	gchar          *a;
+	size_t          nfuncs;
+	guint32        *seeds;
 } rspamd_bloom_filter_t;
 
 
@@ -23,7 +23,7 @@ typedef struct rspamd_bloom_filter_s {
  * @param nfuncs number of hash functions
  * @param ... hash functions list
  */
-rspamd_bloom_filter_t * rspamd_bloom_create (size_t size, size_t nfuncs, ...);
+rspamd_bloom_filter_t* rspamd_bloom_create (size_t size, size_t nfuncs, ...);
 
 /*
  * Destroy bloom filter
diff --git a/src/libutil/diff.c b/src/libutil/diff.c
index cee175ceb..4038d8680 100644
--- a/src/libutil/diff.c
+++ b/src/libutil/diff.c
@@ -39,8 +39,8 @@
 #include "diff.h"
 
 
-#define FV(k) _v (ctx, (k), 0)
-#define RV(k) _v (ctx, (k), 1)
+#define FV(k) _v(ctx, (k), 0)
+#define RV(k) _v(ctx, (k), 1)
 
 #define MAX_DIFF 1024
 
@@ -58,8 +58,7 @@ struct middle_snake
 };
 
 static
-void
-maybe_resize_array (GArray *arr, guint k)
+void maybe_resize_array(GArray *arr, guint k)
 {
 	if (k > arr->len) {
 		g_array_set_size (arr, k);
@@ -68,7 +67,7 @@ maybe_resize_array (GArray *arr, guint k)
 }
 
 static void
-_setv (struct _ctx *ctx, gint k, gint r, gint val)
+_setv(struct _ctx *ctx, gint k, gint r, gint val)
 {
 	gint j;
 	gint *i;
@@ -82,7 +81,7 @@ _setv (struct _ctx *ctx, gint k, gint r, gint val)
 }
 
 static gint
-_v (struct _ctx *ctx, gint k, gint r)
+_v(struct _ctx *ctx, gint k, gint r)
 {
 	gint j;
 
@@ -92,8 +91,8 @@ _v (struct _ctx *ctx, gint k, gint r)
 }
 
 static gint
-_find_middle_snake (const void *a, gint aoff, gint n, const void *b,
-	gint boff, gint m, struct _ctx *ctx, struct middle_snake *ms)
+_find_middle_snake(const void *a, gint aoff, gint n, const void *b,
+		gint boff, gint m, struct _ctx *ctx, struct middle_snake *ms)
 {
 	gint delta, odd, mid, d;
 
@@ -102,7 +101,7 @@ _find_middle_snake (const void *a, gint aoff, gint n, const void *b,
 	mid = (n + m) / 2;
 	mid += odd;
 
-	_setv (ctx, 1,		   0, 0);
+	_setv (ctx, 1, 0, 0);
 	_setv (ctx, delta - 1, 1, n);
 
 	for (d = 0; d <= mid; d++) {
@@ -113,11 +112,11 @@ _find_middle_snake (const void *a, gint aoff, gint n, const void *b,
 		}
 
 		for (k = d; k >= -d; k -= 2) {
-			if (k == -d || (k != d && FV (k - 1) < FV (k + 1))) {
-				x = FV (k + 1);
+			if (k == -d || (k != d && FV(k - 1) < FV(k + 1))) {
+				x = FV(k + 1);
 			}
 			else {
-				x = FV (k - 1) + 1;
+				x = FV(k - 1) + 1;
 			}
 			y = x - k;
 
@@ -132,7 +131,7 @@ _find_middle_snake (const void *a, gint aoff, gint n, const void *b,
 			_setv (ctx, k, 0, x);
 
 			if (odd && k >= (delta - (d - 1)) && k <= (delta + (d - 1))) {
-				if (x >= RV (k)) {
+				if (x >= RV(k)) {
 					ms->u = x;
 					ms->v = y;
 					return 2 * d - 1;
@@ -142,11 +141,11 @@ _find_middle_snake (const void *a, gint aoff, gint n, const void *b,
 		for (k = d; k >= -d; k -= 2) {
 			gint kr = (n - m) + k;
 
-			if (k == d || (k != -d && RV (kr - 1) < RV (kr + 1))) {
-				x = RV (kr - 1);
+			if (k == d || (k != -d && RV(kr - 1) < RV(kr + 1))) {
+				x = RV(kr - 1);
 			}
 			else {
-				x = RV (kr + 1) - 1;
+				x = RV(kr + 1) - 1;
 			}
 			y = x - kr;
 
@@ -161,7 +160,7 @@ _find_middle_snake (const void *a, gint aoff, gint n, const void *b,
 			_setv (ctx, kr, 1, x);
 
 			if (!odd && kr >= -d && kr <= d) {
-				if (x <= FV (kr)) {
+				if (x <= FV(kr)) {
 					ms->x = x;
 					ms->y = y;
 					return 2 * d;
@@ -176,7 +175,7 @@ _find_middle_snake (const void *a, gint aoff, gint n, const void *b,
 }
 
 static void
-_edit (struct _ctx *ctx, gint op, gint off, gint len)
+_edit(struct _ctx *ctx, gint op, gint off, gint len)
 {
 	struct diff_edit *e = NULL, newe;
 
@@ -202,8 +201,8 @@ _edit (struct _ctx *ctx, gint op, gint off, gint len)
 }
 
 static gint
-_ses (const void *a, gint aoff, gint n, const void *b, gint boff,
-	gint m, struct _ctx *ctx)
+_ses(const void *a, gint aoff, gint n, const void *b, gint boff,
+		gint m, struct _ctx *ctx)
 {
 	struct middle_snake ms = {
 		.x = 0,
@@ -270,22 +269,22 @@ _ses (const void *a, gint aoff, gint n, const void *b, gint boff,
 
 			if (m > n) {
 				if (x == u) {
-					_edit (ctx, DIFF_MATCH,	 aoff,			 n);
+					_edit (ctx, DIFF_MATCH, aoff, n);
 					_edit (ctx, DIFF_INSERT, boff + (m - 1), 1);
 				}
 				else {
 					_edit (ctx, DIFF_INSERT, boff, 1);
-					_edit (ctx, DIFF_MATCH,	 aoff, n);
+					_edit (ctx, DIFF_MATCH, aoff, n);
 				}
 			}
 			else {
 				if (x == u) {
-					_edit (ctx, DIFF_MATCH,	 aoff,			 m);
+					_edit (ctx, DIFF_MATCH, aoff, m);
 					_edit (ctx, DIFF_DELETE, aoff + (n - 1), 1);
 				}
 				else {
-					_edit (ctx, DIFF_DELETE, aoff,	   1);
-					_edit (ctx, DIFF_MATCH,	 aoff + 1, m);
+					_edit (ctx, DIFF_DELETE, aoff, 1);
+					_edit (ctx, DIFF_MATCH, aoff + 1, m);
 				}
 			}
 		}
@@ -295,8 +294,8 @@ _ses (const void *a, gint aoff, gint n, const void *b, gint boff,
 }
 
 gint
-rspamd_diff (const void *a, gint aoff, gint n, const void *b, gint boff, gint m,
-	gint dmax, GArray *ses, gint *sn)
+rspamd_diff(const void *a, gint aoff, gint n, const void *b, gint boff, gint m,
+		gint dmax, GArray *ses, gint *sn)
 {
 	struct _ctx ctx;
 	gint d, x, y;
@@ -346,14 +345,14 @@ compare_diff_distance_unnormalized (f_str_t *s1, f_str_t *s2)
 	ses = g_array_sized_new (FALSE, TRUE, sizeof (struct diff_edit), MAX_DIFF);
 
 	if (rspamd_diff (s1->begin, 0, s1->len,
-		s2->begin, 0, s2->len, MAX_DIFF, ses, NULL) == -1) {
+			s2->begin, 0, s2->len, MAX_DIFF, ses, NULL) == -1) {
 		/* Diff failed, strings are different */
 		g_array_free (ses, TRUE);
 		return 0;
 	}
 
-	for (i = 0; i < ses->len; i++) {
-		e = &g_array_index (ses, struct diff_edit, i);
+	for (i = 0; i < ses->len; i ++) {
+		e = &g_array_index(ses, struct diff_edit, i);
 		if (e->op != DIFF_MATCH) {
 			distance += e->len;
 		}
@@ -368,10 +367,7 @@ guint32
 compare_diff_distance (f_str_t *s1, f_str_t *s2)
 {
 
-	return 100 -
-		   (2 *
-		   compare_diff_distance_unnormalized (s1,
-		   s2) * 100) / (s1->len + s2->len);
+	return 100 - (2 * compare_diff_distance_unnormalized (s1, s2) * 100) / (s1->len + s2->len);
 }
 
 
@@ -398,9 +394,9 @@ compare_diff_distance_normalized (f_str_t *s1, f_str_t *s2)
 			if (!g_ascii_isspace (*h)) {
 				*t++ = g_ascii_tolower (*h);
 			}
-			h++;
-			p1++;
-			r1--;
+			h ++;
+			p1 ++;
+			r1 --;
 		}
 
 		t1.begin = b1;
@@ -413,9 +409,9 @@ compare_diff_distance_normalized (f_str_t *s1, f_str_t *s2)
 			if (!g_ascii_isspace (*h)) {
 				*t++ = g_ascii_tolower (*h);
 			}
-			h++;
-			p2++;
-			r2--;
+			h ++;
+			p2 ++;
+			r2 --;
 		}
 
 		t2.begin = b2;
@@ -428,20 +424,20 @@ compare_diff_distance_normalized (f_str_t *s1, f_str_t *s2)
 		h = p1;
 		while (r1 > 0) {
 			if (!g_ascii_isspace (*h)) {
-				cur_diff++;
+				cur_diff ++;
 			}
-			r1--;
-			h++;
+			r1 --;
+			h ++;
 		}
 	}
 	else if (r2 > 0) {
 		h = p2;
 		while (r2 > 0) {
 			if (!g_ascii_isspace (*h)) {
-				cur_diff++;
+				cur_diff ++;
 			}
-			r2--;
-			h++;
+			r2 --;
+			h ++;
 		}
 	}
 
diff --git a/src/libutil/diff.h b/src/libutil/diff.h
index 7caa35dd8..cea5e5d4a 100644
--- a/src/libutil/diff.h
+++ b/src/libutil/diff.h
@@ -55,15 +55,8 @@ struct diff_edit
  * @param sn here would be stored a number of differences between a and b
  * @return distance between strings or -1 in case of error
  */
-gint rspamd_diff (const void *a,
-	gint aoff,
-	gint n,
-	const void *b,
-	gint boff,
-	gint m,
-	gint dmax,
-	GArray *ses,
-	gint *sn);
+gint rspamd_diff(const void *a, gint aoff, gint n, const void *b, gint boff, gint m,
+		gint dmax, GArray *ses, gint *sn);
 
 /*
  * Calculate distance between two strings (in percentage) using diff algorithm.
@@ -75,7 +68,7 @@ guint32 compare_diff_distance (f_str_t *s1, f_str_t *s2);
  * Calculate distance between two strings (in percentage) using diff algorithm. Strings are normalized before:
  * all spaces are removed and all characters are lowercased.
  * @return 100 in case of identical strings and 0 in case of totally different strings.
- */
+*/
 guint32 compare_diff_distance_normalized (f_str_t *s1, f_str_t *s2);
 
 #endif /* DIFF_H_ */
diff --git a/src/libutil/fstring.c b/src/libutil/fstring.c
index a83bbd662..098824101 100644
--- a/src/libutil/fstring.c
+++ b/src/libutil/fstring.c
@@ -30,7 +30,7 @@
 ssize_t
 fstrchr (f_str_t * src, gchar c)
 {
-	register size_t cur = 0;
+	register size_t                cur = 0;
 
 	while (cur < src->len) {
 		if (*(src->begin + cur) == c) {
@@ -48,7 +48,7 @@ fstrchr (f_str_t * src, gchar c)
 ssize_t
 fstrrchr (f_str_t * src, gchar c)
 {
-	register ssize_t cur = src->len;
+	register ssize_t                cur = src->len;
 
 	while (cur > 0) {
 		if (*(src->begin + cur) == c) {
@@ -66,7 +66,7 @@ fstrrchr (f_str_t * src, gchar c)
 ssize_t
 fstrstr (f_str_t * orig, f_str_t * pattern)
 {
-	register size_t cur = 0, pcur = 0;
+	register size_t                cur = 0, pcur = 0;
 
 	if (pattern->len > orig->len) {
 		return -1;
@@ -97,18 +97,16 @@ fstrstr (f_str_t * orig, f_str_t * pattern)
 ssize_t
 fstrstri (f_str_t * orig, f_str_t * pattern)
 {
-	register size_t cur = 0, pcur = 0;
+	register size_t                cur = 0, pcur = 0;
 
 	if (pattern->len > orig->len) {
 		return -1;
 	}
 
 	while (cur < orig->len) {
-		if (g_ascii_tolower (*(orig->begin + cur)) ==
-			g_ascii_tolower (*pattern->begin)) {
+		if (g_ascii_tolower (*(orig->begin + cur)) == g_ascii_tolower (*pattern->begin)) {
 			while (cur < orig->len && pcur < pattern->len) {
-				if (g_ascii_tolower (*(orig->begin + cur)) !=
-					g_ascii_tolower (*(pattern->begin + pcur))) {
+				if (g_ascii_tolower (*(orig->begin + cur)) != g_ascii_tolower (*(pattern->begin + pcur))) {
 					pcur = 0;
 					break;
 				}
@@ -129,14 +127,14 @@ fstrstri (f_str_t * orig, f_str_t * pattern)
  * word contains parsed word
  *
  * Return: -1 - no new words can be extracted
- *          1 - word was extracted and there are more words
- *          0 - last word extracted
+ * 			1 - word was extracted and there are more words
+ * 			0 - last word extracted
  */
 gint
 fstrtok (f_str_t * text, const gchar *sep, f_tok_t * state)
 {
-	register size_t cur;
-	const gchar *csep = sep;
+	register size_t                 cur;
+	const gchar                     *csep = sep;
 
 	if (state->pos >= text->len) {
 		return -1;
@@ -172,7 +170,7 @@ fstrtok (f_str_t * text, const gchar *sep, f_tok_t * state)
 size_t
 fstrcpy (f_str_t * dest, f_str_t * src)
 {
-	register size_t cur = 0;
+	register size_t                 cur = 0;
 
 	if (dest->size < src->len) {
 		return 0;
@@ -192,8 +190,8 @@ fstrcpy (f_str_t * dest, f_str_t * src)
 size_t
 fstrcat (f_str_t * dest, f_str_t * src)
 {
-	register size_t cur = 0;
-	gchar *p = dest->begin + dest->len;
+	register size_t                 cur = 0;
+	gchar                           *p = dest->begin + dest->len;
 
 	if (dest->size < src->len + dest->len) {
 		return 0;
@@ -214,10 +212,10 @@ fstrcat (f_str_t * dest, f_str_t * src)
 /*
  * Make copy of string to 0-terminated string
  */
-gchar *
+gchar                           *
 fstrcstr (f_str_t * str, rspamd_mempool_t * pool)
 {
-	gchar *res;
+	gchar                           *res;
 	res = rspamd_mempool_alloc (pool, str->len + 1);
 
 	/* Do not allow multiply \0 characters */
@@ -249,7 +247,7 @@ fstrpush (f_str_t * dest, gchar c)
 gint
 fstrpush_unichar (f_str_t * dest, gunichar c)
 {
-	int l;
+	int                            l;
 	if (dest->size < dest->len) {
 		/* Need to reallocate string */
 		return 0;
@@ -263,10 +261,10 @@ fstrpush_unichar (f_str_t * dest, gunichar c)
 /*
  * Allocate memory for f_str_t
  */
-f_str_t *
+f_str_t                        *
 fstralloc (rspamd_mempool_t * pool, size_t len)
 {
-	f_str_t *res = rspamd_mempool_alloc (pool, sizeof (f_str_t));
+	f_str_t                        *res = rspamd_mempool_alloc (pool, sizeof (f_str_t));
 
 	res->begin = rspamd_mempool_alloc (pool, len);
 
@@ -278,10 +276,10 @@ fstralloc (rspamd_mempool_t * pool, size_t len)
 /*
  * Allocate memory for f_str_t from temporary pool
  */
-f_str_t *
+f_str_t                        *
 fstralloc_tmp (rspamd_mempool_t * pool, size_t len)
 {
-	f_str_t *res = rspamd_mempool_alloc_tmp (pool, sizeof (f_str_t));
+	f_str_t                        *res = rspamd_mempool_alloc_tmp (pool, sizeof (f_str_t));
 
 	res->begin = rspamd_mempool_alloc_tmp (pool, len);
 
@@ -293,10 +291,10 @@ fstralloc_tmp (rspamd_mempool_t * pool, size_t len)
 /*
  * Truncate string to its len
  */
-f_str_t *
+f_str_t                        *
 fstrtruncate (rspamd_mempool_t * pool, f_str_t * orig)
 {
-	f_str_t *res;
+	f_str_t                        *res;
 
 	if (orig == NULL || orig->len == 0 || orig->size <= orig->len) {
 		return orig;
@@ -314,10 +312,10 @@ fstrtruncate (rspamd_mempool_t * pool, f_str_t * orig)
 /*
  * Enlarge string to new size
  */
-f_str_t *
+f_str_t                        *
 fstrgrow (rspamd_mempool_t * pool, f_str_t * orig, size_t newlen)
 {
-	f_str_t *res;
+	f_str_t                        *res;
 
 	if (orig == NULL || orig->len == 0 || orig->size >= newlen) {
 		return orig;
@@ -335,7 +333,7 @@ fstrgrow (rspamd_mempool_t * pool, f_str_t * orig, size_t newlen)
 static guint32
 fstrhash_c (gchar c, guint32 hval)
 {
-	guint32 tmp;
+	guint32                         tmp;
 	/*
 	 * xor in the current byte against each byte of hval
 	 * (which alone gaurantees that every bit of input will have
@@ -366,9 +364,9 @@ fstrhash_c (gchar c, guint32 hval)
 guint32
 fstrhash (f_str_t * str)
 {
-	size_t i;
-	guint32 hval;
-	gchar *c = str->begin;
+	size_t                          i;
+	guint32                         hval;
+	gchar                           *c = str->begin;
 
 	if (str == NULL) {
 		return 0;
@@ -387,11 +385,11 @@ fstrhash (f_str_t * str)
 guint32
 fstrhash_lowercase (f_str_t * str, gboolean is_utf)
 {
-	gsize i;
-	guint32 j, hval;
-	const gchar *p = str->begin, *end = NULL;
-	gchar t;
-	gunichar uc;
+	gsize                           i;
+	guint32                         j, hval;
+	const gchar                    *p = str->begin, *end = NULL;
+	gchar                           t;
+	gunichar                        uc;
 
 	if (str == NULL) {
 		return 0;
@@ -405,7 +403,7 @@ fstrhash_lowercase (f_str_t * str, gboolean is_utf)
 			}
 			while (p < end) {
 				uc = g_unichar_tolower (g_utf8_get_char (p));
-				for (j = 0; j < sizeof (gunichar); j++) {
+				for (j = 0; j < sizeof (gunichar); j ++) {
 					t = (uc >> (j * 8)) & 0xff;
 					if (t != 0) {
 						hval = fstrhash_c (t, hval);
@@ -429,8 +427,8 @@ fstrhash_lowercase (f_str_t * str, gboolean is_utf)
 void
 fstrstrip (f_str_t * str)
 {
-	gchar *p = str->begin;
-	guint r = 0;
+	gchar                           *p = str->begin;
+	guint                            r = 0;
 
 	while (r < str->len) {
 		if (g_ascii_isspace (*p)) {
diff --git a/src/libutil/fstring.h b/src/libutil/fstring.h
index 3cba00592..bd680e365 100644
--- a/src/libutil/fstring.h
+++ b/src/libutil/fstring.h
@@ -8,8 +8,7 @@
 #include "config.h"
 #include "mem_pool.h"
 
-#define update_buf_size(x) (x)->free = (x)->buf->size - \
-		((x)->pos - (x)->buf->begin); (x)->buf->len = (x)->pos - (x)->buf->begin
+#define update_buf_size(x) (x)->free = (x)->buf->size - ((x)->pos - (x)->buf->begin); (x)->buf->len = (x)->pos - (x)->buf->begin
 
 typedef struct f_str_s {
 	gchar *begin;
@@ -77,22 +76,22 @@ gint fstrpush_unichar (f_str_t *dest, gunichar c);
 /*
  * Allocate memory for f_str_t
  */
-f_str_t * fstralloc (rspamd_mempool_t *pool, size_t len);
+f_str_t* fstralloc (rspamd_mempool_t *pool, size_t len);
 
 /*
  * Allocate memory for f_str_t from temporary pool
  */
-f_str_t * fstralloc_tmp (rspamd_mempool_t *pool, size_t len);
+f_str_t* fstralloc_tmp (rspamd_mempool_t *pool, size_t len);
 
 /*
  * Truncate string to its len
  */
-f_str_t * fstrtruncate (rspamd_mempool_t *pool, f_str_t *orig);
+f_str_t* fstrtruncate (rspamd_mempool_t *pool, f_str_t *orig);
 
 /*
  * Enlarge string to new size
  */
-f_str_t * fstrgrow (rspamd_mempool_t *pool, f_str_t *orig, size_t newlen);
+f_str_t* fstrgrow (rspamd_mempool_t *pool, f_str_t *orig, size_t newlen);
 
 /*
  * Return specified character
@@ -111,7 +110,7 @@ guint32 fstrhash_lowercase (f_str_t *str, gboolean is_utf);
 /*
  * Make copy of string to 0-terminated string
  */
-gchar * fstrcstr (f_str_t *str, rspamd_mempool_t *pool);
+gchar* fstrcstr (f_str_t *str, rspamd_mempool_t *pool);
 
 /*
  * Strip fstr string from space symbols
diff --git a/src/libutil/fuzzy.c b/src/libutil/fuzzy.c
index a58fee654..7e8a01ce3 100644
--- a/src/libutil/fuzzy.c
+++ b/src/libutil/fuzzy.c
@@ -24,31 +24,30 @@
 
 
 #include "config.h"
+#include "mem_pool.h"
 #include "fstring.h"
 #include "fuzzy.h"
-#include "main.h"
-#include "mem_pool.h"
 #include "message.h"
 #include "url.h"
+#include "main.h"
 
 #define ROLL_WINDOW_SIZE 9
 #define MIN_FUZZY_BLOCK_SIZE 3
 #define HASH_INIT      0x28021967
 
-static const char *b64 =
-	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 struct roll_state {
-	guint32 h[3];
-	gchar window[ROLL_WINDOW_SIZE];
-	gint n;
+	guint32                         h[3];
+	gchar                           window[ROLL_WINDOW_SIZE];
+	gint                            n;
 };
 
-static struct roll_state rs;
+static struct roll_state        rs;
 
 
 /* Rolling hash function based on Adler-32 checksum */
-static guint32
+static                          guint32
 fuzzy_roll_hash (guint c)
 {
 	/* Check window position */
@@ -73,20 +72,19 @@ fuzzy_roll_hash (guint c)
 }
 
 /* A simple non-rolling hash, based on the FNV hash */
-static guint32
+static                          guint32
 fuzzy_fnv_hash (guint c, guint32 hval)
 {
 	hval ^= c;
-	hval +=
-		(hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
+	hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
 	return hval;
 }
 
 /* Calculate blocksize depending on length of input */
-static guint32
+static                          guint32
 fuzzy_blocksize (guint32 len)
 {
-	guint32 nlen = MIN_FUZZY_BLOCK_SIZE;
+	guint32                     nlen = MIN_FUZZY_BLOCK_SIZE;
 
 	while (nlen * (FUZZY_HASHLEN - 1) < len) {
 		nlen *= 2;
@@ -143,12 +141,12 @@ fuzzy_update2 (fuzzy_hash_t * h1, fuzzy_hash_t *h2, guint c)
 guint32
 lev_distance (gchar *s1, gint len1, gchar *s2, gint len2)
 {
-	gint i;
-	gint *row;                              /* we only need to keep one row of costs */
-	gint *end;
-	gint half, nx;
-	gchar *sx, *char2p, char1;
-	gint *p, D, x, offset, c3;
+	gint                            i;
+	gint                            *row;	/* we only need to keep one row of costs */
+	gint                            *end;
+	gint                            half, nx;
+	gchar                           *sx, *char2p, char1;
+	gint                            *p, D, x, offset, c3;
 
 	/* strip common prefix */
 	while (len1 > 0 && len2 > 0 && *s1 == *s2) {
@@ -254,13 +252,13 @@ lev_distance (gchar *s1, gint len1, gchar *s2, gint len2)
 }
 
 /* Calculate fuzzy hash for specified string */
-fuzzy_hash_t *
+fuzzy_hash_t                   *
 fuzzy_init (f_str_t * in, rspamd_mempool_t * pool)
 {
-	fuzzy_hash_t *new;
-	guint i, repeats = 0;
-	gchar *c = in->begin, last = '\0';
-	gsize real_len = 0;
+	fuzzy_hash_t                   *new;
+	guint                           i, repeats = 0;
+	gchar                          *c = in->begin, last = '\0';
+	gsize                           real_len = 0;
 
 	new = rspamd_mempool_alloc0 (pool, sizeof (fuzzy_hash_t));
 	bzero (&rs, sizeof (rs));
@@ -272,7 +270,7 @@ fuzzy_init (f_str_t * in, rspamd_mempool_t * pool)
 			repeats = 0;
 		}
 		if (!g_ascii_isspace (*c) && !g_ascii_ispunct (*c) && repeats < 3) {
-			real_len++;
+			real_len ++;
 		}
 		last = *c;
 		c++;
@@ -303,10 +301,10 @@ fuzzy_init (f_str_t * in, rspamd_mempool_t * pool)
 	return new;
 }
 
-fuzzy_hash_t *
+fuzzy_hash_t                   *
 fuzzy_init_byte_array (GByteArray * in, rspamd_mempool_t * pool)
 {
-	f_str_t f;
+	f_str_t                         f;
 
 	f.begin = (gchar *)in->data;
 	f.len = in->len;
@@ -315,17 +313,15 @@ fuzzy_init_byte_array (GByteArray * in, rspamd_mempool_t * pool)
 }
 
 void
-fuzzy_init_part (struct mime_text_part *part,
-	rspamd_mempool_t *pool,
-	gsize max_diff)
+fuzzy_init_part (struct mime_text_part *part, rspamd_mempool_t *pool, gsize max_diff)
 {
-	fuzzy_hash_t *new, *new2;
-	gchar *c, *end, *begin;
-	gsize real_len = 0, len = part->content->len;
-	GList *cur_offset;
-	struct process_exception *cur_ex = NULL;
-	gunichar uc;
-	gboolean write_diff = FALSE;
+	fuzzy_hash_t                   *new, *new2;
+	gchar                          *c, *end, *begin;
+	gsize                           real_len = 0, len = part->content->len;
+	GList                          *cur_offset;
+	struct process_exception       *cur_ex = NULL;
+	gunichar                        uc;
+	gboolean                        write_diff = FALSE;
 
 	cur_offset = part->urls_offset;
 	if (cur_offset != NULL) {
@@ -351,7 +347,7 @@ fuzzy_init_part (struct mime_text_part *part,
 			else {
 				uc = g_utf8_get_char (c);
 				if (g_unichar_isalnum (uc)) {
-					real_len++;
+					real_len ++;
 				}
 				c = g_utf8_next_char (c);
 			}
@@ -368,7 +364,7 @@ fuzzy_init_part (struct mime_text_part *part,
 			}
 			else {
 				if (!g_ascii_isspace (*c) && !g_ascii_ispunct (*c)) {
-					real_len++;
+					real_len ++;
 				}
 				c++;
 			}
@@ -454,7 +450,7 @@ fuzzy_init_part (struct mime_text_part *part,
 gint
 fuzzy_compare_hashes (fuzzy_hash_t * h1, fuzzy_hash_t * h2)
 {
-	gint res, l1, l2;
+	gint                            res, l1, l2;
 
 	/* If we have hashes of different size, input strings are too different */
 	if (h1->block_size != h2->block_size) {
@@ -497,6 +493,6 @@ fuzzy_compare_parts (struct mime_text_part *p1, struct mime_text_part *p2)
 	return 0;
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libutil/fuzzy.h b/src/libutil/fuzzy.h
index 2e3c8a752..c226c5765 100644
--- a/src/libutil/fuzzy.h
+++ b/src/libutil/fuzzy.h
@@ -7,17 +7,17 @@
 #define RSPAMD_FUZZY_H
 
 #include "config.h"
-#include "fstring.h"
 #include "mem_pool.h"
+#include "fstring.h"
 
 #define FUZZY_HASHLEN 64
 
 typedef struct fuzzy_hash_s {
-	gchar hash_pipe[FUZZY_HASHLEN];     /**< result hash					*/
-	guint32 block_size;                 /**< current blocksize				*/
-	guint32 rh;                         /**< roll hash value				*/
-	guint32 h;                              /**< hash of block					*/
-	guint32 hi;                         /**< current index in hash pipe		*/
+	gchar hash_pipe[FUZZY_HASHLEN];		/**< result hash					*/
+	guint32 block_size;					/**< current blocksize				*/
+	guint32 rh;							/**< roll hash value				*/
+	guint32 h;								/**< hash of block					*/
+	guint32 hi;							/**< current index in hash pipe		*/
 } fuzzy_hash_t;
 
 struct mime_text_part;
@@ -44,15 +44,13 @@ fuzzy_hash_t * fuzzy_init_byte_array (GByteArray *in, rspamd_mempool_t *pool);
  * @param max_diff maximum text length to use diff algorithm in comparasions
  * @return fuzzy_hash object allocated in pool
  */
-void fuzzy_init_part (struct mime_text_part *part,
-	rspamd_mempool_t *pool,
-	gsize max_diff);
+void fuzzy_init_part (struct mime_text_part *part, rspamd_mempool_t *pool, gsize max_diff);
 
 /**
- * Compare score of difference between two hashes
+ * Compare score of difference between two hashes 
  * @param h1 first hash
  * @param h2 second hash
- * @return result in percents 0 - different hashes, 100 - identical hashes
+ * @return result in percents 0 - different hashes, 100 - identical hashes 
  */
 gint fuzzy_compare_hashes (fuzzy_hash_t *h1, fuzzy_hash_t *h2);
 
diff --git a/src/libutil/hash.c b/src/libutil/hash.c
index 0e8b1646e..3bb381651 100644
--- a/src/libutil/hash.c
+++ b/src/libutil/hash.c
@@ -33,13 +33,11 @@
  * will use this function internally.
  */
 static inline struct rspamd_hash_node **
-rspamd_hash_lookup_node (rspamd_hash_t * hash,
-	gconstpointer key,
-	guint * hash_return)
+rspamd_hash_lookup_node (rspamd_hash_t * hash, gconstpointer key, guint * hash_return)
 {
-	struct rspamd_hash_node **node_ptr, *node;
-	guint hash_value;
-	hash_value = (*hash->hash_func)(key);
+	struct rspamd_hash_node       **node_ptr, *node;
+	guint                           hash_value;
+	hash_value = (*hash->hash_func) (key);
 
 	if (hash->shared) {
 		rspamd_mempool_rlock_rwlock (hash->lock);
@@ -60,8 +58,7 @@ rspamd_hash_lookup_node (rspamd_hash_t * hash,
 	 */
 	if (hash->key_equal_func) {
 		while ((node = *node_ptr)) {
-			if (node->key_hash == hash_value &&
-				hash->key_equal_func (node->key, key)) {
+			if (node->key_hash == hash_value && hash->key_equal_func (node->key, key)) {
 				break;
 			}
 			node_ptr = &(*node_ptr)->next;
@@ -86,10 +83,9 @@ rspamd_hash_lookup_node (rspamd_hash_t * hash,
  * No table resize is performed.
  */
 static void
-rspamd_hash_remove_node (rspamd_hash_t * hash,
-	struct rspamd_hash_node ***node_ptr_ptr)
+rspamd_hash_remove_node (rspamd_hash_t * hash, struct rspamd_hash_node ***node_ptr_ptr)
 {
-	struct rspamd_hash_node **node_ptr, *node;
+	struct rspamd_hash_node       **node_ptr, *node;
 
 	if (hash->shared) {
 		rspamd_mempool_wlock_rwlock (hash->lock);
@@ -112,23 +108,19 @@ rspamd_hash_remove_node (rspamd_hash_t * hash,
 static void
 rspamd_hash_resize (rspamd_hash_t * hash)
 {
-	struct rspamd_hash_node **new_nodes;
-	struct rspamd_hash_node *node, *next;
-	guint hash_val;
-	gint new_size, i;
+	struct rspamd_hash_node       **new_nodes;
+	struct rspamd_hash_node        *node, *next;
+	guint                           hash_val;
+	gint                            new_size, i;
 
 	new_size = g_spaced_primes_closest (hash->nnodes);
 	new_size = CLAMP (new_size, HASH_TABLE_MIN_SIZE, HASH_TABLE_MAX_SIZE);
 
 	if (hash->shared) {
-		new_nodes =
-			rspamd_mempool_alloc_shared (hash->pool,
-				sizeof (struct rspamd_hash_node *) * new_size);
+		new_nodes = rspamd_mempool_alloc_shared (hash->pool, sizeof (struct rspamd_hash_node *) * new_size);
 	}
 	else {
-		new_nodes =
-			rspamd_mempool_alloc (hash->pool,
-				sizeof (struct rspamd_hash_node *) * new_size);
+		new_nodes = rspamd_mempool_alloc (hash->pool, sizeof (struct rspamd_hash_node *) * new_size);
 	}
 
 	if (hash->shared) {
@@ -158,56 +150,46 @@ rspamd_hash_resize (rspamd_hash_t * hash)
 static inline void
 rspamd_hash_maybe_resize (rspamd_hash_t * hash)
 {
-	gint nnodes = hash->nnodes;
-	gint size = hash->size;
+	gint                            nnodes = hash->nnodes;
+	gint                            size = hash->size;
 
-	if ((size >= 3 * nnodes &&
-		size > HASH_TABLE_MIN_SIZE) ||
-		(3 * size <= nnodes && size < HASH_TABLE_MAX_SIZE)) {
+	if ((size >= 3 * nnodes && size > HASH_TABLE_MIN_SIZE) || (3 * size <= nnodes && size < HASH_TABLE_MAX_SIZE)) {
 		rspamd_hash_resize (hash);
 	}
 }
 
 /* Create new hash in specified pool */
-rspamd_hash_t *
-rspamd_hash_new (rspamd_mempool_t * pool,
-	GHashFunc hash_func,
-	GEqualFunc key_equal_func)
+rspamd_hash_t                  *
+rspamd_hash_new (rspamd_mempool_t * pool, GHashFunc hash_func, GEqualFunc key_equal_func)
 {
-	rspamd_hash_t *hash;
+	rspamd_hash_t                  *hash;
 
 	hash = rspamd_mempool_alloc (pool, sizeof (rspamd_hash_t));
 	hash->size = HASH_TABLE_MIN_SIZE;
 	hash->nnodes = 0;
 	hash->hash_func = hash_func ? hash_func : g_direct_hash;
 	hash->key_equal_func = key_equal_func;
-	hash->nodes = rspamd_mempool_alloc0 (pool,
-			sizeof (struct rspamd_hash_node *) * hash->size);
+	hash->nodes = rspamd_mempool_alloc0 (pool, sizeof (struct rspamd_hash_node *) * hash->size);
 	hash->shared = 0;
 	hash->pool = pool;
 
 	return hash;
 }
 
-/*
- * Create new hash in specified pool using shared memory
+/* 
+ * Create new hash in specified pool using shared memory 
  */
-rspamd_hash_t *
-rspamd_hash_new_shared (rspamd_mempool_t * pool,
-	GHashFunc hash_func,
-	GEqualFunc key_equal_func,
-	gint size)
+rspamd_hash_t                  *
+rspamd_hash_new_shared (rspamd_mempool_t * pool, GHashFunc hash_func, GEqualFunc key_equal_func, gint size)
 {
-	rspamd_hash_t *hash;
+	rspamd_hash_t                  *hash;
 
 	hash = rspamd_mempool_alloc_shared (pool, sizeof (rspamd_hash_t));
 	hash->size = size;
 	hash->nnodes = 0;
 	hash->hash_func = hash_func ? hash_func : g_direct_hash;
 	hash->key_equal_func = key_equal_func;
-	hash->nodes =
-		rspamd_mempool_alloc0_shared (pool,
-			sizeof (struct rspamd_hash_node *) * hash->size);
+	hash->nodes = rspamd_mempool_alloc0_shared (pool, sizeof (struct rspamd_hash_node *) * hash->size);
 	hash->shared = 1;
 	/* Get mutex from pool for locking on insert/remove operations */
 	hash->lock = rspamd_mempool_get_rwlock (pool);
@@ -216,14 +198,14 @@ rspamd_hash_new_shared (rspamd_mempool_t * pool,
 	return hash;
 }
 
-/*
- * Insert item in hash
+/* 
+ * Insert item in hash 
  */
 void
 rspamd_hash_insert (rspamd_hash_t * hash, gpointer key, gpointer value)
 {
-	struct rspamd_hash_node **node_ptr, *node;
-	guint key_hash;
+	struct rspamd_hash_node       **node_ptr, *node;
+	guint                           key_hash;
 
 	g_return_if_fail (hash != NULL);
 	node_ptr = rspamd_hash_lookup_node (hash, key, &key_hash);
@@ -237,14 +219,10 @@ rspamd_hash_insert (rspamd_hash_t * hash, gpointer key, gpointer value)
 	}
 	else {
 		if (hash->shared) {
-			node =
-				rspamd_mempool_alloc_shared (hash->pool,
-					sizeof (struct rspamd_hash_node));
+			node = rspamd_mempool_alloc_shared (hash->pool, sizeof (struct rspamd_hash_node));
 		}
 		else {
-			node =
-				rspamd_mempool_alloc (hash->pool,
-					sizeof (struct rspamd_hash_node));
+			node = rspamd_mempool_alloc (hash->pool, sizeof (struct rspamd_hash_node));
 		}
 
 		node->key = key;
@@ -264,13 +242,13 @@ rspamd_hash_insert (rspamd_hash_t * hash, gpointer key, gpointer value)
 	}
 }
 
-/*
- * Remove item from hash
+/* 
+ * Remove item from hash 
  */
 gboolean
 rspamd_hash_remove (rspamd_hash_t * hash, gpointer key)
 {
-	struct rspamd_hash_node **node_ptr;
+	struct rspamd_hash_node       **node_ptr;
 
 	g_return_val_if_fail (hash != NULL, FALSE);
 
@@ -284,13 +262,13 @@ rspamd_hash_remove (rspamd_hash_t * hash, gpointer key)
 	return TRUE;
 }
 
-/*
- * Lookup item from hash
+/* 
+ * Lookup item from hash 
  */
 gpointer
 rspamd_hash_lookup (rspamd_hash_t * hash, gpointer key)
 {
-	struct rspamd_hash_node *node;
+	struct rspamd_hash_node        *node;
 	g_return_val_if_fail (hash != NULL, NULL);
 
 	node = *rspamd_hash_lookup_node (hash, key, NULL);
@@ -298,14 +276,14 @@ rspamd_hash_lookup (rspamd_hash_t * hash, gpointer key)
 	return node ? node->value : NULL;
 }
 
-/*
- * Iterate throught hash
+/* 
+ * Iterate throught hash 
  */
 void
 rspamd_hash_foreach (rspamd_hash_t * hash, GHFunc func, gpointer user_data)
 {
-	struct rspamd_hash_node *node;
-	gint i;
+	struct rspamd_hash_node        *node;
+	gint                            i;
 
 	g_return_if_fail (hash != NULL);
 	g_return_if_fail (func != NULL);
@@ -315,7 +293,7 @@ rspamd_hash_foreach (rspamd_hash_t * hash, GHFunc func, gpointer user_data)
 	}
 	for (i = 0; i < hash->size; i++) {
 		for (node = hash->nodes[i]; node; node = node->next) {
-			(*func)(node->key, node->value, user_data);
+			(*func) (node->key, node->value, user_data);
 		}
 	}
 	if (hash->shared) {
@@ -330,7 +308,7 @@ rspamd_hash_foreach (rspamd_hash_t * hash, GHFunc func, gpointer user_data)
 static void
 rspamd_lru_hash_destroy_node (gpointer v)
 {
-	rspamd_lru_element_t *node = v;
+	rspamd_lru_element_t           *node = v;
 
 	if (node->hash->value_destroy) {
 		node->hash->value_destroy (node->data);
@@ -339,14 +317,10 @@ rspamd_lru_hash_destroy_node (gpointer v)
 	g_slice_free1 (sizeof (rspamd_lru_element_t), node);
 }
 
-static rspamd_lru_element_t *
-rspamd_lru_create_node (rspamd_lru_hash_t *hash,
-	gpointer key,
-	gpointer value,
-	time_t now,
-	guint ttl)
+static rspamd_lru_element_t*
+rspamd_lru_create_node (rspamd_lru_hash_t *hash, gpointer key, gpointer value, time_t now, guint ttl)
 {
-	rspamd_lru_element_t *node;
+	rspamd_lru_element_t           *node;
 
 	node = g_slice_alloc (sizeof (rspamd_lru_element_t));
 	node->data = value;
@@ -366,21 +340,14 @@ rspamd_lru_create_node (rspamd_lru_hash_t *hash,
  * @param key_equal_func pointer to function for comparing keys
  * @return new rspamd_hash object
  */
-rspamd_lru_hash_t *
-rspamd_lru_hash_new (GHashFunc hash_func,
-	GEqualFunc key_equal_func,
-	gint maxsize,
-	gint maxage,
-	GDestroyNotify key_destroy,
-	GDestroyNotify value_destroy)
+rspamd_lru_hash_t*
+rspamd_lru_hash_new (GHashFunc hash_func, GEqualFunc key_equal_func, gint maxsize, gint maxage,
+		GDestroyNotify key_destroy, GDestroyNotify value_destroy)
 {
-	rspamd_lru_hash_t *new;
+	rspamd_lru_hash_t              *new;
 
 	new = g_malloc (sizeof (rspamd_lru_hash_t));
-	new->storage = g_hash_table_new_full (hash_func,
-			key_equal_func,
-			key_destroy,
-			rspamd_lru_hash_destroy_node);
+	new->storage = g_hash_table_new_full (hash_func, key_equal_func, key_destroy, rspamd_lru_hash_destroy_node);
 	new->maxage = maxage;
 	new->maxsize = maxsize;
 	new->value_destroy = value_destroy;
@@ -401,19 +368,13 @@ rspamd_lru_hash_new (GHashFunc hash_func,
  * @param key_equal_func pointer to function for comparing keys
  * @return new rspamd_hash object
  */
-rspamd_lru_hash_t *
-rspamd_lru_hash_new_full (GHashFunc hash_func,
-	GEqualFunc key_equal_func,
-	gint maxsize,
-	gint maxage,
-	GDestroyNotify key_destroy,
-	GDestroyNotify value_destroy,
-	gpointer storage,
-	lru_cache_insert_func insert_func,
-	lru_cache_lookup_func lookup_func,
-	lru_cache_delete_func delete_func)
+rspamd_lru_hash_t*
+rspamd_lru_hash_new_full (GHashFunc hash_func, GEqualFunc key_equal_func,
+		gint maxsize, gint maxage, GDestroyNotify key_destroy, GDestroyNotify value_destroy,
+		gpointer storage, lru_cache_insert_func insert_func, lru_cache_lookup_func lookup_func,
+		lru_cache_delete_func delete_func)
 {
-	rspamd_lru_hash_t *new;
+	rspamd_lru_hash_t              *new;
 
 	new = g_malloc (sizeof (rspamd_lru_hash_t));
 	new->storage = storage;
@@ -439,7 +400,7 @@ rspamd_lru_hash_new_full (GHashFunc hash_func,
 gpointer
 rspamd_lru_hash_lookup (rspamd_lru_hash_t *hash, gpointer key, time_t now)
 {
-	rspamd_lru_element_t *res;
+	rspamd_lru_element_t           *res;
 
 	if ((res = hash->lookup_func (hash->storage, key)) != NULL) {
 		if (res->ttl != 0) {
@@ -473,17 +434,17 @@ rspamd_lru_hash_lookup (rspamd_lru_hash_t *hash, gpointer key, time_t now)
  */
 void
 rspamd_lru_hash_insert (rspamd_lru_hash_t *hash, gpointer key, gpointer value,
-	time_t now, guint ttl)
+		time_t now, guint ttl)
 {
-	rspamd_lru_element_t *res;
-	gint removed = 0;
+	rspamd_lru_element_t           *res;
+	gint                            removed = 0;
 
 	if ((res = hash->lookup_func (hash->storage, key)) != NULL) {
 		hash->delete_func (hash->storage, res->key);
 	}
 	else {
 		if (hash->maxsize > 0 &&
-			(gint)g_queue_get_length (hash->q) >= hash->maxsize) {
+				(gint)g_queue_get_length (hash->q) >= hash->maxsize) {
 			/* Expire some elements */
 			res = g_queue_peek_tail (hash->q);
 			if (hash->maxage > 0) {
@@ -495,7 +456,7 @@ rspamd_lru_hash_insert (rspamd_lru_hash_t *hash, gpointer key, gpointer value,
 						break;
 					}
 					res = g_queue_peek_tail (hash->q);
-					removed++;
+					removed ++;
 				}
 			}
 			if (removed == 0) {
diff --git a/src/libutil/hash.h b/src/libutil/hash.h
index 7f4f82b43..c5d4639af 100644
--- a/src/libutil/hash.h
+++ b/src/libutil/hash.h
@@ -10,50 +10,49 @@
 #include "mem_pool.h"
 
 struct rspamd_hash_node {
-	gpointer key;
-	gpointer value;
-	guint key_hash;
+	gpointer                 key;
+	gpointer                 value;
+	guint                    key_hash;
 	struct rspamd_hash_node *next;
 };
 
 typedef struct rspamd_hash_s {
-	gint size;
-	gint nnodes;
+	gint                      size;
+	gint                      nnodes;
 	struct rspamd_hash_node **nodes;
 
-	GHashFunc hash_func;
-	GEqualFunc key_equal_func;
-	gint shared;
-	rspamd_mempool_rwlock_t *lock;
-	rspamd_mempool_t *pool;
+	GHashFunc                 hash_func;
+	GEqualFunc                key_equal_func;
+	gint                      shared;
+	rspamd_mempool_rwlock_t     *lock;
+	rspamd_mempool_t            *pool;
 } rspamd_hash_t;
 
-typedef void (*lru_cache_insert_func)(gpointer storage, gpointer key,
-	gpointer value);
+typedef void (*lru_cache_insert_func)(gpointer storage, gpointer key, gpointer value);
 typedef gpointer (*lru_cache_lookup_func)(gpointer storage, gpointer key);
 typedef gboolean (*lru_cache_delete_func)(gpointer storage, gpointer key);
 typedef void (*lru_cache_destroy_func)(gpointer storage);
 
 typedef struct rspamd_lru_hash_s {
-	gint maxsize;
-	gint maxage;
-	GDestroyNotify value_destroy;
-	GDestroyNotify key_destroy;
-	GQueue *q;
-	gpointer storage;
-	lru_cache_insert_func insert_func;
-	lru_cache_lookup_func lookup_func;
-	lru_cache_delete_func delete_func;
-	lru_cache_destroy_func destroy_func;
+	gint                      maxsize;
+	gint                      maxage;
+	GDestroyNotify            value_destroy;
+	GDestroyNotify			  key_destroy;
+	GQueue                   *q;
+	gpointer                  storage;
+	lru_cache_insert_func     insert_func;
+	lru_cache_lookup_func     lookup_func;
+	lru_cache_delete_func     delete_func;
+	lru_cache_destroy_func    destroy_func;
 } rspamd_lru_hash_t;
 
 typedef struct rspamd_lru_element_s {
-	gpointer data;
-	gpointer key;
-	time_t store_time;
-	guint ttl;
-	rspamd_lru_hash_t *hash;
-	GList *link;
+	gpointer                  data;
+	gpointer                  key;
+	time_t                    store_time;
+	guint                     ttl;
+	rspamd_lru_hash_t        *hash;
+	GList                    *link;
 } rspamd_lru_element_t;
 
 
@@ -66,9 +65,7 @@ typedef struct rspamd_lru_element_s {
  * @param key_equal_func pointer to function for comparing keys
  * @return new rspamd_hash object
  */
-rspamd_hash_t * rspamd_hash_new (rspamd_mempool_t *pool,
-	GHashFunc hash_func,
-	GEqualFunc key_equal_func);
+rspamd_hash_t* rspamd_hash_new (rspamd_mempool_t *pool, GHashFunc hash_func, GEqualFunc key_equal_func);
 
 /**
  * Create new hash in specified pool using shared memory
@@ -77,10 +74,7 @@ rspamd_hash_t * rspamd_hash_new (rspamd_mempool_t *pool,
  * @param key_equal_func pointer to function for comparing keys
  * @return new rspamd_hash object
  */
-rspamd_hash_t * rspamd_hash_new_shared (rspamd_mempool_t *pool,
-	GHashFunc hash_func,
-	GEqualFunc key_equal_func,
-	gint size);
+rspamd_hash_t* rspamd_hash_new_shared (rspamd_mempool_t *pool, GHashFunc hash_func, GEqualFunc key_equal_func, gint size);
 
 /**
  * Insert item in hash
@@ -105,7 +99,7 @@ gboolean rspamd_hash_remove (rspamd_hash_t *hash, gpointer key);
  */
 gpointer rspamd_hash_lookup (rspamd_hash_t *hash, gpointer key);
 
-/**
+/** 
  * Iterate throught hash
  * @param hash hash object
  * @param func user's function that would be called for each key/value pair
@@ -121,12 +115,8 @@ void rspamd_hash_foreach (rspamd_hash_t *hash, GHFunc func, gpointer user_data);
  * @param key_equal_func pointer to function for comparing keys
  * @return new rspamd_hash object
  */
-rspamd_lru_hash_t * rspamd_lru_hash_new (GHashFunc hash_func,
-	GEqualFunc key_equal_func,
-	gint maxsize,
-	gint maxage,
-	GDestroyNotify key_destroy,
-	GDestroyNotify value_destroy);
+rspamd_lru_hash_t* rspamd_lru_hash_new (GHashFunc hash_func, GEqualFunc key_equal_func,
+		gint maxsize, gint maxage, GDestroyNotify key_destroy, GDestroyNotify value_destroy);
 
 /**
  * Create new lru hash with custom storage
@@ -136,36 +126,25 @@ rspamd_lru_hash_t * rspamd_lru_hash_new (GHashFunc hash_func,
  * @param key_equal_func pointer to function for comparing keys
  * @return new rspamd_hash object
  */
-rspamd_lru_hash_t * rspamd_lru_hash_new_full (GHashFunc hash_func,
-	GEqualFunc key_equal_func,
-	gint maxsize,
-	gint maxage,
-	GDestroyNotify key_destroy,
-	GDestroyNotify value_destroy,
-	gpointer storage,
-	lru_cache_insert_func insert_func,
-	lru_cache_lookup_func lookup_func,
-	lru_cache_delete_func delete_func);
+rspamd_lru_hash_t* rspamd_lru_hash_new_full (GHashFunc hash_func, GEqualFunc key_equal_func,
+		gint maxsize, gint maxage, GDestroyNotify key_destroy, GDestroyNotify value_destroy,
+		gpointer storage, lru_cache_insert_func insert_func, lru_cache_lookup_func lookup_func,
+		lru_cache_delete_func delete_func);
 /**
  * Lookup item from hash
  * @param hash hash object
  * @param key key to find
  * @return value of key or NULL if key is not found
  */
-gpointer rspamd_lru_hash_lookup (rspamd_lru_hash_t *hash,
-	gpointer key,
-	time_t now);
+gpointer rspamd_lru_hash_lookup (rspamd_lru_hash_t *hash, gpointer key, time_t now);
 /**
  * Insert item in hash
  * @param hash hash object
  * @param key key to insert
  * @param value value of key
  */
-void rspamd_lru_hash_insert (rspamd_lru_hash_t *hash,
-	gpointer key,
-	gpointer value,
-	time_t now,
-	guint ttl);
+void rspamd_lru_hash_insert (rspamd_lru_hash_t *hash, gpointer key, gpointer value,
+		time_t now, guint ttl);
 
 /**
  * Remove lru hash
diff --git a/src/libutil/http.c b/src/libutil/http.c
index 58eda7267..420dd165c 100644
--- a/src/libutil/http.c
+++ b/src/libutil/http.c
@@ -23,10 +23,10 @@
 
 #include "config.h"
 #include "http.h"
-#include "logger.h"
-#include "printf.h"
-#include "util.h"
 #include "utlist.h"
+#include "util.h"
+#include "printf.h"
+#include "logger.h"
 
 struct rspamd_http_connection_private {
 	GString *buf;
@@ -65,9 +65,9 @@ static const struct _rspamd_http_magic {
 	[HTTP_MAGIC_JPG] = { "jpg", "image/jpeg" },
 };
 
-static gchar *http_week[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-static gchar *http_month[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-							   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+static gchar  *http_week[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+static gchar  *http_month[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+							"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
 
 
 #define HTTP_ERROR http_error_quark ()
@@ -228,13 +228,13 @@ rspamd_http_parse_date (const gchar *header, gsize len)
 
 	if (fmt == rfc822) {
 		if (*p < '0' || *p > '9' || *(p + 1) < '0' || *(p + 1) > '9'
-			|| *(p + 2) < '0' || *(p + 2) > '9' || *(p + 3) < '0'
-			|| *(p + 3) > '9') {
+		|| *(p + 2) < '0' || *(p + 2) > '9' || *(p + 3) < '0'
+		|| *(p + 3) > '9') {
 			return (time_t)-1;
 		}
 
 		year = (*p - '0') * 1000 + (*(p + 1) - '0') * 100
-			+ (*(p + 2) - '0') * 10 + *(p + 3) - '0';
+				+ (*(p + 2) - '0') * 10 + *(p + 3) - '0';
 		p += 4;
 
 	}
@@ -312,13 +312,13 @@ rspamd_http_parse_date (const gchar *header, gsize len)
 		}
 
 		if (*p < '0' || *p > '9' || *(p + 1) < '0' || *(p + 1) > '9'
-			|| *(p + 2) < '0' || *(p + 2) > '9' || *(p + 3) < '0'
-			|| *(p + 3) > '9') {
+		|| *(p + 2) < '0' || *(p + 2) > '9' || *(p + 3) < '0'
+		|| *(p + 3) > '9') {
 			return (time_t)-1;
 		}
 
 		year = (*p - '0') * 1000 + (*(p + 1) - '0') * 100
-			+ (*(p + 2) - '0') * 10 + *(p + 3) - '0';
+				+ (*(p + 2) - '0') * 10 + *(p + 3) - '0';
 	}
 
 	if (hour > 23 || min > 59 || sec > 59) {
@@ -348,24 +348,24 @@ rspamd_http_parse_date (const gchar *header, gsize len)
 	/* Gauss' formula for Gregorian days since March 1, 1 BC */
 
 	time = (guint64) (
-	    /* days in years including leap years since March 1, 1 BC */
+			/* days in years including leap years since March 1, 1 BC */
 
-		365 * year + year / 4 - year / 100 + year / 400
+			365 * year + year / 4 - year / 100 + year / 400
 
-	    /* days before the month */
+			/* days before the month */
 
-		+ 367 * month / 12 - 30
+			+ 367 * month / 12 - 30
 
-	    /* days before the day */
+			/* days before the day */
 
-		+ day - 1
+			+ day - 1
 
-	    /*
-	     * 719527 days were between March 1, 1 BC and March 1, 1970,
-	     * 31 and 28 days were in January and February 1970
-	     */
+			/*
+			 * 719527 days were between March 1, 1 BC and March 1, 1970,
+			 * 31 and 28 days were in January and February 1970
+			 */
 
-		- 719527 + 31 + 28) * 86400 + hour * 3600 + min * 60 + sec;
+			- 719527 + 31 + 28) * 86400 + hour * 3600 + min * 60 + sec;
 
 	return (time_t) time;
 }
@@ -380,10 +380,9 @@ rspamd_http_check_date (struct rspamd_http_connection_private *priv)
 }
 
 static gint
-rspamd_http_on_url (http_parser * parser, const gchar *at, size_t length)
+rspamd_http_on_url (http_parser* parser, const gchar *at, size_t length)
 {
-	struct rspamd_http_connection *conn =
-		(struct rspamd_http_connection *)parser->data;
+	struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
 	struct rspamd_http_connection_private *priv;
 
 	priv = conn->priv;
@@ -394,10 +393,9 @@ rspamd_http_on_url (http_parser * parser, const gchar *at, size_t length)
 }
 
 static gint
-rspamd_http_on_status (http_parser * parser, const gchar *at, size_t length)
+rspamd_http_on_status (http_parser* parser, const gchar *at, size_t length)
 {
-	struct rspamd_http_connection *conn =
-		(struct rspamd_http_connection *)parser->data;
+	struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
 	struct rspamd_http_connection_private *priv;
 
 	priv = conn->priv;
@@ -413,12 +411,9 @@ rspamd_http_on_status (http_parser * parser, const gchar *at, size_t length)
 }
 
 static gint
-rspamd_http_on_header_field (http_parser * parser,
-	const gchar *at,
-	size_t length)
+rspamd_http_on_header_field (http_parser* parser, const gchar *at, size_t length)
 {
-	struct rspamd_http_connection *conn =
-		(struct rspamd_http_connection *)parser->data;
+	struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
 	struct rspamd_http_connection_private *priv;
 
 	priv = conn->priv;
@@ -443,12 +438,9 @@ rspamd_http_on_header_field (http_parser * parser,
 }
 
 static gint
-rspamd_http_on_header_value (http_parser * parser,
-	const gchar *at,
-	size_t length)
+rspamd_http_on_header_value (http_parser* parser, const gchar *at, size_t length)
 {
-	struct rspamd_http_connection *conn =
-		(struct rspamd_http_connection *)parser->data;
+	struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
 	struct rspamd_http_connection_private *priv;
 
 	priv = conn->priv;
@@ -465,10 +457,9 @@ rspamd_http_on_header_value (http_parser * parser,
 }
 
 static int
-rspamd_http_on_headers_complete (http_parser * parser)
+rspamd_http_on_headers_complete (http_parser* parser)
 {
-	struct rspamd_http_connection *conn =
-		(struct rspamd_http_connection *)parser->data;
+	struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
 	struct rspamd_http_connection_private *priv;
 
 	priv = conn->priv;
@@ -493,10 +484,9 @@ rspamd_http_on_headers_complete (http_parser * parser)
 }
 
 static int
-rspamd_http_on_body (http_parser * parser, const gchar *at, size_t length)
+rspamd_http_on_body (http_parser* parser, const gchar *at, size_t length)
 {
-	struct rspamd_http_connection *conn =
-		(struct rspamd_http_connection *)parser->data;
+	struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
 	struct rspamd_http_connection_private *priv;
 
 	priv = conn->priv;
@@ -511,10 +501,9 @@ rspamd_http_on_body (http_parser * parser, const gchar *at, size_t length)
 }
 
 static int
-rspamd_http_on_message_complete (http_parser * parser)
+rspamd_http_on_message_complete (http_parser* parser)
 {
-	struct rspamd_http_connection *conn =
-		(struct rspamd_http_connection *)parser->data;
+	struct rspamd_http_connection *conn = (struct rspamd_http_connection *)parser->data;
 	struct rspamd_http_connection_private *priv;
 	int ret = 0;
 
@@ -526,10 +515,7 @@ rspamd_http_on_message_complete (http_parser * parser)
 			ret = conn->body_handler (conn, priv->msg, NULL, 0);
 		}
 		else {
-			ret = conn->body_handler (conn,
-					priv->msg,
-					priv->msg->body->str,
-					priv->msg->body->len);
+			ret = conn->body_handler (conn, priv->msg, priv->msg->body->str, priv->msg->body->len);
 		}
 		rspamd_http_connection_unref (conn);
 	}
@@ -571,13 +557,13 @@ rspamd_http_write_helper (struct rspamd_http_connection *conn)
 	start = &priv->out[0];
 	niov = priv->outlen;
 	remain = priv->wr_pos;
-	for (i = 0; i < priv->outlen && remain > 0; i++) {
+	for (i = 0; i < priv->outlen && remain > 0; i ++) {
 		/* Find out the first iov required */
 		start = &priv->out[i];
 		if (start->iov_len <= remain) {
 			remain -= start->iov_len;
 			start = &priv->out[i + 1];
-			niov--;
+			niov --;
 		}
 		else {
 			start->iov_base = (void *)((char *)start->iov_base + remain);
@@ -589,9 +575,7 @@ rspamd_http_write_helper (struct rspamd_http_connection *conn)
 	r = writev (conn->fd, start, MIN (IOV_MAX, niov));
 
 	if (r == -1) {
-		err =
-			g_error_new (HTTP_ERROR, errno, "IO write error: %s", strerror (
-					errno));
+		err = g_error_new (HTTP_ERROR, errno, "IO write error: %s", strerror (errno));
 		rspamd_http_connection_ref (conn);
 		conn->error_handler (conn, err);
 		rspamd_http_connection_unref (conn);
@@ -629,10 +613,7 @@ rspamd_http_event_handler (int fd, short what, gpointer ud)
 	if (what == EV_READ) {
 		r = read (fd, buf->str, buf->allocated_len);
 		if (r == -1) {
-			err = g_error_new (HTTP_ERROR,
-					errno,
-					"IO read error: %s",
-					strerror (errno));
+			err = g_error_new (HTTP_ERROR, errno, "IO read error: %s", strerror (errno));
 			conn->error_handler (conn, err);
 			g_error_free (err);
 			return;
@@ -643,9 +624,7 @@ rspamd_http_event_handler (int fd, short what, gpointer ud)
 				return;
 			}
 			else {
-				err = g_error_new (HTTP_ERROR,
-						errno,
-						"IO read error: unexpected EOF");
+				err = g_error_new (HTTP_ERROR, errno, "IO read error: unexpected EOF");
 				conn->error_handler (conn, err);
 				g_error_free (err);
 				return;
@@ -654,11 +633,9 @@ rspamd_http_event_handler (int fd, short what, gpointer ud)
 		else {
 			buf->len = r;
 			rspamd_http_connection_ref (conn);
-			if (http_parser_execute (&priv->parser, &priv->parser_cb, buf->str,
-				r) != (size_t)r) {
+			if (http_parser_execute (&priv->parser, &priv->parser_cb, buf->str, r) != (size_t)r) {
 				err = g_error_new (HTTP_ERROR, priv->parser.http_errno,
-						"HTTP parser error: %s",
-						http_errno_description (priv->parser.http_errno));
+						"HTTP parser error: %s", http_errno_description (priv->parser.http_errno));
 				conn->error_handler (conn, err);
 				g_error_free (err);
 				rspamd_http_connection_unref (conn);
@@ -681,12 +658,12 @@ rspamd_http_event_handler (int fd, short what, gpointer ud)
 	}
 }
 
-struct rspamd_http_connection *
+struct rspamd_http_connection*
 rspamd_http_connection_new (rspamd_http_body_handler_t body_handler,
-	rspamd_http_error_handler_t error_handler,
-	rspamd_http_finish_handler_t finish_handler,
-	enum rspamd_http_options opts,
-	enum rspamd_http_connection_type type)
+		rspamd_http_error_handler_t error_handler,
+		rspamd_http_finish_handler_t finish_handler,
+		enum rspamd_http_options opts,
+		enum rspamd_http_connection_type type)
 {
 	struct rspamd_http_connection *new;
 	struct rspamd_http_connection_private *priv;
@@ -707,8 +684,7 @@ rspamd_http_connection_new (rspamd_http_body_handler_t body_handler,
 
 	/* Init priv */
 	priv = g_slice_alloc0 (sizeof (struct rspamd_http_connection_private));
-	http_parser_init (&priv->parser,
-		type == RSPAMD_HTTP_SERVER ? HTTP_REQUEST : HTTP_RESPONSE);
+	http_parser_init (&priv->parser, type == RSPAMD_HTTP_SERVER ? HTTP_REQUEST : HTTP_RESPONSE);
 	priv->parser.data = new;
 	priv->parser_cb.on_url = rspamd_http_on_url;
 	priv->parser_cb.on_status = rspamd_http_on_status;
@@ -758,20 +734,19 @@ rspamd_http_connection_free (struct rspamd_http_connection *conn)
 	priv = conn->priv;
 	rspamd_http_connection_reset (conn);
 	g_slice_free1 (sizeof (struct rspamd_http_connection_private), priv);
-	g_slice_free1 (sizeof (struct rspamd_http_connection),		   conn);
+	g_slice_free1 (sizeof (struct rspamd_http_connection), conn);
 }
 
 void
 rspamd_http_connection_read_message (struct rspamd_http_connection *conn,
-	gpointer ud, gint fd, struct timeval *timeout, struct event_base *base)
+		gpointer ud, gint fd, struct timeval *timeout, struct event_base *base)
 {
 	struct rspamd_http_connection_private *priv = conn->priv;
 	struct rspamd_http_message *req;
 
 	conn->fd = fd;
 	conn->ud = ud;
-	req = rspamd_http_new_message (
-		conn->type == RSPAMD_HTTP_SERVER ? HTTP_REQUEST : HTTP_RESPONSE);
+	req = rspamd_http_new_message (conn->type == RSPAMD_HTTP_SERVER ? HTTP_REQUEST : HTTP_RESPONSE);
 	priv->msg = req;
 
 	if (timeout == NULL) {
@@ -785,19 +760,15 @@ rspamd_http_connection_read_message (struct rspamd_http_connection *conn,
 	priv->buf = g_string_sized_new (BUFSIZ);
 	priv->new_header = TRUE;
 
-	event_set (&priv->ev,
-		fd,
-		EV_READ | EV_PERSIST,
-		rspamd_http_event_handler,
-		conn);
+	event_set (&priv->ev, fd, EV_READ | EV_PERSIST, rspamd_http_event_handler, conn);
 	event_base_set (base, &priv->ev);
 	event_add (&priv->ev, priv->ptv);
 }
 
 void
 rspamd_http_connection_write_message (struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg, const gchar *host, const gchar *mime_type,
-	gpointer ud, gint fd, struct timeval *timeout, struct event_base *base)
+		struct rspamd_http_message *msg, const gchar *host, const gchar *mime_type,
+		gpointer ud, gint fd, struct timeval *timeout, struct event_base *base)
 {
 	struct rspamd_http_connection_private *priv = conn->priv;
 	struct rspamd_http_header *hdr;
@@ -849,32 +820,29 @@ rspamd_http_connection_write_message (struct rspamd_http_connection *conn,
 		if (msg->method < HTTP_SYMBOLS) {
 			ptm = gmtime (&msg->date);
 			t = *ptm;
-			rspamd_snprintf (datebuf,
-				sizeof (datebuf),
-				"%s, %02d %s %4d %02d:%02d:%02d GMT",
-				http_week[t.tm_wday],
-				t.tm_mday,
-				http_month[t.tm_mon],
-				t.tm_year + 1900,
-				t.tm_hour,
-				t.tm_min,
-				t.tm_sec);
+			rspamd_snprintf (datebuf, sizeof (datebuf), "%s, %02d %s %4d %02d:%02d:%02d GMT",
+					http_week[t.tm_wday],
+					t.tm_mday,
+					http_month[t.tm_mon],
+					t.tm_year + 1900,
+					t.tm_hour,
+					t.tm_min,
+					t.tm_sec);
 			if (mime_type == NULL) {
 				mime_type = "text/plain";
 			}
 			rspamd_printf_gstring (priv->buf, "HTTP/1.1 %d %s\r\n"
-				"Connection: close\r\n"
-				"Server: %s\r\n"
-				"Date: %s\r\n"
-				"Content-Length: %z\r\n"
-				"Content-Type: %s\r\n",
-				msg->code,
-				msg->status ? msg->status->str : rspamd_http_code_to_str (msg->
-				code),
-				"rspamd/" RVERSION,
-				datebuf,
-				bodylen,
-				mime_type);
+					"Connection: close\r\n"
+					"Server: %s\r\n"
+					"Date: %s\r\n"
+					"Content-Length: %z\r\n"
+					"Content-Type: %s\r\n",
+					msg->code,
+					msg->status ? msg->status->str : rspamd_http_code_to_str (msg->code),
+					"rspamd/" RVERSION,
+					datebuf,
+					bodylen,
+					mime_type);
 		}
 		else {
 			/* Legacy spamd reply */
@@ -885,22 +853,21 @@ rspamd_http_connection_write_message (struct rspamd_http_connection *conn,
 		/* Format request */
 		if (host != NULL) {
 			rspamd_printf_gstring (priv->buf, "%s %v HTTP/1.1\r\n"
-				"Connection: close\r\n"
-				"Host: %s\r\n"
-				"Content-Length: %z\r\n",
+					"Connection: close\r\n"
+					"Host: %s\r\n"
+					"Content-Length: %z\r\n",
 				http_method_str (msg->method), msg->url, host, bodylen);
 		}
 		else {
 			/* Fallback to HTTP/1.0 */
 			rspamd_printf_gstring (priv->buf, "%s %v HTTP/1.0\r\n"
-				"Content-Length: %z\r\n",
+					"Content-Length: %z\r\n",
 				http_method_str (msg->method), msg->url, bodylen);
 		}
 	}
 	/* Allocate iov */
 	priv->wr_total = bodylen + priv->buf->len + 2;
-	DL_FOREACH (msg->headers, hdr)
-	{
+	DL_FOREACH (msg->headers, hdr) {
 		/* <name><: ><value><\r\n> */
 		priv->wr_total += hdr->name->len + hdr->value->len + 4;
 		priv->outlen += 4;
@@ -912,8 +879,7 @@ rspamd_http_connection_write_message (struct rspamd_http_connection *conn,
 	priv->out[0].iov_base = priv->buf->str;
 	priv->out[0].iov_len = priv->buf->len;
 	i = 1;
-	LL_FOREACH (msg->headers, hdr)
-	{
+	LL_FOREACH (msg->headers, hdr) {
 		priv->out[i].iov_base = hdr->name->str;
 		priv->out[i++].iov_len = hdr->name->len;
 		priv->out[i].iov_base = ": ";
@@ -941,7 +907,7 @@ rspamd_http_connection_write_message (struct rspamd_http_connection *conn,
 	event_add (&priv->ev, priv->ptv);
 }
 
-struct rspamd_http_message *
+struct rspamd_http_message*
 rspamd_http_new_message (enum http_parser_type type)
 {
 	struct rspamd_http_message *new;
@@ -969,9 +935,8 @@ rspamd_http_message_free (struct rspamd_http_message *msg)
 {
 	struct rspamd_http_header *hdr, *tmp_hdr;
 
-	LL_FOREACH_SAFE (msg->headers, hdr, tmp_hdr)
-	{
-		g_string_free (hdr->name,  TRUE);
+	LL_FOREACH_SAFE (msg->headers, hdr, tmp_hdr) {
+		g_string_free (hdr->name, TRUE);
 		g_string_free (hdr->value, TRUE);
 		g_slice_free1 (sizeof (struct rspamd_http_header), hdr);
 	}
@@ -987,10 +952,9 @@ rspamd_http_message_free (struct rspamd_http_message *msg)
 	g_slice_free1 (sizeof (struct rspamd_http_message), msg);
 }
 
-void
-rspamd_http_message_add_header (struct rspamd_http_message *msg,
-	const gchar *name,
-	const gchar *value)
+void rspamd_http_message_add_header (struct rspamd_http_message *msg,
+		const gchar *name,
+		const gchar *value)
 {
 	struct rspamd_http_header *hdr;
 
@@ -1002,17 +966,15 @@ rspamd_http_message_add_header (struct rspamd_http_message *msg,
 	}
 }
 
-const gchar *
-rspamd_http_message_find_header (struct rspamd_http_message *msg,
-	const gchar *name)
+const gchar*
+rspamd_http_message_find_header (struct rspamd_http_message *msg, const gchar *name)
 {
 	struct rspamd_http_header *hdr;
 	const gchar *res = NULL;
 	guint slen = strlen (name);
 
 	if (msg != NULL) {
-		LL_FOREACH (msg->headers, hdr)
-		{
+		LL_FOREACH (msg->headers, hdr) {
 			if (hdr->name->len == slen) {
 				if (memcmp (hdr->name->str, name, slen) == 0) {
 					res = hdr->value->str;
@@ -1043,8 +1005,7 @@ rspamd_http_entry_free (struct rspamd_http_connection_entry *entry)
 }
 
 static void
-rspamd_http_router_error_handler (struct rspamd_http_connection *conn,
-	GError *err)
+rspamd_http_router_error_handler (struct rspamd_http_connection *conn, GError *err)
 {
 	struct rspamd_http_connection_entry *entry = conn->ud;
 	struct rspamd_http_message *msg;
@@ -1066,14 +1027,8 @@ rspamd_http_router_error_handler (struct rspamd_http_connection *conn,
 		msg->code = err->code;
 		msg->body = g_string_new (err->message);
 		rspamd_http_connection_reset (entry->conn);
-		rspamd_http_connection_write_message (entry->conn,
-			msg,
-			NULL,
-			"text/plain",
-			entry,
-			entry->conn->fd,
-			entry->rt->ptv,
-			entry->rt->ev_base);
+		rspamd_http_connection_write_message (entry->conn, msg, NULL,
+					"text/plain", entry, entry->conn->fd, entry->rt->ptv, entry->rt->ev_base);
 		entry->is_reply = TRUE;
 	}
 }
@@ -1088,9 +1043,9 @@ rspamd_http_router_detect_ct (const gchar *path)
 	if (dot == NULL) {
 		return http_file_types[HTTP_MAGIC_PLAIN].ct;
 	}
-	dot++;
+	dot ++;
 
-	for (i = 0; i < G_N_ELEMENTS (http_file_types); i++) {
+	for (i = 0; i < G_N_ELEMENTS (http_file_types); i ++) {
 		if (strcmp (http_file_types[i].ext, dot) == 0) {
 			return http_file_types[i].ct;
 		}
@@ -1110,11 +1065,11 @@ rspamd_http_router_is_subdir (const gchar *parent, const gchar *sub)
 		if (*sub != *parent) {
 			return FALSE;
 		}
-		parent++;
-		sub++;
+		parent ++;
+		sub ++;
 	}
 
-	parent--;
+	parent --;
 	if (*parent == G_DIR_SEPARATOR) {
 		return TRUE;
 	}
@@ -1124,7 +1079,7 @@ rspamd_http_router_is_subdir (const gchar *parent, const gchar *sub)
 
 static gboolean
 rspamd_http_router_try_file (struct rspamd_http_connection_entry *entry,
-	struct rspamd_http_message *msg, gboolean expand_path)
+		struct rspamd_http_message *msg, gboolean expand_path)
 {
 	struct stat st;
 	gint fd;
@@ -1132,17 +1087,17 @@ rspamd_http_router_try_file (struct rspamd_http_connection_entry *entry,
 	struct rspamd_http_message *reply_msg;
 
 	rspamd_snprintf (filebuf, sizeof (filebuf), "%s%c%v",
-		entry->rt->default_fs_path, G_DIR_SEPARATOR, msg->url);
+			entry->rt->default_fs_path, G_DIR_SEPARATOR, msg->url);
 
 	if (realpath (filebuf, realbuf) == NULL ||
-		lstat (realbuf, &st) == -1) {
+			lstat (realbuf, &st) == -1) {
 		return FALSE;
 	}
 
 	if (S_ISDIR (st.st_mode) && expand_path) {
 		/* Try to append 'index.html' to the url */
 		g_string_append_printf (msg->url, "%c%s", G_DIR_SEPARATOR,
-			"index.html");
+				"index.html");
 		return rspamd_http_router_try_file (entry, msg, FALSE);
 	}
 	else if (!S_ISREG (st.st_mode)) {
@@ -1152,9 +1107,8 @@ rspamd_http_router_try_file (struct rspamd_http_connection_entry *entry,
 	/* We also need to ensure that file is inside the defined dir */
 	rspamd_strlcpy (filebuf, realbuf, sizeof (filebuf));
 	dir = dirname (filebuf);
-	if (dir == NULL ||
-		!rspamd_http_router_is_subdir (entry->rt->default_fs_path,
-		dir)) {
+	if (dir == NULL || !rspamd_http_router_is_subdir (entry->rt->default_fs_path,
+			dir)) {
 		return FALSE;
 	}
 
@@ -1182,15 +1136,15 @@ rspamd_http_router_try_file (struct rspamd_http_connection_entry *entry,
 
 	/* XXX: detect content type */
 	rspamd_http_connection_write_message (entry->conn, reply_msg, NULL,
-		rspamd_http_router_detect_ct (realbuf), entry, entry->conn->fd,
-		entry->rt->ptv, entry->rt->ev_base);
+			rspamd_http_router_detect_ct (realbuf), entry, entry->conn->fd,
+			entry->rt->ptv, entry->rt->ev_base);
 
 	return TRUE;
 }
 
 static int
 rspamd_http_router_finish_handler (struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
 	struct rspamd_http_connection_entry *entry = conn->ud;
 	rspamd_http_router_handler_t handler = NULL;
@@ -1198,8 +1152,7 @@ rspamd_http_router_finish_handler (struct rspamd_http_connection *conn,
 	struct rspamd_http_message *err_msg;
 	GError *err;
 
-	G_STATIC_ASSERT (sizeof (rspamd_http_router_handler_t) ==
-		sizeof (gpointer));
+	G_STATIC_ASSERT (sizeof (rspamd_http_router_handler_t) == sizeof (gpointer));
 
 	if (entry->is_reply) {
 		/* Request is finished, it is safe to free a connection */
@@ -1217,7 +1170,7 @@ rspamd_http_router_finish_handler (struct rspamd_http_connection *conn,
 		}
 		else {
 			if (entry->rt->default_fs_path == NULL ||
-				!rspamd_http_router_try_file (entry, msg, TRUE)) {
+					!rspamd_http_router_try_file (entry, msg, TRUE)) {
 				err = g_error_new (HTTP_ERROR, 404,
 						"Not found");
 				if (entry->rt->error_handler != NULL) {
@@ -1228,14 +1181,9 @@ rspamd_http_router_finish_handler (struct rspamd_http_connection *conn,
 				err_msg->code = err->code;
 				err_msg->body = g_string_new (err->message);
 				rspamd_http_connection_reset (entry->conn);
-				rspamd_http_connection_write_message (entry->conn,
-					err_msg,
-					NULL,
-					"text/plain",
-					entry,
-					entry->conn->fd,
-					entry->rt->ptv,
-					entry->rt->ev_base);
+				rspamd_http_connection_write_message (entry->conn, err_msg, NULL,
+						"text/plain", entry, entry->conn->fd,
+						entry->rt->ptv, entry->rt->ev_base);
 				g_error_free (err);
 			}
 		}
@@ -1244,13 +1192,13 @@ rspamd_http_router_finish_handler (struct rspamd_http_connection *conn,
 	return 0;
 }
 
-struct rspamd_http_connection_router *
+struct rspamd_http_connection_router*
 rspamd_http_router_new (rspamd_http_router_error_handler_t eh,
-	rspamd_http_router_finish_handler_t fh,
-	struct timeval *timeout, struct event_base *base,
-	const char *default_fs_path)
+		rspamd_http_router_finish_handler_t fh,
+		struct timeval *timeout, struct event_base *base,
+		const char *default_fs_path)
 {
-	struct rspamd_http_connection_router * new;
+	struct rspamd_http_connection_router* new;
 	struct stat st;
 
 	new = g_slice_alloc (sizeof (struct rspamd_http_connection_router));
@@ -1287,11 +1235,10 @@ rspamd_http_router_new (rspamd_http_router_error_handler_t eh,
 
 void
 rspamd_http_router_add_path (struct rspamd_http_connection_router *router,
-	const gchar *path, rspamd_http_router_handler_t handler)
+		const gchar *path, rspamd_http_router_handler_t handler)
 {
 	gpointer ptr;
-	G_STATIC_ASSERT (sizeof (rspamd_http_router_handler_t) ==
-		sizeof (gpointer));
+	G_STATIC_ASSERT (sizeof (rspamd_http_router_handler_t) == sizeof (gpointer));
 
 	if (path != NULL && handler != NULL && router != NULL) {
 		memcpy (&ptr, &handler, sizeof (ptr));
@@ -1301,7 +1248,7 @@ rspamd_http_router_add_path (struct rspamd_http_connection_router *router,
 
 void
 rspamd_http_router_handle_socket (struct rspamd_http_connection_router *router,
-	gint fd, gpointer ud)
+		gint fd, gpointer ud)
 {
 	struct rspamd_http_connection_entry *conn;
 
@@ -1310,14 +1257,11 @@ rspamd_http_router_handle_socket (struct rspamd_http_connection_router *router,
 	conn->ud = ud;
 	conn->is_reply = FALSE;
 
-	conn->conn = rspamd_http_connection_new (NULL,
-			rspamd_http_router_error_handler,
-			rspamd_http_router_finish_handler,
-			0,
-			RSPAMD_HTTP_SERVER);
+	conn->conn = rspamd_http_connection_new (NULL, rspamd_http_router_error_handler,
+			rspamd_http_router_finish_handler, 0, RSPAMD_HTTP_SERVER);
 
 	rspamd_http_connection_read_message (conn->conn, conn, fd, router->ptv,
-		router->ev_base);
+			router->ev_base);
 	LL_PREPEND (router->conns, conn);
 }
 
@@ -1327,8 +1271,7 @@ rspamd_http_router_free (struct rspamd_http_connection_router *router)
 	struct rspamd_http_connection_entry *conn, *tmp;
 
 	if (router) {
-		LL_FOREACH_SAFE (router->conns, conn, tmp)
-		{
+		LL_FOREACH_SAFE (router->conns, conn, tmp) {
 			rspamd_http_entry_free (conn);
 		}
 
diff --git a/src/libutil/http.h b/src/libutil/http.h
index c6a142e3b..695f23896 100644
--- a/src/libutil/http.h
+++ b/src/libutil/http.h
@@ -67,7 +67,7 @@ struct rspamd_http_message {
  * Options for HTTP connection
  */
 enum rspamd_http_options {
-	RSPAMD_HTTP_BODY_PARTIAL = 0x1 //!< RSPAMD_HTTP_BODY_PARTIAL
+	RSPAMD_HTTP_BODY_PARTIAL = 0x1//!< RSPAMD_HTTP_BODY_PARTIAL
 };
 
 struct rspamd_http_connection_private;
@@ -76,24 +76,20 @@ struct rspamd_http_connection_router;
 struct rspamd_http_connection_entry;
 
 typedef int (*rspamd_http_body_handler_t) (struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg,
-	const gchar *chunk,
-	gsize len);
+		struct rspamd_http_message *msg,
+		const gchar *chunk,
+		gsize len);
 
-typedef void (*rspamd_http_error_handler_t) (struct rspamd_http_connection *conn,
-	GError *err);
+typedef void (*rspamd_http_error_handler_t) (struct rspamd_http_connection *conn, GError *err);
 
 typedef int (*rspamd_http_finish_handler_t) (struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg);
+		struct rspamd_http_message *msg);
 
-typedef int (*rspamd_http_router_handler_t) (struct rspamd_http_connection_entry
-	*conn_ent,
-	struct rspamd_http_message *msg);
-typedef void (*rspamd_http_router_error_handler_t) (struct
-	rspamd_http_connection_entry *conn_ent,
-	GError *err);
-typedef void (*rspamd_http_router_finish_handler_t) (struct
-	rspamd_http_connection_entry *conn_ent);
+typedef int (*rspamd_http_router_handler_t) (struct rspamd_http_connection_entry *conn_ent,
+		struct rspamd_http_message *msg);
+typedef void (*rspamd_http_router_error_handler_t) (struct rspamd_http_connection_entry *conn_ent,
+		GError *err);
+typedef void (*rspamd_http_router_finish_handler_t) (struct rspamd_http_connection_entry *conn_ent);
 
 /**
  * HTTP connection structure
@@ -136,12 +132,12 @@ struct rspamd_http_connection_router {
  * @param opts options
  * @return new connection structure
  */
-struct rspamd_http_connection * rspamd_http_connection_new (
-	rspamd_http_body_handler_t body_handler,
-	rspamd_http_error_handler_t error_handler,
-	rspamd_http_finish_handler_t finish_handler,
-	enum rspamd_http_options opts,
-	enum rspamd_http_connection_type type);
+struct rspamd_http_connection* rspamd_http_connection_new (
+		rspamd_http_body_handler_t body_handler,
+		rspamd_http_error_handler_t error_handler,
+		rspamd_http_finish_handler_t finish_handler,
+		enum rspamd_http_options opts,
+		enum rspamd_http_connection_type type);
 
 /**
  * Handle a request using socket fd and user data ud
@@ -150,11 +146,11 @@ struct rspamd_http_connection * rspamd_http_connection_new (
  * @param fd fd to read/write
  */
 void rspamd_http_connection_read_message (
-	struct rspamd_http_connection *conn,
-	gpointer ud,
-	gint fd,
-	struct timeval *timeout,
-	struct event_base *base);
+		struct rspamd_http_connection *conn,
+		gpointer ud,
+		gint fd,
+		struct timeval *timeout,
+		struct event_base *base);
 
 /**
  * Send reply using initialised connection
@@ -164,14 +160,14 @@ void rspamd_http_connection_read_message (
  * @param fd fd to read/write
  */
 void rspamd_http_connection_write_message (
-	struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg,
-	const gchar *host,
-	const gchar *mime_type,
-	gpointer ud,
-	gint fd,
-	struct timeval *timeout,
-	struct event_base *base);
+		struct rspamd_http_connection *conn,
+		struct rspamd_http_message *msg,
+		const gchar *host,
+		const gchar *mime_type,
+		gpointer ud,
+		gint fd,
+		struct timeval *timeout,
+		struct event_base *base);
 
 /**
  * Free connection structure
@@ -187,7 +183,7 @@ void rspamd_http_connection_free (struct rspamd_http_connection *conn);
 static inline struct rspamd_http_connection *
 rspamd_http_connection_ref (struct rspamd_http_connection *conn)
 {
-	conn->ref++;
+	conn->ref ++;
 	return conn;
 }
 
@@ -214,7 +210,7 @@ void rspamd_http_connection_reset (struct rspamd_http_connection *conn);
  * @param code code to pass
  * @return new reply object
  */
-struct rspamd_http_message * rspamd_http_new_message (enum http_parser_type type);
+struct rspamd_http_message* rspamd_http_new_message (enum http_parser_type type);
 
 /**
  * Append a header to reply
@@ -222,17 +218,14 @@ struct rspamd_http_message * rspamd_http_new_message (enum http_parser_type type
  * @param name
  * @param value
  */
-void rspamd_http_message_add_header (struct rspamd_http_message *rep,
-	const gchar *name,
-	const gchar *value);
+void rspamd_http_message_add_header (struct rspamd_http_message *rep, const gchar *name, const gchar *value);
 
 /**
  * Search for a specified header in message
  * @param rep message
  * @param name name of header
  */
-const gchar * rspamd_http_message_find_header (struct rspamd_http_message *rep,
-	const gchar *name);
+const gchar* rspamd_http_message_find_header (struct rspamd_http_message *rep, const gchar *name);
 
 /**
  * Free HTTP reply
@@ -256,18 +249,18 @@ time_t rspamd_http_parse_date (const gchar *header, gsize len);
  * the specified directory
  * @return
  */
-struct rspamd_http_connection_router * rspamd_http_router_new (
-	rspamd_http_router_error_handler_t eh,
-	rspamd_http_router_finish_handler_t fh,
-	struct timeval *timeout,
-	struct event_base *base,
-	const char *default_fs_path);
+struct rspamd_http_connection_router* rspamd_http_router_new (
+		rspamd_http_router_error_handler_t eh,
+		rspamd_http_router_finish_handler_t fh,
+		struct timeval *timeout,
+		struct event_base *base,
+		const char *default_fs_path);
 
 /**
  * Add new path to the router
  */
 void rspamd_http_router_add_path (struct rspamd_http_connection_router *router,
-	const gchar *path, rspamd_http_router_handler_t handler);
+		const gchar *path, rspamd_http_router_handler_t handler);
 
 /**
  * Handle new accepted socket
@@ -275,10 +268,8 @@ void rspamd_http_router_add_path (struct rspamd_http_connection_router *router,
  * @param fd server socket
  * @param ud opaque userdata
  */
-void rspamd_http_router_handle_socket (
-	struct rspamd_http_connection_router *router,
-	gint fd,
-	gpointer ud);
+void rspamd_http_router_handle_socket (struct rspamd_http_connection_router *router,
+		gint fd, gpointer ud);
 
 /**
  * Free router and all connections associated
diff --git a/src/libutil/logger.c b/src/libutil/logger.c
index a3211078a..47e308ecd 100644
--- a/src/libutil/logger.c
+++ b/src/libutil/logger.c
@@ -25,9 +25,9 @@
 
 #include "config.h"
 #include "logger.h"
+#include "util.h"
 #include "main.h"
 #include "map.h"
-#include "util.h"
 
 /* How much message should be repeated before it is count to be repeated one */
 #define REPEATS_MIN 3
@@ -38,29 +38,29 @@
  * It is NOT shared between processes and is created by main process
  */
 struct rspamd_logger_s {
-	rspamd_log_func_t log_func;
-	struct rspamd_config *cfg;
+	rspamd_log_func_t        log_func;
+	struct rspamd_config		*cfg;
 	struct {
-		guint32 size;
-		guint32 used;
-		u_char *buf;
+		guint32              size;
+		guint32              used;
+		u_char              *buf;
 	}                        io_buf;
-	gint fd;
-	gboolean is_buffered;
-	gboolean enabled;
-	gboolean is_debug;
-	gboolean throttling;
-	time_t throttling_time;
-	sig_atomic_t do_reopen_log;
-	enum rspamd_log_type type;
-	pid_t pid;
-	GQuark process_type;
-	radix_tree_t *debug_ip;
-	guint32 last_line_cksum;
-	guint32 repeats;
-	gchar *saved_message;
-	gchar *saved_function;
-	GMutex *mtx;
+	gint                     fd;
+	gboolean                 is_buffered;
+	gboolean                 enabled;
+	gboolean                 is_debug;
+	gboolean                 throttling;
+	time_t                   throttling_time;
+	sig_atomic_t             do_reopen_log;
+	enum rspamd_log_type     type;
+	pid_t                    pid;
+	GQuark					 process_type;
+	radix_tree_t            *debug_ip;
+	guint32                  last_line_cksum;
+	guint32                  repeats;
+	gchar                   *saved_message;
+	gchar                   *saved_function;
+	GMutex					*mtx;
 };
 
 static const gchar lf_chr = '\n';
@@ -69,13 +69,13 @@ static rspamd_logger_t *default_logger = NULL;
 
 
 static void
-syslog_log_function (const gchar * log_domain, const gchar *function,
-	GLogLevelFlags log_level, const gchar * message,
-	gboolean forced, gpointer arg);
+syslog_log_function (const gchar * log_domain, const gchar *function, 
+					GLogLevelFlags log_level, const gchar * message, 
+					gboolean forced, gpointer arg);
 static void
-file_log_function (const gchar * log_domain, const gchar *function,
-	GLogLevelFlags log_level, const gchar * message,
-	gboolean forced, gpointer arg);
+file_log_function (const gchar * log_domain, const gchar *function, 
+					GLogLevelFlags log_level, const gchar * message, 
+					gboolean forced, gpointer arg);
 
 /**
  * Calculate checksum for log line (used for repeating logic)
@@ -83,36 +83,31 @@ file_log_function (const gchar * log_domain, const gchar *function,
 static inline guint32
 rspamd_log_calculate_cksum (const gchar *message, size_t mlen)
 {
-	const gchar *bp = message;
-	const gchar *be = bp + mlen;
-	guint32 hval = 0;
-
-	while (bp < be) {
-		hval +=
-			(hval <<
-			1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
-		hval ^= (guint32) * bp++;
-	}
-
-	/* return our new hash value */
-	return hval;
-
+	const gchar                    *bp = message;
+	const gchar                    *be = bp + mlen;
+	guint32                         hval = 0;
+
+    while (bp < be) {
+		hval += (hval<<1) + (hval<<4) + (hval<<7) + (hval<<8) + (hval<<24);
+		hval ^= (guint32)*bp++;
+    }
+
+    /* return our new hash value */
+    return hval;
+	
 }
 
 /*
  * Write a line to log file (unbuffered)
  */
 static void
-direct_write_log_line (rspamd_logger_t *rspamd_log,
-	void *data,
-	gint count,
-	gboolean is_iov)
+direct_write_log_line (rspamd_logger_t *rspamd_log, void *data, gint count, gboolean is_iov)
 {
-	gchar errmsg[128];
-	struct iovec *iov;
-	const gchar *line;
-	gint r;
-
+	gchar                           errmsg[128];
+	struct iovec                  *iov;
+	const gchar                    *line;
+	gint                            r;
+	
 	if (rspamd_log->enabled) {
 		if (is_iov) {
 			iov = (struct iovec *)data;
@@ -124,10 +119,7 @@ direct_write_log_line (rspamd_logger_t *rspamd_log,
 		}
 		if (r == -1) {
 			/* We cannot write message to file, so we need to detect error and make decision */
-			r = rspamd_snprintf (errmsg,
-					sizeof (errmsg),
-					"direct_write_log_line: cannot write log line: %s",
-					strerror (errno));
+			r = rspamd_snprintf (errmsg, sizeof (errmsg), "direct_write_log_line: cannot write log line: %s", strerror (errno));
 			if (errno == EIO || errno == EINTR) {
 				/* Descriptor is somehow invalid, try to restart */
 				reopen_log (rspamd_log);
@@ -136,8 +128,7 @@ direct_write_log_line (rspamd_logger_t *rspamd_log,
 					direct_write_log_line (rspamd_log, data, count, is_iov);
 				}
 			}
-			else if (errno == EFAULT || errno == EINVAL || errno == EFBIG ||
-				errno == ENOSPC) {
+			else if (errno == EFAULT || errno == EINVAL || errno == EFBIG || errno == ENOSPC) {
 				/* Rare case */
 				rspamd_log->throttling = TRUE;
 				rspamd_log->throttling_time = time (NULL);
@@ -165,7 +156,7 @@ rspamd_escape_log_string (gchar *str)
 		else if (*p == '\n' || *p == '\r') {
 			*p = ' ';
 		}
-		p++;
+		p ++;
 	}
 }
 
@@ -183,17 +174,16 @@ open_log_priv (rspamd_logger_t *rspamd_log, uid_t uid, gid_t gid)
 		rspamd_log->enabled = TRUE;
 		return 0;
 	case RSPAMD_LOG_FILE:
-		rspamd_log->fd = open (rspamd_log->cfg->log_file,
-				O_CREAT | O_WRONLY | O_APPEND,
+		rspamd_log->fd = open (rspamd_log->cfg->log_file, O_CREAT | O_WRONLY | O_APPEND,
 				S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
 		if (rspamd_log->fd == -1) {
 			fprintf (stderr, "open_log: cannot open desired log file: %s, %s",
-				rspamd_log->cfg->log_file, strerror (errno));
+					rspamd_log->cfg->log_file, strerror (errno));
 			return -1;
 		}
 		if (fchown (rspamd_log->fd, uid, gid) == -1) {
 			fprintf (stderr, "open_log: cannot chown desired log file: %s, %s",
-				rspamd_log->cfg->log_file, strerror (errno));
+					rspamd_log->cfg->log_file, strerror (errno));
 			close (rspamd_log->fd);
 			return -1;
 		}
@@ -206,7 +196,7 @@ open_log_priv (rspamd_logger_t *rspamd_log, uid_t uid, gid_t gid)
 void
 close_log_priv (rspamd_logger_t *rspamd_log, uid_t uid, gid_t gid)
 {
-	gchar tmpbuf[256];
+	gchar                           tmpbuf[256];
 	flush_log_buf (rspamd_log);
 
 	switch (rspamd_log->type) {
@@ -219,30 +209,17 @@ close_log_priv (rspamd_logger_t *rspamd_log, uid_t uid, gid_t gid)
 	case RSPAMD_LOG_FILE:
 		if (rspamd_log->enabled) {
 			if (rspamd_log->repeats > REPEATS_MIN) {
-				rspamd_snprintf (tmpbuf,
-					sizeof (tmpbuf),
-					"Last message repeated %ud times",
-					rspamd_log->repeats);
+				rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "Last message repeated %ud times", rspamd_log->repeats);
 				rspamd_log->repeats = 0;
 				if (rspamd_log->saved_message) {
-					file_log_function (NULL,
-						rspamd_log->saved_function,
-						rspamd_log->cfg->log_level,
-						rspamd_log->saved_message,
-						TRUE,
-						rspamd_log);
+					file_log_function (NULL, rspamd_log->saved_function, rspamd_log->cfg->log_level, rspamd_log->saved_message, TRUE, rspamd_log);
 					g_free (rspamd_log->saved_message);
 					g_free (rspamd_log->saved_function);
 					rspamd_log->saved_message = NULL;
 					rspamd_log->saved_function = NULL;
-				}
+				}	
 				/* It is safe to use temporary buffer here as it is not static */
-				file_log_function (NULL,
-					__FUNCTION__,
-					rspamd_log->cfg->log_level,
-					tmpbuf,
-					TRUE,
-					rspamd_log);
+				file_log_function (NULL, __FUNCTION__, rspamd_log->cfg->log_level, tmpbuf, TRUE, rspamd_log);
 				return;
 			}
 
@@ -298,14 +275,12 @@ reopen_log (rspamd_logger_t *logger)
  * Setup logger
  */
 void
-rspamd_set_logger (struct rspamd_config *cfg,
-	GQuark ptype,
-	struct rspamd_main *rspamd)
+rspamd_set_logger (struct rspamd_config *cfg, GQuark ptype, struct rspamd_main *rspamd)
 {
-	gchar **strvec, *p, *err;
-	gint num, i, k;
-	struct in_addr addr;
-	guint32 mask = 0xFFFFFFFF;
+	gchar                           **strvec, *p, *err;
+	gint                            num, i, k;
+	struct in_addr                  addr;
+	guint32                         mask = 0xFFFFFFFF;
 
 	if (rspamd->logger == NULL) {
 		rspamd->logger = g_malloc (sizeof (rspamd_logger_t));
@@ -324,16 +299,16 @@ rspamd_set_logger (struct rspamd_config *cfg,
 #endif
 
 	switch (cfg->log_type) {
-	case RSPAMD_LOG_CONSOLE:
-		rspamd->logger->log_func = file_log_function;
-		rspamd->logger->fd = STDERR_FILENO;
-		break;
-	case RSPAMD_LOG_SYSLOG:
-		rspamd->logger->log_func = syslog_log_function;
-		break;
-	case RSPAMD_LOG_FILE:
-		rspamd->logger->log_func = file_log_function;
-		break;
+		case RSPAMD_LOG_CONSOLE:
+			rspamd->logger->log_func = file_log_function;
+			rspamd->logger->fd = STDERR_FILENO;
+			break;
+		case RSPAMD_LOG_SYSLOG:
+			rspamd->logger->log_func = syslog_log_function;
+			break;
+		case RSPAMD_LOG_FILE:
+			rspamd->logger->log_func = file_log_function;
+			break;
 	}
 
 	rspamd->logger->cfg = cfg;
@@ -355,10 +330,8 @@ rspamd_set_logger (struct rspamd_config *cfg,
 			radix_tree_free (rspamd->logger->debug_ip);
 		}
 		rspamd->logger->debug_ip = radix_tree_create ();
-		if (!add_map (rspamd->cfg, rspamd->cfg->debug_ip_map,
-			"IP addresses for which debug logs are enabled",
-			read_radix_list, fin_radix_list,
-			(void **)&rspamd->logger->debug_ip)) {
+		if (!add_map (rspamd->cfg, rspamd->cfg->debug_ip_map, "IP addresses for which debug logs are enabled",
+				read_radix_list, fin_radix_list, (void **)&rspamd->logger->debug_ip)) {
 			/* Try to parse it as list */
 			strvec = g_strsplit_set (rspamd->cfg->debug_ip_map, ",; ", 0);
 			num = g_strv_length (strvec);
@@ -369,7 +342,7 @@ rspamd_set_logger (struct rspamd_config *cfg,
 				if ((p = strchr (strvec[i], '/')) != NULL) {
 					/* Try to extract mask */
 					*p = '\0';
-					p++;
+					p ++;
 					errno = 0;
 					k = strtoul (p, &err, 10);
 					if (errno != 0 || *err != '\0' || k > 32) {
@@ -382,8 +355,7 @@ rspamd_set_logger (struct rspamd_config *cfg,
 				if (inet_aton (strvec[i], &addr)) {
 					/* Check ip */
 					mask = mask << (32 - k);
-					radix32tree_insert (rspamd->logger->debug_ip,
-						ntohl (addr.s_addr), mask, 1);
+					radix32tree_insert (rspamd->logger->debug_ip, ntohl (addr.s_addr), mask, 1);
 				}
 			}
 			g_strfreev (strvec);
@@ -413,27 +385,19 @@ update_log_pid (GQuark ptype, rspamd_logger_t *rspamd_log)
 void
 flush_log_buf (rspamd_logger_t *rspamd_log)
 {
-	if (rspamd_log->is_buffered &&
-		(rspamd_log->type == RSPAMD_LOG_CONSOLE || rspamd_log->type ==
-		RSPAMD_LOG_FILE)) {
-		direct_write_log_line (rspamd_log,
-			rspamd_log->io_buf.buf,
-			rspamd_log->io_buf.used,
-			FALSE);
+	if (rspamd_log->is_buffered && (rspamd_log->type == RSPAMD_LOG_CONSOLE || rspamd_log->type == RSPAMD_LOG_FILE)) {
+		direct_write_log_line (rspamd_log, rspamd_log->io_buf.buf, rspamd_log->io_buf.used, FALSE);
 		rspamd_log->io_buf.used = 0;
 	}
 }
 
 
 void
-rspamd_common_logv (rspamd_logger_t *rspamd_log,
-	GLogLevelFlags log_level,
-	const gchar *function,
-	const gchar *fmt,
-	va_list args)
+rspamd_common_logv (rspamd_logger_t *rspamd_log, GLogLevelFlags log_level, const gchar *function,
+		const gchar *fmt, va_list args)
 {
-	static gchar logbuf[BUFSIZ];
-	u_char *end;
+	static gchar                   logbuf[BUFSIZ];
+	u_char                         *end;
 
 	if (rspamd_log == NULL) {
 		rspamd_log = default_logger;
@@ -453,12 +417,7 @@ rspamd_common_logv (rspamd_logger_t *rspamd_log,
 		end = rspamd_vsnprintf (logbuf, sizeof (logbuf), fmt, args);
 		*end = '\0';
 		rspamd_escape_log_string (logbuf);
-		rspamd_log->log_func (NULL,
-			function,
-			log_level,
-			logbuf,
-			FALSE,
-			rspamd_log);
+		rspamd_log->log_func (NULL, function, log_level, logbuf, FALSE, rspamd_log);
 		g_mutex_unlock (rspamd_log->mtx);
 	}
 }
@@ -467,13 +426,10 @@ rspamd_common_logv (rspamd_logger_t *rspamd_log,
  * This log functions select real logger and write message if level is less or equal to configured log level
  */
 void
-rspamd_common_log_function (rspamd_logger_t *rspamd_log,
-	GLogLevelFlags log_level,
-	const gchar *function,
-	const gchar *fmt,
-	...)
+rspamd_common_log_function (rspamd_logger_t *rspamd_log, GLogLevelFlags log_level,
+		const gchar *function, const gchar *fmt, ...)
 {
-	va_list vp;
+	va_list                         vp;
 
 	va_start (vp, fmt);
 	rspamd_common_logv (rspamd_log, log_level, function, fmt, vp);
@@ -482,17 +438,17 @@ rspamd_common_log_function (rspamd_logger_t *rspamd_log,
 
 void
 rspamd_default_logv (GLogLevelFlags log_level, const gchar *function,
-	const gchar *fmt, va_list args)
+		const gchar *fmt, va_list args)
 {
 	rspamd_common_logv (NULL, log_level, function, fmt, args);
 }
 
 void
 rspamd_default_log_function (GLogLevelFlags log_level,
-	const gchar *function, const gchar *fmt, ...)
+		const gchar *function, const gchar *fmt, ...)
 {
 
-	va_list vp;
+	va_list                         vp;
 
 	va_start (vp, fmt);
 	rspamd_default_logv (log_level, function, fmt, vp);
@@ -506,12 +462,10 @@ rspamd_default_log_function (GLogLevelFlags log_level,
 static void
 fill_buffer (rspamd_logger_t *rspamd_log, const struct iovec *iov, gint iovcnt)
 {
-	gint i;
+	gint                            i;
 
-	for (i = 0; i < iovcnt; i++) {
-		memcpy (rspamd_log->io_buf.buf + rspamd_log->io_buf.used,
-			iov[i].iov_base,
-			iov[i].iov_len);
+	for (i = 0; i < iovcnt; i ++) {
+		memcpy (rspamd_log->io_buf.buf + rspamd_log->io_buf.used, iov[i].iov_base, iov[i].iov_len);
 		rspamd_log->io_buf.used += iov[i].iov_len;
 	}
 
@@ -521,20 +475,18 @@ fill_buffer (rspamd_logger_t *rspamd_log, const struct iovec *iov, gint iovcnt)
  * Write message to buffer or to file (using direct_write_log_line function)
  */
 static void
-file_log_helper (rspamd_logger_t *rspamd_log,
-	const struct iovec *iov,
-	gint iovcnt)
+file_log_helper (rspamd_logger_t *rspamd_log, const struct iovec *iov, gint iovcnt)
 {
-	size_t len = 0;
-	gint i;
+	size_t                         len = 0;
+	gint                            i;
 
-	if (!rspamd_log->is_buffered) {
+	if (! rspamd_log->is_buffered) {
 		/* Write string directly */
 		direct_write_log_line (rspamd_log, (void *)iov, iovcnt, TRUE);
 	}
 	else {
 		/* Calculate total length */
-		for (i = 0; i < iovcnt; i++) {
+		for (i = 0; i < iovcnt; i ++) {
 			len += iov[i].iov_len;
 		}
 		/* Fill buffer */
@@ -559,16 +511,11 @@ file_log_helper (rspamd_logger_t *rspamd_log,
  * Syslog interface for logging
  */
 static void
-syslog_log_function (const gchar * log_domain,
-	const gchar *function,
-	GLogLevelFlags log_level,
-	const gchar * message,
-	gboolean forced,
-	gpointer arg)
+syslog_log_function (const gchar * log_domain, const gchar *function, GLogLevelFlags log_level, const gchar * message, gboolean forced, gpointer arg)
 {
-	rspamd_logger_t *rspamd_log = arg;
+	rspamd_logger_t             *rspamd_log = arg;
 
-	if (!rspamd_log->enabled) {
+	if (! rspamd_log->enabled) {
 		return;
 	}
 	if (function == NULL) {
@@ -609,25 +556,20 @@ syslog_log_function (const gchar * log_domain,
  * Main file interface for logging
  */
 static void
-file_log_function (const gchar * log_domain,
-	const gchar *function,
-	GLogLevelFlags log_level,
-	const gchar * message,
-	gboolean forced,
-	gpointer arg)
+file_log_function (const gchar * log_domain, const gchar *function, GLogLevelFlags log_level, const gchar * message, gboolean forced, gpointer arg)
 {
-	gchar tmpbuf[256], timebuf[32];
-	time_t now;
-	struct tm *tms;
-	struct iovec iov[4];
-	gint r = 0;
-	guint32 cksum;
-	size_t mlen;
-	const gchar *cptype = NULL;
-	gboolean got_time = FALSE;
-	rspamd_logger_t *rspamd_log = arg;
-
-	if (!rspamd_log->enabled) {
+	gchar                           tmpbuf[256], timebuf[32];
+	time_t                          now;
+	struct tm                      *tms;
+	struct iovec                    iov[4];
+	gint                            r = 0;
+	guint32                         cksum;
+	size_t                          mlen;
+	const gchar                     *cptype = NULL;
+	gboolean                        got_time = FALSE;
+	rspamd_logger_t                *rspamd_log = arg;
+
+	if (! rspamd_log->enabled) {
 		return;
 	}
 
@@ -649,9 +591,8 @@ file_log_function (const gchar * log_domain,
 		mlen = strlen (message);
 		cksum = rspamd_log_calculate_cksum (message, mlen);
 		if (cksum == rspamd_log->last_line_cksum) {
-			rspamd_log->repeats++;
-			if (rspamd_log->repeats > REPEATS_MIN && rspamd_log->repeats <
-				REPEATS_MAX) {
+			rspamd_log->repeats ++;
+			if (rspamd_log->repeats > REPEATS_MIN && rspamd_log->repeats < REPEATS_MAX) {
 				/* Do not log anything */
 				if (rspamd_log->saved_message == 0) {
 					rspamd_log->saved_message = g_strdup (message);
@@ -660,32 +601,14 @@ file_log_function (const gchar * log_domain,
 				return;
 			}
 			else if (rspamd_log->repeats > REPEATS_MAX) {
-				rspamd_snprintf (tmpbuf,
-					sizeof (tmpbuf),
-					"Last message repeated %ud times",
-					rspamd_log->repeats);
+				rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "Last message repeated %ud times", rspamd_log->repeats);
 				rspamd_log->repeats = 0;
 				/* It is safe to use temporary buffer here as it is not static */
 				if (rspamd_log->saved_message) {
-					file_log_function (log_domain,
-						rspamd_log->saved_function,
-						log_level,
-						rspamd_log->saved_message,
-						forced,
-						arg);
-				}
-				file_log_function (log_domain,
-					__FUNCTION__,
-					log_level,
-					tmpbuf,
-					forced,
-					arg);
-				file_log_function (log_domain,
-					function,
-					log_level,
-					message,
-					forced,
-					arg);
+					file_log_function (log_domain, rspamd_log->saved_function, log_level, rspamd_log->saved_message, forced, arg);
+				}	
+				file_log_function (log_domain, __FUNCTION__, log_level, tmpbuf, forced, arg);
+				file_log_function (log_domain, function, log_level, message, forced, arg);
 				rspamd_log->repeats = REPEATS_MIN + 1;
 				return;
 			}
@@ -694,36 +617,18 @@ file_log_function (const gchar * log_domain,
 			/* Reset counter if new message differs from saved message */
 			rspamd_log->last_line_cksum = cksum;
 			if (rspamd_log->repeats > REPEATS_MIN) {
-				rspamd_snprintf (tmpbuf,
-					sizeof (tmpbuf),
-					"Last message repeated %ud times",
-					rspamd_log->repeats);
+				rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "Last message repeated %ud times", rspamd_log->repeats);
 				rspamd_log->repeats = 0;
 				if (rspamd_log->saved_message) {
-					file_log_function (log_domain,
-						rspamd_log->saved_function,
-						log_level,
-						rspamd_log->saved_message,
-						forced,
-						arg);
+					file_log_function (log_domain, rspamd_log->saved_function, log_level, rspamd_log->saved_message, forced, arg);
 					g_free (rspamd_log->saved_message);
 					g_free (rspamd_log->saved_function);
 					rspamd_log->saved_message = NULL;
 					rspamd_log->saved_function = NULL;
-				}
-				file_log_function (log_domain,
-					__FUNCTION__,
-					log_level,
-					tmpbuf,
-					forced,
-					arg);
+				}	
+				file_log_function (log_domain, __FUNCTION__, log_level, tmpbuf, forced, arg);
 				/* It is safe to use temporary buffer here as it is not static */
-				file_log_function (log_domain,
-					function,
-					log_level,
-					message,
-					forced,
-					arg);
+				file_log_function (log_domain, function, log_level, message, forced, arg);
 				return;
 			}
 			else {
@@ -732,7 +637,7 @@ file_log_function (const gchar * log_domain,
 		}
 
 		if (rspamd_log->cfg->log_extended) {
-			if (!got_time) {
+			if (! got_time) {
 				now = time (NULL);
 			}
 
@@ -760,21 +665,10 @@ file_log_function (const gchar * log_domain,
 				r = 0;
 			}
 			if (function == NULL) {
-				r += rspamd_snprintf (tmpbuf + r,
-						sizeof (tmpbuf) - r,
-						"%s #%P(%s) ",
-						timebuf,
-						rspamd_log->pid,
-						cptype);
+				r += rspamd_snprintf (tmpbuf + r, sizeof (tmpbuf) - r, "%s #%P(%s) ", timebuf, rspamd_log->pid, cptype);
 			}
 			else {
-				r += rspamd_snprintf (tmpbuf + r,
-						sizeof (tmpbuf) - r,
-						"%s #%P(%s) %s: ",
-						timebuf,
-						rspamd_log->pid,
-						cptype,
-						function);
+				r += rspamd_snprintf (tmpbuf + r, sizeof (tmpbuf) -r, "%s #%P(%s) %s: ", timebuf, rspamd_log->pid, cptype, function);
 			}
 			/* Construct IOV for log line */
 			iov[0].iov_base = tmpbuf;
@@ -818,17 +712,16 @@ file_log_function (const gchar * log_domain,
  */
 void
 rspamd_conditional_debug (rspamd_logger_t *rspamd_log,
-	rspamd_inet_addr_t *addr, const gchar *function, const gchar *fmt, ...)
+		rspamd_inet_addr_t *addr, const gchar *function, const gchar *fmt, ...)
 {
-	static gchar logbuf[BUFSIZ];
-	va_list vp;
-	u_char *end;
+	static gchar                     logbuf[BUFSIZ];
+	va_list                         vp;
+    u_char                         *end;
 
-	if (rspamd_log->cfg->log_level >= G_LOG_LEVEL_DEBUG ||
-		rspamd_log->is_debug) {
+	if (rspamd_log->cfg->log_level >= G_LOG_LEVEL_DEBUG || rspamd_log->is_debug) {
 		if (rspamd_log->debug_ip && addr != NULL) {
 			if (addr->af == AF_INET && radix32tree_find (rspamd_log->debug_ip,
-				ntohl (addr->addr.s4.sin_addr.s_addr)) == RADIX_NO_VALUE) {
+					ntohl (addr->addr.s4.sin_addr.s_addr)) == RADIX_NO_VALUE) {
 				return;
 			}
 		}
@@ -838,34 +731,21 @@ rspamd_conditional_debug (rspamd_logger_t *rspamd_log,
 		*end = '\0';
 		rspamd_escape_log_string (logbuf);
 		va_end (vp);
-		rspamd_log->log_func (NULL,
-			function,
-			G_LOG_LEVEL_DEBUG,
-			logbuf,
-			TRUE,
-			rspamd_log);
+		rspamd_log->log_func (NULL, function, G_LOG_LEVEL_DEBUG, logbuf, TRUE, rspamd_log);
 		g_mutex_unlock (rspamd_log->mtx);
 	}
-}
+} 
 /**
  * Wrapper for glib logger
  */
 void
-rspamd_glib_log_function (const gchar *log_domain,
-	GLogLevelFlags log_level,
-	const gchar *message,
-	gpointer arg)
+rspamd_glib_log_function (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer arg)
 {
-	rspamd_logger_t *rspamd_log = arg;
+	rspamd_logger_t              *rspamd_log = arg;
 
 	if (rspamd_log->enabled) {
 		g_mutex_lock (rspamd_log->mtx);
-		rspamd_log->log_func (log_domain,
-			NULL,
-			log_level,
-			message,
-			FALSE,
-			rspamd_log);
+		rspamd_log->log_func (log_domain, NULL, log_level, message, FALSE, rspamd_log);
 		g_mutex_unlock (rspamd_log->mtx);
 	}
 }
diff --git a/src/libutil/logger.h b/src/libutil/logger.h
index 8d4b3763b..4b1c74410 100644
--- a/src/libutil/logger.h
+++ b/src/libutil/logger.h
@@ -1,24 +1,21 @@
 #ifndef RSPAMD_LOGGER_H
 #define RSPAMD_LOGGER_H
 
-#include "cfg_file.h"
 #include "config.h"
+#include "cfg_file.h"
 #include "radix.h"
 #include "util.h"
 
 
-typedef void (*rspamd_log_func_t)(const gchar * log_domain,
-	const gchar *function,
-	GLogLevelFlags log_level, const gchar * message,
-	gboolean forced, gpointer arg);
+typedef void (*rspamd_log_func_t)(const gchar * log_domain, const gchar *function,
+								  GLogLevelFlags log_level, const gchar * message, 
+								  gboolean forced, gpointer arg);
 
 typedef struct rspamd_logger_s rspamd_logger_t;
 /**
  * Init logger
  */
-void rspamd_set_logger (struct rspamd_config *cfg,
-	GQuark ptype,
-	struct rspamd_main *main);
+void rspamd_set_logger (struct rspamd_config *cfg, GQuark ptype, struct rspamd_main *main);
 /**
  * Open log file or initialize other structures
  */
@@ -58,33 +55,28 @@ void flush_log_buf (rspamd_logger_t *logger);
  * Log function that is compatible for glib messages
  */
 void rspamd_glib_log_function (const gchar *log_domain,
-	GLogLevelFlags log_level, const gchar *message, gpointer arg);
+		GLogLevelFlags log_level, const gchar *message, gpointer arg);
 
 /**
  * Function with variable number of arguments support
  */
 void rspamd_common_log_function (rspamd_logger_t *logger,
-	GLogLevelFlags log_level, const gchar *function, const gchar *fmt, ...);
+		GLogLevelFlags log_level, const gchar *function, const gchar *fmt, ...);
 
 void rspamd_common_logv (rspamd_logger_t *logger,
-	GLogLevelFlags log_level,
-	const gchar *function,
-	const gchar *fmt,
-	va_list args);
+		GLogLevelFlags log_level, const gchar *function, const gchar *fmt, va_list args);
 
 /**
  * Conditional debug function
  */
 void rspamd_conditional_debug (rspamd_logger_t *logger,
-	rspamd_inet_addr_t *addr, const gchar *function, const gchar *fmt, ...);
+		rspamd_inet_addr_t *addr, const gchar *function, const gchar *fmt, ...) ;
 
 /**
  * Function with variable number of arguments support that uses static default logger
  */
-void rspamd_default_log_function (GLogLevelFlags log_level,
-	const gchar *function,
-	const gchar *fmt,
-	...);
+void rspamd_default_log_function (GLogLevelFlags log_level, const gchar *function,
+		const gchar *fmt, ...);
 
 /**
  * Varargs version of default log function
@@ -93,10 +85,7 @@ void rspamd_default_log_function (GLogLevelFlags log_level,
  * @param fmt
  * @param args
  */
-void rspamd_default_logv (GLogLevelFlags log_level,
-	const gchar *function,
-	const gchar *fmt,
-	va_list args);
+void rspamd_default_logv (GLogLevelFlags log_level, const gchar *function, const gchar *fmt, va_list args);
 
 /**
  * Temporary turn on debug
@@ -112,42 +101,17 @@ void rspamd_log_nodebug (rspamd_logger_t *logger);
 
 /* Logging in postfix style */
 #if defined(RSPAMD_MAIN)
-#define msg_err(...)    rspamd_common_log_function (rspamd_main->logger, \
-		G_LOG_LEVEL_CRITICAL, \
-		__FUNCTION__, \
-		__VA_ARGS__)
-#define msg_warn(...)   rspamd_common_log_function (rspamd_main->logger, \
-		G_LOG_LEVEL_WARNING, \
-		__FUNCTION__, \
-		__VA_ARGS__)
-#define msg_info(...)   rspamd_common_log_function (rspamd_main->logger, \
-		G_LOG_LEVEL_INFO, \
-		__FUNCTION__, \
-		__VA_ARGS__)
-#define msg_debug(...)  rspamd_conditional_debug (rspamd_main->logger, \
-		NULL, \
-		__FUNCTION__, \
-		__VA_ARGS__)
-#define debug_task(...) rspamd_conditional_debug (rspamd_main->logger, \
-		&task->from_addr, \
-		__FUNCTION__, \
-		__VA_ARGS__)
+#define msg_err(...)	rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_CRITICAL, __FUNCTION__, __VA_ARGS__)
+#define msg_warn(...)	rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_WARNING, __FUNCTION__, __VA_ARGS__)
+#define msg_info(...)	rspamd_common_log_function(rspamd_main->logger, G_LOG_LEVEL_INFO, __FUNCTION__, __VA_ARGS__)
+#define msg_debug(...)	rspamd_conditional_debug(rspamd_main->logger, NULL, __FUNCTION__, __VA_ARGS__)
+#define debug_task(...) rspamd_conditional_debug(rspamd_main->logger, &task->from_addr, __FUNCTION__, __VA_ARGS__)
 #else
-#define msg_err(...)    rspamd_default_log_function (G_LOG_LEVEL_CRITICAL, \
-		__FUNCTION__, \
-		__VA_ARGS__)
-#define msg_warn(...)   rspamd_default_log_function (G_LOG_LEVEL_WARNING, \
-		__FUNCTION__, \
-		__VA_ARGS__)
-#define msg_info(...)   rspamd_default_log_function (G_LOG_LEVEL_INFO, \
-		__FUNCTION__, \
-		__VA_ARGS__)
-#define msg_debug(...)  rspamd_default_log_function (G_LOG_LEVEL_DEBUG, \
-		__FUNCTION__, \
-		__VA_ARGS__)
-#define debug_task(...) rspamd_default_log_function (G_LOG_LEVEL_DEBUG, \
-		__FUNCTION__, \
-		__VA_ARGS__)
+#define msg_err(...)	rspamd_default_log_function(G_LOG_LEVEL_CRITICAL, __FUNCTION__, __VA_ARGS__)
+#define msg_warn(...)	rspamd_default_log_function(G_LOG_LEVEL_WARNING, __FUNCTION__, __VA_ARGS__)
+#define msg_info(...)	rspamd_default_log_function(G_LOG_LEVEL_INFO, __FUNCTION__, __VA_ARGS__)
+#define msg_debug(...)	rspamd_default_log_function(G_LOG_LEVEL_DEBUG, __FUNCTION__, __VA_ARGS__)
+#define debug_task(...) rspamd_default_log_function(G_LOG_LEVEL_DEBUG, __FUNCTION__, __VA_ARGS__)
 #endif
 
 #endif
diff --git a/src/libutil/map.c b/src/libutil/map.c
index 21612ddfb..ffe3a1e6f 100644
--- a/src/libutil/map.c
+++ b/src/libutil/map.c
@@ -26,33 +26,33 @@
  * Implementation of map files handling
  */
 #include "config.h"
+#include "map.h"
 #include "http.h"
 #include "main.h"
-#include "map.h"
-#include "mem_pool.h"
 #include "util.h"
+#include "mem_pool.h"
 
-static const gchar *hash_fill = "1";
+static const gchar             *hash_fill = "1";
 
 /* Http reply */
 struct http_reply {
-	gint code;
-	GHashTable *headers;
-	gchar *cur_header;
-	gint parser_state;
+	gint                            code;
+	GHashTable                     *headers;
+	gchar                          *cur_header;
+	gint                            parser_state;
 };
 
 struct http_callback_data {
-	struct event ev;
-	struct event_base *ev_base;
-	struct timeval tv;
-	struct rspamd_map *map;
-	struct http_map_data *data;
-	struct http_reply *reply;
-	struct map_cb_data cbdata;
-
-	gint state;
-	gint fd;
+	struct event                    ev;
+	struct event_base			   *ev_base;
+	struct timeval                  tv;
+	struct rspamd_map              *map;
+	struct http_map_data           *data;
+	struct http_reply              *reply;
+	struct map_cb_data              cbdata;
+
+	gint                            state;
+	gint                            fd;
 };
 
 /* Value in seconds after whitch we would try to do stat on list file */
@@ -65,17 +65,12 @@ struct http_callback_data {
  * Helper for HTTP connection establishment
  */
 static gint
-connect_http (struct rspamd_map *map,
-	struct http_map_data *data,
-	gboolean is_async)
+connect_http (struct rspamd_map *map, struct http_map_data *data, gboolean is_async)
 {
-	gint sock;
+	gint                            sock;
 
 	if ((sock = make_tcp_socket (data->addr, FALSE, is_async)) == -1) {
-		msg_info ("cannot connect to http server %s: %d, %s",
-			data->host,
-			errno,
-			strerror (errno));
+		msg_info ("cannot connect to http server %s: %d, %s", data->host, errno, strerror (errno));
 		return -1;
 	}
 
@@ -86,27 +81,17 @@ connect_http (struct rspamd_map *map,
  * Write HTTP request
  */
 static void
-write_http_request (struct rspamd_map *map,
-	struct http_map_data *data,
-	gint sock)
+write_http_request (struct rspamd_map *map, struct http_map_data *data, gint sock)
 {
-	gchar outbuf[BUFSIZ], datebuf[128];
-	gint r;
-	struct tm *tm;
+	gchar                           outbuf[BUFSIZ], datebuf[128];
+	gint                            r;
+	struct tm			 			*tm;
 
 	tm = gmtime (&data->last_checked);
 	strftime (datebuf, sizeof (datebuf), "%a, %d %b %Y %H:%M:%S %Z", tm);
-	r = rspamd_snprintf (outbuf,
-			sizeof (outbuf),
-			"GET %s%s HTTP/1.1" CRLF "Connection: close" CRLF "Host: %s" CRLF,
-			(*data->path == '/') ? "" : "/",
-			data->path,
-			data->host);
+	r = rspamd_snprintf (outbuf, sizeof (outbuf), "GET %s%s HTTP/1.1" CRLF "Connection: close" CRLF "Host: %s" CRLF, (*data->path == '/') ? "" : "/", data->path, data->host);
 	if (data->last_checked != 0) {
-		r += rspamd_snprintf (outbuf + r,
-				sizeof (outbuf) - r,
-				"If-Modified-Since: %s" CRLF,
-				datebuf);
+		r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "If-Modified-Since: %s" CRLF, datebuf);
 	}
 
 	r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, CRLF);
@@ -119,16 +104,16 @@ write_http_request (struct rspamd_map *map,
 /**
  * FSM for parsing HTTP reply
  */
-static gchar *
+static gchar                  *
 parse_http_reply (gchar * chunk, gint len, struct http_reply *reply)
 {
-	gchar *s, *p, *err_str, *tmp;
+	gchar                         *s, *p, *err_str, *tmp;
 	p = chunk;
 	s = chunk;
 
 	while (p - chunk < len) {
 		switch (reply->parser_state) {
-		/* Search status code */
+			/* Search status code */
 		case 0:
 			/* Search for status code */
 			if (*p != ' ') {
@@ -146,7 +131,7 @@ parse_http_reply (gchar * chunk, gint len, struct http_reply *reply)
 				continue;
 			}
 			break;
-		/* Skip to end of line */
+			/* Skip to end of line */
 		case 1:
 			if (*p == '\n') {
 				/* Switch to read header state */
@@ -155,7 +140,7 @@ parse_http_reply (gchar * chunk, gint len, struct http_reply *reply)
 			/* Each skipped symbol is proceeded */
 			s = ++p;
 			break;
-		/* Read header value */
+			/* Read header value */
 		case 2:
 			if (*p == ':') {
 				reply->cur_header = g_malloc (p - s + 1);
@@ -168,7 +153,7 @@ parse_http_reply (gchar * chunk, gint len, struct http_reply *reply)
 			}
 			p++;
 			break;
-		/* Skip spaces after header name */
+			/* Skip spaces after header name */
 		case 3:
 			if (*p != ' ') {
 				s = p;
@@ -178,14 +163,13 @@ parse_http_reply (gchar * chunk, gint len, struct http_reply *reply)
 				p++;
 			}
 			break;
-		/* Read header value */
+			/* Read header value */
 		case 4:
 			if (*p == '\r') {
 				if (reply->cur_header != NULL) {
 					tmp = g_malloc (p - s + 1);
 					rspamd_strlcpy (tmp, s, p - s + 1);
-					g_hash_table_insert (reply->headers, reply->cur_header,
-						tmp);
+					g_hash_table_insert (reply->headers, reply->cur_header, tmp);
 					reply->cur_header = NULL;
 				}
 				reply->parser_state = 1;
@@ -214,14 +198,13 @@ parse_http_reply (gchar * chunk, gint len, struct http_reply *reply)
 static gint
 read_chunk_header (gchar * buf, gint len, struct http_map_data *data)
 {
-	gchar chunkbuf[32], *p, *c, *err_str;
-	gint skip = 0;
+	gchar                           chunkbuf[32], *p, *c, *err_str;
+	gint                            skip = 0;
 
 	p = chunkbuf;
 	c = buf;
 	/* Find hex digits */
-	while (g_ascii_isxdigit (*c) && p - chunkbuf <
-		(gint)(sizeof (chunkbuf) - 1) && skip < len) {
+	while (g_ascii_isxdigit (*c) && p - chunkbuf < (gint)(sizeof (chunkbuf) - 1) && skip < len) {
 		*p++ = *c++;
 		skip++;
 	}
@@ -248,15 +231,11 @@ read_chunk_header (gchar * buf, gint len, struct http_map_data *data)
 /**
  * Helper callback for reading chunked reply
  */
-static gboolean
-read_http_chunked (gchar * buf,
-	size_t len,
-	struct rspamd_map *map,
-	struct http_map_data *data,
-	struct map_cb_data *cbdata)
+static                          gboolean
+read_http_chunked (gchar * buf, size_t len, struct rspamd_map *map, struct http_map_data *data, struct map_cb_data *cbdata)
 {
-	gchar *p = buf, *remain;
-	gint skip = 0;
+	gchar                          *p = buf, *remain;
+	gint                            skip = 0;
 
 	if (data->chunked == 1) {
 		/* Read first chunk data */
@@ -322,20 +301,14 @@ read_http_chunked (gchar * buf,
 /**
  * Callback for reading HTTP reply
  */
-static gboolean
-read_http_common (struct rspamd_map *map,
-	struct http_map_data *data,
-	struct http_reply *reply,
-	struct map_cb_data *cbdata,
-	gint fd)
+static                          gboolean
+read_http_common (struct rspamd_map *map, struct http_map_data *data, struct http_reply *reply, struct map_cb_data *cbdata, gint fd)
 {
-	gchar *remain, *pos;
-	ssize_t r;
-	gchar *te, *date;
-
-	if ((r =
-		read (fd, data->read_buf + data->rlen, sizeof (data->read_buf) -
-		data->rlen)) > 0) {
+	gchar                         *remain, *pos;
+	ssize_t                         r;
+	gchar                           *te, *date;
+	
+	if ((r = read (fd, data->read_buf + data->rlen, sizeof (data->read_buf) - data->rlen)) > 0) {
 		r += data->rlen;
 		data->rlen = 0;
 		remain = parse_http_reply (data->read_buf, r, reply);
@@ -352,9 +325,7 @@ read_http_common (struct rspamd_map *map,
 		if (reply->parser_state == 6) {
 			/* If reply header is parsed successfully, try to read further data */
 			if (reply->code != 200 && reply->code != 304) {
-				msg_err ("got error reply from server %s, %d",
-					data->host,
-					reply->code);
+				msg_err ("got error reply from server %s, %d", data->host, reply->code);
 				return FALSE;
 			}
 			else if (reply->code == 304) {
@@ -364,9 +335,7 @@ read_http_common (struct rspamd_map *map,
 			pos = data->read_buf;
 			/* Check for chunked */
 			if (data->chunked == 0) {
-				if ((te =
-					g_hash_table_lookup (reply->headers,
-					"Transfer-Encoding")) != NULL) {
+				if ((te = g_hash_table_lookup (reply->headers, "Transfer-Encoding")) != NULL) {
 					if (g_ascii_strcasecmp (te, "chunked") == 0) {
 						data->chunked = 1;
 					}
@@ -412,9 +381,9 @@ read_http_common (struct rspamd_map *map,
 static void
 read_http_sync (struct rspamd_map *map, struct http_map_data *data)
 {
-	struct map_cb_data cbdata;
-	gint fd;
-	struct http_reply *repl;
+	struct map_cb_data              cbdata;
+	gint                            fd;
+	struct http_reply              *repl;
 
 	if (map->read_callback == NULL || map->fin_callback == NULL) {
 		msg_err ("bad callback for reading map file");
@@ -435,12 +404,9 @@ read_http_sync (struct rspamd_map *map, struct http_map_data *data)
 	repl = g_malloc (sizeof (struct http_reply));
 	repl->parser_state = 0;
 	repl->code = 404;
-	repl->headers = g_hash_table_new_full (rspamd_strcase_hash,
-			rspamd_strcase_equal,
-			g_free,
-			g_free);
+	repl->headers = g_hash_table_new_full (rspamd_strcase_hash, rspamd_strcase_equal, g_free, g_free);
 
-	while (read_http_common (map, data, repl, &cbdata, fd)) ;
+	while (read_http_common (map, data, repl, &cbdata, fd));
 
 	close (fd);
 
@@ -460,10 +426,10 @@ read_http_sync (struct rspamd_map *map, struct http_map_data *data)
 static void
 read_map_file (struct rspamd_map *map, struct file_map_data *data)
 {
-	struct map_cb_data cbdata;
-	gchar buf[BUFSIZ], *remain;
-	ssize_t r;
-	gint fd, rlen;
+	struct map_cb_data              cbdata;
+	gchar                          buf[BUFSIZ], *remain;
+	ssize_t                         r;
+	gint                            fd, rlen;
 
 	if (map->read_callback == NULL || map->fin_callback == NULL) {
 		msg_err ("bad callback for reading map file");
@@ -471,8 +437,7 @@ read_map_file (struct rspamd_map *map, struct file_map_data *data)
 	}
 
 	if ((fd = open (data->filename, O_RDONLY)) == -1) {
-		msg_warn ("cannot open file '%s': %s", data->filename,
-			strerror (errno));
+		msg_warn ("cannot open file '%s': %s", data->filename, strerror (errno));
 		return;
 	}
 
@@ -502,14 +467,10 @@ read_map_file (struct rspamd_map *map, struct file_map_data *data)
 /**
  * FSM for parsing lists
  */
-gchar *
-abstract_parse_kv_list (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data,
-	insert_func func)
+gchar                  *
+abstract_parse_kv_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data, insert_func func)
 {
-	gchar *c, *p, *key = NULL, *value = NULL;
+	gchar                         *c, *p, *key = NULL, *value = NULL;
 
 	p = chunk;
 	c = p;
@@ -565,7 +526,7 @@ abstract_parse_kv_list (rspamd_mempool_t * pool,
 				}
 			}
 			else {
-				p++;
+				p ++;
 			}
 			break;
 		case 2:
@@ -575,7 +536,7 @@ abstract_parse_kv_list (rspamd_mempool_t * pool,
 				data->state = 0;
 			}
 			else {
-				p++;
+				p ++;
 			}
 			break;
 		case 99:
@@ -596,7 +557,7 @@ abstract_parse_kv_list (rspamd_mempool_t * pool,
 		case 100:
 			/* Skip \r\n and whitespaces */
 			if (*p == '\r' || *p == '\n' || g_ascii_isspace (*p)) {
-				p++;
+				p ++;
 			}
 			else {
 				c = p;
@@ -610,14 +571,10 @@ abstract_parse_kv_list (rspamd_mempool_t * pool,
 	return c;
 }
 
-gchar *
-abstract_parse_list (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data,
-	insert_func func)
+gchar                  *
+abstract_parse_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data, insert_func func)
 {
-	gchar *s, *p, *str, *start;
+	gchar                         *s, *p, *str, *start;
 
 	p = chunk;
 	start = p;
@@ -627,7 +584,7 @@ abstract_parse_list (rspamd_mempool_t * pool,
 
 	while (p - chunk < len) {
 		switch (data->state) {
-		/* READ_SYMBOL */
+			/* READ_SYMBOL */
 		case 0:
 			if (*p == '#') {
 				/* Got comment */
@@ -666,7 +623,7 @@ abstract_parse_list (rspamd_mempool_t * pool,
 				p++;
 			}
 			break;
-		/* SKIP_COMMENT */
+			/* SKIP_COMMENT */
 		case 1:
 			/* Skip comment till end of line */
 			if (*p == '\r' || *p == '\n') {
@@ -695,13 +652,13 @@ abstract_parse_list (rspamd_mempool_t * pool,
 static void
 radix_tree_insert_helper (gpointer st, gconstpointer key, gpointer value)
 {
-	radix_tree_t *tree = st;
+	radix_tree_t                   *tree = st;
 
-	guint32 mask = 0xFFFFFFFF;
-	guint32 ip;
-	gchar *token, *ipnet, *err_str, **strv, **cur;
-	struct in_addr ina;
-	gint k;
+	guint32                         mask = 0xFFFFFFFF;
+	guint32                         ip;
+	gchar                           *token, *ipnet, *err_str, **strv, **cur;
+	struct in_addr                  ina;
+	gint                            k;
 
 	/* Split string if there are multiple items inside a single string */
 	strv = g_strsplit_set ((gchar *)key, " ,;", 0);
@@ -720,10 +677,7 @@ radix_tree_insert_helper (gpointer st, gconstpointer key, gpointer value)
 			/* Get mask */
 			k = strtoul (ipnet, &err_str, 10);
 			if (errno != 0) {
-				msg_warn (
-					"invalid netmask, error detected on symbol: %s, erorr: %s",
-					err_str,
-					strerror (errno));
+				msg_warn ("invalid netmask, error detected on symbol: %s, erorr: %s", err_str, strerror (errno));
 				k = 32;
 			}
 			else if (k > 32 || k < 0) {
@@ -744,12 +698,10 @@ radix_tree_insert_helper (gpointer st, gconstpointer key, gpointer value)
 		ip = ntohl ((guint32) ina.s_addr);
 		k = radix32tree_insert (tree, ip, mask, 1);
 		if (k == -1) {
-			msg_warn ("cannot insert ip to tree: %s, mask %X", inet_ntoa (
-					ina), mask);
+			msg_warn ("cannot insert ip to tree: %s, mask %X", inet_ntoa (ina), mask);
 		}
 		else if (k == 1) {
-			msg_warn ("ip %s, mask %X, value already exists", inet_ntoa (
-					ina), mask);
+			msg_warn ("ip %s, mask %X, value already exists", inet_ntoa (ina), mask);
 		}
 		cur++;
 	}
@@ -758,21 +710,13 @@ radix_tree_insert_helper (gpointer st, gconstpointer key, gpointer value)
 }
 
 /* Helpers */
-gchar *
-read_host_list (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data)
+gchar                         *
+read_host_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
 {
 	if (data->cur_data == NULL) {
-		data->cur_data = g_hash_table_new (rspamd_strcase_hash,
-				rspamd_strcase_equal);
+		data->cur_data = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
 	}
-	return abstract_parse_list (pool,
-			   chunk,
-			   len,
-			   data,
-			   (insert_func) g_hash_table_insert);
+	return abstract_parse_list (pool, chunk, len, data, (insert_func) g_hash_table_insert);
 }
 
 void
@@ -783,21 +727,13 @@ fin_host_list (rspamd_mempool_t * pool, struct map_cb_data *data)
 	}
 }
 
-gchar *
-read_kv_list (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data)
+gchar                         *
+read_kv_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
 {
 	if (data->cur_data == NULL) {
-		data->cur_data = g_hash_table_new (rspamd_strcase_hash,
-				rspamd_strcase_equal);
+		data->cur_data = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
 	}
-	return abstract_parse_kv_list (pool,
-			   chunk,
-			   len,
-			   data,
-			   (insert_func) g_hash_table_insert);
+	return abstract_parse_kv_list (pool, chunk, len, data, (insert_func) g_hash_table_insert);
 }
 
 void
@@ -808,20 +744,13 @@ fin_kv_list (rspamd_mempool_t * pool, struct map_cb_data *data)
 	}
 }
 
-gchar *
-read_radix_list (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data)
+gchar                         *
+read_radix_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
 {
 	if (data->cur_data == NULL) {
 		data->cur_data = radix_tree_create ();
 	}
-	return abstract_parse_list (pool,
-			   chunk,
-			   len,
-			   data,
-			   (insert_func) radix_tree_insert_helper);
+	return abstract_parse_list (pool, chunk, len, data, (insert_func) radix_tree_insert_helper);
 }
 
 void
@@ -838,28 +767,24 @@ fin_radix_list (rspamd_mempool_t * pool, struct map_cb_data *data)
 static void
 file_callback (gint fd, short what, void *ud)
 {
-	struct rspamd_map *map = ud;
-	struct file_map_data *data = map->map_data;
-	struct stat st;
-	gdouble jittered_sec;
+	struct rspamd_map              *map = ud;
+	struct file_map_data           *data = map->map_data;
+	struct stat                     st;
+	gdouble							jittered_sec;
 
 	/* Plan event again with jitter */
 	evtimer_del (&map->ev);
-	jittered_sec =
-		(map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
+	jittered_sec = (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
 	double_to_tv (jittered_sec, &map->tv);
 
 	evtimer_add (&map->ev, &map->tv);
 
 	if (g_atomic_int_get (map->locked)) {
-		msg_info (
-			"don't try to reread map as it is locked by other process, will reread it later");
+		msg_info ("don't try to reread map as it is locked by other process, will reread it later");
 		return;
 	}
 
-	if (stat (data->filename,
-		&st) != -1 &&
-		(st.st_mtime > data->st.st_mtime || data->st.st_mtime == -1)) {
+	if (stat (data->filename, &st) != -1 && (st.st_mtime > data->st.st_mtime || data->st.st_mtime == -1)) {
 		/* File was modified since last check */
 		memcpy (&data->st, &st, sizeof (struct stat));
 	}
@@ -893,7 +818,7 @@ free_http_cbdata (struct http_callback_data *cbd)
 static void
 http_async_callback (gint fd, short what, void *ud)
 {
-	struct http_callback_data *cbd = ud;
+	struct http_callback_data      *cbd = ud;
 
 	/* Begin of connection */
 	if (what == EV_WRITE) {
@@ -901,11 +826,7 @@ http_async_callback (gint fd, short what, void *ud)
 			/* Can write request */
 			write_http_request (cbd->map, cbd->data, fd);
 			/* Plan reading */
-			event_set (&cbd->ev,
-				cbd->fd,
-				EV_READ | EV_PERSIST,
-				http_async_callback,
-				cbd);
+			event_set (&cbd->ev, cbd->fd, EV_READ | EV_PERSIST, http_async_callback, cbd);
 			event_base_set (cbd->ev_base, &cbd->ev);
 			cbd->tv.tv_sec = HTTP_READ_TIMEOUT;
 			cbd->tv.tv_usec = 0;
@@ -914,10 +835,7 @@ http_async_callback (gint fd, short what, void *ud)
 			cbd->reply = g_malloc (sizeof (struct http_reply));
 			cbd->reply->parser_state = 0;
 			cbd->reply->code = 404;
-			cbd->reply->headers = g_hash_table_new_full (rspamd_strcase_hash,
-					rspamd_strcase_equal,
-					g_free,
-					g_free);
+			cbd->reply->headers = g_hash_table_new_full (rspamd_strcase_hash, rspamd_strcase_equal, g_free, g_free);
 			cbd->cbdata.state = 0;
 			cbd->cbdata.prev_data = *cbd->map->user_data;
 			cbd->cbdata.cur_data = NULL;
@@ -939,15 +857,13 @@ http_async_callback (gint fd, short what, void *ud)
 	/* Got reply, parse it */
 	else if (what == EV_READ) {
 		if (cbd->state >= 1) {
-			if (!read_http_common (cbd->map, cbd->data, cbd->reply,
-				&cbd->cbdata, cbd->fd)) {
+			if (!read_http_common (cbd->map, cbd->data, cbd->reply, &cbd->cbdata, cbd->fd)) {
 				/* Handle Not-Modified in a special way */
 				if (cbd->reply->code == 304) {
 					if (cbd->data->last_checked == (time_t)-1) {
 						cbd->data->last_checked = time (NULL);
 					}
-					msg_info ("data is not modified for server %s",
-						cbd->data->host);
+					msg_info ("data is not modified for server %s", cbd->data->host);
 				}
 				else if (cbd->cbdata.cur_data != NULL) {
 					/* Destroy old data and start reading request data */
@@ -984,22 +900,20 @@ http_async_callback (gint fd, short what, void *ud)
 static void
 http_callback (gint fd, short what, void *ud)
 {
-	struct rspamd_map *map = ud;
-	struct http_map_data *data = map->map_data;
-	gint sock;
-	struct http_callback_data *cbd;
-	gdouble jittered_sec;
+	struct rspamd_map              *map = ud;
+	struct http_map_data           *data = map->map_data;
+	gint                            sock;
+	struct http_callback_data      *cbd;
+	gdouble							jittered_sec;
 
 	/* Plan event again with jitter */
 	evtimer_del (&map->ev);
-	jittered_sec =
-		(map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
+	jittered_sec = (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
 	double_to_tv (jittered_sec, &map->tv);
 	evtimer_add (&map->ev, &map->tv);
 
 	if (g_atomic_int_get (map->locked)) {
-		msg_info (
-			"don't try to reread map as it is locked by other process, will reread it later");
+		msg_info ("don't try to reread map as it is locked by other process, will reread it later");
 		return;
 	}
 
@@ -1031,10 +945,10 @@ http_callback (gint fd, short what, void *ud)
 void
 start_map_watch (struct rspamd_config *cfg, struct event_base *ev_base)
 {
-	GList *cur = cfg->maps;
-	struct rspamd_map *map;
-	struct file_map_data *fdata;
-	gdouble jittered_sec;
+	GList                          *cur = cfg->maps;
+	struct rspamd_map              *map;
+	struct file_map_data           *fdata;
+	gdouble							jittered_sec;
 
 	/* First of all do synced read of data */
 	while (cur) {
@@ -1050,9 +964,7 @@ start_map_watch (struct rspamd_config *cfg, struct event_base *ev_base)
 				read_map_file (map, map->map_data);
 			}
 			/* Plan event with jitter */
-			jittered_sec =
-				(map->cfg->map_timeout + g_random_double () *
-				map->cfg->map_timeout) / 2.;
+			jittered_sec = (map->cfg->map_timeout + g_random_double ()  * map->cfg->map_timeout) / 2.;
 			double_to_tv (jittered_sec, &map->tv);
 			evtimer_add (&map->ev, &map->tv);
 		}
@@ -1062,9 +974,7 @@ start_map_watch (struct rspamd_config *cfg, struct event_base *ev_base)
 			/* Read initial data */
 			read_http_sync (map, map->map_data);
 			/* Plan event with jitter */
-			jittered_sec =
-				(map->cfg->map_timeout + g_random_double () *
-				map->cfg->map_timeout);
+			jittered_sec = (map->cfg->map_timeout + g_random_double () * map->cfg->map_timeout);
 			double_to_tv (jittered_sec, &map->tv);
 			evtimer_add (&map->ev, &map->tv);
 		}
@@ -1072,7 +982,7 @@ start_map_watch (struct rspamd_config *cfg, struct event_base *ev_base)
 	}
 }
 
-void
+void 
 remove_all_maps (struct rspamd_config *cfg)
 {
 	g_list_free (cfg->maps);
@@ -1086,15 +996,13 @@ remove_all_maps (struct rspamd_config *cfg)
 gboolean
 check_map_proto (const gchar *map_line, gint *res, const gchar **pos)
 {
-	if (g_ascii_strncasecmp (map_line, "http://",
-		sizeof ("http://") - 1) == 0) {
+	if (g_ascii_strncasecmp (map_line, "http://", sizeof ("http://") - 1) == 0) {
 		if (res && pos) {
 			*res = MAP_PROTO_HTTP;
 			*pos = map_line + sizeof ("http://") - 1;
 		}
 	}
-	else if (g_ascii_strncasecmp (map_line, "file://", sizeof ("file://") -
-		1) == 0) {
+	else if (g_ascii_strncasecmp (map_line, "file://", sizeof ("file://") - 1) == 0) {
 		if (res && pos) {
 			*res = MAP_PROTO_FILE;
 			*pos = map_line + sizeof ("file://") - 1;
@@ -1114,21 +1022,17 @@ check_map_proto (const gchar *map_line, gint *res, const gchar **pos)
 }
 
 gboolean
-add_map (struct rspamd_config *cfg,
-	const gchar *map_line,
-	const gchar *description,
-	map_cb_t read_callback,
-	map_fin_cb_t fin_callback,
-	void **user_data)
+add_map (struct rspamd_config *cfg, const gchar *map_line, const gchar *description,
+		map_cb_t read_callback, map_fin_cb_t fin_callback, void **user_data)
 {
-	struct rspamd_map *new_map;
-	enum fetch_proto proto;
-	const gchar *def, *p, *hostend;
-	struct file_map_data *fdata;
-	struct http_map_data *hdata;
-	gchar portbuf[6];
-	gint i, s, r;
-	struct addrinfo hints, *res;
+	struct rspamd_map              *new_map;
+	enum fetch_proto                proto;
+	const gchar                    *def, *p, *hostend;
+	struct file_map_data           *fdata;
+	struct http_map_data           *hdata;
+	gchar                           portbuf[6];
+	gint                            i, s, r;
+	struct addrinfo                hints, *res;
 
 	/* First of all detect protocol line */
 	if (!check_map_proto (map_line, (int *)&proto, &def)) {
@@ -1145,8 +1049,7 @@ add_map (struct rspamd_config *cfg,
 	new_map->protocol = proto;
 	new_map->cfg = cfg;
 	new_map->id = g_random_int ();
-	new_map->locked =
-		rspamd_mempool_alloc0_shared (cfg->cfg_pool, sizeof (gint));
+	new_map->locked = rspamd_mempool_alloc0_shared (cfg->cfg_pool, sizeof (gint));
 
 	if (proto == MAP_PROTO_FILE) {
 		new_map->uri = rspamd_mempool_strdup (cfg->cfg_pool, def);
@@ -1156,24 +1059,19 @@ add_map (struct rspamd_config *cfg,
 		new_map->uri = rspamd_mempool_strdup (cfg->cfg_pool, map_line);
 	}
 	if (description != NULL) {
-		new_map->description =
-			rspamd_mempool_strdup (cfg->cfg_pool, description);
+		new_map->description = rspamd_mempool_strdup (cfg->cfg_pool, description);
 	}
 
 	/* Now check for each proto separately */
 	if (proto == MAP_PROTO_FILE) {
-		fdata =
-			rspamd_mempool_alloc0 (cfg->map_pool,
-				sizeof (struct file_map_data));
+		fdata = rspamd_mempool_alloc0 (cfg->map_pool, sizeof (struct file_map_data));
 		if (access (def, R_OK) == -1) {
 			if (errno != ENOENT) {
 				msg_err ("cannot open file '%s': %s", def, strerror (errno));
 				return FALSE;
 
 			}
-			msg_info (
-				"map '%s' is not found, but it can be loaded automatically later",
-				def);
+			msg_info ("map '%s' is not found, but it can be loaded automatically later", def);
 			/* We still can add this file */
 			fdata->st.st_mtime = -1;
 		}
@@ -1184,9 +1082,7 @@ add_map (struct rspamd_config *cfg,
 		new_map->map_data = fdata;
 	}
 	else if (proto == MAP_PROTO_HTTP) {
-		hdata =
-			rspamd_mempool_alloc0 (cfg->map_pool,
-				sizeof (struct http_map_data));
+		hdata = rspamd_mempool_alloc0 (cfg->map_pool, sizeof (struct http_map_data));
 		/* Try to search port */
 		if ((p = strchr (def, ':')) != NULL) {
 			hostend = p;
@@ -1229,21 +1125,15 @@ add_map (struct rspamd_config *cfg,
 
 		if ((r = getaddrinfo (hdata->host, portbuf, &hints, &res)) == 0) {
 			hdata->addr = res;
-			rspamd_mempool_add_destructor (cfg->cfg_pool,
-				(rspamd_mempool_destruct_t)freeaddrinfo, hdata->addr);
+			rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)freeaddrinfo, hdata->addr);
 		}
 		else {
-			msg_err ("address resolution for %s failed: %s",
-				hdata->host,
-				gai_strerror (r));
+			msg_err ("address resolution for %s failed: %s", hdata->host, gai_strerror (r));
 			return FALSE;
 		}
 		/* Now try to connect */
 		if ((s = make_tcp_socket (hdata->addr, FALSE, FALSE)) == -1) {
-			msg_info ("cannot connect to http server %s: %d, %s",
-				hdata->host,
-				errno,
-				strerror (errno));
+			msg_info ("cannot connect to http server %s: %d, %s", hdata->host, errno, strerror (errno));
 			return FALSE;
 		}
 		close (s);
diff --git a/src/libutil/map.h b/src/libutil/map.h
index 1b5c01f1e..ddb9882e4 100644
--- a/src/libutil/map.h
+++ b/src/libutil/map.h
@@ -34,7 +34,7 @@ struct http_map_data {
 	gchar *host;
 	time_t last_checked;
 	gshort chunked;
-	gchar read_buf[BUFSIZ];
+	gchar  read_buf[BUFSIZ];
 	guint32 rlen;
 	guint32 chunk;
 	guint32 chunk_remain;
@@ -45,8 +45,7 @@ struct map_cb_data;
 /**
  * Callback types
  */
-typedef gchar * (*map_cb_t)(rspamd_mempool_t *pool, gchar *chunk, gint len,
-	struct map_cb_data *data);
+typedef gchar* (*map_cb_t)(rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data);
 typedef void (*map_fin_cb_t)(rspamd_mempool_t *pool, struct map_cb_data *data);
 
 /**
@@ -90,12 +89,8 @@ gboolean check_map_proto (const gchar *map_line, gint *res, const gchar **pos);
 /**
  * Add map from line
  */
-gboolean add_map (struct rspamd_config *cfg,
-	const gchar *map_line,
-	const gchar *description,
-	map_cb_t read_callback,
-	map_fin_cb_t fin_callback,
-	void **user_data);
+gboolean add_map (struct rspamd_config *cfg, const gchar *map_line, const gchar *description,
+		map_cb_t read_callback, map_fin_cb_t fin_callback, void **user_data);
 
 /**
  * Start watching of maps by adding events to libevent event loop
@@ -107,8 +102,7 @@ void start_map_watch (struct rspamd_config *cfg, struct event_base *ev_base);
  */
 void remove_all_maps (struct rspamd_config *cfg);
 
-typedef void (*insert_func) (gpointer st, gconstpointer key,
-	gconstpointer value);
+typedef void                    (*insert_func) (gpointer st, gconstpointer key, gconstpointer value);
 
 /**
  * Common callbacks for frequent types of lists
@@ -117,37 +111,24 @@ typedef void (*insert_func) (gpointer st, gconstpointer key,
 /**
  * Radix list is a list like ip/mask
  */
-gchar * read_radix_list (rspamd_mempool_t *pool,
-	gchar *chunk,
-	gint len,
-	struct map_cb_data *data);
+gchar* read_radix_list (rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data);
 void fin_radix_list (rspamd_mempool_t *pool, struct map_cb_data *data);
 
 /**
  * Host list is an ordinal list of hosts or domains
  */
-gchar * read_host_list (rspamd_mempool_t *pool,
-	gchar *chunk,
-	gint len,
-	struct map_cb_data *data);
+gchar* read_host_list (rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data);
 void fin_host_list (rspamd_mempool_t *pool, struct map_cb_data *data);
 
 /**
  * Kv list is an ordinal list of keys and values separated by whitespace
  */
-gchar * read_kv_list (rspamd_mempool_t *pool,
-	gchar *chunk,
-	gint len,
-	struct map_cb_data *data);
+gchar* read_kv_list (rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data);
 void fin_kv_list (rspamd_mempool_t *pool, struct map_cb_data *data);
 
 /**
  * FSM for lists parsing (support comments, blank lines and partial replies)
  */
-gchar * abstract_parse_list (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data,
-	insert_func func);
+gchar * abstract_parse_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data, insert_func func);
 
 #endif
diff --git a/src/libutil/mem_pool.c b/src/libutil/mem_pool.c
index 630ea6b3c..6ace865a0 100644
--- a/src/libutil/mem_pool.c
+++ b/src/libutil/mem_pool.c
@@ -23,18 +23,18 @@
  */
 
 #include "config.h"
+#include "mem_pool.h"
 #include "fstring.h"
 #include "logger.h"
-#include "main.h"
-#include "mem_pool.h"
 #include "util.h"
+#include "main.h"
 
 /* Sleep time for spin lock in nanoseconds */
 #define MUTEX_SLEEP_TIME 10000000L
 #define MUTEX_SPIN_COUNT 100
 
 #ifdef _THREAD_SAFE
-pthread_mutex_t stat_mtx = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t                 stat_mtx = PTHREAD_MUTEX_INITIALIZER;
 #   define STAT_LOCK() do { pthread_mutex_lock (&stat_mtx); } while (0)
 #   define STAT_UNLOCK() do { pthread_mutex_unlock (&stat_mtx); } while (0)
 #else
@@ -42,10 +42,10 @@ pthread_mutex_t stat_mtx = PTHREAD_MUTEX_INITIALIZER;
 #   define STAT_UNLOCK() do {} while (0)
 #endif
 
-#define POOL_MTX_LOCK() do { rspamd_mutex_lock (pool->mtx); } while (0)
-#define POOL_MTX_UNLOCK()   do { rspamd_mutex_unlock (pool->mtx); } while (0)
+#define POOL_MTX_LOCK()	do { rspamd_mutex_lock (pool->mtx); } while (0)
+#define POOL_MTX_UNLOCK()	do { rspamd_mutex_unlock (pool->mtx); } while (0)
 
-/*
+/* 
  * This define specify whether we should check all pools for free space for new object
  * or just begin scan from current (recently attached) pool
  * If MEMORY_GREEDY is defined, then we scan all pools to find free space (more CPU usage, slower
@@ -56,7 +56,7 @@ pthread_mutex_t stat_mtx = PTHREAD_MUTEX_INITIALIZER;
 #undef MEMORY_GREEDY
 
 /* Internal statistic */
-static rspamd_mempool_stat_t *mem_pool_stat = NULL;
+static rspamd_mempool_stat_t      *mem_pool_stat = NULL;
 
 /**
  * Function that return free space in pool page
@@ -68,18 +68,17 @@ pool_chain_free (struct _pool_chain *chain)
 	return (gint)chain->len - (chain->pos - chain->begin + MEM_ALIGNMENT);
 }
 
-static struct _pool_chain *
+static struct _pool_chain      *
 pool_chain_new (gsize size)
 {
-	struct _pool_chain *chain;
+	struct _pool_chain             *chain;
 
 	g_return_val_if_fail (size > 0, NULL);
 
 	chain = g_slice_alloc (sizeof (struct _pool_chain));
 
 	if (chain == NULL) {
-		msg_err ("cannot allocate %z bytes, aborting",
-			sizeof (struct _pool_chain));
+		msg_err ("cannot allocate %z bytes, aborting", sizeof (struct _pool_chain));
 		abort ();
 	}
 
@@ -103,46 +102,34 @@ pool_chain_new (gsize size)
 static struct _pool_chain_shared *
 pool_chain_new_shared (gsize size)
 {
-	struct _pool_chain_shared *chain;
-	gpointer map;
+	struct _pool_chain_shared      *chain;
+	gpointer                        map;
 
 
 #if defined(HAVE_MMAP_ANON)
-	map = mmap (NULL,
-			size + sizeof (struct _pool_chain_shared),
-			PROT_READ | PROT_WRITE,
-			MAP_ANON | MAP_SHARED,
-			-1,
-			0);
+	map = mmap (NULL, size + sizeof (struct _pool_chain_shared), PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
 	if (map == MAP_FAILED) {
-		msg_err ("cannot allocate %z bytes, aborting", size +
-			sizeof (struct _pool_chain));
+		msg_err ("cannot allocate %z bytes, aborting", size + sizeof (struct _pool_chain));
 		abort ();
 	}
 	chain = (struct _pool_chain_shared *)map;
 	chain->begin = ((guint8 *) chain) + sizeof (struct _pool_chain_shared);
 #elif defined(HAVE_MMAP_ZERO)
-	gint fd;
+	gint                            fd;
 
 	fd = open ("/dev/zero", O_RDWR);
 	if (fd == -1) {
 		return NULL;
 	}
-	map = mmap (NULL,
-			size + sizeof (struct _pool_chain_shared),
-			PROT_READ | PROT_WRITE,
-			MAP_SHARED,
-			fd,
-			0);
+	map = mmap (NULL, size + sizeof (struct _pool_chain_shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 	if (map == MAP_FAILED) {
-		msg_err ("cannot allocate %z bytes, aborting", size +
-			sizeof (struct _pool_chain));
+		msg_err ("cannot allocate %z bytes, aborting", size + sizeof (struct _pool_chain));
 		abort ();
 	}
 	chain = (struct _pool_chain_shared *)map;
 	chain->begin = ((guint8 *) chain) + sizeof (struct _pool_chain_shared);
 #else
-#       error No mmap methods are defined
+#   	error No mmap methods are defined
 #endif
 	chain->pos = align_ptr (chain->begin, MEM_ALIGNMENT);
 	chain->len = size;
@@ -158,59 +145,46 @@ pool_chain_new_shared (gsize size)
 
 
 /**
- * Allocate new memory poll
+ * Allocate new memory poll 
  * @param size size of pool's page
  * @return new memory pool object
  */
-rspamd_mempool_t *
+rspamd_mempool_t                  *
 rspamd_mempool_new (gsize size)
 {
-	rspamd_mempool_t *new;
-	gpointer map;
+	rspamd_mempool_t                  *new;
+	gpointer                        map;
 
 	g_return_val_if_fail (size > 0, NULL);
 	/* Allocate statistic structure if it is not allocated before */
 	if (mem_pool_stat == NULL) {
 #if defined(HAVE_MMAP_ANON)
-		map = mmap (NULL,
-				sizeof (rspamd_mempool_stat_t),
-				PROT_READ | PROT_WRITE,
-				MAP_ANON | MAP_SHARED,
-				-1,
-				0);
+		map = mmap (NULL, sizeof (rspamd_mempool_stat_t), PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
 		if (map == MAP_FAILED) {
-			msg_err ("cannot allocate %z bytes, aborting",
-				sizeof (rspamd_mempool_stat_t));
+			msg_err ("cannot allocate %z bytes, aborting", sizeof (rspamd_mempool_stat_t));
 			abort ();
 		}
 		mem_pool_stat = (rspamd_mempool_stat_t *)map;
 #elif defined(HAVE_MMAP_ZERO)
-		gint fd;
+		gint                            fd;
 
 		fd = open ("/dev/zero", O_RDWR);
 		g_assert (fd != -1);
-		map = mmap (NULL,
-				sizeof (rspamd_mempool_stat_t),
-				PROT_READ | PROT_WRITE,
-				MAP_SHARED,
-				fd,
-				0);
+		map = mmap (NULL, sizeof (rspamd_mempool_stat_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 		if (map == MAP_FAILED) {
-			msg_err ("cannot allocate %z bytes, aborting",
-				sizeof (rspamd_mempool_stat_t));
+			msg_err ("cannot allocate %z bytes, aborting", sizeof (rspamd_mempool_stat_t));
 			abort ();
 		}
 		mem_pool_stat = (rspamd_mempool_stat_t *)map;
 #else
-#       error No mmap methods are defined
+#   	error No mmap methods are defined
 #endif
 		memset (map, 0, sizeof (rspamd_mempool_stat_t));
 	}
 
 	new = g_slice_alloc (sizeof (rspamd_mempool_t));
 	if (new == NULL) {
-		msg_err ("cannot allocate %z bytes, aborting",
-			sizeof (rspamd_mempool_t));
+		msg_err ("cannot allocate %z bytes, aborting", sizeof (rspamd_mempool_t));
 		abort ();
 	}
 
@@ -229,12 +203,12 @@ rspamd_mempool_new (gsize size)
 	return new;
 }
 
-static void *
+static void                           *
 memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size, gboolean is_tmp)
 {
-	guint8 *tmp;
-	struct _pool_chain *new, *cur;
-	gint free;
+	guint8                         *tmp;
+	struct _pool_chain             *new, *cur;
+	gint                            free;
 
 	if (pool) {
 		POOL_MTX_LOCK ();
@@ -255,8 +229,8 @@ memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size, gboolean is_tmp)
 #endif
 		/* Find free space in pool chain */
 		while (cur != NULL &&
-			(free = pool_chain_free (cur)) < (gint)size &&
-			cur->next != NULL) {
+				(free = pool_chain_free (cur)) < (gint)size &&
+				cur->next != NULL) {
 			cur = cur->next;
 		}
 
@@ -267,8 +241,7 @@ memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size, gboolean is_tmp)
 					new = pool_chain_new (pool->first_pool->len);
 				}
 				else {
-					new = pool_chain_new (
-						size + pool->first_pool->len + MEM_ALIGNMENT);
+					new = pool_chain_new (size + pool->first_pool->len + MEM_ALIGNMENT);
 				}
 				/* Connect to pool subsystem */
 				if (is_tmp) {
@@ -284,8 +257,7 @@ memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size, gboolean is_tmp)
 				}
 				else {
 					mem_pool_stat->oversized_chunks++;
-					new = pool_chain_new (
-						size + pool->first_pool->len + MEM_ALIGNMENT);
+					new = pool_chain_new (size + pool->first_pool->len + MEM_ALIGNMENT);
 				}
 				/* Attach new pool to chain */
 				cur->next = new;
@@ -312,42 +284,42 @@ memory_pool_alloc_common (rspamd_mempool_t * pool, gsize size, gboolean is_tmp)
 }
 
 
-void *
+void                           *
 rspamd_mempool_alloc (rspamd_mempool_t * pool, gsize size)
 {
 	return memory_pool_alloc_common (pool, size, FALSE);
 }
 
-void *
+void                           *
 rspamd_mempool_alloc_tmp (rspamd_mempool_t * pool, gsize size)
 {
 	return memory_pool_alloc_common (pool, size, TRUE);
 }
 
-void *
+void                           *
 rspamd_mempool_alloc0 (rspamd_mempool_t * pool, gsize size)
 {
-	void *pointer = rspamd_mempool_alloc (pool, size);
+	void                           *pointer = rspamd_mempool_alloc (pool, size);
 	if (pointer) {
 		memset (pointer, 0, size);
 	}
 	return pointer;
 }
 
-void *
+void                           *
 rspamd_mempool_alloc0_tmp (rspamd_mempool_t * pool, gsize size)
 {
-	void *pointer = rspamd_mempool_alloc_tmp (pool, size);
+	void                           *pointer = rspamd_mempool_alloc_tmp (pool, size);
 	if (pointer) {
 		memset (pointer, 0, size);
 	}
 	return pointer;
 }
 
-void *
+void                           *
 rspamd_mempool_alloc0_shared (rspamd_mempool_t * pool, gsize size)
 {
-	void *pointer = rspamd_mempool_alloc_shared (pool, size);
+	void                           *pointer = rspamd_mempool_alloc_shared (pool, size);
 	if (pointer) {
 		memset (pointer, 0, size);
 	}
@@ -362,7 +334,7 @@ rspamd_mempool_alloc_shared (rspamd_mempool_t * pool, gsize size)
 	gint free;
 
 	if (pool) {
-		g_return_val_if_fail (size > 0, NULL);
+		g_return_val_if_fail(size > 0, NULL);
 
 		POOL_MTX_LOCK ()
 		;
@@ -374,7 +346,7 @@ rspamd_mempool_alloc_shared (rspamd_mempool_t * pool, gsize size)
 
 		/* Find free space in pool chain */
 		while ((free = pool_chain_free ((struct _pool_chain *) cur))
-			< (gint) size && cur->next) {
+				< (gint) size && cur->next) {
 			cur = cur->next;
 		}
 		if (free < (gint) size && cur->next == NULL) {
@@ -386,7 +358,7 @@ rspamd_mempool_alloc_shared (rspamd_mempool_t * pool, gsize size)
 			else {
 				mem_pool_stat->oversized_chunks++;
 				new = pool_chain_new_shared (
-					size + pool->first_pool->len + MEM_ALIGNMENT);
+						size + pool->first_pool->len + MEM_ALIGNMENT);
 			}
 			/* Attach new pool to chain */
 			cur->next = new;
@@ -398,7 +370,7 @@ rspamd_mempool_alloc_shared (rspamd_mempool_t * pool, gsize size)
 			;
 			return new->begin;
 		}
-		tmp = align_ptr (cur->pos, MEM_ALIGNMENT);
+		tmp = align_ptr(cur->pos, MEM_ALIGNMENT);
 		cur->pos = tmp + size;
 		POOL_MTX_UNLOCK ()
 		;
@@ -408,11 +380,11 @@ rspamd_mempool_alloc_shared (rspamd_mempool_t * pool, gsize size)
 }
 
 
-gchar *
+gchar                           *
 rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src)
 {
-	gsize len;
-	gchar *newstr;
+	gsize             len;
+	gchar                           *newstr;
 
 	if (src == NULL) {
 		return NULL;
@@ -425,10 +397,10 @@ rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src)
 	return newstr;
 }
 
-gchar *
+gchar                           *
 rspamd_mempool_fstrdup (rspamd_mempool_t * pool, const struct f_str_s *src)
 {
-	gchar *newstr;
+	gchar                           *newstr;
 
 	if (src == NULL) {
 		return NULL;
@@ -441,11 +413,11 @@ rspamd_mempool_fstrdup (rspamd_mempool_t * pool, const struct f_str_s *src)
 }
 
 
-gchar *
+gchar                           *
 rspamd_mempool_strdup_shared (rspamd_mempool_t * pool, const gchar *src)
 {
-	gsize len;
-	gchar *newstr;
+	gsize             len;
+	gchar                           *newstr;
 
 	if (src == NULL) {
 		return NULL;
@@ -462,11 +434,10 @@ rspamd_mempool_strdup_shared (rspamd_mempool_t * pool, const gchar *src)
 static struct _pool_chain_shared *
 memory_pool_find_pool (rspamd_mempool_t * pool, void *pointer)
 {
-	struct _pool_chain_shared *cur = pool->shared_pool;
+	struct _pool_chain_shared      *cur = pool->shared_pool;
 
 	while (cur) {
-		if ((guint8 *) pointer >= cur->begin && (guint8 *) pointer <=
-			(cur->begin + cur->len)) {
+		if ((guint8 *) pointer >= cur->begin && (guint8 *) pointer <= (cur->begin + cur->len)) {
 			return cur;
 		}
 		cur = cur->next;
@@ -495,19 +466,19 @@ __mutex_spin (rspamd_mempool_mutex_t * mutex)
 		g_atomic_int_set (&mutex->spin, MUTEX_SPIN_COUNT);
 	}
 #ifdef HAVE_ASM_PAUSE
-	__asm __volatile ("pause");
+	__asm                           __volatile ("pause");
 #elif defined(HAVE_SCHED_YIELD)
 	(void)sched_yield ();
 #endif
 
 #if defined(HAVE_NANOSLEEP)
-	struct timespec ts;
+	struct timespec                 ts;
 	ts.tv_sec = 0;
 	ts.tv_nsec = MUTEX_SLEEP_TIME;
 	/* Spin */
-	while (nanosleep (&ts, &ts) == -1 && errno == EINTR) ;
+	while (nanosleep (&ts, &ts) == -1 && errno == EINTR);
 #else
-#       error No methods to spin are defined
+#   	error No methods to spin are defined
 #endif
 	return 1;
 }
@@ -526,7 +497,7 @@ memory_pool_mutex_spin (rspamd_mempool_mutex_t * mutex)
 void
 rspamd_mempool_lock_shared (rspamd_mempool_t * pool, void *pointer)
 {
-	struct _pool_chain_shared *chain;
+	struct _pool_chain_shared      *chain;
 
 	chain = memory_pool_find_pool (pool, pointer);
 	if (chain == NULL) {
@@ -541,7 +512,7 @@ rspamd_mempool_lock_shared (rspamd_mempool_t * pool, void *pointer)
 void
 rspamd_mempool_unlock_shared (rspamd_mempool_t * pool, void *pointer)
 {
-	struct _pool_chain_shared *chain;
+	struct _pool_chain_shared      *chain;
 
 	chain = memory_pool_find_pool (pool, pointer);
 	if (chain == NULL) {
@@ -556,13 +527,10 @@ rspamd_mempool_unlock_shared (rspamd_mempool_t * pool, void *pointer)
 }
 
 void
-rspamd_mempool_add_destructor_full (rspamd_mempool_t * pool,
-	rspamd_mempool_destruct_t func,
-	void *data,
-	const gchar *function,
-	const gchar *line)
+rspamd_mempool_add_destructor_full (rspamd_mempool_t * pool, rspamd_mempool_destruct_t func, void *data,
+		const gchar *function, const gchar *line)
 {
-	struct _pool_destructors *cur;
+	struct _pool_destructors       *cur;
 
 	cur = rspamd_mempool_alloc (pool, sizeof (struct _pool_destructors));
 	if (cur) {
@@ -578,12 +546,9 @@ rspamd_mempool_add_destructor_full (rspamd_mempool_t * pool,
 }
 
 void
-rspamd_mempool_replace_destructor (rspamd_mempool_t * pool,
-	rspamd_mempool_destruct_t func,
-	void *old_data,
-	void *new_data)
+rspamd_mempool_replace_destructor (rspamd_mempool_t * pool, rspamd_mempool_destruct_t func, void *old_data, void *new_data)
 {
-	struct _pool_destructors *tmp;
+	struct _pool_destructors       *tmp;
 
 	tmp = pool->destructors;
 	while (tmp) {
@@ -600,9 +565,9 @@ rspamd_mempool_replace_destructor (rspamd_mempool_t * pool,
 void
 rspamd_mempool_delete (rspamd_mempool_t * pool)
 {
-	struct _pool_chain *cur = pool->first_pool, *tmp;
-	struct _pool_chain_shared *cur_shared = pool->shared_pool, *tmp_shared;
-	struct _pool_destructors *destructor = pool->destructors;
+	struct _pool_chain             *cur = pool->first_pool, *tmp;
+	struct _pool_chain_shared      *cur_shared = pool->shared_pool, *tmp_shared;
+	struct _pool_destructors       *destructor = pool->destructors;
 
 	POOL_MTX_LOCK ();
 	/* Call all pool destructors */
@@ -644,8 +609,7 @@ rspamd_mempool_delete (rspamd_mempool_t * pool)
 		mem_pool_stat->chunks_freed++;
 		mem_pool_stat->bytes_allocated -= tmp_shared->len;
 		STAT_UNLOCK ();
-		munmap ((void *)tmp_shared, tmp_shared->len +
-			sizeof (struct _pool_chain_shared));
+		munmap ((void *)tmp_shared, tmp_shared->len + sizeof (struct _pool_chain_shared));
 	}
 	if (pool->variables) {
 		g_hash_table_destroy (pool->variables);
@@ -658,9 +622,9 @@ rspamd_mempool_delete (rspamd_mempool_t * pool)
 }
 
 void
-rspamd_mempool_cleanup_tmp (rspamd_mempool_t * pool)
+rspamd_mempool_cleanup_tmp (rspamd_mempool_t* pool)
 {
-	struct _pool_chain *cur = pool->first_pool, *tmp;
+	struct _pool_chain             *cur = pool->first_pool, *tmp;
 
 	POOL_MTX_LOCK ();
 	cur = pool->first_pool_tmp;
@@ -713,13 +677,12 @@ rspamd_mempool_suggest_size (void)
 #endif
 }
 
-rspamd_mempool_mutex_t *
+rspamd_mempool_mutex_t            *
 rspamd_mempool_get_mutex (rspamd_mempool_t * pool)
 {
-	rspamd_mempool_mutex_t *res;
+	rspamd_mempool_mutex_t            *res;
 	if (pool != NULL) {
-		res =
-			rspamd_mempool_alloc_shared (pool, sizeof (rspamd_mempool_mutex_t));
+		res = rspamd_mempool_alloc_shared (pool, sizeof (rspamd_mempool_mutex_t));
 		res->lock = 0;
 		res->owner = 0;
 		res->spin = MUTEX_SPIN_COUNT;
@@ -742,10 +705,10 @@ rspamd_mempool_unlock_mutex (rspamd_mempool_mutex_t * mutex)
 	(void)g_atomic_int_compare_and_exchange (&mutex->lock, 1, 0);
 }
 
-rspamd_mempool_rwlock_t *
+rspamd_mempool_rwlock_t           *
 rspamd_mempool_get_rwlock (rspamd_mempool_t * pool)
 {
-	rspamd_mempool_rwlock_t *lock;
+	rspamd_mempool_rwlock_t           *lock;
 
 	lock = rspamd_mempool_alloc_shared (pool, sizeof (rspamd_mempool_rwlock_t));
 	lock->__r_lock = rspamd_mempool_get_mutex (pool);
@@ -794,18 +757,14 @@ rspamd_mempool_wunlock_rwlock (rspamd_mempool_rwlock_t * lock)
 	rspamd_mempool_unlock_mutex (lock->__w_lock);
 }
 
-void
-rspamd_mempool_set_variable (rspamd_mempool_t *pool,
-	const gchar *name,
-	gpointer value,
-	rspamd_mempool_destruct_t destructor)
+void 
+rspamd_mempool_set_variable (rspamd_mempool_t *pool, const gchar *name, gpointer value, rspamd_mempool_destruct_t destructor)
 {
 	if (pool->variables == NULL) {
 		pool->variables = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	}
 
-	g_hash_table_insert (pool->variables, rspamd_mempool_strdup (pool,
-		name), value);
+	g_hash_table_insert (pool->variables, rspamd_mempool_strdup (pool, name), value);
 	if (destructor != NULL) {
 		rspamd_mempool_add_destructor (pool, destructor, value);
 	}
diff --git a/src/libutil/mem_pool.h b/src/libutil/mem_pool.h
index 2a8546ef0..17edf2fb2 100644
--- a/src/libutil/mem_pool.h
+++ b/src/libutil/mem_pool.h
@@ -19,10 +19,10 @@ struct f_str_s;
 
 #define MEM_ALIGNMENT   sizeof(unsigned long)    /* platform word */
 #define align_ptr(p, a)                                                   \
-	(guint8 *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
+    (guint8 *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
 
-/**
- * Destructor type definition
+/** 
+ * Destructor type definition 
  */
 typedef void (*rspamd_mempool_destruct_t)(void *ptr);
 
@@ -39,10 +39,10 @@ typedef struct memory_pool_mutex_s {
  * Pool page structure
  */
 struct _pool_chain {
-	guint8 *begin;                  /**< begin of pool chain block              */
-	guint8 *pos;                    /**< current start of free space in block   */
-	gsize len;      /**< length of block                        */
-	struct _pool_chain *next;       /**< chain link                             */
+	guint8 *begin;					/**< begin of pool chain block 				*/
+	guint8 *pos;					/**< current start of free space in block 	*/
+	gsize len;		/**< length of block 						*/
+	struct _pool_chain *next;		/**< chain link 							*/
 };
 
 /**
@@ -60,11 +60,11 @@ struct _pool_chain_shared {
  * Destructors list item structure
  */
 struct _pool_destructors {
-	rspamd_mempool_destruct_t func;             /**< pointer to destructor					*/
-	void *data;                             /**< data to free							*/
-	const gchar *function;                  /**< function from which this destructor was added */
-	const gchar *loc;                       /**< line number                            */
-	struct _pool_destructors *prev;         /**< chain link								*/
+	rspamd_mempool_destruct_t func;				/**< pointer to destructor					*/
+	void *data;								/**< data to free							*/
+	const gchar *function;					/**< function from which this destructor was added */
+	const gchar *loc;						/**< line number                            */
+	struct _pool_destructors *prev;			/**< chain link								*/
 };
 
 /**
@@ -72,51 +72,51 @@ struct _pool_destructors {
  */
 struct rspamd_mutex_s;
 typedef struct memory_pool_s {
-	struct _pool_chain *cur_pool;           /**< currently used page					*/
-	struct _pool_chain *first_pool;         /**< first page								*/
-	struct _pool_chain *cur_pool_tmp;       /**< currently used temporary page			*/
-	struct _pool_chain *first_pool_tmp;     /**< first temporary page					*/
-	struct _pool_chain_shared *shared_pool; /**< shared chain							*/
-	struct _pool_destructors *destructors;  /**< destructors chain						*/
-	GHashTable *variables;                  /**< private memory pool variables			*/
-	struct rspamd_mutex_s *mtx;             /**< threads lock							*/
+	struct _pool_chain *cur_pool;			/**< currently used page					*/
+	struct _pool_chain *first_pool;			/**< first page								*/
+	struct _pool_chain *cur_pool_tmp;		/**< currently used temporary page			*/
+	struct _pool_chain *first_pool_tmp;		/**< first temporary page					*/
+	struct _pool_chain_shared *shared_pool;	/**< shared chain							*/
+	struct _pool_destructors *destructors;	/**< destructors chain						*/
+	GHashTable *variables;					/**< private memory pool variables			*/
+	struct rspamd_mutex_s *mtx;				/**< threads lock							*/
 } rspamd_mempool_t;
 
 /**
  * Statistics structure
  */
 typedef struct memory_pool_stat_s {
-	gsize pools_allocated;              /**< total number of allocated pools					*/
-	gsize pools_freed;                  /**< number of freed pools								*/
-	gsize bytes_allocated;              /**< bytes that are allocated with pool allocator		*/
-	gsize chunks_allocated;             /**< number of chunks that are allocated				*/
-	gsize shared_chunks_allocated;      /**< shared chunks allocated							*/
-	gsize chunks_freed;                 /**< chunks freed										*/
-	gsize oversized_chunks;             /**< oversized chunks									*/
+	gsize pools_allocated;				/**< total number of allocated pools					*/
+	gsize pools_freed;					/**< number of freed pools								*/
+	gsize bytes_allocated;				/**< bytes that are allocated with pool allocator		*/
+	gsize chunks_allocated;				/**< number of chunks that are allocated				*/
+	gsize shared_chunks_allocated;		/**< shared chunks allocated							*/
+	gsize chunks_freed;					/**< chunks freed										*/
+	gsize oversized_chunks;				/**< oversized chunks									*/
 } rspamd_mempool_stat_t;
 
 /**
  * Rwlock for locking shared memory regions
  */
 typedef struct memory_pool_rwlock_s {
-	rspamd_mempool_mutex_t *__r_lock;                           /**< read mutex (private)								*/
-	rspamd_mempool_mutex_t *__w_lock;                           /**< write mutex (private)								*/
+	rspamd_mempool_mutex_t *__r_lock;							/**< read mutex (private)								*/
+	rspamd_mempool_mutex_t *__w_lock;							/**< write mutex (private)								*/
 } rspamd_mempool_rwlock_t;
 
 /**
- * Allocate new memory poll
+ * Allocate new memory poll 
  * @param size size of pool's page
  * @return new memory pool object
  */
-rspamd_mempool_t * rspamd_mempool_new (gsize size);
+rspamd_mempool_t* rspamd_mempool_new (gsize size);
 
-/**
+/** 
  * Get memory from pool
  * @param pool memory pool object
  * @param size bytes to allocate
  * @return pointer to allocated object
  */
-void * rspamd_mempool_alloc (rspamd_mempool_t * pool, gsize size);
+void* rspamd_mempool_alloc (rspamd_mempool_t* pool, gsize size);
 
 /**
  * Get memory from temporary pool
@@ -124,7 +124,7 @@ void * rspamd_mempool_alloc (rspamd_mempool_t * pool, gsize size);
  * @param size bytes to allocate
  * @return pointer to allocated object
  */
-void * rspamd_mempool_alloc_tmp (rspamd_mempool_t * pool, gsize size);
+void* rspamd_mempool_alloc_tmp (rspamd_mempool_t* pool, gsize size);
 
 /**
  * Get memory and set it to zero
@@ -132,7 +132,7 @@ void * rspamd_mempool_alloc_tmp (rspamd_mempool_t * pool, gsize size);
  * @param size bytes to allocate
  * @return pointer to allocated object
  */
-void * rspamd_mempool_alloc0 (rspamd_mempool_t * pool, gsize size);
+void* rspamd_mempool_alloc0 (rspamd_mempool_t* pool, gsize size);
 
 /**
  * Get memory and set it to zero
@@ -140,12 +140,12 @@ void * rspamd_mempool_alloc0 (rspamd_mempool_t * pool, gsize size);
  * @param size bytes to allocate
  * @return pointer to allocated object
  */
-void * rspamd_mempool_alloc0_tmp (rspamd_mempool_t * pool, gsize size);
+void* rspamd_mempool_alloc0_tmp (rspamd_mempool_t* pool, gsize size);
 
 /**
  * Cleanup temporary data in pool
  */
-void rspamd_mempool_cleanup_tmp (rspamd_mempool_t * pool);
+void rspamd_mempool_cleanup_tmp (rspamd_mempool_t* pool);
 
 /**
  * Make a copy of string in pool
@@ -153,7 +153,7 @@ void rspamd_mempool_cleanup_tmp (rspamd_mempool_t * pool);
  * @param src source string
  * @return pointer to newly created string that is copy of src
  */
-gchar * rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src);
+gchar* rspamd_mempool_strdup (rspamd_mempool_t* pool, const gchar *src);
 
 /**
  * Make a copy of fixed string in pool as null terminated string
@@ -161,18 +161,16 @@ gchar * rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src);
  * @param src source string
  * @return pointer to newly created string that is copy of src
  */
-gchar * rspamd_mempool_fstrdup (rspamd_mempool_t * pool,
-	const struct f_str_s *src);
+gchar* rspamd_mempool_fstrdup (rspamd_mempool_t* pool, const struct f_str_s *src);
 
 /**
  * Allocate piece of shared memory
  * @param pool memory pool object
  * @param size bytes to allocate
  */
-void * rspamd_mempool_alloc_shared (rspamd_mempool_t * pool, gsize size);
-void * rspamd_mempool_alloc0_shared (rspamd_mempool_t *pool, gsize size);
-gchar * rspamd_mempool_strdup_shared (rspamd_mempool_t * pool,
-	const gchar *src);
+void* rspamd_mempool_alloc_shared (rspamd_mempool_t* pool, gsize size);
+void* rspamd_mempool_alloc0_shared (rspamd_mempool_t *pool, gsize size);
+gchar* rspamd_mempool_strdup_shared (rspamd_mempool_t* pool, const gchar *src);
 
 /**
  * Lock chunk of shared memory in which pointer is placed
@@ -194,15 +192,12 @@ void rspamd_mempool_lock_shared (rspamd_mempool_t *pool, void *pointer);
  * @param func pointer to function-destructor
  * @param data pointer to data that would be passed to destructor
  */
-void rspamd_mempool_add_destructor_full (rspamd_mempool_t *pool,
-	rspamd_mempool_destruct_t func,
-	void *data,
-	const gchar *function,
-	const gchar *line);
+void rspamd_mempool_add_destructor_full (rspamd_mempool_t *pool, rspamd_mempool_destruct_t func, void *data,
+		const gchar *function, const gchar *line);
 
 /* Macros for common usage */
 #define rspamd_mempool_add_destructor(pool, func, data) \
-	rspamd_mempool_add_destructor_full (pool, func, data, G_STRFUNC, G_STRLOC)
+	rspamd_mempool_add_destructor_full(pool, func, data, G_STRFUNC, G_STRLOC)
 
 /**
  * Replace destructor callback to pool for specified pointer
@@ -212,7 +207,7 @@ void rspamd_mempool_add_destructor_full (rspamd_mempool_t *pool,
  * @param new_data pointer to data that would be passed to destructor
  */
 void rspamd_mempool_replace_destructor (rspamd_mempool_t *pool,
-	rspamd_mempool_destruct_t func, void *old_data, void *new_data);
+		rspamd_mempool_destruct_t func, void *old_data, void *new_data);
 
 /**
  * Delete pool, free all its chunks and call destructors chain
@@ -220,12 +215,12 @@ void rspamd_mempool_replace_destructor (rspamd_mempool_t *pool,
  */
 void rspamd_mempool_delete (rspamd_mempool_t *pool);
 
-/**
+/** 
  * Get new mutex from pool (allocated in shared memory)
  * @param pool memory pool object
  * @return mutex object
  */
-rspamd_mempool_mutex_t * rspamd_mempool_get_mutex (rspamd_mempool_t *pool);
+rspamd_mempool_mutex_t* rspamd_mempool_get_mutex (rspamd_mempool_t *pool);
 
 /**
  * Lock mutex
@@ -244,7 +239,7 @@ void rspamd_mempool_unlock_mutex (rspamd_mempool_mutex_t *mutex);
  * @param pool memory pool object
  * @return rwlock object
  */
-rspamd_mempool_rwlock_t * rspamd_mempool_get_rwlock (rspamd_mempool_t *pool);
+rspamd_mempool_rwlock_t* rspamd_mempool_get_rwlock (rspamd_mempool_t *pool);
 
 /**
  * Aquire read lock
@@ -295,7 +290,7 @@ gsize rspamd_mempool_suggest_size (void);
  * @param destructor pointer to function-destructor
  */
 void rspamd_mempool_set_variable (rspamd_mempool_t *pool, const gchar *name,
-	gpointer value, rspamd_mempool_destruct_t destructor);
+		gpointer value, rspamd_mempool_destruct_t destructor);
 
 /**
  * Get memory pool variable
@@ -303,8 +298,7 @@ void rspamd_mempool_set_variable (rspamd_mempool_t *pool, const gchar *name,
  * @param name name of variable
  * @return NULL or pointer to variable data
  */
-gpointer rspamd_mempool_get_variable (rspamd_mempool_t *pool,
-	const gchar *name);
+gpointer rspamd_mempool_get_variable (rspamd_mempool_t *pool, const gchar *name);
 
 
 #endif
diff --git a/src/libutil/printf.c b/src/libutil/printf.c
index d40b74bca..ba30587fc 100644
--- a/src/libutil/printf.c
+++ b/src/libutil/printf.c
@@ -21,9 +21,9 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "printf.h"
 #include "fstring.h"
 #include "main.h"
-#include "printf.h"
 
 /**
  * From FreeBSD libutil code
@@ -90,13 +90,13 @@ rspamd_humanize_number (gchar *buf, gchar *last, gint64 num, gboolean bytes)
 
 static gchar *
 rspamd_sprintf_num (gchar *buf, gchar *last, guint64 ui64, gchar zero,
-	guint hexadecimal, guint width)
+	guint                           hexadecimal, guint width)
 {
-	gchar *p, temp[sizeof ("18446744073709551615")];
-	size_t len;
-	guint32 ui32;
-	static gchar hex[] = "0123456789abcdef";
-	static gchar HEX[] = "0123456789ABCDEF";
+	gchar		   *p, temp[sizeof ("18446744073709551615")];
+	size_t		    len;
+	guint32                         ui32;
+	static gchar   hex[] = "0123456789abcdef";
+	static gchar   HEX[] = "0123456789ABCDEF";
 
 	p = temp + sizeof(temp);
 
@@ -220,7 +220,7 @@ rspamd_printf_append_gstring (const gchar *buf, glong buflen, gpointer ud)
 glong
 rspamd_fprintf (FILE *f, const gchar *fmt, ...)
 {
-	va_list args;
+	va_list   args;
 	glong r;
 
 	va_start (args, fmt);
@@ -233,7 +233,7 @@ rspamd_fprintf (FILE *f, const gchar *fmt, ...)
 glong
 rspamd_printf (const gchar *fmt, ...)
 {
-	va_list args;
+	va_list   args;
 	glong r;
 
 	va_start (args, fmt);
@@ -246,7 +246,7 @@ rspamd_printf (const gchar *fmt, ...)
 glong
 rspamd_log_fprintf (FILE *f, const gchar *fmt, ...)
 {
-	va_list args;
+	va_list   args;
 	glong r;
 
 	va_start (args, fmt);
@@ -299,34 +299,31 @@ rspamd_printf_gstring (GString *s, const gchar *fmt, ...)
 	return r;
 }
 
-#define RSPAMD_PRINTF_APPEND(buf, len)                                          \
-	do {                                                                        \
-		wr = func ((buf), (len), apd);                                              \
-		if (wr < (__typeof (wr))(len)) {                                         \
-			goto oob;                                                               \
-		}                                                                           \
-		written += wr;                                                              \
-		fmt++;                                                                     \
-		buf_start = fmt;                                                            \
-	} while (0)
+#define RSPAMD_PRINTF_APPEND(buf, len)											\
+    do {																		\
+    wr = func ((buf), (len), apd);												\
+    if (wr < (__typeof(wr))(len)) {											\
+        goto oob;																\
+    }																			\
+    written += wr;																\
+    fmt ++;																		\
+    buf_start = fmt;															\
+    } while(0)
 
 glong
-rspamd_vprintf_common (rspamd_printf_append_func func,
-	gpointer apd,
-	const gchar *fmt,
-	va_list args)
+rspamd_vprintf_common (rspamd_printf_append_func func, gpointer apd, const gchar *fmt, va_list args)
 {
-	gchar zero, numbuf[G_ASCII_DTOSTR_BUF_SIZE], *p, *last, c;
-	const gchar *buf_start = fmt;
-	gint d;
-	long double f, scale;
-	glong written = 0, wr, slen;
-	gint64 i64;
-	guint64 ui64;
-	guint width, sign, hex, humanize, bytes, frac_width, i;
-	f_str_t *v;
-	GString *gs;
-	gboolean bv;
+	gchar               zero, numbuf[G_ASCII_DTOSTR_BUF_SIZE], *p, *last, c;
+	const gchar        *buf_start = fmt;
+	gint                d;
+	long double         f, scale;
+	glong               written = 0, wr, slen;
+	gint64              i64;
+	guint64             ui64;
+	guint               width, sign, hex, humanize, bytes, frac_width, i;
+	f_str_t			   *v;
+	GString            *gs;
+	gboolean            bv;
 
 	while (*fmt) {
 
@@ -363,7 +360,7 @@ rspamd_vprintf_common (rspamd_printf_append_func func,
 			}
 
 
-			for (;; ) {
+			for ( ;; ) {
 				switch (*fmt) {
 
 				case 'u':
@@ -390,12 +387,12 @@ rspamd_vprintf_common (rspamd_printf_append_func func,
 					humanize = 1;
 					bytes = 1;
 					sign = 0;
-					fmt++;
+					fmt ++;
 					continue;
 				case 'h':
 					humanize = 1;
 					sign = 0;
-					fmt++;
+					fmt ++;
 					continue;
 				case '.':
 					fmt++;
@@ -485,17 +482,17 @@ rspamd_vprintf_common (rspamd_printf_append_func func,
 
 			case 'l':
 				if (sign) {
-					i64 = (gint64) va_arg (args, glong);
+					i64 = (gint64) va_arg(args, glong);
 				} else {
-					ui64 = (guint64) va_arg (args, gulong);
+					ui64 = (guint64) va_arg(args, gulong);
 				}
 				break;
 
 			case 'D':
 				if (sign) {
-					i64 = (gint64) va_arg (args, gint32);
+					i64 = (gint64) va_arg(args, gint32);
 				} else {
-					ui64 = (guint64) va_arg (args, guint32);
+					ui64 = (guint64) va_arg(args, guint32);
 				}
 				break;
 
@@ -543,9 +540,9 @@ rspamd_vprintf_common (rspamd_printf_append_func func,
 					}
 
 					/*
-					 * (gint64) cast is required for msvc6:
-					 * it can not convert guint64 to double
-					 */
+					* (gint64) cast is required for msvc6:
+					* it can not convert guint64 to double
+					*/
 					ui64 = (guint64) ((f - (gint64) ui64) * scale);
 
 					p = rspamd_sprintf_num (p, last, ui64, '0', 0, frac_width);
@@ -623,7 +620,7 @@ rspamd_vprintf_common (rspamd_printf_append_func func,
 			if (sign) {
 				if (i64 < 0) {
 					*p++ = '-';
-					ui64 = (guint64) - i64;
+					ui64 = (guint64) -i64;
 
 				} else {
 					ui64 = (guint64) i64;
diff --git a/src/libutil/printf.h b/src/libutil/printf.h
index aee982e41..bd5c62cb6 100644
--- a/src/libutil/printf.h
+++ b/src/libutil/printf.h
@@ -62,20 +62,15 @@
  * @param ud opaque pointer
  * @return number of characters written
  */
-typedef glong (*rspamd_printf_append_func)(const gchar *buf, glong buflen,
-	gpointer ud);
+typedef glong (*rspamd_printf_append_func)(const gchar *buf, glong buflen, gpointer ud);
 
 glong rspamd_fprintf (FILE *f, const gchar *fmt, ...);
 glong rspamd_printf (const gchar *fmt, ...);
 glong rspamd_log_fprintf (FILE *f, const gchar *fmt, ...);
 glong rspamd_snprintf (gchar *buf, glong max, const gchar *fmt, ...);
-gchar * rspamd_vsnprintf (gchar *buf, glong max, const gchar *fmt,
-	va_list args);
+gchar *rspamd_vsnprintf (gchar *buf, glong max, const gchar *fmt, va_list args);
 glong rspamd_printf_gstring (GString *s, const gchar *fmt, ...);
 
-glong rspamd_vprintf_common (rspamd_printf_append_func func,
-	gpointer apd,
-	const gchar *fmt,
-	va_list args);
+glong rspamd_vprintf_common (rspamd_printf_append_func func, gpointer apd, const gchar *fmt, va_list args);
 
 #endif /* PRINTF_H_ */
diff --git a/src/libutil/radix.c b/src/libutil/radix.c
index c33ac0d05..7af665331 100644
--- a/src/libutil/radix.c
+++ b/src/libutil/radix.c
@@ -24,15 +24,15 @@
 
 
 #include "config.h"
-#include "mem_pool.h"
 #include "radix.h"
+#include "mem_pool.h"
 
-static void * radix_alloc (radix_tree_t * tree);
+static void                    *radix_alloc (radix_tree_t * tree);
 
-radix_tree_t *
+radix_tree_t                   *
 radix_tree_create (void)
 {
-	radix_tree_t *tree;
+	radix_tree_t                   *tree;
 
 	tree = g_malloc (sizeof (radix_tree_t));
 	if (tree == NULL) {
@@ -62,14 +62,10 @@ enum radix_insert_type {
 };
 
 static uintptr_t
-radix32tree_insert_common (radix_tree_t * tree,
-	guint32 key,
-	guint32 mask,
-	uintptr_t value,
-	enum radix_insert_type type)
+radix32tree_insert_common (radix_tree_t * tree, guint32 key, guint32 mask, uintptr_t value, enum radix_insert_type type)
 {
-	guint32 bit;
-	radix_node_t *node, *next;
+	guint32                         bit;
+	radix_node_t                   *node, *next;
 
 	bit = 0x80000000;
 
@@ -96,14 +92,14 @@ radix32tree_insert_common (radix_tree_t * tree,
 		if (node->value != RADIX_NO_VALUE) {
 			/* Value was found, switch on insert type */
 			switch (type) {
-			case RADIX_INSERT:
-				return 1;
-			case RADIX_ADD:
-				node->value += value;
-				return value;
-			case RADIX_REPLACE:
-				node->value = value;
-				return 1;
+				case RADIX_INSERT:
+					return 1;
+				case RADIX_ADD:
+					node->value += value;
+					return value;
+				case RADIX_REPLACE:
+					node->value = value;
+					return 1;
 			}
 		}
 
@@ -141,33 +137,22 @@ radix32tree_insert_common (radix_tree_t * tree,
 	return 0;
 }
 
-gint
-radix32tree_insert (radix_tree_t *tree,
-	guint32 key,
-	guint32 mask,
-	uintptr_t value)
+gint 
+radix32tree_insert (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
 {
-	return (gint)radix32tree_insert_common (tree, key, mask, value,
-			   RADIX_INSERT);
+	return (gint)radix32tree_insert_common (tree, key, mask, value, RADIX_INSERT);
 }
 
-uintptr_t
+uintptr_t 
 radix32tree_add (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
 {
 	return radix32tree_insert_common (tree, key, mask, value, RADIX_ADD);
 }
 
-gint
-radix32tree_replace (radix_tree_t *tree,
-	guint32 key,
-	guint32 mask,
-	uintptr_t value)
+gint 
+radix32tree_replace (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value)
 {
-	return (gint)radix32tree_insert_common (tree,
-			   key,
-			   mask,
-			   value,
-			   RADIX_REPLACE);
+	return (gint)radix32tree_insert_common (tree, key, mask, value, RADIX_REPLACE);
 }
 
 /*
@@ -177,17 +162,14 @@ radix32tree_replace (radix_tree_t *tree,
  * 5 words total in stack
  */
 static gboolean
-radix_recurse_nodes (radix_node_t *node,
-	radix_tree_traverse_func func,
-	void *user_data,
-	gint level)
+radix_recurse_nodes (radix_node_t *node, radix_tree_traverse_func func, void *user_data, gint level)
 {
 	if (node->left) {
 		if (radix_recurse_nodes (node->left, func, user_data, level + 1)) {
 			return TRUE;
 		}
 	}
-
+	
 	if (node->value != RADIX_NO_VALUE) {
 		if (func (node->key, level, node->value, user_data)) {
 			return TRUE;
@@ -204,19 +186,17 @@ radix_recurse_nodes (radix_node_t *node,
 }
 
 void
-radix32tree_traverse (radix_tree_t *tree,
-	radix_tree_traverse_func func,
-	void *user_data)
+radix32tree_traverse (radix_tree_t *tree, radix_tree_traverse_func func, void *user_data)
 {
-	radix_recurse_nodes (tree->root, func, user_data, 0);
+	radix_recurse_nodes (tree->root, func, user_data, 0); 
 }
 
 
 gint
 radix32tree_delete (radix_tree_t * tree, guint32 key, guint32 mask)
 {
-	guint32 bit;
-	radix_node_t *node;
+	guint32                         bit;
+	radix_node_t                   *node;
 
 	bit = 0x80000000;
 	node = tree->root;
@@ -246,7 +226,7 @@ radix32tree_delete (radix_tree_t * tree, guint32 key, guint32 mask)
 		return -1;
 	}
 
-	for (;; ) {
+	for (;;) {
 		if (node->parent->right == node) {
 			node->parent->right = NULL;
 
@@ -277,9 +257,9 @@ radix32tree_delete (radix_tree_t * tree, guint32 key, guint32 mask)
 uintptr_t
 radix32tree_find (radix_tree_t * tree, guint32 key)
 {
-	guint32 bit;
-	uintptr_t value;
-	radix_node_t *node;
+	guint32                         bit;
+	uintptr_t                       value;
+	radix_node_t                   *node;
 
 	bit = 0x80000000;
 	value = RADIX_NO_VALUE;
@@ -305,10 +285,10 @@ radix32tree_find (radix_tree_t * tree, guint32 key)
 }
 
 
-static void *
+static void                    *
 radix_alloc (radix_tree_t * tree)
 {
-	gchar *p;
+	gchar                           *p;
 
 	p = rspamd_mempool_alloc (tree->pool, sizeof (radix_node_t));
 
@@ -336,6 +316,6 @@ radix32_tree_find_addr (radix_tree_t *tree, rspamd_inet_addr_t *addr)
 	return radix32tree_find (tree, ntohl (addr->addr.s4.sin_addr.s_addr));
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libutil/radix.h b/src/libutil/radix.h
index cfdefa25b..88f345e3d 100644
--- a/src/libutil/radix.h
+++ b/src/libutil/radix.h
@@ -7,30 +7,29 @@
 
 #define RADIX_NO_VALUE   (uintptr_t)-1
 
-typedef struct radix_node_s radix_node_t;
+typedef struct radix_node_s  radix_node_t;
 
 struct radix_node_s {
-	radix_node_t *right;
-	radix_node_t *left;
-	radix_node_t *parent;
-	uintptr_t value;
+    radix_node_t *right;
+    radix_node_t *left;
+    radix_node_t *parent;
+    uintptr_t value;
 	guint32 key;
 };
 
 
 typedef struct {
-	radix_node_t *root;
-	size_t size;
+    radix_node_t  *root;
+    size_t         size;
 	rspamd_mempool_t *pool;
 } radix_tree_t;
 
-typedef gboolean (*radix_tree_traverse_func)(guint32 key, guint32 mask,
-	uintptr_t value, void *user_data);
+typedef gboolean (*radix_tree_traverse_func)(guint32 key, guint32 mask, uintptr_t value, void *user_data);
 
 /**
  * Create new radix tree
  */
-radix_tree_t * radix_tree_create (void);
+radix_tree_t *radix_tree_create (void);
 
 /**
  * Insert value to radix tree
@@ -38,10 +37,7 @@ radix_tree_t * radix_tree_create (void);
  *          0 if operation was successfull
  *          -1 if there was some error
  */
-gint radix32tree_insert (radix_tree_t *tree,
-	guint32 key,
-	guint32 mask,
-	uintptr_t value);
+gint radix32tree_insert (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value);
 
 /**
  * Add value to radix tree or insert it if value does not exists
@@ -49,10 +45,7 @@ gint radix32tree_insert (radix_tree_t *tree,
  *          0 if value was inserted
  *          -1 if there was some error
  */
-uintptr_t radix32tree_add (radix_tree_t *tree,
-	guint32 key,
-	guint32 mask,
-	uintptr_t value);
+uintptr_t radix32tree_add (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value);
 
 /**
  * Replace value in radix tree or insert it if value does not exists
@@ -60,10 +53,7 @@ uintptr_t radix32tree_add (radix_tree_t *tree,
  *          0 if value was inserted
  *          -1 if there was some error
  */
-gint radix32tree_replace (radix_tree_t *tree,
-	guint32 key,
-	guint32 mask,
-	uintptr_t value);
+gint radix32tree_replace (radix_tree_t *tree, guint32 key, guint32 mask, uintptr_t value);
 
 /**
  * Delete value from radix tree
@@ -91,9 +81,7 @@ uintptr_t radix32_tree_find_addr (radix_tree_t *tree, rspamd_inet_addr_t *addr);
 /**
  * Traverse via the whole tree calling specified callback
  */
-void radix32tree_traverse (radix_tree_t *tree,
-	radix_tree_traverse_func func,
-	void *user_data);
+void radix32tree_traverse (radix_tree_t *tree, radix_tree_traverse_func func, void *user_data);
 
 /**
  * Frees radix tree
diff --git a/src/libutil/rrd.c b/src/libutil/rrd.c
index fa9324dc4..a0e21eaed 100644
--- a/src/libutil/rrd.c
+++ b/src/libutil/rrd.c
@@ -58,7 +58,7 @@ rrd_dst_from_string (const gchar *str)
 /**
  * Convert numeric presentation of dst to string
  */
-const gchar *
+const gchar*
 rrd_dst_to_string (enum rrd_dst_type type)
 {
 	switch (type) {
@@ -105,7 +105,7 @@ rrd_cf_from_string (const gchar *str)
 /**
  * Convert numeric presentation of cf to string
  */
-const gchar *
+const gchar*
 rrd_cf_to_string (enum rrd_cf_type type)
 {
 	switch (type) {
@@ -127,10 +127,7 @@ rrd_cf_to_string (enum rrd_cf_type type)
 }
 
 void
-rrd_make_default_rra (const gchar *cf_name,
-	gulong pdp_cnt,
-	gulong rows,
-	struct rrd_rra_def *rra)
+rrd_make_default_rra (const gchar *cf_name, gulong pdp_cnt, gulong rows, struct rrd_rra_def *rra)
 {
 	rra->pdp_cnt = pdp_cnt;
 	rra->row_cnt = rows;
@@ -142,8 +139,8 @@ rrd_make_default_rra (const gchar *cf_name,
 void
 rrd_make_default_ds (const gchar *name, gulong pdp_step, struct rrd_ds_def *ds)
 {
-	rspamd_strlcpy (ds->ds_nam, name,	   sizeof (ds->ds_nam));
-	rspamd_strlcpy (ds->dst,	"COUNTER", sizeof (ds->dst));
+	rspamd_strlcpy (ds->ds_nam, name, sizeof (ds->ds_nam));
+	rspamd_strlcpy (ds->dst, "COUNTER", sizeof (ds->dst));
 	memset (ds->par, 0, sizeof (ds->par));
 	ds->par[RRD_DS_mrhb_cnt].lv = pdp_step * 2;
 	ds->par[RRD_DS_min_val].dv = NAN;
@@ -156,90 +153,74 @@ rrd_make_default_ds (const gchar *name, gulong pdp_step, struct rrd_ds_def *ds)
 static gboolean
 rspamd_rrd_check_file (const gchar *filename, gboolean need_data, GError **err)
 {
-	gint fd, i;
-	struct stat st;
-	struct rrd_file_head head;
-	struct rrd_rra_def rra;
-	gint head_size;
+	gint								 fd, i;
+	struct stat							 st;
+	struct rrd_file_head				 head;
+	struct rrd_rra_def					 rra;
+	gint								 head_size;
 
 	fd = open (filename, O_RDWR);
 	if (fd == -1) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
 		return FALSE;
 	}
 
 	if (fstat (fd, &st) == -1) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
 		close (fd);
 		return FALSE;
 	}
 	if (st.st_size < (goffset)sizeof (struct rrd_file_head)) {
 		/* We have trimmed file */
-		g_set_error (err, rrd_error_quark (), EINVAL, "rrd size is bad: %ud",
-			(guint)st.st_size);
+		g_set_error (err, rrd_error_quark (), EINVAL, "rrd size is bad: %ud", (guint)st.st_size);
 		close (fd);
 		return FALSE;
 	}
 
 	/* Try to read header */
 	if (read (fd, &head, sizeof (head)) != sizeof (head)) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd read head error: %s",
-			strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd read head error: %s", strerror (errno));
 		close (fd);
 		return FALSE;
 	}
 	/* Check magic */
 	if (memcmp (head.cookie, RRD_COOKIE, sizeof (head.cookie)) != 0 ||
-		memcmp (head.version, RRD_VERSION, sizeof (head.version)) != 0 ||
-		head.float_cookie != RRD_FLOAT_COOKIE) {
-		g_set_error (err,
-			rrd_error_quark (), EINVAL, "rrd head cookies error: %s",
-			strerror (errno));
+			memcmp (head.version, RRD_VERSION, sizeof (head.version)) != 0 ||
+			head.float_cookie != RRD_FLOAT_COOKIE) {
+		g_set_error (err, rrd_error_quark (), EINVAL, "rrd head cookies error: %s", strerror (errno));
 		close (fd);
 		return FALSE;
 	}
 	/* Check for other params */
 	if (head.ds_cnt <= 0 || head.rra_cnt <= 0) {
-		g_set_error (err,
-			rrd_error_quark (), EINVAL, "rrd head cookies error: %s",
-			strerror (errno));
+		g_set_error (err, rrd_error_quark (), EINVAL, "rrd head cookies error: %s", strerror (errno));
 		close (fd);
 		return FALSE;
 	}
 	/* Now we can calculate the overall size of rrd */
 	head_size = sizeof (struct rrd_file_head) +
-		sizeof (struct rrd_ds_def) * head.ds_cnt +
-		sizeof (struct rrd_rra_def) * head.rra_cnt +
-		sizeof (struct rrd_live_head) +
-		sizeof (struct rrd_pdp_prep) * head.ds_cnt +
-		sizeof (struct rrd_cdp_prep) * head.ds_cnt * head.rra_cnt +
-		sizeof (struct rrd_rra_ptr) * head.rra_cnt;
+			sizeof (struct rrd_ds_def) * head.ds_cnt +
+			sizeof (struct rrd_rra_def) * head.rra_cnt +
+			sizeof (struct rrd_live_head) +
+			sizeof (struct rrd_pdp_prep) * head.ds_cnt +
+			sizeof (struct rrd_cdp_prep) * head.ds_cnt * head.rra_cnt +
+			sizeof (struct rrd_rra_ptr) * head.rra_cnt;
 	if (st.st_size < (goffset)head_size) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd file seems to have stripped header: %d",
-			head_size);
+		g_set_error (err, rrd_error_quark (), errno, "rrd file seems to have stripped header: %d", head_size);
 		close (fd);
 		return FALSE;
 	}
 
 	if (need_data) {
 		/* Now check rra */
-		if (lseek (fd, sizeof (struct rrd_ds_def) * head.ds_cnt,
-			SEEK_CUR) == -1) {
-			g_set_error (err,
-				rrd_error_quark (), errno, "rrd head lseek error: %s",
-				strerror (errno));
+		if (lseek (fd, sizeof (struct rrd_ds_def) * head.ds_cnt, SEEK_CUR) == -1) {
+			g_set_error (err, rrd_error_quark (), errno, "rrd head lseek error: %s", strerror (errno));
 			close (fd);
 			return FALSE;
 		}
-		for (i = 0; i < (gint)head.rra_cnt; i++) {
+		for (i = 0; i < (gint)head.rra_cnt; i ++) {
 			if (read (fd, &rra, sizeof (rra)) != sizeof (rra)) {
-				g_set_error (err,
-					rrd_error_quark (), errno, "rrd read rra error: %s",
-					strerror (errno));
+				g_set_error (err, rrd_error_quark (), errno, "rrd read rra error: %s", strerror (errno));
 				close (fd);
 				return FALSE;
 			}
@@ -247,9 +228,7 @@ rspamd_rrd_check_file (const gchar *filename, gboolean need_data, GError **err)
 		}
 
 		if (st.st_size != head_size) {
-			g_set_error (err,
-				rrd_error_quark (), EINVAL, "rrd file seems to have incorrect size: %d, must be %d",
-				(gint)st.st_size, head_size);
+			g_set_error (err, rrd_error_quark (), EINVAL, "rrd file seems to have incorrect size: %d, must be %d", (gint)st.st_size, head_size);
 			close (fd);
 			return FALSE;
 		}
@@ -266,7 +245,7 @@ rspamd_rrd_check_file (const gchar *filename, gboolean need_data, GError **err)
 static void
 rspamd_rrd_adjust_pointers (struct rspamd_rrd_file *file, gboolean completed)
 {
-	guint8 *ptr;
+	guint8										*ptr;
 
 	ptr = file->map;
 	file->stat_head = (struct rrd_file_head *)ptr;
@@ -280,8 +259,7 @@ rspamd_rrd_adjust_pointers (struct rspamd_rrd_file *file, gboolean completed)
 	file->pdp_prep = (struct rrd_pdp_prep *)ptr;
 	ptr += sizeof (struct rrd_pdp_prep) * file->stat_head->ds_cnt;
 	file->cdp_prep = (struct rrd_cdp_prep *)ptr;
-	ptr += sizeof (struct rrd_cdp_prep) * file->stat_head->rra_cnt *
-		file->stat_head->ds_cnt;
+	ptr += sizeof (struct rrd_cdp_prep) * file->stat_head->rra_cnt * file->stat_head->ds_cnt;
 	file->rra_ptr = (struct rrd_rra_ptr *)ptr;
 	if (completed) {
 		ptr += sizeof (struct rrd_rra_ptr) * file->stat_head->rra_cnt;
@@ -299,12 +277,12 @@ rspamd_rrd_adjust_pointers (struct rspamd_rrd_file *file, gboolean completed)
  * @param err
  * @return
  */
-static struct rspamd_rrd_file *
+static struct rspamd_rrd_file*
 rspamd_rrd_open_common (const gchar *filename, gboolean completed, GError **err)
 {
-	struct rspamd_rrd_file *new;
-	gint fd;
-	struct stat st;
+	struct rspamd_rrd_file						*new;
+	gint										 fd;
+	struct stat									 st;
 
 	if (!rspamd_rrd_check_file (filename, completed, err)) {
 		return NULL;
@@ -320,25 +298,20 @@ rspamd_rrd_open_common (const gchar *filename, gboolean completed, GError **err)
 	/* Open file */
 	fd = open (filename, O_RDWR);
 	if (fd == -1) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
 		return FALSE;
 	}
 
 	if (fstat (fd, &st) == -1) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
 		close (fd);
 		return FALSE;
 	}
 	/* Mmap file */
 	new->size = st.st_size;
-	if ((new->map =
-		mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
-		0)) == MAP_FAILED) {
+	if ((new->map = mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 		close (fd);
-		g_set_error (err,
-			rrd_error_quark (), ENOMEM, "mmap failed: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), ENOMEM, "mmap failed: %s", strerror (errno));
 		g_slice_free1 (sizeof (struct rspamd_rrd_file), new);
 		return NULL;
 	}
@@ -362,7 +335,7 @@ rspamd_rrd_open_common (const gchar *filename, gboolean completed, GError **err)
  * @param err error pointer
  * @return rrd file structure
  */
-struct rspamd_rrd_file *
+struct rspamd_rrd_file*
 rspamd_rrd_open (const gchar *filename, GError **err)
 {
 	return rspamd_rrd_open_common (filename, TRUE, err);
@@ -377,31 +350,25 @@ rspamd_rrd_open (const gchar *filename, GError **err)
  * @param err error pointer
  * @return TRUE if file has been created
  */
-struct rspamd_rrd_file *
-rspamd_rrd_create (const gchar *filename,
-	gulong ds_count,
-	gulong rra_count,
-	gulong pdp_step,
-	GError **err)
+struct rspamd_rrd_file*
+rspamd_rrd_create (const gchar *filename, gulong ds_count, gulong rra_count, gulong pdp_step, GError **err)
 {
-	struct rspamd_rrd_file *new;
-	struct rrd_file_head head;
-	struct rrd_ds_def ds;
-	struct rrd_rra_def rra;
-	struct rrd_live_head lh;
-	struct rrd_pdp_prep pdp;
-	struct rrd_cdp_prep cdp;
-	struct rrd_rra_ptr rra_ptr;
-	gint fd;
-	guint i, j;
-	struct timeval tv;
+	struct rspamd_rrd_file						*new;
+	struct rrd_file_head						 head;
+	struct rrd_ds_def							 ds;
+	struct rrd_rra_def							 rra;
+	struct rrd_live_head						 lh;
+	struct rrd_pdp_prep							 pdp;
+	struct rrd_cdp_prep							 cdp;
+	struct rrd_rra_ptr							 rra_ptr;
+	gint										 fd;
+	guint										 i, j;
+	struct timeval								 tv;
 
 	/* Open file */
 	fd = open (filename, O_RDWR | O_CREAT | O_TRUNC, 0644);
 	if (fd == -1) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd create error: %s",
-			strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd create error: %s", strerror (errno));
 		return NULL;
 	}
 
@@ -410,14 +377,13 @@ rspamd_rrd_create (const gchar *filename,
 	head.rra_cnt = rra_count;
 	head.ds_cnt = ds_count;
 	head.pdp_step = pdp_step;
-	memcpy (head.cookie,  RRD_COOKIE,  sizeof (head.cookie));
+	memcpy (head.cookie, RRD_COOKIE, sizeof (head.cookie));
 	memcpy (head.version, RRD_VERSION, sizeof (head.version));
 	head.float_cookie = RRD_FLOAT_COOKIE;
 
 	if (write (fd, &head, sizeof (head)) != sizeof (head)) {
 		close (fd);
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
 		return NULL;
 	}
 
@@ -425,12 +391,10 @@ rspamd_rrd_create (const gchar *filename,
 	memset (&ds.ds_nam, 0, sizeof (ds.ds_nam));
 	memcpy (&ds.dst, "COUNTER", sizeof ("COUNTER"));
 	memset (&ds.par, 0, sizeof (ds.par));
-	for (i = 0; i < ds_count; i++) {
+	for (i = 0; i < ds_count; i ++) {
 		if (write (fd, &ds, sizeof (ds)) != sizeof (ds)) {
 			close (fd);
-			g_set_error (err,
-				rrd_error_quark (), errno, "rrd write error: %s",
-				strerror (errno));
+			g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
 			return NULL;
 		}
 	}
@@ -439,12 +403,10 @@ rspamd_rrd_create (const gchar *filename,
 	memcpy (&rra.cf_nam, "AVERAGE", sizeof ("AVERAGE"));
 	rra.pdp_cnt = 1;
 	memset (&rra.par, 0, sizeof (rra.par));
-	for (i = 0; i < rra_count; i++) {
+	for (i = 0; i < rra_count; i ++) {
 		if (write (fd, &rra, sizeof (rra)) != sizeof (rra)) {
 			close (fd);
-			g_set_error (err,
-				rrd_error_quark (), errno, "rrd write error: %s",
-				strerror (errno));
+			g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
 			return NULL;
 		}
 	}
@@ -456,8 +418,7 @@ rspamd_rrd_create (const gchar *filename,
 
 	if (write (fd, &lh, sizeof (lh)) != sizeof (lh)) {
 		close (fd);
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
 		return NULL;
 	}
 
@@ -466,12 +427,10 @@ rspamd_rrd_create (const gchar *filename,
 	memset (&pdp.scratch, 0, sizeof (pdp.scratch));
 	pdp.scratch[PDP_val].dv = 0.;
 	pdp.scratch[PDP_unkn_sec_cnt].lv = 0;
-	for (i = 0; i < ds_count; i++) {
+	for (i = 0; i < ds_count; i ++) {
 		if (write (fd, &pdp, sizeof (pdp)) != sizeof (pdp)) {
 			close (fd);
-			g_set_error (err,
-				rrd_error_quark (), errno, "rrd write error: %s",
-				strerror (errno));
+			g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
 			return NULL;
 		}
 	}
@@ -479,14 +438,12 @@ rspamd_rrd_create (const gchar *filename,
 	/* Fill cdp prep */
 	memset (&cdp.scratch, 0, sizeof (cdp.scratch));
 	cdp.scratch[CDP_val].dv = NAN;
-	for (i = 0; i < rra_count; i++) {
+	for (i = 0; i < rra_count; i ++) {
 		cdp.scratch[CDP_unkn_pdp_cnt].lv = 0;
-		for (j = 0; j < ds_count; j++) {
+		for (j = 0; j < ds_count; j ++) {
 			if (write (fd, &cdp, sizeof (cdp)) != sizeof (cdp)) {
 				close (fd);
-				g_set_error (err,
-					rrd_error_quark (), errno, "rrd write error: %s",
-					strerror (errno));
+				g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
 				return NULL;
 			}
 		}
@@ -494,12 +451,10 @@ rspamd_rrd_create (const gchar *filename,
 
 	/* Set row pointers */
 	memset (&rra_ptr, 0, sizeof (rra_ptr));
-	for (i = 0; i < rra_count; i++) {
+	for (i = 0; i < rra_count; i ++) {
 		if (write (fd, &rra_ptr, sizeof (rra_ptr)) != sizeof (rra_ptr)) {
 			close (fd);
-			g_set_error (err,
-				rrd_error_quark (), errno, "rrd write error: %s",
-				strerror (errno));
+			g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
 			return NULL;
 		}
 	}
@@ -521,10 +476,8 @@ gboolean
 rspamd_rrd_add_ds (struct rspamd_rrd_file *file, GArray *ds, GError **err)
 {
 
-	if (file == NULL || file->stat_head->ds_cnt * sizeof (struct rrd_ds_def) !=
-		ds->len) {
-		g_set_error (err,
-			rrd_error_quark (), EINVAL, "rrd add ds failed: wrong arguments");
+	if (file == NULL || file->stat_head->ds_cnt * sizeof (struct rrd_ds_def) != ds->len) {
+		g_set_error (err, rrd_error_quark (), EINVAL, "rrd add ds failed: wrong arguments");
 		return FALSE;
 	}
 
@@ -544,10 +497,8 @@ rspamd_rrd_add_ds (struct rspamd_rrd_file *file, GArray *ds, GError **err)
 gboolean
 rspamd_rrd_add_rra (struct rspamd_rrd_file *file, GArray *rra, GError **err)
 {
-	if (file == NULL || file->stat_head->rra_cnt *
-		sizeof (struct rrd_rra_def) != rra->len) {
-		g_set_error (err,
-			rrd_error_quark (), EINVAL, "rrd add rra failed: wrong arguments");
+	if (file == NULL || file->stat_head->rra_cnt * sizeof (struct rrd_rra_def) != rra->len) {
+		g_set_error (err, rrd_error_quark (), EINVAL, "rrd add rra failed: wrong arguments");
 		return FALSE;
 	}
 
@@ -566,34 +517,31 @@ rspamd_rrd_add_rra (struct rspamd_rrd_file *file, GArray *rra, GError **err)
 gboolean
 rspamd_rrd_finalize (struct rspamd_rrd_file *file, GError **err)
 {
-	gint fd;
-	guint i;
-	gint count = 0;
-	gdouble vbuf[1024];
-	struct stat st;
+	gint										 fd;
+	guint										 i;
+	gint										 count = 0;
+	gdouble										 vbuf[1024];
+	struct stat									 st;
 
 	if (file == NULL || file->filename == NULL) {
-		g_set_error (err,
-			rrd_error_quark (), EINVAL, "rrd add rra failed: wrong arguments");
+		g_set_error (err, rrd_error_quark (), EINVAL, "rrd add rra failed: wrong arguments");
 		return FALSE;
 	}
 
 	fd = open (file->filename, O_RDWR);
 	if (fd == -1) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd open error: %s", strerror (errno));
 		return FALSE;
 	}
 
 	if (lseek (fd, 0, SEEK_END) == -1) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd seek error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd seek error: %s", strerror (errno));
 		close (fd);
 		return FALSE;
 	}
 
 	/* Adjust CDP */
-	for (i = 0; i < file->stat_head->rra_cnt; i++) {
+	for (i = 0; i < file->stat_head->rra_cnt; i ++) {
 		file->cdp_prep->scratch[CDP_unkn_pdp_cnt].lv = 0;
 		/* Randomize row pointer */
 		file->rra_ptr->cur_row = g_random_int () % file->rra_def[i].row_cnt;
@@ -603,17 +551,14 @@ rspamd_rrd_finalize (struct rspamd_rrd_file *file, GError **err)
 
 	munmap (file->map, file->size);
 	/* Write values */
-	for (i = 0; i < G_N_ELEMENTS (vbuf); i++) {
+	for (i = 0; i < G_N_ELEMENTS (vbuf); i ++) {
 		vbuf[i] = NAN;
 	}
 
 	while (count > 0) {
 		/* Write values in buffered matter */
-		if (write (fd, vbuf,
-			MIN ((gint)G_N_ELEMENTS (vbuf), count) * sizeof (gdouble)) == -1) {
-			g_set_error (err,
-				rrd_error_quark (), errno, "rrd write error: %s",
-				strerror (errno));
+		if (write (fd, vbuf, MIN ((gint)G_N_ELEMENTS (vbuf), count) * sizeof (gdouble)) == -1) {
+			g_set_error (err, rrd_error_quark (), errno, "rrd write error: %s", strerror (errno));
 			close (fd);
 			return FALSE;
 		}
@@ -621,20 +566,16 @@ rspamd_rrd_finalize (struct rspamd_rrd_file *file, GError **err)
 	}
 
 	if (fstat (fd, &st) == -1) {
-		g_set_error (err,
-			rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), errno, "rrd stat error: %s", strerror (errno));
 		close (fd);
 		return FALSE;
 	}
 
 	/* Mmap again */
 	file->size = st.st_size;
-	if ((file->map =
-		mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
-		0)) == MAP_FAILED) {
+	if ((file->map = mmap (NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 		close (fd);
-		g_set_error (err,
-			rrd_error_quark (), ENOMEM, "mmap failed: %s", strerror (errno));
+		g_set_error (err, rrd_error_quark (), ENOMEM, "mmap failed: %s", strerror (errno));
 		g_slice_free1 (sizeof (struct rspamd_rrd_file), file);
 		return FALSE;
 	}
@@ -656,20 +597,16 @@ rspamd_rrd_finalize (struct rspamd_rrd_file *file, GError **err)
  * @return
  */
 static gboolean
-rspamd_rrd_update_pdp_prep (struct rspamd_rrd_file *file,
-	gdouble *vals,
-	gdouble *pdp_new,
-	gdouble interval)
+rspamd_rrd_update_pdp_prep (struct rspamd_rrd_file *file, gdouble *vals, gdouble *pdp_new, gdouble interval)
 {
-	guint i;
-	enum rrd_dst_type type;
+	guint									 i;
+	enum rrd_dst_type						 type;
 
-	for (i = 0; i < file->stat_head->ds_cnt; i++) {
+	for (i = 0; i < file->stat_head->ds_cnt; i ++) {
 		type = rrd_dst_from_string (file->ds_def[i].dst);
 
 		if (file->ds_def[i].par[RRD_DS_mrhb_cnt].lv < interval) {
-			rspamd_strlcpy (file->pdp_prep[i].last_ds, "U",
-				sizeof (file->pdp_prep[i].last_ds));
+			rspamd_strlcpy (file->pdp_prep[i].last_ds, "U", sizeof (file->pdp_prep[i].last_ds));
 		}
 
 		if (file->ds_def[i].par[RRD_DS_mrhb_cnt].lv >= interval) {
@@ -680,8 +617,7 @@ rspamd_rrd_update_pdp_prep (struct rspamd_rrd_file *file,
 					pdp_new[i] = NAN;
 				}
 				else {
-					pdp_new[i] = vals[i] - strtod (file->pdp_prep[i].last_ds,
-							NULL);
+					pdp_new[i] = vals[i] - strtod (file->pdp_prep[i].last_ds, NULL);
 				}
 				break;
 			case RRD_DST_GAUGE:
@@ -699,8 +635,7 @@ rspamd_rrd_update_pdp_prep (struct rspamd_rrd_file *file,
 		}
 		/* Copy value to the last_ds */
 		if (!isnan (vals[i])) {
-			rspamd_snprintf (file->pdp_prep[i].last_ds,
-				sizeof (file->pdp_prep[i].last_ds), "%.4f", vals[i]);
+			rspamd_snprintf (file->pdp_prep[i].last_ds, sizeof (file->pdp_prep[i].last_ds), "%.4f", vals[i]);
 		}
 		else {
 			file->pdp_prep[i].last_ds[0] = 'U';
@@ -723,20 +658,15 @@ rspamd_rrd_update_pdp_prep (struct rspamd_rrd_file *file,
  * @param pdp_diff time till last pdp update
  */
 static void
-rspamd_rrd_update_pdp_step (struct rspamd_rrd_file *file,
-	gdouble *pdp_new,
-	gdouble *pdp_temp,
-	gdouble interval,
-	gdouble pre_int,
-	gdouble post_int,
-	gulong pdp_diff)
+rspamd_rrd_update_pdp_step (struct rspamd_rrd_file *file, gdouble *pdp_new, gdouble *pdp_temp, gdouble interval,
+		gdouble pre_int, gdouble post_int, gulong pdp_diff)
 {
-	guint i;
-	rrd_value_t *scratch;
-	gulong heartbeat;
+	guint									 i;
+	rrd_value_t 							*scratch;
+	gulong									 heartbeat;
 
 
-	for (i = 0; i < file->stat_head->ds_cnt; i++) {
+	for (i = 0; i < file->stat_head->ds_cnt; i ++) {
 		scratch = file->pdp_prep[i].scratch;
 		heartbeat = file->ds_def[i].par[RRD_DS_mrhb_cnt].lv;
 		if (!isnan (pdp_new[i])) {
@@ -747,22 +677,21 @@ rspamd_rrd_update_pdp_step (struct rspamd_rrd_file *file,
 			pre_int = 0.0;
 		}
 		/* Check interval value for heartbeat for this DS */
-		if ((interval > heartbeat) ||
-			(file->stat_head->pdp_step / 2.0 < scratch[PDP_unkn_sec_cnt].lv)) {
+		if ((interval > heartbeat) || (file->stat_head->pdp_step / 2.0 < scratch[PDP_unkn_sec_cnt].lv)) {
 			pdp_temp[i] = NAN;
 		}
 		else {
 			pdp_temp[i] = scratch[PDP_val].dv /
-				((double) (pdp_diff - scratch[PDP_unkn_sec_cnt].lv) - pre_int);
+					((double) (pdp_diff - scratch[PDP_unkn_sec_cnt].lv) - pre_int);
 		}
 
-		if (isnan (pdp_new[i])) {
-			scratch[PDP_unkn_sec_cnt].lv = floor (post_int);
-			scratch[PDP_val].dv = NAN;
-		} else {
-			scratch[PDP_unkn_sec_cnt].lv = 0;
-			scratch[PDP_val].dv = pdp_new[i] / interval * post_int;
-		}
+	    if (isnan (pdp_new[i])) {
+	        scratch[PDP_unkn_sec_cnt].lv = floor (post_int);
+	        scratch[PDP_val].dv = NAN;
+	    } else {
+	        scratch[PDP_unkn_sec_cnt].lv = 0;
+	        scratch[PDP_val].dv = pdp_new[i] / interval * post_int;
+	    }
 	}
 }
 
@@ -776,28 +705,23 @@ rspamd_rrd_update_pdp_step (struct rspamd_rrd_file *file,
  * @param pdp_temp temporary pdp points
  */
 static void
-rspamd_rrd_update_cdp (struct rspamd_rrd_file *file,
-	gdouble pdp_steps,
-	gdouble pdp_offset,
-	gulong *rra_steps,
-	gulong rra_index,
-	gdouble *pdp_temp)
+rspamd_rrd_update_cdp (struct rspamd_rrd_file *file, gdouble pdp_steps, gdouble pdp_offset, gulong *rra_steps, gulong rra_index,
+		gdouble *pdp_temp)
 {
-	guint i;
-	struct rrd_rra_def *rra;
-	rrd_value_t *scratch;
-	enum rrd_cf_type cf;
-	gdouble last_cdp, cur_cdp;
-	gulong pdp_in_cdp;
+	guint									 i;
+	struct rrd_rra_def						*rra;
+	rrd_value_t								*scratch;
+	enum rrd_cf_type						 cf;
+	gdouble									 last_cdp, cur_cdp;
+	gulong									 pdp_in_cdp;
 
 	rra = &file->rra_def[rra_index];
 	cf = rrd_cf_from_string (rra->cf_nam);
 
 	/* Iterate over all DS for this RRA */
-	for (i = 0; i < file->stat_head->ds_cnt; i++) {
+	for (i = 0; i < file->stat_head->ds_cnt; i ++) {
 		/* Get CDP for this RRA and DS */
-		scratch =
-			file->cdp_prep[rra_index * file->stat_head->ds_cnt + i].scratch;
+		scratch = file->cdp_prep[rra_index * file->stat_head->ds_cnt + i].scratch;
 		if (rra->pdp_cnt > 1) {
 			/* Do we have any CDP to update for this rra ? */
 			if (rra_steps[rra_index] > 0) {
@@ -813,8 +737,7 @@ rspamd_rrd_update_cdp (struct rspamd_rrd_file *file,
 				}
 
 				/* Check XFF for this rra */
-				if (scratch[CDP_unkn_pdp_cnt].lv > rra->pdp_cnt *
-					rra->par[RRA_cdp_xff_val].lv) {
+				if (scratch[CDP_unkn_pdp_cnt].lv > rra->pdp_cnt * rra->par[RRA_cdp_xff_val].lv) {
 					/* XFF is reached */
 					scratch[CDP_primary_val].dv = NAN;
 				}
@@ -822,26 +745,17 @@ rspamd_rrd_update_cdp (struct rspamd_rrd_file *file,
 					/* Need to initialize CDP using specified consolidation */
 					switch (cf) {
 					case RRD_CF_AVERAGE:
-						last_cdp =
-							isnan (scratch[CDP_val].dv) ? 0.0 : scratch[CDP_val]
-							.dv;
+						last_cdp = isnan (scratch[CDP_val].dv) ? 0.0 : scratch[CDP_val].dv;
 						cur_cdp = isnan (pdp_temp[i]) ? 0.0 : pdp_temp[i];
-						scratch[CDP_primary_val].dv =
-							(last_cdp + cur_cdp *
-							pdp_offset) /
-							(rra->pdp_cnt - scratch[CDP_unkn_pdp_cnt].lv);
+						scratch[CDP_primary_val].dv = (last_cdp + cur_cdp * pdp_offset) / (rra->pdp_cnt - scratch[CDP_unkn_pdp_cnt].lv);
 						break;
 					case RRD_CF_MAXIMUM:
-						last_cdp =
-							isnan (scratch[CDP_val].dv) ? -INFINITY : scratch[
-							CDP_val].dv;
+						last_cdp = isnan (scratch[CDP_val].dv) ? -INFINITY : scratch[CDP_val].dv;
 						cur_cdp = isnan (pdp_temp[i]) ? -INFINITY : pdp_temp[i];
 						scratch[CDP_primary_val].dv = MAX (last_cdp, cur_cdp);
 						break;
 					case RRD_CF_MINIMUM:
-						last_cdp =
-							isnan (scratch[CDP_val].dv) ? INFINITY : scratch[
-							CDP_val].dv;
+						last_cdp = isnan (scratch[CDP_val].dv) ? INFINITY : scratch[CDP_val].dv;
 						cur_cdp = isnan (pdp_temp[i]) ? INFINITY : pdp_temp[i];
 						scratch[CDP_primary_val].dv = MIN (last_cdp, cur_cdp);
 						break;
@@ -895,8 +809,7 @@ rspamd_rrd_update_cdp (struct rspamd_rrd_file *file,
 							scratch[CDP_val].dv = pdp_temp[i] * pdp_steps;
 						}
 						else {
-							scratch[CDP_val].dv = last_cdp + pdp_temp[i] *
-								pdp_steps;
+							scratch[CDP_val].dv = last_cdp + pdp_temp[i] * pdp_steps;
 						}
 						break;
 					case RRD_CF_MAXIMUM:
@@ -935,31 +848,26 @@ rspamd_rrd_update_cdp (struct rspamd_rrd_file *file,
 void
 rspamd_rrd_write_rra (struct rspamd_rrd_file *file, gulong *rra_steps)
 {
-	guint i, j, scratch_idx, cdp_idx, k;
-	struct rrd_rra_def *rra;
-	gdouble *rra_row;
+	guint									 i, j, scratch_idx, cdp_idx, k;
+	struct rrd_rra_def						*rra;
+	gdouble									*rra_row;
 
 	/* Iterate over all RRA */
-	for (i = 0; i < file->stat_head->rra_cnt; i++) {
+	for (i = 0; i < file->stat_head->rra_cnt; i ++) {
 		rra = &file->rra_def[i];
 		/* How much steps need to be updated */
-		for (j = 0, scratch_idx = CDP_primary_val;
-			j < rra_steps[i];
-			j++, scratch_idx = CDP_secondary_val) {
+		for (j = 0, scratch_idx = CDP_primary_val; j < rra_steps[i]; j ++, scratch_idx = CDP_secondary_val) {
 			/* Move row ptr */
 			if (++file->rra_ptr[i].cur_row >= rra->row_cnt) {
 				file->rra_ptr[i].cur_row = 0;
 			}
 			/* Calculate seek */
-			rra_row = file->rrd_value +
-				(file->stat_head->ds_cnt * i + file->rra_ptr[i].cur_row);
+			rra_row = file->rrd_value + (file->stat_head->ds_cnt * i + file->rra_ptr[i].cur_row);
 			/* Iterate over DS */
-			for (k = 0; k < file->stat_head->ds_cnt; k++) {
+			for (k = 0; k < file->stat_head->ds_cnt; k ++) {
 				cdp_idx = i * file->stat_head->ds_cnt + k;
-				memcpy (rra_row,
-					&file->cdp_prep[cdp_idx].scratch[scratch_idx].dv,
-					sizeof (gdouble));
-				rra_row++;
+				memcpy (rra_row, &file->cdp_prep[cdp_idx].scratch[scratch_idx].dv, sizeof (gdouble));
+				rra_row ++;
 			}
 		}
 	}
@@ -973,28 +881,23 @@ rspamd_rrd_write_rra (struct rspamd_rrd_file *file, gulong *rra_steps)
  * @return TRUE if a row has been added
  */
 gboolean
-rspamd_rrd_add_record (struct rspamd_rrd_file * file,
-	GArray *points,
-	GError **err)
+rspamd_rrd_add_record (struct rspamd_rrd_file* file, GArray *points, GError **err)
 {
-	gdouble interval, *pdp_new, *pdp_temp, pre_int, post_int;
-	guint i;
-	gulong pdp_steps, cur_pdp_count, prev_pdp_step, cur_pdp_step,
-		prev_pdp_age, cur_pdp_age, *rra_steps, pdp_offset;
-	struct timeval tv;
-
-	if (file == NULL || file->stat_head->ds_cnt * sizeof (gdouble) !=
-		points->len) {
-		g_set_error (err,
-			rrd_error_quark (), EINVAL,
-			"rrd add points failed: wrong arguments");
+	gdouble									 interval, *pdp_new, *pdp_temp, pre_int, post_int;
+	guint									 i;
+	gulong									 pdp_steps, cur_pdp_count, prev_pdp_step, cur_pdp_step,
+											 prev_pdp_age, cur_pdp_age, *rra_steps, pdp_offset;
+	struct timeval							 tv;
+
+	if (file == NULL || file->stat_head->ds_cnt * sizeof (gdouble) != points->len) {
+		g_set_error (err, rrd_error_quark (), EINVAL, "rrd add points failed: wrong arguments");
 		return FALSE;
 	}
 
 	/* Get interval */
 	gettimeofday (&tv, NULL);
 	interval = (gdouble)(tv.tv_sec - file->live_head->last_up) +
-		(gdouble)(tv.tv_usec - file->live_head->last_up_usec) / 1e6f;
+			(gdouble)(tv.tv_usec - file->live_head->last_up_usec) / 1e6f;
 
 	/* Update PDP preparation values */
 	pdp_new = g_malloc (sizeof (gdouble) * file->stat_head->ds_cnt);
@@ -1002,11 +905,8 @@ rspamd_rrd_add_record (struct rspamd_rrd_file * file,
 	/* How much steps need to be updated in each RRA */
 	rra_steps = g_malloc0 (sizeof (gulong) * file->stat_head->rra_cnt);
 
-	if (!rspamd_rrd_update_pdp_prep (file, (gdouble *)points->data, pdp_new,
-		interval)) {
-		g_set_error (err,
-			rrd_error_quark (), EINVAL,
-			"rrd update pdp failed: wrong arguments");
+	if (!rspamd_rrd_update_pdp_prep (file, (gdouble *)points->data, pdp_new, interval)) {
+		g_set_error (err, rrd_error_quark (), EINVAL, "rrd update pdp failed: wrong arguments");
 		g_free (pdp_new);
 		g_free (pdp_temp);
 		g_free (rra_steps);
@@ -1015,7 +915,7 @@ rspamd_rrd_add_record (struct rspamd_rrd_file * file,
 
 	/* Calculate elapsed steps */
 	/* Age in seconds for previous pdp store */
-	prev_pdp_age = file->live_head->last_up % file->stat_head->pdp_step;
+	prev_pdp_age =  file->live_head->last_up % file->stat_head->pdp_step;
 	/* Time in seconds for last pdp update */
 	prev_pdp_step = file->live_head->last_up - prev_pdp_age;
 	/* Age in seconds from current time to required pdp time */
@@ -1024,10 +924,7 @@ rspamd_rrd_add_record (struct rspamd_rrd_file * file,
 	cur_pdp_step = tv.tv_sec - cur_pdp_age;
 
 	if (cur_pdp_step > prev_pdp_step) {
-		pre_int =
-			(gdouble)(cur_pdp_step -
-			file->live_head->last_up) -
-			((double)file->live_head->last_up_usec) / 1e6f;
+		pre_int = (gdouble)(cur_pdp_step - file->live_head->last_up) - ((double)file->live_head->last_up_usec) / 1e6f;
 		post_int = (gdouble)cur_pdp_age + ((double)tv.tv_usec) / 1e6f;
 	}
 	else {
@@ -1040,11 +937,10 @@ rspamd_rrd_add_record (struct rspamd_rrd_file * file,
 
 	if (pdp_steps == 0) {
 		/* Simple update of pdp prep */
-		for (i = 0; i < file->stat_head->ds_cnt; i++) {
+		for (i = 0; i < file->stat_head->ds_cnt; i ++) {
 			if (isnan (pdp_new[i])) {
 				/* Increment unknown period */
-				file->pdp_prep[i].scratch[PDP_unkn_sec_cnt].lv += floor (
-					interval);
+				file->pdp_prep[i].scratch[PDP_unkn_sec_cnt].lv += floor (interval);
 			}
 			else {
 				if (isnan (file->pdp_prep[i].scratch[PDP_val].dv)) {
@@ -1062,36 +958,23 @@ rspamd_rrd_add_record (struct rspamd_rrd_file * file,
 		/* Complex update of PDP, CDP and RRA */
 
 		/* Update PDP for this step */
-		rspamd_rrd_update_pdp_step (file,
-			pdp_new,
-			pdp_temp,
-			interval,
-			pre_int,
-			post_int,
-			pdp_steps * file->stat_head->pdp_step);
+		rspamd_rrd_update_pdp_step (file, pdp_new, pdp_temp, interval, pre_int, post_int, pdp_steps * file->stat_head->pdp_step);
 
 
 		/* Update CDP points for each RRA*/
-		for (i = 0; i < file->stat_head->rra_cnt; i++) {
+		for (i = 0; i < file->stat_head->rra_cnt; i ++) {
 			/* Calculate pdp offset for this RRA */
-			pdp_offset = file->rra_def[i].pdp_cnt - cur_pdp_count %
-				file->rra_def[i].pdp_cnt;
+			pdp_offset = file->rra_def[i].pdp_cnt - cur_pdp_count % file->rra_def[i].pdp_cnt;
 			/* How much steps we got for this RRA */
 			if (pdp_offset <= pdp_steps) {
-				rra_steps[i] =
-					(pdp_steps - pdp_offset) / file->rra_def[i].pdp_cnt + 1;
+				rra_steps[i] = (pdp_steps - pdp_offset) / file->rra_def[i].pdp_cnt + 1;
 			}
 			else {
 				/* This rra have not passed enough pdp steps */
 				rra_steps[i] = 0;
 			}
 			/* Update this specific CDP */
-			rspamd_rrd_update_cdp (file,
-				pdp_steps,
-				pdp_offset,
-				rra_steps,
-				i,
-				pdp_temp);
+			rspamd_rrd_update_cdp (file, pdp_steps, pdp_offset, rra_steps, i, pdp_temp);
 			/* Write RRA */
 			rspamd_rrd_write_rra (file, rra_steps);
 		}
@@ -1115,7 +998,7 @@ rspamd_rrd_add_record (struct rspamd_rrd_file * file,
  * @return
  */
 gint
-rspamd_rrd_close (struct rspamd_rrd_file * file)
+rspamd_rrd_close (struct rspamd_rrd_file* file)
 {
 	if (file == NULL) {
 		errno = EINVAL;
diff --git a/src/libutil/rrd.h b/src/libutil/rrd.h
index 13ed965ab..ff6902894 100644
--- a/src/libutil/rrd.h
+++ b/src/libutil/rrd.h
@@ -42,17 +42,17 @@ typedef union {
 
 struct rrd_file_head {
 	/* Data Base Identification Section ** */
-	gchar cookie[4];         /* RRD */
-	gchar version[5];        /* version of the format */
-	gdouble float_cookie;    /* is it the correct double representation ?  */
+	gchar      cookie[4];    /* RRD */
+	gchar      version[5];   /* version of the format */
+	gdouble    float_cookie; /* is it the correct double representation ?  */
 
 	/* Data Base Structure Definition **** */
 	gulong ds_cnt;   /* how many different ds provid input to the rrd */
 	gulong rra_cnt;  /* how many rras will be maintained in the rrd */
 	gulong pdp_step; /* pdp interval in seconds */
 
-	rrd_value_t par[10];    /* global parameters ... unused
-	                           at the moment */
+	rrd_value_t   par[10];  /* global parameters ... unused
+                           at the moment */
 };
 
 enum rrd_dst_type {
@@ -66,9 +66,9 @@ enum rrd_ds_param {
 	RRD_DS_mrhb_cnt = 0, /* minimum required heartbeat */
 	RRD_DS_min_val,         /* the processed input of a ds must */
 	RRD_DS_max_val,         /* be between max_val and min_val
-	                         * both can be set to UNKNOWN if you
-	                         * do not care. Data outside the limits
-	                         * set to UNKNOWN */
+	 	 	 	 	 	 * both can be set to UNKNOWN if you
+	 	 	 	 	 	 * do not care. Data outside the limits
+	 	 	 	 	 	 * set to UNKNOWN */
 	RRD_DS_cdef = RRD_DS_mrhb_cnt
 };                      /* pointer to encoded rpn expression only applies to DST_CDEF */
 
@@ -117,8 +117,8 @@ enum rrd_cf_type {
 
 enum rrd_rra_param {
 	RRA_cdp_xff_val = 0,  /* what part of the consolidated
-	                       * datapoint must be known, to produce a
-	                       * valid entry in the rra */
+ * datapoint must be known, to produce a
+ * valid entry in the rra */
 	/* CF_HWPREDICT: */
 	RRA_hw_alpha = 1,
 	/* exponential smoothing parameter for the intercept in
@@ -161,18 +161,18 @@ enum rrd_rra_param {
 	/* RRA_dependent_rra_idx = 3, */
 	RRA_window_len = 4,
 	RRA_failure_threshold = 5
-	    /* For CF_FAILURES, number of violations within the last
-	     * window required to mark a failure. */
+	/* For CF_FAILURES, number of violations within the last
+	 * window required to mark a failure. */
 };
 
 
 #define RRD_CF_NAM_SIZE   20
 
 struct rrd_rra_def {
-	gchar cf_nam[RRD_CF_NAM_SIZE];   /* consolidation function (null term) */
+	gchar  cf_nam[RRD_CF_NAM_SIZE];  /* consolidation function (null term) */
 	gulong row_cnt;  /* number of entries in the store */
 	gulong pdp_cnt;  /* how many primary data points are
-	                  * required for a consolidated data point?*/
+	 	 	 	 	  * required for a consolidated data point?*/
 	rrd_value_t par[MAX_RRA_PAR_EN];  /* index see rra_param_en */
 
 };
@@ -186,17 +186,17 @@ struct rrd_live_head {
 
 enum rrd_pdp_param {
 	PDP_unkn_sec_cnt = 0, /* how many seconds of the current
-	                       * pdp value is unknown data? */
+	 * pdp value is unknown data? */
 	PDP_val
 };                      /* current value of the pdp.
                            this depends on dst */
 
 struct rrd_pdp_prep {
 	gchar last_ds[RRD_LAST_DS_LEN]; /* the last reading from the data
-	                                 * source.  this is stored in ASCII
-	                                 * to cater for very large counters
-	                                 * we might encounter in connection
-	                                 * with SNMP. */
+	 	 	 	 	 	 	 	 	 * source.  this is stored in ASCII
+	 	 	 	 	 	 	 	 	 * to cater for very large counters
+	 	 	 	 	 	 	 	 	 * we might encounter in connection
+	 	 	 	 	 	 	 	 	 * with SNMP. */
 	rrd_value_t scratch[10];  /* contents according to pdp_par_en */
 };
 
@@ -249,9 +249,9 @@ enum rrd_cdp_param {
 };
 
 struct rrd_cdp_prep {
-	rrd_value_t scratch[RRD_MAX_CDP_PAR_EN];
-	/* contents according to cdp_par_en *
-	 * init state should be NAN */
+    rrd_value_t scratch[RRD_MAX_CDP_PAR_EN];
+    /* contents according to cdp_par_en *
+     * init state should be NAN */
 };
 
 struct rrd_rra_ptr {
@@ -270,7 +270,7 @@ struct rspamd_rrd_file {
 	gdouble *rrd_value; /* list of rrd values */
 
 	gchar *filename;
-	guint8 * map; /* mmapped area */
+	guint8* map; /* mmapped area */
 	gsize size; /* its size */
 	gboolean finalized;
 };
@@ -284,7 +284,7 @@ struct rspamd_rrd_file {
  * @param err error pointer
  * @return rrd file structure
  */
-struct rspamd_rrd_file * rspamd_rrd_open (const gchar *filename, GError **err);
+struct rspamd_rrd_file* rspamd_rrd_open (const gchar *filename, GError **err);
 
 /**
  * Create basic header for rrd file
@@ -295,11 +295,7 @@ struct rspamd_rrd_file * rspamd_rrd_open (const gchar *filename, GError **err);
  * @param err error pointer
  * @return TRUE if file has been created
  */
-struct rspamd_rrd_file * rspamd_rrd_create (const gchar *filename,
-	gulong ds_count,
-	gulong rra_count,
-	gulong pdp_step,
-	GError **err);
+struct rspamd_rrd_file* rspamd_rrd_create (const gchar *filename, gulong ds_count, gulong rra_count, gulong pdp_step, GError **err);
 
 /**
  * Add data sources to rrd file
@@ -308,9 +304,7 @@ struct rspamd_rrd_file * rspamd_rrd_create (const gchar *filename,
  * @param err error pointer
  * @return TRUE if data sources were added
  */
-gboolean rspamd_rrd_add_ds (struct rspamd_rrd_file * file,
-	GArray *ds,
-	GError **err);
+gboolean rspamd_rrd_add_ds (struct rspamd_rrd_file* file, GArray *ds, GError **err);
 
 /**
  * Add round robin archives to rrd file
@@ -319,9 +313,7 @@ gboolean rspamd_rrd_add_ds (struct rspamd_rrd_file * file,
  * @param err error pointer
  * @return TRUE if archives were added
  */
-gboolean rspamd_rrd_add_rra (struct rspamd_rrd_file *file,
-	GArray *rra,
-	GError **err);
+gboolean rspamd_rrd_add_rra (struct rspamd_rrd_file *file, GArray *rra, GError **err);
 
 /**
  * Finalize rrd file header and initialize all RRA in the file
@@ -338,16 +330,14 @@ gboolean rspamd_rrd_finalize (struct rspamd_rrd_file *file, GError **err);
  * @param err error pointer
  * @return TRUE if a row has been added
  */
-gboolean rspamd_rrd_add_record (struct rspamd_rrd_file * file,
-	GArray *points,
-	GError **err);
+gboolean rspamd_rrd_add_record (struct rspamd_rrd_file* file, GArray *points, GError **err);
 
 /**
  * Close rrd file
  * @param file
  * @return
  */
-gint rspamd_rrd_close (struct rspamd_rrd_file * file);
+gint rspamd_rrd_close (struct rspamd_rrd_file* file);
 
 /*
  * Conversion functions
@@ -360,7 +350,7 @@ enum rrd_dst_type rrd_dst_from_string (const gchar *str);
 /**
  * Convert numeric presentation of dst to string
  */
-const gchar * rrd_dst_to_string (enum rrd_dst_type type);
+const gchar* rrd_dst_to_string (enum rrd_dst_type type);
 /**
  * Convert rrd consolidation function type from string to numeric value
  */
@@ -368,22 +358,17 @@ enum rrd_cf_type rrd_cf_from_string (const gchar *str);
 /**
  * Convert numeric presentation of cf to string
  */
-const gchar * rrd_cf_to_string (enum rrd_cf_type type);
+const gchar* rrd_cf_to_string (enum rrd_cf_type type);
 
 /* Default RRA and DS */
 
 /**
  * Create default RRA
  */
-void rrd_make_default_rra (const gchar *cf_name,
-	gulong pdp_cnt,
-	gulong rows,
-	struct rrd_rra_def *rra);
+void rrd_make_default_rra (const gchar *cf_name, gulong pdp_cnt, gulong rows, struct rrd_rra_def *rra);
 
 /**
  * Create default DS
  */
-void rrd_make_default_ds (const gchar *name,
-	gulong pdp_step,
-	struct rrd_ds_def *ds);
+void rrd_make_default_ds (const gchar *name, gulong pdp_step, struct rrd_ds_def *ds);
 #endif /* RRD_H_ */
diff --git a/src/libutil/trie.c b/src/libutil/trie.c
index 8c9e0f600..394c4e939 100644
--- a/src/libutil/trie.c
+++ b/src/libutil/trie.c
@@ -25,10 +25,10 @@
 #include "mem_pool.h"
 #include "trie.h"
 
-rspamd_trie_t *
+rspamd_trie_t*
 rspamd_trie_create (gboolean icase)
 {
-	rspamd_trie_t *new;
+	rspamd_trie_t                 *new;
 
 	new = g_malloc (sizeof (rspamd_trie_t));
 
@@ -48,25 +48,20 @@ rspamd_trie_create (gboolean icase)
  * Insert a single character as the specified level of the suffix tree
  */
 static struct rspamd_trie_state *
-rspamd_trie_insert_char (rspamd_trie_t *trie,
-	guint depth,
-	struct rspamd_trie_state *pos,
-	gchar c)
+rspamd_trie_insert_char (rspamd_trie_t *trie, guint depth, struct rspamd_trie_state *pos, gchar c)
 {
-	struct rspamd_trie_match *new_match;
-	struct rspamd_trie_state *new_pos;
+	struct rspamd_trie_match     *new_match;
+	struct rspamd_trie_state     *new_pos;
 
 	/* New match is inserted before pos */
-	new_match =
-		rspamd_mempool_alloc (trie->pool, sizeof (struct rspamd_trie_match));
+	new_match = rspamd_mempool_alloc (trie->pool, sizeof (struct rspamd_trie_match));
 	new_match->next = pos->match;
 	new_match->c = c;
 
 	/* Now set match link */
 	pos->match = new_match;
 
-	new_match->state =
-		rspamd_mempool_alloc (trie->pool, sizeof (struct rspamd_trie_state));
+	new_match->state = rspamd_mempool_alloc (trie->pool, sizeof (struct rspamd_trie_state));
 	new_pos = new_match->state;
 	new_pos->match = NULL;
 	new_pos->fail = &trie->root;
@@ -91,7 +86,7 @@ rspamd_trie_insert_char (rspamd_trie_t *trie,
 static inline struct rspamd_trie_match *
 check_match (struct rspamd_trie_state *s, gchar c)
 {
-	struct rspamd_trie_match *match = s->match;
+	struct rspamd_trie_match         *match = s->match;
 
 	while (match && match->c != c) {
 		match = match->next;
@@ -103,11 +98,11 @@ check_match (struct rspamd_trie_state *s, gchar c)
 void
 rspamd_trie_insert (rspamd_trie_t *trie, const gchar *pattern, gint pattern_id)
 {
-	const guchar *p = pattern;
-	struct rspamd_trie_state *q, *q1, *r, *cur_node;
-	struct rspamd_trie_match *m, *n;
-	guint i, depth = 0;
-	gchar c;
+	const guchar               *p =  pattern;
+	struct rspamd_trie_state   *q, *q1, *r, *cur_node;
+	struct rspamd_trie_match   *m, *n;
+	guint                       i, depth = 0;
+	gchar                       c;
 
 	/* Insert pattern to the trie */
 
@@ -123,8 +118,8 @@ rspamd_trie_insert (rspamd_trie_t *trie, const gchar *pattern, gint pattern_id)
 		else {
 			cur_node = m->state;
 		}
-		p++;
-		depth++;
+		p ++;
+		depth ++;
 	}
 
 	cur_node->final = depth;
@@ -170,16 +165,13 @@ rspamd_trie_insert (rspamd_trie_t *trie, const gchar *pattern, gint pattern_id)
 	}
 }
 
-const gchar *
-rspamd_trie_lookup (rspamd_trie_t *trie,
-	const gchar *buffer,
-	gsize buflen,
-	gint *matched_id)
+const gchar*
+rspamd_trie_lookup (rspamd_trie_t *trie, const gchar *buffer, gsize buflen, gint *matched_id)
 {
-	const guchar *p = buffer, *prev, *ret;
-	struct rspamd_trie_state *cur_node;
-	struct rspamd_trie_match *m = NULL;
-	gchar c;
+	const guchar               *p = buffer, *prev, *ret;
+	struct rspamd_trie_state   *cur_node;
+	struct rspamd_trie_match   *m = NULL;
+	gchar                       c;
 
 
 	cur_node = &trie->root;
@@ -203,9 +195,9 @@ rspamd_trie_lookup (rspamd_trie_t *trie,
 			/* We have tried the pattern but eventually it was not found */
 			cur_node = &trie->root;
 			ret = p;
-			p++;
+			p ++;
 			prev = p;
-			buflen--;
+			buflen --;
 			continue;
 		}
 
@@ -221,9 +213,9 @@ rspamd_trie_lookup (rspamd_trie_t *trie,
 				return (const gchar *) ret;
 			}
 		}
-		p++;
+		p ++;
 		prev = p;
-		buflen--;
+		buflen --;
 	}
 
 	return NULL;
diff --git a/src/libutil/trie.h b/src/libutil/trie.h
index 037ffd9ee..2792ee4a5 100644
--- a/src/libutil/trie.h
+++ b/src/libutil/trie.h
@@ -58,7 +58,7 @@ typedef struct rspamd_trie_s {
 /*
  * Create a new suffix trie
  */
-rspamd_trie_t * rspamd_trie_create (gboolean icase);
+rspamd_trie_t*	rspamd_trie_create (gboolean icase);
 
 /*
  * Insert a pattern into the trie
@@ -66,9 +66,7 @@ rspamd_trie_t * rspamd_trie_create (gboolean icase);
  * @param pattern text of element
  * @param pattern_id id of element
  */
-void rspamd_trie_insert (rspamd_trie_t *trie,
-	const gchar *pattern,
-	gint pattern_id);
+void rspamd_trie_insert (rspamd_trie_t *trie, const gchar *pattern, gint pattern_id);
 
 /*
  * Search for a text using suffix trie
@@ -78,10 +76,7 @@ void rspamd_trie_insert (rspamd_trie_t *trie,
  * @param mached_id on a successfull search here would be stored id of pattern found
  * @return Position in a text where pattern was found or NULL if no patterns were found
  */
-const gchar * rspamd_trie_lookup (rspamd_trie_t *trie,
-	const gchar *buffer,
-	gsize buflen,
-	gint *matched_id);
+const gchar* rspamd_trie_lookup (rspamd_trie_t *trie, const gchar *buffer, gsize buflen, gint *matched_id);
 
 /*
  * Deallocate suffix trie
diff --git a/src/libutil/upstream.c b/src/libutil/upstream.c
index ee21a5ec3..f82d3ba50 100644
--- a/src/libutil/upstream.c
+++ b/src/libutil/upstream.c
@@ -27,7 +27,7 @@
 
 
 #ifdef _THREAD_SAFE
-pthread_rwlock_t upstream_mtx = PTHREAD_RWLOCK_INITIALIZER;
+pthread_rwlock_t                upstream_mtx = PTHREAD_RWLOCK_INITIALIZER;
 #   define U_RLOCK() do { pthread_rwlock_rdlock (&upstream_mtx); } while (0)
 #   define U_WLOCK() do { pthread_rwlock_wrlock (&upstream_mtx); } while (0)
 #   define U_UNLOCK() do { pthread_rwlock_unlock (&upstream_mtx); } while (0)
@@ -45,91 +45,49 @@ pthread_rwlock_t upstream_mtx = PTHREAD_RWLOCK_INITIALIZER;
  * Init: 0x0
  */
 
-static const guint32 crc32lookup[256] = {
-	0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U,
-	0x706af48fU,
-	0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, 0xe0d5e91eU,
-	0x97d2d988U,
-	0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, 0x90bf1d91U, 0x1db71064U,
-	0x6ab020f2U,
-	0xf3b97148U, 0x84be41deU, 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U,
-	0x83d385c7U,
-	0x136c9856U, 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU,
-	0x63066cd9U,
-	0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U,
-	0xa2677172U,
-	0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU, 0x35b5a8faU,
-	0x42b2986cU,
-	0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, 0x45df5c75U, 0xdcd60dcfU,
-	0xabd13d59U,
-	0x26d930acU, 0x51de003aU, 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U,
-	0x56b3c423U,
-	0xcfba9599U, 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U,
-	0xb10be924U,
-	0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U,
-	0x01db7106U,
-	0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU, 0x9fbfe4a5U,
-	0xe8b8d433U,
-	0x7807c9a2U, 0x0f00f934U, 0x9609a88eU, 0xe10e9818U, 0x7f6a0dbbU,
-	0x086d3d2dU,
-	0x91646c97U, 0xe6635c01U, 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U,
-	0xf262004eU,
-	0x6c0695edU, 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U,
-	0x12b7e950U,
-	0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U,
-	0xfbd44c65U,
-	0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U, 0x4adfa541U,
-	0x3dd895d7U,
-	0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU, 0x346ed9fcU, 0xad678846U,
-	0xda60b8d0U,
-	0x44042d73U, 0x33031de5U, 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU,
-	0x270241aaU,
-	0xbe0b1010U, 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U,
-	0xce61e49fU,
-	0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U,
-	0x2eb40d81U,
-	0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U, 0x03b6e20cU,
-	0x74b1d29aU,
-	0xead54739U, 0x9dd277afU, 0x04db2615U, 0x73dc1683U, 0xe3630b12U,
-	0x94643b84U,
-	0x0d6d6a3eU, 0x7a6a5aa8U, 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U,
-	0x7d079eb1U,
-	0xf00f9344U, 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU,
-	0x806567cbU,
-	0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU,
-	0x67dd4accU,
-	0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U, 0xd6d6a3e8U,
-	0xa1d1937eU,
-	0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U, 0xa6bc5767U, 0x3fb506ddU,
-	0x48b2364bU,
-	0xd80d2bdaU, 0xaf0a1b4cU, 0x36034af6U, 0x41047a60U, 0xdf60efc3U,
-	0xa867df55U,
-	0x316e8eefU, 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U,
-	0x5268e236U,
-	0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU,
-	0xb2bd0b28U,
-	0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U, 0x2cd99e8bU,
-	0x5bdeae1dU,
-	0x9b64c2b0U, 0xec63f226U, 0x756aa39cU, 0x026d930aU, 0x9c0906a9U,
-	0xeb0e363fU,
-	0x72076785U, 0x05005713U, 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU,
-	0x0cb61b38U,
-	0x92d28e9bU, 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U,
-	0xf1d4e242U,
-	0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U,
-	0x18b74777U,
-	0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU, 0x8f659effU,
-	0xf862ae69U,
-	0x616bffd3U, 0x166ccf45U, 0xa00ae278U, 0xd70dd2eeU, 0x4e048354U,
-	0x3903b3c2U,
-	0xa7672661U, 0xd06016f7U, 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU,
-	0xd9d65adcU,
-	0x40df0b66U, 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU,
-	0x30b5ffe9U,
-	0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U,
-	0xcdd70693U,
-	0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U, 0x5d681b02U,
-	0x2a6f2b94U,
+static const guint32           crc32lookup[256] = {
+	0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, 0x706af48fU,
+	0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, 0xe0d5e91eU, 0x97d2d988U,
+	0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U,
+	0xf3b97148U, 0x84be41deU, 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U,
+	0x136c9856U, 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U,
+	0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U, 0xa2677172U,
+	0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU, 0x35b5a8faU, 0x42b2986cU,
+	0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U,
+	0x26d930acU, 0x51de003aU, 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U,
+	0xcfba9599U, 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U,
+	0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U, 0x01db7106U,
+	0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU, 0x9fbfe4a5U, 0xe8b8d433U,
+	0x7807c9a2U, 0x0f00f934U, 0x9609a88eU, 0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU,
+	0x91646c97U, 0xe6635c01U, 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU,
+	0x6c0695edU, 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U,
+	0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U, 0xfbd44c65U,
+	0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U, 0x4adfa541U, 0x3dd895d7U,
+	0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU, 0x346ed9fcU, 0xad678846U, 0xda60b8d0U,
+	0x44042d73U, 0x33031de5U, 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU,
+	0xbe0b1010U, 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU,
+	0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U, 0x2eb40d81U,
+	0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U, 0x03b6e20cU, 0x74b1d29aU,
+	0xead54739U, 0x9dd277afU, 0x04db2615U, 0x73dc1683U, 0xe3630b12U, 0x94643b84U,
+	0x0d6d6a3eU, 0x7a6a5aa8U, 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U,
+	0xf00f9344U, 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU,
+	0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU, 0x67dd4accU,
+	0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U, 0xd6d6a3e8U, 0xa1d1937eU,
+	0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U, 0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU,
+	0xd80d2bdaU, 0xaf0a1b4cU, 0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U,
+	0x316e8eefU, 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U,
+	0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU, 0xb2bd0b28U,
+	0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U, 0x2cd99e8bU, 0x5bdeae1dU,
+	0x9b64c2b0U, 0xec63f226U, 0x756aa39cU, 0x026d930aU, 0x9c0906a9U, 0xeb0e363fU,
+	0x72076785U, 0x05005713U, 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U,
+	0x92d28e9bU, 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U,
+	0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U, 0x18b74777U,
+	0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU, 0x8f659effU, 0xf862ae69U,
+	0x616bffd3U, 0x166ccf45U, 0xa00ae278U, 0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U,
+	0xa7672661U, 0xd06016f7U, 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU,
+	0x40df0b66U, 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U,
+	0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U, 0xcdd70693U,
+	0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U, 0x5d681b02U, 0x2a6f2b94U,
 	0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU, 0x2d02ef8dU
 };
 
@@ -137,11 +95,7 @@ static const guint32 crc32lookup[256] = {
  * Check upstream parameters and mark it whether valid or dead
  */
 static void
-check_upstream (struct upstream *up,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors)
+check_upstream (struct upstream *up, time_t now, time_t error_timeout, time_t revive_timeout, size_t max_errors)
 {
 	if (up->dead) {
 		if (now - up->time >= revive_timeout) {
@@ -164,7 +118,7 @@ check_upstream (struct upstream *up,
 	}
 }
 
-/*
+/* 
  * Call this function after failed upstream request
  */
 void
@@ -181,7 +135,7 @@ upstream_fail (struct upstream *up, time_t now)
 	}
 }
 
-/*
+/* 
  * Call this function after successfull upstream request
  */
 void
@@ -197,15 +151,15 @@ upstream_ok (struct upstream *up, time_t now)
 	up->weight--;
 }
 
-/*
+/* 
  * Mark all upstreams as active. This function is used when all upstreams are marked as inactive
  */
 void
 revive_all_upstreams (void *ups, size_t members, size_t msize)
 {
-	guint i;
-	struct upstream *cur;
-	guchar *p;
+	guint                            i;
+	struct upstream                 *cur;
+	guchar                          *p;
 
 	U_WLOCK ();
 	p = ups;
@@ -220,22 +174,16 @@ revive_all_upstreams (void *ups, size_t members, size_t msize)
 	U_UNLOCK ();
 }
 
-/*
+/* 
  * Scan all upstreams for errors and mark upstreams dead or alive depends on conditions,
- * return number of alive upstreams
+ * return number of alive upstreams 
  */
 static gint
-rescan_upstreams (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors)
+rescan_upstreams (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout, time_t revive_timeout, size_t max_errors)
 {
-	guint i, alive;
-	struct upstream *cur;
-	guchar *p;
+	guint                           i, alive;
+	struct upstream                *cur;
+	guchar                         *p;
 
 	/* Recheck all upstreams */
 	p = ups;
@@ -259,18 +207,18 @@ rescan_upstreams (void *ups,
 }
 
 /* Return alive upstream by its number */
-static struct upstream *
+static struct upstream         *
 get_upstream_by_number (void *ups, size_t members, size_t msize, gint selected)
 {
-	guint i;
-	u_char *p, *c;
-	struct upstream *cur;
+	guint                           i;
+	u_char                         *p, *c;
+	struct upstream                *cur;
 
 	i = 0;
 	p = ups;
 	c = ups;
 	U_RLOCK ();
-	for (;; ) {
+	for (;;) {
 		/* Out of range, return NULL */
 		if (p > c + members * msize) {
 			break;
@@ -300,11 +248,11 @@ get_upstream_by_number (void *ups, size_t members, size_t msize, gint selected)
 /*
  * Get hash key for specified key (perl hash)
  */
-static guint32
+static                          guint32
 get_hash_for_key (guint32 hash, const gchar *key, size_t keylen)
 {
-	guint32 h, index;
-	const gchar *end = key + keylen;
+	guint32                         h, index;
+	const gchar                     *end = key + keylen;
 
 	h = ~hash;
 
@@ -329,24 +277,13 @@ get_hash_for_key (guint32 hash, const gchar *key, size_t keylen)
 /*
  * Recheck all upstreams and return random active upstream
  */
-struct upstream *
-get_random_upstream (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors)
+struct upstream                *
+get_random_upstream (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout,
+		time_t revive_timeout, size_t max_errors)
 {
-	gint alive, selected;
-
-	alive = rescan_upstreams (ups,
-			members,
-			msize,
-			now,
-			error_timeout,
-			revive_timeout,
-			max_errors);
+	gint                            alive, selected;
+
+	alive = rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
 	selected = rand () % alive;
 
 	return get_upstream_by_number (ups, members, msize, selected);
@@ -355,29 +292,16 @@ get_random_upstream (void *ups,
 /*
  * Return upstream by hash, that is calculated from active upstreams number
  */
-struct upstream *
-get_upstream_by_hash (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors,
-	const gchar *key,
-	size_t keylen)
+struct upstream                *
+get_upstream_by_hash (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout,
+		time_t revive_timeout, size_t max_errors, const gchar *key, size_t keylen)
 {
-	gint alive, tries = 0, r;
-	guint32 h = 0, ht;
-	gchar *p, numbuf[4];
-	struct upstream *cur;
-
-	alive = rescan_upstreams (ups,
-			members,
-			msize,
-			now,
-			error_timeout,
-			revive_timeout,
-			max_errors);
+	gint                            alive, tries = 0, r;
+	guint32                         h = 0, ht;
+	gchar                           *p, numbuf[4];
+	struct upstream                *cur;
+
+	alive = rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
 
 	if (alive == 0) {
 		return NULL;
@@ -389,7 +313,7 @@ get_upstream_by_hash (void *ups,
 #endif
 	h %= members;
 
-	for (;; ) {
+	for (;;) {
 		p = (gchar *)ups + msize * h;
 		cur = (struct upstream *)p;
 		if (!cur->dead) {
@@ -419,27 +343,16 @@ get_upstream_by_hash (void *ups,
 /*
  * Recheck all upstreams and return upstream in round-robin order according to weight and priority
  */
-struct upstream *
-get_upstream_round_robin (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors)
+struct upstream                *
+get_upstream_round_robin (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout,
+		time_t revive_timeout, size_t max_errors)
 {
-	guint max_weight, i;
-	struct upstream *cur, *selected = NULL;
-	u_char *p;
+	guint                           max_weight, i;
+	struct upstream                *cur, *selected = NULL;
+	u_char                         *p;
 
 	/* Recheck all upstreams */
-	(void)rescan_upstreams (ups,
-		members,
-		msize,
-		now,
-		error_timeout,
-		revive_timeout,
-		max_errors);
+	(void)rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
 
 	p = ups;
 	max_weight = 0;
@@ -480,27 +393,16 @@ get_upstream_round_robin (void *ups,
 /*
  * Recheck all upstreams and return upstream in round-robin order according to only priority (master-slaves)
  */
-struct upstream *
-get_upstream_master_slave (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors)
+struct upstream                *
+get_upstream_master_slave (void *ups, size_t members, size_t msize, time_t now, time_t error_timeout,
+		time_t revive_timeout, size_t max_errors)
 {
-	guint max_weight, i;
-	struct upstream *cur, *selected = NULL;
-	u_char *p;
+	guint                           max_weight, i;
+	struct upstream                *cur, *selected = NULL;
+	u_char                         *p;
 
 	/* Recheck all upstreams */
-	(void)rescan_upstreams (ups,
-		members,
-		msize,
-		now,
-		error_timeout,
-		revive_timeout,
-		max_errors);
+	(void)rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
 
 	p = ups;
 	max_weight = 0;
@@ -535,14 +437,11 @@ ketama_sort_cmp (const void *a1, const void *a2)
  * Add ketama points for specified upstream
  */
 gint
-upstream_ketama_add (struct upstream *up,
-	gchar *up_key,
-	size_t keylen,
-	size_t keypoints)
+upstream_ketama_add (struct upstream *up, gchar *up_key, size_t keylen, size_t keypoints)
 {
-	guint32 h = 0;
-	gchar tmp[4];
-	guint i;
+	guint32                         h = 0;
+	gchar                           tmp[4];
+	guint                           i;
 
 	/* Allocate ketama points array */
 	if (up->ketama_points == NULL) {
@@ -573,29 +472,16 @@ upstream_ketama_add (struct upstream *up,
 /*
  * Return upstream by hash and find nearest ketama point in some server
  */
-struct upstream *
-get_upstream_by_hash_ketama (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors,
-	const gchar *key,
-	size_t keylen)
+struct upstream                *
+get_upstream_by_hash_ketama (void *ups, size_t members, size_t msize,
+		time_t now, time_t error_timeout, time_t revive_timeout, size_t max_errors, const gchar *key, size_t keylen)
 {
-	guint alive, i;
-	guint32 h = 0, step, middle, d, min_diff = UINT_MAX;
-	gchar *p;
-	struct upstream *cur = NULL, *nearest = NULL;
-
-	alive = rescan_upstreams (ups,
-			members,
-			msize,
-			now,
-			error_timeout,
-			revive_timeout,
-			max_errors);
+	guint                           alive, i;
+	guint32                         h = 0, step, middle, d, min_diff = UINT_MAX;
+	gchar                           *p;
+	struct upstream                *cur = NULL, *nearest = NULL;
+
+	alive = rescan_upstreams (ups, members, msize, now, error_timeout, revive_timeout, max_errors);
 
 	if (alive == 0) {
 		return NULL;
@@ -634,6 +520,6 @@ get_upstream_by_hash_ketama (void *ups,
 
 #undef U_LOCK
 #undef U_UNLOCK
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libutil/upstream.h b/src/libutil/upstream.h
index 6b2224e30..da0a00013 100644
--- a/src/libutil/upstream.h
+++ b/src/libutil/upstream.h
@@ -1,20 +1,20 @@
 #ifndef UPSTREAM_H
 #define UPSTREAM_H
 
-#include <stdint.h>
 #include <sys/types.h>
+#include <stdint.h>
 
 /**
  * Structure of generic upstream
  */
 struct upstream {
-	guint errors;                       /**< Errors for this upstream   */
-	time_t time;                        /**< Time of marking            */
-	guint dead;                         /**< Dead flag					*/
-	guint priority;                     /**< Fixed priority				*/
-	gint16 weight;                      /**< Dynamic weight				*/
-	guint32 *ketama_points;             /**< Ketama points array		*/
-	size_t ketama_points_size;          /**< Ketama array size			*/
+	guint errors;						/**< Errors for this upstream 	*/
+	time_t time;						/**< Time of marking 			*/
+	guint dead;							/**< Dead flag					*/
+	guint priority;						/**< Fixed priority				*/
+	gint16 weight;						/**< Dynamic weight				*/
+	guint32 *ketama_points;				/**< Ketama points array		*/
+	size_t ketama_points_size;			/**< Ketama array size			*/
 };
 
 /**
@@ -43,10 +43,7 @@ void revive_all_upstreams (void *ups, size_t members, size_t msize);
 /**
  * Add ketama points for upstream
  */
-gint upstream_ketama_add (struct upstream *up,
-	gchar *up_key,
-	size_t keylen,
-	size_t keypoints);
+gint upstream_ketama_add (struct upstream *up, gchar *up_key, size_t keylen, size_t keypoints);
 
 /**
  * Get a random upstream from array of upstreams
@@ -58,9 +55,9 @@ gint upstream_ketama_add (struct upstream *up,
  * @param revive_timeout time during which we counts upstream dead
  * @param max_errors maximum errors during error_timeout to mark upstream dead
  */
-struct upstream * get_random_upstream (void *ups, size_t members, size_t msize,
-	time_t now, time_t error_timeout,
-	time_t revive_timeout, size_t max_errors);
+struct upstream* get_random_upstream   (void *ups, size_t members, size_t msize, 
+										time_t now, time_t error_timeout, 
+										time_t revive_timeout, size_t max_errors);
 
 /**
  * Get upstream based on hash from array of upstreams
@@ -74,10 +71,10 @@ struct upstream * get_random_upstream (void *ups, size_t members, size_t msize,
  * @param key key for hashing
  * @param keylen length of the key
  */
-struct upstream * get_upstream_by_hash (void *ups, size_t members, size_t msize,
-	time_t now,  time_t error_timeout,
-	time_t revive_timeout, size_t max_errors,
-	const gchar *key, size_t keylen);
+struct upstream* get_upstream_by_hash  (void *ups, size_t members, size_t msize, 
+										time_t now,  time_t error_timeout, 
+										time_t revive_timeout, size_t max_errors,
+										const gchar *key, size_t keylen);
 
 /**
  * Get an upstream from array of upstreams based on its current weight
@@ -89,13 +86,9 @@ struct upstream * get_upstream_by_hash (void *ups, size_t members, size_t msize,
  * @param revive_timeout time during which we counts upstream dead
  * @param max_errors maximum errors during error_timeout to mark upstream dead
  */
-struct upstream * get_upstream_round_robin (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors);
+struct upstream* get_upstream_round_robin (void *ups, size_t members, size_t msize, 
+										time_t now, time_t error_timeout, 
+										time_t revive_timeout, size_t max_errors);
 
 /**
  * Get upstream based on hash from array of upstreams, this functions is using ketama algorithm
@@ -109,15 +102,9 @@ struct upstream * get_upstream_round_robin (void *ups,
  * @param key key for hashing
  * @param keylen length of the key
  */
-struct upstream * get_upstream_by_hash_ketama (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors,
-	const gchar *key,
-	size_t keylen);
+struct upstream* get_upstream_by_hash_ketama (void *ups, size_t members, size_t msize, time_t now, 
+										time_t error_timeout, time_t revive_timeout, size_t max_errors,
+										const gchar *key, size_t keylen);
 
 /**
  * Get an upstream from array of upstreams based on its current priority (not weight)
@@ -129,16 +116,12 @@ struct upstream * get_upstream_by_hash_ketama (void *ups,
  * @param revive_timeout time during which we counts upstream dead
  * @param max_errors maximum errors during error_timeout to mark upstream dead
  */
-struct upstream * get_upstream_master_slave (void *ups,
-	size_t members,
-	size_t msize,
-	time_t now,
-	time_t error_timeout,
-	time_t revive_timeout,
-	size_t max_errors);
+struct upstream* get_upstream_master_slave (void *ups, size_t members, size_t msize,
+										time_t now, time_t error_timeout,
+										time_t revive_timeout, size_t max_errors);
 
 
 #endif /* UPSTREAM_H */
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/libutil/util.c b/src/libutil/util.c
index 8a644bfc2..8d1a6353d 100644
--- a/src/libutil/util.c
+++ b/src/libutil/util.c
@@ -23,17 +23,17 @@
  */
 
 
-#include "cfg_file.h"
 #include "config.h"
-#include "filter.h"
+#include "util.h"
+#include "cfg_file.h"
 #include "main.h"
-#include "message.h"
 #include "statfile.h"
-#include "util.h"
+#include "filter.h"
+#include "message.h"
 
 #ifdef HAVE_OPENSSL
-#include <openssl/err.h>
 #include <openssl/rand.h>
+#include <openssl/err.h>
 #endif
 
 #ifdef HAVE_TERMIOS_H
@@ -53,7 +53,7 @@
 gint
 make_socket_nonblocking (gint fd)
 {
-	gint ofl;
+	gint                            ofl;
 
 	ofl = fcntl (fd, F_GETFL, 0);
 
@@ -67,7 +67,7 @@ make_socket_nonblocking (gint fd)
 gint
 make_socket_blocking (gint fd)
 {
-	gint ofl;
+	gint                            ofl;
 
 	ofl = fcntl (fd, F_GETFL, 0);
 
@@ -81,8 +81,8 @@ make_socket_blocking (gint fd)
 gint
 poll_sync_socket (gint fd, gint timeout, short events)
 {
-	gint r;
-	struct pollfd fds[1];
+	gint                            r;
+	struct pollfd                   fds[1];
 
 	fds->fd = fd;
 	fds->events = events;
@@ -98,10 +98,10 @@ poll_sync_socket (gint fd, gint timeout, short events)
 
 static gint
 make_inet_socket (gint type, struct addrinfo *addr, gboolean is_server,
-	gboolean async, GList **list)
+		gboolean async, GList **list)
 {
-	gint fd, r, optlen, on = 1, s_error;
-	struct addrinfo *cur;
+	gint                            fd, r, optlen, on = 1, s_error;
+	struct addrinfo               *cur;
 
 	cur = addr;
 	while (cur) {
@@ -123,18 +123,10 @@ make_inet_socket (gint type, struct addrinfo *addr, gboolean is_server,
 		}
 
 		if (is_server) {
-			setsockopt (fd,
-				SOL_SOCKET,
-				SO_REUSEADDR,
-				(const void *)&on,
-				sizeof (gint));
+			setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on, sizeof (gint));
 #ifdef HAVE_IPV6_V6ONLY
 			if (cur->ai_family == AF_INET6) {
-				setsockopt (fd,
-					IPPROTO_IPV6,
-					IPV6_V6ONLY,
-					(const void *)&on,
-					sizeof (gint));
+				setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, (const void *)&on, sizeof (gint));
 			}
 #endif
 			r = bind (fd, cur->ai_addr, cur->ai_addrlen);
@@ -145,14 +137,12 @@ make_inet_socket (gint type, struct addrinfo *addr, gboolean is_server,
 
 		if (r == -1) {
 			if (errno != EINPROGRESS) {
-				msg_warn ("bind/connect failed: %d, '%s'", errno,
-					strerror (errno));
+				msg_warn ("bind/connect failed: %d, '%s'", errno, strerror (errno));
 				goto out;
 			}
 			if (!async) {
 				/* Try to poll */
-				if (poll_sync_socket (fd, CONNECT_TIMEOUT * 1000,
-					POLLOUT) <= 0) {
+				if (poll_sync_socket (fd, CONNECT_TIMEOUT * 1000, POLLOUT) <= 0) {
 					errno = ETIMEDOUT;
 					msg_warn ("bind/connect failed: timeout");
 					goto out;
@@ -206,14 +196,10 @@ make_udp_socket (struct addrinfo *addr, gboolean is_server, gboolean async)
 }
 
 gint
-make_unix_socket (const gchar *path,
-	struct sockaddr_un *addr,
-	gint type,
-	gboolean is_server,
-	gboolean async)
+make_unix_socket (const gchar *path, struct sockaddr_un *addr, gint type, gboolean is_server, gboolean async)
 {
-	gint fd = -1, s_error, r, optlen, serrno, on = 1;
-	struct stat st;
+	gint                            fd = -1, s_error, r, optlen, serrno, on = 1;
+	struct stat                     st;
 
 	if (path == NULL)
 		return -1;
@@ -230,10 +216,7 @@ make_unix_socket (const gchar *path,
 		if (lstat (addr->sun_path, &st) != -1) {
 			if (S_ISSOCK (st.st_mode)) {
 				if (unlink (addr->sun_path) == -1) {
-					msg_warn ("unlink %s failed: %d, '%s'",
-						addr->sun_path,
-						errno,
-						strerror (errno));
+					msg_warn ("unlink %s failed: %d, '%s'", addr->sun_path, errno, strerror (errno));
 					goto out;
 				}
 			}
@@ -246,10 +229,7 @@ make_unix_socket (const gchar *path,
 	fd = socket (PF_LOCAL, type, 0);
 
 	if (fd == -1) {
-		msg_warn ("socket failed %s: %d, '%s'",
-			addr->sun_path,
-			errno,
-			strerror (errno));
+		msg_warn ("socket failed %s: %d, '%s'", addr->sun_path, errno, strerror (errno));
 		return -1;
 	}
 
@@ -259,13 +239,11 @@ make_unix_socket (const gchar *path,
 
 	/* Set close on exec */
 	if (fcntl (fd, F_SETFD, FD_CLOEXEC) == -1) {
-		msg_warn ("fcntl failed %s: %d, '%s'", addr->sun_path, errno,
-			strerror (errno));
+		msg_warn ("fcntl failed %s: %d, '%s'", addr->sun_path, errno, strerror (errno));
 		goto out;
 	}
 	if (is_server) {
-		setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on,
-			sizeof (gint));
+		setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on, sizeof (gint));
 		r = bind (fd, (struct sockaddr *)addr, SUN_LEN (addr));
 	}
 	else {
@@ -274,10 +252,7 @@ make_unix_socket (const gchar *path,
 
 	if (r == -1) {
 		if (errno != EINPROGRESS) {
-			msg_warn ("bind/connect failed %s: %d, '%s'",
-				addr->sun_path,
-				errno,
-				strerror (errno));
+			msg_warn ("bind/connect failed %s: %d, '%s'", addr->sun_path, errno, strerror (errno));
 			goto out;
 		}
 		if (!async) {
@@ -308,7 +283,7 @@ make_unix_socket (const gchar *path,
 
 	return (fd);
 
-out:
+  out:
 	serrno = errno;
 	if (fd != -1) {
 		close (fd);
@@ -327,13 +302,13 @@ out:
  */
 gint
 make_universal_socket (const gchar *credits, guint16 port,
-	gint type, gboolean async, gboolean is_server, gboolean try_resolve)
+		gint type, gboolean async, gboolean is_server, gboolean try_resolve)
 {
-	struct sockaddr_un un;
-	struct stat st;
-	struct addrinfo hints, *res;
-	gint r;
-	gchar portbuf[8];
+	struct sockaddr_un              un;
+	struct stat                     st;
+	struct addrinfo                 hints, *res;
+	gint                             r;
+	gchar                            portbuf[8];
 
 	if (*credits == '/') {
 		if (is_server) {
@@ -353,11 +328,7 @@ make_universal_socket (const gchar *credits, guint16 port,
 					return -1;
 				}
 				else {
-					return make_unix_socket (credits,
-							   &un,
-							   type,
-							   is_server,
-							   async);
+					return make_unix_socket (credits, &un, type, is_server, async);
 				}
 			}
 		}
@@ -384,9 +355,7 @@ make_universal_socket (const gchar *credits, guint16 port,
 			return r;
 		}
 		else {
-			msg_err ("address resolution for %s failed: %s",
-				credits,
-				gai_strerror (r));
+			msg_err ("address resolution for %s failed: %s", credits, gai_strerror (r));
 			return FALSE;
 		}
 	}
@@ -400,16 +369,16 @@ make_universal_socket (const gchar *credits, guint16 port,
  * @param is_server make this socket as server socket
  * @param try_resolve try name resolution for a socket (BLOCKING)
  */
-GList *
+GList*
 make_universal_sockets_list (const gchar *credits, guint16 port,
-	gint type, gboolean async, gboolean is_server, gboolean try_resolve)
+		gint type, gboolean async, gboolean is_server, gboolean try_resolve)
 {
-	struct sockaddr_un un;
-	struct stat st;
-	struct addrinfo hints, *res;
-	gint r, fd, serrno;
-	gchar portbuf[8], **strv, **cur;
-	GList *result = NULL, *rcur;
+	struct sockaddr_un              un;
+	struct stat                     st;
+	struct addrinfo                 hints, *res;
+	gint                             r, fd, serrno;
+	gchar                            portbuf[8], **strv, **cur;
+	GList                           *result = NULL, *rcur;
 
 	strv = g_strsplit_set (credits, ",", -1);
 	if (strv == NULL) {
@@ -436,11 +405,7 @@ make_universal_sockets_list (const gchar *credits, guint16 port,
 						goto err;
 					}
 					else {
-						fd = make_unix_socket (credits,
-								&un,
-								type,
-								is_server,
-								async);
+						fd = make_unix_socket (credits, &un, type, is_server, async);
 					}
 				}
 			}
@@ -475,13 +440,11 @@ make_universal_sockets_list (const gchar *credits, guint16 port,
 				}
 			}
 			else {
-				msg_err ("address resolution for %s failed: %s",
-					credits,
-					gai_strerror (r));
+				msg_err ("address resolution for %s failed: %s", credits, gai_strerror (r));
 				goto err;
 			}
 		}
-		cur++;
+		cur ++;
 	}
 
 	g_strfreev (strv);
@@ -509,13 +472,12 @@ err:
 gint
 make_socketpair (gint pair[2])
 {
-	gint r;
+	gint                            r;
 
 	r = socketpair (AF_LOCAL, SOCK_STREAM, 0, pair);
 
 	if (r == -1) {
-		msg_warn ("socketpair failed: %d, '%s'", errno, strerror (
-				errno), pair[0], pair[1]);
+		msg_warn ("socketpair failed: %d, '%s'", errno, strerror (errno), pair[0], pair[1]);
 		return -1;
 	}
 	/* Set close on exec */
@@ -539,7 +501,7 @@ out:
 gint
 write_pid (struct rspamd_main *main)
 {
-	pid_t pid;
+	pid_t                           pid;
 
 	if (main->cfg->pid_file == NULL) {
 		return -1;
@@ -557,8 +519,7 @@ write_pid (struct rspamd_main *main)
 #else
 		if (fchown (main->pfh->pf_fd, 0, 0) == -1) {
 #endif
-			msg_err ("cannot chown of pidfile %s to 0:0 user",
-				main->cfg->pid_file);
+			msg_err ("cannot chown of pidfile %s to 0:0 user", main->cfg->pid_file);
 		}
 	}
 
@@ -569,15 +530,13 @@ write_pid (struct rspamd_main *main)
 
 #ifdef HAVE_SA_SIGINFO
 void
-init_signals (struct sigaction *signals, void (*sig_handler)(gint,
-	siginfo_t *,
-	void *))
+init_signals (struct sigaction *signals, void (*sig_handler)(gint, siginfo_t *, void *))
 #else
 void
 init_signals (struct sigaction *signals, void (*sig_handler)(gint))
 #endif
 {
-	struct sigaction sigpipe_act;
+	struct sigaction                sigpipe_act;
 	/* Setting up signal handlers */
 	/* SIGUSR1 - reopen config file */
 	/* SIGUSR2 - worker is ready for accept */
@@ -600,8 +559,8 @@ init_signals (struct sigaction *signals, void (*sig_handler)(gint))
 	signals->sa_flags = 0;
 #endif
 	sigaction (SIGTERM, signals, NULL);
-	sigaction (SIGINT,	signals, NULL);
-	sigaction (SIGHUP,	signals, NULL);
+	sigaction (SIGINT, signals, NULL);
+	sigaction (SIGHUP, signals, NULL);
 	sigaction (SIGCHLD, signals, NULL);
 	sigaction (SIGUSR1, signals, NULL);
 	sigaction (SIGUSR2, signals, NULL);
@@ -618,8 +577,8 @@ init_signals (struct sigaction *signals, void (*sig_handler)(gint))
 static void
 pass_signal_cb (gpointer key, gpointer value, gpointer ud)
 {
-	struct rspamd_worker *cur = value;
-	gint signo = GPOINTER_TO_INT (ud);
+	struct rspamd_worker           *cur = value;
+    gint                            signo = GPOINTER_TO_INT (ud);
 
 	kill (cur->pid, signo);
 }
@@ -627,7 +586,7 @@ pass_signal_cb (gpointer key, gpointer value, gpointer ud)
 void
 pass_signal_worker (GHashTable * workers, gint signo)
 {
-	g_hash_table_foreach (workers, pass_signal_cb, GINT_TO_POINTER (signo));
+    g_hash_table_foreach (workers, pass_signal_cb, GINT_TO_POINTER (signo));
 }
 
 void
@@ -641,9 +600,9 @@ convert_to_lowercase (gchar *str, guint size)
 
 #ifndef HAVE_SETPROCTITLE
 
-static gchar *title_buffer = 0;
-static size_t title_buffer_size = 0;
-static gchar *title_progname, *title_progname_full;
+static gchar                    *title_buffer = 0;
+static size_t                   title_buffer_size = 0;
+static gchar                    *title_progname, *title_progname_full;
 
 gint
 setproctitle (const gchar *fmt, ...)
@@ -655,33 +614,24 @@ setproctitle (const gchar *fmt, ...)
 
 	memset (title_buffer, '\0', title_buffer_size);
 
-	ssize_t written;
+	ssize_t                         written;
 
 	if (fmt) {
-		ssize_t written2;
-		va_list ap;
+		ssize_t                         written2;
+		va_list                         ap;
 
-		written = snprintf (title_buffer,
-				title_buffer_size,
-				"%s: ",
-				title_progname);
+		written = snprintf (title_buffer, title_buffer_size, "%s: ", title_progname);
 		if (written < 0 || (size_t) written >= title_buffer_size)
 			return -1;
 
 		va_start (ap, fmt);
-		written2 = vsnprintf (title_buffer + written,
-				title_buffer_size - written,
-				fmt,
-				ap);
+		written2 = vsnprintf (title_buffer + written, title_buffer_size - written, fmt, ap);
 		va_end (ap);
 		if (written2 < 0 || (size_t) written2 >= title_buffer_size - written)
 			return -1;
 	}
 	else {
-		written = snprintf (title_buffer,
-				title_buffer_size,
-				"%s",
-				title_progname);
+		written = snprintf (title_buffer, title_buffer_size, "%s", title_progname);
 		if (written < 0 || (size_t) written >= title_buffer_size)
 			return -1;
 	}
@@ -693,9 +643,9 @@ setproctitle (const gchar *fmt, ...)
 }
 
 /*
-   It has to be _init function, because __attribute__((constructor))
-   functions gets called without arguments.
- */
+  It has to be _init function, because __attribute__((constructor))
+  functions gets called without arguments.
+*/
 
 gint
 init_title (gint argc, gchar *argv[], gchar *envp[])
@@ -704,8 +654,8 @@ init_title (gint argc, gchar *argv[], gchar *envp[])
 	/* XXX: try to handle these OSes too */
 	return 0;
 #else
-	gchar *begin_of_buffer = 0, *end_of_buffer = 0;
-	gint i;
+	gchar                           *begin_of_buffer = 0, *end_of_buffer = 0;
+	gint                            i;
 
 	for (i = 0; i < argc; ++i) {
 		if (!begin_of_buffer)
@@ -724,7 +674,7 @@ init_title (gint argc, gchar *argv[], gchar *envp[])
 	if (!end_of_buffer)
 		return 0;
 
-	gchar **new_environ = g_malloc ((i + 1) * sizeof (envp[0]));
+	gchar                           **new_environ = g_malloc ((i + 1) * sizeof (envp[0]));
 
 	if (!new_environ)
 		return 0;
@@ -741,7 +691,7 @@ init_title (gint argc, gchar *argv[], gchar *envp[])
 		if (!title_progname_full)
 			goto cleanup_enomem;
 
-		gchar *p = strrchr (title_progname_full, '/');
+		gchar                           *p = strrchr (title_progname_full, '/');
 
 		if (p)
 			title_progname = p + 1;
@@ -758,7 +708,7 @@ init_title (gint argc, gchar *argv[], gchar *envp[])
 
 	return 0;
 
-cleanup_enomem:
+  cleanup_enomem:
 	for (--i; i >= 0; --i) {
 		g_free (new_environ[i]);
 	}
@@ -769,13 +719,13 @@ cleanup_enomem:
 #endif
 
 #ifndef HAVE_PIDFILE
-extern gchar *__progname;
-static gint _rspamd_pidfile_remove (rspamd_pidfh_t *pfh, gint freeit);
+extern gchar                    *__progname;
+static gint                      _rspamd_pidfile_remove (rspamd_pidfh_t *pfh, gint freeit);
 
 static gint
 rspamd_pidfile_verify (rspamd_pidfh_t *pfh)
 {
-	struct stat sb;
+	struct stat                     sb;
 
 	if (pfh == NULL || pfh->pf_fd == -1)
 		return (-1);
@@ -792,15 +742,15 @@ rspamd_pidfile_verify (rspamd_pidfh_t *pfh)
 static gint
 rspamd_pidfile_read (const gchar *path, pid_t * pidptr)
 {
-	gchar buf[16], *endptr;
-	gint error, fd, i;
+	gchar                           buf[16], *endptr;
+	gint                            error, fd, i;
 
 	fd = open (path, O_RDONLY);
 	if (fd == -1)
 		return (errno);
 
 	i = read (fd, buf, sizeof (buf) - 1);
-	error = errno;              /* Remember errno in case close() wants to change it. */
+	error = errno;				/* Remember errno in case close() wants to change it. */
 	close (fd);
 	if (i == -1)
 		return error;
@@ -815,23 +765,20 @@ rspamd_pidfile_read (const gchar *path, pid_t * pidptr)
 	return 0;
 }
 
-rspamd_pidfh_t *
+rspamd_pidfh_t                   *
 rspamd_pidfile_open (const gchar *path, mode_t mode, pid_t * pidptr)
 {
-	rspamd_pidfh_t *pfh;
-	struct stat sb;
-	gint error, fd, len, count;
-	struct timespec rqtp;
+	rspamd_pidfh_t                 *pfh;
+	struct stat                     sb;
+	gint                            error, fd, len, count;
+	struct timespec                 rqtp;
 
 	pfh = g_malloc (sizeof (*pfh));
 	if (pfh == NULL)
 		return NULL;
 
 	if (path == NULL)
-		len = snprintf (pfh->pf_path,
-				sizeof (pfh->pf_path),
-				"/var/run/%s.pid",
-				g_get_prgname ());
+		len = snprintf (pfh->pf_path, sizeof (pfh->pf_path), "/var/run/%s.pid", g_get_prgname ());
 	else
 		len = snprintf (pfh->pf_path, sizeof (pfh->pf_path), "%s", path);
 	if (len >= (gint)sizeof (pfh->pf_path)) {
@@ -853,7 +800,7 @@ rspamd_pidfile_open (const gchar *path, mode_t mode, pid_t * pidptr)
 		rqtp.tv_sec = 0;
 		rqtp.tv_nsec = 5000000;
 		if (errno == EWOULDBLOCK && pidptr != NULL) {
-again:
+		  again:
 			errno = rspamd_pidfile_read (pfh->pf_path, pidptr);
 			if (errno == 0)
 				errno = EEXIST;
@@ -890,8 +837,8 @@ again:
 gint
 rspamd_pidfile_write (rspamd_pidfh_t *pfh)
 {
-	gchar pidstr[16];
-	gint error, fd;
+	gchar                           pidstr[16];
+	gint                            error, fd;
 
 	/*
 	 * Check remembered descriptor, so we don't overwrite some other
@@ -930,7 +877,7 @@ rspamd_pidfile_write (rspamd_pidfh_t *pfh)
 gint
 rspamd_pidfile_close (rspamd_pidfh_t *pfh)
 {
-	gint error;
+	gint                            error;
 
 	error = rspamd_pidfile_verify (pfh);
 	if (error != 0) {
@@ -951,7 +898,7 @@ rspamd_pidfile_close (rspamd_pidfh_t *pfh)
 static gint
 _rspamd_pidfile_remove (rspamd_pidfh_t *pfh, gint freeit)
 {
-	gint error;
+	gint                            error;
 
 	error = rspamd_pidfile_verify (pfh);
 	if (error != 0) {
@@ -989,15 +936,12 @@ rspamd_pidfile_remove (rspamd_pidfh_t *pfh)
 #endif
 
 /* Replace %r with rcpt value and %f with from value, new string is allocated in pool */
-gchar *
-resolve_stat_filename (rspamd_mempool_t * pool,
-	gchar *pattern,
-	gchar *rcpt,
-	gchar *from)
+gchar                           *
+resolve_stat_filename (rspamd_mempool_t * pool, gchar *pattern, gchar *rcpt, gchar *from)
 {
-	gint need_to_format = 0, len = 0;
-	gint rcptlen, fromlen;
-	gchar *c = pattern, *new, *s;
+	gint                            need_to_format = 0, len = 0;
+	gint                            rcptlen, fromlen;
+	gchar                           *c = pattern, *new, *s;
 
 	if (rcpt) {
 		rcptlen = strlen (rcpt);
@@ -1063,43 +1007,39 @@ resolve_stat_filename (rspamd_mempool_t * pool,
 }
 
 #ifdef HAVE_CLOCK_GETTIME
-const gchar *
-calculate_check_time (struct timeval *tv,
-	struct timespec *begin,
-	gint resolution,
-	guint32 *scan_time)
+const gchar                     *
+calculate_check_time (struct timeval *tv, struct timespec *begin, gint resolution, guint32 *scan_time)
 #else
-const gchar *
-calculate_check_time (struct timeval *begin, gint resolution,
-	guint32 *scan_time)
+const gchar                     *
+calculate_check_time (struct timeval *begin, gint resolution, guint32 *scan_time)
 #endif
 {
-	double vdiff, diff;
-	static gchar res[64];
-	static gchar fmt[sizeof ("%.10f ms real, %.10f ms virtual")];
-	struct timeval tv_now;
+	double                          vdiff, diff;
+	static gchar                     res[64];
+	static gchar                     fmt[sizeof ("%.10f ms real, %.10f ms virtual")];
+	struct timeval                  tv_now;
 
 	if (gettimeofday (&tv_now, NULL) == -1) {
 		msg_warn ("gettimeofday failed: %s", strerror (errno));
 	}
 #ifdef HAVE_CLOCK_GETTIME
-	struct timespec ts;
+	struct timespec                 ts;
 
-	diff = (tv_now.tv_sec - tv->tv_sec) * 1000. +   /* Seconds */
-		(tv_now.tv_usec - tv->tv_usec) / 1000.; /* Microseconds */
+	diff = (tv_now.tv_sec - tv->tv_sec) * 1000. +	/* Seconds */
+		(tv_now.tv_usec - tv->tv_usec) / 1000.;	/* Microseconds */
 #ifdef HAVE_CLOCK_PROCESS_CPUTIME_ID
 	clock_gettime (CLOCK_PROCESS_CPUTIME_ID, &ts);
 #elif defined(HAVE_CLOCK_VIRTUAL)
-	clock_gettime (CLOCK_VIRTUAL,			 &ts);
+	clock_gettime (CLOCK_VIRTUAL, &ts);
 #else
-	clock_gettime (CLOCK_REALTIME,			 &ts);
+	clock_gettime (CLOCK_REALTIME, &ts);
 #endif
 
-	vdiff = (ts.tv_sec - begin->tv_sec) * 1000. +   /* Seconds */
-		(ts.tv_nsec - begin->tv_nsec) / 1000000.;   /* Nanoseconds */
+	vdiff = (ts.tv_sec - begin->tv_sec) * 1000. +	/* Seconds */
+		(ts.tv_nsec - begin->tv_nsec) / 1000000.;	/* Nanoseconds */
 #else
-	diff = (tv_now.tv_sec - begin->tv_sec) * 1000. +    /* Seconds */
-		(tv_now.tv_usec - begin->tv_usec) / 1000.;  /* Microseconds */
+	diff = (tv_now.tv_sec - begin->tv_sec) * 1000. +	/* Seconds */
+		(tv_now.tv_usec - begin->tv_usec) / 1000.;	/* Microseconds */
 
 	vdiff = diff;
 #endif
@@ -1131,9 +1071,9 @@ rspamd_strcase_equal (gconstpointer v, gconstpointer v2)
 guint
 rspamd_strcase_hash (gconstpointer key)
 {
-	const gchar *p = key;
-	gchar buf[256];
-	guint h = 0, i = 0;
+	const gchar                     *p = key;
+	gchar							 buf[256];
+	guint                            h = 0, i = 0;
 
 
 	while (*p != '\0') {
@@ -1156,7 +1096,7 @@ rspamd_strcase_hash (gconstpointer key)
 guint
 rspamd_str_hash (gconstpointer key)
 {
-	gsize len;
+	gsize							len;
 
 	len = strlen ((const gchar *)key);
 
@@ -1173,8 +1113,7 @@ gboolean
 fstr_strcase_equal (gconstpointer v, gconstpointer v2)
 {
 	const f_str_t *f1 = v, *f2 = v2;
-	if (f1->len == f2->len &&
-		g_ascii_strncasecmp (f1->begin, f2->begin, f1->len) == 0) {
+	if (f1->len == f2->len && g_ascii_strncasecmp (f1->begin, f2->begin, f1->len) == 0) {
 		return TRUE;
 	}
 
@@ -1185,11 +1124,11 @@ fstr_strcase_equal (gconstpointer v, gconstpointer v2)
 guint
 fstr_strcase_hash (gconstpointer key)
 {
-	const f_str_t *f = key;
-	const gchar *p;
-	guint h = 0, i = 0;
-	gchar buf[256];
-
+	const f_str_t                   *f = key;
+	const gchar                     *p;
+	guint                            h = 0, i = 0;
+	gchar							 buf[256];
+	
 	p = f->begin;
 	while (p - f->begin < (gint)f->len) {
 		buf[i] = g_ascii_tolower (*p);
@@ -1212,7 +1151,7 @@ void
 gperf_profiler_init (struct rspamd_config *cfg, const gchar *descr)
 {
 #if defined(WITH_GPERF_TOOLS)
-	gchar prof_path[PATH_MAX];
+	gchar                           prof_path[PATH_MAX];
 
 	if (getenv ("CPUPROFILE")) {
 
@@ -1221,16 +1160,10 @@ gperf_profiler_init (struct rspamd_config *cfg, const gchar *descr)
 	}
 	/* Try to create temp directory for gmon.out and chdir to it */
 	if (cfg->profile_path == NULL) {
-		cfg->profile_path =
-			g_strdup_printf ("%s/rspamd-profile", cfg->temp_dir);
+		cfg->profile_path = g_strdup_printf ("%s/rspamd-profile", cfg->temp_dir);
 	}
 
-	snprintf (prof_path,
-		sizeof (prof_path),
-		"%s-%s.%d",
-		cfg->profile_path,
-		descr,
-		(gint)getpid ());
+	snprintf (prof_path, sizeof (prof_path), "%s-%s.%d", cfg->profile_path, descr, (gint)getpid ());
 	if (ProfilerStart (prof_path)) {
 		/* start ITIMER_PROF timer */
 		ProfilerRegisterThread ();
@@ -1244,94 +1177,94 @@ gperf_profiler_init (struct rspamd_config *cfg, const gchar *descr)
 
 #ifdef HAVE_FLOCK
 /* Flock version */
-gboolean
+gboolean 
 lock_file (gint fd, gboolean async)
 {
-	gint flags;
+    gint                            flags;
 
-	if (async) {
-		flags = LOCK_EX | LOCK_NB;
-	}
-	else {
-		flags = LOCK_EX;
-	}
+    if (async) {
+        flags = LOCK_EX | LOCK_NB;
+    }
+    else {
+        flags = LOCK_EX;
+    }
 
-	if (flock (fd, flags) == -1) {
-		if (async && errno == EAGAIN) {
-			return FALSE;
-		}
-		msg_warn ("lock on file failed: %s", strerror (errno));
-		return FALSE;
-	}
+    if (flock (fd, flags) == -1) {
+        if (async && errno == EAGAIN) {
+            return FALSE;
+        }
+        msg_warn ("lock on file failed: %s", strerror (errno));
+        return FALSE;
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
-gboolean
+gboolean 
 unlock_file (gint fd, gboolean async)
 {
-	gint flags;
+    gint                            flags;
 
-	if (async) {
-		flags = LOCK_UN | LOCK_NB;
-	}
-	else {
-		flags = LOCK_UN;
-	}
+    if (async) {
+        flags = LOCK_UN | LOCK_NB;
+    }
+    else {
+        flags = LOCK_UN;
+    }
 
-	if (flock (fd, flags) == -1) {
-		if (async && errno == EAGAIN) {
-			return FALSE;
-		}
-		msg_warn ("lock on file failed: %s", strerror (errno));
-		return FALSE;
-	}
+    if (flock (fd, flags) == -1) {
+        if (async && errno == EAGAIN) {
+            return FALSE;
+        }
+        msg_warn ("lock on file failed: %s", strerror (errno));
+        return FALSE;
+    }
 
-	return TRUE;
+    return TRUE;
 
 }
 #else /* HAVE_FLOCK */
 /* Fctnl version */
-gboolean
+gboolean 
 lock_file (gint fd, gboolean async)
 {
-	struct flock fl = {
-		.l_type = F_WRLCK,
-		.l_whence = SEEK_SET,
-		.l_start = 0,
-		.l_len = 0
-	};
+    struct flock fl = {
+        .l_type = F_WRLCK,
+        .l_whence = SEEK_SET,
+        .l_start = 0,
+        .l_len = 0
+    };
 
-	if (fcntl (fd, async ? F_SETLK : F_SETLKW, &fl) == -1) {
-		if (async && (errno == EAGAIN || errno == EACCES)) {
-			return FALSE;
-		}
-		msg_warn ("lock on file failed: %s", strerror (errno));
-		return FALSE;
-	}
+    if (fcntl (fd, async ? F_SETLK : F_SETLKW, &fl) == -1) {
+        if (async && (errno == EAGAIN || errno == EACCES)) {
+            return FALSE;
+        }
+        msg_warn ("lock on file failed: %s", strerror (errno));
+        return FALSE;
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
-gboolean
+gboolean 
 unlock_file (gint fd, gboolean async)
 {
-	struct flock fl = {
-		.l_type = F_UNLCK,
-		.l_whence = SEEK_SET,
-		.l_start = 0,
-		.l_len = 0
-	};
+    struct flock fl = {
+        .l_type = F_UNLCK,
+        .l_whence = SEEK_SET,
+        .l_start = 0,
+        .l_len = 0
+    };
 
-	if (fcntl (fd, async ? F_SETLK : F_SETLKW, &fl) == -1) {
-		if (async && (errno == EAGAIN || errno == EACCES)) {
-			return FALSE;
-		}
-		msg_warn ("lock on file failed: %s", strerror (errno));
-		return FALSE;
-	}
+    if (fcntl (fd, async ? F_SETLK : F_SETLKW, &fl) == -1) {
+        if (async && (errno == EAGAIN || errno == EACCES)) {
+            return FALSE;
+        }
+        msg_warn ("lock on file failed: %s", strerror (errno));
+        return FALSE;
+    }
 
-	return TRUE;
+    return TRUE;
 
 }
 #endif /* HAVE_FLOCK */
@@ -1406,14 +1339,14 @@ rspamd_strlcpy_tolower (gchar *dst, const gchar *src, gsize siz)
 gint
 compare_email_func (gconstpointer a, gconstpointer b)
 {
-	const struct uri *u1 = a, *u2 = b;
-	gint r;
+	const struct uri               *u1 = a, *u2 = b;
+	gint                            r;
 
 	if (u1->hostlen != u2->hostlen || u1->hostlen == 0) {
 		return u1->hostlen - u2->hostlen;
 	}
 	else {
-		if ((r = g_ascii_strncasecmp (u1->host, u2->host, u1->hostlen)) == 0) {
+		if ((r = g_ascii_strncasecmp (u1->host, u2->host, u1->hostlen)) == 0){
 			if (u1->userlen != u2->userlen || u1->userlen == 0) {
 				return u1->userlen - u2->userlen;
 			}
@@ -1432,8 +1365,8 @@ compare_email_func (gconstpointer a, gconstpointer b)
 gint
 compare_url_func (gconstpointer a, gconstpointer b)
 {
-	const struct uri *u1 = a, *u2 = b;
-	int r;
+	const struct uri               *u1 = a, *u2 = b;
+	int                             r;
 
 	if (u1->hostlen != u2->hostlen || u1->hostlen == 0) {
 		return u1->hostlen - u2->hostlen;
@@ -1455,15 +1388,15 @@ compare_url_func (gconstpointer a, gconstpointer b)
 gchar *
 rspamd_strncasestr (const gchar *s, const gchar *find, gint len)
 {
-	gchar c, sc;
-	gsize mlen;
+	gchar                           c, sc;
+	gsize                           mlen;
 
 	if ((c = *find++) != 0) {
 		c = g_ascii_tolower (c);
 		mlen = strlen (find);
 		do {
 			do {
-				if ((sc = *s++) == 0 || len-- == 0)
+				if ((sc = *s++) == 0 || len -- == 0)
 					return (NULL);
 			} while (g_ascii_tolower (sc) != c);
 		} while (g_ascii_strncasecmp (s, find, mlen) != 0);
@@ -1478,16 +1411,16 @@ rspamd_strncasestr (const gchar *s, const gchar *find, gint len)
 gboolean
 rspamd_strtol (const gchar *s, gsize len, glong *value)
 {
-	const gchar *p = s, *end = s + len;
-	gchar c;
-	glong v = 0;
-	const glong cutoff = G_MAXLONG / 10, cutlim = G_MAXLONG % 10;
-	gboolean neg;
+	const gchar                    *p = s, *end = s + len;
+	gchar							c;
+	glong							v = 0;
+	const glong						cutoff = G_MAXLONG / 10, cutlim = G_MAXLONG % 10;
+	gboolean                        neg;
 
 	/* Case negative values */
 	if (*p == '-') {
 		neg = TRUE;
-		p++;
+		p ++;
 	}
 	else {
 		neg = FALSE;
@@ -1511,7 +1444,7 @@ rspamd_strtol (const gchar *s, gsize len, glong *value)
 		else {
 			return FALSE;
 		}
-		p++;
+		p ++;
 	}
 
 	*value = neg ? -(v) : v;
@@ -1524,10 +1457,10 @@ rspamd_strtol (const gchar *s, gsize len, glong *value)
 gboolean
 rspamd_strtoul (const gchar *s, gsize len, gulong *value)
 {
-	const gchar *p = s, *end = s + len;
-	gchar c;
-	gulong v = 0;
-	const gulong cutoff = G_MAXULONG / 10, cutlim = G_MAXULONG % 10;
+	const gchar                    *p = s, *end = s + len;
+	gchar							c;
+	gulong							v = 0;
+	const gulong					cutoff = G_MAXULONG / 10, cutlim = G_MAXULONG % 10;
 
 	/* Some preparations for range errors */
 	while (p < end) {
@@ -1547,7 +1480,7 @@ rspamd_strtoul (const gchar *s, gsize len, gulong *value)
 		else {
 			return FALSE;
 		}
-		p++;
+		p ++;
 	}
 
 	*value = v;
@@ -1572,10 +1505,10 @@ rspamd_fallocate (gint fd, off_t offset, off_t len)
  * Create new mutex
  * @return mutex or NULL
  */
-inline rspamd_mutex_t *
+inline rspamd_mutex_t*
 rspamd_mutex_new (void)
 {
-	rspamd_mutex_t *new;
+	rspamd_mutex_t					*new;
 
 	new = g_slice_alloc (sizeof (rspamd_mutex_t));
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION > 30))
@@ -1628,10 +1561,10 @@ rspamd_mutex_free (rspamd_mutex_t *mtx)
  * Create new rwlock
  * @return
  */
-rspamd_rwlock_t *
+rspamd_rwlock_t*
 rspamd_rwlock_new (void)
 {
-	rspamd_rwlock_t *new;
+	rspamd_rwlock_t					*new;
 
 	new = g_malloc (sizeof (rspamd_rwlock_t));
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION > 30))
@@ -1718,8 +1651,8 @@ struct rspamd_thread_data {
 static gpointer
 rspamd_thread_func (gpointer ud)
 {
-	struct rspamd_thread_data *td = ud;
-	sigset_t s_mask;
+	struct rspamd_thread_data		*td = ud;
+	sigset_t						 s_mask;
 
 	/* Ignore signals in thread */
 	sigemptyset (&s_mask);
@@ -1749,16 +1682,13 @@ rspamd_thread_func (gpointer ud)
  * @param err error pointer
  * @return new thread object that can be joined
  */
-GThread *
-rspamd_create_thread (const gchar *name,
-	GThreadFunc func,
-	gpointer data,
-	GError **err)
+GThread*
+rspamd_create_thread (const gchar *name, GThreadFunc func, gpointer data, GError **err)
 {
-	GThread *new;
-	struct rspamd_thread_data *td;
-	static gint32 id;
-	guint r;
+	GThread							*new;
+	struct rspamd_thread_data		*td;
+	static gint32					 id;
+	guint							 r;
 
 	r = strlen (name);
 	td = g_malloc (sizeof (struct rspamd_thread_data));
@@ -1782,15 +1712,15 @@ murmur32_hash (const guint8 *in, gsize len)
 {
 
 
-	const guint32 c1 = 0xcc9e2d51;
-	const guint32 c2 = 0x1b873593;
+	const guint32 			 c1 = 0xcc9e2d51;
+	const guint32 			 c2 = 0x1b873593;
 
-	const int nblocks = len / 4;
-	const guint32 *blocks = (const guint32 *)(in);
-	const guint8 *tail;
-	guint32 h = 0;
-	gint i;
-	guint32 k;
+	const int				 nblocks = len / 4;
+	const guint32 			*blocks = (const guint32 *)(in);
+	const guint8 			*tail;
+	guint32 				 h = 0;
+	gint 					 i;
+	guint32 				 k;
 
 	if (in == NULL || len == 0) {
 		return 0;
@@ -1838,15 +1768,15 @@ murmur32_hash (const guint8 *in, gsize len)
 void
 murmur128_hash (const guint8 *in, gsize len, guint64 out[])
 {
-	const guint64 c1 = 0x87c37b91114253d5ULL;
-	const guint64 c2 = 0x4cf5ad432745937fULL;
-	const gint nblocks = len / 16;
-	const guint64 *blocks = (const guint64 *)(in);
-	const guint8 *tail;
-	guint64 h1 = 0;
-	guint64 h2 = 0;
-	int i;
-	guint64 k1, k2;
+	const guint64 			 c1 = 0x87c37b91114253d5ULL;
+	const guint64 			 c2 = 0x4cf5ad432745937fULL;
+	const gint 				 nblocks = len / 16;
+	const guint64 			*blocks = (const guint64 *)(in);
+	const guint8 			*tail;
+	guint64 				 h1 = 0;
+	guint64 				 h2 = 0;
+	int 					 i;
+	guint64 				 k1, k2;
 
 	if (in == NULL || len == 0 || out == NULL) {
 		return;
@@ -1855,26 +1785,26 @@ murmur128_hash (const guint8 *in, gsize len, guint64 out[])
 	tail = (const guint8 *)(in + (nblocks * 16));
 
 	for (i = 0; i < nblocks; i++) {
-		k1 = blocks[i * 2 + 0];
-		k2 = blocks[i * 2 + 1];
+		k1 = blocks[i*2+0];
+		k2 = blocks[i*2+1];
 
 		k1 *= c1;
-		k1 = (k1 << 31) | (k1 >> (64 - 31));
+		k1  = (k1 << 31) | (k1 >> (64 - 31));
 		k1 *= c2;
 		h1 ^= k1;
 
 		h1 = (h1 << 27) | (h1 >> (64 - 27));
 		h1 += h2;
-		h1 = h1 * 5 + 0x52dce729;
+		h1 = h1*5+0x52dce729;
 
 		k2 *= c2;
-		k2 = (k2 << 33) | (k2 >> (64 - 33));
+		k2  = (k2 << 33) | (k2 >> (64 - 33));
 		k2 *= c1;
 		h2 ^= k2;
 
 		h2 = (h2 << 31) | (h2 >> (64 - 31));
 		h2 += h1;
-		h2 = h2 * 5 + 0x38495ab5;
+		h2 = h2*5+0x38495ab5;
 	}
 
 	k1 = k2 = 0;
@@ -1894,7 +1824,7 @@ murmur128_hash (const guint8 *in, gsize len, guint64 out[])
 	case  9:
 		k2 ^= (guint64)(tail[ 8]) << 0;
 		k2 *= c2;
-		k2 = (k2 << 33) | (k2 >> (64 - 33));
+		k2  = (k2 << 33) | (k2 >> (64 - 33));
 		k2 *= c1;
 		h2 ^= k2;
 
@@ -1915,7 +1845,7 @@ murmur128_hash (const guint8 *in, gsize len, guint64 out[])
 	case  1:
 		k1 ^= (guint64)(tail[ 0]) << 0;
 		k1 *= c1;
-		k1 = (k1 << 31) | (k1 >> (64 - 31));
+		k1  = (k1 << 31) | (k1 >> (64 - 31));
 		k1 *= c2;
 		h1 ^= k1;
 	};
@@ -1958,13 +1888,11 @@ struct hash_copy_callback_data {
 static void
 copy_foreach_callback (gpointer key, gpointer value, gpointer ud)
 {
-	struct hash_copy_callback_data *cb = ud;
-	gpointer nkey, nvalue;
+	struct hash_copy_callback_data		*cb = ud;
+	gpointer							 nkey, nvalue;
 
 	nkey = cb->key_copy_func ? cb->key_copy_func (key, cb->ud) : (gpointer)key;
-	nvalue =
-		cb->value_copy_func ? cb->value_copy_func (value,
-			cb->ud) : (gpointer)value;
+	nvalue = cb->value_copy_func ? cb->value_copy_func (value, cb->ud) : (gpointer)value;
 	g_hash_table_insert (cb->dst, nkey, nvalue);
 }
 /**
@@ -1975,13 +1903,12 @@ copy_foreach_callback (gpointer key, gpointer value, gpointer ud)
  * @param value_copy_func function called to copy or modify values (or NULL)
  * @param ud user data for copy functions
  */
-void
-rspamd_hash_table_copy (GHashTable *src, GHashTable *dst,
-	gpointer (*key_copy_func)(gconstpointer data, gpointer ud),
-	gpointer (*value_copy_func)(gconstpointer data, gpointer ud),
-	gpointer ud)
+void rspamd_hash_table_copy (GHashTable *src, GHashTable *dst,
+		gpointer (*key_copy_func)(gconstpointer data, gpointer ud),
+		gpointer (*value_copy_func)(gconstpointer data, gpointer ud),
+		gpointer ud)
 {
-	struct hash_copy_callback_data cb;
+	struct hash_copy_callback_data		 cb;
 	if (src != NULL && dst != NULL) {
 		cb.key_copy_func = key_copy_func;
 		cb.value_copy_func = value_copy_func;
@@ -2000,7 +1927,7 @@ rspamd_hash_table_copy (GHashTable *src, GHashTable *dst,
 gpointer
 rspamd_str_pool_copy (gconstpointer data, gpointer ud)
 {
-	rspamd_mempool_t *pool = ud;
+	rspamd_mempool_t						*pool = ud;
 
 	return data ? rspamd_mempool_strdup (pool, data) : NULL;
 }
@@ -2014,8 +1941,7 @@ parse_ipmask_v4 (const char *line, struct in_addr *ina, int *mask)
 	bzero (ip_buf, sizeof (ip_buf));
 
 	if ((pos = strchr (line, '/')) != NULL) {
-		rspamd_strlcpy (ip_buf, line,
-			MIN ((gsize)(pos - line), sizeof (ip_buf)));
+		rspamd_strlcpy (ip_buf, line, MIN ((gsize)(pos - line), sizeof (ip_buf)));
 		rspamd_strlcpy (mask_buf, pos + 1, sizeof (mask_buf));
 	}
 	else {
@@ -2045,8 +1971,7 @@ parse_ipmask_v4 (const char *line, struct in_addr *ina, int *mask)
 static volatile sig_atomic_t saved_signo[NSIG];
 
 static
-void
-read_pass_tmp_sig_handler (int s)
+void read_pass_tmp_sig_handler (int s)
 {
 
 	saved_signo[s] = 1;
@@ -2063,8 +1988,7 @@ rspamd_read_passphrase (gchar *buf, gint size, gint rwflag, gpointer key)
 	gint len = 0;
 	gchar pass[BUFSIZ];
 
-	if (readpassphrase ("Enter passphrase: ", buf, size, RPP_ECHO_OFF |
-		RPP_REQUIRE_TTY) == NULL) {
+	if (readpassphrase ("Enter passphrase: ", buf, size, RPP_ECHO_OFF | RPP_REQUIRE_TTY) == NULL) {
 		return 0;
 	}
 
@@ -2090,17 +2014,16 @@ restart:
 		errno = ENOTTY;
 		return 0;
 	}
-	memcpy (&term, &oterm, sizeof(term));
+	memcpy(&term, &oterm, sizeof(term));
 	term.c_lflag &= ~(ECHO | ECHONL);
-	(void)tcsetattr (input, TCSAFLUSH, &term);
-	(void)write (output, "Enter passphrase: ", sizeof ("Enter passphrase: ") -
-		1);
+	(void)tcsetattr(input, TCSAFLUSH, &term);
+	(void)write (output, "Enter passphrase: ", sizeof ("Enter passphrase: ") - 1);
 
 	/* Save the current sighandler */
 	for (i = 0; i < NSIG; i++) {
 		saved_signo[i] = 0;
 	}
-	sigemptyset (&sa.sa_mask);
+	sigemptyset(&sa.sa_mask);
 	sa.sa_flags = 0;
 	sa.sa_handler = read_pass_tmp_sig_handler;
 	(void)sigaction (SIGALRM, &sa, &savealrm);
@@ -2127,7 +2050,7 @@ restart:
 	/* Restore terminal state */
 	if (memcmp (&term, &oterm, sizeof (term)) != 0) {
 		while (tcsetattr (input, TCSAFLUSH, &oterm) == -1 &&
-			errno == EINTR && !saved_signo[SIGTTOU]) ;
+				errno == EINTR && !saved_signo[SIGTTOU]);
 	}
 
 	/* Restore signal handlers */
@@ -2146,7 +2069,7 @@ restart:
 	/* Send signals pending */
 	for (i = 0; i < NSIG; i++) {
 		if (saved_signo[i]) {
-			kill (getpid (), i);
+			kill(getpid(), i);
 			switch (i) {
 			case SIGTSTP:
 			case SIGTTIN:
@@ -2169,16 +2092,15 @@ rspamd_ip_is_valid (rspamd_inet_addr_t *addr)
 	gboolean ret = FALSE;
 
 	if (G_LIKELY (addr->af == AF_INET)) {
-		if (memcmp (&addr->addr.s4.sin_addr, &ip4_any,
-			sizeof (struct in_addr)) != 0 &&
-			memcmp (&addr->addr.s4.sin_addr, &ip4_none,
-			sizeof (struct in_addr)) != 0) {
+		if (memcmp (&addr->addr.s4.sin_addr, &ip4_any, sizeof (struct in_addr)) != 0 &&
+				memcmp (&addr->addr.s4.sin_addr, &ip4_none,
+						sizeof (struct in_addr)) != 0) {
 			ret = TRUE;
 		}
 	}
 	else if (G_UNLIKELY (addr->af == AF_INET6)) {
 		if (memcmp (&addr->addr.s6.sin6_addr, &ip6_any,
-			sizeof (struct in6_addr)) != 0) {
+				sizeof (struct in6_addr)) != 0) {
 			ret = TRUE;
 		}
 	}
@@ -2251,9 +2173,7 @@ rspamd_gstring_append_double (double val, void *ud)
 }
 
 void
-rspamd_ucl_emit_gstring (ucl_object_t *obj,
-	enum ucl_emitter emit_type,
-	GString *target)
+rspamd_ucl_emit_gstring (ucl_object_t *obj, enum ucl_emitter emit_type, GString *target)
 {
 	struct ucl_emitter_functions func = {
 		.ucl_emitter_append_character = rspamd_gstring_append_character,
@@ -2294,7 +2214,7 @@ rspamd_accept_from_socket (gint sock, rspamd_inet_addr_t *addr)
 
 	return (nfd);
 
-out:
+  out:
 	serrno = errno;
 	close (nfd);
 	errno = serrno;
@@ -2323,7 +2243,7 @@ rspamd_parse_inet_address (rspamd_inet_addr_t *target, const char *src)
 	return ret;
 }
 
-const char *
+const char*
 rspamd_inet_address_to_string (rspamd_inet_addr_t *addr)
 {
 	static char addr_str[INET6_ADDRSTRLEN + 1];
@@ -2331,10 +2251,10 @@ rspamd_inet_address_to_string (rspamd_inet_addr_t *addr)
 	switch (addr->af) {
 	case AF_INET:
 		return inet_ntop (addr->af, &addr->addr.s4.sin_addr, addr_str,
-				   sizeof (addr_str));
+				sizeof (addr_str));
 	case AF_INET6:
 		return inet_ntop (addr->af, &addr->addr.s6.sin6_addr, addr_str,
-				   sizeof (addr_str));
+				sizeof (addr_str));
 	case AF_UNIX:
 		return addr->addr.su.sun_path;
 	}
diff --git a/src/libutil/util.h b/src/libutil/util.h
index 0b506967d..a142f15fb 100644
--- a/src/libutil/util.h
+++ b/src/libutil/util.h
@@ -2,10 +2,10 @@
 #define RSPAMD_UTIL_H
 
 #include "config.h"
-#include "fstring.h"
 #include "mem_pool.h"
-#include "printf.h"
 #include "statfile.h"
+#include "printf.h"
+#include "fstring.h"
 #include "ucl.h"
 
 struct rspamd_config;
@@ -44,11 +44,7 @@ gint make_udp_socket (struct addrinfo *, gboolean is_server, gboolean async);
 /*
  * Create and bind or connect unix socket
  */
-gint make_unix_socket (const gchar *,
-	struct sockaddr_un *,
-	gint type,
-	gboolean is_server,
-	gboolean async);
+gint make_unix_socket (const gchar *, struct sockaddr_un *, gint type, gboolean is_server, gboolean async);
 
 /**
  * Make a universal socket
@@ -60,7 +56,7 @@ gint make_unix_socket (const gchar *,
  * @param try_resolve try name resolution for a socket (BLOCKING)
  */
 gint make_universal_socket (const gchar *credits, guint16 port, gint type,
-	gboolean async, gboolean is_server, gboolean try_resolve);
+		gboolean async, gboolean is_server, gboolean try_resolve);
 
 /**
  * Make a universal sockets
@@ -71,12 +67,8 @@ gint make_universal_socket (const gchar *credits, guint16 port, gint type,
  * @param is_server make this socket as server socket
  * @param try_resolve try name resolution for a socket (BLOCKING)
  */
-GList * make_universal_sockets_list (const gchar *credits,
-	guint16 port,
-	gint type,
-	gboolean async,
-	gboolean is_server,
-	gboolean try_resolve);
+GList* make_universal_sockets_list (const gchar *credits, guint16 port, gint type,
+		gboolean async, gboolean is_server, gboolean try_resolve);
 /*
  * Create socketpair
  */
@@ -105,9 +97,7 @@ gint poll_sync_socket (gint fd, gint timeout, short events);
  * Init signals
  */
 #ifdef HAVE_SA_SIGINFO
-void init_signals (struct sigaction *sa, void (*sig_handler)(gint,
-	siginfo_t *,
-	void *));
+void init_signals (struct sigaction *sa, void (*sig_handler)(gint, siginfo_t *, void *));
 #else
 void init_signals (struct sigaction *sa, void (*sig_handler)(gint));
 #endif
@@ -125,8 +115,8 @@ void convert_to_lowercase (gchar *str, guint size);
 /*
  * Process title utility functions
  */
-gint init_title (gint argc, gchar *argv[], gchar *envp[]);
-gint setproctitle (const gchar *fmt, ...);
+gint init_title(gint argc, gchar *argv[], gchar *envp[]);
+gint setproctitle(const gchar *fmt, ...);
 #endif
 
 #ifndef HAVE_PIDFILE
@@ -136,21 +126,19 @@ gint setproctitle (const gchar *fmt, ...);
 typedef struct rspamd_pidfh_s {
 	gint pf_fd;
 #ifdef HAVE_PATH_MAX
-	gchar pf_path[PATH_MAX + 1];
+	gchar    pf_path[PATH_MAX + 1];
 #elif defined(HAVE_MAXPATHLEN)
-	gchar pf_path[MAXPATHLEN + 1];
+	gchar    pf_path[MAXPATHLEN + 1];
 #else
-	gchar pf_path[1024 + 1];
+	gchar    pf_path[1024 + 1];
 #endif
-	dev_t pf_dev;
-	ino_t pf_ino;
+ 	dev_t pf_dev;
+ 	ino_t   pf_ino;
 } rspamd_pidfh_t;
-rspamd_pidfh_t * rspamd_pidfile_open (const gchar *path,
-	mode_t mode,
-	pid_t *pidptr);
-gint rspamd_pidfile_write (rspamd_pidfh_t *pfh);
-gint rspamd_pidfile_close (rspamd_pidfh_t *pfh);
-gint rspamd_pidfile_remove (rspamd_pidfh_t *pfh);
+rspamd_pidfh_t *rspamd_pidfile_open(const gchar *path, mode_t mode, pid_t *pidptr);
+gint rspamd_pidfile_write(rspamd_pidfh_t *pfh);
+gint rspamd_pidfile_close(rspamd_pidfh_t *pfh);
+gint rspamd_pidfile_remove(rspamd_pidfh_t *pfh);
 #else
 typedef struct pidfh rspamd_pidfh_t;
 #define rspamd_pidfile_open pidfile_open
@@ -162,22 +150,14 @@ typedef struct pidfh rspamd_pidfh_t;
 /*
  * Replace %r with rcpt value and %f with from value, new string is allocated in pool
  */
-gchar * resolve_stat_filename (rspamd_mempool_t *pool,
-	gchar *pattern,
-	gchar *rcpt,
-	gchar *from);
+gchar* resolve_stat_filename (rspamd_mempool_t *pool, gchar *pattern, gchar *rcpt, gchar *from);
 #ifdef HAVE_CLOCK_GETTIME
 /*
  * Calculate check time with specified resolution of timer
  */
-const gchar * calculate_check_time (struct timeval *tv,
-	struct timespec *begin,
-	gint resolution,
-	guint32 *scan_ms);
+const gchar* calculate_check_time (struct timeval *tv, struct timespec *begin, gint resolution, guint32 *scan_ms);
 #else
-const gchar * calculate_check_time (struct timeval *begin,
-	gint resolution,
-	guint32 *scan_ms);
+const gchar* calculate_check_time (struct timeval *begin, gint resolution, guint32 *scan_ms);
 #endif
 
 /*
@@ -245,12 +225,8 @@ gsize rspamd_strlcpy_tolower (gchar *dst, const gchar *src, gsize siz);
 /*
  * Convert milliseconds to timeval fields
  */
-#define msec_to_tv(msec, tv) do { (tv)->tv_sec = (msec) / 1000; (tv)->tv_usec = \
-									  ((msec) - (tv)->tv_sec * 1000) * 1000; \
-} while (0)
-#define double_to_tv(dbl, tv) do { (tv)->tv_sec = (int)(dbl); (tv)->tv_usec = \
-									   ((dbl) - (int)(dbl)) * 1000 * 1000; \
-} while (0)
+#define msec_to_tv(msec, tv) do { (tv)->tv_sec = (msec) / 1000; (tv)->tv_usec = ((msec) - (tv)->tv_sec * 1000) * 1000; } while(0)
+#define double_to_tv(dbl, tv) do { (tv)->tv_sec = (int)(dbl); (tv)->tv_usec = ((dbl) - (int)(dbl))*1000*1000; } while(0)
 #define tv_to_msec(tv) (tv)->tv_sec * 1000 + (tv)->tv_usec / 1000
 
 /* Compare two emails for building emails tree */
@@ -262,7 +238,7 @@ gint compare_url_func (gconstpointer a, gconstpointer b);
 /*
  * Find string find in string s ignoring case
  */
-gchar * rspamd_strncasestr (const gchar *s, const gchar *find, gint len);
+gchar* rspamd_strncasestr (const gchar *s, const gchar *find, gint len);
 
 /*
  * Try to convert string of length to long
@@ -307,7 +283,7 @@ typedef struct rspamd_rwlock_s {
  * Create new mutex
  * @return mutex or NULL
  */
-rspamd_mutex_t * rspamd_mutex_new (void);
+rspamd_mutex_t* rspamd_mutex_new (void);
 
 /**
  * Lock mutex
@@ -331,7 +307,7 @@ void rspamd_mutex_free (rspamd_mutex_t *mtx);
  * Create new rwloc
  * @return
  */
-rspamd_rwlock_t * rspamd_rwlock_new (void);
+rspamd_rwlock_t* rspamd_rwlock_new (void);
 
 /**
  * Lock rwlock for writing
@@ -381,10 +357,7 @@ rspamd_cond_wait (GCond *cond, rspamd_mutex_t *mtx)
  * @param err error pointer
  * @return new thread object that can be joined
  */
-GThread * rspamd_create_thread (const gchar *name,
-	GThreadFunc func,
-	gpointer data,
-	GError **err);
+GThread* rspamd_create_thread (const gchar *name, GThreadFunc func, gpointer data, GError **err);
 
 /**
  * Return 32bit murmur hash value for specified input
@@ -430,9 +403,9 @@ void murmur128_hash (const guint8 *in, gsize len, guint64 out[]);
  * @param ud user data for copy functions
  */
 void rspamd_hash_table_copy (GHashTable *src, GHashTable *dst,
-	gpointer (*key_copy_func)(gconstpointer data, gpointer ud),
-	gpointer (*value_copy_func)(gconstpointer data, gpointer ud),
-	gpointer ud);
+		gpointer (*key_copy_func)(gconstpointer data, gpointer ud),
+		gpointer (*value_copy_func)(gconstpointer data, gpointer ud),
+		gpointer ud);
 
 /**
  * Utility function to provide mem_pool copy for rspamd_hash_table_copy function
@@ -475,9 +448,7 @@ gboolean rspamd_ip_is_valid (rspamd_inet_addr_t *addr);
  * @param emit_type emitter type
  * @param target target string
  */
-void rspamd_ucl_emit_gstring (ucl_object_t *obj,
-	enum ucl_emitter emit_type,
-	GString *target);
+void rspamd_ucl_emit_gstring (ucl_object_t *obj, enum ucl_emitter emit_type, GString *target);
 
 /**
  * Accept from listening socket filling addr structure
@@ -493,15 +464,14 @@ gint rspamd_accept_from_socket (gint sock, rspamd_inet_addr_t *addr);
  * @param src IP string representation
  * @return TRUE if addr has been parsed
  */
-gboolean rspamd_parse_inet_address (rspamd_inet_addr_t *target,
-	const char *src);
+gboolean rspamd_parse_inet_address (rspamd_inet_addr_t *target, const char *src);
 
 /**
  * Returns string representation of inet address
  * @param addr
  * @return statically allocated string pointer (not thread safe)
  */
-const char * rspamd_inet_address_to_string (rspamd_inet_addr_t *addr);
+const char* rspamd_inet_address_to_string (rspamd_inet_addr_t *addr);
 
 /**
  * Returns port number for the specified inet address in host byte order
diff --git a/src/lmtp.c b/src/lmtp.c
index 2d0a7a922..946f8ca8b 100644
--- a/src/lmtp.c
+++ b/src/lmtp.c
@@ -22,31 +22,31 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "buffer.h"
-#include "cfg_file.h"
 #include "config.h"
+#include "buffer.h"
+#include "main.h"
 #include "lmtp.h"
 #include "lmtp_proto.h"
-#include "main.h"
-#include "message.h"
-#include "url.h"
+#include "cfg_file.h"
 #include "util.h"
+#include "url.h"
+#include "message.h"
 
-static gchar greetingbuf[1024];
-static struct timeval io_tv;
+static gchar                     greetingbuf[1024];
+static struct timeval           io_tv;
 
-static gboolean lmtp_write_socket (void *arg);
+static gboolean                 lmtp_write_socket (void *arg);
 
 void start_lmtp (struct rspamd_worker *worker);
 
 worker_t lmtp_worker = {
-	"controller",               /* Name */
-	NULL,                       /* Init function */
-	start_lmtp,                 /* Start function */
-	TRUE,                       /* Has socket */
-	FALSE,                      /* Non unique */
-	FALSE,                      /* Non threaded */
-	TRUE                        /* Killable */
+	"controller",				/* Name */
+	NULL,						/* Init function */
+	start_lmtp,					/* Start function */
+	TRUE,						/* Has socket */
+	FALSE,						/* Non unique */
+	FALSE,						/* Non threaded */
+	TRUE						/* Killable */
 };
 
 #ifndef HAVE_SA_SIGINFO
@@ -71,16 +71,15 @@ sig_handler (gint signo, siginfo_t *info, void *unused)
 static void
 sigusr2_handler (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
+	struct rspamd_worker           *worker = (struct rspamd_worker *)arg;
 	/* Do not accept new connections, preparing to end worker's process */
-	struct timeval tv;
+	struct timeval                  tv;
 	tv.tv_sec = SOFT_SHUTDOWN_TIME;
 	tv.tv_usec = 0;
 	event_del (&worker->sig_ev_usr1);
 	event_del (&worker->sig_ev_usr2);
 	event_del (&worker->bind_ev);
-	msg_info ("lmtp worker's shutdown is pending in %d sec",
-		SOFT_SHUTDOWN_TIME);
+	msg_info ("lmtp worker's shutdown is pending in %d sec", SOFT_SHUTDOWN_TIME);
 	event_loopexit (&tv);
 	return;
 }
@@ -91,7 +90,7 @@ sigusr2_handler (gint fd, short what, void *arg)
 static void
 sigusr1_handler (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *) arg;
+	struct rspamd_worker           *worker = (struct rspamd_worker *) arg;
 
 	reopen_log (worker->srv->logger);
 
@@ -104,7 +103,7 @@ sigusr1_handler (gint fd, short what, void *arg)
 static void
 rcpt_destruct (void *pointer)
 {
-	struct rspamd_task *task = (struct rspamd_task *)pointer;
+	struct rspamd_task             *task = (struct rspamd_task *)pointer;
 
 	if (task->rcpt) {
 		g_list_free (task->rcpt);
@@ -117,9 +116,9 @@ rcpt_destruct (void *pointer)
 static void
 free_lmtp_task (struct rspamd_lmtp_proto *lmtp, gboolean is_soft)
 {
-	GList *part;
-	struct mime_part *p;
-	struct rspamd_task *task = lmtp->task;
+	GList                          *part;
+	struct mime_part               *p;
+	struct rspamd_task             *task = lmtp->task;
 
 	if (lmtp) {
 		debug_task ("free pointer %p", lmtp->task);
@@ -146,12 +145,12 @@ free_lmtp_task (struct rspamd_lmtp_proto *lmtp, gboolean is_soft)
 /*
  * Callback that is called when there is data to read in buffer
  */
-static gboolean
+static                          gboolean
 lmtp_read_socket (f_str_t * in, void *arg)
 {
-	struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
-	struct rspamd_task *task = lmtp->task;
-	ssize_t r;
+	struct rspamd_lmtp_proto       *lmtp = (struct rspamd_lmtp_proto *)arg;
+	struct rspamd_task             *task = lmtp->task;
+	ssize_t                         r;
 
 	switch (task->state) {
 	case READ_COMMAND:
@@ -182,8 +181,7 @@ lmtp_read_socket (f_str_t * in, void *arg)
 		}
 		break;
 	default:
-		debug_task ("invalid state while reading from socket %d",
-			lmtp->task->state);
+		debug_task ("invalid state while reading from socket %d", lmtp->task->state);
 		break;
 	}
 
@@ -193,11 +191,11 @@ lmtp_read_socket (f_str_t * in, void *arg)
 /*
  * Callback for socket writing
  */
-static gboolean
+static                          gboolean
 lmtp_write_socket (void *arg)
 {
-	struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
-	struct rspamd_task *task = lmtp->task;
+	struct rspamd_lmtp_proto       *lmtp = (struct rspamd_lmtp_proto *)arg;
+	struct rspamd_task             *task = lmtp->task;
 
 	switch (lmtp->task->state) {
 	case WRITE_REPLY:
@@ -218,8 +216,7 @@ lmtp_write_socket (void *arg)
 		return FALSE;
 		break;
 	default:
-		debug_task ("invalid state while writing to socket %d",
-			lmtp->task->state);
+		debug_task ("invalid state while writing to socket %d", lmtp->task->state);
 		break;
 	}
 
@@ -232,7 +229,7 @@ lmtp_write_socket (void *arg)
 static void
 lmtp_err_socket (GError * err, void *arg)
 {
-	struct rspamd_lmtp_proto *lmtp = (struct rspamd_lmtp_proto *)arg;
+	struct rspamd_lmtp_proto       *lmtp = (struct rspamd_lmtp_proto *)arg;
 	msg_info ("abnormally closing connection, error: %s", err->message);
 	/* Free buffers */
 	free_lmtp_task (lmtp, FALSE);
@@ -244,15 +241,14 @@ lmtp_err_socket (GError * err, void *arg)
 static void
 accept_socket (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
-	union sa_union su;
-	struct rspamd_task *new_task;
-	struct rspamd_lmtp_proto *lmtp;
-	socklen_t addrlen = sizeof (su.ss);
-	gint nfd;
-
-	if ((nfd =
-		accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
+	struct rspamd_worker           *worker = (struct rspamd_worker *)arg;
+	union sa_union                  su;
+	struct rspamd_task             *new_task;
+	struct rspamd_lmtp_proto       *lmtp;
+	socklen_t                       addrlen = sizeof (su.ss);
+	gint                            nfd;
+
+	if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
 		msg_warn ("accept failed: %s", strerror (errno));
 		return;
 	}
@@ -266,38 +262,26 @@ accept_socket (gint fd, short what, void *arg)
 		new_task->client_addr.s_addr = INADDR_NONE;
 	}
 	else if (su.ss.ss_family == AF_INET) {
-		msg_info ("accepted connection from %s port %d",
-			inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
-		memcpy (&new_task->client_addr, &su.s4.sin_addr,
-			sizeof (struct in_addr));
+		msg_info ("accepted connection from %s port %d", inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
+		memcpy (&new_task->client_addr, &su.s4.sin_addr, sizeof (struct in_addr));
 	}
 
 	new_task->sock = nfd;
 	new_task->cfg = worker->srv->cfg;
 	new_task->task_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 	/* Add destructor for recipients list (it would be better to use anonymous function here */
-	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t) rcpt_destruct,		  new_task);
+	rspamd_mempool_add_destructor (new_task->task_pool, (rspamd_mempool_destruct_t) rcpt_destruct, new_task);
 	new_task->results = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	new_task->ev_base = worker->ctx;
-	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy, new_task->results);
+	rspamd_mempool_add_destructor (new_task->task_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, new_task->results);
 	worker->srv->stat->connections_count++;
 	lmtp->task = new_task;
 	lmtp->state = LMTP_READ_LHLO;
 
 	/* Set up dispatcher */
-	new_task->dispatcher = rspamd_create_dispatcher (new_task->ev_base,
-			nfd,
-			BUFFER_LINE,
-			lmtp_read_socket,
-			lmtp_write_socket,
-			lmtp_err_socket,
-			&io_tv,
-			(void *)lmtp);
+	new_task->dispatcher = rspamd_create_dispatcher (new_task->ev_base, nfd, BUFFER_LINE, lmtp_read_socket, lmtp_write_socket, lmtp_err_socket, &io_tv, (void *)lmtp);
 	new_task->dispatcher->peer_addr = new_task->client_addr.s_addr;
-	if (!rspamd_dispatcher_write (lmtp->task->dispatcher, greetingbuf,
-		strlen (greetingbuf), FALSE, FALSE)) {
+	if (! rspamd_dispatcher_write (lmtp->task->dispatcher, greetingbuf, strlen (greetingbuf), FALSE, FALSE)) {
 		msg_warn ("cannot write greeting");
 	}
 }
@@ -308,10 +292,10 @@ accept_socket (gint fd, short what, void *arg)
 void
 start_lmtp (struct rspamd_worker *worker)
 {
-	struct sigaction signals;
-	gchar *hostbuf;
-	gsize hostmax;
-	module_t **mod;
+	struct sigaction                signals;
+	gchar                          *hostbuf;
+	gsize                           hostmax;
+	module_t					  **mod;
 
 	worker->srv->pid = getpid ();
 	worker->ctx = event_init ();
@@ -321,23 +305,17 @@ start_lmtp (struct rspamd_worker *worker)
 	sigprocmask (SIG_UNBLOCK, &signals.sa_mask, NULL);
 
 	/* SIGUSR2 handler */
-	signal_set (&worker->sig_ev_usr2, SIGUSR2, sigusr2_handler,
-		(void *) worker);
+	signal_set (&worker->sig_ev_usr2, SIGUSR2, sigusr2_handler, (void *) worker);
 	event_base_set (worker->ctx, &worker->sig_ev_usr2);
 	signal_add (&worker->sig_ev_usr2, NULL);
 
 	/* SIGUSR1 handler */
-	signal_set (&worker->sig_ev_usr1, SIGUSR1, sigusr1_handler,
-		(void *) worker);
+	signal_set (&worker->sig_ev_usr1, SIGUSR1, sigusr1_handler, (void *) worker);
 	event_base_set (worker->ctx, &worker->sig_ev_usr1);
 	signal_add (&worker->sig_ev_usr1, NULL);
 
 	/* Accept event */
-	event_set (&worker->bind_ev,
-		worker->cf->listen_sock,
-		EV_READ | EV_PERSIST,
-		accept_socket,
-		(void *)worker);
+	event_set (&worker->bind_ev, worker->cf->listen_sock, EV_READ | EV_PERSIST, accept_socket, (void *)worker);
 	event_base_set (worker->ctx, &worker->bind_ev);
 	event_add (&worker->bind_ev, NULL);
 
@@ -345,7 +323,7 @@ start_lmtp (struct rspamd_worker *worker)
 	mod = &modules[0];
 	while (*mod) {
 		(*mod)->module_config_func (worker->srv->cfg);
-		mod++;
+		mod ++;
 	}
 
 	/* Fill hostname buf */
@@ -353,12 +331,7 @@ start_lmtp (struct rspamd_worker *worker)
 	hostbuf = alloca (hostmax);
 	gethostname (hostbuf, hostmax);
 	hostbuf[hostmax - 1] = '\0';
-	rspamd_snprintf (greetingbuf,
-		sizeof (greetingbuf),
-		"%d rspamd version %s LMTP on %s Ready\r\n",
-		LMTP_OK,
-		RVERSION,
-		hostbuf);
+	rspamd_snprintf (greetingbuf, sizeof (greetingbuf), "%d rspamd version %s LMTP on %s Ready\r\n", LMTP_OK, RVERSION, hostbuf);
 
 	io_tv.tv_sec = 60000;
 	io_tv.tv_usec = 0;
@@ -369,6 +342,6 @@ start_lmtp (struct rspamd_worker *worker)
 	exit (EXIT_SUCCESS);
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/lmtp_proto.c b/src/lmtp_proto.c
index ff00a5d3a..81cd13607 100644
--- a/src/lmtp_proto.c
+++ b/src/lmtp_proto.c
@@ -22,64 +22,62 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "lmtp.h"
-#include "lmtp_proto.h"
 #include "main.h"
+#include "cfg_file.h"
 #include "util.h"
+#include "lmtp.h"
+#include "lmtp_proto.h"
 
 /* Max line size as it is defined in rfc2822 */
 #define OUTBUFSIZ 1000
 
 /* LMTP commands */
-static f_str_t lhlo_command = {
+static f_str_t                  lhlo_command = {
 	.begin = "LHLO",
 	.len = sizeof ("LHLO") - 1
 };
 
-static f_str_t mail_command = {
+static f_str_t                  mail_command = {
 	.begin = "MAIL FROM:",
 	.len = sizeof ("MAIL FROM:") - 1
 };
 
-static f_str_t rcpt_command = {
+static f_str_t                  rcpt_command = {
 	.begin = "RCPT TO:",
 	.len = sizeof ("RCPT TO:") - 1
 };
 
-static f_str_t data_command = {
+static f_str_t                  data_command = {
 	.begin = "DATA",
 	.len = sizeof ("DATA") - 1
 };
 
-static f_str_t data_dot = {
+static f_str_t                  data_dot = {
 	.begin = ".\r\n",
 	.len = sizeof (".\r\n") - 1
 };
 
-static const gchar *mail_regexp =
-	"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?";
-static GRegex *mail_re = NULL;
+static const gchar              *mail_regexp = "[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?";
+static GRegex                  *mail_re = NULL;
 
 /*
- * Extract e-mail from read line
+ * Extract e-mail from read line 
  * return <> if no valid address detected
  */
-static gchar *
+static gchar                    *
 extract_mail (rspamd_mempool_t * pool, f_str_t * line)
 {
-	GError *err = NULL;
-	gchar *match;
-	GMatchInfo *info;
+	GError                         *err = NULL;
+	gchar                           *match;
+	GMatchInfo                     *info;
 
 	if (mail_re == NULL) {
 		/* Compile regexp */
 		mail_re = g_regex_new (mail_regexp, G_REGEX_RAW, 0, &err);
 	}
 
-	if (g_regex_match_full (mail_re, line->begin, line->len, 0, 0, &info,
-		NULL) == TRUE) {
+	if (g_regex_match_full (mail_re, line->begin, line->len, 0, 0, &info, NULL) == TRUE) {
 		match = rspamd_mempool_strdup (pool, g_match_info_fetch (info, 0));
 		g_match_info_free (info);
 	}
@@ -93,18 +91,16 @@ extract_mail (rspamd_mempool_t * pool, f_str_t * line)
 static gboolean
 out_lmtp_reply (struct rspamd_task *task, gint code, gchar *rcode, gchar *msg)
 {
-	gchar outbuf[OUTBUFSIZ];
-	gint r;
+	gchar                           outbuf[OUTBUFSIZ];
+	gint                            r;
 
 	if (*rcode == '\0') {
 		r = rspamd_snprintf (outbuf, OUTBUFSIZ, "%d %s\r\n", code, msg);
 	}
 	else {
-		r =
-			rspamd_snprintf (outbuf, OUTBUFSIZ, "%d %s %s\r\n", code, rcode,
-				msg);
+		r = rspamd_snprintf (outbuf, OUTBUFSIZ, "%d %s %s\r\n", code, rcode, msg);
 	}
-	if (!rspamd_dispatcher_write (task->dispatcher, outbuf, r, FALSE, FALSE)) {
+	if (! rspamd_dispatcher_write (task->dispatcher, outbuf, r, FALSE, FALSE)) {
 		return FALSE;
 	}
 	return TRUE;
@@ -113,19 +109,16 @@ out_lmtp_reply (struct rspamd_task *task, gint code, gchar *rcode, gchar *msg)
 gint
 read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 {
-	gchar *c, *rcpt;
-	f_str_t fstr;
-	gint i = 0, l = 0, size;
+	gchar                           *c, *rcpt;
+	f_str_t                         fstr;
+	gint                            i = 0, l = 0, size;
 
 	switch (lmtp->state) {
 	case LMTP_READ_LHLO:
 		/* Search LHLO line */
 		if ((i = fstrstri (line, &lhlo_command)) == -1) {
 			msg_info ("LHLO expected but not found");
-			(void)out_lmtp_reply (lmtp->task,
-				LMTP_BAD_CMD,
-				"5.0.0",
-				"Need LHLO here");
+			(void)out_lmtp_reply (lmtp->task, LMTP_BAD_CMD, "5.0.0", "Need LHLO here");
 			return -1;
 		}
 		else {
@@ -136,12 +129,11 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 				i++;
 				c++;
 			}
-			lmtp->task->helo = rspamd_mempool_alloc (lmtp->task->task_pool,
-					line->len - i + 1);
+			lmtp->task->helo = rspamd_mempool_alloc (lmtp->task->task_pool, line->len - i + 1);
 			/* Strlcpy makes string null terminated by design */
 			rspamd_strlcpy (lmtp->task->helo, c, line->len - i + 1);
 			lmtp->state = LMTP_READ_FROM;
-			if (!out_lmtp_reply (lmtp->task, LMTP_OK, "", "Ok")) {
+			if (! out_lmtp_reply (lmtp->task, LMTP_OK, "", "Ok")) {
 				return -1;
 			}
 			return 0;
@@ -151,10 +143,7 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 		/* Search MAIL FROM: line */
 		if ((i = fstrstri (line, &mail_command)) == -1) {
 			msg_info ("MAIL expected but not found");
-			(void)out_lmtp_reply (lmtp->task,
-				LMTP_BAD_CMD,
-				"5.0.0",
-				"Need MAIL here");
+			(void)out_lmtp_reply (lmtp->task, LMTP_BAD_CMD, "5.0.0", "Need MAIL here");
 			return -1;
 		}
 		else {
@@ -164,7 +153,7 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 			fstr.len = line->len - i;
 			lmtp->task->from = extract_mail (lmtp->task->task_pool, &fstr);
 			lmtp->state = LMTP_READ_RCPT;
-			if (!out_lmtp_reply (lmtp->task, LMTP_OK, "2.1.0", "Sender ok")) {
+			if (! out_lmtp_reply (lmtp->task, LMTP_OK, "2.1.0", "Sender ok")) {
 				return -1;
 			}
 			return 0;
@@ -174,10 +163,7 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 		/* Search RCPT_TO: line */
 		if ((i = fstrstri (line, &rcpt_command)) == -1) {
 			msg_info ("RCPT expected but not found");
-			(void)out_lmtp_reply (lmtp->task,
-				LMTP_NO_RCPT,
-				"5.5.4",
-				"Need RCPT here");
+			(void)out_lmtp_reply (lmtp->task, LMTP_NO_RCPT, "5.5.4", "Need RCPT here");
 			return -1;
 		}
 		else {
@@ -189,17 +175,13 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 			if (*rcpt == '<' && *(rcpt + 1) == '>') {
 				/* Invalid or empty rcpt not allowed */
 				msg_info ("bad recipient");
-				(void)out_lmtp_reply (lmtp->task,
-					LMTP_NO_RCPT,
-					"5.5.4",
-					"Bad recipient");
+				(void)out_lmtp_reply (lmtp->task, LMTP_NO_RCPT, "5.5.4", "Bad recipient");
 				return -1;
 			}
 			/* Strlcpy makes string null terminated by design */
 			lmtp->task->rcpt = g_list_prepend (lmtp->task->rcpt, rcpt);
 			lmtp->state = LMTP_READ_DATA;
-			if (!out_lmtp_reply (lmtp->task, LMTP_OK, "2.1.0",
-				"Recipient ok")) {
+			if (! out_lmtp_reply (lmtp->task, LMTP_OK, "2.1.0", "Recipient ok")) {
 				return -1;
 			}
 			return 0;
@@ -209,10 +191,7 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 		/* Search DATA line */
 		if ((i = fstrstri (line, &data_command)) == -1) {
 			msg_info ("DATA expected but not found");
-			(void)out_lmtp_reply (lmtp->task,
-				LMTP_BAD_CMD,
-				"5.0.0",
-				"Need DATA here");
+			(void)out_lmtp_reply (lmtp->task, LMTP_BAD_CMD, "5.0.0", "Need DATA here");
 			return -1;
 		}
 		else {
@@ -222,14 +201,12 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 			while (g_ascii_isspace (*c++)) {
 				i++;
 			}
-			rcpt = rspamd_mempool_alloc (lmtp->task->task_pool,
-					line->len - i + 1);
+			rcpt = rspamd_mempool_alloc (lmtp->task->task_pool, line->len - i + 1);
 			/* Strlcpy makes string null terminated by design */
 			rspamd_strlcpy (rcpt, c, line->len - i + 1);
 			lmtp->task->rcpt = g_list_prepend (lmtp->task->rcpt, rcpt);
 			lmtp->state = LMTP_READ_MESSAGE;
-			if (!out_lmtp_reply (lmtp->task, LMTP_DATA, "",
-				"Enter message, ending with \".\" on a line by itself")) {
+			if (! out_lmtp_reply (lmtp->task, LMTP_DATA, "", "Enter message, ending with \".\" on a line by itself")) {
 				return -1;
 			}
 			lmtp->task->msg = fstralloc (lmtp->task->task_pool, BUFSIZ);
@@ -254,19 +231,17 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 					/* size *= 2 */
 					size <<= 1;
 				}
-				lmtp->task->msg = fstrgrow (lmtp->task->task_pool,
-						lmtp->task->msg,
-						size);
+				lmtp->task->msg = fstrgrow (lmtp->task->task_pool, lmtp->task->msg, size);
 			}
 			fstrcat (lmtp->task->msg, line);
 			return 0;
 		}
 		break;
 	case LMTP_READ_DOT:
-		/* We have some input after reading dot, close connection as we have no currently support of multiply
+		/* We have some input after reading dot, close connection as we have no currently support of multiply 
 		 * messages per session
 		 */
-		if (!out_lmtp_reply (lmtp->task, LMTP_QUIT, "", "Bye")) {
+		if (! out_lmtp_reply (lmtp->task, LMTP_QUIT, "", "Bye")) {
 			return -1;
 		}
 		return 0;
@@ -277,8 +252,8 @@ read_lmtp_input_line (struct rspamd_lmtp_proto *lmtp, f_str_t * line)
 }
 
 struct mta_callback_data {
-	struct rspamd_task *task;
-	rspamd_io_dispatcher_t *dispatcher;
+	struct rspamd_task             *task;
+	rspamd_io_dispatcher_t         *dispatcher;
 	enum {
 		LMTP_WANT_GREETING,
 		LMTP_WANT_MAIL,
@@ -289,20 +264,18 @@ struct mta_callback_data {
 	} state;
 };
 
-static gboolean
+static                          gboolean
 parse_mta_str (f_str_t * in, struct mta_callback_data *cd)
 {
-	gint r;
-	static f_str_t okres1 = {
+	gint                            r;
+	static f_str_t                  okres1 = {
 		.begin = "250 ",
 		.len = sizeof ("250 ") - 1,
 	}
 	, okres2 = {
-		.begin = "220 ",.len = sizeof ("220 ") - 1,
-	}
+	.begin = "220 ",.len = sizeof ("220 ") - 1,}
 	, datares = {
-		.begin = "354 ",.len = sizeof ("354 ") - 1,
-	};
+	.begin = "354 ",.len = sizeof ("354 ") - 1,};
 
 	switch (cd->state) {
 	case LMTP_WANT_GREETING:
@@ -328,12 +301,12 @@ close_mta_connection (struct mta_callback_data *cd, gboolean is_success)
 {
 	cd->task->state = CLOSING_CONNECTION;
 	if (is_success) {
-		if (!out_lmtp_reply (cd->task, LMTP_OK, "", "Delivery completed")) {
+		if (! out_lmtp_reply (cd->task, LMTP_OK, "", "Delivery completed")) {
 			return;
 		}
 	}
 	else {
-		if (!out_lmtp_reply (cd->task, LMTP_FAILURE, "", "Delivery failure")) {
+		if (! out_lmtp_reply (cd->task, LMTP_FAILURE, "", "Delivery failure")) {
 			return;
 		}
 	}
@@ -343,20 +316,19 @@ close_mta_connection (struct mta_callback_data *cd, gboolean is_success)
 /*
  * Callback that is called when there is data to read in buffer
  */
-static gboolean
+static                          gboolean
 mta_read_socket (f_str_t * in, void *arg)
 {
-	struct mta_callback_data *cd = (struct mta_callback_data *)arg;
-	gchar outbuf[1024], *hostbuf, *c;
-	gint hostmax, r;
-	GList *cur;
-	static f_str_t contres1 = {
+	struct mta_callback_data       *cd = (struct mta_callback_data *)arg;
+	gchar                           outbuf[1024], *hostbuf, *c;
+	gint                            hostmax, r;
+	GList                          *cur;
+	static f_str_t                  contres1 = {
 		.begin = "250-",
 		.len = sizeof ("250-") - 1,
 	}
 	, contres2 = {
-		.begin = "220-",.len = sizeof ("220-") - 1,
-	};
+	.begin = "220-",.len = sizeof ("220-") - 1,};
 
 	if (fstrstr (in, &contres1) != -1 || fstrstr (in, &contres2) != -1) {
 		/* Skip such lines */
@@ -375,19 +347,12 @@ mta_read_socket (f_str_t * in, void *arg)
 		gethostname (hostbuf, hostmax);
 		hostbuf[hostmax - 1] = '\0';
 		if (cd->task->cfg->deliver_lmtp) {
-			r = rspamd_snprintf (outbuf,
-					sizeof (outbuf),
-					"LHLO %s" CRLF,
-					hostbuf);
+			r = rspamd_snprintf (outbuf, sizeof (outbuf), "LHLO %s" CRLF, hostbuf);
 		}
 		else {
-			r = rspamd_snprintf (outbuf,
-					sizeof (outbuf),
-					"HELO %s" CRLF,
-					hostbuf);
+			r = rspamd_snprintf (outbuf, sizeof (outbuf), "HELO %s" CRLF, hostbuf);
 		}
-		if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
-			FALSE)) {
+		if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
 			return FALSE;
 		}
 		cd->state = LMTP_WANT_MAIL;
@@ -398,12 +363,8 @@ mta_read_socket (f_str_t * in, void *arg)
 			close_mta_connection (cd, FALSE);
 			return FALSE;
 		}
-		r = rspamd_snprintf (outbuf,
-				sizeof (outbuf),
-				"MAIL FROM: <%s>" CRLF,
-				cd->task->from);
-		if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
-			FALSE)) {
+		r = rspamd_snprintf (outbuf, sizeof (outbuf), "MAIL FROM: <%s>" CRLF, cd->task->from);
+		if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
 			return FALSE;
 		}
 		cd->state = LMTP_WANT_RCPT;
@@ -417,15 +378,11 @@ mta_read_socket (f_str_t * in, void *arg)
 		cur = g_list_first (cd->task->rcpt);
 		r = 0;
 		while (cur) {
-			r += rspamd_snprintf (outbuf + r,
-					sizeof (outbuf) - r,
-					"RCPT TO: <%s>" CRLF,
-					(gchar *)cur->data);
+			r += rspamd_snprintf (outbuf + r, sizeof (outbuf) - r, "RCPT TO: <%s>" CRLF, (gchar *)cur->data);
 			cur = g_list_next (cur);
 		}
 
-		if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
-			FALSE)) {
+		if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
 			return FALSE;
 		}
 		cd->state = LMTP_WANT_DATA;
@@ -437,8 +394,7 @@ mta_read_socket (f_str_t * in, void *arg)
 			return FALSE;
 		}
 		r = rspamd_snprintf (outbuf, sizeof (outbuf), "DATA" CRLF);
-		if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
-			FALSE)) {
+		if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
 			return FALSE;
 		}
 		cd->state = LMTP_WANT_DOT;
@@ -451,14 +407,12 @@ mta_read_socket (f_str_t * in, void *arg)
 		}
 		c = g_mime_object_to_string ((GMimeObject *) cd->task->message);
 		r = strlen (c);
-		if (!rspamd_dispatcher_write (cd->task->dispatcher, c, r, TRUE, TRUE)) {
+		if (! rspamd_dispatcher_write (cd->task->dispatcher, c, r, TRUE, TRUE)) {
 			return FALSE;
 		}
-		rspamd_mempool_add_destructor (cd->task->task_pool,
-			(rspamd_mempool_destruct_t) g_free, c);
+		rspamd_mempool_add_destructor (cd->task->task_pool, (rspamd_mempool_destruct_t) g_free, c);
 		r = rspamd_snprintf (outbuf, sizeof (outbuf), CRLF "." CRLF);
-		if (!rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE,
-			FALSE)) {
+		if (! rspamd_dispatcher_write (cd->task->dispatcher, outbuf, r, FALSE, FALSE)) {
 			return FALSE;
 		}
 		cd->state = LMTP_WANT_CLOSING;
@@ -482,7 +436,7 @@ mta_read_socket (f_str_t * in, void *arg)
 static void
 mta_err_socket (GError * err, void *arg)
 {
-	struct mta_callback_data *cd = (struct mta_callback_data *)arg;
+	struct mta_callback_data       *cd = (struct mta_callback_data *)arg;
 	msg_info ("abnormaly terminating connection with MTA");
 	close_mta_connection (cd, FALSE);
 }
@@ -493,54 +447,36 @@ mta_err_socket (GError * err, void *arg)
 static gint
 lmtp_deliver_mta (struct rspamd_task *task)
 {
-	gint sock;
-	struct sockaddr_un *un;
-	struct mta_callback_data *cd;
+	gint                            sock;
+	struct sockaddr_un             *un;
+	struct mta_callback_data       *cd;
 
 	if (task->cfg->deliver_family == AF_UNIX) {
 		un = alloca (sizeof (struct sockaddr_un));
-		sock = make_unix_socket (task->cfg->deliver_host,
-				un,
-				SOCK_STREAM,
-				FALSE,
-				TRUE);
+		sock = make_unix_socket (task->cfg->deliver_host, un, SOCK_STREAM, FALSE, TRUE);
 	}
 	else {
-		sock = make_universal_socket (task->cfg->deliver_host,
-				task->cfg->deliver_port,
-				SOCK_STREAM,
-				TRUE,
-				FALSE,
-				TRUE);
+		sock = make_universal_socket (task->cfg->deliver_host, task->cfg->deliver_port,
+				SOCK_STREAM, TRUE, FALSE, TRUE);
 	}
 	if (sock == -1) {
-		msg_warn ("cannot create socket for %s, %s",
-			task->cfg->deliver_host,
-			strerror (errno));
+		msg_warn ("cannot create socket for %s, %s", task->cfg->deliver_host, strerror (errno));
 	}
 
-	cd = rspamd_mempool_alloc (task->task_pool,
-			sizeof (struct mta_callback_data));
+	cd = rspamd_mempool_alloc (task->task_pool, sizeof (struct mta_callback_data));
 	cd->task = task;
 	cd->state = LMTP_WANT_GREETING;
-	cd->dispatcher = rspamd_create_dispatcher (task->ev_base,
-			sock,
-			BUFFER_LINE,
-			mta_read_socket,
-			NULL,
-			mta_err_socket,
-			NULL,
-			(void *)cd);
+	cd->dispatcher = rspamd_create_dispatcher (task->ev_base, sock, BUFFER_LINE, mta_read_socket, NULL, mta_err_socket, NULL, (void *)cd);
 	return 0;
 }
 
-static gchar *
+static gchar                    *
 format_lda_args (struct rspamd_task *task)
 {
-	gchar *res, *c, *r;
-	size_t len;
-	GList *rcpt;
-	gboolean got_args = FALSE;
+	gchar                           *res, *c, *r;
+	size_t                          len;
+	GList                          *rcpt;
+	gboolean                        got_args = FALSE;
 
 	c = task->cfg->deliver_agent_path;
 	/* Find first arg */
@@ -621,10 +557,10 @@ format_lda_args (struct rspamd_task *task)
 static gint
 lmtp_deliver_lda (struct rspamd_task *task)
 {
-	gchar *args, **argv;
-	GMimeStream *stream;
-	gint rc, ecode, p[2], argc;
-	pid_t cpid, pid;
+	gchar                           *args, **argv;
+	GMimeStream                    *stream;
+	gint                            rc, ecode, p[2], argc;
+	pid_t                           cpid, pid;
 
 	if ((args = format_lda_args (task)) == NULL) {
 		return -1;
@@ -673,8 +609,7 @@ lmtp_deliver_lda (struct rspamd_task *task)
 	close (p[0]);
 	stream = g_mime_stream_fs_new (p[1]);
 
-	if (g_mime_object_write_to_stream ((GMimeObject *) task->message,
-		stream) == -1) {
+	if (g_mime_object_write_to_stream ((GMimeObject *) task->message, stream) == -1) {
 		g_strfreev (argv);
 		msg_info ("cannot write stream to lda");
 		return -1;
@@ -732,13 +667,12 @@ lmtp_deliver_message (struct rspamd_task *task)
 gint
 write_lmtp_reply (struct rspamd_lmtp_proto *lmtp)
 {
-	gint r;
-	struct rspamd_task *task = lmtp->task;
+	gint                            r;
+	struct rspamd_task             *task = lmtp->task;
 
 	debug_task ("writing reply to client");
 	if (lmtp->task->error_code != 0) {
-		if (!out_lmtp_reply (lmtp->task, lmtp->task->error_code, "",
-			lmtp->task->last_error)) {
+		if (! out_lmtp_reply (lmtp->task, lmtp->task->error_code, "", lmtp->task->last_error)) {
 			return -1;
 		}
 	}
@@ -749,8 +683,7 @@ write_lmtp_reply (struct rspamd_lmtp_proto *lmtp)
 			return -1;
 		}
 		else if (r == 0) {
-			if (!out_lmtp_reply (lmtp->task, LMTP_OK, "",
-				"Delivery completed")) {
+			if (! out_lmtp_reply (lmtp->task, LMTP_OK, "", "Delivery completed")) {
 				return -1;
 			}
 		}
@@ -762,6 +695,6 @@ write_lmtp_reply (struct rspamd_lmtp_proto *lmtp)
 	return 0;
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/lua/lua_buffer.c b/src/lua/lua_buffer.c
index d119f8e27..37c4fce61 100644
--- a/src/lua/lua_buffer.c
+++ b/src/lua/lua_buffer.c
@@ -21,11 +21,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "buffer.h"
 #include "lua_common.h"
+#include "buffer.h"
 
 /* Public prototypes */
-struct rspamd_io_dispatcher_s * lua_check_io_dispatcher (lua_State * L);
+struct rspamd_io_dispatcher_s *lua_check_io_dispatcher (lua_State * L);
 gint luaopen_io_dispatcher (lua_State * L);
 
 /* Lua bindings */
@@ -36,7 +36,7 @@ LUA_FUNCTION_DEF (io_dispatcher, pause);
 LUA_FUNCTION_DEF (io_dispatcher, restore);
 LUA_FUNCTION_DEF (io_dispatcher, destroy);
 
-static const struct luaL_reg io_dispatcherlib_m[] = {
+static const struct luaL_reg    io_dispatcherlib_m[] = {
 	LUA_INTERFACE_DEF (io_dispatcher, set_policy),
 	LUA_INTERFACE_DEF (io_dispatcher, write),
 	LUA_INTERFACE_DEF (io_dispatcher, pause),
@@ -46,7 +46,7 @@ static const struct luaL_reg io_dispatcherlib_m[] = {
 	{NULL, NULL}
 };
 
-static const struct luaL_reg io_dispatcherlib_f[] = {
+static const struct luaL_reg    io_dispatcherlib_f[] = {
 	LUA_INTERFACE_DEF (io_dispatcher, create),
 	{NULL, NULL}
 };
@@ -60,10 +60,10 @@ struct lua_dispatcher_cbdata {
 	gint cbref_err;
 };
 
-struct rspamd_io_dispatcher_s *
+struct rspamd_io_dispatcher_s      *
 lua_check_io_dispatcher (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{io_dispatcher}");
+	void								*ud = luaL_checkudata (L, 1, "rspamd{io_dispatcher}");
 	luaL_argcheck (L, ud != NULL, 1, "'io_dispatcher' expected");
 	return ud ? *((struct rspamd_io_dispatcher_s **)ud) : NULL;
 }
@@ -71,31 +71,29 @@ lua_check_io_dispatcher (lua_State * L)
 struct event_base *
 lua_check_event_base (lua_State *L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{ev_base}");
+	void								*ud = luaL_checkudata (L, 1, "rspamd{ev_base}");
 	luaL_argcheck (L, ud != NULL, 1, "'ev_base' expected");
 	return ud ? *((struct event_base **)ud) : NULL;
 }
 
 /* Dispatcher callbacks */
 
-static gboolean
+static                          gboolean
 lua_io_read_cb (f_str_t * in, void *arg)
 {
-	struct lua_dispatcher_cbdata *cbdata = arg;
-	gboolean res;
-	rspamd_io_dispatcher_t **pdispatcher;
+	struct lua_dispatcher_cbdata					*cbdata = arg;
+	gboolean								 		  res;
+	rspamd_io_dispatcher_t							**pdispatcher;
 
 	/* callback (dispatcher, data) */
 	lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_read);
-	pdispatcher =
-		lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
+	pdispatcher = lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
 	lua_setclass (cbdata->L, "rspamd{io_dispatcher}", -1);
 	*pdispatcher = cbdata->d;
 	lua_pushlstring (cbdata->L, in->begin, in->len);
 
 	if (lua_pcall (cbdata->L, 2, 1, 0) != 0) {
-		msg_info ("call to session finalizer failed: %s",
-			lua_tostring (cbdata->L, -1));
+		msg_info ("call to session finalizer failed: %s", lua_tostring (cbdata->L, -1));
 	}
 
 	res = lua_toboolean (cbdata->L, -1);
@@ -104,26 +102,23 @@ lua_io_read_cb (f_str_t * in, void *arg)
 	return res;
 }
 
-static gboolean
+static                          gboolean
 lua_io_write_cb (void *arg)
 {
-	struct lua_dispatcher_cbdata *cbdata = arg;
-	gboolean res = FALSE;
-	rspamd_io_dispatcher_t **pdispatcher;
+	struct lua_dispatcher_cbdata					*cbdata = arg;
+	gboolean										  res = FALSE;
+	rspamd_io_dispatcher_t							**pdispatcher;
 
 	if (cbdata->cbref_write) {
 		lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_read);
 		/* callback (dispatcher) */
-		pdispatcher =
-			lua_newuserdata (cbdata->L,
-				sizeof (struct rspamd_io_dispatcher_s *));
+		pdispatcher = lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
 		lua_setclass (cbdata->L, "rspamd{io_dispatcher}", -1);
 		*pdispatcher = cbdata->d;
 
 
 		if (lua_pcall (cbdata->L, 1, 1, 0) != 0) {
-			msg_info ("call to session finalizer failed: %s",
-				lua_tostring (cbdata->L, -1));
+			msg_info ("call to session finalizer failed: %s", lua_tostring (cbdata->L, -1));
 		}
 
 		res = lua_toboolean (cbdata->L, -1);
@@ -136,20 +131,18 @@ lua_io_write_cb (void *arg)
 static void
 lua_io_err_cb (GError * err, void *arg)
 {
-	struct lua_dispatcher_cbdata *cbdata = arg;
-	rspamd_io_dispatcher_t **pdispatcher;
+	struct lua_dispatcher_cbdata					*cbdata = arg;
+	rspamd_io_dispatcher_t							**pdispatcher;
 
 	/* callback (dispatcher, err) */
 	lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_err);
-	pdispatcher =
-		lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
+	pdispatcher = lua_newuserdata (cbdata->L, sizeof (struct rspamd_io_dispatcher_s *));
 	lua_setclass (cbdata->L, "rspamd{io_dispatcher}", -1);
 	*pdispatcher = cbdata->d;
 	lua_pushstring (cbdata->L, err->message);
 
 	if (lua_pcall (cbdata->L, 2, 0, 0) != 0) {
-		msg_info ("call to session finalizer failed: %s",
-			lua_tostring (cbdata->L, -1));
+		msg_info ("call to session finalizer failed: %s", lua_tostring (cbdata->L, -1));
 	}
 
 	/* Unref callbacks */
@@ -169,11 +162,11 @@ lua_io_err_cb (GError * err, void *arg)
 static int
 lua_io_dispatcher_create (lua_State *L)
 {
-	struct rspamd_io_dispatcher_s *io_dispatcher, **pdispatcher;
-	gint fd;
-	struct lua_dispatcher_cbdata *cbdata;
-	struct timeval tv = {0, 0};
-	double tv_num, tmp;
+	struct rspamd_io_dispatcher_s					*io_dispatcher, **pdispatcher;
+	gint											 fd;
+	struct lua_dispatcher_cbdata					*cbdata;
+	struct timeval									 tv = {0, 0};
+	double											 tv_num, tmp;
 
 	if (lua_gettop (L) >= 5 && lua_isfunction (L, 3) && lua_isfunction (L, 5)) {
 		cbdata = g_slice_alloc0 (sizeof (struct lua_dispatcher_cbdata));
@@ -200,36 +193,20 @@ lua_io_dispatcher_create (lua_State *L)
 			tv_num = lua_tonumber (L, 6);
 			tv.tv_sec = trunc (tv_num);
 			tv.tv_usec = modf (tv_num, &tmp) * 1000.;
-			io_dispatcher = rspamd_create_dispatcher (cbdata->base,
-					fd,
-					BUFFER_LINE,
-					lua_io_read_cb,
-					lua_io_write_cb,
-					lua_io_err_cb,
-					&tv,
-					cbdata);
+			io_dispatcher = rspamd_create_dispatcher (cbdata->base, fd, BUFFER_LINE, lua_io_read_cb, lua_io_write_cb, lua_io_err_cb, &tv, cbdata);
 		}
 		else {
-			io_dispatcher = rspamd_create_dispatcher (cbdata->base,
-					fd,
-					BUFFER_LINE,
-					lua_io_read_cb,
-					lua_io_write_cb,
-					lua_io_err_cb,
-					NULL,
-					cbdata);
+			io_dispatcher = rspamd_create_dispatcher (cbdata->base, fd, BUFFER_LINE, lua_io_read_cb, lua_io_write_cb, lua_io_err_cb, NULL, cbdata);
 		}
 
 		cbdata->d = io_dispatcher;
 		/* Push result */
-		pdispatcher =
-			lua_newuserdata (L, sizeof (struct rspamd_io_dispatcher_s *));
+		pdispatcher = lua_newuserdata (L, sizeof (struct rspamd_io_dispatcher_s *));
 		lua_setclass (L, "rspamd{io_dispatcher}", -1);
 		*pdispatcher = io_dispatcher;
 	}
 	else {
-		msg_err ("invalid number of arguments to io_dispatcher.create: %d",
-			lua_gettop (L));
+		msg_err ("invalid number of arguments to io_dispatcher.create: %d", lua_gettop (L));
 		lua_pushnil (L);
 	}
 
@@ -239,8 +216,8 @@ lua_io_dispatcher_create (lua_State *L)
 static int
 lua_io_dispatcher_set_policy (lua_State *L)
 {
-	struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
-	gint policy, limit = -1;
+	struct rspamd_io_dispatcher_s					*io_dispatcher = lua_check_io_dispatcher (L);
+	gint											 policy, limit = -1;
 
 	if (io_dispatcher) {
 		policy = lua_tonumber (L, 2);
@@ -265,15 +242,14 @@ lua_io_dispatcher_set_policy (lua_State *L)
 static int
 lua_io_dispatcher_write (lua_State *L)
 {
-	struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
-	gboolean delayed = FALSE, res;
-	const gchar *data;
-	size_t len;
+	struct rspamd_io_dispatcher_s					*io_dispatcher = lua_check_io_dispatcher (L);
+	gboolean										 delayed = FALSE, res;
+	const gchar										*data;
+	size_t											 len;
 
 	if (io_dispatcher) {
 		if (lua_gettop (L) < 2) {
-			msg_err ("invalid number of arguments to io_dispatcher.create: %d",
-				lua_gettop (L));
+			msg_err ("invalid number of arguments to io_dispatcher.create: %d", lua_gettop (L));
 			lua_pushboolean (L, FALSE);
 		}
 		else {
@@ -281,11 +257,7 @@ lua_io_dispatcher_write (lua_State *L)
 			if (lua_gettop (L) > 2) {
 				delayed = lua_toboolean (L, 3);
 			}
-			res = rspamd_dispatcher_write (io_dispatcher,
-					(void *)data,
-					len,
-					delayed,
-					FALSE);
+			res = rspamd_dispatcher_write (io_dispatcher, (void *)data, len, delayed, FALSE);
 			lua_pushboolean (L, res);
 		}
 	}
@@ -299,7 +271,7 @@ lua_io_dispatcher_write (lua_State *L)
 static int
 lua_io_dispatcher_pause (lua_State *L)
 {
-	struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
+	struct rspamd_io_dispatcher_s					*io_dispatcher = lua_check_io_dispatcher (L);
 
 	if (io_dispatcher) {
 		rspamd_dispatcher_pause (io_dispatcher);
@@ -315,7 +287,7 @@ lua_io_dispatcher_pause (lua_State *L)
 static int
 lua_io_dispatcher_restore (lua_State *L)
 {
-	struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
+	struct rspamd_io_dispatcher_s					*io_dispatcher = lua_check_io_dispatcher (L);
 
 	if (io_dispatcher) {
 		rspamd_dispatcher_restore (io_dispatcher);
@@ -331,7 +303,7 @@ lua_io_dispatcher_restore (lua_State *L)
 static int
 lua_io_dispatcher_destroy (lua_State *L)
 {
-	struct rspamd_io_dispatcher_s *io_dispatcher = lua_check_io_dispatcher (L);
+	struct rspamd_io_dispatcher_s					*io_dispatcher = lua_check_io_dispatcher (L);
 
 	if (io_dispatcher) {
 		rspamd_remove_dispatcher (io_dispatcher);
@@ -357,16 +329,16 @@ luaopen_io_dispatcher (lua_State * L)
 	lua_pushstring (L, "rspamd{io_dispatcher}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,					  io_dispatcherlib_m);
+	luaL_register (L, NULL, io_dispatcherlib_m);
 	luaL_register (L, "rspamd_io_dispatcher", io_dispatcherlib_f);
 
-	lua_pop (L, 1);                      /* remove metatable from stack */
+	lua_pop(L, 1);                      /* remove metatable from stack */
 
 	/* Simple event class */
 	lua_newclass (L, "rspamd{ev_base}", null_reg);
 	luaL_register (L, "rspamd_ev_base", null_reg);
 
-	lua_pop (L, 1);                      /* remove metatable from stack */
+	lua_pop(L, 1);                      /* remove metatable from stack */
 
 	/* Set buffer types globals */
 	lua_pushnumber (L, BUFFER_LINE);
@@ -375,5 +347,5 @@ luaopen_io_dispatcher (lua_State * L)
 	lua_setglobal (L, "IO_BUFFER_CHARACTER");
 	lua_pushnumber (L, BUFFER_ANY);
 	lua_setglobal (L, "IO_BUFFER_ANY");
-	return 1;
+	return 1;	
 }
diff --git a/src/lua/lua_cdb.c b/src/lua/lua_cdb.c
index 12ef7f501..6832dfe59 100644
--- a/src/lua/lua_cdb.c
+++ b/src/lua/lua_cdb.c
@@ -21,8 +21,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cdb/cdb.h"
 #include "lua_common.h"
+#include "cdb/cdb.h"
 
 #define CDB_REFRESH_TIME 60
 
@@ -31,22 +31,22 @@ LUA_FUNCTION_DEF (cdb, lookup);
 LUA_FUNCTION_DEF (cdb, get_name);
 LUA_FUNCTION_DEF (cdb, destroy);
 
-static const struct luaL_reg cdblib_m[] = {
+static const struct luaL_reg    cdblib_m[] = {
 	LUA_INTERFACE_DEF (cdb, lookup),
 	LUA_INTERFACE_DEF (cdb, get_name),
 	{"__tostring", lua_class_tostring},
 	{"__gc", lua_cdb_destroy},
 	{NULL, NULL}
 };
-static const struct luaL_reg cdblib_f[] = {
+static const struct luaL_reg    cdblib_f[] = {
 	LUA_INTERFACE_DEF (cdb, create),
 	{NULL, NULL}
 };
 
-static struct cdb *
+static struct cdb	*
 lua_check_cdb (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{cdb}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{cdb}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'cdb' expected");
 	return ud ? *((struct cdb **)ud) : NULL;
@@ -55,9 +55,9 @@ lua_check_cdb (lua_State * L)
 static gint
 lua_cdb_create (lua_State *L)
 {
-	struct cdb *cdb, **pcdb;
-	const gchar *filename;
-	gint fd;
+	struct cdb                     *cdb, **pcdb;
+	const gchar                    *filename;
+	gint                            fd;
 
 	filename = luaL_checkstring (L, 1);
 	/* If file begins with cdb://, just skip it */
@@ -79,7 +79,7 @@ lua_cdb_create (lua_State *L)
 			lua_pushnil (L);
 		}
 		else {
-			pcdb = lua_newuserdata (L, sizeof (struct cdb *));
+			pcdb = lua_newuserdata (L, sizeof (struct cdb*));
 			lua_setclass (L, "rspamd{cdb}", -1);
 			*pcdb = cdb;
 		}
@@ -91,7 +91,7 @@ lua_cdb_create (lua_State *L)
 static gint
 lua_cdb_get_name (lua_State *L)
 {
-	struct cdb *cdb = lua_check_cdb (L);
+	struct cdb                     *cdb = lua_check_cdb (L);
 
 	lua_pushstring (L, cdb->filename);
 	return 1;
@@ -100,11 +100,11 @@ lua_cdb_get_name (lua_State *L)
 static gint
 lua_cdb_lookup (lua_State *L)
 {
-	struct cdb *cdb = lua_check_cdb (L);
-	const gchar *what;
-	gchar *value;
-	gsize vlen;
-	gint64 vpos;
+	struct cdb                     *cdb = lua_check_cdb (L);
+	const gchar                    *what;
+	gchar                          *value;
+	gsize                           vlen;
+	gint64                          vpos;
 
 	/*
 	 * XXX: this code is placed here because event_loop is called inside workers, so start
@@ -134,7 +134,7 @@ lua_cdb_lookup (lua_State *L)
 static gint
 lua_cdb_destroy (lua_State *L)
 {
-	struct cdb *cdb = lua_check_cdb (L);
+	struct cdb                     *cdb = lua_check_cdb (L);
 
 	if (cdb) {
 		cdb_free (cdb);
@@ -158,7 +158,7 @@ luaopen_cdb (lua_State * L)
 	lua_pushstring (L, "rspamd{cdb}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,	 cdblib_m);
+	luaL_register (L, NULL, cdblib_m);
 	luaL_register (L, "cdb", cdblib_f);
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
diff --git a/src/lua/lua_cfg_file.c b/src/lua/lua_cfg_file.c
index 08c14a825..83ac4545c 100644
--- a/src/lua/lua_cfg_file.c
+++ b/src/lua/lua_cfg_file.c
@@ -22,26 +22,26 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "expressions.h"
 #include "lua_common.h"
+#include "expressions.h"
 #include "symbols_cache.h"
 #ifdef HAVE_SYS_UTSNAME_H
 #include <sys/utsname.h>
 #endif
 
-/*
- * This is implementation of lua routines to handle config file params
+/* 
+ * This is implementation of lua routines to handle config file params 
  */
 
 /* Process a single item in 'metrics' table */
 static void
 lua_process_metric (lua_State *L, const gchar *name, struct rspamd_config *cfg)
 {
-	GList *metric_list;
-	gchar *symbol, *old_desc;
-	const gchar *desc;
-	struct metric *metric;
-	gdouble *score, *old_score;
+	GList                               *metric_list;
+	gchar                               *symbol, *old_desc;
+	const gchar                         *desc;
+	struct metric                       *metric;
+	gdouble                             *score, *old_score;
 
 	/* Get module opt structure */
 	if ((metric = g_hash_table_lookup (cfg->metrics, name)) == NULL) {
@@ -50,18 +50,16 @@ lua_process_metric (lua_State *L, const gchar *name, struct rspamd_config *cfg)
 	}
 
 	/* Now iterate throught module table */
-	for (lua_pushnil (L); lua_next (L, -2); lua_pop (L, 1)) {
+	for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
 		/* key - -2, value - -1 */
-		symbol =
-			rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, -2));
+		symbol = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, -2));
 		if (symbol != NULL) {
 			if (lua_istable (L, -1)) {
 				/* We got a table, so extract individual attributes */
 				lua_pushstring (L, "weight");
 				lua_gettable (L, -2);
 				if (lua_isnumber (L, -1)) {
-					score =
-						rspamd_mempool_alloc (cfg->cfg_pool, sizeof (double));
+					score = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (double));
 					*score = lua_tonumber (L, -1);
 				}
 				else {
@@ -73,19 +71,15 @@ lua_process_metric (lua_State *L, const gchar *name, struct rspamd_config *cfg)
 				lua_gettable (L, -2);
 				if (lua_isstring (L, -1)) {
 					desc = lua_tostring (L, -1);
-					old_desc =
-						g_hash_table_lookup (metric->descriptions, symbol);
+					old_desc = g_hash_table_lookup (metric->descriptions, symbol);
 					if (old_desc) {
-						msg_info ("replacing description for symbol %s",
-							symbol);
+						msg_info ("replacing description for symbol %s", symbol);
 						g_hash_table_replace (metric->descriptions,
-							symbol,
-							rspamd_mempool_strdup (cfg->cfg_pool, desc));
+							symbol, rspamd_mempool_strdup (cfg->cfg_pool, desc));
 					}
 					else {
 						g_hash_table_insert (metric->descriptions,
-							symbol,
-							rspamd_mempool_strdup (cfg->cfg_pool, desc));
+							symbol, rspamd_mempool_strdup (cfg->cfg_pool, desc));
 					}
 				}
 				lua_pop (L, 1);
@@ -100,23 +94,17 @@ lua_process_metric (lua_State *L, const gchar *name, struct rspamd_config *cfg)
 				continue;
 			}
 			/* Insert symbol */
-			if ((old_score =
-				g_hash_table_lookup (metric->symbols, symbol)) != NULL) {
-				msg_info ("replacing weight for symbol %s: %.2f -> %.2f",
-					symbol,
-					*old_score,
-					*score);
+			if ((old_score = g_hash_table_lookup (metric->symbols, symbol)) != NULL) {
+				msg_info ("replacing weight for symbol %s: %.2f -> %.2f", symbol, *old_score, *score);
 				g_hash_table_replace (metric->symbols, symbol, score);
 			}
 			else {
 				g_hash_table_insert (metric->symbols, symbol, score);
 			}
 
-			if ((metric_list =
-				g_hash_table_lookup (cfg->metrics_symbols, symbol)) == NULL) {
+			if ((metric_list = g_hash_table_lookup (cfg->metrics_symbols, symbol)) == NULL) {
 				metric_list = g_list_prepend (NULL, metric);
-				rspamd_mempool_add_destructor (cfg->cfg_pool,
-					(rspamd_mempool_destruct_t)g_list_free, metric_list);
+				rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_list_free, metric_list);
 				g_hash_table_insert (cfg->metrics_symbols, symbol, metric_list);
 			}
 			else {
@@ -133,30 +121,26 @@ lua_process_metric (lua_State *L, const gchar *name, struct rspamd_config *cfg)
 void
 lua_post_load_config (struct rspamd_config *cfg)
 {
-	lua_State *L = cfg->lua_state;
-	const gchar *name, *val;
-	gchar *sym;
-	struct expression *expr, *old_expr;
-	ucl_object_t *obj;
-	gsize keylen;
+	lua_State                            *L = cfg->lua_state;
+	const gchar                          *name, *val;
+	gchar                                *sym;
+	struct expression                    *expr, *old_expr;
+	ucl_object_t                   *obj;
+	gsize                                 keylen;
 
 	/* First check all module options that may be overriden in 'config' global */
 	lua_getglobal (L, "config");
 
 	if (lua_istable (L, -1)) {
 		/* Iterate */
-		for (lua_pushnil (L); lua_next (L, -2); lua_pop (L, 1)) {
+		for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
 			/* 'key' is at index -2 and 'value' is at index -1 */
 			/* Key must be a string and value must be a table */
 			name = luaL_checklstring (L, -2, &keylen);
 			if (name != NULL && lua_istable (L, -1)) {
 				obj = ucl_object_lua_import (L, lua_gettop (L));
 				if (obj != NULL) {
-					ucl_object_insert_key_merged (cfg->rcl_obj,
-						obj,
-						name,
-						keylen,
-						true);
+					ucl_object_insert_key_merged (cfg->rcl_obj, obj, name, keylen, true);
 				}
 			}
 		}
@@ -167,7 +151,7 @@ lua_post_load_config (struct rspamd_config *cfg)
 
 	if (lua_istable (L, -1)) {
 		/* Iterate */
-		for (lua_pushnil (L); lua_next (L, -2); lua_pop (L, 1)) {
+		for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
 			/* 'key' is at index -2 and 'value' is at index -1 */
 			/* Key must be a string and value must be a table */
 			name = luaL_checkstring (L, -2);
@@ -182,23 +166,19 @@ lua_post_load_config (struct rspamd_config *cfg)
 
 	if (lua_istable (L, -1)) {
 		/* Iterate */
-		for (lua_pushnil (L); lua_next (L, -2); lua_pop (L, 1)) {
+		for (lua_pushnil(L); lua_next(L, -2); lua_pop(L, 1)) {
 			/* 'key' is at index -2 and 'value' is at index -1 */
 			/* Key must be a string and value must be a table */
 			name = luaL_checkstring (L, -2);
 			if (name != NULL && lua_isstring (L, -1)) {
 				val = lua_tostring (L, -1);
-				sym = rspamd_mempool_strdup (cfg->cfg_pool, name);
-				if ((expr =
-					parse_expression (cfg->cfg_pool,
-					rspamd_mempool_strdup (cfg->cfg_pool, val))) == NULL) {
+				sym = rspamd_mempool_strdup(cfg->cfg_pool, name);
+				if ((expr = parse_expression (cfg->cfg_pool, rspamd_mempool_strdup(cfg->cfg_pool, val))) == NULL) {
 					msg_err ("cannot parse composite expression: %s", val);
 					continue;
 				}
 				/* Now check hash table for this composite */
-				if ((old_expr =
-					g_hash_table_lookup (cfg->composite_symbols,
-					name)) != NULL) {
+				if ((old_expr = g_hash_table_lookup (cfg->composite_symbols, name)) != NULL) {
 					msg_info ("replacing composite symbol %s", name);
 					g_hash_table_replace (cfg->composite_symbols, sym, expr);
 				}
@@ -213,14 +193,10 @@ lua_post_load_config (struct rspamd_config *cfg)
 
 /* Handle lua dynamic config param */
 gboolean
-lua_handle_param (struct rspamd_task *task,
-	gchar *mname,
-	gchar *optname,
-	enum lua_var_type expected_type,
-	gpointer *res)
+lua_handle_param (struct rspamd_task *task, gchar *mname, gchar *optname, enum lua_var_type expected_type, gpointer *res)
 {
 	/* xxx: Adopt this for rcl */
-
+	
 	/* Option not found */
 	*res = NULL;
 	return FALSE;
@@ -230,12 +206,12 @@ lua_handle_param (struct rspamd_task *task,
 gboolean
 lua_check_condition (struct rspamd_config *cfg, const gchar *condition)
 {
-	lua_State *L = cfg->lua_state;
-	gchar *hostbuf, *condbuf;
-	gsize hostlen;
-	gboolean res;
+	lua_State                            *L = cfg->lua_state;
+	gchar                                *hostbuf, *condbuf;
+	gsize                                 hostlen;
+	gboolean                              res;
 #ifdef HAVE_SYS_UTSNAME_H
-	struct utsname uts;
+	struct utsname                        uts;
 #endif
 
 	/* Set some globals for condition */
@@ -274,12 +250,12 @@ lua_check_condition (struct rspamd_config *cfg, const gchar *condition)
 
 	/* Rspamd paths */
 	lua_newtable (L);
-	lua_set_table_index (L, "confdir",	  RSPAMD_CONFDIR);
-	lua_set_table_index (L, "rundir",	  RSPAMD_RUNDIR);
-	lua_set_table_index (L, "dbdir",	  RSPAMD_DBDIR);
-	lua_set_table_index (L, "logdir",	  RSPAMD_LOGDIR);
+	lua_set_table_index (L, "confdir", RSPAMD_CONFDIR);
+	lua_set_table_index (L, "rundir", RSPAMD_RUNDIR);
+	lua_set_table_index (L, "dbdir", RSPAMD_DBDIR);
+	lua_set_table_index (L, "logdir", RSPAMD_LOGDIR);
 	lua_set_table_index (L, "pluginsdir", RSPAMD_PLUGINSDIR);
-	lua_set_table_index (L, "prefix",	  RSPAMD_PREFIX);
+	lua_set_table_index (L, "prefix", RSPAMD_PREFIX);
 	lua_setglobal (L, "rspamd_paths");
 
 	/* Make fake string */
@@ -295,11 +271,10 @@ lua_check_condition (struct rspamd_config *cfg, const gchar *condition)
 	}
 	/* Get global variable res to get result */
 	lua_getglobal (L, FAKE_RES_VAR);
-	if (!lua_isboolean (L, -1)) {
-		msg_err ("bad string evaluated: %s, type: %s", condbuf,
-			lua_typename (L, lua_type (L, -1)));
+	if (! lua_isboolean (L, -1)) {
+		msg_err ("bad string evaluated: %s, type: %s", condbuf, lua_typename (L, lua_type (L, -1)));
 		g_free (condbuf);
-		return FALSE;
+			return FALSE;
 	}
 
 	res = lua_toboolean (L, -1);
diff --git a/src/lua/lua_classifier.c b/src/lua/lua_classifier.c
index f1eade146..d227fc5da 100644
--- a/src/lua/lua_classifier.c
+++ b/src/lua/lua_classifier.c
@@ -23,9 +23,9 @@
  */
 
 
+#include "lua_common.h"
 #include "cfg_file.h"
 #include "classifiers/classifiers.h"
-#include "lua_common.h"
 
 /* Classifier methods */
 LUA_FUNCTION_DEF (classifier, register_pre_callback);
@@ -33,7 +33,7 @@ LUA_FUNCTION_DEF (classifier, register_post_callback);
 LUA_FUNCTION_DEF (classifier, get_statfiles);
 LUA_FUNCTION_DEF (classifier, get_statfile_by_label);
 
-static const struct luaL_reg classifierlib_m[] = {
+static const struct luaL_reg    classifierlib_m[] = {
 	LUA_INTERFACE_DEF (classifier, register_pre_callback),
 	LUA_INTERFACE_DEF (classifier, register_post_callback),
 	LUA_INTERFACE_DEF (classifier, get_statfiles),
@@ -50,7 +50,7 @@ LUA_FUNCTION_DEF (statfile, get_size);
 LUA_FUNCTION_DEF (statfile, is_spam);
 LUA_FUNCTION_DEF (statfile, get_param);
 
-static const struct luaL_reg statfilelib_m[] = {
+static const struct luaL_reg    statfilelib_m[] = {
 	LUA_INTERFACE_DEF (statfile, get_symbol),
 	LUA_INTERFACE_DEF (statfile, get_label),
 	LUA_INTERFACE_DEF (statfile, get_path),
@@ -66,30 +66,27 @@ struct classifier_callback_data {
 	const gchar *name;
 };
 
-static struct rspamd_statfile_config * lua_check_statfile (lua_State * L);
+static struct rspamd_statfile_config* lua_check_statfile (lua_State * L);
 
 /* Classifier implementation */
 
 
-static struct rspamd_classifier_config *
+static struct rspamd_classifier_config      *
 lua_check_classifier (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{classifier}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{classifier}");
 	luaL_argcheck (L, ud != NULL, 1, "'classifier' expected");
 	return ud ? *((struct rspamd_classifier_config **)ud) : NULL;
 }
 
 static GList *
-call_classifier_pre_callback (struct rspamd_classifier_config *ccf,
-	struct rspamd_task *task,
-	lua_State *L,
-	gboolean is_learn,
-	gboolean is_spam)
+call_classifier_pre_callback (struct rspamd_classifier_config *ccf, struct rspamd_task *task,
+		lua_State *L, gboolean is_learn, gboolean is_spam)
 {
-	struct rspamd_classifier_config **pccf;
-	struct rspamd_task **ptask;
-	struct rspamd_statfile_config **pst;
-	GList *res = NULL;
+	struct rspamd_classifier_config      **pccf;
+	struct rspamd_task            **ptask;
+	struct rspamd_statfile_config               **pst;
+	GList                          *res = NULL;
 
 	pccf = lua_newuserdata (L, sizeof (struct rspamd_classifier_config *));
 	lua_setclass (L, "rspamd{classifier}", -1);
@@ -103,13 +100,12 @@ call_classifier_pre_callback (struct rspamd_classifier_config *ccf,
 	lua_pushboolean (L, is_spam);
 
 	if (lua_pcall (L, 4, 1, 0) != 0) {
-		msg_warn ("error running pre classifier callback %s",
-			lua_tostring (L, -1));
+		msg_warn ("error running pre classifier callback %s", lua_tostring (L, -1));
 	}
 	else {
 		if (lua_istable (L, -1)) {
 			lua_pushnil (L);
-			while (lua_next (L, -2)) {
+			while(lua_next (L, -2)) {
 				pst = luaL_checkudata (L, -1, "rspamd{statfile}");
 				if (pst) {
 					res = g_list_prepend (res, *pst);
@@ -124,13 +120,10 @@ call_classifier_pre_callback (struct rspamd_classifier_config *ccf,
 
 /* Return list of statfiles that should be checked for this message */
 GList *
-call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf,
-	struct rspamd_task *task,
-	gboolean is_learn,
-	gboolean is_spam,
-	lua_State *L)
+call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf, struct rspamd_task *task,
+		gboolean is_learn, gboolean is_spam, lua_State *L)
 {
-	GList *res = NULL, *cur;
+	GList                           *res = NULL, *cur;
 	struct classifier_callback_data *cd;
 
 
@@ -140,9 +133,7 @@ call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf,
 		cd = cur->data;
 		lua_getglobal (L, cd->name);
 
-		res =
-			g_list_concat (res,
-				call_classifier_pre_callback (ccf, task, L, is_learn, is_spam));
+		res = g_list_concat (res, call_classifier_pre_callback (ccf, task, L, is_learn, is_spam));
 
 		cur = g_list_next (cur);
 	}
@@ -155,11 +146,7 @@ call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf,
 			lua_gettable (L, -2);
 			/* Function is now on top */
 			if (lua_isfunction (L, -1)) {
-				res = call_classifier_pre_callback (ccf,
-						task,
-						L,
-						is_learn,
-						is_spam);
+				res = call_classifier_pre_callback (ccf, task, L, is_learn, is_spam);
 			}
 			lua_pop (L, 1);
 		}
@@ -171,16 +158,13 @@ call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf,
 
 /* Return result mark for statfile */
 double
-call_classifier_post_callbacks (struct rspamd_classifier_config *ccf,
-	struct rspamd_task *task,
-	double in,
-	lua_State *L)
+call_classifier_post_callbacks (struct rspamd_classifier_config *ccf, struct rspamd_task *task, double in, lua_State *L)
 {
 	struct classifier_callback_data *cd;
-	struct rspamd_classifier_config **pccf;
-	struct rspamd_task **ptask;
-	double out = in;
-	GList *cur;
+	struct rspamd_classifier_config      **pccf;
+	struct rspamd_task            **ptask;
+	double                          out = in;
+	GList                          *cur;
 
 	/* Go throught all callbacks and call them, appending results to list */
 	cur = g_list_first (ccf->pre_callbacks);
@@ -199,8 +183,7 @@ call_classifier_post_callbacks (struct rspamd_classifier_config *ccf,
 		lua_pushnumber (L, out);
 
 		if (lua_pcall (L, 3, 1, 0) != 0) {
-			msg_warn ("error running function %s: %s", cd->name,
-				lua_tostring (L, -1));
+			msg_warn ("error running function %s: %s", cd->name, lua_tostring (L, -1));
 		}
 		else {
 			if (lua_isnumber (L, 1)) {
@@ -219,9 +202,9 @@ call_classifier_post_callbacks (struct rspamd_classifier_config *ccf,
 static gint
 lua_classifier_register_pre_callback (lua_State *L)
 {
-	struct rspamd_classifier_config *ccf = lua_check_classifier (L);
+	struct rspamd_classifier_config       *ccf = lua_check_classifier (L);
 	struct classifier_callback_data *cd;
-	const gchar *name;
+	const gchar                     *name;
 
 	if (ccf) {
 		name = luaL_checkstring (L, 2);
@@ -240,9 +223,9 @@ lua_classifier_register_pre_callback (lua_State *L)
 static gint
 lua_classifier_register_post_callback (lua_State *L)
 {
-	struct rspamd_classifier_config *ccf = lua_check_classifier (L);
+	struct rspamd_classifier_config       *ccf = lua_check_classifier (L);
 	struct classifier_callback_data *cd;
-	const gchar *name;
+	const gchar                     *name;
 
 	if (ccf) {
 		name = luaL_checkstring (L, 2);
@@ -261,10 +244,10 @@ lua_classifier_register_post_callback (lua_State *L)
 static gint
 lua_classifier_get_statfiles (lua_State *L)
 {
-	struct rspamd_classifier_config *ccf = lua_check_classifier (L);
-	GList *cur;
-	struct rspamd_statfile_config *st, **pst;
-	gint i;
+	struct rspamd_classifier_config       *ccf = lua_check_classifier (L);
+	GList                          *cur;
+	struct rspamd_statfile_config                *st, **pst;
+	gint							i;
 
 	if (ccf) {
 		lua_newtable (L);
@@ -291,11 +274,11 @@ lua_classifier_get_statfiles (lua_State *L)
 static gint
 lua_classifier_get_statfile_by_label (lua_State *L)
 {
-	struct rspamd_classifier_config *ccf = lua_check_classifier (L);
-	struct rspamd_statfile_config *st, **pst;
-	const gchar *label;
-	GList *cur;
-	gint i;
+	struct rspamd_classifier_config       *ccf = lua_check_classifier (L);
+	struct rspamd_statfile_config                *st, **pst;
+	const gchar					   *label;
+	GList						   *cur;
+	gint							i;
 
 	label = luaL_checkstring (L, 2);
 	if (ccf && label) {
@@ -305,9 +288,7 @@ lua_classifier_get_statfile_by_label (lua_State *L)
 			i = 1;
 			while (cur) {
 				st = cur->data;
-				pst =
-					lua_newuserdata (L,
-						sizeof (struct rspamd_statfile_config *));
+				pst = lua_newuserdata (L, sizeof (struct rspamd_statfile_config *));
 				lua_setclass (L, "rspamd{statfile}", -1);
 				*pst = st;
 				lua_rawseti (L, -2, i++);
@@ -324,7 +305,7 @@ lua_classifier_get_statfile_by_label (lua_State *L)
 static gint
 lua_statfile_get_symbol (lua_State *L)
 {
-	struct rspamd_statfile_config *st = lua_check_statfile (L);
+	struct rspamd_statfile_config                *st = lua_check_statfile (L);
 
 	if (st != NULL) {
 		lua_pushstring (L, st->symbol);
@@ -339,7 +320,7 @@ lua_statfile_get_symbol (lua_State *L)
 static gint
 lua_statfile_get_label (lua_State *L)
 {
-	struct rspamd_statfile_config *st = lua_check_statfile (L);
+	struct rspamd_statfile_config                *st = lua_check_statfile (L);
 
 	if (st != NULL && st->label != NULL) {
 		lua_pushstring (L, st->label);
@@ -354,7 +335,7 @@ lua_statfile_get_label (lua_State *L)
 static gint
 lua_statfile_get_path (lua_State *L)
 {
-	struct rspamd_statfile_config *st = lua_check_statfile (L);
+	struct rspamd_statfile_config                *st = lua_check_statfile (L);
 
 	if (st != NULL) {
 		lua_pushstring (L, st->path);
@@ -369,7 +350,7 @@ lua_statfile_get_path (lua_State *L)
 static gint
 lua_statfile_get_size (lua_State *L)
 {
-	struct rspamd_statfile_config *st = lua_check_statfile (L);
+	struct rspamd_statfile_config                *st = lua_check_statfile (L);
 
 	if (st != NULL) {
 		lua_pushinteger (L, st->size);
@@ -384,7 +365,7 @@ lua_statfile_get_size (lua_State *L)
 static gint
 lua_statfile_is_spam (lua_State *L)
 {
-	struct rspamd_statfile_config *st = lua_check_statfile (L);
+	struct rspamd_statfile_config                *st = lua_check_statfile (L);
 
 	if (st != NULL) {
 		lua_pushboolean (L, st->is_spam);
@@ -399,9 +380,9 @@ lua_statfile_is_spam (lua_State *L)
 static gint
 lua_statfile_get_param (lua_State *L)
 {
-	struct rspamd_statfile_config *st = lua_check_statfile (L);
-	const gchar *param;
-	const ucl_object_t *value;
+	struct rspamd_statfile_config                *st = lua_check_statfile (L);
+	const gchar                    *param;
+	const ucl_object_t                    *value;
 
 	param = luaL_checkstring (L, 2);
 
@@ -417,10 +398,10 @@ lua_statfile_get_param (lua_State *L)
 	return 1;
 }
 
-static struct rspamd_statfile_config *
+static struct rspamd_statfile_config      *
 lua_check_statfile (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{statfile}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{statfile}");
 	luaL_argcheck (L, ud != NULL, 1, "'statfile' expected");
 	return ud ? *((struct rspamd_statfile_config **)ud) : NULL;
 }
diff --git a/src/lua/lua_common.c b/src/lua/lua_common.c
index cb2730231..ea1e43010 100644
--- a/src/lua/lua_common.c
+++ b/src/lua/lua_common.c
@@ -22,13 +22,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "expressions.h"
 #include "lua_common.h"
+#include "expressions.h"
 
 /* Lua module init function */
 #define MODULE_INIT_FUNC "module_init"
 
-const luaL_reg null_reg[] = {
+const luaL_reg                  null_reg[] = {
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
 };
@@ -39,7 +39,7 @@ LUA_FUNCTION_DEF (logger, warn);
 LUA_FUNCTION_DEF (logger, info);
 LUA_FUNCTION_DEF (logger, debug);
 
-static const struct luaL_reg loggerlib_f[] = {
+static const struct luaL_reg    loggerlib_f[] = {
 	LUA_INTERFACE_DEF (logger, err),
 	LUA_INTERFACE_DEF (logger, warn),
 	LUA_INTERFACE_DEF (logger, info),
@@ -57,18 +57,16 @@ static const struct luaL_reg loggerlib_f[] = {
  * @param func table of class methods
  */
 void
-lua_newclass (lua_State * L,
-	const gchar *classname,
-	const struct luaL_reg *methods)
+lua_newclass (lua_State * L, const gchar *classname, const struct luaL_reg *methods)
 {
-	luaL_newmetatable (L, classname);   /* mt */
+	luaL_newmetatable (L, classname);	/* mt */
 	lua_pushstring (L, "__index");
-	lua_pushvalue (L, -2);      /* pushes the metatable */
-	lua_settable (L, -3);       /* metatable.__index = metatable */
+	lua_pushvalue (L, -2);		/* pushes the metatable */
+	lua_settable (L, -3);		/* metatable.__index = metatable */
 
-	lua_pushstring (L, "class");    /* mt,"__index",it,"class" */
-	lua_pushstring (L, classname);  /* mt,"__index",it,"class",classname */
-	lua_rawset (L, -3);         /* mt,"__index",it */
+	lua_pushstring (L, "class");	/* mt,"__index",it,"class" */
+	lua_pushstring (L, classname);	/* mt,"__index",it,"class",classname */
+	lua_rawset (L, -3);			/* mt,"__index",it */
 	luaL_register (L, NULL, methods);
 }
 
@@ -76,11 +74,7 @@ lua_newclass (lua_State * L,
  * Create and register new class with static methods and store metatable on top of the stack
  */
 void
-lua_newclass_full (lua_State *L,
-	const gchar *classname,
-	const gchar *static_name,
-	const struct luaL_reg *methods,
-	const struct luaL_reg *func)
+lua_newclass_full (lua_State *L, const gchar *classname, const gchar *static_name, const struct luaL_reg *methods, const struct luaL_reg *func)
 {
 	lua_newclass (L, classname, methods);
 	luaL_register (L, static_name, func);
@@ -89,7 +83,7 @@ lua_newclass_full (lua_State *L,
 gint
 lua_class_tostring (lua_State * L)
 {
-	gchar buf[32];
+	gchar                           buf[32];
 
 	if (!lua_getmetatable (L, 1)) {
 		goto error;
@@ -113,7 +107,7 @@ lua_class_tostring (lua_State * L)
 
 	return 1;
 
-error:
+  error:
 	lua_pushstring (L, "invalid object passed to 'lua_common.c:__tostring'");
 	lua_error (L);
 	return 1;
@@ -163,48 +157,31 @@ lua_get_table_index_str (lua_State *L, const gchar *index)
 static void
 lua_common_log (GLogLevelFlags level, lua_State *L, const gchar *msg)
 {
-	lua_Debug d;
-	gchar func_buf[128], *p;
+	lua_Debug                      d;
+	gchar                           func_buf[128], *p;
 
 	if (lua_getstack (L, 1, &d) == 1) {
-		(void)lua_getinfo (L, "Sl", &d);
+		(void)lua_getinfo(L, "Sl", &d);
 		if ((p = strrchr (d.short_src, '/')) == NULL) {
 			p = d.short_src;
 		}
 		else {
-			p++;
+			p ++;
 		}
-		rspamd_snprintf (func_buf, sizeof (func_buf), "%s:%d", p,
-			d.currentline);
+		rspamd_snprintf (func_buf, sizeof (func_buf), "%s:%d", p, d.currentline);
 		if (level == G_LOG_LEVEL_DEBUG) {
-			rspamd_conditional_debug (rspamd_main->logger,
-				NULL,
-				func_buf,
-				"%s",
-				msg);
+			rspamd_conditional_debug (rspamd_main->logger, NULL, func_buf, "%s", msg);
 		}
 		else {
-			rspamd_common_log_function (rspamd_main->logger,
-				level,
-				func_buf,
-				"%s",
-				msg);
+			rspamd_common_log_function (rspamd_main->logger, level, func_buf, "%s", msg);
 		}
 	}
 	else {
 		if (level == G_LOG_LEVEL_DEBUG) {
-			rspamd_conditional_debug (rspamd_main->logger,
-				NULL,
-				__FUNCTION__,
-				"%s",
-				msg);
+			rspamd_conditional_debug (rspamd_main->logger, NULL, __FUNCTION__, "%s", msg);
 		}
 		else {
-			rspamd_common_log_function (rspamd_main->logger,
-				level,
-				__FUNCTION__,
-				"%s",
-				msg);
+			rspamd_common_log_function (rspamd_main->logger, level, __FUNCTION__, "%s", msg);
 		}
 	}
 }
@@ -213,7 +190,7 @@ lua_common_log (GLogLevelFlags level, lua_State *L, const gchar *msg)
 static gint
 lua_logger_err (lua_State * L)
 {
-	const gchar *msg;
+	const gchar                     *msg;
 	msg = luaL_checkstring (L, 1);
 	lua_common_log (G_LOG_LEVEL_CRITICAL, L, msg);
 	return 1;
@@ -222,7 +199,7 @@ lua_logger_err (lua_State * L)
 static gint
 lua_logger_warn (lua_State * L)
 {
-	const gchar *msg;
+	const gchar                     *msg;
 	msg = luaL_checkstring (L, 1);
 	lua_common_log (G_LOG_LEVEL_WARNING, L, msg);
 	return 1;
@@ -231,7 +208,7 @@ lua_logger_warn (lua_State * L)
 static gint
 lua_logger_info (lua_State * L)
 {
-	const gchar *msg;
+	const gchar                     *msg;
 	msg = luaL_checkstring (L, 1);
 	lua_common_log (G_LOG_LEVEL_INFO, L, msg);
 	return 1;
@@ -240,7 +217,7 @@ lua_logger_info (lua_State * L)
 static gint
 lua_logger_debug (lua_State * L)
 {
-	const gchar *msg;
+	const gchar                     *msg;
 	msg = luaL_checkstring (L, 1);
 	lua_common_log (G_LOG_LEVEL_DEBUG, L, msg);
 	return 1;
@@ -273,11 +250,11 @@ luaopen_logger (lua_State * L)
 static void
 lua_add_actions_global (lua_State *L)
 {
-	gint i;
+	gint							i;
 
 	lua_newtable (L);
 
-	for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
+	for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i ++) {
 		lua_pushstring (L, str_action_metric (i));
 		lua_pushinteger (L, i);
 		lua_settable (L, -3);
@@ -289,7 +266,7 @@ lua_add_actions_global (lua_State *L)
 lua_State *
 init_lua (struct rspamd_config *cfg)
 {
-	lua_State *L;
+	lua_State                      *L;
 
 	L = luaL_newstate ();
 	luaL_openlibs (L);
@@ -329,10 +306,10 @@ init_lua (struct rspamd_config *cfg)
 /**
  * Initialize new locked lua_State structure
  */
-struct lua_locked_state *
+struct lua_locked_state*
 init_lua_locked (struct rspamd_config *cfg)
 {
-	struct lua_locked_state *new;
+	struct lua_locked_state			*new;
 
 	new = g_slice_alloc (sizeof (struct lua_locked_state));
 	new->L = init_lua (cfg);
@@ -360,19 +337,18 @@ free_lua_locked (struct lua_locked_state *st)
 gboolean
 init_lua_filters (struct rspamd_config *cfg)
 {
-	struct rspamd_config **pcfg;
-	GList *cur, *tmp;
-	struct script_module *module;
-	struct rspamd_statfile_config *st;
-	lua_State *L = cfg->lua_state;
+	struct rspamd_config            **pcfg;
+	GList                          *cur, *tmp;
+	struct script_module           *module;
+    struct rspamd_statfile_config                *st;
+	lua_State                      *L = cfg->lua_state;
 
 	cur = g_list_first (cfg->script_modules);
 	while (cur) {
 		module = cur->data;
 		if (module->path) {
 			if (luaL_loadfile (L, module->path) != 0) {
-				msg_info ("load of %s failed: %s", module->path,
-					lua_tostring (L, -1));
+				msg_info ("load of %s failed: %s", module->path, lua_tostring (L, -1));
 				cur = g_list_next (cur);
 				return FALSE;
 			}
@@ -385,15 +361,12 @@ init_lua_filters (struct rspamd_config *cfg)
 
 			/* do the call (0 arguments, N result) */
 			if (lua_pcall (L, 0, LUA_MULTRET, 0) != 0) {
-				msg_info ("init of %s failed: %s", module->path,
-					lua_tostring (L, -1));
+				msg_info ("init of %s failed: %s", module->path, lua_tostring (L, -1));
 				return FALSE;
 			}
 			if (lua_gettop (L) != 0) {
 				if (lua_tonumber (L, -1) == -1) {
-					msg_info (
-						"%s returned -1 that indicates configuration error",
-						module->path);
+					msg_info ("%s returned -1 that indicates configuration error", module->path);
 					return FALSE;
 				}
 				lua_pop (L, lua_gettop (L));
@@ -401,24 +374,24 @@ init_lua_filters (struct rspamd_config *cfg)
 		}
 		cur = g_list_next (cur);
 	}
-	/* Init statfiles normalizers */
-	cur = g_list_first (cfg->statfiles);
-	while (cur) {
-		st = cur->data;
-		if (st->normalizer == lua_normalizer_func) {
-			tmp = st->normalizer_data;
-			if (tmp && (tmp = g_list_next (tmp))) {
-				if (tmp->data) {
-					/* Code must be loaded from data */
-					if (luaL_loadstring (L, tmp->data) != 0) {
-						msg_info ("cannot load normalizer code %s", tmp->data);
-						return FALSE;
-					}
-				}
-			}
-		}
-		cur = g_list_next (cur);
-	}
+    /* Init statfiles normalizers */
+    cur = g_list_first (cfg->statfiles);
+    while (cur) {
+        st = cur->data;
+        if (st->normalizer == lua_normalizer_func) {
+            tmp = st->normalizer_data;
+            if (tmp && (tmp = g_list_next (tmp))) {
+                if (tmp->data) {
+                    /* Code must be loaded from data */
+                    if (luaL_loadstring (L, tmp->data) != 0) {
+                        msg_info ("cannot load normalizer code %s", tmp->data);
+                        return FALSE;
+                    }
+                }
+            }
+        }
+        cur = g_list_next (cur);
+    }
 	/* Assign state */
 	cfg->lua_state = L;
 
@@ -430,9 +403,9 @@ init_lua_filters (struct rspamd_config *cfg)
 gint
 lua_call_filter (const gchar *function, struct rspamd_task *task)
 {
-	gint result;
-	struct rspamd_task **ptask;
-	lua_State *L = task->cfg->lua_state;
+	gint                            result;
+	struct rspamd_task            **ptask;
+	lua_State                      *L = task->cfg->lua_state;
 
 	lua_getglobal (L, function);
 	ptask = lua_newuserdata (L, sizeof (struct rspamd_task *));
@@ -448,20 +421,17 @@ lua_call_filter (const gchar *function, struct rspamd_task *task)
 		msg_info ("function %s must return a number", function);
 	}
 	result = lua_tonumber (L, -1);
-	lua_pop (L, 1);             /* pop returned value */
+	lua_pop (L, 1);				/* pop returned value */
 
 	return result;
 }
 
 gint
-lua_call_chain_filter (const gchar *function,
-	struct rspamd_task *task,
-	gint *marks,
-	guint number)
+lua_call_chain_filter (const gchar *function, struct rspamd_task *task, gint *marks, guint number)
 {
-	gint result;
-	guint i;
-	lua_State *L = task->cfg->lua_state;
+	gint                            result;
+	guint                           i;
+	lua_State                      *L = task->cfg->lua_state;
 
 	lua_getglobal (L, function);
 
@@ -477,46 +447,46 @@ lua_call_chain_filter (const gchar *function,
 		msg_info ("function %s must return a number", function);
 	}
 	result = lua_tonumber (L, -1);
-	lua_pop (L, 1);             /* pop returned value */
+	lua_pop (L, 1);				/* pop returned value */
 
 	return result;
 }
 
 /* Call custom lua function in rspamd expression */
-gboolean
+gboolean 
 lua_call_expression_func (gpointer lua_data,
-	struct rspamd_task *task, GList *args, gboolean *res)
+		struct rspamd_task *task, GList *args, gboolean *res)
 {
-	lua_State *L = task->cfg->lua_state;
-	struct rspamd_task **ptask;
-	GList *cur;
-	struct expression_argument *arg;
-	int nargs = 1, pop = 0;
+	lua_State                      *L = task->cfg->lua_state;
+	struct rspamd_task            **ptask;
+	GList                          *cur;
+	struct expression_argument     *arg;
+	int                             nargs = 1, pop = 0;
 
 	lua_rawgeti (L, LUA_REGISTRYINDEX, GPOINTER_TO_INT (lua_data));
 	/* Now we got function in top of stack */
 	ptask = lua_newuserdata (L, sizeof (struct rspamd_task *));
 	lua_setclass (L, "rspamd{task}", -1);
 	*ptask = task;
-
+	
 	/* Now push all arguments */
 	cur = args;
 	while (cur) {
 		arg = get_function_arg (cur->data, task, FALSE);
 		if (arg) {
 			switch (arg->type) {
-			case EXPRESSION_ARGUMENT_NORMAL:
-				lua_pushstring (L, (const gchar *)arg->data);
-				break;
-			case EXPRESSION_ARGUMENT_BOOL:
-				lua_pushboolean (L, (gboolean) GPOINTER_TO_SIZE (arg->data));
-				break;
-			default:
-				msg_err ("cannot pass custom params to lua function");
-				return FALSE;
+				case EXPRESSION_ARGUMENT_NORMAL:
+					lua_pushstring (L, (const gchar *)arg->data);
+					break;
+				case EXPRESSION_ARGUMENT_BOOL:
+					lua_pushboolean (L, (gboolean) GPOINTER_TO_SIZE (arg->data));
+					break;
+				default:
+					msg_err ("cannot pass custom params to lua function");
+					return FALSE;
 			}
 		}
-		nargs++;
+		nargs ++;
 		cur = g_list_next (cur);
 	}
 
@@ -524,7 +494,7 @@ lua_call_expression_func (gpointer lua_data,
 		msg_info ("call to lua function failed: %s", lua_tostring (L, -1));
 		return FALSE;
 	}
-	pop++;
+	pop ++;
 
 	if (!lua_isboolean (L, -1)) {
 		lua_pop (L, pop);
@@ -542,19 +512,18 @@ lua_call_expression_func (gpointer lua_data,
  * LUA custom consolidation function
  */
 struct consolidation_callback_data {
-	struct rspamd_task *task;
-	double score;
-	const gchar *func;
+	struct rspamd_task             *task;
+	double                          score;
+	const gchar                     *func;
 };
 
 static void
 lua_consolidation_callback (gpointer key, gpointer value, gpointer arg)
 {
-	double res;
-	struct symbol *s = (struct symbol *)value;
-	struct consolidation_callback_data *data =
-		(struct consolidation_callback_data *)arg;
-	lua_State *L = data->task->cfg->lua_state;
+	double                          res;
+	struct symbol                  *s = (struct symbol *)value;
+	struct consolidation_callback_data *data = (struct consolidation_callback_data *)arg;
+	lua_State                      *L = data->task->cfg->lua_state;
 
 	lua_getglobal (L, data->func);
 
@@ -569,17 +538,15 @@ lua_consolidation_callback (gpointer key, gpointer value, gpointer arg)
 		msg_info ("function %s must return a number", data->func);
 	}
 	res = lua_tonumber (L, -1);
-	lua_pop (L, 1);             /* pop returned value */
+	lua_pop (L, 1);				/* pop returned value */
 	data->score += res;
 }
 
 double
-lua_consolidation_func (struct rspamd_task *task,
-	const gchar *metric_name,
-	const gchar *function_name)
+lua_consolidation_func (struct rspamd_task *task, const gchar *metric_name, const gchar *function_name)
 {
-	struct metric_result *metric_res;
-	double res = 0.;
+	struct metric_result           *metric_res;
+	double                          res = 0.;
 	struct consolidation_callback_data data = { task, 0, function_name };
 
 	if (function_name == NULL) {
@@ -591,29 +558,28 @@ lua_consolidation_func (struct rspamd_task *task,
 		return res;
 	}
 
-	g_hash_table_foreach (metric_res->symbols, lua_consolidation_callback,
-		&data);
+	g_hash_table_foreach (metric_res->symbols, lua_consolidation_callback, &data);
 
 	return data.score;
 }
 
-double
+double 
 lua_normalizer_func (struct rspamd_config *cfg, long double score, void *params)
 {
-	GList *p = params;
-	long double res = score;
-	lua_State *L = cfg->lua_state;
-
-	/* Call specified function and put input score on stack */
-	if (!p->data) {
-		msg_info ("bad function name while calling normalizer");
-		return score;
-	}
+    GList                          *p = params;
+    long double                    	res = score;
+	lua_State                      *L = cfg->lua_state;
 
-	lua_getglobal (L, p->data);
-	lua_pushnumber (L, score);
+    /* Call specified function and put input score on stack */
+    if (!p->data) {
+        msg_info ("bad function name while calling normalizer");
+        return score;
+    }
 
-	if (lua_pcall (L, 1, 1, 0) != 0) {
+    lua_getglobal (L, p->data);
+    lua_pushnumber (L, score);
+
+    if (lua_pcall (L, 1, 1, 0) != 0) {
 		msg_info ("call to %s failed", p->data);
 	}
 
@@ -624,16 +590,16 @@ lua_normalizer_func (struct rspamd_config *cfg, long double score, void *params)
 	res = lua_tonumber (L, -1);
 	lua_pop (L, 1);
 
-	return res;
+    return res;
 }
 
 
 void
 lua_dumpstack (lua_State *L)
 {
-	gint i, t, r = 0;
-	gint top = lua_gettop (L);
-	gchar buf[BUFSIZ];
+	gint 							i, t, r = 0;
+	gint 							top = lua_gettop (L);
+	gchar 							buf[BUFSIZ];
 
 	r += rspamd_snprintf (buf + r, sizeof (buf) - r, "lua stack: ");
 	for (i = 1; i <= top; i++) { /* repeat for each level */
@@ -641,29 +607,19 @@ lua_dumpstack (lua_State *L)
 		switch (t)
 		{
 		case LUA_TSTRING: /* strings */
-			r += rspamd_snprintf (buf + r,
-					sizeof (buf) - r,
-					"str: %s",
-					lua_tostring (L, i));
+			r += rspamd_snprintf (buf + r, sizeof (buf) - r, "str: %s", lua_tostring(L, i));
 			break;
 
 		case LUA_TBOOLEAN: /* booleans */
-			r += rspamd_snprintf (buf + r, sizeof (buf) - r,lua_toboolean (L,
-					i) ? "bool: true" : "bool: false");
+			r += rspamd_snprintf (buf + r, sizeof (buf) - r,lua_toboolean (L, i) ? "bool: true" : "bool: false");
 			break;
 
 		case LUA_TNUMBER: /* numbers */
-			r += rspamd_snprintf (buf + r,
-					sizeof (buf) - r,
-					"number: %.2f",
-					lua_tonumber (L, i));
+			r += rspamd_snprintf (buf + r, sizeof (buf) - r, "number: %.2f", lua_tonumber (L, i));
 			break;
 
 		default: /* other values */
-			r += rspamd_snprintf (buf + r,
-					sizeof (buf) - r,
-					"type: %s",
-					lua_typename (L, t));
+			r += rspamd_snprintf (buf + r, sizeof (buf) - r, "type: %s", lua_typename (L, t));
 			break;
 
 		}
@@ -677,7 +633,7 @@ lua_dumpstack (lua_State *L)
 gpointer
 lua_check_class (lua_State *L, gint index, const gchar *name)
 {
-	gpointer p;
+	gpointer					p;
 
 	if (lua_type (L, index) == LUA_TUSERDATA) {
 		p = lua_touserdata (L, index);
@@ -699,6 +655,6 @@ int
 rspamd_lua_typerror (lua_State *L, int narg, const char *tname)
 {
 	const char *msg = lua_pushfstring (L, "%s expected, got %s", tname,
-			luaL_typename (L, narg));
+			luaL_typename(L, narg));
 	return luaL_argerror (L, narg, msg);
 }
diff --git a/src/lua/lua_common.h b/src/lua/lua_common.h
index 093d27483..ca0ab6d28 100644
--- a/src/lua/lua_common.h
+++ b/src/lua/lua_common.h
@@ -4,26 +4,26 @@
 #include "config.h"
 #ifdef WITH_LUA
 
-#include "cfg_file.h"
-#include "lua_ucl.h"
 #include "main.h"
+#include "cfg_file.h"
 #include "ucl.h"
-#include <lauxlib.h>
+#include "lua_ucl.h"
 #include <lua.h>
+#include <lauxlib.h>
 #include <lualib.h>
 
 #ifndef lua_open
-#define lua_open()  luaL_newstate ()
+#define lua_open()	luaL_newstate()
 #endif
 
 #ifndef luaL_reg
-#define luaL_reg    luaL_Reg
+#define luaL_reg	luaL_Reg
 #endif
 
 #define LUA_ENUM(L, name, val) \
-	lua_pushlstring (L, # name, sizeof(# name) - 1); \
-	lua_pushnumber (L, val); \
-	lua_settable (L, -3);
+  lua_pushlstring(L, #name, sizeof(#name)-1); \
+  lua_pushnumber(L, val); \
+  lua_settable(L, -3);
 
 #if LUA_VERSION_NUM > 501
 static inline void
@@ -32,18 +32,17 @@ luaL_register (lua_State *L, const gchar *name, const struct luaL_reg *methods)
 	if (name != NULL) {
 		lua_newtable (L);
 	}
-	luaL_setfuncs (L, methods, 0);
-	if (name != NULL) {
-		lua_pushvalue (L, -1);
-		lua_setglobal (L, name);
-	}
+    luaL_setfuncs (L, methods, 0);
+    if (name != NULL) {
+    	lua_pushvalue (L, -1);
+    	lua_setglobal (L, name);
+    }
 }
 #endif
 
 /* Interface definitions */
-#define LUA_FUNCTION_DEF(class, name) static gint lua_ ## class ## _ ## name ( \
-		lua_State * L)
-#define LUA_INTERFACE_DEF(class, name) { # name, lua_ ## class ## _ ## name }
+#define LUA_FUNCTION_DEF(class, name) static gint lua_##class##_##name(lua_State *L)
+#define LUA_INTERFACE_DEF(class, name) { #name, lua_##class##_##name }
 
 extern const luaL_reg null_reg[];
 
@@ -60,18 +59,12 @@ struct lua_locked_state {
 /**
  * Create and register new class
  */
-void lua_newclass (lua_State *L,
-	const gchar *classname,
-	const struct luaL_reg *methods);
+void lua_newclass (lua_State *L, const gchar *classname, const struct luaL_reg *methods);
 
 /**
  * Create and register new class with static methods
  */
-void lua_newclass_full (lua_State *L,
-	const gchar *classname,
-	const gchar *static_name,
-	const struct luaL_reg *methods,
-	const struct luaL_reg *func);
+void lua_newclass_full (lua_State *L, const gchar *classname, const gchar *static_name, const struct luaL_reg *methods, const struct luaL_reg *func);
 
 /**
  * Set class name for object at @param objidx position
@@ -101,7 +94,7 @@ gpointer lua_check_class (lua_State *L, gint index, const gchar *name);
 /**
  * Initialize lua and bindings
  */
-lua_State * init_lua (struct rspamd_config *cfg);
+lua_State* init_lua (struct rspamd_config *cfg);
 
 /**
  * Load and initialize lua plugins
@@ -111,7 +104,7 @@ gboolean init_lua_filters (struct rspamd_config *cfg);
 /**
  * Initialize new locked lua_State structure
  */
-struct lua_locked_state * init_lua_locked (struct rspamd_config *cfg);
+struct lua_locked_state* init_lua_locked (struct rspamd_config *cfg);
 /**
  * Free locked state structure
  */
@@ -170,54 +163,29 @@ gint luaopen_rsa (lua_State * L);
 gint luaopen_ip (lua_State * L);
 
 gint lua_call_filter (const gchar *function, struct rspamd_task *task);
-gint lua_call_chain_filter (const gchar *function,
-	struct rspamd_task *task,
-	gint *marks,
-	guint number);
-double lua_consolidation_func (struct rspamd_task *task,
-	const gchar *metric_name,
-	const gchar *function_name);
-gboolean lua_call_expression_func (gpointer lua_data,
-	struct rspamd_task *task,
-	GList *args,
-	gboolean *res);
+gint lua_call_chain_filter (const gchar *function, struct rspamd_task *task, gint *marks, guint number);
+double lua_consolidation_func (struct rspamd_task *task, const gchar *metric_name, const gchar *function_name);
+gboolean lua_call_expression_func (gpointer lua_data, struct rspamd_task *task, GList *args, gboolean *res);
 void lua_call_post_filters (struct rspamd_task *task);
 void lua_call_pre_filters (struct rspamd_task *task);
 void add_luabuf (const gchar *line);
 
 /* Classify functions */
-GList * call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf,
-	struct rspamd_task *task,
-	gboolean is_learn,
-	gboolean is_spam,
-	lua_State *L);
-double call_classifier_post_callbacks (struct rspamd_classifier_config *ccf,
-	struct rspamd_task *task,
-	double in,
-	lua_State *L);
-
-double lua_normalizer_func (struct rspamd_config *cfg,
-	long double score,
-	void *params);
+GList *call_classifier_pre_callbacks (struct rspamd_classifier_config *ccf, struct rspamd_task *task, gboolean is_learn, gboolean is_spam, lua_State *L);
+double call_classifier_post_callbacks (struct rspamd_classifier_config *ccf, struct rspamd_task *task, double in, lua_State *L);
+
+double lua_normalizer_func (struct rspamd_config *cfg, long double score, void *params);
 
 /* Config file functions */
 void lua_post_load_config (struct rspamd_config *cfg);
-void lua_process_element (struct rspamd_config *cfg,
-	const gchar *name,
-	const gchar *module_name,
-	struct rspamd_module_opt *opt,
-	gint idx,
-	gboolean allow_meta);
-gboolean lua_handle_param (struct rspamd_task *task,
-	gchar *mname,
-	gchar *optname,
-	enum lua_var_type expected_type,
-	gpointer *res);
-gboolean lua_check_condition (struct rspamd_config *cfg,
-	const gchar *condition);
+void lua_process_element (struct rspamd_config *cfg, const gchar *name,
+		const gchar *module_name, struct rspamd_module_opt *opt, gint idx, gboolean allow_meta);
+gboolean lua_handle_param (struct rspamd_task *task, gchar *mname, gchar *optname, 
+							enum lua_var_type expected_type, gpointer *res);
+gboolean lua_check_condition (struct rspamd_config *cfg, const gchar *condition);
 void lua_dumpstack (lua_State *L);
 
-struct memory_pool_s * lua_check_mempool (lua_State * L);
+struct memory_pool_s *lua_check_mempool (lua_State * L);
 
 
 #endif /* WITH_LUA */
diff --git a/src/lua/lua_config.c b/src/lua/lua_config.c
index e42e8af0a..162c7b842 100644
--- a/src/lua/lua_config.c
+++ b/src/lua/lua_config.c
@@ -23,13 +23,13 @@
  */
 
 
-#include "classifiers/classifiers.h"
-#include "expressions.h"
 #include "lua_common.h"
+#include "expressions.h"
 #include "map.h"
 #include "message.h"
 #include "radix.h"
 #include "trie.h"
+#include "classifiers/classifiers.h"
 
 /* Config file methods */
 LUA_FUNCTION_DEF (config, get_module_opt);
@@ -51,7 +51,7 @@ LUA_FUNCTION_DEF (config, register_post_filter);
 LUA_FUNCTION_DEF (config, register_module_option);
 LUA_FUNCTION_DEF (config, get_api_version);
 
-static const struct luaL_reg configlib_m[] = {
+static const struct luaL_reg    configlib_m[] = {
 	LUA_INTERFACE_DEF (config, get_module_opt),
 	LUA_INTERFACE_DEF (config, get_mempool),
 	LUA_INTERFACE_DEF (config, get_all_opt),
@@ -78,7 +78,7 @@ static const struct luaL_reg configlib_m[] = {
 /* Radix tree */
 LUA_FUNCTION_DEF (radix, get_key);
 
-static const struct luaL_reg radixlib_m[] = {
+static const struct luaL_reg    radixlib_m[] = {
 	LUA_INTERFACE_DEF (radix, get_key),
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
@@ -87,7 +87,7 @@ static const struct luaL_reg radixlib_m[] = {
 /* Hash table */
 LUA_FUNCTION_DEF (hash_table, get_key);
 
-static const struct luaL_reg hashlib_m[] = {
+static const struct luaL_reg    hashlib_m[] = {
 	LUA_INTERFACE_DEF (hash_table, get_key),
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
@@ -99,46 +99,46 @@ LUA_FUNCTION_DEF (trie, add_pattern);
 LUA_FUNCTION_DEF (trie, search_text);
 LUA_FUNCTION_DEF (trie, search_task);
 
-static const struct luaL_reg trielib_m[] = {
+static const struct luaL_reg    trielib_m[] = {
 	LUA_INTERFACE_DEF (trie, add_pattern),
 	LUA_INTERFACE_DEF (trie, search_text),
 	LUA_INTERFACE_DEF (trie, search_task),
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
 };
-static const struct luaL_reg trielib_f[] = {
+static const struct luaL_reg    trielib_f[] = {
 	LUA_INTERFACE_DEF (trie, create),
 	{NULL, NULL}
 };
 
-static struct rspamd_config *
+static struct rspamd_config      *
 lua_check_config (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{config}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{config}");
 	luaL_argcheck (L, ud != NULL, 1, "'config' expected");
 	return ud ? *((struct rspamd_config **)ud) : NULL;
 }
 
-static radix_tree_t *
+static radix_tree_t           *
 lua_check_radix (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{radix}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{radix}");
 	luaL_argcheck (L, ud != NULL, 1, "'radix' expected");
 	return ud ? **((radix_tree_t ***)ud) : NULL;
 }
 
-static GHashTable *
+static GHashTable           *
 lua_check_hash_table (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{hash_table}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{hash_table}");
 	luaL_argcheck (L, ud != NULL, 1, "'hash_table' expected");
 	return ud ? **((GHashTable ***)ud) : NULL;
 }
 
-static rspamd_trie_t *
+static rspamd_trie_t          *
 lua_check_trie (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{trie}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{trie}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'trie' expected");
 	return ud ? *((rspamd_trie_t **)ud) : NULL;
@@ -155,9 +155,9 @@ lua_config_get_api_version (lua_State *L)
 static gint
 lua_config_get_module_opt (lua_State * L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	const gchar *mname, *optname;
-	const ucl_object_t *obj;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	const gchar                     *mname, *optname;
+	const ucl_object_t              *obj;
 
 	if (cfg) {
 		mname = luaL_checkstring (L, 2);
@@ -177,8 +177,8 @@ lua_config_get_module_opt (lua_State * L)
 static int
 lua_config_get_mempool (lua_State * L)
 {
-	rspamd_mempool_t **ppool;
-	struct rspamd_config *cfg = lua_check_config (L);
+	rspamd_mempool_t                  **ppool;
+	struct rspamd_config             *cfg = lua_check_config (L);
 
 	if (cfg != NULL) {
 		ppool = lua_newuserdata (L, sizeof (rspamd_mempool_t *));
@@ -191,9 +191,9 @@ lua_config_get_mempool (lua_State * L)
 static gint
 lua_config_get_all_opt (lua_State * L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	const gchar *mname;
-	const ucl_object_t *obj;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	const gchar                     *mname;
+	const ucl_object_t              *obj;
 
 	if (cfg) {
 		mname = luaL_checkstring (L, 2);
@@ -213,10 +213,10 @@ lua_config_get_all_opt (lua_State * L)
 static gint
 lua_config_get_classifier (lua_State * L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	struct rspamd_classifier_config *clc = NULL, **pclc = NULL;
-	const gchar *name;
-	GList *cur;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	struct rspamd_classifier_config       *clc = NULL, **pclc = NULL;
+	const gchar                     *name;
+	GList                          *cur;
 
 	if (cfg) {
 		name = luaL_checkstring (L, 2);
@@ -231,8 +231,7 @@ lua_config_get_classifier (lua_State * L)
 			cur = g_list_next (cur);
 		}
 		if (pclc) {
-			pclc = lua_newuserdata (L,
-					sizeof (struct rspamd_classifier_config *));
+			pclc = lua_newuserdata (L, sizeof (struct rspamd_classifier_config *));
 			lua_setclass (L, "rspamd{classifier}", -1);
 			*pclc = clc;
 			return 1;
@@ -246,12 +245,12 @@ lua_config_get_classifier (lua_State * L)
 
 struct lua_callback_data {
 	union {
-		gchar *name;
-		gint ref;
+		gchar						*name;
+		gint						 ref;
 	} callback;
-	gboolean cb_is_ref;
-	lua_State *L;
-	gchar *symbol;
+	gboolean						 cb_is_ref;
+	lua_State						*L;
+	gchar 							*symbol;
 };
 
 /*
@@ -260,7 +259,7 @@ struct lua_callback_data {
 static void
 lua_destroy_cfg_symbol (gpointer ud)
 {
-	struct lua_callback_data *cd = ud;
+	struct lua_callback_data       *cd = ud;
 
 	/* Unref callback */
 	if (cd->cb_is_ref) {
@@ -269,16 +268,14 @@ lua_destroy_cfg_symbol (gpointer ud)
 }
 
 static gboolean
-lua_config_function_callback (struct rspamd_task *task,
-	GList *args,
-	void *user_data)
+lua_config_function_callback (struct rspamd_task *task, GList *args, void *user_data)
 {
-	struct lua_callback_data *cd = user_data;
-	struct rspamd_task **ptask;
-	gint i = 1;
-	struct expression_argument *arg;
-	GList *cur;
-	gboolean res = FALSE;
+	struct lua_callback_data       *cd = user_data;
+	struct rspamd_task            **ptask;
+	gint                            i = 1;
+	struct expression_argument     *arg;
+	GList                          *cur;
+	gboolean                        res = FALSE;
 
 	if (cd->cb_is_ref) {
 		lua_rawgeti (cd->L, LUA_REGISTRYINDEX, cd->callback.ref);
@@ -295,15 +292,13 @@ lua_config_function_callback (struct rspamd_task *task,
 		arg = get_function_arg (cur->data, task, TRUE);
 		lua_pushstring (cd->L, (const gchar *)arg->data);
 		cur = g_list_next (cur);
-		i++;
+		i ++;
 	}
 
 	if (lua_pcall (cd->L, i, 1, 0) != 0) {
-		msg_info ("error processing symbol %s: call to %s failed: %s",
-			cd->symbol,
-			cd->cb_is_ref ? "local function" :
-			cd->callback.name,
-			lua_tostring (cd->L, -1));
+		msg_info ("error processing symbol %s: call to %s failed: %s", cd->symbol,
+						cd->cb_is_ref ? "local function" :
+						cd->callback.name, lua_tostring (cd->L, -1));
 	}
 	else {
 		if (lua_isboolean (cd->L, 1)) {
@@ -318,19 +313,16 @@ lua_config_function_callback (struct rspamd_task *task,
 static gint
 lua_config_register_function (lua_State *L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	gchar *name;
-	struct lua_callback_data *cd;
-
+	struct rspamd_config             *cfg = lua_check_config (L);
+	gchar                          *name;
+	struct lua_callback_data       *cd;
+	
 	if (cfg) {
 		name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
-		cd =
-			rspamd_mempool_alloc (cfg->cfg_pool,
-				sizeof (struct lua_callback_data));
+		cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
 
 		if (lua_type (L, 3) == LUA_TSTRING) {
-			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
-					luaL_checkstring (L, 3));
+			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 3));
 			cd->cb_is_ref = FALSE;
 		}
 		else {
@@ -342,12 +334,9 @@ lua_config_register_function (lua_State *L)
 		if (name) {
 			cd->L = L;
 			cd->symbol = name;
-			register_expression_function (name, lua_config_function_callback,
-				cd);
+			register_expression_function (name, lua_config_function_callback, cd);
 		}
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
-			cd);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
 	}
 	return 1;
 }
@@ -361,9 +350,9 @@ lua_config_register_module_option (lua_State *L)
 void
 lua_call_post_filters (struct rspamd_task *task)
 {
-	struct lua_callback_data *cd;
-	struct rspamd_task **ptask;
-	GList *cur;
+	struct lua_callback_data       *cd;
+	struct rspamd_task            **ptask;
+	GList                          *cur;
 
 	cur = task->cfg->post_filters;
 	while (cur) {
@@ -379,10 +368,8 @@ lua_call_post_filters (struct rspamd_task *task)
 		*ptask = task;
 
 		if (lua_pcall (cd->L, 1, 0, 0) != 0) {
-			msg_info ("call to %s failed: %s",
-				cd->cb_is_ref ? "local function" :
-				cd->callback.name,
-				lua_tostring (cd->L, -1));
+			msg_info ("call to %s failed: %s", cd->cb_is_ref ? "local function" :
+							cd->callback.name, lua_tostring (cd->L, -1));
 		}
 		cur = g_list_next (cur);
 	}
@@ -391,16 +378,13 @@ lua_call_post_filters (struct rspamd_task *task)
 static gint
 lua_config_register_post_filter (lua_State *L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	struct lua_callback_data *cd;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	struct lua_callback_data       *cd;
 
 	if (cfg) {
-		cd =
-			rspamd_mempool_alloc (cfg->cfg_pool,
-				sizeof (struct lua_callback_data));
+		cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
 		if (lua_type (L, 2) == LUA_TSTRING) {
-			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
-					luaL_checkstring (L, 2));
+			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
 			cd->cb_is_ref = FALSE;
 		}
 		else {
@@ -411,9 +395,7 @@ lua_config_register_post_filter (lua_State *L)
 		}
 		cd->L = L;
 		cfg->post_filters = g_list_prepend (cfg->post_filters, cd);
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
-			cd);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
 	}
 	return 1;
 }
@@ -421,9 +403,9 @@ lua_config_register_post_filter (lua_State *L)
 void
 lua_call_pre_filters (struct rspamd_task *task)
 {
-	struct lua_callback_data *cd;
-	struct rspamd_task **ptask;
-	GList *cur;
+	struct lua_callback_data       *cd;
+	struct rspamd_task            **ptask;
+	GList                          *cur;
 
 	cur = task->cfg->pre_filters;
 	while (cur) {
@@ -439,10 +421,8 @@ lua_call_pre_filters (struct rspamd_task *task)
 		*ptask = task;
 
 		if (lua_pcall (cd->L, 1, 0, 0) != 0) {
-			msg_info ("call to %s failed: %s",
-				cd->cb_is_ref ? "local function" :
-				cd->callback.name,
-				lua_tostring (cd->L, -1));
+			msg_info ("call to %s failed: %s", cd->cb_is_ref ? "local function" :
+							cd->callback.name, lua_tostring (cd->L, -1));
 		}
 		cur = g_list_next (cur);
 	}
@@ -451,16 +431,13 @@ lua_call_pre_filters (struct rspamd_task *task)
 static gint
 lua_config_register_pre_filter (lua_State *L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	struct lua_callback_data *cd;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	struct lua_callback_data       *cd;
 
 	if (cfg) {
-		cd =
-			rspamd_mempool_alloc (cfg->cfg_pool,
-				sizeof (struct lua_callback_data));
+		cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
 		if (lua_type (L, 2) == LUA_TSTRING) {
-			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
-					luaL_checkstring (L, 2));
+			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
 			cd->cb_is_ref = FALSE;
 		}
 		else {
@@ -471,9 +448,7 @@ lua_config_register_pre_filter (lua_State *L)
 		}
 		cd->L = L;
 		cfg->pre_filters = g_list_prepend (cfg->pre_filters, cd);
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
-			cd);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
 	}
 	return 1;
 }
@@ -481,17 +456,16 @@ lua_config_register_pre_filter (lua_State *L)
 static gint
 lua_config_add_radix_map (lua_State *L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	const gchar *map_line, *description;
-	radix_tree_t **r, ***ud;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	const gchar                     *map_line, *description;
+	radix_tree_t                   **r, ***ud;
 
 	if (cfg) {
 		map_line = luaL_checkstring (L, 2);
 		description = lua_tostring (L, 3);
 		r = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (radix_tree_t *));
 		*r = radix_tree_create ();
-		if (!add_map (cfg, map_line, description, read_radix_list,
-			fin_radix_list, (void **)r)) {
+		if (!add_map (cfg, map_line, description, read_radix_list, fin_radix_list, (void **)r)) {
 			msg_warn ("invalid radix map %s", map_line);
 			radix_tree_free (*r);
 			lua_pushnil (L);
@@ -512,25 +486,22 @@ lua_config_add_radix_map (lua_State *L)
 static gint
 lua_config_add_hash_map (lua_State *L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	const gchar *map_line, *description;
-	GHashTable **r, ***ud;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	const gchar                     *map_line, *description;
+	GHashTable                    **r, ***ud;
 
 	if (cfg) {
 		map_line = luaL_checkstring (L, 2);
 		description = lua_tostring (L, 3);
 		r = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (GHashTable *));
 		*r = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
-		if (!add_map (cfg, map_line, description, read_host_list, fin_host_list,
-			(void **)r)) {
+		if (!add_map (cfg, map_line, description, read_host_list, fin_host_list, (void **)r)) {
 			msg_warn ("invalid hash map %s", map_line);
 			g_hash_table_destroy (*r);
 			lua_pushnil (L);
 			return 1;
 		}
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)g_hash_table_destroy,
-			*r);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_hash_table_destroy, *r);
 		ud = lua_newuserdata (L, sizeof (GHashTable *));
 		*ud = r;
 		lua_setclass (L, "rspamd{hash_table}", -1);
@@ -546,25 +517,22 @@ lua_config_add_hash_map (lua_State *L)
 static gint
 lua_config_add_kv_map (lua_State *L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	const gchar *map_line, *description;
-	GHashTable **r, ***ud;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	const gchar                     *map_line, *description;
+	GHashTable                    **r, ***ud;
 
 	if (cfg) {
 		map_line = luaL_checkstring (L, 2);
 		description = lua_tostring (L, 3);
 		r = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (GHashTable *));
 		*r = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
-		if (!add_map (cfg, map_line, description, read_kv_list, fin_kv_list,
-			(void **)r)) {
+		if (!add_map (cfg, map_line, description, read_kv_list, fin_kv_list, (void **)r)) {
 			msg_warn ("invalid hash map %s", map_line);
 			g_hash_table_destroy (*r);
 			lua_pushnil (L);
 			return 1;
 		}
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)g_hash_table_destroy,
-			*r);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)g_hash_table_destroy, *r);
 		ud = lua_newuserdata (L, sizeof (GHashTable *));
 		*ud = r;
 		lua_setclass (L, "rspamd{hash_table}", -1);
@@ -585,7 +553,7 @@ struct lua_map_callback_data {
 
 static gchar *
 lua_map_read (rspamd_mempool_t *pool, gchar *chunk, gint len,
-	struct map_cb_data *data)
+		struct map_cb_data *data)
 {
 	struct lua_map_callback_data *cbdata, *old;
 
@@ -637,7 +605,7 @@ lua_map_fin (rspamd_mempool_t * pool, struct map_cb_data *data)
 
 		if (lua_pcall (cbdata->L, 1, 0, 0) != 0) {
 			msg_info ("call to %s failed: %s", "local function",
-				lua_tostring (cbdata->L, -1));
+					lua_tostring (cbdata->L, -1));
 		}
 	}
 }
@@ -645,9 +613,9 @@ lua_map_fin (rspamd_mempool_t * pool, struct map_cb_data *data)
 static gint
 lua_config_add_map (lua_State *L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	const gchar *map_line, *description;
-	struct lua_map_callback_data *cbdata, **pcbdata;
+	struct rspamd_config            *cfg = lua_check_config (L);
+	const gchar                     *map_line, *description;
+	struct lua_map_callback_data    *cbdata, **pcbdata;
 
 	if (cfg) {
 		map_line = luaL_checkstring (L, 2);
@@ -663,7 +631,7 @@ lua_config_add_map (lua_State *L)
 			pcbdata = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (cbdata));
 			*pcbdata = cbdata;
 			if (!add_map (cfg, map_line, description, lua_map_read, lua_map_fin,
-				(void **)pcbdata)) {
+					(void **)pcbdata)) {
 				msg_warn ("invalid hash map %s", map_line);
 				lua_pushboolean (L, false);
 			}
@@ -689,8 +657,8 @@ lua_config_add_map (lua_State *L)
 static void
 lua_metric_symbol_callback (struct rspamd_task *task, gpointer ud)
 {
-	struct lua_callback_data *cd = ud;
-	struct rspamd_task **ptask;
+	struct lua_callback_data       *cd = ud;
+	struct rspamd_task            **ptask;
 
 	if (cd->cb_is_ref) {
 		lua_rawgeti (cd->L, LUA_REGISTRYINDEX, cd->callback.ref);
@@ -704,27 +672,24 @@ lua_metric_symbol_callback (struct rspamd_task *task, gpointer ud)
 
 	if (lua_pcall (cd->L, 1, 0, 0) != 0) {
 		msg_info ("call to %s failed: %s", cd->cb_is_ref ? "local function" :
-			cd->callback.name, lua_tostring (cd->L, -1));
+									cd->callback.name, lua_tostring (cd->L, -1));
 	}
 }
 
 static gint
 lua_config_register_symbol (lua_State * L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	gchar *name;
-	double weight;
-	struct lua_callback_data *cd;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	gchar                          *name;
+	double                          weight;
+	struct lua_callback_data       *cd;
 
 	if (cfg) {
 		name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
 		weight = luaL_checknumber (L, 3);
-		cd =
-			rspamd_mempool_alloc (cfg->cfg_pool,
-				sizeof (struct lua_callback_data));
+		cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
 		if (lua_type (L, 4) == LUA_TSTRING) {
-			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
-					luaL_checkstring (L, 4));
+			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 4));
 			cd->cb_is_ref = FALSE;
 		}
 		else {
@@ -736,15 +701,9 @@ lua_config_register_symbol (lua_State * L)
 		if (name) {
 			cd->symbol = name;
 			cd->L = L;
-			register_symbol (&cfg->cache,
-				name,
-				weight,
-				lua_metric_symbol_callback,
-				cd);
+			register_symbol (&cfg->cache, name, weight, lua_metric_symbol_callback, cd);
 		}
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
-			cd);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
 	}
 	return 0;
 }
@@ -752,23 +711,20 @@ lua_config_register_symbol (lua_State * L)
 static gint
 lua_config_register_symbols (lua_State *L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	struct lua_callback_data *cd;
-	gint i, top;
-	gchar *sym;
-	gdouble weight = 1.0;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	struct lua_callback_data       *cd;
+	gint                             i, top;
+	gchar                           *sym;
+	gdouble                          weight = 1.0;
 
 	if (lua_gettop (L) < 3) {
 		msg_err ("not enough arguments to register a function");
 		return 0;
 	}
 	if (cfg) {
-		cd =
-			rspamd_mempool_alloc (cfg->cfg_pool,
-				sizeof (struct lua_callback_data));
+		cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
 		if (lua_type (L, 2) == LUA_TSTRING) {
-			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
-					luaL_checkstring (L, 2));
+			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
 			cd->cb_is_ref = FALSE;
 		}
 		else {
@@ -787,15 +743,9 @@ lua_config_register_symbols (lua_State *L)
 		sym = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, top));
 		cd->symbol = sym;
 		cd->L = L;
-		register_symbol (&cfg->cache,
-			sym,
-			weight,
-			lua_metric_symbol_callback,
-			cd);
-		for (i = top; i < lua_gettop (L); i++) {
-			sym =
-				rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L,
-					i + 1));
+		register_symbol (&cfg->cache, sym, weight, lua_metric_symbol_callback, cd);
+		for (i = top; i < lua_gettop (L); i ++) {
+			sym = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, i + 1));
 			register_virtual_symbol (&cfg->cache, sym, weight);
 		}
 	}
@@ -806,9 +756,9 @@ lua_config_register_symbols (lua_State *L)
 static gint
 lua_config_register_virtual_symbol (lua_State * L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	gchar *name;
-	double weight;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	gchar                          *name;
+	double                          weight;
 
 	if (cfg) {
 		name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
@@ -823,20 +773,17 @@ lua_config_register_virtual_symbol (lua_State * L)
 static gint
 lua_config_register_callback_symbol (lua_State * L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	gchar *name;
-	double weight;
-	struct lua_callback_data *cd;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	gchar                          *name;
+	double                          weight;
+	struct lua_callback_data       *cd;
 
 	if (cfg) {
 		name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
 		weight = luaL_checknumber (L, 3);
-		cd =
-			rspamd_mempool_alloc (cfg->cfg_pool,
-				sizeof (struct lua_callback_data));
+		cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
 		if (lua_type (L, 4) == LUA_TSTRING) {
-			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
-					luaL_checkstring (L, 4));
+			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 4));
 			cd->cb_is_ref = FALSE;
 		}
 		else {
@@ -848,15 +795,9 @@ lua_config_register_callback_symbol (lua_State * L)
 		if (name) {
 			cd->symbol = name;
 			cd->L = L;
-			register_callback_symbol (&cfg->cache,
-				name,
-				weight,
-				lua_metric_symbol_callback,
-				cd);
+			register_callback_symbol (&cfg->cache, name, weight, lua_metric_symbol_callback, cd);
 		}
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
-			cd);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
 	}
 	return 0;
 }
@@ -864,22 +805,19 @@ lua_config_register_callback_symbol (lua_State * L)
 static gint
 lua_config_register_callback_symbol_priority (lua_State * L)
 {
-	struct rspamd_config *cfg = lua_check_config (L);
-	gchar *name;
-	double weight;
-	gint priority;
-	struct lua_callback_data *cd;
+	struct rspamd_config             *cfg = lua_check_config (L);
+	gchar                          *name;
+	double                          weight;
+	gint                            priority;
+	struct lua_callback_data       *cd;
 
 	if (cfg) {
 		name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 2));
 		weight = luaL_checknumber (L, 3);
 		priority = luaL_checknumber (L, 4);
-		cd =
-			rspamd_mempool_alloc (cfg->cfg_pool,
-				sizeof (struct lua_callback_data));
+		cd = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct lua_callback_data));
 		if (lua_type (L, 5) == LUA_TSTRING) {
-			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool,
-					luaL_checkstring (L, 5));
+			cd->callback.name = rspamd_mempool_strdup (cfg->cfg_pool, luaL_checkstring (L, 5));
 			cd->cb_is_ref = FALSE;
 		}
 		else {
@@ -892,16 +830,9 @@ lua_config_register_callback_symbol_priority (lua_State * L)
 		if (name) {
 			cd->L = L;
 			cd->symbol = name;
-			register_callback_symbol_priority (&cfg->cache,
-				name,
-				weight,
-				priority,
-				lua_metric_symbol_callback,
-				cd);
+			register_callback_symbol_priority (&cfg->cache, name, weight, priority, lua_metric_symbol_callback, cd);
 		}
-		rspamd_mempool_add_destructor (cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)lua_destroy_cfg_symbol,
-			cd);
+		rspamd_mempool_add_destructor (cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_destroy_cfg_symbol, cd);
 
 	}
 	return 0;
@@ -912,8 +843,8 @@ lua_config_register_callback_symbol_priority (lua_State * L)
 static gint
 lua_radix_get_key (lua_State * L)
 {
-	radix_tree_t *radix = lua_check_radix (L);
-	guint32 key;
+	radix_tree_t                  *radix = lua_check_radix (L);
+	guint32                         key;
 
 	if (radix) {
 		key = luaL_checkint (L, 2);
@@ -931,8 +862,8 @@ lua_radix_get_key (lua_State * L)
 static gint
 lua_hash_table_get_key (lua_State * L)
 {
-	GHashTable *tbl = lua_check_hash_table (L);
-	const gchar *key, *value;
+	GHashTable                    *tbl = lua_check_hash_table (L);
+	const gchar                    *key, *value;
 
 	if (tbl) {
 		key = luaL_checkstring (L, 2);
@@ -951,8 +882,8 @@ lua_hash_table_get_key (lua_State * L)
 static gint
 lua_trie_create (lua_State *L)
 {
-	rspamd_trie_t *trie, **ptrie;
-	gboolean icase = FALSE;
+	rspamd_trie_t                 *trie, **ptrie;
+	gboolean                       icase = FALSE;
 
 	if (lua_gettop (L) == 1) {
 		icase = lua_toboolean (L, 1);
@@ -970,12 +901,12 @@ lua_trie_create (lua_State *L)
 static gint
 lua_trie_add_pattern (lua_State *L)
 {
-	rspamd_trie_t *trie = lua_check_trie (L);
-	const gchar *pattern;
-	gint id;
+	rspamd_trie_t                 *trie = lua_check_trie (L);
+	const gchar                   *pattern;
+	gint                           id;
 
 	if (trie) {
-		pattern = luaL_checkstring (L, 2);
+		pattern  = luaL_checkstring (L, 2);
 		id = luaL_checknumber (L, 3);
 
 		if (pattern != NULL) {
@@ -992,11 +923,11 @@ lua_trie_add_pattern (lua_State *L)
 static gint
 lua_trie_search_text (lua_State *L)
 {
-	rspamd_trie_t *trie = lua_check_trie (L);
-	const gchar *text, *pos;
-	gint id, i = 1;
-	gsize len;
-	gboolean found = FALSE;
+	rspamd_trie_t                 *trie = lua_check_trie (L);
+	const gchar                   *text, *pos;
+	gint                           id, i = 1;
+	gsize                          len;
+	gboolean                       found = FALSE;
 
 	if (trie) {
 		text = luaL_checkstring (L, 2);
@@ -1004,12 +935,11 @@ lua_trie_search_text (lua_State *L)
 		if (text) {
 			lua_newtable (L);
 			pos = text;
-			while (pos < text + len &&
-				(pos = rspamd_trie_lookup (trie, pos, len, &id)) != NULL) {
+			while (pos < text + len && (pos = rspamd_trie_lookup (trie, pos, len, &id)) != NULL) {
 				lua_pushinteger (L, i);
 				lua_pushinteger (L, id);
 				lua_settable (L, -3);
-				i++;
+				i ++;
 				found = TRUE;
 				break;
 			}
@@ -1028,14 +958,14 @@ lua_trie_search_text (lua_State *L)
 static gint
 lua_trie_search_task (lua_State *L)
 {
-	rspamd_trie_t *trie = lua_check_trie (L);
-	struct rspamd_task *task;
-	struct mime_text_part *part;
-	GList *cur;
-	const gchar *pos, *end;
-	gint id, i = 1;
-	void *ud;
-	gboolean found = FALSE;
+	rspamd_trie_t                 *trie = lua_check_trie (L);
+	struct rspamd_task            *task;
+	struct mime_text_part         *part;
+	GList                         *cur;
+	const gchar                   *pos, *end;
+	gint                           id, i = 1;
+	void                          *ud;
+	gboolean                       found = FALSE;
 
 	if (trie) {
 		ud = luaL_checkudata (L, 2, "rspamd{task}");
@@ -1049,14 +979,11 @@ lua_trie_search_task (lua_State *L)
 				if (!part->is_empty && part->content != NULL) {
 					pos = (const gchar *)part->content->data;
 					end = pos + part->content->len;
-					while (pos < end &&
-						(pos =
-						rspamd_trie_lookup (trie, pos, part->content->len,
-						&id)) != NULL) {
+					while (pos < end && (pos = rspamd_trie_lookup (trie, pos, part->content->len, &id)) != NULL) {
 						lua_pushinteger (L, i);
 						lua_pushinteger (L, id);
 						lua_settable (L, -3);
-						i++;
+						i ++;
 						found = TRUE;
 						break;
 					}
@@ -1122,7 +1049,7 @@ luaopen_trie (lua_State * L)
 	lua_pushstring (L, "rspamd{trie}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,			 trielib_m);
+	luaL_register (L, NULL, trielib_m);
 	luaL_register (L, "rspamd_trie", trielib_f);
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
diff --git a/src/lua/lua_dns.c b/src/lua/lua_dns.c
index 0e7857f42..49ed205da 100644
--- a/src/lua/lua_dns.c
+++ b/src/lua/lua_dns.c
@@ -21,11 +21,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "dns.h"
 #include "lua_common.h"
+#include "dns.h"
 
 /* Public prototypes */
-struct rspamd_dns_resolver * lua_check_dns_resolver (lua_State * L);
+struct rspamd_dns_resolver *lua_check_dns_resolver (lua_State * L);
 gint luaopen_dns_resolver (lua_State * L);
 
 /* Lua bindings */
@@ -36,12 +36,12 @@ LUA_FUNCTION_DEF (dns_resolver, resolve_txt);
 LUA_FUNCTION_DEF (dns_resolver, resolve_mx);
 LUA_FUNCTION_DEF (dns_resolver, resolve);
 
-static const struct luaL_reg dns_resolverlib_f[] = {
+static const struct luaL_reg    dns_resolverlib_f[] = {
 	LUA_INTERFACE_DEF (dns_resolver, init),
 	{NULL, NULL}
 };
 
-static const struct luaL_reg dns_resolverlib_m[] = {
+static const struct luaL_reg    dns_resolverlib_m[] = {
 	LUA_INTERFACE_DEF (dns_resolver, resolve_a),
 	LUA_INTERFACE_DEF (dns_resolver, resolve_ptr),
 	LUA_INTERFACE_DEF (dns_resolver, resolve_txt),
@@ -51,20 +51,20 @@ static const struct luaL_reg dns_resolverlib_m[] = {
 	{NULL, NULL}
 };
 
-struct rspamd_dns_resolver *
+struct rspamd_dns_resolver      *
 lua_check_dns_resolver (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{resolver}");
+	void								*ud = luaL_checkudata (L, 1, "rspamd{resolver}");
 	luaL_argcheck (L, ud != NULL, 1, "'resolver' expected");
 	return ud ? *((struct rspamd_dns_resolver **)ud) : NULL;
 }
 
 struct lua_dns_cbdata {
-	lua_State *L;
-	struct rspamd_dns_resolver *resolver;
-	gint cbref;
-	const gchar *to_resolve;
-	const gchar *user_str;
+	lua_State                      *L;
+	struct rspamd_dns_resolver	   *resolver;
+	gint							cbref;
+	const gchar                    *to_resolve;
+	const gchar                    *user_str;
 };
 
 static int
@@ -86,11 +86,11 @@ lua_dns_get_type (lua_State *L, int argno)
 static void
 lua_dns_callback (struct rdns_reply *reply, gpointer arg)
 {
-	struct lua_dns_cbdata *cd = arg;
-	gint i = 0;
-	struct rspamd_dns_resolver **presolver;
-	struct rdns_reply_entry *elt;
-	rspamd_inet_addr_t addr;
+	struct lua_dns_cbdata   	   *cd = arg;
+	gint                            i = 0;
+	struct rspamd_dns_resolver    **presolver;
+	struct rdns_reply_entry        *elt;
+	rspamd_inet_addr_t               addr;
 
 	lua_rawgeti (cd->L, LUA_REGISTRYINDEX, cd->cbref);
 	presolver = lua_newuserdata (cd->L, sizeof (gpointer));
@@ -104,14 +104,13 @@ lua_dns_callback (struct rdns_reply *reply, gpointer arg)
 	 */
 	if (reply->code == RDNS_RC_NOERROR) {
 		lua_newtable (cd->L);
-		LL_FOREACH (reply->entries, elt)
-		{
+		LL_FOREACH (reply->entries, elt) {
 			switch (elt->type) {
 			case RDNS_REQUEST_A:
 				addr.af = AF_INET;
 				addr.slen = sizeof (addr.addr.s4);
 				memcpy (&addr.addr.s4.sin_addr, &elt->content.a.addr,
-					sizeof (addr.addr.s4.sin_addr));
+						sizeof (addr.addr.s4.sin_addr));
 				lua_ip_push (cd->L, &addr);
 				lua_rawseti (cd->L, -2, ++i);
 				break;
@@ -119,7 +118,7 @@ lua_dns_callback (struct rdns_reply *reply, gpointer arg)
 				addr.af = AF_INET6;
 				addr.slen = sizeof (addr.addr.s6);
 				memcpy (&addr.addr.s6.sin6_addr, &elt->content.aaa.addr,
-					sizeof (addr.addr.s6.sin6_addr));
+						sizeof (addr.addr.s6.sin6_addr));
 				lua_ip_push (cd->L, &addr);
 				lua_rawseti (cd->L, -2, ++i);
 				break;
@@ -169,16 +168,16 @@ lua_dns_callback (struct rdns_reply *reply, gpointer arg)
 static int
 lua_dns_resolver_init (lua_State *L)
 {
-	struct rspamd_dns_resolver *resolver, **presolver;
-	struct rspamd_config *cfg, **pcfg;
-	struct event_base *base, **pbase;
+	struct rspamd_dns_resolver					*resolver, **presolver;
+	struct rspamd_config 							*cfg, **pcfg;
+	struct event_base							*base, **pbase;
 
 	/* Check args */
 	pbase = luaL_checkudata (L, 1, "rspamd{ev_base}");
 	luaL_argcheck (L, pbase != NULL, 1, "'ev_base' expected");
 	base = pbase ? *(pbase) : NULL;
 	pcfg = luaL_checkudata (L, 2, "rspamd{config}");
-	luaL_argcheck (L, pcfg != NULL,	 2, "'config' expected");
+	luaL_argcheck (L, pcfg != NULL, 2, "'config' expected");
 	cfg = pcfg ? *(pcfg) : NULL;
 
 	if (base != NULL && cfg != NULL) {
@@ -200,27 +199,24 @@ lua_dns_resolver_init (lua_State *L)
 }
 
 static int
-lua_dns_resolver_resolve_common (lua_State *L,
-	struct rspamd_dns_resolver *resolver,
-	enum rdns_request_type type,
-	int first)
+lua_dns_resolver_resolve_common (lua_State *L, struct rspamd_dns_resolver *resolver,
+		enum rdns_request_type type, int first)
 {
-	struct rspamd_async_session *session, **psession;
-	rspamd_mempool_t *pool, **ppool;
-	const gchar *to_resolve;
-	struct lua_dns_cbdata *cbdata;
+	struct rspamd_async_session					*session, **psession;
+	rspamd_mempool_t								*pool, **ppool;
+	const gchar									*to_resolve;
+	struct lua_dns_cbdata						*cbdata;
 
 	/* Check arguments */
 	psession = luaL_checkudata (L, first, "rspamd{session}");
-	luaL_argcheck (L, psession != NULL, first,	   "'session' expected");
+	luaL_argcheck (L, psession != NULL, first, "'session' expected");
 	session = psession ? *(psession) : NULL;
 	ppool = luaL_checkudata (L, first + 1, "rspamd{mempool}");
-	luaL_argcheck (L, ppool != NULL,	first + 1, "'mempool' expected");
+	luaL_argcheck (L, ppool != NULL, first + 1, "'mempool' expected");
 	pool = ppool ? *(ppool) : NULL;
 	to_resolve = luaL_checkstring (L, first + 2);
 
-	if (pool != NULL && session != NULL && to_resolve != NULL &&
-		lua_isfunction (L, first + 3)) {
+	if (pool != NULL && session != NULL && to_resolve != NULL && lua_isfunction (L, first + 3)) {
 		cbdata = rspamd_mempool_alloc (pool, sizeof (struct lua_dns_cbdata));
 		cbdata->L = L;
 		cbdata->resolver = resolver;
@@ -247,13 +243,7 @@ lua_dns_resolver_resolve_common (lua_State *L,
 		else {
 			cbdata->user_str = NULL;
 		}
-		make_dns_request (resolver,
-			session,
-			pool,
-			lua_dns_callback,
-			cbdata,
-			type,
-			to_resolve);
+		make_dns_request (resolver, session, pool, lua_dns_callback, cbdata, type, to_resolve);
 		lua_pushboolean (L, TRUE);
 	}
 	else {
@@ -268,13 +258,10 @@ lua_dns_resolver_resolve_common (lua_State *L,
 static int
 lua_dns_resolver_resolve_a (lua_State *L)
 {
-	struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+	struct rspamd_dns_resolver					*dns_resolver = lua_check_dns_resolver (L);
 
 	if (dns_resolver) {
-		return lua_dns_resolver_resolve_common (L,
-				   dns_resolver,
-				   RDNS_REQUEST_A,
-				   2);
+		return lua_dns_resolver_resolve_common (L, dns_resolver, RDNS_REQUEST_A, 2);
 	}
 	else {
 		lua_pushnil (L);
@@ -286,13 +273,10 @@ lua_dns_resolver_resolve_a (lua_State *L)
 static int
 lua_dns_resolver_resolve_ptr (lua_State *L)
 {
-	struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+	struct rspamd_dns_resolver					*dns_resolver = lua_check_dns_resolver (L);
 
 	if (dns_resolver) {
-		return lua_dns_resolver_resolve_common (L,
-				   dns_resolver,
-				   RDNS_REQUEST_PTR,
-				   2);
+		return lua_dns_resolver_resolve_common (L, dns_resolver, RDNS_REQUEST_PTR, 2);
 	}
 	else {
 		lua_pushnil (L);
@@ -304,13 +288,10 @@ lua_dns_resolver_resolve_ptr (lua_State *L)
 static int
 lua_dns_resolver_resolve_txt (lua_State *L)
 {
-	struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+	struct rspamd_dns_resolver					*dns_resolver = lua_check_dns_resolver (L);
 
 	if (dns_resolver) {
-		return lua_dns_resolver_resolve_common (L,
-				   dns_resolver,
-				   RDNS_REQUEST_TXT,
-				   2);
+		return lua_dns_resolver_resolve_common (L, dns_resolver, RDNS_REQUEST_TXT, 2);
 	}
 	else {
 		lua_pushnil (L);
@@ -322,13 +303,10 @@ lua_dns_resolver_resolve_txt (lua_State *L)
 static int
 lua_dns_resolver_resolve_mx (lua_State *L)
 {
-	struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+	struct rspamd_dns_resolver					*dns_resolver = lua_check_dns_resolver (L);
 
 	if (dns_resolver) {
-		return lua_dns_resolver_resolve_common (L,
-				   dns_resolver,
-				   RDNS_REQUEST_MX,
-				   2);
+		return lua_dns_resolver_resolve_common (L, dns_resolver, RDNS_REQUEST_MX, 2);
 	}
 	else {
 		lua_pushnil (L);
@@ -340,7 +318,7 @@ lua_dns_resolver_resolve_mx (lua_State *L)
 static int
 lua_dns_resolver_resolve (lua_State *L)
 {
-	struct rspamd_dns_resolver *dns_resolver = lua_check_dns_resolver (L);
+	struct rspamd_dns_resolver					*dns_resolver = lua_check_dns_resolver (L);
 	int type;
 
 	type = lua_dns_get_type (L, 2);
@@ -369,18 +347,18 @@ luaopen_dns_resolver (lua_State * L)
 	lua_rawset (L, -3);
 
 	{
-		LUA_ENUM (L, RDNS_REQUEST_A,	 RDNS_REQUEST_A);
-		LUA_ENUM (L, RDNS_REQUEST_PTR, RDNS_REQUEST_PTR);
-		LUA_ENUM (L, RDNS_REQUEST_MX,	RDNS_REQUEST_MX);
-		LUA_ENUM (L, RDNS_REQUEST_TXT, RDNS_REQUEST_TXT);
-		LUA_ENUM (L, RDNS_REQUEST_SRV, RDNS_REQUEST_SRV);
-		LUA_ENUM (L, RDNS_REQUEST_SPF, RDNS_REQUEST_SRV);
-		LUA_ENUM (L, RDNS_REQUEST_AAA, RDNS_REQUEST_SRV);
+		LUA_ENUM(L, RDNS_REQUEST_A, RDNS_REQUEST_A);
+		LUA_ENUM(L, RDNS_REQUEST_PTR, RDNS_REQUEST_PTR);
+		LUA_ENUM(L, RDNS_REQUEST_MX, RDNS_REQUEST_MX);
+		LUA_ENUM(L, RDNS_REQUEST_TXT, RDNS_REQUEST_TXT);
+		LUA_ENUM(L, RDNS_REQUEST_SRV, RDNS_REQUEST_SRV);
+		LUA_ENUM(L, RDNS_REQUEST_SPF, RDNS_REQUEST_SRV);
+		LUA_ENUM(L, RDNS_REQUEST_AAA, RDNS_REQUEST_SRV);
 	}
 
-	luaL_register (L, NULL,				 dns_resolverlib_m);
+	luaL_register (L, NULL, dns_resolverlib_m);
 	luaL_register (L, "rspamd_resolver", dns_resolverlib_f);
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
-	return 1;
+	return 1;	
 }
diff --git a/src/lua/lua_http.c b/src/lua/lua_http.c
index 6d6201f03..60253c000 100644
--- a/src/lua/lua_http.c
+++ b/src/lua/lua_http.c
@@ -21,17 +21,17 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "lua_common.h"
 #include "buffer.h"
 #include "dns.h"
 #include "http.h"
-#include "lua_common.h"
 
 #define MAX_HEADERS_SIZE 8192
 
 LUA_FUNCTION_DEF (http, make_post_request);
 LUA_FUNCTION_DEF (http, make_get_request);
 
-static const struct luaL_reg httplib_m[] = {
+static const struct luaL_reg    httplib_m[] = {
 	LUA_INTERFACE_DEF (http, make_post_request),
 	LUA_INTERFACE_DEF (http, make_get_request),
 	{"__tostring", lua_class_tostring},
@@ -68,7 +68,7 @@ struct lua_http_ud {
 static void
 lua_http_fin (void *arg)
 {
-	struct lua_http_ud *ud = arg;
+	struct lua_http_ud             *ud = arg;
 
 	if (ud->callback == NULL) {
 		/* Unref callback */
@@ -81,8 +81,8 @@ lua_http_fin (void *arg)
 static void
 lua_http_push_error (gint code, struct lua_http_ud *ud)
 {
-	struct rspamd_task **ptask;
-	gint num;
+	struct rspamd_task            **ptask;
+	gint							num;
 
 	/* Push error */
 	if (ud->callback) {
@@ -104,9 +104,7 @@ lua_http_push_error (gint code, struct lua_http_ud *ud)
 	/* Reply */
 	lua_pushnil (ud->L);
 	if (lua_pcall (ud->L, num, 0, 0) != 0) {
-		msg_info ("call to %s failed: %s",
-			ud->callback ? ud->callback : "local function",
-			lua_tostring (ud->L, -1));
+		msg_info ("call to %s failed: %s", ud->callback ? ud->callback : "local function", lua_tostring (ud->L, -1));
 	}
 
 	if (ud->headers != NULL) {
@@ -122,10 +120,10 @@ lua_http_push_error (gint code, struct lua_http_ud *ud)
 static void
 lua_http_push_reply (f_str_t *in, struct lua_http_ud *ud)
 {
-	GList *cur;
-	struct lua_http_header *header;
-	struct rspamd_task **ptask;
-	gint num;
+	GList                          *cur;
+	struct lua_http_header         *header;
+	struct rspamd_task            **ptask;
+	gint							num;
 
 	if (ud->callback) {
 		/* Push error */
@@ -158,14 +156,12 @@ lua_http_push_reply (f_str_t *in, struct lua_http_ud *ud)
 
 	/* Date */
 	if (ud->date != (time_t)-1) {
-		num++;
+		num ++;
 		lua_pushnumber (ud->L, ud->date);
 	}
 
 	if (lua_pcall (ud->L, num, 0, 0) != 0) {
-		msg_info ("call to %s failed: %s",
-			ud->callback ? ud->callback : "local function",
-			lua_tostring (ud->L, -1));
+		msg_info ("call to %s failed: %s", ud->callback ? ud->callback : "local function", lua_tostring (ud->L, -1));
 	}
 
 	if (ud->headers != NULL) {
@@ -183,7 +179,7 @@ lua_http_push_reply (f_str_t *in, struct lua_http_ud *ud)
 static gboolean
 lua_http_parse_first_line (struct lua_http_ud *ud, f_str_t *in)
 {
-	const gchar *p;
+	const gchar                    *p;
 
 	/* Assume first line is like this: HTTP/1.1 200 OK */
 	if (in->len < sizeof ("HTTP/1.1 OK") + 2) {
@@ -201,14 +197,14 @@ lua_http_parse_first_line (struct lua_http_ud *ud, f_str_t *in)
 static gboolean
 lua_http_parse_header_line (struct lua_http_ud *ud, f_str_t *in)
 {
-	const gchar *p = in->begin;
-	struct lua_http_header *new;
+	const gchar                    *p = in->begin;
+	struct lua_http_header         *new;
 
 	while (p < in->begin + in->len) {
 		if (*p == ':') {
 			break;
 		}
-		p++;
+		p ++;
 	}
 
 	if (*p != ':') {
@@ -219,17 +215,16 @@ lua_http_parse_header_line (struct lua_http_ud *ud, f_str_t *in)
 	new->name = rspamd_mempool_alloc (ud->pool, p - in->begin + 1);
 	rspamd_strlcpy (new->name, in->begin, p - in->begin + 1);
 
-	p++;
+	p ++;
 	/* Copy value */
 	while (p < in->begin + in->len && g_ascii_isspace (*p)) {
-		p++;
+		p ++;
 	}
 	new->value = rspamd_mempool_alloc (ud->pool, in->begin + in->len - p + 1);
 	rspamd_strlcpy (new->value, p, in->begin + in->len - p + 1);
 
 	/* Check content-length */
-	if (ud->rep_len == 0 &&
-		g_ascii_strcasecmp (new->name, "content-length") == 0) {
+	if (ud->rep_len == 0 && g_ascii_strcasecmp (new->name, "content-length") == 0) {
 		ud->rep_len = strtoul (new->value, NULL, 10);
 	}
 
@@ -248,7 +243,7 @@ lua_http_parse_header_line (struct lua_http_ud *ud, f_str_t *in)
 static gboolean
 lua_http_read_cb (f_str_t * in, void *arg)
 {
-	struct lua_http_ud *ud = arg;
+	struct lua_http_ud             *ud = arg;
 
 	switch (ud->parser_state) {
 	case 0:
@@ -270,9 +265,7 @@ lua_http_read_cb (f_str_t * in, void *arg)
 			}
 			else {
 				ud->parser_state = 2;
-				rspamd_set_dispatcher_policy (ud->io_dispatcher,
-					BUFFER_CHARACTER,
-					ud->rep_len);
+				rspamd_set_dispatcher_policy (ud->io_dispatcher, BUFFER_CHARACTER, ud->rep_len);
 			}
 		}
 		else {
@@ -291,9 +284,8 @@ lua_http_read_cb (f_str_t * in, void *arg)
 static void
 lua_http_err_cb (GError * err, void *arg)
 {
-	struct lua_http_ud *ud = arg;
-	msg_info ("abnormally closing connection to http server error: %s",
-		err->message);
+	struct lua_http_ud             *ud = arg;
+	msg_info ("abnormally closing connection to http server error: %s", err->message);
 	g_error_free (err);
 
 	if (ud->parser_state != 3) {
@@ -309,10 +301,10 @@ lua_http_err_cb (GError * err, void *arg)
 static void
 lua_http_dns_callback (struct rdns_reply *reply, gpointer arg)
 {
-	struct lua_http_ud *ud = arg;
-	struct rdns_reply_entry *elt;
-	struct in_addr ina;
-	struct timeval tv;
+	struct lua_http_ud             *ud = arg;
+	struct rdns_reply_entry        *elt;
+	struct in_addr                  ina;
+	struct timeval                  tv;
 
 	if (reply->code != RDNS_RC_NOERROR) {
 		lua_http_push_error (450, ud);
@@ -323,8 +315,7 @@ lua_http_dns_callback (struct rdns_reply *reply, gpointer arg)
 	elt = reply->entries;
 	memcpy (&ina, &elt->content.a.addr, sizeof (struct in_addr));
 
-	ud->fd = make_universal_socket (inet_ntoa (
-				ina), ud->port, SOCK_STREAM, TRUE, FALSE, FALSE);
+	ud->fd = make_universal_socket (inet_ntoa (ina), ud->port, SOCK_STREAM, TRUE, FALSE, FALSE);
 
 	if (ud->fd == -1) {
 		lua_http_push_error (450, ud);
@@ -333,20 +324,12 @@ lua_http_dns_callback (struct rdns_reply *reply, gpointer arg)
 
 	/* Create dispatcher for HTTP protocol */
 	msec_to_tv (ud->timeout, &tv);
-	ud->io_dispatcher = rspamd_create_dispatcher (ud->ev_base,
-			ud->fd,
-			BUFFER_LINE,
-			lua_http_read_cb,
-			NULL,
-			lua_http_err_cb,
-			&tv,
-			ud);
+	ud->io_dispatcher = rspamd_create_dispatcher (ud->ev_base, ud->fd, BUFFER_LINE, lua_http_read_cb, NULL,
+			lua_http_err_cb, &tv, ud);
 	/* Write request */
-	register_async_event (ud->s, lua_http_fin, ud,
-		g_quark_from_static_string ("lua http"));
+	register_async_event (ud->s, lua_http_fin, ud, g_quark_from_static_string ("lua http"));
 
-	if (!rspamd_dispatcher_write (ud->io_dispatcher, ud->req_buf, ud->req_len,
-		TRUE, TRUE)) {
+	if (!rspamd_dispatcher_write (ud->io_dispatcher, ud->req_buf, ud->req_len, TRUE, TRUE)) {
 		lua_http_push_error (450, ud);
 		return;
 	}
@@ -356,22 +339,16 @@ lua_http_dns_callback (struct rdns_reply *reply, gpointer arg)
  * Common request function
  */
 static gint
-lua_http_make_request_common (lua_State *L,
-	struct rspamd_task *task,
-	const gchar *callback,
-	const gchar *hostname,
-	const gchar *path,
-	const gchar *data,
-	gint top)
+lua_http_make_request_common (lua_State *L, struct rspamd_task *task, const gchar *callback,
+		const gchar *hostname, const gchar *path, const gchar *data, gint top)
 {
-	gint r, s, datalen;
-	struct lua_http_ud *ud;
+	gint                           r, s, datalen;
+	struct lua_http_ud			  *ud;
 
 	/* Calculate buffer size */
 	datalen = (data != NULL) ? strlen (data) : 0;
-	s = MAX_HEADERS_SIZE + sizeof (CRLF) * 3 + strlen (hostname) +
-		strlen (path) + datalen
-		+ sizeof ("POST HTTP/1.1");
+	s = MAX_HEADERS_SIZE + sizeof (CRLF) * 3 + strlen (hostname) + strlen (path) + datalen
+			+ sizeof ("POST HTTP/1.1");
 
 	ud = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct lua_http_ud));
 	ud->L = L;
@@ -385,14 +362,11 @@ lua_http_make_request_common (lua_State *L,
 
 	/* Print request */
 	r = rspamd_snprintf (ud->req_buf, s, "%s %s HTTP/1.1" CRLF
-			"Connection: close" CRLF
-			"Host: %s" CRLF,
-			(data != NULL) ? "POST" : "GET", path, hostname);
+										 "Connection: close" CRLF
+										 "Host: %s" CRLF,
+										 (data != NULL) ? "POST" : "GET", path, hostname);
 	if (datalen > 0) {
-		r += rspamd_snprintf (ud->req_buf + r,
-				s - r,
-				"Content-Length: %d" CRLF,
-				datalen);
+		r += rspamd_snprintf (ud->req_buf + r, s - r, "Content-Length: %d" CRLF, datalen);
 	}
 	/* Now assume that we have a table with headers at the top of the stack */
 
@@ -400,12 +374,8 @@ lua_http_make_request_common (lua_State *L,
 		/* Add headers */
 		lua_pushnil (L);  /* first key */
 		while (lua_next (L, top + 1) != 0) {
-			r += rspamd_snprintf (ud->req_buf + r,
-					s - r,
-					"%s: %s" CRLF,
-					lua_tostring (L, -2),
-					lua_tostring (L, -1));
-			lua_pop (L, 1);
+			r += rspamd_snprintf (ud->req_buf + r, s - r, "%s: %s" CRLF, lua_tostring (L, -2), lua_tostring (L, -1));
+			lua_pop(L, 1);
 		}
 	}
 	/* Now check port and timeout */
@@ -433,10 +403,9 @@ lua_http_make_request_common (lua_State *L,
 	ud->req_len = r;
 
 	/* Resolve hostname */
-	if (make_dns_request (task->resolver, task->s, task->task_pool,
-		lua_http_dns_callback, ud,
-		RDNS_REQUEST_A, hostname)) {
-		task->dns_requests++;
+	if (make_dns_request (task->resolver, task->s, task->task_pool, lua_http_dns_callback, ud,
+			RDNS_REQUEST_A, hostname)) {
+		task->dns_requests ++;
 	}
 
 	return 0;
@@ -446,26 +415,18 @@ lua_http_make_request_common (lua_State *L,
  * Common request function (new version)
  */
 static gint
-lua_http_make_request_common_new (lua_State *L,
-	struct rspamd_async_session *session,
-	rspamd_mempool_t *pool,
-	struct event_base *base,
-	gint cbref,
-	const gchar *hostname,
-	const gchar *path,
-	const gchar *data,
-	gint top)
+lua_http_make_request_common_new (lua_State *L, struct rspamd_async_session *session, rspamd_mempool_t *pool, struct event_base *base, gint cbref,
+		const gchar *hostname, const gchar *path, const gchar *data, gint top)
 {
-	gint r, s, datalen;
-	struct lua_http_ud *ud;
-	struct in_addr ina;
-	struct timeval tv;
+	gint                           r, s, datalen;
+	struct lua_http_ud			  *ud;
+	struct in_addr				   ina;
+	struct timeval                 tv;
 
 	/* Calculate buffer size */
 	datalen = (data != NULL) ? strlen (data) : 0;
-	s = MAX_HEADERS_SIZE + sizeof (CRLF) * 3 + strlen (hostname) +
-		strlen (path) + datalen
-		+ sizeof ("POST HTTP/1.1");
+	s = MAX_HEADERS_SIZE + sizeof (CRLF) * 3 + strlen (hostname) + strlen (path) + datalen
+			+ sizeof ("POST HTTP/1.1");
 
 	ud = rspamd_mempool_alloc0 (pool, sizeof (struct lua_http_ud));
 	ud->L = L;
@@ -479,13 +440,10 @@ lua_http_make_request_common_new (lua_State *L,
 
 	/* Print request */
 	r = rspamd_snprintf (ud->req_buf, s, "%s %s HTTP/1.1" CRLF
-			"Connection: close" CRLF,
-			(data != NULL) ? "POST" : "GET", path);
+										 "Connection: close" CRLF,
+										 (data != NULL) ? "POST" : "GET", path);
 	if (datalen > 0) {
-		r += rspamd_snprintf (ud->req_buf + r,
-				s - r,
-				"Content-Length: %d" CRLF,
-				datalen);
+		r += rspamd_snprintf (ud->req_buf + r, s - r, "Content-Length: %d" CRLF, datalen);
 	}
 	/* Now assume that we have a table with headers at the top of the stack */
 
@@ -493,11 +451,7 @@ lua_http_make_request_common_new (lua_State *L,
 		/* Add headers */
 		lua_pushnil (L);  /* first key */
 		while (lua_next (L, top + 1) != 0) {
-			r += rspamd_snprintf (ud->req_buf + r,
-					s - r,
-					"%s: %s" CRLF,
-					lua_tostring (L, -2),
-					lua_tostring (L, -1));
+			r += rspamd_snprintf (ud->req_buf + r, s - r, "%s: %s" CRLF, lua_tostring (L, -2), lua_tostring (L, -1));
 			lua_pop (L, 1);
 		}
 	}
@@ -532,8 +486,7 @@ lua_http_make_request_common_new (lua_State *L,
 		return 1;
 	}
 
-	ud->fd = make_universal_socket (inet_ntoa (
-				ina), ud->port, SOCK_STREAM, TRUE, FALSE, FALSE);
+	ud->fd = make_universal_socket (inet_ntoa (ina), ud->port, SOCK_STREAM, TRUE, FALSE, FALSE);
 
 	if (ud->fd == -1) {
 		luaL_unref (L, LUA_REGISTRYINDEX, cbref);
@@ -543,20 +496,12 @@ lua_http_make_request_common_new (lua_State *L,
 
 	/* Create dispatcher for HTTP protocol */
 	msec_to_tv (ud->timeout, &tv);
-	ud->io_dispatcher = rspamd_create_dispatcher (ud->ev_base,
-			ud->fd,
-			BUFFER_LINE,
-			lua_http_read_cb,
-			NULL,
-			lua_http_err_cb,
-			&tv,
-			ud);
+	ud->io_dispatcher = rspamd_create_dispatcher (ud->ev_base, ud->fd, BUFFER_LINE, lua_http_read_cb, NULL,
+			lua_http_err_cb, &tv, ud);
 	/* Write request */
-	register_async_event (ud->s, lua_http_fin, ud,
-		g_quark_from_static_string ("lua http"));
+	register_async_event (ud->s, lua_http_fin, ud, g_quark_from_static_string ("lua http"));
 
-	if (!rspamd_dispatcher_write (ud->io_dispatcher, ud->req_buf, ud->req_len,
-		TRUE, TRUE)) {
+	if (!rspamd_dispatcher_write (ud->io_dispatcher, ud->req_buf, ud->req_len, TRUE, TRUE)) {
 		luaL_unref (L, LUA_REGISTRYINDEX, cbref);
 		lua_pushnil (L);
 		return 1;
@@ -573,12 +518,12 @@ lua_http_make_request_common_new (lua_State *L,
 static gint
 lua_http_make_post_request (lua_State *L)
 {
-	struct rspamd_task *task, **ptask;
-	rspamd_mempool_t *pool, **ppool;
-	struct rspamd_async_session *session, **psession;
-	struct event_base *base, **pbase;
-	const gchar *hostname, *path, *data, *callback;
-	gint cbref;
+	struct rspamd_task            *task, **ptask;
+	rspamd_mempool_t				  *pool, **ppool;
+	struct rspamd_async_session	  *session, **psession;
+	struct event_base			  *base, **pbase;
+	const gchar                   *hostname, *path, *data, *callback;
+	gint						   cbref;
 
 
 	/* Check whether we have a task object */
@@ -590,32 +535,23 @@ lua_http_make_post_request (lua_State *L)
 		luaL_argcheck (L, psession != NULL, 1, "'session' expected");
 		session = psession ? *(psession) : NULL;
 		ppool = luaL_checkudata (L, 2, "rspamd{mempool}");
-		luaL_argcheck (L, ppool != NULL,	2, "'mempool' expected");
+		luaL_argcheck (L, ppool != NULL, 2, "'mempool' expected");
 		pool = ppool ? *(ppool) : NULL;
 		pbase = luaL_checkudata (L, 3, "rspamd{ev_base}");
-		luaL_argcheck (L, ppool != NULL,	3, "'ev_base' expected");
+		luaL_argcheck (L, ppool != NULL, 3, "'ev_base' expected");
 		base = pbase ? *(pbase) : NULL;
 	}
 
 	/* Now extract hostname, path and data */
 
 	if (task) {
-		callback =
-			rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
-		hostname =
-			rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
+		callback = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
+		hostname = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
 		path = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 4));
 		data = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 5));
 
-		if (callback != NULL && hostname != NULL && path != NULL && data !=
-			NULL) {
-			return lua_http_make_request_common (L,
-					   task,
-					   callback,
-					   hostname,
-					   path,
-					   data,
-					   5);
+		if (callback != NULL && hostname != NULL && path != NULL && data != NULL) {
+			return lua_http_make_request_common (L, task, callback, hostname, path, data, 5);
 		}
 		else {
 			msg_info ("invalid arguments number");
@@ -626,19 +562,10 @@ lua_http_make_post_request (lua_State *L)
 		hostname = rspamd_mempool_strdup (pool, luaL_checkstring (L, 4));
 		path = rspamd_mempool_strdup (pool, luaL_checkstring (L, 5));
 		data = rspamd_mempool_strdup (pool, luaL_checkstring (L, 6));
-		if (session != NULL && pool != NULL && hostname != NULL && path !=
-			NULL && data != NULL && lua_isfunction (L, 7)) {
+		if (session != NULL && pool != NULL && hostname != NULL && path != NULL && data != NULL && lua_isfunction (L, 7)) {
 			lua_pushvalue (L, 7);
 			cbref = luaL_ref (L, LUA_REGISTRYINDEX);
-			return lua_http_make_request_common_new (L,
-					   session,
-					   pool,
-					   base,
-					   cbref,
-					   hostname,
-					   path,
-					   data,
-					   7);
+			return lua_http_make_request_common_new (L, session, pool, base, cbref, hostname, path, data, 7);
 		}
 	}
 
@@ -652,12 +579,12 @@ lua_http_make_post_request (lua_State *L)
 static gint
 lua_http_make_get_request (lua_State *L)
 {
-	struct rspamd_task *task, **ptask;
-	rspamd_mempool_t *pool, **ppool;
-	struct rspamd_async_session *session, **psession;
-	struct event_base *base, **pbase;
-	const gchar *hostname, *path, *callback;
-	gint cbref;
+	struct rspamd_task            *task, **ptask;
+	rspamd_mempool_t				  *pool, **ppool;
+	struct rspamd_async_session	  *session, **psession;
+	struct event_base			  *base, **pbase;
+	const gchar                   *hostname, *path, *callback;
+	gint						   cbref;
 
 
 	/* Check whether we have a task object */
@@ -669,30 +596,22 @@ lua_http_make_get_request (lua_State *L)
 		luaL_argcheck (L, psession != NULL, 1, "'session' expected");
 		session = psession ? *(psession) : NULL;
 		ppool = luaL_checkudata (L, 2, "rspamd{mempool}");
-		luaL_argcheck (L, ppool != NULL,	2, "'mempool' expected");
+		luaL_argcheck (L, ppool != NULL, 2, "'mempool' expected");
 		pool = ppool ? *(ppool) : NULL;
 		pbase = luaL_checkudata (L, 3, "rspamd{ev_base}");
-		luaL_argcheck (L, ppool != NULL,	3, "'ev_base' expected");
+		luaL_argcheck (L, ppool != NULL, 3, "'ev_base' expected");
 		base = pbase ? *(pbase) : NULL;
 	}
 
 	/* Now extract hostname, path and data */
 
 	if (task) {
-		callback =
-			rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
-		hostname =
-			rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
+		callback = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
+		hostname = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
 		path = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 4));
 
 		if (callback != NULL && hostname != NULL && path != NULL) {
-			return lua_http_make_request_common (L,
-					   task,
-					   callback,
-					   hostname,
-					   path,
-					   NULL,
-					   4);
+			return lua_http_make_request_common (L, task, callback, hostname, path, NULL, 4);
 		}
 		else {
 			msg_info ("invalid arguments number");
@@ -702,19 +621,10 @@ lua_http_make_get_request (lua_State *L)
 		/* Common version */
 		hostname = rspamd_mempool_strdup (pool, luaL_checkstring (L, 4));
 		path = rspamd_mempool_strdup (pool, luaL_checkstring (L, 5));
-		if (session != NULL && pool != NULL && hostname != NULL && path !=
-			NULL && lua_isfunction (L, 6)) {
+		if (session != NULL && pool != NULL && hostname != NULL && path != NULL && lua_isfunction (L, 6)) {
 			lua_pushvalue (L, 6);
 			cbref = luaL_ref (L, LUA_REGISTRYINDEX);
-			return lua_http_make_request_common_new (L,
-					   session,
-					   pool,
-					   base,
-					   cbref,
-					   hostname,
-					   path,
-					   NULL,
-					   6);
+			return lua_http_make_request_common_new (L, session, pool, base, cbref, hostname, path, NULL, 6);
 		}
 	}
 
diff --git a/src/lua/lua_ip.c b/src/lua/lua_ip.c
index 3292d93e7..f477e1d77 100644
--- a/src/lua/lua_ip.c
+++ b/src/lua/lua_ip.c
@@ -34,7 +34,7 @@ LUA_FUNCTION_DEF (ip, destroy);
 LUA_FUNCTION_DEF (ip, get_version);
 LUA_FUNCTION_DEF (ip, is_valid);
 
-static const struct luaL_reg iplib_m[] = {
+static const struct luaL_reg    iplib_m[] = {
 	LUA_INTERFACE_DEF (ip, to_string),
 	LUA_INTERFACE_DEF (ip, to_table),
 	LUA_INTERFACE_DEF (ip, to_number),
@@ -47,13 +47,13 @@ static const struct luaL_reg iplib_m[] = {
 	{NULL, NULL}
 };
 
-static const struct luaL_reg iplib_f[] = {
+static const struct luaL_reg    iplib_f[] = {
 	LUA_INTERFACE_DEF (ip, from_string),
 	LUA_INTERFACE_DEF (ip, from_number),
 	{NULL, NULL}
 };
 
-static struct rspamd_lua_ip *
+static struct rspamd_lua_ip	*
 lua_check_ip (lua_State * L, gint pos)
 {
 	void *ud = luaL_checkudata (L, pos, "rspamd{ip}");
@@ -80,7 +80,7 @@ lua_ip_to_table (lua_State *L)
 			ptr = (guint8 *)&ip->addr.addr.s6.sin6_addr;
 		}
 
-		for (i = 1; i <= max; i++, ptr++) {
+		for (i = 1; i <= max; i ++, ptr ++) {
 			lua_pushnumber (L, *ptr);
 			lua_rawseti (L, -2, i);
 		}
@@ -111,22 +111,19 @@ lua_ip_str_octets (lua_State *L)
 			ptr = (guint8 *)&ip->addr.addr.s6.sin6_addr;
 		}
 
-		for (i = 1; i <= max; i++, ptr++) {
+		for (i = 1; i <= max; i ++, ptr ++) {
 			if (ip->addr.af == AF_INET) {
 				rspamd_snprintf (numbuf, sizeof (numbuf), "%d", *ptr);
 				lua_pushstring (L, numbuf);
 				lua_rawseti (L, -2, i);
 			}
 			else {
-				rspamd_snprintf (numbuf,
-					sizeof (numbuf),
-					"%xd",
-					(*ptr & 0xf0) >> 4);
+				rspamd_snprintf (numbuf, sizeof (numbuf), "%xd", (*ptr & 0xf0) >> 4);
 				lua_pushstring (L, numbuf);
-				lua_rawseti (L, -2, i * 2 - 1);
+				lua_rawseti (L, -2, i*2 - 1);
 				rspamd_snprintf (numbuf, sizeof (numbuf), "%xd", *ptr & 0x0f);
 				lua_pushstring (L, numbuf);
-				lua_rawseti (L, -2, i * 2);
+				lua_rawseti (L, -2, i*2);
 			}
 		}
 	}
@@ -157,7 +154,7 @@ lua_ip_inversed_str_octets (lua_State *L)
 		}
 
 		ptr += max - 1;
-		for (i = 1; i <= max; i++, ptr--) {
+		for (i = 1; i <= max; i ++, ptr --) {
 			if (ip->addr.af == AF_INET) {
 				rspamd_snprintf (numbuf, sizeof (numbuf), "%d", *ptr);
 				lua_pushstring (L, numbuf);
@@ -166,13 +163,10 @@ lua_ip_inversed_str_octets (lua_State *L)
 			else {
 				rspamd_snprintf (numbuf, sizeof (numbuf), "%xd", *ptr & 0x0f);
 				lua_pushstring (L, numbuf);
-				lua_rawseti (L, -2, i * 2 - 1);
-				rspamd_snprintf (numbuf,
-					sizeof (numbuf),
-					"%xd",
-					(*ptr & 0xf0) >> 4);
+				lua_rawseti (L, -2, i*2 - 1);
+				rspamd_snprintf (numbuf, sizeof (numbuf), "%xd", (*ptr & 0xf0) >> 4);
 				lua_pushstring (L, numbuf);
-				lua_rawseti (L, -2, i * 2);
+				lua_rawseti (L, -2, i*2);
 			}
 		}
 	}
@@ -232,10 +226,9 @@ lua_ip_to_number (lua_State *L)
 		}
 		else {
 			/* 4 integers in host byte order */
-			G_STATIC_ASSERT (sizeof (ip->addr.addr.s6.sin6_addr) >=
-				sizeof (dst));
+			G_STATIC_ASSERT (sizeof (ip->addr.addr.s6.sin6_addr) >= sizeof (dst));
 			memcpy (dst, &ip->addr.addr.s6.sin6_addr, sizeof (dst));
-			for (i = 0; i < G_N_ELEMENTS (dst); i++) {
+			for (i = 0; i < G_N_ELEMENTS (dst); i ++) {
 				lua_pushinteger (L, ntohl (dst[i]));
 			}
 			return 4;
@@ -267,7 +260,7 @@ lua_ip_from_number (lua_State *L)
 	}
 	else if (lua_gettop (L) == 4 && lua_isnumber (L, 1)) {
 		/* Ipv6 version */
-		for (i = 0; i < 4; i++) {
+		for (i = 0; i < 4; i ++) {
 			src[i] = htonl (lua_tonumber (L, i + 1));
 		}
 		G_STATIC_ASSERT (sizeof (ip->addr.addr.s6.sin6_addr) >= sizeof (src));
@@ -377,7 +370,7 @@ luaopen_ip (lua_State * L)
 	lua_pushstring (L, "rspamd{ip}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,		   iplib_m);
+	luaL_register (L, NULL, iplib_m);
 	luaL_register (L, "rspamd_ip", iplib_f);
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
diff --git a/src/lua/lua_mempool.c b/src/lua/lua_mempool.c
index 50de17dd1..2648a60b2 100644
--- a/src/lua/lua_mempool.c
+++ b/src/lua/lua_mempool.c
@@ -25,7 +25,7 @@
 #include "mem_pool.h"
 
 /* Public prototypes */
-struct memory_pool_s * lua_check_mempool (lua_State * L);
+struct memory_pool_s *lua_check_mempool (lua_State * L);
 gint luaopen_mempool (lua_State * L);
 
 /* Lua bindings */
@@ -37,7 +37,7 @@ LUA_FUNCTION_DEF (mempool, memory_pool_suggest_size);
 LUA_FUNCTION_DEF (mempool, memory_pool_set_variable);
 LUA_FUNCTION_DEF (mempool, memory_pool_get_variable);
 
-static const struct luaL_reg mempoollib_m[] = {
+static const struct luaL_reg    mempoollib_m[] = {
 	LUA_INTERFACE_DEF (mempool, memory_pool_add_destructor),
 	LUA_INTERFACE_DEF (mempool, memory_pool_stat),
 	LUA_INTERFACE_DEF (mempool, memory_pool_suggest_size),
@@ -48,7 +48,7 @@ static const struct luaL_reg mempoollib_m[] = {
 	{NULL, NULL}
 };
 
-static const struct luaL_reg mempoollib_f[] = {
+static const struct luaL_reg    mempoollib_f[] = {
 	LUA_INTERFACE_DEF (mempool, create),
 	{NULL, NULL}
 };
@@ -63,10 +63,10 @@ struct lua_mempool_udata {
 	rspamd_mempool_t *mempool;
 };
 
-struct memory_pool_s *
+struct memory_pool_s      *
 lua_check_mempool (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{mempool}");
+	void								*ud = luaL_checkudata (L, 1, "rspamd{mempool}");
 	luaL_argcheck (L, ud != NULL, 1, "'mempool' expected");
 	return ud ? *((struct memory_pool_s **)ud) : NULL;
 }
@@ -75,8 +75,7 @@ lua_check_mempool (lua_State * L)
 static int
 lua_mempool_create (lua_State *L)
 {
-	struct memory_pool_s *mempool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ()), **pmempool;
+	struct memory_pool_s					*mempool = rspamd_mempool_new (rspamd_mempool_suggest_size ()), **pmempool;
 
 	if (mempool) {
 		pmempool = lua_newuserdata (L, sizeof (struct memory_pool_s *));
@@ -93,7 +92,7 @@ lua_mempool_create (lua_State *L)
 static void
 lua_mempool_destructor_func (gpointer p)
 {
-	struct lua_mempool_udata *ud = p;
+	struct lua_mempool_udata				*ud = p;
 
 	lua_rawgeti (ud->L, LUA_REGISTRYINDEX, ud->cbref);
 	if (lua_pcall (ud->L, 0, 0, 0) != 0) {
@@ -105,21 +104,18 @@ lua_mempool_destructor_func (gpointer p)
 static int
 lua_mempool_memory_pool_add_destructor (lua_State *L)
 {
-	struct memory_pool_s *mempool = lua_check_mempool (L);
-	struct lua_mempool_udata *ud;
+	struct memory_pool_s					*mempool = lua_check_mempool (L);
+	struct lua_mempool_udata				*ud;
 
 	if (mempool) {
 		if (lua_isfunction (L, 2)) {
-			ud = rspamd_mempool_alloc (mempool,
-					sizeof (struct lua_mempool_udata));
+			ud = rspamd_mempool_alloc (mempool, sizeof (struct lua_mempool_udata));
 			lua_pushvalue (L, 2);
 			/* Get a reference */
 			ud->cbref = luaL_ref (L, LUA_REGISTRYINDEX);
 			ud->L = L;
 			ud->mempool = mempool;
-			rspamd_mempool_add_destructor (mempool,
-				lua_mempool_destructor_func,
-				ud);
+			rspamd_mempool_add_destructor (mempool, lua_mempool_destructor_func, ud);
 		}
 		else {
 			msg_err ("trying to add destructor without function");
@@ -135,7 +131,7 @@ lua_mempool_memory_pool_add_destructor (lua_State *L)
 static int
 lua_mempool_memory_pool_delete (lua_State *L)
 {
-	struct memory_pool_s *mempool = lua_check_mempool (L);
+	struct memory_pool_s					*mempool = lua_check_mempool (L);
 
 	if (mempool) {
 		rspamd_mempool_delete (mempool);
@@ -151,10 +147,10 @@ lua_mempool_memory_pool_delete (lua_State *L)
 static int
 lua_mempool_memory_pool_stat (lua_State *L)
 {
-	struct memory_pool_s *mempool = lua_check_mempool (L);
+	struct memory_pool_s					*mempool = lua_check_mempool (L);
 
 	if (mempool) {
-
+		
 	}
 	else {
 		lua_pushnil (L);
@@ -166,7 +162,7 @@ lua_mempool_memory_pool_stat (lua_State *L)
 static int
 lua_mempool_memory_pool_suggest_size (lua_State *L)
 {
-	struct memory_pool_s *mempool = lua_check_mempool (L);
+	struct memory_pool_s					*mempool = lua_check_mempool (L);
 
 	if (mempool) {
 		lua_pushinteger (L, rspamd_mempool_suggest_size ());
@@ -182,13 +178,12 @@ lua_mempool_memory_pool_suggest_size (lua_State *L)
 static int
 lua_mempool_memory_pool_set_variable (lua_State *L)
 {
-	struct memory_pool_s *mempool = lua_check_mempool (L);
-	const gchar *var = luaL_checkstring (L, 2),
-	*value = luaL_checkstring (L, 3);
+	struct memory_pool_s					*mempool = lua_check_mempool (L);
+	const gchar								*var = luaL_checkstring (L, 2),
+											*value = luaL_checkstring (L, 3);
 
 	if (mempool && var && value) {
-		rspamd_mempool_set_variable (mempool, var,
-			rspamd_mempool_strdup (mempool, value), NULL);
+		rspamd_mempool_set_variable (mempool, var, rspamd_mempool_strdup (mempool, value), NULL);
 		return 0;
 	}
 	else {
@@ -201,9 +196,9 @@ lua_mempool_memory_pool_set_variable (lua_State *L)
 static int
 lua_mempool_memory_pool_get_variable (lua_State *L)
 {
-	struct memory_pool_s *mempool = lua_check_mempool (L);
-	const gchar *var = luaL_checkstring (L, 2);
-	gchar *value;
+	struct memory_pool_s					*mempool = lua_check_mempool (L);
+	const gchar								*var = luaL_checkstring (L, 2);
+	gchar									*value;
 
 	if (mempool && var) {
 		value = rspamd_mempool_get_variable (mempool, var);
@@ -233,10 +228,10 @@ luaopen_mempool (lua_State * L)
 	lua_pushstring (L, "rspamd{mempool}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,				mempoollib_m);
+	luaL_register (L, NULL, mempoollib_m);
 	luaL_register (L, "rspamd_mempool", mempoollib_f);
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
 
-	return 1;
+	return 1;	
 }
diff --git a/src/lua/lua_message.c b/src/lua/lua_message.c
index 8dd89c75c..f02178d1a 100644
--- a/src/lua/lua_message.c
+++ b/src/lua/lua_message.c
@@ -26,35 +26,35 @@
 #include "lua_common.h"
 #include "message.h"
 
-#define LUA_GMIME_BRIDGE_GET(class, name, mime_class)                                   \
-	static gint                                                                             \
-	lua_ ## class ## _ ## name (lua_State * L)                                                      \
-	{                                                                                       \
-		GMime ## mime_class * obj = lua_check_ ## class (L);                                      \
-		if (obj != NULL) {                                                                  \
-			lua_pushstring (L, g_mime_ ## class ## _ ## name (obj));                               \
-		}                                                                                   \
-		else {                                                                              \
-			lua_pushnil (L);                                                                \
-		}                                                                                   \
-		return 1;                                                                           \
-	}
+#define LUA_GMIME_BRIDGE_GET(class, name, mime_class)									\
+static gint																				\
+lua_##class##_##name(lua_State *L)														\
+{																						\
+	GMime##mime_class *obj = lua_check_##class(L);										\
+	if (obj != NULL) {																	\
+		lua_pushstring (L, g_mime_##class##_##name(obj));								\
+	}																					\
+	else {																				\
+		lua_pushnil (L);																\
+	}																					\
+	return 1;																			\
+}
 
-#define LUA_GMIME_BRIDGE_SET(class, name, mime_class)                                   \
-	static gint                                                                             \
-	lua_ ## class ## _ ## name (lua_State * L)                                                      \
-	{                                                                                       \
-		const gchar *str;                                                                   \
-		GMime ## mime_class * obj = lua_check_ ## class (L);                                      \
-		if (obj != NULL) {                                                                  \
-			str = luaL_checkstring (L, 2);                                                  \
-			g_mime_ ## class ## _ ## name (obj, str);                                              \
-		}                                                                                   \
-		else {                                                                              \
-			lua_pushnil (L);                                                                \
-		}                                                                                   \
-		return 1;                                                                           \
-	}
+#define LUA_GMIME_BRIDGE_SET(class, name, mime_class)									\
+static gint																				\
+lua_##class##_##name(lua_State *L)														\
+{																						\
+	const gchar *str;																	\
+	GMime##mime_class *obj = lua_check_##class(L);										\
+	if (obj != NULL) {																	\
+		str = luaL_checkstring (L, 2);													\
+		g_mime_##class##_##name(obj, str);												\
+	}																					\
+	else {																				\
+		lua_pushnil (L);																\
+	}																					\
+	return 1;																			\
+}
 
 /*  Message methods */
 LUA_FUNCTION_DEF (message, get_subject);
@@ -70,7 +70,7 @@ LUA_FUNCTION_DEF (message, get_header_strong);
 LUA_FUNCTION_DEF (message, set_header);
 LUA_FUNCTION_DEF (message, get_date);
 
-static const struct luaL_reg msglib_m[] = {
+static const struct luaL_reg    msglib_m[] = {
 	LUA_INTERFACE_DEF (message, get_subject),
 	LUA_INTERFACE_DEF (message, set_subject),
 	LUA_INTERFACE_DEF (message, get_message_id),
@@ -89,10 +89,10 @@ static const struct luaL_reg msglib_m[] = {
 
 
 
-static GMimeMessage *
+static GMimeMessage            *
 lua_check_message (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{message}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{message}");
 	luaL_argcheck (L, ud != NULL, 1, "'message' expected");
 	return ud ? *((GMimeMessage **) ud) : NULL;
 }
@@ -112,10 +112,10 @@ LUA_GMIME_BRIDGE_SET (message, set_reply_to, Message)
 static gint
 lua_message_get_header_common (lua_State * L, gboolean strong)
 {
-	const gchar *headern;
-	GMimeMessage *obj = lua_check_message (L);
-	GList *res = NULL, *cur;
-	gint i = 1;
+	const gchar                     *headern;
+	GMimeMessage                   *obj = lua_check_message (L);
+	GList                          *res = NULL, *cur;
+	gint                            i = 1;
 
 	if (obj != NULL) {
 		headern = luaL_checkstring (L, 2);
@@ -162,8 +162,8 @@ lua_message_get_header_strong (lua_State * L)
 static gint
 lua_message_set_header (lua_State * L)
 {
-	const gchar *headern, *headerv;
-	GMimeMessage *obj = lua_check_message (L);
+	const gchar                     *headern, *headerv;
+	GMimeMessage                   *obj = lua_check_message (L);
 
 	if (obj != NULL) {
 		headern = luaL_checkstring (L, 2);
@@ -185,9 +185,9 @@ lua_message_set_header (lua_State * L)
 static gint
 lua_message_get_date (lua_State * L)
 {
-	GMimeMessage *obj = lua_check_message (L);
-	time_t msg_time;
-	int offset;
+	GMimeMessage                   *obj = lua_check_message (L);
+	time_t                          msg_time;
+	int                             offset;
 
 	if (obj != NULL) {
 		g_mime_message_get_date (obj, &msg_time, &offset);
diff --git a/src/lua/lua_redis.c b/src/lua/lua_redis.c
index 9d5ab5a5f..2642daf9a 100644
--- a/src/lua/lua_redis.c
+++ b/src/lua/lua_redis.c
@@ -21,17 +21,17 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "dns.h"
 #include "lua_common.h"
+#include "dns.h"
 
 #ifndef WITH_SYSTEM_HIREDIS
-#include "adapters/libevent.h"
-#include "async.h"
 #include "hiredis.h"
+#include "async.h"
+#include "adapters/libevent.h"
 #else
-#include <hiredis/adapters/libevent.h>
-#include <hiredis/async.h>
 #include <hiredis/hiredis.h>
+#include <hiredis/async.h>
+#include <hiredis/adapters/libevent.h>
 #endif
 
 
@@ -41,7 +41,7 @@
 
 LUA_FUNCTION_DEF (redis, make_request);
 
-static const struct luaL_reg redislib_m[] = {
+static const struct luaL_reg    redislib_m[] = {
 	LUA_INTERFACE_DEF (redis, make_request),
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
@@ -68,10 +68,10 @@ struct lua_redis_userdata {
  * @param L lua stack
  * @return worker task object
  */
-static struct rspamd_task *
+static struct rspamd_task      *
 lua_check_task (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{task}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{task}");
 	luaL_argcheck (L, ud != NULL, 1, "'task' expected");
 	return ud ? *((struct rspamd_task **)ud) : NULL;
 }
@@ -79,7 +79,7 @@ lua_check_task (lua_State * L)
 static void
 lua_redis_fin (void *arg)
 {
-	struct lua_redis_userdata *ud = arg;
+	struct lua_redis_userdata			*ud = arg;
 
 	if (ud->ctx) {
 		redisAsyncFree (ud->ctx);
@@ -93,11 +93,9 @@ lua_redis_fin (void *arg)
  * @param ud
  */
 static void
-lua_redis_push_error (const gchar *err,
-	struct lua_redis_userdata *ud,
-	gboolean connected)
+lua_redis_push_error (const gchar *err, struct lua_redis_userdata *ud, gboolean connected)
 {
-	struct rspamd_task **ptask;
+	struct rspamd_task					**ptask;
 
 	/* Push error */
 	lua_rawgeti (ud->L, LUA_REGISTRYINDEX, ud->cbref);
@@ -127,7 +125,7 @@ lua_redis_push_error (const gchar *err,
 static void
 lua_redis_push_data (const redisReply *r, struct lua_redis_userdata *ud)
 {
-	struct rspamd_task **ptask;
+	struct rspamd_task					**ptask;
 
 	/* Push error */
 	lua_rawgeti (ud->L, LUA_REGISTRYINDEX, ud->cbref);
@@ -171,8 +169,8 @@ lua_redis_push_data (const redisReply *r, struct lua_redis_userdata *ud)
 static void
 lua_redis_callback (redisAsyncContext *c, gpointer r, gpointer priv)
 {
-	redisReply *reply = r;
-	struct lua_redis_userdata *ud = priv;
+	redisReply 							*reply = r;
+	struct lua_redis_userdata			*ud = priv;
 
 	if (c->err == 0) {
 		if (r != NULL) {
@@ -206,16 +204,11 @@ lua_redis_make_request_real (struct lua_redis_userdata *ud)
 {
 	ud->ctx = redisAsyncConnect (inet_ntoa (ud->ina), ud->port);
 	if (ud->ctx == NULL || ud->ctx->err) {
-		lua_redis_push_error (ud->ctx ? ud->ctx->errstr : "unknown error",
-			ud,
-			FALSE);
+		lua_redis_push_error (ud->ctx ? ud->ctx->errstr : "unknown error", ud, FALSE);
 		return FALSE;
 	}
 	else {
-		register_async_event (ud->task->s,
-			lua_redis_fin,
-			ud,
-			g_quark_from_static_string ("lua redis"));
+		register_async_event (ud->task->s, lua_redis_fin, ud, g_quark_from_static_string ("lua redis"));
 	}
 	redisLibeventAttach (ud->ctx, ud->task->ev_base);
 	/* Make a request now */
@@ -224,35 +217,17 @@ lua_redis_make_request_real (struct lua_redis_userdata *ud)
 		redisAsyncCommand (ud->ctx, lua_redis_callback, ud, ud->reqline);
 		break;
 	case 1:
-		redisAsyncCommand (ud->ctx,
-			lua_redis_callback,
-			ud,
-			ud->reqline,
-			ud->args[0].begin,
-			ud->args[0].len);
+		redisAsyncCommand (ud->ctx, lua_redis_callback, ud, ud->reqline, ud->args[0].begin, ud->args[0].len);
 		break;
 	case 2:
-		redisAsyncCommand (ud->ctx,
-			lua_redis_callback,
-			ud,
-			ud->reqline,
-			ud->args[0].begin,
-			ud->args[0].len,
-			ud->args[1].begin,
-			ud->args[1].len);
+		redisAsyncCommand (ud->ctx, lua_redis_callback, ud, ud->reqline, ud->args[0].begin, ud->args[0].len,
+				ud->args[1].begin, ud->args[1].len);
 		break;
 	default:
 		/* XXX: cannot handle more than 3 arguments */
-		redisAsyncCommand (ud->ctx,
-			lua_redis_callback,
-			ud,
-			ud->reqline,
-			ud->args[0].begin,
-			ud->args[0].len,
-			ud->args[1].begin,
-			ud->args[1].len,
-			ud->args[2].begin,
-			ud->args[2].len);
+		redisAsyncCommand (ud->ctx, lua_redis_callback, ud, ud->reqline, ud->args[0].begin, ud->args[0].len,
+				ud->args[1].begin, ud->args[1].len,
+				ud->args[2].begin, ud->args[2].len);
 		break;
 	}
 
@@ -267,8 +242,8 @@ lua_redis_make_request_real (struct lua_redis_userdata *ud)
 static void
 lua_redis_dns_callback (struct rdns_reply *reply, gpointer arg)
 {
-	struct lua_redis_userdata *ud = arg;
-	struct rdns_reply_entry *elt;
+	struct lua_redis_userdata			*ud = arg;
+	struct rdns_reply_entry			*elt;
 
 
 	if (reply->code != RDNS_RC_NOERROR) {
@@ -296,21 +271,18 @@ lua_redis_dns_callback (struct rdns_reply *reply, gpointer arg)
 static int
 lua_redis_make_request (lua_State *L)
 {
-	struct rspamd_task *task;
-	struct lua_redis_userdata *ud;
-	const gchar *server, *tmp;
-	guint port, i;
+	struct rspamd_task					*task;
+	struct lua_redis_userdata			*ud;
+	const gchar						 	*server, *tmp;
+	guint								 port, i;
 
 	if ((task = lua_check_task (L)) != NULL) {
 		server = luaL_checkstring (L, 2);
 		port = luaL_checkint (L, 3);
 		/* Now get callback */
-		if (lua_isfunction (L,
-			4) && server != NULL && port > 0 && port < G_MAXUINT16) {
+		if (lua_isfunction (L, 4) && server != NULL && port > 0 && port < G_MAXUINT16) {
 			/* Create userdata */
-			ud =
-				rspamd_mempool_alloc (task->task_pool,
-					sizeof (struct lua_redis_userdata));
+			ud = rspamd_mempool_alloc (task->task_pool, sizeof (struct lua_redis_userdata));
 			ud->server = rspamd_mempool_strdup (task->task_pool, server);
 			ud->port = port;
 			ud->task = task;
@@ -320,17 +292,14 @@ lua_redis_make_request (lua_State *L)
 			lua_pushvalue (L, 4);
 			/* Get a reference */
 			ud->cbref = luaL_ref (L, LUA_REGISTRYINDEX);
-			ud->reqline = rspamd_mempool_strdup (task->task_pool,
-					luaL_checkstring (L, 5));
+			ud->reqline = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 5));
 			/* Now get remaining args */
 			ud->args_num = lua_gettop (L) - 5;
-			ud->args = rspamd_mempool_alloc (task->task_pool,
-					ud->args_num * sizeof (f_str_t));
-			for (i = 0; i < ud->args_num; i++) {
+			ud->args = rspamd_mempool_alloc (task->task_pool, ud->args_num * sizeof (f_str_t));
+			for (i = 0; i < ud->args_num; i ++) {
 				tmp = lua_tolstring (L, i + 6, &ud->args[i].len);
 				/* Make a copy of argument */
-				ud->args[i].begin = rspamd_mempool_alloc (task->task_pool,
-						ud->args[i].len);
+				ud->args[i].begin = rspamd_mempool_alloc (task->task_pool, ud->args[i].len);
 				memcpy (ud->args[i].begin, tmp, ud->args[i].len);
 			}
 			/* Now check whether we need to perform DNS request */
@@ -338,9 +307,9 @@ lua_redis_make_request (lua_State *L)
 				/* Need to make dns request */
 				/* Resolve hostname */
 				if (make_dns_request (task->resolver, task->s, task->task_pool,
-					lua_redis_dns_callback, ud,
-					RDNS_REQUEST_A, ud->server)) {
-					task->dns_requests++;
+						lua_redis_dns_callback, ud,
+						RDNS_REQUEST_A, ud->server)) {
+					task->dns_requests ++;
 					lua_pushboolean (L, TRUE);
 				}
 				else {
@@ -349,7 +318,7 @@ lua_redis_make_request (lua_State *L)
 				}
 			}
 			else {
-				if (!lua_redis_make_request_real (ud)) {
+				if (! lua_redis_make_request_real (ud)) {
 					lua_pushboolean (L, FALSE);
 				}
 				else {
diff --git a/src/lua/lua_regexp.c b/src/lua/lua_regexp.c
index ba6379f54..ac489e53d 100644
--- a/src/lua/lua_regexp.c
+++ b/src/lua/lua_regexp.c
@@ -21,8 +21,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "expressions.h"
 #include "lua_common.h"
+#include "expressions.h"
 
 LUA_FUNCTION_DEF (regexp, create);
 LUA_FUNCTION_DEF (regexp, get_cached);
@@ -31,7 +31,7 @@ LUA_FUNCTION_DEF (regexp, match);
 LUA_FUNCTION_DEF (regexp, split);
 LUA_FUNCTION_DEF (regexp, destroy);
 
-static const struct luaL_reg regexplib_m[] = {
+static const struct luaL_reg    regexplib_m[] = {
 	LUA_INTERFACE_DEF (regexp, get_pattern),
 	LUA_INTERFACE_DEF (regexp, match),
 	LUA_INTERFACE_DEF (regexp, split),
@@ -39,7 +39,7 @@ static const struct luaL_reg regexplib_m[] = {
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
 };
-static const struct luaL_reg regexplib_f[] = {
+static const struct luaL_reg    regexplib_f[] = {
 	LUA_INTERFACE_DEF (regexp, create),
 	LUA_INTERFACE_DEF (regexp, get_cached),
 	{NULL, NULL}
@@ -53,10 +53,10 @@ struct rspamd_lua_regexp {
 	gint re_flags;
 };
 
-static struct rspamd_lua_regexp *
+static struct rspamd_lua_regexp	*
 lua_check_regexp (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{regexp}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{regexp}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'regexp' expected");
 	return ud ? *((struct rspamd_lua_regexp **)ud) : NULL;
@@ -65,11 +65,11 @@ lua_check_regexp (lua_State * L)
 static int
 lua_regexp_create (lua_State *L)
 {
-	gint regexp_flags = 0;
-	GRegex *re;
-	struct rspamd_lua_regexp *new, **pnew;
-	const gchar *string, *flags_str = NULL;
-	GError *err = NULL;
+	gint                            regexp_flags = 0;
+	GRegex                         *re;
+	struct rspamd_lua_regexp       *new, **pnew;
+	const gchar                    *string, *flags_str = NULL;
+	GError                         *err = NULL;
 
 	string = luaL_checkstring (L, 1);
 	if (lua_gettop (L) == 2) {
@@ -104,16 +104,14 @@ lua_regexp_create (lua_State *L)
 				msg_info ("invalid regexp flag: %c", *flags_str);
 				break;
 			}
-			flags_str++;
+			flags_str ++;
 		}
 	}
 
 	re = g_regex_new (string, regexp_flags, 0, &err);
 	if (re == NULL) {
 		lua_pushnil (L);
-		msg_info ("cannot parse regexp: %s, error: %s",
-			string,
-			err == NULL ? "undefined" : err->message);
+		msg_info ("cannot parse regexp: %s, error: %s", string, err == NULL ? "undefined" : err->message);
 	}
 	else {
 		new = g_slice_alloc (sizeof (struct rspamd_lua_regexp));
@@ -132,8 +130,8 @@ lua_regexp_create (lua_State *L)
 static int
 lua_regexp_get_cached (lua_State *L)
 {
-	struct rspamd_lua_regexp *new, **pnew;
-	const gchar *line;
+	struct rspamd_lua_regexp       *new, **pnew;
+	const gchar                    *line;
 
 	line = luaL_checkstring (L, 1);
 	new = re_cache_check (line, regexp_static_pool);
@@ -152,7 +150,7 @@ lua_regexp_get_cached (lua_State *L)
 static int
 lua_regexp_get_pattern (lua_State *L)
 {
-	struct rspamd_lua_regexp *re = lua_check_regexp (L);
+	struct rspamd_lua_regexp      *re = lua_check_regexp (L);
 
 	if (re) {
 		lua_pushstring (L, re->re_pattern);
@@ -164,11 +162,11 @@ lua_regexp_get_pattern (lua_State *L)
 static int
 lua_regexp_match (lua_State *L)
 {
-	struct rspamd_lua_regexp *re = lua_check_regexp (L);
-	GMatchInfo *mi;
-	const gchar *data;
-	gchar **matches;
-	gint i;
+	struct rspamd_lua_regexp       *re = lua_check_regexp (L);
+	GMatchInfo                     *mi;
+	const gchar                    *data;
+	gchar                         **matches;
+	gint                            i;
 
 	if (re) {
 		data = luaL_checkstring (L, 2);
@@ -183,7 +181,7 @@ lua_regexp_match (lua_State *L)
 			if (g_regex_match_full (re->re, data, -1, 0, 0, &mi, NULL)) {
 				matches = g_match_info_fetch_all (mi);
 				lua_newtable (L);
-				for (i = 1; matches[i - 1] != NULL; i++) {
+				for (i = 1; matches[i - 1] != NULL; i ++) {
 					lua_pushstring (L, matches[i - 1]);
 					lua_rawseti (L, -2, i);
 				}
@@ -204,10 +202,10 @@ lua_regexp_match (lua_State *L)
 static int
 lua_regexp_split (lua_State *L)
 {
-	struct rspamd_lua_regexp *re = lua_check_regexp (L);
-	const gchar *data;
-	gchar **parts;
-	gint i;
+	struct rspamd_lua_regexp       *re = lua_check_regexp (L);
+	const gchar                    *data;
+	gchar                         **parts;
+	gint                            i;
 
 	if (re) {
 		data = luaL_checkstring (L, 2);
@@ -221,7 +219,7 @@ lua_regexp_split (lua_State *L)
 			}
 			parts = g_regex_split (re->re, data, 0);
 			lua_newtable (L);
-			for (i = 1; parts[i - 1] != NULL; i++) {
+			for (i = 1; parts[i - 1] != NULL; i ++) {
 				lua_pushstring (L, parts[i - 1]);
 				lua_rawseti (L, -2, i);
 			}
@@ -244,7 +242,7 @@ lua_regexp_split (lua_State *L)
 static gint
 lua_regexp_destroy (lua_State *L)
 {
-	struct rspamd_lua_regexp *to_del = lua_check_regexp (L);
+	struct rspamd_lua_regexp           *to_del = lua_check_regexp (L);
 
 	if (to_del) {
 		re_cache_del (to_del->re_pattern, regexp_static_pool);
@@ -268,7 +266,7 @@ luaopen_glib_regexp (lua_State * L)
 	lua_pushstring (L, "rspamd{regexp}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,		regexplib_m);
+	luaL_register (L, NULL, regexplib_m);
 	luaL_register (L, "regexp", regexplib_f);
 
 	regexp_static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
diff --git a/src/lua/lua_rsa.c b/src/lua/lua_rsa.c
index e68fc3da1..38820e4e2 100644
--- a/src/lua/lua_rsa.c
+++ b/src/lua/lua_rsa.c
@@ -32,26 +32,26 @@
 
 #ifdef HAVE_OPENSSL
 #include <openssl/err.h>
-#include <openssl/pem.h>
-#include <openssl/rsa.h>
 #include <openssl/sha.h>
+#include <openssl/rsa.h>
+#include <openssl/pem.h>
 
-LUA_FUNCTION_DEF (rsa_pubkey,	 load);
-LUA_FUNCTION_DEF (rsa_pubkey,	 create);
-LUA_FUNCTION_DEF (rsa_pubkey,	 gc);
-LUA_FUNCTION_DEF (rsa_privkey,	 load);
-LUA_FUNCTION_DEF (rsa_privkey,	 create);
-LUA_FUNCTION_DEF (rsa_privkey,	 gc);
+LUA_FUNCTION_DEF (rsa_pubkey, load);
+LUA_FUNCTION_DEF (rsa_pubkey, create);
+LUA_FUNCTION_DEF (rsa_pubkey, gc);
+LUA_FUNCTION_DEF (rsa_privkey, load);
+LUA_FUNCTION_DEF (rsa_privkey, create);
+LUA_FUNCTION_DEF (rsa_privkey, gc);
 LUA_FUNCTION_DEF (rsa_signature, create);
 LUA_FUNCTION_DEF (rsa_signature, load);
 LUA_FUNCTION_DEF (rsa_signature, save);
 LUA_FUNCTION_DEF (rsa_signature, gc);
-LUA_FUNCTION_DEF (rsa,			 verify_memory);
-LUA_FUNCTION_DEF (rsa,			 verify_file);
-LUA_FUNCTION_DEF (rsa,			 sign_file);
-LUA_FUNCTION_DEF (rsa,			 sign_memory);
+LUA_FUNCTION_DEF (rsa, verify_memory);
+LUA_FUNCTION_DEF (rsa, verify_file);
+LUA_FUNCTION_DEF (rsa, sign_file);
+LUA_FUNCTION_DEF (rsa, sign_memory);
 
-static const struct luaL_reg rsalib_f[] = {
+static const struct luaL_reg    rsalib_f[] = {
 	LUA_INTERFACE_DEF (rsa, verify_memory),
 	LUA_INTERFACE_DEF (rsa, verify_file),
 	LUA_INTERFACE_DEF (rsa, sign_memory),
@@ -60,46 +60,46 @@ static const struct luaL_reg rsalib_f[] = {
 };
 
 static const struct luaL_reg rsapubkeylib_f[] = {
-	LUA_INTERFACE_DEF (rsa_pubkey, load),
-	LUA_INTERFACE_DEF (rsa_pubkey, create),
-	{NULL, NULL}
+		LUA_INTERFACE_DEF (rsa_pubkey, load),
+		LUA_INTERFACE_DEF (rsa_pubkey, create),
+		{NULL, NULL}
 };
 
 static const struct luaL_reg rsapubkeylib_m[] = {
-	{"__tostring", lua_class_tostring},
-	{"__gc", lua_rsa_pubkey_gc},
-	{NULL, NULL}
+		{"__tostring", lua_class_tostring},
+		{"__gc", lua_rsa_pubkey_gc},
+		{NULL, NULL}
 };
 
 static const struct luaL_reg rsaprivkeylib_f[] = {
-	LUA_INTERFACE_DEF (rsa_privkey, load),
-	LUA_INTERFACE_DEF (rsa_privkey, create),
-	{NULL, NULL}
+		LUA_INTERFACE_DEF (rsa_privkey, load),
+		LUA_INTERFACE_DEF (rsa_privkey, create),
+		{NULL, NULL}
 };
 
 static const struct luaL_reg rsaprivkeylib_m[] = {
-	{"__tostring", lua_class_tostring},
-	{"__gc", lua_rsa_privkey_gc},
-	{NULL, NULL}
+		{"__tostring", lua_class_tostring},
+		{"__gc", lua_rsa_privkey_gc},
+		{NULL, NULL}
 };
 
 static const struct luaL_reg rsasignlib_f[] = {
-	LUA_INTERFACE_DEF (rsa_signature, load),
-	LUA_INTERFACE_DEF (rsa_signature, create),
-	{NULL, NULL}
+		LUA_INTERFACE_DEF (rsa_signature, load),
+		LUA_INTERFACE_DEF (rsa_signature, create),
+		{NULL, NULL}
 };
 
 static const struct luaL_reg rsasignlib_m[] = {
-	LUA_INTERFACE_DEF (rsa_signature, save),
-	{"__tostring", lua_class_tostring},
-	{"__gc", lua_rsa_signature_gc},
-	{NULL, NULL}
+		LUA_INTERFACE_DEF (rsa_signature, save),
+		{"__tostring", lua_class_tostring},
+		{"__gc", lua_rsa_signature_gc},
+		{NULL, NULL}
 };
 
 static RSA *
 lua_check_rsa_pubkey (lua_State * L, int pos)
 {
-	void *ud = luaL_checkudata (L, pos, "rspamd{rsa_pubkey}");
+	void                           *ud = luaL_checkudata (L, pos, "rspamd{rsa_pubkey}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'rsa_pubkey' expected");
 	return ud ? *((RSA **)ud) : NULL;
@@ -108,7 +108,7 @@ lua_check_rsa_pubkey (lua_State * L, int pos)
 static RSA *
 lua_check_rsa_privkey (lua_State * L, int pos)
 {
-	void *ud = luaL_checkudata (L, pos, "rspamd{rsa_privkey}");
+	void                           *ud = luaL_checkudata (L, pos, "rspamd{rsa_privkey}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'rsa_privkey' expected");
 	return ud ? *((RSA **)ud) : NULL;
@@ -117,7 +117,7 @@ lua_check_rsa_privkey (lua_State * L, int pos)
 static f_str_t *
 lua_check_rsa_sign (lua_State * L, int pos)
 {
-	void *ud = luaL_checkudata (L, pos, "rspamd{rsa_signature}");
+	void                           *ud = luaL_checkudata (L, pos, "rspamd{rsa_signature}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'rsa_signature' expected");
 	return ud ? *((f_str_t **)ud) : NULL;
@@ -126,7 +126,7 @@ lua_check_rsa_sign (lua_State * L, int pos)
 static gint
 lua_rsa_pubkey_load (lua_State *L)
 {
-	RSA *rsa = NULL, **prsa;
+	RSA	*rsa = NULL, **prsa;
 	const gchar *filename;
 	FILE *f;
 
@@ -134,15 +134,13 @@ lua_rsa_pubkey_load (lua_State *L)
 	if (filename != NULL) {
 		f = fopen (filename, "r");
 		if (f == NULL) {
-			msg_err ("cannot open pubkey from file: %s, %s",
-				filename,
-				strerror (errno));
+			msg_err ("cannot open pubkey from file: %s, %s", filename, strerror (errno));
 			lua_pushnil (L);
 		}
 		else {
-			if (!PEM_read_RSA_PUBKEY (f, &rsa, NULL, NULL)) {
+			if (! PEM_read_RSA_PUBKEY (f, &rsa, NULL, NULL)) {
 				msg_err ("cannot open pubkey from file: %s, %s", filename,
-					ERR_error_string (ERR_get_error (), NULL));
+						ERR_error_string (ERR_get_error (), NULL));
 				lua_pushnil (L);
 			}
 			else {
@@ -162,7 +160,7 @@ lua_rsa_pubkey_load (lua_State *L)
 static gint
 lua_rsa_pubkey_create (lua_State *L)
 {
-	RSA *rsa = NULL, **prsa;
+	RSA	*rsa = NULL, **prsa;
 	const gchar *buf;
 	BIO *bp;
 
@@ -170,9 +168,9 @@ lua_rsa_pubkey_create (lua_State *L)
 	if (buf != NULL) {
 		bp = BIO_new_mem_buf ((void *)buf, -1);
 
-		if (!PEM_read_bio_RSA_PUBKEY (bp, &rsa, NULL, NULL)) {
+		if (! PEM_read_bio_RSA_PUBKEY (bp, &rsa, NULL, NULL)) {
 			msg_err ("cannot parse pubkey: %s",
-				ERR_error_string (ERR_get_error (), NULL));
+					ERR_error_string (ERR_get_error (), NULL));
 			lua_pushnil (L);
 		}
 		else {
@@ -203,7 +201,7 @@ lua_rsa_pubkey_gc (lua_State *L)
 static gint
 lua_rsa_privkey_load (lua_State *L)
 {
-	RSA *rsa = NULL, **prsa;
+	RSA	*rsa = NULL, **prsa;
 	const gchar *filename;
 	FILE *f;
 
@@ -211,15 +209,13 @@ lua_rsa_privkey_load (lua_State *L)
 	if (filename != NULL) {
 		f = fopen (filename, "r");
 		if (f == NULL) {
-			msg_err ("cannot open private key from file: %s, %s",
-				filename,
-				strerror (errno));
+			msg_err ("cannot open private key from file: %s, %s", filename, strerror (errno));
 			lua_pushnil (L);
 		}
 		else {
-			if (!PEM_read_RSAPrivateKey (f, &rsa, NULL, NULL)) {
+			if (! PEM_read_RSAPrivateKey (f, &rsa, NULL, NULL)) {
 				msg_err ("cannot open private key from file: %s, %s", filename,
-					ERR_error_string (ERR_get_error (), NULL));
+						ERR_error_string (ERR_get_error (), NULL));
 				lua_pushnil (L);
 			}
 			else {
@@ -239,7 +235,7 @@ lua_rsa_privkey_load (lua_State *L)
 static gint
 lua_rsa_privkey_create (lua_State *L)
 {
-	RSA *rsa = NULL, **prsa;
+	RSA	*rsa = NULL, **prsa;
 	const gchar *buf;
 	BIO *bp;
 
@@ -247,9 +243,9 @@ lua_rsa_privkey_create (lua_State *L)
 	if (buf != NULL) {
 		bp = BIO_new_mem_buf ((void *)buf, -1);
 
-		if (!PEM_read_bio_RSAPrivateKey (bp, &rsa, NULL, NULL)) {
+		if (! PEM_read_bio_RSAPrivateKey (bp, &rsa, NULL, NULL)) {
 			msg_err ("cannot parse private key: %s",
-				ERR_error_string (ERR_get_error (), NULL));
+					ERR_error_string (ERR_get_error (), NULL));
 			lua_pushnil (L);
 		}
 		else {
@@ -290,16 +286,13 @@ lua_rsa_signature_load (lua_State *L)
 	if (filename != NULL) {
 		fd = open (filename, O_RDONLY);
 		if (fd == -1) {
-			msg_err ("cannot open signature file: %s, %s", filename,
-				strerror (errno));
+			msg_err ("cannot open signature file: %s, %s", filename, strerror (errno));
 			lua_pushnil (L);
 		}
 		else {
 			sig = g_malloc (sizeof (f_str_t));
 			if (fstat (fd, &st) == -1 ||
-				(data =
-				mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
-				0)) == MAP_FAILED) {
+					(data = mmap (NULL,  st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 				msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
 				lua_pushnil (L);
 			}
@@ -346,9 +339,7 @@ lua_rsa_signature_save (lua_State *L)
 		}
 		fd = open (filename, flags, 00644);
 		if (fd == -1) {
-			msg_err ("cannot create a signature file: %s, %s",
-				filename,
-				strerror (errno));
+			msg_err ("cannot create a signature file: %s, %s", filename, strerror (errno));
 			lua_pushboolean (L, FALSE);
 		}
 		else {
@@ -356,9 +347,7 @@ lua_rsa_signature_save (lua_State *L)
 				if (errno == EINTR) {
 					continue;
 				}
-				msg_err ("cannot write to a signature file: %s, %s",
-					filename,
-					strerror (errno));
+				msg_err ("cannot write to a signature file: %s, %s", filename, strerror (errno));
 				res = FALSE;
 				break;
 			}
@@ -438,7 +427,7 @@ lua_rsa_verify_memory (lua_State *L)
 				signature->begin, signature->len, rsa);
 		if (ret == 0) {
 			msg_info ("cannot check rsa signature for data: %s",
-				ERR_error_string (ERR_get_error (), NULL));
+					ERR_error_string (ERR_get_error (), NULL));
 			lua_pushboolean (L, FALSE);
 		}
 		else {
@@ -485,21 +474,17 @@ lua_rsa_verify_file (lua_State *L)
 		}
 		else {
 			if (fstat (fd, &st) == -1 ||
-				(data =
-				mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
-				0)) == MAP_FAILED) {
+					(data = mmap (NULL,  st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 				msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
 				lua_pushnil (L);
 			}
 			else {
-				data_sig = g_compute_checksum_for_data (G_CHECKSUM_SHA256,
-						data,
-						st.st_size);
+				data_sig = g_compute_checksum_for_data (G_CHECKSUM_SHA256, data, st.st_size);
 				ret = RSA_verify (NID_sha1, data_sig, strlen (data_sig),
 						signature->begin, signature->len, rsa);
 				if (ret == 0) {
 					msg_info ("cannot check rsa signature for file: %s, %s",
-						filename, ERR_error_string (ERR_get_error (), NULL));
+							filename, ERR_error_string (ERR_get_error (), NULL));
 					lua_pushboolean (L, FALSE);
 				}
 				else {
@@ -550,7 +535,7 @@ lua_rsa_sign_memory (lua_State *L)
 				signature->begin, (guint *)&signature->len, rsa);
 		if (ret == 0) {
 			msg_info ("cannot make a signature for data: %s",
-				ERR_error_string (ERR_get_error (), NULL));
+					ERR_error_string (ERR_get_error (), NULL));
 			lua_pushnil (L);
 			g_free (signature->begin);
 			g_free (signature);
@@ -600,9 +585,7 @@ lua_rsa_sign_file (lua_State *L)
 		}
 		else {
 			if (fstat (fd, &st) == -1 ||
-				(data =
-				mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
-				0)) == MAP_FAILED) {
+					(data = mmap (NULL,  st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 				msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
 				lua_pushnil (L);
 			}
@@ -611,14 +594,12 @@ lua_rsa_sign_file (lua_State *L)
 				signature->len = RSA_size (rsa);
 				signature->size = signature->len;
 				signature->begin = g_malloc (signature->len);
-				data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256,
-						data,
-						st.st_size);
+				data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256, data, st.st_size);
 				ret = RSA_sign (NID_sha1, data_sig, strlen (data_sig),
 						signature->begin, (guint *)&signature->len, rsa);
 				if (ret == 0) {
 					msg_info ("cannot make a signature for data: %s",
-						ERR_error_string (ERR_get_error (), NULL));
+							ERR_error_string (ERR_get_error (), NULL));
 					lua_pushnil (L);
 					g_free (signature->begin);
 					g_free (signature);
@@ -653,7 +634,7 @@ luaopen_rsa (lua_State * L)
 	lua_pushstring (L, "rspamd{rsa_pubkey}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,			rsapubkeylib_m);
+	luaL_register (L, NULL, rsapubkeylib_m);
 	luaL_register (L, "rsa_pubkey", rsapubkeylib_f);
 
 	luaL_newmetatable (L, "rspamd{rsa_privkey}");
@@ -665,7 +646,7 @@ luaopen_rsa (lua_State * L)
 	lua_pushstring (L, "rspamd{rsa_privkey}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,			 rsaprivkeylib_m);
+	luaL_register (L, NULL, rsaprivkeylib_m);
 	luaL_register (L, "rsa_privkey", rsaprivkeylib_f);
 
 	luaL_newmetatable (L, "rspamd{rsa_signature}");
@@ -677,10 +658,10 @@ luaopen_rsa (lua_State * L)
 	lua_pushstring (L, "rspamd{rsa_signature}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,			   rsasignlib_m);
+	luaL_register (L, NULL, rsasignlib_m);
 	luaL_register (L, "rsa_signature", rsasignlib_f);
 
-	luaL_register (L, "rsa",			   rsalib_f);
+	luaL_register (L, "rsa", rsalib_f);
 
 	return 1;
 }
@@ -690,7 +671,7 @@ gint
 luaopen_rsa (lua_State * L)
 {
 	msg_info ("this rspamd version is not linked against openssl, therefore no "
-		"RSA support is available");
+			"RSA support is available");
 
 	return 1;
 
diff --git a/src/lua/lua_session.c b/src/lua/lua_session.c
index 7cfdcccbe..193488cef 100644
--- a/src/lua/lua_session.c
+++ b/src/lua/lua_session.c
@@ -24,7 +24,7 @@
 #include "lua_common.h"
 
 /* Public prototypes */
-struct rspamd_async_session * lua_check_session (lua_State * L);
+struct rspamd_async_session *lua_check_session (lua_State * L);
 gint luaopen_session (lua_State * L);
 
 /* Lua bindings */
@@ -34,7 +34,7 @@ LUA_FUNCTION_DEF (session, check_session_pending);
 LUA_FUNCTION_DEF (session, create);
 LUA_FUNCTION_DEF (session, delete);
 
-static const struct luaL_reg sessionlib_m[] = {
+static const struct luaL_reg    sessionlib_m[] = {
 	LUA_INTERFACE_DEF (session, register_async_event),
 	LUA_INTERFACE_DEF (session, remove_normal_event),
 	LUA_INTERFACE_DEF (session, check_session_pending),
@@ -43,12 +43,12 @@ static const struct luaL_reg sessionlib_m[] = {
 	{NULL, NULL}
 };
 
-static const struct luaL_reg sessionlib_f[] = {
+static const struct luaL_reg    sessionlib_f[] = {
 	LUA_INTERFACE_DEF (session, create),
 	{NULL, NULL}
 };
 
-static const struct luaL_reg eventlib_m[] = {
+static const struct luaL_reg    eventlib_m[] = {
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
 };
@@ -67,18 +67,18 @@ struct lua_event_udata {
 	struct rspamd_async_session *session;
 };
 
-struct rspamd_async_session *
+struct rspamd_async_session      *
 lua_check_session (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{session}");
+	void								*ud = luaL_checkudata (L, 1, "rspamd{session}");
 	luaL_argcheck (L, ud != NULL, 1, "'session' expected");
 	return ud ? *((struct rspamd_async_session **)ud) : NULL;
 }
 
-struct rspamd_async_event *
+struct rspamd_async_event      *
 lua_check_event (lua_State * L, gint pos)
 {
-	void *ud = luaL_checkudata (L, pos, "rspamd{event}");
+	void								*ud = luaL_checkudata (L, pos, "rspamd{event}");
 	luaL_argcheck (L, ud != NULL, 1, "'event' expected");
 	return ud ? *((struct rspamd_async_event **)ud) : NULL;
 }
@@ -88,14 +88,13 @@ lua_check_event (lua_State * L, gint pos)
 static gboolean
 lua_session_finalizer (gpointer ud)
 {
-	struct lua_session_udata *cbdata = ud;
-	gboolean res;
+	struct lua_session_udata					*cbdata = ud;
+	gboolean								 	 res;
 
 	/* Call finalizer function */
 	lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_fin);
 	if (lua_pcall (cbdata->L, 0, 1, 0) != 0) {
-		msg_info ("call to session finalizer failed: %s",
-			lua_tostring (cbdata->L, -1));
+		msg_info ("call to session finalizer failed: %s", lua_tostring (cbdata->L, -1));
 	}
 	res = lua_toboolean (cbdata->L, -1);
 	lua_pop (cbdata->L, 1);
@@ -108,15 +107,14 @@ lua_session_finalizer (gpointer ud)
 static void
 lua_session_restore (gpointer ud)
 {
-	struct lua_session_udata *cbdata = ud;
+	struct lua_session_udata					*cbdata = ud;
 
 	if (cbdata->cbref_restore) {
 
 		/* Call restorer function */
 		lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_restore);
 		if (lua_pcall (cbdata->L, 0, 0, 0) != 0) {
-			msg_info ("call to session restorer failed: %s",
-				lua_tostring (cbdata->L, -1));
+			msg_info ("call to session restorer failed: %s", lua_tostring (cbdata->L, -1));
 		}
 		luaL_unref (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_restore);
 	}
@@ -125,15 +123,14 @@ lua_session_restore (gpointer ud)
 static void
 lua_session_cleanup (gpointer ud)
 {
-	struct lua_session_udata *cbdata = ud;
+	struct lua_session_udata					*cbdata = ud;
 
 	if (cbdata->cbref_cleanup) {
 
 		/* Call restorer function */
 		lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_cleanup);
 		if (lua_pcall (cbdata->L, 0, 0, 0) != 0) {
-			msg_info ("call to session cleanup failed: %s",
-				lua_tostring (cbdata->L, -1));
+			msg_info ("call to session cleanup failed: %s", lua_tostring (cbdata->L, -1));
 		}
 		luaL_unref (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref_cleanup);
 	}
@@ -144,9 +141,9 @@ lua_session_cleanup (gpointer ud)
 static int
 lua_session_create (lua_State *L)
 {
-	struct rspamd_async_session *session, **psession;
-	struct lua_session_udata *cbdata;
-	rspamd_mempool_t *mempool;
+	struct rspamd_async_session					*session, **psession;
+	struct lua_session_udata					*cbdata;
+	rspamd_mempool_t								*mempool;
 
 
 
@@ -189,11 +186,7 @@ lua_session_create (lua_State *L)
 			cbdata->cbref_cleanup = luaL_ref (L, LUA_REGISTRYINDEX);
 		}
 	}
-	session = new_async_session (mempool,
-			lua_session_finalizer,
-			lua_session_restore,
-			lua_session_cleanup,
-			cbdata);
+	session = new_async_session (mempool, lua_session_finalizer, lua_session_restore, lua_session_cleanup, cbdata);
 	cbdata->session = session;
 	psession = lua_newuserdata (L, sizeof (struct rspamd_async_session *));
 	lua_setclass (L, "rspamd{session}", -1);
@@ -205,7 +198,7 @@ lua_session_create (lua_State *L)
 static int
 lua_session_delete (lua_State *L)
 {
-	struct rspamd_async_session *session = lua_check_session (L);
+	struct rspamd_async_session					*session = lua_check_session (L);
 
 	if (session) {
 		destroy_session (session);
@@ -221,14 +214,13 @@ lua_session_delete (lua_State *L)
 static void
 lua_event_fin (gpointer ud)
 {
-	struct lua_event_udata *cbdata = ud;
+	struct lua_event_udata						*cbdata = ud;
 
 	if (cbdata->cbref) {
 		/* Call restorer function */
 		lua_rawgeti (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref);
 		if (lua_pcall (cbdata->L, 0, 0, 0) != 0) {
-			msg_info ("call to event finalizer failed: %s",
-				lua_tostring (cbdata->L, -1));
+			msg_info ("call to event finalizer failed: %s", lua_tostring (cbdata->L, -1));
 		}
 		luaL_unref (cbdata->L, LUA_REGISTRYINDEX, cbdata->cbref);
 	}
@@ -237,23 +229,18 @@ lua_event_fin (gpointer ud)
 static int
 lua_session_register_async_event (lua_State *L)
 {
-	struct rspamd_async_session *session = lua_check_session (L);
-	struct lua_event_udata *cbdata;
-	gpointer *pdata;
+	struct rspamd_async_session					*session = lua_check_session (L);
+	struct lua_event_udata						*cbdata;
+	gpointer									*pdata;
 
 	if (session) {
 		if (lua_isfunction (L, 1)) {
-			cbdata =
-				rspamd_mempool_alloc (session->pool,
-					sizeof (struct lua_event_udata));
+			cbdata = rspamd_mempool_alloc (session->pool, sizeof (struct lua_event_udata));
 			cbdata->L = L;
 			lua_pushvalue (L, 1);
 			cbdata->cbref = luaL_ref (L, LUA_REGISTRYINDEX);
 			cbdata->session = session;
-			register_async_event (session,
-				lua_event_fin,
-				cbdata,
-				g_quark_from_static_string ("lua event"));
+			register_async_event (session, lua_event_fin, cbdata, g_quark_from_static_string ("lua event"));
 			pdata = lua_newuserdata (L, sizeof (gpointer));
 			lua_setclass (L, "rspamd{event}", -1);
 			*pdata = cbdata;
@@ -270,8 +257,8 @@ lua_session_register_async_event (lua_State *L)
 static int
 lua_session_remove_normal_event (lua_State *L)
 {
-	struct rspamd_async_session *session = lua_check_session (L);
-	gpointer data;
+	struct rspamd_async_session					*session = lua_check_session (L);
+	gpointer									 data;
 
 	if (session) {
 		data = lua_check_event (L, 2);
@@ -290,10 +277,10 @@ lua_session_remove_normal_event (lua_State *L)
 static int
 lua_session_check_session_pending (lua_State *L)
 {
-	struct rspamd_async_session *session = lua_check_session (L);
+	struct rspamd_async_session					*session = lua_check_session (L);
 
 	if (session) {
-
+		
 	}
 	else {
 		lua_pushnil (L);
@@ -314,7 +301,7 @@ luaopen_session (lua_State * L)
 	lua_pushstring (L, "rspamd{session}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,				sessionlib_m);
+	luaL_register (L, NULL, sessionlib_m);
 	luaL_register (L, "rspamd_session", sessionlib_f);
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
@@ -325,5 +312,5 @@ luaopen_session (lua_State * L)
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
 
-	return 1;
+	return 1;	
 }
diff --git a/src/lua/lua_task.c b/src/lua/lua_task.c
index 6cf8f5d99..0572226be 100644
--- a/src/lua/lua_task.c
+++ b/src/lua/lua_task.c
@@ -23,27 +23,24 @@
  */
 
 
-#include "binlog.h"
-#include "cfg_file.h"
-#include "classifiers/classifiers.h"
-#include "diff.h"
-#include "dns.h"
-#include "expressions.h"
-#include "filter.h"
-#include "images.h"
 #include "lua_common.h"
 #include "message.h"
+#include "expressions.h"
 #include "protocol.h"
+#include "filter.h"
+#include "dns.h"
+#include "util.h"
+#include "images.h"
+#include "cfg_file.h"
 #include "statfile.h"
-#include "statfile_sync.h"
 #include "tokenizers/tokenizers.h"
-#include "util.h"
+#include "classifiers/classifiers.h"
+#include "binlog.h"
+#include "statfile_sync.h"
+#include "diff.h"
 
-extern stat_file_t * get_statfile_by_symbol (statfile_pool_t *pool,
-	struct rspamd_classifier_config *ccf,
-	const gchar *symbol,
-	struct rspamd_statfile_config **st,
-	gboolean try_create);
+extern stat_file_t* get_statfile_by_symbol (statfile_pool_t *pool, struct rspamd_classifier_config *ccf,
+		const gchar *symbol, struct rspamd_statfile_config **st, gboolean try_create);
 
 /* Task creation */
 LUA_FUNCTION_DEF (task, create_empty);
@@ -93,13 +90,13 @@ LUA_FUNCTION_DEF (task, get_metric_score);
 LUA_FUNCTION_DEF (task, get_metric_action);
 LUA_FUNCTION_DEF (task, learn_statfile);
 
-static const struct luaL_reg tasklib_f[] = {
+static const struct luaL_reg    tasklib_f[] = {
 	LUA_INTERFACE_DEF (task, create_empty),
 	LUA_INTERFACE_DEF (task, create_from_buffer),
 	{NULL, NULL}
 };
 
-static const struct luaL_reg tasklib_m[] = {
+static const struct luaL_reg    tasklib_m[] = {
 	LUA_INTERFACE_DEF (task, get_message),
 	LUA_INTERFACE_DEF (task, destroy),
 	LUA_INTERFACE_DEF (task, process_message),
@@ -156,7 +153,7 @@ LUA_FUNCTION_DEF (textpart, get_fuzzy);
 LUA_FUNCTION_DEF (textpart, get_language);
 LUA_FUNCTION_DEF (textpart, compare_distance);
 
-static const struct luaL_reg textpartlib_m[] = {
+static const struct luaL_reg    textpartlib_m[] = {
 	LUA_INTERFACE_DEF (textpart, get_content),
 	LUA_INTERFACE_DEF (textpart, get_length),
 	LUA_INTERFACE_DEF (textpart, is_empty),
@@ -174,7 +171,7 @@ LUA_FUNCTION_DEF (mimepart, get_length);
 LUA_FUNCTION_DEF (mimepart, get_type);
 LUA_FUNCTION_DEF (mimepart, get_filename);
 
-static const struct luaL_reg mimepartlib_m[] = {
+static const struct luaL_reg    mimepartlib_m[] = {
 	LUA_INTERFACE_DEF (mimepart, get_content),
 	LUA_INTERFACE_DEF (mimepart, get_length),
 	LUA_INTERFACE_DEF (mimepart, get_type),
@@ -191,7 +188,7 @@ LUA_FUNCTION_DEF (image, get_type);
 LUA_FUNCTION_DEF (image, get_filename);
 LUA_FUNCTION_DEF (image, get_size);
 
-static const struct luaL_reg imagelib_m[] = {
+static const struct luaL_reg    imagelib_m[] = {
 	LUA_INTERFACE_DEF (image, get_width),
 	LUA_INTERFACE_DEF (image, get_height),
 	LUA_INTERFACE_DEF (image, get_type),
@@ -210,7 +207,7 @@ LUA_FUNCTION_DEF (url, get_text);
 LUA_FUNCTION_DEF (url, is_phished);
 LUA_FUNCTION_DEF (url, get_phished);
 
-static const struct luaL_reg urllib_m[] = {
+static const struct luaL_reg    urllib_m[] = {
 	LUA_INTERFACE_DEF (url, get_length),
 	LUA_INTERFACE_DEF (url, get_host),
 	LUA_INTERFACE_DEF (url, get_user),
@@ -223,42 +220,42 @@ static const struct luaL_reg urllib_m[] = {
 };
 
 /* Utility functions */
-static struct rspamd_task *
+static struct rspamd_task      *
 lua_check_task (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{task}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{task}");
 	luaL_argcheck (L, ud != NULL, 1, "'task' expected");
 	return ud ? *((struct rspamd_task **)ud) : NULL;
 }
 
-static struct mime_text_part *
+static struct mime_text_part   *
 lua_check_textpart (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{textpart}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{textpart}");
 	luaL_argcheck (L, ud != NULL, 1, "'textpart' expected");
 	return ud ? *((struct mime_text_part **)ud) : NULL;
 }
 
-static struct mime_part *
+static struct mime_part   *
 lua_check_mimepart (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{mimepart}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{mimepart}");
 	luaL_argcheck (L, ud != NULL, 1, "'mimepart' expected");
 	return ud ? *((struct mime_part **)ud) : NULL;
 }
 
-static struct rspamd_image *
+static struct rspamd_image      *
 lua_check_image (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{image}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{image}");
 	luaL_argcheck (L, ud != NULL, 1, "'image' expected");
 	return ud ? *((struct rspamd_image **)ud) : NULL;
 }
 
-static struct uri *
+static struct uri      *
 lua_check_url (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{url}");
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{url}");
 	luaL_argcheck (L, ud != NULL, 1, "'url' expected");
 	return ud ? *((struct uri **)ud) : NULL;
 }
@@ -268,7 +265,7 @@ lua_check_url (lua_State * L)
 static int
 lua_task_create_empty (lua_State *L)
 {
-	struct rspamd_task **ptask, *task;
+	struct rspamd_task             **ptask, *task;
 
 	task = rspamd_task_new (NULL);
 	ptask = lua_newuserdata (L, sizeof (gpointer));
@@ -280,9 +277,9 @@ lua_task_create_empty (lua_State *L)
 static int
 lua_task_create_from_buffer (lua_State *L)
 {
-	struct rspamd_task **ptask, *task;
-	const gchar *data;
-	size_t len;
+	struct rspamd_task             **ptask, *task;
+	const gchar						*data;
+	size_t							 len;
 
 	data = luaL_checklstring (L, 1, &len);
 	if (data) {
@@ -298,7 +295,7 @@ lua_task_create_from_buffer (lua_State *L)
 static int
 lua_task_process_message (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL && task->msg != NULL && task->msg->len > 0) {
 		if (process_message (task) == 0) {
@@ -317,8 +314,8 @@ lua_task_process_message (lua_State *L)
 static int
 lua_task_set_cfg (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	void *ud = luaL_checkudata (L, 2, "rspamd{config}");
+	struct rspamd_task             *task = lua_check_task (L);
+	void                           *ud = luaL_checkudata (L, 2, "rspamd{config}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'config' expected");
 	task->cfg = ud ? *((struct rspamd_config **)ud) : NULL;
@@ -328,7 +325,7 @@ lua_task_set_cfg (lua_State *L)
 static int
 lua_task_destroy (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL) {
 		rspamd_task_free (task, FALSE);
@@ -340,8 +337,8 @@ lua_task_destroy (lua_State *L)
 static int
 lua_task_get_message (lua_State * L)
 {
-	GMimeMessage **pmsg;
-	struct rspamd_task *task = lua_check_task (L);
+	GMimeMessage                  **pmsg;
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL && task->message != NULL) {
 		pmsg = lua_newuserdata (L, sizeof (GMimeMessage *));
@@ -357,8 +354,8 @@ lua_task_get_message (lua_State * L)
 static int
 lua_task_get_mempool (lua_State * L)
 {
-	rspamd_mempool_t **ppool;
-	struct rspamd_task *task = lua_check_task (L);
+	rspamd_mempool_t                  **ppool;
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL) {
 		ppool = lua_newuserdata (L, sizeof (rspamd_mempool_t *));
@@ -374,8 +371,8 @@ lua_task_get_mempool (lua_State * L)
 static int
 lua_task_get_session (lua_State * L)
 {
-	struct rspamd_async_session **psession;
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_async_session   **psession;
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL) {
 		psession = lua_newuserdata (L, sizeof (void *));
@@ -391,8 +388,8 @@ lua_task_get_session (lua_State * L)
 static int
 lua_task_get_ev_base (lua_State * L)
 {
-	struct event_base **pbase;
-	struct rspamd_task *task = lua_check_task (L);
+	struct event_base             **pbase;
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL) {
 		pbase = lua_newuserdata (L, sizeof (struct event_base *));
@@ -408,23 +405,20 @@ lua_task_get_ev_base (lua_State * L)
 static gint
 lua_task_insert_result (lua_State * L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *symbol_name, *param;
-	double flag;
-	GList *params = NULL;
-	gint i, top;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar                     *symbol_name, *param;
+	double                          flag;
+	GList                          *params = NULL;
+	gint                            i, top;
 
 	if (task != NULL) {
-		symbol_name =
-			rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
+		symbol_name = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 2));
 		flag = luaL_checknumber (L, 3);
 		top = lua_gettop (L);
 		/* Get additional options */
 		for (i = 4; i <= top; i++) {
 			param = luaL_checkstring (L, i);
-			params =
-				g_list_prepend (params,
-					rspamd_mempool_strdup (task->task_pool, param));
+			params = g_list_prepend (params, rspamd_mempool_strdup (task->task_pool, param));
 		}
 
 		insert_result (task, symbol_name, flag, params);
@@ -435,17 +429,16 @@ lua_task_insert_result (lua_State * L)
 static gint
 lua_task_set_pre_result (lua_State * L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	gchar *action_str;
-	guint action;
+	struct rspamd_task				*task = lua_check_task (L);
+	gchar		                    *action_str;
+	guint                            action;
 
 	if (task != NULL) {
 		action = luaL_checkinteger (L, 2);
 		if (action < task->pre_result.action) {
 			task->pre_result.action = action;
 			if (lua_gettop (L) >= 3) {
-				action_str = rspamd_mempool_strdup (task->task_pool,
-						luaL_checkstring (L, 3));
+				action_str = rspamd_mempool_strdup (task->task_pool, luaL_checkstring (L, 3));
 				task->pre_result.str = action_str;
 			}
 			else {
@@ -457,15 +450,15 @@ lua_task_set_pre_result (lua_State * L)
 }
 
 struct lua_tree_cb_data {
-	lua_State *L;
-	int i;
+	lua_State                     *L;
+	int                            i;
 };
 
 static gboolean
 lua_tree_url_callback (gpointer key, gpointer value, gpointer ud)
 {
-	struct uri **purl;
-	struct lua_tree_cb_data *cb = ud;
+	struct uri                    **purl;
+	struct lua_tree_cb_data         *cb = ud;
 
 	purl = lua_newuserdata (cb->L, sizeof (struct uri *));
 	lua_setclass (cb->L, "rspamd{url}", -1);
@@ -478,8 +471,8 @@ lua_tree_url_callback (gpointer key, gpointer value, gpointer ud)
 static gint
 lua_task_get_urls (lua_State * L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	struct lua_tree_cb_data cb;
+	struct rspamd_task             *task = lua_check_task (L);
+	struct lua_tree_cb_data         cb;
 
 	if (task) {
 		lua_newtable (L);
@@ -496,8 +489,8 @@ lua_task_get_urls (lua_State * L)
 static gint
 lua_task_get_emails (lua_State * L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	struct lua_tree_cb_data cb;
+	struct rspamd_task             *task = lua_check_task (L);
+	struct lua_tree_cb_data         cb;
 
 	if (task) {
 		lua_newtable (L);
@@ -514,10 +507,10 @@ lua_task_get_emails (lua_State * L)
 static gint
 lua_task_get_text_parts (lua_State * L)
 {
-	gint i = 1;
-	struct rspamd_task *task = lua_check_task (L);
-	GList *cur;
-	struct mime_text_part *part, **ppart;
+	gint                            i = 1;
+	struct rspamd_task             *task = lua_check_task (L);
+	GList                          *cur;
+	struct mime_text_part          *part, **ppart;
 
 	if (task != NULL) {
 		lua_newtable (L);
@@ -540,10 +533,10 @@ lua_task_get_text_parts (lua_State * L)
 static gint
 lua_task_get_parts (lua_State * L)
 {
-	gint i = 1;
-	struct rspamd_task *task = lua_check_task (L);
-	GList *cur;
-	struct mime_part *part, **ppart;
+	gint                            i = 1;
+	struct rspamd_task             *task = lua_check_task (L);
+	GList                          *cur;
+	struct mime_part          *part, **ppart;
 
 	if (task != NULL) {
 		lua_newtable (L);
@@ -567,7 +560,7 @@ lua_task_get_parts (lua_State * L)
 static gint
 lua_task_get_raw_headers (lua_State * L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task) {
 		lua_pushstring (L, task->raw_headers_str);
@@ -582,10 +575,10 @@ lua_task_get_raw_headers (lua_State * L)
 static gint
 lua_task_get_raw_header_common (lua_State * L, gboolean strong)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	struct raw_header *rh;
-	gint i = 1;
-	const gchar *name;
+	struct rspamd_task             *task = lua_check_task (L);
+	struct raw_header  			   *rh;
+	gint                            i = 1;
+	const gchar                    *name;
 
 	if (task) {
 		name = luaL_checkstring (L, 2);
@@ -620,7 +613,7 @@ lua_task_get_raw_header_common (lua_State * L, gboolean strong)
 			}
 			/* Create new associated table for a header */
 			lua_newtable (L);
-			lua_set_table_index (L, "name",	 rh->name);
+			lua_set_table_index (L, "name", rh->name);
 			lua_set_table_index (L, "value", rh->value);
 			lua_pushstring (L, "tab_separated");
 			lua_pushboolean (L, rh->tab_separated);
@@ -656,17 +649,17 @@ lua_task_get_raw_header_strong (lua_State * L)
 static gint
 lua_task_get_received_headers (lua_State * L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	GList *cur;
-	struct received_header *rh;
-	gint i = 1;
+	struct rspamd_task             *task = lua_check_task (L);
+	GList                          *cur;
+	struct received_header         *rh;
+	gint                            i = 1;
 
 	if (task) {
 		lua_newtable (L);
 		cur = g_list_first (task->received);
 		while (cur) {
 			rh = cur->data;
-			if (rh->is_error || G_UNLIKELY (
+			if (rh->is_error || G_UNLIKELY(
 					rh->from_ip == NULL &&
 					rh->real_ip == NULL &&
 					rh->real_hostname == NULL &&
@@ -698,8 +691,8 @@ lua_task_get_received_headers (lua_State * L)
 static gint
 lua_task_get_resolver (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	struct rspamd_dns_resolver **presolver;
+	struct rspamd_task             *task = lua_check_task (L);
+	struct rspamd_dns_resolver    **presolver;
 
 	if (task != NULL && task->resolver != NULL) {
 		presolver = lua_newuserdata (L, sizeof (void *));
@@ -716,10 +709,10 @@ lua_task_get_resolver (lua_State *L)
 static gint
 lua_task_inc_dns_req (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL) {
-		task->dns_requests++;
+		task->dns_requests ++;
 	}
 
 	return 0;
@@ -728,11 +721,11 @@ lua_task_inc_dns_req (lua_State *L)
 static gint
 lua_task_call_rspamd_function (lua_State * L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	struct expression_function f;
-	gint i, top;
-	gboolean res;
-	gchar *arg;
+	struct rspamd_task             *task = lua_check_task (L);
+	struct expression_function      f;
+	gint                            i, top;
+	gboolean                        res;
+	gchar                           *arg;
 
 	if (task) {
 		f.name = (gchar *)luaL_checkstring (L, 2);
@@ -776,13 +769,12 @@ lua_push_internet_address (lua_State *L, InternetAddress *ia)
 	}
 	return FALSE;
 #else
-	InternetAddressMailbox *iamb;
+	InternetAddressMailbox        *iamb;
 	if (ia && INTERNET_ADDRESS_IS_MAILBOX (ia)) {
 		lua_newtable (L);
 		iamb = INTERNET_ADDRESS_MAILBOX (ia);
 		lua_set_table_index (L, "name", internet_address_get_name (ia));
-		lua_set_table_index (L, "addr",
-			internet_address_mailbox_get_addr (iamb));
+		lua_set_table_index (L, "addr", internet_address_mailbox_get_addr (iamb));
 		return TRUE;
 	}
 	return FALSE;
@@ -795,12 +787,12 @@ lua_push_internet_address (lua_State *L, InternetAddress *ia)
 static void
 lua_push_internet_address_list (lua_State *L, InternetAddressList *addrs)
 {
-	InternetAddress *ia;
-	gint idx = 1;
+	InternetAddress                *ia;
+	gint                            idx = 1;
 
 #ifndef GMIME24
 	/* Gmime 2.2 version */
-	InternetAddressList *cur;
+	InternetAddressList            *cur;
 
 	lua_newtable (L);
 	cur = addrs;
@@ -813,12 +805,12 @@ lua_push_internet_address_list (lua_State *L, InternetAddressList *addrs)
 	}
 #else
 	/* Gmime 2.4 version */
-	gsize len, i;
+	gsize                          len, i;
 
 	lua_newtable (L);
 	if (addrs != NULL) {
 		len = internet_address_list_length (addrs);
-		for (i = 0; i < len; i++) {
+		for (i = 0; i < len; i ++) {
 			ia = internet_address_list_get_address (addrs, i);
 			if (lua_push_internet_address (L, ia)) {
 				lua_rawseti (L, -2, idx++);
@@ -831,10 +823,10 @@ lua_push_internet_address_list (lua_State *L, InternetAddressList *addrs)
 static gint
 lua_task_get_recipients (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	GList *cur;
-	InternetAddressList *addrs;
-	gint idx = 1;
+	struct rspamd_task             *task = lua_check_task (L);
+	GList                          *cur;
+	InternetAddressList            *addrs;
+	gint                            idx = 1;
 
 	if (task) {
 		cur = task->rcpt;
@@ -844,8 +836,7 @@ lua_task_get_recipients (lua_State *L)
 #ifndef GMIME24
 				addrs = internet_address_parse_string (cur->data);
 				if (addrs) {
-					if (lua_push_internet_address (L,
-						internet_address_list_get_address (addrs))) {
+					if (lua_push_internet_address (L, internet_address_list_get_address (addrs))) {
 						lua_rawseti (L, -2, idx++);
 					}
 					internet_address_list_destroy (addrs);
@@ -854,8 +845,7 @@ lua_task_get_recipients (lua_State *L)
 
 				addrs = internet_address_list_parse_string (cur->data);
 				if (addrs) {
-					if (lua_push_internet_address (L,
-						internet_address_list_get_address (addrs, 0))) {
+					if (lua_push_internet_address (L, internet_address_list_get_address (addrs, 0))) {
 						lua_rawseti (L, -2, idx++);
 					}
 					g_object_unref (addrs);
@@ -874,9 +864,9 @@ lua_task_get_recipients (lua_State *L)
 static gint
 lua_task_get_from (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	InternetAddressList *addrs;
-
+	struct rspamd_task             *task = lua_check_task (L);
+	InternetAddressList            *addrs;
+	
 	if (task) {
 		if (task->from != NULL) {
 #ifndef GMIME24
@@ -886,7 +876,7 @@ lua_task_get_from (lua_State *L)
 #endif
 			if (addrs != NULL) {
 				lua_push_internet_address_list (L, addrs);
-#ifndef GMIME24
+#ifndef	GMIME24
 				internet_address_list_destroy (addrs);
 #else
 				g_object_unref (addrs);
@@ -907,8 +897,8 @@ lua_task_get_from (lua_State *L)
 static gint
 lua_task_set_from (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *new_from;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar					   *new_from;
 
 	if (task) {
 		new_from = luaL_checkstring (L, 2);
@@ -923,7 +913,7 @@ lua_task_set_from (lua_State *L)
 static gint
 lua_task_get_user (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task && task->user != NULL) {
 		lua_pushstring (L, task->user);
@@ -937,8 +927,8 @@ lua_task_get_user (lua_State *L)
 static gint
 lua_task_set_user (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *new_user;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar					   *new_user;
 
 	if (task) {
 		new_user = luaL_checkstring (L, 2);
@@ -956,7 +946,7 @@ lua_task_set_user (lua_State *L)
 static gint
 lua_task_get_recipients_headers (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task && task->rcpts) {
 		lua_push_internet_address_list (L, task->rcpts);
@@ -970,22 +960,18 @@ lua_task_get_recipients_headers (lua_State *L)
 static gint
 lua_task_get_from_headers (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	InternetAddressList *addrs;
+	struct rspamd_task             *task = lua_check_task (L);
+	InternetAddressList            *addrs;
 
 	if (task && task->message != NULL) {
 #ifndef GMIME24
-		addrs =
-			internet_address_parse_string (g_mime_message_get_sender (
-					task->message));
+		addrs = internet_address_parse_string (g_mime_message_get_sender (task->message));
 #else
-		addrs =
-			internet_address_list_parse_string (g_mime_message_get_sender (task
-				->message));
+		addrs = internet_address_list_parse_string (g_mime_message_get_sender (task->message));
 #endif
 		if (addrs) {
 			lua_push_internet_address_list (L, addrs);
-#ifndef GMIME24
+#ifndef	GMIME24
 			internet_address_list_destroy (addrs);
 #else
 			g_object_unref (addrs);
@@ -1004,8 +990,8 @@ lua_task_get_from_headers (lua_State *L)
 static gint
 lua_task_get_from_ip (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-
+	struct rspamd_task             *task = lua_check_task (L);
+	
 	if (task) {
 		lua_ip_push (L, &task->from_addr);
 	}
@@ -1034,8 +1020,8 @@ lua_task_get_from_ip_num (lua_State *L)
 static gint
 lua_task_get_client_ip_num (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-
+	struct rspamd_task             *task = lua_check_task (L);
+	
 	if (task) {
 		lua_ip_push (L, &task->client_addr);
 	}
@@ -1049,8 +1035,8 @@ lua_task_get_client_ip_num (lua_State *L)
 static gint
 lua_task_get_helo (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-
+	struct rspamd_task             *task = lua_check_task (L);
+	
 	if (task) {
 		if (task->helo != NULL) {
 			lua_pushstring (L, (gchar *)task->helo);
@@ -1065,8 +1051,8 @@ lua_task_get_helo (lua_State *L)
 static gint
 lua_task_set_helo (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *new_helo;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar					   *new_helo;
 
 	if (task) {
 		new_helo = luaL_checkstring (L, 2);
@@ -1081,7 +1067,7 @@ lua_task_set_helo (lua_State *L)
 static gint
 lua_task_get_hostname (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task) {
 		if (task->hostname != NULL) {
@@ -1111,14 +1097,13 @@ lua_task_get_hostname (lua_State *L)
 static gint
 lua_task_set_hostname (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *new_hostname;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar					   *new_hostname;
 
 	if (task) {
 		new_hostname = luaL_checkstring (L, 2);
 		if (new_hostname) {
-			task->hostname = rspamd_mempool_strdup (task->task_pool,
-					new_hostname);
+			task->hostname = rspamd_mempool_strdup (task->task_pool, new_hostname);
 		}
 	}
 
@@ -1128,10 +1113,10 @@ lua_task_set_hostname (lua_State *L)
 static gint
 lua_task_get_images (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	gint i = 1;
-	GList *cur;
-	struct rspamd_image **pimg;
+	struct rspamd_task             *task = lua_check_task (L);
+	gint                            i = 1;
+	GList                          *cur;
+	struct rspamd_image           **pimg;
 
 	if (task) {
 		cur = task->images;
@@ -1153,15 +1138,12 @@ lua_task_get_images (lua_State *L)
 }
 
 static inline gboolean
-lua_push_symbol_result (lua_State *L,
-	struct rspamd_task *task,
-	struct metric *metric,
-	const gchar *symbol)
+lua_push_symbol_result (lua_State *L, struct rspamd_task *task, struct metric *metric, const gchar *symbol)
 {
-	struct metric_result *metric_res;
-	struct symbol *s;
-	gint j;
-	GList *opt;
+	struct metric_result           *metric_res;
+	struct symbol                  *s;
+	gint                            j;
+	GList                          *opt;
 
 	metric_res = g_hash_table_lookup (task->results, metric->name);
 	if (metric_res) {
@@ -1196,12 +1178,12 @@ lua_push_symbol_result (lua_State *L,
 static gint
 lua_task_get_symbol (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *symbol;
-	struct metric *metric;
-	GList *cur = NULL, *metric_list;
-	gboolean found = FALSE;
-	gint i = 1;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar                     *symbol;
+	struct metric                  *metric;
+	GList                          *cur = NULL, *metric_list;
+	gboolean                        found = FALSE;
+	gint                            i = 1;
 
 	symbol = luaL_checkstring (L, 2);
 
@@ -1242,8 +1224,8 @@ lua_task_get_symbol (lua_State *L)
 static gint
 lua_task_get_date (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	time_t task_time;
+	struct rspamd_task             *task = lua_check_task (L);
+	time_t                          task_time;
 
 	if (task != NULL) {
 		/* Get GMT date and store it to time_t */
@@ -1260,7 +1242,7 @@ lua_task_get_date (lua_State *L)
 static gint
 lua_task_get_message_id (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL && task->message_id != NULL) {
 		lua_pushstring (L, task->message_id);
@@ -1275,7 +1257,7 @@ lua_task_get_message_id (lua_State *L)
 static gint
 lua_task_get_timeval (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
+	struct rspamd_task             *task = lua_check_task (L);
 
 	if (task != NULL) {
 		lua_newtable (L);
@@ -1297,13 +1279,13 @@ lua_task_get_timeval (lua_State *L)
 static gint
 lua_task_learn_statfile (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *symbol;
-	struct rspamd_classifier_config *cl;
-	GTree *tokens;
-	struct rspamd_statfile_config *st;
-	stat_file_t *statfile;
-	struct classifier_ctx *ctx;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar                     *symbol;
+	struct rspamd_classifier_config       *cl;
+	GTree                          *tokens;
+	struct rspamd_statfile_config                *st;
+	stat_file_t                    *statfile;
+	struct classifier_ctx          *ctx;
 
 	symbol = luaL_checkstring (L, 2);
 
@@ -1315,17 +1297,13 @@ lua_task_learn_statfile (lua_State *L)
 			return 1;
 		}
 		ctx = cl->classifier->init_func (task->task_pool, cl);
-		if ((tokens =
-			g_hash_table_lookup (task->tokens, cl->tokenizer)) == NULL) {
+		if ((tokens = g_hash_table_lookup (task->tokens, cl->tokenizer)) == NULL) {
 			msg_warn ("no tokens found learn failed!");
 			lua_pushboolean (L, FALSE);
 			return 1;
 		}
-		statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool,
-				ctx->cfg,
-				symbol,
-				&st,
-				TRUE);
+		statfile = get_statfile_by_symbol (task->worker->srv->statfile_pool, ctx->cfg,
+								symbol, &st, TRUE);
 
 		if (statfile == NULL) {
 			msg_warn ("opening statfile failed!");
@@ -1333,14 +1311,7 @@ lua_task_learn_statfile (lua_State *L)
 			return 1;
 		}
 
-		cl->classifier->learn_func (ctx,
-			task->worker->srv->statfile_pool,
-			symbol,
-			tokens,
-			TRUE,
-			NULL,
-			1.,
-			NULL);
+		cl->classifier->learn_func (ctx, task->worker->srv->statfile_pool, symbol, tokens, TRUE, NULL, 1., NULL);
 		maybe_write_binlog (ctx->cfg, st, statfile, tokens);
 		lua_pushboolean (L, TRUE);
 	}
@@ -1351,23 +1322,20 @@ lua_task_learn_statfile (lua_State *L)
 static gint
 lua_task_get_metric_score (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *metric_name;
-	struct metric_result *metric_res;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar                     *metric_name;
+	struct metric_result           *metric_res;
 
 	metric_name = luaL_checkstring (L, 2);
 
 	if (task && metric_name) {
-		if ((metric_res =
-			g_hash_table_lookup (task->results, metric_name)) != NULL) {
+		if ((metric_res = g_hash_table_lookup (task->results, metric_name)) != NULL) {
 			lua_newtable (L);
 			lua_pushnumber (L, metric_res->score);
 			lua_rawseti (L, -2, 1);
-			lua_pushnumber (L,
-				metric_res->metric->actions[METRIC_ACTION_REJECT].score);
+			lua_pushnumber (L, metric_res->metric->actions[METRIC_ACTION_REJECT].score);
 			lua_rawseti (L, -2, 2);
-			lua_pushnumber (L,
-				metric_res->metric->actions[METRIC_ACTION_REJECT].score);
+			lua_pushnumber (L, metric_res->metric->actions[METRIC_ACTION_REJECT].score);
 			lua_rawseti (L, -2, 3);
 		}
 		else {
@@ -1382,19 +1350,17 @@ lua_task_get_metric_score (lua_State *L)
 static gint
 lua_task_get_metric_action (lua_State *L)
 {
-	struct rspamd_task *task = lua_check_task (L);
-	const gchar *metric_name;
-	struct metric_result *metric_res;
-	enum rspamd_metric_action action;
+	struct rspamd_task             *task = lua_check_task (L);
+	const gchar                     *metric_name;
+	struct metric_result           *metric_res;
+	enum rspamd_metric_action       action;
 
 	metric_name = luaL_checkstring (L, 2);
 
 	if (task && metric_name) {
-		if ((metric_res =
-			g_hash_table_lookup (task->results, metric_name)) != NULL) {
+		if ((metric_res = g_hash_table_lookup (task->results, metric_name)) != NULL) {
 			action = check_metric_action (metric_res->score,
-					metric_res->metric->actions[METRIC_ACTION_REJECT].score,
-					metric_res->metric);
+					metric_res->metric->actions[METRIC_ACTION_REJECT].score, metric_res->metric);
 			lua_pushstring (L, str_action_metric (action));
 		}
 		else {
@@ -1411,7 +1377,7 @@ lua_task_get_metric_action (lua_State *L)
 static gint
 lua_textpart_get_content (lua_State * L)
 {
-	struct mime_text_part *part = lua_check_textpart (L);
+	struct mime_text_part          *part = lua_check_textpart (L);
 
 	if (part == NULL || part->is_empty) {
 		lua_pushnil (L);
@@ -1426,7 +1392,7 @@ lua_textpart_get_content (lua_State * L)
 static gint
 lua_textpart_get_length (lua_State * L)
 {
-	struct mime_text_part *part = lua_check_textpart (L);
+	struct mime_text_part          *part = lua_check_textpart (L);
 
 	if (part == NULL) {
 		lua_pushnil (L);
@@ -1446,7 +1412,7 @@ lua_textpart_get_length (lua_State * L)
 static gint
 lua_textpart_is_empty (lua_State * L)
 {
-	struct mime_text_part *part = lua_check_textpart (L);
+	struct mime_text_part          *part = lua_check_textpart (L);
 
 	if (part == NULL) {
 		lua_pushnil (L);
@@ -1461,7 +1427,7 @@ lua_textpart_is_empty (lua_State * L)
 static gint
 lua_textpart_is_html (lua_State * L)
 {
-	struct mime_text_part *part = lua_check_textpart (L);
+	struct mime_text_part          *part = lua_check_textpart (L);
 
 	if (part == NULL) {
 		lua_pushnil (L);
@@ -1476,108 +1442,106 @@ lua_textpart_is_html (lua_State * L)
 static gint
 lua_textpart_get_fuzzy (lua_State * L)
 {
-	struct mime_text_part *part = lua_check_textpart (L);
+	struct mime_text_part          *part = lua_check_textpart (L);
 
 	if (part == NULL || part->is_empty) {
 		lua_pushnil (L);
 		return 1;
 	}
 
-	lua_pushlstring (L, part->fuzzy->hash_pipe,
-		sizeof (part->fuzzy->hash_pipe));
+	lua_pushlstring (L, part->fuzzy->hash_pipe, sizeof (part->fuzzy->hash_pipe));
 	return 1;
 }
 
 static gint
 lua_textpart_get_language (lua_State * L)
 {
-	struct mime_text_part *part = lua_check_textpart (L);
-	static const gchar languages[][4] = {
-		"",        /* G_UNICODE_SCRIPT_COMMON */
-		"",        /* G_UNICODE_SCRIPT_INHERITED */
-		"ar",      /* G_UNICODE_SCRIPT_ARABIC */
-		"hy",      /* G_UNICODE_SCRIPT_ARMENIAN */
-		"bn",      /* G_UNICODE_SCRIPT_BENGALI */
-		/* Used primarily in Taiwan, but not part of the standard
-		 * zh-tw orthography  */
-		"",        /* G_UNICODE_SCRIPT_BOPOMOFO */
-		"chr",     /* G_UNICODE_SCRIPT_CHEROKEE */
-		"cop",     /* G_UNICODE_SCRIPT_COPTIC */
-		"ru",      /* G_UNICODE_SCRIPT_CYRILLIC */
-		/* Deseret was used to write English */
-		"",        /* G_UNICODE_SCRIPT_DESERET */
-		"hi",      /* G_UNICODE_SCRIPT_DEVANAGARI */
-		"am",      /* G_UNICODE_SCRIPT_ETHIOPIC */
-		"ka",      /* G_UNICODE_SCRIPT_GEORGIAN */
-		"",        /* G_UNICODE_SCRIPT_GOTHIC */
-		"el",      /* G_UNICODE_SCRIPT_GREEK */
-		"gu",      /* G_UNICODE_SCRIPT_GUJARATI */
-		"pa",      /* G_UNICODE_SCRIPT_GURMUKHI */
-		"",        /* G_UNICODE_SCRIPT_HAN */
-		"ko",      /* G_UNICODE_SCRIPT_HANGUL */
-		"he",      /* G_UNICODE_SCRIPT_HEBREW */
-		"ja",      /* G_UNICODE_SCRIPT_HIRAGANA */
-		"kn",      /* G_UNICODE_SCRIPT_KANNADA */
-		"ja",      /* G_UNICODE_SCRIPT_KATAKANA */
-		"km",      /* G_UNICODE_SCRIPT_KHMER */
-		"lo",      /* G_UNICODE_SCRIPT_LAO */
-		"en",      /* G_UNICODE_SCRIPT_LATIN */
-		"ml",      /* G_UNICODE_SCRIPT_MALAYALAM */
-		"mn",      /* G_UNICODE_SCRIPT_MONGOLIAN */
-		"my",      /* G_UNICODE_SCRIPT_MYANMAR */
-		/* Ogham was used to write old Irish */
-		"",        /* G_UNICODE_SCRIPT_OGHAM */
-		"",        /* G_UNICODE_SCRIPT_OLD_ITALIC */
-		"or",      /* G_UNICODE_SCRIPT_ORIYA */
-		"",        /* G_UNICODE_SCRIPT_RUNIC */
-		"si",      /* G_UNICODE_SCRIPT_SINHALA */
-		"syr",     /* G_UNICODE_SCRIPT_SYRIAC */
-		"ta",      /* G_UNICODE_SCRIPT_TAMIL */
-		"te",      /* G_UNICODE_SCRIPT_TELUGU */
-		"dv",      /* G_UNICODE_SCRIPT_THAANA */
-		"th",      /* G_UNICODE_SCRIPT_THAI */
-		"bo",      /* G_UNICODE_SCRIPT_TIBETAN */
-		"iu",      /* G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL */
-		"",        /* G_UNICODE_SCRIPT_YI */
-		"tl",      /* G_UNICODE_SCRIPT_TAGALOG */
-		/* Phillipino languages/scripts */
-		"hnn",     /* G_UNICODE_SCRIPT_HANUNOO */
-		"bku",     /* G_UNICODE_SCRIPT_BUHID */
-		"tbw",     /* G_UNICODE_SCRIPT_TAGBANWA */
-
-		"",        /* G_UNICODE_SCRIPT_BRAILLE */
-		"",        /* G_UNICODE_SCRIPT_CYPRIOT */
-		"",        /* G_UNICODE_SCRIPT_LIMBU */
-		/* Used for Somali (so) in the past */
-		"",        /* G_UNICODE_SCRIPT_OSMANYA */
-		/* The Shavian alphabet was designed for English */
-		"",        /* G_UNICODE_SCRIPT_SHAVIAN */
-		"",        /* G_UNICODE_SCRIPT_LINEAR_B */
-		"",        /* G_UNICODE_SCRIPT_TAI_LE */
-		"uga",     /* G_UNICODE_SCRIPT_UGARITIC */
-
-		"",        /* G_UNICODE_SCRIPT_NEW_TAI_LUE */
-		"bug",     /* G_UNICODE_SCRIPT_BUGINESE */
-		/* The original script for Old Church Slavonic (chu), later
-		 * written with Cyrillic */
-		"",        /* G_UNICODE_SCRIPT_GLAGOLITIC */
-		/* Used for for Berber (ber), but Arabic script is more common */
-		"",        /* G_UNICODE_SCRIPT_TIFINAGH */
-		"syl",     /* G_UNICODE_SCRIPT_SYLOTI_NAGRI */
-		"peo",     /* G_UNICODE_SCRIPT_OLD_PERSIAN */
-		"",        /* G_UNICODE_SCRIPT_KHAROSHTHI */
-
-		"",        /* G_UNICODE_SCRIPT_UNKNOWN */
-		"",        /* G_UNICODE_SCRIPT_BALINESE */
-		"",        /* G_UNICODE_SCRIPT_CUNEIFORM */
-		"",        /* G_UNICODE_SCRIPT_PHOENICIAN */
-		"",        /* G_UNICODE_SCRIPT_PHAGS_PA */
-		"nqo"      /* G_UNICODE_SCRIPT_NKO */
+	struct mime_text_part          *part = lua_check_textpart (L);
+	static const gchar              languages[][4] = {
+			"",    /* G_UNICODE_SCRIPT_COMMON */
+			"",    /* G_UNICODE_SCRIPT_INHERITED */
+			"ar",  /* G_UNICODE_SCRIPT_ARABIC */
+			"hy",  /* G_UNICODE_SCRIPT_ARMENIAN */
+			"bn",  /* G_UNICODE_SCRIPT_BENGALI */
+			/* Used primarily in Taiwan, but not part of the standard
+			 * zh-tw orthography  */
+			"",    /* G_UNICODE_SCRIPT_BOPOMOFO */
+			"chr", /* G_UNICODE_SCRIPT_CHEROKEE */
+			"cop", /* G_UNICODE_SCRIPT_COPTIC */
+			"ru",  /* G_UNICODE_SCRIPT_CYRILLIC */
+			/* Deseret was used to write English */
+			"",    /* G_UNICODE_SCRIPT_DESERET */
+			"hi",  /* G_UNICODE_SCRIPT_DEVANAGARI */
+			"am",  /* G_UNICODE_SCRIPT_ETHIOPIC */
+			"ka",  /* G_UNICODE_SCRIPT_GEORGIAN */
+			"",    /* G_UNICODE_SCRIPT_GOTHIC */
+			"el",  /* G_UNICODE_SCRIPT_GREEK */
+			"gu",  /* G_UNICODE_SCRIPT_GUJARATI */
+			"pa",  /* G_UNICODE_SCRIPT_GURMUKHI */
+			"",    /* G_UNICODE_SCRIPT_HAN */
+			"ko",  /* G_UNICODE_SCRIPT_HANGUL */
+			"he",  /* G_UNICODE_SCRIPT_HEBREW */
+			"ja",  /* G_UNICODE_SCRIPT_HIRAGANA */
+			"kn",  /* G_UNICODE_SCRIPT_KANNADA */
+			"ja",  /* G_UNICODE_SCRIPT_KATAKANA */
+			"km",  /* G_UNICODE_SCRIPT_KHMER */
+			"lo",  /* G_UNICODE_SCRIPT_LAO */
+			"en",  /* G_UNICODE_SCRIPT_LATIN */
+			"ml",  /* G_UNICODE_SCRIPT_MALAYALAM */
+			"mn",  /* G_UNICODE_SCRIPT_MONGOLIAN */
+			"my",  /* G_UNICODE_SCRIPT_MYANMAR */
+			/* Ogham was used to write old Irish */
+			"",    /* G_UNICODE_SCRIPT_OGHAM */
+			"",    /* G_UNICODE_SCRIPT_OLD_ITALIC */
+			"or",  /* G_UNICODE_SCRIPT_ORIYA */
+			"",    /* G_UNICODE_SCRIPT_RUNIC */
+			"si",  /* G_UNICODE_SCRIPT_SINHALA */
+			"syr", /* G_UNICODE_SCRIPT_SYRIAC */
+			"ta",  /* G_UNICODE_SCRIPT_TAMIL */
+			"te",  /* G_UNICODE_SCRIPT_TELUGU */
+			"dv",  /* G_UNICODE_SCRIPT_THAANA */
+			"th",  /* G_UNICODE_SCRIPT_THAI */
+			"bo",  /* G_UNICODE_SCRIPT_TIBETAN */
+			"iu",  /* G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL */
+			"",    /* G_UNICODE_SCRIPT_YI */
+			"tl",  /* G_UNICODE_SCRIPT_TAGALOG */
+			/* Phillipino languages/scripts */
+			"hnn", /* G_UNICODE_SCRIPT_HANUNOO */
+			"bku", /* G_UNICODE_SCRIPT_BUHID */
+			"tbw", /* G_UNICODE_SCRIPT_TAGBANWA */
+
+			"",    /* G_UNICODE_SCRIPT_BRAILLE */
+			"",    /* G_UNICODE_SCRIPT_CYPRIOT */
+			"",    /* G_UNICODE_SCRIPT_LIMBU */
+			/* Used for Somali (so) in the past */
+			"",    /* G_UNICODE_SCRIPT_OSMANYA */
+			/* The Shavian alphabet was designed for English */
+			"",    /* G_UNICODE_SCRIPT_SHAVIAN */
+			"",    /* G_UNICODE_SCRIPT_LINEAR_B */
+			"",    /* G_UNICODE_SCRIPT_TAI_LE */
+			"uga", /* G_UNICODE_SCRIPT_UGARITIC */
+
+			"",    /* G_UNICODE_SCRIPT_NEW_TAI_LUE */
+			"bug", /* G_UNICODE_SCRIPT_BUGINESE */
+			/* The original script for Old Church Slavonic (chu), later
+			 * written with Cyrillic */
+			"",    /* G_UNICODE_SCRIPT_GLAGOLITIC */
+			/* Used for for Berber (ber), but Arabic script is more common */
+			"",    /* G_UNICODE_SCRIPT_TIFINAGH */
+			"syl", /* G_UNICODE_SCRIPT_SYLOTI_NAGRI */
+			"peo", /* G_UNICODE_SCRIPT_OLD_PERSIAN */
+			"",    /* G_UNICODE_SCRIPT_KHAROSHTHI */
+
+			"",    /* G_UNICODE_SCRIPT_UNKNOWN */
+			"",    /* G_UNICODE_SCRIPT_BALINESE */
+			"",    /* G_UNICODE_SCRIPT_CUNEIFORM */
+			"",    /* G_UNICODE_SCRIPT_PHOENICIAN */
+			"",    /* G_UNICODE_SCRIPT_PHAGS_PA */
+			"nqo"  /* G_UNICODE_SCRIPT_NKO */
 	};
-	const gchar *sel;
+	const gchar                    *sel;
 
-	if (part != NULL && part->script > 0 && part->script <
-		(gint)G_N_ELEMENTS (languages)) {
+	if (part != NULL && part->script > 0 && part->script < (gint)G_N_ELEMENTS (languages)) {
 		sel = languages[part->script];
 		if (*sel != '\0') {
 			lua_pushstring (L, sel);
@@ -1592,11 +1556,11 @@ lua_textpart_get_language (lua_State * L)
 static gint
 lua_textpart_compare_distance (lua_State * L)
 {
-	struct mime_text_part *part = lua_check_textpart (L), *other;
-	void *ud = luaL_checkudata (L, 2, "rspamd{textpart}");
-	gint diff = -1;
-	GMimeObject *parent;
-	const GMimeContentType *ct;
+	struct mime_text_part          *part = lua_check_textpart (L), *other;
+	void                           *ud = luaL_checkudata (L, 2, "rspamd{textpart}");
+	gint                            diff = -1;
+	GMimeObject                    *parent;
+	const GMimeContentType         *ct;
 
 	luaL_argcheck (L, ud != NULL, 2, "'textpart' expected");
 	other = ud ? *((struct mime_text_part **)ud) : NULL;
@@ -1605,12 +1569,9 @@ lua_textpart_compare_distance (lua_State * L)
 		parent = part->parent;
 		ct = g_mime_object_get_content_type (parent);
 #ifndef GMIME24
-		if (ct == NULL ||
-			!g_mime_content_type_is_type (ct, "multipart", "alternative")) {
+		if (ct == NULL || ! g_mime_content_type_is_type (ct, "multipart", "alternative")) {
 #else
-		if (ct == NULL ||
-			!g_mime_content_type_is_type ((GMimeContentType *)ct, "multipart",
-			"alternative")) {
+		if (ct == NULL || ! g_mime_content_type_is_type ((GMimeContentType *)ct, "multipart", "alternative")) {
 #endif
 			diff = -1;
 
@@ -1618,22 +1579,20 @@ lua_textpart_compare_distance (lua_State * L)
 		else {
 			if (!part->is_empty && !other->is_empty) {
 				if (part->diff_str != NULL && other->diff_str != NULL) {
-					diff = compare_diff_distance (part->diff_str,
-							other->diff_str);
+					diff = compare_diff_distance (part->diff_str, other->diff_str);
 				}
 				else {
 					diff = fuzzy_compare_parts (part, other);
 				}
 			}
-			else if ((part->is_empty &&
-				!other->is_empty) || (!part->is_empty && other->is_empty)) {
+			else if ((part->is_empty && !other->is_empty) || (!part->is_empty && other->is_empty)) {
 				/* Empty and non empty parts are different */
 				diff = 0;
 			}
 		}
 	}
 	else {
-		diff = -1;
+			diff = -1;
 	}
 
 
@@ -1647,7 +1606,7 @@ lua_textpart_compare_distance (lua_State * L)
 static gint
 lua_mimepart_get_content (lua_State * L)
 {
-	struct mime_part *part = lua_check_mimepart (L);
+	struct mime_part          	  *part = lua_check_mimepart (L);
 
 	if (part == NULL) {
 		lua_pushnil (L);
@@ -1662,7 +1621,7 @@ lua_mimepart_get_content (lua_State * L)
 static gint
 lua_mimepart_get_length (lua_State * L)
 {
-	struct mime_part *part = lua_check_mimepart (L);
+	struct mime_part              *part = lua_check_mimepart (L);
 
 	if (part == NULL) {
 		lua_pushnil (L);
@@ -1677,7 +1636,7 @@ lua_mimepart_get_length (lua_State * L)
 static gint
 lua_mimepart_get_type (lua_State * L)
 {
-	struct mime_part *part = lua_check_mimepart (L);
+	struct mime_part          	  *part = lua_check_mimepart (L);
 
 	if (part == NULL) {
 		lua_pushnil (L);
@@ -1698,7 +1657,7 @@ lua_mimepart_get_type (lua_State * L)
 static gint
 lua_mimepart_get_filename (lua_State * L)
 {
-	struct mime_part *part = lua_check_mimepart (L);
+	struct mime_part              *part = lua_check_mimepart (L);
 
 	if (part == NULL || part->filename == NULL) {
 		lua_pushnil (L);
@@ -1714,7 +1673,7 @@ lua_mimepart_get_filename (lua_State * L)
 static gint
 lua_image_get_width (lua_State *L)
 {
-	struct rspamd_image *img = lua_check_image (L);
+	struct rspamd_image             *img = lua_check_image (L);
 
 	if (img != NULL) {
 		lua_pushnumber (L, img->width);
@@ -1728,7 +1687,7 @@ lua_image_get_width (lua_State *L)
 static gint
 lua_image_get_height (lua_State *L)
 {
-	struct rspamd_image *img = lua_check_image (L);
+	struct rspamd_image             *img = lua_check_image (L);
 
 	if (img != NULL) {
 		lua_pushnumber (L, img->height);
@@ -1743,7 +1702,7 @@ lua_image_get_height (lua_State *L)
 static gint
 lua_image_get_type (lua_State *L)
 {
-	struct rspamd_image *img = lua_check_image (L);
+	struct rspamd_image             *img = lua_check_image (L);
 
 	if (img != NULL) {
 		lua_pushstring (L, image_type_str (img->type));
@@ -1758,7 +1717,7 @@ lua_image_get_type (lua_State *L)
 static gint
 lua_image_get_size (lua_State *L)
 {
-	struct rspamd_image *img = lua_check_image (L);
+	struct rspamd_image             *img = lua_check_image (L);
 
 	if (img != NULL) {
 		lua_pushinteger (L, img->data->len);
@@ -1773,7 +1732,7 @@ lua_image_get_size (lua_State *L)
 static gint
 lua_image_get_filename (lua_State *L)
 {
-	struct rspamd_image *img = lua_check_image (L);
+	struct rspamd_image             *img = lua_check_image (L);
 
 	if (img != NULL && img->filename != NULL) {
 		lua_pushstring (L, img->filename);
@@ -1789,7 +1748,7 @@ lua_image_get_filename (lua_State *L)
 static gint
 lua_url_get_length (lua_State *L)
 {
-	struct uri *url = lua_check_url (L);
+	struct uri                      *url = lua_check_url (L);
 
 	if (url != NULL) {
 		lua_pushinteger (L, strlen (struri (url)));
@@ -1803,7 +1762,7 @@ lua_url_get_length (lua_State *L)
 static gint
 lua_url_get_host (lua_State *L)
 {
-	struct uri *url = lua_check_url (L);
+	struct uri                      *url = lua_check_url (L);
 
 	if (url != NULL) {
 		lua_pushlstring (L, url->host, url->hostlen);
@@ -1817,7 +1776,7 @@ lua_url_get_host (lua_State *L)
 static gint
 lua_url_get_user (lua_State *L)
 {
-	struct uri *url = lua_check_url (L);
+	struct uri                      *url = lua_check_url (L);
 
 	if (url != NULL) {
 		lua_pushlstring (L, url->user, url->userlen);
@@ -1832,7 +1791,7 @@ lua_url_get_user (lua_State *L)
 static gint
 lua_url_get_path (lua_State *L)
 {
-	struct uri *url = lua_check_url (L);
+	struct uri                      *url = lua_check_url (L);
 
 	if (url != NULL) {
 		lua_pushlstring (L, url->data, url->datalen);
@@ -1847,7 +1806,7 @@ lua_url_get_path (lua_State *L)
 static gint
 lua_url_get_text (lua_State *L)
 {
-	struct uri *url = lua_check_url (L);
+	struct uri                      *url = lua_check_url (L);
 
 	if (url != NULL) {
 		lua_pushstring (L, struri (url));
@@ -1862,7 +1821,7 @@ lua_url_get_text (lua_State *L)
 static gint
 lua_url_is_phished (lua_State *L)
 {
-	struct uri *url = lua_check_url (L);
+	struct uri                      *url = lua_check_url (L);
 
 	if (url != NULL) {
 		lua_pushboolean (L, url->is_phished);
@@ -1877,7 +1836,7 @@ lua_url_is_phished (lua_State *L)
 static gint
 lua_url_get_phished (lua_State *L)
 {
-	struct uri **purl, *url = lua_check_url (L);
+	struct uri                    **purl, *url = lua_check_url (L);
 
 	if (url) {
 		if (url->is_phished && url->phished_url != NULL) {
diff --git a/src/lua/lua_upstream.c b/src/lua/lua_upstream.c
index 255f2d194..ee06fe2c1 100644
--- a/src/lua/lua_upstream.c
+++ b/src/lua/lua_upstream.c
@@ -21,10 +21,10 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
 #include "lua_common.h"
 #include "upstream.h"
+#include "cfg_file.h"
 
 /* Upstream timeouts */
 #define DEFAULT_UPSTREAM_ERROR_TIME 10
@@ -41,7 +41,7 @@ LUA_FUNCTION_DEF (upstream_list, get_upstream_by_hash);
 LUA_FUNCTION_DEF (upstream_list, get_upstream_round_robin);
 LUA_FUNCTION_DEF (upstream_list, get_upstream_master_slave);
 
-static const struct luaL_reg upstream_list_m[] = {
+static const struct luaL_reg  upstream_list_m[] = {
 
 	LUA_INTERFACE_DEF (upstream_list, get_upstream_by_hash),
 	LUA_INTERFACE_DEF (upstream_list, get_upstream_round_robin),
@@ -50,7 +50,7 @@ static const struct luaL_reg upstream_list_m[] = {
 	{"__gc", lua_upstream_list_destroy},
 	{NULL, NULL}
 };
-static const struct luaL_reg upstream_list_f[] = {
+static const struct luaL_reg  upstream_list_f[] = {
 	LUA_INTERFACE_DEF (upstream_list, create),
 	{NULL, NULL}
 };
@@ -65,7 +65,7 @@ LUA_FUNCTION_DEF (upstream, get_port);
 LUA_FUNCTION_DEF (upstream, get_ip_string);
 LUA_FUNCTION_DEF (upstream, get_priority);
 
-static const struct luaL_reg upstream_m[] = {
+static const struct luaL_reg  upstream_m[] = {
 	LUA_INTERFACE_DEF (upstream, ok),
 	LUA_INTERFACE_DEF (upstream, fail),
 	LUA_INTERFACE_DEF (upstream, get_ip),
@@ -76,7 +76,7 @@ static const struct luaL_reg upstream_m[] = {
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
 };
-static const struct luaL_reg upstream_f[] = {
+static const struct luaL_reg  upstream_f[] = {
 	LUA_INTERFACE_DEF (upstream, create),
 	{NULL, NULL}
 };
@@ -89,10 +89,10 @@ struct lua_upstream {
 	gchar *addr;
 };
 
-static struct lua_upstream *
+static struct lua_upstream	*
 lua_check_upstream (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{upstream}");
+	void									*ud = luaL_checkudata (L, 1, "rspamd{upstream}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'upstream' expected");
 	return ud ? *((struct lua_upstream **)ud) : NULL;
@@ -106,16 +106,15 @@ lua_check_upstream (lua_State * L)
 static gint
 lua_upstream_create (lua_State *L)
 {
-	struct lua_upstream *new, **pnew;
-	const gchar *def;
+	struct lua_upstream						*new, **pnew;
+	const gchar								*def;
 
 	def = luaL_checkstring (L, 1);
 	if (def) {
 		new = g_slice_alloc0 (sizeof (struct lua_upstream));
 		new->def = g_strdup (def);
 		new->addr = g_malloc (INET6_ADDRSTRLEN);
-		if (!rspamd_parse_host_port_priority (NULL, new->def, &new->addr,
-			&new->port, &new->up.priority)) {
+		if (!rspamd_parse_host_port_priority (NULL, new->def, &new->addr, &new->port, &new->up.priority)) {
 			g_free (new->def);
 			g_slice_free1 (sizeof (struct lua_upstream), new);
 			lua_pushnil (L);
@@ -138,7 +137,7 @@ lua_upstream_create (lua_State *L)
 static gint
 lua_upstream_destroy (lua_State *L)
 {
-	struct lua_upstream *up = lua_check_upstream (L);
+	struct lua_upstream						*up = lua_check_upstream (L);
 
 	if (up) {
 		g_free (up->def);
@@ -157,7 +156,7 @@ lua_upstream_destroy (lua_State *L)
 static gint
 lua_upstream_get_ip (lua_State *L)
 {
-	struct lua_upstream *up = lua_check_upstream (L);
+	struct lua_upstream						*up = lua_check_upstream (L);
 
 	if (up) {
 		lua_pushstring (L, up->addr);
@@ -177,7 +176,7 @@ lua_upstream_get_ip (lua_State *L)
 static gint
 lua_upstream_get_ip_string (lua_State *L)
 {
-	struct lua_upstream *up = lua_check_upstream (L);
+	struct lua_upstream						*up = lua_check_upstream (L);
 
 	if (up) {
 		lua_pushstring (L, up->addr);
@@ -197,7 +196,7 @@ lua_upstream_get_ip_string (lua_State *L)
 static gint
 lua_upstream_get_port (lua_State *L)
 {
-	struct lua_upstream *up = lua_check_upstream (L);
+	struct lua_upstream						*up = lua_check_upstream (L);
 
 	if (up) {
 		lua_pushinteger (L, up->port);
@@ -217,7 +216,7 @@ lua_upstream_get_port (lua_State *L)
 static gint
 lua_upstream_get_priority (lua_State *L)
 {
-	struct lua_upstream *up = lua_check_upstream (L);
+	struct lua_upstream						*up = lua_check_upstream (L);
 
 	if (up) {
 		lua_pushinteger (L, up->up.priority);
@@ -237,8 +236,8 @@ lua_upstream_get_priority (lua_State *L)
 static gint
 lua_upstream_fail (lua_State *L)
 {
-	struct lua_upstream *up = lua_check_upstream (L);
-	time_t now;
+	struct lua_upstream						*up = lua_check_upstream (L);
+	time_t									 now;
 
 	if (up) {
 		if (lua_gettop (L) >= 2) {
@@ -261,8 +260,8 @@ lua_upstream_fail (lua_State *L)
 static gint
 lua_upstream_ok (lua_State *L)
 {
-	struct lua_upstream *up = lua_check_upstream (L);
-	time_t now;
+	struct lua_upstream						*up = lua_check_upstream (L);
+	time_t									 now;
 
 	if (up) {
 		if (lua_gettop (L) >= 2) {
@@ -283,10 +282,10 @@ struct lua_upstream_list {
 	guint count;
 };
 
-static struct lua_upstream_list *
+static struct lua_upstream_list	*
 lua_check_upstream_list (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{upstream_list}");
+	void									*ud = luaL_checkudata (L, 1, "rspamd{upstream_list}");
 
 	luaL_argcheck (L, ud != NULL, 1, "'upstream_list' expected");
 	return ud ? *((struct lua_upstream_list **)ud) : NULL;
@@ -300,11 +299,11 @@ lua_check_upstream_list (lua_State * L)
 static gint
 lua_upstream_list_create (lua_State *L)
 {
-	struct lua_upstream_list *new, **pnew;
-	struct lua_upstream *cur;
-	const gchar *def;
-	char **tokens;
-	guint i, default_port = 0;
+	struct lua_upstream_list				*new, **pnew;
+	struct lua_upstream						*cur;
+	const gchar								*def;
+	char									**tokens;
+	guint									 i, default_port = 0;
 
 	def = luaL_checkstring (L, 1);
 	if (def) {
@@ -318,14 +317,12 @@ lua_upstream_list_create (lua_State *L)
 			goto err;
 		}
 		new->count = g_strv_length (tokens);
-		new->upstreams =
-			g_slice_alloc0 (new->count * sizeof (struct lua_upstream));
+		new->upstreams = g_slice_alloc0 (new->count * sizeof (struct lua_upstream));
 
-		for (i = 0; i < new->count; i++) {
+		for (i = 0; i < new->count; i ++) {
 			cur = &new->upstreams[i];
 			cur->addr = g_malloc (INET6_ADDRSTRLEN);
-			if (!rspamd_parse_host_port_priority (NULL, tokens[i], &cur->addr,
-				&cur->port, &cur->up.priority)) {
+			if (!rspamd_parse_host_port_priority (NULL, tokens[i], &cur->addr, &cur->port, &cur->up.priority)) {
 				goto err;
 			}
 			if (cur->port == 0) {
@@ -343,14 +340,13 @@ err:
 		g_strfreev (tokens);
 	}
 	if (new->upstreams) {
-		for (i = 0; i < new->count; i++) {
+		for (i = 0; i < new->count; i ++) {
 			cur = &new->upstreams[i];
 			if (cur->addr) {
 				g_free (cur->addr);
 			}
 		}
-		g_slice_free1 (new->count * sizeof (struct lua_upstream),
-			new->upstreams);
+		g_slice_free1 (new->count * sizeof (struct lua_upstream), new->upstreams);
 	}
 	g_slice_free1 (sizeof (struct lua_upstream_list), new);
 	lua_pushnil (L);
@@ -365,20 +361,19 @@ err:
 static gint
 lua_upstream_list_destroy (lua_State *L)
 {
-	struct lua_upstream_list *upl = lua_check_upstream_list (L);
-	struct lua_upstream *cur;
-	guint i;
+	struct lua_upstream_list					*upl = lua_check_upstream_list (L);
+	struct lua_upstream							*cur;
+	guint									 	 i;
 
 	if (upl) {
 		if (upl->upstreams) {
-			for (i = 0; i < upl->count; i++) {
+			for (i = 0; i < upl->count; i ++) {
 				cur = &upl->upstreams[i];
 				if (cur->addr) {
 					g_free (cur->addr);
 				}
 			}
-			g_slice_free1 (upl->count * sizeof (struct lua_upstream),
-				upl->upstreams);
+			g_slice_free1 (upl->count * sizeof (struct lua_upstream), upl->upstreams);
 		}
 		g_slice_free1 (sizeof (struct lua_upstream_list), upl);
 	}
@@ -394,10 +389,10 @@ lua_upstream_list_destroy (lua_State *L)
 static gint
 lua_upstream_list_get_upstream_by_hash (lua_State *L)
 {
-	struct lua_upstream_list *upl;
-	struct lua_upstream *selected, **pselected;
-	time_t now;
-	const gchar *key;
+	struct lua_upstream_list					*upl;
+	struct lua_upstream							*selected, **pselected;
+	time_t										 now;
+	const gchar									*key;
 
 	upl = lua_check_upstream_list (L);
 	if (upl) {
@@ -409,16 +404,10 @@ lua_upstream_list_get_upstream_by_hash (lua_State *L)
 			else {
 				now = time (NULL);
 			}
-			selected = (struct lua_upstream *)get_upstream_by_hash (
-				upl->upstreams,
-				upl->count,
-				sizeof (struct lua_upstream),
-				now,
-				DEFAULT_UPSTREAM_ERROR_TIME,
-				DEFAULT_UPSTREAM_DEAD_TIME,
-				DEFAULT_UPSTREAM_MAXERRORS,
-				key,
-				0);
+			selected = (struct lua_upstream *)get_upstream_by_hash (upl->upstreams, upl->count,
+					sizeof (struct lua_upstream), now,
+					DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS,
+					key, 0);
 			if (selected) {
 				pselected = lua_newuserdata (L, sizeof (struct lua_upstream *));
 				lua_setclass (L, "rspamd{upstream}", -1);
@@ -447,9 +436,9 @@ lua_upstream_list_get_upstream_by_hash (lua_State *L)
 static gint
 lua_upstream_list_get_upstream_round_robin (lua_State *L)
 {
-	struct lua_upstream_list *upl;
-	struct lua_upstream *selected, **pselected;
-	time_t now;
+	struct lua_upstream_list					*upl;
+	struct lua_upstream							*selected, **pselected;
+	time_t										 now;
 
 	upl = lua_check_upstream_list (L);
 	if (upl) {
@@ -459,14 +448,9 @@ lua_upstream_list_get_upstream_round_robin (lua_State *L)
 		else {
 			now = time (NULL);
 		}
-		selected = (struct lua_upstream *)get_upstream_round_robin (
-			upl->upstreams,
-			upl->count,
-			sizeof (struct lua_upstream),
-			now,
-			DEFAULT_UPSTREAM_ERROR_TIME,
-			DEFAULT_UPSTREAM_DEAD_TIME,
-			DEFAULT_UPSTREAM_MAXERRORS);
+		selected = (struct lua_upstream *)get_upstream_round_robin (upl->upstreams, upl->count,
+				sizeof (struct lua_upstream), now,
+				DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
 		if (selected) {
 			pselected = lua_newuserdata (L, sizeof (struct lua_upstream *));
 			lua_setclass (L, "rspamd{upstream}", -1);
@@ -491,9 +475,9 @@ lua_upstream_list_get_upstream_round_robin (lua_State *L)
 static gint
 lua_upstream_list_get_upstream_master_slave (lua_State *L)
 {
-	struct lua_upstream_list *upl;
-	struct lua_upstream *selected, **pselected;
-	time_t now;
+	struct lua_upstream_list					*upl;
+	struct lua_upstream							*selected, **pselected;
+	time_t										 now;
 
 	upl = lua_check_upstream_list (L);
 	if (upl) {
@@ -503,14 +487,9 @@ lua_upstream_list_get_upstream_master_slave (lua_State *L)
 		else {
 			now = time (NULL);
 		}
-		selected = (struct lua_upstream *)get_upstream_master_slave (
-			upl->upstreams,
-			upl->count,
-			sizeof (struct lua_upstream),
-			now,
-			DEFAULT_UPSTREAM_ERROR_TIME,
-			DEFAULT_UPSTREAM_DEAD_TIME,
-			DEFAULT_UPSTREAM_MAXERRORS);
+		selected = (struct lua_upstream *)get_upstream_master_slave (upl->upstreams, upl->count,
+				sizeof (struct lua_upstream), now,
+				DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
 		if (selected) {
 			pselected = lua_newuserdata (L, sizeof (struct lua_upstream *));
 			lua_setclass (L, "rspamd{upstream}", -1);
@@ -540,7 +519,7 @@ luaopen_upstream (lua_State * L)
 	lua_pushstring (L, "rspamd{upstream_list}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,			   upstream_list_m);
+	luaL_register (L, NULL, upstream_list_m);
 	luaL_register (L, "upstream_list", upstream_list_f);
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
@@ -554,7 +533,7 @@ luaopen_upstream (lua_State * L)
 	lua_pushstring (L, "rspamd{upstream}");
 	lua_rawset (L, -3);
 
-	luaL_register (L, NULL,		  upstream_m);
+	luaL_register (L, NULL, upstream_m);
 	luaL_register (L, "upstream", upstream_f);
 
 	lua_pop (L, 1);                      /* remove metatable from stack */
diff --git a/src/lua/lua_xmlrpc.c b/src/lua/lua_xmlrpc.c
index 762711c30..4608d2328 100644
--- a/src/lua/lua_xmlrpc.c
+++ b/src/lua/lua_xmlrpc.c
@@ -27,7 +27,7 @@
 LUA_FUNCTION_DEF (xmlrpc, parse_reply);
 LUA_FUNCTION_DEF (xmlrpc, make_request);
 
-static const struct luaL_reg xmlrpclib_m[] = {
+static const struct luaL_reg    xmlrpclib_m[] = {
 	LUA_INTERFACE_DEF (xmlrpc, parse_reply),
 	LUA_INTERFACE_DEF (xmlrpc, make_request),
 	{"__tostring", lua_class_tostring},
@@ -42,24 +42,13 @@ struct lua_xmlrpc_ud {
 	lua_State *L;
 };
 
-static void xmlrpc_start_element (GMarkupParseContext *context,
-	const gchar *name,
-	const gchar **attribute_names,
-	const gchar **attribute_values,
-	gpointer user_data,
-	GError **error);
-static void xmlrpc_end_element (GMarkupParseContext *context,
-	const gchar *element_name,
-	gpointer user_data,
-	GError **error);
-static void xmlrpc_error (GMarkupParseContext *context,
-	GError *error,
-	gpointer user_data);
-static void xmlrpc_text (GMarkupParseContext *context,
-	const gchar *text,
-	gsize text_len,
-	gpointer user_data,
-	GError **error);
+static void xmlrpc_start_element (GMarkupParseContext *context, const gchar *name, const gchar **attribute_names,
+								const gchar **attribute_values, gpointer user_data, GError **error);
+static void xmlrpc_end_element (GMarkupParseContext	*context, const gchar *element_name, gpointer user_data,
+								GError **error);
+static void xmlrpc_error (GMarkupParseContext *context, GError *error, gpointer user_data);
+static void xmlrpc_text (GMarkupParseContext *context, const gchar *text, gsize text_len, gpointer user_data,
+								GError **error);
 
 static GMarkupParser xmlrpc_parser = {
 	.start_element = xmlrpc_start_element,
@@ -76,15 +65,11 @@ xmlrpc_error_quark (void)
 }
 
 static void
-xmlrpc_start_element (GMarkupParseContext *context,
-	const gchar *name,
-	const gchar **attribute_names,
-	const gchar **attribute_values,
-	gpointer user_data,
-	GError **error)
+xmlrpc_start_element (GMarkupParseContext *context, const gchar *name, const gchar **attribute_names,
+								const gchar **attribute_values, gpointer user_data, GError **error)
 {
-	struct lua_xmlrpc_ud *ud = user_data;
-	int last_state;
+	struct lua_xmlrpc_ud           *ud = user_data;
+	int                             last_state;
 
 	last_state = ud->parser_state;
 
@@ -138,7 +123,7 @@ xmlrpc_start_element (GMarkupParseContext *context,
 			ud->parser_state = 5;
 			/* Create new param of table type */
 			lua_newtable (ud->L);
-			ud->depth++;
+			ud->depth ++;
 		}
 		else if (g_ascii_strcasecmp (name, "string") == 0) {
 			ud->parser_state = 11;
@@ -208,7 +193,7 @@ xmlrpc_start_element (GMarkupParseContext *context,
 			ud->parser_state = 5;
 			/* Create new param of table type */
 			lua_newtable (ud->L);
-			ud->depth++;
+			ud->depth ++;
 		}
 		else {
 			/* Error state */
@@ -218,20 +203,16 @@ xmlrpc_start_element (GMarkupParseContext *context,
 	}
 
 	if (ud->parser_state == 99) {
-		g_set_error (error,
-			xmlrpc_error_quark (), 1, "xmlrpc parse error on state: %d, while parsing start tag: %s",
-			last_state, name);
+		g_set_error (error, xmlrpc_error_quark(), 1, "xmlrpc parse error on state: %d, while parsing start tag: %s",
+				last_state, name);
 	}
 }
 
 static void
-xmlrpc_end_element (GMarkupParseContext *context,
-	const gchar *name,
-	gpointer user_data,
-	GError **error)
+xmlrpc_end_element (GMarkupParseContext	*context, const gchar *name, gpointer user_data, GError **error)
 {
-	struct lua_xmlrpc_ud *ud = user_data;
-	int last_state;
+	struct lua_xmlrpc_ud           *ud = user_data;
+	int                             last_state;
 
 	last_state = ud->parser_state;
 
@@ -291,7 +272,7 @@ xmlrpc_end_element (GMarkupParseContext *context,
 		/* Got tag struct */
 		if (g_ascii_strcasecmp (name, "struct") == 0) {
 			ud->parser_state = 4;
-			ud->depth--;
+			ud->depth --;
 		}
 		else {
 			/* Error state */
@@ -359,30 +340,25 @@ xmlrpc_end_element (GMarkupParseContext *context,
 	}
 
 	if (ud->parser_state == 99) {
-		g_set_error (error,
-			xmlrpc_error_quark (), 1, "xmlrpc parse error on state: %d, while parsing end tag: %s",
-			last_state, name);
+		g_set_error (error, xmlrpc_error_quark(), 1, "xmlrpc parse error on state: %d, while parsing end tag: %s",
+				last_state, name);
 	}
 }
 
 static void
-xmlrpc_text (GMarkupParseContext *context,
-	const gchar *text,
-	gsize text_len,
-	gpointer user_data,
-	GError **error)
+xmlrpc_text (GMarkupParseContext *context, const gchar *text, gsize text_len, gpointer user_data, GError **error)
 {
-	struct lua_xmlrpc_ud *ud = user_data;
-	gint num;
-	gdouble dnum;
+	struct lua_xmlrpc_ud           *ud = user_data;
+	gint                            num;
+	gdouble                         dnum;
 
 	/* Strip line */
 	while (text_len > 0 && g_ascii_isspace (*text)) {
-		text++;
-		text_len--;
+		text ++;
+		text_len --;
 	}
 	while (text_len > 0 && g_ascii_isspace (text[text_len - 1])) {
-		text_len--;
+		text_len --;
 	}
 
 	if (text_len > 0) {
@@ -414,7 +390,7 @@ xmlrpc_text (GMarkupParseContext *context,
 static void
 xmlrpc_error (GMarkupParseContext *context, GError *error, gpointer user_data)
 {
-	struct lua_xmlrpc_ud *ud = user_data;
+	struct lua_xmlrpc_ud           *ud = user_data;
 
 	msg_err ("xmlrpc parser error: %s", error->message, ud->parser_state);
 }
@@ -422,12 +398,12 @@ xmlrpc_error (GMarkupParseContext *context, GError *error, gpointer user_data)
 static gint
 lua_xmlrpc_parse_reply (lua_State *L)
 {
-	const gchar *data;
-	GMarkupParseContext *ctx;
-	GError *err = NULL;
-	struct lua_xmlrpc_ud ud;
-	gsize s;
-	gboolean res;
+	const gchar                    *data;
+	GMarkupParseContext            *ctx;
+	GError                         *err = NULL;
+	struct lua_xmlrpc_ud            ud;
+	gsize                           s;
+	gboolean                        res;
 
 	data = luaL_checklstring (L, 1, &s);
 
@@ -442,7 +418,7 @@ lua_xmlrpc_parse_reply (lua_State *L)
 		res = g_markup_parse_context_parse (ctx, data, s, &err);
 
 		g_markup_parse_context_free (ctx);
-		if (!res) {
+		if (! res) {
 			lua_pushnil (L);
 		}
 	}
@@ -455,14 +431,10 @@ lua_xmlrpc_parse_reply (lua_State *L)
 }
 
 static gint
-lua_xmlrpc_parse_table (lua_State *L,
-	gint pos,
-	gchar *databuf,
-	gint pr,
-	gsize size)
+lua_xmlrpc_parse_table (lua_State *L, gint pos, gchar *databuf, gint pr, gsize size)
 {
-	gint r = pr, num;
-	double dnum;
+	gint                           r = pr, num;
+	double                         dnum;
 
 	r += rspamd_snprintf (databuf + r, size - r, "<struct>");
 	lua_pushnil (L);  /* first key */
@@ -470,12 +442,10 @@ lua_xmlrpc_parse_table (lua_State *L,
 		/* uses 'key' (at index -2) and 'value' (at index -1) */
 		if (lua_type (L, -2) != LUA_TSTRING) {
 			/* Ignore non sting keys */
-			lua_pop (L, 1);
+			lua_pop(L, 1);
 			continue;
 		}
-		r += rspamd_snprintf (databuf + r,
-				size - r,
-				"<member><name>%s</name><value>",
+		r += rspamd_snprintf (databuf + r, size - r, "<member><name>%s</name><value>",
 				lua_tostring (L, -2));
 		switch (lua_type (L, -1)) {
 		case LUA_TNUMBER:
@@ -484,22 +454,16 @@ lua_xmlrpc_parse_table (lua_State *L,
 
 			/* Try to avoid conversion errors */
 			if (dnum != (double)num) {
-				r += rspamd_snprintf (databuf + r,
-						sizeof (databuf) - r,
-						"<double>%f</double>",
+				r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<double>%f</double>",
 						dnum);
 			}
 			else {
-				r += rspamd_snprintf (databuf + r,
-						sizeof (databuf) - r,
-						"<int>%d</int>",
+				r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<int>%d</int>",
 						num);
 			}
 			break;
 		case LUA_TBOOLEAN:
-			r += rspamd_snprintf (databuf + r,
-					size - r,
-					"<boolean>%d</boolean>",
+			r += rspamd_snprintf (databuf + r, size - r, "<boolean>%d</boolean>",
 					lua_toboolean (L, -1) ? 1 : 0);
 			break;
 		case LUA_TSTRING:
@@ -513,7 +477,7 @@ lua_xmlrpc_parse_table (lua_State *L,
 		}
 		r += rspamd_snprintf (databuf + r, size - r, "</value></member>");
 		/* removes 'value'; keeps 'key' for next iteration */
-		lua_pop (L, 1);
+		lua_pop(L, 1);
 	}
 	r += rspamd_snprintf (databuf + r, size - r, "</struct>");
 
@@ -527,10 +491,10 @@ lua_xmlrpc_parse_table (lua_State *L,
 static gint
 lua_xmlrpc_make_request (lua_State *L)
 {
-	gchar databuf[BUFSIZ * 2];
-	const gchar *func;
-	gint r, top, i, num;
-	double dnum;
+	gchar                          databuf[BUFSIZ * 2];
+	const gchar                   *func;
+	gint                           r, top, i, num;
+	double                         dnum;
 
 	func = luaL_checkstring (L, 1);
 
@@ -543,9 +507,7 @@ lua_xmlrpc_make_request (lua_State *L)
 		top = lua_gettop (L);
 		/* Get additional options */
 		for (i = 2; i <= top; i++) {
-			r += rspamd_snprintf (databuf + r,
-					sizeof (databuf) - r,
-					"<param><value>");
+			r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<param><value>");
 			switch (lua_type (L, i)) {
 			case LUA_TNUMBER:
 				num = lua_tointeger (L, i);
@@ -553,43 +515,30 @@ lua_xmlrpc_make_request (lua_State *L)
 
 				/* Try to avoid conversion errors */
 				if (dnum != (double)num) {
-					r += rspamd_snprintf (databuf + r,
-							sizeof (databuf) - r,
-							"<double>%f</double>",
-							dnum);
+					r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<double>%f</double>",
+											dnum);
 				}
 				else {
-					r += rspamd_snprintf (databuf + r,
-							sizeof (databuf) - r,
-							"<int>%d</int>",
-							num);
+					r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<int>%d</int>",
+						num);
 				}
 				break;
 			case LUA_TBOOLEAN:
-				r += rspamd_snprintf (databuf + r,
-						sizeof (databuf) - r,
-						"<boolean>%d</boolean>",
+				r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<boolean>%d</boolean>",
 						lua_toboolean (L, i) ? 1 : 0);
 				break;
 			case LUA_TSTRING:
-				r += rspamd_snprintf (databuf + r,
-						sizeof (databuf) - r,
-						"<string>%s</string>",
+				r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "<string>%s</string>",
 						lua_tostring (L, i));
 				break;
 			case LUA_TTABLE:
-				r +=
-					lua_xmlrpc_parse_table (L, i, databuf, r, sizeof (databuf));
+				r += lua_xmlrpc_parse_table (L, i, databuf, r, sizeof (databuf));
 				break;
 			}
-			r += rspamd_snprintf (databuf + r,
-					sizeof (databuf) - r,
-					"</value></param>");
+			r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "</value></param>");
 		}
 
-		r += rspamd_snprintf (databuf + r,
-				sizeof (databuf) - r,
-				"</params></methodCall>");
+		r += rspamd_snprintf (databuf + r, sizeof (databuf) - r, "</params></methodCall>");
 		lua_pushlstring (L, databuf, r);
 	}
 	else {
diff --git a/src/lua_worker.c b/src/lua_worker.c
index 7ddcebaad..8aeeb94d1 100644
--- a/src/lua_worker.c
+++ b/src/lua_worker.c
@@ -22,16 +22,16 @@
  */
 
 
-#include "cfg_file.h"
 #include "config.h"
-#include "dns.h"
+#include "util.h"
 #include "main.h"
-#include "map.h"
-#include "message.h"
 #include "protocol.h"
 #include "upstream.h"
+#include "cfg_file.h"
 #include "url.h"
-#include "util.h"
+#include "message.h"
+#include "map.h"
+#include "dns.h"
 
 #include "lua/lua_common.h"
 
@@ -46,14 +46,14 @@ gpointer init_lua_worker (struct rspamd_config *cfg);
 void start_lua_worker (struct rspamd_worker *worker);
 
 worker_t lua_worker = {
-	"lua",                  /* Name */
-	init_lua_worker,        /* Init function */
-	start_lua_worker,       /* Start function */
-	TRUE,                   /* Has socket */
-	FALSE,                  /* Non unique */
-	FALSE,                  /* Non threaded */
-	TRUE,                   /* Killable */
-	SOCK_STREAM             /* TCP socket */
+	"lua",					/* Name */
+	init_lua_worker,		/* Init function */
+	start_lua_worker,		/* Start function */
+	TRUE,					/* Has socket */
+	FALSE,					/* Non unique */
+	FALSE,					/* Non threaded */
+	TRUE,					/* Killable */
+	SOCK_STREAM				/* TCP socket */
 };
 
 /*
@@ -61,23 +61,23 @@ worker_t lua_worker = {
  */
 struct rspamd_lua_worker_ctx {
 	/* DNS resolver */
-	struct rspamd_dns_resolver *resolver;
+	struct rspamd_dns_resolver     *resolver;
 	/* Events base */
-	struct event_base *ev_base;
+	struct event_base              *ev_base;
 	/* Other params */
-	GHashTable *params;
+	GHashTable					   *params;
 	/* Lua script to load */
-	gchar *file;
+	gchar						   *file;
 	/* Lua state */
-	lua_State *L;
+	lua_State					   *L;
 	/* Callback for accept */
-	gint cbref_accept;
+	gint							cbref_accept;
 	/* Callback for finishing */
-	gint cbref_fin;
+	gint							cbref_fin;
 	/* Config file */
-	struct rspamd_config *cfg;
+	struct rspamd_config 			   *cfg;
 	/* The rest options */
-	ucl_object_t *opts;
+	ucl_object_t				   *opts;
 };
 
 /* Lua bindings */
@@ -88,7 +88,7 @@ LUA_FUNCTION_DEF (worker, get_option);
 LUA_FUNCTION_DEF (worker, get_resolver);
 LUA_FUNCTION_DEF (worker, get_cfg);
 
-static const struct luaL_reg lua_workerlib_m[] = {
+static const struct luaL_reg    lua_workerlib_m[] = {
 	LUA_INTERFACE_DEF (worker, get_ev_base),
 	LUA_INTERFACE_DEF (worker, register_accept_callback),
 	LUA_INTERFACE_DEF (worker, register_exit_callback),
@@ -111,10 +111,10 @@ luaopen_lua_worker (lua_State * L)
 	return 1;
 }
 
-struct rspamd_lua_worker_ctx *
+struct rspamd_lua_worker_ctx      *
 lua_check_lua_worker (lua_State * L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{worker}");
+	void								*ud = luaL_checkudata (L, 1, "rspamd{worker}");
 	luaL_argcheck (L, ud != NULL, 1, "'worker' expected");
 	return ud ? *((struct rspamd_lua_worker_ctx **)ud) : NULL;
 }
@@ -122,8 +122,8 @@ lua_check_lua_worker (lua_State * L)
 static int
 lua_worker_get_ev_base (lua_State *L)
 {
-	struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
-	struct event_base **pbase;
+	struct rspamd_lua_worker_ctx					*ctx = lua_check_lua_worker (L);
+	struct event_base								**pbase;
 
 	if (ctx) {
 		pbase = lua_newuserdata (L, sizeof (struct event_base *));
@@ -140,7 +140,7 @@ lua_worker_get_ev_base (lua_State *L)
 static int
 lua_worker_register_accept_callback (lua_State *L)
 {
-	struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
+	struct rspamd_lua_worker_ctx					*ctx = lua_check_lua_worker (L);
 
 	if (ctx) {
 		if (!lua_isfunction (L, 2)) {
@@ -163,7 +163,7 @@ lua_worker_register_accept_callback (lua_State *L)
 static int
 lua_worker_register_exit_callback (lua_State *L)
 {
-	struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
+	struct rspamd_lua_worker_ctx					*ctx = lua_check_lua_worker (L);
 
 	if (ctx) {
 		if (!lua_isfunction (L, 2)) {
@@ -187,9 +187,9 @@ lua_worker_register_exit_callback (lua_State *L)
 static int
 lua_worker_get_option (lua_State *L)
 {
-	struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
-	const ucl_object_t *val;
-	const gchar *name;
+	struct rspamd_lua_worker_ctx					*ctx = lua_check_lua_worker (L);
+	const ucl_object_t									*val;
+	const gchar										*name;
 
 	if (ctx) {
 		name = luaL_checkstring (L, 2);
@@ -217,8 +217,8 @@ lua_worker_get_option (lua_State *L)
 static int
 lua_worker_get_resolver (lua_State *L)
 {
-	struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
-	struct rspamd_dns_resolver **presolver;
+	struct rspamd_lua_worker_ctx					*ctx = lua_check_lua_worker (L);
+	struct rspamd_dns_resolver						**presolver;
 
 	if (ctx) {
 		presolver = lua_newuserdata (L, sizeof (gpointer));
@@ -235,8 +235,8 @@ lua_worker_get_resolver (lua_State *L)
 static int
 lua_worker_get_cfg (lua_State *L)
 {
-	struct rspamd_lua_worker_ctx *ctx = lua_check_lua_worker (L);
-	struct rspamd_config **pcfg;
+	struct rspamd_lua_worker_ctx					*ctx = lua_check_lua_worker (L);
+	struct rspamd_config								**pcfg;
 
 	if (ctx) {
 		pcfg = lua_newuserdata (L, sizeof (gpointer));
@@ -258,17 +258,17 @@ lua_worker_get_cfg (lua_State *L)
 static void
 lua_accept_socket (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *) arg;
-	struct rspamd_lua_worker_ctx *ctx, **pctx;
-	gint nfd;
-	lua_State *L;
-	rspamd_inet_addr_t addr;
+	struct rspamd_worker           *worker = (struct rspamd_worker *) arg;
+	struct rspamd_lua_worker_ctx   *ctx, **pctx;
+	gint                            nfd;
+	lua_State					   *L;
+	rspamd_inet_addr_t              addr;
 
 	ctx = worker->ctx;
 	L = ctx->L;
 
 	if ((nfd =
-		rspamd_accept_from_socket (fd, &addr)) == -1) {
+			rspamd_accept_from_socket (fd, &addr)) == -1) {
 		msg_warn ("accept failed: %s", strerror (errno));
 		return;
 	}
@@ -278,8 +278,8 @@ lua_accept_socket (gint fd, short what, void *arg)
 	}
 
 	msg_info ("accepted connection from %s port %d",
-		rspamd_inet_address_to_string (&addr),
-		rspamd_inet_address_get_port (&addr));
+				rspamd_inet_address_to_string (&addr),
+				rspamd_inet_address_get_port (&addr));
 
 	/* Call finalizer function */
 	lua_rawgeti (L, LUA_REGISTRYINDEX, ctx->cbref_accept);
@@ -299,7 +299,7 @@ lua_accept_socket (gint fd, short what, void *arg)
 static gboolean
 rspamd_lua_worker_parser (ucl_object_t *obj, gpointer ud)
 {
-	struct rspamd_lua_worker_ctx *ctx = ud;
+	struct rspamd_lua_worker_ctx       *ctx = ud;
 
 	ctx->opts = obj;
 
@@ -309,24 +309,20 @@ rspamd_lua_worker_parser (ucl_object_t *obj, gpointer ud)
 gpointer
 init_lua_worker (struct rspamd_config *cfg)
 {
-	struct rspamd_lua_worker_ctx *ctx;
-	GQuark type;
+	struct rspamd_lua_worker_ctx       *ctx;
+	GQuark								type;
 
 	type = g_quark_try_string ("lua");
 
 	ctx = g_malloc0 (sizeof (struct rspamd_lua_worker_ctx));
-	ctx->params = g_hash_table_new_full (rspamd_str_hash,
-			rspamd_str_equal,
-			g_free,
-			(GDestroyNotify)g_list_free);
+	ctx->params = g_hash_table_new_full (rspamd_str_hash, rspamd_str_equal, g_free, (GDestroyNotify)g_list_free);
 
 
 	rspamd_rcl_register_worker_option (cfg, type, "file",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct rspamd_lua_worker_ctx, file), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct rspamd_lua_worker_ctx, file), 0);
 
-	rspamd_rcl_register_worker_parser (cfg, type, rspamd_lua_worker_parser,
-		ctx);
+	rspamd_rcl_register_worker_parser (cfg, type, rspamd_lua_worker_parser, ctx);
 
 	return ctx;
 }
@@ -337,25 +333,21 @@ init_lua_worker (struct rspamd_config *cfg)
 void
 start_lua_worker (struct rspamd_worker *worker)
 {
-	struct rspamd_lua_worker_ctx *ctx = worker->ctx, **pctx;
-	lua_State *L;
+	struct rspamd_lua_worker_ctx   *ctx = worker->ctx, **pctx;
+	lua_State					   *L;
 
 #ifdef WITH_PROFILER
-	extern void _start (void), etext (void);
+	extern void                     _start (void), etext (void);
 	monstartup ((u_long) & _start, (u_long) & etext);
 #endif
 
-	ctx->ev_base = rspamd_prepare_worker (worker,
-			"lua_worker",
-			lua_accept_socket);
+	ctx->ev_base = rspamd_prepare_worker (worker, "lua_worker", lua_accept_socket);
 
 	L = worker->srv->cfg->lua_state;
 	ctx->L = L;
 	ctx->cfg = worker->srv->cfg;
 
-	ctx->resolver = dns_resolver_init (worker->srv->logger,
-			ctx->ev_base,
-			worker->srv->cfg);
+	ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
 
 	/* Open worker's lib */
 	luaopen_lua_worker (L);
@@ -365,8 +357,7 @@ start_lua_worker (struct rspamd_worker *worker)
 		exit (EXIT_SUCCESS);
 	}
 	if (access (ctx->file, R_OK) == -1) {
-		msg_err ("Error reading lua script %s: %s", ctx->file,
-			strerror (errno));
+		msg_err ("Error reading lua script %s: %s", ctx->file, strerror (errno));
 		exit (EXIT_SUCCESS);
 	}
 
@@ -376,8 +367,7 @@ start_lua_worker (struct rspamd_worker *worker)
 	*pctx = ctx;
 
 	if (luaL_dofile (L, ctx->file) != 0) {
-		msg_err ("Error executing lua script %s: %s", ctx->file,
-			lua_tostring (L, -1));
+		msg_err ("Error executing lua script %s: %s", ctx->file, lua_tostring (L, -1));
 		exit (EXIT_SUCCESS);
 	}
 
@@ -398,8 +388,7 @@ start_lua_worker (struct rspamd_worker *worker)
 		lua_setclass (L, "rspamd{worker}", -1);
 		*pctx = ctx;
 		if (lua_pcall (L, 1, 0, 0) != 0) {
-			msg_info ("call to worker finalizer failed: %s", lua_tostring (L,
-				-1));
+			msg_info ("call to worker finalizer failed: %s", lua_tostring (L, -1));
 		}
 		/* Free resources */
 		luaL_unref (L, LUA_REGISTRYINDEX, ctx->cbref_fin);
diff --git a/src/main.c b/src/main.c
index 28981f792..83c072ccf 100644
--- a/src/main.c
+++ b/src/main.c
@@ -22,24 +22,24 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
+#include "main.h"
+#include "cfg_file.h"
+#include "util.h"
+#include "lmtp.h"
+#include "smtp.h"
+#include "map.h"
 #include "fuzzy_storage.h"
 #include "kvstorage_server.h"
-#include "lmtp.h"
+#include "symbols_cache.h"
 #include "lua/lua_common.h"
-#include "main.h"
-#include "map.h"
 #include "ottery.h"
-#include "smtp.h"
-#include "symbols_cache.h"
-#include "util.h"
 #ifdef HAVE_OPENSSL
+#include <openssl/rand.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
-#include <openssl/pem.h>
-#include <openssl/rand.h>
 #include <openssl/rsa.h>
+#include <openssl/pem.h>
 #endif
 #ifdef HAVE_LOCALE_H
 #include <locale.h>
@@ -52,73 +52,59 @@
 /* 10 seconds after getting termination signal to terminate all workers with SIGKILL */
 #define HARD_TERMINATION_TIME 10
 
-static struct rspamd_worker * fork_worker (struct rspamd_main *,
-	struct rspamd_worker_conf *);
-static gboolean load_rspamd_config (struct rspamd_config *cfg,
-	gboolean init_modules);
-static void init_cfg_cache (struct rspamd_config *cfg);
+static struct rspamd_worker    *fork_worker (struct rspamd_main *, struct rspamd_worker_conf *);
+static gboolean                 load_rspamd_config (struct rspamd_config *cfg, gboolean init_modules);
+static void                     init_cfg_cache (struct rspamd_config *cfg);
 
-sig_atomic_t do_restart = 0;
-sig_atomic_t do_reopen_log = 0;
-sig_atomic_t do_terminate = 0;
-sig_atomic_t child_dead = 0;
-sig_atomic_t got_alarm = 0;
+sig_atomic_t                    do_restart = 0;
+sig_atomic_t                    do_reopen_log = 0;
+sig_atomic_t                    do_terminate = 0;
+sig_atomic_t                    child_dead = 0;
+sig_atomic_t                    got_alarm = 0;
 
 #ifdef HAVE_SA_SIGINFO
-GQueue *signals_info = NULL;
+GQueue                         *signals_info = NULL;
 #endif
 
-static gboolean config_test = FALSE;
-static gboolean no_fork = FALSE;
-static gchar **cfg_names = NULL;
-static gchar **lua_tests = NULL;
-static gchar **sign_configs = NULL;
-static gchar *privkey = NULL;
-static gchar *rspamd_user = NULL;
-static gchar *rspamd_group = NULL;
-static gchar *rspamd_pidfile = NULL;
-static gboolean dump_cache = FALSE;
-static gboolean is_debug = FALSE;
-static gboolean is_insecure = FALSE;
+static gboolean                 config_test = FALSE;
+static gboolean                 no_fork = FALSE;
+static gchar                  **cfg_names = NULL;
+static gchar                  **lua_tests = NULL;
+static gchar                  **sign_configs = NULL;
+static gchar                   *privkey = NULL;
+static gchar                   *rspamd_user = NULL;
+static gchar                   *rspamd_group = NULL;
+static gchar                   *rspamd_pidfile = NULL;
+static gboolean                 dump_cache = FALSE;
+static gboolean                 is_debug = FALSE;
+static gboolean                 is_insecure = FALSE;
 /* List of workers that are pending to start */
-static GList *workers_pending = NULL;
+static GList                   *workers_pending = NULL;
 
 /* List of unrelated forked processes */
-static GArray *other_workers = NULL;
+static GArray                  *other_workers = NULL;
 
 /* List of active listen sockets indexed by worker type */
-static GHashTable *listen_sockets = NULL;
+static GHashTable              *listen_sockets = NULL;
 
-struct rspamd_main *rspamd_main;
+struct rspamd_main             *rspamd_main;
 
 /* Commandline options */
-static GOptionEntry entries[] =
+static GOptionEntry entries[] = 
 {
-	{ "config-test", 't', 0, G_OPTION_ARG_NONE, &config_test,
-	  "Do config test and exit", NULL },
-	{ "no-fork", 'f', 0, G_OPTION_ARG_NONE, &no_fork,
-	  "Do not daemonize main process", NULL },
-	{ "config", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &cfg_names,
-	  "Specify config file(s)", NULL },
-	{ "user", 'u', 0, G_OPTION_ARG_STRING, &rspamd_user,
-	  "User to run rspamd as", NULL },
-	{ "group", 'g', 0, G_OPTION_ARG_STRING, &rspamd_group,
-	  "Group to run rspamd as", NULL },
-	{ "pid", 'p', 0, G_OPTION_ARG_STRING, &rspamd_pidfile, "Path to pidfile",
-	  NULL },
-	{ "dump-cache", 'C', 0, G_OPTION_ARG_NONE, &dump_cache,
-	  "Dump symbols cache stats and exit", NULL },
-	{ "debug", 'd', 0, G_OPTION_ARG_NONE, &is_debug, "Force debug output",
-	  NULL },
-	{ "insecure", 'i', 0, G_OPTION_ARG_NONE, &is_insecure,
-	  "Ignore running workers as privileged users (insecure)", NULL },
-	{ "test-lua", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &lua_tests,
-	  "Specify lua file(s) to test", NULL },
-	{ "sign-config", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &sign_configs,
-	  "Specify config file(s) to sign", NULL },
-	{ "private-key", 0, 0, G_OPTION_ARG_FILENAME, &privkey,
-	  "Specify private key to sign", NULL },
-	{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
+  { "config-test", 't', 0, G_OPTION_ARG_NONE, &config_test, "Do config test and exit", NULL },
+  { "no-fork", 'f', 0, G_OPTION_ARG_NONE, &no_fork, "Do not daemonize main process", NULL },
+  { "config", 'c', 0, G_OPTION_ARG_FILENAME_ARRAY, &cfg_names, "Specify config file(s)", NULL },
+  { "user", 'u', 0, G_OPTION_ARG_STRING, &rspamd_user, "User to run rspamd as", NULL },
+  { "group", 'g', 0, G_OPTION_ARG_STRING, &rspamd_group, "Group to run rspamd as", NULL },
+  { "pid", 'p', 0, G_OPTION_ARG_STRING, &rspamd_pidfile, "Path to pidfile", NULL },
+  { "dump-cache", 'C', 0, G_OPTION_ARG_NONE, &dump_cache, "Dump symbols cache stats and exit", NULL },
+  { "debug", 'd', 0, G_OPTION_ARG_NONE, &is_debug, "Force debug output", NULL },
+  { "insecure", 'i', 0, G_OPTION_ARG_NONE, &is_insecure, "Ignore running workers as privileged users (insecure)", NULL },
+  { "test-lua", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &lua_tests, "Specify lua file(s) to test", NULL },
+  { "sign-config", 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &sign_configs, "Specify config file(s) to sign", NULL },
+  { "private-key", 0, 0, G_OPTION_ARG_FILENAME, &privkey, "Specify private key to sign", NULL },
+  { NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
 };
 
 
@@ -166,17 +152,17 @@ static const gchar *
 chldsigcode (gint code) {
 	switch (code) {
 #ifdef CLD_EXITED
-	case CLD_EXITED:
-		return "Child exited normally";
-	case CLD_KILLED:
-		return "Child has terminated abnormally but did not create a core file";
-	case CLD_DUMPED:
-		return "Child has terminated abnormally and created a core file";
-	case CLD_TRAPPED:
-		return "Traced child has trapped";
+		case CLD_EXITED:
+			return "Child exited normally";
+		case CLD_KILLED:
+			return "Child has terminated abnormally but did not create a core file";
+		case CLD_DUMPED:
+			return "Child has terminated abnormally and created a core file";
+		case CLD_TRAPPED:
+			return "Traced child has trapped";
 #endif
-	default:
-		return "Unknown reason";
+		default:
+			return "Unknown reason";
 	}
 }
 
@@ -189,11 +175,11 @@ print_signals_info (void)
 	while ((inf = g_queue_pop_head (signals_info))) {
 		if (inf->si_signo == SIGCHLD) {
 			msg_info ("got SIGCHLD from child: %P; reason: '%s'",
-				inf->si_pid, chldsigcode (inf->si_code));
+					inf->si_pid, chldsigcode (inf->si_code));
 		}
 		else {
 			msg_info ("got signal: '%s'; received from pid: %P; uid: %ul",
-				g_strsignal (inf->si_signo), inf->si_pid, (gulong)inf->si_uid);
+					g_strsignal (inf->si_signo), inf->si_pid, (gulong)inf->si_uid);
 		}
 		g_free (inf);
 	}
@@ -204,14 +190,13 @@ print_signals_info (void)
 static void
 read_cmd_line (gint argc, gchar **argv, struct rspamd_config *cfg)
 {
-	GError *error = NULL;
-	GOptionContext *context;
-	guint i, cfg_num;
-	pid_t r;
+	GError                         *error = NULL;
+	GOptionContext                 *context;
+	guint							i, cfg_num;
+	pid_t							r;
 
 	context = g_option_context_new ("- run rspamd daemon");
-	g_option_context_set_summary (context,
-		"Summary:\n  Rspamd daemon version " RVERSION "\n  Release id: " RID);
+	g_option_context_set_summary (context, "Summary:\n  Rspamd daemon version " RVERSION "\n  Release id: " RID);
 	g_option_context_add_main_entries (context, entries, NULL);
 	if (!g_option_context_parse (context, &argc, &argv, &error)) {
 		fprintf (stderr, "option parsing failed: %s\n", error->message);
@@ -228,7 +213,7 @@ read_cmd_line (gint argc, gchar **argv, struct rspamd_config *cfg)
 	else {
 		cfg->cfg_name = cfg_names[0];
 	}
-	for (i = 1; i < cfg_num; i++) {
+	for (i = 1; i < cfg_num; i ++) {
 		r = fork ();
 		if (r == 0) {
 			/* Spawning new main process */
@@ -236,10 +221,7 @@ read_cmd_line (gint argc, gchar **argv, struct rspamd_config *cfg)
 			(void)setsid ();
 		}
 		else if (r == -1) {
-			fprintf (stderr,
-				"fork failed while spawning process for %s configuration file: %s\n",
-				cfg_names[i],
-				strerror (errno));
+			fprintf (stderr, "fork failed while spawning process for %s configuration file: %s\n", cfg_names[i], strerror (errno));
 		}
 		else {
 			/* Save pid to the list of other main processes, we need it to ignore SIGCHLD from them */
@@ -253,16 +235,15 @@ read_cmd_line (gint argc, gchar **argv, struct rspamd_config *cfg)
 static void
 detect_priv (struct rspamd_main *rspamd)
 {
-	struct passwd *pwd;
-	struct group *grp;
-	uid_t euid;
+	struct passwd                  *pwd;
+	struct group                   *grp;
+	uid_t                           euid;
 
 	euid = geteuid ();
 
 	if (euid == 0) {
 		if (!rspamd->cfg->rspamd_user && !is_insecure) {
-			msg_err (
-				"cannot run rspamd workers as root user, please add -u and -g options to select a proper unprivilleged user or specify --insecure flag");
+			msg_err ("cannot run rspamd workers as root user, please add -u and -g options to select a proper unprivilleged user or specify --insecure flag");
 			exit (EXIT_FAILURE);
 		}
 		else if (is_insecure) {
@@ -274,15 +255,13 @@ detect_priv (struct rspamd_main *rspamd)
 			rspamd->is_privilleged = TRUE;
 			pwd = getpwnam (rspamd->cfg->rspamd_user);
 			if (pwd == NULL) {
-				msg_err ("user specified does not exists (%s), aborting",
-					strerror (errno));
+				msg_err ("user specified does not exists (%s), aborting", strerror (errno));
 				exit (-errno);
 			}
 			if (rspamd->cfg->rspamd_group) {
 				grp = getgrnam (rspamd->cfg->rspamd_group);
 				if (grp == NULL) {
-					msg_err ("group specified does not exists (%s), aborting",
-						strerror (errno));
+					msg_err ("group specified does not exists (%s), aborting", strerror (errno));
 					exit (-errno);
 				}
 				rspamd->workers_gid = grp->gr_gid;
@@ -305,20 +284,16 @@ drop_priv (struct rspamd_main *rspamd)
 {
 	if (rspamd->is_privilleged) {
 		if (setgid (rspamd->workers_gid) == -1) {
-			msg_err ("cannot setgid to %d (%s), aborting",
-				(gint)rspamd->workers_gid,
-				strerror (errno));
+			msg_err ("cannot setgid to %d (%s), aborting", (gint)rspamd->workers_gid, strerror (errno));
 			exit (-errno);
 		}
 		if (rspamd->cfg->rspamd_user &&
-			initgroups (rspamd->cfg->rspamd_user, rspamd->workers_gid) == -1) {
+				initgroups (rspamd->cfg->rspamd_user, rspamd->workers_gid) == -1) {
 			msg_err ("initgroups failed (%s), aborting", strerror (errno));
 			exit (-errno);
 		}
 		if (setuid (rspamd->workers_uid) == -1) {
-			msg_err ("cannot setuid to %d (%s), aborting",
-				(gint)rspamd->workers_uid,
-				strerror (errno));
+			msg_err ("cannot setuid to %d (%s), aborting", (gint)rspamd->workers_uid, strerror (errno));
 			exit (-errno);
 		}
 	}
@@ -344,9 +319,9 @@ config_logger (struct rspamd_config *cfg, gpointer ud)
 static void
 parse_filters_str (struct rspamd_config *cfg, const gchar *str)
 {
-	gchar **strvec, **p;
-	struct filter *cur;
-	module_t **pmodule;
+	gchar                         **strvec, **p;
+	struct filter                  *cur;
+	module_t					  **pmodule;
 
 	if (str == NULL) {
 		return;
@@ -364,10 +339,8 @@ parse_filters_str (struct rspamd_config *cfg, const gchar *str)
 		pmodule = &modules[0];
 		while (*pmodule) {
 			g_strstrip (*p);
-			if ((*pmodule)->name != NULL &&
-				g_ascii_strcasecmp ((*pmodule)->name, *p) == 0) {
-				cur = rspamd_mempool_alloc (cfg->cfg_pool,
-						sizeof (struct filter));
+			if ((*pmodule)->name != NULL && g_ascii_strcasecmp ((*pmodule)->name, *p) == 0) {
+				cur = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct filter));
 				cur->type = C_FILTER;
 				msg_debug ("found C filter %s", *p);
 				cur->func_name = rspamd_mempool_strdup (cfg->cfg_pool, *p);
@@ -376,7 +349,7 @@ parse_filters_str (struct rspamd_config *cfg, const gchar *str)
 
 				break;
 			}
-			pmodule++;
+			pmodule ++;
 		}
 		if (cur != NULL) {
 			/* Go to next iteration */
@@ -392,27 +365,24 @@ parse_filters_str (struct rspamd_config *cfg, const gchar *str)
 static void
 reread_config (struct rspamd_main *rspamd)
 {
-	struct rspamd_config *tmp_cfg;
-	gchar *cfg_file;
-	GList *l;
-	struct filter *filt;
+	struct rspamd_config             *tmp_cfg;
+	gchar                           *cfg_file;
+	GList                          *l;
+	struct filter                  *filt;
 
 	tmp_cfg = (struct rspamd_config *)g_malloc (sizeof (struct rspamd_config));
 	if (tmp_cfg) {
 		bzero (tmp_cfg, sizeof (struct rspamd_config));
 		tmp_cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 		rspamd_config_defaults (tmp_cfg);
-		cfg_file = rspamd_mempool_strdup (tmp_cfg->cfg_pool,
-				rspamd->cfg->cfg_name);
+		cfg_file = rspamd_mempool_strdup (tmp_cfg->cfg_pool, rspamd->cfg->cfg_name);
 		/* Save some variables */
 		tmp_cfg->cfg_name = cfg_file;
 		tmp_cfg->lua_state = init_lua (tmp_cfg);
-		rspamd_mempool_add_destructor (tmp_cfg->cfg_pool,
-			(rspamd_mempool_destruct_t)lua_close, tmp_cfg->lua_state);
+		rspamd_mempool_add_destructor (tmp_cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_close, tmp_cfg->lua_state);
 
-		if (!load_rspamd_config (tmp_cfg, FALSE)) {
-			rspamd_set_logger (rspamd_main->cfg, g_quark_try_string (
-					"main"), rspamd_main);
+		if (! load_rspamd_config (tmp_cfg, FALSE)) {
+			rspamd_set_logger (rspamd_main->cfg, g_quark_try_string ("main"), rspamd_main);
 			msg_err ("cannot parse new config file, revert to old one");
 			rspamd_config_free (tmp_cfg);
 		}
@@ -428,12 +398,9 @@ reread_config (struct rspamd_main *rspamd)
 			}
 			/* Pre-init of cache */
 			rspamd->cfg->cache = g_new0 (struct symbols_cache, 1);
-			rspamd->cfg->cache->static_pool = rspamd_mempool_new (
-				rspamd_mempool_suggest_size ());
+			rspamd->cfg->cache->static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 			rspamd->cfg->cache->cfg = rspamd->cfg;
-			rspamd_main->cfg->cache->items_by_symbol = g_hash_table_new (
-				rspamd_str_hash,
-				rspamd_str_equal);
+			rspamd_main->cfg->cache->items_by_symbol = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 			/* Perform modules configuring */
 			l = g_list_first (rspamd->cfg->filters);
 
@@ -455,35 +422,31 @@ reread_config (struct rspamd_main *rspamd)
 static void
 set_worker_limits (struct rspamd_worker_conf *cf)
 {
-	struct rlimit rlmt;
+	struct rlimit                   rlmt;
 
 	if (cf->rlimit_nofile != 0) {
 		rlmt.rlim_cur = (rlim_t) cf->rlimit_nofile;
 		rlmt.rlim_max = (rlim_t) cf->rlimit_nofile;
 
-		if (setrlimit (RLIMIT_NOFILE, &rlmt) == -1) {
-			msg_warn ("cannot set files rlimit: %d, %s",
-				cf->rlimit_nofile,
-				strerror (errno));
-		}
+		if (setrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
+			msg_warn ("cannot set files rlimit: %d, %s", cf->rlimit_nofile, strerror (errno));
+        }
 	}
 
 	if (cf->rlimit_maxcore != 0) {
 		rlmt.rlim_cur = (rlim_t) cf->rlimit_maxcore;
 		rlmt.rlim_max = (rlim_t) cf->rlimit_maxcore;
 
-		if (setrlimit (RLIMIT_CORE, &rlmt) == -1) {
-			msg_warn ("cannot set max core rlimit: %d, %s",
-				cf->rlimit_maxcore,
-				strerror (errno));
-		}
+		if (setrlimit(RLIMIT_CORE, &rlmt) == -1) {
+			msg_warn ("cannot set max core rlimit: %d, %s", cf->rlimit_maxcore, strerror (errno));
+        }
 	}
 }
 
-static struct rspamd_worker *
+static struct rspamd_worker    *
 fork_worker (struct rspamd_main *rspamd, struct rspamd_worker_conf *cf)
 {
-	struct rspamd_worker *cur;
+	struct rspamd_worker           *cur;
 	/* Starting worker process */
 	cur = (struct rspamd_worker *)g_malloc (sizeof (struct rspamd_worker));
 	if (cur) {
@@ -530,8 +493,7 @@ fork_worker (struct rspamd_main *rspamd, struct rspamd_worker_conf *cf)
 			break;
 		default:
 			/* Insert worker into worker's table, pid is index */
-			g_hash_table_insert (rspamd->workers, GSIZE_TO_POINTER (
-					cur->pid), cur);
+			g_hash_table_insert (rspamd->workers, GSIZE_TO_POINTER (cur->pid), cur);
 			break;
 		}
 	}
@@ -543,7 +505,7 @@ static void
 set_alarm (guint seconds)
 {
 #ifdef HAVE_SETITIMER
-	static struct itimerval itv;
+	static struct itimerval         itv;
 
 	itv.it_interval.tv_sec = 0;
 	itv.it_interval.tv_usec = 0;
@@ -568,15 +530,10 @@ delay_fork (struct rspamd_worker_conf *cf)
 static GList *
 create_listen_socket (const gchar *addr, gint port, gint listen_type)
 {
-	gint listen_sock = -1;
-	GList *result, *cur;
+	gint                            listen_sock = -1;
+	GList                          *result, *cur;
 	/* Create listen sockets */
-	result = make_universal_sockets_list (addr,
-			port,
-			listen_type,
-			TRUE,
-			TRUE,
-			TRUE);
+	result = make_universal_sockets_list (addr, port, listen_type, TRUE, TRUE, TRUE);
 
 	cur = result;
 	while (cur != NULL) {
@@ -636,8 +593,8 @@ systemd_get_socket (gint number)
 static void
 fork_delayed (struct rspamd_main *rspamd)
 {
-	GList *cur;
-	struct rspamd_worker_conf *cf;
+	GList                          *cur;
+	struct rspamd_worker_conf             *cf;
 
 	while (workers_pending != NULL) {
 		cur = workers_pending;
@@ -652,7 +609,7 @@ fork_delayed (struct rspamd_main *rspamd)
 static inline uintptr_t
 make_listen_key (gint ai, const gchar *addr, gint port)
 {
-	uintptr_t res = 0;
+	uintptr_t                       res = 0;
 
 	res = murmur32_hash (addr, strlen (addr));
 	res += murmur32_hash ((guchar *)&ai, sizeof (gint));
@@ -664,10 +621,10 @@ make_listen_key (gint ai, const gchar *addr, gint port)
 static void
 spawn_workers (struct rspamd_main *rspamd)
 {
-	GList *cur, *ls;
-	struct rspamd_worker_conf *cf;
-	gint i, key;
-	gpointer p;
+	GList                          *cur, *ls;
+	struct rspamd_worker_conf             *cf;
+	gint                            i, key;
+	gpointer                        p;
 	struct rspamd_worker_bind_conf *bcf;
 
 	cur = rspamd->cfg->workers;
@@ -680,31 +637,22 @@ spawn_workers (struct rspamd_main *rspamd)
 		}
 		else {
 			if (cf->worker->has_socket) {
-				LL_FOREACH (cf->bind_conf, bcf)
-				{
-					key = make_listen_key (bcf->ai,
-							bcf->bind_host,
-							bcf->bind_port);
-					if ((p =
-						g_hash_table_lookup (listen_sockets,
-						GINT_TO_POINTER (key))) == NULL) {
+				LL_FOREACH (cf->bind_conf, bcf) {
+					key = make_listen_key (bcf->ai, bcf->bind_host, bcf->bind_port);
+					if ((p = g_hash_table_lookup (listen_sockets, GINT_TO_POINTER (key))) == NULL) {
 						if (!bcf->is_systemd) {
 							/* Create listen socket */
-							ls = create_listen_socket (bcf->bind_host,
-									bcf->bind_port,
+							ls = create_listen_socket (bcf->bind_host, bcf->bind_port,
 									cf->worker->listen_type);
 						}
 						else {
 							ls = systemd_get_socket (bcf->ai);
 						}
 						if (ls == NULL) {
-							msg_err ("cannot listen on socket %s: %s",
-								bcf->bind_host,
-								strerror (errno));
+							msg_err ("cannot listen on socket %s: %s", bcf->bind_host, strerror (errno));
 							exit (-errno);
 						}
-						g_hash_table_insert (listen_sockets,
-							GINT_TO_POINTER (key), ls);
+						g_hash_table_insert (listen_sockets, GINT_TO_POINTER (key), ls);
 					}
 					else {
 						/* We had socket for this type of worker */
@@ -719,8 +667,7 @@ spawn_workers (struct rspamd_main *rspamd)
 
 			if (cf->worker->unique) {
 				if (cf->count > 1) {
-					msg_err ("cannot spawn more than 1 %s worker, so spawn one",
-						cf->worker->name);
+					msg_err ("cannot spawn more than 1 %s worker, so spawn one", cf->worker->name);
 				}
 				fork_worker (rspamd, cf);
 			}
@@ -741,7 +688,7 @@ spawn_workers (struct rspamd_main *rspamd)
 static void
 kill_old_workers (gpointer key, gpointer value, gpointer unused)
 {
-	struct rspamd_worker *w = value;
+	struct rspamd_worker         *w = value;
 
 	kill (w->pid, SIGUSR2);
 	msg_info ("send signal to worker %P", w->pid);
@@ -750,8 +697,8 @@ kill_old_workers (gpointer key, gpointer value, gpointer unused)
 static gboolean
 wait_for_workers (gpointer key, gpointer value, gpointer unused)
 {
-	struct rspamd_worker *w = value;
-	gint res = 0;
+	struct rspamd_worker          *w = value;
+	gint                            res = 0;
 
 	if (got_alarm) {
 		got_alarm = 0;
@@ -774,9 +721,8 @@ wait_for_workers (gpointer key, gpointer value, gpointer unused)
 		}
 	}
 
-	msg_info ("%s process %P terminated %s", g_quark_to_string (
-			w->type), w->pid,
-		got_alarm ? "hardly" : "softly");
+	msg_info ("%s process %P terminated %s", g_quark_to_string (w->type), w->pid,
+			got_alarm ? "hardly" : "softly");
 	g_free (w->cf);
 	g_free (w);
 
@@ -786,7 +732,7 @@ wait_for_workers (gpointer key, gpointer value, gpointer unused)
 static void
 reopen_log_handler (gpointer key, gpointer value, gpointer unused)
 {
-	struct rspamd_worker *w = value;
+	struct rspamd_worker          *w = value;
 
 	if (kill (w->pid, SIGUSR1) == -1) {
 		msg_err ("kill failed for pid %P: %s", w->pid, strerror (errno));
@@ -796,10 +742,10 @@ reopen_log_handler (gpointer key, gpointer value, gpointer unused)
 static void
 preload_statfiles (struct rspamd_main *rspamd)
 {
-	struct rspamd_classifier_config *cf;
-	struct rspamd_statfile_config *st;
-	stat_file_t *stf;
-	GList *cur_cl, *cur_st;
+	struct rspamd_classifier_config       *cf;
+	struct rspamd_statfile_config                *st;
+	stat_file_t                    *stf;
+	GList                          *cur_cl, *cur_st;
 
 	cur_cl = rspamd->cfg->classifiers;
 	while (cur_cl) {
@@ -809,10 +755,7 @@ preload_statfiles (struct rspamd_main *rspamd)
 		cur_st = cf->statfiles;
 		while (cur_st) {
 			st = cur_st->data;
-			stf = statfile_pool_open (rspamd->statfile_pool,
-					st->path,
-					st->size,
-					FALSE);
+			stf = statfile_pool_open (rspamd->statfile_pool, st->path, st->size, FALSE);
 			if (stf == NULL) {
 				msg_warn ("preload of %s from %s failed", st->symbol, st->path);
 			}
@@ -826,20 +769,19 @@ preload_statfiles (struct rspamd_main *rspamd)
 static gboolean
 load_rspamd_config (struct rspamd_config *cfg, gboolean init_modules)
 {
-	GList *l;
-	struct filter *filt;
-	struct module_ctx *cur_module = NULL;
+	GList                          *l;
+	struct filter                  *filt;
+	struct module_ctx              *cur_module = NULL;
 
-	if (!rspamd_config_read (cfg, cfg->cfg_name, NULL,
-		config_logger, rspamd_main)) {
+	if (! rspamd_config_read (cfg, cfg->cfg_name, NULL,
+			config_logger, rspamd_main)) {
 		return FALSE;
 	}
 
 	/* Strictly set temp dir */
 	if (!cfg->temp_dir) {
 		msg_warn ("tempdir is not set, trying to use $TMPDIR");
-		cfg->temp_dir =
-			rspamd_mempool_strdup (cfg->cfg_pool, getenv ("TMPDIR"));
+		cfg->temp_dir = rspamd_mempool_strdup (cfg->cfg_pool, getenv ("TMPDIR"));
 
 		if (!cfg->temp_dir) {
 			msg_warn ("$TMPDIR is empty too, using /tmp as default");
@@ -850,7 +792,7 @@ load_rspamd_config (struct rspamd_config *cfg, gboolean init_modules)
 	/* Do post-load actions */
 	rspamd_config_post_load (cfg);
 	parse_filters_str (cfg, cfg->filters_str);
-
+	
 	if (init_modules) {
 		/* Init C modules */
 		l = g_list_first (cfg->filters);
@@ -858,102 +800,80 @@ load_rspamd_config (struct rspamd_config *cfg, gboolean init_modules)
 		while (l) {
 			filt = l->data;
 			if (filt->module) {
-				cur_module =
-					rspamd_mempool_alloc (cfg->cfg_pool,
-						sizeof (struct module_ctx));
+				cur_module = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (struct module_ctx));
 				if (filt->module->module_init_func (cfg, &cur_module) == 0) {
-					g_hash_table_insert (cfg->c_modules,
-						(gpointer) filt->module->name,
-						cur_module);
+					g_hash_table_insert (cfg->c_modules, (gpointer) filt->module->name, cur_module);
 				}
 			}
 			l = g_list_next (l);
 		}
 	}
-
+	
 	return TRUE;
 }
 
 static void
-init_cfg_cache (struct rspamd_config *cfg)
+init_cfg_cache (struct rspamd_config *cfg) 
 {
 
-	if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg,
-		cfg->cache_filename, FALSE)) {
+	if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg, cfg->cache_filename, FALSE)) {
 		exit (EXIT_FAILURE);
 	}
 }
 
 static void
-print_symbols_cache (struct rspamd_config *cfg)
+print_symbols_cache (struct rspamd_config *cfg) 
 {
-	GList *cur;
-	struct cache_item *item;
-	gint i;
+	GList                          *cur;
+	struct cache_item              *item;
+	gint                            i;
 
-	if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg,
-		cfg->cache_filename, TRUE)) {
+	if (!init_symbols_cache (cfg->cfg_pool, cfg->cache, cfg, cfg->cache_filename, TRUE)) {
 		exit (EXIT_FAILURE);
 	}
 	if (cfg->cache) {
 		printf ("Symbols cache\n");
-		printf (
-			"-----------------------------------------------------------------\n");
-		printf (
-			"| Pri  | Symbol                | Weight | Frequency | Avg. time |\n");
+		printf ("-----------------------------------------------------------------\n");
+		printf ("| Pri  | Symbol                | Weight | Frequency | Avg. time |\n");
 		i = 0;
 		cur = cfg->cache->negative_items;
 		while (cur) {
 			item = cur->data;
 			if (!item->is_callback) {
-				printf (
-						"-----------------------------------------------------------------\n");
-				printf ("| %3d | %22s | %6.1f | %9d | %9.3f |\n",
-					i,
-					item->s->symbol,
-					item->s->weight,
-					item->s->frequency,
-					item->s->avg_time);
+				printf ("-----------------------------------------------------------------\n");
+				printf ("| %3d | %22s | %6.1f | %9d | %9.3f |\n", i, item->s->symbol, item->s->weight, item->s->frequency, item->s->avg_time);
 			}
 			cur = g_list_next (cur);
-			i++;
+			i ++;
 		}
 		cur = cfg->cache->static_items;
 		while (cur) {
 			item = cur->data;
 			if (!item->is_callback) {
-				printf (
-						"-----------------------------------------------------------------\n");
-				printf ("| %3d | %22s | %6.1f | %9d | %9.3f |\n",
-					i,
-					item->s->symbol,
-					item->s->weight,
-					item->s->frequency,
-					item->s->avg_time);
+				printf ("-----------------------------------------------------------------\n");
+				printf ("| %3d | %22s | %6.1f | %9d | %9.3f |\n", i, item->s->symbol, item->s->weight, item->s->frequency, item->s->avg_time);
 			}
 			cur = g_list_next (cur);
-			i++;
+			i ++;
 		}
 
-		printf (
-			"-----------------------------------------------------------------\n");
+		printf ("-----------------------------------------------------------------\n");
 	}
 }
 
 static gint
 perform_lua_tests (struct rspamd_config *cfg)
 {
-	gint i, tests_num, res = EXIT_SUCCESS;
-	gchar *cur_script;
-	lua_State *L = cfg->lua_state;
+	gint                            i, tests_num, res = EXIT_SUCCESS;
+	gchar                          *cur_script;
+	lua_State                      *L = cfg->lua_state;
 
 	tests_num = g_strv_length (lua_tests);
 
-	for (i = 0; i < tests_num; i++) {
+	for (i = 0; i < tests_num; i ++) {
 
 		if (luaL_loadfile (L, lua_tests[i]) != 0) {
-			msg_err ("load of %s failed: %s", lua_tests[i],
-				lua_tostring (L, -1));
+			msg_err ("load of %s failed: %s", lua_tests[i], lua_tostring (L, -1));
 			res = EXIT_FAILURE;
 			continue;
 		}
@@ -967,15 +887,13 @@ perform_lua_tests (struct rspamd_config *cfg)
 
 		/* do the call (0 arguments, N result) */
 		if (lua_pcall (L, 0, LUA_MULTRET, 0) != 0) {
-			msg_info ("init of %s failed: %s", lua_tests[i], lua_tostring (L,
-				-1));
+			msg_info ("init of %s failed: %s", lua_tests[i], lua_tostring (L, -1));
 			res = EXIT_FAILURE;
 			continue;
 		}
 		if (lua_gettop (L) != 0) {
 			if (lua_tonumber (L, -1) == -1) {
-				msg_info ("%s returned -1 that indicates configuration error",
-					lua_tests[i]);
+				msg_info ("%s returned -1 that indicates configuration error", lua_tests[i]);
 				res = EXIT_FAILURE;
 				continue;
 			}
@@ -997,51 +915,51 @@ perform_configs_sign (void)
 	msg_err ("must have openssl at least 1.0.0 to perform this action");
 	return EXIT_FAILURE;
 # else
-	gint i, tests_num, res = EXIT_SUCCESS, fd;
-	guint diglen;
-	gchar *cur_file, in_file[PATH_MAX],
-		out_file[PATH_MAX], dig[EVP_MAX_MD_SIZE];
-	gsize siglen;
-	struct stat st;
-	gpointer map, sig;
-	EVP_PKEY *key = NULL;
-	BIO *fbio;
-	EVP_PKEY_CTX *key_ctx = NULL;
-	EVP_MD_CTX *sign_ctx = NULL;
+	gint                            i, tests_num, res = EXIT_SUCCESS, fd;
+	guint                           diglen;
+	gchar                          *cur_file, in_file[PATH_MAX],
+	                                out_file[PATH_MAX], dig[EVP_MAX_MD_SIZE];
+	gsize                           siglen;
+	struct stat                    st;
+	gpointer                        map, sig;
+	EVP_PKEY                       *key = NULL;
+	BIO                            *fbio;
+	EVP_PKEY_CTX                   *key_ctx = NULL;
+	EVP_MD_CTX                     *sign_ctx = NULL;
 
 	/* Load private key */
 	fbio = BIO_new_file (privkey, "r");
 	if (fbio == NULL) {
 		msg_err ("cannot open private key %s, %s", privkey,
-			ERR_error_string (ERR_get_error (), NULL));
+				ERR_error_string (ERR_get_error (), NULL));
 		return ERR_get_error ();
 	}
 	if (!PEM_read_bio_PrivateKey (fbio, &key, rspamd_read_passphrase, NULL)) {
 		msg_err ("cannot read private key %s, %s", privkey,
-			ERR_error_string (ERR_get_error (), NULL));
+				ERR_error_string (ERR_get_error (), NULL));
 		return ERR_get_error ();
 	}
 
 	key_ctx = EVP_PKEY_CTX_new (key, NULL);
 	if (key_ctx == NULL) {
 		msg_err ("cannot parse private key %s, %s", privkey,
-			ERR_error_string (ERR_get_error (), NULL));
+				ERR_error_string (ERR_get_error (), NULL));
 		return ERR_get_error ();
 	}
 
 	if (EVP_PKEY_sign_init (key_ctx) <= 0) {
 		msg_err ("cannot parse private key %s, %s", privkey,
-			ERR_error_string (ERR_get_error (), NULL));
+				ERR_error_string (ERR_get_error (), NULL));
 		return ERR_get_error ();
 	}
 	if (EVP_PKEY_CTX_set_rsa_padding (key_ctx, RSA_PKCS1_PADDING) <= 0) {
 		msg_err ("cannot init private key %s, %s", privkey,
-			ERR_error_string (ERR_get_error (), NULL));
+				ERR_error_string (ERR_get_error (), NULL));
 		return ERR_get_error ();
 	}
 	if (EVP_PKEY_CTX_set_signature_md (key_ctx, EVP_sha256 ()) <= 0) {
 		msg_err ("cannot init signature private key %s, %s", privkey,
-			ERR_error_string (ERR_get_error (), NULL));
+				ERR_error_string (ERR_get_error (), NULL));
 		return ERR_get_error ();
 	}
 
@@ -1049,7 +967,7 @@ perform_configs_sign (void)
 
 	tests_num = g_strv_length (sign_configs);
 
-	for (i = 0; i < tests_num; i++) {
+	for (i = 0; i < tests_num; i ++) {
 		cur_file = sign_configs[i];
 		if (realpath (cur_file, in_file) == NULL) {
 			msg_err ("cannot resolve %s: %s", cur_file, strerror (errno));
@@ -1064,9 +982,7 @@ perform_configs_sign (void)
 			continue;
 		}
 
-		if ((map =
-			mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
-			0)) == MAP_FAILED) {
+		if ((map = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
 			close (fd);
 			msg_err ("cannot mmap %s: %s", in_file, strerror (errno));
 			continue;
@@ -1081,19 +997,15 @@ perform_configs_sign (void)
 		munmap (map, st.st_size);
 
 		if (EVP_PKEY_sign (key_ctx, NULL, &siglen, dig, diglen) <= 0) {
-			msg_err ("cannot sign %s using private key %s, %s",
-				in_file,
-				privkey,
-				ERR_error_string (ERR_get_error (), NULL));
+			msg_err ("cannot sign %s using private key %s, %s", in_file, privkey,
+					ERR_error_string (ERR_get_error (), NULL));
 			continue;
 		}
 
 		sig = OPENSSL_malloc (siglen);
 		if (EVP_PKEY_sign (key_ctx, sig, &siglen, dig, diglen) <= 0) {
-			msg_err ("cannot sign %s using private key %s, %s",
-				in_file,
-				privkey,
-				ERR_error_string (ERR_get_error (), NULL));
+			msg_err ("cannot sign %s using private key %s, %s", in_file, privkey,
+					ERR_error_string (ERR_get_error (), NULL));
 			OPENSSL_free (sig);
 			continue;
 		}
@@ -1101,14 +1013,12 @@ perform_configs_sign (void)
 		rspamd_snprintf (out_file, sizeof (out_file), "%s.sig", in_file);
 		fd = open (out_file, O_WRONLY | O_CREAT | O_TRUNC, 00644);
 		if (fd == -1) {
-			msg_err ("cannot open output file %s: %s", out_file, strerror (
-					errno));
+			msg_err ("cannot open output file %s: %s", out_file, strerror (errno));
 			OPENSSL_free (sig);
 			continue;
 		}
 		if (write (fd, sig, siglen) == -1) {
-			msg_err ("cannot write to output file %s: %s", out_file,
-				strerror (errno));
+			msg_err ("cannot write to output file %s: %s", out_file, strerror (errno));
 		}
 		OPENSSL_free (sig);
 		close (fd);
@@ -1128,15 +1038,15 @@ perform_configs_sign (void)
 gint
 main (gint argc, gchar **argv, gchar **env)
 {
-	gint res = 0, i;
-	struct sigaction signals;
-	struct rspamd_worker *cur;
-	struct rlimit rlim;
-	struct filter *filt;
-	pid_t wrk;
-	GList *l;
-	worker_t **pworker;
-	GQuark type;
+	gint                             res = 0, i;
+	struct sigaction                signals;
+	struct rspamd_worker           *cur;
+	struct rlimit                   rlim;
+	struct filter                  *filt;
+	pid_t                            wrk;
+	GList                           *l;
+	worker_t                       **pworker;
+	GQuark                           type;
 
 #ifdef HAVE_SA_SIGINFO
 	signals_info = g_queue_new ();
@@ -1145,10 +1055,8 @@ main (gint argc, gchar **argv, gchar **env)
 	g_thread_init (NULL);
 #endif
 	rspamd_main = (struct rspamd_main *)g_malloc0 (sizeof (struct rspamd_main));
-	rspamd_main->server_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
-	rspamd_main->cfg =
-		(struct rspamd_config *)g_malloc0 (sizeof (struct rspamd_config));
+	rspamd_main->server_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
+	rspamd_main->cfg = (struct rspamd_config *)g_malloc0 (sizeof (struct rspamd_config));
 
 	if (!rspamd_main || !rspamd_main->cfg) {
 		fprintf (stderr, "Cannot allocate memory\n");
@@ -1159,12 +1067,10 @@ main (gint argc, gchar **argv, gchar **env)
 	init_title (argc, argv, env);
 #endif
 
-	rspamd_main->stat = rspamd_mempool_alloc_shared (rspamd_main->server_pool,
-			sizeof (struct rspamd_stat));
+	rspamd_main->stat = rspamd_mempool_alloc_shared (rspamd_main->server_pool, sizeof (struct rspamd_stat));
 	memset (rspamd_main->stat, 0, sizeof (struct rspamd_stat));
 
-	rspamd_main->cfg->cfg_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	rspamd_main->cfg->cfg_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 	rspamd_config_defaults (rspamd_main->cfg);
 
 	memset (&signals, 0, sizeof (struct sigaction));
@@ -1184,10 +1090,10 @@ main (gint argc, gchar **argv, gchar **env)
 
 #ifdef HAVE_SETLOCALE
 	/* Set locale setting to C locale to avoid problems in future */
-	setlocale (LC_ALL,		"C");
-	setlocale (LC_CTYPE,	"C");
+	setlocale (LC_ALL, "C");
+	setlocale (LC_CTYPE, "C");
 	setlocale (LC_MESSAGES, "C");
-	setlocale (LC_TIME,		"C");
+	setlocale (LC_TIME, "C");
 #endif
 
 #ifdef HAVE_OPENSSL
@@ -1208,32 +1114,25 @@ main (gint argc, gchar **argv, gchar **env)
 
 	detect_priv (rspamd_main);
 	rspamd_main->cfg->lua_state = init_lua (rspamd_main->cfg);
-	rspamd_mempool_add_destructor (rspamd_main->cfg->cfg_pool,
-		(rspamd_mempool_destruct_t)lua_close, rspamd_main->cfg->lua_state);
+	rspamd_mempool_add_destructor (rspamd_main->cfg->cfg_pool, (rspamd_mempool_destruct_t)lua_close, rspamd_main->cfg->lua_state);
 
 	pworker = &workers[0];
 	while (*pworker) {
 		/* Init string quarks */
 		(void)g_quark_from_static_string ((*pworker)->name);
-		pworker++;
+		pworker ++;
 	}
 
 	/* Init counters */
-	rspamd_main->counters = rspamd_hash_new_shared (rspamd_main->server_pool,
-			rspamd_str_hash,
-			rspamd_str_equal,
-			64);
+	rspamd_main->counters = rspamd_hash_new_shared (rspamd_main->server_pool, rspamd_str_hash, rspamd_str_equal, 64);
 	/* Init listen sockets hash */
 	listen_sockets = g_hash_table_new (g_direct_hash, g_direct_equal);
 
 	/* Pre-init of cache */
 	rspamd_main->cfg->cache = g_new0 (struct symbols_cache, 1);
-	rspamd_main->cfg->cache->static_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	rspamd_main->cfg->cache->static_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 	rspamd_main->cfg->cache->cfg = rspamd_main->cfg;
-	rspamd_main->cfg->cache->items_by_symbol = g_hash_table_new (
-		rspamd_str_hash,
-		rspamd_str_equal);
+	rspamd_main->cfg->cache->items_by_symbol = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 
 	/* If we want to test lua skip everything except it */
 	if (lua_tests != NULL && lua_tests[0] != NULL) {
@@ -1246,7 +1145,7 @@ main (gint argc, gchar **argv, gchar **env)
 	}
 
 	/* Load config */
-	if (!load_rspamd_config (rspamd_main->cfg, TRUE)) {
+	if (! load_rspamd_config (rspamd_main->cfg, TRUE)) {
 		exit (EXIT_FAILURE);
 	}
 
@@ -1254,7 +1153,7 @@ main (gint argc, gchar **argv, gchar **env)
 	if (rspamd_pidfile != NULL) {
 		rspamd_main->cfg->pid_file = rspamd_pidfile;
 	}
-
+	
 	/* Force debug log */
 	if (is_debug) {
 		rspamd_main->cfg->log_level = G_LOG_LEVEL_DEBUG;
@@ -1264,7 +1163,7 @@ main (gint argc, gchar **argv, gchar **env)
 		/* Init events to test modules */
 		event_init ();
 		res = TRUE;
-		if (!init_lua_filters (rspamd_main->cfg)) {
+		if (! init_lua_filters (rspamd_main->cfg)) {
 			res = FALSE;
 		}
 		/* Perform modules configuring */
@@ -1282,8 +1181,7 @@ main (gint argc, gchar **argv, gchar **env)
 		/* Insert classifiers symbols */
 		(void)rspamd_config_insert_classify_symbols (rspamd_main->cfg);
 
-		if (!validate_cache (rspamd_main->cfg->cache, rspamd_main->cfg,
-			FALSE)) {
+		if (! validate_cache (rspamd_main->cfg->cache, rspamd_main->cfg, FALSE)) {
 			res = FALSE;
 		}
 		if (dump_cache) {
@@ -1303,9 +1201,7 @@ main (gint argc, gchar **argv, gchar **env)
 	rspamd_main->history = rspamd_roll_history_new (rspamd_main->server_pool);
 
 	msg_info ("rspamd " RVERSION " is starting, build id: " RID);
-	rspamd_main->cfg->cfg_name = rspamd_mempool_strdup (
-		rspamd_main->cfg->cfg_pool,
-		rspamd_main->cfg->cfg_name);
+	rspamd_main->cfg->cfg_name = rspamd_mempool_strdup (rspamd_main->cfg->cfg_pool, rspamd_main->cfg->cfg_name);
 
 	/* Daemonize */
 	if (!rspamd_main->cfg->no_fork && daemon (0, 0) == -1) {
@@ -1330,14 +1226,13 @@ main (gint argc, gchar **argv, gchar **env)
 	setproctitle ("main process");
 
 	/* Init statfile pool */
-	rspamd_main->statfile_pool = statfile_pool_new (rspamd_main->server_pool,
-			rspamd_main->cfg->mlock_statfile_pool);
+	rspamd_main->statfile_pool = statfile_pool_new (rspamd_main->server_pool, rspamd_main->cfg->mlock_statfile_pool);
 
 	event_init ();
 	g_mime_init (0);
 
 	/* Init lua filters */
-	if (!init_lua_filters (rspamd_main->cfg)) {
+	if (! init_lua_filters (rspamd_main->cfg)) {
 		msg_err ("error loading lua plugins");
 		exit (EXIT_FAILURE);
 	}
@@ -1373,8 +1268,7 @@ main (gint argc, gchar **argv, gchar **env)
 
 	/* Maybe read roll history */
 	if (rspamd_main->cfg->history_file) {
-		rspamd_roll_history_load (rspamd_main->history,
-			rspamd_main->cfg->history_file);
+		rspamd_roll_history_load (rspamd_main->history, rspamd_main->cfg->history_file);
 	}
 
 	/* Spawn workers */
@@ -1382,7 +1276,7 @@ main (gint argc, gchar **argv, gchar **env)
 	spawn_workers (rspamd_main);
 
 	/* Signal processing cycle */
-	for (;; ) {
+	for (;;) {
 		msg_debug ("calling sigsuspend");
 		sigemptyset (&signals.sa_mask);
 		sigsuspend (&signals.sa_mask);
@@ -1400,32 +1294,21 @@ main (gint argc, gchar **argv, gchar **env)
 			msg_debug ("catch SIGCHLD signal, finding terminated worker");
 			/* Remove dead child form children list */
 			wrk = waitpid (0, &res, 0);
-			if ((cur =
-				g_hash_table_lookup (rspamd_main->workers,
-				GSIZE_TO_POINTER (wrk))) != NULL) {
+			if ((cur = g_hash_table_lookup (rspamd_main->workers, GSIZE_TO_POINTER (wrk))) != NULL) {
 				/* Unlink dead process from queue and hash table */
 
-				g_hash_table_remove (rspamd_main->workers, GSIZE_TO_POINTER (
-						wrk));
+				g_hash_table_remove (rspamd_main->workers, GSIZE_TO_POINTER (wrk));
 
 				if (WIFEXITED (res) && WEXITSTATUS (res) == 0) {
 					/* Normal worker termination, do not fork one more */
-					msg_info ("%s process %P terminated normally",
-						g_quark_to_string (cur->type),
-						cur->pid);
+					msg_info ("%s process %P terminated normally", g_quark_to_string (cur->type), cur->pid);
 				}
 				else {
 					if (WIFSIGNALED (res)) {
-						msg_warn (
-							"%s process %P terminated abnormally by signal: %d",
-							g_quark_to_string (cur->type),
-							cur->pid,
-							WTERMSIG (res));
+						msg_warn ("%s process %P terminated abnormally by signal: %d", g_quark_to_string (cur->type), cur->pid, WTERMSIG (res));
 					}
 					else {
-						msg_warn ("%s process %P terminated abnormally",
-							g_quark_to_string (cur->type),
-							cur->pid);
+						msg_warn ("%s process %P terminated abnormally", g_quark_to_string (cur->type), cur->pid);
 					}
 					/* Fork another worker in replace of dead one */
 					delay_fork (cur->cf);
@@ -1434,7 +1317,7 @@ main (gint argc, gchar **argv, gchar **env)
 				g_free (cur);
 			}
 			else {
-				for (i = 0; i < (gint)other_workers->len; i++) {
+				for (i = 0; i < (gint)other_workers->len; i ++) {
 					if (g_array_index (other_workers, pid_t, i) == wrk) {
 						g_array_remove_index_fast (other_workers, i);
 						msg_info ("related process %P terminated", wrk);
@@ -1444,9 +1327,7 @@ main (gint argc, gchar **argv, gchar **env)
 		}
 		if (do_restart) {
 			do_restart = 0;
-			reopen_log_priv (rspamd_main->logger,
-				rspamd_main->workers_uid,
-				rspamd_main->workers_gid);
+			reopen_log_priv (rspamd_main->logger, rspamd_main->workers_uid, rspamd_main->workers_gid);
 			msg_info ("rspamd " RVERSION " is restarting");
 			g_hash_table_foreach (rspamd_main->workers, kill_old_workers, NULL);
 			remove_all_maps (rspamd_main->cfg);
@@ -1455,11 +1336,8 @@ main (gint argc, gchar **argv, gchar **env)
 		}
 		if (do_reopen_log) {
 			do_reopen_log = 0;
-			reopen_log_priv (rspamd_main->logger,
-				rspamd_main->workers_uid,
-				rspamd_main->workers_gid);
-			g_hash_table_foreach (rspamd_main->workers, reopen_log_handler,
-				NULL);
+			reopen_log_priv (rspamd_main->logger, rspamd_main->workers_uid, rspamd_main->workers_gid);
+			g_hash_table_foreach (rspamd_main->workers, reopen_log_handler, NULL);
 		}
 		if (got_alarm) {
 			got_alarm = 0;
@@ -1474,7 +1352,7 @@ main (gint argc, gchar **argv, gchar **env)
 	sigaddset (&signals.sa_mask, SIGTERM);
 	sigaction (SIGALRM, &signals, NULL);
 	sigaction (SIGTERM, &signals, NULL);
-	sigaction (SIGINT,	&signals, NULL);
+	sigaction (SIGINT, &signals, NULL);
 	sigprocmask (SIG_UNBLOCK, &signals.sa_mask, NULL);
 	/* Set alarm for hard termination */
 	set_alarm (HARD_TERMINATION_TIME);
@@ -1483,8 +1361,7 @@ main (gint argc, gchar **argv, gchar **env)
 
 	/* Maybe save roll history */
 	if (rspamd_main->cfg->history_file) {
-		rspamd_roll_history_save (rspamd_main->history,
-			rspamd_main->cfg->history_file);
+		rspamd_roll_history_save (rspamd_main->history, rspamd_main->cfg->history_file);
 	}
 
 	msg_info ("terminating...");
@@ -1505,6 +1382,6 @@ main (gint argc, gchar **argv, gchar **env)
 	return (res);
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/main.h b/src/main.h
index 05d9bbdeb..df3792d13 100644
--- a/src/main.h
+++ b/src/main.h
@@ -6,21 +6,21 @@
 #ifndef RSPAMD_MAIN_H
 #define RSPAMD_MAIN_H
 
-#include "buffer.h"
 #include "config.h"
-#include "events.h"
-#include "filter.h"
 #include "fstring.h"
-#include "hash.h"
-#include "http.h"
-#include "logger.h"
 #include "mem_pool.h"
-#include "protocol.h"
-#include "roll_history.h"
 #include "statfile.h"
-#include "task.h"
 #include "url.h"
+#include "protocol.h"
+#include "filter.h"
+#include "buffer.h"
+#include "hash.h"
+#include "events.h"
 #include "util.h"
+#include "logger.h"
+#include "roll_history.h"
+#include "http.h"
+#include "task.h"
 #include "worker_util.h"
 
 /* Default values */
@@ -43,21 +43,21 @@
 #define CR '\r'
 #define LF '\n'
 
-/**
- * Worker process structure
+/** 
+ * Worker process structure 
  */
 struct rspamd_worker {
-	pid_t pid;                                                  /**< pid of worker									*/
-	gboolean is_initialized;                                    /**< is initialized									*/
-	gboolean is_dying;                                          /**< if worker is going to shutdown					*/
-	gboolean pending;                                           /**< if worker is pending to run					*/
-	struct rspamd_main *srv;                                    /**< pointer to server structure					*/
-	GQuark type;                                                /**< process type									*/
-	struct event sig_ev_usr1;                                   /**< signals event									*/
-	struct event sig_ev_usr2;                                   /**< signals event									*/
-	GList *accept_events;                                       /**< socket events									*/
-	struct rspamd_worker_conf *cf;                                      /**< worker config data								*/
-	gpointer ctx;                                               /**< worker's specific data							*/
+	pid_t pid;													/**< pid of worker									*/
+	gboolean is_initialized;									/**< is initialized									*/
+	gboolean is_dying;											/**< if worker is going to shutdown					*/
+	gboolean pending;											/**< if worker is pending to run					*/
+	struct rspamd_main *srv;									/**< pointer to server structure					*/
+	GQuark type;												/**< process type									*/
+	struct event sig_ev_usr1;									/**< signals event									*/
+	struct event sig_ev_usr2;									/**< signals event									*/
+	GList *accept_events;										/**< socket events									*/
+	struct rspamd_worker_conf *cf;										/**< worker config data								*/
+	gpointer ctx;												/**< worker's specific data							*/
 };
 
 /**
@@ -73,40 +73,40 @@ struct mime_part;
 struct rspamd_dns_resolver;
 struct rspamd_task;
 
-/**
+/** 
  * Server statistics
  */
 struct rspamd_stat {
-	guint messages_scanned;                             /**< total number of messages scanned				*/
-	guint actions_stat[METRIC_ACTION_NOACTION + 1];     /**< statistic for each action						*/
-	guint connections_count;                            /**< total connections count						*/
-	guint control_connections_count;                    /**< connections count to control interface			*/
-	guint messages_learned;                             /**< messages learned								*/
-	guint fuzzy_hashes;                                 /**< number of fuzzy hashes stored					*/
-	guint fuzzy_hashes_expired;                         /**< number of fuzzy hashes expired					*/
+	guint messages_scanned;								/**< total number of messages scanned				*/
+	guint actions_stat[METRIC_ACTION_NOACTION + 1];		/**< statistic for each action						*/
+	guint connections_count;							/**< total connections count						*/
+	guint control_connections_count;					/**< connections count to control interface			*/
+	guint messages_learned;								/**< messages learned								*/
+	guint fuzzy_hashes;									/**< number of fuzzy hashes stored					*/
+	guint fuzzy_hashes_expired;							/**< number of fuzzy hashes expired					*/
 };
 
 /**
  * Struct that determine main server object (for logging purposes)
  */
 struct rspamd_main {
-	struct rspamd_config *cfg;                                  /**< pointer to config structure					*/
-	pid_t pid;                                                  /**< main pid										*/
+	struct rspamd_config *cfg;									/**< pointer to config structure					*/
+	pid_t pid;													/**< main pid										*/
 	/* Pid file structure */
-	rspamd_pidfh_t *pfh;                                        /**< struct pidfh for pidfile						*/
-	GQuark type;                                                /**< process type									*/
-	guint ev_initialized;                                       /**< is event system is initialized					*/
-	struct rspamd_stat *stat;                                   /**< pointer to statistics							*/
+	rspamd_pidfh_t *pfh;										/**< struct pidfh for pidfile						*/
+	GQuark type;												/**< process type									*/
+	guint ev_initialized;										/**< is event system is initialized					*/
+	struct rspamd_stat *stat;									/**< pointer to statistics							*/
 
-	rspamd_mempool_t *server_pool;                                  /**< server's memory pool							*/
-	statfile_pool_t *statfile_pool;                             /**< shared statfiles pool							*/
+	rspamd_mempool_t *server_pool;									/**< server's memory pool							*/
+	statfile_pool_t *statfile_pool;								/**< shared statfiles pool							*/
 	GHashTable *workers;                                        /**< workers pool indexed by pid                    */
-	rspamd_hash_t *counters;                                    /**< symbol cache counters							*/
+	rspamd_hash_t *counters;									/**< symbol cache counters							*/
 	rspamd_logger_t *logger;
-	uid_t workers_uid;                                          /**< worker's uid running to                        */
-	gid_t workers_gid;                                          /**< worker's gid running to						*/
-	gboolean is_privilleged;                                    /**< true if run in privilleged mode                */
-	struct roll_history *history;                               /**< rolling history								*/
+	uid_t workers_uid;											/**< worker's uid running to 						*/
+	gid_t workers_gid;											/**< worker's gid running to						*/
+	gboolean is_privilleged;									/**< true if run in privilleged mode 				*/
+	struct roll_history *history;								/**< rolling history								*/
 };
 
 struct counter_data {
@@ -127,11 +127,10 @@ struct process_exception {
  */
 struct controller_command;
 struct controller_session;
-typedef gboolean (*controller_func_t)(gchar **args,
-	struct controller_session *session);
+typedef gboolean (*controller_func_t)(gchar **args, struct controller_session *session);
 
 struct controller_session {
-	struct rspamd_worker *worker;                               /**< pointer to worker structure (controller in fact) */
+	struct rspamd_worker *worker;								/**< pointer to worker structure (controller in fact) */
 	enum {
 		STATE_COMMAND,
 		STATE_HEADER,
@@ -143,48 +142,45 @@ struct controller_session {
 		STATE_OTHER,
 		STATE_WAIT,
 		STATE_WEIGHTS
-	} state;                                                    /**< current session state							*/
-	gint sock;                                                  /**< socket descriptor								*/
+	} state;													/**< current session state							*/
+	gint sock;													/**< socket descriptor								*/
 	/* Access to authorized commands */
-	gboolean authorized;                                        /**< whether this session is authorized				*/
-	gboolean restful;                                           /**< whether this session is a restful session		*/
-	GHashTable *kwargs;                                         /**< keyword arguments for restful command			*/
-	struct controller_command *cmd;                             /**< real command									*/
-	rspamd_mempool_t *session_pool;                             /**< memory pool for session                        */
-	struct rspamd_config *cfg;                                  /**< pointer to config file							*/
-	gchar *learn_rcpt;                                          /**< recipient for learning							*/
-	gchar *learn_from;                                          /**< from address for learning						*/
+	gboolean authorized;										/**< whether this session is authorized				*/
+	gboolean restful;											/**< whether this session is a restful session		*/
+	GHashTable *kwargs;											/**< keyword arguments for restful command			*/
+	struct controller_command *cmd;								/**< real command									*/
+	rspamd_mempool_t *session_pool;								/**< memory pool for session 						*/
+	struct rspamd_config *cfg;									/**< pointer to config file							*/
+	gchar *learn_rcpt;											/**< recipient for learning							*/
+	gchar *learn_from;											/**< from address for learning						*/
 	struct rspamd_classifier_config *learn_classifier;
-	gchar *learn_symbol;                                            /**< symbol to train								*/
-	double learn_multiplier;                                    /**< multiplier for learning						*/
-	rspamd_io_dispatcher_t *dispatcher;                         /**< IO dispatcher object							*/
-	f_str_t *learn_buf;                                         /**< learn input									*/
-	GList *parts;                                               /**< extracted mime parts							*/
-	gint in_class;                                              /**< positive or negative learn						*/
+	gchar *learn_symbol;											/**< symbol to train								*/
+	double learn_multiplier;									/**< multiplier for learning						*/
+	rspamd_io_dispatcher_t *dispatcher;							/**< IO dispatcher object							*/
+	f_str_t *learn_buf;											/**< learn input									*/
+	GList *parts;												/**< extracted mime parts							*/
+	gint in_class;												/**< positive or negative learn						*/
 	gboolean (*other_handler)(struct controller_session *session,
-		f_str_t *in);                       /**< other command handler to execute at the end of processing */
-	void *other_data;                                           /**< and its data                                   */
-	controller_func_t custom_handler;                           /**< custom command handler							*/
-	struct rspamd_async_session * s;                             /**< async session object							*/
+			f_str_t *in);					/**< other command handler to execute at the end of processing */
+	void *other_data;											/**< and its data 									*/
+	controller_func_t custom_handler;							/**< custom command handler							*/
+	struct rspamd_async_session* s;								/**< async session object							*/
 	struct rspamd_task *learn_task;
-	struct rspamd_dns_resolver *resolver;                       /**< DNS resolver									*/
-	struct event_base *ev_base;                                 /**< Event base										*/
+	struct rspamd_dns_resolver *resolver;						/**< DNS resolver									*/
+	struct event_base *ev_base;									/**< Event base										*/
 };
 
 /**
  * Common structure representing C module context
  */
 struct module_ctx {
-	gint (*filter)(struct rspamd_task *task);                   /**< pointer to headers process function			*/
+	gint (*filter)(struct rspamd_task *task);					/**< pointer to headers process function			*/
 };
 
 /**
  * Register custom controller function
  */
-void register_custom_controller_command (const gchar *name,
-	controller_func_t handler,
-	gboolean privilleged,
-	gboolean require_message);
+void register_custom_controller_command (const gchar *name, controller_func_t handler, gboolean privilleged, gboolean require_message);
 
 /**
  * If set, reopen log file on next write
@@ -193,6 +189,6 @@ extern struct rspamd_main *rspamd_main;
 
 #endif
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/plugins/chartable.c b/src/plugins/chartable.c
index 4203c5ac5..e5ea0fb71 100644
--- a/src/plugins/chartable.c
+++ b/src/plugins/chartable.c
@@ -31,11 +31,11 @@
  *   (e.g. if threshold is 0.1 than charset change should occure more often than in 10 symbols), default: 0.1
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "expressions.h"
 #include "main.h"
 #include "message.h"
+#include "cfg_file.h"
+#include "expressions.h"
 
 #define DEFAULT_SYMBOL "R_CHARSET_MIXED"
 #define DEFAULT_THRESHOLD 0.1
@@ -54,17 +54,17 @@ module_t chartable_module = {
 };
 
 struct chartable_ctx {
-	gint (*filter) (struct rspamd_task * task);
-	const gchar *symbol;
-	double threshold;
+	gint                            (*filter) (struct rspamd_task * task);
+	const gchar                    *symbol;
+	double                          threshold;
 
-	rspamd_mempool_t *chartable_pool;
+	rspamd_mempool_t                  *chartable_pool;
 };
 
-static struct chartable_ctx *chartable_module_ctx = NULL;
+static struct chartable_ctx    *chartable_module_ctx = NULL;
 
-static gint chartable_mime_filter (struct rspamd_task *task);
-static void chartable_symbol_callback (struct rspamd_task *task, void *unused);
+static gint                      chartable_mime_filter (struct rspamd_task *task);
+static void                     chartable_symbol_callback (struct rspamd_task *task, void *unused);
 
 gint
 chartable_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
@@ -72,8 +72,7 @@ chartable_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 	chartable_module_ctx = g_malloc (sizeof (struct chartable_ctx));
 
 	chartable_module_ctx->filter = chartable_mime_filter;
-	chartable_module_ctx->chartable_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	chartable_module_ctx->chartable_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 	*ctx = (struct module_ctx *)chartable_module_ctx;
 
@@ -84,18 +83,16 @@ chartable_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 gint
 chartable_module_config (struct rspamd_config *cfg)
 {
-	const ucl_object_t *value;
-	gint res = TRUE;
+	const ucl_object_t             *value;
+	gint                            res = TRUE;
 
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "chartable", "symbol")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "chartable", "symbol")) != NULL) {
 		chartable_module_ctx->symbol = ucl_obj_tostring (value);
 	}
 	else {
 		chartable_module_ctx->symbol = DEFAULT_SYMBOL;
-	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "chartable", "threshold")) != NULL) {
+	} 
+	if ((value = rspamd_config_get_module_opt (cfg, "chartable", "threshold")) != NULL) {
 		if (!ucl_obj_todouble_safe (value, &chartable_module_ctx->threshold)) {
 			msg_warn ("invalid numeric value");
 			chartable_module_ctx->threshold = DEFAULT_THRESHOLD;
@@ -105,11 +102,7 @@ chartable_module_config (struct rspamd_config *cfg)
 		chartable_module_ctx->threshold = DEFAULT_THRESHOLD;
 	}
 
-	register_symbol (&cfg->cache,
-		chartable_module_ctx->symbol,
-		1,
-		chartable_symbol_callback,
-		NULL);
+	register_symbol (&cfg->cache, chartable_module_ctx->symbol, 1, chartable_symbol_callback, NULL);
 
 	return res;
 }
@@ -123,31 +116,27 @@ chartable_module_reconfig (struct rspamd_config *cfg)
 	return chartable_module_config (cfg);
 }
 
-static gboolean
+static                          gboolean
 check_part (struct mime_text_part *part, gboolean raw_mode)
 {
-	guchar *p, *p1;
-	gunichar c, t;
-	GUnicodeScript scc, sct;
-	guint32 mark = 0, total = 0, max = 0, i;
-	guint32 remain = part->content->len;
-	guint32 scripts[G_UNICODE_SCRIPT_NKO];
-	GUnicodeScript sel = 0;
+	guchar                          *p, *p1;
+	gunichar                        c, t;
+	GUnicodeScript                  scc, sct;
+	guint32                         mark = 0, total = 0, max = 0, i;
+	guint32                         remain = part->content->len;
+	guint32                         scripts[G_UNICODE_SCRIPT_NKO];
+	GUnicodeScript                  sel = 0;
 
 	p = part->content->data;
 
 	if (part->is_raw || raw_mode) {
 		while (remain > 1) {
-			if ((g_ascii_isalpha (*p) &&
-				(*(p + 1) & 0x80)) ||
-				((*p & 0x80) && g_ascii_isalpha (*(p + 1)))) {
+			if ((g_ascii_isalpha (*p) && (*(p + 1) & 0x80)) || ((*p & 0x80) && g_ascii_isalpha (*(p + 1)))) {
 				mark++;
 				total++;
 			}
 			/* Current and next symbols are of one class */
-			else if (((*p & 0x80) &&
-				(*(p + 1) & 0x80)) ||
-				(g_ascii_isalpha (*p) && g_ascii_isalpha (*(p + 1)))) {
+			else if (((*p & 0x80) && (*(p + 1) & 0x80)) || (g_ascii_isalpha (*p) && g_ascii_isalpha (*(p + 1)))) {
 				total++;
 			}
 			p++;
@@ -158,14 +147,14 @@ check_part (struct mime_text_part *part, gboolean raw_mode)
 		memset (&scripts, 0, sizeof (scripts));
 		while (remain > 0) {
 			c = g_utf8_get_char_validated (p, remain);
-			if (c == (gunichar) - 2 || c == (gunichar) - 1) {
+			if (c == (gunichar) -2 || c == (gunichar) -1) {
 				/* Invalid characters detected, stop processing */
 				return FALSE;
 			}
 
 			scc = g_unichar_get_script (c);
 			if (scc < (gint)G_N_ELEMENTS (scripts)) {
-				scripts[scc]++;
+				scripts[scc] ++;
 			}
 			p1 = g_utf8_next_char (p);
 			remain -= p1 - p;
@@ -173,7 +162,7 @@ check_part (struct mime_text_part *part, gboolean raw_mode)
 
 			if (remain > 0) {
 				t = g_utf8_get_char_validated (p, remain);
-				if (t == (gunichar) - 2 || t == (gunichar) - 1) {
+				if (t == (gunichar) -2 || t == (gunichar) -1) {
 					/* Invalid characters detected, stop processing */
 					return FALSE;
 				}
@@ -191,7 +180,7 @@ check_part (struct mime_text_part *part, gboolean raw_mode)
 			}
 		}
 		/* Detect the mostly charset of this part */
-		for (i = 0; i < G_N_ELEMENTS (scripts); i++) {
+		for (i = 0; i < G_N_ELEMENTS (scripts); i ++) {
 			if (scripts[i] > max) {
 				max = scripts[i];
 				sel = i;
@@ -210,8 +199,8 @@ check_part (struct mime_text_part *part, gboolean raw_mode)
 static void
 chartable_symbol_callback (struct rspamd_task *task, void *unused)
 {
-	GList *cur;
-	struct mime_text_part *part;
+	GList                          *cur;
+	struct mime_text_part          *part;
 
 	cur = g_list_first (task->text_parts);
 	while (cur) {
diff --git a/src/plugins/dkim_check.c b/src/plugins/dkim_check.c
index 5ebe336f0..78743ebf1 100644
--- a/src/plugins/dkim_check.c
+++ b/src/plugins/dkim_check.c
@@ -37,15 +37,15 @@
  * - skip_mutli (flag): skip messages with multiply dkim signatures
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "dkim.h"
-#include "expressions.h"
-#include "hash.h"
 #include "main.h"
-#include "map.h"
 #include "message.h"
+#include "cfg_file.h"
+#include "expressions.h"
 #include "util.h"
+#include "map.h"
+#include "dkim.h"
+#include "hash.h"
 
 #define DEFAULT_SYMBOL_REJECT "R_DKIM_REJECT"
 #define DEFAULT_SYMBOL_TEMPFAIL "R_DKIM_TEMPFAIL"
@@ -55,24 +55,24 @@
 #define DEFAULT_TIME_JITTER 60
 
 struct dkim_ctx {
-	gint (*filter) (struct rspamd_task * task);
-	const gchar *symbol_reject;
-	const gchar *symbol_tempfail;
-	const gchar *symbol_allow;
-
-	rspamd_mempool_t *dkim_pool;
-	radix_tree_t *whitelist_ip;
-	GHashTable *dkim_domains;
-	guint strict_multiplier;
-	guint time_jitter;
-	rspamd_lru_hash_t *dkim_hash;
-	gboolean trusted_only;
-	gboolean skip_multi;
+	gint                            (*filter) (struct rspamd_task * task);
+	const gchar                    *symbol_reject;
+	const gchar                    *symbol_tempfail;
+	const gchar                    *symbol_allow;
+
+	rspamd_mempool_t                   *dkim_pool;
+	radix_tree_t                    *whitelist_ip;
+	GHashTable						*dkim_domains;
+	guint							 strict_multiplier;
+	guint							 time_jitter;
+	rspamd_lru_hash_t               *dkim_hash;
+	gboolean						 trusted_only;
+	gboolean						 skip_multi;
 };
 
-static struct dkim_ctx *dkim_module_ctx = NULL;
+static struct dkim_ctx        *dkim_module_ctx = NULL;
 
-static void dkim_symbol_callback (struct rspamd_task *task, void *unused);
+static void                   dkim_symbol_callback (struct rspamd_task *task, void *unused);
 
 /* Initialization */
 gint dkim_module_init (struct rspamd_config *cfg, struct module_ctx **ctx);
@@ -92,8 +92,7 @@ dkim_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 {
 	dkim_module_ctx = g_malloc0 (sizeof (struct dkim_ctx));
 
-	dkim_module_ctx->dkim_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	dkim_module_ctx->dkim_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 	*ctx = (struct module_ctx *)dkim_module_ctx;
 
@@ -103,96 +102,79 @@ dkim_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 gint
 dkim_module_config (struct rspamd_config *cfg)
 {
-	const ucl_object_t *value;
-	gint res = TRUE;
-	guint cache_size, cache_expire;
-	gboolean got_trusted = FALSE;
+	const ucl_object_t             *value;
+	gint                            res = TRUE;
+	guint                           cache_size, cache_expire;
+	gboolean						got_trusted = FALSE;
 
 	dkim_module_ctx->whitelist_ip = radix_tree_create ();
 
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim", "symbol_reject")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "symbol_reject")) != NULL) {
 		dkim_module_ctx->symbol_reject = ucl_obj_tostring (value);
 	}
 	else {
 		dkim_module_ctx->symbol_reject = DEFAULT_SYMBOL_REJECT;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim",
-		"symbol_tempfail")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "symbol_tempfail")) != NULL) {
 		dkim_module_ctx->symbol_tempfail = ucl_obj_tostring (value);
 	}
 	else {
 		dkim_module_ctx->symbol_tempfail = DEFAULT_SYMBOL_TEMPFAIL;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim", "symbol_allow")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "symbol_allow")) != NULL) {
 		dkim_module_ctx->symbol_allow = ucl_obj_tostring (value);
 	}
 	else {
 		dkim_module_ctx->symbol_allow = DEFAULT_SYMBOL_ALLOW;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim",
-		"dkim_cache_size")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "dkim_cache_size")) != NULL) {
 		cache_size = ucl_obj_toint (value);
 	}
 	else {
 		cache_size = DEFAULT_CACHE_SIZE;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim",
-		"dkim_cache_expire")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "dkim_cache_expire")) != NULL) {
 		cache_expire = ucl_obj_todouble (value);
 	}
 	else {
 		cache_expire = DEFAULT_CACHE_MAXAGE;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim", "time_jitter")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "time_jitter")) != NULL) {
 		dkim_module_ctx->time_jitter = ucl_obj_todouble (value);
 	}
 	else {
 		dkim_module_ctx->time_jitter = DEFAULT_TIME_JITTER;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim", "whitelist")) != NULL) {
-		if (!add_map (cfg, ucl_obj_tostring (value),
-			"DKIM whitelist", read_radix_list, fin_radix_list,
-			(void **)&dkim_module_ctx->whitelist_ip)) {
-			msg_warn ("cannot load whitelist from %s",
-				ucl_obj_tostring (value));
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "whitelist")) != NULL) {
+		if (! add_map (cfg, ucl_obj_tostring (value),
+				"DKIM whitelist", read_radix_list, fin_radix_list,
+				(void **)&dkim_module_ctx->whitelist_ip)) {
+			msg_warn ("cannot load whitelist from %s", ucl_obj_tostring (value));
 		}
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim", "domains")) != NULL) {
-		if (!add_map (cfg, ucl_obj_tostring (value),
-			"DKIM domains", read_kv_list, fin_kv_list,
-			(void **)&dkim_module_ctx->dkim_domains)) {
-			msg_warn ("cannot load dkim domains list from %s",
-				ucl_obj_tostring (value));
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "domains")) != NULL) {
+		if (! add_map (cfg, ucl_obj_tostring (value),
+				"DKIM domains", read_kv_list, fin_kv_list,
+				(void **)&dkim_module_ctx->dkim_domains)) {
+			msg_warn ("cannot load dkim domains list from %s", ucl_obj_tostring (value));
 		}
 		else {
 			got_trusted = TRUE;
 		}
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim",
-		"strict_multiplier")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "strict_multiplier")) != NULL) {
 		dkim_module_ctx->strict_multiplier = ucl_obj_toint (value);
 	}
 	else {
 		dkim_module_ctx->strict_multiplier = 1;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim", "trusted_only")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "trusted_only")) != NULL) {
 		dkim_module_ctx->trusted_only = ucl_obj_toboolean (value);
 	}
 	else {
 		dkim_module_ctx->trusted_only = FALSE;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "dkim", "skip_multi")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "dkim", "skip_multi")) != NULL) {
 		dkim_module_ctx->skip_multi = ucl_obj_toboolean (value);
 	}
 	else {
@@ -200,33 +182,19 @@ dkim_module_config (struct rspamd_config *cfg)
 	}
 
 	if (dkim_module_ctx->trusted_only && !got_trusted) {
-		msg_err (
-			"trusted_only option is set and no trusted domains are defined; disabling dkim module completely as it is useless in this case");
+		msg_err ("trusted_only option is set and no trusted domains are defined; disabling dkim module completely as it is useless in this case");
 	}
 	else {
-		register_symbol (&cfg->cache,
-			dkim_module_ctx->symbol_reject,
-			1,
-			dkim_symbol_callback,
-			NULL);
-		register_virtual_symbol (&cfg->cache,
-			dkim_module_ctx->symbol_tempfail,
-			1);
-		register_virtual_symbol (&cfg->cache,
-			dkim_module_ctx->symbol_allow,
-			1);
-
-		dkim_module_ctx->dkim_hash = rspamd_lru_hash_new (rspamd_strcase_hash,
-				rspamd_strcase_equal,
-				cache_size,
-				cache_expire,
-				g_free,
-				(GDestroyNotify)rspamd_dkim_key_free);
+		register_symbol (&cfg->cache, dkim_module_ctx->symbol_reject, 1, dkim_symbol_callback, NULL);
+		register_virtual_symbol (&cfg->cache, dkim_module_ctx->symbol_tempfail, 1);
+		register_virtual_symbol (&cfg->cache, dkim_module_ctx->symbol_allow, 1);
+
+		dkim_module_ctx->dkim_hash = rspamd_lru_hash_new (rspamd_strcase_hash, rspamd_strcase_equal,
+				cache_size, cache_expire, g_free, (GDestroyNotify)rspamd_dkim_key_free);
 
 
 #ifndef HAVE_OPENSSL
-		msg_warn (
-			"openssl is not found so dkim rsa check is disabled, only check body hash, it is NOT safe to trust these results");
+		msg_warn ("openssl is not found so dkim rsa check is disabled, only check body hash, it is NOT safe to trust these results");
 #endif
 	}
 
@@ -241,8 +209,7 @@ dkim_module_reconfig (struct rspamd_config *cfg)
 	if (dkim_module_ctx->dkim_domains) {
 		g_hash_table_destroy (dkim_module_ctx->dkim_domains);
 	}
-	dkim_module_ctx->dkim_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	dkim_module_ctx->dkim_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 	return dkim_module_config (cfg);
 }
@@ -253,14 +220,14 @@ dkim_module_reconfig (struct rspamd_config *cfg)
 static gboolean
 dkim_module_parse_strict (const gchar *value, gint *allow, gint *deny)
 {
-	const gchar *colon;
-	gulong val;
+	const gchar							*colon;
+	gulong								 val;
 
 	colon = strchr (value, ':');
 	if (colon) {
 		if (rspamd_strtoul (value, colon - value, &val)) {
 			*deny = val;
-			colon++;
+			colon ++;
 			if (rspamd_strtoul (colon, strlen (colon), &val)) {
 				*allow = val;
 				return TRUE;
@@ -271,38 +238,25 @@ dkim_module_parse_strict (const gchar *value, gint *allow, gint *deny)
 }
 
 static void
-dkim_module_check (struct rspamd_task *task,
-	rspamd_dkim_context_t *ctx,
-	rspamd_dkim_key_t *key)
+dkim_module_check (struct rspamd_task *task, rspamd_dkim_context_t *ctx, rspamd_dkim_key_t *key)
 {
-	gint res, score_allow = 1, score_deny = 1;
-	const gchar *strict_value;
+	gint								 res, score_allow = 1, score_deny = 1;
+	const gchar							*strict_value;
 
-	msg_debug ("check dkim signature for %s domain from %s",
-		ctx->domain,
-		ctx->dns_key);
+	msg_debug ("check dkim signature for %s domain from %s", ctx->domain, ctx->dns_key);
 	res = rspamd_dkim_check (ctx, key, task);
 
 	if (dkim_module_ctx->dkim_domains != NULL) {
 		/* Perform strict check */
-		if ((strict_value =
-			g_hash_table_lookup (dkim_module_ctx->dkim_domains,
-			ctx->domain)) != NULL) {
-			if (!dkim_module_parse_strict (strict_value, &score_allow,
-				&score_deny)) {
+		if ((strict_value = g_hash_table_lookup (dkim_module_ctx->dkim_domains, ctx->domain)) != NULL) {
+			if (!dkim_module_parse_strict (strict_value, &score_allow, &score_deny)) {
 				score_allow = dkim_module_ctx->strict_multiplier;
 				score_deny = dkim_module_ctx->strict_multiplier;
-				msg_debug (
-					"no specific score found for %s domain, using %d for it",
-					ctx->domain,
-					score_deny);
+				msg_debug ("no specific score found for %s domain, using %d for it", ctx->domain, score_deny);
 			}
 			else {
-				msg_debug (
-					"specific score found for %s domain: using %d for deny and %d for allow",
-					ctx->dns_key,
-					score_deny,
-					score_allow);
+				msg_debug ("specific score found for %s domain: using %d for deny and %d for allow",
+						ctx->dns_key, score_deny, score_allow);
 			}
 		}
 	}
@@ -319,20 +273,15 @@ dkim_module_check (struct rspamd_task *task,
 }
 
 static void
-dkim_module_key_handler (rspamd_dkim_key_t *key,
-	gsize keylen,
-	rspamd_dkim_context_t *ctx,
-	gpointer ud,
-	GError *err)
+dkim_module_key_handler (rspamd_dkim_key_t *key, gsize keylen, rspamd_dkim_context_t *ctx, gpointer ud, GError *err)
 {
-	struct rspamd_task *task = ud;
+	struct rspamd_task					*task = ud;
 
 
 	if (key != NULL) {
 		/* Add new key to the lru cache */
-		rspamd_lru_hash_insert (dkim_module_ctx->dkim_hash,
-			g_strdup (ctx->dns_key),
-			key, task->tv.tv_sec, key->ttl);
+		rspamd_lru_hash_insert (dkim_module_ctx->dkim_hash, g_strdup (ctx->dns_key),
+				key, task->tv.tv_sec, key->ttl);
 		dkim_module_check (task, ctx, key);
 	}
 	else {
@@ -340,8 +289,7 @@ dkim_module_key_handler (rspamd_dkim_key_t *key,
 		msg_info ("cannot get key for domain %s", ctx->dns_key);
 		if (err != NULL) {
 			insert_result (task, dkim_module_ctx->symbol_tempfail, 1,
-				g_list_prepend (NULL,
-				rspamd_mempool_strdup (task->task_pool, err->message)));
+					g_list_prepend (NULL, rspamd_mempool_strdup (task->task_pool, err->message)));
 
 		}
 		else {
@@ -357,23 +305,19 @@ dkim_module_key_handler (rspamd_dkim_key_t *key,
 static void
 dkim_symbol_callback (struct rspamd_task *task, void *unused)
 {
-	GList *hlist;
-	rspamd_dkim_context_t *ctx;
-	rspamd_dkim_key_t *key;
-	GError *err = NULL;
+	GList								*hlist;
+	rspamd_dkim_context_t				*ctx;
+	rspamd_dkim_key_t					*key;
+	GError								*err = NULL;
 	/* First check if a message has its signature */
 
-	hlist = message_get_header (task->task_pool,
-			task->message,
-			DKIM_SIGNHEADER,
-			FALSE);
+	hlist = message_get_header (task->task_pool, task->message, DKIM_SIGNHEADER, FALSE);
 	if (hlist != NULL) {
 		/* Check whitelist */
 		msg_debug ("dkim signature found");
 		if (task->from_addr.af == AF_INET ||
-			radix32tree_find (dkim_module_ctx->whitelist_ip,
-			ntohl (task->from_addr.addr.s4.sin_addr.s_addr)) ==
-			RADIX_NO_VALUE) {
+				radix32tree_find (dkim_module_ctx->whitelist_ip,
+						ntohl (task->from_addr.addr.s4.sin_addr.s_addr)) == RADIX_NO_VALUE) {
 			/* Parse signature */
 			msg_debug ("create dkim signature");
 			/*
@@ -382,45 +326,32 @@ dkim_symbol_callback (struct rspamd_task *task, void *unused)
 			 */
 			if (dkim_module_ctx->skip_multi) {
 				if (hlist->next != NULL) {
-					msg_info (
-						"<%s> skip dkim check as it has several dkim signatures",
-						task->message_id);
+					msg_info ("<%s> skip dkim check as it has several dkim signatures", task->message_id);
 					return;
 				}
 			}
 			hlist = g_list_last (hlist);
-			ctx = rspamd_create_dkim_context (hlist->data,
-					task->task_pool,
-					dkim_module_ctx->time_jitter,
-					&err);
+			ctx = rspamd_create_dkim_context (hlist->data, task->task_pool, dkim_module_ctx->time_jitter, &err);
 			if (ctx == NULL) {
 				msg_info ("cannot parse DKIM context: %s", err->message);
 				g_error_free (err);
 			}
 			else {
 				/* Get key */
-				if (dkim_module_ctx->trusted_only &&
-					(dkim_module_ctx->dkim_domains == NULL ||
-					g_hash_table_lookup (dkim_module_ctx->dkim_domains,
-					ctx->domain) == NULL)) {
+				if (dkim_module_ctx->trusted_only && (dkim_module_ctx->dkim_domains == NULL ||
+						g_hash_table_lookup (dkim_module_ctx->dkim_domains, ctx->domain) == NULL)) {
 					msg_debug ("skip dkim check for %s domain", ctx->domain);
 					return;
 				}
-				key = rspamd_lru_hash_lookup (dkim_module_ctx->dkim_hash,
-						ctx->dns_key,
-						task->tv.tv_sec);
+				key = rspamd_lru_hash_lookup (dkim_module_ctx->dkim_hash, ctx->dns_key, task->tv.tv_sec);
 				if (key != NULL) {
 					debug_task ("found key for %s in cache", ctx->dns_key);
 					dkim_module_check (task, ctx, key);
 				}
 				else {
 					debug_task ("request key for %s from DNS", ctx->dns_key);
-					task->dns_requests++;
-					rspamd_get_dkim_key (ctx,
-						task->resolver,
-						task->s,
-						dkim_module_key_handler,
-						task);
+					task->dns_requests ++;
+					rspamd_get_dkim_key (ctx, task->resolver, task->s, dkim_module_key_handler, task);
 				}
 			}
 		}
diff --git a/src/plugins/fuzzy_check.c b/src/plugins/fuzzy_check.c
index 871a2e2e7..1ee1013e6 100644
--- a/src/plugins/fuzzy_check.c
+++ b/src/plugins/fuzzy_check.c
@@ -29,7 +29,7 @@
  * - symbol (string): symbol to insert (default: 'R_FUZZY')
  * - max_score (double): maximum score to that weights of hashes would be normalized (default: 0 - no normalization)
  *
- * - fuzzy_map (string): a string that contains map in format { fuzzy_key => [ symbol, weight ] } where fuzzy_key is number of
+ * - fuzzy_map (string): a string that contains map in format { fuzzy_key => [ symbol, weight ] } where fuzzy_key is number of 
  *   fuzzy list. This string itself should be in format 1:R_FUZZY_SAMPLE1:10,2:R_FUZZY_SAMPLE2:1 etc, where first number is fuzzy
  *   key, second is symbol to insert and third - weight for normalization
  *
@@ -39,15 +39,15 @@
  *   fuzzy hashes
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "expressions.h"
-#include "fuzzy_storage.h"
-#include "images.h"
 #include "main.h"
-#include "map.h"
 #include "message.h"
+#include "cfg_file.h"
+#include "expressions.h"
 #include "util.h"
+#include "map.h"
+#include "images.h"
+#include "fuzzy_storage.h"
 
 #define DEFAULT_SYMBOL "R_FUZZY_HASH"
 #define DEFAULT_UPSTREAM_ERROR_TIME 10
@@ -133,12 +133,10 @@ static const gchar hex_digits[] = "0123456789abcdef";
 static void fuzzy_symbol_callback (struct rspamd_task *task, void *unused);
 
 /* Initialization */
-gint fuzzy_check_module_init (struct rspamd_config *cfg,
-	struct module_ctx **ctx);
+gint fuzzy_check_module_init (struct rspamd_config *cfg, struct module_ctx **ctx);
 gint fuzzy_check_module_config (struct rspamd_config *cfg);
 gint fuzzy_check_module_reconfig (struct rspamd_config *cfg);
-static gint fuzzy_attach_controller (struct module_ctx *ctx,
-	GHashTable *commands);
+static gint fuzzy_attach_controller (struct module_ctx *ctx, GHashTable *commands);
 
 module_t fuzzy_check_module = {
 	"fuzzy_check",
@@ -149,17 +147,14 @@ module_t fuzzy_check_module = {
 };
 
 static void
-parse_flags (struct fuzzy_rule *rule,
-	struct rspamd_config *cfg,
-	const ucl_object_t *val)
+parse_flags (struct fuzzy_rule *rule, struct rspamd_config *cfg, const ucl_object_t *val)
 {
 	const ucl_object_t *elt;
 	struct fuzzy_mapping *map;
 	const gchar *sym = NULL;
 
 	if (val->type == UCL_STRING) {
-		msg_err (
-			"string mappings are deprecated and no longer supported, use new style configuration");
+		msg_err ("string mappings are deprecated and no longer supported, use new style configuration");
 	}
 	else if (val->type == UCL_OBJECT) {
 		elt = ucl_object_find_key (val, "symbol");
@@ -167,9 +162,7 @@ parse_flags (struct fuzzy_rule *rule,
 			sym = ucl_object_key (val);
 		}
 		if (sym != NULL) {
-			map =
-				rspamd_mempool_alloc (fuzzy_module_ctx->fuzzy_pool,
-					sizeof (struct fuzzy_mapping));
+			map =  rspamd_mempool_alloc (fuzzy_module_ctx->fuzzy_pool, sizeof (struct fuzzy_mapping));
 			map->symbol = sym;
 			elt = ucl_object_find_key (val, "flag");
 			if (elt != NULL && ucl_obj_toint_safe (elt, &map->fuzzy_flag)) {
@@ -181,8 +174,7 @@ parse_flags (struct fuzzy_rule *rule,
 					map->weight = rule->max_score;
 				}
 				/* Add flag to hash table */
-				g_hash_table_insert (rule->mappings,
-					GINT_TO_POINTER (map->fuzzy_flag), map);
+				g_hash_table_insert (rule->mappings, GINT_TO_POINTER (map->fuzzy_flag), map);
 				register_virtual_symbol (&cfg->cache, map->symbol, 1.0);
 			}
 			else {
@@ -201,10 +193,10 @@ parse_flags (struct fuzzy_rule *rule,
 static GList *
 parse_mime_types (const gchar *str)
 {
-	gchar **strvec, *p;
-	gint num, i;
-	struct fuzzy_mime_type *type;
-	GList *res = NULL;
+	gchar                           **strvec, *p;
+	gint                            num, i;
+	struct fuzzy_mime_type         *type;
+	GList                          *res = NULL;
 
 	strvec = g_strsplit_set (str, ",", 0);
 	num = g_strv_length (strvec);
@@ -212,13 +204,9 @@ parse_mime_types (const gchar *str)
 		g_strstrip (strvec[i]);
 		if ((p = strchr (strvec[i], '/')) != NULL) {
 			*p = 0;
-			type =
-				rspamd_mempool_alloc (fuzzy_module_ctx->fuzzy_pool,
-					sizeof (struct fuzzy_mime_type));
-			type->type = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool,
-					strvec[i]);
-			type->subtype = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool,
-					p + 1);
+			type = rspamd_mempool_alloc (fuzzy_module_ctx->fuzzy_pool, sizeof (struct fuzzy_mime_type));
+			type->type = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool, strvec[i]);
+			type->subtype = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool, p + 1);
 			res = g_list_prepend (res, type);
 		}
 		else {
@@ -227,8 +215,7 @@ parse_mime_types (const gchar *str)
 	}
 
 	if (res != NULL) {
-		rspamd_mempool_add_destructor (fuzzy_module_ctx->fuzzy_pool,
-			(rspamd_mempool_destruct_t)g_list_free, res);
+		rspamd_mempool_add_destructor (fuzzy_module_ctx->fuzzy_pool, (rspamd_mempool_destruct_t)g_list_free, res);
 	}
 
 	return res;
@@ -237,8 +224,8 @@ parse_mime_types (const gchar *str)
 static gboolean
 fuzzy_check_content_type (struct fuzzy_rule *rule, GMimeContentType *type)
 {
-	struct fuzzy_mime_type *ft;
-	GList *cur;
+	struct fuzzy_mime_type         *ft;
+	GList                          *cur;
 
 	cur = rule->mime_types;
 	while (cur) {
@@ -255,27 +242,24 @@ fuzzy_check_content_type (struct fuzzy_rule *rule, GMimeContentType *type)
 static void
 parse_servers_string (struct fuzzy_rule *rule, const gchar *str)
 {
-	gchar **strvec;
-	gint i, num;
-	struct storage_server *cur;
+	gchar                           **strvec;
+	gint                            i, num;
+	struct storage_server          *cur;
 
 	strvec = g_strsplit_set (str, ",", 0);
 	num = g_strv_length (strvec);
 
-	rule->servers = rspamd_mempool_alloc0 (fuzzy_module_ctx->fuzzy_pool,
-			sizeof (struct storage_server) * num);
+	rule->servers = rspamd_mempool_alloc0 (fuzzy_module_ctx->fuzzy_pool, sizeof (struct storage_server) * num);
 
 	for (i = 0; i < num; i++) {
 		g_strstrip (strvec[i]);
 
 		cur = &rule->servers[rule->servers_num];
-		if (rspamd_parse_host_port (fuzzy_module_ctx->fuzzy_pool, strvec[i],
-			&cur->addr, &cur->port)) {
+		if (rspamd_parse_host_port (fuzzy_module_ctx->fuzzy_pool, strvec[i], &cur->addr, &cur->port)) {
 			if (cur->port == 0) {
 				cur->port = DEFAULT_PORT;
 			}
-			cur->name = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool,
-					strvec[i]);
+			cur->name = rspamd_mempool_strdup (fuzzy_module_ctx->fuzzy_pool, strvec[i]);
 			rule->servers_num++;
 		}
 	}
@@ -302,10 +286,10 @@ fuzzy_to_string (fuzzy_hash_t *h)
 {
 	static gchar strbuf [FUZZY_HASHLEN * 2 + 1];
 	const int max_print = 5;
-	gint i;
+	gint                            i;
 	guint8 byte;
 
-	for (i = 0; i < max_print; i++) {
+	for (i = 0; i < max_print; i ++) {
 		byte = h->hash_pipe[i];
 		if (byte == '\0') {
 			break;
@@ -332,9 +316,7 @@ fuzzy_rule_new (const char *default_symbol, rspamd_mempool_t *pool)
 
 	rule->mappings = g_hash_table_new (g_direct_hash, g_direct_equal);
 	rule->symbol = default_symbol;
-	rspamd_mempool_add_destructor (pool,
-		(rspamd_mempool_destruct_t)g_hash_table_unref,
-		rule->mappings);
+	rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t)g_hash_table_unref, rule->mappings);
 	rule->read_only = FALSE;
 
 	return rule;
@@ -352,15 +334,13 @@ fuzzy_parse_rule (struct rspamd_config *cfg, const ucl_object_t *obj)
 		return -1;
 	}
 
-	rule = fuzzy_rule_new (fuzzy_module_ctx->default_symbol,
-			fuzzy_module_ctx->fuzzy_pool);
+	rule = fuzzy_rule_new (fuzzy_module_ctx->default_symbol, fuzzy_module_ctx->fuzzy_pool);
 
 	if ((value = ucl_object_find_key (obj, "mime_types")) != NULL) {
 		if (value->type == UCL_ARRAY) {
 			value = value->value.av;
 		}
-		LL_FOREACH (value, cur)
-		{
+		LL_FOREACH (value, cur) {
 			rule->mime_types = g_list_concat (rule->mime_types,
 					parse_mime_types (ucl_obj_tostring (cur)));
 		}
@@ -383,8 +363,7 @@ fuzzy_parse_rule (struct rspamd_config *cfg, const ucl_object_t *obj)
 		if (value->type == UCL_ARRAY) {
 			value = value->value.av;
 		}
-		LL_FOREACH (value, cur)
-		{
+		LL_FOREACH (value, cur) {
 			parse_servers_string (rule, ucl_obj_tostring (cur));
 		}
 	}
@@ -395,14 +374,11 @@ fuzzy_parse_rule (struct rspamd_config *cfg, const ucl_object_t *obj)
 	}
 
 	if (rule->servers_num == 0) {
-		msg_err ("no servers defined for fuzzy rule with symbol: %s",
-			rule->symbol);
+		msg_err ("no servers defined for fuzzy rule with symbol: %s", rule->symbol);
 		return -1;
 	}
 	else {
-		fuzzy_module_ctx->fuzzy_rules = g_list_prepend (
-			fuzzy_module_ctx->fuzzy_rules,
-			rule);
+		fuzzy_module_ctx->fuzzy_rules = g_list_prepend (fuzzy_module_ctx->fuzzy_rules, rule);
 		if (rule->symbol != fuzzy_module_ctx->default_symbol) {
 			register_virtual_symbol (&cfg->cache, rule->symbol, 1.0);
 		}
@@ -416,8 +392,7 @@ fuzzy_check_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 {
 	fuzzy_module_ctx = g_malloc0 (sizeof (struct fuzzy_ctx));
 
-	fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 	fuzzy_module_ctx->cfg = cfg;
 
 	*ctx = (struct module_ctx *)fuzzy_module_ctx;
@@ -428,64 +403,52 @@ fuzzy_check_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 gint
 fuzzy_check_module_config (struct rspamd_config *cfg)
 {
-	const ucl_object_t *value, *cur;
-	gint res = TRUE;
+	const ucl_object_t             *value, *cur;
+	gint                      res = TRUE;
 
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "fuzzy_check", "symbol")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "symbol")) != NULL) {
 		fuzzy_module_ctx->default_symbol = ucl_obj_tostring (value);
 	}
 	else {
 		fuzzy_module_ctx->default_symbol = DEFAULT_SYMBOL;
 	}
 
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "fuzzy_check",
-		"min_length")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "min_length")) != NULL) {
 		fuzzy_module_ctx->min_hash_len = ucl_obj_toint (value);
 	}
 	else {
 		fuzzy_module_ctx->min_hash_len = 0;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "fuzzy_check",
-		"min_bytes")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "min_bytes")) != NULL) {
 		fuzzy_module_ctx->min_bytes = ucl_obj_toint (value);
 	}
 	else {
 		fuzzy_module_ctx->min_bytes = 0;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "fuzzy_check",
-		"min_height")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "min_height")) != NULL) {
 		fuzzy_module_ctx->min_height = ucl_obj_toint (value);
 	}
 	else {
 		fuzzy_module_ctx->min_height = 0;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "fuzzy_check",
-		"min_width")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "min_width")) != NULL) {
 		fuzzy_module_ctx->min_width = ucl_obj_toint (value);
 	}
 	else {
 		fuzzy_module_ctx->min_width = 0;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "fuzzy_check", "timeout")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "timeout")) != NULL) {
 		fuzzy_module_ctx->io_timeout = ucl_obj_todouble (value) * 1000;
 	}
 	else {
 		fuzzy_module_ctx->io_timeout = DEFAULT_IO_TIMEOUT;
 	}
 
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "fuzzy_check",
-		"whitelist")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "whitelist")) != NULL) {
 		fuzzy_module_ctx->whitelist = radix_tree_create ();
 		if (!add_map (cfg, ucl_obj_tostring (value),
-			"Fuzzy whitelist", read_radix_list, fin_radix_list,
-			(void **)&fuzzy_module_ctx->whitelist)) {
+				"Fuzzy whitelist", read_radix_list, fin_radix_list,
+				(void **)&fuzzy_module_ctx->whitelist)) {
 			msg_err ("cannot add whitelist '%s'", ucl_obj_tostring (value));
 		}
 	}
@@ -493,10 +456,8 @@ fuzzy_check_module_config (struct rspamd_config *cfg)
 		fuzzy_module_ctx->whitelist = NULL;
 	}
 
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "fuzzy_check", "rule")) != NULL) {
-		LL_FOREACH (value, cur)
-		{
+	if ((value = rspamd_config_get_module_opt (cfg, "fuzzy_check", "rule")) != NULL) {
+		LL_FOREACH (value, cur) {
 			if (fuzzy_parse_rule (cfg, cur) == -1) {
 				return -1;
 			}
@@ -505,7 +466,7 @@ fuzzy_check_module_config (struct rspamd_config *cfg)
 
 	if (fuzzy_module_ctx->fuzzy_rules != NULL) {
 		register_callback_symbol (&cfg->cache, fuzzy_module_ctx->default_symbol,
-			1.0, fuzzy_symbol_callback, NULL);
+				1.0, fuzzy_symbol_callback, NULL);
 	}
 	else {
 		msg_warn ("fuzzy module is enabled but no rules are defined");
@@ -519,10 +480,9 @@ fuzzy_check_module_reconfig (struct rspamd_config *cfg)
 {
 	rspamd_mempool_delete (fuzzy_module_ctx->fuzzy_pool);
 
-	fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	fuzzy_module_ctx->fuzzy_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 	fuzzy_module_ctx->cfg = cfg;
-
+	
 	return fuzzy_check_module_config (cfg);
 }
 
@@ -530,7 +490,7 @@ fuzzy_check_module_reconfig (struct rspamd_config *cfg)
 static void
 fuzzy_io_fin (void *ud)
 {
-	struct fuzzy_client_session *session = ud;
+	struct fuzzy_client_session    *session = ud;
 
 	event_del (&session->ev);
 	close (session->fd);
@@ -540,13 +500,13 @@ fuzzy_io_fin (void *ud)
 static void
 fuzzy_io_callback (gint fd, short what, void *arg)
 {
-	struct fuzzy_client_session *session = arg;
-	struct fuzzy_cmd cmd;
-	struct fuzzy_mapping *map;
-	gchar buf[62], *err_str;
-	const gchar *symbol;
-	gint value = 0, flag = 0, r;
-	double nval;
+	struct fuzzy_client_session    *session = arg;
+	struct fuzzy_cmd                cmd;
+	struct fuzzy_mapping           *map;
+	gchar                           buf[62], *err_str;
+	const gchar                    *symbol;
+	gint                            value = 0, flag = 0, r;
+	double                          nval;
 
 	if (what == EV_WRITE) {
 		/* Send command to storage */
@@ -580,9 +540,7 @@ fuzzy_io_callback (gint fd, short what, void *arg)
 			}
 			*err_str = '\0';
 			/* Get mapping by flag */
-			if ((map =
-				g_hash_table_lookup (session->rule->mappings,
-				GINT_TO_POINTER (flag))) == NULL) {
+			if ((map = g_hash_table_lookup (session->rule->mappings, GINT_TO_POINTER (flag))) == NULL) {
 				/* Default symbol and default weight */
 				symbol = session->rule->symbol;
 				nval = fuzzy_normalize (value, session->rule->max_score);
@@ -592,53 +550,37 @@ fuzzy_io_callback (gint fd, short what, void *arg)
 				symbol = map->symbol;
 				nval = fuzzy_normalize (value, map->weight);
 			}
-			msg_info (
-				"<%s>, found fuzzy hash '%s' with weight: %.2f, in list: %s:%d%s",
-				session->task->message_id,
-				fuzzy_to_string (session->h),
-				nval,
-				symbol,
-				flag,
-				map == NULL ? "(unknown)" : "");
+			msg_info ("<%s>, found fuzzy hash '%s' with weight: %.2f, in list: %s:%d%s",
+					session->task->message_id, fuzzy_to_string (session->h), nval, symbol,
+					flag, map == NULL ? "(unknown)" : "");
 			if (map != NULL || !session->rule->skip_unknown) {
-				rspamd_snprintf (buf,
-					sizeof (buf),
-					"%d: %d / %.2f",
-					flag,
-					value,
-					nval);
-				insert_result_single (session->task,
-					symbol,
-					nval,
-					g_list_prepend (NULL,
-					rspamd_mempool_strdup (session->task->task_pool, buf)));
+				rspamd_snprintf (buf, sizeof (buf), "%d: %d / %.2f", flag, value, nval);
+				insert_result_single (session->task, symbol, nval, g_list_prepend (NULL,
+						rspamd_mempool_strdup (session->task->task_pool, buf)));
 			}
 		}
 		goto ok;
 	}
 	else {
 		errno = ETIMEDOUT;
-		goto err;
+		goto err;	
 	}
 
 	return;
 
-err:
-	msg_err ("got error on IO with server %s, %d, %s",
-		session->server->name,
-		errno,
-		strerror (errno));
-ok:
+  err:
+	msg_err ("got error on IO with server %s, %d, %s", session->server->name, errno, strerror (errno));
+  ok:
 	remove_normal_event (session->task->s, fuzzy_io_fin, session);
 }
 
 static void
 fuzzy_learn_callback (gint fd, short what, void *arg)
 {
-	struct fuzzy_learn_session *session = arg;
-	struct fuzzy_cmd cmd;
-	gchar buf[512];
-	const gchar *cmd_name;
+	struct fuzzy_learn_session     *session = arg;
+	struct fuzzy_cmd                cmd;
+	gchar                           buf[512];
+	const gchar                     *cmd_name;
 
 	cmd_name = (session->cmd == FUZZY_WRITE ? "add" : "delete");
 	if (what == EV_WRITE) {
@@ -651,52 +593,41 @@ fuzzy_learn_callback (gint fd, short what, void *arg)
 		if (write (fd, &cmd, sizeof (struct fuzzy_cmd)) == -1) {
 			if (*(session->err) == NULL) {
 				g_set_error (session->err,
-					g_quark_from_static_string ("fuzzy check"),
-					errno, "write socket error: %s", strerror (errno));
+						g_quark_from_static_string ("fuzzy check"),
+						errno, "write socket error: %s", strerror (errno));
 			}
 			goto err;
 		}
 		else {
 			event_del (&session->ev);
-			event_set (&session->ev, fd, EV_READ, fuzzy_learn_callback,
-				session);
+			event_set (&session->ev, fd, EV_READ, fuzzy_learn_callback, session);
 			event_add (&session->ev, &session->tv);
 		}
 	}
 	else if (what == EV_READ) {
 		if (read (fd, buf, sizeof (buf)) == -1) {
-			msg_info ("cannot %s fuzzy hash for message <%s>, list %s:%d",
-				cmd_name,
-				session->task->message_id,
-				session->rule->symbol,
-				session->flag);
+			msg_info ("cannot %s fuzzy hash for message <%s>, list %s:%d", cmd_name,
+					session->task->message_id, session->rule->symbol, session->flag);
 			if (*(session->err) == NULL) {
 				g_set_error (session->err,
-					g_quark_from_static_string ("fuzzy check"),
-					errno, "read socket error: %s", strerror (errno));
+						g_quark_from_static_string ("fuzzy check"),
+						errno, "read socket error: %s", strerror (errno));
 			}
 			goto err;
 		}
 		else if (buf[0] == 'O' && buf[1] == 'K') {
-			msg_info ("%s fuzzy hash '%s', list: %s:%d for message <%s>",
-				cmd_name,
-				fuzzy_to_string (session->h),
-				session->rule->symbol,
-				session->flag,
-				session->task->message_id);
+			msg_info ("%s fuzzy hash '%s', list: %s:%d for message <%s>", cmd_name,
+					fuzzy_to_string (session->h), session->rule->symbol,
+					session->flag, session->task->message_id);
 			goto ok;
 		}
 		else {
-			msg_info ("cannot %s fuzzy hash '%s' for message <%s>, list %s:%d",
-				cmd_name,
-				fuzzy_to_string (session->h),
-				session->task->message_id,
-				session->rule->symbol,
-				session->flag);
+			msg_info ("cannot %s fuzzy hash '%s' for message <%s>, list %s:%d", cmd_name,
+					fuzzy_to_string (session->h), session->task->message_id,
+					session->rule->symbol, session->flag);
 			if (*(session->err) == NULL) {
 				g_set_error (session->err,
-					g_quark_from_static_string (
-						"fuzzy check"), EINVAL, "%s fuzzy error", cmd_name);
+						g_quark_from_static_string ("fuzzy check"), EINVAL, "%s fuzzy error", cmd_name);
 			}
 			goto ok;
 		}
@@ -705,17 +636,16 @@ fuzzy_learn_callback (gint fd, short what, void *arg)
 		errno = ETIMEDOUT;
 		if (*(session->err) == NULL) {
 			g_set_error (session->err,
-				g_quark_from_static_string (
-					"fuzzy check"), EINVAL, "%s fuzzy, IO timeout", cmd_name);
+					g_quark_from_static_string ("fuzzy check"), EINVAL, "%s fuzzy, IO timeout", cmd_name);
 		}
-		goto err;
+		goto err;	
 	}
 
 	return;
 
 err:
 	msg_err ("got error in IO with server %s, %d, %s",
-		session->server->name, errno, strerror (errno));
+			session->server->name, errno, strerror (errno));
 	rspamd_http_connection_unref (session->http_entry->conn);
 	rspamd_task_free (session->task, TRUE);
 	event_del (&session->ev);
@@ -725,63 +655,42 @@ ok:
 	if (--(*(session->saved)) == 0) {
 		if (*(session->err) != NULL) {
 			rspamd_controller_send_error (session->http_entry,
-				(*session->err)->code, (*session->err)->message);
+					(*session->err)->code, (*session->err)->message);
 			g_error_free (*session->err);
 		}
 		else {
 			rspamd_controller_send_string (session->http_entry,
-				"{\"success\":true}");
+					"{\"success\":true}");
 		}
 	}
 }
 
 static inline void
-register_fuzzy_call (struct rspamd_task *task,
-	struct fuzzy_rule *rule,
-	fuzzy_hash_t *h)
+register_fuzzy_call (struct rspamd_task *task, struct fuzzy_rule *rule, fuzzy_hash_t *h)
 {
-	struct fuzzy_client_session *session;
-	struct storage_server *selected;
-	gint sock;
+	struct fuzzy_client_session    *session;
+	struct storage_server          *selected;
+	gint                            sock;
 
 	/* Get upstream */
 #ifdef HAVE_CLOCK_GETTIME
-	selected = (struct storage_server *)get_upstream_by_hash (rule->servers,
-			rule->servers_num,
-			sizeof (struct storage_server),
-			task->ts.tv_sec,
-			DEFAULT_UPSTREAM_ERROR_TIME,
-			DEFAULT_UPSTREAM_DEAD_TIME,
-			DEFAULT_UPSTREAM_MAXERRORS,
-			h->hash_pipe,
-			sizeof (h->hash_pipe));
+	selected = (struct storage_server *)get_upstream_by_hash (rule->servers, rule->servers_num,
+			sizeof (struct storage_server), task->ts.tv_sec,
+			DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS,
+			h->hash_pipe, sizeof (h->hash_pipe));
 #else
-	selected = (struct storage_server *)get_upstream_by_hash (rule->servers,
-			rule->servers_num,
-			sizeof (struct storage_server),
-			task->tv.tv_sec,
-			DEFAULT_UPSTREAM_ERROR_TIME,
-			DEFAULT_UPSTREAM_DEAD_TIME,
-			DEFAULT_UPSTREAM_MAXERRORS,
-			h->hash_pipe,
-			sizeof (h->hash_pipe));
+	selected = (struct storage_server *)get_upstream_by_hash (rule->servers, rule->servers_num,
+			sizeof (struct storage_server), task->tv.tv_sec,
+			DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS, h->hash_pipe, sizeof (h->hash_pipe));
 #endif
 	if (selected) {
-		if ((sock =
-			make_universal_socket (selected->addr, selected->port, SOCK_DGRAM,
-			TRUE, FALSE, FALSE)) == -1) {
-			msg_warn ("cannot connect to %s, %d, %s",
-				selected->name,
-				errno,
-				strerror (errno));
+		if ((sock = make_universal_socket (selected->addr, selected->port, SOCK_DGRAM, TRUE, FALSE, FALSE)) == -1) {
+			msg_warn ("cannot connect to %s, %d, %s", selected->name, errno, strerror (errno));
 		}
 		else {
 			/* Create session for a socket */
-			session =
-				rspamd_mempool_alloc (task->task_pool,
-					sizeof (struct fuzzy_client_session));
-			event_set (&session->ev, sock, EV_WRITE, fuzzy_io_callback,
-				session);
+			session = rspamd_mempool_alloc (task->task_pool, sizeof (struct fuzzy_client_session));
+			event_set (&session->ev, sock, EV_WRITE, fuzzy_io_callback, session);
 			msec_to_tv (fuzzy_module_ctx->io_timeout, &session->tv);
 			session->state = 0;
 			session->h = h;
@@ -790,10 +699,7 @@ register_fuzzy_call (struct rspamd_task *task,
 			session->server = selected;
 			session->rule = rule;
 			event_add (&session->ev, &session->tv);
-			register_async_event (task->s,
-				fuzzy_io_fin,
-				session,
-				g_quark_from_static_string ("fuzzy check"));
+			register_async_event (task->s, fuzzy_io_fin, session, g_quark_from_static_string ("fuzzy check"));
 		}
 	}
 }
@@ -801,13 +707,13 @@ register_fuzzy_call (struct rspamd_task *task,
 static void
 fuzzy_check_rule (struct rspamd_task *task, struct fuzzy_rule *rule)
 {
-	struct mime_text_part *part;
-	struct mime_part *mime_part;
-	struct rspamd_image *image;
-	gchar *checksum;
-	gsize hashlen;
-	GList *cur;
-	fuzzy_hash_t *fake_fuzzy;
+	struct mime_text_part          *part;
+	struct mime_part               *mime_part;
+	struct rspamd_image            *image;
+	gchar                           *checksum;
+	gsize                            hashlen;
+	GList                          *cur;
+	fuzzy_hash_t                   *fake_fuzzy;
 
 	cur = task->text_parts;
 
@@ -821,7 +727,7 @@ fuzzy_check_rule (struct rspamd_task *task, struct fuzzy_rule *rule)
 		/* Check length of part */
 		if (fuzzy_module_ctx->min_bytes > part->content->len) {
 			msg_info ("<%s>, part is shorter than %d symbols, skip fuzzy check",
-				task->message_id, fuzzy_module_ctx->min_bytes);
+					task->message_id, fuzzy_module_ctx->min_bytes);
 			cur = g_list_next (cur);
 			continue;
 		}
@@ -829,17 +735,14 @@ fuzzy_check_rule (struct rspamd_task *task, struct fuzzy_rule *rule)
 		hashlen = strlen (part->fuzzy->hash_pipe);
 		if (hashlen == 0) {
 			msg_info ("<%s>, part hash empty, skip fuzzy check",
-				task->message_id, fuzzy_module_ctx->min_hash_len);
+					task->message_id, fuzzy_module_ctx->min_hash_len);
 			cur = g_list_next (cur);
 			continue;
 		}
 		if (fuzzy_module_ctx->min_hash_len != 0 &&
-			hashlen * part->fuzzy->block_size <
-			fuzzy_module_ctx->min_hash_len) {
-			msg_info (
-				"<%s>, part hash is shorter than %d symbols, skip fuzzy check",
-				task->message_id,
-				fuzzy_module_ctx->min_hash_len);
+				hashlen * part->fuzzy->block_size < fuzzy_module_ctx->min_hash_len) {
+			msg_info ("<%s>, part hash is shorter than %d symbols, skip fuzzy check",
+					task->message_id, fuzzy_module_ctx->min_hash_len);
 			cur = g_list_next (cur);
 			continue;
 		}
@@ -854,18 +757,12 @@ fuzzy_check_rule (struct rspamd_task *task, struct fuzzy_rule *rule)
 	while (cur) {
 		image = cur->data;
 		if (image->data->len > 0) {
-			if (fuzzy_module_ctx->min_height <= 0 || image->height >=
-				fuzzy_module_ctx->min_height) {
-				if (fuzzy_module_ctx->min_width <= 0 || image->width >=
-					fuzzy_module_ctx->min_width) {
-					checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
-							image->data->data,
-							image->data->len);
+			if (fuzzy_module_ctx->min_height <= 0 || image->height >= fuzzy_module_ctx->min_height) {
+				if (fuzzy_module_ctx->min_width <= 0 || image->width >= fuzzy_module_ctx->min_width) {
+					checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5, image->data->data, image->data->len);
 					/* Construct fake fuzzy hash */
-					fake_fuzzy = rspamd_mempool_alloc0 (task->task_pool,
-							sizeof (fuzzy_hash_t));
-					rspamd_strlcpy (fake_fuzzy->hash_pipe, checksum,
-						sizeof (fake_fuzzy->hash_pipe));
+					fake_fuzzy = rspamd_mempool_alloc0 (task->task_pool, sizeof (fuzzy_hash_t));
+					rspamd_strlcpy (fake_fuzzy->hash_pipe, checksum, sizeof (fake_fuzzy->hash_pipe));
 					register_fuzzy_call (task, rule, fake_fuzzy);
 					g_free (checksum);
 				}
@@ -877,20 +774,15 @@ fuzzy_check_rule (struct rspamd_task *task, struct fuzzy_rule *rule)
 	cur = task->parts;
 	while (cur) {
 		mime_part = cur->data;
-		if (mime_part->content->len > 0 &&
-			fuzzy_check_content_type (rule, mime_part->type)) {
-			if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >=
-				fuzzy_module_ctx->min_bytes) {
-				checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
-						mime_part->content->data, mime_part->content->len);
-				/* Construct fake fuzzy hash */
-				fake_fuzzy =
-					rspamd_mempool_alloc0 (task->task_pool,
-						sizeof (fuzzy_hash_t));
-				rspamd_strlcpy (fake_fuzzy->hash_pipe, checksum,
-					sizeof (fake_fuzzy->hash_pipe));
-				register_fuzzy_call (task, rule, fake_fuzzy);
-				g_free (checksum);
+		if (mime_part->content->len > 0 && fuzzy_check_content_type (rule, mime_part->type)) {
+			if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >= fuzzy_module_ctx->min_bytes) {
+					checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
+							mime_part->content->data, mime_part->content->len);
+					/* Construct fake fuzzy hash */
+					fake_fuzzy = rspamd_mempool_alloc0 (task->task_pool, sizeof (fuzzy_hash_t));
+					rspamd_strlcpy (fake_fuzzy->hash_pipe, checksum, sizeof (fake_fuzzy->hash_pipe));
+					register_fuzzy_call (task, rule, fake_fuzzy);
+					g_free (checksum);
 			}
 		}
 		cur = g_list_next (cur);
@@ -907,11 +799,9 @@ fuzzy_symbol_callback (struct rspamd_task *task, void *unused)
 	/* Check whitelist */
 	if (fuzzy_module_ctx->whitelist && task->from_addr.af == AF_INET) {
 		if (radix32tree_find (fuzzy_module_ctx->whitelist,
-			ntohl (task->from_addr.addr.s4.sin_addr.s_addr)) !=
-			RADIX_NO_VALUE) {
+				ntohl (task->from_addr.addr.s4.sin_addr.s_addr)) != RADIX_NO_VALUE) {
 			msg_info ("<%s>, address %s is whitelisted, skip fuzzy check",
-				task->message_id,
-				rspamd_inet_address_to_string (&task->from_addr));
+					task->message_id, rspamd_inet_address_to_string (&task->from_addr));
 			return;
 		}
 	}
@@ -926,54 +816,41 @@ fuzzy_symbol_callback (struct rspamd_task *task, void *unused)
 
 static inline gboolean
 register_fuzzy_controller_call (struct rspamd_http_connection_entry *entry,
-	struct fuzzy_rule *rule, struct rspamd_task *task, fuzzy_hash_t *h,
-	gint cmd, gint value, gint flag, gint *saved, GError **err)
+		struct fuzzy_rule *rule, struct rspamd_task *task, fuzzy_hash_t *h,
+		gint cmd, gint value, gint flag, gint *saved, GError **err)
 {
-	struct fuzzy_learn_session *s;
-	struct storage_server *selected;
-	gint sock;
+	struct fuzzy_learn_session     *s;
+	struct storage_server          *selected;
+	gint                            sock;
 
 	/* Get upstream */
 #ifdef HAVE_CLOCK_GETTIME
-	selected = (struct storage_server *)get_upstream_by_hash (rule->servers,
-			rule->servers_num,
-			sizeof (struct storage_server),
-			task->ts.tv_sec,
-			DEFAULT_UPSTREAM_ERROR_TIME,
-			DEFAULT_UPSTREAM_DEAD_TIME,
-			DEFAULT_UPSTREAM_MAXERRORS,
-			h->hash_pipe,
-			sizeof (h->hash_pipe));
+	selected = (struct storage_server *)get_upstream_by_hash (rule->servers, rule->servers_num,
+			sizeof (struct storage_server), task->ts.tv_sec,
+			DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS,
+			h->hash_pipe, sizeof (h->hash_pipe));
 #else
-	selected = (struct storage_server *)get_upstream_by_hash (rule->servers,
-			rule->servers_num,
-			sizeof (struct storage_server),
-			task->tv.tv_sec,
-			DEFAULT_UPSTREAM_ERROR_TIME,
-			DEFAULT_UPSTREAM_DEAD_TIME,
-			DEFAULT_UPSTREAM_MAXERRORS,
-			h->hash_pipe,
-			sizeof (h->hash_pipe));
+	selected = (struct storage_server *)get_upstream_by_hash (rule->servers, rule->servers_num,
+			sizeof (struct storage_server), task->tv.tv_sec,
+			DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS,
+			h->hash_pipe, sizeof (h->hash_pipe));
 #endif
 	if (selected) {
 		/* Create UDP socket */
 		if ((sock = make_universal_socket (selected->addr, selected->port,
-			SOCK_DGRAM, TRUE, FALSE, FALSE)) == -1) {
+				SOCK_DGRAM, TRUE, FALSE, FALSE)) == -1) {
 			return FALSE;
 		}
 		else {
 			/* Socket is made, create session */
-			s =
-				rspamd_mempool_alloc (task->task_pool,
-					sizeof (struct fuzzy_learn_session));
+			s = rspamd_mempool_alloc (task->task_pool, sizeof (struct fuzzy_learn_session));
 			event_set (&s->ev, sock, EV_WRITE, fuzzy_learn_callback, s);
 			event_base_set (entry->rt->ev_base, &s->ev);
 			msec_to_tv (fuzzy_module_ctx->io_timeout, &s->tv);
 			s->task = task;
-			s->h =
-				rspamd_mempool_alloc (task->task_pool, sizeof (fuzzy_hash_t));
+			s->h = rspamd_mempool_alloc (task->task_pool, sizeof (fuzzy_hash_t));
 			memcpy (s->h, h, sizeof (fuzzy_hash_t));
-			s->http_entry = entry;
+			s->http_entry =entry;
 			s->server = selected;
 			s->cmd = cmd;
 			s->value = value;
@@ -994,46 +871,38 @@ register_fuzzy_controller_call (struct rspamd_http_connection_entry *entry,
 }
 
 static int
-fuzzy_process_rule (struct rspamd_http_connection_entry *entry,
-	struct fuzzy_rule *rule,
-	struct rspamd_task *task,
-	GError **err,
-	gint cmd,
-	gint flag,
-	gint value,
-	gint *saved)
+fuzzy_process_rule (struct rspamd_http_connection_entry *entry, struct fuzzy_rule *rule,
+		struct rspamd_task *task, GError **err, gint cmd, gint flag, gint value, gint *saved)
 {
-	struct mime_text_part *part;
-	struct mime_part *mime_part;
-	struct rspamd_image *image;
-	GList *cur;
-	gchar *checksum;
-	fuzzy_hash_t fake_fuzzy;
-	gint processed = 0;
+	struct mime_text_part          *part;
+	struct mime_part               *mime_part;
+	struct rspamd_image            *image;
+	GList                           *cur;
+	gchar                           *checksum;
+	fuzzy_hash_t                    fake_fuzzy;
+	gint                            processed = 0;
 
 	/* Plan new event for writing */
 	cur = task->text_parts;
 
 	while (cur) {
 		part = cur->data;
-		if (part->is_empty || part->fuzzy == NULL ||
-			part->fuzzy->hash_pipe[0] == '\0' ||
-			(fuzzy_module_ctx->min_bytes > 0 && part->content->len <
-			fuzzy_module_ctx->min_bytes)) {
+		if (part->is_empty || part->fuzzy == NULL || part->fuzzy->hash_pipe[0] == '\0' ||
+				(fuzzy_module_ctx->min_bytes > 0 && part->content->len < fuzzy_module_ctx->min_bytes)) {
 			/* Skip empty parts */
 			cur = g_list_next (cur);
 			continue;
 		}
-		if (!register_fuzzy_controller_call (entry, rule, task,
-			part->fuzzy, cmd, value, flag, saved, err)) {
+		if (! register_fuzzy_controller_call (entry, rule, task,
+				part->fuzzy, cmd, value, flag, saved, err)) {
 			goto err;
 		}
-		if (!register_fuzzy_controller_call (entry, rule, task,
-			part->double_fuzzy, cmd, value, flag, saved, err)) {
+		if (! register_fuzzy_controller_call (entry, rule, task,
+				part->double_fuzzy, cmd, value, flag, saved, err)) {
 			/* Cannot write hash */
 			goto err;
 		}
-		processed++;
+		processed ++;
 		cur = g_list_next (cur);
 	}
 
@@ -1042,30 +911,22 @@ fuzzy_process_rule (struct rspamd_http_connection_entry *entry,
 	while (cur) {
 		image = cur->data;
 		if (image->data->len > 0) {
-			if (fuzzy_module_ctx->min_height <= 0 || image->height >=
-				fuzzy_module_ctx->min_height) {
-				if (fuzzy_module_ctx->min_width <= 0 || image->width >=
-					fuzzy_module_ctx->min_width) {
-					checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
-							image->data->data,
-							image->data->len);
+			if (fuzzy_module_ctx->min_height <= 0 || image->height >= fuzzy_module_ctx->min_height) {
+				if (fuzzy_module_ctx->min_width <= 0 || image->width >= fuzzy_module_ctx->min_width) {
+					checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5, image->data->data, image->data->len);
 					/* Construct fake fuzzy hash */
 					fake_fuzzy.block_size = 0;
-					memset (fake_fuzzy.hash_pipe, 0,
-						sizeof (fake_fuzzy.hash_pipe));
-					rspamd_strlcpy (fake_fuzzy.hash_pipe, checksum,
-						sizeof (fake_fuzzy.hash_pipe));
-					if (!register_fuzzy_controller_call (entry, rule, task,
-						&fake_fuzzy, cmd, value, flag, saved, err)) {
+					memset (fake_fuzzy.hash_pipe, 0, sizeof (fake_fuzzy.hash_pipe));
+					rspamd_strlcpy (fake_fuzzy.hash_pipe, checksum, sizeof (fake_fuzzy.hash_pipe));
+					if (! register_fuzzy_controller_call (entry, rule, task,
+							&fake_fuzzy, cmd, value, flag, saved, err)) {
 						g_free (checksum);
 						goto err;
 					}
 
-					msg_info ("save hash of image: [%s] to list: %d",
-						checksum,
-						flag);
+					msg_info ("save hash of image: [%s] to list: %d", checksum, flag);
 					g_free (checksum);
-					processed++;
+					processed ++;
 				}
 			}
 		}
@@ -1075,26 +936,23 @@ fuzzy_process_rule (struct rspamd_http_connection_entry *entry,
 	cur = task->parts;
 	while (cur) {
 		mime_part = cur->data;
-		if (mime_part->content->len > 0 &&
-			fuzzy_check_content_type (rule, mime_part->type)) {
-			if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >=
-				fuzzy_module_ctx->min_bytes) {
+		if (mime_part->content->len > 0 && fuzzy_check_content_type (rule, mime_part->type)) {
+			if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >= fuzzy_module_ctx->min_bytes) {
 				checksum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
 						mime_part->content->data, mime_part->content->len);
 				/* Construct fake fuzzy hash */
 				fake_fuzzy.block_size = 0;
 				memset (fake_fuzzy.hash_pipe, 0, sizeof (fake_fuzzy.hash_pipe));
-				rspamd_strlcpy (fake_fuzzy.hash_pipe, checksum,
-					sizeof (fake_fuzzy.hash_pipe));
-				if (!register_fuzzy_controller_call (entry, rule, task,
-					&fake_fuzzy, cmd, value, flag, saved, err)) {
+				rspamd_strlcpy (fake_fuzzy.hash_pipe, checksum, sizeof (fake_fuzzy.hash_pipe));
+				if (! register_fuzzy_controller_call (entry, rule, task,
+						&fake_fuzzy, cmd, value, flag, saved, err)) {
 					goto err;
 				}
 				msg_info ("save hash of part of type: %s/%s: [%s] to list %d",
-					mime_part->type->type, mime_part->type->subtype,
-					checksum, flag);
+						mime_part->type->type, mime_part->type->subtype,
+						checksum, flag);
 				g_free (checksum);
-				processed++;
+				processed ++;
 			}
 		}
 		cur = g_list_next (cur);
@@ -1109,8 +967,8 @@ err:
 
 static void
 fuzzy_process_handler (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg, gint cmd, gint value, gint flag,
-	struct fuzzy_ctx *ctx)
+		struct rspamd_http_message *msg, gint cmd, gint value, gint flag,
+		struct fuzzy_ctx *ctx)
 {
 	struct fuzzy_rule *rule;
 	gboolean processed = FALSE, res = TRUE;
@@ -1132,8 +990,7 @@ fuzzy_process_handler (struct rspamd_http_connection_entry *conn_ent,
 	if (r == -1) {
 		msg_warn ("cannot process message for fuzzy");
 		rspamd_task_free (task, FALSE);
-		rspamd_controller_send_error (conn_ent, 400,
-			"Message processing error");
+		rspamd_controller_send_error (conn_ent, 400, "Message processing error");
 		return;
 	}
 	cur = fuzzy_module_ctx->fuzzy_rules;
@@ -1146,8 +1003,7 @@ fuzzy_process_handler (struct rspamd_http_connection_entry *conn_ent,
 		}
 
 		/* Check for flag */
-		if (g_hash_table_lookup (rule->mappings,
-			GINT_TO_POINTER (flag)) == NULL) {
+		if (g_hash_table_lookup (rule->mappings, GINT_TO_POINTER (flag)) == NULL) {
 			cur = g_list_next (cur);
 			continue;
 		}
@@ -1183,11 +1039,11 @@ fuzzy_process_handler (struct rspamd_http_connection_entry *conn_ent,
 
 static gboolean
 fuzzy_controller_handler (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg, struct module_ctx *ctx, gint cmd)
+		struct rspamd_http_message *msg, struct module_ctx *ctx, gint cmd)
 {
 	const gchar *arg;
 	gchar *err_str;
-	gint value = 1, flag = 0;
+	gint                            value = 1, flag = 0;
 
 	/* Get size */
 	arg = rspamd_http_message_find_header (msg, "Value");
@@ -1210,25 +1066,25 @@ fuzzy_controller_handler (struct rspamd_http_connection_entry *conn_ent,
 	}
 
 	fuzzy_process_handler (conn_ent, msg, cmd, value, flag,
-		(struct fuzzy_ctx *)ctx);
+			(struct fuzzy_ctx *)ctx);
 
 	return 0;
 }
 
 static gboolean
 fuzzy_add_handler (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg, struct module_ctx *ctx)
+		struct rspamd_http_message *msg, struct module_ctx *ctx)
 {
 	return fuzzy_controller_handler (conn_ent, msg,
-			   ctx, FUZZY_WRITE);
+			ctx, FUZZY_WRITE);
 }
 
 static gboolean
 fuzzy_delete_handler (struct rspamd_http_connection_entry *conn_ent,
-	struct rspamd_http_message *msg, struct module_ctx *ctx)
+		struct rspamd_http_message *msg, struct module_ctx *ctx)
 {
 	return fuzzy_controller_handler (conn_ent, msg,
-			   ctx, FUZZY_DEL);
+			ctx, FUZZY_DEL);
 }
 
 static int
diff --git a/src/plugins/regexp.c b/src/plugins/regexp.c
index 0559b61b3..bddde5383 100644
--- a/src/plugins/regexp.c
+++ b/src/plugins/regexp.c
@@ -27,95 +27,75 @@
  */
 
 
-#include "cfg_file.h"
 #include "config.h"
-#include "expressions.h"
-#include "json/jansson.h"
-#include "lua/lua_common.h"
 #include "main.h"
-#include "map.h"
 #include "message.h"
+#include "cfg_file.h"
+#include "map.h"
 #include "util.h"
+#include "expressions.h"
+#include "lua/lua_common.h"
+#include "json/jansson.h"
 
 #define DEFAULT_STATFILE_PREFIX "./"
 
 struct regexp_module_item {
-	struct expression *expr;
-	const gchar *symbol;
-	guint32 avg_time;
-	gpointer lua_function;
+	struct expression               *expr;
+	const gchar                           *symbol;
+	guint32                         avg_time;
+	gpointer                        lua_function;
 };
 
 struct autolearn_data {
-	gchar *statfile_name;
-	gchar *symbol;
-	float weight;
+	gchar                           *statfile_name;
+	gchar                           *symbol;
+	float                           weight;
 };
 
 struct regexp_ctx {
-	gint (*filter) (struct rspamd_task * task);
-	GHashTable *autolearn_symbols;
-	gchar *statfile_prefix;
-
-	rspamd_mempool_t *regexp_pool;
-	rspamd_mempool_t *dynamic_pool;
-	gsize max_size;
-	gsize max_threads;
-	GThreadPool *workers;
+	gint                          (*filter) (struct rspamd_task * task);
+	GHashTable                     *autolearn_symbols;
+	gchar                          *statfile_prefix;
+
+	rspamd_mempool_t                  *regexp_pool;
+	rspamd_mempool_t                  *dynamic_pool;
+	gsize                           max_size;
+	gsize							max_threads;
+	GThreadPool					   *workers;
 };
 
 struct regexp_json_buf {
-	gchar *buf;
-	gchar *pos;
-	size_t buflen;
-	struct rspamd_config *cfg;
+	gchar                          *buf;
+	gchar                          *pos;
+	size_t                          buflen;
+	struct rspamd_config             *cfg;
 };
 
 /* Lua regexp module for checking rspamd regexps */
 LUA_FUNCTION_DEF (regexp, match);
 
-static const struct luaL_reg regexplib_m[] = {
+static const struct luaL_reg    regexplib_m[] = {
 	LUA_INTERFACE_DEF (regexp, match),
 	{"__tostring", lua_class_tostring},
 	{NULL, NULL}
 };
 
-static struct regexp_ctx *regexp_module_ctx = NULL;
-static GMutex *workers_mtx = NULL;
-
-static gint regexp_common_filter (struct rspamd_task *task);
-static void process_regexp_item_threaded (gpointer data, gpointer user_data);
-static gboolean rspamd_regexp_match_number (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_raw_header_exists (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_check_smtp_data (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_regexp_occurs_number (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_content_type_is_type (struct rspamd_task * task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_content_type_is_subtype (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_content_type_has_param (struct rspamd_task * task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_content_type_compare_param (struct rspamd_task * task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_has_content_part (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-static gboolean rspamd_has_content_part_len (struct rspamd_task *task,
-	GList * args,
-	void *unused);
-static void process_regexp_item (struct rspamd_task *task, void *user_data);
+static struct regexp_ctx       *regexp_module_ctx = NULL;
+static GMutex 				   *workers_mtx = NULL;
+
+static gint                     regexp_common_filter (struct rspamd_task *task);
+static void				     process_regexp_item_threaded (gpointer data, gpointer user_data);
+static gboolean                 rspamd_regexp_match_number (struct rspamd_task *task, GList * args, void *unused);
+static gboolean                 rspamd_raw_header_exists (struct rspamd_task *task, GList * args, void *unused);
+static gboolean                 rspamd_check_smtp_data (struct rspamd_task *task, GList * args, void *unused);
+static gboolean                 rspamd_regexp_occurs_number (struct rspamd_task *task, GList * args, void *unused);
+static gboolean                 rspamd_content_type_is_type (struct rspamd_task * task, GList * args, void *unused);
+static gboolean                 rspamd_content_type_is_subtype (struct rspamd_task *task, GList * args, void *unused);
+static gboolean                 rspamd_content_type_has_param (struct rspamd_task * task, GList * args, void *unused);
+static gboolean                 rspamd_content_type_compare_param (struct rspamd_task * task, GList * args, void *unused);
+static gboolean                 rspamd_has_content_part (struct rspamd_task *task, GList * args, void *unused);
+static gboolean                 rspamd_has_content_part_len (struct rspamd_task *task, GList * args, void *unused);
+static void                    process_regexp_item (struct rspamd_task *task, void *user_data);
 
 
 /* Initialization */
@@ -133,15 +113,13 @@ module_t regexp_module = {
 
 /* Task cache functions */
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
-static GStaticMutex task_cache_mtx = G_STATIC_MUTEX_INIT;
+static GStaticMutex task_cache_mtx =  G_STATIC_MUTEX_INIT;
 #else
 G_LOCK_DEFINE (task_cache_mtx);
 #endif
 
 void
-task_cache_add (struct rspamd_task *task,
-	struct rspamd_regexp *re,
-	gint32 result)
+task_cache_add (struct rspamd_task *task, struct rspamd_regexp *re, gint32 result)
 {
 	if (result == 0) {
 		result = -1;
@@ -152,8 +130,7 @@ task_cache_add (struct rspamd_task *task,
 #else
 	G_LOCK (task_cache_mtx);
 #endif
-	g_hash_table_insert (task->re_cache, re->regexp_text,
-		GINT_TO_POINTER (result));
+	g_hash_table_insert (task->re_cache, re->regexp_text, GINT_TO_POINTER (result));
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
 	g_static_mutex_unlock (&task_cache_mtx);
 #else
@@ -164,8 +141,8 @@ task_cache_add (struct rspamd_task *task,
 gint32
 task_cache_check (struct rspamd_task *task, struct rspamd_regexp *re)
 {
-	gpointer res;
-	gint32 r;
+	gpointer                        res;
+	gint32                          r;
 
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
 	g_static_mutex_lock (&task_cache_mtx);
@@ -201,11 +178,11 @@ luaopen_regexp (lua_State * L)
 	return 1;
 }
 
-static void
+static void 
 regexp_dynamic_insert_result (struct rspamd_task *task, void *user_data)
 {
-	gchar *symbol = user_data;
-
+	gchar                           *symbol = user_data;
+		
 	insert_result (task, symbol, 1, NULL);
 }
 
@@ -245,18 +222,18 @@ op_less_equal (gint a, gint b)
 static gboolean
 parse_regexp_ipmask (const gchar *begin, struct dynamic_map_item *addr)
 {
-	const gchar *pos;
-	gchar ip_buf[sizeof ("255.255.255.255")], mask_buf[3], *p;
-	gint state = 0, dots = 0;
-
-	bzero (ip_buf,	 sizeof (ip_buf));
+	const gchar                    *pos;
+	gchar                           ip_buf[sizeof ("255.255.255.255")], mask_buf[3], *p;
+	gint                            state = 0, dots = 0;
+	
+	bzero (ip_buf, sizeof (ip_buf));
 	bzero (mask_buf, sizeof (mask_buf));
 	pos = begin;
 	p = ip_buf;
 
 	if (*pos == '!') {
 		addr->negative = TRUE;
-		pos++;
+		pos ++;
 	}
 	else {
 		addr->negative = FALSE;
@@ -264,45 +241,45 @@ parse_regexp_ipmask (const gchar *begin, struct dynamic_map_item *addr)
 
 	while (*pos) {
 		switch (state) {
-		case 0:
-			state = 1;
-			p = ip_buf;
-			dots = 0;
-			break;
-		case 1:
-			/* Begin parse ip */
-			if (p - ip_buf >= (gint)sizeof (ip_buf) || dots > 3) {
-				return FALSE;
-			}
-			if (g_ascii_isdigit (*pos)) {
-				*p++ = *pos++;
-			}
-			else if (*pos == '.') {
-				*p++ = *pos++;
-				dots++;
-			}
-			else if (*pos == '/') {
-				pos++;
-				p = mask_buf;
-				state = 2;
-			}
-			else {
-				/* Invalid character */
-				return FALSE;
-			}
-			break;
-		case 2:
-			/* Parse mask */
-			if (p - mask_buf > 2) {
-				return FALSE;
-			}
-			if (g_ascii_isdigit (*pos)) {
-				*p++ = *pos++;
-			}
-			else {
-				return FALSE;
-			}
-			break;
+			case 0:
+				state = 1;
+				p = ip_buf;
+				dots = 0;
+				break;
+			case 1:
+				/* Begin parse ip */
+				if (p - ip_buf >= (gint)sizeof (ip_buf) || dots > 3) {
+					return FALSE;
+				}
+				if (g_ascii_isdigit (*pos)) {
+					*p ++ = *pos ++;
+				}
+				else if (*pos == '.') {
+					*p ++ = *pos ++;
+					dots ++;
+				}
+				else if (*pos == '/') {
+					pos ++;
+					p = mask_buf;
+					state = 2;
+				}
+				else {
+					/* Invalid character */
+					return FALSE;
+				}
+				break;
+			case 2:
+				/* Parse mask */
+				if (p - mask_buf > 2) {
+					return FALSE;
+				}
+				if (g_ascii_isdigit (*pos)) {
+					*p ++ = *pos ++;
+				}
+				else {
+					return FALSE;
+				}
+				break;
 		}
 	}
 
@@ -326,14 +303,11 @@ parse_regexp_ipmask (const gchar *begin, struct dynamic_map_item *addr)
 }
 
 /* Process regexp expression */
-static gboolean
-read_regexp_expression (rspamd_mempool_t * pool,
-	struct regexp_module_item *chain,
-	const gchar *symbol,
-	const gchar *line,
-	gboolean raw_mode)
+static                          gboolean
+read_regexp_expression (rspamd_mempool_t * pool, struct regexp_module_item *chain,
+		const gchar *symbol, const gchar *line, gboolean raw_mode)
 {
-	struct expression *e, *cur;
+	struct expression              *e, *cur;
 
 	e = parse_expression (pool, (gchar *)line);
 	if (e == NULL) {
@@ -344,13 +318,9 @@ read_regexp_expression (rspamd_mempool_t * pool,
 	cur = e;
 	while (cur) {
 		if (cur->type == EXPR_REGEXP) {
-			cur->content.operand = parse_regexp (pool,
-					cur->content.operand,
-					raw_mode);
+			cur->content.operand = parse_regexp (pool, cur->content.operand, raw_mode);
 			if (cur->content.operand == NULL) {
-				msg_warn ("cannot parse regexp, skip expression %s = \"%s\"",
-					symbol,
-					line);
+				msg_warn ("cannot parse regexp, skip expression %s = \"%s\"", symbol, line);
 				return FALSE;
 			}
 			cur->type = EXPR_REGEXP_PARSED;
@@ -363,14 +333,11 @@ read_regexp_expression (rspamd_mempool_t * pool,
 
 
 /* Callbacks for reading json dynamic rules */
-gchar *
-json_regexp_read_cb (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data)
+gchar                         *
+json_regexp_read_cb (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
 {
-	struct regexp_json_buf *jb;
-	gint free, off;
+	struct regexp_json_buf                *jb;
+	gint                            free, off;
 
 	if (data->cur_data == NULL) {
 		jb = g_malloc (sizeof (struct regexp_json_buf));
@@ -409,16 +376,16 @@ json_regexp_read_cb (rspamd_mempool_t * pool,
 void
 json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 {
-	struct regexp_json_buf *jb;
-	guint nelts, i, j;
-	json_t *js, *cur_elt, *cur_nm, *it_val;
-	json_error_t je;
-	gchar *cur_rule, *cur_symbol;
-	double score;
-	struct regexp_module_item *cur_item;
-	GList *cur_networks = NULL;
-	struct dynamic_map_item *cur_nitem;
-	rspamd_mempool_t *new_pool;
+	struct regexp_json_buf         *jb;
+	guint                           nelts, i, j;
+	json_t                         *js, *cur_elt, *cur_nm, *it_val;
+	json_error_t                    je;
+	gchar                           *cur_rule, *cur_symbol;
+	double                          score;
+	struct regexp_module_item      *cur_item;
+	GList                          *cur_networks = NULL;
+	struct dynamic_map_item        *cur_nitem;
+	rspamd_mempool_t                  *new_pool;
 
 	if (data->prev_data) {
 		jb = data->prev_data;
@@ -446,9 +413,7 @@ json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 
 	js = json_loads (jb->buf, &je);
 	if (!js) {
-		msg_err ("cannot load json data: parse error %s, on line %d",
-			je.text,
-			je.line);
+		msg_err ("cannot load json data: parse error %s, on line %d", je.text, je.line);
 		return;
 	}
 
@@ -457,9 +422,9 @@ json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 		msg_err ("loaded json is not an array");
 		return;
 	}
-
+	
 	new_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
-
+		
 	remove_dynamic_rules (jb->cfg->cache);
 	if (regexp_module_ctx->dynamic_pool != NULL) {
 		rspamd_mempool_delete (regexp_module_ctx->dynamic_pool);
@@ -482,15 +447,14 @@ json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 			msg_err ("factor is not a number or not exists, but is required");
 			continue;
 		}
-		score = json_number_value (cur_nm);
+		score = json_number_value (cur_nm); 
 		/* Symbol param */
 		cur_nm = json_object_get (cur_elt, "symbol");
 		if (cur_nm == NULL || !json_is_string (cur_nm)) {
 			msg_err ("symbol is not a string or not exists, but is required");
 			continue;
 		}
-		cur_symbol =
-			rspamd_mempool_strdup (new_pool, json_string_value (cur_nm));
+		cur_symbol = rspamd_mempool_strdup (new_pool, json_string_value (cur_nm)); 
 		/* Enabled flag */
 		cur_nm = json_object_get (cur_elt, "enabled");
 		if (cur_nm != NULL && json_is_boolean (cur_nm)) {
@@ -503,8 +467,7 @@ json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 		/* Rule */
 		cur_nm = json_object_get (cur_elt, "rule");
 		if (cur_nm != NULL && json_is_string (cur_nm)) {
-			cur_rule =
-				rspamd_mempool_strdup (new_pool, json_string_value (cur_nm));
+			cur_rule = rspamd_mempool_strdup (new_pool, json_string_value (cur_nm));
 		}
 		/* Networks array */
 		cur_nm = json_object_get (cur_elt, "networks");
@@ -512,11 +475,8 @@ json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 			for (j = 0; j < json_array_size (cur_nm); j++) {
 				it_val = json_array_get (cur_nm, i);
 				if (it_val && json_is_string (it_val)) {
-					cur_nitem =
-						rspamd_mempool_alloc (new_pool,
-							sizeof (struct dynamic_map_item));
-					if (parse_regexp_ipmask (json_string_value (it_val),
-						cur_nitem)) {
+					cur_nitem = rspamd_mempool_alloc (new_pool, sizeof (struct dynamic_map_item));
+					if (parse_regexp_ipmask (json_string_value (it_val), cur_nitem)) {
 						cur_networks = g_list_prepend (cur_networks, cur_nitem);
 					}
 				}
@@ -524,19 +484,10 @@ json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 		}
 		if (cur_rule) {
 			/* Dynamic rule has rule option */
-			cur_item =
-				rspamd_mempool_alloc0 (new_pool,
-					sizeof (struct regexp_module_item));
+			cur_item = rspamd_mempool_alloc0 (new_pool, sizeof (struct regexp_module_item));
 			cur_item->symbol = cur_symbol;
-			if (read_regexp_expression (new_pool, cur_item, cur_symbol,
-				cur_rule, jb->cfg->raw_mode)) {
-				register_dynamic_symbol (new_pool,
-					&jb->cfg->cache,
-					cur_symbol,
-					score,
-					process_regexp_item,
-					cur_item,
-					cur_networks);
+			if (read_regexp_expression (new_pool, cur_item, cur_symbol, cur_rule, jb->cfg->raw_mode)) {
+				register_dynamic_symbol (new_pool, &jb->cfg->cache, cur_symbol, score, process_regexp_item, cur_item, cur_networks);
 			}
 			else {
 				msg_warn ("cannot parse dynamic rule");
@@ -544,13 +495,7 @@ json_regexp_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
 		}
 		else {
 			/* Just rule that is allways true (for whitelisting for example) */
-			register_dynamic_symbol (new_pool,
-				&jb->cfg->cache,
-				cur_symbol,
-				score,
-				regexp_dynamic_insert_result,
-				cur_symbol,
-				cur_networks);
+			register_dynamic_symbol (new_pool, &jb->cfg->cache, cur_symbol, score, regexp_dynamic_insert_result, cur_symbol, cur_networks);
 		}
 		if (cur_networks) {
 			g_list_free (cur_networks);
@@ -565,44 +510,22 @@ regexp_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 {
 	regexp_module_ctx = g_malloc (sizeof (struct regexp_ctx));
 
-	regexp_module_ctx->regexp_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	regexp_module_ctx->regexp_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 	regexp_module_ctx->dynamic_pool = NULL;
-	regexp_module_ctx->autolearn_symbols = g_hash_table_new (rspamd_str_hash,
-			rspamd_str_equal);
+	regexp_module_ctx->autolearn_symbols = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
 	regexp_module_ctx->workers = NULL;
 
 	*ctx = (struct module_ctx *)regexp_module_ctx;
-	register_expression_function ("regexp_match_number",
-		rspamd_regexp_match_number,
-		NULL);
-	register_expression_function ("regexp_occurs_number",
-		rspamd_regexp_occurs_number,
-		NULL);
-	register_expression_function ("raw_header_exists",
-		rspamd_raw_header_exists,
-		NULL);
-	register_expression_function ("check_smtp_data",
-		rspamd_check_smtp_data,
-		NULL);
-	register_expression_function ("content_type_is_type",
-		rspamd_content_type_is_type,
-		NULL);
-	register_expression_function ("content_type_is_subtype",
-		rspamd_content_type_is_subtype,
-		NULL);
-	register_expression_function ("content_type_has_param",
-		rspamd_content_type_has_param,
-		NULL);
-	register_expression_function ("content_type_compare_param",
-		rspamd_content_type_compare_param,
-		NULL);
-	register_expression_function ("has_content_part",
-		rspamd_has_content_part,
-		NULL);
-	register_expression_function ("has_content_part_len",
-		rspamd_has_content_part_len,
-		NULL);
+	register_expression_function ("regexp_match_number", rspamd_regexp_match_number, NULL);
+	register_expression_function ("regexp_occurs_number", rspamd_regexp_occurs_number, NULL);
+	register_expression_function ("raw_header_exists", rspamd_raw_header_exists, NULL);
+	register_expression_function ("check_smtp_data", rspamd_check_smtp_data, NULL);
+	register_expression_function ("content_type_is_type", rspamd_content_type_is_type, NULL);
+	register_expression_function ("content_type_is_subtype", rspamd_content_type_is_subtype, NULL);
+	register_expression_function ("content_type_has_param", rspamd_content_type_has_param, NULL);
+	register_expression_function ("content_type_compare_param", rspamd_content_type_compare_param, NULL);
+	register_expression_function ("has_content_part", rspamd_has_content_part, NULL);
+	register_expression_function ("has_content_part_len", rspamd_has_content_part_len, NULL);
 
 	(void)luaopen_regexp (cfg->lua_state);
 
@@ -610,22 +533,18 @@ regexp_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 }
 
 
-/*
+/* 
  * Parse string in format:
  * SYMBOL:statfile:weight
  */
 void
-parse_autolearn_param (const gchar *param,
-	const gchar *value,
-	struct rspamd_config *cfg)
+parse_autolearn_param (const gchar *param, const gchar *value, struct rspamd_config *cfg)
 {
-	struct autolearn_data *d;
-	gchar *p;
+	struct autolearn_data          *d;
+	gchar                           *p;
 
 	p = rspamd_mempool_strdup (regexp_module_ctx->regexp_pool, value);
-	d =
-		rspamd_mempool_alloc (regexp_module_ctx->regexp_pool,
-			sizeof (struct autolearn_data));
+	d = rspamd_mempool_alloc (regexp_module_ctx->regexp_pool, sizeof (struct autolearn_data));
 
 	d->symbol = strsep (&p, ":");
 	if (d->symbol) {
@@ -633,9 +552,7 @@ parse_autolearn_param (const gchar *param,
 		if (d->statfile_name) {
 			if (p != NULL && *p != '\0') {
 				d->weight = strtod (p, NULL);
-				g_hash_table_insert (regexp_module_ctx->autolearn_symbols,
-					d->symbol,
-					d);
+				g_hash_table_insert (regexp_module_ctx->autolearn_symbols, d->symbol, d);
 			}
 		}
 		else {
@@ -650,11 +567,11 @@ parse_autolearn_param (const gchar *param,
 gint
 regexp_module_config (struct rspamd_config *cfg)
 {
-	struct regexp_module_item *cur_item;
-	const ucl_object_t *sec, *value;
-	ucl_object_iter_t it = NULL;
-	gint res = TRUE;
-	struct regexp_json_buf *jb, **pjb;
+	struct regexp_module_item      *cur_item;
+	const ucl_object_t             *sec, *value;
+	ucl_object_iter_t               it = NULL;
+	gint                            res = TRUE;
+	struct regexp_json_buf         *jb, **pjb;
 
 
 	sec = ucl_object_find_key (cfg->rcl_obj, "regexp");
@@ -668,61 +585,44 @@ regexp_module_config (struct rspamd_config *cfg)
 	regexp_module_ctx->workers = NULL;
 
 	while ((value = ucl_iterate_object (sec, &it, true)) != NULL) {
-		if (g_ascii_strncasecmp (ucl_object_key (value), "autolearn",
-			sizeof ("autolearn") - 1) == 0) {
-			parse_autolearn_param (ucl_object_key (value),
-				ucl_obj_tostring (value), cfg);
+		if (g_ascii_strncasecmp (ucl_object_key (value), "autolearn", sizeof ("autolearn") - 1) == 0) {
+			parse_autolearn_param (ucl_object_key (value), ucl_obj_tostring (value), cfg);
 		}
-		else if (g_ascii_strncasecmp (ucl_object_key (value), "dynamic_rules",
-			sizeof ("dynamic_rules") - 1) == 0) {
+		else if (g_ascii_strncasecmp (ucl_object_key (value), "dynamic_rules", sizeof ("dynamic_rules") - 1) == 0) {
 			jb = g_malloc (sizeof (struct regexp_json_buf));
 			pjb = g_malloc (sizeof (struct regexp_json_buf *));
 			jb->buf = NULL;
 			jb->cfg = cfg;
 			*pjb = jb;
 			if (!add_map (cfg, ucl_obj_tostring (value),
-				"Dynamic regexp rules", json_regexp_read_cb, json_regexp_fin_cb,
-				(void **)pjb)) {
+					"Dynamic regexp rules", json_regexp_read_cb, json_regexp_fin_cb,
+					(void **)pjb)) {
 				msg_err ("cannot add map %s", ucl_obj_tostring (value));
 			}
 		}
-		else if (g_ascii_strncasecmp (ucl_object_key (value), "max_size",
-			sizeof ("max_size") - 1) == 0) {
+		else if (g_ascii_strncasecmp (ucl_object_key (value), "max_size", sizeof ("max_size") - 1) == 0) {
 			regexp_module_ctx->max_size = ucl_obj_toint (value);
 		}
-		else if (g_ascii_strncasecmp (ucl_object_key (value), "max_threads",
-			sizeof ("max_threads") - 1) == 0) {
+		else if (g_ascii_strncasecmp (ucl_object_key (value), "max_threads", sizeof ("max_threads") - 1) == 0) {
 			regexp_module_ctx->max_threads = ucl_obj_toint (value);
 		}
 		else if (value->type == UCL_STRING) {
-			cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool,
-					sizeof (struct regexp_module_item));
+			cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool, sizeof (struct regexp_module_item));
 			cur_item->symbol = ucl_object_key (value);
-			if (!read_regexp_expression (regexp_module_ctx->regexp_pool,
-				cur_item, ucl_object_key (value),
-				ucl_obj_tostring (value), cfg->raw_mode)) {
+			if (!read_regexp_expression (regexp_module_ctx->regexp_pool, cur_item, ucl_object_key (value),
+					ucl_obj_tostring (value), cfg->raw_mode)) {
 				res = FALSE;
 			}
-			register_symbol (&cfg->cache,
-				cur_item->symbol,
-				1,
-				process_regexp_item,
-				cur_item);
+			register_symbol (&cfg->cache, cur_item->symbol, 1, process_regexp_item, cur_item);
 		}
 		else if (value->type == UCL_USERDATA) {
-			cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool,
-					sizeof (struct regexp_module_item));
+			cur_item = rspamd_mempool_alloc0 (regexp_module_ctx->regexp_pool, sizeof (struct regexp_module_item));
 			cur_item->symbol = ucl_object_key (value);
 			cur_item->lua_function = value->value.ud;
-			register_symbol (&cfg->cache,
-				cur_item->symbol,
-				1,
-				process_regexp_item,
-				cur_item);
+			register_symbol (&cfg->cache, cur_item->symbol, 1, process_regexp_item, cur_item);
 		}
 		else {
-			msg_warn ("unknown type of attribute %s for regexp module",
-				ucl_object_key (value));
+			msg_warn ("unknown type of attribute %s for regexp module", ucl_object_key (value));
 		}
 	}
 
@@ -733,72 +633,63 @@ gint
 regexp_module_reconfig (struct rspamd_config *cfg)
 {
 	rspamd_mempool_delete (regexp_module_ctx->regexp_pool);
-	regexp_module_ctx->regexp_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	regexp_module_ctx->regexp_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 	return regexp_module_config (cfg);
 }
 
 struct url_regexp_param {
-	struct rspamd_task *task;
-	GRegex *regexp;
-	struct rspamd_regexp *re;
-	gboolean found;
+	struct rspamd_task             *task;
+	GRegex                         *regexp;
+	struct rspamd_regexp           *re;
+	gboolean                        found;
 };
 
-static gboolean
+static                          gboolean
 tree_url_callback (gpointer key, gpointer value, void *data)
 {
-	struct url_regexp_param *param = data;
-	struct uri *url = value;
-	GError *err = NULL;
+	struct url_regexp_param        *param = data;
+	struct uri                     *url = value;
+	GError                         *err = NULL;
 
-	if (g_regex_match_full (param->regexp, struri (url), -1, 0, 0, NULL,
-		&err) == TRUE) {
+	if (g_regex_match_full (param->regexp, struri (url), -1, 0, 0, NULL, &err) == TRUE) {
 		if (G_UNLIKELY (param->re->is_test)) {
-			msg_info ("process test regexp %s for url %s returned TRUE",
-				struri (url));
+			msg_info ("process test regexp %s for url %s returned TRUE", struri (url));
 		}
 		task_cache_add (param->task, param->re, 1);
 		param->found = TRUE;
 		return TRUE;
 	}
 	else if (G_UNLIKELY (param->re->is_test)) {
-		msg_info ("process test regexp %s for url %s returned FALSE",
-			struri (url));
+		msg_info ("process test regexp %s for url %s returned FALSE", struri (url));
 	}
 	if (err != NULL) {
-		msg_info ("error occured while processing regexp \"%s\": %s",
-			param->re->regexp_text,
-			err->message);
+		msg_info ("error occured while processing regexp \"%s\": %s", param->re->regexp_text, err->message);
 	}
 
 	return FALSE;
 }
 
-static gsize
-process_regexp (struct rspamd_regexp *re,
-	struct rspamd_task *task,
-	const gchar *additional,
-	gint limit,
-	int_compare_func f)
+static                          gsize
+process_regexp (struct rspamd_regexp *re, struct rspamd_task *task, const gchar *additional,
+		gint limit, int_compare_func f)
 {
-	guint8 *ct;
-	gsize clen;
-	gint r, passed = 0, start, end, old;
-	gboolean matched = FALSE;
-
-	GList *cur, *headerlist;
-	GRegex *regexp;
-	GMatchInfo *info;
-	GError *err = NULL;
-	struct url_regexp_param callback_param = {
+	guint8                         *ct;
+	gsize                           clen;
+	gint                            r, passed = 0, start, end, old;
+	gboolean                        matched = FALSE;
+
+	GList                          *cur, *headerlist;
+	GRegex                         *regexp;
+	GMatchInfo                     *info;
+	GError                         *err = NULL;
+	struct url_regexp_param         callback_param = {
 		.task = task,
 		.re = re,
 		.found = FALSE
 	};
-	struct mime_text_part *part;
-	struct raw_header *rh;
+	struct mime_text_part          *part;
+	struct raw_header              *rh;
 
 	if (re == NULL) {
 		msg_info ("invalid regexp passed");
@@ -807,21 +698,16 @@ process_regexp (struct rspamd_regexp *re,
 
 	callback_param.regexp = re->regexp;
 	if ((r = task_cache_check (task, re)) != -1) {
-		debug_task ("regexp /%s/ is found in cache, result: %d",
-			re->regexp_text,
-			r);
+		debug_task ("regexp /%s/ is found in cache, result: %d", re->regexp_text, r);
 		return r == 1;
 	}
-
+	
 	if (additional != NULL) {
 		/* We have additional parameter defined, so ignore type of regexp expression and use it for parsing */
 		if (G_UNLIKELY (re->is_test)) {
-			msg_info ("process test regexp %s with test %s",
-				re->regexp_text,
-				additional);
+			msg_info ("process test regexp %s with test %s", re->regexp_text, additional);
 		}
-		if (g_regex_match_full (re->regexp, additional, strlen (additional), 0,
-			0, NULL, NULL) == TRUE) {
+		if (g_regex_match_full (re->regexp, additional, strlen (additional), 0, 0, NULL, NULL) == TRUE) {
 			if (G_UNLIKELY (re->is_test)) {
 				msg_info ("result of regexp %s is true", re->regexp_text);
 			}
@@ -836,53 +722,39 @@ process_regexp (struct rspamd_regexp *re,
 
 	switch (re->type) {
 	case REGEXP_NONE:
-		msg_warn ("bad error detected: %s has invalid regexp type",
-			re->regexp_text);
+		msg_warn ("bad error detected: %s has invalid regexp type", re->regexp_text);
 		return 0;
 	case REGEXP_HEADER:
 		/* Check header's name */
 		if (re->header == NULL) {
-			msg_info ("header regexp without header name: '%s'",
-				re->regexp_text);
+			msg_info ("header regexp without header name: '%s'", re->regexp_text);
 			task_cache_add (task, re, 0);
 			return 0;
 		}
-		debug_task ("checking header regexp: %s = %s",
-			re->header,
-			re->regexp_text);
+		debug_task ("checking header regexp: %s = %s", re->header, re->regexp_text);
 
 		/* Get list of specified headers */
-		headerlist = message_get_header (task->task_pool,
-				task->message,
-				re->header,
-				re->is_strong);
+		headerlist = message_get_header (task->task_pool, task->message, re->header, re->is_strong);
 		if (headerlist == NULL) {
 			/* Header is not found */
 			if (G_UNLIKELY (re->is_test)) {
-				msg_info (
-					"process test regexp %s for header %s returned FALSE: no header found",
-					re->regexp_text,
-					re->header);
+				msg_info ("process test regexp %s for header %s returned FALSE: no header found", re->regexp_text, re->header);
 			}
 			task_cache_add (task, re, 0);
 			return 0;
 		}
 		else {
-			rspamd_mempool_add_destructor (task->task_pool,
-				(rspamd_mempool_destruct_t)g_list_free, headerlist);
+			rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_list_free, headerlist);
 			/* Check whether we have regexp for it */
 			if (re->regexp == NULL) {
-				debug_task ("regexp contains only header and it is found %s",
-					re->header);
+				debug_task ("regexp contains only header and it is found %s", re->header);
 				task_cache_add (task, re, 1);
 				return 1;
 			}
 			/* Iterate throught headers */
 			cur = headerlist;
 			while (cur) {
-				debug_task ("found header \"%s\" with value \"%s\"",
-					re->header,
-					(const gchar *)cur->data);
+				debug_task ("found header \"%s\" with value \"%s\"", re->header, (const gchar *)cur->data);
 				/* Try to match regexp */
 				if (!re->is_raw) {
 					/* Validate input */
@@ -891,15 +763,9 @@ process_regexp (struct rspamd_regexp *re,
 						continue;
 					}
 				}
-				if (cur->data &&
-					g_regex_match_full (re->regexp, cur->data, -1, 0, 0, NULL,
-					&err) == TRUE) {
+				if (cur->data && g_regex_match_full (re->regexp, cur->data, -1, 0, 0, NULL, &err) == TRUE) {
 					if (G_UNLIKELY (re->is_test)) {
-						msg_info (
-							"process test regexp %s for header %s with value '%s' returned TRUE",
-							re->regexp_text,
-							re->header,
-							(const gchar *)cur->data);
+						msg_info ("process test regexp %s for header %s with value '%s' returned TRUE", re->regexp_text, re->header, (const gchar *)cur->data);
 					}
 					if (f != NULL && limit > 1) {
 						/* If we have limit count, increase passed count and compare with limit */
@@ -914,17 +780,10 @@ process_regexp (struct rspamd_regexp *re,
 					}
 				}
 				else if (G_UNLIKELY (re->is_test)) {
-					msg_info (
-						"process test regexp %s for header %s with value '%s' returned FALSE",
-						re->regexp_text,
-						re->header,
-						(const gchar *)cur->data);
+					msg_info ("process test regexp %s for header %s with value '%s' returned FALSE", re->regexp_text, re->header, (const gchar *)cur->data);
 				}
 				if (err != NULL) {
-					msg_info (
-						"error occured while processing regexp \"%s\": %s",
-						re->regexp_text,
-						err->message);
+					msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
 				}
 				cur = g_list_next (cur);
 			}
@@ -944,11 +803,8 @@ process_regexp (struct rspamd_regexp *re,
 				continue;
 			}
 			/* Skip too large parts */
-			if (regexp_module_ctx->max_size != 0 && part->content->len >
-				regexp_module_ctx->max_size) {
-				msg_info ("<%s> skip part of size %Hud",
-					task->message_id,
-					part->content->len);
+			if (regexp_module_ctx->max_size != 0 && part->content->len > regexp_module_ctx->max_size) {
+				msg_info ("<%s> skip part of size %Hud", task->message_id, part->content->len);
 				cur = g_list_next (cur);
 				continue;
 			}
@@ -972,15 +828,12 @@ process_regexp (struct rspamd_regexp *re,
 			/* If we have limit, apply regexp so much times as we can */
 			if (f != NULL && limit > 1) {
 				end = 0;
-				while ((matched =
-					g_regex_match_full (regexp, ct + end + 1, clen - end - 1, 0,
-					0, &info, &err)) == TRUE) {
+				while ((matched = g_regex_match_full (regexp, ct + end + 1, clen - end - 1, 0, 0, &info, &err)) == TRUE) {
 					if (G_UNLIKELY (re->is_test)) {
-						msg_info (
-							"process test regexp %s for mime part of length %d returned TRUE",
-							re->regexp_text,
-							(gint)clen,
-							end);
+						msg_info ("process test regexp %s for mime part of length %d returned TRUE",
+								re->regexp_text,
+								(gint)clen,
+								end);
 					}
 					if (f (++passed, limit)) {
 						task_cache_add (task, re, 1);
@@ -989,8 +842,7 @@ process_regexp (struct rspamd_regexp *re,
 					else {
 						/* Match not found, skip further cycles */
 						old = end;
-						if (!g_match_info_fetch_pos (info, 0, &start,
-							&end) || end <= 0) {
+						if (!g_match_info_fetch_pos (info, 0, &start, &end) || end <= 0) {
 							break;
 						}
 						end += old;
@@ -1000,13 +852,10 @@ process_regexp (struct rspamd_regexp *re,
 				g_match_info_free (info);
 			}
 			else {
-				if (g_regex_match_full (regexp, ct, clen, 0, 0, NULL,
-					&err) == TRUE) {
+				if (g_regex_match_full (regexp, ct, clen, 0, 0, NULL, &err) == TRUE) {
 					if (G_UNLIKELY (re->is_test)) {
-						msg_info (
-							"process test regexp %s for mime part of length %d returned TRUE",
-							re->regexp_text,
-							(gint)clen);
+						msg_info ("process test regexp %s for mime part of length %d returned TRUE", re->regexp_text,
+								(gint)clen);
 					}
 					task_cache_add (task, re, 1);
 					return 1;
@@ -1014,15 +863,11 @@ process_regexp (struct rspamd_regexp *re,
 
 			}
 			if (!matched && G_UNLIKELY (re->is_test)) {
-				msg_info (
-					"process test regexp %s for mime part of length %d returned FALSE",
-					re->regexp_text,
-					(gint)clen);
+				msg_info ("process test regexp %s for mime part of length %d returned FALSE", re->regexp_text,
+						(gint)clen);
 			}
 			if (err != NULL) {
-				msg_info ("error occured while processing regexp \"%s\": %s",
-					re->regexp_text,
-					err->message);
+				msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
 			}
 			cur = g_list_next (cur);
 		}
@@ -1034,22 +879,17 @@ process_regexp (struct rspamd_regexp *re,
 		ct = task->msg->str;
 		clen = task->msg->len;
 
-		if (regexp_module_ctx->max_size != 0 && clen >
-			regexp_module_ctx->max_size) {
+		if (regexp_module_ctx->max_size != 0 && clen > regexp_module_ctx->max_size) {
 			msg_info ("<%s> skip message of size %Hz", task->message_id, clen);
 			return 0;
 		}
 		/* If we have limit, apply regexp so much times as we can */
 		if (f != NULL && limit > 1) {
 			end = 0;
-			while ((matched =
-				g_regex_match_full (regexp, ct + end + 1, clen - end - 1, 0, 0,
-				&info, &err)) == TRUE) {
+			while ((matched = g_regex_match_full (regexp, ct + end + 1, clen - end - 1, 0, 0, &info, &err)) == TRUE) {
 				if (G_UNLIKELY (re->is_test)) {
-					msg_info (
-						"process test regexp %s for mime part of length %d returned TRUE",
-						re->regexp_text,
-						(gint)clen);
+					msg_info ("process test regexp %s for mime part of length %d returned TRUE", re->regexp_text,
+							(gint)clen);
 				}
 				if (f (++passed, limit)) {
 					task_cache_add (task, re, 1);
@@ -1058,8 +898,7 @@ process_regexp (struct rspamd_regexp *re,
 				else {
 					/* Match not found, skip further cycles */
 					old = end;
-					if (!g_match_info_fetch_pos (info, 0, &start,
-						&end) || end <= 0) {
+					if (!g_match_info_fetch_pos (info, 0, &start, &end) || end <= 0) {
 						break;
 					}
 					old += end;
@@ -1069,13 +908,10 @@ process_regexp (struct rspamd_regexp *re,
 			g_match_info_free (info);
 		}
 		else {
-			if (g_regex_match_full (regexp, ct, clen, 0, 0, NULL,
-				&err) == TRUE) {
+			if (g_regex_match_full (regexp, ct, clen, 0, 0, NULL, &err) == TRUE) {
 				if (G_UNLIKELY (re->is_test)) {
-					msg_info (
-						"process test regexp %s for message part of length %d returned TRUE",
-						re->regexp_text,
-						(gint)clen);
+					msg_info ("process test regexp %s for message part of length %d returned TRUE", re->regexp_text,
+							(gint)clen);
 				}
 				task_cache_add (task, re, 1);
 				return 1;
@@ -1083,15 +919,11 @@ process_regexp (struct rspamd_regexp *re,
 
 		}
 		if (!matched && G_UNLIKELY (re->is_test)) {
-			msg_info (
-				"process test regexp %s for message part of length %d returned FALSE",
-				re->regexp_text,
-				(gint)clen);
+			msg_info ("process test regexp %s for message part of length %d returned FALSE", re->regexp_text,
+					(gint)clen);
 		}
 		if (err != NULL) {
-			msg_info ("error occured while processing regexp \"%s\": %s",
-				re->regexp_text,
-				err->message);
+			msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
 		}
 		task_cache_add (task, re, 0);
 		return 0;
@@ -1117,29 +949,21 @@ process_regexp (struct rspamd_regexp *re,
 		}
 		return 0;
 	case REGEXP_RAW_HEADER:
-		debug_task ("checking for raw header: %s with regexp: %s",
-			re->header,
-			re->regexp_text);
+		debug_task ("checking for raw header: %s with regexp: %s", re->header, re->regexp_text);
 		/* Check header's name */
 		if (re->header == NULL) {
-			msg_info ("header regexp without header name: '%s'",
-				re->regexp_text);
+			msg_info ("header regexp without header name: '%s'", re->regexp_text);
 			task_cache_add (task, re, 0);
 			return 0;
 		}
-		debug_task ("checking header regexp: %s = %s",
-			re->header,
-			re->regexp_text);
+		debug_task ("checking header regexp: %s = %s", re->header, re->regexp_text);
 
 		/* Get list of specified headers */
 		headerlist = message_get_raw_header (task, re->header, re->is_strong);
 		if (headerlist == NULL) {
 			/* Header is not found */
 			if (G_UNLIKELY (re->is_test)) {
-				msg_info (
-					"process test regexp %s for header %s returned FALSE: no header found",
-					re->regexp_text,
-					re->header);
+				msg_info ("process test regexp %s for header %s returned FALSE: no header found", re->regexp_text, re->header);
 			}
 			task_cache_add (task, re, 0);
 			return 0;
@@ -1147,17 +971,14 @@ process_regexp (struct rspamd_regexp *re,
 		else {
 			/* Check whether we have regexp for it */
 			if (re->regexp == NULL) {
-				debug_task ("regexp contains only header and it is found %s",
-					re->header);
+				debug_task ("regexp contains only header and it is found %s", re->header);
 				task_cache_add (task, re, 1);
 				return 1;
 			}
 			/* Iterate throught headers */
 			cur = headerlist;
 			while (cur) {
-				debug_task ("found header \"%s\" with value \"%s\"",
-					re->header,
-					(const gchar *)cur->data);
+				debug_task ("found header \"%s\" with value \"%s\"", re->header, (const gchar *)cur->data);
 				rh = cur->data;
 				/* Try to match regexp */
 				if (!re->is_raw) {
@@ -1167,15 +988,9 @@ process_regexp (struct rspamd_regexp *re,
 						continue;
 					}
 				}
-				if (rh->value &&
-					g_regex_match_full (re->regexp, rh->value, -1, 0, 0, NULL,
-					&err) == TRUE) {
+				if (rh->value && g_regex_match_full (re->regexp, rh->value, -1, 0, 0, NULL, &err) == TRUE) {
 					if (G_UNLIKELY (re->is_test)) {
-						msg_info (
-							"process test regexp %s for header %s with value '%s' returned TRUE",
-							re->regexp_text,
-							re->header,
-							(const gchar *)cur->data);
+						msg_info ("process test regexp %s for header %s with value '%s' returned TRUE", re->regexp_text, re->header, (const gchar *)cur->data);
 					}
 					if (f != NULL && limit > 1) {
 						/* If we have limit count, increase passed count and compare with limit */
@@ -1190,17 +1005,10 @@ process_regexp (struct rspamd_regexp *re,
 					}
 				}
 				else if (G_UNLIKELY (re->is_test)) {
-					msg_info (
-						"process test regexp %s for header %s with value '%s' returned FALSE",
-						re->regexp_text,
-						re->header,
-						(const gchar *)cur->data);
+					msg_info ("process test regexp %s for header %s with value '%s' returned FALSE", re->regexp_text, re->header, (const gchar *)cur->data);
 				}
 				if (err != NULL) {
-					msg_info (
-						"error occured while processing regexp \"%s\": %s",
-						re->regexp_text,
-						err->message);
+					msg_info ("error occured while processing regexp \"%s\": %s", re->regexp_text, err->message);
 				}
 				cur = g_list_next (cur);
 			}
@@ -1217,12 +1025,10 @@ process_regexp (struct rspamd_regexp *re,
 }
 
 static gboolean
-maybe_call_lua_function (const gchar *name,
-	struct rspamd_task *task,
-	lua_State *L)
+maybe_call_lua_function (const gchar *name, struct rspamd_task *task, lua_State *L)
 {
-	struct rspamd_task **ptask;
-	gboolean res;
+	struct rspamd_task            **ptask;
+	gboolean                        res;
 
 	lua_getglobal (L, name);
 	if (lua_isfunction (L, -1)) {
@@ -1231,8 +1037,7 @@ maybe_call_lua_function (const gchar *name,
 		*ptask = task;
 		/* Call function */
 		if (lua_pcall (L, 1, 1, 0) != 0) {
-			msg_info ("call to %s failed: %s", (gchar *)name,
-				lua_tostring (L, -1));
+			msg_info ("call to %s failed: %s", (gchar *)name, lua_tostring (L, -1));
 			return FALSE;
 		}
 		res = lua_toboolean (L, -1);
@@ -1245,12 +1050,12 @@ maybe_call_lua_function (const gchar *name,
 	return FALSE;
 }
 
-static gboolean
+static                          gboolean
 optimize_regexp_expression (struct expression **e, GQueue * stack, gboolean res)
 {
-	struct expression *it = (*e)->next;
-	gboolean ret = FALSE, is_nearest = TRUE;
-	gint skip_level = 0;
+	struct expression              *it = (*e)->next;
+	gboolean                        ret = FALSE, is_nearest = TRUE;
+	gint                            skip_level = 0;
 
 	/* Skip nearest logical operators from optimization */
 	if (!it || (it->type == EXPR_OPERATION && it->content.operation != '!')) {
@@ -1301,29 +1106,22 @@ optimize_regexp_expression (struct expression **e, GQueue * stack, gboolean res)
 	return ret;
 }
 
-static gboolean
-process_regexp_expression (struct expression *expr,
-	const gchar *symbol,
-	struct rspamd_task *task,
-	const gchar *additional,
-	struct lua_locked_state *nL)
+static                          gboolean
+process_regexp_expression (struct expression *expr, const gchar *symbol, struct rspamd_task *task,
+		const gchar *additional, struct lua_locked_state *nL)
 {
-	GQueue *stack;
-	gsize cur, op1, op2;
-	struct expression *it = expr;
-	struct rspamd_regexp *re;
-	gboolean try_optimize = TRUE;
+	GQueue                         *stack;
+	gsize                           cur, op1, op2;
+	struct expression              *it = expr;
+	struct rspamd_regexp           *re;
+	gboolean                        try_optimize = TRUE;
 
 	stack = g_queue_new ();
 
 	while (it) {
 		if (it->type == EXPR_REGEXP_PARSED) {
 			/* Find corresponding symbol */
-			cur = process_regexp ((struct rspamd_regexp *)it->content.operand,
-					task,
-					additional,
-					0,
-					NULL);
+			cur = process_regexp ((struct rspamd_regexp *)it->content.operand, task, additional, 0, NULL);
 			debug_task ("regexp %s found", cur ? "is" : "is not");
 			if (try_optimize) {
 				try_optimize = optimize_regexp_expression (&it, stack, cur);
@@ -1335,21 +1133,13 @@ process_regexp_expression (struct expression *expr,
 		else if (it->type == EXPR_FUNCTION) {
 			if (nL) {
 				rspamd_mutex_lock (nL->m);
-				cur =
-					(gsize) call_expression_function ((struct
-						expression_function
-						*)it->content.operand, task, nL->L);
+				cur = (gsize) call_expression_function ((struct expression_function *)it->content.operand, task, nL->L);
 				rspamd_mutex_unlock (nL->m);
 			}
 			else {
-				cur =
-					(gsize) call_expression_function ((struct
-						expression_function
-						*)it->content.operand, task, task->cfg->lua_state);
-			}
-			debug_task ("function %s returned %s",
-				((struct expression_function *)it->content.operand)->name,
-				cur ? "true" : "false");
+				cur = (gsize) call_expression_function ((struct expression_function *)it->content.operand, task, task->cfg->lua_state);
+			}
+			debug_task ("function %s returned %s", ((struct expression_function *)it->content.operand)->name, cur ? "true" : "false");
 			if (try_optimize) {
 				try_optimize = optimize_regexp_expression (&it, stack, cur);
 			}
@@ -1361,21 +1151,13 @@ process_regexp_expression (struct expression *expr,
 			/* This may be lua function, try to call it */
 			if (nL) {
 				rspamd_mutex_lock (nL->m);
-				cur = maybe_call_lua_function (
-					(const gchar *)it->content.operand,
-					task,
-					nL->L);
+				cur = maybe_call_lua_function ((const gchar*)it->content.operand, task, nL->L);
 				rspamd_mutex_unlock (nL->m);
 			}
 			else {
-				cur = maybe_call_lua_function (
-					(const gchar *)it->content.operand,
-					task,
-					task->cfg->lua_state);
-			}
-			debug_task ("function %s returned %s",
-				(const gchar *)it->content.operand,
-				cur ? "true" : "false");
+				cur = maybe_call_lua_function ((const gchar*)it->content.operand, task, task->cfg->lua_state);
+			}
+			debug_task ("function %s returned %s", (const gchar *)it->content.operand, cur ? "true" : "false");
 			if (try_optimize) {
 				try_optimize = optimize_regexp_expression (&it, stack, cur);
 			}
@@ -1389,9 +1171,7 @@ process_regexp_expression (struct expression *expr,
 				it = it->next;
 				continue;
 			}
-			re = parse_regexp (task->cfg->cfg_pool,
-					it->content.operand,
-					task->cfg->raw_mode);
+			re = parse_regexp (task->cfg->cfg_pool, it->content.operand, task->cfg->raw_mode);
 			if (re == NULL) {
 				msg_warn ("cannot parse regexp, skip expression");
 				g_queue_free (stack);
@@ -1405,8 +1185,7 @@ process_regexp_expression (struct expression *expr,
 		else if (it->type == EXPR_OPERATION) {
 			if (g_queue_is_empty (stack)) {
 				/* Queue has no operands for operation, exiting */
-				msg_warn (
-					"regexp expression seems to be invalid: empty stack while reading operation");
+				msg_warn ("regexp expression seems to be invalid: empty stack while reading operation");
 				g_queue_free (stack);
 				return FALSE;
 			}
@@ -1420,16 +1199,12 @@ process_regexp_expression (struct expression *expr,
 			case '&':
 				op1 = GPOINTER_TO_SIZE (g_queue_pop_head (stack));
 				op2 = GPOINTER_TO_SIZE (g_queue_pop_head (stack));
-				try_optimize = optimize_regexp_expression (&it,
-						stack,
-						op1 && op2);
+				try_optimize = optimize_regexp_expression (&it, stack, op1 && op2);
 				break;
 			case '|':
 				op1 = GPOINTER_TO_SIZE (g_queue_pop_head (stack));
 				op2 = GPOINTER_TO_SIZE (g_queue_pop_head (stack));
-				try_optimize = optimize_regexp_expression (&it,
-						stack,
-						op1 || op2);
+				try_optimize = optimize_regexp_expression (&it, stack, op1 || op2);
 				break;
 			default:
 				it = it->next;
@@ -1448,9 +1223,7 @@ process_regexp_expression (struct expression *expr,
 		}
 	}
 	else {
-		msg_warn (
-			"regexp expression seems to be invalid: empty stack at the end of expression, symbol %s",
-			symbol);
+		msg_warn ("regexp expression seems to be invalid: empty stack at the end of expression, symbol %s", symbol);
 	}
 
 	g_queue_free (stack);
@@ -1466,12 +1239,11 @@ struct regexp_threaded_ud {
 static void
 process_regexp_item_threaded (gpointer data, gpointer user_data)
 {
-	struct regexp_threaded_ud *ud = data;
-	struct lua_locked_state *nL = user_data;
+	struct regexp_threaded_ud	   *ud = data;
+	struct lua_locked_state		   *nL = user_data;
 
 	/* Process expression */
-	if (process_regexp_expression (ud->item->expr, ud->item->symbol, ud->task,
-		NULL, nL)) {
+	if (process_regexp_expression (ud->item->expr, ud->item->symbol, ud->task, NULL, nL)) {
 		g_mutex_lock (workers_mtx);
 		insert_result (ud->task, ud->item->symbol, 1, NULL);
 		g_mutex_unlock (workers_mtx);
@@ -1482,18 +1254,18 @@ process_regexp_item_threaded (gpointer data, gpointer user_data)
 static void
 process_regexp_item (struct rspamd_task *task, void *user_data)
 {
-	struct regexp_module_item *item = user_data;
-	gboolean res = FALSE;
-	struct regexp_threaded_ud *thr_ud;
-	GError *err = NULL;
-	struct lua_locked_state *nL;
+	struct regexp_module_item      *item = user_data;
+	gboolean                        res = FALSE;
+	struct regexp_threaded_ud	   *thr_ud;
+	GError						   *err = NULL;
+	struct lua_locked_state		   *nL;
 
 
 	if (!item->lua_function && regexp_module_ctx->max_threads > 1) {
 		if (regexp_module_ctx->workers == NULL) {
 #if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION <= 30))
 # if GLIB_MINOR_VERSION > 20
-			if (!g_thread_get_initialized ()) {
+			if (! g_thread_get_initialized ()) {
 				g_thread_init (NULL);
 			}
 # else
@@ -1501,27 +1273,20 @@ process_regexp_item (struct rspamd_task *task, void *user_data)
 # endif
 			workers_mtx = g_mutex_new ();
 #else
-			workers_mtx = rspamd_mempool_alloc (regexp_module_ctx->regexp_pool,
-					sizeof (GMutex));
+			workers_mtx = rspamd_mempool_alloc (regexp_module_ctx->regexp_pool, sizeof (GMutex));
 			g_mutex_init (workers_mtx);
 #endif
 			nL = init_lua_locked (task->cfg);
 			luaopen_regexp (nL->L);
-			regexp_module_ctx->workers = g_thread_pool_new (
-				process_regexp_item_threaded,
-				nL,
-				regexp_module_ctx->max_threads,
-				TRUE,
-				&err);
+			regexp_module_ctx->workers = g_thread_pool_new (process_regexp_item_threaded,
+					nL, regexp_module_ctx->max_threads, TRUE, &err);
 			if (err != NULL) {
 				msg_err ("thread pool creation failed: %s", err->message);
 				regexp_module_ctx->max_threads = 0;
 				return;
 			}
 		}
-		thr_ud =
-			rspamd_mempool_alloc (task->task_pool,
-				sizeof (struct regexp_threaded_ud));
+		thr_ud = rspamd_mempool_alloc (task->task_pool, sizeof (struct regexp_threaded_ud));
 		thr_ud->item = item;
 		thr_ud->task = task;
 
@@ -1529,8 +1294,7 @@ process_regexp_item (struct rspamd_task *task, void *user_data)
 		register_async_thread (task->s);
 		g_thread_pool_push (regexp_module_ctx->workers, thr_ud, &err);
 		if (err != NULL) {
-			msg_err ("error pushing task to the regexp thread pool: %s",
-				err->message);
+			msg_err ("error pushing task to the regexp thread pool: %s", err->message);
 			remove_async_thread (task->s);
 		}
 	}
@@ -1538,28 +1302,25 @@ process_regexp_item (struct rspamd_task *task, void *user_data)
 		/* Non-threaded version */
 		if (item->lua_function) {
 			/* Just call function */
-			if (lua_call_expression_func (item->lua_function, task, NULL,
-				&res) && res) {
+			if (lua_call_expression_func (item->lua_function, task, NULL, &res) && res) {
 				insert_result (task, item->symbol, 1, NULL);
 			}
 		}
 		else {
 			/* Process expression */
-			if (process_regexp_expression (item->expr, item->symbol, task, NULL,
-				NULL)) {
+			if (process_regexp_expression (item->expr, item->symbol, task, NULL, NULL)) {
 				insert_result (task, item->symbol, 1, NULL);
 			}
 		}
 	}
 }
 
-static gboolean
-rspamd_regexp_match_number (struct rspamd_task *task, GList * args,
-	void *unused)
+static                          gboolean
+rspamd_regexp_match_number (struct rspamd_task *task, GList * args, void *unused)
 {
-	gint param_count, res = 0;
-	struct expression_argument *arg;
-	GList *cur;
+	gint                            param_count, res = 0;
+	struct expression_argument     *arg;
+	GList                          *cur;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -1578,8 +1339,7 @@ rspamd_regexp_match_number (struct rspamd_task *task, GList * args,
 			}
 		}
 		else {
-			if (process_regexp_expression (cur->data, "regexp_match_number",
-				task, NULL, NULL)) {
+			if (process_regexp_expression (cur->data, "regexp_match_number", task, NULL, NULL)) {
 				res++;
 			}
 			if (res >= param_count) {
@@ -1592,16 +1352,14 @@ rspamd_regexp_match_number (struct rspamd_task *task, GList * args,
 	return res >= param_count;
 }
 
-static gboolean
-rspamd_regexp_occurs_number (struct rspamd_task *task,
-	GList * args,
-	void *unused)
+static                          gboolean
+rspamd_regexp_occurs_number (struct rspamd_task *task, GList * args, void *unused)
 {
-	gint limit;
-	struct expression_argument *arg;
-	struct rspamd_regexp *re;
-	gchar *param, *err_str, op;
-	int_compare_func f = NULL;
+	gint                            limit;
+	struct expression_argument     *arg;
+	struct rspamd_regexp           *re;
+	gchar                          *param, *err_str, op;
+	int_compare_func                f = NULL;
 
 	if (args == NULL || args->next == NULL) {
 		msg_warn ("wrong number of parameters to function, must be 2");
@@ -1624,13 +1382,13 @@ rspamd_regexp_occurs_number (struct rspamd_task *task,
 		op = '=';
 	}
 	else {
-		param++;
+		param ++;
 	}
 	switch (op) {
 	case '>':
 		if (*param == '=') {
 			f = op_more_equal;
-			param++;
+			param ++;
 		}
 		else {
 			f = op_more;
@@ -1639,7 +1397,7 @@ rspamd_regexp_occurs_number (struct rspamd_task *task,
 	case '<':
 		if (*param == '=') {
 			f = op_less_equal;
-			param++;
+			param ++;
 		}
 		else {
 			f = op_less;
@@ -1649,9 +1407,7 @@ rspamd_regexp_occurs_number (struct rspamd_task *task,
 		f = op_equal;
 		break;
 	default:
-		msg_err (
-			"wrong operation character: %c, assumed '=', '>', '<', '>=', '<=' or empty op",
-			op);
+		msg_err ("wrong operation character: %c, assumed '=', '>', '<', '>=', '<=' or empty op", op);
 		return FALSE;
 	}
 
@@ -1663,10 +1419,10 @@ rspamd_regexp_occurs_number (struct rspamd_task *task,
 
 	return process_regexp (re, task, NULL, limit, f);
 }
-static gboolean
+static                          gboolean
 rspamd_raw_header_exists (struct rspamd_task *task, GList * args, void *unused)
 {
-	struct expression_argument *arg;
+	struct expression_argument     *arg;
 
 	if (args == NULL || task == NULL) {
 		return FALSE;
@@ -1682,19 +1438,15 @@ rspamd_raw_header_exists (struct rspamd_task *task, GList * args, void *unused)
 }
 
 static gboolean
-match_smtp_data (struct rspamd_task *task,
-	const gchar *re_text,
-	const gchar *what)
+match_smtp_data (struct rspamd_task *task, const gchar *re_text, const gchar *what)
 {
-	struct rspamd_regexp *re;
-	gint r;
+	struct rspamd_regexp           *re;
+	gint                            r;
 
 	if (*re_text == '/') {
 		/* This is a regexp */
 		if ((re = re_cache_check (re_text, task->cfg->cfg_pool)) == NULL) {
-			re = parse_regexp (task->cfg->cfg_pool,
-					(gchar *)re_text,
-					task->cfg->raw_mode);
+			re = parse_regexp (task->cfg->cfg_pool, (gchar *)re_text, task->cfg->raw_mode);
 			if (re == NULL) {
 				msg_warn ("cannot compile regexp for function");
 				return FALSE;
@@ -1719,12 +1471,12 @@ match_smtp_data (struct rspamd_task *task,
 	return FALSE;
 }
 
-static gboolean
+static                          gboolean
 rspamd_check_smtp_data (struct rspamd_task *task, GList * args, void *unused)
 {
-	struct expression_argument *arg;
-	GList *cur, *rcpt_list = NULL;
-	gchar *type, *what = NULL;
+	struct expression_argument     *arg;
+	GList                          *cur, *rcpt_list = NULL;
+	gchar                           *type, *what = NULL;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -1740,59 +1492,59 @@ rspamd_check_smtp_data (struct rspamd_task *task, GList * args, void *unused)
 	else {
 		type = arg->data;
 		switch (*type) {
-		case 'f':
-		case 'F':
-			if (g_ascii_strcasecmp (type, "from") == 0) {
-				what = task->from;
-			}
-			else {
-				msg_warn ("bad argument to function: %s", type);
-				return FALSE;
-			}
-			break;
-		case 'h':
-		case 'H':
-			if (g_ascii_strcasecmp (type, "helo") == 0) {
-				what = task->helo;
-			}
-			else {
-				msg_warn ("bad argument to function: %s", type);
-				return FALSE;
-			}
-			break;
-		case 'u':
-		case 'U':
-			if (g_ascii_strcasecmp (type, "user") == 0) {
-				what = task->user;
-			}
-			else {
-				msg_warn ("bad argument to function: %s", type);
-				return FALSE;
-			}
-			break;
-		case 's':
-		case 'S':
-			if (g_ascii_strcasecmp (type, "subject") == 0) {
-				what = task->subject;
-			}
-			else {
-				msg_warn ("bad argument to function: %s", type);
-				return FALSE;
-			}
-			break;
-		case 'r':
-		case 'R':
-			if (g_ascii_strcasecmp (type, "rcpt") == 0) {
-				rcpt_list = task->rcpt;
-			}
-			else {
+			case 'f':
+			case 'F':
+				if (g_ascii_strcasecmp (type, "from") == 0) {
+					what = task->from;
+				}
+				else {
+					msg_warn ("bad argument to function: %s", type);
+					return FALSE;
+				}
+				break;
+			case 'h':
+			case 'H':
+				if (g_ascii_strcasecmp (type, "helo") == 0) {
+					what = task->helo;
+				}
+				else {
+					msg_warn ("bad argument to function: %s", type);
+					return FALSE;
+				}
+				break;
+			case 'u':
+			case 'U':
+				if (g_ascii_strcasecmp (type, "user") == 0) {
+					what = task->user;
+				}
+				else {
+					msg_warn ("bad argument to function: %s", type);
+					return FALSE;
+				}
+				break;
+			case 's':
+			case 'S':
+				if (g_ascii_strcasecmp (type, "subject") == 0) {
+					what = task->subject;
+				}
+				else {
+					msg_warn ("bad argument to function: %s", type);
+					return FALSE;
+				}
+				break;
+			case 'r':
+			case 'R':
+				if (g_ascii_strcasecmp (type, "rcpt") == 0) {
+					rcpt_list = task->rcpt;
+				}
+				else {
+					msg_warn ("bad argument to function: %s", type);
+					return FALSE;
+				}
+				break;
+			default:
 				msg_warn ("bad argument to function: %s", type);
 				return FALSE;
-			}
-			break;
-		default:
-			msg_warn ("bad argument to function: %s", type);
-			return FALSE;
 		}
 	}
 
@@ -1800,7 +1552,7 @@ rspamd_check_smtp_data (struct rspamd_task *task, GList * args, void *unused)
 		/* Not enough data so regexp would NOT be found anyway */
 		return FALSE;
 	}
-
+	
 	/* We would process only one more argument, others are ignored */
 	cur = args->next;
 	if (cur) {
@@ -1820,16 +1572,13 @@ rspamd_check_smtp_data (struct rspamd_task *task, GList * args, void *unused)
 		}
 		else if (arg != NULL) {
 			if (what != NULL) {
-				if (process_regexp_expression (arg->data,
-					"regexp_check_smtp_data", task, what, NULL)) {
+				if (process_regexp_expression (arg->data, "regexp_check_smtp_data", task, what, NULL)) {
 					return TRUE;
 				}
 			}
 			else {
 				while (rcpt_list) {
-					if (process_regexp_expression (arg->data,
-						"regexp_check_smtp_data", task, rcpt_list->data,
-						NULL)) {
+					if (process_regexp_expression (arg->data, "regexp_check_smtp_data", task, rcpt_list->data, NULL)) {
 						return TRUE;
 					}
 					rcpt_list = g_list_next (rcpt_list);
@@ -1845,11 +1594,11 @@ rspamd_check_smtp_data (struct rspamd_task *task, GList * args, void *unused)
 static gint
 lua_regexp_match (lua_State *L)
 {
-	void *ud = luaL_checkudata (L, 1, "rspamd{task}");
-	struct rspamd_task *task;
-	const gchar *re_text;
-	struct rspamd_regexp *re;
-	gint r = 0;
+	void                           *ud = luaL_checkudata (L, 1, "rspamd{task}");
+	struct rspamd_task             *task;
+	const gchar                    *re_text;
+	struct rspamd_regexp           *re;
+	gint                            r = 0;
 
 	luaL_argcheck (L, ud != NULL, 1, "'task' expected");
 	task = ud ? *((struct rspamd_task **)ud) : NULL;
@@ -1858,9 +1607,7 @@ lua_regexp_match (lua_State *L)
 	/* This is a regexp */
 	if (task != NULL) {
 		if ((re = re_cache_check (re_text, task->cfg->cfg_pool)) == NULL) {
-			re = parse_regexp (task->cfg->cfg_pool,
-					(gchar *)re_text,
-					task->cfg->raw_mode);
+			re = parse_regexp (task->cfg->cfg_pool, (gchar *)re_text, task->cfg->raw_mode);
 			if (re == NULL) {
 				msg_warn ("cannot compile regexp for function");
 				return FALSE;
@@ -1875,20 +1622,18 @@ lua_regexp_match (lua_State *L)
 }
 
 static gboolean
-rspamd_content_type_compare_param (struct rspamd_task * task,
-	GList * args,
-	void *unused)
+rspamd_content_type_compare_param (struct rspamd_task * task, GList * args, void *unused)
 {
-	gchar *param_name, *param_pattern;
-	const gchar *param_data;
-	struct rspamd_regexp *re;
-	struct expression_argument *arg, *arg1;
-	GMimeObject *part;
-	GMimeContentType *ct;
-	gint r;
-	gboolean recursive = FALSE, result = FALSE;
-	GList *cur = NULL;
-	struct mime_part *cur_part;
+	gchar                           *param_name, *param_pattern;
+	const gchar                     *param_data;
+	struct rspamd_regexp           *re;
+	struct expression_argument     *arg, *arg1;
+	GMimeObject                    *part;
+	GMimeContentType               *ct;
+	gint                            r;
+	gboolean                        recursive = FALSE, result = FALSE;
+	GList                          *cur = NULL;
+	struct mime_part               *cur_part;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -1911,8 +1656,7 @@ rspamd_content_type_compare_param (struct rspamd_task * task,
 		if (args->next) {
 			args = g_list_next (args);
 			arg1 = get_function_arg (args->data, task, TRUE);
-			if (g_ascii_strncasecmp (arg1->data, "true",
-				sizeof ("true") - 1) == 0) {
+			if (g_ascii_strncasecmp (arg1->data, "true", sizeof ("true") - 1) == 0) {
 				recursive = TRUE;
 			}
 		}
@@ -1933,21 +1677,15 @@ rspamd_content_type_compare_param (struct rspamd_task * task,
 #ifndef GMIME24
 		g_object_unref (part);
 #endif
-		for (;; ) {
-			if ((param_data =
-				g_mime_content_type_get_parameter ((GMimeContentType *)ct,
-				param_name)) == NULL) {
+		for (;;) {
+			if ((param_data = g_mime_content_type_get_parameter ((GMimeContentType *)ct, param_name)) == NULL) {
 				result = FALSE;
 			}
 			else {
 				if (*param_pattern == '/') {
 					/* This is regexp, so compile and create g_regexp object */
-					if ((re =
-						re_cache_check (param_pattern,
-						task->cfg->cfg_pool)) == NULL) {
-						re = parse_regexp (task->cfg->cfg_pool,
-								param_pattern,
-								task->cfg->raw_mode);
+					if ((re = re_cache_check (param_pattern, task->cfg->cfg_pool)) == NULL) {
+						re = parse_regexp (task->cfg->cfg_pool, param_pattern, task->cfg->raw_mode);
 						if (re == NULL) {
 							msg_warn ("cannot compile regexp for function");
 							return FALSE;
@@ -1955,8 +1693,7 @@ rspamd_content_type_compare_param (struct rspamd_task * task,
 						re_cache_add (param_pattern, re, task->cfg->cfg_pool);
 					}
 					if ((r = task_cache_check (task, re)) == -1) {
-						if (g_regex_match (re->regexp, param_data, 0,
-							NULL) == TRUE) {
+						if (g_regex_match (re->regexp, param_data, 0, NULL) == TRUE) {
 							task_cache_add (task, re, 1);
 							return TRUE;
 						}
@@ -1974,7 +1711,7 @@ rspamd_content_type_compare_param (struct rspamd_task * task,
 				}
 			}
 			/* Get next part */
-			if (!recursive) {
+			if (! recursive) {
 				return result;
 			}
 			else if (cur != NULL) {
@@ -1996,18 +1733,16 @@ rspamd_content_type_compare_param (struct rspamd_task * task,
 }
 
 static gboolean
-rspamd_content_type_has_param (struct rspamd_task * task,
-	GList * args,
-	void *unused)
+rspamd_content_type_has_param (struct rspamd_task * task, GList * args, void *unused)
 {
-	gchar *param_name;
-	const gchar *param_data;
-	struct expression_argument *arg, *arg1;
-	GMimeObject *part;
-	GMimeContentType *ct;
-	gboolean recursive = FALSE, result = FALSE;
-	GList *cur = NULL;
-	struct mime_part *cur_part;
+	gchar                           *param_name;
+	const gchar                     *param_data;
+	struct expression_argument     *arg, *arg1;
+	GMimeObject                    *part;
+	GMimeContentType               *ct;
+	gboolean                        recursive = FALSE, result = FALSE;
+	GList                          *cur = NULL;
+	struct mime_part               *cur_part;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -2022,8 +1757,7 @@ rspamd_content_type_has_param (struct rspamd_task * task,
 		if (args->next) {
 			args = g_list_next (args);
 			arg1 = get_function_arg (args->data, task, TRUE);
-			if (g_ascii_strncasecmp (arg1->data, "true",
-				sizeof ("true") - 1) == 0) {
+			if (g_ascii_strncasecmp (arg1->data, "true", sizeof ("true") - 1) == 0) {
 				recursive = TRUE;
 			}
 		}
@@ -2044,14 +1778,12 @@ rspamd_content_type_has_param (struct rspamd_task * task,
 #ifndef GMIME24
 		g_object_unref (part);
 #endif
-		for (;; ) {
-			if ((param_data =
-				g_mime_content_type_get_parameter ((GMimeContentType *)ct,
-				param_name)) != NULL) {
+		for (;;) {
+			if ((param_data = g_mime_content_type_get_parameter ((GMimeContentType *)ct, param_name)) != NULL) {
 				return TRUE;
 			}
 			/* Get next part */
-			if (!recursive) {
+			if (! recursive) {
 				return result;
 			}
 			else if (cur != NULL) {
@@ -2073,19 +1805,17 @@ rspamd_content_type_has_param (struct rspamd_task * task,
 }
 
 static gboolean
-rspamd_content_type_is_subtype (struct rspamd_task *task,
-	GList * args,
-	void *unused)
+rspamd_content_type_is_subtype (struct rspamd_task *task, GList * args, void *unused)
 {
-	gchar *param_pattern;
-	struct rspamd_regexp *re;
-	struct expression_argument *arg, *arg1;
-	GMimeObject *part;
-	GMimeContentType *ct;
-	gint r;
-	gboolean recursive = FALSE, result = FALSE;
-	GList *cur = NULL;
-	struct mime_part *cur_part;
+	gchar                          *param_pattern;
+	struct rspamd_regexp           *re;
+	struct expression_argument     *arg, *arg1;
+	GMimeObject                    *part;
+	GMimeContentType               *ct;
+	gint                            r;
+	gboolean                        recursive = FALSE, result = FALSE;
+	GList                          *cur = NULL;
+	struct mime_part               *cur_part;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -2100,8 +1830,7 @@ rspamd_content_type_is_subtype (struct rspamd_task *task,
 		if (args->next) {
 			args = g_list_next (args);
 			arg1 = get_function_arg (args->data, task, TRUE);
-			if (g_ascii_strncasecmp (arg1->data, "true",
-				sizeof ("true") - 1) == 0) {
+			if (g_ascii_strncasecmp (arg1->data, "true", sizeof ("true") - 1) == 0) {
 				recursive = TRUE;
 			}
 		}
@@ -2122,15 +1851,11 @@ rspamd_content_type_is_subtype (struct rspamd_task *task,
 #ifndef GMIME24
 		g_object_unref (part);
 #endif
-		for (;; ) {
+		for (;;) {
 			if (*param_pattern == '/') {
 				/* This is regexp, so compile and create g_regexp object */
-				if ((re =
-					re_cache_check (param_pattern,
-					task->cfg->cfg_pool)) == NULL) {
-					re = parse_regexp (task->cfg->cfg_pool,
-							param_pattern,
-							task->cfg->raw_mode);
+				if ((re = re_cache_check (param_pattern, task->cfg->cfg_pool)) == NULL) {
+					re = parse_regexp (task->cfg->cfg_pool, param_pattern, task->cfg->raw_mode);
 					if (re == NULL) {
 						msg_warn ("cannot compile regexp for function");
 						return FALSE;
@@ -2138,8 +1863,7 @@ rspamd_content_type_is_subtype (struct rspamd_task *task,
 					re_cache_add (param_pattern, re, task->cfg->cfg_pool);
 				}
 				if ((r = task_cache_check (task, re)) == -1) {
-					if (g_regex_match (re->regexp, ct->subtype, 0,
-						NULL) == TRUE) {
+					if (g_regex_match (re->regexp, ct->subtype, 0, NULL) == TRUE) {
 						task_cache_add (task, re, 1);
 						return TRUE;
 					}
@@ -2156,7 +1880,7 @@ rspamd_content_type_is_subtype (struct rspamd_task *task,
 				}
 			}
 			/* Get next part */
-			if (!recursive) {
+			if (! recursive) {
 				return result;
 			}
 			else if (cur != NULL) {
@@ -2178,19 +1902,17 @@ rspamd_content_type_is_subtype (struct rspamd_task *task,
 }
 
 static gboolean
-rspamd_content_type_is_type (struct rspamd_task * task,
-	GList * args,
-	void *unused)
+rspamd_content_type_is_type (struct rspamd_task * task, GList * args, void *unused)
 {
-	gchar *param_pattern;
-	struct rspamd_regexp *re;
-	struct expression_argument *arg, *arg1;
-	GMimeObject *part;
-	GMimeContentType *ct;
-	gint r;
-	gboolean recursive = FALSE, result = FALSE;
-	GList *cur = NULL;
-	struct mime_part *cur_part;
+	gchar                          *param_pattern;
+	struct rspamd_regexp           *re;
+	struct expression_argument     *arg, *arg1;
+	GMimeObject                    *part;
+	GMimeContentType               *ct;
+	gint                            r;
+	gboolean                        recursive = FALSE, result = FALSE;
+	GList                          *cur = NULL;
+	struct mime_part               *cur_part;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -2206,8 +1928,7 @@ rspamd_content_type_is_type (struct rspamd_task * task,
 		if (args->next) {
 			args = g_list_next (args);
 			arg1 = get_function_arg (args->data, task, TRUE);
-			if (g_ascii_strncasecmp (arg1->data, "true",
-				sizeof ("true") - 1) == 0) {
+			if (g_ascii_strncasecmp (arg1->data, "true", sizeof ("true") - 1) == 0) {
 				recursive = TRUE;
 			}
 		}
@@ -2228,15 +1949,11 @@ rspamd_content_type_is_type (struct rspamd_task * task,
 #ifndef GMIME24
 		g_object_unref (part);
 #endif
-		for (;; ) {
+		for (;;) {
 			if (*param_pattern == '/') {
 				/* This is regexp, so compile and create g_regexp object */
-				if ((re =
-					re_cache_check (param_pattern,
-					task->cfg->cfg_pool)) == NULL) {
-					re = parse_regexp (task->cfg->cfg_pool,
-							param_pattern,
-							task->cfg->raw_mode);
+				if ((re = re_cache_check (param_pattern, task->cfg->cfg_pool)) == NULL) {
+					re = parse_regexp (task->cfg->cfg_pool, param_pattern, task->cfg->raw_mode);
 					if (re == NULL) {
 						msg_warn ("cannot compile regexp for function");
 						return FALSE;
@@ -2261,7 +1978,7 @@ rspamd_content_type_is_type (struct rspamd_task * task,
 				}
 			}
 			/* Get next part */
-			if (!recursive) {
+			if (! recursive) {
 				return result;
 			}
 			else if (cur != NULL) {
@@ -2282,12 +1999,11 @@ rspamd_content_type_is_type (struct rspamd_task * task,
 	return FALSE;
 }
 
-static gboolean
-compare_subtype (struct rspamd_task *task, GMimeContentType * ct,
-	gchar *subtype)
+static                   gboolean
+compare_subtype (struct rspamd_task *task, GMimeContentType * ct, gchar *subtype)
 {
-	struct rspamd_regexp *re;
-	gint r;
+	struct rspamd_regexp           *re;
+	gint                            r;
 
 	if (subtype == NULL || ct == NULL) {
 		msg_warn ("invalid parameters passed");
@@ -2296,9 +2012,7 @@ compare_subtype (struct rspamd_task *task, GMimeContentType * ct,
 	if (*subtype == '/') {
 		/* This is regexp, so compile and create g_regexp object */
 		if ((re = re_cache_check (subtype, task->cfg->cfg_pool)) == NULL) {
-			re =
-				parse_regexp (task->cfg->cfg_pool, subtype,
-					task->cfg->raw_mode);
+			re = parse_regexp (task->cfg->cfg_pool, subtype, task->cfg->raw_mode);
 			if (re == NULL) {
 				msg_warn ("cannot compile regexp for function");
 				return FALSE;
@@ -2326,7 +2040,7 @@ compare_subtype (struct rspamd_task *task, GMimeContentType * ct,
 	return FALSE;
 }
 
-static gboolean
+static                   gboolean
 compare_len (struct mime_part *part, guint min, guint max)
 {
 	if (min == 0 && max == 0) {
@@ -2345,17 +2059,13 @@ compare_len (struct mime_part *part, guint min, guint max)
 }
 
 static gboolean
-common_has_content_part (struct rspamd_task * task,
-	gchar *param_type,
-	gchar *param_subtype,
-	gint min_len,
-	gint max_len)
+common_has_content_part (struct rspamd_task * task, gchar *param_type, gchar *param_subtype, gint min_len, gint max_len)
 {
-	struct rspamd_regexp *re;
-	struct mime_part *part;
-	GList *cur;
-	GMimeContentType *ct;
-	gint r;
+	struct rspamd_regexp           *re;
+	struct mime_part               *part;
+	GList                          *cur;
+	GMimeContentType               *ct;
+	gint                            r;
 
 	cur = g_list_first (task->parts);
 	while (cur) {
@@ -2368,11 +2078,8 @@ common_has_content_part (struct rspamd_task * task,
 
 		if (*param_type == '/') {
 			/* This is regexp, so compile and create g_regexp object */
-			if ((re =
-				re_cache_check (param_type, task->cfg->cfg_pool)) == NULL) {
-				re = parse_regexp (task->cfg->cfg_pool,
-						param_type,
-						task->cfg->raw_mode);
+			if ((re = re_cache_check (param_type, task->cfg->cfg_pool)) == NULL) {
+				re = parse_regexp (task->cfg->cfg_pool, param_type, task->cfg->raw_mode);
 				if (re == NULL) {
 					msg_warn ("cannot compile regexp for function");
 					cur = g_list_next (cur);
@@ -2381,8 +2088,7 @@ common_has_content_part (struct rspamd_task * task,
 				re_cache_add (param_type, re, task->cfg->cfg_pool);
 			}
 			if ((r = task_cache_check (task, re)) == -1) {
-				if (ct->type &&
-					g_regex_match (re->regexp, ct->type, 0, NULL) == TRUE) {
+				if (ct->type && g_regex_match (re->regexp, ct->type, 0, NULL) == TRUE) {
 					if (param_subtype) {
 						if (compare_subtype (task, ct, param_subtype)) {
 							if (compare_len (part, min_len, max_len)) {
@@ -2437,8 +2143,8 @@ common_has_content_part (struct rspamd_task * task,
 static gboolean
 rspamd_has_content_part (struct rspamd_task * task, GList * args, void *unused)
 {
-	gchar *param_type = NULL, *param_subtype = NULL;
-	struct expression_argument *arg;
+	gchar                           *param_type = NULL, *param_subtype = NULL;
+	struct expression_argument     *arg;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -2457,13 +2163,11 @@ rspamd_has_content_part (struct rspamd_task * task, GList * args, void *unused)
 }
 
 static gboolean
-rspamd_has_content_part_len (struct rspamd_task * task,
-	GList * args,
-	void *unused)
+rspamd_has_content_part_len (struct rspamd_task * task, GList * args, void *unused)
 {
-	gchar *param_type = NULL, *param_subtype = NULL;
-	gint min = 0, max = 0;
-	struct expression_argument *arg;
+	gchar                           *param_type = NULL, *param_subtype = NULL;
+	gint                            min = 0, max = 0;
+	struct expression_argument     *arg;
 
 	if (args == NULL) {
 		msg_warn ("no parameters to function");
@@ -2482,9 +2186,7 @@ rspamd_has_content_part_len (struct rspamd_task * task,
 			errno = 0;
 			min = strtoul (arg->data, NULL, 10);
 			if (errno != 0) {
-				msg_warn ("invalid numeric value '%s': %s",
-					(gchar *)arg->data,
-					strerror (errno));
+				msg_warn ("invalid numeric value '%s': %s", (gchar *)arg->data, strerror (errno));
 				return FALSE;
 			}
 			args = args->next;
@@ -2492,9 +2194,7 @@ rspamd_has_content_part_len (struct rspamd_task * task,
 				arg = get_function_arg (args->data, task, TRUE);
 				max = strtoul (arg->data, NULL, 10);
 				if (errno != 0) {
-					msg_warn ("invalid numeric value '%s': %s",
-						(gchar *)arg->data,
-						strerror (errno));
+					msg_warn ("invalid numeric value '%s': %s", (gchar *)arg->data, strerror (errno));
 					return FALSE;
 				}
 			}
diff --git a/src/plugins/spf.c b/src/plugins/spf.c
index ecbb40889..8b9e64754 100644
--- a/src/plugins/spf.c
+++ b/src/plugins/spf.c
@@ -32,15 +32,15 @@
  * - whitelist (map): map of whitelisted networks
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "expressions.h"
-#include "hash.h"
 #include "main.h"
-#include "map.h"
 #include "message.h"
-#include "spf.h"
+#include "cfg_file.h"
+#include "expressions.h"
 #include "util.h"
+#include "map.h"
+#include "spf.h"
+#include "hash.h"
 
 #define DEFAULT_SYMBOL_FAIL "R_SPF_FAIL"
 #define DEFAULT_SYMBOL_SOFTFAIL "R_SPF_SOFTFAIL"
@@ -49,21 +49,21 @@
 #define DEFAULT_CACHE_MAXAGE 86400
 
 struct spf_ctx {
-	gint (*filter) (struct rspamd_task * task);
-	const gchar *symbol_fail;
-	const gchar *symbol_softfail;
-	const gchar *symbol_allow;
-
-	rspamd_mempool_t *spf_pool;
-	radix_tree_t *whitelist_ip;
-	rspamd_lru_hash_t *spf_hash;
+	gint                            (*filter) (struct rspamd_task * task);
+	const gchar                    *symbol_fail;
+	const gchar                    *symbol_softfail;
+	const gchar                    *symbol_allow;
+
+	rspamd_mempool_t                   *spf_pool;
+	radix_tree_t                    *whitelist_ip;
+	rspamd_lru_hash_t               *spf_hash;
 };
 
-static struct spf_ctx *spf_module_ctx = NULL;
+static struct spf_ctx        *spf_module_ctx = NULL;
 
-static void spf_symbol_callback (struct rspamd_task *task, void *unused);
-static GList * spf_record_copy (GList *addrs);
-static void spf_record_destroy (gpointer list);
+static void                   spf_symbol_callback (struct rspamd_task *task, void *unused);
+static GList *                spf_record_copy (GList *addrs);
+static void                   spf_record_destroy (gpointer list);
 
 /* Initialization */
 gint spf_module_init (struct rspamd_config *cfg, struct module_ctx **ctx);
@@ -83,8 +83,7 @@ spf_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 {
 	spf_module_ctx = g_malloc (sizeof (struct spf_ctx));
 
-	spf_module_ctx->spf_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	spf_module_ctx->spf_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 	*ctx = (struct module_ctx *)spf_module_ctx;
 
@@ -95,71 +94,56 @@ spf_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 gint
 spf_module_config (struct rspamd_config *cfg)
 {
-	const ucl_object_t *value;
-	gint res = TRUE;
-	guint cache_size, cache_expire;
+	const ucl_object_t             *value;
+	gint                            res = TRUE;
+	guint                           cache_size, cache_expire;
 
 	spf_module_ctx->whitelist_ip = radix_tree_create ();
-
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "spf", "symbol_fail")) != NULL) {
+	
+	if ((value = rspamd_config_get_module_opt (cfg, "spf", "symbol_fail")) != NULL) {
 		spf_module_ctx->symbol_fail = ucl_obj_tostring (value);
 	}
 	else {
 		spf_module_ctx->symbol_fail = DEFAULT_SYMBOL_FAIL;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "spf", "symbol_softfail")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "spf", "symbol_softfail")) != NULL) {
 		spf_module_ctx->symbol_softfail = ucl_obj_tostring (value);
 	}
 	else {
 		spf_module_ctx->symbol_softfail = DEFAULT_SYMBOL_SOFTFAIL;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "spf", "symbol_allow")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "spf", "symbol_allow")) != NULL) {
 		spf_module_ctx->symbol_allow = ucl_obj_tostring (value);
 	}
 	else {
 		spf_module_ctx->symbol_allow = DEFAULT_SYMBOL_ALLOW;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "spf", "spf_cache_size")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "spf", "spf_cache_size")) != NULL) {
 		cache_size = ucl_obj_toint (value);
 	}
 	else {
 		cache_size = DEFAULT_CACHE_SIZE;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "spf",
-		"spf_cache_expire")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "spf", "spf_cache_expire")) != NULL) {
 		cache_expire = ucl_obj_toint (value);
 	}
 	else {
 		cache_expire = DEFAULT_CACHE_MAXAGE;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "spf", "whitelist")) != NULL) {
-		if (!add_map (cfg, ucl_obj_tostring (value),
-			"SPF whitelist", read_radix_list, fin_radix_list,
-			(void **)&spf_module_ctx->whitelist_ip)) {
+	if ((value = rspamd_config_get_module_opt (cfg, "spf", "whitelist")) != NULL) {
+		if (! add_map (cfg, ucl_obj_tostring (value),
+				"SPF whitelist", read_radix_list, fin_radix_list,
+				(void **)&spf_module_ctx->whitelist_ip)) {
 			msg_warn ("cannot load whitelist from %s", value);
 		}
 	}
 
-	register_symbol (&cfg->cache,
-		spf_module_ctx->symbol_fail,
-		1,
-		spf_symbol_callback,
-		NULL);
+	register_symbol (&cfg->cache, spf_module_ctx->symbol_fail, 1, spf_symbol_callback, NULL);
 	register_virtual_symbol (&cfg->cache, spf_module_ctx->symbol_softfail, 1);
-	register_virtual_symbol (&cfg->cache, spf_module_ctx->symbol_allow,	   1);
+	register_virtual_symbol (&cfg->cache, spf_module_ctx->symbol_allow, 1);
 
-	spf_module_ctx->spf_hash = rspamd_lru_hash_new (rspamd_strcase_hash,
-			rspamd_strcase_equal,
-			cache_size,
-			cache_expire,
-			g_free,
-			spf_record_destroy);
+	spf_module_ctx->spf_hash = rspamd_lru_hash_new (rspamd_strcase_hash, rspamd_strcase_equal,
+			cache_size, cache_expire, g_free, spf_record_destroy);
 
 	return res;
 }
@@ -169,8 +153,7 @@ spf_module_reconfig (struct rspamd_config *cfg)
 {
 	rspamd_mempool_delete (spf_module_ctx->spf_pool);
 	radix_tree_free (spf_module_ctx->whitelist_ip);
-	spf_module_ctx->spf_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	spf_module_ctx->spf_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 	return spf_module_config (cfg);
 }
@@ -178,30 +161,26 @@ spf_module_reconfig (struct rspamd_config *cfg)
 static gboolean
 spf_check_element (struct spf_addr *addr, struct rspamd_task *task)
 {
-	gboolean res = FALSE;
-	guint8 *s, *d, t;
-	guint nbits, addrlen;
-	struct in_addr in4s, in4d;
-	struct in6_addr in6s, in6d;
+	gboolean                        res = FALSE;
+	guint8                         *s, *d, t;
+	guint                           nbits, addrlen;
+	struct in_addr					in4s, in4d;
+	struct in6_addr                 in6s, in6d;
 
 	/* Basic comparing algorithm */
 	if ((addr->data.normal.ipv6 && task->from_addr.af == AF_INET6) ||
-		(!addr->data.normal.ipv6 && task->from_addr.af == AF_INET)) {
+			(!addr->data.normal.ipv6 && task->from_addr.af == AF_INET)) {
 		if (addr->data.normal.ipv6) {
 			addrlen = sizeof (struct in6_addr);
-			memcpy (&in6s, &addr->data.normal.d.in6,
-				sizeof (struct in6_addr));
-			memcpy (&in6d, &task->from_addr.addr.s6.sin6_addr,
-				sizeof (struct in6_addr));
+			memcpy (&in6s, &addr->data.normal.d.in6, sizeof (struct in6_addr));
+			memcpy (&in6d, &task->from_addr.addr.s6.sin6_addr, sizeof (struct in6_addr));
 			s = (guint8 *)&in6s;
 			d = (guint8 *)&in6d;
 		}
 		else {
 			addrlen = sizeof (struct in_addr);
-			memcpy (&in4s, &addr->data.normal.d.in4,
-				sizeof (struct in_addr));
-			memcpy (&in4d, &task->from_addr.addr.s4.sin_addr,
-				sizeof (struct in_addr));
+			memcpy (&in4s, &addr->data.normal.d.in4, sizeof (struct in_addr));
+			memcpy (&in4d, &task->from_addr.addr.s4.sin_addr, sizeof (struct in_addr));
 			s = (guint8 *)&in4s;
 			d = (guint8 *)&in4d;
 		}
@@ -210,14 +189,12 @@ spf_check_element (struct spf_addr *addr, struct rspamd_task *task)
 		s += addrlen - 1;
 		d += addrlen - 1;
 		/* TODO: improve this cycle by masking by words */
-		for (nbits = 0;
-			nbits < addrlen * CHAR_BIT - addr->data.normal.mask;
-			nbits++) {
+		for (nbits = 0; nbits < addrlen * CHAR_BIT - addr->data.normal.mask; nbits ++) {
 			/* Skip bits from the beginning as we know that data is in network byte order */
 			if (nbits != 0 && nbits % 8 == 0) {
 				/* Move pointer to the next byte */
-				s--;
-				d--;
+				s --;
+				d --;
 				t = 0x1;
 			}
 			*s |= t;
@@ -243,28 +220,17 @@ spf_check_element (struct spf_addr *addr, struct rspamd_task *task)
 	if (res) {
 		switch (addr->mech) {
 		case SPF_FAIL:
-			insert_result (task,
-				spf_module_ctx->symbol_fail,
-				1,
-				g_list_prepend (NULL, addr->spf_string));
+			insert_result (task, spf_module_ctx->symbol_fail, 1, g_list_prepend (NULL, addr->spf_string));
 			task->messages = g_list_prepend (task->messages, "(SPF): spf fail");
 			break;
 		case SPF_SOFT_FAIL:
 		case SPF_NEUTRAL:
-			insert_result (task,
-				spf_module_ctx->symbol_softfail,
-				1,
-				g_list_prepend (NULL, addr->spf_string));
-			task->messages = g_list_prepend (task->messages,
-					"(SPF): spf softfail");
+			insert_result (task, spf_module_ctx->symbol_softfail, 1, g_list_prepend (NULL, addr->spf_string));
+			task->messages = g_list_prepend (task->messages, "(SPF): spf softfail");
 			break;
 		default:
-			insert_result (task,
-				spf_module_ctx->symbol_allow,
-				1,
-				g_list_prepend (NULL,			addr->spf_string));
-			task->messages =
-				g_list_prepend (task->messages, "(SPF): spf allow");
+			insert_result (task, spf_module_ctx->symbol_allow, 1, g_list_prepend (NULL, addr->spf_string));
+			task->messages = g_list_prepend (task->messages, "(SPF): spf allow");
 			break;
 		}
 		return TRUE;
@@ -276,8 +242,8 @@ spf_check_element (struct spf_addr *addr, struct rspamd_task *task)
 static gboolean
 spf_check_list (GList *list, struct rspamd_task *task)
 {
-	GList *cur;
-	struct spf_addr *addr;
+	GList                           *cur;
+	struct spf_addr                 *addr;
 
 	cur = list;
 
@@ -300,19 +266,16 @@ spf_check_list (GList *list, struct rspamd_task *task)
 	return FALSE;
 }
 
-static void
+static void 
 spf_plugin_callback (struct spf_record *record, struct rspamd_task *task)
 {
-	GList *l;
+	GList                           *l;
 
 	if (record && record->addrs && record->sender_domain) {
 
-		if ((l =
-			rspamd_lru_hash_lookup (spf_module_ctx->spf_hash,
-			record->sender_domain, task->tv.tv_sec)) == NULL) {
+		if ((l = rspamd_lru_hash_lookup (spf_module_ctx->spf_hash, record->sender_domain, task->tv.tv_sec)) == NULL) {
 			l = spf_record_copy (record->addrs);
-			rspamd_lru_hash_insert (spf_module_ctx->spf_hash,
-				g_strdup (record->sender_domain),
+			rspamd_lru_hash_insert (spf_module_ctx->spf_hash, g_strdup (record->sender_domain),
 				l, task->tv.tv_sec, record->ttl);
 		}
 		spf_check_list (l, task);
@@ -320,18 +283,16 @@ spf_plugin_callback (struct spf_record *record, struct rspamd_task *task)
 }
 
 
-static void
+static void 
 spf_symbol_callback (struct rspamd_task *task, void *unused)
 {
-	gchar *domain;
-	GList *l;
+	gchar                           *domain;
+	GList                           *l;
 
 	if (task->from_addr.af != AF_UNIX) {
 		domain = get_spf_domain (task);
 		if (domain) {
-			if ((l =
-				rspamd_lru_hash_lookup (spf_module_ctx->spf_hash, domain,
-				task->tv.tv_sec)) != NULL) {
+			if ((l = rspamd_lru_hash_lookup (spf_module_ctx->spf_hash, domain, task->tv.tv_sec)) != NULL) {
 				spf_check_list (l, task);
 			}
 			else if (!resolve_spf (task, spf_plugin_callback)) {
@@ -347,8 +308,8 @@ spf_symbol_callback (struct rspamd_task *task, void *unused)
 static GList *
 spf_record_copy (GList *addrs)
 {
-	GList *cur, *newl = NULL;
-	struct spf_addr *addr, *newa;
+	GList                           *cur, *newl = NULL;
+	struct spf_addr                 *addr, *newa;
 
 	cur = addrs;
 
@@ -380,8 +341,8 @@ spf_record_copy (GList *addrs)
 static void
 spf_record_destroy (gpointer list)
 {
-	GList *cur = list;
-	struct spf_addr *addr;
+	GList                           *cur = list;
+	struct spf_addr                 *addr;
 
 	while (cur) {
 		addr = cur->data;
diff --git a/src/plugins/surbl.c b/src/plugins/surbl.c
index bd4037228..ef25c1d78 100644
--- a/src/plugins/surbl.c
+++ b/src/plugins/surbl.c
@@ -41,27 +41,27 @@
  * - bit (string): describes a prefix for a single bit
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "dns.h"
-#include "expressions.h"
-#include "hash.h"
 #include "main.h"
-#include "map.h"
 #include "message.h"
+#include "cfg_file.h"
+#include "expressions.h"
 #include "util.h"
+#include "map.h"
+#include "dns.h"
+#include "hash.h"
 
 #include "surbl.h"
 
-static struct surbl_ctx *surbl_module_ctx = NULL;
+static struct surbl_ctx        *surbl_module_ctx = NULL;
 
 static void surbl_test_url (struct rspamd_task *task, void *user_data);
 static void dns_callback (struct rdns_reply *reply, gpointer arg);
 static void process_dns_results (struct rspamd_task *task,
-	struct suffix_item *suffix, gchar *url, guint32 addr);
+		struct suffix_item *suffix, gchar *url, guint32 addr);
 
 
-#define NO_REGEXP (gpointer) - 1
+#define NO_REGEXP (gpointer)-1
 
 #define SURBL_ERROR surbl_error_quark ()
 #define WHITELIST_ERROR 0
@@ -89,63 +89,50 @@ module_t surbl_module = {
 static void
 exception_insert (gpointer st, gconstpointer key, gpointer value)
 {
-	GHashTable **t = st;
-	gint level = 0;
-	const gchar *p = key;
-	f_str_t *val;
-
+	GHashTable                    **t = st;
+	gint                            level = 0;
+	const gchar                   *p = key;
+	f_str_t                        *val;
+	
 
 	while (*p) {
 		if (*p == '.') {
-			level++;
+			level ++;
 		}
-		p++;
+		p ++;
 	}
 	if (level >= MAX_LEVELS) {
-		msg_err ("invalid domain in exceptions list: %s, levels: %d",
-			(gchar *)key,
-			level);
+		msg_err ("invalid domain in exceptions list: %s, levels: %d", (gchar *)key, level);
 		return;
 	}
-
+	
 	val = g_malloc (sizeof (f_str_t));
 	val->begin = (gchar *)key;
 	val->len = strlen (key);
 	if (t[level] == NULL) {
-		t[level] = g_hash_table_new_full (fstr_strcase_hash,
-				fstr_strcase_equal,
-				g_free,
-				NULL);
+		t[level] = g_hash_table_new_full (fstr_strcase_hash, fstr_strcase_equal, g_free, NULL);
 	}
 	g_hash_table_insert (t[level], val, value);
 }
 
 static gchar *
-read_exceptions_list (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data)
+read_exceptions_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
 {
 	if (data->cur_data == NULL) {
-		data->cur_data = rspamd_mempool_alloc0 (pool,
-				sizeof (GHashTable *) * MAX_LEVELS);
+		data->cur_data = rspamd_mempool_alloc0 (pool, sizeof (GHashTable *) * MAX_LEVELS);
 	}
-	return abstract_parse_list (pool,
-			   chunk,
-			   len,
-			   data,
-			   (insert_func) exception_insert);
+	return abstract_parse_list (pool, chunk, len, data, (insert_func) exception_insert);
 }
 
 static void
 fin_exceptions_list (rspamd_mempool_t * pool, struct map_cb_data *data)
 {
-	GHashTable **t;
-	gint i;
+	GHashTable                    **t;
+	gint                            i;
 
 	if (data->prev_data) {
 		t = data->prev_data;
-		for (i = 0; i < MAX_LEVELS; i++) {
+		for (i = 0; i < MAX_LEVELS; i ++) {
 			if (t[i] != NULL) {
 				g_hash_table_destroy (t[i]);
 			}
@@ -156,16 +143,16 @@ fin_exceptions_list (rspamd_mempool_t * pool, struct map_cb_data *data)
 static void
 redirector_insert (gpointer st, gconstpointer key, gpointer value)
 {
-	GHashTable *t = st;
-	const gchar *p = key, *begin = key;
-	gchar *new;
-	gsize len;
-	GRegex *re = NO_REGEXP;
-	GError *err = NULL;
-	guint idx;
+	GHashTable                     *t = st;
+	const gchar                     *p = key, *begin = key;
+	gchar                          *new;
+	gsize                           len;
+	GRegex  			           *re = NO_REGEXP;
+	GError                         *err = NULL;
+	guint                           idx;
 
 	while (*p && !g_ascii_isspace (*p)) {
-		p++;
+		p ++;
 	}
 
 	len = p - begin;
@@ -178,17 +165,13 @@ redirector_insert (gpointer st, gconstpointer key, gpointer value)
 
 	if (g_ascii_isspace (*p)) {
 		while (g_ascii_isspace (*p) && *p) {
-			p++;
+			p ++;
 		}
 		if (*p) {
-			re = g_regex_new (p,
-					G_REGEX_RAW | G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE | G_REGEX_CASELESS,
-					0,
-					&err);
+			re = g_regex_new (p, G_REGEX_RAW | G_REGEX_OPTIMIZE | G_REGEX_NO_AUTO_CAPTURE | G_REGEX_CASELESS,
+					0, &err);
 			if (re == NULL) {
-				msg_warn ("could not read regexp: %s while reading regexp %s",
-					err->message,
-					p);
+				msg_warn ("could not read regexp: %s while reading regexp %s", err->message, p);
 				re = NO_REGEXP;
 			}
 		}
@@ -199,31 +182,21 @@ redirector_insert (gpointer st, gconstpointer key, gpointer value)
 static void
 redirector_item_free (gpointer p)
 {
-	GRegex *re;
+	GRegex                       *re;
 	if (p != NULL && p != NO_REGEXP) {
 		re = (GRegex *)p;
 		g_regex_unref (re);
 	}
 }
 
-static gchar *
-read_redirectors_list (rspamd_mempool_t * pool,
-	gchar * chunk,
-	gint len,
-	struct map_cb_data *data)
+static gchar                         *
+read_redirectors_list (rspamd_mempool_t * pool, gchar * chunk, gint len, struct map_cb_data *data)
 {
 	if (data->cur_data == NULL) {
-		data->cur_data = g_hash_table_new_full (rspamd_strcase_hash,
-				rspamd_strcase_equal,
-				g_free,
-				redirector_item_free);
+		data->cur_data = g_hash_table_new_full (rspamd_strcase_hash, rspamd_strcase_equal, g_free, redirector_item_free);
 	}
 
-	return abstract_parse_list (pool,
-			   chunk,
-			   len,
-			   data,
-			   (insert_func) redirector_insert);
+	return abstract_parse_list (pool, chunk, len, data, (insert_func) redirector_insert);
 }
 
 void
@@ -241,8 +214,7 @@ surbl_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 
 	surbl_module_ctx->use_redirector = 0;
 	surbl_module_ctx->suffixes = NULL;
-	surbl_module_ctx->surbl_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	surbl_module_ctx->surbl_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 	surbl_module_ctx->tld2_file = NULL;
 	surbl_module_ctx->whitelist_file = NULL;
@@ -250,28 +222,16 @@ surbl_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 	surbl_module_ctx->redirector_trie = rspamd_trie_create (TRUE);
 	surbl_module_ctx->redirector_ptrs = g_ptr_array_new ();
 
-	surbl_module_ctx->redirector_hosts = g_hash_table_new (rspamd_strcase_hash,
-			rspamd_strcase_equal);
-	surbl_module_ctx->whitelist = g_hash_table_new (rspamd_strcase_hash,
-			rspamd_strcase_equal);
+	surbl_module_ctx->redirector_hosts = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
+	surbl_module_ctx->whitelist = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
 	/* Zero exceptions hashes */
-	surbl_module_ctx->exceptions = rspamd_mempool_alloc0 (
-		surbl_module_ctx->surbl_pool,
-		MAX_LEVELS * sizeof (GHashTable *));
+	surbl_module_ctx->exceptions = rspamd_mempool_alloc0 (surbl_module_ctx->surbl_pool, MAX_LEVELS * sizeof (GHashTable *));
 	/* Register destructors */
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy,
-		surbl_module_ctx->whitelist);
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy,
-		surbl_module_ctx->redirector_hosts);
-
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) rspamd_trie_free,
-		surbl_module_ctx->redirector_trie);
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) g_ptr_array_unref,
-		surbl_module_ctx->redirector_ptrs);
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, surbl_module_ctx->whitelist);
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, surbl_module_ctx->redirector_hosts);
+
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) rspamd_trie_free, surbl_module_ctx->redirector_trie);
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_ptr_array_unref, surbl_module_ctx->redirector_ptrs);
 
 	*ctx = (struct module_ctx *)surbl_module_ctx;
 
@@ -284,8 +244,8 @@ surbl_module_init (struct rspamd_config *cfg, struct module_ctx **ctx)
 static void
 register_bit_symbols (struct rspamd_config *cfg, struct suffix_item *suffix)
 {
-	GList *cur;
-	struct surbl_bit_item *bit;
+	GList                           *cur;
+	struct surbl_bit_item          *bit;
 
 	if (suffix->bits != NULL) {
 		/* Prepend bit to symbol */
@@ -304,163 +264,131 @@ register_bit_symbols (struct rspamd_config *cfg, struct suffix_item *suffix)
 gint
 surbl_module_config (struct rspamd_config *cfg)
 {
-	GList *cur_opt;
-	struct suffix_item *new_suffix, *cur_suffix = NULL;
-	struct surbl_bit_item *new_bit;
+	GList                          *cur_opt;
+	struct suffix_item             *new_suffix, *cur_suffix = NULL;
+	struct surbl_bit_item          *new_bit;
 
-	const ucl_object_t *value, *cur, *cur_rule, *cur_bit;
-	ucl_object_iter_t it = NULL;
-	const gchar *redir_val;
-	guint32 bit;
-	gint i, idx;
+	const ucl_object_t                   *value, *cur, *cur_rule, *cur_bit;
+	ucl_object_iter_t               it = NULL;
+	const gchar                    *redir_val;
+	guint32                         bit;
+	gint                            i, idx;
 
 
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl", "redirector")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector")) != NULL) {
 		i = 0;
-		LL_FOREACH (value, cur)
-		{
-			i++;
+		LL_FOREACH (value, cur) {
+			i ++;
 		}
-		surbl_module_ctx->redirectors = rspamd_mempool_alloc0 (
-			surbl_module_ctx->surbl_pool,
-			i * sizeof (struct redirector_upstream));
+		surbl_module_ctx->redirectors = rspamd_mempool_alloc0 (surbl_module_ctx->surbl_pool,
+								i * sizeof (struct redirector_upstream));
 		idx = 0;
-		LL_FOREACH (value, cur)
-		{
+		LL_FOREACH (value, cur) {
 			redir_val = ucl_obj_tostring (cur);
 			surbl_module_ctx->redirectors[idx].up.priority = 100;
-			if (!rspamd_parse_host_port_priority (surbl_module_ctx->surbl_pool,
-				redir_val, &surbl_module_ctx->redirectors[idx].addr,
-				&surbl_module_ctx->redirectors[idx].port,
-				&surbl_module_ctx->redirectors[idx].up.priority)) {
+			if (! rspamd_parse_host_port_priority (surbl_module_ctx->surbl_pool,
+					redir_val, &surbl_module_ctx->redirectors[idx].addr,
+					&surbl_module_ctx->redirectors[idx].port,
+					&surbl_module_ctx->redirectors[idx].up.priority)) {
 				msg_warn ("invalid redirector definition: %s", redir_val);
 			}
 			else {
 				if (surbl_module_ctx->redirectors[idx].port != 0) {
-					surbl_module_ctx->redirectors[idx].name =
-						rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
+					surbl_module_ctx->redirectors[idx].name = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
 							redir_val);
-					msg_info ("add redirector %s",
-						surbl_module_ctx->redirectors[idx].name);
-					idx++;
+					msg_info ("add redirector %s", surbl_module_ctx->redirectors[idx].name);
+					idx ++;
 				}
 			}
-			i++;
+			i ++;
 		}
 		surbl_module_ctx->redirectors_number = idx;
-		surbl_module_ctx->use_redirector =
-			(surbl_module_ctx->redirectors_number != 0);
+		surbl_module_ctx->use_redirector = (surbl_module_ctx->redirectors_number != 0);
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl",
-		"redirector_symbol")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector_symbol")) != NULL) {
 		surbl_module_ctx->redirector_symbol = ucl_obj_tostring (value);
-		register_virtual_symbol (&cfg->cache,
-			surbl_module_ctx->redirector_symbol,
-			1.0);
+		register_virtual_symbol (&cfg->cache, surbl_module_ctx->redirector_symbol, 1.0);
 	}
 	else {
 		surbl_module_ctx->redirector_symbol = NULL;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl", "weight")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "weight")) != NULL) {
 		surbl_module_ctx->weight = ucl_obj_toint (value);
 	}
 	else {
 		surbl_module_ctx->weight = DEFAULT_SURBL_WEIGHT;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl", "url_expire")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "url_expire")) != NULL) {
 		surbl_module_ctx->url_expire = ucl_obj_todouble (value);
 	}
 	else {
 		surbl_module_ctx->url_expire = DEFAULT_SURBL_URL_EXPIRE;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl",
-		"redirector_connect_timeout")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector_connect_timeout")) != NULL) {
 		surbl_module_ctx->connect_timeout = ucl_obj_todouble (value);
 	}
 	else {
 		surbl_module_ctx->connect_timeout = DEFAULT_REDIRECTOR_CONNECT_TIMEOUT;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl",
-		"redirector_read_timeout")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector_read_timeout")) != NULL) {
 		surbl_module_ctx->read_timeout = ucl_obj_todouble (value);
 	}
 	else {
 		surbl_module_ctx->read_timeout = DEFAULT_REDIRECTOR_READ_TIMEOUT;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl",
-		"redirector_hosts_map")) != NULL) {
-		add_map (cfg, ucl_obj_tostring (
-				value),
-			"SURBL redirectors list", read_redirectors_list, fin_redirectors_list,
-			(void **)&surbl_module_ctx->redirector_hosts);
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "redirector_hosts_map")) != NULL) {
+		add_map (cfg, ucl_obj_tostring (value),
+				"SURBL redirectors list", read_redirectors_list, fin_redirectors_list,
+				(void **)&surbl_module_ctx->redirector_hosts);
 	}
 
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl", "max_urls")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "max_urls")) != NULL) {
 		surbl_module_ctx->max_urls = ucl_obj_toint (value);
 	}
 	else {
 		surbl_module_ctx->max_urls = DEFAULT_SURBL_MAX_URLS;
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl", "exceptions")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "exceptions")) != NULL) {
 		if (add_map (cfg, ucl_obj_tostring (value),
-			"SURBL exceptions list", read_exceptions_list, fin_exceptions_list,
-			(void **)&surbl_module_ctx->exceptions)) {
-			surbl_module_ctx->tld2_file = rspamd_mempool_strdup (
-				surbl_module_ctx->surbl_pool,
-				ucl_obj_tostring (value) + sizeof ("file://") - 1);
+				"SURBL exceptions list", read_exceptions_list, fin_exceptions_list,
+				(void **)&surbl_module_ctx->exceptions)) {
+			surbl_module_ctx->tld2_file = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
+					ucl_obj_tostring (value) + sizeof ("file://") - 1);
 		}
 	}
-	if ((value =
-		rspamd_config_get_module_opt (cfg, "surbl", "whitelist")) != NULL) {
+	if ((value = rspamd_config_get_module_opt (cfg, "surbl", "whitelist")) != NULL) {
 		if (add_map (cfg, ucl_obj_tostring (value),
-			"SURBL whitelist", read_host_list, fin_host_list,
-			(void **)&surbl_module_ctx->whitelist)) {
-			surbl_module_ctx->whitelist_file = rspamd_mempool_strdup (
-				surbl_module_ctx->surbl_pool,
-				ucl_obj_tostring (value) + sizeof ("file://") - 1);
+				"SURBL whitelist", read_host_list, fin_host_list,
+				(void **)&surbl_module_ctx->whitelist)) {
+			surbl_module_ctx->whitelist_file = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
+					ucl_obj_tostring (value) + sizeof ("file://") - 1);
 		}
 	}
 
 	value = rspamd_config_get_module_opt (cfg, "surbl", "rule");
 	if (value != NULL && value->type == UCL_OBJECT) {
-		LL_FOREACH (value, cur_rule)
-		{
+		LL_FOREACH (value, cur_rule) {
 			cur = ucl_obj_get_key (cur_rule, "suffix");
 			if (cur == NULL) {
 				msg_err ("surbl rule must have explicit symbol definition");
 				continue;
 			}
-			new_suffix = rspamd_mempool_alloc (surbl_module_ctx->surbl_pool,
-					sizeof (struct suffix_item));
-			new_suffix->suffix = rspamd_mempool_strdup (
-				surbl_module_ctx->surbl_pool,
-				ucl_obj_tostring (cur));
+			new_suffix = rspamd_mempool_alloc (surbl_module_ctx->surbl_pool, sizeof (struct suffix_item));
+			new_suffix->suffix = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
+					ucl_obj_tostring (cur));
 			new_suffix->options = 0;
 			new_suffix->bits = NULL;
 
 			cur = ucl_obj_get_key (cur_rule, "symbol");
 			if (cur == NULL) {
-				msg_warn (
-					"surbl rule for suffix %s lacks symbol, using %s as symbol",
-					new_suffix->suffix,
-					DEFAULT_SURBL_SYMBOL);
-				new_suffix->symbol = rspamd_mempool_strdup (
-					surbl_module_ctx->surbl_pool,
-					DEFAULT_SURBL_SYMBOL);
+				msg_warn ("surbl rule for suffix %s lacks symbol, using %s as symbol", new_suffix->suffix,
+						DEFAULT_SURBL_SYMBOL);
+				new_suffix->symbol = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
+						DEFAULT_SURBL_SYMBOL);
 			}
 			else {
-				new_suffix->symbol = rspamd_mempool_strdup (
-					surbl_module_ctx->surbl_pool,
-					ucl_obj_tostring (cur));
+				new_suffix->symbol = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool,
+						ucl_obj_tostring (cur));
 			}
 			cur = ucl_obj_get_key (cur_rule, "options");
 			if (cur != NULL && cur->type == UCL_STRING) {
@@ -471,33 +399,19 @@ surbl_module_config (struct rspamd_config *cfg)
 			cur = ucl_obj_get_key (cur_rule, "bits");
 			if (cur != NULL && cur->type == UCL_OBJECT) {
 				it = NULL;
-				while ((cur_bit =
-					ucl_iterate_object (cur, &it, true)) != NULL) {
-					if (ucl_object_key (cur_bit) != NULL && cur_bit->type ==
-						UCL_INT) {
+				while ((cur_bit = ucl_iterate_object (cur, &it, true)) != NULL) {
+					if (ucl_object_key (cur_bit) != NULL && cur_bit->type == UCL_INT) {
 						bit = ucl_obj_toint (cur_bit);
-						new_bit = rspamd_mempool_alloc (
-							surbl_module_ctx->surbl_pool,
-							sizeof (struct surbl_bit_item));
+						new_bit = rspamd_mempool_alloc (surbl_module_ctx->surbl_pool, sizeof (struct surbl_bit_item));
 						new_bit->bit = bit;
-						new_bit->symbol = rspamd_mempool_strdup (
-							surbl_module_ctx->surbl_pool,
-							ucl_object_key (cur_bit));
-						msg_debug ("add new bit suffix: %d with symbol: %s",
-							(gint)new_bit->bit, new_bit->symbol);
-						new_suffix->bits = g_list_prepend (new_suffix->bits,
-								new_bit);
+						new_bit->symbol = rspamd_mempool_strdup (surbl_module_ctx->surbl_pool, ucl_object_key (cur_bit));
+						msg_debug ("add new bit suffix: %d with symbol: %s", (gint)new_bit->bit, new_bit->symbol);
+						new_suffix->bits = g_list_prepend (new_suffix->bits, new_bit);
 					}
 				}
 			}
-			surbl_module_ctx->suffixes = g_list_prepend (
-				surbl_module_ctx->suffixes,
-				new_suffix);
-			register_callback_symbol (&cfg->cache,
-				new_suffix->symbol,
-				1,
-				surbl_test_url,
-				new_suffix);
+			surbl_module_ctx->suffixes = g_list_prepend (surbl_module_ctx->suffixes, new_suffix);
+			register_callback_symbol (&cfg->cache, new_suffix->symbol, 1, surbl_test_url, new_suffix);
 		}
 	}
 	/* Add default suffix */
@@ -507,9 +421,8 @@ surbl_module_config (struct rspamd_config *cfg)
 	}
 
 	if (surbl_module_ctx->suffixes != NULL) {
-		rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-			(rspamd_mempool_destruct_t) g_list_free,
-			surbl_module_ctx->suffixes);
+		rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_list_free,
+				surbl_module_ctx->suffixes);
 	}
 
 	cur_opt = surbl_module_ctx->suffixes;
@@ -517,9 +430,8 @@ surbl_module_config (struct rspamd_config *cfg)
 		cur_suffix = cur_opt->data;
 		if (cur_suffix->bits != NULL) {
 			register_bit_symbols (cfg, cur_suffix);
-			rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-				(rspamd_mempool_destruct_t) g_list_free,
-				cur_suffix->bits);
+			rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_list_free,
+					cur_suffix->bits);
 		}
 		cur_opt = g_list_next (cur_opt);
 	}
@@ -535,40 +447,25 @@ surbl_module_reconfig (struct rspamd_config *cfg)
 	/* Reinit module */
 	surbl_module_ctx->use_redirector = 0;
 	surbl_module_ctx->suffixes = NULL;
-	surbl_module_ctx->surbl_pool = rspamd_mempool_new (
-		rspamd_mempool_suggest_size ());
+	surbl_module_ctx->surbl_pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
 
 	surbl_module_ctx->tld2_file = NULL;
 	surbl_module_ctx->whitelist_file = NULL;
 	surbl_module_ctx->redirectors_number = 0;
 	surbl_module_ctx->redirector_trie = rspamd_trie_create (TRUE);
 
-	surbl_module_ctx->redirector_hosts = g_hash_table_new (rspamd_strcase_hash,
-			rspamd_strcase_equal);
-	surbl_module_ctx->whitelist = g_hash_table_new (rspamd_strcase_hash,
-			rspamd_strcase_equal);
+	surbl_module_ctx->redirector_hosts = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
+	surbl_module_ctx->whitelist = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
 	/* Zero exceptions hashes */
-	surbl_module_ctx->exceptions = rspamd_mempool_alloc0 (
-		surbl_module_ctx->surbl_pool,
-		MAX_LEVELS * sizeof (GHashTable *));
+	surbl_module_ctx->exceptions = rspamd_mempool_alloc0 (surbl_module_ctx->surbl_pool, MAX_LEVELS * sizeof (GHashTable *));
 	/* Register destructors */
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy,
-		surbl_module_ctx->whitelist);
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) g_hash_table_destroy,
-		surbl_module_ctx->redirector_hosts);
-
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) g_list_free,
-		surbl_module_ctx->suffixes);
-
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) rspamd_trie_free,
-		surbl_module_ctx->redirector_trie);
-	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool,
-		(rspamd_mempool_destruct_t) g_ptr_array_unref,
-		surbl_module_ctx->redirector_ptrs);
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, surbl_module_ctx->whitelist);
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_hash_table_destroy, surbl_module_ctx->redirector_hosts);
+
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_list_free, surbl_module_ctx->suffixes);
+	
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) rspamd_trie_free, surbl_module_ctx->redirector_trie);
+	rspamd_mempool_add_destructor (surbl_module_ctx->surbl_pool, (rspamd_mempool_destruct_t) g_ptr_array_unref, surbl_module_ctx->redirector_ptrs);
 
 	/* Perform configure */
 	return surbl_module_config (cfg);
@@ -576,22 +473,16 @@ surbl_module_reconfig (struct rspamd_config *cfg)
 
 
 
-static gchar *
-format_surbl_request (rspamd_mempool_t * pool,
-	f_str_t * hostname,
-	struct suffix_item *suffix,
-	gboolean append_suffix,
-	GError ** err,
-	gboolean forced,
-	GTree *tree)
+static gchar                    *
+format_surbl_request (rspamd_mempool_t * pool, f_str_t * hostname, struct suffix_item *suffix,
+		gboolean append_suffix, GError ** err, gboolean forced, GTree *tree)
 {
-	GHashTable *t;
-	gchar *result = NULL, *dots[MAX_LEVELS],
-		num_buf[sizeof("18446744073709551616")], *p;
-	gint len, slen, r, i, dots_num = 0, level = MAX_LEVELS;
-	gboolean is_numeric = TRUE;
-	guint64 ip_num;
-	f_str_t f;
+	GHashTable                     *t;
+	gchar                           *result = NULL, *dots[MAX_LEVELS], num_buf[sizeof("18446744073709551616")], *p;
+	gint                            len, slen, r, i, dots_num = 0, level = MAX_LEVELS;
+	gboolean                        is_numeric = TRUE;
+	guint64                         ip_num;
+	f_str_t                         f;
 
 	if (G_LIKELY (suffix != NULL)) {
 		slen = strlen (suffix->suffix);
@@ -603,19 +494,19 @@ format_surbl_request (rspamd_mempool_t * pool,
 		g_assert_not_reached ();
 	}
 	len = hostname->len + slen + 2;
-
+	
 	p = hostname->begin;
 	while (p - hostname->begin < (gint)hostname->len && dots_num < MAX_LEVELS) {
 		if (*p == '.') {
 			dots[dots_num] = p;
-			dots_num++;
+			dots_num ++;
 		}
-		else if (!g_ascii_isdigit (*p)) {
+		else if (! g_ascii_isdigit (*p)) {
 			is_numeric = FALSE;
 		}
-		p++;
+		p ++;
 	}
-
+	
 	/* Check for numeric expressions */
 	if (is_numeric && dots_num == 3) {
 		/* This is ip address */
@@ -625,7 +516,7 @@ format_surbl_request (rspamd_mempool_t * pool,
 			return NULL;
 		}
 		result = rspamd_mempool_alloc (pool, len);
-		r = rspamd_snprintf (result, len, "%*s.%*s.%*s.%*s",
+		r = rspamd_snprintf (result, len, "%*s.%*s.%*s.%*s", 
 				(gint)(hostname->len - (dots[2] - hostname->begin + 1)),
 				dots[2] + 1,
 				(gint)(dots[2] - dots[1] - 1),
@@ -642,16 +533,13 @@ format_surbl_request (rspamd_mempool_t * pool,
 			msg_info ("ignore request of ip url for list %s", suffix->symbol);
 			return NULL;
 		}
-		rspamd_strlcpy (num_buf, hostname->begin,
-			MIN (hostname->len + 1, sizeof (num_buf)));
+		rspamd_strlcpy (num_buf, hostname->begin, MIN (hostname->len + 1, sizeof (num_buf)));
 		errno = 0;
 		ip_num = strtoull (num_buf, NULL, 10);
 		if (errno != 0) {
-			msg_info ("cannot convert ip to number '%s': %s",
-				num_buf,
-				strerror (errno));
-			g_set_error (err, SURBL_ERROR, /* error domain */
-				CONVERSION_ERROR,   /* error code */
+			msg_info ("cannot convert ip to number '%s': %s", num_buf, strerror (errno));
+			g_set_error (err, SURBL_ERROR,	/* error domain */
+				CONVERSION_ERROR,	/* error code */
 				"URL cannot be decoded");
 			return NULL;
 		}
@@ -661,25 +549,19 @@ format_surbl_request (rspamd_mempool_t * pool,
 		/* Hack for bugged windows resolver */
 		ip_num &= 0xFFFFFFFF;
 		/* Get octets */
-		r = rspamd_snprintf (result,
-				len,
-				"%ud.%ud.%ud.%ud",
-				(guint32) ip_num & 0x000000FF,
-				(guint32) (ip_num & 0x0000FF00) >> 8,
-				(guint32) (ip_num & 0x00FF0000) >> 16,
-				(guint32) (ip_num & 0xFF000000) >> 24);
+		r = rspamd_snprintf (result, len, "%ud.%ud.%ud.%ud",
+			(guint32) ip_num & 0x000000FF, (guint32) (ip_num & 0x0000FF00) >> 8, (guint32) (ip_num & 0x00FF0000) >> 16, (guint32) (ip_num & 0xFF000000) >> 24);
 	}
 	else {
 		/* Not a numeric url */
 		result = rspamd_mempool_alloc (pool, len);
 		/* Now we should try to check for exceptions */
-		if (!forced) {
-			for (i = MAX_LEVELS - 1; i >= 0; i--) {
+		if (! forced) {
+			for (i = MAX_LEVELS - 1; i >= 0; i --) {
 				t = surbl_module_ctx->exceptions[i];
 				if (t != NULL && dots_num >= i + 1) {
 					f.begin = dots[dots_num - i - 1] + 1;
-					f.len = hostname->len -
-						(dots[dots_num - i - 1] - hostname->begin + 1);
+					f.len = hostname->len - (dots[dots_num - i - 1] - hostname->begin + 1);
 					if (g_hash_table_lookup (t, &f) != NULL) {
 						level = dots_num - i - 1;
 						break;
@@ -689,41 +571,31 @@ format_surbl_request (rspamd_mempool_t * pool,
 		}
 		if (level != MAX_LEVELS) {
 			if (level == 0) {
-				r = rspamd_snprintf (result,
-						len,
-						"%*s",
-						(gint)hostname->len,
-						hostname->begin);
+				r = rspamd_snprintf (result, len, "%*s", (gint)hostname->len, hostname->begin);
 			}
 			else {
-				r = rspamd_snprintf (result, len, "%*s",
-						(gint)(hostname->len -
-						(dots[level - 1] - hostname->begin + 1)),
-						dots[level - 1] + 1);
+				r = rspamd_snprintf (result, len, "%*s", 
+					(gint)(hostname->len - (dots[level - 1] - hostname->begin + 1)),
+					dots[level - 1] + 1);
 			}
 		}
 		else if (dots_num >= 2) {
 			r = rspamd_snprintf (result, len, "%*s",
-					(gint)(hostname->len -
-					(dots[dots_num - 2] - hostname->begin + 1)),
+					(gint)(hostname->len - (dots[dots_num - 2] - hostname->begin + 1)),
 					dots[dots_num - 2] + 1);
 		}
 		else {
-			r = rspamd_snprintf (result,
-					len,
-					"%*s",
-					(gint)hostname->len,
-					hostname->begin);
+			r = rspamd_snprintf (result, len, "%*s", (gint)hostname->len, hostname->begin);
 		}
 	}
 
 	if (tree != NULL) {
 		if (g_tree_lookup (tree, result) != NULL) {
 			msg_debug ("url %s is already registered", result);
-			g_set_error (err, SURBL_ERROR, /* error domain */
-				DUPLICATE_ERROR,        /* error code */
-				"URL is duplicated: %s",        /* error message format string */
-				result);
+			g_set_error (err, SURBL_ERROR,	/* error domain */
+					DUPLICATE_ERROR,	/* error code */
+					"URL is duplicated: %s",	/* error message format string */
+					result);
 			return NULL;
 		}
 		else {
@@ -731,13 +603,12 @@ format_surbl_request (rspamd_mempool_t * pool,
 		}
 	}
 
-	if (!forced &&
-		g_hash_table_lookup (surbl_module_ctx->whitelist, result) != NULL) {
+	if (!forced && g_hash_table_lookup (surbl_module_ctx->whitelist, result) != NULL) {
 		msg_debug ("url %s is whitelisted", result);
-		g_set_error (err, SURBL_ERROR, /* error domain */
-			WHITELIST_ERROR,                /* error code */
-			"URL is whitelisted: %s",               /* error message format string */
-			result);
+		g_set_error (err, SURBL_ERROR,	/* error domain */
+						WHITELIST_ERROR,	/* error code */
+						"URL is whitelisted: %s",	/* error message format string */
+						result);
 		return NULL;
 	}
 
@@ -746,48 +617,38 @@ format_surbl_request (rspamd_mempool_t * pool,
 		rspamd_snprintf (result + r, len - r, ".%s", suffix->suffix);
 	}
 
-	msg_debug ("request: %s, dots: %d, level: %d, orig: %*s",
-		result,
-		dots_num,
-		level,
-		(gint)hostname->len,
-		hostname->begin);
+	msg_debug ("request: %s, dots: %d, level: %d, orig: %*s", result, dots_num, level, (gint)hostname->len, hostname->begin);
 
 	return result;
 }
 
 static void
 make_surbl_requests (struct uri *url, struct rspamd_task *task,
-	struct suffix_item *suffix, gboolean forced, GTree *tree)
+		struct suffix_item *suffix, gboolean forced, GTree *tree)
 {
-	gchar *surbl_req;
-	f_str_t f;
-	GError *err = NULL;
-	struct dns_param *param;
+	gchar                           *surbl_req;
+	f_str_t                         f;
+	GError                         *err = NULL;
+	struct dns_param               *param;
 
 	f.begin = url->host;
 	f.len = url->hostlen;
 
 	if ((surbl_req = format_surbl_request (task->task_pool, &f, suffix, TRUE,
-		&err, forced, tree)) != NULL) {
-		param =
-			rspamd_mempool_alloc (task->task_pool, sizeof (struct dns_param));
+			&err, forced, tree)) != NULL) {
+		param = rspamd_mempool_alloc (task->task_pool, sizeof (struct dns_param));
 		param->url = url;
 		param->task = task;
 		param->suffix = suffix;
-		param->host_resolve =
-			rspamd_mempool_strdup (task->task_pool, surbl_req);
+		param->host_resolve = rspamd_mempool_strdup (task->task_pool, surbl_req);
 		debug_task ("send surbl dns request %s", surbl_req);
-		if (make_dns_request (task->resolver, task->s, task->task_pool,
-			dns_callback,
-			(void *)param, RDNS_REQUEST_A, surbl_req)) {
-			task->dns_requests++;
+		if (make_dns_request (task->resolver, task->s, task->task_pool, dns_callback,
+				(void *)param, RDNS_REQUEST_A, surbl_req)) {
+			task->dns_requests ++;
 		}
 	}
-	else if (err != NULL && err->code != WHITELIST_ERROR && err->code !=
-		DUPLICATE_ERROR) {
-		msg_info ("cannot format url string for surbl %s, %s", struri (
-				url), err->message);
+	else if (err != NULL && err->code != WHITELIST_ERROR && err->code != DUPLICATE_ERROR) {
+		msg_info ("cannot format url string for surbl %s, %s", struri (url), err->message);
 		g_error_free (err);
 		return;
 	}
@@ -797,67 +658,58 @@ make_surbl_requests (struct uri *url, struct rspamd_task *task,
 }
 
 static void
-process_dns_results (struct rspamd_task *task,
-	struct suffix_item *suffix,
-	gchar *url,
-	guint32 addr)
+process_dns_results (struct rspamd_task *task, struct suffix_item *suffix, gchar *url, guint32 addr)
 {
-	GList *cur;
-	struct surbl_bit_item *bit;
+	GList                           *cur;
+	struct surbl_bit_item          *bit;
 
 	if (suffix->bits != NULL) {
 		cur = g_list_first (suffix->bits);
 
 		while (cur) {
 			bit = (struct surbl_bit_item *)cur->data;
-			debug_task ("got result(%d) AND bit(%d): %d",
-				(gint)addr,
-				(gint)ntohl (bit->bit),
-				(gint)bit->bit & (gint)ntohl (addr));
+			debug_task ("got result(%d) AND bit(%d): %d", (gint)addr, (gint)ntohl (bit->bit),
+					(gint)bit->bit & (gint)ntohl (addr));
 			if (((gint)bit->bit & (gint)ntohl (addr)) != 0) {
 				insert_result (task, bit->symbol, 1,
-					g_list_prepend (NULL,
-					rspamd_mempool_strdup (task->task_pool, url)));
+						g_list_prepend (NULL, rspamd_mempool_strdup (task->task_pool, url)));
 			}
 			cur = g_list_next (cur);
 		}
 	}
 	else {
-		insert_result (task, suffix->symbol, 1,
-			g_list_prepend (NULL,
-			rspamd_mempool_strdup (task->task_pool, url)));
+		insert_result (task, suffix->symbol, 1, g_list_prepend (NULL, rspamd_mempool_strdup (task->task_pool, url)));
 	}
 }
 
 static void
 dns_callback (struct rdns_reply *reply, gpointer arg)
 {
-	struct dns_param *param = (struct dns_param *)arg;
-	struct rspamd_task *task = param->task;
-	struct rdns_reply_entry *elt;
+	struct dns_param               *param = (struct dns_param *)arg;
+	struct rspamd_task             *task = param->task;
+	struct rdns_reply_entry        *elt;
 
 	debug_task ("in surbl request callback");
 	/* If we have result from DNS server, this url exists in SURBL, so increase score */
 	if (reply->code == RDNS_RC_NOERROR && reply->entries) {
 		msg_info ("<%s> domain [%s] is in surbl %s", param->task->message_id,
-			param->host_resolve, param->suffix->suffix);
+				param->host_resolve, param->suffix->suffix);
 		elt = reply->entries;
 		if (elt->type == RDNS_REQUEST_A) {
 			process_dns_results (param->task, param->suffix,
-				param->host_resolve, (guint32)elt->content.a.addr.s_addr);
+					param->host_resolve, (guint32)elt->content.a.addr.s_addr);
 		}
 	}
 	else {
 		debug_task ("<%s> domain [%s] is not in surbl %s",
-			param->task->message_id, param->host_resolve,
-			param->suffix->suffix);
+				param->task->message_id, param->host_resolve, param->suffix->suffix);
 	}
 }
 
 static void
 free_redirector_session (void *ud)
 {
-	struct redirector_param *param = (struct redirector_param *)ud;
+	struct redirector_param        *param = (struct redirector_param *)ud;
 
 	event_del (&param->ev);
 	g_string_free (param->buf, TRUE);
@@ -867,55 +719,38 @@ free_redirector_session (void *ud)
 static void
 redirector_callback (gint fd, short what, void *arg)
 {
-	struct redirector_param *param = (struct redirector_param *)arg;
-	struct rspamd_task *task = param->task;
-	gchar url_buf[512];
-	gint r;
-	struct timeval *timeout;
-	gchar *p, *c;
-	gboolean found = FALSE;
+	struct redirector_param        *param = (struct redirector_param *)arg;
+	struct rspamd_task             *task = param->task;
+	gchar                           url_buf[512];
+	gint                            r;
+	struct timeval                 *timeout;
+	gchar                           *p, *c;
+	gboolean						 found = FALSE;
 
 	switch (param->state) {
 	case STATE_CONNECT:
 		/* We have write readiness after connect call, so reinit event */
 		if (what == EV_WRITE) {
-			timeout =
-				rspamd_mempool_alloc (param->task->task_pool,
-					sizeof (struct timeval));
+			timeout = rspamd_mempool_alloc (param->task->task_pool, sizeof (struct timeval));
 			timeout->tv_sec = surbl_module_ctx->read_timeout / 1000;
-			timeout->tv_usec =
-				(surbl_module_ctx->read_timeout - timeout->tv_sec *
-				1000) * 1000;
+			timeout->tv_usec = (surbl_module_ctx->read_timeout - timeout->tv_sec * 1000) * 1000;
 			event_del (&param->ev);
-			event_set (&param->ev,
-				param->sock,
-				EV_READ | EV_PERSIST,
-				redirector_callback,
-				(void *)param);
+			event_set (&param->ev, param->sock, EV_READ | EV_PERSIST, redirector_callback, (void *)param);
 			event_add (&param->ev, timeout);
-			r = rspamd_snprintf (url_buf,
-					sizeof (url_buf),
-					"GET %s HTTP/1.0\r\n\r\n",
-					struri (param->url));
+			r = rspamd_snprintf (url_buf, sizeof (url_buf), "GET %s HTTP/1.0\r\n\r\n", struri (param->url));
 			if (write (param->sock, url_buf, r) == -1) {
-				msg_err ("write failed %s to %s", strerror (
-						errno), param->redirector->name);
+				msg_err ("write failed %s to %s", strerror (errno), param->redirector->name);
 				upstream_fail (&param->redirector->up, param->task->tv.tv_sec);
-				remove_normal_event (param->task->s,
-					free_redirector_session,
-					param);
+				remove_normal_event (param->task->s, free_redirector_session, param);
 				return;
 			}
 			param->state = STATE_READ;
 		}
 		else {
-			msg_info (
-				"<%s> connection to redirector %s timed out while waiting for write",
-				param->task->message_id,
-				param->redirector->name);
+			msg_info ("<%s> connection to redirector %s timed out while waiting for write",
+					param->task->message_id, param->redirector->name);
 			upstream_fail (&param->redirector->up, param->task->tv.tv_sec);
-			remove_normal_event (param->task->s, free_redirector_session,
-				param);
+			remove_normal_event (param->task->s, free_redirector_session, param);
 
 			return;
 		}
@@ -924,17 +759,10 @@ redirector_callback (gint fd, short what, void *arg)
 		if (what == EV_READ) {
 			r = read (param->sock, url_buf, sizeof (url_buf) - 1);
 			if (r <= 0) {
-				msg_err ("read failed: %s from %s", strerror (
-						errno), param->redirector->name);
+				msg_err ("read failed: %s from %s", strerror (errno), param->redirector->name);
 				upstream_fail (&param->redirector->up, param->task->tv.tv_sec);
-				make_surbl_requests (param->url,
-					param->task,
-					param->suffix,
-					FALSE,
-					param->tree);
-				remove_normal_event (param->task->s,
-					free_redirector_session,
-					param);
+				make_surbl_requests (param->url, param->task, param->suffix, FALSE, param->tree);
+				remove_normal_event (param->task->s, free_redirector_session, param);
 				return;
 			}
 
@@ -951,36 +779,21 @@ redirector_callback (gint fd, short what, void *arg)
 					}
 				}
 				if (found) {
-					debug_task ("<%s> got reply from redirector: '%s' -> '%s'",
-						param->task->message_id,
-						struri (param->url),
-						c);
-					r =
-						parse_uri (param->url,
-							rspamd_mempool_strdup (param->task->task_pool,
-							c), param->task->task_pool);
-					if (r == URI_ERRNO_OK || r == URI_ERRNO_NO_SLASHES || r ==
-						URI_ERRNO_NO_HOST_SLASH) {
-						make_surbl_requests (param->url,
-							param->task,
-							param->suffix,
-							FALSE,
-							param->tree);
+					debug_task ("<%s> got reply from redirector: '%s' -> '%s'", param->task->message_id, struri (param->url), c);
+					r = parse_uri (param->url, rspamd_mempool_strdup (param->task->task_pool, c), param->task->task_pool);
+					if (r == URI_ERRNO_OK || r == URI_ERRNO_NO_SLASHES || r == URI_ERRNO_NO_HOST_SLASH) {
+						make_surbl_requests (param->url, param->task, param->suffix, FALSE, param->tree);
 					}
 				}
 			}
 			upstream_ok (&param->redirector->up, param->task->tv.tv_sec);
-			remove_normal_event (param->task->s, free_redirector_session,
-				param);
+			remove_normal_event (param->task->s, free_redirector_session, param);
 		}
 		else {
-			msg_info (
-				"<%s> reading redirector %s timed out, while waiting for read",
-				param->redirector->name,
-				param->task->message_id);
+			msg_info ("<%s> reading redirector %s timed out, while waiting for read",
+					param->redirector->name, param->task->message_id);
 			upstream_fail (&param->redirector->up, param->task->tv.tv_sec);
-			remove_normal_event (param->task->s, free_redirector_session,
-				param);
+			remove_normal_event (param->task->s, free_redirector_session, param);
 		}
 		break;
 	}
@@ -989,42 +802,30 @@ redirector_callback (gint fd, short what, void *arg)
 
 static void
 register_redirector_call (struct uri *url, struct rspamd_task *task,
-	struct suffix_item *suffix, const gchar *rule, GTree *tree)
+		struct suffix_item *suffix, const gchar *rule, GTree *tree)
 {
-	gint s = -1;
-	struct redirector_param *param;
-	struct timeval *timeout;
-	struct redirector_upstream *selected;
-
-	selected = (struct redirector_upstream *)get_upstream_round_robin (
-		surbl_module_ctx->redirectors,
-		surbl_module_ctx->redirectors_number,
-		sizeof (struct redirector_upstream),
-		task->tv.tv_sec,
-		DEFAULT_UPSTREAM_ERROR_TIME,
-		DEFAULT_UPSTREAM_DEAD_TIME,
-		DEFAULT_UPSTREAM_MAXERRORS);
+	gint                            s = -1;
+	struct redirector_param        *param;
+	struct timeval                 *timeout;
+	struct redirector_upstream     *selected;
+
+	selected = (struct redirector_upstream *)get_upstream_round_robin (surbl_module_ctx->redirectors,
+										 surbl_module_ctx->redirectors_number,
+										 sizeof (struct redirector_upstream),
+										 task->tv.tv_sec, DEFAULT_UPSTREAM_ERROR_TIME,
+										 DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
 
 	if (selected) {
-		s = make_universal_socket (selected->addr,
-				selected->port,
-				SOCK_STREAM,
-				TRUE,
-				FALSE,
-				FALSE);
+		s = make_universal_socket (selected->addr, selected->port, SOCK_STREAM, TRUE, FALSE, FALSE);
 	}
 
 	if (s == -1) {
-		msg_info ("<%s> cannot create tcp socket failed: %s",
-			task->message_id,
-			strerror (errno));
+		msg_info ("<%s> cannot create tcp socket failed: %s", task->message_id, strerror (errno));
 		make_surbl_requests (url, task, suffix, FALSE, tree);
 		return;
 	}
 
-	param =
-		rspamd_mempool_alloc (task->task_pool,
-			sizeof (struct redirector_param));
+	param = rspamd_mempool_alloc (task->task_pool, sizeof (struct redirector_param));
 	param->url = url;
 	param->task = task;
 	param->state = STATE_CONNECT;
@@ -1035,33 +836,25 @@ register_redirector_call (struct uri *url, struct rspamd_task *task,
 	param->tree = tree;
 	timeout = rspamd_mempool_alloc (task->task_pool, sizeof (struct timeval));
 	timeout->tv_sec = surbl_module_ctx->connect_timeout / 1000;
-	timeout->tv_usec =
-		(surbl_module_ctx->connect_timeout - timeout->tv_sec * 1000) * 1000;
+	timeout->tv_usec = (surbl_module_ctx->connect_timeout - timeout->tv_sec * 1000) * 1000;
 	event_set (&param->ev, s, EV_WRITE, redirector_callback, (void *)param);
 	event_add (&param->ev, timeout);
-	register_async_event (task->s,
-		free_redirector_session,
-		param,
-		g_quark_from_static_string ("surbl"));
-
-	msg_info (
-		"<%s> registered redirector call for %s to %s, according to rule: %s",
-		task->message_id,
-		struri (url),
-		selected->name,
-		rule);
+	register_async_event (task->s, free_redirector_session, param, g_quark_from_static_string ("surbl"));
+
+	msg_info ("<%s> registered redirector call for %s to %s, according to rule: %s",
+			task->message_id, struri (url), selected->name, rule);
 }
 
-static gboolean
+static                          gboolean
 surbl_tree_url_callback (gpointer key, gpointer value, void *data)
 {
-	struct redirector_param *param = data;
-	struct rspamd_task *task;
-	struct uri *url = value;
-	gchar *red_domain;
-	const gchar *pos;
-	GRegex *re;
-	guint idx, len;
+	struct redirector_param        *param = data;
+	struct rspamd_task             *task;
+	struct uri                     *url = value;
+	gchar                          *red_domain;
+	const gchar                    *pos;
+	GRegex                         *re;
+	guint                           idx, len;
 
 	task = param->task;
 	debug_task ("check url %s", struri (url));
@@ -1073,48 +866,32 @@ surbl_tree_url_callback (gpointer key, gpointer value, void *data)
 	if (surbl_module_ctx->use_redirector) {
 		/* Search in trie */
 		if (surbl_module_ctx->redirector_trie &&
-			(pos =
-			rspamd_trie_lookup (surbl_module_ctx->redirector_trie, url->host,
-			url->hostlen, &idx)) != NULL &&
-			idx < surbl_module_ctx->redirector_ptrs->len) {
+				(pos = rspamd_trie_lookup (surbl_module_ctx->redirector_trie, url->host, url->hostlen, &idx)) != NULL &&
+				idx < surbl_module_ctx->redirector_ptrs->len) {
 			/* Get corresponding prefix */
-			red_domain = g_ptr_array_index (surbl_module_ctx->redirector_ptrs,
-					idx);
+			red_domain = g_ptr_array_index (surbl_module_ctx->redirector_ptrs, idx);
 			if (red_domain != NULL) {
 				len = strlen (red_domain);
 				/* First check that we have found domain at the end of host */
 				if (pos + len == url->host + url->hostlen &&
 					(pos == url->host || *(pos - 1) == '.')) {
 					/* Try to find corresponding regexp */
-					re = g_hash_table_lookup (
-						surbl_module_ctx->redirector_hosts,
-						red_domain);
-					if (re != NULL &&
-						(re == NO_REGEXP ||
-						g_regex_match (re, url->string, 0, NULL))) {
+					re = g_hash_table_lookup (surbl_module_ctx->redirector_hosts, red_domain);
+					if (re != NULL && (re == NO_REGEXP || g_regex_match (re, url->string, 0, NULL))) {
 						/* If no regexp found or founded regexp matches url string register redirector's call */
 						if (surbl_module_ctx->redirector_symbol != NULL) {
-							insert_result (param->task,
-								surbl_module_ctx->redirector_symbol,
-								1,
-								g_list_prepend (NULL, red_domain));
+							insert_result (param->task, surbl_module_ctx->redirector_symbol, 1, g_list_prepend (NULL, red_domain));
 						}
-						register_redirector_call (url,
-							param->task,
-							param->suffix,
-							red_domain,
-							param->tree);
+						register_redirector_call (url, param->task, param->suffix, red_domain, param->tree);
 						return FALSE;
 					}
 				}
 			}
 		}
-		make_surbl_requests (url, param->task, param->suffix, FALSE,
-			param->tree);
+		make_surbl_requests (url, param->task, param->suffix, FALSE, param->tree);
 	}
 	else {
-		make_surbl_requests (url, param->task, param->suffix, FALSE,
-			param->tree);
+		make_surbl_requests (url, param->task, param->suffix, FALSE, param->tree);
 	}
 
 	return FALSE;
@@ -1123,15 +900,13 @@ surbl_tree_url_callback (gpointer key, gpointer value, void *data)
 static void
 surbl_test_url (struct rspamd_task *task, void *user_data)
 {
-	struct redirector_param param;
-	struct suffix_item *suffix = user_data;
+	struct redirector_param         param;
+	struct suffix_item             *suffix = user_data;
 
 	param.task = task;
 	param.suffix = suffix;
 	param.tree = g_tree_new ((GCompareFunc)strcmp);
-	rspamd_mempool_add_destructor (task->task_pool,
-		(rspamd_mempool_destruct_t)g_tree_destroy,
-		param.tree);
+	rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t)g_tree_destroy, param.tree);
 	g_tree_foreach (task->urls, surbl_tree_url_callback, &param);
 }
 /*
@@ -1139,17 +914,17 @@ surbl_test_url (struct rspamd_task *task, void *user_data)
  */
 #if 0
 struct urls_tree_cb_data {
-	gchar *buf;
-	gsize len;
-	gsize off;
-	struct rspamd_task *task;
+	gchar                          *buf;
+	gsize                           len;
+	gsize                           off;
+	struct rspamd_task             *task;
 };
 
 static gboolean
 calculate_buflen_cb (gpointer key, gpointer value, gpointer cbdata)
 {
-	struct urls_tree_cb_data *cb = cbdata;
-	struct uri *url = value;
+	struct urls_tree_cb_data       *cb = cbdata;
+	struct uri                     *url = value;
 
 	cb->len += strlen (struri (url)) + url->hostlen + sizeof (" <\"\">, ") - 1;
 
@@ -1159,30 +934,23 @@ calculate_buflen_cb (gpointer key, gpointer value, gpointer cbdata)
 static gboolean
 write_urls_buffer (gpointer key, gpointer value, gpointer cbdata)
 {
-	struct urls_tree_cb_data *cb = cbdata;
-	struct uri *url = value;
-	f_str_t f;
-	gchar *urlstr;
-	gsize len;
+	struct urls_tree_cb_data       *cb = cbdata;
+	struct uri                     *url = value;
+	f_str_t                         f;
+	gchar                          *urlstr;
+	gsize                           len;
 
 	f.begin = url->host;
 	f.len = url->hostlen;
-	if ((urlstr =
-		format_surbl_request (cb->task->task_pool, &f, NULL, FALSE, NULL,
-		FALSE)) != NULL) {
+	if ((urlstr = format_surbl_request (cb->task->task_pool, &f, NULL, FALSE, NULL, FALSE)) != NULL) {
 		len = strlen (urlstr);
 		if (cb->off + len >= cb->len) {
-			msg_info (
-				"cannot write urls header completely, stripped reply at: %z",
-				cb->off);
+			msg_info ("cannot write urls header completely, stripped reply at: %z", cb->off);
 			return TRUE;
 		}
 		else {
-			cb->off += rspamd_snprintf (cb->buf + cb->off,
-					cb->len - cb->off,
-					" %s <\"%s\">,",
-					urlstr,
-					struri (url));
+			cb->off += rspamd_snprintf (cb->buf + cb->off, cb->len - cb->off, " %s <\"%s\">,",
+					urlstr, struri (url));
 		}
 	}
 
@@ -1193,7 +961,7 @@ write_urls_buffer (gpointer key, gpointer value, gpointer cbdata)
 static gboolean
 urls_command_handler (struct rspamd_task *task)
 {
-	struct urls_tree_cb_data cb;
+	struct urls_tree_cb_data        cb;
 
 	/* First calculate buffer length */
 	cb.len = sizeof (RSPAMD_REPLY_BANNER "/1.0 0 " SPAMD_OK CRLF "Urls: " CRLF);
@@ -1201,12 +969,9 @@ urls_command_handler (struct rspamd_task *task)
 	g_tree_foreach (task->urls, calculate_buflen_cb, &cb);
 
 	cb.buf = rspamd_mempool_alloc (task->task_pool, cb.len * sizeof (gchar));
-	cb.off += rspamd_snprintf (cb.buf + cb.off,
-			cb.len - cb.off,
-			"%s/%s 0 %s" CRLF "Urls:",
-			(task->proto == SPAMC_PROTO) ? SPAMD_REPLY_BANNER : RSPAMD_REPLY_BANNER,
-			"1.3",
-			SPAMD_OK);
+	cb.off += rspamd_snprintf (cb.buf + cb.off, cb.len - cb.off, "%s/%s 0 %s" CRLF "Urls:",
+				(task->proto == SPAMC_PROTO) ? SPAMD_REPLY_BANNER : RSPAMD_REPLY_BANNER,
+				"1.3", SPAMD_OK);
 	cb.task = task;
 
 	/* Write urls to buffer */
@@ -1217,12 +982,10 @@ urls_command_handler (struct rspamd_task *task)
 		cb.buf[--cb.off] = '\0';
 	}
 	/* Write result */
-	if (!rspamd_dispatcher_write (task->dispatcher, cb.buf, cb.off, FALSE,
-		TRUE)) {
+	if (! rspamd_dispatcher_write (task->dispatcher, cb.buf, cb.off, FALSE, TRUE)) {
 		return FALSE;
 	}
-	if (!rspamd_dispatcher_write (task->dispatcher, CRLF, sizeof (CRLF) - 1,
-		FALSE, TRUE)) {
+	if (!rspamd_dispatcher_write (task->dispatcher, CRLF, sizeof (CRLF) - 1, FALSE, TRUE)) {
 		return FALSE;
 	}
 	task->state = STATE_REPLY;
@@ -1231,5 +994,5 @@ urls_command_handler (struct rspamd_task *task)
 }
 #endif
 /*
- * vi:ts=4
+ * vi:ts=4 
  */
diff --git a/src/plugins/surbl.h b/src/plugins/surbl.h
index 5b5f195e8..912e7fb11 100644
--- a/src/plugins/surbl.h
+++ b/src/plugins/surbl.h
@@ -1,9 +1,9 @@
 #ifndef RSPAMD_MODULE_SURBL
 #define RSPAMD_MODULE_SURBL
 
-#include "cfg_file.h"
 #include "config.h"
 #include "main.h"
+#include "cfg_file.h"
 #include "trie.h"
 
 #define DEFAULT_REDIRECTOR_PORT 8080
diff --git a/src/smtp.c b/src/smtp.c
index 00b4db700..dc3ff6089 100644
--- a/src/smtp.c
+++ b/src/smtp.c
@@ -22,19 +22,19 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
-#include "cfg_xml.h"
 #include "config.h"
-#include "dns.h"
-#include "lua/lua_common.h"
 #include "main.h"
-#include "map.h"
-#include "message.h"
-#include "settings.h"
+#include "cfg_file.h"
+#include "cfg_xml.h"
+#include "util.h"
 #include "smtp.h"
 #include "smtp_proto.h"
 #include "smtp_utils.h"
-#include "util.h"
+#include "map.h"
+#include "message.h"
+#include "settings.h"
+#include "dns.h"
+#include "lua/lua_common.h"
 
 /* Max line size as it is defined in rfc2822 */
 #define OUTBUFSIZ 1000
@@ -53,26 +53,26 @@ gpointer init_smtp (struct rspamd_config *cfg);
 void start_smtp (struct rspamd_worker *worker);
 
 worker_t smtp_worker = {
-	"smtp",                     /* Name */
-	init_smtp,                  /* Init function */
-	start_smtp,                 /* Start function */
-	TRUE,                       /* Has socket */
-	FALSE,                      /* Non unique */
-	FALSE,                      /* Non threaded */
-	TRUE,                       /* Killable */
-	SOCK_STREAM                 /* TCP socket */
+	"smtp",						/* Name */
+	init_smtp,					/* Init function */
+	start_smtp,					/* Start function */
+	TRUE,						/* Has socket */
+	FALSE,						/* Non unique */
+	FALSE,						/* Non threaded */
+	TRUE,						/* Killable */
+	SOCK_STREAM					/* TCP socket */
 };
 
 static gboolean
 call_stage_filters (struct smtp_session *session, enum rspamd_smtp_stage stage)
 {
-	gboolean res = TRUE;
-	GList *list = session->ctx->smtp_filters[stage];
-	struct smtp_filter *filter;
-
+	gboolean                         res = TRUE;
+	GList                           *list = session->ctx->smtp_filters[stage];
+	struct smtp_filter              *filter;
+	
 	while (list) {
 		filter = list->data;
-		if (!filter->filter (session, filter->filter_data)) {
+		if (! filter->filter (session, filter->filter_data)) {
 			res = FALSE;
 			break;
 		}
@@ -85,159 +85,144 @@ call_stage_filters (struct smtp_session *session, enum rspamd_smtp_stage stage)
 static gboolean
 read_smtp_command (struct smtp_session *session, f_str_t *line)
 {
-	struct smtp_command *cmd;
-	gchar outbuf[BUFSIZ];
-	gint r;
-
-	if (!parse_smtp_command (session, line, &cmd)) {
+	struct smtp_command             *cmd;
+	gchar                           outbuf[BUFSIZ];
+	gint                            r;
+	
+	if (! parse_smtp_command (session, line, &cmd)) {
 		session->error = SMTP_ERROR_BAD_COMMAND;
-		session->errors++;
+		session->errors ++;
 		return FALSE;
 	}
-
+	
 	switch (cmd->command) {
-	case SMTP_COMMAND_HELO:
-	case SMTP_COMMAND_EHLO:
-		if (session->state == SMTP_STATE_GREETING || session->state ==
-			SMTP_STATE_HELO) {
-			if (parse_smtp_helo (session, cmd)) {
-				session->state = SMTP_STATE_FROM;
+		case SMTP_COMMAND_HELO:
+		case SMTP_COMMAND_EHLO:
+			if (session->state == SMTP_STATE_GREETING || session->state == SMTP_STATE_HELO) {
+				if (parse_smtp_helo (session, cmd)) {
+					session->state = SMTP_STATE_FROM;
+				}
+				else {
+					session->errors ++;
+				}
+				if (! call_stage_filters (session, SMTP_STAGE_HELO)) {
+					return FALSE;
+				}
+				return TRUE;
 			}
 			else {
-				session->errors++;
+				goto improper_sequence;
 			}
-			if (!call_stage_filters (session, SMTP_STAGE_HELO)) {
-				return FALSE;
-			}
-			return TRUE;
-		}
-		else {
-			goto improper_sequence;
-		}
-		break;
-	case SMTP_COMMAND_QUIT:
-		session->state = SMTP_STATE_QUIT;
-		break;
-	case SMTP_COMMAND_NOOP:
-		break;
-	case SMTP_COMMAND_MAIL:
-		if (((session->state == SMTP_STATE_GREETING || session->state ==
-			SMTP_STATE_HELO) && !session->ctx->helo_required)
-			|| session->state == SMTP_STATE_FROM) {
-			if (parse_smtp_from (session, cmd)) {
-				session->state = SMTP_STATE_RCPT;
+			break;
+		case SMTP_COMMAND_QUIT:
+			session->state = SMTP_STATE_QUIT;
+			break;
+		case SMTP_COMMAND_NOOP:
+			break;
+		case SMTP_COMMAND_MAIL:
+			if (((session->state == SMTP_STATE_GREETING || session->state == SMTP_STATE_HELO) && !session->ctx->helo_required) 
+					|| session->state == SMTP_STATE_FROM) {
+				if (parse_smtp_from (session, cmd)) {
+					session->state = SMTP_STATE_RCPT;
+				}
+				else {
+					session->errors ++;
+					return FALSE;
+				}
+				if (! call_stage_filters (session, SMTP_STAGE_MAIL)) {
+					return FALSE;
+				}
 			}
 			else {
-				session->errors++;
-				return FALSE;
-			}
-			if (!call_stage_filters (session, SMTP_STAGE_MAIL)) {
-				return FALSE;
+				goto improper_sequence;
 			}
-		}
-		else {
-			goto improper_sequence;
-		}
-		break;
-	case SMTP_COMMAND_RCPT:
-		if (session->state == SMTP_STATE_RCPT) {
-			if (parse_smtp_rcpt (session, cmd)) {
-				if (!call_stage_filters (session, SMTP_STAGE_RCPT)) {
-					return FALSE;
-				}
-				/* Make upstream connection */
-				if (session->upstream == NULL) {
-					if (!create_smtp_upstream_connection (session)) {
-						session->error = SMTP_ERROR_UPSTREAM;
-						session->state = SMTP_STATE_CRITICAL_ERROR;
+			break;
+		case SMTP_COMMAND_RCPT:
+			if (session->state == SMTP_STATE_RCPT) {
+				if (parse_smtp_rcpt (session, cmd)) {
+					if (! call_stage_filters (session, SMTP_STAGE_RCPT)) {
 						return FALSE;
 					}
+					/* Make upstream connection */
+					if (session->upstream == NULL) {
+						if (!create_smtp_upstream_connection (session)) {
+							session->error = SMTP_ERROR_UPSTREAM;
+							session->state = SMTP_STATE_CRITICAL_ERROR;
+							return FALSE;
+						}
+					}
+					else {
+						/* Send next rcpt to upstream */
+						session->state = SMTP_STATE_WAIT_UPSTREAM;
+						session->upstream_state = SMTP_STATE_BEFORE_DATA;
+						rspamd_dispatcher_restore (session->upstream_dispatcher);
+						r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
+						r += smtp_upstream_write_list (session->rcpt->data, outbuf + r, sizeof (outbuf) - r);
+						session->cur_rcpt = NULL;
+						return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
+					}
+					session->state = SMTP_STATE_WAIT_UPSTREAM;
+					return TRUE;
 				}
 				else {
-					/* Send next rcpt to upstream */
-					session->state = SMTP_STATE_WAIT_UPSTREAM;
-					session->upstream_state = SMTP_STATE_BEFORE_DATA;
-					rspamd_dispatcher_restore (session->upstream_dispatcher);
-					r = rspamd_snprintf (outbuf, sizeof (outbuf), "RCPT TO: ");
-					r += smtp_upstream_write_list (session->rcpt->data,
-							outbuf + r,
-							sizeof (outbuf) - r);
-					session->cur_rcpt = NULL;
-					return rspamd_dispatcher_write (
-						session->upstream_dispatcher,
-						outbuf,
-						r,
-						FALSE,
-						FALSE);
+					session->errors ++;
+					return FALSE;
 				}
-				session->state = SMTP_STATE_WAIT_UPSTREAM;
-				return TRUE;
 			}
 			else {
-				session->errors++;
-				return FALSE;
+				goto improper_sequence;
 			}
-		}
-		else {
-			goto improper_sequence;
-		}
-		break;
-	case SMTP_COMMAND_RSET:
-		session->from = NULL;
-		if (session->rcpt) {
-			g_list_free (session->rcpt);
-		}
-		if (session->upstream) {
-			remove_normal_event (session->s,
-				smtp_upstream_finalize_connection,
-				session);
-			session->upstream = NULL;
-		}
-		session->state = SMTP_STATE_GREETING;
-		break;
-	case SMTP_COMMAND_DATA:
-		if (session->state == SMTP_STATE_RCPT) {
-			if (session->rcpt == NULL) {
-				session->error = SMTP_ERROR_RECIPIENTS;
-				session->errors++;
-				return FALSE;
+			break;
+		case SMTP_COMMAND_RSET:
+			session->from = NULL;
+			if (session->rcpt) {
+				g_list_free (session->rcpt);
 			}
-			if (!call_stage_filters (session, SMTP_STAGE_DATA)) {
-				return FALSE;
+			if (session->upstream) {
+				remove_normal_event (session->s, smtp_upstream_finalize_connection, session);
+				session->upstream = NULL;
 			}
-			if (session->upstream == NULL) {
-				session->error = SMTP_ERROR_UPSTREAM;
-				session->state = SMTP_STATE_CRITICAL_ERROR;
-				return FALSE;
+			session->state = SMTP_STATE_GREETING; 
+			break;
+		case SMTP_COMMAND_DATA:
+			if (session->state == SMTP_STATE_RCPT) {
+				if (session->rcpt == NULL) {
+					session->error = SMTP_ERROR_RECIPIENTS;
+					session->errors ++;
+					return FALSE;
+				}
+				if (! call_stage_filters (session, SMTP_STAGE_DATA)) {
+					return FALSE;
+				}
+				if (session->upstream == NULL) {
+					session->error = SMTP_ERROR_UPSTREAM;
+					session->state = SMTP_STATE_CRITICAL_ERROR;
+					return FALSE;
+				}
+				else {
+					session->upstream_state = SMTP_STATE_DATA;
+					rspamd_dispatcher_restore (session->upstream_dispatcher);
+					r = rspamd_snprintf (outbuf, sizeof (outbuf), "DATA" CRLF);
+					session->state = SMTP_STATE_WAIT_UPSTREAM;
+					session->error = SMTP_ERROR_DATA_OK;
+					return rspamd_dispatcher_write (session->upstream_dispatcher, outbuf, r, FALSE, FALSE);
+				}
 			}
 			else {
-				session->upstream_state = SMTP_STATE_DATA;
-				rspamd_dispatcher_restore (session->upstream_dispatcher);
-				r = rspamd_snprintf (outbuf, sizeof (outbuf), "DATA" CRLF);
-				session->state = SMTP_STATE_WAIT_UPSTREAM;
-				session->error = SMTP_ERROR_DATA_OK;
-				return rspamd_dispatcher_write (session->upstream_dispatcher,
-						   outbuf,
-						   r,
-						   FALSE,
-						   FALSE);
+				goto improper_sequence;
 			}
-		}
-		else {
-			goto improper_sequence;
-		}
-	case SMTP_COMMAND_VRFY:
-	case SMTP_COMMAND_EXPN:
-	case SMTP_COMMAND_HELP:
-		session->error = SMTP_ERROR_UNIMPLIMENTED;
-		return FALSE;
+		case SMTP_COMMAND_VRFY:
+		case SMTP_COMMAND_EXPN:
+		case SMTP_COMMAND_HELP:
+			session->error = SMTP_ERROR_UNIMPLIMENTED;
+			return FALSE;
 	}
-
+	
 	session->error = SMTP_ERROR_OK;
 	return TRUE;
 
 improper_sequence:
-	session->errors++;
+	session->errors ++;
 	session->error = SMTP_ERROR_SEQUENCE;
 	return FALSE;
 }
@@ -245,11 +230,11 @@ improper_sequence:
 static gboolean
 process_smtp_data (struct smtp_session *session)
 {
-	struct stat st;
-	gint r;
-	GList *cur, *t;
-	f_str_t *f;
-	gchar *s;
+	struct stat                     st;
+	gint                            r;
+	GList                          *cur, *t;
+	f_str_t                        *f;
+	gchar                           *s;
 
 	if (fstat (session->temp_fd, &st) == -1) {
 		msg_err ("fstat failed: %s", strerror (errno));
@@ -257,23 +242,17 @@ process_smtp_data (struct smtp_session *session)
 	}
 	/* Now mmap temp file if it is small enough */
 	session->temp_size = st.st_size;
-	if (session->ctx->max_size == 0 || st.st_size <
-		(off_t)session->ctx->max_size) {
+	if (session->ctx->max_size == 0 || st.st_size < (off_t)session->ctx->max_size) {
 		session->task = rspamd_task_new (session->worker);
 		session->task->resolver = session->resolver;
 		session->task->fin_callback = smtp_write_socket;
 		session->task->fin_arg = session;
-		session->task->msg =
-			rspamd_mempool_alloc (session->pool, sizeof (GString));
+		session->task->msg = rspamd_mempool_alloc (session->pool, sizeof (GString));
 		session->task->s = session->s;
 #ifdef HAVE_MMAP_NOCORE
-		if ((session->task->msg->str =
-			mmap (NULL, st.st_size, PROT_READ, MAP_SHARED | MAP_NOCORE,
-			session->temp_fd, 0)) == MAP_FAILED) {
+		if ((session->task->msg->str = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED | MAP_NOCORE, session->temp_fd, 0)) == MAP_FAILED) {
 #else
-		if ((session->task->msg->str =
-			mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, session->temp_fd,
-			0)) == MAP_FAILED) {
+		if ((session->task->msg->str = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, session->temp_fd, 0)) == MAP_FAILED) {
 #endif
 			msg_err ("mmap failed: %s", strerror (errno));
 			goto err;
@@ -301,8 +280,7 @@ process_smtp_data (struct smtp_session *session)
 			t = g_list_next (t);
 		}
 
-		memcpy (&session->task->from_addr, &session->client_addr,
-			sizeof (struct in_addr));
+		memcpy (&session->task->from_addr, &session->client_addr, sizeof (struct in_addr));
 		session->task->cmd = CMD_CHECK;
 
 		if (process_message (session->task) == -1) {
@@ -327,9 +305,7 @@ process_smtp_data (struct smtp_session *session)
 		}
 	}
 	else {
-		msg_info ("not scan message as it is %z bytes and maximum is %z",
-			st.st_size,
-			session->ctx->max_size);
+		msg_info ("not scan message as it is %z bytes and maximum is %z", st.st_size, session->ctx->max_size);
 		session->task = NULL;
 		return smtp_send_upstream_message (session);
 	}
@@ -338,8 +314,7 @@ process_smtp_data (struct smtp_session *session)
 err:
 	session->error = SMTP_ERROR_FILE;
 	session->state = SMTP_STATE_CRITICAL_ERROR;
-	if (!rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE,
-		TRUE)) {
+	if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 		return FALSE;
 	}
 	destroy_session (session->s);
@@ -349,74 +324,65 @@ err:
 /*
  * Callback that is called when there is data to read in buffer
  */
-static gboolean
+static                          gboolean
 smtp_read_socket (f_str_t * in, void *arg)
 {
-	struct smtp_session *session = arg;
+	struct smtp_session            *session = arg;
 
 	switch (session->state) {
-	case SMTP_STATE_RESOLVE_REVERSE:
-	case SMTP_STATE_RESOLVE_NORMAL:
-	case SMTP_STATE_DELAY:
-		session->error = make_smtp_error (session->pool,
-				550,
-				"%s Improper use of SMTP command pipelining",
-				"5.5.0");
-		session->state = SMTP_STATE_ERROR;
-		break;
-	case SMTP_STATE_GREETING:
-	case SMTP_STATE_HELO:
-	case SMTP_STATE_FROM:
-	case SMTP_STATE_RCPT:
-	case SMTP_STATE_DATA:
-		read_smtp_command (session, in);
-		if (session->state != SMTP_STATE_WAIT_UPSTREAM) {
-			if (session->errors > session->ctx->max_errors) {
-				session->error = SMTP_ERROR_LIMIT;
-				session->state = SMTP_STATE_CRITICAL_ERROR;
-				if (!rspamd_dispatcher_write (session->dispatcher,
-					session->error, 0, FALSE, TRUE)) {
+		case SMTP_STATE_RESOLVE_REVERSE:
+		case SMTP_STATE_RESOLVE_NORMAL:
+		case SMTP_STATE_DELAY:
+			session->error = make_smtp_error (session->pool, 550, "%s Improper use of SMTP command pipelining", "5.5.0");
+			session->state = SMTP_STATE_ERROR;
+			break;
+		case SMTP_STATE_GREETING:
+		case SMTP_STATE_HELO:
+		case SMTP_STATE_FROM:
+		case SMTP_STATE_RCPT:
+		case SMTP_STATE_DATA:
+			read_smtp_command (session, in);
+			if (session->state != SMTP_STATE_WAIT_UPSTREAM) {
+				if (session->errors > session->ctx->max_errors) {
+					session->error = SMTP_ERROR_LIMIT;
+					session->state = SMTP_STATE_CRITICAL_ERROR;
+					if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+						return FALSE;
+					}
+					destroy_session (session->s);
+					return FALSE;
+				}
+				if (! smtp_write_socket (session)) {
 					return FALSE;
 				}
-				destroy_session (session->s);
-				return FALSE;
 			}
-			if (!smtp_write_socket (session)) {
-				return FALSE;
+			break;
+		case SMTP_STATE_AFTER_DATA:
+			if (in->len == 0) {
+				return TRUE;
+			}
+			if (in->len == 3 && memcmp (in->begin, DATA_END_TRAILER, in->len) == 0) {
+				return process_smtp_data (session);
 			}
-		}
-		break;
-	case SMTP_STATE_AFTER_DATA:
-		if (in->len == 0) {
-			return TRUE;
-		}
-		if (in->len == 3 &&
-			memcmp (in->begin, DATA_END_TRAILER, in->len) == 0) {
-			return process_smtp_data (session);
-		}
 
-		if (write (session->temp_fd, in->begin, in->len) != (ssize_t)in->len) {
-			msg_err ("cannot write to temp file: %s", strerror (errno));
-			session->error = SMTP_ERROR_FILE;
-			session->state = SMTP_STATE_CRITICAL_ERROR;
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				0, FALSE, TRUE)) {
+			if (write (session->temp_fd, in->begin, in->len) != (ssize_t)in->len) {
+				msg_err ("cannot write to temp file: %s", strerror (errno));
+				session->error = SMTP_ERROR_FILE;
+				session->state = SMTP_STATE_CRITICAL_ERROR;
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
+					return FALSE;
+				}
+				destroy_session (session->s);
 				return FALSE;
 			}
-			destroy_session (session->s);
-			return FALSE;
-		}
-		break;
-	case SMTP_STATE_WAIT_UPSTREAM:
-		rspamd_dispatcher_pause (session->dispatcher);
-		break;
-	default:
-		session->error = make_smtp_error (session->pool,
-				550,
-				"%s Internal error",
-				"5.5.0");
-		session->state = SMTP_STATE_ERROR;
-		break;
+			break;
+		case SMTP_STATE_WAIT_UPSTREAM:
+			rspamd_dispatcher_pause (session->dispatcher);
+			break;
+		default:
+			session->error = make_smtp_error (session->pool, 550, "%s Internal error", "5.5.0");
+			session->state = SMTP_STATE_ERROR;
+			break;
 	}
 
 	if (session->state == SMTP_STATE_QUIT) {
@@ -433,15 +399,14 @@ smtp_read_socket (f_str_t * in, void *arg)
 /*
  * Callback for socket writing
  */
-static gboolean
+static                          gboolean
 smtp_write_socket (void *arg)
 {
-	struct smtp_session *session = arg;
+	struct smtp_session            *session = arg;
 
 	if (session->state == SMTP_STATE_CRITICAL_ERROR) {
 		if (session->error != NULL) {
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				0, FALSE, TRUE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 				return FALSE;
 			}
 		}
@@ -454,8 +419,7 @@ smtp_write_socket (void *arg)
 		}
 		else {
 			if (session->error != NULL) {
-				if (!rspamd_dispatcher_write (session->dispatcher,
-					session->error, 0, FALSE, TRUE)) {
+				if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 					return FALSE;
 				}
 			}
@@ -463,13 +427,12 @@ smtp_write_socket (void *arg)
 	}
 	else {
 		if (session->error != NULL) {
-			if (!rspamd_dispatcher_write (session->dispatcher, session->error,
-				0, FALSE, TRUE)) {
+			if (! rspamd_dispatcher_write (session->dispatcher, session->error, 0, FALSE, TRUE)) {
 				return FALSE;
 			}
 		}
 	}
-
+	
 	return TRUE;
 }
 
@@ -479,7 +442,7 @@ smtp_write_socket (void *arg)
 static void
 smtp_err_socket (GError * err, void *arg)
 {
-	struct smtp_session *session = arg;
+	struct smtp_session            *session = arg;
 
 	msg_info ("abnormally closing connection, error: %s", err->message);
 	/* Free buffers */
@@ -493,8 +456,7 @@ static gboolean
 write_smtp_greeting (struct smtp_session *session)
 {
 	if (session->ctx->smtp_banner) {
-		if (!rspamd_dispatcher_write (session->dispatcher,
-			session->ctx->smtp_banner, 0, FALSE, TRUE)) {
+		if (! rspamd_dispatcher_write (session->dispatcher, session->ctx->smtp_banner, 0, FALSE, TRUE)) {
 			return FALSE;
 		}
 	}
@@ -508,11 +470,9 @@ write_smtp_greeting (struct smtp_session *session)
 static void
 smtp_delay_handler (gint fd, short what, void *arg)
 {
-	struct smtp_session *session = arg;
-
-	remove_normal_event (session->s,
-		(event_finalizer_t)event_del,
-		session->delay_timer);
+	struct smtp_session            *session = arg;
+	
+	remove_normal_event (session->s, (event_finalizer_t)event_del, session->delay_timer);
 	if (session->state == SMTP_STATE_DELAY) {
 		session->state = SMTP_STATE_GREETING;
 		write_smtp_greeting (session);
@@ -529,9 +489,9 @@ smtp_delay_handler (gint fd, short what, void *arg)
 static void
 smtp_make_delay (struct smtp_session *session)
 {
-	struct event *tev;
-	struct timeval *tv;
-	gint32 jitter;
+	struct event                  *tev;
+	struct timeval                *tv;
+	gint32                         jitter;
 
 	if (session->ctx->smtp_delay != 0 && session->state == SMTP_STATE_DELAY) {
 		tev = rspamd_mempool_alloc (session->pool, sizeof (struct event));
@@ -546,10 +506,7 @@ smtp_make_delay (struct smtp_session *session)
 
 		evtimer_set (tev, smtp_delay_handler, session);
 		evtimer_add (tev, tv);
-		register_async_event (session->s,
-			(event_finalizer_t)event_del,
-			tev,
-			g_quark_from_static_string ("smtp proxy"));
+		register_async_event (session->s, (event_finalizer_t)event_del, tev, g_quark_from_static_string ("smtp proxy"));
 		session->delay_timer = tev;
 	}
 	else if (session->state == SMTP_STATE_DELAY) {
@@ -564,98 +521,83 @@ smtp_make_delay (struct smtp_session *session)
 static void
 smtp_dns_cb (struct rspamd_dns_reply *reply, void *arg)
 {
-	struct smtp_session *session = arg;
-	gint res = 0;
-	union rspamd_reply_element *elt;
-	GList *cur;
+	struct smtp_session            *session = arg;
+	gint                            res = 0;
+	union rspamd_reply_element     *elt;
+	GList                          *cur;
 
 	switch (session->state) {
-	case SMTP_STATE_RESOLVE_REVERSE:
-		/* Parse reverse reply and start resolve of this ip */
-		if (reply->code != RDNS_RC_NOERROR) {
-			rspamd_conditional_debug (rspamd_main->logger,
-				session->client_addr.s_addr,
-				__FUNCTION__,
-				"DNS error: %s",
-				dns_strerror (reply->code));
-
-			if (reply->code == RDNS_RC_NXDOMAIN) {
-				session->hostname = rspamd_mempool_strdup (session->pool,
-						XCLIENT_HOST_UNAVAILABLE);
+		case SMTP_STATE_RESOLVE_REVERSE:
+			/* Parse reverse reply and start resolve of this ip */
+			if (reply->code != RDNS_RC_NOERROR) {
+				rspamd_conditional_debug(rspamd_main->logger, session->client_addr.s_addr, __FUNCTION__,
+						"DNS error: %s", dns_strerror (reply->code));
+				
+				if (reply->code == RDNS_RC_NXDOMAIN) {
+					session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_UNAVAILABLE);
+				}
+				else {
+					session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_TEMPFAIL);
+				}
+				session->state = SMTP_STATE_DELAY;
+				smtp_make_delay (session);
 			}
 			else {
-				session->hostname = rspamd_mempool_strdup (session->pool,
-						XCLIENT_HOST_TEMPFAIL);
+				if (reply->elements) {
+					elt = reply->elements->data;
+					session->hostname = rspamd_mempool_strdup (session->pool, elt->ptr.name);
+					session->state = SMTP_STATE_RESOLVE_NORMAL;
+					make_dns_request (session->resolver, session->s, session->pool,
+							smtp_dns_cb, session, RDNS_REQUEST_A, session->hostname);
+					
+				}
 			}
-			session->state = SMTP_STATE_DELAY;
-			smtp_make_delay (session);
-		}
-		else {
-			if (reply->elements) {
-				elt = reply->elements->data;
-				session->hostname = rspamd_mempool_strdup (session->pool,
-						elt->ptr.name);
-				session->state = SMTP_STATE_RESOLVE_NORMAL;
-				make_dns_request (session->resolver, session->s, session->pool,
-					smtp_dns_cb, session, RDNS_REQUEST_A, session->hostname);
+			break;
+		case SMTP_STATE_RESOLVE_NORMAL:
+			if (reply->code != RDNS_RC_NOERROR) {
+				rspamd_conditional_debug(rspamd_main->logger, session->client_addr.s_addr, __FUNCTION__,
+										"DNS error: %s", dns_strerror (reply->code));
 
-			}
-		}
-		break;
-	case SMTP_STATE_RESOLVE_NORMAL:
-		if (reply->code != RDNS_RC_NOERROR) {
-			rspamd_conditional_debug (rspamd_main->logger,
-				session->client_addr.s_addr,
-				__FUNCTION__,
-				"DNS error: %s",
-				dns_strerror (reply->code));
-
-			if (reply->code == RDNS_RC_NXDOMAIN) {
-				session->hostname = rspamd_mempool_strdup (session->pool,
-						XCLIENT_HOST_UNAVAILABLE);
+				if (reply->code == RDNS_RC_NXDOMAIN) {
+					session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_UNAVAILABLE);
+				}
+				else {
+					session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_TEMPFAIL);
+				}
+				session->state = SMTP_STATE_DELAY;
+				smtp_make_delay (session);
 			}
 			else {
-				session->hostname = rspamd_mempool_strdup (session->pool,
-						XCLIENT_HOST_TEMPFAIL);
-			}
-			session->state = SMTP_STATE_DELAY;
-			smtp_make_delay (session);
-		}
-		else {
-			res = 0;
-			cur = reply->elements;
-			while (cur) {
-				elt = cur->data;
-				if (memcmp (&session->client_addr, &elt->a.addr[0],
-					sizeof (struct in_addr)) == 0) {
-					res = 1;
-					session->resolved = TRUE;
-					break;
+				res = 0;
+				cur = reply->elements;
+				while (cur) {
+					elt = cur->data;
+					if (memcmp (&session->client_addr, &elt->a.addr[0], sizeof (struct in_addr)) == 0) {
+						res = 1;
+						session->resolved = TRUE;
+						break;
+					}
+					cur = g_list_next (cur);
 				}
-				cur = g_list_next (cur);
-			}
 
-			if (res == 0) {
-				msg_info ("cannot find address for hostname: %s, ip: %s",
-					session->hostname,
-					inet_ntoa (session->client_addr));
-				session->hostname = rspamd_mempool_strdup (session->pool,
-						XCLIENT_HOST_UNAVAILABLE);
+				if (res == 0) {
+					msg_info ("cannot find address for hostname: %s, ip: %s", session->hostname, inet_ntoa (session->client_addr));
+					session->hostname = rspamd_mempool_strdup (session->pool, XCLIENT_HOST_UNAVAILABLE);
+				}
+				session->state = SMTP_STATE_DELAY;
+				smtp_make_delay (session);
 			}
-			session->state = SMTP_STATE_DELAY;
-			smtp_make_delay (session);
-		}
-		break;
-	case SMTP_STATE_ERROR:
-		session->state = SMTP_STATE_WRITE_ERROR;
-		smtp_write_socket (session);
-		break;
-	default:
-		/*
-		 * This callback is called on unknown state, usually this indicates
-		 * an error (invalid pipelining)
-		 */
-		break;
+			break;
+		case SMTP_STATE_ERROR:
+			session->state = SMTP_STATE_WRITE_ERROR;
+			smtp_write_socket (session);
+			break;
+		default:
+			/* 
+			 * This callback is called on unknown state, usually this indicates
+			 * an error (invalid pipelining)
+			 */
+			break;
 	}
 }
 
@@ -665,16 +607,15 @@ smtp_dns_cb (struct rspamd_dns_reply *reply, void *arg)
 static void
 accept_socket (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
-	union sa_union su;
-	struct smtp_session *session;
-	struct smtp_worker_ctx *ctx;
+	struct rspamd_worker           *worker = (struct rspamd_worker *)arg;
+	union sa_union                  su;
+	struct smtp_session            *session;
+	struct smtp_worker_ctx         *ctx;
 
-	socklen_t addrlen = sizeof (su.ss);
-	gint nfd;
+	socklen_t                       addrlen = sizeof (su.ss);
+	gint                            nfd;
 
-	if ((nfd =
-		accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
+	if ((nfd = accept_from_socket (fd, (struct sockaddr *)&su.ss, &addrlen)) == -1) {
 		msg_warn ("accept failed: %s", strerror (errno));
 		return;
 	}
@@ -692,10 +633,8 @@ accept_socket (gint fd, short what, void *arg)
 		session->client_addr.s_addr = INADDR_NONE;
 	}
 	else if (su.ss.ss_family == AF_INET) {
-		msg_info ("accepted connection from %s port %d",
-			inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
-		memcpy (&session->client_addr, &su.s4.sin_addr,
-			sizeof (struct in_addr));
+		msg_info ("accepted connection from %s port %d", inet_ntoa (su.s4.sin_addr), ntohs (su.s4.sin_port));
+		memcpy (&session->client_addr, &su.s4.sin_addr, sizeof (struct in_addr));
 	}
 
 	session->sock = nfd;
@@ -710,28 +649,18 @@ accept_socket (gint fd, short what, void *arg)
 
 	/* Resolve client's addr */
 	/* Set up async session */
-	session->s = new_async_session (session->pool,
-			NULL,
-			NULL,
-			free_smtp_session,
-			session);
+	session->s = new_async_session (session->pool, NULL, NULL, free_smtp_session, session);
 	session->state = SMTP_STATE_RESOLVE_REVERSE;
-	if (!make_dns_request (session->resolver, session->s, session->pool,
-		smtp_dns_cb, session, RDNS_REQUEST_PTR, &session->client_addr)) {
+	if (! make_dns_request (session->resolver, session->s, session->pool,
+			smtp_dns_cb, session, RDNS_REQUEST_PTR, &session->client_addr)) {
 		msg_err ("cannot resolve %s", inet_ntoa (session->client_addr));
 		g_free (session);
 		close (nfd);
 		return;
 	}
 	else {
-		session->dispatcher = rspamd_create_dispatcher (session->ev_base,
-				nfd,
-				BUFFER_LINE,
-				smtp_read_socket,
-				smtp_write_socket,
-				smtp_err_socket,
-				&session->ctx->smtp_timeout,
-				session);
+		session->dispatcher = rspamd_create_dispatcher (session->ev_base, nfd, BUFFER_LINE,
+								smtp_read_socket, smtp_write_socket, smtp_err_socket, &session->ctx->smtp_timeout, session);
 		session->dispatcher->peer_addr = session->client_addr.s_addr;
 	}
 }
@@ -739,41 +668,41 @@ accept_socket (gint fd, short what, void *arg)
 static void
 parse_smtp_banner (struct smtp_worker_ctx *ctx, const gchar *line)
 {
-	gint hostmax, banner_len = sizeof ("220 ") - 1;
-	gchar *p, *t, *hostbuf = NULL;
-	gboolean has_crlf = FALSE;
+	gint                            hostmax, banner_len = sizeof ("220 ") - 1;
+	gchar                           *p, *t, *hostbuf = NULL;
+	gboolean                        has_crlf = FALSE;
 
 	p = (gchar *)line;
 	while (*p) {
 		if (*p == '%') {
-			p++;
+			p ++;
 			switch (*p) {
-			case 'n':
-				/* Assume %n as CRLF */
-				banner_len += sizeof (CRLF) - 1 + sizeof ("220 -") - 1;
-				has_crlf = TRUE;
-				break;
-			case 'h':
-				hostmax = sysconf (_SC_HOST_NAME_MAX) + 1;
-				hostbuf = alloca (hostmax);
-				gethostname (hostbuf, hostmax);
-				hostbuf[hostmax - 1] = '\0';
-				banner_len += strlen (hostbuf);
-				break;
-			case '%':
-				banner_len += 1;
-				break;
-			default:
-				banner_len += 2;
-				break;
+				case 'n':
+					/* Assume %n as CRLF */
+					banner_len += sizeof (CRLF) - 1 + sizeof ("220 -") - 1;
+					has_crlf = TRUE;
+					break;
+				case 'h':
+					hostmax = sysconf (_SC_HOST_NAME_MAX) + 1;
+					hostbuf = alloca (hostmax);
+					gethostname (hostbuf, hostmax);
+					hostbuf[hostmax - 1] = '\0';
+					banner_len += strlen (hostbuf);
+					break;
+				case '%':
+					banner_len += 1;
+					break;
+				default:
+					banner_len += 2;
+					break;
 			}
 		}
 		else {
-			banner_len++;
+			banner_len ++;
 		}
-		p++;
+		p ++;
 	}
-
+	
 	if (has_crlf) {
 		banner_len += sizeof (CRLF "220 " CRLF);
 	}
@@ -794,30 +723,30 @@ parse_smtp_banner (struct smtp_worker_ctx *ctx, const gchar *line)
 
 	while (*p) {
 		if (*p == '%') {
-			p++;
+			p ++;
 			switch (*p) {
-			case 'n':
-				/* Assume %n as CRLF */
-				*t++ = CR; *t++ = LF;
-				t = g_stpcpy (t, "220-");
-				p++;
-				break;
-			case 'h':
-				t = g_stpcpy (t, hostbuf);
-				p++;
-				break;
-			case '%':
-				*t++ = '%';
-				p++;
-				break;
-			default:
-				/* Copy all %<gchar> to dest */
-				*t++ = *(p - 1); *t++ = *p;
-				break;
+				case 'n':
+					/* Assume %n as CRLF */
+					*t++ = CR; *t++ = LF;
+					t = g_stpcpy (t, "220-");
+					p ++;
+					break;
+				case 'h':
+					t = g_stpcpy (t, hostbuf);
+					p ++;
+					break;
+				case '%':
+					*t++ = '%';
+					p ++;
+					break;
+				default:
+					/* Copy all %<gchar> to dest */
+					*t++ = *(p - 1); *t++ = *p;
+					break;
 			}
 		}
 		else {
-			*t++ = *p++;
+			*t ++ = *p ++;
 		}
 	}
 	if (has_crlf) {
@@ -831,12 +760,12 @@ parse_smtp_banner (struct smtp_worker_ctx *ctx, const gchar *line)
 static void
 make_capabilities (struct smtp_worker_ctx *ctx, const gchar *line)
 {
-	gchar **strv, *p, *result, *hostbuf;
-	guint32 num, i, len, hostmax;
+	gchar                           **strv, *p, *result, *hostbuf;
+	guint32                         num, i, len, hostmax;
 
 	strv = g_strsplit_set (line, ",;", -1);
 	num = g_strv_length (strv);
-
+	
 	hostmax = sysconf (_SC_HOST_NAME_MAX) + 1;
 	hostbuf = alloca (hostmax);
 	gethostname (hostbuf, hostmax);
@@ -844,32 +773,26 @@ make_capabilities (struct smtp_worker_ctx *ctx, const gchar *line)
 
 	len = sizeof ("250-") + strlen (hostbuf) + sizeof (CRLF) - 1;
 
-	for (i = 0; i < num; i++) {
+	for (i = 0; i < num; i ++) {
 		p = strv[i];
 		len += sizeof ("250-") + sizeof (CRLF) + strlen (p) - 2;
 	}
 
 	result = rspamd_mempool_alloc (ctx->pool, len);
 	ctx->smtp_capabilities = result;
-
+	
 	p = result;
 	if (num == 0) {
 		p += rspamd_snprintf (p, len - (p - result), "250 %s" CRLF, hostbuf);
 	}
 	else {
 		p += rspamd_snprintf (p, len - (p - result), "250-%s" CRLF, hostbuf);
-		for (i = 0; i < num; i++) {
+		for (i = 0; i < num; i ++) {
 			if (i != num - 1) {
-				p += rspamd_snprintf (p,
-						len - (p - result),
-						"250-%s" CRLF,
-						strv[i]);
+				p += rspamd_snprintf (p, len - (p - result), "250-%s" CRLF, strv[i]);
 			}
 			else {
-				p += rspamd_snprintf (p,
-						len - (p - result),
-						"250 %s" CRLF,
-						strv[i]);
+				p += rspamd_snprintf (p, len - (p - result), "250 %s" CRLF, strv[i]);
 			}
 		}
 	}
@@ -880,14 +803,14 @@ make_capabilities (struct smtp_worker_ctx *ctx, const gchar *line)
 gpointer
 init_smtp (struct rspamd_config *cfg)
 {
-	struct smtp_worker_ctx *ctx;
-	GQuark type;
+	struct smtp_worker_ctx         		*ctx;
+	GQuark								type;
 
 	type = g_quark_try_string ("smtp");
 
 	ctx = g_malloc0 (sizeof (struct smtp_worker_ctx));
 	ctx->pool = rspamd_mempool_new (rspamd_mempool_suggest_size ());
-
+	
 	/* Set default values */
 	ctx->smtp_timeout_raw = 300000;
 	ctx->smtp_delay = 0;
@@ -897,49 +820,44 @@ init_smtp (struct rspamd_config *cfg)
 	ctx->reject_message = DEFAULT_REJECT_MESSAGE;
 
 	rspamd_rcl_register_worker_option (cfg, type, "upstreams",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx, upstreams_str), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, upstreams_str), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "banner",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_banner_str), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_banner_str), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "timeout",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx,
-		smtp_timeout_raw), RSPAMD_CL_FLAG_TIME_UINT_32);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_timeout_raw), RSPAMD_CL_FLAG_TIME_UINT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "delay",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx,
-		smtp_delay), RSPAMD_CL_FLAG_TIME_UINT_32);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_delay), RSPAMD_CL_FLAG_TIME_UINT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "jitter",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx,
-		delay_jitter), RSPAMD_CL_FLAG_TIME_UINT_32);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, delay_jitter), RSPAMD_CL_FLAG_TIME_UINT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "capabilities",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_capabilities_str), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, smtp_capabilities_str), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "xclient",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx, use_xclient), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, use_xclient), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "reject_message",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx, reject_message), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, reject_message), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "max_errors",
-		rspamd_rcl_parse_struct_integer, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx,
-		max_errors), RSPAMD_CL_FLAG_INT_32);
+			rspamd_rcl_parse_struct_integer, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, max_errors), RSPAMD_CL_FLAG_INT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "max_size",
-		rspamd_rcl_parse_struct_integer, ctx,
-		G_STRUCT_OFFSET (struct smtp_worker_ctx,
-		max_size), RSPAMD_CL_FLAG_INT_SIZE);
+			rspamd_rcl_parse_struct_integer, ctx,
+			G_STRUCT_OFFSET (struct smtp_worker_ctx, max_size), RSPAMD_CL_FLAG_INT_SIZE);
 
 	return ctx;
 }
@@ -948,16 +866,15 @@ init_smtp (struct rspamd_config *cfg)
 static gboolean
 config_smtp_worker (struct rspamd_worker *worker)
 {
-	struct smtp_worker_ctx *ctx = worker->ctx;
-	gchar *value;
+	struct smtp_worker_ctx         *ctx = worker->ctx;
+	gchar                          *value;
 
 	/* Init timeval */
 	msec_to_tv (ctx->smtp_timeout_raw, &ctx->smtp_timeout);
 
 	/* Init upstreams */
 	if ((value = ctx->upstreams_str) != NULL) {
-		if (!parse_upstreams_line (ctx->pool, ctx->upstreams, value,
-			&ctx->upstream_num)) {
+		if (!parse_upstreams_line (ctx->pool, ctx->upstreams, value, &ctx->upstream_num)) {
 			return FALSE;
 		}
 	}
@@ -974,7 +891,7 @@ config_smtp_worker (struct rspamd_worker *worker)
 	if ((value = ctx->smtp_capabilities_str) != NULL) {
 		make_capabilities (ctx, value);
 	}
-
+	
 	return TRUE;
 }
 
@@ -985,7 +902,7 @@ config_smtp_worker (struct rspamd_worker *worker)
 void
 start_smtp (struct rspamd_worker *worker)
 {
-	struct smtp_worker_ctx *ctx = worker->ctx;
+	struct smtp_worker_ctx         *ctx = worker->ctx;
 
 	ctx->ev_base = rspamd_prepare_worker (worker, "smtp_worker", accept_socket);
 
@@ -1005,18 +922,15 @@ start_smtp (struct rspamd_worker *worker)
 	umask (S_IWGRP | S_IWOTH | S_IROTH | S_IRGRP);
 
 	event_base_loop (ctx->ev_base, 0);
-
+	
 	close_log (rspamd_main->logger);
 	exit (EXIT_SUCCESS);
 }
 
-void
-register_smtp_filter (struct smtp_worker_ctx *ctx,
-	enum rspamd_smtp_stage stage,
-	smtp_filter_t filter,
-	gpointer filter_data)
+void 
+register_smtp_filter (struct smtp_worker_ctx *ctx, enum rspamd_smtp_stage stage, smtp_filter_t filter, gpointer filter_data)
 {
-	struct smtp_filter *new;
+	struct smtp_filter             *new;
 
 	new = rspamd_mempool_alloc (ctx->pool, sizeof (struct smtp_filter));
 
@@ -1027,11 +941,10 @@ register_smtp_filter (struct smtp_worker_ctx *ctx,
 		msg_err ("invalid smtp stage: %d", stage);
 	}
 	else {
-		ctx->smtp_filters[stage] =
-			g_list_prepend (ctx->smtp_filters[stage], new);
+		ctx->smtp_filters[stage] = g_list_prepend (ctx->smtp_filters[stage], new);
 	}
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/src/smtp.h b/src/smtp.h
index fac886620..482f5243d 100644
--- a/src/smtp.h
+++ b/src/smtp.h
@@ -3,8 +3,8 @@
 
 #include "config.h"
 #include "main.h"
-#include "smtp_utils.h"
 #include "upstream.h"
+#include "smtp_utils.h"
 
 struct rspamd_dns_resolver;
 
@@ -23,7 +23,7 @@ struct smtp_worker_ctx {
 	struct smtp_upstream upstreams[MAX_SMTP_UPSTREAMS];
 	gsize upstream_num;
 	gchar *upstreams_str;
-
+	
 	rspamd_mempool_t *pool;
 	gchar *smtp_banner;
 	gchar *smtp_banner_str;
@@ -90,7 +90,7 @@ struct smtp_session {
 	GList *cur_rcpt;
 
 	guint errors;
-
+	
 	struct rspamd_async_session *s;
 	rspamd_io_dispatcher_t *dispatcher;
 	rspamd_io_dispatcher_t *upstream_dispatcher;
@@ -105,8 +105,7 @@ struct smtp_session {
 	struct event_base *ev_base;
 };
 
-typedef gboolean (*smtp_filter_t)(struct smtp_session *session,
-	gpointer filter_data);
+typedef gboolean (*smtp_filter_t)(struct smtp_session *session, gpointer filter_data);
 
 struct smtp_filter {
 	smtp_filter_t filter;
@@ -117,9 +116,6 @@ struct smtp_filter {
  * Register new SMTP filter
  * XXX: work is still in progress
  */
-void register_smtp_filter (struct smtp_worker_ctx *ctx,
-	enum rspamd_smtp_stage stage,
-	smtp_filter_t filter,
-	gpointer filter_data);
+void register_smtp_filter (struct smtp_worker_ctx *ctx, enum rspamd_smtp_stage stage, smtp_filter_t filter, gpointer filter_data);
 
 #endif
diff --git a/src/smtp_proxy.c b/src/smtp_proxy.c
index 63cfdf50e..c2df491b6 100644
--- a/src/smtp_proxy.c
+++ b/src/smtp_proxy.c
@@ -21,16 +21,16 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "dns.h"
 #include "main.h"
+#include "cfg_file.h"
+#include "util.h"
+#include "smtp_proto.h"
 #include "map.h"
 #include "message.h"
-#include "proxy.h"
-#include "smtp_proto.h"
+#include "dns.h"
 #include "upstream.h"
-#include "util.h"
+#include "proxy.h"
 
 /*
  * SMTP proxy is a simple smtp proxy worker for dns resolving and
@@ -53,14 +53,14 @@ gpointer init_smtp_proxy (struct rspamd_config *cfg);
 void start_smtp_proxy (struct rspamd_worker *worker);
 
 worker_t smtp_proxy_worker = {
-	"smtp_proxy",               /* Name */
-	init_smtp_proxy,            /* Init function */
-	start_smtp_proxy,           /* Start function */
-	TRUE,                       /* Has socket */
-	FALSE,                      /* Non unique */
-	FALSE,                      /* Non threaded */
-	TRUE,                       /* Killable */
-	SOCK_STREAM                 /* TCP socket */
+	"smtp_proxy",				/* Name */
+	init_smtp_proxy,			/* Init function */
+	start_smtp_proxy,			/* Start function */
+	TRUE,						/* Has socket */
+	FALSE,						/* Non unique */
+	FALSE,						/* Non threaded */
+	TRUE,						/* Killable */
+	SOCK_STREAM					/* TCP socket */
 };
 
 struct smtp_proxy_ctx {
@@ -140,7 +140,7 @@ struct smtp_proxy_session {
 static void
 free_smtp_proxy_session (gpointer arg)
 {
-	struct smtp_proxy_session *session = arg;
+	struct smtp_proxy_session            *session = arg;
 	static const char fatal_smtp_error[] = "521 5.2.1 Internal error" CRLF;
 
 	if (session) {
@@ -152,23 +152,17 @@ free_smtp_proxy_session (gpointer arg)
 			g_string_free (session->upstream_greeting, TRUE);
 		}
 
-		if (session->state != SMTP_PROXY_STATE_PROXY && session->state !=
-			SMTP_PROXY_STATE_REJECT &&
-			session->state != SMTP_PROXY_STATE_REJECT_EMULATE) {
+		if (session->state != SMTP_PROXY_STATE_PROXY && session->state != SMTP_PROXY_STATE_REJECT &&
+				session->state != SMTP_PROXY_STATE_REJECT_EMULATE) {
 			/* Send 521 fatal error */
-			if (write (session->sock, fatal_smtp_error,
-				sizeof (fatal_smtp_error)) == -1) {
+			if (write (session->sock, fatal_smtp_error, sizeof (fatal_smtp_error)) == -1) {
 				msg_err ("write error to client failed: %s", strerror (errno));
 			}
 		}
-		else if ((session->state == SMTP_PROXY_STATE_REJECT || session->state ==
-			SMTP_PROXY_STATE_REJECT_EMULATE) &&
-			session->from && session->rcpt && session->dnsbl_applied) {
-			msg_info ("reject by %s mail from <%s> to <%s>, ip: %s",
-				session->dnsbl_applied,
-				session->from,
-				session->rcpt,
-				inet_ntoa (session->client_addr));
+		else if ((session->state == SMTP_PROXY_STATE_REJECT || session->state == SMTP_PROXY_STATE_REJECT_EMULATE) &&
+				session->from && session->rcpt && session->dnsbl_applied) {
+			msg_info ("reject by %s mail from <%s> to <%s>, ip: %s", session->dnsbl_applied,
+					session->from, session->rcpt, inet_ntoa (session->client_addr));
 		}
 
 		close (session->sock);
@@ -191,7 +185,7 @@ free_smtp_proxy_session (gpointer arg)
 static void
 smtp_proxy_err_proxy (GError * err, void *arg)
 {
-	struct smtp_proxy_session *session = arg;
+	struct smtp_proxy_session            *session = arg;
 
 	if (err) {
 		g_error_free (err);
@@ -210,7 +204,7 @@ smtp_proxy_err_proxy (GError * err, void *arg)
 static gint
 check_valid_smtp_greeting (GString *s)
 {
-	gchar *p;
+	gchar								*p;
 
 	p = s->str + s->len - 1;
 	if (s->len < 6 || (*p != '\n' || *(p - 1) != '\r')) {
@@ -228,10 +222,10 @@ check_valid_smtp_greeting (GString *s)
 			return 0;
 		}
 		else if ((*p == '5' || *p == '4' || *p == '3') &&
-			g_ascii_isdigit (p[1]) && g_ascii_isdigit (p[2]) && p[3] == ' ') {
+				g_ascii_isdigit (p[1]) && g_ascii_isdigit (p[2]) && p[3] == ' ') {
 			return -1;
 		}
-		p--;
+		p --;
 	}
 
 	return 1;
@@ -244,9 +238,9 @@ check_valid_smtp_greeting (GString *s)
 static void
 smtp_proxy_greeting_handler (gint fd, short what, void *arg)
 {
-	struct smtp_proxy_session *session = arg;
-	gint r;
-	gchar read_buf[BUFSIZ];
+	struct smtp_proxy_session           *session = arg;
+	gint								 r;
+	gchar								 read_buf[BUFSIZ];
 
 	if (what == EV_READ) {
 		if (session->state == SMTP_PROXY_STATE_GREETING) {
@@ -259,23 +253,16 @@ smtp_proxy_greeting_handler (gint fd, short what, void *arg)
 				if (r == 1) {
 					/* Send xclient */
 					if (session->ctx->use_xclient) {
-						r = rspamd_snprintf (read_buf,
-								sizeof (read_buf),
-								"XCLIENT NAME=%s ADDR=%s" CRLF,
-								session->hostname,
-								inet_ntoa (session->client_addr));
+						r = rspamd_snprintf (read_buf, sizeof (read_buf), "XCLIENT NAME=%s ADDR=%s" CRLF,
+								session->hostname, inet_ntoa (session->client_addr));
 						r = write (session->upstream_sock, read_buf, r);
 
 						if (r < 0 && errno == EAGAIN) {
 							/* Add write event */
 							event_del (&session->upstream_ev);
-							event_set (&session->upstream_ev,
-								session->upstream_sock,
-								EV_WRITE,
-								smtp_proxy_greeting_handler,
-								session);
-							event_base_set (session->ev_base,
-								&session->upstream_ev);
+							event_set (&session->upstream_ev, session->upstream_sock,
+									EV_WRITE, smtp_proxy_greeting_handler, session);
+							event_base_set (session->ev_base, &session->upstream_ev);
 							event_add (&session->upstream_ev, NULL);
 						}
 						else if (r > 0) {
@@ -283,49 +270,35 @@ smtp_proxy_greeting_handler (gint fd, short what, void *arg)
 							session->state = SMTP_PROXY_STATE_XCLIENT;
 						}
 						else {
-							msg_info ("connection with %s got write error: %s",
-								inet_ntoa (session->client_addr),
-								strerror (errno));
+							msg_info ("connection with %s got write error: %s", inet_ntoa (session->client_addr), strerror (errno));
 							destroy_session (session->s);
 						}
 					}
 					else {
 						event_del (&session->upstream_ev);
 						/* Start direct proxy */
-						r = write (session->sock,
-								session->upstream_greeting->str,
-								session->upstream_greeting->len);
+						r = write (session->sock, session->upstream_greeting->str, session->upstream_greeting->len);
 						/* TODO: handle client's error here */
 						if (r > 0) {
-							session->proxy = rspamd_create_proxy (session->sock,
-									session->upstream_sock,
-									session->pool,
-									session->ev_base,
-									session->ctx->proxy_buf_len,
-									&session->ctx->smtp_timeout,
-									smtp_proxy_err_proxy,
-									session);
+							session->proxy = rspamd_create_proxy (session->sock, session->upstream_sock, session->pool,
+								session->ev_base, session->ctx->proxy_buf_len,
+								&session->ctx->smtp_timeout, smtp_proxy_err_proxy, session);
 							session->state = SMTP_PROXY_STATE_PROXY;
 						}
 						else {
-							msg_info ("connection with %s got write error: %s",
-								inet_ntoa (session->client_addr),
-								strerror (errno));
+							msg_info ("connection with %s got write error: %s", inet_ntoa (session->client_addr), strerror (errno));
 							destroy_session (session->s);
 						}
 					}
 				}
 				else if (r == -1) {
 					/* Proxy sent 500 error */
-					msg_info ("connection with %s got smtp error for greeting",
-						session->upstream->name);
+					msg_info ("connection with %s got smtp error for greeting", session->upstream->name);
 					destroy_session (session->s);
 				}
 			}
 			else {
-				msg_info ("connection with %s got read error: %s",
-					session->upstream->name,
-					strerror (errno));
+				msg_info ("connection with %s got read error: %s", session->upstream->name, strerror (errno));
 				destroy_session (session->s);
 			}
 		}
@@ -339,58 +312,43 @@ smtp_proxy_greeting_handler (gint fd, short what, void *arg)
 				if (r == 1) {
 					event_del (&session->upstream_ev);
 					/* Start direct proxy */
-					r = write (session->sock,
-							session->upstream_greeting->str,
-							session->upstream_greeting->len);
+					r = write (session->sock, session->upstream_greeting->str, session->upstream_greeting->len);
 					/* TODO: handle client's error here */
 					if (r > 0) {
-						session->proxy = rspamd_create_proxy (session->sock,
-								session->upstream_sock,
-								session->pool,
-								session->ev_base,
-								session->ctx->proxy_buf_len,
-								&session->ctx->smtp_timeout,
-								smtp_proxy_err_proxy,
-								session);
+						session->proxy = rspamd_create_proxy (session->sock, session->upstream_sock, session->pool,
+								session->ev_base, session->ctx->proxy_buf_len,
+								&session->ctx->smtp_timeout, smtp_proxy_err_proxy, session);
 						session->state = SMTP_PROXY_STATE_PROXY;
 					}
 					else {
-						msg_info ("connection with %s got write error: %s",
-							inet_ntoa (session->client_addr),
-							strerror (errno));
+						msg_info ("connection with %s got write error: %s", inet_ntoa (session->client_addr), strerror (errno));
 						destroy_session (session->s);
 					}
 				}
 				else if (r == -1) {
 					/* Proxy sent 500 error */
-					msg_info ("connection with %s got smtp error for xclient",
-						session->upstream->name);
+					msg_info ("connection with %s got smtp error for xclient", session->upstream->name);
 					destroy_session (session->s);
 				}
 			}
 		}
 		else {
-			msg_info ("connection with %s got read event at improper state: %d",
-				session->upstream->name,
-				session->state);
+			msg_info ("connection with %s got read event at improper state: %d", session->upstream->name, session->state);
 			destroy_session (session->s);
 		}
 	}
 	else if (what == EV_WRITE) {
 		if (session->state == SMTP_PROXY_STATE_GREETING) {
 			/* Send xclient again */
-			r = rspamd_snprintf (read_buf,
-					sizeof (read_buf),
-					"XCLIENT NAME=%s ADDR=%s" CRLF,
-					session->hostname,
-					inet_ntoa (session->client_addr));
+			r = rspamd_snprintf (read_buf, sizeof (read_buf), "XCLIENT NAME=%s ADDR=%s" CRLF,
+					session->hostname, inet_ntoa (session->client_addr));
 			r = write (session->upstream_sock, read_buf, r);
 
 			if (r < 0 && errno == EAGAIN) {
 				/* Add write event */
 				event_del (&session->upstream_ev);
 				event_set (&session->upstream_ev, session->upstream_sock,
-					EV_WRITE, smtp_proxy_greeting_handler, session);
+						EV_WRITE, smtp_proxy_greeting_handler, session);
 				event_base_set (session->ev_base, &session->upstream_ev);
 				event_add (&session->upstream_ev, NULL);
 			}
@@ -399,22 +357,17 @@ smtp_proxy_greeting_handler (gint fd, short what, void *arg)
 				session->state = SMTP_PROXY_STATE_XCLIENT;
 				event_del (&session->upstream_ev);
 				event_set (&session->upstream_ev, session->upstream_sock,
-					EV_READ | EV_PERSIST, smtp_proxy_greeting_handler, session);
+						EV_READ | EV_PERSIST, smtp_proxy_greeting_handler, session);
 				event_base_set (session->ev_base, &session->upstream_ev);
 				event_add (&session->upstream_ev, NULL);
 			}
 			else {
-				msg_info ("connection with %s got write error: %s",
-					session->upstream->name,
-					strerror (errno));
+				msg_info ("connection with %s got write error: %s", session->upstream->name, strerror (errno));
 				destroy_session (session->s);
 			}
 		}
 		else {
-			msg_info (
-				"connection with %s got write event at improper state: %d",
-				session->upstream->name,
-				session->state);
+			msg_info ("connection with %s got write event at improper state: %d", session->upstream->name, session->state);
 			destroy_session (session->s);
 		}
 	}
@@ -428,17 +381,12 @@ smtp_proxy_greeting_handler (gint fd, short what, void *arg)
 static gboolean
 create_smtp_proxy_upstream_connection (struct smtp_proxy_session *session)
 {
-	struct smtp_upstream *selected;
+	struct smtp_upstream              	*selected;
 
 	/* Try to select upstream */
-	selected = (struct smtp_upstream *)get_upstream_round_robin (
-		session->ctx->upstreams,
-		session->ctx->upstream_num,
-		sizeof (struct smtp_upstream),
-		time (NULL),
-		DEFAULT_UPSTREAM_ERROR_TIME,
-		DEFAULT_UPSTREAM_DEAD_TIME,
-		DEFAULT_UPSTREAM_MAXERRORS);
+	selected = (struct smtp_upstream *)get_upstream_round_robin (session->ctx->upstreams,
+			session->ctx->upstream_num, sizeof (struct smtp_upstream),
+			time (NULL), DEFAULT_UPSTREAM_ERROR_TIME, DEFAULT_UPSTREAM_DEAD_TIME, DEFAULT_UPSTREAM_MAXERRORS);
 	if (selected == NULL) {
 		msg_err ("no upstreams suitable found");
 		return FALSE;
@@ -447,12 +395,7 @@ create_smtp_proxy_upstream_connection (struct smtp_proxy_session *session)
 	session->upstream = selected;
 
 	/* Now try to create socket */
-	session->upstream_sock = make_universal_socket (selected->name,
-			selected->port,
-			SOCK_STREAM,
-			TRUE,
-			FALSE,
-			FALSE);
+	session->upstream_sock = make_universal_socket (selected->name, selected->port, SOCK_STREAM, TRUE, FALSE, FALSE);
 	if (session->upstream_sock == -1) {
 		msg_err ("cannot make a connection to %s", selected->name);
 		upstream_fail (&selected->up, time (NULL));
@@ -463,11 +406,7 @@ create_smtp_proxy_upstream_connection (struct smtp_proxy_session *session)
 	/* First of all get upstream's greeting */
 	session->state = SMTP_PROXY_STATE_GREETING;
 
-	event_set (&session->upstream_ev,
-		session->upstream_sock,
-		EV_READ | EV_PERSIST,
-		smtp_proxy_greeting_handler,
-		session);
+	event_set (&session->upstream_ev, session->upstream_sock, EV_READ | EV_PERSIST, smtp_proxy_greeting_handler, session);
 	event_base_set (session->ev_base, &session->upstream_ev);
 	event_add (&session->upstream_ev, &session->ctx->smtp_timeout);
 
@@ -479,17 +418,16 @@ create_smtp_proxy_upstream_connection (struct smtp_proxy_session *session)
 static void
 smtp_dnsbl_cb (struct rdns_reply *reply, void *arg)
 {
-	struct smtp_proxy_session *session = arg;
-	const gchar *p;
-	gint dots = 0;
-	const struct rdns_request_name *req_name;
+	struct smtp_proxy_session 						*session = arg;
+	const gchar										*p;
+	gint											 dots = 0;
+	const struct rdns_request_name					*req_name;
 
-	session->rbl_requests--;
+	session->rbl_requests --;
 
 	req_name = rdns_request_get_name (reply->request, NULL);
 
-	msg_debug ("got reply for %s: %s", req_name[0].name,
-		rdns_strerror (reply->code));
+	msg_debug ("got reply for %s: %s", req_name[0].name, rdns_strerror (reply->code));
 
 	if (session->state != SMTP_PROXY_STATE_REJECT) {
 
@@ -498,13 +436,13 @@ smtp_dnsbl_cb (struct rdns_reply *reply, void *arg)
 			p = req_name[0].name;
 			while (*p) {
 				if (*p == '.') {
-					dots++;
+					dots ++;
 				}
 				if (dots == 4) {
 					session->dnsbl_applied = (gchar *)p + 1;
 					break;
 				}
-				p++;
+				p ++;
 			}
 			session->state = SMTP_PROXY_STATE_REJECT;
 		}
@@ -520,22 +458,19 @@ smtp_dnsbl_cb (struct rdns_reply *reply, void *arg)
 		else {
 			if (session->ctx->instant_reject) {
 				msg_info ("reject %s is denied by dnsbl: %s",
-					inet_ntoa (session->client_addr), session->dnsbl_applied);
+						inet_ntoa (session->client_addr), session->dnsbl_applied);
 				if (!rspamd_dispatcher_write (session->dispatcher,
-					make_smtp_error (session->pool, 521,
-					"%s Client denied by %s", "5.2.1", session->dnsbl_applied),
-					0, FALSE, TRUE)) {
+						make_smtp_error (session->pool, 521, "%s Client denied by %s", "5.2.1", session->dnsbl_applied),
+						0, FALSE, TRUE)) {
 					msg_err ("cannot write smtp error");
 				}
 			}
 			else {
 				/* Emulate fake smtp session */
-				rspamd_set_dispatcher_policy (session->dispatcher,
-					BUFFER_LINE,
-					0);
+				rspamd_set_dispatcher_policy (session->dispatcher, BUFFER_LINE, 0);
 				if (!rspamd_dispatcher_write (session->dispatcher,
-					make_smtp_error (session->pool, 220, "smtp ready"),
-					0, FALSE, TRUE)) {
+						make_smtp_error (session->pool, 220, "smtp ready"),
+						0, FALSE, TRUE)) {
 					msg_err ("cannot write smtp reply");
 				}
 			}
@@ -550,9 +485,9 @@ smtp_dnsbl_cb (struct rdns_reply *reply, void *arg)
 static void
 make_rbl_requests (struct smtp_proxy_session *session)
 {
-	GList *cur;
-	gchar *p, *dst;
-	guint len;
+	GList									*cur;
+	gchar									*p, *dst;
+	guint									 len;
 
 	cur = session->ctx->rbls;
 	while (cur) {
@@ -561,10 +496,10 @@ make_rbl_requests (struct smtp_proxy_session *session)
 		/* Print ipv4 addr */
 		p = (gchar *)&session->client_addr.s_addr;
 		rspamd_snprintf (dst, len, "%ud.%ud.%ud.%ud.%s", (guint)p[3],
-			(guint)p[2], (guint)p[1], (guint)p[0], cur->data);
+				(guint)p[2], (guint)p[1], (guint)p[0], cur->data);
 		if (make_dns_request (session->resolver, session->s, session->pool,
-			smtp_dnsbl_cb, session, RDNS_REQUEST_A, dst)) {
-			session->rbl_requests++;
+								smtp_dnsbl_cb, session, RDNS_REQUEST_A, dst)) {
+			session->rbl_requests ++;
 			msg_debug ("send request to %s", dst);
 		}
 		cur = g_list_next (cur);
@@ -572,7 +507,7 @@ make_rbl_requests (struct smtp_proxy_session *session)
 
 	if (session->rbl_requests == 0) {
 		/* Create proxy */
-		if (!create_smtp_proxy_upstream_connection (session)) {
+		if (! create_smtp_proxy_upstream_connection (session)) {
 			rspamd_dispatcher_restore (session->dispatcher);
 		}
 	}
@@ -585,10 +520,10 @@ make_rbl_requests (struct smtp_proxy_session *session)
 static void
 smtp_delay_handler (gint fd, short what, void *arg)
 {
-	struct smtp_proxy_session *session = arg;
+	struct smtp_proxy_session 				*session = arg;
 
 	remove_normal_event (session->s, (event_finalizer_t) event_del,
-		session->delay_timer);
+			session->delay_timer);
 	if (session->state == SMTP_PROXY_STATE_DELAY) {
 		/* TODO: Create upstream connection here */
 		if (session->ctx->rbls) {
@@ -604,9 +539,8 @@ smtp_delay_handler (gint fd, short what, void *arg)
 		/* TODO: Write error here */
 		session->state = SMTP_PROXY_STATE_REJECT;
 		if (!rspamd_dispatcher_write (session->dispatcher,
-			make_smtp_error (session->pool, 521,
-			"%s Improper use of SMTP command pipelining", "5.2.1"),
-			0, FALSE, TRUE)) {
+				make_smtp_error (session->pool, 521, "%s Improper use of SMTP command pipelining", "5.2.1"),
+				0, FALSE, TRUE)) {
 			msg_err ("cannot write smtp error");
 		}
 		rspamd_dispatcher_restore (session->dispatcher);
@@ -619,12 +553,11 @@ smtp_delay_handler (gint fd, short what, void *arg)
 static void
 smtp_make_delay (struct smtp_proxy_session *session)
 {
-	struct event *tev;
-	struct timeval *tv;
-	gint32 jitter;
+	struct event 							*tev;
+	struct timeval 							*tv;
+	gint32 									 jitter;
 
-	if (session->ctx->smtp_delay != 0 && session->state ==
-		SMTP_PROXY_STATE_DELAY) {
+	if (session->ctx->smtp_delay != 0 && session->state == SMTP_PROXY_STATE_DELAY) {
 		tev = rspamd_mempool_alloc (session->pool, sizeof(struct event));
 		tv = rspamd_mempool_alloc (session->pool, sizeof(struct timeval));
 		if (session->ctx->delay_jitter != 0) {
@@ -638,7 +571,7 @@ smtp_make_delay (struct smtp_proxy_session *session)
 		evtimer_set (tev, smtp_delay_handler, session);
 		evtimer_add (tev, tv);
 		register_async_event (session->s, (event_finalizer_t) event_del, tev,
-			g_quark_from_static_string ("smtp proxy"));
+				g_quark_from_static_string ("smtp proxy"));
 		session->delay_timer = tev;
 	}
 	else if (session->state == SMTP_PROXY_STATE_DELAY) {
@@ -660,10 +593,10 @@ smtp_make_delay (struct smtp_proxy_session *session)
 static void
 smtp_dns_cb (struct rdns_reply *reply, void *arg)
 {
-	struct smtp_proxy_session *session = arg;
-	gint res = 0;
-	struct rdns_reply_entry *elt;
-	GList *cur;
+	struct smtp_proxy_session 						*session = arg;
+	gint 											 res = 0;
+	struct rdns_reply_entry 						*elt;
+	GList 											*cur;
 
 	switch (session->state)
 	{
@@ -671,8 +604,8 @@ smtp_dns_cb (struct rdns_reply *reply, void *arg)
 		/* Parse reverse reply and start resolve of this ip */
 		if (reply->code != RDNS_RC_NOERROR) {
 			rspamd_conditional_debug (rspamd_main->logger,
-				NULL, __FUNCTION__, "DNS error: %s",
-				rdns_strerror (reply->code));
+					NULL, __FUNCTION__, "DNS error: %s",
+					rdns_strerror (reply->code));
 
 			if (reply->code == RDNS_RC_NXDOMAIN) {
 				session->hostname = rspamd_mempool_strdup (session->pool,
@@ -692,7 +625,7 @@ smtp_dns_cb (struct rdns_reply *reply, void *arg)
 						elt->content.ptr.name);
 				session->state = SMTP_PROXY_STATE_RESOLVE_NORMAL;
 				make_dns_request (session->resolver, session->s, session->pool,
-					smtp_dns_cb, session, RDNS_REQUEST_A, session->hostname);
+						smtp_dns_cb, session, RDNS_REQUEST_A, session->hostname);
 
 			}
 		}
@@ -700,8 +633,8 @@ smtp_dns_cb (struct rdns_reply *reply, void *arg)
 	case SMTP_PROXY_STATE_RESOLVE_NORMAL:
 		if (reply->code != RDNS_RC_NOERROR) {
 			rspamd_conditional_debug (rspamd_main->logger,
-				NULL, __FUNCTION__, "DNS error: %s",
-				rdns_strerror (reply->code));
+					NULL, __FUNCTION__, "DNS error: %s",
+					rdns_strerror (reply->code));
 
 			if (reply->code == RDNS_RC_NXDOMAIN) {
 				session->hostname = rspamd_mempool_strdup (session->pool,
@@ -716,10 +649,9 @@ smtp_dns_cb (struct rdns_reply *reply, void *arg)
 		}
 		else {
 			res = 0;
-			LL_FOREACH (reply->entries, elt)
-			{
+			LL_FOREACH (reply->entries, elt) {
 				if (memcmp (&session->client_addr, &elt->content.a.addr,
-					sizeof(struct in_addr)) == 0) {
+						sizeof(struct in_addr)) == 0) {
 					res = 1;
 					session->resolved = TRUE;
 					break;
@@ -728,10 +660,9 @@ smtp_dns_cb (struct rdns_reply *reply, void *arg)
 			}
 
 			if (res == 0) {
-				msg_info (
-					"cannot find address for hostname: %s, ip: %s",
-					session->hostname,
-					inet_ntoa (session->client_addr));
+				msg_info(
+						"cannot find address for hostname: %s, ip: %s", session->hostname,
+						inet_ntoa (session->client_addr));
 				session->hostname = rspamd_mempool_strdup (session->pool,
 						XCLIENT_HOST_UNAVAILABLE);
 			}
@@ -748,41 +679,37 @@ smtp_dns_cb (struct rdns_reply *reply, void *arg)
 static void
 proxy_parse_smtp_input (f_str_t *line, struct smtp_proxy_session *session)
 {
-	gchar *p, *c, *end;
-	gsize len;
+	gchar								 *p, *c, *end;
+	gsize								  len;
 
 	p = line->begin;
 	end = line->begin + line->len;
-	if (line->len >= sizeof("rcpt to: ") - 1 &&
-		(*p == 'r' || *p == 'R') && session->rcpt == NULL) {
-		if (g_ascii_strncasecmp (p, "rcpt to: ",
-			sizeof ("rcpt to: ") - 1) == 0) {
+	if (line->len >= sizeof("rcpt to: ") - 1 && (*p == 'r' || *p == 'R') && session->rcpt == NULL) {
+		if (g_ascii_strncasecmp (p, "rcpt to: ", sizeof ("rcpt to: ") - 1) == 0) {
 			p += sizeof ("rcpt to: ") - 1;
 			/* Skip spaces */
 			while ((g_ascii_isspace (*p) || *p == '<') && p < end) {
-				p++;
+				p ++;
 			}
 			c = p;
 			while (!(g_ascii_isspace (*p) || *p == '>') && p < end) {
-				p++;
+				p ++;
 			}
 			len = p - c;
 			session->rcpt = rspamd_mempool_alloc (session->pool, len + 1);
 			rspamd_strlcpy (session->rcpt, c, len + 1);
 		}
 	}
-	else if (line->len >= sizeof("mail from: ") - 1 &&
-		(*p == 'm' || *p == 'M') && session->from == NULL) {
-		if (g_ascii_strncasecmp (p, "mail from: ", sizeof ("mail from: ") -
-			1) == 0) {
+	else if (line->len >= sizeof("mail from: ") - 1 && (*p == 'm' || *p == 'M') && session->from == NULL) {
+		if (g_ascii_strncasecmp (p, "mail from: ", sizeof ("mail from: ") - 1) == 0) {
 			p += sizeof ("mail from: ") - 1;
 			/* Skip spaces */
 			while ((g_ascii_isspace (*p) || *p == '<') && p < end) {
-				p++;
+				p ++;
 			}
 			c = p;
 			while (!(g_ascii_isspace (*p) || *p == '>') && p < end) {
-				p++;
+				p ++;
 			}
 			len = p - c;
 			session->from = rspamd_mempool_alloc (session->pool, len + 1);
@@ -799,19 +726,18 @@ proxy_parse_smtp_input (f_str_t *line, struct smtp_proxy_session *session)
 /*
  * Callback that is called when there is data to read in buffer
  */
-static gboolean
+static                          gboolean
 smtp_proxy_read_socket (f_str_t * in, void *arg)
 {
-	struct smtp_proxy_session *session = arg;
-	gchar *p;
+	struct smtp_proxy_session            *session = arg;
+	gchar								 *p;
 
 	if (session->state != SMTP_PROXY_STATE_REJECT_EMULATE) {
 		/* This can be called only if client is using invalid pipelining */
 		session->state = SMTP_PROXY_STATE_REJECT;
 		if (!rspamd_dispatcher_write (session->dispatcher,
-			make_smtp_error (session->pool, 521,
-			"%s Improper use of SMTP command pipelining", "5.2.1"),
-			0, FALSE, TRUE)) {
+				make_smtp_error (session->pool, 521, "%s Improper use of SMTP command pipelining", "5.2.1"),
+				0, FALSE, TRUE)) {
 			msg_err ("cannot write smtp error");
 		}
 		destroy_session (session->s);
@@ -819,11 +745,10 @@ smtp_proxy_read_socket (f_str_t * in, void *arg)
 	else {
 		/* Try to extract data */
 		p = in->begin;
-		if (in->len >= sizeof ("helo") - 1 &&
-			(*p == 'h' || *p == 'H' || *p == 'e' || *p == 'E')) {
+		if (in->len >= sizeof ("helo") - 1 && (*p == 'h' || *p == 'H' || *p == 'e' || *p == 'E')) {
 			return rspamd_dispatcher_write (session->dispatcher,
-					   "220 smtp ready" CRLF,
-					   0, FALSE, TRUE);
+					"220 smtp ready" CRLF,
+					0, FALSE, TRUE);
 		}
 		else if (in->len > 0) {
 			proxy_parse_smtp_input (in, session);
@@ -831,36 +756,32 @@ smtp_proxy_read_socket (f_str_t * in, void *arg)
 		if (session->state == SMTP_PROXY_STATE_REJECT) {
 			/* Received QUIT command */
 			if (!rspamd_dispatcher_write (session->dispatcher,
-				"221 2.0.0 Bye" CRLF,
-				0, FALSE, TRUE)) {
+					"221 2.0.0 Bye" CRLF,
+					0, FALSE, TRUE)) {
 				msg_err ("cannot write smtp error");
 			}
 			destroy_session (session->s);
 			return FALSE;
 		}
 		if (session->rcpt != NULL) {
-			session->errors++;
+			session->errors ++;
 			if (session->errors > SMTP_MAXERRORS) {
 				if (!rspamd_dispatcher_write (session->dispatcher,
-					"521 5.2.1 Maximum errors reached" CRLF,
-					0, FALSE, TRUE)) {
+						"521 5.2.1 Maximum errors reached" CRLF,
+						0, FALSE, TRUE)) {
 					msg_err ("cannot write smtp error");
 				}
 				destroy_session (session->s);
 				return FALSE;
 			}
 			return rspamd_dispatcher_write (session->dispatcher,
-					   make_smtp_error (session->pool,
-					   521,
-					   "%s Client denied by %s",
-					   "5.2.1",
-					   session->dnsbl_applied),
-					   0, FALSE, TRUE);
+					make_smtp_error (session->pool, 521, "%s Client denied by %s", "5.2.1", session->dnsbl_applied),
+					0, FALSE, TRUE);
 		}
 		else {
 			return rspamd_dispatcher_write (session->dispatcher,
-					   "250 smtp ready" CRLF,
-					   0, FALSE, TRUE);
+					"250 smtp ready" CRLF,
+					0, FALSE, TRUE);
 		}
 	}
 
@@ -870,10 +791,10 @@ smtp_proxy_read_socket (f_str_t * in, void *arg)
 /*
  * Actually called only if something goes wrong
  */
-static gboolean
+static                          gboolean
 smtp_proxy_write_socket (void *arg)
 {
-	struct smtp_proxy_session *session = arg;
+	struct smtp_proxy_session            *session = arg;
 
 	if (session->ctx->instant_reject) {
 		destroy_session (session->s);
@@ -892,14 +813,14 @@ smtp_proxy_write_socket (void *arg)
 static void
 smtp_proxy_err_socket (GError * err, void *arg)
 {
-	struct smtp_proxy_session *session = arg;
+	struct smtp_proxy_session            *session = arg;
 
 	if (err) {
 		if (err->code == ETIMEDOUT) {
 			/* Write smtp error */
 			if (!rspamd_dispatcher_write (session->dispatcher,
-				"421 4.4.2 Error: timeout exceeded" CRLF,
-				0, FALSE, TRUE)) {
+					"421 4.4.2 Error: timeout exceeded" CRLF,
+					0, FALSE, TRUE)) {
 				msg_err ("cannot write smtp error");
 			}
 		}
@@ -916,16 +837,16 @@ smtp_proxy_err_socket (GError * err, void *arg)
 static void
 accept_socket (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *)arg;
-	struct smtp_proxy_session *session;
-	struct smtp_proxy_ctx *ctx;
-	rspamd_inet_addr_t addr;
-	gint nfd;
+	struct rspamd_worker           *worker = (struct rspamd_worker *)arg;
+	struct smtp_proxy_session      *session;
+	struct smtp_proxy_ctx          *ctx;
+	rspamd_inet_addr_t               addr;
+	gint                             nfd;
 
 	ctx = worker->ctx;
 
 	if ((nfd =
-		rspamd_accept_from_socket (fd, &addr)) == -1) {
+			rspamd_accept_from_socket (fd, &addr)) == -1) {
 		msg_warn ("accept failed: %s", strerror (errno));
 		return;
 	}
@@ -935,8 +856,8 @@ accept_socket (gint fd, short what, void *arg)
 	}
 
 	msg_info ("accepted connection from %s port %d",
-		rspamd_inet_address_to_string (&addr),
-		rspamd_inet_address_get_port (&addr));
+			rspamd_inet_address_to_string (&addr),
+			rspamd_inet_address_get_port (&addr));
 
 	ctx = worker->ctx;
 	session = g_slice_alloc0 (sizeof (struct smtp_proxy_session));
@@ -949,34 +870,24 @@ accept_socket (gint fd, short what, void *arg)
 	session->resolver = ctx->resolver;
 	session->ev_base = ctx->ev_base;
 	session->upstream_sock = -1;
-	session->ptr_str = rdns_generate_ptr_from_str (rspamd_inet_address_to_string (
-				&addr));
+	session->ptr_str = rdns_generate_ptr_from_str (rspamd_inet_address_to_string (&addr));
 	worker->srv->stat->connections_count++;
 
 	/* Resolve client's addr */
 	/* Set up async session */
-	session->s = new_async_session (session->pool,
-			NULL,
-			NULL,
-			free_smtp_proxy_session,
-			session);
+	session->s = new_async_session (session->pool, NULL, NULL, free_smtp_proxy_session, session);
 	session->state = SMTP_PROXY_STATE_RESOLVE_REVERSE;
-	if (!make_dns_request (session->resolver, session->s, session->pool,
-		smtp_dns_cb, session, RDNS_REQUEST_PTR, session->ptr_str)) {
+	if (! make_dns_request (session->resolver, session->s, session->pool,
+			smtp_dns_cb, session, RDNS_REQUEST_PTR, session->ptr_str)) {
 		msg_err ("cannot resolve %s", inet_ntoa (session->client_addr));
 		g_slice_free1 (sizeof (struct smtp_proxy_session), session);
 		close (nfd);
 		return;
 	}
 	else {
-		session->dispatcher = rspamd_create_dispatcher (session->ev_base,
-				nfd,
-				BUFFER_ANY,
-				smtp_proxy_read_socket,
-				smtp_proxy_write_socket,
-				smtp_proxy_err_socket,
-				&session->ctx->smtp_timeout,
-				session);
+		session->dispatcher = rspamd_create_dispatcher (session->ev_base, nfd, BUFFER_ANY,
+								smtp_proxy_read_socket, smtp_proxy_write_socket, smtp_proxy_err_socket,
+								&session->ctx->smtp_timeout, session);
 		session->dispatcher->peer_addr = session->client_addr.s_addr;
 	}
 }
@@ -984,8 +895,8 @@ accept_socket (gint fd, short what, void *arg)
 gpointer
 init_smtp_proxy (struct rspamd_config *cfg)
 {
-	struct smtp_proxy_ctx *ctx;
-	GQuark type;
+	struct smtp_proxy_ctx         		*ctx;
+	GQuark								type;
 
 	type = g_quark_try_string ("smtp_proxy");
 
@@ -998,40 +909,36 @@ init_smtp_proxy (struct rspamd_config *cfg)
 	ctx->instant_reject = TRUE;
 
 	rspamd_rcl_register_worker_option (cfg, type, "upstreams",
-		rspamd_rcl_parse_struct_string, ctx,
-		G_STRUCT_OFFSET (struct smtp_proxy_ctx, upstreams_str), 0);
+			rspamd_rcl_parse_struct_string, ctx,
+			G_STRUCT_OFFSET (struct smtp_proxy_ctx, upstreams_str), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "timeout",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct smtp_proxy_ctx,
-		smtp_timeout_raw), RSPAMD_CL_FLAG_TIME_UINT_32);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct smtp_proxy_ctx, smtp_timeout_raw), RSPAMD_CL_FLAG_TIME_UINT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "delay",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct smtp_proxy_ctx,
-		smtp_delay), RSPAMD_CL_FLAG_TIME_UINT_32);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct smtp_proxy_ctx, smtp_delay), RSPAMD_CL_FLAG_TIME_UINT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "jitter",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct smtp_proxy_ctx,
-		delay_jitter), RSPAMD_CL_FLAG_TIME_UINT_32);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct smtp_proxy_ctx, delay_jitter), RSPAMD_CL_FLAG_TIME_UINT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "xclient",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct smtp_proxy_ctx, use_xclient), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct smtp_proxy_ctx, use_xclient), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "instant_reject",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct smtp_proxy_ctx, instant_reject), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct smtp_proxy_ctx, instant_reject), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "proxy_buffer",
-		rspamd_rcl_parse_struct_integer, ctx,
-		G_STRUCT_OFFSET (struct smtp_proxy_ctx,
-		proxy_buf_len), RSPAMD_CL_FLAG_INT_32);
+			rspamd_rcl_parse_struct_integer, ctx,
+			G_STRUCT_OFFSET (struct smtp_proxy_ctx, proxy_buf_len), RSPAMD_CL_FLAG_INT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "dnsbl",
-		rspamd_rcl_parse_struct_string_list, ctx,
-		G_STRUCT_OFFSET (struct smtp_proxy_ctx, rbls), 0);
+			rspamd_rcl_parse_struct_string_list, ctx,
+			G_STRUCT_OFFSET (struct smtp_proxy_ctx, rbls), 0);
 
 	return ctx;
 }
@@ -1040,16 +947,15 @@ init_smtp_proxy (struct rspamd_config *cfg)
 static gboolean
 config_smtp_proxy_worker (struct rspamd_worker *worker)
 {
-	struct smtp_proxy_ctx *ctx = worker->ctx;
-	gchar *value;
+	struct smtp_proxy_ctx         *ctx = worker->ctx;
+	gchar                         *value;
 
 	/* Init timeval */
 	msec_to_tv (ctx->smtp_timeout_raw, &ctx->smtp_timeout);
 
 	/* Init upstreams */
 	if ((value = ctx->upstreams_str) != NULL) {
-		if (!parse_upstreams_line (ctx->pool, ctx->upstreams, value,
-			&ctx->upstream_num)) {
+		if (!parse_upstreams_line (ctx->pool, ctx->upstreams, value, &ctx->upstream_num)) {
 			return FALSE;
 		}
 	}
@@ -1071,7 +977,7 @@ config_smtp_proxy_worker (struct rspamd_worker *worker)
 void
 start_smtp_proxy (struct rspamd_worker *worker)
 {
-	struct smtp_proxy_ctx *ctx = worker->ctx;
+	struct smtp_proxy_ctx         *ctx = worker->ctx;
 
 	ctx->ev_base = rspamd_prepare_worker (worker, "smtp_proxy", accept_socket);
 
@@ -1082,9 +988,7 @@ start_smtp_proxy (struct rspamd_worker *worker)
 	}
 
 	/* DNS resolver */
-	ctx->resolver = dns_resolver_init (worker->srv->logger,
-			ctx->ev_base,
-			worker->srv->cfg);
+	ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
 
 	/* Set umask */
 	umask (S_IWGRP | S_IWOTH | S_IROTH | S_IRGRP);
diff --git a/src/tokenizers/osb.c b/src/tokenizers/osb.c
index faa6a9669..823e1e5b5 100644
--- a/src/tokenizers/osb.c
+++ b/src/tokenizers/osb.c
@@ -26,40 +26,32 @@
  * OSB tokenizer
  */
 
-#include "tokenizers.h"
 #include <sys/types.h>
+#include "tokenizers.h"
 
 /* Minimum length of token */
 #define MIN_LEN 4
 
-extern const int primes[];
+extern const int                primes[];
 
 int
-osb_tokenize_text (struct tokenizer *tokenizer,
-	rspamd_mempool_t * pool,
-	f_str_t * input,
-	GTree ** tree,
-	gboolean save_token,
-	gboolean is_utf,
-	GList *exceptions)
+osb_tokenize_text (struct tokenizer *tokenizer, rspamd_mempool_t * pool, f_str_t * input, GTree ** tree,
+		gboolean save_token, gboolean is_utf, GList *exceptions)
 {
-	token_node_t *new = NULL;
-	f_str_t token = { NULL, 0, 0 };
-	guint32 hashpipe[FEATURE_WINDOW_SIZE], h1, h2;
-	gint i, l, processed = 0;
-	gchar *res;
+	token_node_t                   *new = NULL;
+	f_str_t                         token = { NULL, 0, 0 };
+	guint32                         hashpipe[FEATURE_WINDOW_SIZE], h1, h2;
+	gint                            i, l, processed = 0;
+	gchar                          *res;
 
 	if (*tree == NULL) {
 		*tree = g_tree_new (token_node_compare_func);
-		rspamd_mempool_add_destructor (pool,
-			(rspamd_mempool_destruct_t) g_tree_destroy,
-			*tree);
+		rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_tree_destroy, *tree);
 	}
 
 	memset (hashpipe, 0xfe, FEATURE_WINDOW_SIZE * sizeof (hashpipe[0]));
 
-	while ((res =
-		tokenizer->get_next_word (input, &token, &exceptions)) != NULL) {
+	while ((res = tokenizer->get_next_word (input, &token, &exceptions)) != NULL) {
 		/* Skip small words */
 		if (is_utf) {
 			l = g_utf8_strlen (token.begin, token.len);
@@ -75,7 +67,7 @@ osb_tokenize_text (struct tokenizer *tokenizer,
 		if (processed < FEATURE_WINDOW_SIZE) {
 			/* Just fill a hashpipe */
 			hashpipe[FEATURE_WINDOW_SIZE - ++processed] =
-				fstrhash_lowercase (&token, is_utf);
+					fstrhash_lowercase (&token, is_utf);
 		}
 		else {
 			/* Shift hashpipe */
@@ -83,18 +75,16 @@ osb_tokenize_text (struct tokenizer *tokenizer,
 				hashpipe[i] = hashpipe[i - 1];
 			}
 			hashpipe[0] = fstrhash_lowercase (&token, is_utf);
-			processed++;
+			processed ++;
 
 			for (i = 1; i < FEATURE_WINDOW_SIZE; i++) {
 				h1 = hashpipe[0] * primes[0] + hashpipe[i] * primes[i << 1];
-				h2 = hashpipe[0] * primes[1] + hashpipe[i] *
-					primes[(i << 1) - 1];
+				h2 = hashpipe[0] * primes[1] + hashpipe[i] * primes[(i << 1) - 1];
 				new = rspamd_mempool_alloc0 (pool, sizeof (token_node_t));
 				new->h1 = h1;
 				new->h2 = h2;
 				if (save_token) {
-					new->extra =
-						(uintptr_t)rspamd_mempool_fstrdup (pool, &token);
+					new->extra = (uintptr_t)rspamd_mempool_fstrdup (pool, &token);
 				}
 
 				if (g_tree_lookup (*tree, new) == NULL) {
diff --git a/src/tokenizers/tokenizers.c b/src/tokenizers/tokenizers.c
index 05901531a..448dcd53e 100644
--- a/src/tokenizers/tokenizers.c
+++ b/src/tokenizers/tokenizers.c
@@ -26,15 +26,15 @@
  * Common tokenization functions
  */
 
+#include <sys/types.h>
 #include "main.h"
 #include "tokenizers.h"
-#include <sys/types.h>
 
-struct tokenizer tokenizers[] = {
+struct tokenizer                tokenizers[] = {
 	{"osb-text", osb_tokenize_text, get_next_word},
 };
 
-const int primes[] = {
+const int                       primes[] = {
 	1, 7,
 	3, 13,
 	5, 29,
@@ -48,38 +48,38 @@ const int primes[] = {
 };
 
 const gchar t_delimiters[255] = {
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-	1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 1, 0, 1, 1, 1, 1, 1, 0,
-	1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
-	1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+		1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 1, 0, 1, 1, 1, 1, 1, 0,
+		1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+		1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0
 };
 
-struct tokenizer *
+struct tokenizer               *
 get_tokenizer (const char *name)
 {
-	guint i;
+	guint                            i;
 
 	for (i = 0; i < sizeof (tokenizers) / sizeof (tokenizers[0]); i++) {
 		if (strcmp (tokenizers[i].name, name) == 0) {
@@ -93,7 +93,7 @@ get_tokenizer (const char *name)
 int
 token_node_compare_func (gconstpointer a, gconstpointer b)
 {
-	const token_node_t *aa = a, *bb = b;
+	const token_node_t             *aa = a, *bb = b;
 
 	if (aa->h1 == bb->h1) {
 		return aa->h2 - bb->h2;
@@ -106,9 +106,9 @@ token_node_compare_func (gconstpointer a, gconstpointer b)
 gchar *
 get_next_word (f_str_t * buf, f_str_t * token, GList **exceptions)
 {
-	gsize remain, pos;
-	guchar *p;
-	struct process_exception *ex = NULL;
+	gsize                           remain, pos;
+	guchar                         *p;
+	struct process_exception	   *ex = NULL;
 
 	if (buf == NULL) {
 		return NULL;
@@ -165,7 +165,7 @@ get_next_word (f_str_t * buf, f_str_t * token, GList **exceptions)
 		token->len++;
 		pos++;
 		remain--;
-		p++;
+		p ++;
 	}
 
 	if (remain == 0) {
@@ -177,34 +177,30 @@ get_next_word (f_str_t * buf, f_str_t * token, GList **exceptions)
 
 /* Struct to access gmime headers */
 struct raw_header {
-	struct raw_header *next;
-	char *name;
-	char *value;
+	struct raw_header              *next;
+	char                           *name;
+	char                           *value;
 };
 
 typedef struct _GMimeHeader {
-	GHashTable *hash;
-	GHashTable *writers;
-	struct raw_header *headers;
+	GHashTable                     *hash;
+	GHashTable                     *writers;
+	struct raw_header              *headers;
 } local_GMimeHeader;
 
 int
-tokenize_headers (rspamd_mempool_t * pool,
-	struct rspamd_task *task,
-	GTree ** tree)
+tokenize_headers (rspamd_mempool_t * pool, struct rspamd_task *task, GTree ** tree)
 {
-	token_node_t *new = NULL;
-	f_str_t headername;
-	f_str_t headervalue;
+	token_node_t                   *new = NULL;
+	f_str_t                         headername;
+	f_str_t                         headervalue;
 
 	if (*tree == NULL) {
 		*tree = g_tree_new (token_node_compare_func);
-		rspamd_mempool_add_destructor (pool,
-			(rspamd_mempool_destruct_t) g_tree_destroy,
-			*tree);
+		rspamd_mempool_add_destructor (pool, (rspamd_mempool_destruct_t) g_tree_destroy, *tree);
 	}
 #ifndef GMIME24
-	struct raw_header *h;
+	struct raw_header              *h;
 
 	h = GMIME_OBJECT (task->message)->headers->headers;
 	while (h) {
@@ -223,10 +219,10 @@ tokenize_headers (rspamd_mempool_t * pool,
 		h = h->next;
 	}
 #else
-	GMimeHeaderList *ls;
-	GMimeHeaderIter *iter;
-	const char *name;
-	const char *value;
+	GMimeHeaderList                *ls;
+	GMimeHeaderIter                *iter;
+	const char                     *name;
+	const char                     *value;
 
 	ls = GMIME_OBJECT (task->message)->headers;
 	iter = g_mime_header_iter_new ();
@@ -258,14 +254,13 @@ tokenize_headers (rspamd_mempool_t * pool,
 void
 tokenize_subject (struct rspamd_task *task, GTree ** tree)
 {
-	f_str_t subject;
-	const gchar *sub;
-	struct tokenizer *osb_tokenizer;
+	f_str_t                         subject;
+	const gchar                    *sub;
+	struct tokenizer               *osb_tokenizer;
 
 	if (*tree == NULL) {
 		*tree = g_tree_new (token_node_compare_func);
-		rspamd_mempool_add_destructor (task->task_pool,
-			(rspamd_mempool_destruct_t) g_tree_destroy, *tree);
+		rspamd_mempool_add_destructor (task->task_pool, (rspamd_mempool_destruct_t) g_tree_destroy, *tree);
 	}
 
 	osb_tokenizer = get_tokenizer ("osb-text");
@@ -274,24 +269,12 @@ tokenize_subject (struct rspamd_task *task, GTree ** tree)
 	if (task->subject != NULL) {
 		subject.begin = task->subject;
 		subject.len = strlen (task->subject);
-		osb_tokenizer->tokenize_func (osb_tokenizer,
-			task->task_pool,
-			&subject,
-			tree,
-			FALSE,
-			TRUE,
-			NULL);
+		osb_tokenizer->tokenize_func (osb_tokenizer, task->task_pool, &subject, tree, FALSE, TRUE, NULL);
 	}
 	if ((sub = g_mime_message_get_subject (task->message)) != NULL) {
 		subject.begin = (gchar *)sub;
 		subject.len = strlen (sub);
-		osb_tokenizer->tokenize_func (osb_tokenizer,
-			task->task_pool,
-			&subject,
-			tree,
-			FALSE,
-			TRUE,
-			NULL);
+		osb_tokenizer->tokenize_func (osb_tokenizer, task->task_pool, &subject, tree, FALSE, TRUE, NULL);
 	}
 }
 
diff --git a/src/tokenizers/tokenizers.h b/src/tokenizers/tokenizers.h
index ce056377b..207602dc8 100644
--- a/src/tokenizers/tokenizers.h
+++ b/src/tokenizers/tokenizers.h
@@ -2,9 +2,9 @@
 #define TOKENIZERS_H
 
 #include "config.h"
+#include "mem_pool.h"
 #include "fstring.h"
 #include "main.h"
-#include "mem_pool.h"
 
 /* Size for features pipe */
 #define FEATURE_WINDOW_SIZE 5
@@ -19,30 +19,22 @@ typedef struct token_node_s {
 /* Common tokenizer structure */
 struct tokenizer {
 	gchar *name;
-	gint (*tokenize_func)(struct tokenizer *tokenizer, rspamd_mempool_t *pool,
-		f_str_t *input,
-		GTree **cur, gboolean save_token, gboolean is_utf, GList *exceptions);
-	gchar * (*get_next_word)(f_str_t *buf, f_str_t *token, GList **exceptions);
+	gint (*tokenize_func)(struct tokenizer *tokenizer, rspamd_mempool_t *pool, f_str_t *input,
+			GTree **cur, gboolean save_token, gboolean is_utf, GList *exceptions);
+	gchar* (*get_next_word)(f_str_t *buf, f_str_t *token, GList **exceptions);
 };
 
 /* Compare two token nodes */
 int token_node_compare_func (gconstpointer a, gconstpointer b);
 /* Get tokenizer structure by name or return NULL if this name is not found */
-struct tokenizer * get_tokenizer (const char *name);
+struct tokenizer* get_tokenizer (const char *name);
 /* Get next word from specified f_str_t buf */
-gchar * get_next_word (f_str_t *buf, f_str_t *token, GList **exceptions);
+gchar* get_next_word (f_str_t *buf, f_str_t *token, GList **exceptions);
 /* OSB tokenize function */
-int osb_tokenize_text (struct tokenizer *tokenizer,
-	rspamd_mempool_t *pool,
-	f_str_t *input,
-	GTree **cur,
-	gboolean save_token,
-	gboolean is_utf,
-	GList *exceptions);
+int osb_tokenize_text (struct tokenizer *tokenizer, rspamd_mempool_t *pool, f_str_t *input,
+		GTree **cur, gboolean save_token, gboolean is_utf, GList *exceptions);
 /* Common tokenizer for headers */
-int tokenize_headers (rspamd_mempool_t *pool,
-	struct rspamd_task *task,
-	GTree **cur);
+int tokenize_headers (rspamd_mempool_t *pool, struct rspamd_task *task, GTree **cur);
 /* Make tokens for a subject */
 void tokenize_subject (struct rspamd_task *task, GTree ** tree);
 
diff --git a/src/worker.c b/src/worker.c
index 232ed6c4a..229ee1a4e 100644
--- a/src/worker.c
+++ b/src/worker.c
@@ -26,16 +26,16 @@
  * Rspamd worker implementation
  */
 
-#include "cfg_file.h"
 #include "config.h"
-#include "dns.h"
+#include "util.h"
 #include "main.h"
-#include "map.h"
-#include "message.h"
 #include "protocol.h"
 #include "upstream.h"
+#include "cfg_file.h"
 #include "url.h"
-#include "util.h"
+#include "message.h"
+#include "map.h"
+#include "dns.h"
 
 #include "lua/lua_common.h"
 
@@ -50,42 +50,42 @@ gpointer init_worker (struct rspamd_config *cfg);
 void start_worker (struct rspamd_worker *worker);
 
 worker_t normal_worker = {
-	"normal",                   /* Name */
-	init_worker,                /* Init function */
-	start_worker,               /* Start function */
-	TRUE,                       /* Has socket */
-	FALSE,                      /* Non unique */
-	FALSE,                      /* Non threaded */
-	TRUE,                       /* Killable */
-	SOCK_STREAM                 /* TCP socket */
+	"normal",					/* Name */
+	init_worker,				/* Init function */
+	start_worker,				/* Start function */
+	TRUE,						/* Has socket */
+	FALSE,						/* Non unique */
+	FALSE,						/* Non threaded */
+	TRUE,						/* Killable */
+	SOCK_STREAM					/* TCP socket */
 };
 
 /*
  * Worker's context
  */
 struct rspamd_worker_ctx {
-	guint32 timeout;
-	struct timeval io_tv;
-	/* Detect whether this worker is mime worker    */
-	gboolean is_mime;
+	guint32                         timeout;
+	struct timeval                  io_tv;
+	/* Detect whether this worker is mime worker 	*/
+	gboolean                        is_mime;
 	/* HTTP worker									*/
-	gboolean is_http;
-	/* JSON output                                  */
-	gboolean is_json;
+	gboolean                        is_http;
+	/* JSON output     								*/
+	gboolean                        is_json;
 	/* Allow learning throught worker				*/
-	gboolean allow_learn;
+	gboolean                        allow_learn;
 	/* DNS resolver */
-	struct rspamd_dns_resolver *resolver;
+	struct rspamd_dns_resolver     *resolver;
 	/* Current tasks */
-	guint32 tasks;
+	guint32                         tasks;
 	/* Limit of tasks */
-	guint32 max_tasks;
+	guint32                         max_tasks;
 	/* Classify threads */
-	guint32 classify_threads;
+	guint32							classify_threads;
 	/* Classify threads */
-	GThreadPool *classify_pool;
+	GThreadPool					   *classify_pool;
 	/* Events base */
-	struct event_base *ev_base;
+	struct event_base              *ev_base;
 };
 
 /*
@@ -94,18 +94,18 @@ struct rspamd_worker_ctx {
 static void
 reduce_tasks_count (gpointer arg)
 {
-	guint32 *tasks = arg;
+	guint32                        *tasks = arg;
 
-	(*tasks)--;
+	(*tasks) --;
 }
 
 static gint
 rspamd_worker_body_handler (struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg,
-	const gchar *chunk, gsize len)
+		struct rspamd_http_message *msg,
+		const gchar *chunk, gsize len)
 {
-	struct rspamd_task *task = (struct rspamd_task *) conn->ud;
-	struct rspamd_worker_ctx *ctx;
+	struct rspamd_task             *task = (struct rspamd_task *) conn->ud;
+	struct rspamd_worker_ctx       *ctx;
 
 	ctx = task->worker->ctx;
 
@@ -137,15 +137,14 @@ rspamd_worker_body_handler (struct rspamd_http_connection *conn,
 static void
 rspamd_worker_error_handler (struct rspamd_http_connection *conn, GError *err)
 {
-	struct rspamd_task *task = (struct rspamd_task *) conn->ud;
+	struct rspamd_task             *task = (struct rspamd_task *) conn->ud;
 
 	msg_info ("abnormally closing connection from: %s, error: %s",
-		rspamd_inet_address_to_string (&task->client_addr), err->message);
+			rspamd_inet_address_to_string (&task->client_addr), err->message);
 	if (task->state != CLOSING_CONNECTION) {
 		/* We still need to write a reply */
 		task->error_code = err->code;
-		task->last_error =
-			rspamd_mempool_strdup (task->task_pool, err->message);
+		task->last_error = rspamd_mempool_strdup (task->task_pool, err->message);
 		task->state = WRITE_REPLY;
 		rspamd_protocol_write_reply (task);
 	}
@@ -157,13 +156,13 @@ rspamd_worker_error_handler (struct rspamd_http_connection *conn, GError *err)
 
 static gint
 rspamd_worker_finish_handler (struct rspamd_http_connection *conn,
-	struct rspamd_http_message *msg)
+		struct rspamd_http_message *msg)
 {
-	struct rspamd_task *task = (struct rspamd_task *) conn->ud;
+	struct rspamd_task             *task = (struct rspamd_task *) conn->ud;
 
 	if (task->state == CLOSING_CONNECTION) {
 		msg_debug ("normally closing connection from: %s",
-			rspamd_inet_address_to_string (&task->client_addr));
+				rspamd_inet_address_to_string (&task->client_addr));
 		destroy_session (task->s);
 	}
 	else {
@@ -184,23 +183,21 @@ rspamd_worker_finish_handler (struct rspamd_http_connection *conn,
 static void
 accept_socket (gint fd, short what, void *arg)
 {
-	struct rspamd_worker *worker = (struct rspamd_worker *) arg;
-	struct rspamd_worker_ctx *ctx;
-	struct rspamd_task *new_task;
-	rspamd_inet_addr_t addr;
-	gint nfd;
+	struct rspamd_worker           *worker = (struct rspamd_worker *) arg;
+	struct rspamd_worker_ctx       *ctx;
+	struct rspamd_task             *new_task;
+	rspamd_inet_addr_t               addr;
+	gint                             nfd;
 
 	ctx = worker->ctx;
 
 	if (ctx->max_tasks != 0 && ctx->tasks > ctx->max_tasks) {
-		msg_info ("current tasks is now: %uD while maximum is: %uD",
-			ctx->tasks,
-			ctx->max_tasks);
+		msg_info ("current tasks is now: %uD while maximum is: %uD", ctx->tasks, ctx->max_tasks);
 		return;
 	}
 
 	if ((nfd =
-		rspamd_accept_from_socket (fd, &addr)) == -1) {
+			rspamd_accept_from_socket (fd, &addr)) == -1) {
 		msg_warn ("accept failed: %s", strerror (errno));
 		return;
 	}
@@ -212,8 +209,8 @@ accept_socket (gint fd, short what, void *arg)
 	new_task = rspamd_task_new (worker);
 
 	msg_info ("accepted connection from %s port %d",
-		rspamd_inet_address_to_string (&addr),
-		rspamd_inet_address_get_port (&addr));
+			rspamd_inet_address_to_string (&addr),
+			rspamd_inet_address_get_port (&addr));
 
 	/* Copy some variables */
 	new_task->sock = nfd;
@@ -223,35 +220,26 @@ accept_socket (gint fd, short what, void *arg)
 	worker->srv->stat->connections_count++;
 	new_task->resolver = ctx->resolver;
 
-	new_task->http_conn = rspamd_http_connection_new (
-		rspamd_worker_body_handler,
-		rspamd_worker_error_handler,
-		rspamd_worker_finish_handler,
-		0,
-		RSPAMD_HTTP_SERVER);
+	new_task->http_conn = rspamd_http_connection_new (rspamd_worker_body_handler,
+			rspamd_worker_error_handler, rspamd_worker_finish_handler, 0, RSPAMD_HTTP_SERVER);
 	new_task->ev_base = ctx->ev_base;
-	ctx->tasks++;
-	rspamd_mempool_add_destructor (new_task->task_pool,
-		(rspamd_mempool_destruct_t)reduce_tasks_count, &ctx->tasks);
+	ctx->tasks ++;
+	rspamd_mempool_add_destructor (new_task->task_pool, (rspamd_mempool_destruct_t)reduce_tasks_count, &ctx->tasks);
 
 	/* Set up async session */
 	new_task->s = new_async_session (new_task->task_pool, rspamd_task_fin,
-			rspamd_task_restore, rspamd_task_free_hard, new_task);
+						rspamd_task_restore, rspamd_task_free_hard, new_task);
 
 	new_task->classify_pool = ctx->classify_pool;
 
-	rspamd_http_connection_read_message (new_task->http_conn,
-		new_task,
-		nfd,
-		&ctx->io_tv,
-		ctx->ev_base);
+	rspamd_http_connection_read_message (new_task->http_conn, new_task, nfd, &ctx->io_tv, ctx->ev_base);
 }
 
 gpointer
 init_worker (struct rspamd_config *cfg)
 {
-	struct rspamd_worker_ctx *ctx;
-	GQuark type;
+	struct rspamd_worker_ctx       *ctx;
+	GQuark								type;
 
 	type = g_quark_try_string ("normal");
 
@@ -262,35 +250,32 @@ init_worker (struct rspamd_config *cfg)
 	ctx->classify_threads = 1;
 
 	rspamd_rcl_register_worker_option (cfg, type, "mime",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_mime), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_mime), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "http",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_http), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_http), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "json",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_json), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct rspamd_worker_ctx, is_json), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "allow_learn",
-		rspamd_rcl_parse_struct_boolean, ctx,
-		G_STRUCT_OFFSET (struct rspamd_worker_ctx, allow_learn), 0);
+			rspamd_rcl_parse_struct_boolean, ctx,
+			G_STRUCT_OFFSET (struct rspamd_worker_ctx, allow_learn), 0);
 
 	rspamd_rcl_register_worker_option (cfg, type, "timeout",
-		rspamd_rcl_parse_struct_time, ctx,
-		G_STRUCT_OFFSET (struct rspamd_worker_ctx,
-		timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
+			rspamd_rcl_parse_struct_time, ctx,
+			G_STRUCT_OFFSET (struct rspamd_worker_ctx, timeout), RSPAMD_CL_FLAG_TIME_INTEGER);
 
 	rspamd_rcl_register_worker_option (cfg, type, "max_tasks",
-		rspamd_rcl_parse_struct_integer, ctx,
-		G_STRUCT_OFFSET (struct rspamd_worker_ctx,
-		max_tasks), RSPAMD_CL_FLAG_INT_32);
+			rspamd_rcl_parse_struct_integer, ctx,
+			G_STRUCT_OFFSET (struct rspamd_worker_ctx, max_tasks), RSPAMD_CL_FLAG_INT_32);
 
 	rspamd_rcl_register_worker_option (cfg, type, "classify_threads",
-		rspamd_rcl_parse_struct_integer, ctx,
-		G_STRUCT_OFFSET (struct rspamd_worker_ctx,
-		classify_threads), RSPAMD_CL_FLAG_INT_32);
+			rspamd_rcl_parse_struct_integer, ctx,
+			G_STRUCT_OFFSET (struct rspamd_worker_ctx, classify_threads), RSPAMD_CL_FLAG_INT_32);
 
 	return ctx;
 }
@@ -301,9 +286,9 @@ init_worker (struct rspamd_config *cfg)
 void
 start_worker (struct rspamd_worker *worker)
 {
-	struct rspamd_worker_ctx *ctx = worker->ctx;
-	GError *err = NULL;
-	struct lua_locked_state *nL;
+	struct rspamd_worker_ctx       *ctx = worker->ctx;
+	GError						   *err = NULL;
+	struct lua_locked_state		   *nL;
 
 	ctx->ev_base = rspamd_prepare_worker (worker, "normal", accept_socket);
 	msec_to_tv (ctx->timeout, &ctx->io_tv);
@@ -311,19 +296,13 @@ start_worker (struct rspamd_worker *worker)
 	start_map_watch (worker->srv->cfg, ctx->ev_base);
 
 
-	ctx->resolver = dns_resolver_init (worker->srv->logger,
-			ctx->ev_base,
-			worker->srv->cfg);
+	ctx->resolver = dns_resolver_init (worker->srv->logger, ctx->ev_base, worker->srv->cfg);
 
 	/* Create classify pool */
 	ctx->classify_pool = NULL;
 	if (ctx->classify_threads > 1) {
 		nL = init_lua_locked (worker->srv->cfg);
-		ctx->classify_pool = g_thread_pool_new (process_statfiles_threaded,
-				nL,
-				ctx->classify_threads,
-				TRUE,
-				&err);
+		ctx->classify_pool = g_thread_pool_new (process_statfiles_threaded, nL, ctx->classify_threads, TRUE, &err);
 		if (err != NULL) {
 			msg_err ("pool create failed: %s", err->message);
 			ctx->classify_pool = NULL;
@@ -337,6 +316,6 @@ start_worker (struct rspamd_worker *worker)
 	exit (EXIT_SUCCESS);
 }
 
-/*
- * vi:ts=4
+/* 
+ * vi:ts=4 
  */
diff --git a/uncrustify.cfg b/uncrustify.cfg
deleted file mode 100644
index 858017bb0..000000000
--- a/uncrustify.cfg
+++ /dev/null
@@ -1,135 +0,0 @@
-tok_split_gte=false
-utf8_byte=false
-utf8_force=false
-indent_cmt_with_tabs=false
-indent_align_string=false
-indent_braces=false
-indent_braces_no_func=false
-indent_braces_no_class=false
-indent_braces_no_struct=false
-indent_brace_parent=false
-indent_namespace=false
-indent_extern=false
-indent_class=false
-indent_class_colon=false
-indent_else_if=false
-indent_var_def_cont=false
-indent_func_call_param=false
-indent_func_def_param=false
-indent_func_proto_param=false
-indent_func_class_param=false
-indent_func_ctor_var_param=false
-indent_template_param=false
-indent_func_param_double=false
-indent_relative_single_line_comments=false
-indent_col1_comment=false
-indent_access_spec_body=false
-indent_paren_nl=false
-indent_comma_paren=false
-indent_bool_paren=false
-indent_first_bool_expr=false
-indent_square_nl=false
-indent_preserve_sql=false
-indent_align_assign=true
-sp_balance_nested_parens=false
-align_keep_tabs=false
-align_with_tabs=true
-align_on_tabstop=false
-align_number_left=false
-align_func_params=false
-align_same_func_call_params=true
-align_var_def_colon=false
-align_var_def_attribute=false
-align_var_def_inline=false
-align_right_cmt_mix=false
-align_on_operator=false
-align_mix_var_proto=false
-align_single_line_func=false
-align_single_line_brace=false
-align_nl_cont=false
-align_left_shift=true
-align_oc_decl_colon=false
-nl_collapse_empty_body=false
-nl_assign_leave_one_liners=false
-nl_class_leave_one_liners=false
-nl_enum_leave_one_liners=false
-nl_getset_leave_one_liners=false
-nl_func_leave_one_liners=false
-nl_if_leave_one_liners=false
-nl_multi_line_cond=false
-nl_multi_line_define=false
-nl_before_case=false
-nl_after_case=false
-nl_after_return=false
-nl_after_semicolon=false
-nl_after_brace_open=false
-nl_after_brace_open_cmt=false
-nl_after_vbrace_open=false
-nl_after_vbrace_open_empty=false
-nl_after_brace_close=false
-nl_after_vbrace_close=false
-nl_define_macro=false
-nl_squeeze_ifdef=false
-nl_ds_struct_enum_cmt=false
-nl_ds_struct_enum_close_brace=false
-nl_create_if_one_liner=false
-nl_create_for_one_liner=false
-nl_create_while_one_liner=false
-ls_for_split_full=true
-ls_func_split_full=true
-nl_after_multiline_comment=false
-eat_blanks_after_open_brace=false
-eat_blanks_before_close_brace=false
-mod_full_brace_if_chain=false
-mod_pawn_semicolon=false
-mod_full_paren_if_bool=false
-mod_remove_extra_semicolon=false
-mod_sort_import=false
-mod_sort_using=false
-mod_sort_include=true
-mod_move_case_break=false
-mod_remove_empty_return=false
-cmt_indent_multi=true
-cmt_c_group=false
-cmt_c_nl_start=false
-cmt_c_nl_end=false
-cmt_cpp_group=false
-cmt_cpp_nl_start=false
-cmt_cpp_nl_end=false
-cmt_cpp_to_c=false
-cmt_star_cont=false
-cmt_multi_check_last=true
-cmt_insert_before_preproc=false
-pp_indent_at_level=false
-pp_region_indent_code=false
-pp_if_indent_code=false
-pp_define_at_level=false
-input_tab_size=4
-output_tab_size=4
-indent_columns=4
-indent_continue=4
-code_width=80
-indent_with_tabs=2
-sp_arith=force
-sp_assign=force
-sp_assign_default=force
-sp_before_assign=force
-sp_pp_concat=add
-sp_pp_stringify=add
-sp_bool=add
-sp_paren_brace=force
-sp_before_ptr_star=force
-sp_between_ptr_star=remove
-sp_after_type=force
-sp_before_sparen=force
-sp_sparen_brace=force
-sp_after_semi=add
-sp_after_semi_for=force
-sp_before_comma=remove
-sp_type_func=force
-sp_func_proto_paren=force
-sp_func_def_paren=force
-sp_func_call_paren=force
-sp_case_label=force
-nl_fcall_brace=force
-nl_func_type_name=force
diff --git a/uncrustify.sh b/uncrustify.sh
deleted file mode 100755
index 65058736c..000000000
--- a/uncrustify.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh 
-
-for d in src src/libserver src/client src/libmime src/libutil src/lua src/classifiers src/tokenizers src/plugins ; do
-	file_list=`find ${d} -maxdepth 1 -name "*.c" -or -name "*.h" -type f`
-	for file2indent in $file_list
-	do 
-		echo "Indenting file $file2indent"
-		uncrustify -f "$file2indent" -c "./uncrustify.cfg" -o indentoutput.tmp
-		mv indentoutput.tmp "$file2indent"
-	done
-done