Merge branch 'strings-rework'

38 files changed, 435 insertions, 668 deletions

diff --git a/src/client/rspamc.c b/src/client/rspamc.c
index 8c2878ced..150c780a1 100644
--- a/src/client/rspamc.c
+++ b/src/client/rspamc.c
@@ -941,7 +941,7 @@ rspamc_mime_output (FILE *out, ucl_object_t *result, GString *input,
 		folded_symbuf = rspamd_header_value_fold ("X-Spam-Symbols",
 				symbuf->str,
 				0);
-		rspamd_printf_gstring (added_headers, "X-Spam-Symbols: %V\r\n",
+		rspamd_printf_gstring (added_headers, "X-Spam-Symbols: %v\r\n",
 				folded_symbuf);
 		g_string_free (folded_symbuf, TRUE);
 		g_string_free (symbuf, TRUE);
@@ -978,7 +978,8 @@ rspamc_mime_output (FILE *out, ucl_object_t *result, GString *input,
 	/* Write message */
 	if (rspamd_fprintf (out, "%*s", (gint)headers_pos, input->str)
 			== headers_pos) {
-		if (rspamd_fprintf (out, "%V", added_headers) == (gint)added_headers->len) {
+		if (rspamd_fprintf (out, "%v", added_headers)
+				== (gint)added_headers->len) {
 			rspamd_fprintf (out, "%s", input->str + headers_pos);
 		}
 	}
diff --git a/src/controller.c b/src/controller.c
index 6bee8cf57..c68cd1bdc 100644
--- a/src/controller.c
+++ b/src/controller.c
@@ -139,8 +139,8 @@ struct rspamd_controller_worker_ctx {
 	/* Privilleged password */
 	gchar *enable_password;
 	/* Cached versions of the passwords */
-	rspamd_fstring_t cached_password;
-	rspamd_fstring_t cached_enable_password;
+	rspamd_ftok_t cached_password;
+	rspamd_ftok_t cached_enable_password;
 	/* HTTP server */
 	struct rspamd_http_connection_router *http;
 	/* Server's start time */
@@ -261,7 +261,8 @@ rspamd_check_encrypted_password (struct rspamd_controller_worker_ctx *ctx,
 	gsize salt_len, key_len;
 	gboolean ret = TRUE;
 	guchar *local_key;
-	rspamd_fstring_t *cache;
+	rspamd_ftok_t *cache;
+	gpointer m;
 
 	/* First of all check cached versions to save resources */
 	if (is_enable && ctx->cached_enable_password.len != 0) {
@@ -332,11 +333,12 @@ rspamd_check_encrypted_password (struct rspamd_controller_worker_ctx *ctx,
 
 		if (cache->len == 0) {
 			/* Mmap region */
-			cache->begin = mmap (NULL, password->len, PROT_WRITE,
+			m = mmap (NULL, password->len, PROT_WRITE,
 					MAP_PRIVATE | MAP_ANON, -1, 0);
-			memcpy (cache->begin, password->str, password->len);
-			(void)mprotect (cache->begin, password->len, PROT_READ);
-			(void)mlock (cache->begin, password->len);
+			memcpy (m, password->str, password->len);
+			(void)mprotect (m, password->len, PROT_READ);
+			(void)mlock (m, password->len);
+			cache->begin = m;
 			cache->len = password->len;
 		}
 	}
@@ -1668,7 +1670,7 @@ rspamd_controller_handle_savemap (struct rspamd_http_connection_entry *conn_ent,
 
 	id = strtoul (idstr->str, &errstr, 10);
 	if (*errstr != '\0' && !g_ascii_isspace (*errstr)) {
-		msg_info_session ("invalid map id: %V", idstr);
+		msg_info_session ("invalid map id: %v", idstr);
 		rspamd_controller_send_error (conn_ent, 400, "Map id is invalid");
 		return 0;
 	}
@@ -1981,7 +1983,7 @@ rspamd_controller_handle_custom (struct rspamd_http_connection_entry *conn_ent,
 
 	cmd = g_hash_table_lookup (session->ctx->custom_commands, msg->url->str);
 	if (cmd == NULL || cmd->handler == NULL) {
-		msg_err_session ("custom command %V has not been found", msg->url);
+		msg_err_session ("custom command %v has not been found", msg->url);
 		rspamd_controller_send_error (conn_ent, 404, "No command associated");
 		return 0;
 	}
@@ -2386,6 +2388,7 @@ start_controller_worker (struct rspamd_worker *worker)
 	gpointer key, value;
 	struct rspamd_keypair_cache *cache;
 	gchar *secure_ip;
+	gpointer m;
 
 	ctx->ev_base = rspamd_prepare_worker (worker,
 			"controller",
@@ -2556,11 +2559,13 @@ start_controller_worker (struct rspamd_worker *worker)
 	}
 
 	if (ctx->cached_password.len > 0) {
-		munmap (ctx->cached_password.begin, ctx->cached_password.len);
+		m = (gpointer)ctx->cached_password.begin;
+		munmap (m, ctx->cached_password.len);
 	}
 
 	if (ctx->cached_enable_password.len > 0) {
-		munmap (ctx->cached_enable_password.begin, ctx->cached_enable_password.len);
+		m = (gpointer) ctx->cached_enable_password.begin;
+		munmap (m, ctx->cached_enable_password.len);
 	}
 
 	exit (EXIT_SUCCESS);
diff --git a/src/libmime/message.c b/src/libmime/message.c
index 3537f70c0..183b9bcee 100644
--- a/src/libmime/message.c
+++ b/src/libmime/message.c
@@ -112,8 +112,7 @@ parse_recv_header (rspamd_mempool_t * pool,
 		RSPAMD_RECV_STATE_PARSE_IP,
 		RSPAMD_RECV_STATE_SKIP_SPACES,
 		RSPAMD_RECV_STATE_ERROR
-	}                               state = RSPAMD_RECV_STATE_INIT,
-		next_state = RSPAMD_RECV_STATE_INIT;
+	} state = RSPAMD_RECV_STATE_INIT, next_state = RSPAMD_RECV_STATE_INIT;
 	gboolean is_exim = FALSE;
 
 	line = rh->decoded;
@@ -949,7 +948,7 @@ rspamd_normalize_text_part (struct rspamd_task *task,
 		struct mime_text_part *part)
 {
 	struct sb_stemmer *stem = NULL;
-	rspamd_fstring_t *w;
+	rspamd_ftok_t *w;
 	const guchar *r;
 	gchar *temp_word;
 	guint i, nlen;
@@ -971,7 +970,7 @@ rspamd_normalize_text_part (struct rspamd_task *task,
 
 	if (tmp) {
 		for (i = 0; i < tmp->len; i ++) {
-			w = &g_array_index (tmp, rspamd_fstring_t, i);
+			w = &g_array_index (tmp, rspamd_ftok_t, i);
 			if (stem) {
 				r = sb_stemmer_stem (stem, w->begin, w->len);
 			}
@@ -980,21 +979,23 @@ rspamd_normalize_text_part (struct rspamd_task *task,
 				if (stem != NULL && r != NULL) {
 					nlen = strlen (r);
 					nlen = MIN (nlen, w->len);
-					w->begin = rspamd_mempool_alloc (task->task_pool, nlen);
-					memcpy (w->begin, r, nlen);
+					temp_word = rspamd_mempool_alloc (task->task_pool, nlen);
+					memcpy (temp_word, r, nlen);
+					w->begin = temp_word;
 					w->len = nlen;
 				}
 				else {
-					temp_word = w->begin;
-					w->begin = rspamd_mempool_alloc (task->task_pool, w->len);
-					memcpy (w->begin, temp_word, w->len);
+					temp_word = rspamd_mempool_alloc (task->task_pool, w->len);
+					memcpy (temp_word, w->begin, w->len);
 
 					if (IS_PART_UTF (part)) {
-						rspamd_str_lc_utf8 (w->begin, w->len);
+						rspamd_str_lc_utf8 (temp_word, w->len);
 					}
 					else {
-						rspamd_str_lc (w->begin, w->len);
+						rspamd_str_lc (temp_word, w->len);
 					}
+
+					w->begin = temp_word;
 				}
 			}
 		}
@@ -1463,8 +1464,9 @@ rspamd_message_parse (struct rspamd_task *task)
 	guint tw, dw;
 
 	tmp = rspamd_mempool_alloc (task->task_pool, sizeof (GByteArray));
-	p = task->msg.start;
+	p = task->msg.begin;
 	len = task->msg.len;
+
 	/* Skip any space characters to avoid some bad messages to be unparsed */
 	while (g_ascii_isspace (*p) && len > 0) {
 		p ++;
diff --git a/src/libmime/mime_expressions.c b/src/libmime/mime_expressions.c
index 6581b7362..d5b38437d 100644
--- a/src/libmime/mime_expressions.c
+++ b/src/libmime/mime_expressions.c
@@ -125,6 +125,12 @@ struct rspamd_function_atom {
 	GArray *args;	/**< its args										*/
 };
 
+enum rspamd_mime_atom_type {
+	MIME_ATOM_REGEXP = 0,
+	MIME_ATOM_INTERNAL_FUNCTION,
+	MIME_ATOM_LUA_FUNCTION
+};
+
 struct rspamd_mime_atom {
 	gchar *str;
 	union {
@@ -132,11 +138,7 @@ struct rspamd_mime_atom {
 		struct rspamd_function_atom *func;
 		const gchar *lua_function;
 	} d;
-	enum {
-		MIME_ATOM_REGEXP = 0,
-		MIME_ATOM_INTERNAL_FUNCTION,
-		MIME_ATOM_LUA_FUNCTION
-	} type;
+	enum rspamd_mime_atom_type type;
 };
 
 /*
@@ -923,7 +925,7 @@ rspamd_mime_expr_process_regexp (struct rspamd_regexp_atom *re,
 		break;
 	case REGEXP_MESSAGE:
 		raw = TRUE;
-		ct = (guint8 *)task->msg.start;
+		ct = (guint8 *)task->msg.begin;
 		clen = task->msg.len;
 
 		ret = rspamd_mime_regexp_element_process (task, re, ct, clen, raw);
diff --git a/src/libmime/mime_expressions.h b/src/libmime/mime_expressions.h
index 41e8b33ac..834f1983f 100644
--- a/src/libmime/mime_expressions.h
+++ b/src/libmime/mime_expressions.h
@@ -16,12 +16,13 @@ extern const struct rspamd_atom_subr mime_expr_subr;
 /**
  * Function's argument
  */
+enum rspamd_expression_type {
+	EXPRESSION_ARGUMENT_NORMAL = 0,
+	EXPRESSION_ARGUMENT_BOOL,
+	EXPRESSION_ARGUMENT_REGEXP
+};
 struct expression_argument {
-	enum {
-		EXPRESSION_ARGUMENT_NORMAL = 0,
-		EXPRESSION_ARGUMENT_BOOL,
-		EXPRESSION_ARGUMENT_REGEXP
-	} type;                                                     /**< type of argument (text or other function)		*/
+	enum rspamd_expression_type type;                           /**< type of argument (text or other function)		*/
 	void *data;                                                 /**< pointer to its data							*/
 };
 
diff --git a/src/libmime/smtp_proto.c b/src/libmime/smtp_proto.c
index 988bd37af..05d5c43d5 100644
--- a/src/libmime/smtp_proto.c
+++ b/src/libmime/smtp_proto.c
@@ -57,7 +57,7 @@ make_smtp_error (rspamd_mempool_t *pool,
 
 gboolean
 parse_smtp_command (struct smtp_session *session,
-	rspamd_fstring_t *line,
+	rspamd_ftok_t *line,
 	struct smtp_command **cmd)
 {
 	enum {
@@ -66,9 +66,10 @@ parse_smtp_command (struct smtp_session *session,
 		SMTP_PARSE_ARGUMENT,
 		SMTP_PARSE_DONE
 	}                              state;
-	gchar *p, *c, ch, cmd_buf[4];
+	const gchar *p, *c;
+	gchar ch, cmd_buf[4];
 	guint i;
-	rspamd_fstring_t *arg = NULL;
+	rspamd_ftok_t *arg = NULL;
 	struct smtp_command *pcmd;
 
 	if (line->len == 0) {
@@ -176,8 +177,9 @@ parse_smtp_command (struct smtp_session *session,
 				}
 				arg->len = p - c;
 				arg->begin = rspamd_mempool_alloc (session->pool, arg->len);
-				memcpy (arg->begin, c, arg->len);
+				memcpy ((gchar *)arg->begin, c, arg->len);
 				pcmd->args = g_list_prepend (pcmd->args, arg);
+
 				if (ch == ' ' || ch == ':') {
 					state = SMTP_PARSE_SPACES;
 				}
@@ -209,10 +211,10 @@ end:
 }
 
 static gboolean
-check_smtp_path (rspamd_fstring_t *path)
+check_smtp_path (rspamd_ftok_t *path)
 {
 	guint i;
-	gchar *p;
+	const gchar *p;
 
 	p = path->begin;
 	if (*p != '<' || path->len < 2) {
@@ -230,7 +232,7 @@ check_smtp_path (rspamd_fstring_t *path)
 gboolean
 parse_smtp_helo (struct smtp_session *session, struct smtp_command *cmd)
 {
-	rspamd_fstring_t *arg;
+	rspamd_ftok_t *arg;
 
 	if (cmd->args == NULL) {
 		session->error = SMTP_ERROR_BAD_ARGUMENTS;
@@ -265,7 +267,7 @@ parse_smtp_helo (struct smtp_session *session, struct smtp_command *cmd)
 gboolean
 parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd)
 {
-	rspamd_fstring_t *arg;
+	rspamd_ftok_t *arg;
 	GList *cur = cmd->args;
 
 	if (cmd->args == NULL) {
@@ -303,7 +305,7 @@ parse_smtp_from (struct smtp_session *session, struct smtp_command *cmd)
 gboolean
 parse_smtp_rcpt (struct smtp_session *session, struct smtp_command *cmd)
 {
-	rspamd_fstring_t *arg;
+	rspamd_ftok_t *arg;
 	GList *cur = cmd->args;
 
 	if (cmd->args == NULL) {
@@ -339,9 +341,9 @@ parse_smtp_rcpt (struct smtp_session *session, struct smtp_command *cmd)
 
 /* Return -1 if there are some error, 1 if all is ok and 0 in case of incomplete reply */
 static gint
-check_smtp_ustream_reply (rspamd_fstring_t *in, gchar success_code)
+check_smtp_ustream_reply (rspamd_ftok_t *in, gchar success_code)
 {
-	gchar *p;
+	const gchar *p;
 
 	/* Check for 250 at the begin of line */
 	if (in->len >= sizeof ("220 ") - 1) {
@@ -368,11 +370,11 @@ smtp_upstream_write_list (GList *args, gchar *buf, size_t buflen)
 {
 	GList *cur = args;
 	size_t r = 0;
-	rspamd_fstring_t *arg;
+	rspamd_ftok_t *arg;
 
 	while (cur && r < buflen - 3) {
 		arg = cur->data;
-		r += rspamd_snprintf (buf + r, buflen - r, " %V", arg);
+		r += rspamd_snprintf (buf + r, buflen - r, " %T", arg);
 		cur = g_list_next (cur);
 	}
 
@@ -401,13 +403,13 @@ smtp_upstream_write_socket (void *arg)
 }
 
 gboolean
-smtp_upstream_read_socket (rspamd_fstring_t * in, void *arg)
+smtp_upstream_read_socket (rspamd_ftok_t * in, void *arg)
 {
 	struct smtp_session *session = arg;
 	gchar outbuf[BUFSIZ];
 	gint r;
 
-	msg_debug ("in: %V, state: %d", in, session->upstream_state);
+	msg_debug ("in: %T, state: %d", in, session->upstream_state);
 	switch (session->upstream_state) {
 	case SMTP_STATE_GREETING:
 		r = check_smtp_ustream_reply (in, '2');
@@ -713,7 +715,7 @@ smtp_upstream_read_socket (rspamd_fstring_t * in, void *arg)
 		return FALSE;
 		break;
 	default:
-		msg_err ("got upstream reply at unexpected state: %d, reply: %V",
+		msg_err ("got upstream reply at unexpected state: %d, reply: %T",
 			session->upstream_state,
 			in);
 		session->state = SMTP_STATE_CRITICAL_ERROR;
diff --git a/src/libmime/smtp_proto.h b/src/libmime/smtp_proto.h
index a0f2ec5c2..7ede6f803 100644
--- a/src/libmime/smtp_proto.h
+++ b/src/libmime/smtp_proto.h
@@ -24,20 +24,21 @@
 
 #define MAX_SMTP_UPSTREAMS 128
 
+enum smtp_command_type {
+	SMTP_COMMAND_HELO = 0,
+	SMTP_COMMAND_EHLO,
+	SMTP_COMMAND_QUIT,
+	SMTP_COMMAND_NOOP,
+	SMTP_COMMAND_MAIL,
+	SMTP_COMMAND_RCPT,
+	SMTP_COMMAND_RSET,
+	SMTP_COMMAND_DATA,
+	SMTP_COMMAND_VRFY,
+	SMTP_COMMAND_EXPN,
+	SMTP_COMMAND_HELP
+};
 struct smtp_command {
-	enum {
-		SMTP_COMMAND_HELO,
-		SMTP_COMMAND_EHLO,
-		SMTP_COMMAND_QUIT,
-		SMTP_COMMAND_NOOP,
-		SMTP_COMMAND_MAIL,
-		SMTP_COMMAND_RCPT,
-		SMTP_COMMAND_RSET,
-		SMTP_COMMAND_DATA,
-		SMTP_COMMAND_VRFY,
-		SMTP_COMMAND_EXPN,
-		SMTP_COMMAND_HELP
-	} command;
+	enum smtp_command_type command;
 	GList *args;
 };
 
@@ -53,7 +54,7 @@ gchar * make_smtp_error (rspamd_mempool_t *pool,
  * Parse a single SMTP command
  */
 gboolean parse_smtp_command (struct smtp_session *session,
-	rspamd_fstring_t *line,
+	rspamd_ftok_t *line,
 	struct smtp_command **cmd);
 
 /*
@@ -79,7 +80,7 @@ gboolean parse_smtp_rcpt (struct smtp_session *session,
 /*
  * Read a line from SMTP upstream
  */
-gboolean smtp_upstream_read_socket (rspamd_fstring_t * in, void *arg);
+gboolean smtp_upstream_read_socket (rspamd_ftok_t * in, void *arg);
 
 /*
  * Write to SMTP upstream
diff --git a/src/libmime/smtp_utils.c b/src/libmime/smtp_utils.c
index edc7f3b14..df50abc65 100644
--- a/src/libmime/smtp_utils.c
+++ b/src/libmime/smtp_utils.c
@@ -35,8 +35,9 @@ free_smtp_session (gpointer arg)
 	if (session) {
 		if (session->task) {
 			rspamd_task_free (session->task, FALSE);
-			if (session->task->msg.start) {
-				munmap (session->task->msg.start, session->task->msg.len);
+			if (session->task->msg.begin) {
+				munmap ((gpointer)session->task->msg.begin,
+						session->task->msg.len);
 			}
 		}
 		if (session->rcpt) {
diff --git a/src/libserver/buffer.c b/src/libserver/buffer.c
index e4268863c..0875de300 100644
--- a/src/libserver/buffer.c
+++ b/src/libserver/buffer.c
@@ -310,14 +310,27 @@ write_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean is_delayed)
 	return TRUE;
 }
 
+static struct rspamd_buffer_buf *
+allocate_buffer (rspamd_mempool_t *pool, gsize size)
+{
+	struct rspamd_buffer_buf *b;
+
+	b = rspamd_mempool_alloc_tmp (pool, sizeof (*b));
+	b->begin = rspamd_mempool_alloc_tmp (pool, size);
+	b->size = size;
+	b->len = 0;
+
+	return b;
+}
+
 static void
 read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 {
 	ssize_t r;
 	GError *err = NULL;
-	rspamd_fstring_t res;
-	gchar *c, *b;
-	gchar *end;
+	rspamd_ftok_t res;
+	guchar *c, *b;
+	guchar *end;
 	size_t len;
 	enum io_policy saved_policy;
 
@@ -330,10 +343,10 @@ read_buffers (gint fd, rspamd_io_dispatcher_t * d, gboolean skip_read)
 		d->in_buf =
 			rspamd_mempool_alloc_tmp (d->pool, sizeof (rspamd_buffer_t));
 		if (d->policy == BUFFER_LINE || d->policy == BUFFER_ANY) {
-			d->in_buf->data = rspamd_fstralloc_tmp (d->pool, d->default_buf_size);
+			d->in_buf->data = allocate_buffer (d->pool, d->default_buf_size);
 		}
 		else {
-			d->in_buf->data = rspamd_fstralloc_tmp (d->pool, d->nchars + 1);
+			d->in_buf->data = allocate_buffer (d->pool, d->nchars + 1);
 		}
 		d->in_buf->pos = d->in_buf->data->begin;
 	}
@@ -657,7 +670,7 @@ rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d,
 	enum io_policy policy,
 	size_t nchars)
 {
-	rspamd_fstring_t *tmp;
+	struct rspamd_buffer_buf *tmp;
 	gint t;
 
 	if (d->policy != policy || nchars != d->nchars) {
@@ -666,7 +679,7 @@ rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d,
 		/* Resize input buffer if needed */
 		if (policy == BUFFER_CHARACTER && nchars != 0) {
 			if (d->in_buf && d->in_buf->data->size < nchars) {
-				tmp = rspamd_fstralloc_tmp (d->pool, d->nchars + 1);
+				tmp = allocate_buffer (d->pool, d->nchars + 1);
 				memcpy (tmp->begin, d->in_buf->data->begin,
 					d->in_buf->data->len);
 				t = d->in_buf->pos - d->in_buf->data->begin;
@@ -677,7 +690,7 @@ rspamd_set_dispatcher_policy (rspamd_io_dispatcher_t * d,
 		}
 		else if (policy == BUFFER_LINE || policy == BUFFER_ANY) {
 			if (d->in_buf && d->nchars < d->default_buf_size) {
-				tmp = rspamd_fstralloc_tmp (d->pool, d->default_buf_size);
+				tmp = allocate_buffer (d->pool, d->default_buf_size);
 				memcpy (tmp->begin, d->in_buf->data->begin,
 					d->in_buf->data->len);
 				t = d->in_buf->pos - d->in_buf->data->begin;
@@ -732,33 +745,6 @@ rspamd_dispatcher_write (rspamd_io_dispatcher_t * d,
 }
 
 gboolean
-rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
-	GString *str,
-	gboolean delayed,
-	gboolean free_on_write)
-{
-	struct rspamd_out_buffer_s *newbuf;
-
-	newbuf = g_slice_alloc (sizeof (struct rspamd_out_buffer_s));
-	newbuf->data = str;
-	newbuf->allocated = free_on_write;
-
-	APPEND_OUT_BUFFER (d, newbuf);
-
-	if (!delayed) {
-		debug_ip ("plan write event");
-		return write_buffers (d->fd, d, FALSE);
-	}
-	/* Otherwise plan write event */
-	event_del (d->ev);
-	event_set (d->ev, d->fd, EV_WRITE, dispatcher_cb, (void *)d);
-	event_base_set (d->ev_base, d->ev);
-	event_add (d->ev, d->tv);
-
-	return TRUE;
-}
-
-gboolean
 rspamd_dispatcher_sendfile (rspamd_io_dispatcher_t *d, gint fd, size_t len)
 {
 	if (lseek (fd, 0, SEEK_SET) == -1) {
@@ -824,7 +810,3 @@ rspamd_dispacther_cleanup (rspamd_io_dispatcher_t *d)
 }
 
 #undef debug_ip
-
-/*
- * vi:ts=4
- */
diff --git a/src/libserver/buffer.h b/src/libserver/buffer.h
index 7fa799573..26c605484 100644
--- a/src/libserver/buffer.h
+++ b/src/libserver/buffer.h
@@ -10,7 +10,7 @@
 #include "mem_pool.h"
 #include "fstring.h"
 
-typedef gboolean (*dispatcher_read_callback_t)(rspamd_fstring_t *in, void *user_data);
+typedef gboolean (*dispatcher_read_callback_t)(rspamd_ftok_t *in, void *user_data);
 typedef gboolean (*dispatcher_write_callback_t)(void *user_data);
 typedef void (*dispatcher_err_callback_t)(GError *err, void *user_data);
 
@@ -26,9 +26,15 @@ enum io_policy {
 /**
  * Buffer structure
  */
+struct rspamd_buffer_buf {
+	gsize size;
+	gsize len;
+	guchar *begin;
+};
+
 typedef struct rspamd_buffer_s {
-	rspamd_fstring_t *data;                                                  /**< buffer logic			*/
-	gchar *pos;                                                     /**< current position		*/
+	struct rspamd_buffer_buf *data;
+	guchar *pos;                                                     /**< current position		*/
 } rspamd_buffer_t;
 
 struct rspamd_out_buffer_s {
@@ -112,19 +118,6 @@ gboolean rspamd_dispatcher_write (rspamd_io_dispatcher_t *d,
 	gboolean allocated) G_GNUC_WARN_UNUSED_RESULT;
 
 /**
- * Write a GString to dispatcher
- * @param d dipatcher object
- * @param str string to write
- * @param delayed delay write
- * @param free_on_write free string after writing to a socket
- * @return TRUE if write has been queued successfully
- */
-gboolean rspamd_dispatcher_write_string (rspamd_io_dispatcher_t *d,
-	GString *str,
-	gboolean delayed,
-	gboolean free_on_write) G_GNUC_WARN_UNUSED_RESULT;
-
-/**
  * Send specified descriptor to dispatcher
  * @param d pointer to dispatcher's object
  * @param fd descriptor of file
diff --git a/src/libserver/dkim.c b/src/libserver/dkim.c
index 2cfa184a3..3b8fc63b5 100644
--- a/src/libserver/dkim.c
+++ b/src/libserver/dkim.c
@@ -1630,9 +1630,9 @@ rspamd_dkim_check (rspamd_dkim_context_t *ctx,
 	g_return_val_if_fail (task->msg.len > 0, DKIM_ERROR);
 
 	/* First of all find place of body */
-	p = task->msg.start;
+	p = task->msg.begin;
 
-	end = task->msg.start + task->msg.len;
+	end = task->msg.begin + task->msg.len;
 
 	while (p <= end) {
 		/* Search for \r\n\r\n at the end of headers */
diff --git a/src/libserver/html.c b/src/libserver/html.c
index 520c49d39..887924bd2 100644
--- a/src/libserver/html.c
+++ b/src/libserver/html.c
@@ -1350,7 +1350,7 @@ rspamd_html_process_img_tag (rspamd_mempool_t *pool, struct html_tag *tag,
 {
 	struct html_tag_component *comp;
 	struct html_image *img;
-	rspamd_fstring_t fstr;
+	rspamd_ftok_t fstr;
 	GList *cur;
 	gulong val;
 
@@ -1363,7 +1363,7 @@ rspamd_html_process_img_tag (rspamd_mempool_t *pool, struct html_tag *tag,
 		if (comp->type == RSPAMD_HTML_COMPONENT_HREF && comp->len > 0) {
 			fstr.begin = (gchar *)comp->start;
 			fstr.len = comp->len;
-			img->src = rspamd_mempool_fstrdup (pool, &fstr);
+			img->src = rspamd_mempool_ftokdup (pool, &fstr);
 
 			if (comp->len > sizeof ("cid:") - 1 && memcmp (comp->start,
 					"cid:", sizeof ("cid:") - 1) == 0) {
@@ -1427,7 +1427,7 @@ struct html_color_match {
 static gint
 rspamd_html_color_cmp (const void *key, const void *elt)
 {
-	const rspamd_fstring_t *fk = key;
+	const rspamd_ftok_t *fk = key;
 	const struct html_color_match *el = elt;
 
 	return g_ascii_strncasecmp (fk->begin, el->name, fk->len);
@@ -1438,7 +1438,7 @@ rspamd_html_process_color (const gchar *line, guint len, struct html_color *cl)
 {
 	const gchar *p = line, *end = line + len;
 	char hexbuf[7];
-	rspamd_fstring_t search;
+	rspamd_ftok_t search;
 	struct html_color_match *el;
 
 	memset (cl, 0, sizeof (*cl));
@@ -1452,7 +1452,7 @@ rspamd_html_process_color (const gchar *line, guint len, struct html_color *cl)
 	}
 	else {
 		/* Compare color by name */
-		search.begin = (gchar *)line;
+		search.begin = line;
 		search.len = len;
 
 		el = bsearch (&search, html_colors, G_N_ELEMENTS (html_colors),
@@ -1558,7 +1558,7 @@ rspamd_html_process_block_tag (rspamd_mempool_t *pool, struct html_tag *tag,
 {
 	struct html_tag_component *comp;
 	struct html_block *bl;
-	rspamd_fstring_t fstr;
+	rspamd_ftok_t fstr;
 	GList *cur;
 
 	cur = tag->params;
@@ -1583,7 +1583,7 @@ rspamd_html_process_block_tag (rspamd_mempool_t *pool, struct html_tag *tag,
 		else if (comp->type == RSPAMD_HTML_COMPONENT_CLASS && comp->len > 0) {
 			fstr.begin = (gchar *)comp->start;
 			fstr.len = comp->len;
-			bl->class = rspamd_mempool_fstrdup (pool, &fstr);
+			bl->class = rspamd_mempool_ftokdup (pool, &fstr);
 			msg_debug_pool ("got class: %s", bl->class);
 		}
 
diff --git a/src/libserver/protocol.c b/src/libserver/protocol.c
index 360239f34..221db1513 100644
--- a/src/libserver/protocol.c
+++ b/src/libserver/protocol.c
@@ -270,11 +270,11 @@ rspamd_protocol_handle_url (struct rspamd_task *task,
 
 		if (res == NULL) {
 			/* Treat the whole query as path */
-			task->msg.start = msg->url->str + u.field_data[UF_QUERY].off;
+			task->msg.begin = msg->url->str + u.field_data[UF_QUERY].off;
 			task->msg.len = u.field_data[UF_QUERY].len;
 		}
 		else {
-			task->msg.start = rspamd_mempool_strdup (task->task_pool, res->str);
+			task->msg.begin = rspamd_mempool_strdup (task->task_pool, res->str);
 			task->msg.len = res->len;
 		}
 
diff --git a/src/libserver/task.c b/src/libserver/task.c
index fc22f784f..6d0eca2a2 100644
--- a/src/libserver/task.c
+++ b/src/libserver/task.c
@@ -249,7 +249,7 @@ rspamd_task_unmapper (gpointer ud)
 {
 	struct rspamd_task *task = ud;
 
-	munmap ((void *)task->msg.start, task->msg.len);
+	munmap ((void *)task->msg.begin, task->msg.len);
 }
 
 gboolean
@@ -271,7 +271,7 @@ rspamd_task_load_message (struct rspamd_task *task,
 	if (task->flags & RSPAMD_TASK_FLAG_FILE) {
 		g_assert (task->msg.len > 0);
 
-		r = rspamd_strlcpy (filepath, task->msg.start,
+		r = rspamd_strlcpy (filepath, task->msg.begin,
 				MIN (sizeof (filepath), task->msg.len + 1));
 
 		rspamd_decode_url (filepath, filepath, r + 1);
@@ -311,14 +311,14 @@ rspamd_task_load_message (struct rspamd_task *task,
 		}
 
 		close (fd);
-		task->msg.start = map;
+		task->msg.begin = map;
 		task->msg.len = st.st_size;
 
 		rspamd_mempool_add_destructor (task->task_pool, rspamd_task_unmapper, task);
 	}
 	else {
 		debug_task ("got input of length %z", task->msg.len);
-		task->msg.start = start;
+		task->msg.begin = start;
 		task->msg.len = len;
 
 		if (task->msg.len == 0) {
@@ -343,7 +343,7 @@ rspamd_task_load_message (struct rspamd_task *task,
 			if (control_len > 0) {
 				parser = ucl_parser_new (UCL_PARSER_KEY_LOWERCASE);
 
-				if (!ucl_parser_add_chunk (parser, task->msg.start, control_len)) {
+				if (!ucl_parser_add_chunk (parser, task->msg.begin, control_len)) {
 					msg_warn_task ("processing of control chunk failed: %s",
 							ucl_parser_get_error (parser));
 					ucl_parser_free (parser);
@@ -355,7 +355,7 @@ rspamd_task_load_message (struct rspamd_task *task,
 					ucl_object_unref (control_obj);
 				}
 
-				task->msg.start += control_len;
+				task->msg.begin += control_len;
 				task->msg.len -= control_len;
 			}
 		}
diff --git a/src/libserver/task.h b/src/libserver/task.h
index 16c3d4a70..02f6f9ea0 100644
--- a/src/libserver/task.h
+++ b/src/libserver/task.h
@@ -128,16 +128,13 @@ struct rspamd_task {
 	gchar *hostname;								/**< hostname reported by MTA						*/
 	GHashTable *request_headers;					/**< HTTP headers in a request						*/
 	GHashTable *reply_headers;						/**< Custom reply headers							*/
-	struct {
-		const gchar *start;
-		gsize len;
-	} msg;											/**< message buffer									*/
+	rspamd_ftok_t msg;								/**< message buffer									*/
 	struct rspamd_http_connection *http_conn;		/**< HTTP server connection							*/
 	struct rspamd_async_session * s;				/**< async session object							*/
 	GMimeMessage *message;							/**< message, parsed with GMime						*/
 	GPtrArray *parts;								/**< list of parsed parts							*/
 	GPtrArray *text_parts;							/**< list of text parts								*/
-	rspamd_fstring_t raw_headers_content;			/**< list of raw headers							*/
+	rspamd_ftok_t raw_headers_content;				/**< list of raw headers							*/
 	GPtrArray *received;							/**< list of received headers						*/
 	GHashTable *urls;								/**< list of parsed urls							*/
 	GHashTable *emails;								/**< list of parsed emails							*/
diff --git a/src/libstat/learn_cache/sqlite3_cache.c b/src/libstat/learn_cache/sqlite3_cache.c
index 6eabaefda..987f6cb0c 100644
--- a/src/libstat/learn_cache/sqlite3_cache.c
+++ b/src/libstat/learn_cache/sqlite3_cache.c
@@ -247,7 +247,7 @@ rspamd_stat_cache_sqlite3_process (struct rspamd_task *task,
 	struct rspamd_stat_sqlite3_ctx *ctx = (struct rspamd_stat_sqlite3_ctx *)c;
 	struct mime_text_part *part;
 	blake2b_state st;
-	rspamd_fstring_t *word;
+	rspamd_ftok_t *word;
 	guchar out[BLAKE2B_OUTBYTES];
 	guint i, j;
 
@@ -259,7 +259,7 @@ rspamd_stat_cache_sqlite3_process (struct rspamd_task *task,
 
 			if (part->words != NULL) {
 				for (j = 0; j < part->words->len; j ++) {
-					word = &g_array_index (part->words, rspamd_fstring_t, j);
+					word = &g_array_index (part->words, rspamd_ftok_t, j);
 					blake2b_update (&st, word->begin, word->len);
 				}
 			}
diff --git a/src/libstat/stat_process.c b/src/libstat/stat_process.c
index a6f5d31ae..a1cbe9c33 100644
--- a/src/libstat/stat_process.c
+++ b/src/libstat/stat_process.c
@@ -52,7 +52,7 @@ rspamd_stat_tokenize_header (struct rspamd_task *task,
 		const gchar *name, const gchar *prefix, GArray *ar)
 {
 	struct raw_header *rh, *cur;
-	rspamd_fstring_t str;
+	rspamd_ftok_t str;
 
 	rh = g_hash_table_lookup (task->raw_headers, name);
 
@@ -89,7 +89,7 @@ rspamd_stat_tokenize_parts_metadata (struct rspamd_task *task,
 	struct mime_text_part *tp;
 	GList *cur;
 	GArray *ar;
-	rspamd_fstring_t elt;
+	rspamd_ftok_t elt;
 	guint i;
 
 	ar = g_array_sized_new (FALSE, FALSE, sizeof (elt), 4);
diff --git a/src/libstat/tokenizers/osb.c b/src/libstat/tokenizers/osb.c
index 690a7ab5b..7744e2883 100644
--- a/src/libstat/tokenizers/osb.c
+++ b/src/libstat/tokenizers/osb.c
@@ -232,7 +232,7 @@ rspamd_tokenizer_osb (struct rspamd_tokenizer_runtime *rt,
 	const gchar *prefix)
 {
 	rspamd_token_t *new = NULL;
-	rspamd_fstring_t *token;
+	rspamd_ftok_t *token;
 	struct rspamd_osb_tokenizer_config *osb_cf;
 	guint64 *hashpipe, cur, seed;
 	guint32 h1, h2;
@@ -259,7 +259,7 @@ rspamd_tokenizer_osb (struct rspamd_tokenizer_runtime *rt,
 	memset (hashpipe, 0xfe, window_size * sizeof (hashpipe[0]));
 
 	for (w = 0; w < input->len; w ++) {
-		token = &g_array_index (input, rspamd_fstring_t, w);
+		token = &g_array_index (input, rspamd_ftok_t, w);
 
 		if (osb_cf->ht == RSPAMD_OSB_HASH_COMPAT) {
 			cur = rspamd_fstrhash_lc (token, is_utf);
diff --git a/src/libstat/tokenizers/tokenizers.c b/src/libstat/tokenizers/tokenizers.c
index 07e7a1f45..439c639a6 100644
--- a/src/libstat/tokenizers/tokenizers.c
+++ b/src/libstat/tokenizers/tokenizers.c
@@ -30,8 +30,8 @@
 #include "tokenizers.h"
 #include "stat_internal.h"
 
-typedef gboolean (*token_get_function) (rspamd_fstring_t * buf, gchar **pos,
-		rspamd_fstring_t * token,
+typedef gboolean (*token_get_function) (rspamd_ftok_t * buf, gchar const **pos,
+		rspamd_ftok_t * token,
 		GList **exceptions, gboolean is_utf, gsize *rl, gboolean check_signature);
 
 const gchar t_delimiters[255] = {
@@ -77,12 +77,12 @@ token_node_compare_func (gconstpointer a, gconstpointer b)
 
 /* Get next word from specified f_str_t buf */
 static gboolean
-rspamd_tokenizer_get_word_compat (rspamd_fstring_t * buf,
-		gchar **cur, rspamd_fstring_t * token,
+rspamd_tokenizer_get_word_compat (rspamd_ftok_t * buf,
+		gchar const **cur, rspamd_ftok_t * token,
 		GList **exceptions, gboolean is_utf, gsize *rl, gboolean unused)
 {
 	gsize remain, pos;
-	guchar *p;
+	const gchar *p;
 	struct process_exception *ex = NULL;
 
 	if (buf == NULL) {
@@ -134,11 +134,11 @@ rspamd_tokenizer_get_word_compat (rspamd_fstring_t * buf,
 		pos++;
 		p++;
 		remain--;
-	} while (remain > 0 && t_delimiters[*p]);
+	} while (remain > 0 && t_delimiters[(guchar)*p]);
 
 	token->begin = p;
 
-	while (remain > 0 && !t_delimiters[*p]) {
+	while (remain > 0 && !t_delimiters[(guchar)*p]) {
 		if (ex != NULL && ex->pos == pos) {
 			*exceptions = g_list_next (*exceptions);
 			*cur = p + ex->len;
@@ -169,13 +169,13 @@ rspamd_tokenizer_get_word_compat (rspamd_fstring_t * buf,
 }
 
 static gboolean
-rspamd_tokenizer_get_word (rspamd_fstring_t * buf,
-		gchar **cur, rspamd_fstring_t * token,
+rspamd_tokenizer_get_word (rspamd_ftok_t * buf,
+		gchar const **cur, rspamd_ftok_t * token,
 		GList **exceptions, gboolean is_utf, gsize *rl,
 		gboolean check_signature)
 {
 	gsize remain, pos, siglen = 0;
-	gchar *p, *next_p, *sig = NULL;
+	const gchar *p, *next_p, *sig = NULL;
 	gunichar uc;
 	guint processed = 0;
 	struct process_exception *ex = NULL;
@@ -292,8 +292,8 @@ rspamd_tokenize_text (gchar *text, gsize len, gboolean is_utf,
 		gsize min_len, GList *exceptions, gboolean compat,
 		gboolean check_signature)
 {
-	rspamd_fstring_t token, buf;
-	gchar *pos = NULL;
+	rspamd_ftok_t token, buf;
+	const gchar *pos = NULL;
 	gsize l;
 	GArray *res;
 	GList *cur = exceptions;
@@ -305,7 +305,6 @@ rspamd_tokenize_text (gchar *text, gsize len, gboolean is_utf,
 
 	buf.begin = text;
 	buf.len = len;
-	buf.size = buf.len;
 	token.begin = NULL;
 	token.len = 0;
 
@@ -316,7 +315,7 @@ rspamd_tokenize_text (gchar *text, gsize len, gboolean is_utf,
 		func = rspamd_tokenizer_get_word;
 	}
 
-	res = g_array_sized_new (FALSE, FALSE, sizeof (rspamd_fstring_t), 128);
+	res = g_array_sized_new (FALSE, FALSE, sizeof (rspamd_ftok_t), 128);
 
 	while (func (&buf, &pos, &token, &cur, is_utf, &l, FALSE)) {
 		if (l == 0 || (min_len > 0 && l < min_len)) {
diff --git a/src/libstat/tokenizers/tokenizers.h b/src/libstat/tokenizers/tokenizers.h
index 7b01d9fe8..4689d1cc6 100644
--- a/src/libstat/tokenizers/tokenizers.h
+++ b/src/libstat/tokenizers/tokenizers.h
@@ -33,7 +33,7 @@ struct rspamd_stat_tokenizer {
 gint token_node_compare_func (gconstpointer a, gconstpointer b);
 
 
-/* Tokenize text into array of words (rspamd_fstring_t type) */
+/* Tokenize text into array of words (rspamd_ftok_t type) */
 GArray * rspamd_tokenize_text (gchar *text, gsize len, gboolean is_utf,
 		gsize min_len, GList *exceptions, gboolean compat,
 		gboolean check_signature);
diff --git a/src/libutil/fstring.c b/src/libutil/fstring.c
index 991cd3000..6a1304423 100644
--- a/src/libutil/fstring.c
+++ b/src/libutil/fstring.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009-2012, Vsevolod Stakhov
+ * Copyright (c) 2009-2015, Vsevolod Stakhov
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -24,316 +24,132 @@
 
 #include "fstring.h"
 
-/*
- * Search first occurence of character in string
- */
-ssize_t
-rspamd_fstrchr (rspamd_fstring_t * src, gchar c)
-{
-	register size_t cur = 0;
-
-	while (cur < src->len) {
-		if (*(src->begin + cur) == c) {
-			return cur;
-		}
-		cur++;
-	}
+static const gsize default_initial_size = 48;
+/* Maximum size when we double the size of new string */
+static const gsize max_grow = 1024 * 1024;
 
-	return -1;
-}
+#define fstravail(s) ((s)->allocated - (s)->len)
+static rspamd_fstring_t * rspamd_fstring_grow (rspamd_fstring_t *str,
+		gsize needed_len) G_GNUC_WARN_UNUSED_RESULT;
 
-/*
- * Search last occurence of character in string
- */
-ssize_t
-rspamd_fstrrchr (rspamd_fstring_t * src, gchar c)
+rspamd_fstring_t *
+rspamd_fstring_new (void)
 {
-	register ssize_t cur = src->len;
+	rspamd_fstring_t *s;
 
-	while (cur > 0) {
-		if (*(src->begin + cur) == c) {
-			return cur;
-		}
-		cur--;
-	}
+	g_assert (posix_memalign ((void**)&s, 16, default_initial_size + sizeof (*s)) == 0);
+	s->len = 0;
+	s->allocated = default_initial_size;
 
-	return -1;
+	return s;
 }
 
-/*
- * Search for pattern in orig
- */
-ssize_t
-rspamd_fstrstr (rspamd_fstring_t * orig, rspamd_fstring_t * pattern)
-{
-	register size_t cur = 0, pcur = 0;
-
-	if (pattern->len > orig->len) {
-		return -1;
-	}
-
-	while (cur < orig->len) {
-		if (*(orig->begin + cur) == *pattern->begin) {
-			pcur = 0;
-			while (cur < orig->len && pcur < pattern->len) {
-				if (*(orig->begin + cur) != *(pattern->begin + pcur)) {
-					pcur = 0;
-					break;
-				}
-				cur++;
-				pcur++;
-			}
-			return cur - pattern->len;
-		}
-		cur++;
-	}
-
-	return -1;
-
-}
-
-/*
- * Search for pattern in orig ignoring case
- */
-ssize_t
-rspamd_fstrstri (rspamd_fstring_t * orig, rspamd_fstring_t * pattern)
+rspamd_fstring_t *
+rspamd_fstring_sized_new (gsize initial_size)
 {
-	register size_t cur = 0, pcur = 0;
+	rspamd_fstring_t *s;
+	gsize real_size = MAX (default_initial_size, initial_size);
 
-	if (pattern->len > orig->len) {
-		return -1;
-	}
-
-	while (cur < orig->len) {
-		if (g_ascii_tolower (*(orig->begin + cur)) ==
-			g_ascii_tolower (*pattern->begin)) {
-			pcur = 0;
-			while (cur < orig->len && pcur < pattern->len) {
-				if (g_ascii_tolower (*(orig->begin + cur)) !=
-					g_ascii_tolower (*(pattern->begin + pcur))) {
-					pcur = 0;
-					break;
-				}
-				cur++;
-				pcur++;
-			}
-			return cur - pattern->len;
-		}
-		cur++;
-	}
-
-	return -1;
+	g_assert (posix_memalign ((void **)&s, 16, real_size + sizeof (*s)) == 0);
+	s->len = 0;
+	s->allocated = real_size;
 
+	return s;
 }
 
-/*
- * Split string by tokens
- * word contains parsed word
- *
- * Return: -1 - no new words can be extracted
- *          1 - word was extracted and there are more words
- *          0 - last word extracted
- */
-gint
-rspamd_fstrtok (rspamd_fstring_t * text, const gchar *sep, rspamd_fstring_token_t * state)
+rspamd_fstring_t *
+rspamd_fstring_new_init (const gchar *init, gsize len)
 {
-	register size_t cur;
-	const gchar *csep = sep;
-
-	if (state->pos >= text->len) {
-		return -1;
-	}
-
-	cur = state->pos;
-
-	while (cur < text->len) {
-		while (*csep) {
-			if (*(text->begin + cur) == *csep) {
-				state->word.begin = (text->begin + state->pos);
-				state->word.len = cur - state->pos;
-				state->pos = cur + 1;
-				return 1;
-			}
-			csep++;
-		}
-		csep = sep;
-		cur++;
-	}
+	rspamd_fstring_t *s;
+	gsize real_size = MAX (default_initial_size, len);
 
-	/* Last word */
-	state->word.begin = (text->begin + state->pos);
-	state->word.len = cur - state->pos;
-	state->pos = cur;
+	g_assert (posix_memalign ((void **) &s, 16, real_size + sizeof (*s)) == 0);
+	s->len = len;
+	s->allocated = real_size;
+	memcpy (s->str, init, len);
 
-	return 0;
+	return s;
 }
 
-/*
- * Copy one string into other
- */
-size_t
-rspamd_fstrcpy (rspamd_fstring_t * dest, rspamd_fstring_t * src)
+void
+rspamd_fstring_free (rspamd_fstring_t *str)
 {
-	register size_t cur = 0;
-
-	if (dest->size < src->len) {
-		return 0;
-	}
-
-	while (cur < src->len && cur < dest->size) {
-		*(dest->begin + cur) = *(src->begin + cur);
-		cur++;
-	}
-
-	return cur;
+	free (str);
 }
 
-/*
- * Concatenate two strings
- */
-size_t
-rspamd_fstrcat (rspamd_fstring_t * dest, rspamd_fstring_t * src)
+static rspamd_fstring_t *
+rspamd_fstring_grow (rspamd_fstring_t *str, gsize needed_len)
 {
-	register size_t cur = 0;
-	gchar *p = dest->begin + dest->len;
+	gsize newlen;
+	gpointer nptr;
 
-	if (dest->size < src->len + dest->len) {
-		return 0;
-	}
+	newlen = str->len + needed_len;
 
-	while (cur < src->len) {
-		*p = *(src->begin + cur);
-		p++;
-		cur++;
+	/*
+	 * Stop exponential grow at some point, since it might be slow for the
+	 * vast majority of cases
+	 */
+	if (newlen < max_grow) {
+		newlen *= 2;
 	}
-
-	dest->len += src->len;
-
-	return cur;
-
-}
-
-/*
- * Make copy of string to 0-terminated string
- */
-gchar *
-rspamd_fstr_c_str (rspamd_fstring_t * str, rspamd_mempool_t * pool)
-{
-	gchar *res;
-	res = rspamd_mempool_alloc (pool, str->len + 1);
-
-	/* Do not allow multiply \0 characters */
-	memccpy (res, str->begin, '\0', str->len);
-	res[str->len] = 0;
-
-	return res;
-}
-
-/*
- * Push one character to fstr
- */
-gint
-rspamd_fstrappend_c (rspamd_fstring_t * dest, gchar c)
-{
-	if (dest->size < dest->len) {
-		/* Need to reallocate string */
-		return 0;
+	else {
+		newlen += max_grow;
 	}
 
-	*(dest->begin + dest->len) = c;
-	dest->len++;
-	return 1;
-}
+	nptr = realloc (str, newlen + sizeof (*str));
 
-/*
- * Push one character to fstr
- */
-gint
-rspamd_fstrappend_u (rspamd_fstring_t * dest, gunichar c)
-{
-	int l;
-	if (dest->size < dest->len) {
-		/* Need to reallocate string */
-		return 0;
+	if (nptr == NULL) {
+		/* Avoid memory leak */
+		free (str);
+		g_assert (nptr);
 	}
 
-	l = g_unichar_to_utf8 (c, dest->begin + dest->len);
-	dest->len += l;
-	return l;
-}
-
-/*
- * Allocate memory for f_str_t
- */
-rspamd_fstring_t *
-rspamd_fstralloc (rspamd_mempool_t * pool, size_t len)
-{
-	rspamd_fstring_t *res = rspamd_mempool_alloc (pool, sizeof (rspamd_fstring_t));
-
-	res->begin = rspamd_mempool_alloc (pool, len);
+	str = nptr;
+	str->allocated = newlen;
 
-	res->size = len;
-	res->len = 0;
-	return res;
+	return str;
 }
 
-/*
- * Allocate memory for f_str_t from temporary pool
- */
-rspamd_fstring_t *
-rspamd_fstralloc_tmp (rspamd_mempool_t * pool, size_t len)
-{
-	rspamd_fstring_t *res = rspamd_mempool_alloc_tmp (pool, sizeof (rspamd_fstring_t));
-
-	res->begin = rspamd_mempool_alloc_tmp (pool, len);
-
-	res->size = len;
-	res->len = 0;
-	return res;
-}
-
-/*
- * Truncate string to its len
- */
 rspamd_fstring_t *
-rspamd_fstrtruncate (rspamd_mempool_t * pool, rspamd_fstring_t * orig)
+rspamd_fstring_append (rspamd_fstring_t *str, const char *in, gsize len)
 {
-	rspamd_fstring_t *res;
+	gsize avail = fstravail (str);
 
-	if (orig == NULL || orig->len == 0 || orig->size <= orig->len) {
-		return orig;
+	if (avail < len) {
+		str = rspamd_fstring_grow (str, len);
 	}
 
-	res = rspamd_fstralloc (pool, orig->len);
-	if (res == NULL) {
-		return NULL;
-	}
-	rspamd_fstrcpy (res, orig);
+	memcpy (str->str + str->len, in, len);
+	str->len += len;
 
-	return res;
+	return str;
 }
 
-/*
- * Enlarge string to new size
- */
-rspamd_fstring_t *
-rspamd_fstrgrow (rspamd_mempool_t * pool, rspamd_fstring_t * orig, size_t newlen)
+void
+rspamd_fstring_erase (rspamd_fstring_t *str, gsize pos, gsize len)
 {
-	rspamd_fstring_t *res;
+	if (pos < str->len) {
+		if (pos + len > str->len) {
+			len = str->len - pos;
+		}
 
-	if (orig == NULL || orig->len == 0 || orig->size >= newlen) {
-		return orig;
+		if (len == str->len - pos) {
+			/* Fast path */
+			str->len = pos;
+		}
+		else {
+			memmove (str->str + pos, str->str + pos + len, str->len - pos);
+			str->len -= pos;
+		}
 	}
-
-	res = rspamd_fstralloc (pool, newlen);
-	if (res == NULL) {
-		return NULL;
+	else {
+		/* Do nothing */
 	}
-	rspamd_fstrcpy (res, orig);
-
-	return res;
 }
 
+char *rspamd_fstring_cstr (const rspamd_fstring_t *str);
+
+/* Compat code */
 static guint32
 fstrhash_c (gchar c, guint32 hval)
 {
@@ -362,33 +178,12 @@ fstrhash_c (gchar c, guint32 hval)
 	return (hval << 3) + (hval >> 29);
 }
 
-/*
- * Return hash value for a string
- */
-guint32
-rspamd_fstrhash (rspamd_fstring_t * str)
-{
-	size_t i;
-	guint32 hval;
-	gchar *c;
-
-	if (str == NULL) {
-		return 0;
-	}
-	c = str->begin;
-	hval = str->len;
-
-	for (i = 0; i < str->len; i++, c++) {
-		hval = fstrhash_c (*c, hval);
-	}
-	return hval;
-}
 
 /*
  * Return hash value for a string
  */
 guint32
-rspamd_fstrhash_lc (rspamd_fstring_t * str, gboolean is_utf)
+rspamd_fstrhash_lc (const rspamd_ftok_t * str, gboolean is_utf)
 {
 	gsize i;
 	guint32 j, hval;
@@ -431,42 +226,6 @@ rspamd_fstrhash_lc (rspamd_fstring_t * str, gboolean is_utf)
 	return hval;
 }
 
-void
-rspamd_fstrstrip (rspamd_fstring_t * str)
-{
-	gchar *p = str->begin;
-	guint r = 0;
-
-	while (r < str->len) {
-		if (g_ascii_isspace (*p)) {
-			p++;
-			r++;
-		}
-		else {
-			break;
-		}
-	}
-
-	if (r > 0) {
-		memmove (str->begin, p, str->len - r);
-		str->len -= r;
-	}
-
-	r = str->len;
-	p = str->begin + str->len;
-	while (r > 0) {
-		if (g_ascii_isspace (*p)) {
-			p--;
-			r--;
-		}
-		else {
-			break;
-		}
-	}
-
-	str->len = r;
-}
-
 gboolean
 rspamd_fstring_equal (const rspamd_fstring_t *s1,
 		const rspamd_fstring_t *s2)
@@ -474,7 +233,7 @@ rspamd_fstring_equal (const rspamd_fstring_t *s1,
 	g_assert (s1 != NULL && s2 != NULL);
 
 	if (s1->len == s2->len) {
-		return (memcmp (s1->begin, s2->begin, s1->len) == 0);
+		return (memcmp (s1->str, s2->str, s1->len) == 0);
 	}
 
 	return FALSE;
diff --git a/src/libutil/fstring.h b/src/libutil/fstring.h
index 27482877c..02b92bea3 100644
--- a/src/libutil/fstring.h
+++ b/src/libutil/fstring.h
@@ -1,123 +1,96 @@
 /*
- * Functions for handling with fixed size strings
+ * Copyright (c) 2009-2015, Vsevolod Stakhov
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+
 #ifndef FSTRING_H
 #define FSTRING_H
 
 #include "config.h"
 #include "mem_pool.h"
 
-#define update_buf_size(x) (x)->free = (x)->buf->size - \
-		((x)->pos - (x)->buf->begin); (x)->buf->len = (x)->pos - (x)->buf->begin
+/**
+ * Fixed strings library
+ * These strings are NOT null-terminated for speed
+ */
 
 typedef struct f_str_s {
-	gchar *begin;
-	size_t len;
-	size_t size;
+	gsize len;
+	gsize allocated;
+	gchar str[];
 } rspamd_fstring_t;
 
-typedef struct f_str_buf_s {
-	rspamd_fstring_t *buf;
-	gchar *pos;
-	size_t free;
-} rspamd_fstring_buf_t;
-
-typedef struct f_tok_s {
-	rspamd_fstring_t word;
-	size_t pos;
-} rspamd_fstring_token_t;
+typedef struct f_str_tok {
+	gsize len;
+	const gchar *begin;
+} rspamd_ftok_t;
 
-/*
- * Search first occurence of character in string
+/**
+ * Create new fixed length string
  */
-ssize_t rspamd_fstrchr (rspamd_fstring_t *src, gchar c);
+rspamd_fstring_t* rspamd_fstring_new (void);
 
-/*
- * Search last occurence of character in string
+/**
+ * Create new fixed length string with preallocated size
  */
-ssize_t rspamd_fstrrchr (rspamd_fstring_t *src, gchar c);
+rspamd_fstring_t *rspamd_fstring_sized_new (gsize initial_size);
 
-/*
- * Search for pattern in orig
+/**
+ * Create new fixed length string and initialize it with the initial data
  */
-ssize_t rspamd_fstrstr (rspamd_fstring_t *orig, rspamd_fstring_t *pattern);
+rspamd_fstring_t *rspamd_fstring_new_init (const gchar *init, gsize len);
 
-/*
- * Search for pattern in orig ignoring case
+/**
+ * Free fixed length string
  */
-ssize_t rspamd_fstrstri (rspamd_fstring_t *orig, rspamd_fstring_t *pattern);
+void rspamd_fstring_free (rspamd_fstring_t *str);
 
-/*
- * Split string by tokens
- * word contains parsed word
+/**
+ * Append data to a fixed length string
  */
-gint rspamd_fstrtok (rspamd_fstring_t *text, const gchar *sep, rspamd_fstring_token_t *state);
+rspamd_fstring_t* rspamd_fstring_append (rspamd_fstring_t *str,
+		const char *in, gsize len) G_GNUC_WARN_UNUSED_RESULT;
 
-/*
- * Copy one string into other
- */
-size_t rspamd_fstrcpy (rspamd_fstring_t *dest, rspamd_fstring_t *src);
 
-/*
- * Concatenate two strings
+/**
+ * Erase `len` characters at postion `pos`
  */
-size_t rspamd_fstrcat (rspamd_fstring_t *dest, rspamd_fstring_t *src);
+void rspamd_fstring_erase (rspamd_fstring_t *str, gsize pos, gsize len);
 
-/*
- * Push one character to fstr
- */
-gint rspamd_fstrappend_c (rspamd_fstring_t *dest, gchar c);
-
-/*
- * Push one character to fstr
+/**
+ * Convert fixed string to a zero terminated string. This string should be
+ * freed by a caller
  */
-gint rspamd_fstrappend_u (rspamd_fstring_t *dest, gunichar c);
-
-/*
- * Allocate memory for f_str_t
- */
-rspamd_fstring_t * rspamd_fstralloc (rspamd_mempool_t *pool, size_t len);
-
-/*
- * Allocate memory for f_str_t from temporary pool
- */
-rspamd_fstring_t * rspamd_fstralloc_tmp (rspamd_mempool_t *pool, size_t len);
-
-/*
- * Truncate string to its len
- */
-rspamd_fstring_t * rspamd_fstrtruncate (rspamd_mempool_t *pool, rspamd_fstring_t *orig);
-
-/*
- * Enlarge string to new size
- */
-rspamd_fstring_t * rspamd_fstrgrow (rspamd_mempool_t *pool, rspamd_fstring_t *orig, size_t newlen);
-
-/*
- * Return specified character
- */
-#define fstridx(str, pos) *((str)->begin + (pos))
-
-/*
- * Return fast hash value for fixed string
- */
-guint32 rspamd_fstrhash (rspamd_fstring_t *str);
+char * rspamd_fstring_cstr (const rspamd_fstring_t *str);
 
 /*
  * Return fast hash value for fixed string converted to lowercase
  */
-guint32 rspamd_fstrhash_lc (rspamd_fstring_t *str, gboolean is_utf);
-/*
- * Make copy of string to 0-terminated string
- */
-gchar * rspamd_fstr_c_str (rspamd_fstring_t *str, rspamd_mempool_t *pool);
+guint32 rspamd_fstrhash_lc (const rspamd_ftok_t *str, gboolean is_utf);
 
-/*
- * Strip fstr string from space symbols
+/**
+ * Return true if two strings are equal
  */
-void rspamd_fstrstrip (rspamd_fstring_t *str);
-
 gboolean rspamd_fstring_equal (const rspamd_fstring_t *s1,
 		const rspamd_fstring_t *s2);
 
diff --git a/src/libutil/mem_pool.c b/src/libutil/mem_pool.c
index ea5fa0bd8..849e70c03 100644
--- a/src/libutil/mem_pool.c
+++ b/src/libutil/mem_pool.c
@@ -26,8 +26,6 @@
 #include "mem_pool.h"
 #include "fstring.h"
 #include "logger.h"
-#include "util.h"
-#include "rspamd.h"
 #include "utlist.h"
 #include "ottery.h"
 
@@ -424,11 +422,25 @@ rspamd_mempool_fstrdup (rspamd_mempool_t * pool, const struct f_str_s *src)
 	}
 
 	newstr = rspamd_mempool_alloc (pool, src->len + 1);
-	memcpy (newstr, src->begin, src->len);
+	memcpy (newstr, src->str, src->len);
 	newstr[src->len] = '\0';
 	return newstr;
 }
 
+gchar *
+rspamd_mempool_ftokdup (rspamd_mempool_t *pool, const rspamd_ftok_t *src)
+{
+	gchar *newstr;
+
+	if (src == NULL) {
+		return NULL;
+	}
+
+	newstr = rspamd_mempool_alloc (pool, src->len + 1);
+	memcpy (newstr, src->begin, src->len);
+	newstr[src->len] = '\0';
+	return newstr;
+}
 
 gchar *
 rspamd_mempool_strdup_shared (rspamd_mempool_t * pool, const gchar *src)
diff --git a/src/libutil/mem_pool.h b/src/libutil/mem_pool.h
index 3b0e97666..21ddc9d90 100644
--- a/src/libutil/mem_pool.h
+++ b/src/libutil/mem_pool.h
@@ -179,6 +179,17 @@ gchar * rspamd_mempool_strdup (rspamd_mempool_t * pool, const gchar *src);
 gchar * rspamd_mempool_fstrdup (rspamd_mempool_t * pool,
 	const struct f_str_s *src);
 
+struct f_str_tok;
+
+/**
+ * Make a copy of fixed string token in pool as null terminated string
+ * @param pool memory pool object
+ * @param src source string
+ * @return pointer to newly created string that is copy of src
+ */
+gchar * rspamd_mempool_ftokdup (rspamd_mempool_t *pool,
+		const struct f_str_tok *src);
+
 /**
  * Allocate piece of shared memory
  * @param pool memory pool object
@@ -201,7 +212,7 @@ void rspamd_mempool_lock_shared (rspamd_mempool_t *pool, void *pointer);
  * @param pool memory pool object
  * @param pointer pointer of shared memory object that is to be unlocked (the whole page that contains that object is locked)
  */
-void rspamd_mempool_lock_shared (rspamd_mempool_t *pool, void *pointer);
+void rspamd_mempool_unlock_shared (rspamd_mempool_t *pool, void *pointer);
 
 /**
  * Add destructor callback to pool
diff --git a/src/libutil/printf.c b/src/libutil/printf.c
index 328173bd0..345682f28 100644
--- a/src/libutil/printf.c
+++ b/src/libutil/printf.c
@@ -219,6 +219,18 @@ rspamd_printf_append_gstring (const gchar *buf, glong buflen, gpointer ud)
 	return buflen;
 }
 
+static glong
+rspamd_printf_append_fstring (const gchar *buf, glong buflen, gpointer ud)
+{
+	rspamd_fstring_t **dst = ud;
+
+	if (buflen > 0) {
+		*dst = rspamd_fstring_append (*dst, buf, buflen);
+	}
+
+	return buflen;
+}
+
 glong
 rspamd_fprintf (FILE *f, const gchar *fmt, ...)
 {
@@ -307,6 +319,25 @@ rspamd_vprintf_gstring (GString *s, const gchar *fmt, va_list args)
 	return rspamd_vprintf_common (rspamd_printf_append_gstring, s, fmt, args);
 }
 
+glong
+rspamd_printf_fstring (rspamd_fstring_t **s, const gchar *fmt, ...)
+{
+	va_list args;
+	glong r;
+
+	va_start (args, fmt);
+	r = rspamd_vprintf_fstring (s, fmt, args);
+	va_end (args);
+
+	return r;
+}
+
+glong
+rspamd_vprintf_fstring (rspamd_fstring_t **s, const gchar *fmt, va_list args)
+{
+	return rspamd_vprintf_common (rspamd_printf_append_fstring, s, fmt, args);
+}
+
 #define RSPAMD_PRINTF_APPEND(buf, len)                                         \
 	do {                                                                       \
 		RSPAMD_PRINTF_APPEND_BUF(buf, len);                                    \
@@ -338,6 +369,7 @@ rspamd_vprintf_common (rspamd_printf_append_func func,
 	guint64 ui64;
 	guint width, sign, hex, humanize, bytes, frac_width, i;
 	rspamd_fstring_t *v;
+	rspamd_ftok_t *tok;
 	GString *gs;
 	GError *err;
 	gboolean bv;
@@ -453,10 +485,15 @@ rspamd_vprintf_common (rspamd_printf_append_func func,
 
 			case 'V':
 				v = va_arg (args, rspamd_fstring_t *);
-				RSPAMD_PRINTF_APPEND (v->begin, v->len);
+				RSPAMD_PRINTF_APPEND (v->str, v->len);
 
 				continue;
 
+			case 'T':
+				tok = va_arg (args, rspamd_ftok_t *);
+				RSPAMD_PRINTF_APPEND (tok->begin, tok->len);
+				continue;
+
 			case 'v':
 				gs = va_arg (args, GString *);
 				RSPAMD_PRINTF_APPEND (gs->str, gs->len);
@@ -523,7 +560,7 @@ rspamd_vprintf_common (rspamd_printf_append_func func,
 				sign = 1;
 				break;
 
-			case 'T':
+			case 't':
 				i64 = (gint64) va_arg (args, time_t);
 				sign = 1;
 				break;
diff --git a/src/libutil/printf.h b/src/libutil/printf.h
index d0db483d9..ea73cf0a0 100644
--- a/src/libutil/printf.h
+++ b/src/libutil/printf.h
@@ -26,6 +26,7 @@
 #define PRINTF_H_
 
 #include "config.h"
+#include "fstring.h"
 
 /*
  * supported formats:
@@ -44,7 +45,8 @@
  *	%P						    pid_t
  *	%r				            rlim_t
  *	%p						    void *
- *	%V						    f_str_t *
+ *	%V						    rspamd_fstring_t *
+ *	%T						    rspamd_ftok_t
  *	%v                          GString *
  *	%s						    null-terminated string
  *	%xs                         hex encoded string
@@ -52,6 +54,7 @@
  *	%Z						    '\0'
  *	%N						    '\n'
  *	%c						    gchar
+ *	%t						    time_t
  *	%e                          GError *
  *	%%						    %
  *
@@ -76,6 +79,9 @@ gchar * rspamd_vsnprintf (gchar *buf, glong max, const gchar *fmt,
 glong rspamd_printf_gstring (GString *s, const gchar *fmt, ...);
 glong rspamd_vprintf_gstring (GString *s, const gchar *fmt, va_list args);
 
+glong rspamd_printf_fstring (rspamd_fstring_t **s, const gchar *fmt, ...);
+glong rspamd_vprintf_fstring (rspamd_fstring_t **s, const gchar *fmt, va_list args);
+
 glong rspamd_vprintf_common (rspamd_printf_append_func func,
 	gpointer apd,
 	const gchar *fmt,
diff --git a/src/libutil/shingles.c b/src/libutil/shingles.c
index 776ecfa96..e3bcc0f10 100644
--- a/src/libutil/shingles.c
+++ b/src/libutil/shingles.c
@@ -41,7 +41,7 @@ rspamd_shingles_generate (GArray *input,
 	guchar shabuf[BLAKE2B_OUTBYTES], *out_key;
 	const guchar *cur_key;
 	GString *row;
-	rspamd_fstring_t *word;
+	rspamd_ftok_t *word;
 	blake2b_state bs;
 	guint64 val;
 	gint i, j, beg = 0;
@@ -84,7 +84,7 @@ rspamd_shingles_generate (GArray *input,
 	for (i = 0; i <= (gint)input->len; i ++) {
 		if (i - beg >= SHINGLES_WINDOW || i == (gint)input->len) {
 			for (j = beg; j < i; j ++) {
-				word = &g_array_index (input, rspamd_fstring_t, j);
+				word = &g_array_index (input, rspamd_ftok_t, j);
 				g_string_append_len (row, word->begin, word->len);
 			}
 			beg++;
diff --git a/src/libutil/str_util.c b/src/libutil/str_util.c
index 6465208f9..d92ceb1ad 100644
--- a/src/libutil/str_util.c
+++ b/src/libutil/str_util.c
@@ -215,9 +215,10 @@ rspamd_str_equal (gconstpointer v, gconstpointer v2)
 }
 
 gboolean
-rspamd_fstring_icase_equal (gconstpointer v, gconstpointer v2)
+rspamd_ftok_icase_equal (gconstpointer v, gconstpointer v2)
 {
-	const rspamd_fstring_t *f1 = v, *f2 = v2;
+	const rspamd_ftok_t *f1 = v, *f2 = v2;
+
 	if (f1->len == f2->len &&
 		g_ascii_strncasecmp (f1->begin, f2->begin, f1->len) == 0) {
 		return TRUE;
@@ -228,9 +229,9 @@ rspamd_fstring_icase_equal (gconstpointer v, gconstpointer v2)
 
 
 guint
-rspamd_fstring_icase_hash (gconstpointer key)
+rspamd_ftok_icase_hash (gconstpointer key)
 {
-	const rspamd_fstring_t *f = key;
+	const rspamd_ftok_t *f = key;
 
 	return rspamd_icase_hash (f->begin, f->len);
 }
diff --git a/src/libutil/str_util.h b/src/libutil/str_util.h
index b6c8b2981..fdadc4811 100644
--- a/src/libutil/str_util.h
+++ b/src/libutil/str_util.h
@@ -53,8 +53,8 @@ gboolean rspamd_str_equal (gconstpointer v, gconstpointer v2);
 /*
  * Hash table utility functions for hashing fixed strings
  */
-guint rspamd_fstring_icase_hash (gconstpointer key);
-gboolean rspamd_fstring_icase_equal (gconstpointer v, gconstpointer v2);
+guint rspamd_ftok_icase_hash (gconstpointer key);
+gboolean rspamd_ftok_icase_equal (gconstpointer v, gconstpointer v2);
 guint rspamd_gstring_icase_hash (gconstpointer key);
 gboolean rspamd_gstring_icase_equal (gconstpointer v, gconstpointer v2);
 
diff --git a/src/lua/lua_buffer.c b/src/lua/lua_buffer.c
index 7a23a9579..021b13a0d 100644
--- a/src/lua/lua_buffer.c
+++ b/src/lua/lua_buffer.c
@@ -79,7 +79,7 @@ lua_check_event_base (lua_State *L)
 /* Dispatcher callbacks */
 
 static gboolean
-lua_io_read_cb (rspamd_fstring_t * in, void *arg)
+lua_io_read_cb (rspamd_ftok_t * in, void *arg)
 {
 	struct lua_dispatcher_cbdata *cbdata = arg;
 	gboolean res;
diff --git a/src/lua/lua_rsa.c b/src/lua/lua_rsa.c
index 394332fd0..a85d0db71 100644
--- a/src/lua/lua_rsa.c
+++ b/src/lua/lua_rsa.c
@@ -298,16 +298,13 @@ lua_rsa_signature_load (lua_State *L)
 			sig = g_malloc (sizeof (rspamd_fstring_t));
 			if (fstat (fd, &st) == -1 ||
 				(data =
-				mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
-				0)) == MAP_FAILED) {
+				mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0))
+						== MAP_FAILED) {
 				msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
 				lua_pushnil (L);
 			}
 			else {
-				sig->size = st.st_size;
-				sig->len = sig->size;
-				sig->begin = g_malloc (sig->len);
-				memcpy (sig->begin, data, sig->len);
+				sig = rspamd_fstring_new_init (data, st.st_size);
 				psig = lua_newuserdata (L, sizeof (rspamd_fstring_t *));
 				rspamd_lua_setclass (L, "rspamd{rsa_signature}", -1);
 				*psig = sig;
@@ -352,7 +349,7 @@ lua_rsa_signature_save (lua_State *L)
 			lua_pushboolean (L, FALSE);
 		}
 		else {
-			while (write (fd, sig->begin, sig->len) == -1) {
+			while (write (fd, sig->str, sig->len) == -1) {
 				if (errno == EINTR) {
 					continue;
 				}
@@ -378,14 +375,11 @@ lua_rsa_signature_create (lua_State *L)
 {
 	rspamd_fstring_t *sig, **psig;
 	const gchar *data;
+	gsize dlen;
 
-	data = luaL_checkstring (L, 1);
+	data = luaL_checklstring (L, 1, &dlen);
 	if (data != NULL) {
-		sig = g_malloc (sizeof (rspamd_fstring_t));
-		sig->len = strlen (data);
-		sig->size = sig->len;
-		sig->begin = g_malloc (sig->len);
-		memcpy (sig->begin, data, sig->len);
+		sig = rspamd_fstring_new_init (data, dlen);
 		psig = lua_newuserdata (L, sizeof (rspamd_fstring_t *));
 		rspamd_lua_setclass (L, "rspamd{rsa_signature}", -1);
 		*psig = sig;
@@ -399,12 +393,7 @@ lua_rsa_signature_gc (lua_State *L)
 {
 	rspamd_fstring_t *sig = lua_check_rsa_sign (L, 1);
 
-	if (sig != NULL) {
-		if (sig->begin != NULL) {
-			g_free (sig->begin);
-		}
-		g_free (sig);
-	}
+	rspamd_fstring_free (sig);
 
 	return 0;
 }
@@ -435,7 +424,7 @@ lua_rsa_verify_memory (lua_State *L)
 	if (rsa != NULL && signature != NULL && data != NULL) {
 		data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256, data, -1);
 		ret = RSA_verify (NID_sha1, data_sig, strlen (data_sig),
-				signature->begin, signature->len, rsa);
+				signature->str, signature->len, rsa);
 		if (ret == 0) {
 			msg_info ("cannot check rsa signature for data: %s",
 				ERR_error_string (ERR_get_error (), NULL));
@@ -496,7 +485,7 @@ lua_rsa_verify_file (lua_State *L)
 						data,
 						st.st_size);
 				ret = RSA_verify (NID_sha1, data_sig, strlen (data_sig),
-						signature->begin, signature->len, rsa);
+						signature->str, signature->len, rsa);
 				if (ret == 0) {
 					msg_info ("cannot check rsa signature for file: %s, %s",
 						filename, ERR_error_string (ERR_get_error (), NULL));
@@ -534,26 +523,22 @@ lua_rsa_sign_memory (lua_State *L)
 	RSA *rsa;
 	rspamd_fstring_t *signature, **psig;
 	const gchar *data;
-	gchar *data_sig;
+	guchar *data_sig;
 	gint ret;
 
 	rsa = lua_check_rsa_privkey (L, 1);
 	data = luaL_checkstring (L, 2);
 
 	if (rsa != NULL && data != NULL) {
-		signature = g_malloc (sizeof (rspamd_fstring_t));
-		signature->len = RSA_size (rsa);
-		signature->size = signature->len;
-		signature->begin = g_malloc (signature->len);
+		signature = rspamd_fstring_sized_new (RSA_size (rsa));
 		data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256, data, -1);
 		ret = RSA_sign (NID_sha1, data_sig, strlen (data_sig),
-				signature->begin, (guint *)&signature->len, rsa);
+				signature->str, (guint *)&signature->len, rsa);
 		if (ret == 0) {
 			msg_info ("cannot make a signature for data: %s",
 				ERR_error_string (ERR_get_error (), NULL));
 			lua_pushnil (L);
-			g_free (signature->begin);
-			g_free (signature);
+			rspamd_fstring_free (signature);
 		}
 		else {
 			psig = lua_newuserdata (L, sizeof (rspamd_fstring_t *));
@@ -607,21 +592,17 @@ lua_rsa_sign_file (lua_State *L)
 				lua_pushnil (L);
 			}
 			else {
-				signature = g_malloc (sizeof (rspamd_fstring_t));
-				signature->len = RSA_size (rsa);
-				signature->size = signature->len;
-				signature->begin = g_malloc (signature->len);
+				signature = rspamd_fstring_sized_new (RSA_size (rsa));
 				data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256,
 						data,
 						st.st_size);
 				ret = RSA_sign (NID_sha1, data_sig, strlen (data_sig),
-						signature->begin, (guint *)&signature->len, rsa);
+						signature->str, (guint *)&signature->len, rsa);
 				if (ret == 0) {
 					msg_info ("cannot make a signature for data: %s",
 						ERR_error_string (ERR_get_error (), NULL));
 					lua_pushnil (L);
-					g_free (signature->begin);
-					g_free (signature);
+					rspamd_fstring_free (signature);
 				}
 				else {
 					psig = lua_newuserdata (L, sizeof (rspamd_fstring_t *));
diff --git a/src/lua/lua_task.c b/src/lua/lua_task.c
index d52eeb166..4ef772a5c 100644
--- a/src/lua/lua_task.c
+++ b/src/lua/lua_task.c
@@ -638,8 +638,8 @@ lua_task_create_from_buffer (lua_State *L)
 		ptask = lua_newuserdata (L, sizeof (gpointer));
 		rspamd_lua_setclass (L, "rspamd{task}", -1);
 		*ptask = task;
-		task->msg.start = rspamd_mempool_alloc (task->task_pool, len + 1);
-		memcpy ((gpointer)task->msg.start, data, len);
+		task->msg.begin = rspamd_mempool_alloc (task->task_pool, len);
+		memcpy ((gpointer)task->msg.begin, data, len);
 		task->msg.len = len;
 	}
 	return 1;
@@ -883,7 +883,7 @@ lua_task_get_content (lua_State * L)
 		t = lua_newuserdata (L, sizeof (*t));
 		rspamd_lua_setclass (L, "rspamd{text}", -1);
 		t->len = task->msg.len;
-		t->start = task->msg.start;
+		t->start = task->msg.begin;
 		t->own = FALSE;
 
 		return 1;
diff --git a/src/lua/lua_trie.c b/src/lua/lua_trie.c
index bceda4502..b0b1551e3 100644
--- a/src/lua/lua_trie.c
+++ b/src/lua/lua_trie.c
@@ -303,7 +303,7 @@ lua_trie_search_rawmsg (lua_State *L)
 	gboolean found = FALSE;
 
 	if (trie) {
-		text = task->msg.start;
+		text = task->msg.begin;
 		len = task->msg.len;
 
 		if (lua_trie_search_str (L, trie, text, len, &state) != 0) {
diff --git a/src/lua/lua_util.c b/src/lua/lua_util.c
index f9f71c532..3a7d00211 100644
--- a/src/lua/lua_util.c
+++ b/src/lua/lua_util.c
@@ -244,8 +244,8 @@ lua_util_process_message (lua_State *L)
 		task = rspamd_task_new (NULL);
 		task->cfg = cfg;
 		task->ev_base = base;
-		task->msg.start = rspamd_mempool_alloc (task->task_pool, mlen + 1);
-		rspamd_strlcpy ((gpointer)task->msg.start, message, mlen + 1);
+		task->msg.begin = rspamd_mempool_alloc (task->task_pool, mlen);
+		rspamd_strlcpy ((gpointer)task->msg.begin, message, mlen);
 		task->msg.len = mlen;
 		task->fin_callback = lua_util_task_fin;
 		task->fin_arg = &res;
@@ -397,7 +397,7 @@ lua_util_tokenize_text (lua_State *L)
 	struct rspamd_lua_text *t;
 	struct process_exception *ex;
 	GArray *res;
-	rspamd_fstring_t *w;
+	rspamd_ftok_t *w;
 	gboolean compat = FALSE, check_sig = FALSE;
 
 	if (lua_type (L, 1) == LUA_TSTRING) {
@@ -465,7 +465,7 @@ lua_util_tokenize_text (lua_State *L)
 		lua_newtable (L);
 
 		for (i = 0; i < res->len; i ++) {
-			w = &g_array_index (res, rspamd_fstring_t, i);
+			w = &g_array_index (res, rspamd_ftok_t, i);
 			lua_pushlstring (L, w->begin, w->len);
 			lua_rawseti (L, -2, i + 1);
 		}
diff --git a/src/plugins/fuzzy_check.c b/src/plugins/fuzzy_check.c
index 8b5c2ee58..bc4822b17 100644
--- a/src/plugins/fuzzy_check.c
+++ b/src/plugins/fuzzy_check.c
@@ -621,7 +621,7 @@ fuzzy_cmd_from_text_part (struct fuzzy_rule *rule,
 	struct rspamd_shingle *sh;
 	guint i;
 	blake2b_state st;
-	rspamd_fstring_t *word;
+	rspamd_ftok_t *word;
 	GArray *words;
 	struct fuzzy_cmd_io *io;
 	struct rspamd_http_keypair *lk, *rk;
@@ -645,7 +645,7 @@ fuzzy_cmd_from_text_part (struct fuzzy_rule *rule,
 	words = fuzzy_preprocess_words (part, pool);
 
 	for (i = 0; i < words->len; i ++) {
-		word = &g_array_index (words, rspamd_fstring_t, i);
+		word = &g_array_index (words, rspamd_ftok_t, i);
 		blake2b_update (&st, word->begin, word->len);
 	}
 	blake2b_final (&st, shcmd->basic.digest, sizeof (shcmd->basic.digest));
@@ -1466,7 +1466,7 @@ fuzzy_process_handler (struct rspamd_http_connection_entry *conn_ent,
 
 	/* Allocate message from string */
 	/* XXX: what about encrypted messsages ? */
-	task->msg.start = msg->body->str;
+	task->msg.begin = msg->body->str;
 	task->msg.len = msg->body->len;
 
 	saved = rspamd_mempool_alloc0 (task->task_pool, sizeof (gint));
diff --git a/src/plugins/surbl.c b/src/plugins/surbl.c
index 882eed2d4..0c1d6887f 100644
--- a/src/plugins/surbl.c
+++ b/src/plugins/surbl.c
@@ -91,8 +91,7 @@ exception_insert (gpointer st, gconstpointer key, gpointer value)
 	GHashTable **t = st;
 	gint level = 0;
 	const gchar *p = key;
-	rspamd_fstring_t *val;
-
+	rspamd_ftok_t *val;
 
 	while (*p) {
 		if (*p == '.') {
@@ -107,12 +106,12 @@ exception_insert (gpointer st, gconstpointer key, gpointer value)
 		return;
 	}
 
-	val = g_malloc (sizeof (rspamd_fstring_t));
-	val->begin = (gchar *)key;
+	val = g_malloc (sizeof (rspamd_ftok_t));
+	val->begin = key;
 	val->len = strlen (key);
 	if (t[level] == NULL) {
-		t[level] = g_hash_table_new_full (rspamd_fstring_icase_hash,
-				rspamd_fstring_icase_equal,
+		t[level] = g_hash_table_new_full (rspamd_ftok_icase_hash,
+				rspamd_ftok_icase_equal,
 				g_free,
 				NULL);
 	}
@@ -654,7 +653,7 @@ surbl_module_reconfig (struct rspamd_config *cfg)
 
 static gchar *
 format_surbl_request (rspamd_mempool_t * pool,
-	rspamd_fstring_t * hostname,
+	rspamd_ftok_t * hostname,
 	struct suffix_item *suffix,
 	gboolean append_suffix,
 	GError ** err,
@@ -663,12 +662,12 @@ format_surbl_request (rspamd_mempool_t * pool,
 	struct rspamd_url *url)
 {
 	GHashTable *t;
-	gchar *result = NULL, *dots[MAX_LEVELS],
-		num_buf[sizeof("18446744073709551616")], *p;
+	gchar *result = NULL, num_buf[sizeof("18446744073709551616")];
+	const gchar *p, *dots[MAX_LEVELS];
 	gint len, slen, r, i, dots_num = 0, level = MAX_LEVELS;
 	gboolean is_numeric = TRUE, found_exception = FALSE;
 	guint64 ip_num;
-	rspamd_fstring_t f;
+	rspamd_ftok_t f;
 
 	if (G_LIKELY (suffix != NULL)) {
 		slen = strlen (suffix->suffix);
@@ -773,7 +772,7 @@ format_surbl_request (rspamd_mempool_t * pool,
 				if (level == 0) {
 					r = rspamd_snprintf (result,
 							len,
-							"%V",
+							"%T",
 							hostname);
 				}
 				else {
@@ -792,7 +791,7 @@ format_surbl_request (rspamd_mempool_t * pool,
 			else {
 				r = rspamd_snprintf (result,
 						len,
-						"%V",
+						"%T",
 						hostname);
 			}
 		}
@@ -852,7 +851,7 @@ make_surbl_requests (struct rspamd_url *url, struct rspamd_task *task,
 	struct suffix_item *suffix, gboolean forced, GHashTable *tree)
 {
 	gchar *surbl_req;
-	rspamd_fstring_t f;
+	rspamd_ftok_t f;
 	GError *err = NULL;
 	struct dns_param *param;
 
diff --git a/src/smtp_proxy.c b/src/smtp_proxy.c
index b931a7890..43119afa2 100644
--- a/src/smtp_proxy.c
+++ b/src/smtp_proxy.c
@@ -734,9 +734,9 @@ smtp_dns_cb (struct rdns_reply *reply, void *arg)
 }
 
 static void
-proxy_parse_smtp_input (rspamd_fstring_t *line, struct smtp_proxy_session *session)
+proxy_parse_smtp_input (rspamd_ftok_t *line, struct smtp_proxy_session *session)
 {
-	gchar *p, *c, *end;
+	const gchar *p, *c, *end;
 	gsize len;
 
 	p = line->begin;
@@ -788,10 +788,10 @@ proxy_parse_smtp_input (rspamd_fstring_t *line, struct smtp_proxy_session *sessi
  * Callback that is called when there is data to read in buffer
  */
 static gboolean
-smtp_proxy_read_socket (rspamd_fstring_t * in, void *arg)
+smtp_proxy_read_socket (rspamd_ftok_t * in, void *arg)
 {
 	struct smtp_proxy_session *session = arg;
-	gchar *p;
+	const gchar *p;
 
 	if (session->state != SMTP_PROXY_STATE_REJECT_EMULATE) {
 		/* This can be called only if client is using invalid pipelining */
diff --git a/test/rspamd_shingles_test.c b/test/rspamd_shingles_test.c
index 433fe8c67..3a1dd8ba2 100644
--- a/test/rspamd_shingles_test.c
+++ b/test/rspamd_shingles_test.c
@@ -42,16 +42,18 @@ generate_fuzzy_words (gsize cnt, gsize max_len)
 {
 	GArray *res;
 	gsize i, wlen;
-	rspamd_fstring_t w;
+	rspamd_ftok_t w;
+	char *t;
 
-	res = g_array_sized_new (FALSE, FALSE, sizeof (rspamd_fstring_t), cnt);
+	res = g_array_sized_new (FALSE, FALSE, sizeof (rspamd_ftok_t), cnt);
 
 	for (i = 0; i < cnt; i ++) {
 		wlen = ottery_rand_range (max_len) + 1;
 
-		w.len = w.size = wlen;
-		w.begin = g_malloc (wlen);
-		generate_random_string (w.begin, wlen);
+		w.len = wlen;
+		t = g_malloc (wlen);
+		generate_random_string (t, wlen);
+		w.begin = t;
 		g_array_append_val (res, w);
 	}
 
@@ -62,12 +64,12 @@ static void
 permute_vector (GArray *in, gdouble prob)
 {
 	gsize i, total = 0;
-	rspamd_fstring_t *w;
+	rspamd_ftok_t *w;
 
 	for (i = 0; i < in->len; i ++) {
 		if (ottery_rand_unsigned () <= G_MAXUINT * prob) {
-			w = &g_array_index (in, rspamd_fstring_t, i);
-			generate_random_string (w->begin, w->len);
+			w = &g_array_index (in, rspamd_ftok_t, i);
+			generate_random_string ((gchar *)w->begin, w->len);
 			total ++;
 		}
 	}
@@ -78,11 +80,11 @@ static void
 free_fuzzy_words (GArray *ar)
 {
 	gsize i;
-	rspamd_fstring_t *w;
+	rspamd_ftok_t *w;
 
 	for (i = 0; i < ar->len; i ++) {
-		w = &g_array_index (ar, rspamd_fstring_t, i);
-		g_free (w->begin);
+		w = &g_array_index (ar, rspamd_ftok_t, i);
+		g_free ((gpointer)w->begin);
 	}
 }