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

No meaningful changes.

1 files changed, 349 insertions, 508 deletions

diff --git a/src/libstat/backends/sqlite3_backend.c b/src/libstat/backends/sqlite3_backend.c
index 45e51fa7b..2fd34d83f 100644
--- a/src/libstat/backends/sqlite3_backend.c
+++ b/src/libstat/backends/sqlite3_backend.c
@@ -48,33 +48,33 @@ struct rspamd_stat_sqlite3_rt {
 };
 
 static const char *create_tables_sql =
-		"BEGIN IMMEDIATE;"
-		"CREATE TABLE tokenizer(data BLOB);"
-		"CREATE TABLE users("
-		"id INTEGER PRIMARY KEY,"
-		"name TEXT,"
-		"learns INTEGER"
-		");"
-		"CREATE TABLE languages("
-		"id INTEGER PRIMARY KEY,"
-		"name TEXT,"
-		"learns INTEGER"
-		");"
-		"CREATE TABLE tokens("
-		"token INTEGER NOT NULL,"
-		"user INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,"
-		"language INTEGER NOT NULL REFERENCES languages(id) ON DELETE CASCADE,"
-		"value INTEGER,"
-		"modified INTEGER,"
-		"CONSTRAINT tid UNIQUE (token, user, language) ON CONFLICT REPLACE"
-		");"
-		"CREATE UNIQUE INDEX IF NOT EXISTS un ON users(name);"
-		"CREATE INDEX IF NOT EXISTS tok ON tokens(token);"
-		"CREATE UNIQUE INDEX IF NOT EXISTS ln ON languages(name);"
-		"PRAGMA user_version=" SQLITE3_SCHEMA_VERSION ";"
-		"INSERT INTO users(id, name, learns) VALUES(0, '" SQLITE3_DEFAULT "',0);"
-		"INSERT INTO languages(id, name, learns) VALUES(0, '" SQLITE3_DEFAULT "',0);"
-		"COMMIT;";
+	"BEGIN IMMEDIATE;"
+	"CREATE TABLE tokenizer(data BLOB);"
+	"CREATE TABLE users("
+	"id INTEGER PRIMARY KEY,"
+	"name TEXT,"
+	"learns INTEGER"
+	");"
+	"CREATE TABLE languages("
+	"id INTEGER PRIMARY KEY,"
+	"name TEXT,"
+	"learns INTEGER"
+	");"
+	"CREATE TABLE tokens("
+	"token INTEGER NOT NULL,"
+	"user INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,"
+	"language INTEGER NOT NULL REFERENCES languages(id) ON DELETE CASCADE,"
+	"value INTEGER,"
+	"modified INTEGER,"
+	"CONSTRAINT tid UNIQUE (token, user, language) ON CONFLICT REPLACE"
+	");"
+	"CREATE UNIQUE INDEX IF NOT EXISTS un ON users(name);"
+	"CREATE INDEX IF NOT EXISTS tok ON tokens(token);"
+	"CREATE UNIQUE INDEX IF NOT EXISTS ln ON languages(name);"
+	"PRAGMA user_version=" SQLITE3_SCHEMA_VERSION ";"
+	"INSERT INTO users(id, name, learns) VALUES(0, '" SQLITE3_DEFAULT "',0);"
+	"INSERT INTO languages(id, name, learns) VALUES(0, '" SQLITE3_DEFAULT "',0);"
+	"COMMIT;";
 
 enum rspamd_stat_sqlite3_stmt_idx {
 	RSPAMD_STAT_BACKEND_TRANSACTION_START_IM = 0,
@@ -103,221 +103,62 @@ enum rspamd_stat_sqlite3_stmt_idx {
 };
 
 static struct rspamd_sqlite3_prstmt prepared_stmts[RSPAMD_STAT_BACKEND_MAX] =
-{
-	[RSPAMD_STAT_BACKEND_TRANSACTION_START_IM] = {
-		.idx = RSPAMD_STAT_BACKEND_TRANSACTION_START_IM,
-		.sql = "BEGIN IMMEDIATE TRANSACTION;",
-		.args = "",
-		.stmt = NULL,
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = "",
-	},
-	[RSPAMD_STAT_BACKEND_TRANSACTION_START_DEF] = {
-		.idx = RSPAMD_STAT_BACKEND_TRANSACTION_START_DEF,
-		.sql = "BEGIN DEFERRED TRANSACTION;",
-		.args = "",
-		.stmt = NULL,
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_TRANSACTION_START_EXCL] = {
-		.idx = RSPAMD_STAT_BACKEND_TRANSACTION_START_EXCL,
-		.sql = "BEGIN EXCLUSIVE TRANSACTION;",
-		.args = "",
-		.stmt = NULL,
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT] = {
-		.idx = RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT,
-		.sql = "COMMIT;",
-		.args = "",
-		.stmt = NULL,
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_TRANSACTION_ROLLBACK] = {
-		.idx = RSPAMD_STAT_BACKEND_TRANSACTION_ROLLBACK,
-		.sql = "ROLLBACK;",
-		.args = "",
-		.stmt = NULL,
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_GET_TOKEN_FULL] = {
-		.idx = RSPAMD_STAT_BACKEND_GET_TOKEN_FULL,
-		.sql = "SELECT value FROM tokens "
-				"LEFT JOIN languages ON tokens.language=languages.id "
-				"LEFT JOIN users ON tokens.user=users.id "
-				"WHERE token=?1 AND (users.id=?2) "
-				"AND (languages.id=?3 OR languages.id=0);",
-		.stmt = NULL,
-		.args = "III",
-		.result = SQLITE_ROW,
-		.flags = 0,
-		.ret = "I"
-	},
-	[RSPAMD_STAT_BACKEND_GET_TOKEN_SIMPLE] = {
-			.idx = RSPAMD_STAT_BACKEND_GET_TOKEN_SIMPLE,
-			.sql = "SELECT value FROM tokens WHERE token=?1",
+	{
+		[RSPAMD_STAT_BACKEND_TRANSACTION_START_IM] = {
+			.idx = RSPAMD_STAT_BACKEND_TRANSACTION_START_IM,
+			.sql = "BEGIN IMMEDIATE TRANSACTION;",
+			.args = "",
 			.stmt = NULL,
-			.args = "I",
-			.result = SQLITE_ROW,
+			.result = SQLITE_DONE,
 			.flags = 0,
-			.ret = "I"
-	},
-	[RSPAMD_STAT_BACKEND_SET_TOKEN] = {
-		.idx = RSPAMD_STAT_BACKEND_SET_TOKEN,
-		.sql = "INSERT OR REPLACE INTO tokens (token, user, language, value, modified) "
-				"VALUES (?1, ?2, ?3, ?4, strftime('%s','now'))",
-		.stmt = NULL,
-		.args = "IIII",
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_INC_LEARNS_LANG] = {
-		.idx = RSPAMD_STAT_BACKEND_INC_LEARNS_LANG,
-		.sql = "UPDATE languages SET learns=learns + 1 WHERE id=?1",
-		.stmt = NULL,
-		.args = "I",
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_INC_LEARNS_USER] = {
-		.idx = RSPAMD_STAT_BACKEND_INC_LEARNS_USER,
-		.sql = "UPDATE users SET learns=learns + 1 WHERE id=?1",
-		.stmt = NULL,
-		.args = "I",
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_DEC_LEARNS_LANG] = {
-		.idx = RSPAMD_STAT_BACKEND_DEC_LEARNS_LANG,
-		.sql = "UPDATE languages SET learns=MAX(0, learns - 1) WHERE id=?1",
-		.stmt = NULL,
-		.args = "I",
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_DEC_LEARNS_USER] = {
-		.idx = RSPAMD_STAT_BACKEND_DEC_LEARNS_USER,
-		.sql = "UPDATE users SET learns=MAX(0, learns - 1) WHERE id=?1",
-		.stmt = NULL,
-		.args = "I",
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_GET_LEARNS] = {
-		.idx = RSPAMD_STAT_BACKEND_GET_LEARNS,
-		.sql = "SELECT SUM(MAX(0, learns)) FROM languages",
-		.stmt = NULL,
-		.args = "",
-		.result = SQLITE_ROW,
-		.flags = 0,
-		.ret = "I"
-	},
-	[RSPAMD_STAT_BACKEND_GET_LANGUAGE] = {
-		.idx = RSPAMD_STAT_BACKEND_GET_LANGUAGE,
-		.sql = "SELECT id FROM languages WHERE name=?1",
-		.stmt = NULL,
-		.args = "T",
-		.result = SQLITE_ROW,
-		.flags = 0,
-		.ret = "I"
-	},
-	[RSPAMD_STAT_BACKEND_GET_USER] = {
-		.idx = RSPAMD_STAT_BACKEND_GET_USER,
-		.sql = "SELECT id FROM users WHERE name=?1",
-		.stmt = NULL,
-		.args = "T",
-		.result = SQLITE_ROW,
-		.flags = 0,
-		.ret = "I"
-	},
-	[RSPAMD_STAT_BACKEND_INSERT_USER] = {
-		.idx = RSPAMD_STAT_BACKEND_INSERT_USER,
-		.sql = "INSERT INTO users (name, learns) VALUES (?1, 0)",
-		.stmt = NULL,
-		.args = "T",
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = "L"
-	},
-	[RSPAMD_STAT_BACKEND_INSERT_LANGUAGE] = {
-		.idx = RSPAMD_STAT_BACKEND_INSERT_LANGUAGE,
-		.sql = "INSERT INTO languages (name, learns) VALUES (?1, 0)",
-		.stmt = NULL,
-		.args = "T",
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = "L"
-	},
-	[RSPAMD_STAT_BACKEND_SAVE_TOKENIZER] = {
-		.idx = RSPAMD_STAT_BACKEND_SAVE_TOKENIZER,
-		.sql = "INSERT INTO tokenizer(data) VALUES (?1)",
-		.stmt = NULL,
-		.args = "B",
-		.result = SQLITE_DONE,
-		.flags = 0,
-		.ret = ""
-	},
-	[RSPAMD_STAT_BACKEND_LOAD_TOKENIZER] = {
-		.idx = RSPAMD_STAT_BACKEND_LOAD_TOKENIZER,
-		.sql = "SELECT data FROM tokenizer",
-		.stmt = NULL,
-		.args = "",
-		.result = SQLITE_ROW,
-		.flags = 0,
-		.ret = "B"
-	},
-	[RSPAMD_STAT_BACKEND_NTOKENS] = {
-		.idx = RSPAMD_STAT_BACKEND_NTOKENS,
-		.sql = "SELECT COUNT(*) FROM tokens",
-		.stmt = NULL,
-		.args = "",
-		.result = SQLITE_ROW,
-		.flags = 0,
-		.ret = "I"
-	},
-	[RSPAMD_STAT_BACKEND_NLANGUAGES] = {
-		.idx = RSPAMD_STAT_BACKEND_NLANGUAGES,
-		.sql = "SELECT COUNT(*) FROM languages",
-		.stmt = NULL,
-		.args = "",
-		.result = SQLITE_ROW,
-		.flags = 0,
-		.ret = "I"
-	},
-	[RSPAMD_STAT_BACKEND_NUSERS] = {
-		.idx = RSPAMD_STAT_BACKEND_NUSERS,
-		.sql = "SELECT COUNT(*) FROM users",
-		.stmt = NULL,
-		.args = "",
-		.result = SQLITE_ROW,
-		.flags = 0,
-		.ret = "I"
-	}
-};
+			.ret = "",
+		},
+		[RSPAMD_STAT_BACKEND_TRANSACTION_START_DEF] = {.idx = RSPAMD_STAT_BACKEND_TRANSACTION_START_DEF, .sql = "BEGIN DEFERRED TRANSACTION;", .args = "", .stmt = NULL, .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_TRANSACTION_START_EXCL] = {.idx = RSPAMD_STAT_BACKEND_TRANSACTION_START_EXCL, .sql = "BEGIN EXCLUSIVE TRANSACTION;", .args = "", .stmt = NULL, .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT] = {.idx = RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT, .sql = "COMMIT;", .args = "", .stmt = NULL, .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_TRANSACTION_ROLLBACK] = {.idx = RSPAMD_STAT_BACKEND_TRANSACTION_ROLLBACK, .sql = "ROLLBACK;", .args = "", .stmt = NULL, .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_GET_TOKEN_FULL] = {.idx = RSPAMD_STAT_BACKEND_GET_TOKEN_FULL, .sql = "SELECT value FROM tokens "
+																								  "LEFT JOIN languages ON tokens.language=languages.id "
+																								  "LEFT JOIN users ON tokens.user=users.id "
+																								  "WHERE token=?1 AND (users.id=?2) "
+																								  "AND (languages.id=?3 OR languages.id=0);",
+												.stmt = NULL,
+												.args = "III",
+												.result = SQLITE_ROW,
+												.flags = 0,
+												.ret = "I"},
+		[RSPAMD_STAT_BACKEND_GET_TOKEN_SIMPLE] = {.idx = RSPAMD_STAT_BACKEND_GET_TOKEN_SIMPLE, .sql = "SELECT value FROM tokens WHERE token=?1", .stmt = NULL, .args = "I", .result = SQLITE_ROW, .flags = 0, .ret = "I"},
+		[RSPAMD_STAT_BACKEND_SET_TOKEN] = {.idx = RSPAMD_STAT_BACKEND_SET_TOKEN, .sql = "INSERT OR REPLACE INTO tokens (token, user, language, value, modified) "
+																						"VALUES (?1, ?2, ?3, ?4, strftime('%s','now'))",
+										   .stmt = NULL,
+										   .args = "IIII",
+										   .result = SQLITE_DONE,
+										   .flags = 0,
+										   .ret = ""},
+		[RSPAMD_STAT_BACKEND_INC_LEARNS_LANG] = {.idx = RSPAMD_STAT_BACKEND_INC_LEARNS_LANG, .sql = "UPDATE languages SET learns=learns + 1 WHERE id=?1", .stmt = NULL, .args = "I", .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_INC_LEARNS_USER] = {.idx = RSPAMD_STAT_BACKEND_INC_LEARNS_USER, .sql = "UPDATE users SET learns=learns + 1 WHERE id=?1", .stmt = NULL, .args = "I", .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_DEC_LEARNS_LANG] = {.idx = RSPAMD_STAT_BACKEND_DEC_LEARNS_LANG, .sql = "UPDATE languages SET learns=MAX(0, learns - 1) WHERE id=?1", .stmt = NULL, .args = "I", .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_DEC_LEARNS_USER] = {.idx = RSPAMD_STAT_BACKEND_DEC_LEARNS_USER, .sql = "UPDATE users SET learns=MAX(0, learns - 1) WHERE id=?1", .stmt = NULL, .args = "I", .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_GET_LEARNS] = {.idx = RSPAMD_STAT_BACKEND_GET_LEARNS, .sql = "SELECT SUM(MAX(0, learns)) FROM languages", .stmt = NULL, .args = "", .result = SQLITE_ROW, .flags = 0, .ret = "I"},
+		[RSPAMD_STAT_BACKEND_GET_LANGUAGE] = {.idx = RSPAMD_STAT_BACKEND_GET_LANGUAGE, .sql = "SELECT id FROM languages WHERE name=?1", .stmt = NULL, .args = "T", .result = SQLITE_ROW, .flags = 0, .ret = "I"},
+		[RSPAMD_STAT_BACKEND_GET_USER] = {.idx = RSPAMD_STAT_BACKEND_GET_USER, .sql = "SELECT id FROM users WHERE name=?1", .stmt = NULL, .args = "T", .result = SQLITE_ROW, .flags = 0, .ret = "I"},
+		[RSPAMD_STAT_BACKEND_INSERT_USER] = {.idx = RSPAMD_STAT_BACKEND_INSERT_USER, .sql = "INSERT INTO users (name, learns) VALUES (?1, 0)", .stmt = NULL, .args = "T", .result = SQLITE_DONE, .flags = 0, .ret = "L"},
+		[RSPAMD_STAT_BACKEND_INSERT_LANGUAGE] = {.idx = RSPAMD_STAT_BACKEND_INSERT_LANGUAGE, .sql = "INSERT INTO languages (name, learns) VALUES (?1, 0)", .stmt = NULL, .args = "T", .result = SQLITE_DONE, .flags = 0, .ret = "L"},
+		[RSPAMD_STAT_BACKEND_SAVE_TOKENIZER] = {.idx = RSPAMD_STAT_BACKEND_SAVE_TOKENIZER, .sql = "INSERT INTO tokenizer(data) VALUES (?1)", .stmt = NULL, .args = "B", .result = SQLITE_DONE, .flags = 0, .ret = ""},
+		[RSPAMD_STAT_BACKEND_LOAD_TOKENIZER] = {.idx = RSPAMD_STAT_BACKEND_LOAD_TOKENIZER, .sql = "SELECT data FROM tokenizer", .stmt = NULL, .args = "", .result = SQLITE_ROW, .flags = 0, .ret = "B"},
+		[RSPAMD_STAT_BACKEND_NTOKENS] = {.idx = RSPAMD_STAT_BACKEND_NTOKENS, .sql = "SELECT COUNT(*) FROM tokens", .stmt = NULL, .args = "", .result = SQLITE_ROW, .flags = 0, .ret = "I"},
+		[RSPAMD_STAT_BACKEND_NLANGUAGES] = {.idx = RSPAMD_STAT_BACKEND_NLANGUAGES, .sql = "SELECT COUNT(*) FROM languages", .stmt = NULL, .args = "", .result = SQLITE_ROW, .flags = 0, .ret = "I"},
+		[RSPAMD_STAT_BACKEND_NUSERS] = {.idx = RSPAMD_STAT_BACKEND_NUSERS, .sql = "SELECT COUNT(*) FROM users", .stmt = NULL, .args = "", .result = SQLITE_ROW, .flags = 0, .ret = "I"}};
 
 static GQuark
-rspamd_sqlite3_backend_quark (void)
+rspamd_sqlite3_backend_quark(void)
 {
-	return g_quark_from_static_string ("sqlite3-stat-backend");
+	return g_quark_from_static_string("sqlite3-stat-backend");
 }
 
 static gint64
-rspamd_sqlite3_get_user (struct rspamd_stat_sqlite3_db *db,
-		struct rspamd_task *task, gboolean learn)
+rspamd_sqlite3_get_user(struct rspamd_stat_sqlite3_db *db,
+						struct rspamd_task *task, gboolean learn)
 {
 	gint64 id = 0; /* Default user is 0 */
 	gint rc, err_idx;
@@ -326,48 +167,48 @@ rspamd_sqlite3_get_user (struct rspamd_stat_sqlite3_db *db,
 	lua_State *L = db->L;
 
 	if (db->cbref_user == -1) {
-		user = rspamd_task_get_principal_recipient (task);
+		user = rspamd_task_get_principal_recipient(task);
 	}
 	else {
 		/* Execute lua function to get userdata */
-		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, db->cbref_user);
-		ptask = lua_newuserdata (L, sizeof (struct rspamd_task *));
+		lua_rawgeti(L, LUA_REGISTRYINDEX, db->cbref_user);
+		ptask = lua_newuserdata(L, sizeof(struct rspamd_task *));
 		*ptask = task;
-		rspamd_lua_setclass (L, "rspamd{task}", -1);
+		rspamd_lua_setclass(L, "rspamd{task}", -1);
 
-		if (lua_pcall (L, 1, 1, err_idx) != 0) {
-			msg_err_task ("call to user extraction script failed: %s",
-					lua_tostring (L, -1));
+		if (lua_pcall(L, 1, 1, err_idx) != 0) {
+			msg_err_task("call to user extraction script failed: %s",
+						 lua_tostring(L, -1));
 		}
 		else {
-			user = rspamd_mempool_strdup (task->task_pool, lua_tostring (L, -1));
+			user = rspamd_mempool_strdup(task->task_pool, lua_tostring(L, -1));
 		}
 
 		/* Result + error function */
-		lua_settop (L, err_idx - 1);
+		lua_settop(L, err_idx - 1);
 	}
 
 
 	if (user != NULL) {
-		rspamd_mempool_set_variable (task->task_pool, "stat_user",
-				(gpointer)user, NULL);
+		rspamd_mempool_set_variable(task->task_pool, "stat_user",
+									(gpointer) user, NULL);
 
-		rc = rspamd_sqlite3_run_prstmt (task->task_pool, db->sqlite, db->prstmt,
-				RSPAMD_STAT_BACKEND_GET_USER, user, &id);
+		rc = rspamd_sqlite3_run_prstmt(task->task_pool, db->sqlite, db->prstmt,
+									   RSPAMD_STAT_BACKEND_GET_USER, user, &id);
 
 		if (rc != SQLITE_OK && learn) {
 			/* We need to insert a new user */
 			if (!db->in_transaction) {
-				rspamd_sqlite3_run_prstmt (task->task_pool, db->sqlite, db->prstmt,
-						RSPAMD_STAT_BACKEND_TRANSACTION_START_IM);
+				rspamd_sqlite3_run_prstmt(task->task_pool, db->sqlite, db->prstmt,
+										  RSPAMD_STAT_BACKEND_TRANSACTION_START_IM);
 				db->in_transaction = TRUE;
 			}
 
-			rc =  rspamd_sqlite3_run_prstmt (task->task_pool, db->sqlite, db->prstmt,
-					RSPAMD_STAT_BACKEND_INSERT_USER, user, &id);
+			rc = rspamd_sqlite3_run_prstmt(task->task_pool, db->sqlite, db->prstmt,
+										   RSPAMD_STAT_BACKEND_INSERT_USER, user, &id);
 		}
 	}
 
@@ -375,8 +216,8 @@ rspamd_sqlite3_get_user (struct rspamd_stat_sqlite3_db *db,
 }
 
 static gint64
-rspamd_sqlite3_get_language (struct rspamd_stat_sqlite3_db *db,
-		struct rspamd_task *task, gboolean learn)
+rspamd_sqlite3_get_language(struct rspamd_stat_sqlite3_db *db,
+							struct rspamd_task *task, gboolean learn)
 {
 	gint64 id = 0; /* Default language is 0 */
 	gint rc, err_idx;
@@ -387,10 +228,11 @@ rspamd_sqlite3_get_language (struct rspamd_stat_sqlite3_db *db,
 	lua_State *L = db->L;
 
 	if (db->cbref_language == -1) {
-		PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, text_parts), i, tp) {
+		PTR_ARRAY_FOREACH(MESSAGE_FIELD(task, text_parts), i, tp)
+		{
 
 			if (tp->language != NULL && tp->language[0] != '\0' &&
-					strcmp (tp->language, "en") != 0) {
+				strcmp(tp->language, "en") != 0) {
 				language = tp->language;
 				break;
 			}
@@ -398,43 +240,43 @@ rspamd_sqlite3_get_language (struct rspamd_stat_sqlite3_db *db,
 	}
 	else {
 		/* Execute lua function to get userdata */
-		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, db->cbref_language);
-		ptask = lua_newuserdata (L, sizeof (struct rspamd_task *));
+		lua_rawgeti(L, LUA_REGISTRYINDEX, db->cbref_language);
+		ptask = lua_newuserdata(L, sizeof(struct rspamd_task *));
 		*ptask = task;
-		rspamd_lua_setclass (L, "rspamd{task}", -1);
+		rspamd_lua_setclass(L, "rspamd{task}", -1);
 
-		if (lua_pcall (L, 1, 1, err_idx) != 0) {
-			msg_err_task ("call to language extraction script failed: %s",
-					lua_tostring (L, -1));
+		if (lua_pcall(L, 1, 1, err_idx) != 0) {
+			msg_err_task("call to language extraction script failed: %s",
+						 lua_tostring(L, -1));
 		}
 		else {
-			language = rspamd_mempool_strdup (task->task_pool,
-					lua_tostring (L, -1));
+			language = rspamd_mempool_strdup(task->task_pool,
+											 lua_tostring(L, -1));
 		}
 
 		/* Result + error function */
-		lua_settop (L, err_idx - 1);
+		lua_settop(L, err_idx - 1);
 	}
 
 
 	/* XXX: We ignore multiple languages but default + extra */
 	if (language != NULL) {
-		rc = rspamd_sqlite3_run_prstmt (task->task_pool, db->sqlite, db->prstmt,
-				RSPAMD_STAT_BACKEND_GET_LANGUAGE, language, &id);
+		rc = rspamd_sqlite3_run_prstmt(task->task_pool, db->sqlite, db->prstmt,
+									   RSPAMD_STAT_BACKEND_GET_LANGUAGE, language, &id);
 
 		if (rc != SQLITE_OK && learn) {
 			/* We need to insert a new language */
 			if (!db->in_transaction) {
-				rspamd_sqlite3_run_prstmt (task->task_pool, db->sqlite, db->prstmt,
-						RSPAMD_STAT_BACKEND_TRANSACTION_START_IM);
+				rspamd_sqlite3_run_prstmt(task->task_pool, db->sqlite, db->prstmt,
+										  RSPAMD_STAT_BACKEND_TRANSACTION_START_IM);
 				db->in_transaction = TRUE;
 			}
 
-			rc =  rspamd_sqlite3_run_prstmt (task->task_pool, db->sqlite, db->prstmt,
-					RSPAMD_STAT_BACKEND_INSERT_LANGUAGE, language, &id);
+			rc = rspamd_sqlite3_run_prstmt(task->task_pool, db->sqlite, db->prstmt,
+										   RSPAMD_STAT_BACKEND_INSERT_LANGUAGE, language, &id);
 		}
 	}
 
@@ -442,10 +284,10 @@ rspamd_sqlite3_get_language (struct rspamd_stat_sqlite3_db *db,
 }
 
 static struct rspamd_stat_sqlite3_db *
-rspamd_sqlite3_opendb (rspamd_mempool_t *pool,
-		struct rspamd_statfile_config *stcf,
-		const gchar *path, const ucl_object_t *opts,
-		gboolean create, GError **err)
+rspamd_sqlite3_opendb(rspamd_mempool_t *pool,
+					  struct rspamd_statfile_config *stcf,
+					  const gchar *path, const ucl_object_t *opts,
+					  gboolean create, GError **err)
 {
 	struct rspamd_stat_sqlite3_db *bk;
 	struct rspamd_stat_tokenizer *tokenizer;
@@ -456,80 +298,79 @@ rspamd_sqlite3_opendb (rspamd_mempool_t *pool,
 	gint ret, ntries = 0;
 	const gint max_tries = 100;
 	struct timespec sleep_ts = {
-			.tv_sec = 0,
-			.tv_nsec = 1000000
-	};
+		.tv_sec = 0,
+		.tv_nsec = 1000000};
 
-	bk = g_malloc0 (sizeof (*bk));
-	bk->sqlite = rspamd_sqlite3_open_or_create (pool, path, create_tables_sql,
-			0, err);
+	bk = g_malloc0(sizeof(*bk));
+	bk->sqlite = rspamd_sqlite3_open_or_create(pool, path, create_tables_sql,
+											   0, err);
 	bk->pool = pool;
 
 	if (bk->sqlite == NULL) {
-		g_free (bk);
+		g_free(bk);
 
 		return NULL;
 	}
 
-	bk->fname = g_strdup (path);
+	bk->fname = g_strdup(path);
 
-	bk->prstmt = rspamd_sqlite3_init_prstmt (bk->sqlite, prepared_stmts,
-			RSPAMD_STAT_BACKEND_MAX, err);
+	bk->prstmt = rspamd_sqlite3_init_prstmt(bk->sqlite, prepared_stmts,
+											RSPAMD_STAT_BACKEND_MAX, err);
 
 	if (bk->prstmt == NULL) {
-		sqlite3_close (bk->sqlite);
-		g_free (bk);
+		sqlite3_close(bk->sqlite);
+		g_free(bk);
 
 		return NULL;
 	}
 
 	/* Check tokenizer configuration */
-	if (rspamd_sqlite3_run_prstmt (pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_LOAD_TOKENIZER, &sz64, &tk_conf) != SQLITE_OK ||
-			sz64 == 0) {
+	if (rspamd_sqlite3_run_prstmt(pool, bk->sqlite, bk->prstmt,
+								  RSPAMD_STAT_BACKEND_LOAD_TOKENIZER, &sz64, &tk_conf) != SQLITE_OK ||
+		sz64 == 0) {
 
-		while ((ret = rspamd_sqlite3_run_prstmt (pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_TRANSACTION_START_EXCL)) == SQLITE_BUSY &&
+		while ((ret = rspamd_sqlite3_run_prstmt(pool, bk->sqlite, bk->prstmt,
+												RSPAMD_STAT_BACKEND_TRANSACTION_START_EXCL)) == SQLITE_BUSY &&
 			   ++ntries <= max_tries) {
-			nanosleep (&sleep_ts, NULL);
+			nanosleep(&sleep_ts, NULL);
 		}
 
-		msg_info_pool ("absent tokenizer conf in %s, creating a new one",
-				bk->fname);
-		g_assert (stcf->clcf->tokenizer != NULL);
-		tokenizer = rspamd_stat_get_tokenizer (stcf->clcf->tokenizer->name);
-		g_assert (tokenizer != NULL);
-		tk_conf = tokenizer->get_config (pool, stcf->clcf->tokenizer, &sz);
+		msg_info_pool("absent tokenizer conf in %s, creating a new one",
+					  bk->fname);
+		g_assert(stcf->clcf->tokenizer != NULL);
+		tokenizer = rspamd_stat_get_tokenizer(stcf->clcf->tokenizer->name);
+		g_assert(tokenizer != NULL);
+		tk_conf = tokenizer->get_config(pool, stcf->clcf->tokenizer, &sz);
 
 		/* Encode to base32 */
-		tok_conf_encoded = rspamd_encode_base32 (tk_conf, sz, RSPAMD_BASE32_DEFAULT);
+		tok_conf_encoded = rspamd_encode_base32(tk_conf, sz, RSPAMD_BASE32_DEFAULT);
 
-		if (rspamd_sqlite3_run_prstmt (pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_SAVE_TOKENIZER,
-				(gint64)strlen (tok_conf_encoded),
-				tok_conf_encoded) != SQLITE_OK) {
-			sqlite3_close (bk->sqlite);
-			g_free (bk);
-			g_free (tok_conf_encoded);
+		if (rspamd_sqlite3_run_prstmt(pool, bk->sqlite, bk->prstmt,
+									  RSPAMD_STAT_BACKEND_SAVE_TOKENIZER,
+									  (gint64) strlen(tok_conf_encoded),
+									  tok_conf_encoded) != SQLITE_OK) {
+			sqlite3_close(bk->sqlite);
+			g_free(bk);
+			g_free(tok_conf_encoded);
 
 			return NULL;
 		}
 
-		rspamd_sqlite3_run_prstmt (pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
-		g_free (tok_conf_encoded);
+		rspamd_sqlite3_run_prstmt(pool, bk->sqlite, bk->prstmt,
+								  RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+		g_free(tok_conf_encoded);
 	}
 	else {
-		g_free (tk_conf);
+		g_free(tk_conf);
 	}
 
 	return bk;
 }
 
 gpointer
-rspamd_sqlite3_init (struct rspamd_stat_ctx *ctx,
-		struct rspamd_config *cfg,
-		struct rspamd_statfile *st)
+rspamd_sqlite3_init(struct rspamd_stat_ctx *ctx,
+					struct rspamd_config *cfg,
+					struct rspamd_statfile *st)
 {
 	struct rspamd_classifier_config *clf = st->classifier->cfg;
 	struct rspamd_statfile_config *stf = st->stcf;
@@ -538,51 +379,52 @@ rspamd_sqlite3_init (struct rspamd_stat_ctx *ctx,
 	struct rspamd_stat_sqlite3_db *bk;
 	GError *err = NULL;
 
-	filenameo = ucl_object_lookup (stf->opts, "filename");
-	if (filenameo == NULL || ucl_object_type (filenameo) != UCL_STRING) {
-		filenameo = ucl_object_lookup (stf->opts, "path");
-		if (filenameo == NULL || ucl_object_type (filenameo) != UCL_STRING) {
-			msg_err_config ("statfile %s has no filename defined", stf->symbol);
+	filenameo = ucl_object_lookup(stf->opts, "filename");
+	if (filenameo == NULL || ucl_object_type(filenameo) != UCL_STRING) {
+		filenameo = ucl_object_lookup(stf->opts, "path");
+		if (filenameo == NULL || ucl_object_type(filenameo) != UCL_STRING) {
+			msg_err_config("statfile %s has no filename defined", stf->symbol);
 			return NULL;
 		}
 	}
 
-	filename = ucl_object_tostring (filenameo);
+	filename = ucl_object_tostring(filenameo);
 
-	if ((bk = rspamd_sqlite3_opendb (cfg->cfg_pool, stf, filename,
-			stf->opts, TRUE, &err)) == NULL) {
-		msg_err_config ("cannot open sqlite3 db %s: %e", filename, err);
-		g_error_free (err);
+	if ((bk = rspamd_sqlite3_opendb(cfg->cfg_pool, stf, filename,
+									stf->opts, TRUE, &err)) == NULL) {
+		msg_err_config("cannot open sqlite3 db %s: %e", filename, err);
+		g_error_free(err);
 		return NULL;
 	}
 
 	bk->L = cfg->lua_state;
 
-	users_enabled = ucl_object_lookup_any (clf->opts, "per_user",
-			"users_enabled", NULL);
+	users_enabled = ucl_object_lookup_any(clf->opts, "per_user",
+										  "users_enabled", NULL);
 	if (users_enabled != NULL) {
-		if (ucl_object_type (users_enabled) == UCL_BOOLEAN) {
-			bk->enable_users = ucl_object_toboolean (users_enabled);
+		if (ucl_object_type(users_enabled) == UCL_BOOLEAN) {
+			bk->enable_users = ucl_object_toboolean(users_enabled);
 			bk->cbref_user = -1;
 		}
-		else if (ucl_object_type (users_enabled) == UCL_STRING) {
-			lua_script = ucl_object_tostring (users_enabled);
+		else if (ucl_object_type(users_enabled) == UCL_STRING) {
+			lua_script = ucl_object_tostring(users_enabled);
 
-			if (luaL_dostring (cfg->lua_state, lua_script) != 0) {
-				msg_err_config ("cannot execute lua script for users "
-						"extraction: %s", lua_tostring (cfg->lua_state, -1));
+			if (luaL_dostring(cfg->lua_state, lua_script) != 0) {
+				msg_err_config("cannot execute lua script for users "
+							   "extraction: %s",
+							   lua_tostring(cfg->lua_state, -1));
 			}
 			else {
-				if (lua_type (cfg->lua_state, -1) == LUA_TFUNCTION) {
+				if (lua_type(cfg->lua_state, -1) == LUA_TFUNCTION) {
 					bk->enable_users = TRUE;
-					bk->cbref_user = luaL_ref (cfg->lua_state,
-							LUA_REGISTRYINDEX);
+					bk->cbref_user = luaL_ref(cfg->lua_state,
+											  LUA_REGISTRYINDEX);
 				}
 				else {
-					msg_err_config ("lua script must return "
-							"function(task) and not %s",
-							lua_typename (cfg->lua_state, lua_type (
-									cfg->lua_state, -1)));
+					msg_err_config("lua script must return "
+								   "function(task) and not %s",
+								   lua_typename(cfg->lua_state, lua_type(
+																	cfg->lua_state, -1)));
 				}
 			}
 		}
@@ -591,34 +433,34 @@ rspamd_sqlite3_init (struct rspamd_stat_ctx *ctx,
 		bk->enable_users = FALSE;
 	}
 
-	lang_enabled = ucl_object_lookup_any (clf->opts,
-			"per_language", "languages_enabled", NULL);
+	lang_enabled = ucl_object_lookup_any(clf->opts,
+										 "per_language", "languages_enabled", NULL);
 
 	if (lang_enabled != NULL) {
-		if (ucl_object_type (lang_enabled) == UCL_BOOLEAN) {
-			bk->enable_languages = ucl_object_toboolean (lang_enabled);
+		if (ucl_object_type(lang_enabled) == UCL_BOOLEAN) {
+			bk->enable_languages = ucl_object_toboolean(lang_enabled);
 			bk->cbref_language = -1;
 		}
-		else if (ucl_object_type (lang_enabled) == UCL_STRING) {
-			lua_script = ucl_object_tostring (lang_enabled);
-
-			if (luaL_dostring (cfg->lua_state, lua_script) != 0) {
-				msg_err_config (
-						"cannot execute lua script for languages "
-								"extraction: %s",
-						lua_tostring (cfg->lua_state, -1));
+		else if (ucl_object_type(lang_enabled) == UCL_STRING) {
+			lua_script = ucl_object_tostring(lang_enabled);
+
+			if (luaL_dostring(cfg->lua_state, lua_script) != 0) {
+				msg_err_config(
+					"cannot execute lua script for languages "
+					"extraction: %s",
+					lua_tostring(cfg->lua_state, -1));
 			}
 			else {
-				if (lua_type (cfg->lua_state, -1) == LUA_TFUNCTION) {
+				if (lua_type(cfg->lua_state, -1) == LUA_TFUNCTION) {
 					bk->enable_languages = TRUE;
-					bk->cbref_language = luaL_ref (cfg->lua_state,
-							LUA_REGISTRYINDEX);
+					bk->cbref_language = luaL_ref(cfg->lua_state,
+												  LUA_REGISTRYINDEX);
 				}
 				else {
-					msg_err_config ("lua script must return "
-							"function(task) and not %s",
-							lua_typename (cfg->lua_state,
-									lua_type (cfg->lua_state, -1)));
+					msg_err_config("lua script must return "
+								   "function(task) and not %s",
+								   lua_typename(cfg->lua_state,
+												lua_type(cfg->lua_state, -1)));
 				}
 			}
 		}
@@ -628,46 +470,45 @@ rspamd_sqlite3_init (struct rspamd_stat_ctx *ctx,
 	}
 
 	if (bk->enable_languages) {
-		msg_info_config ("enable per language statistics for %s",
-				stf->symbol);
+		msg_info_config("enable per language statistics for %s",
+						stf->symbol);
 	}
 
 	if (bk->enable_users) {
-		msg_info_config ("enable per users statistics for %s",
-				stf->symbol);
+		msg_info_config("enable per users statistics for %s",
+						stf->symbol);
 	}
 
 
 	return (gpointer) bk;
 }
 
-void
-rspamd_sqlite3_close (gpointer p)
+void rspamd_sqlite3_close(gpointer p)
 {
 	struct rspamd_stat_sqlite3_db *bk = p;
 
 	if (bk->sqlite) {
 		if (bk->in_transaction) {
-			rspamd_sqlite3_run_prstmt (bk->pool, bk->sqlite, bk->prstmt,
-					RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+			rspamd_sqlite3_run_prstmt(bk->pool, bk->sqlite, bk->prstmt,
+									  RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
 		}
 
-		rspamd_sqlite3_close_prstmt (bk->sqlite, bk->prstmt);
-		sqlite3_close (bk->sqlite);
-		g_free (bk->fname);
-		g_free (bk);
+		rspamd_sqlite3_close_prstmt(bk->sqlite, bk->prstmt);
+		sqlite3_close(bk->sqlite);
+		g_free(bk->fname);
+		g_free(bk);
 	}
 }
 
 gpointer
-rspamd_sqlite3_runtime (struct rspamd_task *task,
-		struct rspamd_statfile_config *stcf, gboolean learn, gpointer p, gint _id)
+rspamd_sqlite3_runtime(struct rspamd_task *task,
+					   struct rspamd_statfile_config *stcf, gboolean learn, gpointer p, gint _id)
 {
 	struct rspamd_stat_sqlite3_rt *rt = NULL;
 	struct rspamd_stat_sqlite3_db *bk = p;
 
 	if (bk) {
-		rt = rspamd_mempool_alloc (task->task_pool, sizeof (*rt));
+		rt = rspamd_mempool_alloc(task->task_pool, sizeof(*rt));
 		rt->db = bk;
 		rt->task = task;
 		rt->user_id = -1;
@@ -679,9 +520,9 @@ rspamd_sqlite3_runtime (struct rspamd_task *task,
 }
 
 gboolean
-rspamd_sqlite3_process_tokens (struct rspamd_task *task,
-		GPtrArray *tokens,
-		gint id, gpointer p)
+rspamd_sqlite3_process_tokens(struct rspamd_task *task,
+							  GPtrArray *tokens,
+							  gint id, gpointer p)
 {
 	struct rspamd_stat_sqlite3_db *bk;
 	struct rspamd_stat_sqlite3_rt *rt = p;
@@ -689,13 +530,13 @@ rspamd_sqlite3_process_tokens (struct rspamd_task *task,
 	guint i;
 	rspamd_token_t *tok;
 
-	g_assert (p != NULL);
-	g_assert (tokens != NULL);
+	g_assert(p != NULL);
+	g_assert(tokens != NULL);
 
 	bk = rt->db;
 
-	for (i = 0; i < tokens->len; i ++) {
-		tok = g_ptr_array_index (tokens, i);
+	for (i = 0; i < tokens->len; i++) {
+		tok = g_ptr_array_index(tokens, i);
 
 		if (bk == NULL) {
 			/* Statfile is does not exist, so all values are zero */
@@ -704,14 +545,14 @@ rspamd_sqlite3_process_tokens (struct rspamd_task *task,
 		}
 
 		if (!bk->in_transaction) {
-			rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-					RSPAMD_STAT_BACKEND_TRANSACTION_START_DEF);
+			rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+									  RSPAMD_STAT_BACKEND_TRANSACTION_START_DEF);
 			bk->in_transaction = TRUE;
 		}
 
 		if (rt->user_id == -1) {
 			if (bk->enable_users) {
-				rt->user_id = rspamd_sqlite3_get_user (bk, task, FALSE);
+				rt->user_id = rspamd_sqlite3_get_user(bk, task, FALSE);
 			}
 			else {
 				rt->user_id = 0;
@@ -720,7 +561,7 @@ rspamd_sqlite3_process_tokens (struct rspamd_task *task,
 
 		if (rt->lang_id == -1) {
 			if (bk->enable_languages) {
-				rt->lang_id = rspamd_sqlite3_get_language (bk, task, FALSE);
+				rt->lang_id = rspamd_sqlite3_get_language(bk, task, FALSE);
 			}
 			else {
 				rt->lang_id = 0;
@@ -728,9 +569,9 @@ rspamd_sqlite3_process_tokens (struct rspamd_task *task,
 		}
 
 		if (bk->enable_languages || bk->enable_users) {
-			if (rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-					RSPAMD_STAT_BACKEND_GET_TOKEN_FULL,
-					tok->data, rt->user_id, rt->lang_id, &iv) == SQLITE_OK) {
+			if (rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+										  RSPAMD_STAT_BACKEND_GET_TOKEN_FULL,
+										  tok->data, rt->user_id, rt->lang_id, &iv) == SQLITE_OK) {
 				tok->values[id] = iv;
 			}
 			else {
@@ -738,9 +579,9 @@ rspamd_sqlite3_process_tokens (struct rspamd_task *task,
 			}
 		}
 		else {
-			if (rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-					RSPAMD_STAT_BACKEND_GET_TOKEN_SIMPLE,
-					tok->data, &iv) == SQLITE_OK) {
+			if (rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+										  RSPAMD_STAT_BACKEND_GET_TOKEN_SIMPLE,
+										  tok->data, &iv) == SQLITE_OK) {
 				tok->values[id] = iv;
 			}
 			else {
@@ -761,18 +602,18 @@ rspamd_sqlite3_process_tokens (struct rspamd_task *task,
 }
 
 gboolean
-rspamd_sqlite3_finalize_process (struct rspamd_task *task, gpointer runtime,
-		gpointer ctx)
+rspamd_sqlite3_finalize_process(struct rspamd_task *task, gpointer runtime,
+								gpointer ctx)
 {
 	struct rspamd_stat_sqlite3_rt *rt = runtime;
 	struct rspamd_stat_sqlite3_db *bk;
 
-	g_assert (rt != NULL);
+	g_assert(rt != NULL);
 	bk = rt->db;
 
 	if (bk->in_transaction) {
-		rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+		rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+								  RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
 		bk->in_transaction = FALSE;
 	}
 
@@ -783,8 +624,8 @@ rspamd_sqlite3_finalize_process (struct rspamd_task *task, gpointer runtime,
 }
 
 gboolean
-rspamd_sqlite3_learn_tokens (struct rspamd_task *task, GPtrArray *tokens,
-		gint id, gpointer p)
+rspamd_sqlite3_learn_tokens(struct rspamd_task *task, GPtrArray *tokens,
+							gint id, gpointer p)
 {
 	struct rspamd_stat_sqlite3_db *bk;
 	struct rspamd_stat_sqlite3_rt *rt = p;
@@ -792,27 +633,27 @@ rspamd_sqlite3_learn_tokens (struct rspamd_task *task, GPtrArray *tokens,
 	guint i;
 	rspamd_token_t *tok;
 
-	g_assert (tokens != NULL);
-	g_assert (p != NULL);
+	g_assert(tokens != NULL);
+	g_assert(p != NULL);
 
 	bk = rt->db;
 
 	for (i = 0; i < tokens->len; i++) {
-		tok = g_ptr_array_index (tokens, i);
+		tok = g_ptr_array_index(tokens, i);
 		if (bk == NULL) {
 			/* Statfile is does not exist, so all values are zero */
 			return FALSE;
 		}
 
 		if (!bk->in_transaction) {
-			rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-					RSPAMD_STAT_BACKEND_TRANSACTION_START_IM);
+			rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+									  RSPAMD_STAT_BACKEND_TRANSACTION_START_IM);
 			bk->in_transaction = TRUE;
 		}
 
 		if (rt->user_id == -1) {
 			if (bk->enable_users) {
-				rt->user_id = rspamd_sqlite3_get_user (bk, task, TRUE);
+				rt->user_id = rspamd_sqlite3_get_user(bk, task, TRUE);
 			}
 			else {
 				rt->user_id = 0;
@@ -821,7 +662,7 @@ rspamd_sqlite3_learn_tokens (struct rspamd_task *task, GPtrArray *tokens,
 
 		if (rt->lang_id == -1) {
 			if (bk->enable_languages) {
-				rt->lang_id = rspamd_sqlite3_get_language (bk, task, TRUE);
+				rt->lang_id = rspamd_sqlite3_get_language(bk, task, TRUE);
 			}
 			else {
 				rt->lang_id = 0;
@@ -830,11 +671,11 @@ rspamd_sqlite3_learn_tokens (struct rspamd_task *task, GPtrArray *tokens,
 
 		iv = tok->values[id];
 
-		if (rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_SET_TOKEN,
-				tok->data, rt->user_id, rt->lang_id, iv) != SQLITE_OK) {
-			rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-					RSPAMD_STAT_BACKEND_TRANSACTION_ROLLBACK);
+		if (rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+									  RSPAMD_STAT_BACKEND_SET_TOKEN,
+									  tok->data, rt->user_id, rt->lang_id, iv) != SQLITE_OK) {
+			rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+									  RSPAMD_STAT_BACKEND_TRANSACTION_ROLLBACK);
 			bk->in_transaction = FALSE;
 
 			return FALSE;
@@ -845,19 +686,19 @@ rspamd_sqlite3_learn_tokens (struct rspamd_task *task, GPtrArray *tokens,
 }
 
 gboolean
-rspamd_sqlite3_finalize_learn (struct rspamd_task *task, gpointer runtime,
-		gpointer ctx, GError **err)
+rspamd_sqlite3_finalize_learn(struct rspamd_task *task, gpointer runtime,
+							  gpointer ctx, GError **err)
 {
 	struct rspamd_stat_sqlite3_rt *rt = runtime;
 	struct rspamd_stat_sqlite3_db *bk;
 	gint wal_frames, wal_checkpointed, mode;
 
-	g_assert (rt != NULL);
+	g_assert(rt != NULL);
 	bk = rt->db;
 
 	if (bk->in_transaction) {
-		rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+		rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+								  RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
 		bk->in_transaction = FALSE;
 	}
 
@@ -870,17 +711,17 @@ rspamd_sqlite3_finalize_learn (struct rspamd_task *task, gpointer runtime,
 	mode = SQLITE_CHECKPOINT_FULL;
 #endif
 	/* Perform wal checkpoint (might be long) */
-	if (sqlite3_wal_checkpoint_v2 (bk->sqlite,
-			NULL,
-			mode,
-			&wal_frames,
-			&wal_checkpointed) != SQLITE_OK) {
-		msg_warn_task ("cannot commit checkpoint: %s",
-				sqlite3_errmsg (bk->sqlite));
-
-		g_set_error (err, rspamd_sqlite3_backend_quark (), 500,
-				"cannot commit checkpoint: %s",
-				sqlite3_errmsg (bk->sqlite));
+	if (sqlite3_wal_checkpoint_v2(bk->sqlite,
+								  NULL,
+								  mode,
+								  &wal_frames,
+								  &wal_checkpointed) != SQLITE_OK) {
+		msg_warn_task("cannot commit checkpoint: %s",
+					  sqlite3_errmsg(bk->sqlite));
+
+		g_set_error(err, rspamd_sqlite3_backend_quark(), 500,
+					"cannot commit checkpoint: %s",
+					sqlite3_errmsg(bk->sqlite));
 		return FALSE;
 	}
 #endif
@@ -889,98 +730,98 @@ rspamd_sqlite3_finalize_learn (struct rspamd_task *task, gpointer runtime,
 }
 
 gulong
-rspamd_sqlite3_total_learns (struct rspamd_task *task, gpointer runtime,
-		gpointer ctx)
+rspamd_sqlite3_total_learns(struct rspamd_task *task, gpointer runtime,
+							gpointer ctx)
 {
 	struct rspamd_stat_sqlite3_rt *rt = runtime;
 	struct rspamd_stat_sqlite3_db *bk;
 	guint64 res;
 
-	g_assert (rt != NULL);
+	g_assert(rt != NULL);
 	bk = rt->db;
-	rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
+	rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
 
 	return res;
 }
 
 gulong
-rspamd_sqlite3_inc_learns (struct rspamd_task *task, gpointer runtime,
-		gpointer ctx)
+rspamd_sqlite3_inc_learns(struct rspamd_task *task, gpointer runtime,
+						  gpointer ctx)
 {
 	struct rspamd_stat_sqlite3_rt *rt = runtime;
 	struct rspamd_stat_sqlite3_db *bk;
 	guint64 res;
 
-	g_assert (rt != NULL);
+	g_assert(rt != NULL);
 	bk = rt->db;
-	rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_INC_LEARNS_LANG,
-			rt->lang_id);
-	rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_INC_LEARNS_USER,
-			rt->user_id);
+	rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_INC_LEARNS_LANG,
+							  rt->lang_id);
+	rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_INC_LEARNS_USER,
+							  rt->user_id);
 
 	if (bk->in_transaction) {
-		rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+		rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+								  RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
 		bk->in_transaction = FALSE;
 	}
 
-	rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
+	rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
 
 	return res;
 }
 
 gulong
-rspamd_sqlite3_dec_learns (struct rspamd_task *task, gpointer runtime,
-		gpointer ctx)
+rspamd_sqlite3_dec_learns(struct rspamd_task *task, gpointer runtime,
+						  gpointer ctx)
 {
 	struct rspamd_stat_sqlite3_rt *rt = runtime;
 	struct rspamd_stat_sqlite3_db *bk;
 	guint64 res;
 
-	g_assert (rt != NULL);
+	g_assert(rt != NULL);
 	bk = rt->db;
-	rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_DEC_LEARNS_LANG,
-			rt->lang_id);
-	rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_DEC_LEARNS_USER,
-			rt->user_id);
+	rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_DEC_LEARNS_LANG,
+							  rt->lang_id);
+	rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_DEC_LEARNS_USER,
+							  rt->user_id);
 
 	if (bk->in_transaction) {
-		rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+		rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+								  RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
 		bk->in_transaction = FALSE;
 	}
 
-	rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
+	rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
 
 	return res;
 }
 
 gulong
-rspamd_sqlite3_learns (struct rspamd_task *task, gpointer runtime,
-		gpointer ctx)
+rspamd_sqlite3_learns(struct rspamd_task *task, gpointer runtime,
+					  gpointer ctx)
 {
 	struct rspamd_stat_sqlite3_rt *rt = runtime;
 	struct rspamd_stat_sqlite3_db *bk;
 	guint64 res;
 
-	g_assert (rt != NULL);
+	g_assert(rt != NULL);
 	bk = rt->db;
-	rspamd_sqlite3_run_prstmt (task->task_pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
+	rspamd_sqlite3_run_prstmt(task->task_pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
 
 	return res;
 }
 
 ucl_object_t *
-rspamd_sqlite3_get_stat (gpointer runtime,
-		gpointer ctx)
+rspamd_sqlite3_get_stat(gpointer runtime,
+						gpointer ctx)
 {
 	ucl_object_t *res = NULL;
 	struct rspamd_stat_sqlite3_rt *rt = runtime;
@@ -989,73 +830,73 @@ rspamd_sqlite3_get_stat (gpointer runtime,
 	struct stat st;
 	gint64 rev;
 
-	g_assert (rt != NULL);
+	g_assert(rt != NULL);
 	bk = rt->db;
 	pool = bk->pool;
 
-	(void)stat (bk->fname, &st);
-	rspamd_sqlite3_run_prstmt (pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_GET_LEARNS, &rev);
-
-	res = ucl_object_typed_new (UCL_OBJECT);
-	ucl_object_insert_key (res, ucl_object_fromint (rev), "revision",
-			0, false);
-	ucl_object_insert_key (res, ucl_object_fromint (st.st_size), "size",
-			0, false);
-	rspamd_sqlite3_run_prstmt (pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_NTOKENS, &rev);
-	ucl_object_insert_key (res, ucl_object_fromint (rev), "total", 0, false);
-	ucl_object_insert_key (res, ucl_object_fromint (rev), "used", 0, false);
-	ucl_object_insert_key (res, ucl_object_fromstring (rt->cf->symbol),
-			"symbol", 0, false);
-	ucl_object_insert_key (res, ucl_object_fromstring ("sqlite3"),
-			"type", 0, false);
-	rspamd_sqlite3_run_prstmt (pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_NLANGUAGES, &rev);
-	ucl_object_insert_key (res, ucl_object_fromint (rev),
-			"languages", 0, false);
-	rspamd_sqlite3_run_prstmt (pool, bk->sqlite, bk->prstmt,
-			RSPAMD_STAT_BACKEND_NUSERS, &rev);
-	ucl_object_insert_key (res, ucl_object_fromint (rev),
-			"users", 0, false);
+	(void) stat(bk->fname, &st);
+	rspamd_sqlite3_run_prstmt(pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_GET_LEARNS, &rev);
+
+	res = ucl_object_typed_new(UCL_OBJECT);
+	ucl_object_insert_key(res, ucl_object_fromint(rev), "revision",
+						  0, false);
+	ucl_object_insert_key(res, ucl_object_fromint(st.st_size), "size",
+						  0, false);
+	rspamd_sqlite3_run_prstmt(pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_NTOKENS, &rev);
+	ucl_object_insert_key(res, ucl_object_fromint(rev), "total", 0, false);
+	ucl_object_insert_key(res, ucl_object_fromint(rev), "used", 0, false);
+	ucl_object_insert_key(res, ucl_object_fromstring(rt->cf->symbol),
+						  "symbol", 0, false);
+	ucl_object_insert_key(res, ucl_object_fromstring("sqlite3"),
+						  "type", 0, false);
+	rspamd_sqlite3_run_prstmt(pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_NLANGUAGES, &rev);
+	ucl_object_insert_key(res, ucl_object_fromint(rev),
+						  "languages", 0, false);
+	rspamd_sqlite3_run_prstmt(pool, bk->sqlite, bk->prstmt,
+							  RSPAMD_STAT_BACKEND_NUSERS, &rev);
+	ucl_object_insert_key(res, ucl_object_fromint(rev),
+						  "users", 0, false);
 
 	if (rt->cf->label) {
-		ucl_object_insert_key (res, ucl_object_fromstring (rt->cf->label),
-				"label", 0, false);
+		ucl_object_insert_key(res, ucl_object_fromstring(rt->cf->label),
+							  "label", 0, false);
 	}
 
 	return res;
 }
 
 gpointer
-rspamd_sqlite3_load_tokenizer_config (gpointer runtime,
-		gsize *len)
+rspamd_sqlite3_load_tokenizer_config(gpointer runtime,
+									 gsize *len)
 {
 	gpointer tk_conf, copied_conf;
 	guint64 sz;
 	struct rspamd_stat_sqlite3_rt *rt = runtime;
 	struct rspamd_stat_sqlite3_db *bk;
 
-	g_assert (rt != NULL);
+	g_assert(rt != NULL);
 	bk = rt->db;
 
-	g_assert (rspamd_sqlite3_run_prstmt (rt->db->pool, bk->sqlite, bk->prstmt,
-				RSPAMD_STAT_BACKEND_LOAD_TOKENIZER, &sz, &tk_conf) == SQLITE_OK);
-	g_assert (sz > 0);
+	g_assert(rspamd_sqlite3_run_prstmt(rt->db->pool, bk->sqlite, bk->prstmt,
+									   RSPAMD_STAT_BACKEND_LOAD_TOKENIZER, &sz, &tk_conf) == SQLITE_OK);
+	g_assert(sz > 0);
 	/*
 	 * Here we can have either decoded or undecoded version of tokenizer config
 	 * XXX: dirty hack to check if we have osb magic here
 	 */
-	if (sz > 7 && memcmp (tk_conf, "osbtokv", 7) == 0) {
-		copied_conf = rspamd_mempool_alloc (rt->task->task_pool, sz);
-		memcpy (copied_conf, tk_conf, sz);
-		g_free (tk_conf);
+	if (sz > 7 && memcmp(tk_conf, "osbtokv", 7) == 0) {
+		copied_conf = rspamd_mempool_alloc(rt->task->task_pool, sz);
+		memcpy(copied_conf, tk_conf, sz);
+		g_free(tk_conf);
 	}
 	else {
 		/* Need to decode */
-		copied_conf = rspamd_decode_base32 (tk_conf, sz, len, RSPAMD_BASE32_DEFAULT);
-		g_free (tk_conf);
-		rspamd_mempool_add_destructor (rt->task->task_pool, g_free, copied_conf);
+		copied_conf = rspamd_decode_base32(tk_conf, sz, len, RSPAMD_BASE32_DEFAULT);
+		g_free(tk_conf);
+		rspamd_mempool_add_destructor(rt->task->task_pool, g_free, copied_conf);
 	}
 
 	if (len) {