diff --git a/include/types/proxy.h b/include/types/proxy.h
index 3ac80d8..0c1ca76 100644
--- a/include/types/proxy.h
+++ b/include/types/proxy.h
@@ -182,6 +182,7 @@
 	struct {                                /* TCP request processing */
 		unsigned int inspect_delay;     /* inspection delay */
 		struct list inspect_rules;      /* inspection rules */
+		struct list l4_rules;           /* layer4 rules */
 	} tcp_req;
 	int acl_requires;                       /* Elements required to satisfy all ACLs (ACL_USE_*) */
 	struct server *srv, defsrv;		/* known servers; default server configuration */
diff --git a/src/cfgparse.c b/src/cfgparse.c
index 06ebf36..e5b66e8 100644
--- a/src/cfgparse.c
+++ b/src/cfgparse.c
@@ -908,6 +908,7 @@
 	LIST_INIT(&p->sticking_rules);
 	LIST_INIT(&p->storersp_rules);
 	LIST_INIT(&p->tcp_req.inspect_rules);
+	LIST_INIT(&p->tcp_req.l4_rules);
 	LIST_INIT(&p->req_add);
 	LIST_INIT(&p->rsp_add);
 
