From mboxrd@z Thu Jan 1 00:00:00 1970 Received: by passt.top (Postfix, from userid 1000) id DCB855A0272; Sun, 15 Nov 2026 23:38:23 +0100 (CET) From: Stefano Brivio To: passt-dev@passt.top Subject: [FOR REFERENCE ONLY] [PATCH] udp: Don't share a preserved source port with other sockets Date: Sun, 15 Nov 2026 23:38:23 +0100 Message-ID: <20261115223823.1401886-1-sbrivio@redhat.com> X-Mailer: git-send-email 2.43.0 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Message-ID-Hash: AONXDF2UGTOQMGJOV7GJHVEOSWRP3VTM X-Message-ID-Hash: AONXDF2UGTOQMGJOV7GJHVEOSWRP3VTM X-MailFrom: sbrivio@passt.top X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; emergency; loop; banned-address; member-moderation; nonmember-moderation; administrivia; implicit-dest; max-recipients; max-size; news-moderation; no-subject; digests; suspicious-header CC: Gerwim Feiken , David Gibson X-Mailman-Version: 3.3.8 Precedence: list List-Id: Development discussion and patches for passt Archived-At: Archived-At: List-Archive: List-Archive: List-Help: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: From: Gerwim Feiken For a UDP flow initiated from the guest, passt keeps the guest's source port on the host side (fwd_nat_from_tap()) and binds the flow socket with SO_REUSEADDR (sock_l4_()). Several passt instances in one network namespace -- one per VM, as a VM manager spawning passt from one daemon does -- can then each bind the same port towards the same destination, typically the resolver behind --dns-forward. Their sockets share one identical 4-tuple, and the kernel delivers each reply to only one of them: the other guest's queries go unanswered until the flow expires, and the guest owning the receiving socket gets answers to queries it never sent. Bind the host side socket of a flow initiated from the tap interface without SO_REUSEADDR, so that the bind fails if any other socket holds the port, and fall back to a port chosen by the kernel in that case. udp_flow_new() reads the actual port back with getsockname(), as it already does for the address. Listening sockets, and flows initiated from them, keep SO_REUSEADDR. Signed-off-by: Gerwim Feiken --- This was shared by Gerwim a while ago but I never followed up with it. Now that we have https://bugs.passt.top/show_bug.cgi?id=223, I would like to refer to this patch from that ticket, that's why I'm posting it. I guess we could solve both issues, the one originally fixed by this patch and the one raised in https://bugs.passt.top/show_bug.cgi?id=223, using just this patch, as it implements a fallback for bind() anyway. But I didn't review this patch thoroughly yet. flow.c | 11 +++++++---- flow.h | 2 +- icmp.c | 2 +- pif.c | 2 +- udp_flow.c | 28 ++++++++++++++++++++++++---- util.c | 15 ++++++++++----- util.h | 3 ++- 7 files changed, 46 insertions(+), 17 deletions(-) diff --git a/flow.c b/flow.c index 27a24a4..c6ebaf6 100644 --- a/flow.c +++ b/flow.c @@ -177,6 +177,7 @@ static void flowside_from_af(struct flowside *side, sa_family_t af, * @err: Filled in with errno if something failed * @type: Socket epoll type * @sa: Socket address + * @exclusive: Don't set SO_REUSEADDR (see sock_l4_()) */ struct flowside_sock_args { const struct ctx *c; @@ -184,6 +185,7 @@ struct flowside_sock_args { int err; enum epoll_type type; const union sockaddr_inany *sa; + bool exclusive; }; /** flowside_sock_splice() - Create and bind socket for PIF_SPLICE based on flowside @@ -197,7 +199,7 @@ static int flowside_sock_splice(void *arg) ns_enter(a->c); - a->fd = sock_l4(a->c, a->type, a->sa, NULL); + a->fd = sock_l4(a->c, a->type, a->sa, NULL, a->exclusive); a->err = errno; return 0; @@ -208,12 +210,13 @@ static int flowside_sock_splice(void *arg) * @type: Socket epoll type * @pif: Interface for this socket * @side: Flowside to create a socket for + * @exclusive: Don't set SO_REUSEADDR (see sock_l4_()) * * Return: socket fd of protocol @proto bound to our address and port from @side * (if specified). */ int flowside_sock_l4(const struct ctx *c, enum epoll_type type, uint8_t pif, - const struct flowside *side) + const struct flowside *side, bool exclusive) { const char *ifname = NULL; union sockaddr_inany sa; @@ -231,11 +234,11 @@ int flowside_sock_l4(const struct ctx *c, enum epoll_type type, uint8_t pif, else if (sa.sa_family == AF_INET6) ifname = c->ip6.ifname_out; - return sock_l4(c, type, &sa, ifname); + return sock_l4(c, type, &sa, ifname, exclusive); case PIF_SPLICE: { struct flowside_sock_args args = { - .c = c, .type = type, .sa = &sa, + .c = c, .type = type, .sa = &sa, .exclusive = exclusive, }; NS_CALL(flowside_sock_splice, &args); errno = args.err; diff --git a/flow.h b/flow.h index db02845..3b37ac3 100644 --- a/flow.h +++ b/flow.h @@ -173,7 +173,7 @@ static inline bool flowside_eq(const struct flowside *left, } int flowside_sock_l4(const struct ctx *c, enum epoll_type type, uint8_t pif, - const struct flowside *side); + const struct flowside *side, bool exclusive); int flowside_connect(const struct ctx *c, int s, uint8_t pif, const struct flowside *tgt); diff --git a/icmp.c b/icmp.c index 0fe2366..7499a39 100644 --- a/icmp.c +++ b/icmp.c @@ -203,7 +203,7 @@ static struct icmp_ping_flow *icmp_ping_new(const struct ctx *c, pingf->seq = -1; - pingf->sock = flowside_sock_l4(c, EPOLL_TYPE_PING, PIF_HOST, tgt); + pingf->sock = flowside_sock_l4(c, EPOLL_TYPE_PING, PIF_HOST, tgt, false); if (pingf->sock < 0) { warn("Cannot open \"ping\" socket. You might need to:"); diff --git a/pif.c b/pif.c index 8ade587..d028819 100644 --- a/pif.c +++ b/pif.c @@ -114,7 +114,7 @@ int pif_listen(const struct ctx *c, uint8_t proto, uint8_t pif, union sockaddr_inany sa; pif_sockaddr(c, &sa, pif, addr, port); - ref.fd = sock_l4(c, type, &sa, ifname); + ref.fd = sock_l4(c, type, &sa, ifname, false); } if (ref.fd < 0) diff --git a/udp_flow.c b/udp_flow.c index 865702c..a9fab7a 100644 --- a/udp_flow.c +++ b/udp_flow.c @@ -74,10 +74,26 @@ static int udp_flow_sock(const struct ctx *c, { const struct flowside *side = &uflow->f.side[sidei]; uint8_t pif = uflow->f.pif[sidei]; + /* A guest-initiated flow keeps the guest's source port on the host + * side. Bind it exclusively: without SO_REUSEADDR the bind fails if + * any other socket in this network namespace holds the port, such as + * another passt instance's flow towards the same destination (typically + * the same DNS resolver). Two sockets with an identical 4-tuple would + * steal each other's replies. In that case let the kernel pick a free + * port instead, and udp_flow_new() records it. Listening sockets and + * the flows they initiate keep SO_REUSEADDR, as they must share ports. + */ + bool exclusive = sidei == TGTSIDE && uflow->f.pif[INISIDE] == PIF_TAP; int rc; int s; - s = flowside_sock_l4(c, EPOLL_TYPE_UDP, pif, side); + s = flowside_sock_l4(c, EPOLL_TYPE_UDP, pif, side, exclusive); + if (s == -EADDRINUSE && exclusive && side->oport) { + flow_dbg(uflow, "Host port %hu in use, using an ephemeral port", + side->oport); + uflow->f.side[sidei].oport = 0; + s = flowside_sock_l4(c, EPOLL_TYPE_UDP, pif, side, exclusive); + } if (s < 0) { flow_perror_ratelimit(uflow, now, "Couldn't open flow specific socket"); @@ -162,13 +178,15 @@ static flow_sidx_t udp_flow_new(const struct ctx *c, union flow *flow, goto cancel; } - if (uflow->s[TGTSIDE] >= 0 && inany_is_unspecified(&tgt->oaddr)) { + if (uflow->s[TGTSIDE] >= 0 && + (inany_is_unspecified(&tgt->oaddr) || !tgt->oport)) { /* When we target a socket, we connect() it, but might not * always bind(), leaving the kernel to pick our address. In * that case connect() will implicitly bind() the socket, but we * need to determine its local address so that we can match * reply packets back to the correct flow. Update the flow with - * the information from getsockname() */ + * the information from getsockname(). The same applies to the + * port if udp_flow_sock() had to let the kernel pick one. */ union sockaddr_inany sa; socklen_t sl = sizeof(sa); in_port_t port; @@ -179,7 +197,9 @@ static flow_sidx_t udp_flow_new(const struct ctx *c, union flow *flow, flow_perror(uflow, "Unable to determine local address"); goto cancel; } - if (port != tgt->oport) { + if (!tgt->oport) { + uflow->f.side[TGTSIDE].oport = port; + } else if (port != tgt->oport) { flow_err_ratelimit(uflow, now, "Unexpected local port"); goto cancel; } diff --git a/util.c b/util.c index ff1f19f..053dd80 100644 --- a/util.c +++ b/util.c @@ -47,12 +47,14 @@ uint8_t eth_pad[ETH_ZLEN] = { 0 }; * @sa: Socket address to bind to * @ifname: Interface for binding, NULL for any * @v6only: If >= 0, set IPV6_V6ONLY socket option to this value + * @exclusive: Don't set SO_REUSEADDR, so that binding a port already bound + * by any other socket fails with EADDRINUSE * * Return: newly created socket, negative error code on failure */ static int sock_l4_(const struct ctx *c, enum epoll_type type, const union sockaddr_inany *sa, const char *ifname, - int v6only) + int v6only, bool exclusive) { sa_family_t af = sa->sa_family; bool freebind = false; @@ -104,7 +106,8 @@ static int sock_l4_(const struct ctx *c, enum epoll_type type, } } - if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &y, sizeof(y))) + if (!exclusive && + setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &y, sizeof(y))) debug("Failed to set SO_REUSEADDR on socket %i", fd); if (proto == IPPROTO_UDP) { @@ -173,11 +176,13 @@ static int sock_l4_(const struct ctx *c, enum epoll_type type, * @type: epoll type * @sa: Socket address to bind to * @ifname: Interface for binding, NULL for any + * @exclusive: Don't set SO_REUSEADDR (see sock_l4_()) * * Return: newly created socket, negative error code on failure */ int sock_l4(const struct ctx *c, enum epoll_type type, - const union sockaddr_inany *sa, const char *ifname) + const union sockaddr_inany *sa, const char *ifname, + bool exclusive) { int v6only = -1; @@ -188,7 +193,7 @@ int sock_l4(const struct ctx *c, enum epoll_type type, IN6_IS_ADDR_UNSPECIFIED(&sa->sa6.sin6_addr)) v6only = 1; - return sock_l4_(c, type, sa, ifname, v6only); + return sock_l4_(c, type, sa, ifname, v6only, exclusive); } /** @@ -215,7 +220,7 @@ int sock_l4_dualstack_any(const struct ctx *c, enum epoll_type type, * default, but sysctl net.ipv6.bindv6only can change that, so set the * sockopt explicitly. */ - return sock_l4_(c, type, &sa, ifname, 0); + return sock_l4_(c, type, &sa, ifname, 0, false); } /** diff --git a/util.h b/util.h index ec2d9ac..0f187ad 100644 --- a/util.h +++ b/util.h @@ -147,7 +147,8 @@ struct ctx; union sockaddr_inany; int sock_l4(const struct ctx *c, enum epoll_type type, - const union sockaddr_inany *sa, const char *ifname); + const union sockaddr_inany *sa, const char *ifname, + bool exclusive); int sock_l4_dualstack_any(const struct ctx *c, enum epoll_type type, in_port_t port, const char *ifname); int sock_unix(char *sock_path); -- 2.43.0