bpf/prog_tests/btf_skc_cls_ingress.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (c) 2020 Facebook */
0003
0004 #define _GNU_SOURCE
0005 #include <netinet/in.h>
0006 #include <arpa/inet.h>
0007 #include <unistd.h>
0008 #include <stdlib.h>
0009 #include <string.h>
0010 #include <errno.h>
0011 #include <sched.h>
0012 #include <linux/compiler.h>
0013 #include <bpf/libbpf.h>
0014
0015 #include "network_helpers.h"
0016 #include "test_progs.h"
0017 #include "test_btf_skc_cls_ingress.skel.h"
0018
0019 static struct test_btf_skc_cls_ingress *skel;
0020 static struct sockaddr_in6 srv_sa6;
0021 static __u32 duration;
0022
0023 #define PROG_PIN_FILE "/sys/fs/bpf/btf_skc_cls_ingress"
0024
0025 static int write_sysctl(const char *sysctl, const char *value)
0026 {
0027     int fd, err, len;
0028
0029     fd = open(sysctl, O_WRONLY);
0030     if (CHECK(fd == -1, "open sysctl", "open(%s): %s (%d)\n",
0031           sysctl, strerror(errno), errno))
0032         return -1;
0033
0034     len = strlen(value);
0035     err = write(fd, value, len);
0036     close(fd);
0037     if (CHECK(err != len, "write sysctl",
0038           "write(%s, %s, %d): err:%d %s (%d)\n",
0039           sysctl, value, len, err, strerror(errno), errno))
0040         return -1;
0041
0042     return 0;
0043 }
0044
0045 static int prepare_netns(void)
0046 {
0047     if (CHECK(unshare(CLONE_NEWNET), "create netns",
0048           "unshare(CLONE_NEWNET): %s (%d)",
0049           strerror(errno), errno))
0050         return -1;
0051
0052     if (CHECK(system("ip link set dev lo up"),
0053           "ip link set dev lo up", "failed\n"))
0054         return -1;
0055
0056     if (CHECK(system("tc qdisc add dev lo clsact"),
0057           "tc qdisc add dev lo clsact", "failed\n"))
0058         return -1;
0059
0060     if (CHECK(system("tc filter add dev lo ingress bpf direct-action object-pinned " PROG_PIN_FILE),
0061           "install tc cls-prog at ingress", "failed\n"))
0062         return -1;
0063
0064     /* Ensure 20 bytes options (i.e. in total 40 bytes tcp header) for the
0065      * bpf_tcp_gen_syncookie() helper.
0066      */
0067     if (write_sysctl("/proc/sys/net/ipv4/tcp_window_scaling", "1") ||
0068         write_sysctl("/proc/sys/net/ipv4/tcp_timestamps", "1") ||
0069         write_sysctl("/proc/sys/net/ipv4/tcp_sack", "1"))
0070         return -1;
0071
0072     return 0;
0073 }
0074
0075 static void reset_test(void)
0076 {
0077     memset(&skel->bss->srv_sa6, 0, sizeof(skel->bss->srv_sa6));
0078     skel->bss->listen_tp_sport = 0;
0079     skel->bss->req_sk_sport = 0;
0080     skel->bss->recv_cookie = 0;
0081     skel->bss->gen_cookie = 0;
0082     skel->bss->linum = 0;
0083 }
0084
0085 static void print_err_line(void)
0086 {
0087     if (skel->bss->linum)
0088         printf("bpf prog error at line %u\n", skel->bss->linum);
0089 }
0090
0091 static void test_conn(void)
0092 {
0093     int listen_fd = -1, cli_fd = -1, srv_fd = -1, err;
0094     socklen_t addrlen = sizeof(srv_sa6);
0095     int srv_port;
0096
0097     if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "1"))
0098         return;
0099
0100     listen_fd = start_server(AF_INET6, SOCK_STREAM, "::1", 0, 0);
0101     if (CHECK_FAIL(listen_fd == -1))
0102         return;
0103
0104     err = getsockname(listen_fd, (struct sockaddr *)&srv_sa6, &addrlen);
0105     if (CHECK(err, "getsockname(listen_fd)", "err:%d errno:%d\n", err,
0106           errno))
0107         goto done;
0108     memcpy(&skel->bss->srv_sa6, &srv_sa6, sizeof(srv_sa6));
0109     srv_port = ntohs(srv_sa6.sin6_port);
0110
0111     cli_fd = connect_to_fd(listen_fd, 0);
0112     if (CHECK_FAIL(cli_fd == -1))
0113         goto done;
0114
0115     srv_fd = accept(listen_fd, NULL, NULL);
0116     if (CHECK_FAIL(srv_fd == -1))
0117         goto done;
0118
0119     if (CHECK(skel->bss->listen_tp_sport != srv_port ||
0120           skel->bss->req_sk_sport != srv_port,
0121           "Unexpected sk src port",
0122           "listen_tp_sport:%u req_sk_sport:%u expected:%u\n",
0123           skel->bss->listen_tp_sport, skel->bss->req_sk_sport,
0124           srv_port))
0125         goto done;
0126
0127     if (CHECK(skel->bss->gen_cookie || skel->bss->recv_cookie,
0128           "Unexpected syncookie states",
0129           "gen_cookie:%u recv_cookie:%u\n",
0130           skel->bss->gen_cookie, skel->bss->recv_cookie))
0131         goto done;
0132
0133     CHECK(skel->bss->linum, "bpf prog detected error", "at line %u\n",
0134           skel->bss->linum);
0135
0136 done:
0137     if (listen_fd != -1)
0138         close(listen_fd);
0139     if (cli_fd != -1)
0140         close(cli_fd);
0141     if (srv_fd != -1)
0142         close(srv_fd);
0143 }
0144
0145 static void test_syncookie(void)
0146 {
0147     int listen_fd = -1, cli_fd = -1, srv_fd = -1, err;
0148     socklen_t addrlen = sizeof(srv_sa6);
0149     int srv_port;
0150
0151     /* Enforce syncookie mode */
0152     if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "2"))
0153         return;
0154
0155     listen_fd = start_server(AF_INET6, SOCK_STREAM, "::1", 0, 0);
0156     if (CHECK_FAIL(listen_fd == -1))
0157         return;
0158
0159     err = getsockname(listen_fd, (struct sockaddr *)&srv_sa6, &addrlen);
0160     if (CHECK(err, "getsockname(listen_fd)", "err:%d errno:%d\n", err,
0161           errno))
0162         goto done;
0163     memcpy(&skel->bss->srv_sa6, &srv_sa6, sizeof(srv_sa6));
0164     srv_port = ntohs(srv_sa6.sin6_port);
0165
0166     cli_fd = connect_to_fd(listen_fd, 0);
0167     if (CHECK_FAIL(cli_fd == -1))
0168         goto done;
0169
0170     srv_fd = accept(listen_fd, NULL, NULL);
0171     if (CHECK_FAIL(srv_fd == -1))
0172         goto done;
0173
0174     if (CHECK(skel->bss->listen_tp_sport != srv_port,
0175           "Unexpected tp src port",
0176           "listen_tp_sport:%u expected:%u\n",
0177           skel->bss->listen_tp_sport, srv_port))
0178         goto done;
0179
0180     if (CHECK(skel->bss->req_sk_sport,
0181           "Unexpected req_sk src port",
0182           "req_sk_sport:%u expected:0\n",
0183            skel->bss->req_sk_sport))
0184         goto done;
0185
0186     if (CHECK(!skel->bss->gen_cookie ||
0187           skel->bss->gen_cookie != skel->bss->recv_cookie,
0188           "Unexpected syncookie states",
0189           "gen_cookie:%u recv_cookie:%u\n",
0190           skel->bss->gen_cookie, skel->bss->recv_cookie))
0191         goto done;
0192
0193     CHECK(skel->bss->linum, "bpf prog detected error", "at line %u\n",
0194           skel->bss->linum);
0195
0196 done:
0197     if (listen_fd != -1)
0198         close(listen_fd);
0199     if (cli_fd != -1)
0200         close(cli_fd);
0201     if (srv_fd != -1)
0202         close(srv_fd);
0203 }
0204
0205 struct test {
0206     const char *desc;
0207     void (*run)(void);
0208 };
0209
0210 #define DEF_TEST(name) { #name, test_##name }
0211 static struct test tests[] = {
0212     DEF_TEST(conn),
0213     DEF_TEST(syncookie),
0214 };
0215
0216 void test_btf_skc_cls_ingress(void)
0217 {
0218     int i, err;
0219
0220     skel = test_btf_skc_cls_ingress__open_and_load();
0221     if (CHECK(!skel, "test_btf_skc_cls_ingress__open_and_load", "failed\n"))
0222         return;
0223
0224     err = bpf_program__pin(skel->progs.cls_ingress, PROG_PIN_FILE);
0225     if (CHECK(err, "bpf_program__pin",
0226           "cannot pin bpf prog to %s. err:%d\n", PROG_PIN_FILE, err)) {
0227         test_btf_skc_cls_ingress__destroy(skel);
0228         return;
0229     }
0230
0231     for (i = 0; i < ARRAY_SIZE(tests); i++) {
0232         if (!test__start_subtest(tests[i].desc))
0233             continue;
0234
0235         if (prepare_netns())
0236             break;
0237
0238         tests[i].run();
0239
0240         print_err_line();
0241         reset_test();
0242     }
0243
0244     bpf_program__unpin(skel->progs.cls_ingress, PROG_PIN_FILE);
0245     test_btf_skc_cls_ingress__destroy(skel);
0246 }