selftests/bpf: Use sockaddr_storage directly in cls_redirect test

The cls_redirect test uses a custom addr_port/tuple wrapper to represent
IPv4/IPv6 addresses and ports. This custom wrapper requires extra
conversion logic and specific helpers such as fill_addr_port(), which
are no longer necessary when using standard socket address structures.

This commit replaces addr_port/tuple with the standard sockaddr_storage
so test handles address families and ports using native socket types.
It removes the custom helper, eliminates redundant casts, and simplifies
the setup helpers without functional changes. set_up_conn() and
build_input() now take src/dst sockaddr_storage directly.

Reviewed-by: Amery Hung <ameryhung@gmail.com>
Signed-off-by: Hoyeon Lee <hoyeon.lee@suse.com>
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
Link: https://patch.msgid.link/20251121081332.2309838-2-hoyeon.lee@suse.com

diff --git a/tools/testing/selftests/bpf/prog_tests/cls_redirect.c b/tools/testing/selftests/bpf/prog_tests/cls_redirect.c
index 34b59f6baca11ff827ac267a9e8d6f04bbb966b5..7488a7606e6ad70cca9f6a1137d4ec96f67007f9 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/cls_redirect.c
+++ b/tools/testing/selftests/bpf/prog_tests/cls_redirect.c
@@ -22,79 +22,37 @@
 
 static int duration = 0;
 
-struct addr_port {
-       in_port_t port;
-       union {
-               struct in_addr in_addr;
-               struct in6_addr in6_addr;
-       };
-};
-
-struct tuple {
-       int family;
-       struct addr_port src;
-       struct addr_port dst;
-};
-
-static bool fill_addr_port(const struct sockaddr *sa, struct addr_port *ap)
-{
-       const struct sockaddr_in6 *in6;
-       const struct sockaddr_in *in;
-
-       switch (sa->sa_family) {
-       case AF_INET:
-               in = (const struct sockaddr_in *)sa;
-               ap->in_addr = in->sin_addr;
-               ap->port = in->sin_port;
-               return true;
-
-       case AF_INET6:
-               in6 = (const struct sockaddr_in6 *)sa;
-               ap->in6_addr = in6->sin6_addr;
-               ap->port = in6->sin6_port;
-               return true;
-
-       default:
-               return false;
-       }
-}
 
