diff --git a/include/proto/channel.h b/include/proto/channel.h
index c6ab718..2f2a913 100644
--- a/include/proto/channel.h
+++ b/include/proto/channel.h
@@ -34,21 +34,22 @@
 
 #include <types/global.h>
 
-extern struct pool_head *pool2_buffer;
+extern struct pool_head *pool2_channel;
 
 /* perform minimal intializations, report 0 in case of error, 1 if OK. */
-int init_buffer();
+int init_channel();
 
-/* SI-to-buffer functions : buffer_{get,put}_{char,block,string,chunk} */
-int bo_inject(struct channel *buf, const char *msg, int len);
+unsigned long long channel_forward(struct channel *buf, unsigned long long bytes);
+
+/* SI-to-channel functions working with buffers */
 int bi_putblk(struct channel *buf, const char *str, int len);
 int bi_putchr(struct channel *buf, char c);
+int bo_inject(struct channel *buf, const char *msg, int len);
 int bo_getline(struct channel *buf, char *str, int len);
 int bo_getblk(struct channel *buf, char *blk, int len, int offset);
-unsigned long long buffer_forward(struct channel *buf, unsigned long long bytes);
 
-/* Initialize all fields in the buffer. */
-static inline void buffer_init(struct channel *buf)
+/* Initialize all fields in the channel. */
+static inline void channel_init(struct channel *buf)
 {
 	buf->buf.o = 0;
 	buf->buf.i = 0;
@@ -61,9 +62,9 @@
 	buf->flags = 0;
 }
 
-/*****************************************************************/
-/* These functions are used to compute various buffer area sizes */
-/*****************************************************************/
+/*********************************************************************/
+/* These functions are used to compute various channel content sizes */
+/*********************************************************************/
 
 /* Reports non-zero if the channel is empty, which means both its
  * buffer and pipe are empty. The construct looks strange but is
@@ -75,31 +76,6 @@
 	return !(c->buf.o | (long)c->pipe);
 }
 
-/* Return the number of reserved bytes in the buffer, which ensures that once
- * all pending data are forwarded, the buffer still has global.tune.maxrewrite
- * bytes free. The result is between 0 and global.maxrewrite, which is itself
- * smaller than any buf->size.
- */
-static inline int buffer_reserved(const struct channel *buf)
-{
-	int ret = global.tune.maxrewrite - buf->to_forward - buf->buf.o;
-
-	if (buf->to_forward == CHN_INFINITE_FORWARD)
-		return 0;
-	if (ret <= 0)
-		return 0;
-	return ret;
-}
-
-/* Return the max number of bytes the buffer can contain so that once all the
- * pending bytes are forwarded, the buffer still has global.tune.maxrewrite
- * bytes free. The result sits between buf->size - maxrewrite and buf->size.
- */
-static inline int buffer_max_len(const struct channel *buf)
-{
-	return buf->buf.size - buffer_reserved(buf);
-}
-
 /* Returns non-zero if the buffer input is considered full. The reserved space
  * is taken into account if ->to_forward indicates that an end of transfer is
  * close to happen. The test is optimized to avoid as many operations as
@@ -125,64 +101,24 @@
 	return rem <= 0;
 }
 
-/* Returns the amount of space available at the input of the buffer, taking the
- * reserved space into account if ->to_forward indicates that an end of transfer
- * is close to happen. The test is optimized to avoid as many operations as
- * possible for the fast case.
- */
-static inline int bi_avail(const struct channel *b)
-{
-	int rem = b->buf.size;
-	int rem2;
-
-	rem -= b->buf.o;
-	rem -= b->buf.i;
-	if (!rem)
-		return rem; /* buffer already full */
-
-	if (b->to_forward >= b->buf.size ||
-	    (CHN_INFINITE_FORWARD < MAX_RANGE(typeof(b->buf.size)) && // just there to ensure gcc
-	     b->to_forward == CHN_INFINITE_FORWARD))              // avoids the useless second
-		return rem;                                         // test whenever possible
-
-	rem2 = rem - global.tune.maxrewrite;
-	rem2 += b->buf.o;
-	rem2 += b->to_forward;
-
-	if (rem > rem2)
-		rem = rem2;
-	if (rem > 0)
-		return rem;
-	return 0;
-}
-
-/* Return the amount of bytes that can be written into the buffer at once,
- * excluding reserved space, which is preserved.
- */
-static inline int buffer_contig_space_res(const struct channel *chn)
-{
-	return buffer_contig_space_with_res(&chn->buf, buffer_reserved(chn));
-}
-
-/* Returns true if the buffer's input is already closed */
-static inline int buffer_input_closed(struct channel *buf)
+/* Returns true if the channel's input is already closed */
+static inline int channel_input_closed(struct channel *buf)
 {
 	return ((buf->flags & CF_SHUTR) != 0);
 }
 
