dev
Threads by month
- ----- 2026 -----
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2025 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2024 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2023 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2022 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2021 -----
- December
- November
November 2026
- 14 participants
- 44 discussions
[PATCH] fwd_rule: Restore forwarding of ephemeral ports for -t auto, -u auto
by Stefano Brivio 16 Nov '26
by Stefano Brivio 16 Nov '26
16 Nov '26
From: Frajo Haider <frajo(a)frajo.fi>
From an original patch by Frajo: commit 4e09ddf03443 ("conf: Allow
user-specified auto-scanned port forwarding ranges") made automatic
port forwarding exclude ephemeral ports, consistently with -t all and
-u all, and I thought this should actually be desirable, because those
ports are ephemeral, after all, and no services should be bound to
them.
On the other hand, services that can already be contacted on some
other port might want to expose additional (ephemeral indeed) ports.
So perhaps we should really expose them.
Now, Sean reports that this "feature" actually breaks things for the
kind (Kubernetes-in-Docker) project, because Docker relies on the
rootlesskit integration of pasta, which uses automatic port forwarding
instead of explicit configuration.
So, feature or not (and I'm fairly convinced it's a bug by now), it
causes a regression, so restore the previous behaviour: if ports are
automatically forwarded, don't exclude ephemeral ports.
Reported-by: Frajo Haider <frajo(a)frajo.fi>
Reported-by: Sean McGinnis <sean.mcginnis(a)gmail.com>
Link: https://bugs.passt.top/show_bug.cgi?id=219
Link: https://github.com/kubernetes-sigs/kind/issues/4293
Fixes: 4e09ddf03443 ("conf: Allow user-specified auto-scanned port forwarding ranges")
Signed-off-by: Stefano Brivio <sbrivio(a)redhat.com>
---
fwd_rule.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/fwd_rule.c b/fwd_rule.c
index 312bc60..a1294d6 100644
--- a/fwd_rule.c
+++ b/fwd_rule.c
@@ -694,7 +694,8 @@ static void fwd_rule_parse_ports(struct fwd_table *fwd, bool del, uint8_t proto,
/* Finally handle "all" and exclude only cases */
if (exclude_only) {
- fwd_port_map_ephemeral(exclude);
+ if (!(flags & FWD_SCAN))
+ fwd_port_map_ephemeral(exclude);
fwd_rule_range_except(fwd, del, proto, addr, ifname,
1, NUM_PORTS - 1, exclude,
--
2.43.0
2
1
[FOR REFERENCE ONLY] [PATCH] udp: Don't share a preserved source port with other sockets
by Stefano Brivio 15 Nov '26
by Stefano Brivio 15 Nov '26
15 Nov '26
From: Gerwim Feiken <info(a)gerwim.nl>
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 <info(a)gerwim.nl>
---
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
1
0
[PATCH v4 0/2] Implement explicit outbound address and interface selection
by Stefano Brivio 14 Nov '26
by Stefano Brivio 14 Nov '26
14 Nov '26
v4: In 2/2, use --outbound-if4 and --outbound-if6, by default, to also
assign "template" interface indices
Stefano Brivio (2):
conf, passt.h: Rename "outbound" interface to "template" interface
conf, icmp, tcp, udp: Add options to bind to outbound address and
interface
conf.c | 112 ++++++++++++++++++++++++++++++++++++++++++++++++--------
icmp.c | 24 ++++++++++--
passt.1 | 29 ++++++++++++++-
passt.h | 14 ++++++-
tcp.c | 60 ++++++++++++++++++++++++++++++
udp.c | 54 ++++++++++++++++++---------
6 files changed, 252 insertions(+), 41 deletions(-)
--
2.39.2
4
7
[PATCH] conf: Follow changes to the host nameserver used for DNS forwarding
by Aditya Merchant 13 Nov '26
by Aditya Merchant 13 Nov '26
13 Nov '26
We read the host's /etc/resolv.conf once, at start, and forward queries
sent to the --dns-forward address to the first nameserver listed there.
If the host then joins another network, connects to a VPN, or pasta
starts before the network is configured, that nameserver goes stale and
name resolution in the namespace stops working until pasta restarts.
With rootless Podman, that means stopping every container using the
rootless network namespace.
In pasta mode, if we forward DNS queries for an IP version, and the host
nameserver for it comes from resolv.conf (no --dns-host or --dns), watch
resolv.conf with inotify and read it again as it changes, so that new
DNS flows go to its current first nameserver. Watch the directory, not
the file, as NetworkManager and others replace resolv.conf by renaming
a new file over it. If resolv.conf is a symbolic link, watch the
directory of its target.
Once sandboxed, we can't open files by path, and keeping a descriptor
for the directory would undo the filesystem isolation: lookups of ".."
from it reach the rest of the host filesystem. Instead, right after
isolate_prefork() unshares our mount namespace, and before mounts become
unbindable, take a detached copy of the directory with open_tree() and
OPEN_TREE_CLONE: lookups from its root can't go above it, so the
directory holding resolv.conf is all we can still see. Where possible
(Linux 5.12 or later), make that copy read-only, too. Cloning needs
Linux 5.2 or later: if it fails, or if we can't read resolv.conf through
the copy, we just don't follow changes.
AppArmor resolves paths of files on a detached mount relative to their
filesystem, so allow the usual locations of resolv.conf under /run with
paths relative to /run, too.
Flows that already exist keep their target, so a client reusing the
same source port keeps reaching the old nameserver until its flow
expires.
Link: https://github.com/podman-container-tools/podman/issues/29130
Link: https://archives.passt.top/passt-dev/20230121104703.3ebcc753@elisabeth/
Signed-off-by: Aditya Merchant <adityamerchant08(a)gmail.com>
---
Notes:
Tested on Kali (arm64, Linux 7.1) with rootless Podman 5.8.6, and with
pasta alone, with the AppArmor profile enforcing: resolv.conf replaced
by rename, rewritten in place, empty at start and filled in later, and
a symbolic link into /run. With --dns-host, the address stays fixed, as
before. I also checked that, from the copy, ".." doesn't lead anywhere,
and that files can't be written or created. I didn't try kernels older
than 5.12 or 5.2.
I couldn't test SELinux: pasta.te doesn't allow 'watch' on etc_t or on
the directories under /run holding resolv.conf, so on Fedora I'd expect
inotify_add_watch() to be denied, and changes not to be followed (by
default, Fedora points resolv.conf to systemd-resolved on 127.0.0.53,
which doesn't change). I can add rules if you tell me which types or
interfaces you'd prefer.
There's no test under test/ yet, as the tests can't change the host's
resolv.conf. I could try one using a separate mount namespace, if you
think it's worth it.
conf.c | 239 ++++++++++++++++++++++++++--
conf.h | 2 +
contrib/apparmor/abstractions/pasta | 5 +
epoll_type.h | 2 +
isolation.c | 6 +-
isolation.h | 2 +-
linux_dep.h | 30 ++++
passt.1 | 4 +-
passt.c | 5 +
passt.h | 9 ++
10 files changed, 291 insertions(+), 13 deletions(-)
diff --git a/conf.c b/conf.c
index 149a4c7..63b4b9a 100644
--- a/conf.c
+++ b/conf.c
@@ -19,6 +19,9 @@
#include <libgen.h>
#include <string.h>
#include <sched.h>
+#include <sys/inotify.h>
+#include <sys/mount.h>
+#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
@@ -36,6 +39,7 @@
#include <netinet/if_ether.h>
#include "util.h"
+#include "linux_dep.h"
#include "bitmap.h"
#include "ip.h"
#include "passt.h"
@@ -199,6 +203,31 @@ static void add_dns_resolv(struct ctx *c, const char *nameserver,
add_dns_resolv6(c, &ns6, idx6);
}
+/**
+ * resolv_nameserver() - Get address from a nameserver line of resolv.conf
+ * @line: Line from resolv.conf, terminated, might be modified
+ *
+ * Return: address as string, NULL if @line is not a nameserver line
+ */
+static const char *resolv_nameserver(char *line)
+{
+ const char *p;
+ char *end;
+
+ if (strstr(line, "nameserver ") != line)
+ return NULL;
+
+ p = strrchr(line, ' ');
+ if (!p)
+ return NULL;
+
+ end = strpbrk(line, "%\n");
+ if (end)
+ *end = 0;
+
+ return p + 1;
+}
+
/**
* get_dns() - Get nameserver addresses from local /etc/resolv.conf
* @c: Execution context
@@ -218,6 +247,14 @@ static void get_dns(struct ctx *c)
dnss_set = !!*s->n || c->no_dns_search;
dns_set = (dns4_set && dns6_set) || c->no_dns;
+ /* Unless given with --dns-host, or unless we don't read nameservers
+ * at all, host nameservers we forward queries to come from resolv.conf
+ */
+ c->ip4.dns_host_resolv = !c->no_dns && !dns4_set &&
+ IN4_IS_ADDR_UNSPECIFIED(&c->ip4.dns_host);
+ c->ip6.dns_host_resolv = !c->no_dns && !dns6_set &&
+ IN6_IS_ADDR_UNSPECIFIED(&c->ip6.dns_host);
+
if (dns_set && dnss_set)
return;
@@ -226,16 +263,8 @@ static void get_dns(struct ctx *c)
lineread_init(&resolvconf, fd);
while ((line_len = lineread_get(&resolvconf, &line)) > 0) {
- if (!dns_set && strstr(line, "nameserver ") == line) {
- p = strrchr(line, ' ');
- if (!p)
- continue;
-
- end = strpbrk(line, "%\n");
- if (end)
- *end = 0;
-
- add_dns_resolv(c, p + 1,
+ if (!dns_set && (p = resolv_nameserver(line))) {
+ add_dns_resolv(c, p,
dns4_set ? NULL : &dns4_idx,
dns6_set ? NULL : &dns6_idx);
} else if (!dnss_set && strstr(line, "search ") == line &&
@@ -280,6 +309,196 @@ out:
}
}
+/**
+ * conf_resolv_update() - Update host nameservers from host's resolv.conf
+ * @c: Execution context
+ *
+ * Return: 0 on success, negative error code if the file can't be opened
+ *
+ * #syscalls:pasta openat
+ */
+static int conf_resolv_update(struct ctx *c)
+{
+ bool found4 = false, found6 = false;
+ char addr[INET6_ADDRSTRLEN];
+ struct lineread resolvconf;
+ struct in6_addr ns6;
+ struct in_addr ns4;
+ char *line;
+ int fd;
+
+ fd = openat(c->resolv_dir_fd, c->resolv_base, O_RDONLY | O_CLOEXEC);
+ if (fd < 0)
+ return -errno;
+
+ lineread_init(&resolvconf, fd);
+ while (lineread_get(&resolvconf, &line) > 0) {
+ const char *p = resolv_nameserver(line);
+
+ if (!p)
+ continue;
+
+ if (!found4)
+ found4 = inet_pton(AF_INET, p, &ns4) == 1;
+ if (!found6)
+ found6 = inet_pton(AF_INET6, p, &ns6) == 1;
+ }
+ close(fd);
+
+ if (c->ip4.dns_host_resolv && found4 &&
+ !IN4_ARE_ADDR_EQUAL(&ns4, &c->ip4.dns_host)) {
+ c->ip4.dns_host = ns4;
+ info("Forwarding DNS queries to new host nameserver %s",
+ inet_ntop(AF_INET, &ns4, addr, sizeof(addr)));
+ }
+
+ if (c->ip6.dns_host_resolv && found6 &&
+ !IN6_ARE_ADDR_EQUAL(&ns6, &c->ip6.dns_host)) {
+ c->ip6.dns_host = ns6;
+ info("Forwarding DNS queries to new host nameserver %s",
+ inet_ntop(AF_INET6, &ns6, addr, sizeof(addr)));
+ }
+
+ return 0;
+}
+
+/**
+ * conf_resolv_watch() - Watch host's resolv.conf to follow nameserver changes
+ * @c: Execution context
+ *
+ * The host nameserver we forward DNS queries to can change at any time, for
+ * example as the host joins a different network or connects to a VPN. Watch
+ * the directory containing resolv.conf with inotify, as the file is usually
+ * replaced by renaming a new one over it, not rewritten in place.
+ *
+ * Once sandboxed, we can't open resolv.conf by path, and a descriptor for the
+ * directory itself would let lookups of ".." reach the whole filesystem. Keep
+ * a detached, read-only copy of the directory instead: lookups can't go above
+ * its root. Cloning needs our own mount namespace, before its mounts are made
+ * unbindable: see isolate_prefork().
+ */
+void conf_resolv_watch(struct ctx *c)
+{
+ struct mount_attr attr = {
+ .attr_set = MOUNT_ATTR_RDONLY | MOUNT_ATTR_NOSUID |
+ MOUNT_ATTR_NODEV | MOUNT_ATTR_NOEXEC,
+ .propagation = MS_PRIVATE,
+ };
+ union epoll_ref ref = { .type = EPOLL_TYPE_RESOLV_INOTIFY };
+ char dir[PATH_MAX], *base;
+ int fd, dir_fd, rc;
+
+ if (c->mode != MODE_PASTA)
+ return;
+
+ if (IN4_IS_ADDR_UNSPECIFIED(&c->ip4.dns_match))
+ c->ip4.dns_host_resolv = false;
+ if (IN6_IS_ADDR_UNSPECIFIED(&c->ip6.dns_match))
+ c->ip6.dns_host_resolv = false;
+
+ if (!c->ip4.dns_host_resolv && !c->ip6.dns_host_resolv)
+ return;
+
+ /* With systemd-resolved, resolvconf, or NetworkManager in some
+ * configurations, resolv.conf is a symbolic link: watch its target
+ */
+ if (!realpath("/etc/resolv.conf", dir)) {
+ debug_perror("Not following changes to /etc/resolv.conf");
+ return;
+ }
+
+ /* Absolute path from realpath(): split it into directory and file */
+ base = strrchr(dir, '/');
+ if (!base || snprintf_check(c->resolv_base, sizeof(c->resolv_base),
+ "%s", base + 1))
+ return;
+ *(base == dir ? base + 1 : base) = 0;
+
+ /* AT_RECURSIVE: mounts we inherited in our user namespace are locked,
+ * and the kernel refuses to clone a subtree without its submounts
+ */
+ dir_fd = syscall(SYS_open_tree, AT_FDCWD, dir,
+ OPEN_TREE_CLONE | OPEN_TREE_CLOEXEC | AT_RECURSIVE);
+ if (dir_fd < 0) {
+ debug_perror("Can't clone %s, not following changes", dir);
+ return;
+ }
+
+ /* Best effort, needs Linux 5.12: we only need to read from the copy */
+ if (syscall(SYS_mount_setattr, dir_fd, "", AT_EMPTY_PATH | AT_RECURSIVE,
+ &attr, sizeof(attr)))
+ debug_perror("Can't make copy of %s read-only", dir);
+
+ if ((fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC)) < 0) {
+ debug_perror("Can't follow changes to resolv.conf");
+ goto fail;
+ }
+
+ if (inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO) < 0) {
+ debug_perror("Can't watch %s for changes", dir);
+ goto fail;
+ }
+
+ /* With the watch in place, read the file again: it might have changed
+ * since get_dns() read it. This also checks that we can read it through
+ * the copy, which security policies might not allow.
+ */
+ c->resolv_dir_fd = dir_fd;
+ if ((rc = conf_resolv_update(c))) {
+ debug("Can't read %s/%s through a copy: %s", dir, c->resolv_base,
+ strerror_(-rc));
+ goto fail;
+ }
+
+ if (fd > FD_REF_MAX) {
+ debug("resolv.conf watch file number %i too big", fd);
+ goto fail;
+ }
+
+ ref.fd = fd;
+ if (epoll_add(c->epollfd, EPOLLIN, ref))
+ goto fail;
+
+ return;
+
+fail:
+ c->resolv_dir_fd = -1;
+ if (fd >= 0)
+ close(fd);
+ close(dir_fd);
+}
+
+/**
+ * conf_resolv_handler() - Handle inotify events for host's resolv.conf
+ * @c: Execution context
+ * @fd: inotify file descriptor watching directory of resolv.conf
+ */
+void conf_resolv_handler(struct ctx *c, int fd)
+{
+ char buf[sizeof(struct inotify_event) + NAME_MAX + 1]
+ __attribute__ ((aligned(__alignof__(struct inotify_event))));
+ const struct inotify_event *ev;
+ bool changed = false;
+ ssize_t n;
+ char *p;
+ int rc;
+
+ if ((n = read(fd, buf, sizeof(buf))) < (ssize_t)sizeof(*ev))
+ return;
+
+ for (p = buf; p < buf + n; p += sizeof(*ev) + ev->len) {
+ ev = (const struct inotify_event *)p;
+
+ if ((ev->mask & IN_Q_OVERFLOW) ||
+ (ev->len && !strcmp(ev->name, c->resolv_base)))
+ changed = true;
+ }
+
+ if (changed && (rc = conf_resolv_update(c)))
+ warn("Can't read %s to update nameservers: %s",
+ c->resolv_base, strerror_(-rc));
+}
+
/**
* conf_netns_opt() - Parse --netns option
* @netns: buffer of size PATH_MAX, updated with netns path
diff --git a/conf.h b/conf.h
index 19bf9bc..15eb226 100644
--- a/conf.h
+++ b/conf.h
@@ -11,5 +11,7 @@ int conf_tap_fd(int argc, char **argv);
void conf(struct ctx *c, int argc, char **argv);
void conf_listen_handler(struct ctx *c, uint32_t events);
void conf_handler(struct ctx *c, uint32_t events);
+void conf_resolv_watch(struct ctx *c);
+void conf_resolv_handler(struct ctx *c, int fd);
#endif /* CONF_H */
diff --git a/contrib/apparmor/abstractions/pasta b/contrib/apparmor/abstractions/pasta
index 89fa427..8711f9f 100644
--- a/contrib/apparmor/abstractions/pasta
+++ b/contrib/apparmor/abstractions/pasta
@@ -29,6 +29,11 @@
@{run}/user/@{uid}/** rw, # pasta_open_ns()
+ # Host's resolv.conf in /run, read via a detached copy of its directory,
+ # with paths relative to /run: conf_resolv_watch(), conf_resolv_update()
+ /{NetworkManager,connman,netconfig,resolvconf}/resolv.conf r,
+ /systemd/resolve/{,stub-}resolv.conf r,
+
@{PROC}/[0-9]*/ns/ r, # pasta_netns_quit_init(),
@{PROC}/[0-9]*/ns/net r, # pasta_wait_for_ns(),
@{PROC}/[0-9]*/ns/user r, # conf_pasta_ns()
diff --git a/epoll_type.h b/epoll_type.h
index 061325a..a42944f 100644
--- a/epoll_type.h
+++ b/epoll_type.h
@@ -50,6 +50,8 @@ enum epoll_type {
EPOLL_TYPE_CONF_LISTEN,
/* Configuration socket */
EPOLL_TYPE_CONF,
+ /* inotify fd watching host's resolv.conf (pasta) */
+ EPOLL_TYPE_RESOLV_INOTIFY,
EPOLL_NUM_TYPES,
};
diff --git a/isolation.c b/isolation.c
index a00475f..6c42db7 100644
--- a/isolation.c
+++ b/isolation.c
@@ -470,11 +470,12 @@ void isolate_user(const struct ctx *c, uid_t uid, gid_t gid, bool use_userns,
* Should:
* - Move us to our own IPC and UTS namespaces
* - Move us to a mount namespace with only an empty directory
+ * - Keep a detached copy of the directory of resolv.conf, if needed
* - Drop unneeded capabilities (in the new user namespace)
* Mustn't:
* - Remove syscalls we need to daemonise
*/
-int isolate_prefork(const struct ctx *c)
+int isolate_prefork(struct ctx *c)
{
int flags = CLONE_NEWIPC | CLONE_NEWNS | CLONE_NEWUTS;
uint64_t ns_caps = 0;
@@ -491,6 +492,9 @@ int isolate_prefork(const struct ctx *c)
return -errno;
}
+ /* This clones a mount: do it before they all become unbindable */
+ conf_resolv_watch(c);
+
if (mount("", "/", "", MS_UNBINDABLE | MS_REC, NULL)) {
err_perror("Failed to remount /");
return -errno;
diff --git a/isolation.h b/isolation.h
index ec47038..4b8f822 100644
--- a/isolation.h
+++ b/isolation.h
@@ -14,7 +14,7 @@ void isolate_initial(void);
int isolate_fds(int argc, char **argv);
void isolate_user(const struct ctx *c, uid_t uid, gid_t gid, bool use_userns,
const char *userns);
-int isolate_prefork(const struct ctx *c);
+int isolate_prefork(struct ctx *c);
void isolate_postfork(const struct ctx *c);
#endif /* ISOLATION_H */
diff --git a/linux_dep.h b/linux_dep.h
index fa539ce..57ebc0d 100644
--- a/linux_dep.h
+++ b/linux_dep.h
@@ -138,6 +138,36 @@ struct tcp_info_linux {
#define CLOSE_RANGE_UNSHARE (1U << 1)
#endif
+#include <sys/mount.h>
+
+/* Older C libraries, or kernel headers < 5.2 and < 5.12, need these */
+#ifndef SYS_open_tree
+#define SYS_open_tree 428
+#endif
+#ifndef OPEN_TREE_CLONE
+#define OPEN_TREE_CLONE 1
+#define OPEN_TREE_CLOEXEC O_CLOEXEC
+#endif
+#ifndef AT_RECURSIVE
+#define AT_RECURSIVE 0x8000
+#endif
+#ifndef SYS_mount_setattr
+#define SYS_mount_setattr 442
+#endif
+#ifndef MOUNT_ATTR_RDONLY
+#define MOUNT_ATTR_RDONLY 0x00000001
+#define MOUNT_ATTR_NOSUID 0x00000002
+#define MOUNT_ATTR_NODEV 0x00000004
+#define MOUNT_ATTR_NOEXEC 0x00000008
+
+struct mount_attr {
+ uint64_t attr_set;
+ uint64_t attr_clr;
+ uint64_t propagation;
+ uint64_t userns_fd;
+};
+#endif
+
#ifndef TCP_REPAIR_ON
#define TCP_REPAIR_ON 1
#define TCP_REPAIR_OFF 0
diff --git a/passt.1 b/passt.1
index 0b780fe..126e692 100644
--- a/passt.1
+++ b/passt.1
@@ -287,7 +287,9 @@ Configure the host nameserver which guest or namespace queries to the
\fB\-\-dns-forward\fR address will be redirected to. This option can
be specified zero to two times (once for IPv4, once for IPv6).
By default, the first nameserver from the host's
-\fI/etc/resolv.conf\fR.
+\fI/etc/resolv.conf\fR. In pasta mode, this default follows changes to
+that file: new DNS flows go to its current first nameserver of the same IP
+version, while existing flows keep their target until they expire.
.TP
.BR \-S ", " \-\-search " " \fIlist
diff --git a/passt.c b/passt.c
index 5054551..3081166 100644
--- a/passt.c
+++ b/passt.c
@@ -69,6 +69,7 @@ struct ctx passt_ctx = {
.fd_control_listen = -1,
.fd_repair_listen = -1,
.pasta_netns_fd = -1,
+ .resolv_dir_fd = -1,
.device_state_fd = -1,
};
@@ -92,6 +93,7 @@ char *epoll_type_str[] = {
[EPOLL_TYPE_NL_NEIGH] = "netlink neighbour notifier socket",
[EPOLL_TYPE_CONF_LISTEN] = "configuration listening socket",
[EPOLL_TYPE_CONF] = "configuration socket",
+ [EPOLL_TYPE_RESOLV_INOTIFY] = "resolv.conf inotify watch",
};
static_assert(ARRAY_SIZE(epoll_type_str) == EPOLL_NUM_TYPES,
"epoll_type_str[] doesn't match enum epoll_type");
@@ -302,6 +304,9 @@ static void passt_worker(void *opaque, int nfds, struct epoll_event *events)
case EPOLL_TYPE_CONF:
conf_handler(c, eventmask);
break;
+ case EPOLL_TYPE_RESOLV_INOTIFY:
+ conf_resolv_handler(c, ref.fd);
+ break;
default:
/* Can't happen */
assert(0);
diff --git a/passt.h b/passt.h
index afd8e9f..d807222 100644
--- a/passt.h
+++ b/passt.h
@@ -80,6 +80,7 @@ enum passt_modes {
* @dns_host: Use this DNS on the host for forwarding
* @addr_out: Optional source address for outbound traffic
* @ifname_out: Optional interface name to bind outbound sockets to
+ * @dns_host_resolv: @dns_host comes from host's resolv.conf: follow changes
* @no_copy_routes: Don't copy all routes when configuring target namespace
* @no_copy_addrs: Don't copy all addresses when configuring namespace
* @addr_fixed: Address was given explicitly (-a): don't update
@@ -103,6 +104,7 @@ struct ip4_ctx {
char ifname_out[IFNAMSIZ];
+ bool dns_host_resolv;
bool no_copy_routes;
bool no_copy_addrs;
bool addr_fixed;
@@ -125,6 +127,7 @@ struct ip4_ctx {
* @dns_host: Use this DNS on the host for forwarding
* @addr_out: Optional source address for outbound traffic
* @ifname_out: Optional interface name to bind outbound sockets to
+ * @dns_host_resolv: @dns_host comes from host's resolv.conf: follow changes
* @no_copy_routes: Don't copy all routes when configuring target namespace
* @no_copy_addrs: Don't copy all addresses when configuring namespace
* @addr_fixed: Address was given explicitly (-a): don't update
@@ -149,6 +152,7 @@ struct ip6_ctx {
char ifname_out[IFNAMSIZ];
+ bool dns_host_resolv;
bool no_copy_routes;
bool no_copy_addrs;
bool addr_fixed;
@@ -175,6 +179,8 @@ struct ip6_ctx {
* @no_netns_quit: In pasta mode, don't exit if fs-bound namespace is gone
* @netns_base: Base name for fs-bound namespace, if any, in pasta mode
* @netns_dir: Directory of fs-bound namespace, if any, in pasta mode
+ * @resolv_dir_fd: Directory of host's resolv.conf, if watched for changes
+ * @resolv_base: Base name of host's resolv.conf in @resolv_dir_fd
* @epollfd: File descriptor for epoll instance
* @fd_tap_listen: File descriptor for listening AF_UNIX socket, if any
* @fd_tap: AF_UNIX socket, tuntap device, or pre-opened socket
@@ -252,6 +258,9 @@ struct ctx {
char netns_base[PATH_MAX];
char netns_dir[PATH_MAX];
+ int resolv_dir_fd;
+ char resolv_base[NAME_MAX + 1];
+
int epollfd;
int fd_tap_listen;
int fd_tap;
--
2.50.1 (Apple Git-155)
2
2
[PATCH] fwd, conf: Roll back to old rules if switching to new ones fails
by Hayato Kiwata 11 Nov '26
by Hayato Kiwata 11 Nov '26
11 Nov '26
If fwd_listen_init() fails while switching to new forwarding rules
received from pesto, we currently close the old listening sockets,
report an error and keep the (partially bound) new rules. That leaves
pasta in a state the user didn't ask for.
Make fwd_listen_switch() return the result of fwd_listen_init(), and
call it a second time from conf_handler() on failure to switch back
to the old rules.
Don't reset the count of the old table after closing its sockets, so
that the old rules stay in c->fwd_pending and can be restored. The
pending tables are cleared by conf_handler() before receiving new
rules anyway.
Note that reporting the failure to the client is left for a later patch.
Link: https://archives.passt.top/passt-dev/20261025153025.600a4fe9@elisabeth/
Signed-off-by: Hayato Kiwata <dev(a)haytok.jp>
---
This is a follow-up to the discussion on the dropped patch linked above.
Tested with:
$ pasta --ns-ifname=tap0 --mtu=65520 --config-net --address=10.0.2.100 \
--netmask=24 --gateway=10.0.2.2 --dns-forward=10.0.2.3 --no-map-gw \
--tcp-ns=none --udp-ns=none --ipv4-only --tcp-ports=none \
--udp-ports=none --conf-path=/tmp/.pasta.sock \
-- python3 -m http.server 80
$ pesto -A --tcp-ports=127.0.0.1/8085:80 /tmp/.pasta.sock
$ pesto -A --tcp-ports=192.0.2.1/8080:80 /tmp/.pasta.sock
$ pesto -s /tmp/.pasta.sock
passt/pasta configuration (/tmp/.pasta.sock)
HOST
TCP [127.0.0.1]:8085 => 80
SPLICE
$ curl -sI localhost:8085 | head -1
HTTP/1.0 200 OK
pasta logs:
Listen failed for HOST TCP port 192.0.2.1/8080: Cannot assign requested address
Couldn't listen on requested ports
Error switching to new forwarding rules
and the rule for port 8085 keeps working. Adding another valid rule
afterwards works as before.
conf.c | 7 ++++++-
fwd.c | 10 +++++-----
fwd.h | 2 +-
3 files changed, 12 insertions(+), 7 deletions(-)
diff --git a/conf.c b/conf.c
index 149a4c7..0d10ea4 100644
--- a/conf.c
+++ b/conf.c
@@ -2222,7 +2222,12 @@ void conf_handler(struct ctx *c, uint32_t events)
" ", "");
}
- fwd_listen_switch(c);
+ if (fwd_listen_switch(c) < 0) {
+ err("Error switching to new forwarding rules");
+ /* Switch back to old rules (still in c->fwd_pending) */
+ if (fwd_listen_switch(c) < 0)
+ err("Couldn't restore old forwarding rules");
+ }
}
if (events & EPOLLHUP) {
diff --git a/fwd.c b/fwd.c
index 5679a3d..a081664 100644
--- a/fwd.c
+++ b/fwd.c
@@ -536,8 +536,10 @@ int fwd_listen_init(const struct ctx *c)
/**
* fwd_listen_switch() - Switch from current to pending rules table
* @c: Execution context
+ *
+ * Return: 0 on success, -1 on failure
*/
-void fwd_listen_switch(struct ctx *c)
+int fwd_listen_switch(struct ctx *c)
{
struct fwd_table *tmp[PIF_NUM_TYPES];
unsigned i;
@@ -549,9 +551,8 @@ void fwd_listen_switch(struct ctx *c)
if (!fwd)
continue;
- debug("Flushing %u old %s rules", fwd->count, pif_name(i));
+ debug("Flushing %u %s rules", fwd->count, pif_name(i));
fwd_listen_close(fwd);
- fwd->count = fwd->sock_count = 0;
}
/* Swap active and pending tables */
@@ -563,8 +564,7 @@ void fwd_listen_switch(struct ctx *c)
memcpy((void *)c->fwd_pending, &tmp, sizeof(c->fwd_pending));
/* Start listening on the new tables */
- if (fwd_listen_init(c) < 0)
- err("Error switching to new forwarding rules");
+ return fwd_listen_init(c);
}
/* See enum in kernel's include/net/tcp_states.h */
diff --git a/fwd.h b/fwd.h
index b60697d..a6c7bd8 100644
--- a/fwd.h
+++ b/fwd.h
@@ -61,7 +61,7 @@ int fwd_listen_sync(const struct ctx *c, uint8_t pif,
const struct fwd_scan *tcp, const struct fwd_scan *udp);
void fwd_listen_close(const struct fwd_table *fwd);
int fwd_listen_init(const struct ctx *c);
-void fwd_listen_switch(struct ctx *c);
+int fwd_listen_switch(struct ctx *c);
bool nat_inbound(const struct ctx *c, const union inany_addr *addr,
union inany_addr *translated);
--
2.50.1 (Apple Git-155)
3
2
11 Nov '26
As preparation for supporting multiple addresses per interface,
we replace the single addr/prefix_len fields with an array. The
array consists of a new struct inany_addr_entry containing an
address and prefix length, both in inany_addr format.
Despite some code refactoring, there are only two real functional
changes:
- The indicated IPv6 prefix length is now properly stored, instead
of being ignored and overridden with the hardcoded value 64, as
has been the case until now.
- Since even IPv4 addresses now are stored in IPv6 format, we
also store the corresponding prefix length in that format,
i.e. using the range [96,128] instead of [0,32].
In conf_ip6(), the explicit IN6_IS_ADDR_UNSPECIFIED() check on the
address at the end of the function is no longer needed: for
host-discovered addresses, it is now checked inside the if (!a) block
before calling fwd_set_addr(); for user-provided addresses (via -a),
validation already rejects unspecified addresses at parse time.
Signed-off-by: Jon Maloy <jmaloy(a)redhat.com>
---
v2: -Using inany_addr instead of protocol specific addresses as
entry address field.
v3: -Merging into one array, directly in struct ctx
-Changed prefix_len and flags fields in struct inany_addr_entry
to uint8_t, since that makes the struct directly migratable
v4: -Updated according to changes in previous commits
-Updated according to feedback from David G.
-Squashed IP4_MASK macro commit into this one
v6: -Renamed and moved some definitions
-Introduced fwd_set_addr() and fwd_get_addr() already in this commit
-Eliminated first_v4/v6() functions, replaced with fwd_get_addr()
-Some other changes as suggested by David G.
-I kept the flag CONF_ADDR_LINKLOCAL, since it will be
needed later in an address selection function.
v7: -Introduced CONF_ADDR_GENERATED flag
-Other fixes based on feedback from David and Stefano.
-I changed signature of inany_prefix_len(), but I did not change
its semantics, since the premise of David's comment is wrong: the
caller does *not* explicitly know he is dealing with an IPv4 address.
In fact, there are examples later in this series where it may be an
IPv6 address, and the caller just trusts he gets the return value in
the appropriate format.
-Intoduced the inverse of inany_prefix_len(), called inany_prefix_len6()
which always returns the prefix in IPv6 or mapped IPv4 format.
The name of the function isn't great, but any alternative I came up
with became too long to be practical.
v8: -Added inany_prefix_v4() (David G.) to extract IPv4 address and
prefix length simultaneously, replacing inany_prefix_len().
-Removed both inany_prefix_len() and inany_prefix_len6()
auto-detecting functions. Prefix length attached to an inany is
now always stored in IPv6 format (96-128 for IPv4-mapped).
-fwd_set_addr() now requires prefix_len in IPv6 format; callers
updated to pass prefix_len + 96 for IPv4 addresses.
-Fixed -n option to store prefix_len in IPv6 format.
-Fixed addr_seen regression: when address was set via -a,
addr_seen was not initialised in conf_ip4().
-Replaced assert() with graceful no-op in dhcp.c and ndp.c when
no address is configured (David G.).
-Note: addr_seen is still initialised both at conf_ip*() time
and at DHCP/DHCPv6 send time (David's concern). This
inconsistency will be addressed in a follow-up.
-Introduced a new CONF_ADDR_ANY macro to be used for address
selection, as suggested by Stefano.
-Deferred introduction of an explicit scope field (replacing
CONF_ADDR_LINKLOCAL flag) to a later commit or series.
v9: -Rebased on changes made by David Gibson.
-Some minor changes based on feedback from David.
-Defined a new macro CONF_ADDR_GLOBAL to supplant CONF_ADDR_ANY.
-I did not follow up David's suggestion to introduce three
functions to replace the current fwd_get_addr(), because I
don't think it would solve any problems. The 'flags' field
encode both provenance and type properties orthogonally, and
callers need different combinations of them. That is the very
point of that field, and I see nothing confusing in it.
It is correct that some of the calls to fwd_get_addr() go away
in later commits, but enough of them remain to justify its
existence. Defining three new functions to replace it would only
make them wrappers around fwd_get_addr(), and serve no purpose in
my view.
v10: -Redefined and refactored function fwd_get_addr().
v11: -Changes after feedback from Stefano.
- Fixed coverity false positives.
- Fixed bug introduced by wrongly handling ipv4 link local
addresses analogously to ipv6 ditto. These addresses should in
practice be handled like global IPv4 address. Removed now
redundant inany_is_linklocal() function and let fwd_get_addr()
only use inany_is_linklocal6().
- In the same function the removal of the fallback does not
imply a functional change:
* -a without a prefix still gets the class-based default from
inany_default_prefix_len()
* host-discovered addresses get their prefix_len from netlink.
- The changes in conf_print() is not unrelated: inet_ntop() may
fail and leave a stale buffer.
- Re-introduced CONF_ADDR_ANY, this time to 0
- Kept next_addr_idx_(). There is a working solution without it,
but (kernel) checkpatch complains about it.
solution for this.
- Some other minor changes
v12: - Re-defined CONF_ADDR_ANY to be a bitmap
- Added assert() in fwd_set_addr() to ensure no address is added
without at least one flag.
v13: - Renamed 'v4' to 'a4' all through the commit
- In dhcpv6(): set resp.ia_addr.addr dynamically at send time from
the address fetched by fwd_get_addr(), instead of caching a
potentially stale value in dhcpv6_init(). We drop non-
INFORMATION_REQUEST messages silently if no address is available.
- Removed address setup from dhcpv6_init() accordingly.
v14: - In dhcpv6() we now drop all messages when no address is available,
as suggested by Stefano.
v15: - Moved fwd_get_addr() call and the !a early return to just after the
no_dhcpv6 check, so 'a' is guaranteed non-NULL for the remainder of
dhcpv6().
v16: - Fixed a missed struct in_addr *v4 renaming to a4 in
pasta_conf_addr().
---
arp.c | 21 +++++++-
conf.c | 157 +++++++++++++++++++++++++++++++++----------------------
dhcp.c | 20 +++++--
dhcpv6.c | 20 +++++--
fwd.c | 114 +++++++++++++++++++++++++++++++++-------
fwd.h | 4 ++
inany.h | 34 +++++++++++-
ip.h | 2 +
ndp.c | 19 +++++--
passt.h | 63 +++++++++++++++++++---
pasta.c | 23 +++++---
tap.c | 8 ++-
12 files changed, 373 insertions(+), 112 deletions(-)
diff --git a/arp.c b/arp.c
index bb042e95..08d5a9f9 100644
--- a/arp.c
+++ b/arp.c
@@ -41,6 +41,9 @@
static bool ignore_arp(const struct ctx *c,
const struct arphdr *ah, const struct arpmsg *am)
{
+ const struct guest_addr *a;
+ const struct in_addr *a4;
+
if (ah->ar_hrd != htons(ARPHRD_ETHER) ||
ah->ar_pro != htons(ETH_P_IP) ||
ah->ar_hln != ETH_ALEN ||
@@ -54,7 +57,11 @@ static bool ignore_arp(const struct ctx *c,
return true;
/* Don't resolve the guest's assigned address, either. */
- if (!memcmp(am->tip, &c->ip4.addr, sizeof(am->tip)))
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+ if (!a)
+ return false;
+ a4 = inany_v4(&a->addr);
+ if (a4 && !memcmp(am->tip, a4, sizeof(am->tip)))
return true;
return false;
@@ -123,12 +130,22 @@ int arp(const struct ctx *c, struct iov_tail *data)
*/
void arp_send_init_req(const struct ctx *c)
{
+ const struct guest_addr *a;
+ const struct in_addr *a4;
struct {
struct ethhdr eh;
struct arphdr ah;
struct arpmsg am;
} __attribute__((__packed__)) req;
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+ if (!a)
+ return;
+
+ a4 = inany_v4(&a->addr);
+ if (!a4)
+ return;
+
/* Ethernet header */
req.eh.h_proto = htons(ETH_P_ARP);
memcpy(req.eh.h_dest, MAC_BROADCAST, sizeof(req.eh.h_dest));
@@ -145,7 +162,7 @@ void arp_send_init_req(const struct ctx *c)
memcpy(req.am.sha, c->our_tap_mac, sizeof(req.am.sha));
memcpy(req.am.sip, &c->ip4.our_tap_addr, sizeof(req.am.sip));
memcpy(req.am.tha, MAC_BROADCAST, sizeof(req.am.tha));
- memcpy(req.am.tip, &c->ip4.addr, sizeof(req.am.tip));
+ memcpy(req.am.tip, a4, sizeof(req.am.tip));
debug("Sending initial ARP request for guest MAC address");
tap_send_single(c, &req, sizeof(req));
diff --git a/conf.c b/conf.c
index 149a4c79..66aa524e 100644
--- a/conf.c
+++ b/conf.c
@@ -372,13 +372,19 @@ static uint8_t conf_ip4_prefix(const char *arg)
/**
* conf_ip4() - Verify or detect IPv4 support, get relevant addresses
+ * @c: Execution context
* @ifi: Host interface to attempt (0 to determine one)
- * @ip4: IPv4 context (will be written)
*
* Return: interface index for IPv4, or 0 on failure.
*/
-static unsigned int conf_ip4(unsigned int ifi, struct ip4_ctx *ip4)
+static unsigned int conf_ip4(struct ctx *c, unsigned int ifi)
{
+ struct ip4_ctx *ip4 = &c->ip4;
+ const struct guest_addr *a;
+ const struct in_addr *a4;
+
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+
if (!ifi)
ifi = nl_get_ext_if(nl_sock, AF_INET);
@@ -397,67 +403,75 @@ static unsigned int conf_ip4(unsigned int ifi, struct ip4_ctx *ip4)
}
}
- if (IN4_IS_ADDR_UNSPECIFIED(&ip4->addr)) {
+ if (!a) {
+ struct in_addr addr = { 0 };
+ int prefix_len = 0;
int rc = nl_addr_get(nl_sock, ifi, AF_INET,
- &ip4->addr, &ip4->prefix_len, NULL);
+ &addr, &prefix_len, NULL);
if (rc < 0) {
debug("Couldn't discover IPv4 address: %s",
strerror_(-rc));
return 0;
}
+ if (IN4_IS_ADDR_UNSPECIFIED(&addr)) {
+ warn("Host returned address 0.0.0.0");
+ return 0;
+ }
+ fwd_set_addr(c, &inany_from_v4(addr), CONF_ADDR_HOST,
+ prefix_len + 96);
}
- if (!ip4->prefix_len) {
- in_addr_t addr = ntohl(ip4->addr.s_addr);
- if (IN_CLASSA(addr))
- ip4->prefix_len = (32 - IN_CLASSA_NSHIFT);
- else if (IN_CLASSB(addr))
- ip4->prefix_len = (32 - IN_CLASSB_NSHIFT);
- else if (IN_CLASSC(addr))
- ip4->prefix_len = (32 - IN_CLASSC_NSHIFT);
- else
- ip4->prefix_len = 32;
- }
-
- ip4->addr_seen = ip4->addr;
-
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+ assert(a);
+ a4 = inany_v4(&a->addr);
+ assert(a4);
+ ip4->addr_seen = *a4;
ip4->our_tap_addr = ip4->guest_gw;
- if (IN4_IS_ADDR_UNSPECIFIED(&ip4->addr))
- return 0;
-
return ifi;
}
/**
* conf_ip4_local() - Configure IPv4 addresses and attributes for local mode
- * @ip4: IPv4 context (will be written)
+ * @c: Execution context (will be written)
*/
-static void conf_ip4_local(struct ip4_ctx *ip4)
+static void conf_ip4_local(struct ctx *c)
{
- if (IN4_IS_ADDR_UNSPECIFIED(&ip4->addr))
- ip4->addr = IP4_LL_GUEST_ADDR;
- ip4->addr_seen = ip4->addr;
+ struct ip4_ctx *ip4 = &c->ip4;
+ const struct guest_addr *a;
+
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+
+ if (!a) {
+ fwd_set_addr(c, &inany_from_v4(IP4_LL_GUEST_ADDR),
+ CONF_ADDR_GEN, IP4_LL_PREFIX_LEN + 96);
+ ip4->addr_seen = IP4_LL_GUEST_ADDR;
+ } else {
+ const struct in_addr *a4 = inany_v4(&a->addr);
+
+ assert(a4);
+ ip4->addr_seen = *a4;
+ }
if (IN4_IS_ADDR_UNSPECIFIED(&ip4->guest_gw))
ip4->guest_gw = IP4_LL_GUEST_GW;
ip4->our_tap_addr = ip4->guest_gw;
- if (!ip4->prefix_len)
- ip4->prefix_len = IP4_LL_PREFIX_LEN;
-
ip4->no_copy_addrs = ip4->no_copy_routes = true;
}
/**
* conf_ip6() - Verify or detect IPv6 support, get relevant addresses
+ * @c: Execution context
* @ifi: Host interface to attempt (0 to determine one)
- * @ip6: IPv6 context (will be written)
*
* Return: interface index for IPv6, or 0 on failure.
*/
-static unsigned int conf_ip6(unsigned int ifi, struct ip6_ctx *ip6)
+static unsigned int conf_ip6(struct ctx *c, unsigned int ifi)
{
+ struct ip6_ctx *ip6 = &c->ip6;
+ const struct guest_addr *a;
+ union inany_addr addr;
int prefix_len = 0;
int rc;
@@ -478,23 +492,30 @@ static unsigned int conf_ip6(unsigned int ifi, struct ip6_ctx *ip6)
}
}
- rc = nl_addr_get(nl_sock, ifi, AF_INET6,
- IN6_IS_ADDR_UNSPECIFIED(&ip6->addr) ? &ip6->addr : NULL,
+ rc = nl_addr_get(nl_sock, ifi, AF_INET6, &addr.a6,
&prefix_len, &ip6->our_tap_ll);
if (rc < 0) {
debug("Couldn't discover IPv6 address: %s", strerror_(-rc));
return 0;
}
- ip6->addr_seen = ip6->addr;
+ a = fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY);
+ if (!a) {
+ if (IN6_IS_ADDR_UNSPECIFIED(&addr))
+ return 0;
+
+ fwd_set_addr(c, &addr, CONF_ADDR_HOST, prefix_len);
+ ip6->addr_seen = addr.a6;
+ } else {
+ ip6->addr_seen = a->addr.a6;
+ }
if (IN6_IS_ADDR_LINKLOCAL(&ip6->guest_gw))
ip6->our_tap_ll = ip6->guest_gw;
else
ip6->our_tap_addr = ip6->guest_gw;
- if (IN6_IS_ADDR_UNSPECIFIED(&ip6->addr) ||
- IN6_IS_ADDR_UNSPECIFIED(&ip6->our_tap_ll))
+ if (IN6_IS_ADDR_UNSPECIFIED(&ip6->our_tap_ll))
return 0;
return ifi;
@@ -502,10 +523,12 @@ static unsigned int conf_ip6(unsigned int ifi, struct ip6_ctx *ip6)
/**
* conf_ip6_local() - Configure IPv6 addresses and attributes for local mode
- * @ip6: IPv6 context (will be written)
+ * @c: Execution context (will be written)
*/
-static void conf_ip6_local(struct ip6_ctx *ip6)
+static void conf_ip6_local(struct ctx *c)
{
+ struct ip6_ctx *ip6 = &c->ip6;
+
if (IN6_IS_ADDR_UNSPECIFIED(&ip6->guest_gw))
ip6->guest_gw = IP6_LL_GUEST_GW;
@@ -801,6 +824,7 @@ enum passt_modes conf_mode(int argc, char *argv[])
static void conf_print(const struct ctx *c)
{
char buf[INANY_ADDRSTRLEN];
+ const struct guest_addr *a;
int i;
if (c->fd_control_listen >= 0)
@@ -848,16 +872,19 @@ static void conf_print(const struct ctx *c)
inet_ntop(AF_INET, &c->ip4.map_host_loopback,
buf, sizeof(buf)));
- if (!c->no_dhcp) {
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+ if (a && !c->no_dhcp) {
uint32_t mask;
+ int plen = 0;
- mask = htonl(0xffffffff << (32 - c->ip4.prefix_len));
+ inany_prefix_v4(&a->addr, a->prefix_len, &plen);
+ mask = IN4_MASK(plen);
info("DHCP:");
info(" assign: %s",
- inet_ntop(AF_INET, &c->ip4.addr, buf, sizeof(buf)));
+ inany_ntop(&a->addr, buf, sizeof(buf)));
info(" mask: %s",
- inet_ntop(AF_INET, &mask, buf, sizeof(buf)));
+ inet_ntop(AF_INET, &mask, buf, sizeof(buf)));
info(" router: %s",
inet_ntop(AF_INET, &c->ip4.guest_gw,
buf, sizeof(buf)));
@@ -868,8 +895,8 @@ static void conf_print(const struct ctx *c)
break;
if (!i)
info("DNS:");
- inet_ntop(AF_INET, &c->ip4.dns[i], buf, sizeof(buf));
- info(" %s", buf);
+ info(" %s", inet_ntop(AF_INET, &c->ip4.dns[i],
+ buf, sizeof(buf)));
}
for (i = 0; *c->dns_search[i].n; i++) {
@@ -894,13 +921,14 @@ static void conf_print(const struct ctx *c)
else
goto dns6;
- info(" assign: %s",
- inet_ntop(AF_INET6, &c->ip6.addr, buf, sizeof(buf)));
+ a = fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY);
+ if (a)
+ info(" assign: %s",
+ inany_ntop(&a->addr, buf, sizeof(buf)));
info(" router: %s",
inet_ntop(AF_INET6, &c->ip6.guest_gw, buf, sizeof(buf)));
info(" our link-local: %s",
- inet_ntop(AF_INET6, &c->ip6.our_tap_ll,
- buf, sizeof(buf)));
+ inet_ntop(AF_INET6, &c->ip6.our_tap_ll, buf, sizeof(buf)));
dns6:
for (i = 0; i < ARRAY_SIZE(c->ip6.dns); i++) {
@@ -908,8 +936,10 @@ dns6:
break;
if (!i)
info("DNS:");
- inet_ntop(AF_INET6, &c->ip6.dns[i], buf, sizeof(buf));
- info(" %s", buf);
+ info(" %s",
+ inet_ntop(AF_INET6, &c->ip6.dns[i],
+ buf, sizeof(buf)));
+
}
for (i = 0; *c->dns_search[i].n; i++) {
@@ -1213,15 +1243,13 @@ static bool conf_addr(struct ctx *c, char *arg, uint8_t opt_n)
inany_is_loopback(&addr))
goto bad;
+ fwd_set_addr(c, &addr, CONF_ADDR_USER, prefix_len);
if (a4) {
- c->ip4.addr = *a4;
- c->ip4.prefix_len = prefix_len - 96;
- c->ip4.addr_fixed = true;
c->ip4.no_copy_addrs = true;
+ c->ip4.addr_fixed = true;
} else {
- c->ip6.addr = addr.a6;
- c->ip6.addr_fixed = true;
c->ip6.no_copy_addrs = true;
+ c->ip6.addr_fixed = true;
}
return is_prefix;
@@ -1331,6 +1359,7 @@ void conf(struct ctx *c, int argc, char **argv)
unsigned int ifi4 = 0, ifi6 = 0;
bool opt_a_is_prefix = false;
const char *logfile = NULL;
+ struct guest_addr *a;
char *runas = NULL;
size_t logsize = 0;
uint8_t opt_n = 0;
@@ -1652,8 +1681,12 @@ void conf(struct ctx *c, int argc, char **argv)
if (opt_a_is_prefix)
die("Redundant prefix length specification");
- c->ip4.prefix_len = conf_ip4_prefix(optarg);
- opt_n = c->ip4.prefix_len + 96;
+ opt_n = conf_ip4_prefix(optarg) + 96;
+
+ for_each_addr(a, c->addrs, c->addr_count, AF_INET) {
+ a->prefix_len = opt_n;
+ break;
+ }
break;
case 'M':
p = optarg;
@@ -1853,9 +1886,9 @@ void conf(struct ctx *c, int argc, char **argv)
nl_sock_init(c, false);
if (!v6_only && !c->splice_only)
- c->ifi4 = conf_ip4(ifi4, &c->ip4);
+ c->ifi4 = conf_ip4(c, ifi4);
if (!v4_only && !c->splice_only)
- c->ifi6 = conf_ip6(ifi6, &c->ip6);
+ c->ifi6 = conf_ip6(c, ifi6);
if (c->ifi4 && c->mtu < IPV4_MIN_MTU) {
warn("MTU %"PRIu16" is too small for IPv4 (minimum %u)",
@@ -1878,7 +1911,7 @@ void conf(struct ctx *c, int argc, char **argv)
if (!c->ifi4 && !v6_only) {
if (!c->splice_only) {
info("IPv4: no external interface as template, use local mode");
- conf_ip4_local(&c->ip4);
+ conf_ip4_local(c);
}
c->ifi4 = -1;
}
@@ -1886,7 +1919,7 @@ void conf(struct ctx *c, int argc, char **argv)
if (!c->ifi6 && !v4_only) {
if (!c->splice_only) {
info("IPv6: no external interface as template, use local mode");
- conf_ip6_local(&c->ip6);
+ conf_ip6_local(c);
}
c->ifi6 = -1;
}
@@ -1959,7 +1992,7 @@ void conf(struct ctx *c, int argc, char **argv)
if (!c->ifi6) {
c->no_ndp = 1;
c->no_dhcpv6 = 1;
- } else if (IN6_IS_ADDR_UNSPECIFIED(&c->ip6.addr)) {
+ } else if (!fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY)) {
c->no_dhcpv6 = 1;
}
diff --git a/dhcp.c b/dhcp.c
index c3c74224..9336f504 100644
--- a/dhcp.c
+++ b/dhcp.c
@@ -303,7 +303,9 @@ static void opt_set_dns_search(const struct ctx *c, size_t max_len)
int dhcp(const struct ctx *c, struct iov_tail *data)
{
char macstr[ETH_ADDRSTRLEN];
+ const struct guest_addr *a;
size_t mlen, dlen, opt_len;
+ const struct in_addr *addr;
struct in_addr mask, dst;
struct ethhdr eh_storage;
struct iphdr iph_storage;
@@ -315,6 +317,7 @@ int dhcp(const struct ctx *c, struct iov_tail *data)
struct msg const *m;
struct msg reply;
unsigned int i;
+ int plen;
eh = IOV_REMOVE_HEADER(data, eh_storage);
iph = IOV_PEEK_HEADER(data, iph_storage);
@@ -344,6 +347,15 @@ int dhcp(const struct ctx *c, struct iov_tail *data)
m->op != BOOTREQUEST)
return -1;
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_USER);
+ if (!a)
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+ if (!a)
+ return -1;
+
+ addr = inany_prefix_v4(&a->addr, a->prefix_len, &plen);
+ assert(addr);
+
reply.op = BOOTREPLY;
reply.htype = m->htype;
reply.hlen = m->hlen;
@@ -352,7 +364,7 @@ int dhcp(const struct ctx *c, struct iov_tail *data)
reply.secs = 0;
reply.flags = m->flags;
reply.ciaddr = m->ciaddr;
- reply.yiaddr = c->ip4.addr;
+ reply.yiaddr = *addr;
reply.siaddr = 0;
reply.giaddr = m->giaddr;
memcpy(&reply.chaddr, m->chaddr, sizeof(reply.chaddr));
@@ -408,7 +420,7 @@ int dhcp(const struct ctx *c, struct iov_tail *data)
info(" from %s", eth_ntop(m->chaddr, macstr, sizeof(macstr)));
- mask.s_addr = htonl(0xffffffff << (32 - c->ip4.prefix_len));
+ mask.s_addr = IN4_MASK(plen);
memcpy(opts[1].s, &mask, sizeof(mask));
memcpy(opts[3].s, &c->ip4.guest_gw, sizeof(c->ip4.guest_gw));
memcpy(opts[54].s, &c->ip4.our_tap_addr, sizeof(c->ip4.our_tap_addr));
@@ -416,7 +428,7 @@ int dhcp(const struct ctx *c, struct iov_tail *data)
/* If the gateway is not on the assigned subnet, send an option 121
* (Classless Static Routing) adding a dummy route to it.
*/
- if ((c->ip4.addr.s_addr & mask.s_addr)
+ if ((addr->s_addr & mask.s_addr)
!= (c->ip4.guest_gw.s_addr & mask.s_addr)) {
/* a.b.c.d/32:0.0.0.0, 0:a.b.c.d */
opts[121].slen = 14;
@@ -475,7 +487,7 @@ int dhcp(const struct ctx *c, struct iov_tail *data)
if (m->flags & FLAG_BROADCAST)
dst = in4addr_broadcast;
else
- dst = c->ip4.addr;
+ dst = *addr;
tap_udp4_send(c, c->ip4.our_tap_addr, 67, dst, 68, &reply, dlen);
diff --git a/dhcpv6.c b/dhcpv6.c
index 29c7e320..21b0e6bd 100644
--- a/dhcpv6.c
+++ b/dhcpv6.c
@@ -318,7 +318,7 @@ static bool dhcpv6_opt(struct iov_tail *data, uint16_t type)
* false otherwise and @data is unmodified
*/
static bool dhcpv6_ia_notonlink(struct iov_tail *data,
- struct in6_addr *la)
+ const struct in6_addr *la)
{
int ia_types[2] = { OPT_IA_NA, OPT_IA_TA };
struct opt_ia_addr opt_addr_storage;
@@ -567,6 +567,7 @@ int dhcpv6(struct ctx *c, struct iov_tail *data,
struct opt_hdr client_id_storage;
/* cppcheck-suppress [variableScope,unmatchedSuppression] */
struct opt_ia_na ia_storage;
+ const struct guest_addr *a;
const struct in6_addr *src;
struct msg_hdr mh_storage;
const struct msg_hdr *mh;
@@ -584,6 +585,15 @@ int dhcpv6(struct ctx *c, struct iov_tail *data,
if (c->no_dhcpv6)
return 1;
+ /* If no address is available, drop all messages rather than sending a
+ * bogus address. Information-request messages could ideally still be
+ * answered, but since we unconditionally include an IA_NA option in all
+ * replies (RFC 9915, Appendix B.), dropping them is safer.
+ */
+ a = fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY);
+ if (!a)
+ return 1;
+
if (!IN6_IS_ADDR_MULTICAST(daddr))
return -1;
@@ -627,7 +637,7 @@ int dhcpv6(struct ctx *c, struct iov_tail *data,
if (mh->type == TYPE_CONFIRM && server_id)
return -1;
- if (dhcpv6_ia_notonlink(data, &c->ip6.addr)) {
+ if (dhcpv6_ia_notonlink(data, &a->addr.a6)) {
dhcpv6_send_ia_notonlink(c, saddr, data,
&client_id_base,
@@ -667,6 +677,7 @@ int dhcpv6(struct ctx *c, struct iov_tail *data,
default:
return -1;
}
+
if (ia)
resp.ia_na.iaid = ((struct opt_ia_na *)ia)->iaid;
@@ -681,8 +692,9 @@ int dhcpv6(struct ctx *c, struct iov_tail *data,
resp.hdr.xid = mh->xid;
+ resp.ia_addr.addr = a->addr.a6;
tap_udp6_send(c, src, 547, saddr, 546, mh->xid, &resp, n);
- c->ip6.addr_seen = c->ip6.addr;
+ c->ip6.addr_seen = a->addr.a6;
return 1;
}
@@ -705,6 +717,4 @@ void dhcpv6_init(const struct ctx *c)
c->our_tap_mac, sizeof(c->our_tap_mac));
memcpy(resp_not_on_link.server_id.duid_lladdr,
c->our_tap_mac, sizeof(c->our_tap_mac));
-
- resp.ia_addr.addr = c->ip6.addr;
}
diff --git a/fwd.c b/fwd.c
index 5679a3d6..e3f25438 100644
--- a/fwd.c
+++ b/fwd.c
@@ -243,6 +243,62 @@ void fwd_neigh_table_init(const struct ctx *c)
fwd_neigh_table_update(c, &mga, c->our_tap_mac, true);
}
+/**
+ * fwd_set_addr() - Add or update an address in the unified address array
+ * @c: Execution context
+ * @addr: Address to add (IPv4-mapped or IPv6)
+ * @flags: CONF_ADDR_* flags for this address
+ * @prefix_len: Prefix length in IPv6 format (96-128 for IPv4-mapped)
+ *
+ * Find the first existing entry of the same address family and
+ * overwrite it, or create a new one if none exists
+ */
+void fwd_set_addr(struct ctx *c, const union inany_addr *addr,
+ uint8_t flags, int prefix_len)
+{
+ struct guest_addr *a;
+
+ assert(flags);
+
+ for_each_addr(a, c->addrs, c->addr_count, inany_af(addr))
+ goto found;
+
+ if (c->addr_count >= MAX_GUEST_ADDRS)
+ return;
+
+ a = &c->addrs[c->addr_count++];
+
+found:
+ a->addr = *addr;
+ a->prefix_len = prefix_len;
+ a->flags = flags;
+}
+
+/**
+ * fwd_get_addr() - Get guest address entry matching criteria
+ * @c: Execution context
+ * @af: Address family (AF_INET, AF_INET6, or AF_UNSPEC for any)
+ * @global: If true, match global only; if false, match link-local only
+ * @flags: Required provenance flags (any-match), 0 for any provenance
+ *
+ * Return: first address entry matching criteria, or NULL
+ */
+const struct guest_addr *fwd_get_addr(const struct ctx *c, sa_family_t af,
+ bool global, uint8_t flags)
+{
+ const struct guest_addr *a;
+
+ for_each_addr(a, c->addrs, c->addr_count, af) {
+ if (inany_is_linklocal6(&a->addr) == global)
+ continue;
+ if (!(a->flags & flags))
+ continue;
+ return a;
+ }
+
+ return NULL;
+}
+
/* Forwarding table storage, generally accessed via pointers in struct ctx */
static struct fwd_table fwd_in;
static struct fwd_table fwd_out;
@@ -799,8 +855,11 @@ static bool is_dns_flow(uint8_t proto, const struct flowside *ini)
* translation, false otherwise
*/
static bool fwd_guest_accessible4(const struct ctx *c,
- const struct in_addr *addr)
+ const struct in_addr *addr)
{
+ const struct guest_addr *a;
+ const struct in_addr *a4;
+
if (IN4_IS_ADDR_LOOPBACK(addr))
return false;
@@ -815,7 +874,9 @@ static bool fwd_guest_accessible4(const struct ctx *c,
/* For IPv4, addr_seen is initialised to addr, so is always a valid
* address
*/
- if (IN4_ARE_ADDR_EQUAL(addr, &c->ip4.addr) ||
+ a = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+ a4 = a ? inany_v4(&a->addr) : NULL;
+ if ((a4 && IN4_ARE_ADDR_EQUAL(addr, a4)) ||
IN4_ARE_ADDR_EQUAL(addr, &c->ip4.addr_seen))
return false;
@@ -833,10 +894,13 @@ static bool fwd_guest_accessible4(const struct ctx *c,
static bool fwd_guest_accessible6(const struct ctx *c,
const struct in6_addr *addr)
{
+ const struct guest_addr *a;
+
if (IN6_IS_ADDR_LOOPBACK(addr))
return false;
- if (IN6_ARE_ADDR_EQUAL(addr, &c->ip6.addr))
+ a = fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY);
+ if (a && IN6_ARE_ADDR_EQUAL(addr, &a->addr.a6))
return false;
/* For IPv6, addr_seen starts unspecified, because we don't know what LL
@@ -881,16 +945,21 @@ static bool fwd_guest_accessible(const struct ctx *c,
static void nat_outbound(const struct ctx *c, const union inany_addr *addr,
union inany_addr *translated)
{
- if (inany_equals4(addr, &c->ip4.map_host_loopback))
+ const struct guest_addr *ga;
+
+ if (inany_equals4(addr, &c->ip4.map_host_loopback)) {
*translated = inany_loopback4;
- else if (inany_equals6(addr, &c->ip6.map_host_loopback))
+ } else if (inany_equals6(addr, &c->ip6.map_host_loopback)) {
*translated = inany_loopback6;
- else if (inany_equals4(addr, &c->ip4.map_guest_addr))
- *translated = inany_from_v4(c->ip4.addr);
- else if (inany_equals6(addr, &c->ip6.map_guest_addr))
- translated->a6 = c->ip6.addr;
- else
+ } else if (inany_equals4(addr, &c->ip4.map_guest_addr)) {
+ ga = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+ *translated = ga ? ga->addr : inany_any4;
+ } else if (inany_equals6(addr, &c->ip6.map_guest_addr)) {
+ ga = fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY);
+ translated->a6 = ga ? ga->addr.a6 : in6addr_any;
+ } else {
*translated = *addr;
+ }
}
/**
@@ -995,16 +1064,23 @@ bool nat_inbound(const struct ctx *c, const union inany_addr *addr,
} else if (!IN6_IS_ADDR_UNSPECIFIED(&c->ip6.map_host_loopback) &&
inany_equals6(addr, &in6addr_loopback)) {
translated->a6 = c->ip6.map_host_loopback;
- } else if (!IN4_IS_ADDR_UNSPECIFIED(&c->ip4.map_guest_addr) &&
- inany_equals4(addr, &c->ip4.addr)) {
- *translated = inany_from_v4(c->ip4.map_guest_addr);
- } else if (!IN6_IS_ADDR_UNSPECIFIED(&c->ip6.map_guest_addr) &&
- inany_equals6(addr, &c->ip6.addr)) {
- translated->a6 = c->ip6.map_guest_addr;
- } else if (fwd_guest_accessible(c, addr)) {
- *translated = *addr;
} else {
- return false;
+ const struct guest_addr *ga4, *ga6;
+
+ ga4 = fwd_get_addr(c, AF_INET, true, CONF_ADDR_ANY);
+ ga6 = fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY);
+
+ if (!IN4_IS_ADDR_UNSPECIFIED(&c->ip4.map_guest_addr) &&
+ ga4 && inany_equals(addr, &ga4->addr)) {
+ *translated = inany_from_v4(c->ip4.map_guest_addr);
+ } else if (!IN6_IS_ADDR_UNSPECIFIED(&c->ip6.map_guest_addr) &&
+ ga6 && inany_equals(addr, &ga6->addr)) {
+ translated->a6 = c->ip6.map_guest_addr;
+ } else if (fwd_guest_accessible(c, addr)) {
+ *translated = *addr;
+ } else {
+ return false;
+ }
}
return true;
diff --git a/fwd.h b/fwd.h
index b60697d9..d001d8ae 100644
--- a/fwd.h
+++ b/fwd.h
@@ -79,5 +79,9 @@ void fwd_neigh_table_free(const struct ctx *c,
void fwd_neigh_mac_get(const struct ctx *c, const union inany_addr *addr,
uint8_t *mac);
void fwd_neigh_table_init(const struct ctx *c);
+void fwd_set_addr(struct ctx *c, const union inany_addr *addr,
+ uint8_t flags, int prefix_len);
+const struct guest_addr *fwd_get_addr(const struct ctx *c, sa_family_t af,
+ bool global, uint8_t flags);
#endif /* FWD_H */
diff --git a/inany.h b/inany.h
index d0befb15..ecd845a5 100644
--- a/inany.h
+++ b/inany.h
@@ -104,6 +104,36 @@ static inline struct in_addr *inany_v4(const union inany_addr *addr)
return (struct in_addr *)&addr->v4mapped.a4;
}
+/** inany_prefix_v4() - Extract IPv4 address and prefix length from inany
+ * @addr: IPv4 (as mapped) or IPv6 address
+ * @prefix_len: Prefix length in IPv6 format (96-128 for IPv4)
+ * @v4_plen: Set to IPv4 prefix length (0-32) on success
+ *
+ * Return: IPv4 address if @addr is IPv4, NULL otherwise
+ */
+static inline struct in_addr *inany_prefix_v4(const union inany_addr *addr,
+ int prefix_len, int *v4_plen)
+{
+ struct in_addr *a4 = inany_v4(addr);
+
+ if (!a4)
+ return NULL;
+
+ *v4_plen = prefix_len - 96;
+
+ return a4;
+}
+
+/** inany_af() - Get address family of IPv[46] address
+ * @addr: IPv4 or IPv6 address
+ *
+ * Return: AF_INET for IPv4, AF_INET6 for IPv6
+ */
+static inline sa_family_t inany_af(const union inany_addr *addr)
+{
+ return inany_v4(addr) ? AF_INET : AF_INET6;
+}
+
/** inany_default_prefix_len() - Get default prefix length for address
* @addr: IPv4 or iPv6 address
*
@@ -112,9 +142,9 @@ static inline struct in_addr *inany_v4(const union inany_addr *addr)
*/
static inline int inany_default_prefix_len(const union inany_addr *addr)
{
- const struct in_addr *v4 = inany_v4(addr);
+ const struct in_addr *a4 = inany_v4(addr);
- return v4 ? ip4_class_prefix_len(v4) + 96 : 64;
+ return a4 ? ip4_class_prefix_len(a4) + 96 : 64;
}
/** inany_equals - Compare two IPv[46] addresses
diff --git a/ip.h b/ip.h
index aab9b86a..ac93c543 100644
--- a/ip.h
+++ b/ip.h
@@ -19,6 +19,8 @@
(ntohl(((struct in_addr *)(a))->s_addr) >> IN_CLASSA_NSHIFT == IN_LOOPBACKNET)
#define IN4_IS_ADDR_MULTICAST(a) \
(IN_MULTICAST(ntohl(((struct in_addr *)(a))->s_addr)))
+#define IN4_MASK(prefix) \
+ ((prefix) <= 0 ? 0 : htonl(0xffffffff << (32 - (prefix))))
#define IN4_ARE_ADDR_EQUAL(a, b) \
(((struct in_addr *)(a))->s_addr == ((struct in_addr *)b)->s_addr)
#define IN4ADDR_LOOPBACK_INIT \
diff --git a/ndp.c b/ndp.c
index 1f2bcb0c..86df4798 100644
--- a/ndp.c
+++ b/ndp.c
@@ -257,7 +257,6 @@ static void ndp_ra(const struct ctx *c, const struct in6_addr *dst)
.valid_lifetime = ~0U,
.pref_lifetime = ~0U,
},
- .prefix = c->ip6.addr,
.source_ll = {
.header = {
.type = OPT_SRC_L2_ADDR,
@@ -265,8 +264,15 @@ static void ndp_ra(const struct ctx *c, const struct in6_addr *dst)
},
},
};
+ const struct guest_addr *a;
unsigned char *ptr = NULL;
+ a = fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY);
+ if (!a)
+ return;
+
+ ra.prefix = a->addr.a6;
+
ptr = &ra.var[0];
if (c->mtu) {
@@ -460,6 +466,7 @@ first:
*/
void ndp_send_init_req(const struct ctx *c)
{
+ const struct guest_addr *a;
struct ndp_ns ns = {
.ih = {
.icmp6_type = NS,
@@ -468,8 +475,14 @@ void ndp_send_init_req(const struct ctx *c)
.icmp6_solicited = 0, /* Reserved */
.icmp6_override = 0, /* Reserved */
},
- .target_addr = c->ip6.addr
+ .target_addr = IN6ADDR_ANY_INIT
};
+
+ a = fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY);
+ if (!a)
+ return;
+
+ ns.target_addr = a->addr.a6;
debug("Sending initial NDP NS request for guest MAC address");
- ndp_send(c, &c->ip6.addr, &ns, sizeof(ns));
+ ndp_send(c, &a->addr.a6, &ns, sizeof(ns));
}
diff --git a/passt.h b/passt.h
index afd8e9f0..5f68ab91 100644
--- a/passt.h
+++ b/passt.h
@@ -64,11 +64,30 @@ enum passt_modes {
MODE_VU,
};
+/* Maximum number of addresses in context address array */
+#define MAX_GUEST_ADDRS 32
+
+/**
+ * struct guest_addr - Unified IPv4/IPv6 address entry
+ * @addr: IPv4 (as mapped) or IPv6 address
+ * @prefix_len: Prefix length in IPv6/IPv4-mapped [0,128]/[96,128] format
+ * @flags: CONF_ADDR_* flags
+ */
+struct guest_addr {
+ union inany_addr addr;
+ uint8_t prefix_len;
+ uint8_t flags;
+#define CONF_ADDR_USER BIT(0) /* User set via -a */
+#define CONF_ADDR_HOST BIT(1) /* From host */
+#define CONF_ADDR_GEN BIT(2) /* Generated by code */
+#define CONF_ADDR_ANY (CONF_ADDR_USER | \
+ CONF_ADDR_HOST | \
+ CONF_ADDR_GEN) /* Any provenance */
+};
+
/**
* struct ip4_ctx - IPv4 execution context
- * @addr: IPv4 address assigned to guest
* @addr_seen: Latest IPv4 address seen as source from tap
- * @prefixlen: IPv4 prefix length (netmask)
* @guest_gw: IPv4 gateway as seen by the guest
* @map_host_loopback: Outbound connections to this address are NATted to the
* host's 127.0.0.1
@@ -87,9 +106,7 @@ enum passt_modes {
*/
struct ip4_ctx {
/* PIF_TAP addresses */
- struct in_addr addr;
struct in_addr addr_seen;
- int prefix_len;
struct in_addr guest_gw;
struct in_addr map_host_loopback;
struct in_addr map_guest_addr;
@@ -110,7 +127,6 @@ struct ip4_ctx {
/**
* struct ip6_ctx - IPv6 execution context
- * @addr: IPv6 address assigned to guest
* @addr_seen: Latest IPv6 global/site address seen as source from tap
* @addr_ll_seen: Latest IPv6 link-local address seen as source from tap
* @guest_gw: IPv6 gateway as seen by the guest
@@ -132,7 +148,6 @@ struct ip4_ctx {
*/
struct ip6_ctx {
/* PIF_TAP addresses */
- struct in6_addr addr;
struct in6_addr addr_seen;
struct in6_addr addr_ll_seen;
struct in6_addr guest_gw;
@@ -192,6 +207,8 @@ struct ip6_ctx {
* @fqdn: Guest FQDN
* @ifi6: Template interface for IPv6, -1: none, 0: IPv6 disabled
* @ip6: IPv6 configuration
+ * @addrs: Unified address array for both IPv4 (mapped) and IPv6
+ * @addr_count: Number of active entries in @addrs array
* @pasta_ifn: Name of namespace interface for pasta
* @pasta_ifi: Index of namespace interface for pasta
* @pasta_conf_ns: Configure namespace after creating it
@@ -276,6 +293,9 @@ struct ctx {
int ifi6;
struct ip6_ctx ip6;
+ struct guest_addr addrs[MAX_GUEST_ADDRS];
+ int addr_count;
+
char pasta_ifn[IF_NAMESIZE];
unsigned int pasta_ifi;
int pasta_conf_ns;
@@ -321,6 +341,37 @@ struct ctx {
extern struct ctx passt_ctx;
+/**
+ * next_addr_idx_() - Find next address index matching family filter
+ * @addrs: Array of guest addresses
+ * @count: Number of addresses in array
+ * @i: Starting index
+ * @af: Address family filter: AF_INET, AF_INET6, or AF_UNSPEC for all
+ *
+ * Return: next matching index, or count if none found
+ */
+static inline int next_addr_idx_(const struct guest_addr *addrs, int count,
+ int i, sa_family_t af)
+{
+ for (; i < count; i++) {
+ if (af == AF_UNSPEC || af == inany_af(&addrs[i].addr))
+ return i;
+ }
+ return i;
+}
+
+/**
+ * for_each_addr() - Iterate over addresses in array
+ * @a: Pointer variable for current entry (struct guest_addr *)
+ * @addrs: Array of guest addresses (e.g., c->addrs)
+ * @count: Number of addresses (e.g., c->addr_count)
+ * @af: Address family filter: AF_INET, AF_INET6, or 0 for all
+ */
+#define for_each_addr(a, addrs, count, af) \
+ for (int i_ = next_addr_idx_((addrs), (count), 0, (af)); \
+ i_ < (count) && ((a) = &(addrs)[i_], true); \
+ i_ = next_addr_idx_((addrs), (count), i_ + 1, (af)))
+
void proto_update_l2_buf(const unsigned char *eth_d);
#endif /* PASST_H */
diff --git a/pasta.c b/pasta.c
index 10f3ec8d..4cd58fd7 100644
--- a/pasta.c
+++ b/pasta.c
@@ -299,23 +299,32 @@ void pasta_start_ns(struct ctx *c, int argc, char *argv[])
*
* Return: 0 on success, negative error code on failure
*/
-static int pasta_conf_addrs(struct ctx *c, sa_family_t af, int ifi,
+static int pasta_conf_addrs(const struct ctx *c, sa_family_t af, int ifi,
bool no_copy)
{
+ const struct guest_addr *a;
+
if (!ifi)
return 0;
if (!no_copy)
return nl_addr_dup(nl_sock, ifi, nl_sock_ns, c->pasta_ifi, af);
- if (af == AF_INET && !IN4_IS_ADDR_UNSPECIFIED(&c->ip4.addr))
+ a = fwd_get_addr(c, af, true, CONF_ADDR_ANY);
+ if (!a)
+ return 0;
+
+ if (af == AF_INET) {
+ const struct in_addr *a4;
+ int plen = 0;
+
+ a4 = inany_prefix_v4(&a->addr, a->prefix_len, &plen);
return nl_addr_set(nl_sock_ns, c->pasta_ifi, AF_INET,
- &c->ip4.addr, c->ip4.prefix_len);
- if (af == AF_INET6 && !IN6_IS_ADDR_UNSPECIFIED(&c->ip6.addr))
- return nl_addr_set(nl_sock_ns, c->pasta_ifi, AF_INET6,
- &c->ip6.addr, 64);
+ a4, plen);
+ }
- return 0;
+ return nl_addr_set(nl_sock_ns, c->pasta_ifi, AF_INET6,
+ &a->addr.a6, a->prefix_len);
}
/**
diff --git a/tap.c b/tap.c
index dfa66c71..dd055a4e 100644
--- a/tap.c
+++ b/tap.c
@@ -1005,8 +1005,12 @@ resume:
c->ip6.addr_seen = *saddr;
}
- if (IN6_IS_ADDR_UNSPECIFIED(&c->ip6.addr))
- c->ip6.addr = *saddr;
+ if (!fwd_get_addr(c, AF_INET6, true, CONF_ADDR_ANY) &&
+ !fwd_get_addr(c, AF_INET6, false, CONF_ADDR_ANY)) {
+ union inany_addr addr = { .a6 = *saddr };
+
+ fwd_set_addr(c, &addr, CONF_ADDR_GEN, 64);
+ }
} else if (!c->ip6.addr_fixed &&
!IN6_IS_ADDR_UNSPECIFIED(saddr)) {
c->ip6.addr_seen = *saddr;
--
2.52.0
2
1
[PATCH v4] pasta: Add --pass-fds option to skip closing file descriptors
by Richard Lawrence 11 Nov '26
by Richard Lawrence 11 Nov '26
11 Nov '26
When pasta spawns a command (`pasta [options] -- [command]`), all open file
descriptors inherited from the parent process except standard streams (0-2)
and the tap descriptor (`--fd`) are normally closed by `isolate_fds()`.
However, when pasta is used for testing, development, or launching tools like
Bubblewrap (`bwrap`), the spawned command may require file descriptors
passed directly from the parent process. In this case, closing inherited file
descriptors breaks expected behavior.
Add a boolean `--pass-fds` flag for pasta mode that skips the `close_range()`
cleanup step in `isolate_fds()`, leaving all open file descriptors intact
for the child command.
Summary of changes:
- Update `conf_tap_fd()` to `conf_fds()`, allowing early parsing of both
`-F`/`--fd` and `--pass-fds` before main option processing.
- Update `isolate_fds()` to check `c->pass_fds`: if set, skip calling
`close_range()` while still relocating the tap fd out of standard stream
range (0-2) if needed.
- Enforce validation in `conf()` ensuring `--pass-fds` is restricted to pasta
mode when spawning a command (incompatible with attaching to an
existing netns).
- Update man page and usage help output.
Link: https://bugs.passt.top/show_bug.cgi?id=204
Signed-off-by: Richard Lawrence <rlawrence(a)tamu.edu>
---
conf.c | 55 ++++++++++++++++++++++++++----------------
conf.h | 2 +-
isolation.c | 69 +++++++++++++++++++++++++++++++----------------------
isolation.h | 2 +-
passt.1 | 5 ++++
passt.c | 2 +-
passt.h | 2 ++
7 files changed, 84 insertions(+), 53 deletions(-)
diff --git a/conf.c b/conf.c
index 149a4c7..9f7eafb 100644
--- a/conf.c
+++ b/conf.c
@@ -750,7 +750,8 @@ pasta_opts:
" Don't copy all addresses to namespace\n"
" --ns-mac-addr ADDR Set MAC address on tap interface\n"
" --no-splice Disable inbound socket splicing\n"
- " --splice-only Only enable loopback forwarding\n");
+ " --splice-only Only enable loopback forwarding\n"
+ " --pass-fds Preserve open file descriptors\n");
passt_exit(status);
}
@@ -1137,35 +1138,38 @@ static void conf_sock_listen(const struct ctx *c)
}
/**
- * conf_tap_fd() - Read tap fd as supplied by -F command line option
+ * conf_fds() - Read fds as supplied by -F/--fd and --pass-fds options
+ * @c: Execution context
* @argc: Argument count
* @argv: Command line options
- *
- * Return: fd number from --fd option, or -1 if not supplied
*/
-int conf_tap_fd(int argc, char **argv)
+void conf_fds(struct ctx *c, int argc, char **argv)
{
- const struct option optfd[] = { { "fd", required_argument, NULL, 'F' },
- { 0 }, };
- const char *fdarg = NULL, *p;
- unsigned long val;
+ const struct option opt[] = {
+ { "fd", required_argument, NULL, 'F' },
+ { "pass-fds", no_argument, NULL, 2 },
+ { 0 },
+ };
int name;
+ c->fd_tap = -1;
+ c->pass_fds = false;
optind = 0;
do {
- name = getopt_long(argc, argv, "-:F:", optfd, NULL);
- if (name == 'F')
- fdarg = optarg;
- } while (name != -1);
-
- if (!fdarg)
- return -1;
+ name = getopt_long(argc, argv, "-:F:", opt, NULL);
+ if (name == 'F') {
+ const char *p = optarg;
+ unsigned long val;
- p = fdarg;
- if (!parse_unsigned(&p, 0, &val) || !parse_eoi(p) || val > INT_MAX)
- die("Invalid --fd: %s", fdarg);
+ if (!parse_unsigned(&p, 0, &val) || !parse_eoi(p) ||
+ val > INT_MAX)
+ die("Invalid --fd: %s", optarg);
- return val;
+ c->fd_tap = (int)val;
+ } else if (name == 2) {
+ c->pass_fds = true;
+ }
+ } while (name != -1);
}
/**
@@ -1317,6 +1321,7 @@ void conf(struct ctx *c, int argc, char **argv)
{"conf-path", required_argument, NULL, 'c' },
{"chroot-fallback", no_argument, NULL, 32 },
{"no-pidns", no_argument, NULL, 33 },
+ {"pass-fds", no_argument, NULL, 34 },
{ 0 },
};
const char *optstring = "+dqfel:hs:c:F:I:p:P:m:a:n:M:g:i:o:D:S:H:461t:u:T:U:";
@@ -1567,6 +1572,11 @@ void conf(struct ctx *c, int argc, char **argv)
c->no_pidns = true;
break;
+ case 34:
+ /* --pass-fds was parsed early */
+ if (c->mode != MODE_PASTA)
+ die("--pass-fds is for pasta mode only");
+ break;
case 'd':
c->debug = 1;
c->quiet = 0;
@@ -1603,7 +1613,7 @@ void conf(struct ctx *c, int argc, char **argv)
c->fd_control_listen = c->fd_control = -1;
break;
case 'F':
- /* --fd was parsed early and c->fd_tap set in main() */
+ /* --fd was parsed early */
c->one_off = true;
*c->sock_path = 0;
break;
@@ -1929,6 +1939,9 @@ void conf(struct ctx *c, int argc, char **argv)
else if (optind != argc)
die("Extra non-option argument: %s", argv[optind]);
+ if (c->pass_fds && *netns)
+ die("--pass-fds can only be used when spawning a command");
+
if (c->no_pidns && *netns)
die("--no-pidns is incompatible with PID or --netns");
diff --git a/conf.h b/conf.h
index 19bf9bc..654fd16 100644
--- a/conf.h
+++ b/conf.h
@@ -7,7 +7,7 @@
#define CONF_H
enum passt_modes conf_mode(int argc, char *argv[]);
-int conf_tap_fd(int argc, char **argv);
+void conf_fds(struct ctx *c, int argc, char **argv);
void conf(struct ctx *c, int argc, char **argv);
void conf_listen_handler(struct ctx *c, uint32_t events);
void conf_handler(struct ctx *c, uint32_t events);
diff --git a/isolation.c b/isolation.c
index a00475f..1875e6b 100644
--- a/isolation.c
+++ b/isolation.c
@@ -250,46 +250,57 @@ void isolate_initial(void)
}
/*
- * isolate_fds() - Close leaked files, but not --fd, stdin, stdout, stderr
+ * isolate_fds() - Close leaked files if applicable
+ * @c: Execution context
* @argc: Argument count
- * @argv: Command line options, as we need to skip any file given via --fd
+ * @argv: Command line options
*
* Should:
- * - close all open files except for standard streams and the one from --fd
+ * - close all open files except for standard streams and the one from --fd,
+ unless --pass-fds is used, in which case all fds are preserved
* - move the --fd descriptor out of the range 0-2
- *
- * Return: new fd number for descriptor from --fd, or -1 if not specified
+ * - update the execution context
*/
-int isolate_fds(int argc, char **argv)
+void isolate_fds(struct ctx *c, int argc, char **argv)
{
- int fd, close_from = STDERR_FILENO + 1;
+ conf_fds(c, argc, argv);
- fd = conf_tap_fd(argc, argv);
+ if (c->pass_fds) {
+ if (c->fd_tap >= 0 && c->fd_tap < STDERR_FILENO + 1) {
+ /* Move the tap fd to a safer location */
+ int new_fd = fcntl(c->fd_tap, F_DUPFD, STDERR_FILENO + 1);
- if (fd >= 0) {
- /* Move the passed fd to a more convenient location */
- if (fd != close_from &&
- (dup2(fd, close_from) != close_from ||
- close(fd)))
- die_perror("Could not move --fd descriptor");
- fd = close_from++;
- }
+ if (new_fd < 0 || close(c->fd_tap))
+ die_perror("Could not relocate --fd descriptor");
+ c->fd_tap = new_fd;
+ }
+ } else {
+ int close_from = STDERR_FILENO + 1;
+
+ if (c->fd_tap >= 0) {
+ /* Move the tap fd to a more convenient location */
+ if (c->fd_tap != close_from &&
+ (dup2(c->fd_tap, close_from) != close_from ||
+ close(c->fd_tap)))
+ die_perror("Could not move --fd descriptor");
+ c->fd_tap = close_from++;
+ }
- if (close_range(close_from, ~0U, CLOSE_RANGE_UNSHARE)) {
- if (errno == ENOSYS || errno == EINVAL) {
- /* This probably means close_range() or the
- * CLOSE_RANGE_UNSHARE flag is not supported by the
- * kernel. Not much we can do here except carry on and
- * hope for the best.
- */
- warn(
-"Can't use close_range() to ensure no files leaked by parent");
- } else {
- die_perror("Failed to close files leaked by parent");
+ /* Close leaked file descriptors */
+ if (close_range(close_from, ~0U, CLOSE_RANGE_UNSHARE)) {
+ if (errno == ENOSYS || errno == EINVAL) {
+ /* This probably means close_range() or the
+ * CLOSE_RANGE_UNSHARE flag is not supported by the
+ * kernel. Not much we can do here except carry on and
+ * hope for the best.
+ */
+ warn(
+ "Can't use close_range() to ensure no files leaked by parent");
+ } else {
+ die_perror("Failed to close files leaked by parent");
+ }
}
}
-
- return fd;
}
/**
diff --git a/isolation.h b/isolation.h
index ec47038..fe8d7d5 100644
--- a/isolation.h
+++ b/isolation.h
@@ -11,7 +11,7 @@
#include <unistd.h>
void isolate_initial(void);
-int isolate_fds(int argc, char **argv);
+void isolate_fds(struct ctx *c, int argc, char **argv);
void isolate_user(const struct ctx *c, uid_t uid, gid_t gid, bool use_userns,
const char *userns);
int isolate_prefork(const struct ctx *c);
diff --git a/passt.1 b/passt.1
index 0b780fe..56e241f 100644
--- a/passt.1
+++ b/passt.1
@@ -766,6 +766,11 @@ of local traffic in pasta\fR in the \fBNOTES\fR for more details.
Do not create a tap device in the namespace. In this mode, \fIpasta\fR only
forwards loopback traffic between namespaces.
+.TP
+.BR \-\-pass\-fds
+Preserve all open file descriptors and pass them to the spawned command.
+This option may only be used when \fBpasta\fR spawns a command.
+
.SH EXAMPLES
.SS \fBpasta
diff --git a/passt.c b/passt.c
index 5054551..fa7afc5 100644
--- a/passt.c
+++ b/passt.c
@@ -345,7 +345,7 @@ int main(int argc, char **argv)
arch_avx2_exec(argv);
isolate_initial();
- c->fd_tap = isolate_fds(argc, argv);
+ isolate_fds(c, argc, argv);
if ((devnull_fd = open("/dev/null", O_RDWR | O_CLOEXEC)) < 0)
die_perror("Failed to open /dev/null");
diff --git a/passt.h b/passt.h
index afd8e9f..947e859 100644
--- a/passt.h
+++ b/passt.h
@@ -196,6 +196,7 @@ struct ip6_ctx {
* @pasta_ifi: Index of namespace interface for pasta
* @pasta_conf_ns: Configure namespace after creating it
* @no_pidns: Don't create a new PID namespace for spawned command
+ * @pass_fds: Don't close leaked file descriptors
* @fwd: Forwarding tables
* @fwd_pending: Pending forward tables
* @no_tcp: Disable TCP operation
@@ -280,6 +281,7 @@ struct ctx {
unsigned int pasta_ifi;
int pasta_conf_ns;
bool no_pidns;
+ bool pass_fds;
struct fwd_table *fwd[PIF_NUM_TYPES];
struct fwd_table *fwd_pending[PIF_NUM_TYPES];
--
2.52.0
2
1
Fuzz testing with AFL++ persistent mode found that
tcp_buf_data_from_sock() terminates the process with SIGFPE
(signal 8) from division by zero at:
fill_bufs = DIV_ROUND_UP(wnd_scaled - already_sent, mss);
when MSS is small enough (less than four) to round down to 0
during the bit-shift in MSS_SET(). The termination itself is
clean (not memory corruption or data leakage), but we can
handle this condition more gracefully.
We considered resetting connections with a zero or very low
MSS, but concluded this is not RFC-compliant: RFC 9293,
section 3.1 (MUST-7), states: "TCP implementations MUST be
prepared to handle an illegal option length (e.g., zero); a
suggested procedure is to reset the connection and log the
error cause." However, this applies only to option *lengths*,
not *values* — no standard RFC defines a minimum MSS value.
Section 3.5.2 further states: "A reset must not be sent if
it is not clear that this is the case." Very low MSS values
also have legitimate uses in microcontroller applications
with limited buffers, and a zero MSS could represent a
unidirectional connection.
Rounding a low MSS upward is also not an option: emitting
segments larger than the peer advertised violates the
effective send MSS requirement in RFC 9293, section 3.7.1.
Instead, preserve the actual MSS:
- Adjust MSS_SET() to clamp non-zero values below 4 to 1,
avoiding the round-to-zero in bit-field storage.
- Adjust MSS_GET() to return 1 when tap_mss is 1, so we
never inflate the MSS beyond what the peer advertised.
- When MSS is zero, don't send data:
tcp_buf_data_from_sock() returns early. The peer will
eventually determine the connection is unusable and
reset it.
Signed-off-by: Anshu Kumari <anskuma(a)redhat.com>
---
v2:
- added comment for both MSS_SET() and MSS_GET() macro.
- fixed/modified MSS_GET().
- fixed commit message by explaining why we are not
resetting the connection.
NOTE: let the fuzzer run for more than a day with this
fix but till now, haven't found any issue.
---
tcp_buf.c | 3 +++
tcp_conn.h | 10 ++++++++--
2 files changed, 11 insertions(+), 2 deletions(-)
diff --git a/tcp_buf.c b/tcp_buf.c
index 72c45412..ee8c7ce8 100644
--- a/tcp_buf.c
+++ b/tcp_buf.c
@@ -335,6 +335,9 @@ int tcp_buf_data_from_sock(const struct ctx *c, struct tcp_tap_conn *conn,
struct iovec *iov;
uint32_t seq;
+ if (!mss)
+ return 0;
+
/* Set up buffer descriptors we'll fill completely and partially. */
fill_bufs = DIV_ROUND_UP(wnd_scaled - already_sent, mss);
if (fill_bufs > TCP_FRAMES) {
diff --git a/tcp_conn.h b/tcp_conn.h
index e3c55341..3173ddb9 100644
--- a/tcp_conn.h
+++ b/tcp_conn.h
@@ -51,8 +51,14 @@ struct tcp_tap_conn {
#define TCP_MSS_BITS 14
unsigned int tap_mss :TCP_MSS_BITS;
-#define MSS_SET(conn, mss) (conn->tap_mss = (mss >> (16 - TCP_MSS_BITS)))
-#define MSS_GET(conn) (conn->tap_mss << (16 - TCP_MSS_BITS))
+
+ /* Clamp non-zero MSS < 4 to 1 to avoid rounding to zero */
+#define MSS_SET(conn, mss) \
+ (conn->tap_mss = (mss) ? MAX(1, (mss) >> (16 - TCP_MSS_BITS)) : 0)
+
+ /* tap_mss is stored as 1 for any non-zero MSS value <= 4 */
+#define MSS_GET(conn) \
+ ((conn->tap_mss == 1) ? 1 : (conn->tap_mss << (16 - TCP_MSS_BITS)))
#define RTT_EXP_BITS 4
unsigned int rtt_exp :RTT_EXP_BITS;
--
2.55.0
2
1
This series adds support for custom DHCP options in passt, enabling
network boot (PXE/UEFI HTTP Boot) and arbitrary DHCP option injection.
Two new command-line flags are introduced:
--dhcp-boot URL Sets the boot file URL (DHCP option 67 and the
legacy boot file field)
--dhcp-opt CODE,VALUE
Sets any DHCP option by numeric code, with
type-aware parsing per RFC 2132
The DHCP reply path is extended with option overload support (RFC 2132
option 52), allowing options to overflow into the file and sname fields
when the standard options area is full.
RFC 3396 option splitting for concatenation-requiring options has also
been introduce as a separate patch.
Anshu Kumari (6):
dhcp: Refactor fill_one() to operate on a generic buffer
dhcp: Add option configuration tracking with enum opt_conf
dhcp: Add --dhcp-opt with option table and value parser
dhcp: Add --dhcp-boot command-line option
dhcp: Add option overload
dhcp: Add RFC 3396 option splitting for concatenation-requiring
options
conf.c | 30 ++-
dhcp.c | 612 +++++++++++++++++++++++++++++++++++++++++++++++++-------
dhcp.h | 2 +
passt.1 | 48 +++++
4 files changed, 624 insertions(+), 68 deletions(-)
--
2.55.0
2
6
Eliminate the route entries capacity limitations of nl_route_dup
by copying them to the destination namespace in three successive
steps to bypass dependency issues. This approach is inspired by
the code design used in the restore subcommand of iproute2.
Fixes: #221
Link: https://bugs.passt.top/show_bug.cgi?id=221
Signed-off-by: Martin Schitter <ms+git(a)mur.at>
---
netlink.c | 216 +++++++++++++++++++++++++++---------------------------
1 file changed, 107 insertions(+), 109 deletions(-)
diff --git a/netlink.c b/netlink.c
index 225b666..d5c704b 100644
--- a/netlink.c
+++ b/netlink.c
@@ -525,6 +525,21 @@ int nl_route_set_def(int s, unsigned int ifi, sa_family_t af, const void *gw)
return nl_do(s, &req, RTM_NEWROUTE, NLM_F_CREATE | NLM_F_EXCL, len);
}
+/**
+ * nl_rtattr_cmp() - Compare two routing attributes
+ * @rta1: Routing attribute
+ * @rta2: Routing attribute
+ *
+ * Return: 0 if equal
+ */
+static int nl_rtattr_cmp(const struct rtattr *rta1, const struct rtattr *rta2)
+{
+ if (!rta1 || !rta2 || rta1->rta_len != rta2->rta_len)
+ return 1;
+
+ return memcmp(RTA_DATA(rta1), RTA_DATA(rta2), RTA_PAYLOAD(rta1));
+}
+
/**
* nl_route_dup() - Copy routes for given interface and address family
* @s_src: Netlink socket in source namespace
@@ -535,56 +550,81 @@ int nl_route_set_def(int s, unsigned int ifi, sa_family_t af, const void *gw)
*
* Return: 0 on success, negative error code on failure
*/
-int nl_route_dup(int s_src, unsigned int ifi_src,
- int s_dst, unsigned int ifi_dst, sa_family_t af)
+int nl_route_dup(int s_src, unsigned int ifi_src, int s_dst,
+ unsigned int ifi_dst, sa_family_t af)
{
- struct req_t {
- struct nlmsghdr nlh;
- struct rtmsg rtm;
- struct rtattr rta;
- unsigned int ifi;
- } req = {
- .rtm.rtm_family = af,
- .rtm.rtm_table = RT_TABLE_MAIN,
- .rtm.rtm_scope = RT_SCOPE_UNIVERSE,
- .rtm.rtm_type = RTN_UNICAST,
-
- .rta.rta_type = RTA_OIF,
- .rta.rta_len = RTA_LENGTH(sizeof(unsigned int)),
- .ifi = ifi_src,
+ /* Duplicate routes in correct order using 3 successive stages: */
+ enum tasks {
+ DUP_LOCAL_ADDR, /* Duplicate local route address entries */
+ DUP_LOCAL_NET, /* Duplicate local network entries */
+ DUP_OTHER, /* Duplicate all other entries */
+ NR_OF_TASKS,
};
- ssize_t nlmsgs_size, left, status;
- unsigned dup_routes = 0;
- struct nlmsghdr *nh;
- char buf[NLBUFSIZ];
- uint32_t seq;
- unsigned i;
- seq = nl_send(s_src, &req, RTM_GETROUTE, NLM_F_DUMP, sizeof(req));
+ for (enum tasks task = DUP_LOCAL_ADDR; task < NR_OF_TASKS; task++) {
+ struct req_t {
+ struct nlmsghdr nlh;
+ struct rtmsg rtm;
+ struct rtattr rta;
+ unsigned int ifi;
+ } req = {
+ .rtm.rtm_family = af,
+ .rtm.rtm_table = RT_TABLE_MAIN,
+ .rtm.rtm_scope = RT_SCOPE_UNIVERSE,
+ .rtm.rtm_type = RTN_UNICAST,
+
+ .rta.rta_type = RTA_OIF,
+ .rta.rta_len = RTA_LENGTH(sizeof(unsigned int)),
+ .ifi = ifi_src,
+ };
+ struct nlmsghdr *nh;
+ char buf[NLBUFSIZ];
+ ssize_t status;
+ uint32_t seq;
+
+ seq = nl_send(s_src, &req, RTM_GETROUTE, NLM_F_DUMP,
+ sizeof(req));
+
+ nl_foreach(nh, status, s_src, buf, seq) {
+ struct rtmsg *rtm = (struct rtmsg *)NLMSG_DATA(nh);
+ uint16_t flags = nh->nlmsg_flags;
+ struct rtattr *rta;
+ size_t na;
+ int rc;
- /* nl_foreach() will step through multiple response datagrams,
- * which we don't want here because we need to have all the
- * routes in the buffer at once.
- */
- nh = nl_next(s_src, buf, NULL, &nlmsgs_size);
- for (left = nlmsgs_size;
- NLMSG_OK(nh, left) && (status = nl_status(nh, left, seq)) > 0;
- nh = NLMSG_NEXT(nh, left)) {
- struct rtmsg *rtm = (struct rtmsg *)NLMSG_DATA(nh);
- bool discard = false;
- struct rtattr *rta;
- size_t na;
+ if (nh->nlmsg_type != RTM_NEWROUTE)
+ continue;
- if (nh->nlmsg_type != RTM_NEWROUTE)
- continue;
+ struct rtattr *tb[RTA_MAX + 1] = { 0 };
- /* nexthop state flags don't apply to freshly created routes,
- * and the kernel will refuse our route if they are set.
- */
- rtm->rtm_flags &= ~RTNH_COMPARE_MASK;
+ for (rta = RTM_RTA(rtm), na = RTM_PAYLOAD(nh);
+ RTA_OK(rta, na); rta = RTA_NEXT(rta, na)) {
+ tb[rta->rta_type] = rta;
+ }
+
+ /* Duplicate only those routes that belong
+ * to the current processing stage.
+ * An approach inspired by iproute2's
+ * restore_handler() function.
+ * https://github.com/iproute2/iproute2/blob/e6471d7/ip/iproute.c#L2314
+ */
+ if (task == DUP_OTHER && !tb[RTA_GATEWAY])
+ continue;
+ if (task == DUP_LOCAL_NET &&
+ (tb[RTA_GATEWAY] || !tb[RTA_PREFSRC] ||
+ !nl_rtattr_cmp(tb[RTA_PREFSRC], tb[RTA_DST])))
+ continue;
+ if (task == DUP_LOCAL_ADDR && (tb[RTA_GATEWAY] ||
+ (tb[RTA_PREFSRC] &&
+ nl_rtattr_cmp(tb[RTA_PREFSRC], tb[RTA_DST]))))
+ continue;
+
+ /* nexthop state flags don't apply to freshly created
+ * routes, and the kernel will refuse our route if they
+ * are set.
+ */
+ rtm->rtm_flags &= ~RTNH_COMPARE_MASK;
- for (rta = RTM_RTA(rtm), na = RTM_PAYLOAD(nh); RTA_OK(rta, na);
- rta = RTA_NEXT(rta, na)) {
/* RTA_OIF and RTA_MULTIPATH attributes carry the
* identifier of a host interface. If they match the
* host interface we're copying from, change them to
@@ -595,103 +635,61 @@ int nl_route_dup(int s_src, unsigned int ifi_src,
* available), or if any interface index in nexthop
* objects differ from the host interface, discard the
* route altogether.
- */
- if (rta->rta_type == RTA_OIF) {
- if (*(unsigned int *)RTA_DATA(rta) != ifi_src) {
- discard = true;
- break;
- }
-
- *(unsigned int *)RTA_DATA(rta) = ifi_dst;
- } else if (rta->rta_type == RTA_MULTIPATH) {
- int nh_len = RTA_PAYLOAD(rta);
+ */
+ if (tb[RTA_OIF]) {
+ if (*(unsigned int *)RTA_DATA(tb[RTA_OIF]) !=
+ ifi_src)
+ continue;
+ *(unsigned int *)RTA_DATA(tb[RTA_OIF]) =
+ ifi_dst;
+ } else if (tb[RTA_MULTIPATH]) {
+ int nh_len = RTA_PAYLOAD(tb[RTA_MULTIPATH]);
struct rtnexthop *rtnh;
-
- for (rtnh = (struct rtnexthop *)RTA_DATA(rta);
+ bool discard = false;
+ for (rtnh = (struct rtnexthop *)
+ RTA_DATA(tb[RTA_MULTIPATH]);
RTNH_OK(rtnh, nh_len);
rtnh = RTNH_NEXT_AND_DEC(rtnh, nh_len)) {
int src = (int)ifi_src;
-
if (rtnh->rtnh_ifindex != src) {
discard = true;
break;
}
-
rtnh->rtnh_ifindex = ifi_dst;
}
-
if (discard)
- break;
- } else if (rta->rta_type == RTA_PREFSRC ||
- rta->rta_type == RTA_NH_ID) {
+ continue;
+ } else if (tb[RTA_PREFSRC]) {
/* Strip RTA_PREFSRC attributes: host routes
* might include a preferred source address,
* which must be one of the host's addresses.
* However, with -a, pasta will use a different
* namespace address, making such a route
* invalid in the namespace.
- *
- * Strip RTA_NH_ID attributes: host routes set
+ */
+ tb[RTA_PREFSRC]->rta_type = RTA_UNSPEC;
+ } else if (tb[RTA_NH_ID]) {
+ /* Strip RTA_NH_ID attributes: host routes set
* up via routing protocols (e.g. OSPF) might
* contain a nexthop ID (and not nexthop
* objects, which are taken care of in the
* RTA_MULTIPATH case above) that's not valid
* in the target namespace.
*/
- rta->rta_type = RTA_UNSPEC;
+ tb[RTA_NH_ID]->rta_type = RTA_UNSPEC;
}
- }
-
- if (discard)
- nh->nlmsg_type = NLMSG_NOOP;
- else
- dup_routes++;
- }
-
- if (!NLMSG_OK(nh, left)) {
- /* Process any remaining datagrams in a different
- * buffer so we don't overwrite the first one.
- */
- char tail[NLBUFSIZ];
- unsigned extra = 0;
-
- nl_foreach_oftype(nh, status, s_src, tail, seq, RTM_NEWROUTE)
- extra++;
-
- if (extra) {
- err("netlink: Too many routes to duplicate");
- return -E2BIG;
- }
- }
- if (status < 0)
- return status;
-
- /* Routes might have dependencies between each other, and the kernel
- * processes RTM_NEWROUTE messages sequentially. For n routes, we might
- * need to send the requests up to n times to get all of them inserted.
- * Routes that have been already inserted will return -EEXIST, but we
- * can safely ignore that and repeat the requests. This avoids the need
- * to calculate dependencies: let the kernel do that.
- */
- for (i = 0; i < dup_routes; i++) {
- for (nh = (struct nlmsghdr *)buf, left = nlmsgs_size;
- NLMSG_OK(nh, left);
- nh = NLMSG_NEXT(nh, left)) {
- uint16_t flags = nh->nlmsg_flags;
- int rc;
-
- if (nh->nlmsg_type != RTM_NEWROUTE)
- continue;
rc = nl_do(s_dst, nh, RTM_NEWROUTE,
- (flags & ~NLM_F_DUMP_FILTERED) | NLM_F_CREATE,
- nh->nlmsg_len);
+ (flags & ~NLM_F_DUMP_FILTERED) |
+ NLM_F_CREATE,
+ nh->nlmsg_len);
if (rc < 0 && rc != -EEXIST &&
rc != -ENETUNREACH && rc != -EHOSTUNREACH)
return rc;
}
+ if (status < 0)
+ return status;
}
-
return 0;
}
--
2.53.0
2
1