diff --git a/include/haproxy/listener.h b/include/haproxy/listener.h
index 722a9ea..8200395 100644
--- a/include/haproxy/listener.h
+++ b/include/haproxy/listener.h
@@ -124,6 +124,13 @@
  */
 void listener_release(struct listener *l);
 
+/* This function adds the specified <listener> to the protocol <proto>. It
+ * does nothing if the protocol was already added. The listener's state is
+ * automatically updated from LI_INIT to LI_ASSIGNED. The number of listeners
+ * for the protocol is updated. This must be called with the proto lock held.
+ */
+void default_add_listener(struct protocol *proto, struct listener *listener);
+
 /* default function used to unbind a listener. This is for use by standard
  * protocols working on top of accepted sockets. The receiver's rx_unbind()
  * will automatically be used after the listener is disabled if the socket is
diff --git a/include/haproxy/protocol-t.h b/include/haproxy/protocol-t.h
index 2a59950..494f95d 100644
--- a/include/haproxy/protocol-t.h
+++ b/include/haproxy/protocol-t.h
@@ -88,7 +88,7 @@
 	int sock_prot;					/* socket protocol, as passed to socket() */
 
 	/* functions acting on the listener */
-	void (*add)(struct listener *l, int port);      /* add a listener for this protocol and port */
+	void (*add)(struct protocol *p, struct listener *l); /* add a listener for this protocol */
 	int (*listen)(struct listener *l, char *errmsg, int errlen); /* start a listener */
 	void (*enable)(struct listener *l);             /* enable receipt of new connections */
 	void (*disable)(struct listener *l);            /* disable receipt of new connections */
diff --git a/src/listener.c b/src/listener.c
index 7689ceb..87b2bd2 100644
--- a/src/listener.c
+++ b/src/listener.c
@@ -323,6 +323,21 @@
 		HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &px->lock);
 }
 
+/* This function adds the specified <listener> to the protocol <proto>. It
+ * does nothing if the protocol was already added. The listener's state is
+ * automatically updated from LI_INIT to LI_ASSIGNED. The number of listeners
+ * for the protocol is updated. This must be called with the proto lock held.
+ */
+void default_add_listener(struct protocol *proto, struct listener *listener)
+{
+	if (listener->state != LI_INIT)
+		return;
+	listener_set_state(listener, LI_ASSIGNED);
+	listener->rx.proto = proto;
+	LIST_ADDQ(&proto->receivers, &listener->rx.proto_list);
+	proto->nb_receivers++;
+}
+
 /* default function called to suspend a listener: it simply passes the call to
  * the underlying receiver. This is find for most socket-based protocols. This
  * must be called under the listener's lock. It will return non-zero on success,
@@ -616,13 +631,13 @@
 		l->rx.fd = fd;
 
 		memcpy(&l->rx.addr, ss, sizeof(*ss));
-		if (proto->fam.set_port)
-			proto->fam.set_port(&l->rx.addr, port);
+		if (proto->fam->set_port)
+			proto->fam->set_port(&l->rx.addr, port);
 
 		MT_LIST_INIT(&l->wait_queue);
 		listener_set_state(l, LI_INIT);
 
-		proto->add(l, port);
+		proto->add(proto, l);
 
 		if (fd != -1)
 			l->rx.flags |= RX_F_INHERITED;
diff --git a/src/proto_sockpair.c b/src/proto_sockpair.c
index cc92753..fe74ff4 100644
--- a/src/proto_sockpair.c
+++ b/src/proto_sockpair.c
@@ -43,7 +43,6 @@
 #include <haproxy/version.h>
 
 
-static void sockpair_add_listener(struct listener *listener, int port);
 static int sockpair_bind_listener(struct listener *listener, char *errmsg, int errlen);
 static void sockpair_enable_listener(struct listener *listener);
 static void sockpair_disable_listener(struct listener *listener);
@@ -71,7 +70,7 @@
 	.sock_domain = AF_CUST_SOCKPAIR,
 	.sock_type = SOCK_STREAM,
 	.sock_prot = 0,
-	.add = sockpair_add_listener,
+	.add = default_add_listener,
 	.listen = sockpair_bind_listener,
 	.enable = sockpair_enable_listener,
 	.disable = sockpair_disable_listener,
@@ -89,23 +88,6 @@
 
 INITCALL1(STG_REGISTER, protocol_register, &proto_sockpair);
 
-/* Add <listener> to the list of sockpair listeners (port is ignored). The
- * listener's state is automatically updated from LI_INIT to LI_ASSIGNED.
- * The number of listeners for the protocol is updated.
- *
- * Must be called with proto_lock held.
- *
- */
-static void sockpair_add_listener(struct listener *listener, int port)
-{
-	if (listener->state != LI_INIT)
-		return;
-	listener_set_state(listener, LI_ASSIGNED);
-	listener->rx.proto = &proto_sockpair;
-	LIST_ADDQ(&proto_sockpair.receivers, &listener->rx.proto_list);
-	proto_sockpair.nb_receivers++;
-}
-
 /* Enable receipt of incoming connections for listener <l>. The receiver must
  * still be valid.
  */
diff --git a/src/proto_tcp.c b/src/proto_tcp.c
index 7c7670a..30a0045 100644
--- a/src/proto_tcp.c
+++ b/src/proto_tcp.c
@@ -49,8 +49,6 @@
 static int tcp_resume_receiver(struct receiver *rx);
 static void tcp_enable_listener(struct listener *listener);
 static void tcp_disable_listener(struct listener *listener);
-static void tcpv4_add_listener(struct listener *listener, int port);
-static void tcpv6_add_listener(struct listener *listener, int port);
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct protocol proto_tcpv4 = {
@@ -60,7 +58,7 @@
 	.sock_domain = AF_INET,
 	.sock_type = SOCK_STREAM,
 	.sock_prot = IPPROTO_TCP,
-	.add = tcpv4_add_listener,
+	.add = default_add_listener,
 	.listen = tcp_bind_listener,
 	.enable = tcp_enable_listener,
 	.disable = tcp_disable_listener,
@@ -90,7 +88,7 @@
 	.sock_domain = AF_INET6,
 	.sock_type = SOCK_STREAM,
 	.sock_prot = IPPROTO_TCP,
-	.add = tcpv6_add_listener,
+	.add = default_add_listener,
 	.listen = tcp_bind_listener,
 	.enable = tcp_enable_listener,
 	.disable = tcp_disable_listener,
@@ -712,40 +710,6 @@
 	return err;
 }
 
-/* Add <listener> to the list of tcpv4 listeners, on port <port>. The
- * listener's state is automatically updated from LI_INIT to LI_ASSIGNED.
- * The number of listeners for the protocol is updated.
- *
- * Must be called with proto_lock held.
- *
- */
-static void tcpv4_add_listener(struct listener *listener, int port)
-{
-	if (listener->state != LI_INIT)
-		return;
-	listener_set_state(listener, LI_ASSIGNED);
-	listener->rx.proto = &proto_tcpv4;
-	LIST_ADDQ(&proto_tcpv4.receivers, &listener->rx.proto_list);
-	proto_tcpv4.nb_receivers++;
-}
-
-/* Add <listener> to the list of tcpv6 listeners, on port <port>. The
- * listener's state is automatically updated from LI_INIT to LI_ASSIGNED.
- * The number of listeners for the protocol is updated.
- *
- * Must be called with proto_lock held.
- *
- */
-static void tcpv6_add_listener(struct listener *listener, int port)
-{
-	if (listener->state != LI_INIT)
-		return;
-	listener_set_state(listener, LI_ASSIGNED);
-	listener->rx.proto = &proto_tcpv6;
-	LIST_ADDQ(&proto_tcpv6.receivers, &listener->rx.proto_list);
-	proto_tcpv6.nb_receivers++;
-}
-
 /* Enable receipt of incoming connections for listener <l>. The receiver must
  * still be valid.
  */
diff --git a/src/proto_udp.c b/src/proto_udp.c
index 436f2a0..5ac7b15 100644
--- a/src/proto_udp.c
+++ b/src/proto_udp.c
@@ -45,8 +45,6 @@
 static int udp_resume_receiver(struct receiver *rx);
 static void udp_enable_listener(struct listener *listener);
 static void udp_disable_listener(struct listener *listener);
