Revert "Unify code style."

This reverts commit e0483657ff6cf1adc828ccce457814d61fe90a0d.

1 files changed, 280 insertions, 404 deletions

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;