diff --git a/include/proto/hdr_idx.h b/include/proto/hdr_idx.h
deleted file mode 100644
index f65b3c6..0000000
--- a/include/proto/hdr_idx.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * include/proto/hdr_idx.h
- * This file defines function prototypes for fast header indexation.
- *
- * Copyright (C) 2000-2011 Willy Tarreau - w@1wt.eu
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation, version 2.1
- * exclusively.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#ifndef _PROTO_HDR_IDX_H
-#define _PROTO_HDR_IDX_H
-
-#include <common/config.h>
-#include <types/hdr_idx.h>
-
-extern struct pool_head *pool_head_hdr_idx;
-
-/*
- * Initialize the list pointers.
- * list->size must already be set. If list->size is set and list->v is
- * non-null, list->v is also initialized..
- */
-static inline void hdr_idx_init(struct hdr_idx *list)
-{
-	if (list->size && list->v) {
-		register struct hdr_idx_elem e = { .len=0, .cr=0, .next=0};
-		list->v[0] = e;
-	}
-	list->tail = 0;
-	list->used = list->last = 1;
-}
-
-/*
- * Return index of the first entry in the list. Usually, it means the index of
- * the first header just after the request or response. If zero is returned, it
- * means that the list is empty.
- */
-static inline int hdr_idx_first_idx(const struct hdr_idx *list)
-{
-	return list->v[0].next;
-}
-
-/*
- * Return position of the first entry in the list. Usually, it means the
- * position of the first header just after the request, but it can also be the
- * end of the headers if the request has no header. hdr_idx_start_idx() should
- * be checked before to ensure there is a valid header.
- */
-static inline int hdr_idx_first_pos(const struct hdr_idx *list)
-{
-	return list->v[0].len + list->v[0].cr + 1;
-}
-
-/*
- * Sets the information about the start line. Its length and the presence of
- * the CR are registered so that hdr_idx_first_pos() knows exactly where to
- * find the first header.
- */
-static inline void hdr_idx_set_start(struct hdr_idx *list, int len, int cr)
-{
-	list->v[0].len = len;
-	list->v[0].cr = cr;
-}
-
-/*
- * Add a header entry to <list> after element <after>. <after> is ignored when
- * the list is empty or full. Common usage is to set <after> to list->tail.
- *
- * Returns the position of the new entry in the list (from 1 to size-1), or 0
- * if the array is already full. An effort is made to fill the array linearly,
- * but once the last entry has been used, we have to search for unused blocks,
- * which takes much more time. For this reason, it's important to size is
- * appropriately.
- */
-int hdr_idx_add(int len, int cr, struct hdr_idx *list, int after);
-
-#endif /* _PROTO_HDR_IDX_H */
-
-/*
- * Local variables:
- *  c-indent-level: 8
- *  c-basic-offset: 8
- * End:
- */
diff --git a/include/proto/proto_http.h b/include/proto/proto_http.h
index 8683e26..e360a5a 100644
--- a/include/proto/proto_http.h
+++ b/include/proto/proto_http.h
@@ -23,6 +23,7 @@
 #define _PROTO_PROTO_HTTP_H
 
 #include <common/config.h>
+#include <common/htx.h>
 #include <types/proto_http.h>
 #include <types/stream.h>
 #include <types/task.h>
@@ -31,43 +32,6 @@
 
 extern struct pool_head *pool_head_uniqueid;
 
