diff --git a/include/common/buffer.h b/include/common/buffer.h
index d76bc01..3827a9b 100644
--- a/include/common/buffer.h
+++ b/include/common/buffer.h
@@ -30,6 +30,7 @@
 #include <common/chunk.h>
 #include <common/config.h>
 #include <common/ist.h>
+#include <common/istbuf.h>
 #include <common/memory.h>
 
 
@@ -250,112 +251,6 @@
 	HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 }
 
-/*************************************************************************/
-/* functions used to manipulate strings and blocks with wrapping buffers */
-/*************************************************************************/
-
-/* returns > 0 if the first <n> characters of buffer <b> starting at offset <o>
- * relative to the buffer's head match <ist>. (empty strings do match). It is
- * designed to be use with reasonably small strings (ie matches a single byte
- * per iteration). This function is usable both with input and output data. To
- * be used like this depending on what to match :
- * - input contents  :  b_isteq(b, b->o, b->i, ist);
- * - output contents :  b_isteq(b, 0, b->o, ist);
- * Return value :
- *   >0 : the number of matching bytes
- *   =0 : not enough bytes (or matching of empty string)
- *   <0 : non-matching byte found
- */
-static inline int b_isteq(const struct buffer *b, unsigned int o, size_t n, const struct ist ist)
-{
-	struct ist r = ist;
-	const char *p;
-	const char *end = b_wrap(b);
-
-	if (n < r.len)
-		return 0;
-
-	p = b_peek(b, o);
-	while (r.len--) {
-		if (*p++ != *r.ptr++)
-			return -1;
-		if (unlikely(p == end))
-			p = b_orig(b);
-	}
-	return ist.len;
-}
-
-/* "eats" string <ist> from the head of buffer <b>. Wrapping data is explicitly
- * supported. It matches a single byte per iteration so strings should remain
- * reasonably small. Returns :
- *   > 0 : number of bytes matched and eaten
- *   = 0 : not enough bytes (or matching an empty string)
- *   < 0 : non-matching byte found
- */
-static inline int b_eat(struct buffer *b, const struct ist ist)
-{
-	int ret = b_isteq(b, 0, b_data(b), ist);
-	if (ret > 0)
-		b_del(b, ret);
-	return ret;
-}
-
-/* injects string <ist> at the tail of input buffer <b> provided that it
- * fits. Wrapping is supported. It's designed for small strings as it only
- * writes a single byte per iteration. Returns the number of characters copied
- * (ist.len), 0 if it temporarily does not fit or -1 if it will never fit. It
- * will only modify the buffer upon success. In all cases, the contents are
- * copied prior to reporting an error, so that the destination at least
- * contains a valid but truncated string.
- */
-static inline int bi_istput(struct buffer *b, const struct ist ist)
-{
-	const char *end = b_wrap(b);
-	struct ist r = ist;
-	char *p;
-
-	if (r.len > (size_t)b_room(b))
-		return r.len < b->size ? 0 : -1;
-
-	p = b_tail(b);
-	b->len += r.len;
-	while (r.len--) {
-		*p++ = *r.ptr++;
-		if (unlikely(p == end))
-			p = b_orig(b);
-	}
-	return ist.len;
-}
-
-
-/* injects string <ist> at the tail of output buffer <b> provided that it
- * fits. Input data is assumed not to exist and will silently be overwritten.
- * Wrapping is supported. It's designed for small strings as it only writes a
- * single byte per iteration. Returns the number of characters copied (ist.len),
- * 0 if it temporarily does not fit or -1 if it will never fit. It will only
- * modify the buffer upon success. In all cases, the contents are copied prior
- * to reporting an error, so that the destination at least contains a valid
- * but truncated string.
- */
-static inline int bo_istput(struct buffer *b, const struct ist ist)
-{
-	const char *end = b_wrap(b);
-	struct ist r = ist;
-	char *p;
-
-	if (r.len > (size_t)b_room(b))
-		return r.len < b->size ? 0 : -1;
-
-	p = b_tail(b);
-	b->len += r.len;
-	while (r.len--) {
-		*p++ = *r.ptr++;
-		if (unlikely(p == end))
-			p = b_orig(b);
-	}
-	return ist.len;
-}
-
 
 #endif /* _COMMON_BUFFER_H */
 
