diff --git a/include/proto/buffers.h b/include/proto/buffers.h
index fc84ad645..bb2dd45ee 100644
--- a/include/proto/buffers.h
+++ b/include/proto/buffers.h
@@ -55,8 +55,9 @@ unsigned long long buffer_forward(struct buffer *buf, unsigned long long bytes);
 static inline void buffer_init(struct buffer *buf)
 {
 	buf->o = 0;
+	buf->i = 0;
 	buf->to_forward = 0;
-	buf->l = buf->total = 0;
+	buf->total = 0;
 	buf->pipe = NULL;
 	buf->analysers = 0;
 	buf->cons = NULL;
@@ -68,6 +69,24 @@ static inline void buffer_init(struct buffer *buf)
 /* These functions are used to compute various buffer area sizes */
 /*****************************************************************/
 
+/* Return the buffer's length in bytes by summing the input and the output */
+static inline int buffer_len(const struct buffer *buf)
+{
+	return buf->i + buf->o;
+}
+
+/* Return non-zero only if the buffer is not empty */
+static inline int buffer_not_empty(const struct buffer *buf)
+{
+	return buf->i | buf->o;
+}
+
+/* Return non-zero only if the buffer is empty */
+static inline int buffer_empty(const struct buffer *buf)
+{
+	return !buffer_not_empty(buf);
+}
+
 /* 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
@@ -98,7 +117,7 @@ static inline int buffer_max_len(const struct buffer *buf)
  */
 static inline int buffer_total_space(const struct buffer *buf)
 {
-	return buf->size - buf->l;
+	return buf->size - buffer_len(buf);
 }
 
 /* Return the maximum amount of bytes that can be written into the buffer,
@@ -107,7 +126,7 @@ static inline int buffer_total_space(const struct buffer *buf)
  */
 static inline int buffer_total_space_res(const struct buffer *buf)
 {
-	int len = buffer_max_len(buf) - buf->l;
+	int len = buffer_max_len(buf) - buffer_len(buf);
 	return len < 0 ? 0 : len;
 }
 
@@ -129,7 +148,7 @@ static inline int buffer_contig_area(const struct buffer *buf, const char *start
  */
 static inline int buffer_contig_space(const struct buffer *buf)
 {
-	int space_from_end = buf->l - (buf->r - buf->data);
+	int space_from_end = buffer_len(buf) - (buf->r - buf->data);
 	if (space_from_end < 0) /* data does not wrap */
 		space_from_end = buf->r - buf->data;
 	return buf->size - space_from_end;
@@ -148,9 +167,9 @@ static inline int buffer_contig_space_res(const struct buffer *buf)
 	int res = buffer_reserved(buf);
 	int spare = buf->size - res;
 
-	if (buf->l >= spare)
+	if (buffer_len(buf) >= spare)
 		spare = 0;
-	else if (buf->l) {
+	else if (buffer_len(buf)) {
 		spare = buf->w - res - buf->r;
 		if (spare <= 0)
 			spare += buf->size;
@@ -171,9 +190,9 @@ static inline int buffer_contig_space_with_res(const struct buffer *buf, int res
 	 */
 	int spare = buf->size - res;
 
-	if (buf->l >= spare)
+	if (buffer_len(buf) >= spare)
 		spare = 0;
-	else if (buf->l) {
+	else if (buffer_len(buf)) {
 		spare = buf->w - res - buf->r;
 		if (spare <= 0)
 			spare += buf->size;
@@ -213,7 +232,7 @@ static inline int buffer_count(const struct buffer *buf, const char *from, const
  */
 static inline int buffer_pending(const struct buffer *buf)
 {
-	return buf->l - buf->o;
+	return buf->i;
 }
 
 /* Returns the size of the working area which the caller knows ends at <end>.
@@ -248,7 +267,7 @@ static inline int buffer_contig_data(struct buffer *buf)
 {
 	int ret;
 
-	if (!buf->o || !buf->l)
+	if (!buf->o)
 		return 0;
 
 	if (buf->r > buf->w)
@@ -302,8 +321,8 @@ static inline void buffer_check_timeouts(struct buffer *b)
  */
 static inline void buffer_flush(struct buffer *buf)
 {
-	if (buf->o < buf->l)
-		buf->o = buf->l;
+	buf->o += buf->i;
+	buf->i = 0;
 	if (buf->o)
 		buf->flags &= ~BF_OUT_EMPTY;
 }
@@ -315,9 +334,9 @@ static inline void buffer_flush(struct buffer *buf)
 static inline void buffer_erase(struct buffer *buf)
 {
 	buf->o = 0;
+	buf->i = 0;
 	buf->to_forward = 0;
 	buf->r = buf->lr = buf->w = buf->data;
-	buf->l = 0;
 	buf->flags &= ~(BF_FULL | BF_OUT_EMPTY);
 	if (!buf->pipe)
 		buf->flags |= BF_OUT_EMPTY;
@@ -334,16 +353,16 @@ static inline void buffer_cut_tail(struct buffer *buf)
 		return buffer_erase(buf);
 
 	buf->to_forward = 0;
-	if (buf->l == buf->o)
+	if (!buf->i)
 		return;
 
-	buf->l = buf->o;
-	buf->r = buf->w + buf->l;
+	buf->i = 0;
+	buf->r = buf->w + buf->o;
 	if (buf->r >= buf->data + buf->size)
 		buf->r -= buf->size;
 	buf->lr = buf->r;
 	buf->flags &= ~BF_FULL;
-	if (buf->l >= buffer_max_len(buf))
+	if (buffer_len(buf) >= buffer_max_len(buf))
 		buf->flags |= BF_FULL;
 }
 
@@ -353,12 +372,12 @@ static inline void buffer_cut_tail(struct buffer *buf)
  */
 static inline void buffer_ignore(struct buffer *buf, int n)
 {
-	buf->l -= n;
+	buf->i -= n;
 	buf->w += n;
 	if (buf->w >= buf->data + buf->size)
 		buf->w -= buf->size;
 	buf->flags &= ~BF_FULL;
-	if (buf->l >= buffer_max_len(buf))
+	if (buffer_len(buf) >= buffer_max_len(buf))
 		buf->flags |= BF_FULL;
 }
 
@@ -445,7 +464,7 @@ static inline void buffer_dont_read(struct buffer *buf)
  */
 static inline int buffer_realign(struct buffer *buf)
 {
-	if (buf->l == 0) {
+	if (!(buf->i | buf->o)) {
 		/* let's realign the buffer to optimize I/O */
 		buf->r = buf->w = buf->lr = buf->data;
 	}
@@ -464,14 +483,13 @@ static inline void buffer_skip(struct buffer *buf, int len)
 	if (buf->w >= buf->data + buf->size)
 		buf->w -= buf->size; /* wrap around the buffer */
 
-	buf->l -= len;
-	if (!buf->l)
+	buf->o -= len;
+	if (buffer_len(buf) == 0)
 		buf->r = buf->w = buf->lr = buf->data;
 
-	if (buf->l < buffer_max_len(buf))
+	if (buffer_len(buf) < buffer_max_len(buf))
 		buf->flags &= ~BF_FULL;
 
-	buf->o -= len;
 	if (!buf->o && !buf->pipe)
 		buf->flags |= BF_OUT_EMPTY;
 
diff --git a/include/types/buffers.h b/include/types/buffers.h
index b6f09841f..cc394b25d 100644
--- a/include/types/buffers.h
+++ b/include/types/buffers.h
@@ -180,9 +180,9 @@ struct buffer {
 	int wex;                        /* expiration date for a write or connect, in ticks */
 	int rto;                        /* read timeout, in ticks */
 	int wto;                        /* write timeout, in ticks */
-	unsigned int l;                 /* data length */
 	char *r, *w, *lr;               /* read ptr, write ptr, last read */
 	unsigned int size;              /* buffer size in bytes */
+	unsigned int i;                 /* number of input bytes pending for analysis in the buffer */
 	unsigned int o;                 /* number of out bytes the sender can consume from this buffer */
 	unsigned int to_forward;        /* number of bytes to forward after out without a wake-up */
 	unsigned int analysers;         /* bit field indicating what to do on the buffer */
diff --git a/src/acl.c b/src/acl.c
index 46307434c..430f985d7 100644
--- a/src/acl.c
+++ b/src/acl.c
@@ -102,7 +102,7 @@ acl_fetch_req_len(struct proxy *px, struct session *l4, void *l7, int dir,
 	if (!l4 || !l4->req)
 		return 0;
 
-	temp_pattern.data.integer = l4->req->l;
+	temp_pattern.data.integer = l4->req->i;
 	test->flags = ACL_TEST_F_VOLATILE | ACL_TEST_F_MAY_CHANGE;
 	return 1;
 }
@@ -122,7 +122,7 @@ acl_fetch_ssl_hello_type(struct proxy *px, struct session *l4, void *l7, int dir
 
 	b = ((dir & ACL_DIR_MASK) == ACL_DIR_RTR) ? l4->rep : l4->req;
 
-	bleft = b->l;
+	bleft = b->i;
 	data = (const unsigned char *)b->w;
 
 	if (!bleft)
@@ -187,7 +187,7 @@ acl_fetch_req_ssl_ver(struct proxy *px, struct session *l4, void *l7, int dir,
 		return 0;
 
 	msg_len = 0;
-	bleft = l4->req->l;
+	bleft = l4->req->i;
 	if (!bleft)
 		goto too_short;
 
@@ -324,7 +324,7 @@ acl_fetch_ssl_hello_sni(struct proxy *px, struct session *l4, void *l7, int dir,
 
 	b = ((dir & ACL_DIR_MASK) == ACL_DIR_RTR) ? l4->rep : l4->req;
 
-	bleft = b->l;
+	bleft = b->i;
 	data = (unsigned char *)b->w;
 
 	/* Check for SSL/TLS Handshake */
@@ -459,7 +459,7 @@ acl_fetch_rdp_cookie(struct proxy *px, struct session *l4, void *l7, int dir,
 
 	test->flags = 0;
 
-	bleft = l4->req->l;
+	bleft = l4->req->i;
 	if (bleft <= 11)
 		goto too_short;
 
diff --git a/src/backend.c b/src/backend.c
index 57acbe77f..f04e26b4d 100644
--- a/src/backend.c
+++ b/src/backend.c
@@ -257,8 +257,8 @@ struct server *get_server_ph_post(struct session *s)
 	const char      *params = req->data + msg->sov;
 	const char      *p    = params;
 
-	if (len > req->l - (msg->sov - msg->som))
-		len = req->l - (msg->sov - msg->som);
+	if (len > req->i - (msg->sov - msg->som))
+		len = req->i - (msg->sov - msg->som);
 
 	if (len == 0)
 		return NULL;
@@ -1112,13 +1112,13 @@ int tcp_persist_rdp_cookie(struct session *s, struct buffer *req, int an_bit)
 	struct sockaddr_in addr;
 	char *p;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i,
 		req->analysers);
 
 	if (s->flags & SN_ASSIGNED)
diff --git a/src/buffers.c b/src/buffers.c
index 0697d6197..74e3a1069 100644
--- a/src/buffers.c
+++ b/src/buffers.c
@@ -40,40 +40,43 @@ int init_buffer()
  */
 unsigned long long buffer_forward(struct buffer *buf, unsigned long long bytes)
 {
-	unsigned int data_left;
 	unsigned int new_forward;
+	unsigned int forwarded;
 
 	if (!bytes)
 		return 0;
-	data_left = buf->l - buf->o;
-	if (bytes <= (unsigned long long)data_left) {
+	if (bytes <= (unsigned long long)buf->i) {
 		buf->o += bytes;
+		buf->i -= bytes;
 		buf->flags &= ~BF_OUT_EMPTY;
 		return bytes;
 	}
 
-	buf->o += data_left;
+	forwarded = buf->i;
+	buf->o += forwarded;
+	buf->i = 0;
+
 	if (buf->o)
 		buf->flags &= ~BF_OUT_EMPTY;
 
-	if (buf->l < buffer_max_len(buf))
+	if (buf->o < buffer_max_len(buf))
 		buf->flags &= ~BF_FULL;
 	else
 		buf->flags |= BF_FULL;
 
-	if (likely(bytes == BUF_INFINITE_FORWARD)) {
-		buf->to_forward = bytes;
-		return bytes;
-	}
-
 	/* Note: the case below is the only case where we may return
 	 * a byte count that does not fit into a 32-bit number.
 	 */
 	if (likely(buf->to_forward == BUF_INFINITE_FORWARD))
 		return bytes;
 
-	new_forward = buf->to_forward + bytes - data_left;
-	bytes = data_left; /* at least those bytes were scheduled */
+	if (likely(bytes == BUF_INFINITE_FORWARD)) {
+		buf->to_forward = bytes;
+		return bytes;
+	}
+
+	new_forward = buf->to_forward + bytes - forwarded;
+	bytes = forwarded; /* at least those bytes were scheduled */
 
 	if (new_forward <= buf->to_forward) {
 		/* integer overflow detected, let's assume no more than 2G at once */
@@ -114,7 +117,6 @@ int buffer_write(struct buffer *buf, const char *msg, int len)
 		return max;
 
 	memcpy(buf->r, msg, len);
-	buf->l += len;
 	buf->o += len;
 	buf->r += len;
 	buf->total += len;
@@ -122,7 +124,7 @@ int buffer_write(struct buffer *buf, const char *msg, int len)
 		buf->r = buf->data;
 
 	buf->flags &= ~(BF_OUT_EMPTY|BF_FULL);
-	if (buf->l >= buffer_max_len(buf))
+	if (buffer_len(buf) >= buffer_max_len(buf))
 		buf->flags |= BF_FULL;
 
 	return -1;
@@ -145,8 +147,8 @@ int buffer_put_char(struct buffer *buf, char c)
 
 	*buf->r = c;
 
-	buf->l++;
-	if (buf->l >= buffer_max_len(buf))
+	buf->i++;
+	if (buffer_len(buf) >= buffer_max_len(buf))
 		buf->flags |= BF_FULL;
 	buf->flags |= BF_READ_PARTIAL;
 
@@ -158,6 +160,7 @@ int buffer_put_char(struct buffer *buf, char c)
 		if (buf->to_forward != BUF_INFINITE_FORWARD)
 			buf->to_forward--;
 		buf->o++;
+		buf->i--;
 		buf->flags &= ~BF_OUT_EMPTY;
 	}
 
@@ -181,7 +184,7 @@ int buffer_put_block(struct buffer *buf, const char *blk, int len)
 		return -2;
 
 	max = buffer_max_len(buf);
-	if (unlikely(len > max - buf->l)) {
+	if (unlikely(len > max - buffer_len(buf))) {
 		/* we can't write this chunk right now because the buffer is
 		 * almost full or because the block is too large. Return the
 		 * available space or -2 if impossible.
@@ -201,7 +204,7 @@ int buffer_put_block(struct buffer *buf, const char *blk, int len)
 	if (len > max)
 		memcpy(buf->data, blk + max, len - max);
 
-	buf->l += len;
+	buf->i += len;
 	buf->r += len;
 	buf->total += len;
 	if (buf->to_forward) {
@@ -212,6 +215,7 @@ int buffer_put_block(struct buffer *buf, const char *blk, int len)
 			buf->to_forward -= fwd;
 		}
 		buf->o += fwd;
+		buf->i -= fwd;
 		buf->flags &= ~BF_OUT_EMPTY;
 	}
 
@@ -219,7 +223,7 @@ int buffer_put_block(struct buffer *buf, const char *blk, int len)
 		buf->r -= buf->size;
 
 	buf->flags &= ~BF_FULL;
-	if (buf->l >= buffer_max_len(buf))
+	if (buffer_len(buf) >= buffer_max_len(buf))
 		buf->flags |= BF_FULL;
 
 	/* notify that some data was read from the SI into the buffer */
@@ -334,7 +338,7 @@ int buffer_replace2(struct buffer *b, char *pos, char *end, const char *str, int
 	if (delta + b->r >= b->data + b->size)
 		return 0;  /* no space left */
 
-	if (delta + b->r > b->w && b->w >= b->r && b->l)
+	if (delta + b->r > b->w && b->w >= b->r && buffer_not_empty(b))
 		return 0;  /* no space left before wrapping data */
 
 	/* first, protect the end of the buffer */
@@ -347,12 +351,12 @@ int buffer_replace2(struct buffer *b, char *pos, char *end, const char *str, int
 	/* we only move data after the displaced zone */
 	if (b->r  > pos) b->r  += delta;
 	if (b->lr > pos) b->lr += delta;
-	b->l += delta;
+	b->i += delta;
 
 	b->flags &= ~BF_FULL;
-	if (b->l == 0)
+	if (buffer_len(b) == 0)
 		b->r = b->w = b->lr = b->data;
-	if (b->l >= buffer_max_len(b))
+	if (buffer_len(b) >= buffer_max_len(b))
 		b->flags |= BF_FULL;
 
 	return delta;
@@ -389,10 +393,10 @@ int buffer_insert_line2(struct buffer *b, char *pos, const char *str, int len)
 	/* we only move data after the displaced zone */
 	if (b->r  > pos) b->r  += delta;
 	if (b->lr > pos) b->lr += delta;
-	b->l += delta;
+	b->i += delta;
 
 	b->flags &= ~BF_FULL;
-	if (b->l >= buffer_max_len(b))
+	if (buffer_len(b) >= buffer_max_len(b))
 		b->flags |= BF_FULL;
 
 	return delta;
@@ -415,7 +419,7 @@ void buffer_bounce_realign(struct buffer *buf)
 		return;
 
 	from = buf->w;
-	to_move = buf->l;
+	to_move = buffer_len(buf);
 	while (to_move) {
 		char last, save;
 
@@ -572,11 +576,11 @@ int chunk_asciiencode(struct chunk *dst, struct chunk *src, char qc) {
 void buffer_dump(FILE *o, struct buffer *b, int from, int to)
 {
 	fprintf(o, "Dumping buffer %p\n", b);
-	fprintf(o, "  data=%p l=%d r=%p w=%p lr=%p\n",
-		b->data, b->l, b->r, b->w, b->lr);
+	fprintf(o, "  data=%p o=%d i=%d r=%p w=%p lr=%p\n",
+		b->data, b->o, b->i, b->r, b->w, b->lr);
 
-	if (!to || to > b->l)
-		to = b->l;
+	if (!to || to > buffer_len(b))
+		to = buffer_len(b);
 
 	fprintf(o, "Dumping contents from byte %d to byte %d\n", from, to);
 	for (; from < to; from++) {
diff --git a/src/dumpstats.c b/src/dumpstats.c
index 907e2fe0f..26cbdd6fb 100644
--- a/src/dumpstats.c
+++ b/src/dumpstats.c
@@ -1540,9 +1540,9 @@ static void cli_io_handler(struct stream_interface *si)
 	si->ob->wex = TICK_ETERNITY;
 
  out:
-	DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rql=%d, rqs=%d, rl=%d, rs=%d\n",
+	DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rqh=%d, rqs=%d, rh=%d, rs=%d\n",
 		__FUNCTION__, __LINE__,
-		si->state, req->flags, res->flags, req->l, req->o, res->l, res->o);
+		si->state, req->flags, res->flags, req->i, req->o, res->i, res->o);
 
 	if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO)) {
 		/* check that we have released everything then unregister */
@@ -3370,11 +3370,11 @@ static int stats_dump_full_sess_to_buffer(struct stream_interface *si)
 
 
 		chunk_printf(&msg,
-			     "  req=%p (f=0x%06x an=0x%x l=%d o=%d pipe=%d fwd=%d)\n"
+			     "  req=%p (f=0x%06x an=0x%x i=%d o=%d pipe=%d fwd=%d)\n"
 			     "      an_exp=%s",
 			     sess->req,
 			     sess->req->flags, sess->req->analysers,
-			     sess->req->l, sess->req->o,
+			     sess->req->i, sess->req->o,
 			     sess->req->pipe ? sess->req->pipe->data : 0,
 			     sess->req->to_forward,
 			     sess->req->analyse_exp ?
@@ -3400,11 +3400,11 @@ static int stats_dump_full_sess_to_buffer(struct stream_interface *si)
 			     sess->req->total);
 
 		chunk_printf(&msg,
-			     "  res=%p (f=0x%06x an=0x%x l=%d o=%d pipe=%d fwd=%d)\n"
+			     "  res=%p (f=0x%06x an=0x%x i=%d o=%d pipe=%d fwd=%d)\n"
 			     "      an_exp=%s",
 			     sess->rep,
 			     sess->rep->flags, sess->rep->analysers,
-			     sess->rep->l, sess->rep->o,
+			     sess->rep->i, sess->rep->o,
 			     sess->rep->pipe ? sess->rep->pipe->data : 0,
 			     sess->rep->to_forward,
 			     sess->rep->analyse_exp ?
@@ -3544,9 +3544,9 @@ static int stats_dump_sess_to_buffer(struct stream_interface *si)
 				     curr_sess->task->calls);
 
 			chunk_printf(&msg,
-				     " rq[f=%06xh,l=%d,an=%02xh,rx=%s",
+				     " rq[f=%06xh,i=%d,an=%02xh,rx=%s",
 				     curr_sess->req->flags,
-				     curr_sess->req->l,
+				     curr_sess->req->i,
 				     curr_sess->req->analysers,
 				     curr_sess->req->rex ?
 				     human_time(TICKS_TO_MS(curr_sess->req->rex - now_ms),
@@ -3565,9 +3565,9 @@ static int stats_dump_sess_to_buffer(struct stream_interface *si)
 						TICKS_TO_MS(1000)) : "");
 
 			chunk_printf(&msg,
-				     " rp[f=%06xh,l=%d,an=%02xh,rx=%s",
+				     " rp[f=%06xh,i=%d,an=%02xh,rx=%s",
 				     curr_sess->rep->flags,
-				     curr_sess->rep->l,
+				     curr_sess->rep->i,
 				     curr_sess->rep->analysers,
 				     curr_sess->rep->rex ?
 				     human_time(TICKS_TO_MS(curr_sess->rep->rex - now_ms),
diff --git a/src/frontend.c b/src/frontend.c
index e5d847bc9..c18cc66c5 100644
--- a/src/frontend.c
+++ b/src/frontend.c
@@ -253,22 +253,22 @@ int frontend_accept(struct session *s)
 int frontend_decode_proxy_request(struct session *s, struct buffer *req, int an_bit)
 {
 	char *line = req->data;
-	char *end = req->data + req->l;
+	char *end = req->data + req->i;
 	int len;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i,
 		req->analysers);
 
 	if (req->flags & (BF_READ_ERROR|BF_READ_TIMEOUT))
 		goto fail;
 
-	len = MIN(req->l, 6);
+	len = MIN(req->i, 6);
 	if (!len)
 		goto missing;
 
@@ -277,7 +277,7 @@ int frontend_decode_proxy_request(struct session *s, struct buffer *req, int an_
 		goto fail;
 
 	line += 6;
-	if (req->l < 18) /* shortest possible line */
+	if (req->i < 18) /* shortest possible line */
 		goto missing;
 
 	if (!memcmp(line, "TCP4 ", 5) != 0) {
diff --git a/src/proto_http.c b/src/proto_http.c
index 0b6207866..f1167c114 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -1944,7 +1944,7 @@ int http_skip_chunk_crlf(struct buffer *buf, struct http_msg *msg)
 			ptr = buf->data;
 	}
 
-	if (bytes > buf->l - buf->o)
+	if (bytes > buf->i)
 		return 0;
 
 	if (*ptr != '\n') {
@@ -1972,8 +1972,8 @@ void http_buffer_heavy_realign(struct buffer *buf, struct http_msg *msg)
 	 *   - the buffer is in one contiguous block, we move it in-place
 	 *   - the buffer is in two blocks, we move it via the swap_buffer
 	 */
-	if (buf->l) {
-		int block1 = buf->l;
+	if (buf->i) {
+		int block1 = buf->i;
 		int block2 = 0;
 		if (buf->r <= buf->w) {
 			/* non-contiguous block */
@@ -2007,7 +2007,7 @@ void http_buffer_heavy_realign(struct buffer *buf, struct http_msg *msg)
 	}
 
 	buf->flags &= ~BF_FULL;
-	if (buf->l >= buffer_max_len(buf))
+	if (buffer_len(buf) >= buffer_max_len(buf))
 		buf->flags |= BF_FULL;
 }
 
@@ -2047,13 +2047,13 @@ int http_wait_for_request(struct session *s, struct buffer *req, int an_bit)
 	struct http_msg *msg = &txn->req;
 	struct hdr_ctx ctx;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i,
 		req->analysers);
 
 	/* we're speaking HTTP here, so let's speak HTTP to the client */
@@ -2064,7 +2064,7 @@ int http_wait_for_request(struct session *s, struct buffer *req, int an_bit)
 	 * protected area is affected, because we may have to move processed
 	 * data later, which is much more complicated.
 	 */
-	if (req->l && msg->msg_state < HTTP_MSG_ERROR) {
+	if (buffer_not_empty(req) && msg->msg_state < HTTP_MSG_ERROR) {
 		if ((txn->flags & TX_NOT_FIRST) &&
 		    unlikely((req->flags & BF_FULL) ||
 			     req->r < req->lr ||
@@ -2170,7 +2170,7 @@ int http_wait_for_request(struct session *s, struct buffer *req, int an_bit)
 			session_inc_http_err_ctr(s);
 			proxy_inc_fe_req_ctr(s->fe);
 			if (msg->err_pos < 0)
-				msg->err_pos = req->l;
+				msg->err_pos = req->i;
 			goto return_bad_req;
 		}
 
@@ -2592,7 +2592,7 @@ int http_process_req_stat_post(struct stream_interface *si, struct http_txn *txn
 		si->applet.ctx.stats.st_code = STAT_STATUS_EXCD;
 		return 1;
 	}
-	else if (end_params > req->data + req->l) {
+	else if (end_params > req->data + req->i) {
 		/* we need more data */
 		si->applet.ctx.stats.st_code = STAT_STATUS_NONE;
 		return 0;
@@ -2785,13 +2785,13 @@ int http_process_req_common(struct session *s, struct buffer *req, int an_bit, s
 	req->analysers &= ~an_bit;
 	req->analyse_exp = TICK_ETERNITY;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i,
 		req->analysers);
 
 	/* first check whether we have some ACLs set to block this request */
@@ -3242,13 +3242,13 @@ int http_process_request(struct session *s, struct buffer *req, int an_bit)
 		return 0;
 	}
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i,
 		req->analysers);
 
 	/*
@@ -3464,7 +3464,7 @@ int http_process_request(struct session *s, struct buffer *req, int an_bit)
 		 */
 		if ((s->listener->options & LI_O_NOQUICKACK) &&
 		    ((msg->flags & HTTP_MSGF_TE_CHNK) ||
-		     (msg->body_len > req->l - txn->req.eoh - 2)))
+		     (msg->body_len > req->i - txn->req.eoh - 2)))
 			setsockopt(s->si[0].fd, IPPROTO_TCP, TCP_QUICKACK, &one, sizeof(one));
 #endif
 	}
@@ -3623,7 +3623,7 @@ int http_process_request_body(struct session *s, struct buffer *req, int an_bit)
 	if (msg->body_len < limit)
 		limit = msg->body_len;
 
-	if (req->l - (msg->sov - msg->som) >= limit)    /* we have enough bytes now */
+	if (req->i - (msg->sov - msg->som) >= limit)    /* we have enough bytes now */
 		goto http_end;
 
  missing_data:
@@ -3755,8 +3755,8 @@ void http_end_txn_clean_session(struct session *s)
 	}
 
 	/* don't count other requests' data */
-	s->logs.bytes_in  -= s->req->l - s->req->o;
-	s->logs.bytes_out -= s->rep->l - s->rep->o;
+	s->logs.bytes_in  -= s->req->i;
+	s->logs.bytes_out -= s->rep->i;
 
 	/* let's do a final log if we need it */
 	if (s->logs.logwait &&
@@ -3775,8 +3775,8 @@ void http_end_txn_clean_session(struct session *s)
 	s->logs.prx_queue_size = 0;  /* we get the number of pending conns before us */
 	s->logs.srv_queue_size = 0; /* we will get this number soon */
 
-	s->logs.bytes_in = s->req->total = s->req->l - s->req->o;
-	s->logs.bytes_out = s->rep->total = s->rep->l - s->rep->o;
+	s->logs.bytes_in = s->req->total = s->req->i;
+	s->logs.bytes_out = s->rep->total = s->rep->i;
 
 	if (s->pend_pos)
 		pendconn_free(s->pend_pos);
@@ -3821,7 +3821,7 @@ void http_end_txn_clean_session(struct session *s)
 	 * because the request will wait for it to flush a little
 	 * bit before proceeding.
 	 */
-	if (s->req->l > s->req->o) {
+	if (s->req->i) {
 		if (s->rep->o &&
 		    !(s->rep->flags & BF_FULL) &&
 		    s->rep->r <= s->rep->data + s->rep->size - global.tune.maxrewrite)
@@ -4087,7 +4087,7 @@ int http_sync_res_state(struct session *s)
 	if (txn->rsp.msg_state == HTTP_MSG_CLOSED) {
 	http_msg_closed:
 		/* drop any pending data */
-		buffer_ignore(buf, buf->l - buf->o);
+		buffer_ignore(buf, buf->i);
 		buffer_auto_close(buf);
 		buffer_auto_read(buf);
 		goto wait_other_side;
@@ -4153,7 +4153,7 @@ int http_resync_states(struct session *s)
 		buffer_abort(s->req);
 		buffer_auto_close(s->req);
 		buffer_auto_read(s->req);
-		buffer_ignore(s->req, s->req->l - s->req->o);
+		buffer_ignore(s->req, s->req->i);
 	}
 	else if (txn->req.msg_state == HTTP_MSG_CLOSED &&
 		 txn->rsp.msg_state == HTTP_MSG_DONE &&
@@ -4459,13 +4459,13 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
 	int cur_idx;
 	int n;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		rep,
 		rep->rex, rep->wex,
 		rep->flags,
-		rep->l,
+		rep->i,
 		rep->analysers);
 
 	/*
@@ -4490,7 +4490,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
 	 * protected area is affected, because we may have to move processed
 	 * data later, which is much more complicated.
 	 */
-	if (rep->l && msg->msg_state < HTTP_MSG_ERROR) {
+	if (buffer_not_empty(rep) && msg->msg_state < HTTP_MSG_ERROR) {
 		if (unlikely((rep->flags & BF_FULL) ||
 			     rep->r < rep->lr ||
 			     rep->r > rep->data + rep->size - global.tune.maxrewrite)) {
@@ -4502,7 +4502,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
 				rep->flags |= BF_READ_DONTWAIT; /* try to get back here ASAP */
 				return 0;
 			}
-			if (rep->l <= rep->size - global.tune.maxrewrite)
+			if (rep->i <= rep->size - global.tune.maxrewrite)
 				http_buffer_heavy_realign(rep, msg);
 		}
 
@@ -4565,7 +4565,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
 			rep->analysers = 0;
 			txn->status = 502;
 			rep->prod->flags |= SI_FL_NOLINGER;
-			buffer_ignore(rep, rep->l - rep->o);
+			buffer_ignore(rep, rep->i);
 			stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
 
 			if (!(s->flags & SN_ERR_MASK))
@@ -4579,7 +4579,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
 		/* too large response does not fit in buffer. */
 		else if (rep->flags & BF_FULL) {
 			if (msg->err_pos < 0)
-				msg->err_pos = rep->l;
+				msg->err_pos = rep->i;
 			goto hdr_response_bad;
 		}
 
@@ -4598,7 +4598,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
 			rep->analysers = 0;
 			txn->status = 502;
 			rep->prod->flags |= SI_FL_NOLINGER;
-			buffer_ignore(rep, rep->l - rep->o);
+			buffer_ignore(rep, rep->i);
 			stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
 
 			if (!(s->flags & SN_ERR_MASK))
@@ -4623,7 +4623,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
 			rep->analysers = 0;
 			txn->status = 504;
 			rep->prod->flags |= SI_FL_NOLINGER;
-			buffer_ignore(rep, rep->l - rep->o);
+			buffer_ignore(rep, rep->i);
 			stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_504));
 
 			if (!(s->flags & SN_ERR_MASK))
@@ -4648,7 +4648,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
 			rep->analysers = 0;
 			txn->status = 502;
 			rep->prod->flags |= SI_FL_NOLINGER;
-			buffer_ignore(rep, rep->l - rep->o);
+			buffer_ignore(rep, rep->i);
 			stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
 
 			if (!(s->flags & SN_ERR_MASK))
@@ -4889,13 +4889,13 @@ int http_process_res_common(struct session *t, struct buffer *rep, int an_bit, s
 	struct proxy *cur_proxy;
 	struct cond_wordlist *wl;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		t,
 		rep,
 		rep->rex, rep->wex,
 		rep->flags,
-		rep->l,
+		rep->i,
 		rep->analysers);
 
 	if (unlikely(msg->msg_state < HTTP_MSG_BODY))	/* we need more data */
@@ -4998,7 +4998,7 @@ int http_process_res_common(struct session *t, struct buffer *rep, int an_bit, s
 					rep->analysers = 0;
 					txn->status = 502;
 					rep->prod->flags |= SI_FL_NOLINGER;
-					buffer_ignore(rep, rep->l - rep->o);
+					buffer_ignore(rep, rep->i);
 					stream_int_retnclose(rep->cons, error_message(t, HTTP_ERR_502));
 					if (!(t->flags & SN_ERR_MASK))
 						t->flags |= SN_ERR_PRXCOND;
@@ -7456,9 +7456,9 @@ void http_reset_txn(struct session *s)
 	 * a HEAD with some data, or sending more than the advertised
 	 * content-length.
 	 */
-	if (unlikely(s->rep->l > s->rep->o)) {
-		s->rep->l = s->rep->o;
-		s->rep->r = s->rep->w + s->rep->l;
+	if (unlikely(s->rep->i)) {
+		s->rep->i = 0;
+		s->rep->r = s->rep->w + s->rep->o;
 		if (s->rep->r >= s->rep->data + s->rep->size)
 			s->rep->r -= s->rep->size;
 	}
diff --git a/src/proto_tcp.c b/src/proto_tcp.c
index 2a254208b..7a3d7140b 100644
--- a/src/proto_tcp.c
+++ b/src/proto_tcp.c
@@ -669,13 +669,13 @@ int tcp_inspect_request(struct session *s, struct buffer *req, int an_bit)
 	struct stktable *t;
 	int partial;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i,
 		req->analysers);
 
 	/* We don't know whether we have enough data, so must proceed
@@ -787,13 +787,13 @@ int tcp_inspect_response(struct session *s, struct buffer *rep, int an_bit)
 	struct tcp_rule *rule;
 	int partial;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		rep,
 		rep->rex, rep->wex,
 		rep->flags,
-		rep->l,
+		rep->i,
 		rep->analysers);
 
 	/* We don't know whether we have enough data, so must proceed
@@ -1477,10 +1477,10 @@ pattern_fetch_payloadlv(struct proxy *px, struct session *l4, void *l7, int dir,
 
 	b = (dir & PATTERN_FETCH_RTR) ? l4->rep : l4->req;
 
-	if (!b || !b->l)
+	if (!b || !b->i)
 		return 0;
 
-	if (len_offset + len_size > b->l)
+	if (len_offset + len_size > b->i)
 		return 0;
 
 	for (i = 0; i < len_size; i++) {
@@ -1490,7 +1490,7 @@ pattern_fetch_payloadlv(struct proxy *px, struct session *l4, void *l7, int dir,
 	if (!buf_size)
 		return 0;
 
-	if (buf_offset + buf_size > b->l)
+	if (buf_offset + buf_size > b->i)
 		return 0;
 
 	/* init chunk as read only */
@@ -1550,10 +1550,10 @@ pattern_fetch_payload(struct proxy *px, struct session *l4, void *l7, int dir,
 
 	b = (dir & PATTERN_FETCH_RTR) ? l4->rep : l4->req;
 
-	if (!b || !b->l)
+	if (!b || !b->i)
 		return 0;
 
-	if (buf_offset + buf_size > b->l)
+	if (buf_offset + buf_size > b->i)
 		return 0;
 
 	/* init chunk as read only */
diff --git a/src/session.c b/src/session.c
index 66ab81bd9..86aa28c7c 100644
--- a/src/session.c
+++ b/src/session.c
@@ -725,13 +725,13 @@ static void sess_update_stream_int(struct session *s, struct stream_interface *s
 {
 	struct server *srv = target_srv(&s->target);
 
-	DPRINTF(stderr,"[%u] %s: sess=%p rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rql=%d rpl=%d cs=%d ss=%d\n",
+	DPRINTF(stderr,"[%u] %s: sess=%p rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rqh=%d rqt=%d rph=%d rpt=%d cs=%d ss=%d\n",
 		now_ms, __FUNCTION__,
 		s,
 		s->req, s->rep,
 		s->req->rex, s->rep->wex,
 		s->req->flags, s->rep->flags,
-		s->req->l, s->rep->l, s->rep->cons->state, s->req->cons->state);
+		s->req->i, s->req->o, s->rep->i, s->rep->o, s->rep->cons->state, s->req->cons->state);
 
 	if (si->state == SI_ST_ASS) {
 		/* Server assigned to connection request, we have to try to connect now */
@@ -911,14 +911,15 @@ static void sess_set_term_flags(struct session *s)
  * indicating that a server has been assigned. It may also return SI_ST_QUE,
  * or SI_ST_CLO upon error.
  */
-static void sess_prepare_conn_req(struct session *s, struct stream_interface *si) {
-	DPRINTF(stderr,"[%u] %s: sess=%p rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rql=%d rpl=%d cs=%d ss=%d\n",
+static void sess_prepare_conn_req(struct session *s, struct stream_interface *si)
+{
+	DPRINTF(stderr,"[%u] %s: sess=%p rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rqh=%d rqt=%d rph=%d rpt=%d cs=%d ss=%d\n",
 		now_ms, __FUNCTION__,
 		s,
 		s->req, s->rep,
 		s->req->rex, s->rep->wex,
 		s->req->flags, s->rep->flags,
-		s->req->l, s->rep->l, s->rep->cons->state, s->req->cons->state);
+		s->req->i, s->req->o, s->rep->i, s->rep->o, s->rep->cons->state, s->req->cons->state);
 
 	if (si->state != SI_ST_REQ)
 		return;
@@ -961,13 +962,13 @@ static int process_switching_rules(struct session *s, struct buffer *req, int an
 	req->analysers &= ~an_bit;
 	req->analyse_exp = TICK_ETERNITY;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i,
 		req->analysers);
 
 	/* now check whether we have some switching rules for this request */
@@ -1062,7 +1063,7 @@ static int process_server_rules(struct session *s, struct buffer *req, int an_bi
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i + req->o,
 		req->analysers);
 
 	if (!(s->flags & SN_ASSIGNED)) {
@@ -1105,13 +1106,13 @@ static int process_sticking_rules(struct session *s, struct buffer *req, int an_
 	struct proxy    *px   = s->be;
 	struct sticking_rule  *rule;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		req,
 		req->rex, req->wex,
 		req->flags,
-		req->l,
+		req->i,
 		req->analysers);
 
 	list_for_each_entry(rule, &px->sticking_rules, list) {
@@ -1195,13 +1196,13 @@ static int process_store_rules(struct session *s, struct buffer *rep, int an_bit
 	struct sticking_rule  *rule;
 	int i;
 
-	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
+	DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
 		now_ms, __FUNCTION__,
 		s,
 		rep,
 		rep->rex, rep->wex,
 		rep->flags,
-		rep->l,
+		rep->i,
 		rep->analysers);
 
 	list_for_each_entry(rule, &px->storersp_rules, list) {
@@ -1435,14 +1436,14 @@ struct task *process_session(struct task *t)
 	/* Check for connection closure */
 
 	DPRINTF(stderr,
-		"[%u] %s:%d: task=%p s=%p, sfl=0x%08x, rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rql=%d rpl=%d cs=%d ss=%d, cet=0x%x set=0x%x retr=%d\n",
+		"[%u] %s:%d: task=%p s=%p, sfl=0x%08x, rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rqh=%d rqt=%d rph=%d rpt=%d cs=%d ss=%d, cet=0x%x set=0x%x retr=%d\n",
 		now_ms, __FUNCTION__, __LINE__,
 		t,
 		s, s->flags,
 		s->req, s->rep,
 		s->req->rex, s->rep->wex,
 		s->req->flags, s->rep->flags,
-		s->req->l, s->rep->l, s->rep->cons->state, s->req->cons->state,
+		s->req->i, s->req->o, s->rep->i, s->rep->o, s->rep->cons->state, s->req->cons->state,
 		s->rep->cons->err_type, s->req->cons->err_type,
 		s->req->cons->conn_retries);
 
diff --git a/src/stream_sock.c b/src/stream_sock.c
index 36120a161..74fe0b296 100644
--- a/src/stream_sock.c
+++ b/src/stream_sock.c
@@ -85,7 +85,7 @@ static int stream_sock_splice_in(struct buffer *b, struct stream_interface *si)
 	if (!(b->flags & BF_KERN_SPLICING))
 		return -1;
 
-	if (b->l) {
+	if (buffer_not_empty(b)) {
 		/* We're embarrassed, there are already data pending in
 		 * the buffer and we don't want to have them at two
 		 * locations at a time. Let's indicate we need some
@@ -269,7 +269,7 @@ int stream_sock_read(int fd) {
 #endif
 	cur_read = 0;
 	while (1) {
-		max = buffer_max_len(b) - b->l;
+		max = buffer_max_len(b) - buffer_len(b);
 
 		if (max <= 0) {
 			b->flags |= BF_FULL;
@@ -280,7 +280,7 @@ int stream_sock_read(int fd) {
 		/*
 		 * 1. compute the maximum block size we can read at once.
 		 */
-		if (b->l == 0) {
+		if (buffer_empty(b)) {
 			/* let's realign the buffer to optimize I/O */
 			b->r = b->w = b->lr = b->data;
 		}
@@ -298,7 +298,7 @@ int stream_sock_read(int fd) {
 
 		if (ret > 0) {
 			b->r += ret;
-			b->l += ret;
+			b->i += ret;
 			cur_read += ret;
 
 			/* if we're allowed to directly forward data, we must update ->o */
@@ -310,6 +310,7 @@ int stream_sock_read(int fd) {
 					b->to_forward -= fwd;
 				}
 				b->o += fwd;
+				b->i -= fwd;
 				b->flags &= ~BF_OUT_EMPTY;
 			}
 
@@ -324,11 +325,11 @@ int stream_sock_read(int fd) {
 
 			b->total += ret;
 
-			if (b->l >= buffer_max_len(b)) {
+			if (buffer_len(b) >= buffer_max_len(b)) {
 				/* The buffer is now full, there's no point in going through
 				 * the loop again.
 				 */
-				if (!(b->flags & BF_STREAMER_FAST) && (cur_read == b->l)) {
+				if (!(b->flags & BF_STREAMER_FAST) && (cur_read == buffer_len(b))) {
 					b->xfer_small = 0;
 					b->xfer_large++;
 					if (b->xfer_large >= 3) {
@@ -446,7 +447,7 @@ int stream_sock_read(int fd) {
 	 * HTTP chunking).
 	 */
 	if (b->pipe || /* always try to send spliced data */
-	    (b->o == b->l && (b->cons->flags & SI_FL_WAIT_DATA))) {
+	    (b->i == 0 && (b->cons->flags & SI_FL_WAIT_DATA))) {
 		int last_len = b->pipe ? b->pipe->data : 0;
 
 		b->cons->chk_snd(b->cons);
@@ -624,7 +625,7 @@ static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
 			    ((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) ||
 			     (b->flags & BF_EXPECT_MORE))) ||
 			    ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->o)) ||
-			    (max != b->l && max != b->o)) {
+			    (max != b->o)) {
 				send_flag |= MSG_MORE;
 			}
 
@@ -654,15 +655,14 @@ static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
 			if (b->w == b->data + b->size)
 				b->w = b->data; /* wrap around the buffer */
 
-			b->l -= ret;
-			if (likely(b->l < buffer_max_len(b)))
-				b->flags &= ~BF_FULL;
-
-			if (likely(!b->l))
+			b->o -= ret;
+			if (likely(!buffer_len(b)))
 				/* optimize data alignment in the buffer */
 				b->r = b->w = b->lr = b->data;
 
-			b->o -= ret;
+			if (likely(buffer_len(b) < buffer_max_len(b)))
+				b->flags &= ~BF_FULL;
+
 			if (!b->o) {
 				/* Always clear both flags once everything has been sent, they're one-shot */
 				b->flags &= ~(BF_EXPECT_MORE | BF_SEND_DONTWAIT);
@@ -939,13 +939,13 @@ void stream_sock_data_finish(struct stream_interface *si)
 	struct buffer *ob = si->ob;
 	int fd = si->fd;
 
-	DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n",
+	DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
 		now_ms, __FUNCTION__,
 		fd, fdtab[fd].owner,
 		ib, ob,
 		ib->rex, ob->wex,
 		ib->flags, ob->flags,
-		ib->l, ob->l, si->state);
+		ib->i, ib->o, ob->i, ob->o, si->state);
 
 	/* Check if we need to close the read side */
 	if (!(ib->flags & BF_SHUTR)) {
@@ -1017,13 +1017,13 @@ void stream_sock_chk_rcv(struct stream_interface *si)
 {
 	struct buffer *ib = si->ib;
 
-	DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n",
+	DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
 		now_ms, __FUNCTION__,
 		si->fd, fdtab[si->fd].owner,
 		ib, si->ob,
 		ib->rex, si->ob->wex,
 		ib->flags, si->ob->flags,
-		ib->l, si->ob->l, si->state);
+		ib->i, ib->o, si->ob->i, si->ob->o, si->state);
 
 	if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR)))
 		return;
@@ -1052,13 +1052,13 @@ void stream_sock_chk_snd(struct stream_interface *si)
 	struct buffer *ob = si->ob;
 	int retval;
 
-	DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n",
+	DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibh=%d ibt=%d obh=%d obd=%d si=%d\n",
 		now_ms, __FUNCTION__,
 		si->fd, fdtab[si->fd].owner,
 		si->ib, ob,
 		si->ib->rex, ob->wex,
 		si->ib->flags, ob->flags,
-		si->ib->l, ob->l, si->state);
+		si->ib->i, si->ib->o, ob->i, ob->o, si->state);
 
 	if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW)))
 		return;