-int process_cli(struct stream *s);
-int process_srv_data(struct stream *s);
-int process_srv_conn(struct stream *s);
-int http_wait_for_request(struct stream *s, struct channel *req, int an_bit);
-int http_process_req_common(struct stream *s, struct channel *req, int an_bit, struct proxy *px);
-int http_process_request(struct stream *s, struct channel *req, int an_bit);
-int http_process_tarpit(struct stream *s, struct channel *req, int an_bit);
-int http_wait_for_request_body(struct stream *s, struct channel *req, int an_bit);
-int http_send_name_header(struct stream *s, struct proxy* be, const char* svr_name);
-int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit);
-int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, struct proxy *px);
-int http_request_forward_body(struct stream *s, struct channel *req, int an_bit);
-int http_response_forward_body(struct stream *s, struct channel *res, int an_bit);
-int http_upgrade_v09_to_v10(struct http_txn *txn);
-void http_msg_analyzer(struct http_msg *msg, struct hdr_idx *idx);
-void http_txn_reset_req(struct http_txn *txn);
-void http_txn_reset_res(struct http_txn *txn);
-const char *http_parse_reqline(struct http_msg *msg,
-                               enum h1_state state, const char *ptr, const char *end,
-                               unsigned int *ret_ptr, enum h1_state *ret_state);
-const char *http_parse_stsline(struct http_msg *msg,
-                               enum h1_state state, const char *ptr, const char *end,
-                               unsigned int *ret_ptr, enum h1_state *ret_state);
-int http_forward_trailers(struct http_msg *msg);
-int http_legacy_replace_header(struct hdr_idx *idx, struct http_msg *msg,
-                               const char *name, unsigned int name_len,
-                               const char *str, struct my_regex *re,
-                               struct buffer *output);
-int http_legacy_replace_full_header(struct hdr_idx *idx, struct http_msg *msg,
-                                    const char *name, unsigned int name_len,
-                                    const char *str, struct my_regex *re,
-                                    struct buffer *output);
-
-/* Export HTX analyzers and helpers */
-// FIXME: Rename all these functions http_* once legacy code will be removed
-struct htx;
-
 int htx_wait_for_request(struct stream *s, struct channel *req, int an_bit);
 int htx_process_req_common(struct stream *s, struct channel *req, int an_bit, struct proxy *px);
 int htx_process_request(struct stream *s, struct channel *req, int an_bit);
@@ -92,171 +56,20 @@
 void htx_return_srv_error(struct stream *s, struct stream_interface *si);
 struct buffer *htx_error_message(struct stream *s);
 
-void debug_hdr(const char *dir, struct stream *s, const char *start, const char *end);
-int apply_filter_to_req_headers(struct stream *s, struct channel *req, struct hdr_exp *exp);
-int apply_filter_to_req_line(struct stream *s, struct channel *req, struct hdr_exp *exp);
-int apply_filters_to_request(struct stream *s, struct channel *req, struct proxy *px);
-int apply_filters_to_response(struct stream *s, struct channel *rtr, struct proxy *px);
-void manage_client_side_cookies(struct stream *s, struct channel *req);
-void manage_server_side_cookies(struct stream *s, struct channel *rtr);
-void check_request_for_cacheability(struct stream *s, struct channel *chn);
-void check_response_for_cacheability(struct stream *s, struct channel *rtr);
-int stats_check_uri(struct stream_interface *si, struct http_txn *txn, struct proxy *backend);
-int http_find_full_header2(const char *name, int len,
-                           char *sol, struct hdr_idx *idx,
-                           struct hdr_ctx *ctx);
-int http_find_header2(const char *name, int len,
-		      char *sol, struct hdr_idx *idx,
-		      struct hdr_ctx *ctx);
-int http_find_next_header(char *sol, struct hdr_idx *idx,
-                          struct hdr_ctx *ctx);
-int http_remove_header2(struct http_msg *msg, struct hdr_idx *idx, struct hdr_ctx *ctx);
-int http_header_add_tail2(struct http_msg *msg, struct hdr_idx *hdr_idx, const char *text, int len);
-int http_replace_req_line(int action, const char *replace, int len, struct proxy *px, struct stream *s);
-void http_set_status(unsigned int status, const char *reason, struct stream *s);
-int http_transform_header_str(struct stream* s, struct http_msg *msg, const char* name,
-                              unsigned int name_len, const char *str, struct my_regex *re,
-                              int action);
-int http_handle_stats(struct stream *s, struct channel *req);
-enum rule_result http_req_get_intercept_rule(struct proxy *px, struct list *rules,
-					     struct stream *s, int *deny_status);
-enum rule_result http_res_get_intercept_rule(struct proxy *px, struct list *rules,
-					     struct stream *s);
-int http_apply_redirect_rule(struct redirect_rule *rule, struct stream *s, struct http_txn *txn);
-void http_perform_server_redirect(struct stream *s, struct stream_interface *si);
-void http_return_srv_error(struct stream *s, struct stream_interface *si);
-void http_capture_headers(char *som, struct hdr_idx *idx,
-			  char **cap, struct cap_hdr *cap_hdr);
-void http_capture_bad_message(struct proxy *proxy, struct stream *s,
-                              struct http_msg *msg,
-			      enum h1_state state, struct proxy *other_end);
-unsigned int http_get_hdr(const struct http_msg *msg, const char *hname, int hlen,
-			  struct hdr_idx *idx, int occ,
-			  struct hdr_ctx *ctx, char **vptr, size_t *vlen);
-unsigned int http_get_fhdr(const struct http_msg *msg, const char *hname, int hlen,
-			   struct hdr_idx *idx, int occ,
-			   struct hdr_ctx *ctx, char **vptr, size_t *vlen);
-char *http_txn_get_path(const struct http_txn *txn);
-
 struct http_txn *http_alloc_txn(struct stream *s);
 void http_init_txn(struct stream *s);
 void http_end_txn(struct stream *s);
 void http_reset_txn(struct stream *s);