-/* Returns true if the buffer's output is already closed */
-static inline int buffer_output_closed(struct channel *buf)
+/* Returns true if the channel's output is already closed */
+static inline int channel_output_closed(struct channel *buf)
 {
 	return ((buf->flags & CF_SHUTW) != 0);
 }
 
-/* Check buffer timeouts, and set the corresponding flags. The
- * likely/unlikely have been optimized for fastest normal path.
- * The read/write timeouts are not set if there was activity on the buffer.
- * That way, we don't have to update the timeout on every I/O. Note that the
- * analyser timeout is always checked.
+/* Check channel timeouts, and set the corresponding flags. The likely/unlikely
+ * have been optimized for fastest normal path. The read/write timeouts are not
+ * set if there was activity on the channel. That way, we don't have to update
+ * the timeout on every I/O. Note that the analyser timeout is always checked.
  */
-static inline void buffer_check_timeouts(struct channel *b)
+static inline void channel_check_timeouts(struct channel *b)
 {
 	if (likely(!(b->flags & (CF_SHUTR|CF_READ_TIMEOUT|CF_READ_ACTIVITY|CF_READ_NOEXP))) &&
 	    unlikely(tick_is_expired(b->rex, now_ms)))
@@ -197,11 +133,11 @@
 		b->flags |= CF_ANA_TIMEOUT;
 }
 
-/* Erase any content from buffer <buf> and adjusts flags accordingly. Note
+/* Erase any content from channel <buf> and adjusts flags accordingly. Note
  * that any spliced data is not affected since we may not have any access to
  * it.
  */
-static inline void buffer_erase(struct channel *buf)
+static inline void channel_erase(struct channel *buf)
 {
 	buf->buf.o = 0;
 	buf->buf.i = 0;
@@ -209,48 +145,31 @@
 	buf->buf.p = buf->buf.data;
 }
 
-/* Cut the "tail" of the buffer, which means strip it to the length of unsent
- * data only, and kill any remaining unsent data. Any scheduled forwarding is
- * stopped. This is mainly to be used to send error messages after existing
- * data.
- */
-static inline void bi_erase(struct channel *buf)
-{
-	if (!buf->buf.o)
-		return buffer_erase(buf);
-
-	buf->to_forward = 0;
-	if (!buf->buf.i)
-		return;
-
-	buf->buf.i = 0;
-}
-
-/* marks the buffer as "shutdown" ASAP for reads */
-static inline void buffer_shutr_now(struct channel *buf)
+/* marks the channel as "shutdown" ASAP for reads */
+static inline void channel_shutr_now(struct channel *buf)
 {
 	buf->flags |= CF_SHUTR_NOW;
 }
 
-/* marks the buffer as "shutdown" ASAP for writes */
-static inline void buffer_shutw_now(struct channel *buf)
+/* marks the channel as "shutdown" ASAP for writes */
+static inline void channel_shutw_now(struct channel *buf)
 {
 	buf->flags |= CF_SHUTW_NOW;
 }
 
-/* marks the buffer as "shutdown" ASAP in both directions */
-static inline void buffer_abort(struct channel *buf)
+/* marks the channel as "shutdown" ASAP in both directions */
+static inline void channel_abort(struct channel *buf)
 {
 	buf->flags |= CF_SHUTR_NOW | CF_SHUTW_NOW;
 	buf->flags &= ~CF_AUTO_CONNECT;
 }
 
-/* Installs <func> as a hijacker on the buffer <b> for session <s>. The hijack
+/* Installs <func> as a hijacker on the channel <b> for session <s>. The hijack
  * flag is set, and the function called once. The function is responsible for
  * clearing the hijack bit. It is possible that the function clears the flag
  * during this first call.
  */
