6 files changed, 146 insertions, 146 deletions

diff --git a/src/libserver/fuzzy_backend/fuzzy_backend.c b/src/libserver/fuzzy_backend/fuzzy_backend.c
index 607a92e85..c18463618 100644
--- a/src/libserver/fuzzy_backend/fuzzy_backend.c
+++ b/src/libserver/fuzzy_backend/fuzzy_backend.c
@@ -35,18 +35,18 @@ static void rspamd_fuzzy_backend_check_sqlite(struct rspamd_fuzzy_backend *bk,
 											  rspamd_fuzzy_check_cb cb, void *ud,
 											  void *subr_ud);
 static void rspamd_fuzzy_backend_update_sqlite(struct rspamd_fuzzy_backend *bk,
-											   GArray *updates, const gchar *src,
+											   GArray *updates, const char *src,
 											   rspamd_fuzzy_update_cb cb, void *ud,
 											   void *subr_ud);
 static void rspamd_fuzzy_backend_count_sqlite(struct rspamd_fuzzy_backend *bk,
 											  rspamd_fuzzy_count_cb cb, void *ud,
 											  void *subr_ud);
 static void rspamd_fuzzy_backend_version_sqlite(struct rspamd_fuzzy_backend *bk,
-												const gchar *src,
+												const char *src,
 												rspamd_fuzzy_version_cb cb, void *ud,
 												void *subr_ud);
-static const gchar *rspamd_fuzzy_backend_id_sqlite(struct rspamd_fuzzy_backend *bk,
-												   void *subr_ud);
+static const char *rspamd_fuzzy_backend_id_sqlite(struct rspamd_fuzzy_backend *bk,
+												  void *subr_ud);
 static void rspamd_fuzzy_backend_expire_sqlite(struct rspamd_fuzzy_backend *bk,
 											   void *subr_ud);
 static void rspamd_fuzzy_backend_close_sqlite(struct rspamd_fuzzy_backend *bk,
@@ -61,17 +61,17 @@ struct rspamd_fuzzy_backend_subr {
 				  rspamd_fuzzy_check_cb cb, void *ud,
 				  void *subr_ud);
 	void (*update)(struct rspamd_fuzzy_backend *bk,
-				   GArray *updates, const gchar *src,
+				   GArray *updates, const char *src,
 				   rspamd_fuzzy_update_cb cb, void *ud,
 				   void *subr_ud);
 	void (*count)(struct rspamd_fuzzy_backend *bk,
 				  rspamd_fuzzy_count_cb cb, void *ud,
 				  void *subr_ud);
 	void (*version)(struct rspamd_fuzzy_backend *bk,
-					const gchar *src,
+					const char *src,
 					rspamd_fuzzy_version_cb cb, void *ud,
 					void *subr_ud);
-	const gchar *(*id)(struct rspamd_fuzzy_backend *bk, void *subr_ud);
+	const char *(*id)(struct rspamd_fuzzy_backend *bk, void *subr_ud);
 	void (*periodic)(struct rspamd_fuzzy_backend *bk, void *subr_ud);
 	void (*close)(struct rspamd_fuzzy_backend *bk, void *subr_ud);
 };