-static bool set_up_conn(const struct sockaddr *addr, socklen_t len, int type,
-                       int *server, int *conn, struct tuple *tuple)
+static bool set_up_conn(const struct sockaddr_storage *addr, socklen_t len, int type,
+                       int *server, int *conn,
+                       struct sockaddr_storage *src,
+                       struct sockaddr_storage *dst)
 {
        struct sockaddr_storage ss;
        socklen_t slen = sizeof(ss);
-       struct sockaddr *sa = (struct sockaddr *)&ss;
 
-       *server = start_server_addr(type, (struct sockaddr_storage *)addr, len, NULL);
+       *server = start_server_addr(type, addr, len, NULL);
        if (*server < 0)
                return false;
 
-       if (CHECK_FAIL(getsockname(*server, sa, &slen)))
+       if (CHECK_FAIL(getsockname(*server, (struct sockaddr *)&ss, &slen)))
                goto close_server;
 
-       *conn = connect_to_addr(type, (struct sockaddr_storage *)sa, slen, NULL);
+       *conn = connect_to_addr(type, &ss, slen, NULL);
        if (*conn < 0)
                goto close_server;
 
        /* We want to simulate packets arriving at conn, so we have to
         * swap src and dst.
         */
-       slen = sizeof(ss);
-       if (CHECK_FAIL(getsockname(*conn, sa, &slen)))
-               goto close_conn;
-
-       if (CHECK_FAIL(!fill_addr_port(sa, &tuple->dst)))
+       slen = sizeof(*dst);
+       if (CHECK_FAIL(getsockname(*conn, (struct sockaddr *)dst, &slen)))
                goto close_conn;
 
-       slen = sizeof(ss);
-       if (CHECK_FAIL(getpeername(*conn, sa, &slen)))
+       slen = sizeof(*src);
+       if (CHECK_FAIL(getpeername(*conn, (struct sockaddr *)src, &slen)))
                goto close_conn;
 
-       if (CHECK_FAIL(!fill_addr_port(sa, &tuple->src)))
-               goto close_conn;
-
-       tuple->family = ss.ss_family;
        return true;
 
 close_conn:
@@ -110,17 +68,16 @@ static socklen_t prepare_addr(struct sockaddr_storage *addr, int family)
 {
        struct sockaddr_in *addr4;
        struct sockaddr_in6 *addr6;
+       memset(addr, 0, sizeof(*addr));
 
        switch (family) {
        case AF_INET:
                addr4 = (struct sockaddr_in *)addr;
-               memset(addr4, 0, sizeof(*addr4));
                addr4->sin_family = family;
                addr4->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
                return sizeof(*addr4);
        case AF_INET6:
                addr6 = (struct sockaddr_in6 *)addr;
-               memset(addr6, 0, sizeof(*addr6));
                addr6->sin6_family = family;
                addr6->sin6_addr = in6addr_loopback;
                return sizeof(*addr6);
@@ -242,9 +199,15 @@ static void encap_init(encap_headers_t *encap, uint8_t hop_count, uint8_t proto)
 }
 
 static size_t build_input(const struct test_cfg *test, void *const buf,
-                         const struct tuple *tuple)
+                         const struct sockaddr_storage *src,
+                         const struct sockaddr_storage *dst)
 {
-       in_port_t sport = tuple->src.port;
+       struct sockaddr_in6 *src_in6 = (struct sockaddr_in6 *)src;
+       struct sockaddr_in6 *dst_in6 = (struct sockaddr_in6 *)dst;
+       struct sockaddr_in *src_in = (struct sockaddr_in *)src;
+       struct sockaddr_in *dst_in = (struct sockaddr_in *)dst;
+       sa_family_t family = src->ss_family;
+       in_port_t sport, dport;
        encap_headers_t encap;
        struct iphdr ip;
        struct ipv6hdr ipv6;
@@ -254,8 +217,11 @@ static size_t build_input(const struct test_cfg *test, void *const buf,
        uint8_t *p = buf;
        int proto;
 
+       sport = (family == AF_INET) ? src_in->sin_port : src_in6->sin6_port;
+       dport = (family == AF_INET) ? dst_in->sin_port : dst_in6->sin6_port;
+
        proto = IPPROTO_IPIP;
-       if (tuple->family == AF_INET6)
+       if (family == AF_INET6)
                proto = IPPROTO_IPV6;
 
        encap_init(&encap, test->hops == ONE_HOP ? 1 : 0, proto);
@@ -270,15 +236,15 @@ static size_t build_input(const struct test_cfg *test, void *const buf,
        if (test->type == UDP)
                proto = IPPROTO_UDP;
 
-       switch (tuple->family) {
+       switch (family) {
        case AF_INET:
                ip = (struct iphdr){
                        .ihl = 5,
                        .version = 4,
                        .ttl = IPDEFTTL,
                        .protocol = proto,
-                       .saddr = tuple->src.in_addr.s_addr,
-                       .daddr = tuple->dst.in_addr.s_addr,
+                       .saddr = src_in->sin_addr.s_addr,
+                       .daddr = dst_in->sin_addr.s_addr,
                };
                p = mempcpy(p, &ip, sizeof(ip));
                break;
@@ -287,8 +253,8 @@ static size_t build_input(const struct test_cfg *test, void *const buf,
                        .version = 6,
                        .hop_limit = IPDEFTTL,
                        .nexthdr = proto,
-                       .saddr = tuple->src.in6_addr,
-                       .daddr = tuple->dst.in6_addr,
+                       .saddr = src_in6->sin6_addr,
+                       .daddr = dst_in6->sin6_addr,
                };
                p = mempcpy(p, &ipv6, sizeof(ipv6));
                break;
@@ -303,18 +269,16 @@ static size_t build_input(const struct test_cfg *test, void *const buf,
        case TCP:
                tcp = (struct tcphdr){
                        .source = sport,
-                       .dest = tuple->dst.port,
+                       .dest = dport,
+                       .syn = (test->flags == SYN),
+                       .ack = (test->flags == ACK),
                };
-               if (test->flags == SYN)
-                       tcp.syn = true;
-               if (test->flags == ACK)
-                       tcp.ack = true;
                p = mempcpy(p, &tcp, sizeof(tcp));
                break;
        case UDP:
                udp = (struct udphdr){
                        .source = sport,
-                       .dest = tuple->dst.port,
+                       .dest = dport,
                };
                p = mempcpy(p, &udp, sizeof(udp));
                break;
@@ -339,27 +303,26 @@ static void test_cls_redirect_common(struct bpf_program *prog)
        LIBBPF_OPTS(bpf_test_run_opts, tattr);
        int families[] = { AF_INET, AF_INET6 };
        struct sockaddr_storage ss;
-       struct sockaddr *addr;
        socklen_t slen;
        int i, j, err, prog_fd;
        int servers[__NR_KIND][ARRAY_SIZE(families)] = {};
        int conns[__NR_KIND][ARRAY_SIZE(families)] = {};
-       struct tuple tuples[__NR_KIND][ARRAY_SIZE(families)];
+       struct sockaddr_storage srcs[__NR_KIND][ARRAY_SIZE(families)];
+       struct sockaddr_storage dsts[__NR_KIND][ARRAY_SIZE(families)];
 
-       addr = (struct sockaddr *)&ss;
        for (i = 0; i < ARRAY_SIZE(families); i++) {
                slen = prepare_addr(&ss, families[i]);
                if (CHECK_FAIL(!slen))
                        goto cleanup;
 
-               if (CHECK_FAIL(!set_up_conn(addr, slen, SOCK_DGRAM,
+               if (CHECK_FAIL(!set_up_conn(&ss, slen, SOCK_DGRAM,
                                            &servers[UDP][i], &conns[UDP][i],
-                                           &tuples[UDP][i])))
+                                           &srcs[UDP][i], &dsts[UDP][i])))
                        goto cleanup;
 
-               if (CHECK_FAIL(!set_up_conn(addr, slen, SOCK_STREAM,
+               if (CHECK_FAIL(!set_up_conn(&ss, slen, SOCK_STREAM,
                                            &servers[TCP][i], &conns[TCP][i],
-                                           &tuples[TCP][i])))
+                                           &srcs[TCP][i], &dsts[TCP][i])))
                        goto cleanup;
        }
 
@@ -368,11 +331,12 @@ static void test_cls_redirect_common(struct bpf_program *prog)
                struct test_cfg *test = &tests[i];
 
                for (j = 0; j < ARRAY_SIZE(families); j++) {
-                       struct tuple *tuple = &tuples[test->type][j];
+                       struct sockaddr_storage *src = &srcs[test->type][j];
+                       struct sockaddr_storage *dst = &dsts[test->type][j];
                        char input[256];
                        char tmp[256];
 
-                       test_str(tmp, sizeof(tmp), test, tuple->family);
+                       test_str(tmp, sizeof(tmp), test, families[j]);
                        if (!test__start_subtest(tmp))
                                continue;
 
@@ -380,7 +344,7 @@ static void test_cls_redirect_common(struct bpf_program *prog)
                        tattr.data_size_out = sizeof(tmp);
 
                        tattr.data_in = input;
-                       tattr.data_size_in = build_input(test, input, tuple);
+                       tattr.data_size_in = build_input(test, input, src, dst);
                        if (CHECK_FAIL(!tattr.data_size_in))
                                continue;