diff --git a/include/common/istbuf.h b/include/common/istbuf.h
new file mode 100644
index 0000000..2210d4a
--- /dev/null
+++ b/include/common/istbuf.h
@@ -0,0 +1,126 @@
+/*
+ * include/common/istbuf.h
+ * Functions used to manipulate indirect strings with wrapping buffers.
+ *
+ * Copyright (C) 2000-2018 Willy Tarreau - w@1wt.eu
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _COMMON_ISTBUF_H
+#define _COMMON_ISTBUF_H
+
+#include <stdint.h>
+#include <common/buf.h>
+#include <common/ist.h>
+
+
+/* b_isteq() : returns > 0 if the first <n> characters of buffer <b> starting
+ * at offset <o> relative to the buffer's head match <ist>. (empty strings do
+ * match). It is designed to be used with reasonably small strings (it matches
+ * a single byte per loop iteration). It is expected to be used with an offset
+ * to skip old data. For example :
+ * - "input" contents  :  b_isteq(b, old_cnt, new_cnt, ist);
+ * - "output" contents :  b_isteq(b, 0, old_cnt, ist);
+ * Return value :
+ *   >0 : the number of matching bytes
+ *   =0 : not enough bytes (or matching of empty string)
+ *   <0 : non-matching byte found
+ */
+static inline ssize_t b_isteq(const struct buffer *b, size_t o, size_t n, const struct ist ist)
+{
+	struct ist r = ist;
+	const char *p;
+	const char *end = b_wrap(b);
+
+	if (n < r.len)
+		return 0;
+
+	p = b_peek(b, o);
+	while (r.len--) {
+		if (*p++ != *r.ptr++)
+			return -1;
+		if (unlikely(p == end))
+			p = b_orig(b);
+	}
+	return ist.len;
+}
+
+/* b_isteat() : "eats" string <ist> from the head of buffer <b>. Wrapping data
+ * is explicitly supported. It matches a single byte per iteration so strings
+ * should remain reasonably small. Returns :
+ *   > 0 : number of bytes matched and eaten
+ *   = 0 : not enough bytes (or matching an empty string)
+ *   < 0 : non-matching byte found
+ */
+static inline ssize_t b_isteat(struct buffer *b, const struct ist ist)
+{
+	ssize_t ret = b_isteq(b, 0, b_data(b), ist);
+
+	if (ret > 0)
+		b_del(b, ret);
+	return ret;
+}
+
+/* b_istput() : injects string <ist> at the tail of output buffer <b> provided
+ * that it fits. Wrapping is supported. It's designed for small strings as it
+ * only writes a single byte per iteration. Returns the number of characters
+ * copied (ist.len), 0 if it temporarily does not fit, or -1 if it will never
+ * fit. It will only modify the buffer upon success. In all cases, the contents
+ * are copied prior to reporting an error, so that the destination at least
+ * contains a valid but truncated string.
+ */
+static inline ssize_t b_istput(struct buffer *b, const struct ist ist)
+{
+	const char *end = b_wrap(b);
+	struct ist r = ist;
+	char *p;
+
+	if (r.len > (size_t)b_room(b))
+		return r.len < b->size ? 0 : -1;
+
+	p = b_tail(b);
+	b->len += r.len;
+	while (r.len--) {
+		*p++ = *r.ptr++;
+		if (unlikely(p == end))
+			p = b_orig(b);
+	}
+	return ist.len;
+}
+
+/* b_putist() : tries to copy as much as possible of string <ist> into buffer
+ * <b> and returns the number of bytes copied (truncation is possible). It uses
+ * b_putblk() and is suitable for large blocks.
+ */
+static inline size_t b_putist(struct buffer *b, const struct ist ist)
+{
+	return b_putblk(b, ist.ptr, ist.len);
+}
+
+#endif /* _COMMON_ISTBUF_H */
+
+/*
+ * Local variables:
+ *  c-indent-level: 8
+ *  c-basic-offset: 8
+ * End:
+ */