-void http_end_txn_clean_session(struct stream *s);
-void http_resync_states(struct stream *s);
-void http_parse_connection_header(struct http_txn *txn, struct http_msg *msg, int to_del);
-void http_change_connection_header(struct http_txn *txn, struct http_msg *msg, int wanted);
-void http_adjust_conn_mode(struct stream *s, struct http_txn *txn, struct http_msg *msg);
-
-int http_msg_forward_body(struct stream *s, struct http_msg *msg);
-int http_msg_forward_chunked_body(struct stream *s, struct http_msg *msg);
-
-void http_reply_and_close(struct stream *s, short status, struct buffer *msg);
-struct buffer *http_error_message(struct stream *s);
-
-/* to be used when contents change in an HTTP message */
-#define http_msg_move_end(msg, bytes) do { \
-		unsigned int _bytes = (bytes);	\
-		(msg)->next += (_bytes);	\
-		(msg)->sov += (_bytes);		\
-		(msg)->eoh += (_bytes);		\
-	} while (0)
-
-
-/* Return the amount of bytes that need to be rewound before buf->p to access
- * the current message's headers. The purpose is to be able to easily fetch
- * the message's beginning before headers are forwarded, as well as after.
- * The principle is that msg->eoh and msg->eol are immutable while msg->sov
- * equals the sum of the two before forwarding and is zero after forwarding,
- * so the difference cancels the rewinding.
- */
-static inline int http_hdr_rewind(const struct http_msg *msg)
-{
-	return msg->eoh + msg->eol - msg->sov;
-}
-
-/* Return the amount of bytes that need to be rewound before buf->p to access
- * the current message's URI. The purpose is to be able to easily fetch
- * the message's beginning before headers are forwarded, as well as after.
- */
-static inline int http_uri_rewind(const struct http_msg *msg)
-{
-	return http_hdr_rewind(msg) - msg->sl.rq.u;
-}
-
-/* Return the amount of bytes that need to be rewound before buf->p to access
- * the current message's BODY. The purpose is to be able to easily fetch
- * the message's beginning before headers are forwarded, as well as after.
- */
-static inline int http_body_rewind(const struct http_msg *msg)
-{
-	return http_hdr_rewind(msg) - msg->eoh - msg->eol;
-}
-
-/* Return the amount of bytes that need to be rewound before buf->p to access
- * the current message's DATA. The difference with the function above is that
- * if a chunk is present and has already been parsed, its size is skipped so
- * that the byte pointed to is the first byte of actual data. The function is
- * safe for use in state HTTP_MSG_DATA regardless of whether the headers were
- * already forwarded or not.
- */
-static inline int http_data_rewind(const struct http_msg *msg)
-{
-	return http_body_rewind(msg) - msg->sol;
-}
-
-/* Return the maximum amount of bytes that may be read after the beginning of
- * the message body, according to the advertised length. The function is safe
- * for use between HTTP_MSG_BODY and HTTP_MSG_DATA regardless of whether the
- * headers were already forwarded or not.
- */
-static inline int http_body_bytes(const struct http_msg *msg)
-{
-	int len;
-
-	len = ci_data(msg->chn) - msg->sov - msg->sol;
-	if (len > msg->body_len)
-		len = msg->body_len;
-	return len;
-}
 
 /* for debugging, reports the HTTP/1 message state name (legacy version) */
 static inline const char *h1_msg_state_str(enum h1_state msg_state)
 {
 	switch (msg_state) {
 	case HTTP_MSG_RQBEFORE:    return "MSG_RQBEFORE";
-	case HTTP_MSG_RQBEFORE_CR: return "MSG_RQBEFORE_CR";
-	case HTTP_MSG_RQMETH:      return "MSG_RQMETH";
-	case HTTP_MSG_RQMETH_SP:   return "MSG_RQMETH_SP";
-	case HTTP_MSG_RQURI:       return "MSG_RQURI";
-	case HTTP_MSG_RQURI_SP:    return "MSG_RQURI_SP";
-	case HTTP_MSG_RQVER:       return "MSG_RQVER";
-	case HTTP_MSG_RQLINE_END:  return "MSG_RQLINE_END";
 	case HTTP_MSG_RPBEFORE:    return "MSG_RPBEFORE";
-	case HTTP_MSG_RPBEFORE_CR: return "MSG_RPBEFORE_CR";
-	case HTTP_MSG_RPVER:       return "MSG_RPVER";
-	case HTTP_MSG_RPVER_SP:    return "MSG_RPVER_SP";
-	case HTTP_MSG_RPCODE:      return "MSG_RPCODE";
-	case HTTP_MSG_RPCODE_SP:   return "MSG_RPCODE_SP";
-	case HTTP_MSG_RPREASON:    return "MSG_RPREASON";
-	case HTTP_MSG_RPLINE_END:  return "MSG_RPLINE_END";
-	case HTTP_MSG_HDR_FIRST:   return "MSG_HDR_FIRST";
-	case HTTP_MSG_HDR_NAME:    return "MSG_HDR_NAME";
-	case HTTP_MSG_HDR_COL:     return "MSG_HDR_COL";
-	case HTTP_MSG_HDR_L1_SP:   return "MSG_HDR_L1_SP";
-	case HTTP_MSG_HDR_L1_LF:   return "MSG_HDR_L1_LF";
-	case HTTP_MSG_HDR_L1_LWS:  return "MSG_HDR_L1_LWS";
-	case HTTP_MSG_HDR_VAL:     return "MSG_HDR_VAL";
-	case HTTP_MSG_HDR_L2_LF:   return "MSG_HDR_L2_LF";
-	case HTTP_MSG_HDR_L2_LWS:  return "MSG_HDR_L2_LWS";
-	case HTTP_MSG_LAST_LF:     return "MSG_LAST_LF";
 	case HTTP_MSG_ERROR:       return "MSG_ERROR";
 	case HTTP_MSG_BODY:        return "MSG_BODY";
-	case HTTP_MSG_100_SENT:    return "MSG_100_SENT";
-	case HTTP_MSG_CHUNK_SIZE:  return "MSG_CHUNK_SIZE";
 	case HTTP_MSG_DATA:        return "MSG_DATA";
-	case HTTP_MSG_CHUNK_CRLF:  return "MSG_CHUNK_CRLF";
-	case HTTP_MSG_TRAILERS:    return "MSG_TRAILERS";
 	case HTTP_MSG_ENDING:      return "MSG_ENDING";
 	case HTTP_MSG_DONE:        return "MSG_DONE";
 	case HTTP_MSG_CLOSING:     return "MSG_CLOSING";
diff --git a/include/types/hdr_idx.h b/include/types/hdr_idx.h
deleted file mode 100644
index 809ea83..0000000
--- a/include/types/hdr_idx.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-  include/types/hdr_idx.h
-  This file defines everything related to fast header indexation.
-
-  Copyright (C) 2000-2006 Willy Tarreau - w@1wt.eu
-  
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation, version 2.1
-  exclusively.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-
-/*
- * The type of structure described here is a finite linked list used to
- * reference small number of objects of small size. This is typically used
- * to index HTTP headers within one request or response, in order to be able
- * to add, remove, modify and check them in an efficient way. The overhead is
- * very low : 32 bits are used per list element. This is enough to reference
- * 32k headers of at most 64kB each, with one bit to indicate if the header
- * is terminated by 1 or 2 chars. It may also evolve towards something like
- * 1k headers of at most 64B for the name and 32kB of data + CR/CRLF.
- *
- * A future evolution of this concept may allow for fast header manipulation
- * without data movement through the use of vectors. This is not yet possible
- * in this version, whose goal is only to avoid parsing whole lines for each
- * consultation.
- *
- */
-
-
-#ifndef _TYPES_HDR_IDX_H
-#define _TYPES_HDR_IDX_H
-
-/*
- * This describes one element of the hdr_idx array.
- * It's a tiny linked list of at most 32k 32bit elements. The first one has a
- * special meaning, it's used as the head of the list and cannod be removed.
- * That way, we know that 'next==0' is not possible so we use it to indicate
- * an end of list. Also, [0]->next always designates the head of the list. The
- * first allocatable element is at 1. By convention, [0]->len indicates how
- * many chars should be skipped in the original buffer before finding the first
- * header.
- *
- */
-
-struct hdr_idx_elem {
-        unsigned len  :16; /* length of this header not counting CRLF. 0=unused entry. */
-        unsigned cr   : 1; /* CR present (1=CRLF, 0=LF). Total line size=len+cr+1. */
-        unsigned next :15; /* offset of next header if len>0. 0=end of list. */
-};
-
-/*
- * This structure provides necessary information to store, find, remove
- * index entries from a list. This list cannot reference more than 32k
- * elements of 64k each.
- */
-struct hdr_idx {
-	struct hdr_idx_elem *v;     /* the array itself */
-	short size;                 /* size of the array including the head */
-	short used;                 /* # of elements really used (1..size) */
-	short last;                 /* length of the allocated area (1..size) */
-	signed short tail;          /* last used element, 0..size-1 */
-};
-
-
-
-#endif /* _TYPES_HDR_IDX_H */
-
-/*
- * Local variables:
- *  c-indent-level: 8
- *  c-basic-offset: 8
- * End:
- */
diff --git a/include/types/proto_http.h b/include/types/proto_http.h
index d4fa652..205bd5f 100644
--- a/include/types/proto_http.h
+++ b/include/types/proto_http.h
@@ -29,7 +29,6 @@
 #include <common/regex.h>
 
 #include <types/channel.h>
-#include <types/hdr_idx.h>
 #include <types/filters.h>
 //#include <types/sample.h>
 
@@ -188,110 +187,30 @@
  */
 enum h1_state {
 	HTTP_MSG_RQBEFORE     =  0, // request: leading LF, before start line
-	HTTP_MSG_RQBEFORE_CR  =  1, // request: leading CRLF, before start line
-	/* these ones define a request start line */
-	HTTP_MSG_RQMETH       =  2, // parsing the Method
-	HTTP_MSG_RQMETH_SP    =  3, // space(s) after the Method
-	HTTP_MSG_RQURI        =  4, // parsing the Request URI
-	HTTP_MSG_RQURI_SP     =  5, // space(s) after the Request URI
-	HTTP_MSG_RQVER        =  6, // parsing the Request Version
-	HTTP_MSG_RQLINE_END   =  7, // end of request line (CR or LF)
-
-	HTTP_MSG_RPBEFORE     =  8, // response: leading LF, before start line
-	HTTP_MSG_RPBEFORE_CR  =  9, // response: leading CRLF, before start line
-
-	/* these ones define a response start line */
-	HTTP_MSG_RPVER        = 10, // parsing the Response Version
-	HTTP_MSG_RPVER_SP     = 11, // space(s) after the Response Version
-	HTTP_MSG_RPCODE       = 12, // response code
-	HTTP_MSG_RPCODE_SP    = 13, // space(s) after the response code
-	HTTP_MSG_RPREASON     = 14, // response reason
-	HTTP_MSG_RPLINE_END   = 15, // end of response line (CR or LF)
-
-	/* common header processing */
-	HTTP_MSG_HDR_FIRST    = 16, // waiting for first header or last CRLF (no LWS possible)
-	HTTP_MSG_HDR_NAME     = 17, // parsing header name
-	HTTP_MSG_HDR_COL      = 18, // parsing header colon
-	HTTP_MSG_HDR_L1_SP    = 19, // parsing header LWS (SP|HT) before value
-	HTTP_MSG_HDR_L1_LF    = 20, // parsing header LWS (LF) before value
-	HTTP_MSG_HDR_L1_LWS   = 21, // checking whether it's a new header or an LWS
-	HTTP_MSG_HDR_VAL      = 22, // parsing header value
-	HTTP_MSG_HDR_L2_LF    = 23, // parsing header LWS (LF) inside/after value
-	HTTP_MSG_HDR_L2_LWS   = 24, // checking whether it's a new header or an LWS
-
-	HTTP_MSG_LAST_LF      = 25, // parsing last LF
+	HTTP_MSG_RPBEFORE     =  1, // response: leading LF, before start line
 
 	/* error state : must be before HTTP_MSG_BODY so that (>=BODY) always indicates
 	 * that data are being processed.
 	 */
-	HTTP_MSG_ERROR        = 26, // an error occurred
+	HTTP_MSG_ERROR        =  2, // an error occurred
 	/* Body processing.
 	 * The state HTTP_MSG_BODY is a delimiter to know if we're waiting for headers
 	 * or body. All the sub-states below also indicate we're processing the body,
 	 * with some additional information.
 	 */
-	HTTP_MSG_BODY         = 27, // parsing body at end of headers
-	HTTP_MSG_100_SENT     = 28, // parsing body after a 100-Continue was sent
-	HTTP_MSG_CHUNK_SIZE   = 29, // parsing the chunk size (RFC7230 #4.1)
-	HTTP_MSG_DATA         = 30, // skipping data chunk / content-length data
-	HTTP_MSG_CHUNK_CRLF   = 31, // skipping CRLF after data chunk
-	HTTP_MSG_TRAILERS     = 32, // trailers (post-data entity headers)
+	HTTP_MSG_BODY         =  3, // parsing body at end of headers
+	HTTP_MSG_DATA         =  4, // skipping data chunk / content-length data
 	/* we enter this state when we've received the end of the current message */
-	HTTP_MSG_ENDING       = 33, // message end received, wait that the filters end too
-	HTTP_MSG_DONE         = 34, // message end received, waiting for resync or close
-	HTTP_MSG_CLOSING      = 35, // shutdown_w done, not all bytes sent yet
-	HTTP_MSG_CLOSED       = 36, // shutdown_w done, all bytes sent
-	HTTP_MSG_TUNNEL       = 37, // tunneled data after DONE
+	HTTP_MSG_ENDING       =  5, // message end received, wait that the filters end too
+	HTTP_MSG_DONE         =  6, // message end received, waiting for resync or close
+	HTTP_MSG_CLOSING      =  7, // shutdown_w done, not all bytes sent yet
+	HTTP_MSG_CLOSED       =  8, // shutdown_w done, all bytes sent
+	HTTP_MSG_TUNNEL       =  9, // tunneled data after DONE
 } __attribute__((packed));
 
 
-/* This is an HTTP message, as described in RFC7230. It can be either a request
- * message or a response message.
- *
- * The values there are a little bit obscure, because their meaning can change
- * during the parsing. Please read carefully doc/internal/body-parsing.txt if
- * you need to manipulate them. Quick reminder :
- *
- *  - eoh (End of Headers)   : relative offset in the buffer of first byte that
- *                             is not part of a completely processed header.
- *                             During parsing, it points to last header seen
- *                             for states after START. When in HTTP_MSG_BODY,
- *                             eoh points to the first byte of the last CRLF
- *                             preceding data. Relative to buffer's origin.
- *                             This value then remains unchanged till the end
- *                             so that we can rewind the buffer to change some
- *                             headers if needed (eg: http-send-name-header).
- *
- *  - sov (start of value)   : Before HTTP_MSG_BODY, points to the value of
- *                             the header being parsed. Starting from
- *                             HTTP_MSG_BODY, will point to the start of the
- *                             body (relative to buffer's origin). It can be
- *                             negative when forwarding data. It stops growing
- *                             once data start to leave the buffer.
- *
- *  - next (parse pointer)   : next relative byte to be parsed. Always points
- *                             to a byte matching the current state.
- *
- *  - sol (start of line)    : start of current line before MSG_BODY. Starting
- *                             from MSG_BODY and until MSG_TRAILERS, contains
- *                             the length of the last parsed chunk size so that
- *                             when added to sov it always points to the
- *                             beginning of the current data chunk.
- *                             in MSG_TRAILERS state, it contains the length of
- *                             the last parsed part of the trailer headers.
- *
- *  - eol (End of Line)      : Before HTTP_MSG_BODY, relative offset in the
- *                             buffer of the first byte which marks the end of
- *                             the line current (LF or CRLF).
- *                             From HTTP_MSG_BODY to the end, contains the
- *                             length of the last CRLF (1 for a plain LF, or 2
- *                             for a true CRLF). So eoh+eol always contain the
- *                             exact size of the header size.
- *
- * Note that all offsets are relative to the origin of the buffer (buf->p)
- * which always points to the beginning of the message (request or response).
- * Since a message may not wrap, pointer computations may be one without any
- * care for wrapping (no addition overflow nor subtract underflow).
+/* This is the state of an HTTP seen from the analyzers point of view. It can be
+ * either a request message or a response message.
  */
 struct http_msg {
 	enum h1_state msg_state;               /* where we are in the current message parsing */
@@ -299,39 +218,12 @@
 	unsigned char flags;                   /* flags describing the message (HTTP version, ...) */
 	/* 5 bytes unused here */
 	struct channel *chn;                   /* pointer to the channel transporting the message */
-	unsigned int next;                     /* pointer to next byte to parse, relative to buf->p */
-	int sov;                               /* current header: start of value ; data: start of body */
-	unsigned int eoh;                      /* End Of Headers, relative to buffer */
-	unsigned int sol;                      /* start of current line during parsing otherwise zero */
-	unsigned int eol;                      /* end of line */
-	int err_pos;                           /* err handling: -2=block, -1=pass, 0+=detected */
-	union {                                /* useful start line pointers, relative to ->sol */
-		struct {
-			int l;                 /* request line length (not including CR) */
-			int m_l;               /* METHOD length (method starts at buf->p) */
-			int u, u_l;            /* URI, length */
-			int v, v_l;            /* VERSION, length */
-		} rq;                          /* request line : field, length */
-		struct {
-			int l;                 /* status line length (not including CR) */
-			int v_l;               /* VERSION length (version starts at buf->p) */
-			int c, c_l;            /* CODE, length */
-			int r, r_l;            /* REASON, length */
-		} st;                          /* status line : field, length */
-	} sl;                                  /* start line */
-	unsigned long long chunk_len;          /* cache for last chunk size or content-length header value */
-	unsigned long long body_len;           /* total known length of the body, excluding encoding */
 };
 
-struct proxy;
-struct http_txn;
-struct stream;
-
 /* This is an HTTP transaction. It contains both a request message and a
  * response message (which can be empty).
  */
 struct http_txn {
-	struct hdr_idx hdr_idx;         /* array of header indexes (max: global.tune.max_http_hdr) */
 	struct http_msg rsp;            /* HTTP response message */
 	struct http_msg req;            /* HTTP request message */
 	unsigned int flags;             /* transaction flags */
@@ -349,24 +241,6 @@
 	struct http_auth_data auth;	/* HTTP auth data */
 };
 
-
-/* This structure is used by http_find_header() to return values of headers.
- * The header starts at <line>, the value (excluding leading and trailing white
- * spaces) at <line>+<val> for <vlen> bytes, followed by optional <tws> trailing
- * white spaces, and sets <line>+<del> to point to the last delimitor (colon or
- * comma) before this value. <prev> points to the index of the header whose next
- * is this one.
- */
-struct hdr_ctx {
-	char *line;
-	int  idx;
-	int  val;  /* relative to line, may skip some leading white spaces */
-	int  vlen; /* relative to line+val, stops before trailing white spaces */
-	int  tws;  /* added to vlen if some trailing white spaces are present */
-	int  del;  /* relative to line */
-	int  prev; /* index of previous header */
-};
-
 extern struct pool_head *pool_head_http_txn;
 
 #endif /* _TYPES_PROTO_HTTP_H */
diff --git a/include/types/sample.h b/include/types/sample.h
index 015c5ae..e5c2c29 100644
--- a/include/types/sample.h
+++ b/include/types/sample.h
@@ -133,7 +133,7 @@
 	SMP_USE_TXFIN = 1 << SMP_SRC_TXFIN,  /* final information about the transaction (eg: #comp rate) */
 	SMP_USE_SSFIN = 1 << SMP_SRC_SSFIN,  /* final information about the stream (eg: #requests, final flags) */
 
-	/* This composite one is useful to detect if an hdr_idx needs to be allocated */
+	/* This composite one is useful to detect if an http_txn needs to be allocated */
 	SMP_USE_HTTP_ANY = SMP_USE_HRQHV | SMP_USE_HRQHP | SMP_USE_HRQBO |
 	                   SMP_USE_HRSHV | SMP_USE_HRSHP | SMP_USE_HRSBO,
 };