diff --git a/include/haproxy/sock.h b/include/haproxy/sock.h
index 40856f4..7a9125a 100644
--- a/include/haproxy/sock.h
+++ b/include/haproxy/sock.h
@@ -40,7 +40,7 @@
 int sock_get_dst(int fd, struct sockaddr *sa, socklen_t salen, int dir);
 int sock_get_old_sockets(const char *unixsocket);
 int sock_find_compatible_fd(const struct receiver *rx);
-int sock_accept_conn(const struct receiver *rx);
+int sock_accepting_conn(const struct receiver *rx);
 
 #endif /* _HAPROXY_SOCK_H */
 
diff --git a/src/proto_sockpair.c b/src/proto_sockpair.c
index 48b598b..357a5fe 100644
--- a/src/proto_sockpair.c
+++ b/src/proto_sockpair.c
@@ -47,7 +47,7 @@
 static void sockpair_enable_listener(struct listener *listener);
 static void sockpair_disable_listener(struct listener *listener);
 static int sockpair_connect_server(struct connection *conn, int flags);
-static int sockpair_accept_conn(const struct receiver *rx);
+static int sockpair_accepting_conn(const struct receiver *rx);
 
 struct proto_fam proto_fam_sockpair = {
 	.name = "sockpair",
@@ -77,7 +77,7 @@
 	.rx_unbind = sock_unbind,
 	.rx_enable = sock_enable,
 	.rx_disable = sock_disable,
-	.rx_listening = sockpair_accept_conn,
+	.rx_listening = sockpair_accepting_conn,
 	.accept = &listener_accept,
 	.connect = &sockpair_connect_server,
 	.receivers = LIST_HEAD_INIT(proto_sockpair.receivers),
@@ -440,7 +440,7 @@
  * The real test consists in verifying we have a connected SOCK_STREAM of
  * family AF_UNIX.
  */
-static int sockpair_accept_conn(const struct receiver *rx)
+static int sockpair_accepting_conn(const struct receiver *rx)
 {
 	struct sockaddr sa;
 	socklen_t len;
diff --git a/src/proto_tcp.c b/src/proto_tcp.c
index be9a25a..950daec 100644
--- a/src/proto_tcp.c
+++ b/src/proto_tcp.c
@@ -72,7 +72,7 @@
 	.rx_unbind = sock_unbind,
 	.rx_suspend = tcp_suspend_receiver,
 	.rx_resume = tcp_resume_receiver,
-	.rx_listening = sock_accept_conn,
+	.rx_listening = sock_accepting_conn,
 	.accept = &listener_accept,
 	.connect = tcp_connect_server,
 	.receivers = LIST_HEAD_INIT(proto_tcpv4.receivers),
@@ -101,7 +101,7 @@
 	.rx_unbind = sock_unbind,
 	.rx_suspend = tcp_suspend_receiver,
 	.rx_resume = tcp_resume_receiver,
-	.rx_listening = sock_accept_conn,
+	.rx_listening = sock_accepting_conn,
 	.accept = &listener_accept,
 	.connect = tcp_connect_server,
 	.receivers = LIST_HEAD_INIT(proto_tcpv6.receivers),
@@ -678,7 +678,7 @@
 	}
 #endif
 
-	ready = sock_accept_conn(&listener->rx) > 0;
+	ready = sock_accepting_conn(&listener->rx) > 0;
 
 	if (!ready && /* only listen if not already done by external process */
 	    listen(fd, listener_backlog(listener)) == -1) {
@@ -783,7 +783,7 @@
 	 * dealing with a socket that is shared with other processes doing the
 	 * same. Let's check if it's still accepting connections.
 	 */
-	ret = sock_accept_conn(rx);
+	ret = sock_accepting_conn(rx);
 	if (ret <= 0) {
 		/* unrecoverable or paused by another process */
 		fd_stop_recv(rx->fd);
diff --git a/src/proto_uxst.c b/src/proto_uxst.c
index 5cf16a7..be8525b 100644
--- a/src/proto_uxst.c
+++ b/src/proto_uxst.c
@@ -65,7 +65,7 @@
 	.rx_disable = sock_disable,
 	.rx_unbind = sock_unbind,
 	.rx_suspend = uxst_suspend_receiver,
-	.rx_listening = sock_accept_conn,
+	.rx_listening = sock_accepting_conn,
 	.accept = &listener_accept,
 	.connect = &uxst_connect_server,
 	.receivers = LIST_HEAD_INIT(proto_unix.receivers),
@@ -111,7 +111,7 @@
 	}
 
 	fd = listener->rx.fd;
-	ready = sock_accept_conn(&listener->rx) > 0;
+	ready = sock_accepting_conn(&listener->rx) > 0;
 
 	if (!ready && /* only listen if not already done by external process */
 	    listen(fd, listener_backlog(listener)) < 0) {
diff --git a/src/sock.c b/src/sock.c
index ea6e366..8f890ea 100644
--- a/src/sock.c
+++ b/src/sock.c
@@ -471,7 +471,7 @@
  * rationale behind this is that inherited FDs may be broken and that shared
  * FDs might have been paused by another process.
  */
-int sock_accept_conn(const struct receiver *rx)
+int sock_accepting_conn(const struct receiver *rx)
 {
 	int opt_val = 0;
 	socklen_t opt_len = sizeof(opt_val);
