From: Willy Tarreau <w@1wt.eu>
Date: Mon, 27 Feb 2023 15:39:32 +0000 (+0100)
Subject: MEDIUM: proto: duplicate receivers marked RX_F_MUST_DUP
X-Git-Tag: v2.8-dev8~38
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=0e1aaf4e78ad759e452b9459ebbaaa661fe86b25;p=thirdparty%2Fhaproxy.git

MEDIUM: proto: duplicate receivers marked RX_F_MUST_DUP

The different protocol's ->bind() function will now check the receiver's
RX_F_MUST_DUP flag to decide whether to bind a fresh new listener from
scratch or reuse an existing one and just duplicate it. It turns out
that the existing code already supports reusing FDs since that was done
as part of the FD passing and inheriting mechanism. Here it's not much
different, we pass the FD of the reference receiver, it gets duplicated
and becomes the new receiver's FD.

These FDs are also marked RX_F_INHERITED so that they are not exported
and avoid being touched directly (only the reference should be touched).
---

diff --git a/src/proto_sockpair.c b/src/proto_sockpair.c
index 1c5d7422f7..a719063a81 100644
--- a/src/proto_sockpair.c
+++ b/src/proto_sockpair.c
@@ -137,6 +137,30 @@ int sockpair_bind_receiver(struct receiver *rx, char **errmsg)
 	if (rx->flags & RX_F_BOUND)
 		return ERR_NONE;
 
+	if (rx->flags & RX_F_MUST_DUP) {
+		/* this is a secondary receiver that is an exact copy of a
+		 * reference which must already be bound (or has failed).
+		 * We'll try to dup() the other one's FD and take it. We
+		 * try hard not to reconfigure the socket since it's shared.
+		 */
+		BUG_ON(!rx->shard_info);
+		if (!(rx->shard_info->ref->flags & RX_F_BOUND)) {
+			/* it's assumed that the first one has already reported
+			 * the error, let's not spam with another one, and do
+			 * not set ERR_ALERT.
+			 */
+			err |= ERR_RETRYABLE;
+			goto bind_ret_err;
+		}
+		/* taking the other one's FD will result in it being marked
+		 * extern and being dup()ed. Let's mark the receiver as
+		 * inherited so that it properly bypasses all second-stage
+		 * setup and avoids being passed to new processes.
+		 */
+		rx->flags |= RX_F_INHERITED;
+		rx->fd = rx->shard_info->ref->fd;
+	}
+
 	if (rx->fd == -1) {
 		err |= ERR_FATAL | ERR_ALERT;
 		memprintf(errmsg, "sockpair may be only used with inherited FDs");
@@ -164,6 +188,7 @@ int sockpair_bind_receiver(struct receiver *rx, char **errmsg)
 	if (errmsg && *errmsg)
 		memprintf(errmsg, "%s for [fd %d]", *errmsg, rx->fd);
 
+ bind_ret_err:
 	return err;
 
  bind_close_return:
diff --git a/src/sock_inet.c b/src/sock_inet.c
index f85582cfde..b7861f7885 100644
--- a/src/sock_inet.c
+++ b/src/sock_inet.c
@@ -288,6 +288,30 @@ int sock_inet_bind_receiver(struct receiver *rx, char **errmsg)
 	if (rx->flags & RX_F_BOUND)
 		return ERR_NONE;
 
+	if (rx->flags & RX_F_MUST_DUP) {
+		/* this is a secondary receiver that is an exact copy of a
+		 * reference which must already be bound (or has failed).
+		 * We'll try to dup() the other one's FD and take it. We
+		 * try hard not to reconfigure the socket since it's shared.
+		 */
+		BUG_ON(!rx->shard_info);
+		if (!(rx->shard_info->ref->flags & RX_F_BOUND)) {
+			/* it's assumed that the first one has already reported
+			 * the error, let's not spam with another one, and do
+			 * not set ERR_ALERT.
+			 */
+			err |= ERR_RETRYABLE;
+			goto bind_ret_err;
+		}
+		/* taking the other one's FD will result in it being marked
+		 * extern and being dup()ed. Let's mark the receiver as
+		 * inherited so that it properly bypasses all second-stage
+		 * setup and avoids being passed to new processes.
+		 */
+		rx->flags |= RX_F_INHERITED;
+		rx->fd = rx->shard_info->ref->fd;
+	}
+
 	/* if no FD was assigned yet, we'll have to either find a compatible
 	 * one or create a new one.
 	 */
@@ -421,6 +445,7 @@ int sock_inet_bind_receiver(struct receiver *rx, char **errmsg)
 		addr_to_str(&addr_inet, pn, sizeof(pn));
 		memprintf(errmsg, "%s for [%s:%d]", *errmsg, pn, get_host_port(&addr_inet));
 	}
+ bind_ret_err:
 	return err;
 
  bind_close_return:
diff --git a/src/sock_unix.c b/src/sock_unix.c
index ac3cb642d7..1f7da504df 100644
--- a/src/sock_unix.c
+++ b/src/sock_unix.c
@@ -154,6 +154,30 @@ int sock_unix_bind_receiver(struct receiver *rx, char **errmsg)
 	if (rx->flags & RX_F_BOUND)
 		return ERR_NONE;
 
+	if (rx->flags & RX_F_MUST_DUP) {
+		/* this is a secondary receiver that is an exact copy of a
+		 * reference which must already be bound (or has failed).
+		 * We'll try to dup() the other one's FD and take it. We
+		 * try hard not to reconfigure the socket since it's shared.
+		 */
+		BUG_ON(!rx->shard_info);
+		if (!(rx->shard_info->ref->flags & RX_F_BOUND)) {
+			/* it's assumed that the first one has already reported
+			 * the error, let's not spam with another one, and do
+			 * not set ERR_ALERT.
+			 */
+			err |= ERR_RETRYABLE;
+			goto bind_ret_err;
+		}
+		/* taking the other one's FD will result in it being marked
+		 * extern and being dup()ed. Let's mark the receiver as
+		 * inherited so that it properly bypasses all second-stage
+		 * setup and avoids being passed to new processes.
+		 */
+		rx->flags |= RX_F_INHERITED;
+		rx->fd = rx->shard_info->ref->fd;
+	}
+
 	/* if no FD was assigned yet, we'll have to either find a compatible
 	 * one or create a new one.
 	 */
@@ -347,6 +371,7 @@ int sock_unix_bind_receiver(struct receiver *rx, char **errmsg)
 		else
 			memprintf(errmsg, "%s [fd %d]", *errmsg, fd);
 	}
+ bind_ret_err:
 	return err;
 
  bind_close_return: