From mboxrd@z Thu Jan 1 00:00:00 1970 Received: by passt.top (Postfix, from userid 1000) id 458575A0269; Tue, 17 Nov 2026 00:10:44 +0100 (CET) From: Stefano Brivio To: passt-dev@passt.top Subject: [PATCH] udp: Don't share preserved source ports, implement bind() fallback Date: Tue, 17 Nov 2026 00:10:44 +0100 Message-ID: <20261116231044.3995255-1-sbrivio@redhat.com> X-Mailer: git-send-email 2.43.0 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Message-ID-Hash: I7IOLBPB4SJZAPS6PQP6TS47QZU4AGMD X-Message-ID-Hash: I7IOLBPB4SJZAPS6PQP6TS47QZU4AGMD 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 , Rahul , Bug C 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 Gerwim says: -- 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. -- This commit, however, makes sense even beyond Gerwim's use case and the SO_REUSEADDR flag: the bind() fallback implemented here also takes care of conflicts we might have when the source port is already bound by other applications on the host. One notable case are Podman custom networks without pesto(1) (default as of Podman 6.1), where rootlessport is used to forward inbound ports, and pasta takes care of outbound forwards. In that setup, some applications, such as BitTorrent clients using DHT, use the same port as source port for outbound as well as for inbound transfers. If we don't pick a different source port for outbound flows, outbound transfers will fail altogether. Reported-by: Rahul Reported-by: Bug C Link: https://bugs.passt.top/show_bug.cgi?id=223 Signed-off-by: Gerwim Feiken [sbrivio: Add note about relevance in commit message] Signed-off-by: Stefano Brivio --- I'm reposting the same patch as posted by Gerwim, this time also reviewed by me, for review. 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