-static inline void buffer_install_hijacker(struct session *s,
+static inline void channel_install_hijacker(struct session *s,
 					   struct channel *b,
 					   void (*func)(struct session *, struct channel *))
 {
@@ -259,14 +178,14 @@
 	func(s, b);
 }
 
-/* Releases the buffer from hijacking mode. Often used by the hijack function */
-static inline void buffer_stop_hijack(struct channel *buf)
+/* Releases the channel from hijacking mode. Often used by the hijack function */
+static inline void channel_stop_hijacker(struct channel *buf)
 {
 	buf->flags &= ~CF_HIJACK;
 }
 
 /* allow the consumer to try to establish a new connection. */
-static inline void buffer_auto_connect(struct channel *buf)
+static inline void channel_auto_connect(struct channel *buf)
 {
 	buf->flags |= CF_AUTO_CONNECT;
 }
@@ -274,40 +193,129 @@
 /* prevent the consumer from trying to establish a new connection, and also
  * disable auto shutdown forwarding.
  */
-static inline void buffer_dont_connect(struct channel *buf)
+static inline void channel_dont_connect(struct channel *buf)
 {
 	buf->flags &= ~(CF_AUTO_CONNECT|CF_AUTO_CLOSE);
 }
 
 /* allow the producer to forward shutdown requests */
-static inline void buffer_auto_close(struct channel *buf)
+static inline void channel_auto_close(struct channel *buf)
 {
 	buf->flags |= CF_AUTO_CLOSE;
 }
 
 /* prevent the producer from forwarding shutdown requests */
-static inline void buffer_dont_close(struct channel *buf)
+static inline void channel_dont_close(struct channel *buf)
 {
 	buf->flags &= ~CF_AUTO_CLOSE;
 }
 
 /* allow the producer to read / poll the input */
-static inline void buffer_auto_read(struct channel *buf)
+static inline void channel_auto_read(struct channel *buf)
 {
 	buf->flags &= ~CF_DONT_READ;
 }
 
 /* prevent the producer from read / poll the input */
-static inline void buffer_dont_read(struct channel *buf)
+static inline void channel_dont_read(struct channel *buf)
 {
 	buf->flags |= CF_DONT_READ;
 }
 
+
+/*************************************************/
+/* Buffer operations in the context of a channel */
+/*************************************************/
+
+
+/* Return the number of reserved bytes in the channel's visible
+ * buffer, which ensures that once all pending data are forwarded, the
+ * buffer still has global.tune.maxrewrite bytes free. The result is
+ * between 0 and global.tune.maxrewrite, which is itself smaller than
+ * any buf->size.
+ */
+static inline int buffer_reserved(const struct channel *buf)
+{
+	int ret = global.tune.maxrewrite - buf->to_forward - buf->buf.o;
+
+	if (buf->to_forward == CHN_INFINITE_FORWARD)
+		return 0;
+	if (ret <= 0)
+		return 0;
+	return ret;
+}
+
+/* Return the max number of bytes the buffer can contain so that once all the
+ * pending bytes are forwarded, the buffer still has global.tune.maxrewrite
+ * bytes free. The result sits between buf->size - maxrewrite and buf->size.
+ */
+static inline int buffer_max_len(const struct channel *buf)
+{
+	return buf->buf.size - buffer_reserved(buf);
+}
+
+/* Return the amount of bytes that can be written into the buffer at once,
+ * excluding reserved space, which is preserved.
+ */
+static inline int buffer_contig_space_res(const struct channel *chn)
+{
+	return buffer_contig_space_with_res(&chn->buf, buffer_reserved(chn));
+}
+
+/* Returns the amount of space available at the input of the buffer, taking the
+ * reserved space into account if ->to_forward indicates that an end of transfer
+ * is close to happen. The test is optimized to avoid as many operations as
+ * possible for the fast case.
+ */
+static inline int bi_avail(const struct channel *b)
+{
+	int rem = b->buf.size;
+	int rem2;
+
+	rem -= b->buf.o;
+	rem -= b->buf.i;
+	if (!rem)
+		return rem; /* buffer already full */
+
+	if (b->to_forward >= b->buf.size ||
+	    (CHN_INFINITE_FORWARD < MAX_RANGE(typeof(b->buf.size)) && // just there to ensure gcc
+	     b->to_forward == CHN_INFINITE_FORWARD))              // avoids the useless second
+		return rem;                                         // test whenever possible
+
+	rem2 = rem - global.tune.maxrewrite;
+	rem2 += b->buf.o;
+	rem2 += b->to_forward;
+
+	if (rem > rem2)
+		rem = rem2;
+	if (rem > 0)
+		return rem;
+	return 0;
+}
+
+/* Cut the "tail" of the channel's buffer, which means strip it to the length
+ * of unsent data only, and kill any remaining unsent data. Any scheduled
+ * forwarding is stopped. This is mainly to be used to send error messages
+ * after existing data.
+ */
+static inline void bi_erase(struct channel *buf)
+{
+	if (!buf->buf.o)
+		return channel_erase(buf);
+
+	buf->to_forward = 0;
+	if (!buf->buf.i)
+		return;
+
+	buf->buf.i = 0;
+}
+
 /*
- * Advance the buffer's read pointer by <len> bytes. This is useful when data
- * have been read directly from the buffer. It is illegal to call this function
- * with <len> causing a wrapping at the end of the buffer. It's the caller's
- * responsibility to ensure that <len> is never larger than buf->o.
+ * Advance the channel buffer's read pointer by <len> bytes. This is useful
+ * when data have been read directly from the buffer. It is illegal to call
+ * this function with <len> causing a wrapping at the end of the buffer. It's
+ * the caller's responsibility to ensure that <len> is never larger than
+ * buf->o. Channel flag WRITE_PARTIAL is set.
  */
 static inline void bo_skip(struct channel *buf, int len)
 {
@@ -320,12 +328,12 @@
 	buf->flags |= CF_WRITE_PARTIAL;
 }
 
-/* Tries to copy chunk <chunk> into buffer <buf> after length controls.
- * The ->o and to_forward pointers are updated. If the buffer's input is
+/* Tries to copy chunk <chunk> into the channel's buffer after length controls.
+ * The buf->o and to_forward pointers are updated. If the channel's input is
  * closed, -2 is returned. If the block is too large for this buffer, -3 is
  * returned. If there is not enough room left in the buffer, -1 is returned.
  * Otherwise the number of bytes copied is returned (0 being a valid number).
- * Buffer flag READ_PARTIAL is updated if some data can be transferred. The
+ * Channel flag READ_PARTIAL is updated if some data can be transferred. The
  * chunk's length is updated with the number of bytes sent.
  */
 static inline int bi_putchk(struct channel *buf, struct chunk *chunk)
@@ -338,12 +346,13 @@
 	return ret;
 }
 