-static void udp4_add_listener(struct listener *listener, int port);
-static void udp6_add_listener(struct listener *listener, int port);
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct protocol proto_udp4 = {
@@ -56,7 +54,7 @@
 	.sock_domain = AF_INET,
 	.sock_type = SOCK_DGRAM,
 	.sock_prot = IPPROTO_UDP,
-	.add = udp4_add_listener,
+	.add = default_add_listener,
 	.listen = udp_bind_listener,
 	.enable = udp_enable_listener,
 	.disable = udp_disable_listener,
@@ -82,7 +80,7 @@
 	.sock_domain = AF_INET6,
 	.sock_type = SOCK_DGRAM,
 	.sock_prot = IPPROTO_UDP,
-	.add = udp6_add_listener,
+	.add = default_add_listener,
 	.listen = udp_bind_listener,
 	.enable = udp_enable_listener,
 	.disable = udp_disable_listener,
@@ -142,34 +140,6 @@
 	return err;
 }
 
-/* Add <listener> to the list of udp4 listeners, on port <port>. The
- * listener's state is automatically updated from LI_INIT to LI_ASSIGNED.
- * The number of listeners for the protocol is updated.
- */
-static void udp4_add_listener(struct listener *listener, int port)
-{
-	if (listener->state != LI_INIT)
-		return;
-	listener_set_state(listener, LI_ASSIGNED);
-	listener->rx.proto = &proto_udp4;
-	LIST_ADDQ(&proto_udp4.receivers, &listener->rx.proto_list);
-	proto_udp4.nb_receivers++;
-}
-
-/* Add <listener> to the list of udp6 listeners, on port <port>. The
- * listener's state is automatically updated from LI_INIT to LI_ASSIGNED.
- * The number of listeners for the protocol is updated.
- */
-static void udp6_add_listener(struct listener *listener, int port)
-{
-	if (listener->state != LI_INIT)
-		return;
-	listener_set_state(listener, LI_ASSIGNED);
-	listener->rx.proto = &proto_udp6;
-	LIST_ADDQ(&proto_udp6.receivers, &listener->rx.proto_list);
-	proto_udp6.nb_receivers++;
-}
-
 /* Enable receipt of incoming connections for listener <l>. The receiver must
  * still be valid.
  */
diff --git a/src/proto_uxst.c b/src/proto_uxst.c
index f558e5f..9c19374 100644
--- a/src/proto_uxst.c
+++ b/src/proto_uxst.c
@@ -42,7 +42,6 @@
 
 static int uxst_bind_listener(struct listener *listener, char *errmsg, int errlen);
 static int uxst_connect_server(struct connection *conn, int flags);
-static void uxst_add_listener(struct listener *listener, int port);
 static void uxst_enable_listener(struct listener *listener);
 static void uxst_disable_listener(struct listener *listener);
 static int uxst_suspend_receiver(struct receiver *rx);
@@ -55,7 +54,7 @@
 	.sock_domain = PF_UNIX,
 	.sock_type = SOCK_STREAM,
 	.sock_prot = 0,
-	.add = uxst_add_listener,
+	.add = default_add_listener,
 	.listen = uxst_bind_listener,
 	.enable = uxst_enable_listener,
 	.disable = uxst_disable_listener,
@@ -135,23 +134,6 @@
 	return err;
 }
 
-/* Add <listener> to the list of unix stream listeners (port is ignored). The
- * listener's state is automatically updated from LI_INIT to LI_ASSIGNED.
- * The number of listeners for the protocol is updated.
- *
- * Must be called with proto_lock held.
- *
- */
-static void uxst_add_listener(struct listener *listener, int port)
-{
-	if (listener->state != LI_INIT)
-		return;
-	listener_set_state(listener, LI_ASSIGNED);
-	listener->rx.proto = &proto_unix;
-	LIST_ADDQ(&proto_unix.receivers, &listener->rx.proto_list);
-	proto_unix.nb_receivers++;
-}
-
 /* Enable receipt of incoming connections for listener <l>. The receiver must
  * still be valid.
  */
