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

No meaningful changes.

1 files changed, 697 insertions, 683 deletions

diff --git a/src/libmime/mime_expressions.c b/src/libmime/mime_expressions.c
index d3d40c870..88e9e16a1 100644
--- a/src/libmime/mime_expressions.c
+++ b/src/libmime/mime_expressions.c
@@ -24,98 +24,98 @@
 #include "lua/lua_common.h"
 #include "utlist.h"
 
-gboolean rspamd_compare_encoding (struct rspamd_task *task,
-								  GArray * args,
-								  void *unused);
-gboolean rspamd_header_exists (struct rspamd_task *task,
-							   GArray * args,
-							   void *unused);
-gboolean rspamd_parts_distance (struct rspamd_task *task,
-								GArray * args,
-								void *unused);
-gboolean rspamd_recipients_distance (struct rspamd_task *task,
-									 GArray * args,
-									 void *unused);
-gboolean rspamd_has_only_html_part (struct rspamd_task *task,
-									GArray * args,
-									void *unused);
-gboolean rspamd_is_recipients_sorted (struct rspamd_task *task,
-									  GArray * args,
-									  void *unused);
-gboolean rspamd_compare_transfer_encoding (struct rspamd_task *task,
-										   GArray * args,
-										   void *unused);
-gboolean rspamd_is_html_balanced (struct rspamd_task *task,
-								  GArray * args,
-								  void *unused);
-gboolean rspamd_has_html_tag (struct rspamd_task *task,
-							  GArray * args,
+gboolean rspamd_compare_encoding(struct rspamd_task *task,
+								 GArray *args,
+								 void *unused);
+gboolean rspamd_header_exists(struct rspamd_task *task,
+							  GArray *args,
 							  void *unused);
-gboolean rspamd_has_fake_html (struct rspamd_task *task,
-							   GArray * args,
+gboolean rspamd_parts_distance(struct rspamd_task *task,
+							   GArray *args,
 							   void *unused);
-static gboolean rspamd_raw_header_exists (struct rspamd_task *task,
-										  GArray * args,
+gboolean rspamd_recipients_distance(struct rspamd_task *task,
+									GArray *args,
+									void *unused);
+gboolean rspamd_has_only_html_part(struct rspamd_task *task,
+								   GArray *args,
+								   void *unused);
+gboolean rspamd_is_recipients_sorted(struct rspamd_task *task,
+									 GArray *args,
+									 void *unused);
+gboolean rspamd_compare_transfer_encoding(struct rspamd_task *task,
+										  GArray *args,
 										  void *unused);
-static gboolean rspamd_check_smtp_data (struct rspamd_task *task,
-										GArray * args,
-										void *unused);
-static gboolean rspamd_content_type_is_type (struct rspamd_task * task,
-											 GArray * args,
-											 void *unused);
-static gboolean rspamd_content_type_is_subtype (struct rspamd_task *task,
-												GArray * args,
-												void *unused);
-static gboolean rspamd_content_type_has_param (struct rspamd_task * task,
-											   GArray * args,
-											   void *unused);
-static gboolean rspamd_content_type_compare_param (struct rspamd_task * task,
-												   GArray * args,
-												   void *unused);
-static gboolean rspamd_has_content_part (struct rspamd_task *task,
-										 GArray * args,
+gboolean rspamd_is_html_balanced(struct rspamd_task *task,
+								 GArray *args,
+								 void *unused);
+gboolean rspamd_has_html_tag(struct rspamd_task *task,
+							 GArray *args,
+							 void *unused);
+gboolean rspamd_has_fake_html(struct rspamd_task *task,
+							  GArray *args,
+							  void *unused);
+static gboolean rspamd_raw_header_exists(struct rspamd_task *task,
+										 GArray *args,
 										 void *unused);
-static gboolean rspamd_has_content_part_len (struct rspamd_task *task,
-											 GArray * args,
-											 void *unused);
-static gboolean rspamd_is_empty_body (struct rspamd_task *task,
-									  GArray * args,
-									  void *unused);
-static gboolean rspamd_has_flag_expr (struct rspamd_task *task,
-									  GArray * args,
-									  void *unused);
-static gboolean rspamd_has_symbol_expr (struct rspamd_task *task,
-									  GArray * args,
-									  void *unused);
-
-static rspamd_expression_atom_t * rspamd_mime_expr_parse (const gchar *line, gsize len,
-		rspamd_mempool_t *pool, gpointer ud, GError **err);
-static gdouble rspamd_mime_expr_process (void *ud, rspamd_expression_atom_t *atom);
-static gint rspamd_mime_expr_priority (rspamd_expression_atom_t *atom);
-static void rspamd_mime_expr_destroy (rspamd_expression_atom_t *atom);
+static gboolean rspamd_check_smtp_data(struct rspamd_task *task,
+									   GArray *args,
+									   void *unused);
+static gboolean rspamd_content_type_is_type(struct rspamd_task *task,
+											GArray *args,
+											void *unused);
+static gboolean rspamd_content_type_is_subtype(struct rspamd_task *task,
+											   GArray *args,
+											   void *unused);
+static gboolean rspamd_content_type_has_param(struct rspamd_task *task,
+											  GArray *args,
+											  void *unused);
+static gboolean rspamd_content_type_compare_param(struct rspamd_task *task,
+												  GArray *args,
+												  void *unused);
+static gboolean rspamd_has_content_part(struct rspamd_task *task,
+										GArray *args,
+										void *unused);
+static gboolean rspamd_has_content_part_len(struct rspamd_task *task,
+											GArray *args,
+											void *unused);
+static gboolean rspamd_is_empty_body(struct rspamd_task *task,
+									 GArray *args,
+									 void *unused);
+static gboolean rspamd_has_flag_expr(struct rspamd_task *task,
+									 GArray *args,
+									 void *unused);
+static gboolean rspamd_has_symbol_expr(struct rspamd_task *task,
+									   GArray *args,
+									   void *unused);
+
+static rspamd_expression_atom_t *rspamd_mime_expr_parse(const gchar *line, gsize len,
+														rspamd_mempool_t *pool, gpointer ud, GError **err);
+static gdouble rspamd_mime_expr_process(void *ud, rspamd_expression_atom_t *atom);
+static gint rspamd_mime_expr_priority(rspamd_expression_atom_t *atom);
+static void rspamd_mime_expr_destroy(rspamd_expression_atom_t *atom);
 
 /**
  * Regexp structure
  */
 struct rspamd_regexp_atom {
-	enum rspamd_re_type type;                       /**< regexp type										*/
-	gchar *regexp_text;                             /**< regexp text representation							*/
-	rspamd_regexp_t *regexp;                        /**< regexp structure									*/
+	enum rspamd_re_type type; /**< regexp type										*/
+	gchar *regexp_text;       /**< regexp text representation							*/
+	rspamd_regexp_t *regexp;  /**< regexp structure									*/
 	union {
-		const gchar *header;                        /**< header name for header regexps						*/
-		const gchar *selector;                      /**< selector name for lua selector regexp				*/
+		const gchar *header;   /**< header name for header regexps						*/
+		const gchar *selector; /**< selector name for lua selector regexp				*/
 	} extra;
-	gboolean is_test;                               /**< true if this expression must be tested				*/
-	gboolean is_strong;                             /**< true if headers search must be case sensitive		*/
-	gboolean is_multiple;                           /**< true if we need to match all inclusions of atom	*/
+	gboolean is_test;     /**< true if this expression must be tested				*/
+	gboolean is_strong;   /**< true if headers search must be case sensitive		*/
+	gboolean is_multiple; /**< true if we need to match all inclusions of atom	*/
 };
 
 /**
  * Rspamd expression function
  */
 struct rspamd_function_atom {
-	gchar *name;	/**< name of function								*/
-	GArray *args;	/**< its args										*/
+	gchar *name;  /**< name of function								*/
+	GArray *args; /**< its args										*/
 };
 
 enum rspamd_mime_atom_type {
@@ -145,128 +145,127 @@ static struct _fl {
 	rspamd_internal_func_t func;
 	void *user_data;
 } rspamd_functions_list[] = {
-		{"check_smtp_data", rspamd_check_smtp_data, NULL},
-		{"compare_encoding", rspamd_compare_encoding, NULL},
-		{"compare_parts_distance", rspamd_parts_distance, NULL},
-		{"compare_recipients_distance", rspamd_recipients_distance, NULL},
-		{"compare_transfer_encoding", rspamd_compare_transfer_encoding, NULL},
-		{"content_type_compare_param", rspamd_content_type_compare_param, NULL},
-		{"content_type_has_param", rspamd_content_type_has_param, NULL},
-		{"content_type_is_subtype", rspamd_content_type_is_subtype, NULL},
-		{"content_type_is_type", rspamd_content_type_is_type, NULL},
-		{"has_content_part", rspamd_has_content_part, NULL},
-		{"has_content_part_len", rspamd_has_content_part_len, NULL},
-		{"has_fake_html", rspamd_has_fake_html, NULL},
-		{"has_flag", rspamd_has_flag_expr, NULL},
-		{"has_html_tag", rspamd_has_html_tag, NULL},
-		{"has_only_html_part", rspamd_has_only_html_part, NULL},
-		{"has_symbol", rspamd_has_symbol_expr, NULL},
-		{"header_exists", rspamd_header_exists, NULL},
-		{"is_empty_body", rspamd_is_empty_body, NULL},
-		{"is_html_balanced", rspamd_is_html_balanced, NULL},
-		{"is_recipients_sorted", rspamd_is_recipients_sorted, NULL},
-		{"raw_header_exists", rspamd_raw_header_exists, NULL},
+	{"check_smtp_data", rspamd_check_smtp_data, NULL},
+	{"compare_encoding", rspamd_compare_encoding, NULL},
+	{"compare_parts_distance", rspamd_parts_distance, NULL},
+	{"compare_recipients_distance", rspamd_recipients_distance, NULL},
+	{"compare_transfer_encoding", rspamd_compare_transfer_encoding, NULL},
+	{"content_type_compare_param", rspamd_content_type_compare_param, NULL},
+	{"content_type_has_param", rspamd_content_type_has_param, NULL},
+	{"content_type_is_subtype", rspamd_content_type_is_subtype, NULL},
+	{"content_type_is_type", rspamd_content_type_is_type, NULL},
+	{"has_content_part", rspamd_has_content_part, NULL},
+	{"has_content_part_len", rspamd_has_content_part_len, NULL},
+	{"has_fake_html", rspamd_has_fake_html, NULL},
+	{"has_flag", rspamd_has_flag_expr, NULL},
+	{"has_html_tag", rspamd_has_html_tag, NULL},
+	{"has_only_html_part", rspamd_has_only_html_part, NULL},
+	{"has_symbol", rspamd_has_symbol_expr, NULL},
+	{"header_exists", rspamd_header_exists, NULL},
+	{"is_empty_body", rspamd_is_empty_body, NULL},
+	{"is_html_balanced", rspamd_is_html_balanced, NULL},
+	{"is_recipients_sorted", rspamd_is_recipients_sorted, NULL},
+	{"raw_header_exists", rspamd_raw_header_exists, NULL},
 };
 
 const struct rspamd_atom_subr mime_expr_subr = {
 	.parse = rspamd_mime_expr_parse,
 	.process = rspamd_mime_expr_process,
 	.priority = rspamd_mime_expr_priority,
-	.destroy = rspamd_mime_expr_destroy
-};
+	.destroy = rspamd_mime_expr_destroy};
 
 static struct _fl *list_ptr = &rspamd_functions_list[0];
-static guint32 functions_number = sizeof (rspamd_functions_list) /
-	sizeof (struct _fl);
+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)
+fl_cmp(const void *s1, const void *s2)
 {
-	struct _fl *fl1 = (struct _fl *)s1;
-	struct _fl *fl2 = (struct _fl *)s2;
-	return strcmp (fl1->name, fl2->name);
+	struct _fl *fl1 = (struct _fl *) s1;
+	struct _fl *fl2 = (struct _fl *) s2;
+	return strcmp(fl1->name, fl2->name);
 }
 
 static GQuark
-rspamd_mime_expr_quark (void)
+rspamd_mime_expr_quark(void)
 {
-	return g_quark_from_static_string ("mime-expressions");
+	return g_quark_from_static_string("mime-expressions");
 }
 
 #define TYPE_CHECK(str, type, len) (sizeof(type) - 1 == (len) && rspamd_lc_cmp((str), (type), (len)) == 0)
 static gboolean
-rspamd_parse_long_option (const gchar *start, gsize len,
-		struct rspamd_regexp_atom *a)
+rspamd_parse_long_option(const gchar *start, gsize len,
+						 struct rspamd_regexp_atom *a)
 {
 	gboolean ret = FALSE;
 
-	if (TYPE_CHECK (start, "body", len)) {
+	if (TYPE_CHECK(start, "body", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_BODY;
 	}
-	else if (TYPE_CHECK (start, "part", len) ||
-			TYPE_CHECK (start, "mime", len)) {
+	else if (TYPE_CHECK(start, "part", len) ||
+			 TYPE_CHECK(start, "mime", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_MIME;
 	}
-	else if (TYPE_CHECK (start, "raw_part", len) ||
-			TYPE_CHECK (start, "raw_mime", len) ||
-			TYPE_CHECK (start, "mime_raw", len)) {
+	else if (TYPE_CHECK(start, "raw_part", len) ||
+			 TYPE_CHECK(start, "raw_mime", len) ||
+			 TYPE_CHECK(start, "mime_raw", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_RAWMIME;
 	}
-	else if (TYPE_CHECK (start, "header", len)) {
+	else if (TYPE_CHECK(start, "header", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_HEADER;
 	}
-	else if (TYPE_CHECK (start, "mime_header", len) ||
-			TYPE_CHECK (start, "header_mime", len)) {
+	else if (TYPE_CHECK(start, "mime_header", len) ||
+			 TYPE_CHECK(start, "header_mime", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_MIMEHEADER;
 	}
-	else if (TYPE_CHECK (start, "raw_header", len) ||
-			TYPE_CHECK (start, "header_raw", len)) {
+	else if (TYPE_CHECK(start, "raw_header", len) ||
+			 TYPE_CHECK(start, "header_raw", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_RAWHEADER;
 	}
-	else if (TYPE_CHECK (start, "all_header", len) ||
-			TYPE_CHECK (start, "header_all", len) ||
-			TYPE_CHECK (start, "all_headers", len)) {
+	else if (TYPE_CHECK(start, "all_header", len) ||
+			 TYPE_CHECK(start, "header_all", len) ||
+			 TYPE_CHECK(start, "all_headers", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_ALLHEADER;
 	}
-	else if (TYPE_CHECK (start, "url", len)) {
+	else if (TYPE_CHECK(start, "url", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_URL;
 	}
-	else if (TYPE_CHECK (start, "email", len)) {
+	else if (TYPE_CHECK(start, "email", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_EMAIL;
 	}
-	else if (TYPE_CHECK (start, "sa_body", len)) {
+	else if (TYPE_CHECK(start, "sa_body", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_SABODY;
 	}
-	else if (TYPE_CHECK (start, "sa_raw_body", len) ||
-			TYPE_CHECK (start, "sa_body_raw", len)) {
+	else if (TYPE_CHECK(start, "sa_raw_body", len) ||
+			 TYPE_CHECK(start, "sa_body_raw", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_SARAWBODY;
 	}
-	else if (TYPE_CHECK (start, "words", len)) {
+	else if (TYPE_CHECK(start, "words", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_WORDS;
 	}
-	else if (TYPE_CHECK (start, "raw_words", len)) {
+	else if (TYPE_CHECK(start, "raw_words", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_RAWWORDS;
 	}
-	else if (TYPE_CHECK (start, "stem_words", len)) {
+	else if (TYPE_CHECK(start, "stem_words", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_STEMWORDS;
 	}
-	else if (TYPE_CHECK (start, "selector", len)) {
+	else if (TYPE_CHECK(start, "selector", len)) {
 		ret = TRUE;
 		a->type = RSPAMD_RE_SELECTOR;
 	}
@@ -278,8 +277,8 @@ rspamd_parse_long_option (const gchar *start, gsize len,
  * Rspamd regexp utility functions
  */
 static struct rspamd_regexp_atom *
-rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
-		struct rspamd_config *cfg)
+rspamd_mime_expr_parse_regexp_atom(rspamd_mempool_t *pool, const gchar *line,
+								   struct rspamd_config *cfg)
 {
 	const gchar *begin, *end, *p, *src, *start, *brace;
 	gchar *dbegin, *dend, *extra = NULL;
@@ -288,18 +287,18 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 	GString *re_flags;
 
 	if (line == NULL) {
-		msg_err_pool ("cannot parse NULL line");
+		msg_err_pool("cannot parse NULL line");
 		return NULL;
 	}
 
 	src = line;
-	result = rspamd_mempool_alloc0 (pool, sizeof (struct rspamd_regexp_atom));
+	result = rspamd_mempool_alloc0(pool, sizeof(struct rspamd_regexp_atom));
 	/* Skip whitespaces */
-	while (g_ascii_isspace (*line)) {
+	while (g_ascii_isspace(*line)) {
 		line++;
 	}
 	if (*line == '\0') {
-		msg_warn_pool ("got empty regexp");
+		msg_warn_pool("got empty regexp");
 		return NULL;
 	}
 
@@ -307,7 +306,7 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 
 	start = line;
 	/* First try to find header name */
-	begin = strchr (line, '/');
+	begin = strchr(line, '/');
 	if (begin != NULL) {
 		p = begin;
 		end = NULL;
@@ -320,13 +319,13 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 		}
 
 		if (end) {
-			extra = rspamd_mempool_alloc (pool, end - line + 1);
-			rspamd_strlcpy (extra, line, end - line + 1);
+			extra = rspamd_mempool_alloc(pool, end - line + 1);
+			rspamd_strlcpy(extra, line, end - line + 1);
 			line = end;
 		}
 	}
 	else {
-		extra = rspamd_mempool_strdup (pool, line);
+		extra = rspamd_mempool_strdup(pool, line);
 		result->type = RSPAMD_RE_MAX;
 		line = start;
 	}
@@ -339,13 +338,13 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 	}
 	else if (extra == NULL) {
 		/* Assume that line without // is just a header name */
-		extra = rspamd_mempool_strdup (pool, line);
+		extra = rspamd_mempool_strdup(pool, line);
 		result->type = RSPAMD_RE_HEADER;
 		return result;
 	}
 	else {
 		/* We got header name earlier but have not found // expression, so it is invalid regexp */
-		msg_warn_pool (
+		msg_warn_pool(
 			"got no header name (eg. header=) but without corresponding regexp, %s",
 			src);
 		return NULL;
@@ -356,12 +355,12 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 		end++;
 	}
 	if (end == begin || *end != '/') {
-		msg_warn_pool ("no trailing / in regexp %s", src);
+		msg_warn_pool("no trailing / in regexp %s", src);
 		return NULL;
 	}
 	/* Parse flags */
 	p = end + 1;
-	re_flags = g_string_sized_new (32);
+	re_flags = g_string_sized_new(32);
 
 	while (p != NULL) {
 		switch (*p) {
@@ -374,7 +373,7 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 		case 'r':
 		case 'L':
 			/* Handled by rspamd_regexp_t */
-			g_string_append_c (re_flags, *p);
+			g_string_append_c(re_flags, *p);
 			p++;
 			break;
 		case 'o':
@@ -427,10 +426,10 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 			break;
 		case '{':
 			/* Long definition */
-			if ((brace = strchr (p + 1, '}')) != NULL) {
-				if (!rspamd_parse_long_option (p + 1, brace - (p + 1), result)) {
-					msg_warn_pool ("invalid long regexp type: %*s in '%s'",
-							(int)(brace - (p + 1)), p + 1, src);
+			if ((brace = strchr(p + 1, '}')) != NULL) {
+				if (!rspamd_parse_long_option(p + 1, brace - (p + 1), result)) {
+					msg_warn_pool("invalid long regexp type: %*s in '%s'",
+								  (int) (brace - (p + 1)), p + 1, src);
 					p = NULL;
 				}
 				else {
@@ -468,16 +467,16 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 			result->type = RSPAMD_RE_HEADER;
 		}
 		else {
-			msg_err_pool ("could not read regexp: %s, unknown type", src);
+			msg_err_pool("could not read regexp: %s, unknown type", src);
 			return NULL;
 		}
 	}
 
 	if ((result->type == RSPAMD_RE_HEADER ||
-			result->type == RSPAMD_RE_RAWHEADER ||
-			result->type == RSPAMD_RE_MIMEHEADER)) {
+		 result->type == RSPAMD_RE_RAWHEADER ||
+		 result->type == RSPAMD_RE_MIMEHEADER)) {
 		if (extra == NULL) {
-			msg_err_pool ("header regexp: '%s' has no header part", src);
+			msg_err_pool("header regexp: '%s' has no header part", src);
 			return NULL;
 		}
 		else {
@@ -487,7 +486,7 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 
 	if (result->type == RSPAMD_RE_SELECTOR) {
 		if (extra == NULL) {
-			msg_err_pool ("selector regexp: '%s' has no selector part", src);
+			msg_err_pool("selector regexp: '%s' has no selector part", src);
 			return NULL;
 		}
 		else {
@@ -496,35 +495,35 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 	}
 
 
-	result->regexp_text = rspamd_mempool_strdup (pool, start);
+	result->regexp_text = rspamd_mempool_strdup(pool, start);
 	dbegin = result->regexp_text + (begin - start);
 	dend = result->regexp_text + (end - start);
 	*dend = '\0';
 
-	result->regexp = rspamd_regexp_new (dbegin, re_flags->str,
-			&err);
+	result->regexp = rspamd_regexp_new(dbegin, re_flags->str,
+									   &err);
 
-	g_string_free (re_flags, TRUE);
+	g_string_free(re_flags, TRUE);
 
 	if (result->regexp == NULL || err != NULL) {
-		msg_warn_pool ("could not read regexp: %s while reading regexp %e",
-				src, err);
+		msg_warn_pool("could not read regexp: %s while reading regexp %e",
+					  src, err);
 
 		if (err) {
-			g_error_free (err);
+			g_error_free(err);
 		}
 
 		return NULL;
 	}
 
 	if (result->is_multiple) {
-		rspamd_regexp_set_maxhits (result->regexp, 0);
+		rspamd_regexp_set_maxhits(result->regexp, 0);
 	}
 	else {
-		rspamd_regexp_set_maxhits (result->regexp, 1);
+		rspamd_regexp_set_maxhits(result->regexp, 1);
 	}
 
-	rspamd_regexp_set_ud (result->regexp, result);
+	rspamd_regexp_set_ud(result->regexp, result);
 
 	*dend = '/';
 
@@ -532,7 +531,7 @@ rspamd_mime_expr_parse_regexp_atom (rspamd_mempool_t * pool, const gchar *line,
 }
 
 struct rspamd_function_atom *
-rspamd_mime_expr_parse_function_atom (rspamd_mempool_t *pool, const gchar *input)
+rspamd_mime_expr_parse_function_atom(rspamd_mempool_t *pool, const gchar *input)
 {
 	const gchar *obrace, *ebrace, *p, *c;
 	gchar t, *databuf;
@@ -546,17 +545,18 @@ rspamd_mime_expr_parse_function_atom (rspamd_mempool_t *pool, const gchar *input
 		in_regexp,
 		got_backslash,
 		got_comma
-	} state, prev_state = 0;
+	} state,
+		prev_state = 0;
 
-	obrace = strchr (input, '(');
-	ebrace = strrchr (input, ')');
+	obrace = strchr(input, '(');
+	ebrace = strrchr(input, ')');
 
-	g_assert (obrace != NULL && ebrace != NULL);
+	g_assert(obrace != NULL && ebrace != NULL);
 
-	res = rspamd_mempool_alloc0 (pool, sizeof (*res));
-	res->name = rspamd_mempool_alloc (pool, obrace - input + 1);
-	rspamd_strlcpy (res->name, input, obrace - input + 1);
-	res->args = g_array_new (FALSE, FALSE, sizeof (struct expression_argument));
+	res = rspamd_mempool_alloc0(pool, sizeof(*res));
+	res->name = rspamd_mempool_alloc(pool, obrace - input + 1);
+	rspamd_strlcpy(res->name, input, obrace - input + 1);
+	res->args = g_array_new(FALSE, FALSE, sizeof(struct expression_argument));
 
 	p = obrace + 1;
 	c = p;
@@ -571,7 +571,7 @@ rspamd_mime_expr_parse_function_atom (rspamd_mempool_t *pool, const gchar *input
 				state = in_regexp;
 				c = p;
 			}
-			else if (!g_ascii_isspace (t)) {
+			else if (!g_ascii_isspace(t)) {
 				state = in_string;
 
 				if (t == '\'' || t == '\"') {
@@ -581,7 +581,7 @@ rspamd_mime_expr_parse_function_atom (rspamd_mempool_t *pool, const gchar *input
 					c = p;
 				}
 			}
-			p ++;
+			p++;
 			break;
 		case in_regexp:
 			if (t == '\\') {
@@ -590,24 +590,24 @@ rspamd_mime_expr_parse_function_atom (rspamd_mempool_t *pool, const gchar *input
 			}
 			else if (t == ',' || p == ebrace) {
 				len = p - c + 1;
-				databuf = rspamd_mempool_alloc (pool, len);
-				rspamd_strlcpy (databuf, c, len);
+				databuf = rspamd_mempool_alloc(pool, len);
+				rspamd_strlcpy(databuf, c, len);
 				arg.type = EXPRESSION_ARGUMENT_REGEXP;
-				arg.data = rspamd_regexp_cache_create (NULL, databuf, NULL, &err);
+				arg.data = rspamd_regexp_cache_create(NULL, databuf, NULL, &err);
 
 				if (arg.data == NULL) {
 					/* Fallback to string */
-					msg_warn ("cannot parse slashed argument %s as regexp: %s",
-							databuf, err->message);
-					g_error_free (err);
+					msg_warn("cannot parse slashed argument %s as regexp: %s",
+							 databuf, err->message);
+					g_error_free(err);
 					arg.type = EXPRESSION_ARGUMENT_NORMAL;
 					arg.data = databuf;
 				}
 
-				g_array_append_val (res->args, arg);
+				g_array_append_val(res->args, arg);
 				state = got_comma;
 			}
-			p ++;
+			p++;
 			break;
 		case in_string:
 			if (t == '\\') {
@@ -622,18 +622,18 @@ rspamd_mime_expr_parse_function_atom (rspamd_mempool_t *pool, const gchar *input
 					len = p - c + 1;
 				}
 
-				databuf = rspamd_mempool_alloc (pool, len);
-				rspamd_strlcpy (databuf, c, len);
+				databuf = rspamd_mempool_alloc(pool, len);
+				rspamd_strlcpy(databuf, c, len);
 				arg.type = EXPRESSION_ARGUMENT_NORMAL;
 				arg.data = databuf;
-				g_array_append_val (res->args, arg);
+				g_array_append_val(res->args, arg);
 				state = got_comma;
 			}
-			p ++;
+			p++;
 			break;
 		case got_backslash:
 			state = prev_state;
-			p ++;
+			p++;
 			break;
 		case got_comma:
 			state = start_read_argument;
@@ -645,13 +645,13 @@ rspamd_mime_expr_parse_function_atom (rspamd_mempool_t *pool, const gchar *input
 }
 
 static rspamd_expression_atom_t *
-rspamd_mime_expr_parse (const gchar *line, gsize len,
-		rspamd_mempool_t *pool, gpointer ud, GError **err)
+rspamd_mime_expr_parse(const gchar *line, gsize len,
+					   rspamd_mempool_t *pool, gpointer ud, GError **err)
 {
 	rspamd_expression_atom_t *a = NULL;
 	struct rspamd_mime_atom *mime_atom = NULL;
 	const gchar *p, *end, *c = NULL;
-	struct rspamd_mime_expr_ud *real_ud = (struct rspamd_mime_expr_ud *)ud;
+	struct rspamd_mime_expr_ud *real_ud = (struct rspamd_mime_expr_ud *) ud;
 	struct rspamd_config *cfg;
 	rspamd_regexp_t *own_re;
 	gchar t;
@@ -670,7 +670,8 @@ rspamd_mime_expr_parse (const gchar *line, gsize len,
 		got_ebrace,
 		end_atom,
 		bad_atom
-	} state = 0, prev_state = 0;
+	} state = 0,
+	  prev_state = 0;
 
 	p = line;
 	end = p + len;
@@ -689,9 +690,9 @@ rspamd_mime_expr_parse (const gchar *line, gsize len,
 				/* Function */
 				state = got_obrace;
 			}
-			else if (!g_ascii_isalnum (t) && t != '_' && t != '-' && t != '=') {
+			else if (!g_ascii_isalnum(t) && t != '_' && t != '-' && t != '=') {
 				if (t == ':') {
-					if (p - line == 3 && memcmp (line, "lua", 3) == 0) {
+					if (p - line == 3 && memcmp(line, "lua", 3) == 0) {
 						type = MIME_ATOM_LOCAL_LUA_FUNCTION;
 						state = in_local_function;
 						c = p + 1;
@@ -705,10 +706,10 @@ rspamd_mime_expr_parse (const gchar *line, gsize len,
 					continue;
 				}
 			}
-			else if (g_ascii_isspace (t)) {
+			else if (g_ascii_isspace(t)) {
 				state = bad_atom;
 			}
-			p ++;
+			p++;
 			break;
 		case got_slash:
 			state = in_regexp;
@@ -721,7 +722,7 @@ rspamd_mime_expr_parse (const gchar *line, gsize len,
 			else if (t == '/') {
 				state = got_second_slash;
 			}
-			p ++;
+			p++;
 			break;
 		case got_second_slash:
 			state = in_flags;
@@ -729,29 +730,29 @@ rspamd_mime_expr_parse (const gchar *line, gsize len,
 		case in_flags:
 			if (t == '{') {
 				state = in_flags_brace;
-				p ++;
+				p++;
 			}
-			else if (!g_ascii_isalpha (t) && t != '$') {
+			else if (!g_ascii_isalpha(t) && t != '$') {
 				state = end_atom;
 			}
 			else {
-				p ++;
+				p++;
 			}
 			break;
 		case in_flags_brace:
 			if (t == '}') {
 				state = in_flags;
 			}
-			p ++;
+			p++;
 			break;
 		case got_backslash:
 			state = prev_state;
-			p ++;
+			p++;
 			break;
 		case got_obrace:
 			state = in_function;
 			type = MIME_ATOM_INTERNAL_FUNCTION;
-			obraces ++;
+			obraces++;
 			break;
 		case in_function:
 			if (t == '\\') {
@@ -759,19 +760,19 @@ rspamd_mime_expr_parse (const gchar *line, gsize len,
 				prev_state = in_function;
 			}
 			else if (t == '(') {
-				obraces ++;
+				obraces++;
 			}
 			else if (t == ')') {
-				ebraces ++;
+				ebraces++;
 				if (ebraces == obraces) {
 					state = got_ebrace;
 				}
 			}
-			p ++;
+			p++;
 			break;
 		case in_local_function:
-			if (!(g_ascii_isalnum (t) || t == '-' || t == '_')) {
-				g_assert (c != NULL);
+			if (!(g_ascii_isalnum(t) || t == '-' || t == '_')) {
+				g_assert(c != NULL);
 				state = end_atom;
 			}
 			else {
@@ -782,10 +783,11 @@ rspamd_mime_expr_parse (const gchar *line, gsize len,
 			state = end_atom;
 			break;
 		case bad_atom:
-			g_set_error (err, rspamd_mime_expr_quark(), 100, "cannot parse"
-					" mime atom '%s' when reading symbol '%c' at offset %d, "
-					"near %.*s", line, t, (gint)(p - line),
-					(gint)MIN (end - p, 10), p);
+			g_set_error(err, rspamd_mime_expr_quark(), 100, "cannot parse"
+															" mime atom '%s' when reading symbol '%c' at offset %d, "
+															"near %.*s",
+						line, t, (gint) (p - line),
+						(gint) MIN(end - p, 10), p);
 			return NULL;
 		case end_atom:
 			goto set;
@@ -794,24 +796,24 @@ rspamd_mime_expr_parse (const gchar *line, gsize len,
 set:
 
 	if (p - line == 0 || (state != got_ebrace && state != got_second_slash &&
-			state != in_flags && state != end_atom)) {
-		g_set_error (err, rspamd_mime_expr_quark(), 200, "incomplete or empty"
-				" mime atom");
+						  state != in_flags && state != end_atom)) {
+		g_set_error(err, rspamd_mime_expr_quark(), 200, "incomplete or empty"
+														" mime atom");
 		return NULL;
 	}
 
-	mime_atom = rspamd_mempool_alloc (pool, sizeof (*mime_atom));
+	mime_atom = rspamd_mempool_alloc(pool, sizeof(*mime_atom));
 	mime_atom->type = type;
-	mime_atom->str = rspamd_mempool_alloc (pool, p - line + 1);
-	rspamd_strlcpy (mime_atom->str, line, p - line + 1);
+	mime_atom->str = rspamd_mempool_alloc(pool, p - line + 1);
+	rspamd_strlcpy(mime_atom->str, line, p - line + 1);
 
 	if (type == MIME_ATOM_REGEXP) {
-		mime_atom->d.re = rspamd_mime_expr_parse_regexp_atom (pool,
-				mime_atom->str, cfg);
+		mime_atom->d.re = rspamd_mime_expr_parse_regexp_atom(pool,
+															 mime_atom->str, cfg);
 		if (mime_atom->d.re == NULL) {
-			g_set_error (err, rspamd_mime_expr_quark(), 200,
-					"cannot parse regexp '%s'",
-					mime_atom->str);
+			g_set_error(err, rspamd_mime_expr_quark(), 200,
+						"cannot parse regexp '%s'",
+						mime_atom->str);
 			goto err;
 		}
 		else {
@@ -819,27 +821,27 @@ set:
 
 			/* Check regexp condition */
 			if (real_ud->conf_obj != NULL) {
-				const ucl_object_t *re_conditions = ucl_object_lookup (real_ud->conf_obj,
-						"re_conditions");
+				const ucl_object_t *re_conditions = ucl_object_lookup(real_ud->conf_obj,
+																	  "re_conditions");
 
 				if (re_conditions != NULL) {
-					if (ucl_object_type (re_conditions) != UCL_OBJECT) {
-						g_set_error (err, rspamd_mime_expr_quark (), 320,
-								"re_conditions is not a table for '%s'",
-								mime_atom->str);
-						rspamd_regexp_unref (mime_atom->d.re->regexp);
+					if (ucl_object_type(re_conditions) != UCL_OBJECT) {
+						g_set_error(err, rspamd_mime_expr_quark(), 320,
+									"re_conditions is not a table for '%s'",
+									mime_atom->str);
+						rspamd_regexp_unref(mime_atom->d.re->regexp);
 						goto err;
 					}
 
-					const ucl_object_t *function_obj = ucl_object_lookup (re_conditions,
-							mime_atom->str);
+					const ucl_object_t *function_obj = ucl_object_lookup(re_conditions,
+																		 mime_atom->str);
 
 					if (function_obj != NULL) {
-						if (ucl_object_type (function_obj) != UCL_USERDATA) {
-							g_set_error (err, rspamd_mime_expr_quark (), 320,
-									"condition for '%s' is invalid, must be function",
-									mime_atom->str);
-							rspamd_regexp_unref (mime_atom->d.re->regexp);
+						if (ucl_object_type(function_obj) != UCL_USERDATA) {
+							g_set_error(err, rspamd_mime_expr_quark(), 320,
+										"condition for '%s' is invalid, must be function",
+										mime_atom->str);
+							rspamd_regexp_unref(mime_atom->d.re->regexp);
 							goto err;
 						}
 
@@ -851,132 +853,131 @@ set:
 			}
 
 			if (lua_cbref != -1) {
-				msg_info_config ("added condition for regexp %s", mime_atom->str);
+				msg_info_config("added condition for regexp %s", mime_atom->str);
 			}
 
 			/* Register new item in the cache */
 			if (mime_atom->d.re->type == RSPAMD_RE_HEADER ||
-					mime_atom->d.re->type == RSPAMD_RE_RAWHEADER ||
-					mime_atom->d.re->type == RSPAMD_RE_MIMEHEADER) {
+				mime_atom->d.re->type == RSPAMD_RE_RAWHEADER ||
+				mime_atom->d.re->type == RSPAMD_RE_MIMEHEADER) {
 
 				if (mime_atom->d.re->extra.header != NULL) {
 					own_re = mime_atom->d.re->regexp;
-					mime_atom->d.re->regexp = rspamd_re_cache_add (cfg->re_cache,
-							mime_atom->d.re->regexp,
-							mime_atom->d.re->type,
-							mime_atom->d.re->extra.header,
-							strlen (mime_atom->d.re->extra.header) + 1,
-							lua_cbref);
+					mime_atom->d.re->regexp = rspamd_re_cache_add(cfg->re_cache,
+																  mime_atom->d.re->regexp,
+																  mime_atom->d.re->type,
+																  mime_atom->d.re->extra.header,
+																  strlen(mime_atom->d.re->extra.header) + 1,
+																  lua_cbref);
 					/* Pass ownership to the cache */
-					rspamd_regexp_unref (own_re);
+					rspamd_regexp_unref(own_re);
 				}
 				else {
 					/* We have header regexp, but no header name is detected */
-					g_set_error (err,
-							rspamd_mime_expr_quark (),
-							200,
-							"no header name in header regexp: '%s'",
-							mime_atom->str);
-					rspamd_regexp_unref (mime_atom->d.re->regexp);
+					g_set_error(err,
+								rspamd_mime_expr_quark(),
+								200,
+								"no header name in header regexp: '%s'",
+								mime_atom->str);
+					rspamd_regexp_unref(mime_atom->d.re->regexp);
 					goto err;
 				}
-
 			}
 			else if (mime_atom->d.re->type == RSPAMD_RE_SELECTOR) {
 				if (mime_atom->d.re->extra.selector != NULL) {
 					own_re = mime_atom->d.re->regexp;
-					mime_atom->d.re->regexp = rspamd_re_cache_add (cfg->re_cache,
-							mime_atom->d.re->regexp,
-							mime_atom->d.re->type,
-							mime_atom->d.re->extra.selector,
-							strlen (mime_atom->d.re->extra.selector) + 1,
-							lua_cbref);
+					mime_atom->d.re->regexp = rspamd_re_cache_add(cfg->re_cache,
+																  mime_atom->d.re->regexp,
+																  mime_atom->d.re->type,
+																  mime_atom->d.re->extra.selector,
+																  strlen(mime_atom->d.re->extra.selector) + 1,
+																  lua_cbref);
 					/* Pass ownership to the cache */
-					rspamd_regexp_unref (own_re);
+					rspamd_regexp_unref(own_re);
 				}
 				else {
 					/* We have selector regexp, but no selector name is detected */
-					g_set_error (err,
-							rspamd_mime_expr_quark (),
-							200,
-							"no selector name in selector regexp: '%s'",
-							mime_atom->str);
-					rspamd_regexp_unref (mime_atom->d.re->regexp);
+					g_set_error(err,
+								rspamd_mime_expr_quark(),
+								200,
+								"no selector name in selector regexp: '%s'",
+								mime_atom->str);
+					rspamd_regexp_unref(mime_atom->d.re->regexp);
 					goto err;
 				}
 			}
 			else {
 				own_re = mime_atom->d.re->regexp;
-				mime_atom->d.re->regexp = rspamd_re_cache_add (cfg->re_cache,
-						mime_atom->d.re->regexp,
-						mime_atom->d.re->type,
-						NULL,
-						0,
-						lua_cbref);
+				mime_atom->d.re->regexp = rspamd_re_cache_add(cfg->re_cache,
+															  mime_atom->d.re->regexp,
+															  mime_atom->d.re->type,
+															  NULL,
+															  0,
+															  lua_cbref);
 				/* Pass ownership to the cache */
-				rspamd_regexp_unref (own_re);
+				rspamd_regexp_unref(own_re);
 			}
 		}
 	}
 	else if (type == MIME_ATOM_LUA_FUNCTION) {
 		mime_atom->d.lua_function = mime_atom->str;
 
-		lua_getglobal (cfg->lua_state, mime_atom->str);
+		lua_getglobal(cfg->lua_state, mime_atom->str);
 
-		if (lua_type (cfg->lua_state, -1) != LUA_TFUNCTION) {
-			g_set_error (err, rspamd_mime_expr_quark(), 200,
-					"no such lua function '%s'",
-					mime_atom->str);
-			lua_pop (cfg->lua_state, 1);
+		if (lua_type(cfg->lua_state, -1) != LUA_TFUNCTION) {
+			g_set_error(err, rspamd_mime_expr_quark(), 200,
+						"no such lua function '%s'",
+						mime_atom->str);
+			lua_pop(cfg->lua_state, 1);
 
 			goto err;
 		}
 
-		lua_pop (cfg->lua_state, 1);
+		lua_pop(cfg->lua_state, 1);
 	}
 	else if (type == MIME_ATOM_LOCAL_LUA_FUNCTION) {
 		/* p pointer is set to the start of Lua function name */
 
 		if (real_ud->conf_obj == NULL) {
-			g_set_error (err, rspamd_mime_expr_quark(), 300,
-					"no config object for '%s'",
-					mime_atom->str);
+			g_set_error(err, rspamd_mime_expr_quark(), 300,
+						"no config object for '%s'",
+						mime_atom->str);
 			goto err;
 		}
 
-		const ucl_object_t *functions = ucl_object_lookup (real_ud->conf_obj,
-				"functions");
+		const ucl_object_t *functions = ucl_object_lookup(real_ud->conf_obj,
+														  "functions");
 
 		if (functions == NULL) {
-			g_set_error (err, rspamd_mime_expr_quark(), 310,
-					"no functions defined for '%s'",
-					mime_atom->str);
+			g_set_error(err, rspamd_mime_expr_quark(), 310,
+						"no functions defined for '%s'",
+						mime_atom->str);
 			goto err;
 		}
 
-		if (ucl_object_type (functions) != UCL_OBJECT) {
-			g_set_error (err, rspamd_mime_expr_quark(), 320,
-					"functions is not a table for '%s'",
-					mime_atom->str);
+		if (ucl_object_type(functions) != UCL_OBJECT) {
+			g_set_error(err, rspamd_mime_expr_quark(), 320,
+						"functions is not a table for '%s'",
+						mime_atom->str);
 			goto err;
 		}
 
 		const ucl_object_t *function_obj;
 
-		function_obj = ucl_object_lookup_len (functions, c,
-				p - c);
+		function_obj = ucl_object_lookup_len(functions, c,
+											 p - c);
 
 		if (function_obj == NULL) {
-			g_set_error (err, rspamd_mime_expr_quark(), 320,
-					"function %.*s is not found for '%s'",
-					(int)(p - c), c, mime_atom->str);
+			g_set_error(err, rspamd_mime_expr_quark(), 320,
+						"function %.*s is not found for '%s'",
+						(int) (p - c), c, mime_atom->str);
 			goto err;
 		}
 
-		if (ucl_object_type (function_obj) != UCL_USERDATA) {
-			g_set_error (err, rspamd_mime_expr_quark(), 320,
-					"function %.*s has invalid type for '%s'",
-					(int)(p - c), c, mime_atom->str);
+		if (ucl_object_type(function_obj) != UCL_USERDATA) {
+			g_set_error(err, rspamd_mime_expr_quark(), 320,
+						"function %.*s has invalid type for '%s'",
+						(int) (p - c), c, mime_atom->str);
 			goto err;
 		}
 
@@ -985,17 +986,17 @@ set:
 		mime_atom->d.lua_cbref = fd->idx;
 	}
 	else {
-		mime_atom->d.func = rspamd_mime_expr_parse_function_atom (pool,
-				mime_atom->str);
+		mime_atom->d.func = rspamd_mime_expr_parse_function_atom(pool,
+																 mime_atom->str);
 		if (mime_atom->d.func == NULL) {
-			g_set_error (err, rspamd_mime_expr_quark(), 200,
-					"cannot parse function '%s'",
-					mime_atom->str);
+			g_set_error(err, rspamd_mime_expr_quark(), 200,
+						"cannot parse function '%s'",
+						mime_atom->str);
 			goto err;
 		}
 	}
 
-	a = rspamd_mempool_alloc0 (pool, sizeof (*a));
+	a = rspamd_mempool_alloc0(pool, sizeof(*a));
 	a->len = p - line;
 	a->priority = 0;
 	a->data = mime_atom;
@@ -1008,45 +1009,45 @@ err:
 }
 
 static gint
-rspamd_mime_expr_process_regexp (struct rspamd_regexp_atom *re,
-		struct rspamd_task *task)
+rspamd_mime_expr_process_regexp(struct rspamd_regexp_atom *re,
+								struct rspamd_task *task)
 {
 	gint ret;
 
 	if (re == NULL) {
-		msg_info_task ("invalid regexp passed");
+		msg_info_task("invalid regexp passed");
 		return 0;
 	}
 
 	if (re->type == RSPAMD_RE_HEADER || re->type == RSPAMD_RE_RAWHEADER) {
-		ret = rspamd_re_cache_process (task,
-				re->regexp,
-				re->type,
-				re->extra.header,
-				strlen (re->extra.header),
-				re->is_strong);
+		ret = rspamd_re_cache_process(task,
+									  re->regexp,
+									  re->type,
+									  re->extra.header,
+									  strlen(re->extra.header),
+									  re->is_strong);
 	}
 	else if (re->type == RSPAMD_RE_SELECTOR) {
-		ret = rspamd_re_cache_process (task,
-				re->regexp,
-				re->type,
-				re->extra.selector,
-				strlen (re->extra.selector),
-				re->is_strong);
+		ret = rspamd_re_cache_process(task,
+									  re->regexp,
+									  re->type,
+									  re->extra.selector,
+									  strlen(re->extra.selector),
+									  re->is_strong);
 	}
 	else {
-		ret = rspamd_re_cache_process (task,
-				re->regexp,
-				re->type,
-				NULL,
-				0,
-				re->is_strong);
+		ret = rspamd_re_cache_process(task,
+									  re->regexp,
+									  re->type,
+									  NULL,
+									  0,
+									  re->is_strong);
 	}
 
 	if (re->is_test) {
-		msg_info_task ("test %s regexp '%s' returned %d",
-				rspamd_re_cache_type_to_string (re->type),
-				re->regexp_text, ret);
+		msg_info_task("test %s regexp '%s' returned %d",
+					  rspamd_re_cache_type_to_string(re->type),
+					  re->regexp_text, ret);
 	}
 
 	return ret;
@@ -1054,7 +1055,7 @@ rspamd_mime_expr_process_regexp (struct rspamd_regexp_atom *re,
 
 
 static gint
-rspamd_mime_expr_priority (rspamd_expression_atom_t *atom)
+rspamd_mime_expr_priority(rspamd_expression_atom_t *atom)
 {
 	struct rspamd_mime_atom *mime_atom = atom->data;
 	gint ret = 0;
@@ -1099,146 +1100,145 @@ rspamd_mime_expr_priority (rspamd_expression_atom_t *atom)
 }
 
 static void
-rspamd_mime_expr_destroy (rspamd_expression_atom_t *atom)
+rspamd_mime_expr_destroy(rspamd_expression_atom_t *atom)
 {
 	struct rspamd_mime_atom *mime_atom = atom->data;
 
 	if (mime_atom) {
 		if (mime_atom->type == MIME_ATOM_INTERNAL_FUNCTION) {
 			/* Need to cleanup arguments */
-			g_array_free (mime_atom->d.func->args, TRUE);
+			g_array_free(mime_atom->d.func->args, TRUE);
 		}
 	}
 }
 
 static gboolean
-rspamd_mime_expr_process_function (struct rspamd_function_atom * func,
-	struct rspamd_task * task,
-	lua_State *L)
+rspamd_mime_expr_process_function(struct rspamd_function_atom *func,
+								  struct rspamd_task *task,
+								  lua_State *L)
 {
 	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;
 	}
 
-	return selected->func (task, func->args, selected->user_data);
+	return selected->func(task, func->args, selected->user_data);
 }
 
 static gdouble
-rspamd_mime_expr_process (void *ud, rspamd_expression_atom_t *atom)
+rspamd_mime_expr_process(void *ud, rspamd_expression_atom_t *atom)
 {
-	struct rspamd_task *task = (struct rspamd_task *)ud;
+	struct rspamd_task *task = (struct rspamd_task *) ud;
 	struct rspamd_mime_atom *mime_atom;
 	lua_State *L;
 	gdouble ret = 0;
 
-	g_assert (task != NULL);
-	g_assert (atom != NULL);
+	g_assert(task != NULL);
+	g_assert(atom != NULL);
 
 	mime_atom = atom->data;
 
 	if (mime_atom->type == MIME_ATOM_REGEXP) {
-		ret = rspamd_mime_expr_process_regexp (mime_atom->d.re, task);
+		ret = rspamd_mime_expr_process_regexp(mime_atom->d.re, task);
 	}
 	else if (mime_atom->type == MIME_ATOM_LUA_FUNCTION) {
 		L = task->cfg->lua_state;
-		lua_getglobal (L, mime_atom->d.lua_function);
-		rspamd_lua_task_push (L, task);
+		lua_getglobal(L, mime_atom->d.lua_function);
+		rspamd_lua_task_push(L, task);
 
-		if (lua_pcall (L, 1, 1, 0) != 0) {
-			msg_info_task ("lua call to global function '%s' for atom '%s' failed: %s",
-				mime_atom->d.lua_function,
-				mime_atom->str,
-				lua_tostring (L, -1));
-			lua_pop (L, 1);
+		if (lua_pcall(L, 1, 1, 0) != 0) {
+			msg_info_task("lua call to global function '%s' for atom '%s' failed: %s",
+						  mime_atom->d.lua_function,
+						  mime_atom->str,
+						  lua_tostring(L, -1));
+			lua_pop(L, 1);
 		}
 		else {
-			if (lua_type (L, -1) == LUA_TBOOLEAN) {
-				ret = lua_toboolean (L, -1);
+			if (lua_type(L, -1) == LUA_TBOOLEAN) {
+				ret = lua_toboolean(L, -1);
 			}
-			else if (lua_type (L, -1) == LUA_TNUMBER) {
-				ret = lua_tonumber (L, 1);
+			else if (lua_type(L, -1) == LUA_TNUMBER) {
+				ret = lua_tonumber(L, 1);
 			}
 			else {
-				msg_err_task ("%s returned wrong return type: %s",
-						mime_atom->str, lua_typename (L, lua_type (L, -1)));
+				msg_err_task("%s returned wrong return type: %s",
+							 mime_atom->str, lua_typename(L, lua_type(L, -1)));
 			}
 			/* Remove result */
-			lua_pop (L, 1);
+			lua_pop(L, 1);
 		}
 	}
 	else if (mime_atom->type == MIME_ATOM_LOCAL_LUA_FUNCTION) {
 		gint err_idx;
 
 		L = task->cfg->lua_state;
-		lua_pushcfunction (L, &rspamd_lua_traceback);
-		err_idx = lua_gettop (L);
+		lua_pushcfunction(L, &rspamd_lua_traceback);
+		err_idx = lua_gettop(L);
 
-		lua_rawgeti (L, LUA_REGISTRYINDEX, mime_atom->d.lua_cbref);
-		rspamd_lua_task_push (L, task);
+		lua_rawgeti(L, LUA_REGISTRYINDEX, mime_atom->d.lua_cbref);
+		rspamd_lua_task_push(L, task);
 
-		if (lua_pcall (L, 1, 1, err_idx) != 0) {
-			msg_info_task ("lua call to local function for atom '%s' failed: %s",
-					mime_atom->str,
-					lua_tostring (L, -1));
+		if (lua_pcall(L, 1, 1, err_idx) != 0) {
+			msg_info_task("lua call to local function for atom '%s' failed: %s",
+						  mime_atom->str,
+						  lua_tostring(L, -1));
 		}
 		else {
-			if (lua_type (L, -1) == LUA_TBOOLEAN) {
-				ret = lua_toboolean (L, -1);
+			if (lua_type(L, -1) == LUA_TBOOLEAN) {
+				ret = lua_toboolean(L, -1);
 			}
-			else if (lua_type (L, -1) == LUA_TNUMBER) {
-				ret = lua_tonumber (L, 1);
+			else if (lua_type(L, -1) == LUA_TNUMBER) {
+				ret = lua_tonumber(L, 1);
 			}
 			else {
-				msg_err_task ("%s returned wrong return type: %s",
-						mime_atom->str, lua_typename (L, lua_type (L, -1)));
+				msg_err_task("%s returned wrong return type: %s",
+							 mime_atom->str, lua_typename(L, lua_type(L, -1)));
 			}
 		}
 
-		lua_settop (L, 0);
+		lua_settop(L, 0);
 	}
 	else {
-		ret = rspamd_mime_expr_process_function (mime_atom->d.func, task,
-				task->cfg->lua_state);
+		ret = rspamd_mime_expr_process_function(mime_atom->d.func, task,
+												task->cfg->lua_state);
 	}
 
 	return ret;
 }
 
-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)
 {
 	static struct _fl *new;
 
 	functions_number++;
 
-	new = g_new (struct _fl, functions_number);
-	memcpy (new, list_ptr, (functions_number - 1) * sizeof (struct _fl));
+	new = g_new(struct _fl, functions_number);
+	memcpy(new, list_ptr, (functions_number - 1) * sizeof(struct _fl));
 	if (list_allocated) {
-		g_free (list_ptr);
+		g_free(list_ptr);
 	}
 
 	list_allocated = TRUE;
 	new[functions_number - 1].name = name;
 	new[functions_number - 1].func = func;
 	new[functions_number - 1].user_data = user_data;
-	qsort (new, functions_number, sizeof (struct _fl), fl_cmp);
+	qsort(new, functions_number, sizeof(struct _fl), fl_cmp);
 	list_ptr = new;
 }
 
 gboolean
-rspamd_compare_encoding (struct rspamd_task *task, GArray * args, void *unused)
+rspamd_compare_encoding(struct rspamd_task *task, GArray *args, void *unused)
 {
 	struct expression_argument *arg;
 
@@ -1246,9 +1246,9 @@ rspamd_compare_encoding (struct rspamd_task *task, GArray * args, void *unused)
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
+	arg = &g_array_index(args, struct expression_argument, 0);
 	if (!arg || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("invalid argument to function is passed");
+		msg_warn_task("invalid argument to function is passed");
 		return FALSE;
 	}
 
@@ -1257,7 +1257,7 @@ rspamd_compare_encoding (struct rspamd_task *task, GArray * args, void *unused)
 }
 
 gboolean
-rspamd_header_exists (struct rspamd_task * task, GArray * args, void *unused)
+rspamd_header_exists(struct rspamd_task *task, GArray *args, void *unused)
 {
 	struct expression_argument *arg;
 	struct rspamd_mime_header *rh;
@@ -1266,17 +1266,17 @@ rspamd_header_exists (struct rspamd_task * task, GArray * args, void *unused)
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
+	arg = &g_array_index(args, struct expression_argument, 0);
 	if (!arg || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("invalid argument to function is passed");
+		msg_warn_task("invalid argument to function is passed");
 		return FALSE;
 	}
 
 	rh = rspamd_message_get_header_array(task,
-			(gchar *) arg->data, FALSE);
+										 (gchar *) arg->data, FALSE);
 
-	debug_task ("try to get header %s: %d", (gchar *)arg->data,
-			(rh != NULL));
+	debug_task("try to get header %s: %d", (gchar *) arg->data,
+			   (rh != NULL));
 
 	if (rh) {
 		return TRUE;
@@ -1293,56 +1293,56 @@ rspamd_header_exists (struct rspamd_task * task, GArray * args, void *unused)
  * and return FALSE otherwise.
  */
 gboolean
-rspamd_parts_distance (struct rspamd_task * task, GArray * args, void *unused)
+rspamd_parts_distance(struct rspamd_task *task, GArray *args, void *unused)
 {
 	gint threshold, threshold2 = -1;
 	struct expression_argument *arg;
 	gdouble *pdiff, diff;
 
 	if (args == NULL || args->len == 0) {
-		debug_task ("no threshold is specified, assume it 100");
+		debug_task("no threshold is specified, assume it 100");
 		threshold = 100;
 	}
 	else {
 		errno = 0;
-		arg = &g_array_index (args, struct expression_argument, 0);
+		arg = &g_array_index(args, struct expression_argument, 0);
 		if (!arg || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-			msg_warn_task ("invalid argument to function is passed");
+			msg_warn_task("invalid argument to function is passed");
 			return FALSE;
 		}
 
-		threshold = strtoul ((gchar *)arg->data, NULL, 10);
+		threshold = strtoul((gchar *) arg->data, NULL, 10);
 		if (errno != 0) {
-			msg_info_task ("bad numeric value for threshold \"%s\", assume it 100",
-				(gchar *)arg->data);
+			msg_info_task("bad numeric value for threshold \"%s\", assume it 100",
+						  (gchar *) arg->data);
 			threshold = 100;
 		}
 		if (args->len >= 2) {
-			arg = &g_array_index (args, struct expression_argument, 1);
+			arg = &g_array_index(args, struct expression_argument, 1);
 			if (!arg || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-				msg_warn_task ("invalid argument to function is passed");
+				msg_warn_task("invalid argument to function is passed");
 				return FALSE;
 			}
 
 			errno = 0;
-			threshold2 = strtoul ((gchar *)arg->data, NULL, 10);
+			threshold2 = strtoul((gchar *) arg->data, NULL, 10);
 			if (errno != 0) {
-				msg_info_task ("bad numeric value for threshold \"%s\", ignore it",
-					(gchar *)arg->data);
+				msg_info_task("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) {
+			 rspamd_mempool_get_variable(task->task_pool,
+										 "parts_distance")) != NULL) {
 		diff = (1.0 - (*pdiff)) * 100.0;
 
 		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;
 				}
@@ -1370,24 +1370,24 @@ struct addr_list {
 };
 
 static gint
-addr_list_cmp_func (const void *a, const void *b)
+addr_list_cmp_func(const void *a, const void *b)
 {
-	const struct addr_list *addra = (struct addr_list *)a,
-			*addrb = (struct addr_list *)b;
+	const struct addr_list *addra = (struct addr_list *) a,
+						   *addrb = (struct addr_list *) b;
 
 	if (addra->addrlen != addrb->addrlen) {
 		return addra->addrlen - addrb->addrlen;
 	}
 
-	return memcmp (addra->addr, addrb->addr, addra->addrlen);
+	return memcmp(addra->addr, addrb->addr, addra->addrlen);
 }
 
 #define COMPARE_RCPT_LEN 3
 #define MIN_RCPT_TO_COMPARE 7
 
 gboolean
-rspamd_recipients_distance (struct rspamd_task *task, GArray * args,
-	void *unused)
+rspamd_recipients_distance(struct rspamd_task *task, GArray *args,
+						   void *unused)
 {
 	struct expression_argument *arg;
 	struct rspamd_email_address *cur;
@@ -1396,64 +1396,65 @@ rspamd_recipients_distance (struct rspamd_task *task, GArray * args,
 	gint num, i, hits = 0;
 
 	if (args == NULL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
+	arg = &g_array_index(args, struct expression_argument, 0);
 	if (!arg || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("invalid argument to function is passed");
+		msg_warn_task("invalid argument to function is passed");
 		return FALSE;
 	}
 
 	errno = 0;
-	threshold = strtod ((gchar *)arg->data, NULL);
+	threshold = strtod((gchar *) arg->data, NULL);
 
 	if (errno != 0) {
-		msg_warn_task ("invalid numeric value '%s': %s",
-			(gchar *)arg->data,
-			strerror (errno));
+		msg_warn_task("invalid numeric value '%s': %s",
+					  (gchar *) arg->data,
+					  strerror(errno));
 		return FALSE;
 	}
 
-	if (!MESSAGE_FIELD (task, rcpt_mime)) {
+	if (!MESSAGE_FIELD(task, rcpt_mime)) {
 		return FALSE;
 	}
 
-	num = MESSAGE_FIELD (task, rcpt_mime)->len;
+	num = MESSAGE_FIELD(task, rcpt_mime)->len;
 
 	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 */
 	num = 0;
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, rcpt_mime), i, cur) {
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, rcpt_mime), i, cur)
+	{
 		if (cur->addr_len > COMPARE_RCPT_LEN) {
 			ar[num].name = cur->addr;
 			ar[num].namelen = cur->addr_len;
 			ar[num].addr = cur->domain;
 			ar[num].addrlen = cur->domain_len;
-			num ++;
+			num++;
 		}
 	}
 
-	qsort (ar, num, sizeof (*ar), addr_list_cmp_func);
+	qsort(ar, num, sizeof(*ar), addr_list_cmp_func);
 
 	/* Cycle all elements in array */
 	for (i = 0; i < num; i++) {
 		if (i < num - 1) {
 			if (ar[i].namelen == ar[i + 1].namelen) {
-				if (rspamd_lc_cmp (ar[i].name, ar[i + 1].name, COMPARE_RCPT_LEN) == 0) {
+				if (rspamd_lc_cmp(ar[i].name, ar[i + 1].name, COMPARE_RCPT_LEN) == 0) {
 					hits++;
 				}
 			}
 		}
 	}
 
-	if ((hits * num / 2.) / (double)num >= threshold) {
+	if ((hits * num / 2.) / (double) num >= threshold) {
 		return TRUE;
 	}
 
@@ -1461,17 +1462,18 @@ rspamd_recipients_distance (struct rspamd_task *task, GArray * args,
 }
 
 gboolean
-rspamd_has_only_html_part (struct rspamd_task * task, GArray * args,
-	void *unused)
+rspamd_has_only_html_part(struct rspamd_task *task, GArray *args,
+						  void *unused)
 {
 	struct rspamd_mime_text_part *p;
 	guint i, cnt_html = 0, cnt_txt = 0;
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, text_parts), i, p) {
-		p = g_ptr_array_index (MESSAGE_FIELD (task, text_parts), 0);
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, text_parts), i, p)
+	{
+		p = g_ptr_array_index(MESSAGE_FIELD(task, text_parts), 0);
 
-		if (!IS_TEXT_PART_ATTACHMENT (p)) {
-			if (IS_TEXT_PART_HTML (p)) {
+		if (!IS_TEXT_PART_ATTACHMENT(p)) {
+			if (IS_TEXT_PART_HTML(p)) {
 				cnt_html++;
 			}
 			else {
@@ -1484,7 +1486,7 @@ rspamd_has_only_html_part (struct rspamd_task * task, GArray * args,
 }
 
 static gboolean
-is_recipient_list_sorted (GPtrArray *ar)
+is_recipient_list_sorted(GPtrArray *ar)
 {
 	struct rspamd_email_address *addr;
 	gboolean res = TRUE;
@@ -1499,12 +1501,13 @@ is_recipient_list_sorted (GPtrArray *ar)
 	prev.len = 0;
 	prev.begin = NULL;
 
-	PTR_ARRAY_FOREACH (ar, i, addr) {
+	PTR_ARRAY_FOREACH(ar, i, addr)
+	{
 		cur.begin = addr->addr;
 		cur.len = addr->addr_len;
 
 		if (prev.len != 0) {
-			if (rspamd_ftok_casecmp (&cur, &prev) <= 0) {
+			if (rspamd_ftok_casecmp(&cur, &prev) <= 0) {
 				res = FALSE;
 				break;
 			}
@@ -1517,23 +1520,23 @@ is_recipient_list_sorted (GPtrArray *ar)
 }
 
 gboolean
-rspamd_is_recipients_sorted (struct rspamd_task * task,
-	GArray * args,
-	void *unused)
+rspamd_is_recipients_sorted(struct rspamd_task *task,
+							GArray *args,
+							void *unused)
 {
 	/* Check all types of addresses */
 
-	if (MESSAGE_FIELD (task, rcpt_mime)) {
-		return is_recipient_list_sorted (MESSAGE_FIELD (task, rcpt_mime));
+	if (MESSAGE_FIELD(task, rcpt_mime)) {
+		return is_recipient_list_sorted(MESSAGE_FIELD(task, rcpt_mime));
 	}
 
 	return FALSE;
 }
 
 gboolean
-rspamd_compare_transfer_encoding (struct rspamd_task * task,
-	GArray * args,
-	void *unused)
+rspamd_compare_transfer_encoding(struct rspamd_task *task,
+								 GArray *args,
+								 void *unused)
 {
 	struct expression_argument *arg;
 	guint i;
@@ -1541,25 +1544,26 @@ rspamd_compare_transfer_encoding (struct rspamd_task * task,
 	enum rspamd_cte cte;
 
 	if (args == NULL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
+	arg = &g_array_index(args, struct expression_argument, 0);
 	if (!arg || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("invalid argument to function is passed");
+		msg_warn_task("invalid argument to function is passed");
 		return FALSE;
 	}
 
-	cte = rspamd_cte_from_string (arg->data);
+	cte = rspamd_cte_from_string(arg->data);
 
 	if (cte == RSPAMD_CTE_UNKNOWN) {
-		msg_warn_task ("unknown cte: %s", arg->data);
+		msg_warn_task("unknown cte: %s", arg->data);
 		return FALSE;
 	}
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, parts), i, part) {
-		if (IS_PART_TEXT (part)) {
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, part)
+	{
+		if (IS_PART_TEXT(part)) {
 			if (part->cte == cte) {
 				return TRUE;
 			}
@@ -1570,14 +1574,14 @@ rspamd_compare_transfer_encoding (struct rspamd_task * task,
 }
 
 gboolean
-rspamd_is_html_balanced (struct rspamd_task * task, GArray * args, void *unused)
+rspamd_is_html_balanced(struct rspamd_task *task, GArray *args, void *unused)
 {
 	/* Totally broken but seems to be never used */
 	return TRUE;
 }
 
 gboolean
-rspamd_has_html_tag (struct rspamd_task * task, GArray * args, void *unused)
+rspamd_has_html_tag(struct rspamd_task *task, GArray *args, void *unused)
 {
 	struct rspamd_mime_text_part *p;
 	struct expression_argument *arg;
@@ -1585,19 +1589,20 @@ rspamd_has_html_tag (struct rspamd_task * task, GArray * args, void *unused)
 	gboolean res = FALSE;
 
 	if (args == NULL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
+	arg = &g_array_index(args, struct expression_argument, 0);
 	if (!arg || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("invalid argument to function is passed");
+		msg_warn_task("invalid argument to function is passed");
 		return FALSE;
 	}
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, text_parts), i, p) {
-		if (IS_TEXT_PART_HTML (p) && p->html) {
-			res = rspamd_html_tag_seen (p->html, arg->data);
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, text_parts), i, p)
+	{
+		if (IS_TEXT_PART_HTML(p) && p->html) {
+			res = rspamd_html_tag_seen(p->html, arg->data);
 		}
 
 		if (res) {
@@ -1606,18 +1611,18 @@ rspamd_has_html_tag (struct rspamd_task * task, GArray * args, void *unused)
 	}
 
 	return res;
-
 }
 
 gboolean
-rspamd_has_fake_html (struct rspamd_task * task, GArray * args, void *unused)
+rspamd_has_fake_html(struct rspamd_task *task, GArray *args, void *unused)
 {
 	struct rspamd_mime_text_part *p;
 	guint i;
 	gboolean res = FALSE;
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, text_parts), i, p) {
-		if (IS_TEXT_PART_HTML (p) && (rspamd_html_get_tags_count(p->html) < 2)) {
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, text_parts), i, p)
+	{
+		if (IS_TEXT_PART_HTML(p) && (rspamd_html_get_tags_count(p->html) < 2)) {
 			res = TRUE;
 		}
 
@@ -1627,11 +1632,10 @@ rspamd_has_fake_html (struct rspamd_task * task, GArray * args, void *unused)
 	}
 
 	return res;
-
 }
 
 static gboolean
-rspamd_raw_header_exists (struct rspamd_task *task, GArray * args, void *unused)
+rspamd_raw_header_exists(struct rspamd_task *task, GArray *args, void *unused)
 {
 	struct expression_argument *arg;
 
@@ -1639,9 +1643,9 @@ rspamd_raw_header_exists (struct rspamd_task *task, GArray * args, void *unused)
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
+	arg = &g_array_index(args, struct expression_argument, 0);
 	if (!arg || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("invalid argument to function is passed");
+		msg_warn_task("invalid argument to function is passed");
 		return FALSE;
 	}
 
@@ -1649,9 +1653,9 @@ rspamd_raw_header_exists (struct rspamd_task *task, GArray * args, void *unused)
 }
 
 static gboolean
-match_smtp_data (struct rspamd_task *task,
-	struct expression_argument *arg,
-	const gchar *what, gsize len)
+match_smtp_data(struct rspamd_task *task,
+				struct expression_argument *arg,
+				const gchar *what, gsize len)
 {
 	rspamd_regexp_t *re;
 	gint r = 0;
@@ -1660,19 +1664,19 @@ match_smtp_data (struct rspamd_task *task,
 		/* This is a regexp */
 		re = arg->data;
 		if (re == NULL) {
-			msg_warn_task ("cannot compile regexp for function");
+			msg_warn_task("cannot compile regexp for function");
 			return FALSE;
 		}
 
 
 		if (len > 0) {
-			r = rspamd_regexp_search (re, what, len, NULL, NULL, FALSE, NULL);
+			r = rspamd_regexp_search(re, what, len, NULL, NULL, FALSE, NULL);
 		}
 
 		return r;
 	}
 	else if (arg->type == EXPRESSION_ARGUMENT_NORMAL &&
-			g_ascii_strncasecmp (arg->data, what, len) == 0) {
+			 g_ascii_strncasecmp(arg->data, what, len) == 0) {
 		return TRUE;
 	}
 
@@ -1680,7 +1684,7 @@ match_smtp_data (struct rspamd_task *task,
 }
 
 static gboolean
-rspamd_check_smtp_data (struct rspamd_task *task, GArray * args, void *unused)
+rspamd_check_smtp_data(struct rspamd_task *task, GArray *args, void *unused)
 {
 	struct expression_argument *arg;
 	struct rspamd_email_address *addr = NULL;
@@ -1689,14 +1693,14 @@ rspamd_check_smtp_data (struct rspamd_task *task, GArray * args, void *unused)
 	guint i;
 
 	if (args == NULL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
+	arg = &g_array_index(args, struct expression_argument, 0);
 
 	if (!arg || !arg->data || arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 	else {
@@ -1704,56 +1708,56 @@ rspamd_check_smtp_data (struct rspamd_task *task, GArray * args, void *unused)
 		switch (*type) {
 		case 'f':
 		case 'F':
-			if (g_ascii_strcasecmp (type, "from") == 0) {
-				addr = rspamd_task_get_sender (task);
+			if (g_ascii_strcasecmp(type, "from") == 0) {
+				addr = rspamd_task_get_sender(task);
 			}
 			else {
-				msg_warn_task ("bad argument to function: %s", type);
+				msg_warn_task("bad argument to function: %s", type);
 				return FALSE;
 			}
 			break;
 		case 'h':
 		case 'H':
-			if (g_ascii_strcasecmp (type, "helo") == 0) {
+			if (g_ascii_strcasecmp(type, "helo") == 0) {
 				str = task->helo;
 			}
 			else {
-				msg_warn_task ("bad argument to function: %s", type);
+				msg_warn_task("bad argument to function: %s", type);
 				return FALSE;
 			}
 			break;
 		case 'u':
 		case 'U':
-			if (g_ascii_strcasecmp (type, "user") == 0) {
+			if (g_ascii_strcasecmp(type, "user") == 0) {
 				str = task->auth_user;
 			}
 			else {
-				msg_warn_task ("bad argument to function: %s", type);
+				msg_warn_task("bad argument to function: %s", type);
 				return FALSE;
 			}
 			break;
 		case 's':
 		case 'S':
-			if (g_ascii_strcasecmp (type, "subject") == 0) {
-				str = MESSAGE_FIELD (task, subject);
+			if (g_ascii_strcasecmp(type, "subject") == 0) {
+				str = MESSAGE_FIELD(task, subject);
 			}
 			else {
-				msg_warn_task ("bad argument to function: %s", type);
+				msg_warn_task("bad argument to function: %s", type);
 				return FALSE;
 			}
 			break;
 		case 'r':
 		case 'R':
-			if (g_ascii_strcasecmp (type, "rcpt") == 0) {
+			if (g_ascii_strcasecmp(type, "rcpt") == 0) {
 				rcpts = task->rcpt_envelope;
 			}
 			else {
-				msg_warn_task ("bad argument to function: %s", type);
+				msg_warn_task("bad argument to function: %s", type);
 				return FALSE;
 			}
 			break;
 		default:
-			msg_warn_task ("bad argument to function: %s", type);
+			msg_warn_task("bad argument to function: %s", type);
 			return FALSE;
 		}
 	}
@@ -1765,23 +1769,23 @@ rspamd_check_smtp_data (struct rspamd_task *task, GArray * args, void *unused)
 
 	/* We would process only one more argument, others are ignored */
 	if (args->len >= 2) {
-		arg = &g_array_index (args, struct expression_argument, 1);
+		arg = &g_array_index(args, struct expression_argument, 1);
 
 		if (arg) {
 			if (str != NULL) {
-				return match_smtp_data (task, arg, str, strlen (str));
+				return match_smtp_data(task, arg, str, strlen(str));
 			}
 			else if (addr != NULL && addr->addr) {
-				return match_smtp_data (task, arg, addr->addr, addr->addr_len);
+				return match_smtp_data(task, arg, addr->addr, addr->addr_len);
 			}
 			else {
 				if (rcpts != NULL) {
-					for (i = 0; i < rcpts->len; i ++) {
-						addr = g_ptr_array_index (rcpts, i);
+					for (i = 0; i < rcpts->len; i++) {
+						addr = g_ptr_array_index(rcpts, i);
 
 						if (addr && addr->addr &&
-							match_smtp_data (task, arg,
-								addr->addr, addr->addr_len)) {
+							match_smtp_data(task, arg,
+											addr->addr, addr->addr_len)) {
 							return TRUE;
 						}
 					}
@@ -1794,8 +1798,8 @@ rspamd_check_smtp_data (struct rspamd_task *task, GArray * args, void *unused)
 }
 
 static inline gboolean
-rspamd_check_ct_attr (const gchar *begin, gsize len,
-		struct expression_argument *arg_pattern)
+rspamd_check_ct_attr(const gchar *begin, gsize len,
+					 struct expression_argument *arg_pattern)
 {
 	rspamd_regexp_t *re;
 	gboolean r = FALSE;
@@ -1804,9 +1808,9 @@ rspamd_check_ct_attr (const gchar *begin, gsize len,
 		re = arg_pattern->data;
 
 		if (len > 0) {
-			r = rspamd_regexp_search (re,
-					begin, len,
-					NULL, NULL, FALSE, NULL);
+			r = rspamd_regexp_search(re,
+									 begin, len,
+									 NULL, NULL, FALSE, NULL);
 		}
 
 		if (r) {
@@ -1815,10 +1819,10 @@ rspamd_check_ct_attr (const gchar *begin, gsize len,
 	}
 	else {
 		/* Just do strcasecmp */
-		gsize plen = strlen (arg_pattern->data);
+		gsize plen = strlen(arg_pattern->data);
 
 		if (plen == len &&
-			g_ascii_strncasecmp (arg_pattern->data, begin, len) == 0) {
+			g_ascii_strncasecmp(arg_pattern->data, begin, len) == 0) {
 			return TRUE;
 		}
 	}
@@ -1827,9 +1831,9 @@ rspamd_check_ct_attr (const gchar *begin, gsize len,
 }
 
 static gboolean
-rspamd_content_type_compare_param (struct rspamd_task * task,
-	GArray * args,
-	void *unused)
+rspamd_content_type_compare_param(struct rspamd_task *task,
+								  GArray *args,
+								  void *unused)
 {
 
 	struct expression_argument *arg, *arg1, *arg_pattern;
@@ -1841,20 +1845,21 @@ rspamd_content_type_compare_param (struct rspamd_task * task,
 	const gchar *param_name;
 
 	if (args == NULL || args->len < 2) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
-	g_assert (arg->type == EXPRESSION_ARGUMENT_NORMAL);
+	arg = &g_array_index(args, struct expression_argument, 0);
+	g_assert(arg->type == EXPRESSION_ARGUMENT_NORMAL);
 	param_name = arg->data;
-	arg_pattern = &g_array_index (args, struct expression_argument, 1);
+	arg_pattern = &g_array_index(args, struct expression_argument, 1);
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, parts), i, cur_part) {
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, cur_part)
+	{
 		if (args->len >= 3) {
-			arg1 = &g_array_index (args, struct expression_argument, 2);
-			if (g_ascii_strncasecmp (arg1->data, "true",
-					sizeof ("true") - 1) == 0) {
+			arg1 = &g_array_index(args, struct expression_argument, 2);
+			if (g_ascii_strncasecmp(arg1->data, "true",
+									sizeof("true") - 1) == 0) {
 				recursive = TRUE;
 			}
 		}
@@ -1863,37 +1868,38 @@ rspamd_content_type_compare_param (struct rspamd_task * task,
 			 * If user did not specify argument, let's assume that he wants
 			 * recursive search if mime part is multipart/mixed
 			 */
-			if (IS_PART_MULTIPART (cur_part)) {
+			if (IS_PART_MULTIPART(cur_part)) {
 				recursive = TRUE;
 			}
 		}
 
 		rspamd_ftok_t lit;
-		RSPAMD_FTOK_FROM_STR (&srch, param_name);
-		RSPAMD_FTOK_FROM_STR (&lit, "charset");
+		RSPAMD_FTOK_FROM_STR(&srch, param_name);
+		RSPAMD_FTOK_FROM_STR(&lit, "charset");
 
-		if (rspamd_ftok_equal (&srch, &lit)) {
-			if (rspamd_check_ct_attr (cur_part->ct->charset.begin,
-					cur_part->ct->charset.len, arg_pattern)) {
+		if (rspamd_ftok_equal(&srch, &lit)) {
+			if (rspamd_check_ct_attr(cur_part->ct->charset.begin,
+									 cur_part->ct->charset.len, arg_pattern)) {
 				return TRUE;
 			}
 		}
 
-		RSPAMD_FTOK_FROM_STR (&lit, "boundary");
-		if (rspamd_ftok_equal (&srch, &lit)) {
-			if (rspamd_check_ct_attr (cur_part->ct->orig_boundary.begin,
-					cur_part->ct->orig_boundary.len, arg_pattern)) {
+		RSPAMD_FTOK_FROM_STR(&lit, "boundary");
+		if (rspamd_ftok_equal(&srch, &lit)) {
+			if (rspamd_check_ct_attr(cur_part->ct->orig_boundary.begin,
+									 cur_part->ct->orig_boundary.len, arg_pattern)) {
 				return TRUE;
 			}
 		}
 
 		if (cur_part->ct->attrs) {
-			found = g_hash_table_lookup (cur_part->ct->attrs, &srch);
+			found = g_hash_table_lookup(cur_part->ct->attrs, &srch);
 
 			if (found) {
-				DL_FOREACH (found, cur) {
-					if (rspamd_check_ct_attr (cur->value.begin,
-							cur->value.len, arg_pattern)) {
+				DL_FOREACH(found, cur)
+				{
+					if (rspamd_check_ct_attr(cur->value.begin,
+											 cur->value.len, arg_pattern)) {
 						return TRUE;
 					}
 				}
@@ -1909,9 +1915,9 @@ rspamd_content_type_compare_param (struct rspamd_task * task,
 }
 
 static gboolean
-rspamd_content_type_has_param (struct rspamd_task * task,
-	GArray * args,
-	void *unused)
+rspamd_content_type_has_param(struct rspamd_task *task,
+							  GArray *args,
+							  void *unused)
 {
 	struct expression_argument *arg, *arg1;
 	gboolean recursive = FALSE;
@@ -1922,19 +1928,20 @@ rspamd_content_type_has_param (struct rspamd_task * task,
 	const gchar *param_name;
 
 	if (args == NULL || args->len < 1) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	arg = &g_array_index (args, struct expression_argument, 0);
-	g_assert (arg->type == EXPRESSION_ARGUMENT_NORMAL);
+	arg = &g_array_index(args, struct expression_argument, 0);
+	g_assert(arg->type == EXPRESSION_ARGUMENT_NORMAL);
 	param_name = arg->data;
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, parts), i, cur_part) {
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, cur_part)
+	{
 		if (args->len >= 2) {
-			arg1 = &g_array_index (args, struct expression_argument, 1);
-			if (g_ascii_strncasecmp (arg1->data, "true",
-					sizeof ("true") - 1) == 0) {
+			arg1 = &g_array_index(args, struct expression_argument, 1);
+			if (g_ascii_strncasecmp(arg1->data, "true",
+									sizeof("true") - 1) == 0) {
 				recursive = TRUE;
 			}
 		}
@@ -1943,31 +1950,31 @@ rspamd_content_type_has_param (struct rspamd_task * task,
 			 * If user did not specify argument, let's assume that he wants
 			 * recursive search if mime part is multipart/mixed
 			 */
-			if (IS_PART_MULTIPART (cur_part)) {
+			if (IS_PART_MULTIPART(cur_part)) {
 				recursive = TRUE;
 			}
 		}
 
 
 		rspamd_ftok_t lit;
-		RSPAMD_FTOK_FROM_STR (&srch, param_name);
-		RSPAMD_FTOK_FROM_STR (&lit, "charset");
+		RSPAMD_FTOK_FROM_STR(&srch, param_name);
+		RSPAMD_FTOK_FROM_STR(&lit, "charset");
 
-		if (rspamd_ftok_equal (&srch, &lit)) {
+		if (rspamd_ftok_equal(&srch, &lit)) {
 			if (cur_part->ct->charset.len > 0) {
 				return TRUE;
 			}
 		}
 
-		RSPAMD_FTOK_FROM_STR (&lit, "boundary");
-		if (rspamd_ftok_equal (&srch, &lit)) {
+		RSPAMD_FTOK_FROM_STR(&lit, "boundary");
+		if (rspamd_ftok_equal(&srch, &lit)) {
 			if (cur_part->ct->boundary.len > 0) {
 				return TRUE;
 			}
 		}
 
 		if (cur_part->ct->attrs) {
-			found = g_hash_table_lookup (cur_part->ct->attrs, &srch);
+			found = g_hash_table_lookup(cur_part->ct->attrs, &srch);
 
 			if (found) {
 				return TRUE;
@@ -1983,9 +1990,9 @@ rspamd_content_type_has_param (struct rspamd_task * task,
 }
 
 static gboolean
-rspamd_content_type_check (struct rspamd_task *task,
-	GArray * args,
-	gboolean check_subtype)
+rspamd_content_type_check(struct rspamd_task *task,
+						  GArray *args,
+						  gboolean check_subtype)
 {
 	rspamd_ftok_t *param_data, srch;
 	rspamd_regexp_t *re;
@@ -1997,19 +2004,20 @@ rspamd_content_type_check (struct rspamd_task *task,
 	struct rspamd_mime_part *cur_part;
 
 	if (args == NULL || args->len < 1) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	arg_pattern = &g_array_index (args, struct expression_argument, 0);
+	arg_pattern = &g_array_index(args, struct expression_argument, 0);
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, parts), i, cur_part) {
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, cur_part)
+	{
 		ct = cur_part->ct;
 
 		if (args->len >= 2) {
-			arg1 = &g_array_index (args, struct expression_argument, 1);
-			if (g_ascii_strncasecmp (arg1->data, "true",
-					sizeof ("true") - 1) == 0) {
+			arg1 = &g_array_index(args, struct expression_argument, 1);
+			if (g_ascii_strncasecmp(arg1->data, "true",
+									sizeof("true") - 1) == 0) {
 				recursive = TRUE;
 			}
 		}
@@ -2018,7 +2026,7 @@ rspamd_content_type_check (struct rspamd_task *task,
 			 * If user did not specify argument, let's assume that he wants
 			 * recursive search if mime part is multipart/mixed
 			 */
-			if (IS_PART_MULTIPART (cur_part)) {
+			if (IS_PART_MULTIPART(cur_part)) {
 				recursive = TRUE;
 			}
 		}
@@ -2034,8 +2042,8 @@ rspamd_content_type_check (struct rspamd_task *task,
 			re = arg_pattern->data;
 
 			if (param_data->len > 0) {
-				r = rspamd_regexp_search (re, param_data->begin, param_data->len,
-						NULL, NULL, FALSE, NULL);
+				r = rspamd_regexp_search(re, param_data->begin, param_data->len,
+										 NULL, NULL, FALSE, NULL);
 			}
 
 			if (r) {
@@ -2045,9 +2053,9 @@ rspamd_content_type_check (struct rspamd_task *task,
 		else {
 			/* Just do strcasecmp */
 			srch.begin = arg_pattern->data;
-			srch.len = strlen (arg_pattern->data);
+			srch.len = strlen(arg_pattern->data);
 
-			if (rspamd_ftok_casecmp (param_data, &srch) == 0) {
+			if (rspamd_ftok_casecmp(param_data, &srch) == 0) {
 				return TRUE;
 			}
 		}
@@ -2062,47 +2070,47 @@ rspamd_content_type_check (struct rspamd_task *task,
 }
 
 static gboolean
-rspamd_content_type_is_type (struct rspamd_task * task,
-	GArray * args,
-	void *unused)
+rspamd_content_type_is_type(struct rspamd_task *task,
+							GArray *args,
+							void *unused)
 {
-	return rspamd_content_type_check (task, args, FALSE);
+	return rspamd_content_type_check(task, args, FALSE);
 }
 
 static gboolean
-rspamd_content_type_is_subtype (struct rspamd_task * task,
-	GArray * args,
-	void *unused)
+rspamd_content_type_is_subtype(struct rspamd_task *task,
+							   GArray *args,
+							   void *unused)
 {
-	return rspamd_content_type_check (task, args, TRUE);
+	return rspamd_content_type_check(task, args, TRUE);
 }
 
 static gboolean
-compare_subtype (struct rspamd_task *task, struct rspamd_content_type *ct,
-	struct expression_argument *subtype)
+compare_subtype(struct rspamd_task *task, struct rspamd_content_type *ct,
+				struct expression_argument *subtype)
 {
 	rspamd_regexp_t *re;
 	rspamd_ftok_t srch;
 	gint r = 0;
 
 	if (subtype == NULL || ct == NULL) {
-		msg_warn_task ("invalid parameters passed");
+		msg_warn_task("invalid parameters passed");
 		return FALSE;
 	}
 	if (subtype->type == EXPRESSION_ARGUMENT_REGEXP) {
 		re = subtype->data;
 
 		if (ct->subtype.len > 0) {
-			r = rspamd_regexp_search (re, ct->subtype.begin, ct->subtype.len,
-					NULL, NULL, FALSE, NULL);
+			r = rspamd_regexp_search(re, ct->subtype.begin, ct->subtype.len,
+									 NULL, NULL, FALSE, NULL);
 		}
 	}
 	else {
 		srch.begin = subtype->data;
-		srch.len = strlen (subtype->data);
+		srch.len = strlen(subtype->data);
 
 		/* Just do strcasecmp */
-		if (rspamd_ftok_casecmp (&ct->subtype, &srch) == 0) {
+		if (rspamd_ftok_casecmp(&ct->subtype, &srch) == 0) {
 			return TRUE;
 		}
 	}
@@ -2111,7 +2119,7 @@ compare_subtype (struct rspamd_task *task, struct rspamd_content_type *ct,
 }
 
 static gboolean
-compare_len (struct rspamd_mime_part *part, guint min, guint max)
+compare_len(struct rspamd_mime_part *part, guint min, guint max)
 {
 	if (min == 0 && max == 0) {
 		return TRUE;
@@ -2129,11 +2137,11 @@ compare_len (struct rspamd_mime_part *part, guint min, guint max)
 }
 
 static gboolean
-common_has_content_part (struct rspamd_task * task,
-	struct expression_argument *param_type,
-	struct expression_argument *param_subtype,
-	gint min_len,
-	gint max_len)
+common_has_content_part(struct rspamd_task *task,
+						struct expression_argument *param_type,
+						struct expression_argument *param_subtype,
+						gint min_len,
+						gint max_len)
 {
 	rspamd_regexp_t *re;
 	struct rspamd_mime_part *part;
@@ -2142,7 +2150,8 @@ common_has_content_part (struct rspamd_task * task,
 	gint r = 0;
 	guint i;
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, parts), i, part) {
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, part)
+	{
 		ct = part->ct;
 
 		if (ct == NULL) {
@@ -2153,14 +2162,14 @@ common_has_content_part (struct rspamd_task * task,
 			re = param_type->data;
 
 			if (ct->type.len > 0) {
-				r = rspamd_regexp_search (re, ct->type.begin, ct->type.len,
-						NULL, NULL, FALSE, NULL);
+				r = rspamd_regexp_search(re, ct->type.begin, ct->type.len,
+										 NULL, NULL, FALSE, NULL);
 			}
 
 			/* Also check subtype and length of the part */
 			if (r && param_subtype) {
-				r = compare_len (part, min_len, max_len) &&
-						compare_subtype (task, ct, param_subtype);
+				r = compare_len(part, min_len, max_len) &&
+					compare_subtype(task, ct, param_subtype);
 
 				return r;
 			}
@@ -2168,18 +2177,18 @@ common_has_content_part (struct rspamd_task * task,
 		else {
 			/* Just do strcasecmp */
 			srch.begin = param_type->data;
-			srch.len = strlen (param_type->data);
+			srch.len = strlen(param_type->data);
 
-			if (rspamd_ftok_casecmp (&ct->type, &srch) == 0) {
+			if (rspamd_ftok_casecmp(&ct->type, &srch) == 0) {
 				if (param_subtype) {
-					if (compare_subtype (task, ct, param_subtype)) {
-						if (compare_len (part, min_len, max_len)) {
+					if (compare_subtype(task, ct, param_subtype)) {
+						if (compare_len(part, min_len, max_len)) {
 							return TRUE;
 						}
 					}
 				}
 				else {
-					if (compare_len (part, min_len, max_len)) {
+					if (compare_len(part, min_len, max_len)) {
 						return TRUE;
 					}
 				}
@@ -2191,82 +2200,83 @@ common_has_content_part (struct rspamd_task * task,
 }
 
 static gboolean
-rspamd_has_content_part (struct rspamd_task * task, GArray * args, void *unused)
+rspamd_has_content_part(struct rspamd_task *task, GArray *args, void *unused)
 {
 	struct expression_argument *param_type = NULL, *param_subtype = NULL;
 
 	if (args == NULL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	param_type = &g_array_index (args, struct expression_argument, 0);
+	param_type = &g_array_index(args, struct expression_argument, 0);
 	if (args->len >= 2) {
-		param_subtype = &g_array_index (args, struct expression_argument, 1);
+		param_subtype = &g_array_index(args, struct expression_argument, 1);
 	}
 
-	return common_has_content_part (task, param_type, param_subtype, 0, 0);
+	return common_has_content_part(task, param_type, param_subtype, 0, 0);
 }
 
 static gboolean
-rspamd_has_content_part_len (struct rspamd_task * task,
-	GArray * args,
-	void *unused)
+rspamd_has_content_part_len(struct rspamd_task *task,
+							GArray *args,
+							void *unused)
 {
 	struct expression_argument *param_type = NULL, *param_subtype = NULL;
 	gint min = 0, max = 0;
 	struct expression_argument *arg;
 
 	if (args == NULL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	param_type = &g_array_index (args, struct expression_argument, 0);
+	param_type = &g_array_index(args, struct expression_argument, 0);
 
 	if (args->len >= 2) {
-		param_subtype = &g_array_index (args, struct expression_argument, 1);
+		param_subtype = &g_array_index(args, struct expression_argument, 1);
 
 		if (args->len >= 3) {
-			arg = &g_array_index (args, struct expression_argument, 2);
+			arg = &g_array_index(args, struct expression_argument, 2);
 			errno = 0;
-			min = strtoul (arg->data, NULL, 10);
-			g_assert (arg->type == EXPRESSION_ARGUMENT_NORMAL);
+			min = strtoul(arg->data, NULL, 10);
+			g_assert(arg->type == EXPRESSION_ARGUMENT_NORMAL);
 
 			if (errno != 0) {
-				msg_warn_task ("invalid numeric value '%s': %s",
-					(gchar *)arg->data,
-					strerror (errno));
+				msg_warn_task("invalid numeric value '%s': %s",
+							  (gchar *) arg->data,
+							  strerror(errno));
 				return FALSE;
 			}
 
 			if (args->len >= 4) {
-				arg = &g_array_index (args, struct expression_argument, 3);
-				g_assert (arg->type == EXPRESSION_ARGUMENT_NORMAL);
-				max = strtoul (arg->data, NULL, 10);
+				arg = &g_array_index(args, struct expression_argument, 3);
+				g_assert(arg->type == EXPRESSION_ARGUMENT_NORMAL);
+				max = strtoul(arg->data, NULL, 10);
 
 				if (errno != 0) {
-					msg_warn_task ("invalid numeric value '%s': %s",
-						(gchar *)arg->data,
-						strerror (errno));
+					msg_warn_task("invalid numeric value '%s': %s",
+								  (gchar *) arg->data,
+								  strerror(errno));
 					return FALSE;
 				}
 			}
 		}
 	}
 
-	return common_has_content_part (task, param_type, param_subtype, min, max);
+	return common_has_content_part(task, param_type, param_subtype, min, max);
 }
 
 static gboolean
-rspamd_is_empty_body (struct rspamd_task *task,
-		GArray * args,
-		void *unused)
+rspamd_is_empty_body(struct rspamd_task *task,
+					 GArray *args,
+					 void *unused)
 {
 	struct rspamd_mime_part *part;
 	guint i;
 
-	PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, parts), i, part) {
+	PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, parts), i, part)
+	{
 		if (part->parsed_data.len > 0) {
 			return FALSE;
 		}
@@ -2275,72 +2285,76 @@ rspamd_is_empty_body (struct rspamd_task *task,
 	return TRUE;
 }
 
-#define TASK_FLAG_READ(flag) do { \
-	result = !!(task->flags & (flag)); \
-} while(0)
-
-#define TASK_GET_FLAG(flag, strname, macro) do { \
-	if (!found && strcmp ((flag), strname) == 0) { \
-		TASK_FLAG_READ((macro)); \
-		found = TRUE; \
-	} \
-} while(0)
-
-#define TASK_PROTOCOL_FLAG_READ(flag) do { \
-	result = !!(task->protocol_flags & (flag)); \
-} while(0)
-
-#define TASK_GET_PROTOCOL_FLAG(flag, strname, macro) do { \
-	if (!found && strcmp ((flag), strname) == 0) { \
-		TASK_PROTOCOL_FLAG_READ((macro)); \
-		found = TRUE; \
-	} \
-} while(0)
+#define TASK_FLAG_READ(flag)               \
+	do {                                   \
+		result = !!(task->flags & (flag)); \
+	} while (0)
+
+#define TASK_GET_FLAG(flag, strname, macro)           \
+	do {                                              \
+		if (!found && strcmp((flag), strname) == 0) { \
+			TASK_FLAG_READ((macro));                  \
+			found = TRUE;                             \
+		}                                             \
+	} while (0)
+
+#define TASK_PROTOCOL_FLAG_READ(flag)               \
+	do {                                            \
+		result = !!(task->protocol_flags & (flag)); \
+	} while (0)
+
+#define TASK_GET_PROTOCOL_FLAG(flag, strname, macro)  \
+	do {                                              \
+		if (!found && strcmp((flag), strname) == 0) { \
+			TASK_PROTOCOL_FLAG_READ((macro));         \
+			found = TRUE;                             \
+		}                                             \
+	} while (0)
 
 
 static gboolean
-rspamd_has_flag_expr (struct rspamd_task *task,
-					  GArray * args,
-					  void *unused)
+rspamd_has_flag_expr(struct rspamd_task *task,
+					 GArray *args,
+					 void *unused)
 {
 	gboolean found = FALSE, result = FALSE;
 	struct expression_argument *flag_arg;
 	const gchar *flag_str;
 
 	if (args == NULL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	flag_arg = &g_array_index (args, struct expression_argument, 0);
+	flag_arg = &g_array_index(args, struct expression_argument, 0);
 
 	if (flag_arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("invalid parameter to function");
+		msg_warn_task("invalid parameter to function");
 		return FALSE;
 	}
 
-	flag_str = (const gchar *)flag_arg->data;
-
-	TASK_GET_FLAG (flag_str, "pass_all", RSPAMD_TASK_FLAG_PASS_ALL);
-	TASK_GET_FLAG (flag_str, "no_log", RSPAMD_TASK_FLAG_NO_LOG);
-	TASK_GET_FLAG (flag_str, "no_stat", RSPAMD_TASK_FLAG_NO_STAT);
-	TASK_GET_FLAG (flag_str, "skip", RSPAMD_TASK_FLAG_SKIP);
-	TASK_GET_PROTOCOL_FLAG (flag_str, "extended_urls",
-			RSPAMD_TASK_PROTOCOL_FLAG_EXT_URLS);
-	TASK_GET_FLAG (flag_str, "learn_spam", RSPAMD_TASK_FLAG_LEARN_SPAM);
-	TASK_GET_FLAG (flag_str, "learn_ham", RSPAMD_TASK_FLAG_LEARN_HAM);
-	TASK_GET_FLAG (flag_str, "greylisted", RSPAMD_TASK_FLAG_GREYLISTED);
-	TASK_GET_FLAG (flag_str, "broken_headers",
-			RSPAMD_TASK_FLAG_BROKEN_HEADERS);
-	TASK_GET_FLAG (flag_str, "skip_process",
-			RSPAMD_TASK_FLAG_SKIP_PROCESS);
-	TASK_GET_PROTOCOL_FLAG (flag_str, "milter",
-			RSPAMD_TASK_PROTOCOL_FLAG_MILTER);
-	TASK_GET_FLAG (flag_str, "bad_unicode",
-			RSPAMD_TASK_FLAG_BAD_UNICODE);
+	flag_str = (const gchar *) flag_arg->data;
+
+	TASK_GET_FLAG(flag_str, "pass_all", RSPAMD_TASK_FLAG_PASS_ALL);
+	TASK_GET_FLAG(flag_str, "no_log", RSPAMD_TASK_FLAG_NO_LOG);
+	TASK_GET_FLAG(flag_str, "no_stat", RSPAMD_TASK_FLAG_NO_STAT);
+	TASK_GET_FLAG(flag_str, "skip", RSPAMD_TASK_FLAG_SKIP);
+	TASK_GET_PROTOCOL_FLAG(flag_str, "extended_urls",
+						   RSPAMD_TASK_PROTOCOL_FLAG_EXT_URLS);
+	TASK_GET_FLAG(flag_str, "learn_spam", RSPAMD_TASK_FLAG_LEARN_SPAM);
+	TASK_GET_FLAG(flag_str, "learn_ham", RSPAMD_TASK_FLAG_LEARN_HAM);
+	TASK_GET_FLAG(flag_str, "greylisted", RSPAMD_TASK_FLAG_GREYLISTED);
+	TASK_GET_FLAG(flag_str, "broken_headers",
+				  RSPAMD_TASK_FLAG_BROKEN_HEADERS);
+	TASK_GET_FLAG(flag_str, "skip_process",
+				  RSPAMD_TASK_FLAG_SKIP_PROCESS);
+	TASK_GET_PROTOCOL_FLAG(flag_str, "milter",
+						   RSPAMD_TASK_PROTOCOL_FLAG_MILTER);
+	TASK_GET_FLAG(flag_str, "bad_unicode",
+				  RSPAMD_TASK_FLAG_BAD_UNICODE);
 
 	if (!found) {
-		msg_warn_task ("invalid flag name %s", flag_str);
+		msg_warn_task("invalid flag name %s", flag_str);
 		return FALSE;
 	}
 
@@ -2348,28 +2362,28 @@ rspamd_has_flag_expr (struct rspamd_task *task,
 }
 
 static gboolean
-rspamd_has_symbol_expr (struct rspamd_task *task,
-					  GArray * args,
-					  void *unused)
+rspamd_has_symbol_expr(struct rspamd_task *task,
+					   GArray *args,
+					   void *unused)
 {
 	struct expression_argument *sym_arg;
 	const gchar *symbol_str;
 
 	if (args == NULL) {
-		msg_warn_task ("no parameters to function");
+		msg_warn_task("no parameters to function");
 		return FALSE;
 	}
 
-	sym_arg = &g_array_index (args, struct expression_argument, 0);
+	sym_arg = &g_array_index(args, struct expression_argument, 0);
 
 	if (sym_arg->type != EXPRESSION_ARGUMENT_NORMAL) {
-		msg_warn_task ("invalid parameter to function");
+		msg_warn_task("invalid parameter to function");
 		return FALSE;
 	}
 
-	symbol_str = (const gchar *)sym_arg->data;
+	symbol_str = (const gchar *) sym_arg->data;
 
-	if (rspamd_task_find_symbol_result (task, symbol_str, NULL)) {
+	if (rspamd_task_find_symbol_result(task, symbol_str, NULL)) {
 		return TRUE;
 	}