@@ -100,8 +100,8 @@ static const struct rspamd_fuzzy_backend_subr fuzzy_subrs[] = {
 
 struct rspamd_fuzzy_backend {
 	enum rspamd_fuzzy_backend_type type;
-	gdouble expire;
-	gdouble sync;
+	double expire;
+	double sync;
 	struct ev_loop *event_loop;
 	rspamd_fuzzy_periodic_cb periodic_cb;
 	void *periodic_ud;
@@ -153,17 +153,17 @@ rspamd_fuzzy_backend_check_sqlite(struct rspamd_fuzzy_backend *bk,
 
 static void
 rspamd_fuzzy_backend_update_sqlite(struct rspamd_fuzzy_backend *bk,
-								   GArray *updates, const gchar *src,
+								   GArray *updates, const char *src,
 								   rspamd_fuzzy_update_cb cb, void *ud,
 								   void *subr_ud)
 {
 	struct rspamd_fuzzy_backend_sqlite *sq = subr_ud;
 	gboolean success = FALSE;
-	guint i;
+	unsigned int i;
 	struct fuzzy_peer_cmd *io_cmd;
 	struct rspamd_fuzzy_cmd *cmd;
 	gpointer ptr;
-	guint nupdates = 0, nadded = 0, ndeleted = 0, nextended = 0, nignored = 0;
+	unsigned int nupdates = 0, nadded = 0, ndeleted = 0, nextended = 0, nignored = 0;
 
 	if (rspamd_fuzzy_backend_sqlite_prepare_update(sq, src)) {
 		for (i = 0; i < updates->len; i++) {
@@ -226,7 +226,7 @@ rspamd_fuzzy_backend_count_sqlite(struct rspamd_fuzzy_backend *bk,
 
 static void
 rspamd_fuzzy_backend_version_sqlite(struct rspamd_fuzzy_backend *bk,
-									const gchar *src,
+									const char *src,
 									rspamd_fuzzy_version_cb cb, void *ud,
 									void *subr_ud)
 {
@@ -240,7 +240,7 @@ rspamd_fuzzy_backend_version_sqlite(struct rspamd_fuzzy_backend *bk,
 	}
 }
 
-static const gchar *
+static const char *
 rspamd_fuzzy_backend_id_sqlite(struct rspamd_fuzzy_backend *bk,
 							   void *subr_ud)
 {
@@ -276,7 +276,7 @@ rspamd_fuzzy_backend_create(struct ev_loop *ev_base,
 	struct rspamd_fuzzy_backend *bk;
 	enum rspamd_fuzzy_backend_type type = RSPAMD_FUZZY_BACKEND_SQLITE;
 	const ucl_object_t *elt;
-	gdouble expire = DEFAULT_EXPIRE;
+	double expire = DEFAULT_EXPIRE;
 
 	if (config != NULL) {
 		elt = ucl_object_lookup(config, "backend");
@@ -328,10 +328,10 @@ void rspamd_fuzzy_backend_check(struct rspamd_fuzzy_backend *bk,
 	bk->subr->check(bk, cmd, cb, ud, bk->subr_ud);
 }
 
-static guint
+static unsigned int
 rspamd_fuzzy_digest_hash(gconstpointer key)
 {
-	guint ret;
+	unsigned int ret;
 
 	/* Distributed uniformly already */
 	memcpy(&ret, key, sizeof(ret));
@@ -352,8 +352,8 @@ rspamd_fuzzy_backend_deduplicate_queue(GArray *updates)
 										rspamd_fuzzy_digest_equal);
 	struct fuzzy_peer_cmd *io_cmd, *found;
 	struct rspamd_fuzzy_cmd *cmd;
-	guchar *digest;
-	guint i;
+	unsigned char *digest;
+	unsigned int i;
 
 	for (i = 0; i < updates->len; i++) {
 		io_cmd = &g_array_index(updates, struct fuzzy_peer_cmd, i);
@@ -428,7 +428,7 @@ rspamd_fuzzy_backend_deduplicate_queue(GArray *updates)
 }
 
 void rspamd_fuzzy_backend_process_updates(struct rspamd_fuzzy_backend *bk,
-										  GArray *updates, const gchar *src, rspamd_fuzzy_update_cb cb,
+										  GArray *updates, const char *src, rspamd_fuzzy_update_cb cb,
 										  void *ud)
 {
 	g_assert(bk != NULL);
@@ -454,7 +454,7 @@ void rspamd_fuzzy_backend_count(struct rspamd_fuzzy_backend *bk,
 
 
 void rspamd_fuzzy_backend_version(struct rspamd_fuzzy_backend *bk,
-								  const gchar *src,
+								  const char *src,
 								  rspamd_fuzzy_version_cb cb, void *ud)
 {
 	g_assert(bk != NULL);
@@ -462,7 +462,7 @@ void rspamd_fuzzy_backend_version(struct rspamd_fuzzy_backend *bk,
 	bk->subr->version(bk, src, cb, ud, bk->subr_ud);
 }
 
-const gchar *
+const char *
 rspamd_fuzzy_backend_id(struct rspamd_fuzzy_backend *bk)
 {
 	g_assert(bk != NULL);
@@ -495,7 +495,7 @@ static void
 rspamd_fuzzy_backend_periodic_cb(EV_P_ ev_timer *w, int revents)
 {
 	struct rspamd_fuzzy_backend *bk = (struct rspamd_fuzzy_backend *) w->data;
-	gdouble jittered;
+	double jittered;
 
 	jittered = rspamd_time_jitter(bk->sync, bk->sync / 2.0);
 	w->repeat = jittered;
@@ -504,11 +504,11 @@ rspamd_fuzzy_backend_periodic_cb(EV_P_ ev_timer *w, int revents)
 }
 
 void rspamd_fuzzy_backend_start_update(struct rspamd_fuzzy_backend *bk,
-									   gdouble timeout,
+									   double timeout,
 									   rspamd_fuzzy_periodic_cb cb,
 									   void *ud)
 {
-	gdouble jittered;
+	double jittered;
 
 	g_assert(bk != NULL);
 
@@ -553,7 +553,7 @@ rspamd_fuzzy_backend_event_base(struct rspamd_fuzzy_backend *backend)
 	return backend->event_loop;
 }
 
-gdouble
+double
 rspamd_fuzzy_backend_get_expire(struct rspamd_fuzzy_backend *backend)
 {
 	return backend->expire;
diff --git a/src/libserver/fuzzy_backend/fuzzy_backend.h b/src/libserver/fuzzy_backend/fuzzy_backend.h
index 11b60abb3..fe22d473e 100644
--- a/src/libserver/fuzzy_backend/fuzzy_backend.h
+++ b/src/libserver/fuzzy_backend/fuzzy_backend.h
@@ -33,10 +33,10 @@ struct rspamd_config;
 typedef void (*rspamd_fuzzy_check_cb)(struct rspamd_fuzzy_reply *rep, void *ud);
 
 typedef void (*rspamd_fuzzy_update_cb)(gboolean success,
-									   guint nadded,
-									   guint ndeleted,
-									   guint nextended,
-									   guint nignored,
+									   unsigned int nadded,
+									   unsigned int ndeleted,
+									   unsigned int nextended,
+									   unsigned int nignored,
 									   void *ud);
 
 typedef void (*rspamd_fuzzy_version_cb)(uint64_t rev, void *ud);
@@ -75,7 +75,7 @@ void rspamd_fuzzy_backend_check(struct rspamd_fuzzy_backend *bk,
  * @param src
  */
 void rspamd_fuzzy_backend_process_updates(struct rspamd_fuzzy_backend *bk,
-										  GArray *updates, const gchar *src, rspamd_fuzzy_update_cb cb,
+										  GArray *updates, const char *src, rspamd_fuzzy_update_cb cb,
 										  void *ud);
 
 /**
@@ -95,7 +95,7 @@ void rspamd_fuzzy_backend_count(struct rspamd_fuzzy_backend *bk,
  * @param ud
  */
 void rspamd_fuzzy_backend_version(struct rspamd_fuzzy_backend *bk,
-								  const gchar *src,
+								  const char *src,
 								  rspamd_fuzzy_version_cb cb, void *ud);
 
 /**
@@ -103,20 +103,20 @@ void rspamd_fuzzy_backend_version(struct rspamd_fuzzy_backend *bk,
  * @param backend
  * @return
  */
-const gchar *rspamd_fuzzy_backend_id(struct rspamd_fuzzy_backend *backend);
+const char *rspamd_fuzzy_backend_id(struct rspamd_fuzzy_backend *backend);
 
 /**
  * Starts expire process for the backend
  * @param backend
  */
 void rspamd_fuzzy_backend_start_update(struct rspamd_fuzzy_backend *backend,
-									   gdouble timeout,
+									   double timeout,
 									   rspamd_fuzzy_periodic_cb cb,
 									   void *ud);
 
 struct ev_loop *rspamd_fuzzy_backend_event_base(struct rspamd_fuzzy_backend *backend);
 
-gdouble rspamd_fuzzy_backend_get_expire(struct rspamd_fuzzy_backend *backend);
+double rspamd_fuzzy_backend_get_expire(struct rspamd_fuzzy_backend *backend);
 
 /**
  * Closes backend
diff --git a/src/libserver/fuzzy_backend/fuzzy_backend_redis.c b/src/libserver/fuzzy_backend/fuzzy_backend_redis.c
index e1f24dd1a..27c663070 100644
--- a/src/libserver/fuzzy_backend/fuzzy_backend_redis.c
+++ b/src/libserver/fuzzy_backend/fuzzy_backend_redis.c
@@ -51,14 +51,14 @@ INIT_LOG_MODULE(fuzzy_redis)
 
 struct rspamd_fuzzy_backend_redis {
 	lua_State *L;
-	const gchar *redis_object;
-	const gchar *username;
-	const gchar *password;
-	const gchar *dbname;
-	gchar *id;
+	const char *redis_object;
+	const char *username;
+	const char *password;
+	const char *dbname;
+	char *id;
 	struct rspamd_redis_pool *pool;
-	gdouble timeout;
-	gint conf_ref;
+	double timeout;
+	int conf_ref;
 	bool terminated;
 	ref_entry_t ref;
 };
@@ -80,12 +80,12 @@ struct rspamd_fuzzy_redis_session {
 	gboolean shingles_checked;
 
 	enum rspamd_fuzzy_redis_command command;
-	guint nargs;
+	unsigned int nargs;
 
-	guint nadded;
-	guint ndeleted;
-	guint nextended;
-	guint nignored;
+	unsigned int nadded;
+	unsigned int ndeleted;
+	unsigned int nextended;
+	unsigned int nignored;
 
 	union {
 		rspamd_fuzzy_check_cb cb_check;
@@ -95,15 +95,15 @@ struct rspamd_fuzzy_redis_session {
 	} callback;
 	void *cbdata;
 
-	gchar **argv;
+	char **argv;
 	gsize *argv_lens;
 	struct upstream *up;
-	guchar found_digest[rspamd_cryptobox_HASHBYTES];
+	unsigned char found_digest[rspamd_cryptobox_HASHBYTES];
 };
 
 static inline struct upstream_list *
 rspamd_redis_get_servers(struct rspamd_fuzzy_backend_redis *ctx,
-						 const gchar *what)
+						 const char *what)
 {
 	lua_State *L = ctx->L;
 	struct upstream_list *res = NULL;
@@ -117,7 +117,7 @@ rspamd_redis_get_servers(struct rspamd_fuzzy_backend_redis *ctx,
 	}
 	else {
 		struct lua_logger_trace tr;
-		gchar outbuf[8192];
+		char outbuf[8192];
 
 		memset(&tr, 0, sizeof(tr));
 		lua_logger_out_type(L, -2, outbuf, sizeof(outbuf) - 1, &tr,
@@ -135,7 +135,7 @@ rspamd_redis_get_servers(struct rspamd_fuzzy_backend_redis *ctx,
 static inline void
 rspamd_fuzzy_redis_session_free_args(struct rspamd_fuzzy_redis_session *session)
 {
-	guint i;
+	unsigned int i;
 
 	if (session->argv) {
 		for (i = 0; i < session->nargs; i++) {
@@ -190,10 +190,10 @@ rspamd_fuzzy_backend_init_redis(struct rspamd_fuzzy_backend *bk,
 	struct rspamd_fuzzy_backend_redis *backend;
 	const ucl_object_t *elt;
 	gboolean ret = FALSE;
-	guchar id_hash[rspamd_cryptobox_HASHBYTES];
+	unsigned char id_hash[rspamd_cryptobox_HASHBYTES];
 	rspamd_cryptobox_hash_state_t st;
 	lua_State *L = (lua_State *) cfg->lua_state;
-	gint conf_ref = -1;
+	int conf_ref = -1;
 
 	backend = g_malloc0(sizeof(*backend));
 
@@ -328,11 +328,11 @@ static void rspamd_fuzzy_redis_check_callback(redisAsyncContext *c, gpointer r,
 											  gpointer priv);
 
 struct _rspamd_fuzzy_shingles_helper {
-	guchar digest[64];
-	guint found;
+	unsigned char digest[64];
+	unsigned int found;
 };
 
-static gint
+static int
 rspamd_fuzzy_backend_redis_shingles_cmp(const void *a, const void *b)
 {
 	const struct _rspamd_fuzzy_shingles_helper *sha = a,
@@ -350,7 +350,7 @@ rspamd_fuzzy_redis_shingles_callback(redisAsyncContext *c, gpointer r,
 	struct rspamd_fuzzy_reply rep;
 	GString *key;
 	struct _rspamd_fuzzy_shingles_helper *shingles, *prev = NULL, *sel = NULL;
-	guint i, found = 0, max_found = 0, cur_found = 0;
+	unsigned int i, found = 0, max_found = 0, cur_found = 0;
 
 	ev_timer_stop(session->event_loop, &session->timeout);
 	memset(&rep, 0, sizeof(rep));
@@ -413,7 +413,7 @@ rspamd_fuzzy_redis_shingles_callback(redisAsyncContext *c, gpointer r,
 					/* Prepare new check command */
 					rspamd_fuzzy_redis_session_free_args(session);
 					session->nargs = 5;
-					session->argv = g_malloc(sizeof(gchar *) * session->nargs);
+					session->argv = g_malloc(sizeof(char *) * session->nargs);
 					session->argv_lens = g_malloc(sizeof(gsize) * session->nargs);
 
 					key = g_string_new(session->backend->redis_object);
@@ -436,7 +436,7 @@ rspamd_fuzzy_redis_shingles_callback(redisAsyncContext *c, gpointer r,
 					if (redisAsyncCommandArgv(session->ctx,
 											  rspamd_fuzzy_redis_check_callback,
 											  session, session->nargs,
-											  (const gchar **) session->argv,
+											  (const char **) session->argv,
 											  session->argv_lens) != REDIS_OK) {
 
 						if (session->callback.cb_check) {
@@ -489,12 +489,12 @@ rspamd_fuzzy_backend_check_shingles(struct rspamd_fuzzy_redis_session *session)
 	struct rspamd_fuzzy_reply rep;
 	const struct rspamd_fuzzy_shingle_cmd *shcmd;
 	GString *key;
-	guint i, init_len;
+	unsigned int i, init_len;
 
 	rspamd_fuzzy_redis_session_free_args(session);
 	/* First of all check digest */
 	session->nargs = RSPAMD_SHINGLE_SIZE + 1;
-	session->argv = g_malloc(sizeof(gchar *) * session->nargs);
+	session->argv = g_malloc(sizeof(char *) * session->nargs);
 	session->argv_lens = g_malloc(sizeof(gsize) * session->nargs);
 	shcmd = (const struct rspamd_fuzzy_shingle_cmd *) session->cmd;
 
@@ -518,7 +518,7 @@ rspamd_fuzzy_backend_check_shingles(struct rspamd_fuzzy_redis_session *session)
 
 	if (redisAsyncCommandArgv(session->ctx, rspamd_fuzzy_redis_shingles_callback,
 							  session, session->nargs,
-							  (const gchar **) session->argv, session->argv_lens) != REDIS_OK) {
+							  (const char **) session->argv, session->argv_lens) != REDIS_OK) {
 		msg_err("cannot execute redis command on %s: %s",
 				rspamd_inet_address_to_string_pretty(rspamd_upstream_addr_cur(session->up)),
 				session->ctx->errstr);
@@ -549,7 +549,7 @@ rspamd_fuzzy_redis_check_callback(redisAsyncContext *c, gpointer r,
 	redisReply *reply = r, *cur;
 	struct rspamd_fuzzy_reply rep;
 	gulong value;
-	guint found_elts = 0;
+	unsigned int found_elts = 0;
 
 	ev_timer_stop(session->event_loop, &session->timeout);
 	memset(&rep, 0, sizeof(rep));
@@ -669,7 +669,7 @@ void rspamd_fuzzy_backend_check_redis(struct rspamd_fuzzy_backend *bk,
 
 	/* First of all check digest */
 	session->nargs = 5;
-	session->argv = g_malloc(sizeof(gchar *) * session->nargs);
+	session->argv = g_malloc(sizeof(char *) * session->nargs);
 	session->argv_lens = g_malloc(sizeof(gsize) * session->nargs);
 
 	key = g_string_new(backend->redis_object);
@@ -712,7 +712,7 @@ void rspamd_fuzzy_backend_check_redis(struct rspamd_fuzzy_backend *bk,
 	else {
 		if (redisAsyncCommandArgv(session->ctx, rspamd_fuzzy_redis_check_callback,
 								  session, session->nargs,
-								  (const gchar **) session->argv, session->argv_lens) != REDIS_OK) {
+								  (const char **) session->argv, session->argv_lens) != REDIS_OK) {
 			rspamd_fuzzy_redis_session_dtor(session, TRUE);
 
 			if (cb) {
@@ -815,7 +815,7 @@ void rspamd_fuzzy_backend_count_redis(struct rspamd_fuzzy_backend *bk,
 	session->event_loop = rspamd_fuzzy_backend_event_base(bk);
 
 	session->nargs = 2;
-	session->argv = g_malloc(sizeof(gchar *) * 2);
+	session->argv = g_malloc(sizeof(char *) * 2);
 	session->argv_lens = g_malloc(sizeof(gsize) * 2);
 	key = g_string_new(backend->redis_object);
 	g_string_append(key, "_count");
@@ -850,7 +850,7 @@ void rspamd_fuzzy_backend_count_redis(struct rspamd_fuzzy_backend *bk,
 	else {
 		if (redisAsyncCommandArgv(session->ctx, rspamd_fuzzy_redis_count_callback,
 								  session, session->nargs,
-								  (const gchar **) session->argv, session->argv_lens) != REDIS_OK) {
+								  (const char **) session->argv, session->argv_lens) != REDIS_OK) {
 			rspamd_fuzzy_redis_session_dtor(session, TRUE);
 
 			if (cb) {
@@ -921,7 +921,7 @@ rspamd_fuzzy_redis_version_callback(redisAsyncContext *c, gpointer r,
 }
 
 void rspamd_fuzzy_backend_version_redis(struct rspamd_fuzzy_backend *bk,
-										const gchar *src,
+										const char *src,
 										rspamd_fuzzy_version_cb cb, void *ud,
 										void *subr_ud)
 {
@@ -953,7 +953,7 @@ void rspamd_fuzzy_backend_version_redis(struct rspamd_fuzzy_backend *bk,
 	session->event_loop = rspamd_fuzzy_backend_event_base(bk);
 
 	session->nargs = 2;
-	session->argv = g_malloc(sizeof(gchar *) * 2);
+	session->argv = g_malloc(sizeof(char *) * 2);
 	session->argv_lens = g_malloc(sizeof(gsize) * 2);
 	key = g_string_new(backend->redis_object);
 	g_string_append(key, src);
@@ -988,7 +988,7 @@ void rspamd_fuzzy_backend_version_redis(struct rspamd_fuzzy_backend *bk,
 	else {
 		if (redisAsyncCommandArgv(session->ctx, rspamd_fuzzy_redis_version_callback,
 								  session, session->nargs,
-								  (const gchar **) session->argv, session->argv_lens) != REDIS_OK) {
+								  (const char **) session->argv, session->argv_lens) != REDIS_OK) {
 			rspamd_fuzzy_redis_session_dtor(session, TRUE);
 
 			if (cb) {
@@ -1007,7 +1007,7 @@ void rspamd_fuzzy_backend_version_redis(struct rspamd_fuzzy_backend *bk,
 	}
 }
 
-const gchar *
+const char *
 rspamd_fuzzy_backend_id_redis(struct rspamd_fuzzy_backend *bk,
 							  void *subr_ud)
 {
@@ -1028,11 +1028,11 @@ void rspamd_fuzzy_backend_expire_redis(struct rspamd_fuzzy_backend *bk,
 static gboolean
 rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 								   struct rspamd_fuzzy_redis_session *session,
-								   struct fuzzy_peer_cmd *io_cmd, guint *shift)
+								   struct fuzzy_peer_cmd *io_cmd, unsigned int *shift)
 {
 	GString *key, *value;
-	guint cur_shift = *shift;
-	guint i, klen;
+	unsigned int cur_shift = *shift;
+	unsigned int i, klen;
 	struct rspamd_fuzzy_cmd *cmd;
 
 	if (io_cmd->is_shingle) {
@@ -1081,7 +1081,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  4,
-								  (const gchar **) &session->argv[cur_shift - 4],
+								  (const char **) &session->argv[cur_shift - 4],
 								  &session->argv_lens[cur_shift - 4]) != REDIS_OK) {
 
 			return FALSE;
@@ -1108,7 +1108,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  4,
-								  (const gchar **) &session->argv[cur_shift - 4],
+								  (const char **) &session->argv[cur_shift - 4],
 								  &session->argv_lens[cur_shift - 4]) != REDIS_OK) {
 
 			return FALSE;
@@ -1133,7 +1133,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  4,
-								  (const gchar **) &session->argv[cur_shift - 4],
+								  (const char **) &session->argv[cur_shift - 4],
 								  &session->argv_lens[cur_shift - 4]) != REDIS_OK) {
 
 			return FALSE;
@@ -1145,7 +1145,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 		g_string_append_len(key, cmd->digest, sizeof(cmd->digest));
 		value = g_string_sized_new(sizeof("4294967296"));
 		rspamd_printf_gstring(value, "%d",
-							  (gint) rspamd_fuzzy_backend_get_expire(bk));
+							  (int) rspamd_fuzzy_backend_get_expire(bk));
 		session->argv[cur_shift] = g_strdup("EXPIRE");
 		session->argv_lens[cur_shift++] = sizeof("EXPIRE") - 1;
 		session->argv[cur_shift] = key->str;
@@ -1157,7 +1157,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  3,
-								  (const gchar **) &session->argv[cur_shift - 3],
+								  (const char **) &session->argv[cur_shift - 3],
 								  &session->argv_lens[cur_shift - 3]) != REDIS_OK) {
 
 			return FALSE;
@@ -1175,7 +1175,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  2,
-								  (const gchar **) &session->argv[cur_shift - 2],
+								  (const char **) &session->argv[cur_shift - 2],
 								  &session->argv_lens[cur_shift - 2]) != REDIS_OK) {
 
 			return FALSE;
@@ -1197,7 +1197,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  2,
-								  (const gchar **) &session->argv[cur_shift - 2],
+								  (const char **) &session->argv[cur_shift - 2],
 								  &session->argv_lens[cur_shift - 2]) != REDIS_OK) {
 
 			return FALSE;
@@ -1215,7 +1215,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  2,
-								  (const gchar **) &session->argv[cur_shift - 2],
+								  (const char **) &session->argv[cur_shift - 2],
 								  &session->argv_lens[cur_shift - 2]) != REDIS_OK) {
 
 			return FALSE;
@@ -1237,7 +1237,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 		g_string_append_len(key, cmd->digest, sizeof(cmd->digest));
 		value = g_string_sized_new(sizeof("4294967296"));
 		rspamd_printf_gstring(value, "%d",
-							  (gint) rspamd_fuzzy_backend_get_expire(bk));
+							  (int) rspamd_fuzzy_backend_get_expire(bk));
 		session->argv[cur_shift] = g_strdup("EXPIRE");
 		session->argv_lens[cur_shift++] = sizeof("EXPIRE") - 1;
 		session->argv[cur_shift] = key->str;
@@ -1249,7 +1249,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  3,
-								  (const gchar **) &session->argv[cur_shift - 3],
+								  (const char **) &session->argv[cur_shift - 3],
 								  &session->argv_lens[cur_shift - 3]) != REDIS_OK) {
 
 			return FALSE;
@@ -1268,7 +1268,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 				   64 + 1;
 
 			for (i = 0; i < RSPAMD_SHINGLE_SIZE; i++) {
-				guchar *hval;
+				unsigned char *hval;
 				/*
 				 * For each command with shingles we additionally emit 32 commands:
 				 * SETEX <prefix>_<number>_<value> <expire> <digest>
@@ -1282,7 +1282,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 									  io_cmd->cmd.shingle.sgl.hashes[i]);
 				value = g_string_sized_new(sizeof("4294967296"));
 				rspamd_printf_gstring(value, "%d",
-									  (gint) rspamd_fuzzy_backend_get_expire(bk));
+									  (int) rspamd_fuzzy_backend_get_expire(bk));
 				hval = g_malloc(sizeof(io_cmd->cmd.shingle.basic.digest));
 				memcpy(hval, io_cmd->cmd.shingle.basic.digest,
 					   sizeof(io_cmd->cmd.shingle.basic.digest));
@@ -1299,7 +1299,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 				if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 										  4,
-										  (const gchar **) &session->argv[cur_shift - 4],
+										  (const char **) &session->argv[cur_shift - 4],
 										  &session->argv_lens[cur_shift - 4]) != REDIS_OK) {
 
 					return FALSE;
@@ -1324,7 +1324,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 				if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 										  2,
-										  (const gchar **) &session->argv[cur_shift - 2],
+										  (const char **) &session->argv[cur_shift - 2],
 										  &session->argv_lens[cur_shift - 2]) != REDIS_OK) {
 
 					return FALSE;
@@ -1349,7 +1349,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 									  io_cmd->cmd.shingle.sgl.hashes[i]);
 				value = g_string_sized_new(sizeof("18446744073709551616"));
 				rspamd_printf_gstring(value, "%d",
-									  (gint) rspamd_fuzzy_backend_get_expire(bk));
+									  (int) rspamd_fuzzy_backend_get_expire(bk));
 				session->argv[cur_shift] = g_strdup("EXPIRE");
 				session->argv_lens[cur_shift++] = sizeof("EXPIRE") - 1;
 				session->argv[cur_shift] = key->str;
@@ -1361,7 +1361,7 @@ rspamd_fuzzy_update_append_command(struct rspamd_fuzzy_backend *bk,
 
 				if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 										  3,
-										  (const gchar **) &session->argv[cur_shift - 3],
+										  (const char **) &session->argv[cur_shift - 3],
 										  &session->argv_lens[cur_shift - 3]) != REDIS_OK) {
 
 					return FALSE;
@@ -1431,7 +1431,7 @@ rspamd_fuzzy_redis_update_callback(redisAsyncContext *c, gpointer r,
 }
 
 void rspamd_fuzzy_backend_update_redis(struct rspamd_fuzzy_backend *bk,
-									   GArray *updates, const gchar *src,
+									   GArray *updates, const char *src,
 									   rspamd_fuzzy_update_cb cb, void *ud,
 									   void *subr_ud)
 {
@@ -1440,11 +1440,11 @@ void rspamd_fuzzy_backend_update_redis(struct rspamd_fuzzy_backend *bk,
 	struct upstream *up;
 	struct upstream_list *ups;
 	rspamd_inet_addr_t *addr;
-	guint i;
+	unsigned int i;
 	GString *key;
 	struct fuzzy_peer_cmd *io_cmd;
 	struct rspamd_fuzzy_cmd *cmd = NULL;
-	guint nargs, cur_shift;
+	unsigned int nargs, cur_shift;
 
 	g_assert(backend != NULL);
 
@@ -1532,7 +1532,7 @@ void rspamd_fuzzy_backend_update_redis(struct rspamd_fuzzy_backend *bk,
 
 	/* First of all check digest */
 	session->nargs = nargs;
-	session->argv = g_malloc0(sizeof(gchar *) * session->nargs);
+	session->argv = g_malloc0(sizeof(char *) * session->nargs);
 	session->argv_lens = g_malloc0(sizeof(gsize) * session->nargs);
 
 	up = rspamd_upstream_get(ups,
@@ -1564,7 +1564,7 @@ void rspamd_fuzzy_backend_update_redis(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  1,
-								  (const gchar **) session->argv,
+								  (const char **) session->argv,
 								  session->argv_lens) != REDIS_OK) {
 
 			if (cb) {
@@ -1603,7 +1603,7 @@ void rspamd_fuzzy_backend_update_redis(struct rspamd_fuzzy_backend *bk,
 
 		if (redisAsyncCommandArgv(session->ctx, NULL, NULL,
 								  2,
-								  (const gchar **) &session->argv[cur_shift - 2],
+								  (const char **) &session->argv[cur_shift - 2],
 								  &session->argv_lens[cur_shift - 2]) != REDIS_OK) {
 
 			if (cb) {
@@ -1621,7 +1621,7 @@ void rspamd_fuzzy_backend_update_redis(struct rspamd_fuzzy_backend *bk,
 		if (redisAsyncCommandArgv(session->ctx,
 								  rspamd_fuzzy_redis_update_callback, session,
 								  1,
-								  (const gchar **) &session->argv[cur_shift],
+								  (const char **) &session->argv[cur_shift],
 								  &session->argv_lens[cur_shift]) != REDIS_OK) {
 
 			if (cb) {
diff --git a/src/libserver/fuzzy_backend/fuzzy_backend_redis.h b/src/libserver/fuzzy_backend/fuzzy_backend_redis.h
index 3cfa16259..afeb1c573 100644
--- a/src/libserver/fuzzy_backend/fuzzy_backend_redis.h
+++ b/src/libserver/fuzzy_backend/fuzzy_backend_redis.h
@@ -38,7 +38,7 @@ void rspamd_fuzzy_backend_check_redis(struct rspamd_fuzzy_backend *bk,
 									  void *subr_ud);
 
 void rspamd_fuzzy_backend_update_redis(struct rspamd_fuzzy_backend *bk,
-									   GArray *updates, const gchar *src,
+									   GArray *updates, const char *src,
 									   rspamd_fuzzy_update_cb cb, void *ud,
 									   void *subr_ud);
 
@@ -47,12 +47,12 @@ void rspamd_fuzzy_backend_count_redis(struct rspamd_fuzzy_backend *bk,
 									  void *subr_ud);
 
 void rspamd_fuzzy_backend_version_redis(struct rspamd_fuzzy_backend *bk,
-										const gchar *src,
+										const char *src,
 										rspamd_fuzzy_version_cb cb, void *ud,
 										void *subr_ud);
 
-const gchar *rspamd_fuzzy_backend_id_redis(struct rspamd_fuzzy_backend *bk,
-										   void *subr_ud);
+const char *rspamd_fuzzy_backend_id_redis(struct rspamd_fuzzy_backend *bk,
+										  void *subr_ud);
 
 void rspamd_fuzzy_backend_expire_redis(struct rspamd_fuzzy_backend *bk,
 									   void *subr_ud);
diff --git a/src/libserver/fuzzy_backend/fuzzy_backend_sqlite.c b/src/libserver/fuzzy_backend/fuzzy_backend_sqlite.c
index df91c65b0..8ba625446 100644
--- a/src/libserver/fuzzy_backend/fuzzy_backend_sqlite.c
+++ b/src/libserver/fuzzy_backend/fuzzy_backend_sqlite.c
@@ -25,14 +25,14 @@
 struct rspamd_fuzzy_backend_sqlite {
 	sqlite3 *db;
 	char *path;
-	gchar id[MEMPOOL_UID_LEN];
+	char id[MEMPOOL_UID_LEN];
 	gsize count;
 	gsize expired;
 	rspamd_mempool_t *pool;
 };
 
-static const gdouble sql_sleep_time = 0.1;
-static const guint max_retries = 10;
+static const double sql_sleep_time = 0.1;
+static const unsigned int max_retries = 10;
 
 #define msg_err_fuzzy_backend(...) rspamd_default_log_function(G_LOG_LEVEL_CRITICAL,                               \
 															   backend->pool->tag.tagname, backend->pool->tag.uid, \
@@ -107,10 +107,10 @@ enum rspamd_fuzzy_statement_idx {
 };
 static struct rspamd_fuzzy_stmts {
 	enum rspamd_fuzzy_statement_idx idx;
-	const gchar *sql;
-	const gchar *args;
+	const char *sql;
+	const char *args;
 	sqlite3_stmt *stmt;
-	gint result;
+	int result;
 } prepared_stmts[RSPAMD_FUZZY_BACKEND_MAX] =
 	{
 		{.idx = RSPAMD_FUZZY_BACKEND_TRANSACTION_START,
@@ -267,7 +267,7 @@ rspamd_fuzzy_backend_sqlite_run_stmt(struct rspamd_fuzzy_backend_sqlite *backend
 	sqlite3_stmt *stmt;
 	int i;
 	const char *argtypes;
-	guint retries = 0;
+	unsigned int retries = 0;
 	struct timespec ts;
 
 	if (idx < 0 || idx >= RSPAMD_FUZZY_BACKEND_MAX) {
@@ -306,7 +306,7 @@ rspamd_fuzzy_backend_sqlite_run_stmt(struct rspamd_fuzzy_backend_sqlite *backend
 			sqlite3_bind_int64(stmt, i + 1, va_arg(ap, int64_t));
 			break;
 		case 'S':
-			sqlite3_bind_int(stmt, i + 1, va_arg(ap, gint));
+			sqlite3_bind_int(stmt, i + 1, va_arg(ap, int));
 			break;
 		case 'D':
 			/* Special case for digests variable */
@@ -361,12 +361,12 @@ rspamd_fuzzy_backend_sqlite_close_stmts(struct rspamd_fuzzy_backend_sqlite *bk)
 }
 
 static gboolean
-rspamd_fuzzy_backend_sqlite_run_sql(const gchar *sql, struct rspamd_fuzzy_backend_sqlite *bk,
+rspamd_fuzzy_backend_sqlite_run_sql(const char *sql, struct rspamd_fuzzy_backend_sqlite *bk,
 									GError **err)
 {
-	guint retries = 0;
+	unsigned int retries = 0;
 	struct timespec ts;
-	gint ret;
+	int ret;
 
 	do {
 		ret = sqlite3_exec(bk->db, sql, NULL, NULL, NULL);
@@ -385,11 +385,11 @@ rspamd_fuzzy_backend_sqlite_run_sql(const gchar *sql, struct rspamd_fuzzy_backen
 }
 
 static struct rspamd_fuzzy_backend_sqlite *
-rspamd_fuzzy_backend_sqlite_open_db(const gchar *path, GError **err)
+rspamd_fuzzy_backend_sqlite_open_db(const char *path, GError **err)
 {
 	struct rspamd_fuzzy_backend_sqlite *bk;
 	rspamd_cryptobox_hash_state_t st;
-	guchar hash_out[rspamd_cryptobox_HASHBYTES];
+	unsigned char hash_out[rspamd_cryptobox_HASHBYTES];
 
 	g_assert(path != NULL);
 
@@ -424,7 +424,7 @@ rspamd_fuzzy_backend_sqlite_open_db(const gchar *path, GError **err)
 }
 
 struct rspamd_fuzzy_backend_sqlite *
-rspamd_fuzzy_backend_sqlite_open(const gchar *path,
+rspamd_fuzzy_backend_sqlite_open(const char *path,
 								 gboolean vacuum,
 								 GError **err)
 {
@@ -451,7 +451,7 @@ rspamd_fuzzy_backend_sqlite_open(const gchar *path,
 	return backend;
 }
 
-static gint
+static int
 rspamd_fuzzy_backend_sqlite_int64_cmp(const void *a, const void *b)
 {
 	int64_t ia = *(int64_t *) a, ib = *(int64_t *) b;
@@ -605,9 +605,9 @@ rspamd_fuzzy_backend_sqlite_check(struct rspamd_fuzzy_backend_sqlite *backend,
 
 gboolean
 rspamd_fuzzy_backend_sqlite_prepare_update(struct rspamd_fuzzy_backend_sqlite *backend,
-										   const gchar *source)
+										   const char *source)
 {
-	gint rc;
+	int rc;
 
 	if (backend == NULL) {
 		return FALSE;
@@ -657,8 +657,8 @@ rspamd_fuzzy_backend_sqlite_add(struct rspamd_fuzzy_backend_sqlite *backend,
 			if (rc != SQLITE_OK) {
 				msg_warn_fuzzy_backend("cannot update hash to %d -> "
 									   "%*xs: %s",
-									   (gint) cmd->flag,
-									   (gint) sizeof(cmd->digest), cmd->digest,
+									   (int) cmd->flag,
+									   (int) sizeof(cmd->digest), cmd->digest,
 									   sqlite3_errmsg(backend->db));
 			}
 		}
@@ -674,8 +674,8 @@ rspamd_fuzzy_backend_sqlite_add(struct rspamd_fuzzy_backend_sqlite *backend,
 			if (rc != SQLITE_OK) {
 				msg_warn_fuzzy_backend("cannot update hash to %d -> "
 									   "%*xs: %s",
-									   (gint) cmd->flag,
-									   (gint) sizeof(cmd->digest), cmd->digest,
+									   (int) cmd->flag,
+									   (int) sizeof(cmd->digest), cmd->digest,
 									   sqlite3_errmsg(backend->db));
 			}
 		}
@@ -684,7 +684,7 @@ rspamd_fuzzy_backend_sqlite_add(struct rspamd_fuzzy_backend_sqlite *backend,
 		rspamd_fuzzy_backend_sqlite_cleanup_stmt(backend, RSPAMD_FUZZY_BACKEND_CHECK);
 		rc = rspamd_fuzzy_backend_sqlite_run_stmt(backend, FALSE,
 												  RSPAMD_FUZZY_BACKEND_INSERT,
-												  (gint) cmd->flag,
+												  (int) cmd->flag,
 												  cmd->digest,
 												  (int64_t) cmd->value);
 
@@ -715,8 +715,8 @@ rspamd_fuzzy_backend_sqlite_add(struct rspamd_fuzzy_backend_sqlite *backend,
 		else {
 			msg_warn_fuzzy_backend("cannot add hash to %d -> "
 								   "%*xs: %s",
-								   (gint) cmd->flag,
-								   (gint) sizeof(cmd->digest), cmd->digest,
+								   (int) cmd->flag,
+								   (int) sizeof(cmd->digest), cmd->digest,
 								   sqlite3_errmsg(backend->db));
 		}
 
@@ -729,9 +729,9 @@ rspamd_fuzzy_backend_sqlite_add(struct rspamd_fuzzy_backend_sqlite *backend,
 
 gboolean
 rspamd_fuzzy_backend_sqlite_finish_update(struct rspamd_fuzzy_backend_sqlite *backend,
-										  const gchar *source, gboolean version_bump)
+										  const char *source, gboolean version_bump)
 {
-	gint rc = SQLITE_OK, wal_frames, wal_checkpointed, ver;
+	int rc = SQLITE_OK, wal_frames, wal_checkpointed, ver;
 
 	/* Get and update version */
 	if (version_bump) {
@@ -800,8 +800,8 @@ rspamd_fuzzy_backend_sqlite_del(struct rspamd_fuzzy_backend_sqlite *backend,
 		if (rc != SQLITE_OK) {
 			msg_warn_fuzzy_backend("cannot update hash to %d -> "
 								   "%*xs: %s",
-								   (gint) cmd->flag,
-								   (gint) sizeof(cmd->digest), cmd->digest,
+								   (int) cmd->flag,
+								   (int) sizeof(cmd->digest), cmd->digest,
 								   sqlite3_errmsg(backend->db));
 		}
 	}
@@ -827,13 +827,13 @@ rspamd_fuzzy_backend_sqlite_sync(struct rspamd_fuzzy_backend_sqlite *backend,
 	const uint64_t max_changes = 5000;
 	gboolean ret = FALSE;
 	int64_t expire_lim, expired;
-	gint rc, i, orphaned_cnt = 0;
+	int rc, i, orphaned_cnt = 0;
 	GError *err = NULL;
-	static const gchar orphaned_shingles[] = "SELECT shingles.value,shingles.number "
-											 "FROM shingles "
-											 "LEFT JOIN digests ON "
-											 "shingles.digest_id=digests.id WHERE "
-											 "digests.id IS NULL;";
+	static const char orphaned_shingles[] = "SELECT shingles.value,shingles.number "
+											"FROM shingles "
+											"LEFT JOIN digests ON "
+											"shingles.digest_id=digests.id WHERE "
+											"digests.id IS NULL;";
 	sqlite3_stmt *stmt;
 	GArray *orphaned;
 	struct orphaned_shingle_elt orphaned_elt, *pelt;
@@ -925,7 +925,7 @@ rspamd_fuzzy_backend_sqlite_sync(struct rspamd_fuzzy_backend_sqlite *backend,
 						"going to delete %ud orphaned shingles",
 						orphaned_cnt);
 					/* Need to delete orphaned elements */
-					for (i = 0; i < (gint) orphaned_cnt; i++) {
+					for (i = 0; i < (int) orphaned_cnt; i++) {
 						pelt = &g_array_index(orphaned,
 											  struct orphaned_shingle_elt,
 											  i);
@@ -999,10 +999,10 @@ gsize rspamd_fuzzy_backend_sqlite_count(struct rspamd_fuzzy_backend_sqlite *back
 	return 0;
 }
 
-gint rspamd_fuzzy_backend_sqlite_version(struct rspamd_fuzzy_backend_sqlite *backend,
-										 const gchar *source)
+int rspamd_fuzzy_backend_sqlite_version(struct rspamd_fuzzy_backend_sqlite *backend,
+										const char *source)
 {
-	gint ret = 0;
+	int ret = 0;
 
 	if (backend) {
 		if (rspamd_fuzzy_backend_sqlite_run_stmt(backend, FALSE,
@@ -1022,7 +1022,7 @@ gsize rspamd_fuzzy_backend_sqlite_expired(struct rspamd_fuzzy_backend_sqlite *ba
 	return backend != NULL ? backend->expired : 0;
 }
 
-const gchar *
+const char *
 rspamd_fuzzy_sqlite_backend_id(struct rspamd_fuzzy_backend_sqlite *backend)
 {
 	return backend != NULL ? backend->id : 0;
diff --git a/src/libserver/fuzzy_backend/fuzzy_backend_sqlite.h b/src/libserver/fuzzy_backend/fuzzy_backend_sqlite.h
index 62c028f3d..1ace52f35 100644
--- a/src/libserver/fuzzy_backend/fuzzy_backend_sqlite.h
+++ b/src/libserver/fuzzy_backend/fuzzy_backend_sqlite.h
@@ -31,7 +31,7 @@ struct rspamd_fuzzy_backend_sqlite;
  * @param err error pointer
  * @return backend structure or NULL
  */
-struct rspamd_fuzzy_backend_sqlite *rspamd_fuzzy_backend_sqlite_open(const gchar *path,
+struct rspamd_fuzzy_backend_sqlite *rspamd_fuzzy_backend_sqlite_open(const char *path,
 																	 gboolean vacuum,
 																	 GError **err);
 
@@ -50,7 +50,7 @@ struct rspamd_fuzzy_reply rspamd_fuzzy_backend_sqlite_check(
  * Prepare storage for updates (by starting transaction)
  */
 gboolean rspamd_fuzzy_backend_sqlite_prepare_update(struct rspamd_fuzzy_backend_sqlite *backend,
-													const gchar *source);
+													const char *source);
 
 /**
  * Add digest to the database
@@ -75,7 +75,7 @@ gboolean rspamd_fuzzy_backend_sqlite_del(
  * Commit updates to storage
  */
 gboolean rspamd_fuzzy_backend_sqlite_finish_update(struct rspamd_fuzzy_backend_sqlite *backend,
-												   const gchar *source, gboolean version_bump);
+												   const char *source, gboolean version_bump);
 
 /**
  * Sync storage
@@ -94,11 +94,11 @@ void rspamd_fuzzy_backend_sqlite_close(struct rspamd_fuzzy_backend_sqlite *backe
 
 gsize rspamd_fuzzy_backend_sqlite_count(struct rspamd_fuzzy_backend_sqlite *backend);
 
-gint rspamd_fuzzy_backend_sqlite_version(struct rspamd_fuzzy_backend_sqlite *backend, const gchar *source);
+int rspamd_fuzzy_backend_sqlite_version(struct rspamd_fuzzy_backend_sqlite *backend, const char *source);
 
 gsize rspamd_fuzzy_backend_sqlite_expired(struct rspamd_fuzzy_backend_sqlite *backend);
 
-const gchar *rspamd_fuzzy_sqlite_backend_id(struct rspamd_fuzzy_backend_sqlite *backend);
+const char *rspamd_fuzzy_sqlite_backend_id(struct rspamd_fuzzy_backend_sqlite *backend);
 
 #ifdef __cplusplus
 }