-/* Tries to copy string <str> at once into buffer <buf> after length controls.
- * The ->o and to_forward pointers are updated. If the buffer's input is
- * closed, -2 is returned. If the block is too large for this buffer, -3 is
- * returned. If there is not enough room left in the buffer, -1 is returned.
- * Otherwise the number of bytes copied is returned (0 being a valid number).
- * Buffer flag READ_PARTIAL is updated if some data can be transferred.
+/* Tries to copy string <str> at once into the channel's buffer after length
+ * controls.  The buf->o and to_forward pointers are updated. If the channel's
+ * input is closed, -2 is returned. If the block is too large for this buffer,
+ * -3 is returned. If there is not enough room left in the buffer, -1 is
+ * returned.  Otherwise the number of bytes copied is returned (0 being a valid
+ * number).  Channel flag READ_PARTIAL is updated if some data can be
+ * transferred.
  */
 static inline int bi_putstr(struct channel *buf, const char *str)
 {
@@ -351,10 +360,11 @@
 }
 
 /*
- * Return one char from the buffer. If the buffer is empty and closed, return -2.
- * If the buffer is just empty, return -1. The buffer's pointer is not advanced,
- * it's up to the caller to call bo_skip(buf, 1) when it has consumed the char.
- * Also note that this function respects the ->o limit.
+ * Return one char from the channel's buffer. If the buffer is empty and the
+ * channel is closed, return -2. If the buffer is just empty, return -1. The
+ * buffer's pointer is not advanced, it's up to the caller to call bo_skip(buf,
+ * 1) when it has consumed the char.  Also note that this function respects the
+ * buf->o limit.
  */
 static inline int bo_getchr(struct channel *buf)
 {
diff --git a/include/types/channel.h b/include/types/channel.h
index 2ef3b3e..c68f4f7 100644
--- a/include/types/channel.h
+++ b/include/types/channel.h
@@ -137,7 +137,7 @@
  * Those bits indicate that there are some processing to do on the buffer
  * contents. It will probably evolve into a linked list later. Those
  * analysers could be compared to higher level processors.
- * The field is blanked by buffer_init() and only by analysers themselves
+ * The field is blanked by channel_init() and only by analysers themselves
  * afterwards.
  */
 #define AN_REQ_DECODE_PROXY     0x00000001  /* take the proxied address from a 'PROXY' line */