- dev - passt

[PATCH v4 0/9] Reduce differences between inbound and outbound socket binding
by David Gibson 26 Nov '25

26 Nov '25

This series is based on my series fixing bug 176 (regression in auto forwarding). The fact that outbound forwarding sockets are bound to the loopback address, whereas inbound forwarding sockets are (by default) bound to the unspecified address leads to some unexpected differences between the paths setting up each of them. An idea for tackling bug 100 suggested a different approach which will also reduce some of those differences and allow more code to be shared between the two paths. I've since discovered that this approach doesn't help for bug 100, but I think it's still worthwhile for other reasons. Patches 1..7/9 are cleanups which shouldn't change behaviour, and I think are ready to merge. 8/9 and 9/9 introduce behavioural changes, but I've made the case for them in the patch comments. v4: - Add cleanup patch removing unused structure field - Rebase, fixing conflicts with Laurent's changes - A bunch of spelling and other cosmetic fixes - Clarify relation to bug 100 and bug 113 v3: - A number of additional fixes covering the handling of IPV6_V6ONLY sockopt - Assorted trivial changes v2: - Some rearrangements and rewordings for clarity David Gibson (9): flow: Remove bogus @path field from flowside_sock_args inany: Let length of sockaddr_inany be implicit from the family util, flow, pif: Simplify sock_l4_sa() interface tcp: Merge tcp_ns_sock_init[46]() into tcp_sock_init_one() udp: Unify some more inbound/outbound parts of udp_sock_init() udp: Move udp_sock_init() special case to its caller util: Fix setting of IPV6_V6ONLY socket option tcp, udp: Remove fallback if creating dual stack socket fails tcp, udp: Bind outbound listening sockets by interface instead of address conf.c | 4 +- flow.c | 22 +++---- icmp.c | 3 +- inany.h | 17 ++++++ pif.c | 27 ++------- pif.h | 2 +- tcp.c | 164 +++++++++++++++++++-------------------------------- tcp.h | 5 +- tcp_splice.c | 5 +- udp.c | 102 +++++++++++++++----------------- udp.h | 5 +- util.c | 76 ++++++++++++++++++++---- util.h | 8 ++- 13 files changed, 221 insertions(+), 219 deletions(-) -- 2.51.1

2 13

[PATCH 0/3] Fix regression in auto port forwarding
by David Gibson 21 Nov '25

21 Nov '25

My recently merged series cleaning up the auto-port-forward scanning contained a series bug: automatic forwards would only appear on alternating seconds. This turned out to be due to a fundamentally broken premise in my thinking. I was thinking that for consistency we wanted the most recent port map information throughout the process. But that's not really true: for the purposes of exclusion what we really need to know is which of the listening sockets we scan are ours. That's given by the *prior* state of the forward maps, not the updated one based on a new scan. The series also had a number of worthwhile changes though. This series fixes it up, by reverting the most misguided of the patches and correcting behaviour of another one while preserving the accompanying code re-orgs. Link: https://bugs.passt.top/show_bug.cgi?id=176 David Gibson (3): Revert "fwd: Update all port maps before applying exclusions" fwd: Exclude ports based on prior mapping state fwd: Don't explicitly exclude reverse-direction TCP ports for UDP fwd.c | 44 ++++++++++++++++++++------------------------ 1 file changed, 20 insertions(+), 24 deletions(-) -- 2.51.1

2 2

[PATCH 3/3] fwd: Preserve non-standard loopback address when splice forwarding
by David Gibson 20 Nov '25

20 Nov '25

When forwarding "spliced" connections outwards (-T or -U) we listen on the guest's loopback and always forward to 127.0.0.1 (or ::1) on the host. However, it's also possible for clients on the guest to attempt connecting to other addresses in 127.0.0.0/8 (systemd-resolved uses 127.0.0.53 in practice). If the host side server is only listening on that specific non-standard loopback address, the forward won't work. Fix this by preserving the specific (loopback) address when forwarding such connections. Link: https://bugs.passt.top/show_bug.cgi?id=113 Signed-off-by: David Gibson <david(a)gibson.dropbear.id.au> --- fwd.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/fwd.c b/fwd.c index c417e0f5..44a0e109 100644 --- a/fwd.c +++ b/fwd.c @@ -660,7 +660,9 @@ uint8_t fwd_nat_from_splice(const struct ctx *c, uint8_t proto, return PIF_NONE; } - if (inany_v4(&ini->eaddr)) + if (!inany_is_unspecified(&ini->oaddr)) + tgt->eaddr = ini->oaddr; + else if (inany_v4(&ini->oaddr)) tgt->eaddr = inany_loopback4; else tgt->eaddr = inany_loopback6; -- 2.51.1

1 0

[PATCH 2/3] tcp: Always populate oaddr field for socket initiated flows
by David Gibson 20 Nov '25

20 Nov '25

When we receive a TCP connection, we get the peer address from the accept() call. In the case of a listening socket with an unspecified address (:: or 0.0.0.0) the local address of the accept()ed socket could vary. We don't get that from the accept() - we must explicitly call getsockname() to get it. Currently we avoid the latency of that extra syscall, and therefore don't populate the initiating 'oaddr' field of a flow created by an incoming TCP socket connection. This more or less works, because we rarely need that local address, but it does cause some oddities: * For migration we need the local address to recreate the socket on the destination, so we *do* call getsockname() in vhost-user mode * It limits our options in terms of forwarding connections flexibly based on the address to which they're received * It differs from UDP, where we explicitly use the IP_PKTINFO cmsg to populate oaddr. * It means (some) flow debug messages will contain wildcards instead of real local addresses In theory we can elide this call when accept()ing from a socket bound to a specific address instead of a wildcard. However to do that will need revisions to the data structures we use to keep track of listening sockets. The lack of this information is making it hard to implement some fixes we want. So, pay the price of the extra syscall to get this information, with the hope that we can later optimise it away for some cases. Signed-off-by: David Gibson <david(a)gibson.dropbear.id.au> --- tcp.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/tcp.c b/tcp.c index bd25952f..e734a957 100644 --- a/tcp.c +++ b/tcp.c @@ -2354,11 +2354,9 @@ void tcp_listen_handler(const struct ctx *c, union epoll_ref ref, ini = flow_initiate_sa(flow, ref.tcp_listen.pif, &sa, NULL, ref.tcp_listen.port); - if (c->mode == MODE_VU) { /* Rebind to same address after migration */ - if (getsockname(s, &sa.sa, &sl) || - inany_from_sockaddr(&ini->oaddr, &ini->oport, &sa) < 0) - err_perror("Can't get local address for socket %i", s); - } + if (getsockname(s, &sa.sa, &sl) || + inany_from_sockaddr(&ini->oaddr, &ini->oport, &sa) < 0) + err_perror("Can't get local address for socket %i", s); if (!inany_is_unicast(&ini->eaddr) || ini->eport == 0) { char sastr[SOCKADDR_STRLEN]; -- 2.51.1

1 0

[PATCH 1/3] util: Rename sock_l4_dualstack() to sock_l4_dualstack_any()
by David Gibson 20 Nov '25

20 Nov '25

Stefano correctly noted that the fact a socket is dual-stack doesn't necessarily imply that it is bound to a wildcard address. While that's the only case we use for dual-stack sockets, there may be others. Therefore rename this function to make it clearer that it always uses a wildcard bind. Suggested-by: Stefano Brivio <sbrivio(a)redhat.com> Signed-off-by: David Gibson <david(a)gibson.dropbear.id.au> --- pif.c | 2 +- util.c | 6 +++--- util.h | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/pif.c b/pif.c index db447b4f..3d7a90e5 100644 --- a/pif.c +++ b/pif.c @@ -82,7 +82,7 @@ int pif_sock_l4(const struct ctx *c, enum epoll_type type, uint8_t pif, ASSERT(pif_is_socket(pif)); if (!addr) { - ref.fd = sock_l4_dualstack(c, type, port, ifname); + ref.fd = sock_l4_dualstack_any(c, type, port, ifname); } else { union sockaddr_inany sa; diff --git a/util.c b/util.c index 82491326..b460dda2 100644 --- a/util.c +++ b/util.c @@ -197,7 +197,7 @@ int sock_l4(const struct ctx *c, enum epoll_type type, } /** - * sock_l4_dualstack() - Create a dual stack socket bound with wildcard address + * sock_l4_dualstack_any() - Create dualstack socket bound to :: and 0.0.0.0 * @c: Execution context * @type: epoll type * @port Port to bind to (:: and 0.0.0.0) @@ -207,8 +207,8 @@ int sock_l4(const struct ctx *c, enum epoll_type type, * * A dual stack socket is effectively bound to both :: and 0.0.0.0. */ -int sock_l4_dualstack(const struct ctx *c, enum epoll_type type, - in_port_t port, const char *ifname) +int sock_l4_dualstack_any(const struct ctx *c, enum epoll_type type, + in_port_t port, const char *ifname) { union sockaddr_inany sa = { .sa6.sin6_family = AF_INET6, diff --git a/util.h b/util.h index d9fbfe5d..963c0ec8 100644 --- a/util.h +++ b/util.h @@ -210,8 +210,8 @@ union sockaddr_inany; int sock_l4(const struct ctx *c, enum epoll_type type, const union sockaddr_inany *sa, const char *ifname); -int sock_l4_dualstack(const struct ctx *c, enum epoll_type type, - in_port_t port, const char *ifname); +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); void sock_probe_mem(struct ctx *c); long timespec_diff_ms(const struct timespec *a, const struct timespec *b); -- 2.51.1

1 0

[PATCH 0/3] Fix bug 113
by David Gibson 20 Nov '25

20 Nov '25

My previous changes to socket binding didn't quite fix bug 113, but they get us close. Here are the last few pieces we need to fix it. This is based on my previous series improving consistency of listening socket binding. David Gibson (3): util: Rename sock_l4_dualstack() to sock_l4_dualstack_any() tcp: Always populate oaddr field for socket initiated flows fwd: Preserve non-standard loopback address when splice forwarding fwd.c | 4 +++- pif.c | 2 +- tcp.c | 8 +++----- util.c | 6 +++--- util.h | 4 ++-- 5 files changed, 12 insertions(+), 12 deletions(-) -- 2.51.1

1 0

[PATCH v3 2/8] util, flow, pif: Simplify sock_l4_sa() interface
by David Gibson 20 Nov '25

20 Nov '25

sock_l4_sa() has a somewhat confusing 'v6only' option controlling whether to set the IPV6_V6ONLY socket option. Usually it's set when the given address is IPv6, but not when we want to create a dual stack listening socket. The latter only makes sense when the address is :: however. Clarify this by only keeping the v6only option in an internal helper sock_l4_(). External users will call either sock_l4() which always creates a socket bound to a specific IP version, or sock_l4_dualstack() which creates a dual stack socket, but takes only a port not an address. We drop the '_sa' suffix while we're at it - it exists because this used to be an internal version with a sock_l4() wrapper. The wrapper no longer exists so the '_sa' is no longer useful. Signed-off-by: David Gibson <david(a)gibson.dropbear.id.au> --- flow.c | 6 ++---- pif.c | 10 +++------- util.c | 27 +++++++++++++++++++++++---- util.h | 8 +++++--- 4 files changed, 33 insertions(+), 18 deletions(-) diff --git a/flow.c b/flow.c index 9926f408..fd530ddb 100644 --- a/flow.c +++ b/flow.c @@ -186,8 +186,7 @@ static int flowside_sock_splice(void *arg) ns_enter(a->c); - a->fd = sock_l4_sa(a->c, a->type, a->sa, NULL, - a->sa->sa_family == AF_INET6, a->data); + a->fd = sock_l4(a->c, a->type, a->sa, NULL, a->data); a->err = errno; return 0; @@ -222,8 +221,7 @@ 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_sa(c, type, &sa, ifname, - sa.sa_family == AF_INET6, data); + return sock_l4(c, type, &sa, ifname, data); case PIF_SPLICE: { struct flowside_sock_args args = { diff --git a/pif.c b/pif.c index 31723b29..5fb1f455 100644 --- a/pif.c +++ b/pif.c @@ -75,11 +75,7 @@ int pif_sock_l4(const struct ctx *c, enum epoll_type type, uint8_t pif, const union inany_addr *addr, const char *ifname, in_port_t port, uint32_t data) { - union sockaddr_inany sa = { - .sa6.sin6_family = AF_INET6, - .sa6.sin6_addr = in6addr_any, - .sa6.sin6_port = htons(port), - }; + union sockaddr_inany sa; ASSERT(pif_is_socket(pif)); @@ -90,8 +86,8 @@ int pif_sock_l4(const struct ctx *c, enum epoll_type type, uint8_t pif, } if (!addr) - return sock_l4_sa(c, type, &sa, ifname, false, data); + return sock_l4_dualstack(c, type, port, ifname, data); pif_sockaddr(c, &sa, pif, addr, port); - return sock_l4_sa(c, type, &sa, ifname, sa.sa_family == AF_INET6, data); + return sock_l4(c, type, &sa, ifname, data); } diff --git a/util.c b/util.c index 976fcabe..c94efae4 100644 --- a/util.c +++ b/util.c @@ -40,7 +40,7 @@ #endif /** - * sock_l4_sa() - Create and bind socket to socket address, add to epoll list + * sock_l4_() - Create and bind socket to socket address, add to epoll list * @c: Execution context * @type: epoll type * @sa: Socket address to bind to @@ -50,9 +50,9 @@ * * Return: newly created socket, negative error code on failure */ -int sock_l4_sa(const struct ctx *c, enum epoll_type type, - const union sockaddr_inany *sa, const char *ifname, - bool v6only, uint32_t data) +static int sock_l4_(const struct ctx *c, enum epoll_type type, + const union sockaddr_inany *sa, const char *ifname, + bool v6only, uint32_t data) { sa_family_t af = sa->sa_family; union epoll_ref ref = { .type = type, .data = data }; @@ -182,6 +182,25 @@ int sock_l4_sa(const struct ctx *c, enum epoll_type type, return fd; } +int sock_l4(const struct ctx *c, enum epoll_type type, + const union sockaddr_inany *sa, const char *ifname, + uint32_t data) +{ + return sock_l4_(c, type, sa, ifname, sa->sa_family == AF_INET6, data); +} + +int sock_l4_dualstack(const struct ctx *c, enum epoll_type type, + in_port_t port, const char *ifname, uint32_t data) +{ + union sockaddr_inany sa = { + .sa6.sin6_family = AF_INET6, + .sa6.sin6_addr = in6addr_any, + .sa6.sin6_port = htons(port), + }; + + return sock_l4_(c, type, &sa, ifname, 0, data); +} + /** * sock_unix() - Create and bind AF_UNIX socket * @sock_path: Socket path. If empty, set on return (UNIX_SOCK_PATH as prefix) diff --git a/util.h b/util.h index e1a1ebc9..7f0cf686 100644 --- a/util.h +++ b/util.h @@ -203,9 +203,11 @@ int do_clone(int (*fn)(void *), char *stack_area, size_t stack_size, int flags, struct ctx; union sockaddr_inany; -int sock_l4_sa(const struct ctx *c, enum epoll_type type, - const union sockaddr_inany *sa, const char *ifname, - bool v6only, uint32_t data); +int sock_l4(const struct ctx *c, enum epoll_type type, + const union sockaddr_inany *sa, const char *ifname, + uint32_t data); +int sock_l4_dualstack(const struct ctx *c, enum epoll_type type, + in_port_t port, const char *ifname, uint32_t data); int sock_unix(char *sock_path); void sock_probe_mem(struct ctx *c); long timespec_diff_ms(const struct timespec *a, const struct timespec *b); -- 2.51.0

2 7

[PATCH v8 0/6] Retry SYNs for inbound connections
by Yumei Huang 19 Nov '25

19 Nov '25

When a client connects, SYN would be sent to guest only once. If the guest is not connected or ready at that time, the connection will be reset in 10s. These patches introduce the SYN retry mechanism using the similar backoff timeout as linux kernel. Also update the data retransmission timeout using the backoff timeout. v8: - Remove the TCP_/tcp_ suffix from certain macro and struct member names - Add parameter struct ctx *c to tcp_timer_ctl() - Modify rto_max type from size_t to int - Clamp syn_retries and syn_linear_timeouts with MAX_SYNCNT(127) - Some other minor fixes related to wording and formatting v7: - Update read_file() and read_file_integer() - Rename tcp_syn_params_init() to tcp_get_rto_params() - Modify the implementation of the timeout assignment - Add a patch to clamp the retry timeout Yumei Huang (6): tcp: Rename "retrans" to "retries" util: Introduce read_file() and read_file_integer() function tcp: Add parameter struct ctx *c to tcp_timer_ctl() tcp: Resend SYN for inbound connections tcp: Update data retransmission timeout tcp: Clamp the retry timeout tcp.c | 107 +++++++++++++++++++++++++++++++++++++++-------------- tcp.h | 6 +++ tcp_conn.h | 13 ++++--- util.c | 86 ++++++++++++++++++++++++++++++++++++++++++ util.h | 2 + 5 files changed, 181 insertions(+), 33 deletions(-) -- 2.51.0

3 31

[PATCH 3/3] fwd: Don't explicitly exclude reverse-direction TCP ports for UDP
by David Gibson 19 Nov '25

19 Nov '25

In auto-forwarding mode, we forward UDP ports for which there isn't (yet) a listening UDP port on the other side, but where there is a listening TCP socket for the same port number. This is useful for certain protocols such as iperf3. Correspondinly, when excluding ports from forwarding, we also exclude TCP ports from the other direction. That sounds like it makes sense, but is unnecessary: for the purposes of exclusion, we don't care why we have a listening UDP socket for that port, just whether we have one. That is already incorporated into the UDP bitmap alone. Signed-off-by: David Gibson <david(a)gibson.dropbear.id.au> --- fwd.c | 6 ++---- util.c | 1 + 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/fwd.c b/fwd.c index c7a880eb..c417e0f5 100644 --- a/fwd.c +++ b/fwd.c @@ -410,10 +410,8 @@ static void fwd_scan_ports(struct ctx *c) memcpy(excl_tcp_out, c->tcp.fwd_in.map, sizeof(excl_tcp_out)); memcpy(excl_tcp_in, c->tcp.fwd_out.map, sizeof(excl_tcp_in)); - bitmap_or(excl_udp_out, PORT_BITMAP_SIZE, - c->udp.fwd_in.map, c->tcp.fwd_in.map); - bitmap_or(excl_udp_in, PORT_BITMAP_SIZE, - c->udp.fwd_out.map, c->tcp.fwd_out.map); + memcpy(excl_udp_out, c->udp.fwd_in.map, sizeof(excl_udp_out)); + memcpy(excl_udp_in, c->udp.fwd_out.map, sizeof(excl_udp_in)); fwd_scan_ports_tcp(&c->tcp.fwd_out, excl_tcp_out); fwd_scan_ports_tcp(&c->tcp.fwd_in, excl_tcp_in); diff --git a/util.c b/util.c index 7944a495..ab23463b 100644 --- a/util.c +++ b/util.c @@ -338,6 +338,7 @@ bool bitmap_isset(const uint8_t *map, unsigned bit) * @a: First operand * @b: Second operand */ +/* cppcheck-suppress unusedFunction */ void bitmap_or(uint8_t *dst, size_t size, const uint8_t *a, const uint8_t *b) { unsigned long *dw = (unsigned long *)dst; -- 2.51.1

1 0

[PATCH 1/3] Revert "fwd: Update all port maps before applying exclusions"
by David Gibson 19 Nov '25

19 Nov '25

This reverts commit 81942a2417357ff10b02ccc8275cde2d4d6fbfbe. That commit was based on the premise of trying to make all the exclusions use the "latest" scan data. That was a fundamentally wrong approach: what we need to exclude is listening ports that pasta itself has created. That is, we need to exclude ports that we were _already_ listening on, not ones that we intend to listen once we rebind - we *want* the old data. Reverting this reduces the cases in which bug 176 occurs, but it's not a complete fix. Link: https://bugs.passt.top/show_bug.cgi?id=176 Signed-off-by: David Gibson <david(a)gibson.dropbear.id.au> --- fwd.c | 47 +++++++++++++++++++++++------------------------ 1 file changed, 23 insertions(+), 24 deletions(-) diff --git a/fwd.c b/fwd.c index 68bb1166..7b6c40fb 100644 --- a/fwd.c +++ b/fwd.c @@ -358,8 +358,10 @@ static void procfs_scan_listen(int fd, unsigned int lstate, uint8_t *map) /** * fwd_scan_ports_tcp() - Scan /proc to update TCP forwarding map * @fwd: Forwarding information to update + * @rev: Forwarding information for the reverse direction */ -static void fwd_scan_ports_tcp(struct fwd_ports *fwd) +static void fwd_scan_ports_tcp(struct fwd_ports *fwd, + const struct fwd_ports *rev) { if (fwd->mode != FWD_AUTO) return; @@ -367,15 +369,20 @@ static void fwd_scan_ports_tcp(struct fwd_ports *fwd) memset(fwd->map, 0, PORT_BITMAP_SIZE); procfs_scan_listen(fwd->scan4, TCP_LISTEN, fwd->map); procfs_scan_listen(fwd->scan6, TCP_LISTEN, fwd->map); + bitmap_and_not(fwd->map, PORT_BITMAP_SIZE, fwd->map, rev->map); } /** * fwd_scan_ports_udp() - Scan /proc to update UDP forwarding map * @fwd: Forwarding information to update + * @rev: Forwarding information for the reverse direction * @tcp_fwd: Corresponding TCP forwarding information + * @tcp_rev: TCP forwarding information for the reverse direction */ static void fwd_scan_ports_udp(struct fwd_ports *fwd, - const struct fwd_ports *tcp_fwd) + const struct fwd_ports *rev, + const struct fwd_ports *tcp_fwd, + const struct fwd_ports *tcp_rev) { if (fwd->mode != FWD_AUTO) return; @@ -391,6 +398,14 @@ static void fwd_scan_ports_udp(struct fwd_ports *fwd, */ procfs_scan_listen(tcp_fwd->scan4, TCP_LISTEN, fwd->map); procfs_scan_listen(tcp_fwd->scan6, TCP_LISTEN, fwd->map); + + /* This means we need to skip numbers of TCP ports bound on the other + * side, too. Otherwise, we would detect corresponding UDP ports as + * bound and try to forward them from the opposite side, but it's + * already us handling them. + */ + bitmap_and_not(fwd->map, PORT_BITMAP_SIZE, fwd->map, rev->map); + bitmap_and_not(fwd->map, PORT_BITMAP_SIZE, fwd->map, tcp_rev->map); } /** @@ -399,28 +414,12 @@ static void fwd_scan_ports_udp(struct fwd_ports *fwd, */ static void fwd_scan_ports(struct ctx *c) { - fwd_scan_ports_tcp(&c->tcp.fwd_out); - fwd_scan_ports_tcp(&c->tcp.fwd_in); - fwd_scan_ports_udp(&c->udp.fwd_out, &c->tcp.fwd_out); - fwd_scan_ports_udp(&c->udp.fwd_in, &c->tcp.fwd_in); - - if (c->tcp.fwd_out.mode == FWD_AUTO) { - bitmap_and_not(c->tcp.fwd_out.map, PORT_BITMAP_SIZE, - c->tcp.fwd_out.map, c->tcp.fwd_in.map); - } - if (c->tcp.fwd_in.mode == FWD_AUTO) { - bitmap_and_not(c->tcp.fwd_in.map, PORT_BITMAP_SIZE, - c->tcp.fwd_in.map, c->tcp.fwd_out.map); - } - - if (c->udp.fwd_out.mode == FWD_AUTO) { - bitmap_and_not(c->udp.fwd_out.map, PORT_BITMAP_SIZE, - c->udp.fwd_out.map, c->udp.fwd_in.map); - } - if (c->udp.fwd_in.mode == FWD_AUTO) { - bitmap_and_not(c->udp.fwd_in.map, PORT_BITMAP_SIZE, - c->udp.fwd_in.map, c->udp.fwd_out.map); - } + fwd_scan_ports_tcp(&c->tcp.fwd_out, &c->tcp.fwd_in); + fwd_scan_ports_tcp(&c->tcp.fwd_in, &c->tcp.fwd_out); + fwd_scan_ports_udp(&c->udp.fwd_out, &c->udp.fwd_in, + &c->tcp.fwd_out, &c->tcp.fwd_in); + fwd_scan_ports_udp(&c->udp.fwd_in, &c->udp.fwd_out, + &c->tcp.fwd_in, &c->tcp.fwd_out); } /** -- 2.51.1

1 0