| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Jordan Rife | 4550 | 57.23% | 16 | 50.00% |
| Daan De Meyer | 2459 | 30.93% | 1 | 3.12% |
| Andrey Ignatov | 794 | 9.99% | 5 | 15.62% |
| Jussi Mäki | 72 | 0.91% | 1 | 3.12% |
| Daniel Borkmann | 26 | 0.33% | 1 | 3.12% |
| Geliang Tang | 15 | 0.19% | 1 | 3.12% |
| Stanislav Fomichev | 14 | 0.18% | 2 | 6.25% |
| Martin KaFai Lau | 10 | 0.13% | 2 | 6.25% |
| Andrii Nakryiko | 5 | 0.06% | 1 | 3.12% |
| Toke Höiland-Jörgensen | 4 | 0.05% | 1 | 3.12% |
| Nicolas Rybowski | 1 | 0.01% | 1 | 3.12% |
| Total | 7950 | 32 |
// SPDX-License-Identifier: GPL-2.0 #include <sys/un.h> #include "test_progs.h" #include "sock_addr_kern.skel.h" #include "bind4_prog.skel.h" #include "bind6_prog.skel.h" #include "connect_unix_prog.skel.h" #include "connect4_prog.skel.h" #include "connect6_prog.skel.h" #include "sendmsg4_prog.skel.h" #include "sendmsg6_prog.skel.h" #include "recvmsg4_prog.skel.h" #include "recvmsg6_prog.skel.h" #include "sendmsg_unix_prog.skel.h" #include "recvmsg_unix_prog.skel.h" #include "getsockname4_prog.skel.h" #include "getsockname6_prog.skel.h" #include "getsockname_unix_prog.skel.h" #include "getpeername4_prog.skel.h" #include "getpeername6_prog.skel.h" #include "getpeername_unix_prog.skel.h" #include "network_helpers.h" #ifndef ENOTSUPP # define ENOTSUPP 524 #endif #define TEST_NS "sock_addr" #define TEST_IF_PREFIX "test_sock_addr" #define TEST_IPV4 "127.0.0.4" #define TEST_IPV6 "::6" #define SERV4_IP "192.168.1.254" #define SERV4_REWRITE_IP "127.0.0.1" #define SRC4_IP "172.16.0.1" #define SRC4_REWRITE_IP TEST_IPV4 #define SERV4_PORT 4040 #define SERV4_REWRITE_PORT 4444 #define SERV6_IP "face:b00c:1234:5678::abcd" #define SERV6_REWRITE_IP "::1" #define SERV6_V4MAPPED_IP "::ffff:192.168.0.4" #define SRC6_IP "::1" #define SRC6_REWRITE_IP TEST_IPV6 #define WILDCARD6_IP "::" #define SERV6_PORT 6060 #define SERV6_REWRITE_PORT 6666 #define SERVUN_ADDRESS "bpf_cgroup_unix_test" #define SERVUN_REWRITE_ADDRESS "bpf_cgroup_unix_test_rewrite" #define SRCUN_ADDRESS "bpf_cgroup_unix_test_src" #define save_errno_do(op) ({ int __save = errno; op; errno = __save; }) enum sock_addr_test_type { SOCK_ADDR_TEST_BIND, SOCK_ADDR_TEST_CONNECT, SOCK_ADDR_TEST_SENDMSG, SOCK_ADDR_TEST_RECVMSG, SOCK_ADDR_TEST_GETSOCKNAME, SOCK_ADDR_TEST_GETPEERNAME, }; typedef void *(*load_fn)(int cgroup_fd, enum bpf_attach_type attach_type, bool expect_reject); typedef void (*destroy_fn)(void *skel); static int cmp_addr(const struct sockaddr_storage *addr1, socklen_t addr1_len, const struct sockaddr_storage *addr2, socklen_t addr2_len, bool cmp_port); struct init_sock_args { int af; int type; }; struct addr_args { char addr[sizeof(struct sockaddr_storage)]; int addrlen; }; struct sendmsg_args { struct addr_args addr; char msg[10]; int msglen; }; static struct sock_addr_kern *skel; static int run_bpf_prog(const char *prog_name, void *ctx, int ctx_size) { LIBBPF_OPTS(bpf_test_run_opts, topts); struct bpf_program *prog; int prog_fd, err; topts.ctx_in = ctx; topts.ctx_size_in = ctx_size; prog = bpf_object__find_program_by_name(skel->obj, prog_name); if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name")) goto err; prog_fd = bpf_program__fd(prog); err = bpf_prog_test_run_opts(prog_fd, &topts); if (!ASSERT_OK(err, prog_name)) goto err; err = topts.retval; errno = -topts.retval; goto out; err: err = -1; out: return err; } static int kernel_init_sock(int af, int type, int protocol) { struct init_sock_args args = { .af = af, .type = type, }; return run_bpf_prog("init_sock", &args, sizeof(args)); } static int kernel_close_sock(int fd) { return run_bpf_prog("close_sock", NULL, 0); } static int sock_addr_op(const char *name, struct sockaddr *addr, socklen_t *addrlen, bool expect_change) { struct addr_args args; int err; if (addrlen) args.addrlen = *addrlen; if (addr) memcpy(&args.addr, addr, *addrlen); err = run_bpf_prog(name, &args, sizeof(args)); if (!expect_change && addr) if (!ASSERT_EQ(cmp_addr((struct sockaddr_storage *)addr, *addrlen, (struct sockaddr_storage *)&args.addr, args.addrlen, 1), 0, "address_param_modified")) return -1; if (addrlen) *addrlen = args.addrlen; if (addr) memcpy(addr, &args.addr, *addrlen); return err; } static int send_msg_op(const char *name, struct sockaddr *addr, socklen_t addrlen, const char *msg, int msglen) { struct sendmsg_args args; int err; memset(&args, 0, sizeof(args)); memcpy(&args.addr.addr, addr, addrlen); args.addr.addrlen = addrlen; memcpy(args.msg, msg, msglen); args.msglen = msglen; err = run_bpf_prog(name, &args, sizeof(args)); if (!ASSERT_EQ(cmp_addr((struct sockaddr_storage *)addr, addrlen, (struct sockaddr_storage *)&args.addr.addr, args.addr.addrlen, 1), 0, "address_param_modified")) return -1; return err; } static int kernel_connect(struct sockaddr *addr, socklen_t addrlen) { return sock_addr_op("kernel_connect", addr, &addrlen, false); } static int kernel_bind(int fd, struct sockaddr *addr, socklen_t addrlen) { return sock_addr_op("kernel_bind", addr, &addrlen, false); } static int kernel_listen(void) { return sock_addr_op("kernel_listen", NULL, NULL, false); } static int kernel_sendmsg(int fd, struct sockaddr *addr, socklen_t addrlen, char *msg, int msglen) { return send_msg_op("kernel_sendmsg", addr, addrlen, msg, msglen); } static int sock_sendmsg(int fd, struct sockaddr *addr, socklen_t addrlen, char *msg, int msglen) { return send_msg_op("sock_sendmsg", addr, addrlen, msg, msglen); } static int kernel_getsockname(int fd, struct sockaddr *addr, socklen_t *addrlen) { return sock_addr_op("kernel_getsockname", addr, addrlen, true); } static int kernel_getpeername(int fd, struct sockaddr *addr, socklen_t *addrlen) { return sock_addr_op("kernel_getpeername", addr, addrlen, true); } int kernel_connect_to_addr(int type, const struct sockaddr_storage *addr, socklen_t addrlen, const struct network_helper_opts *opts) { int err; if (!ASSERT_OK(kernel_init_sock(addr->ss_family, type, 0), "kernel_init_sock")) goto err; if (kernel_connect((struct sockaddr *)addr, addrlen) < 0) goto err; /* Test code expects a "file descriptor" on success. */ err = 1; goto out; err: err = -1; save_errno_do(ASSERT_OK(kernel_close_sock(0), "kernel_close_sock")); out: return err; } int kernel_start_server(int family, int type, const char *addr_str, __u16 port, int timeout_ms) { struct sockaddr_storage addr; socklen_t addrlen; int err; if (!ASSERT_OK(kernel_init_sock(family, type, 0), "kernel_init_sock")) goto err; if (make_sockaddr(family, addr_str, port, &addr, &addrlen)) goto err; if (kernel_bind(0, (struct sockaddr *)&addr, addrlen) < 0) goto err; if (type == SOCK_STREAM) { if (!ASSERT_OK(kernel_listen(), "kernel_listen")) goto err; } /* Test code expects a "file descriptor" on success. */ err = 1; goto out; err: err = -1; save_errno_do(ASSERT_OK(kernel_close_sock(0), "kernel_close_sock")); out: return err; } struct sock_ops { int (*connect_to_addr)(int type, const struct sockaddr_storage *addr, socklen_t addrlen, const struct network_helper_opts *opts); int (*start_server)(int family, int type, const char *addr_str, __u16 port, int timeout_ms); int (*socket)(int famil, int type, int protocol); int (*bind)(int fd, struct sockaddr *addr, socklen_t addrlen); int (*getsockname)(int fd, struct sockaddr *addr, socklen_t *addrlen); int (*getpeername)(int fd, struct sockaddr *addr, socklen_t *addrlen); int (*sendmsg)(int fd, struct sockaddr *addr, socklen_t addrlen, char *msg, int msglen); int (*close)(int fd); }; static int user_sendmsg(int fd, struct sockaddr *addr, socklen_t addrlen, char *msg, int msglen) { struct msghdr hdr; struct iovec iov; memset(&iov, 0, sizeof(iov)); iov.iov_base = msg; iov.iov_len = msglen; memset(&hdr, 0, sizeof(hdr)); hdr.msg_name = (void *)addr; hdr.msg_namelen = addrlen; hdr.msg_iov = &iov; hdr.msg_iovlen = 1; return sendmsg(fd, &hdr, 0); } static int user_bind(int fd, struct sockaddr *addr, socklen_t addrlen) { return bind(fd, (const struct sockaddr *)addr, addrlen); } struct sock_ops user_ops = { .connect_to_addr = connect_to_addr, .start_server = start_server, .socket = socket, .bind = user_bind, .getsockname = getsockname, .getpeername = getpeername, .sendmsg = user_sendmsg, .close = close, }; struct sock_ops kern_ops_sock_sendmsg = { .connect_to_addr = kernel_connect_to_addr, .start_server = kernel_start_server, .socket = kernel_init_sock, .bind = kernel_bind, .getsockname = kernel_getsockname, .getpeername = kernel_getpeername, .sendmsg = sock_sendmsg, .close = kernel_close_sock, }; struct sock_ops kern_ops_kernel_sendmsg = { .connect_to_addr = kernel_connect_to_addr, .start_server = kernel_start_server, .socket = kernel_init_sock, .bind = kernel_bind, .getsockname = kernel_getsockname, .getpeername = kernel_getpeername, .sendmsg = kernel_sendmsg, .close = kernel_close_sock, }; struct sock_addr_test { enum sock_addr_test_type type; const char *name; /* BPF prog properties */ load_fn loadfn; destroy_fn destroyfn; enum bpf_attach_type attach_type; /* Socket operations */ struct sock_ops *ops; /* Socket properties */ int socket_family; int socket_type; /* IP:port pairs for BPF prog to override */ const char *requested_addr; unsigned short requested_port; const char *expected_addr; unsigned short expected_port; const char *expected_src_addr; /* Expected test result */ enum { LOAD_REJECT, ATTACH_REJECT, SYSCALL_EPERM, SYSCALL_ENOTSUPP, SUCCESS, } expected_result; }; #define BPF_SKEL_FUNCS_RAW(skel_name, prog_name) \ static void *prog_name##_load_raw(int cgroup_fd, \ enum bpf_attach_type attach_type, \ bool expect_reject) \ { \ struct skel_name *skel = skel_name##__open(); \ int prog_fd = -1; \ if (!ASSERT_OK_PTR(skel, "skel_open")) \ goto cleanup; \ if (!ASSERT_OK(skel_name##__load(skel), "load")) \ goto cleanup; \ prog_fd = bpf_program__fd(skel->progs.prog_name); \ if (!ASSERT_GT(prog_fd, 0, "prog_fd")) \ goto cleanup; \ if (bpf_prog_attach(prog_fd, cgroup_fd, attach_type, \ BPF_F_ALLOW_OVERRIDE), "bpf_prog_attach") { \ ASSERT_TRUE(expect_reject, "unexpected rejection"); \ goto cleanup; \ } \ if (!ASSERT_FALSE(expect_reject, "expected rejection")) \ goto cleanup; \ cleanup: \ if (prog_fd > 0) \ bpf_prog_detach(cgroup_fd, attach_type); \ skel_name##__destroy(skel); \ return NULL; \ } \ static void prog_name##_destroy_raw(void *progfd) \ { \ /* No-op. *_load_raw does all cleanup. */ \ } \ #define BPF_SKEL_FUNCS(skel_name, prog_name) \ static void *prog_name##_load(int cgroup_fd, \ enum bpf_attach_type attach_type, \ bool expect_reject) \ { \ struct skel_name *skel = skel_name##__open(); \ if (!ASSERT_OK_PTR(skel, "skel_open")) \ goto cleanup; \ if (!ASSERT_OK(bpf_program__set_expected_attach_type(skel->progs.prog_name, \ attach_type), \ "set_expected_attach_type")) \ goto cleanup; \ if (skel_name##__load(skel)) { \ ASSERT_TRUE(expect_reject, "unexpected rejection"); \ goto cleanup; \ } \ if (!ASSERT_FALSE(expect_reject, "expected rejection")) \ goto cleanup; \ skel->links.prog_name = bpf_program__attach_cgroup( \ skel->progs.prog_name, cgroup_fd); \ if (!ASSERT_OK_PTR(skel->links.prog_name, "prog_attach")) \ goto cleanup; \ return skel; \ cleanup: \ skel_name##__destroy(skel); \ return NULL; \ } \ static void prog_name##_destroy(void *skel) \ { \ skel_name##__destroy(skel); \ } BPF_SKEL_FUNCS(bind4_prog, bind_v4_prog); BPF_SKEL_FUNCS_RAW(bind4_prog, bind_v4_prog); BPF_SKEL_FUNCS(bind4_prog, bind_v4_deny_prog); BPF_SKEL_FUNCS(bind6_prog, bind_v6_prog); BPF_SKEL_FUNCS_RAW(bind6_prog, bind_v6_prog); BPF_SKEL_FUNCS(bind6_prog, bind_v6_deny_prog); BPF_SKEL_FUNCS(connect4_prog, connect_v4_prog); BPF_SKEL_FUNCS_RAW(connect4_prog, connect_v4_prog); BPF_SKEL_FUNCS(connect4_prog, connect_v4_deny_prog); BPF_SKEL_FUNCS(connect6_prog, connect_v6_prog); BPF_SKEL_FUNCS_RAW(connect6_prog, connect_v6_prog); BPF_SKEL_FUNCS(connect6_prog, connect_v6_deny_prog); BPF_SKEL_FUNCS(connect_unix_prog, connect_unix_prog); BPF_SKEL_FUNCS_RAW(connect_unix_prog, connect_unix_prog); BPF_SKEL_FUNCS(connect_unix_prog, connect_unix_deny_prog); BPF_SKEL_FUNCS(sendmsg4_prog, sendmsg_v4_prog); BPF_SKEL_FUNCS_RAW(sendmsg4_prog, sendmsg_v4_prog); BPF_SKEL_FUNCS(sendmsg4_prog, sendmsg_v4_deny_prog); BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_prog); BPF_SKEL_FUNCS_RAW(sendmsg6_prog, sendmsg_v6_prog); BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_deny_prog); BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_preserve_dst_prog); BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_v4mapped_prog); BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_wildcard_prog); BPF_SKEL_FUNCS(sendmsg_unix_prog, sendmsg_unix_prog); BPF_SKEL_FUNCS_RAW(sendmsg_unix_prog, sendmsg_unix_prog); BPF_SKEL_FUNCS(sendmsg_unix_prog, sendmsg_unix_deny_prog); BPF_SKEL_FUNCS(recvmsg4_prog, recvmsg4_prog); BPF_SKEL_FUNCS_RAW(recvmsg4_prog, recvmsg4_prog); BPF_SKEL_FUNCS(recvmsg6_prog, recvmsg6_prog); BPF_SKEL_FUNCS_RAW(recvmsg6_prog, recvmsg6_prog); BPF_SKEL_FUNCS(recvmsg_unix_prog, recvmsg_unix_prog); BPF_SKEL_FUNCS_RAW(recvmsg_unix_prog, recvmsg_unix_prog); BPF_SKEL_FUNCS(getsockname_unix_prog, getsockname_unix_prog); BPF_SKEL_FUNCS_RAW(getsockname_unix_prog, getsockname_unix_prog); BPF_SKEL_FUNCS(getsockname4_prog, getsockname_v4_prog); BPF_SKEL_FUNCS_RAW(getsockname4_prog, getsockname_v4_prog); BPF_SKEL_FUNCS(getsockname6_prog, getsockname_v6_prog); BPF_SKEL_FUNCS_RAW(getsockname6_prog, getsockname_v6_prog); BPF_SKEL_FUNCS(getpeername_unix_prog, getpeername_unix_prog); BPF_SKEL_FUNCS_RAW(getpeername_unix_prog, getpeername_unix_prog); BPF_SKEL_FUNCS(getpeername4_prog, getpeername_v4_prog); BPF_SKEL_FUNCS_RAW(getpeername4_prog, getpeername_v4_prog); BPF_SKEL_FUNCS(getpeername6_prog, getpeername_v6_prog); BPF_SKEL_FUNCS_RAW(getpeername6_prog, getpeername_v6_prog); static struct sock_addr_test tests[] = { /* bind - system calls */ { SOCK_ADDR_TEST_BIND, "bind4: bind (stream)", bind_v4_prog_load, bind_v4_prog_destroy, BPF_CGROUP_INET4_BIND, &user_ops, AF_INET, SOCK_STREAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_BIND, "bind4: bind deny (stream)", bind_v4_deny_prog_load, bind_v4_deny_prog_destroy, BPF_CGROUP_INET4_BIND, &user_ops, AF_INET, SOCK_STREAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_BIND, "bind4: bind (dgram)", bind_v4_prog_load, bind_v4_prog_destroy, BPF_CGROUP_INET4_BIND, &user_ops, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_BIND, "bind4: bind deny (dgram)", bind_v4_deny_prog_load, bind_v4_deny_prog_destroy, BPF_CGROUP_INET4_BIND, &user_ops, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_BIND, "bind4: load prog with wrong expected attach type", bind_v4_prog_load, bind_v4_prog_destroy, BPF_CGROUP_INET6_BIND, &user_ops, AF_INET, SOCK_STREAM, NULL, 0, NULL, 0, NULL, LOAD_REJECT, }, { SOCK_ADDR_TEST_BIND, "bind4: attach prog with wrong attach type", bind_v4_prog_load_raw, bind_v4_prog_destroy_raw, BPF_CGROUP_INET6_BIND, &user_ops, AF_INET, SOCK_STREAM, NULL, 0, NULL, 0, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_BIND, "bind6: bind (stream)", bind_v6_prog_load, bind_v6_prog_destroy, BPF_CGROUP_INET6_BIND, &user_ops, AF_INET6, SOCK_STREAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_BIND, "bind6: bind deny (stream)", bind_v6_deny_prog_load, bind_v6_deny_prog_destroy, BPF_CGROUP_INET6_BIND, &user_ops, AF_INET6, SOCK_STREAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_BIND, "bind6: bind (dgram)", bind_v6_prog_load, bind_v6_prog_destroy, BPF_CGROUP_INET6_BIND, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_BIND, "bind6: bind deny (dgram)", bind_v6_deny_prog_load, bind_v6_deny_prog_destroy, BPF_CGROUP_INET6_BIND, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_BIND, "bind6: load prog with wrong expected attach type", bind_v6_prog_load, bind_v6_prog_destroy, BPF_CGROUP_INET4_BIND, &user_ops, AF_INET6, SOCK_STREAM, NULL, 0, NULL, 0, NULL, LOAD_REJECT, }, { SOCK_ADDR_TEST_BIND, "bind6: attach prog with wrong attach type", bind_v6_prog_load_raw, bind_v6_prog_destroy_raw, BPF_CGROUP_INET4_BIND, &user_ops, AF_INET, SOCK_STREAM, NULL, 0, NULL, 0, NULL, ATTACH_REJECT, }, /* bind - kernel calls */ { SOCK_ADDR_TEST_BIND, "bind4: kernel_bind (stream)", bind_v4_prog_load, bind_v4_prog_destroy, BPF_CGROUP_INET4_BIND, &kern_ops_sock_sendmsg, AF_INET, SOCK_STREAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_BIND, "bind4: kernel_bind deny (stream)", bind_v4_deny_prog_load, bind_v4_deny_prog_destroy, BPF_CGROUP_INET4_BIND, &kern_ops_sock_sendmsg, AF_INET, SOCK_STREAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_BIND, "bind4: kernel_bind (dgram)", bind_v4_prog_load, bind_v4_prog_destroy, BPF_CGROUP_INET4_BIND, &kern_ops_sock_sendmsg, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_BIND, "bind4: kernel_bind deny (dgram)", bind_v4_deny_prog_load, bind_v4_deny_prog_destroy, BPF_CGROUP_INET4_BIND, &kern_ops_sock_sendmsg, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_BIND, "bind6: kernel_bind (stream)", bind_v6_prog_load, bind_v6_prog_destroy, BPF_CGROUP_INET6_BIND, &kern_ops_sock_sendmsg, AF_INET6, SOCK_STREAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_BIND, "bind6: kernel_bind deny (stream)", bind_v6_deny_prog_load, bind_v6_deny_prog_destroy, BPF_CGROUP_INET6_BIND, &kern_ops_sock_sendmsg, AF_INET6, SOCK_STREAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_BIND, "bind6: kernel_bind (dgram)", bind_v6_prog_load, bind_v6_prog_destroy, BPF_CGROUP_INET6_BIND, &kern_ops_sock_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_BIND, "bind6: kernel_bind deny (dgram)", bind_v6_deny_prog_load, bind_v6_deny_prog_destroy, BPF_CGROUP_INET6_BIND, &kern_ops_sock_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, NULL, SYSCALL_EPERM, }, /* connect - system calls */ { SOCK_ADDR_TEST_CONNECT, "connect4: connect (stream)", connect_v4_prog_load, connect_v4_prog_destroy, BPF_CGROUP_INET4_CONNECT, &user_ops, AF_INET, SOCK_STREAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect4: connect deny (stream)", connect_v4_deny_prog_load, connect_v4_deny_prog_destroy, BPF_CGROUP_INET4_CONNECT, &user_ops, AF_INET, SOCK_STREAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect4: connect (dgram)", connect_v4_prog_load, connect_v4_prog_destroy, BPF_CGROUP_INET4_CONNECT, &user_ops, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect4: connect deny (dgram)", connect_v4_deny_prog_load, connect_v4_deny_prog_destroy, BPF_CGROUP_INET4_CONNECT, &user_ops, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect4: load prog with wrong expected attach type", connect_v4_prog_load, connect_v4_prog_destroy, BPF_CGROUP_INET6_CONNECT, &user_ops, AF_INET, SOCK_STREAM, NULL, 0, NULL, 0, NULL, LOAD_REJECT, }, { SOCK_ADDR_TEST_CONNECT, "connect4: attach prog with wrong attach type", connect_v4_prog_load_raw, connect_v4_prog_destroy_raw, BPF_CGROUP_INET6_CONNECT, &user_ops, AF_INET, SOCK_STREAM, NULL, 0, NULL, 0, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_CONNECT, "connect6: connect (stream)", connect_v6_prog_load, connect_v6_prog_destroy, BPF_CGROUP_INET6_CONNECT, &user_ops, AF_INET6, SOCK_STREAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect6: connect deny (stream)", connect_v6_deny_prog_load, connect_v6_deny_prog_destroy, BPF_CGROUP_INET6_CONNECT, &user_ops, AF_INET6, SOCK_STREAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect6: connect (dgram)", connect_v6_prog_load, connect_v6_prog_destroy, BPF_CGROUP_INET6_CONNECT, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect6: connect deny (dgram)", connect_v6_deny_prog_load, connect_v6_deny_prog_destroy, BPF_CGROUP_INET6_CONNECT, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect6: load prog with wrong expected attach type", connect_v6_prog_load, connect_v6_prog_destroy, BPF_CGROUP_INET4_CONNECT, &user_ops, AF_INET6, SOCK_STREAM, NULL, 0, NULL, 0, NULL, LOAD_REJECT, }, { SOCK_ADDR_TEST_CONNECT, "connect6: attach prog with wrong attach type", connect_v6_prog_load_raw, connect_v6_prog_destroy_raw, BPF_CGROUP_INET4_CONNECT, &user_ops, AF_INET, SOCK_STREAM, NULL, 0, NULL, 0, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_CONNECT, "connect_unix: connect (stream)", connect_unix_prog_load, connect_unix_prog_destroy, BPF_CGROUP_UNIX_CONNECT, &user_ops, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect_unix: connect deny (stream)", connect_unix_deny_prog_load, connect_unix_deny_prog_destroy, BPF_CGROUP_UNIX_CONNECT, &user_ops, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect_unix: attach prog with wrong attach type", connect_unix_prog_load_raw, connect_unix_prog_destroy_raw, BPF_CGROUP_INET4_CONNECT, &user_ops, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, ATTACH_REJECT, }, /* connect - kernel calls */ { SOCK_ADDR_TEST_CONNECT, "connect4: kernel_connect (stream)", connect_v4_prog_load, connect_v4_prog_destroy, BPF_CGROUP_INET4_CONNECT, &kern_ops_sock_sendmsg, AF_INET, SOCK_STREAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect4: kernel_connect deny (stream)", connect_v4_deny_prog_load, connect_v4_deny_prog_destroy, BPF_CGROUP_INET4_CONNECT, &kern_ops_sock_sendmsg, AF_INET, SOCK_STREAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect4: kernel_connect (dgram)", connect_v4_prog_load, connect_v4_prog_destroy, BPF_CGROUP_INET4_CONNECT, &kern_ops_sock_sendmsg, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect4: kernel_connect deny (dgram)", connect_v4_deny_prog_load, connect_v4_deny_prog_destroy, BPF_CGROUP_INET4_CONNECT, &kern_ops_sock_sendmsg, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect6: kernel_connect (stream)", connect_v6_prog_load, connect_v6_prog_destroy, BPF_CGROUP_INET6_CONNECT, &kern_ops_sock_sendmsg, AF_INET6, SOCK_STREAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect6: kernel_connect deny (stream)", connect_v6_deny_prog_load, connect_v6_deny_prog_destroy, BPF_CGROUP_INET6_CONNECT, &kern_ops_sock_sendmsg, AF_INET6, SOCK_STREAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect6: kernel_connect (dgram)", connect_v6_prog_load, connect_v6_prog_destroy, BPF_CGROUP_INET6_CONNECT, &kern_ops_sock_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect6: kernel_connect deny (dgram)", connect_v6_deny_prog_load, connect_v6_deny_prog_destroy, BPF_CGROUP_INET6_CONNECT, &kern_ops_sock_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_CONNECT, "connect_unix: kernel_connect (dgram)", connect_unix_prog_load, connect_unix_prog_destroy, BPF_CGROUP_UNIX_CONNECT, &kern_ops_sock_sendmsg, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, { SOCK_ADDR_TEST_CONNECT, "connect_unix: kernel_connect deny (dgram)", connect_unix_deny_prog_load, connect_unix_deny_prog_destroy, BPF_CGROUP_UNIX_CONNECT, &kern_ops_sock_sendmsg, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SYSCALL_EPERM, }, /* sendmsg - system calls */ { SOCK_ADDR_TEST_SENDMSG, "sendmsg4: sendmsg (dgram)", sendmsg_v4_prog_load, sendmsg_v4_prog_destroy, BPF_CGROUP_UDP4_SENDMSG, &user_ops, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg4: sendmsg deny (dgram)", sendmsg_v4_deny_prog_load, sendmsg_v4_deny_prog_destroy, BPF_CGROUP_UDP4_SENDMSG, &user_ops, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg4: load prog with wrong expected attach type", sendmsg_v4_prog_load, sendmsg_v4_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &user_ops, AF_INET, SOCK_DGRAM, NULL, 0, NULL, 0, NULL, LOAD_REJECT, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg4: attach prog with wrong attach type", sendmsg_v4_prog_load_raw, sendmsg_v4_prog_destroy_raw, BPF_CGROUP_UDP6_SENDMSG, &user_ops, AF_INET, SOCK_DGRAM, NULL, 0, NULL, 0, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: sendmsg (dgram)", sendmsg_v6_prog_load, sendmsg_v6_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: sendmsg [::] (BSD'ism) (dgram)", sendmsg_v6_preserve_dst_prog_load, sendmsg_v6_preserve_dst_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &user_ops, AF_INET6, SOCK_DGRAM, WILDCARD6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_PORT, SRC6_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: sendmsg deny (dgram)", sendmsg_v6_deny_prog_load, sendmsg_v6_deny_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: sendmsg IPv4-mapped IPv6 (dgram)", sendmsg_v6_v4mapped_prog_load, sendmsg_v6_v4mapped_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SYSCALL_ENOTSUPP, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: sendmsg dst IP = [::] (BSD'ism) (dgram)", sendmsg_v6_wildcard_prog_load, sendmsg_v6_wildcard_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: load prog with wrong expected attach type", sendmsg_v6_prog_load, sendmsg_v6_prog_destroy, BPF_CGROUP_UDP4_SENDMSG, &user_ops, AF_INET6, SOCK_DGRAM, NULL, 0, NULL, 0, NULL, LOAD_REJECT, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: attach prog with wrong attach type", sendmsg_v6_prog_load_raw, sendmsg_v6_prog_destroy_raw, BPF_CGROUP_UDP4_SENDMSG, &user_ops, AF_INET6, SOCK_DGRAM, NULL, 0, NULL, 0, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg_unix: sendmsg (dgram)", sendmsg_unix_prog_load, sendmsg_unix_prog_destroy, BPF_CGROUP_UNIX_SENDMSG, &user_ops, AF_UNIX, SOCK_DGRAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg_unix: sendmsg deny (dgram)", sendmsg_unix_deny_prog_load, sendmsg_unix_deny_prog_destroy, BPF_CGROUP_UNIX_SENDMSG, &user_ops, AF_UNIX, SOCK_DGRAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg_unix: attach prog with wrong attach type", sendmsg_unix_prog_load_raw, sendmsg_unix_prog_destroy_raw, BPF_CGROUP_UDP4_SENDMSG, &user_ops, AF_UNIX, SOCK_DGRAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, ATTACH_REJECT, }, /* sendmsg - kernel calls (sock_sendmsg) */ { SOCK_ADDR_TEST_SENDMSG, "sendmsg4: sock_sendmsg (dgram)", sendmsg_v4_prog_load, sendmsg_v4_prog_destroy, BPF_CGROUP_UDP4_SENDMSG, &kern_ops_sock_sendmsg, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg4: sock_sendmsg deny (dgram)", sendmsg_v4_deny_prog_load, sendmsg_v4_deny_prog_destroy, BPF_CGROUP_UDP4_SENDMSG, &kern_ops_sock_sendmsg, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: sock_sendmsg (dgram)", sendmsg_v6_prog_load, sendmsg_v6_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &kern_ops_sock_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: sock_sendmsg [::] (BSD'ism) (dgram)", sendmsg_v6_preserve_dst_prog_load, sendmsg_v6_preserve_dst_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &kern_ops_sock_sendmsg, AF_INET6, SOCK_DGRAM, WILDCARD6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_PORT, SRC6_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: sock_sendmsg deny (dgram)", sendmsg_v6_deny_prog_load, sendmsg_v6_deny_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &kern_ops_sock_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg_unix: sock_sendmsg (dgram)", sendmsg_unix_prog_load, sendmsg_unix_prog_destroy, BPF_CGROUP_UNIX_SENDMSG, &kern_ops_sock_sendmsg, AF_UNIX, SOCK_DGRAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg_unix: sock_sendmsg deny (dgram)", sendmsg_unix_deny_prog_load, sendmsg_unix_deny_prog_destroy, BPF_CGROUP_UNIX_SENDMSG, &kern_ops_sock_sendmsg, AF_UNIX, SOCK_DGRAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SYSCALL_EPERM, }, /* sendmsg - kernel calls (kernel_sendmsg) */ { SOCK_ADDR_TEST_SENDMSG, "sendmsg4: kernel_sendmsg (dgram)", sendmsg_v4_prog_load, sendmsg_v4_prog_destroy, BPF_CGROUP_UDP4_SENDMSG, &kern_ops_kernel_sendmsg, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg4: kernel_sendmsg deny (dgram)", sendmsg_v4_deny_prog_load, sendmsg_v4_deny_prog_destroy, BPF_CGROUP_UDP4_SENDMSG, &kern_ops_kernel_sendmsg, AF_INET, SOCK_DGRAM, SERV4_IP, SERV4_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SRC4_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: kernel_sendmsg (dgram)", sendmsg_v6_prog_load, sendmsg_v6_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &kern_ops_kernel_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: kernel_sendmsg [::] (BSD'ism) (dgram)", sendmsg_v6_preserve_dst_prog_load, sendmsg_v6_preserve_dst_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &kern_ops_kernel_sendmsg, AF_INET6, SOCK_DGRAM, WILDCARD6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_PORT, SRC6_IP, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg6: kernel_sendmsg deny (dgram)", sendmsg_v6_deny_prog_load, sendmsg_v6_deny_prog_destroy, BPF_CGROUP_UDP6_SENDMSG, &kern_ops_kernel_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_IP, SERV6_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SRC6_REWRITE_IP, SYSCALL_EPERM, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg_unix: sock_sendmsg (dgram)", sendmsg_unix_prog_load, sendmsg_unix_prog_destroy, BPF_CGROUP_UNIX_SENDMSG, &kern_ops_kernel_sendmsg, AF_UNIX, SOCK_DGRAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, { SOCK_ADDR_TEST_SENDMSG, "sendmsg_unix: kernel_sendmsg deny (dgram)", sendmsg_unix_deny_prog_load, sendmsg_unix_deny_prog_destroy, BPF_CGROUP_UNIX_SENDMSG, &kern_ops_kernel_sendmsg, AF_UNIX, SOCK_DGRAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SYSCALL_EPERM, }, /* recvmsg - system calls */ { SOCK_ADDR_TEST_RECVMSG, "recvmsg4: recvfrom (dgram)", recvmsg4_prog_load, recvmsg4_prog_destroy, BPF_CGROUP_UDP4_RECVMSG, &user_ops, AF_INET, SOCK_DGRAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SUCCESS, }, { SOCK_ADDR_TEST_RECVMSG, "recvmsg4: attach prog with wrong attach type", recvmsg4_prog_load_raw, recvmsg4_prog_destroy_raw, BPF_CGROUP_UDP6_RECVMSG, &user_ops, AF_INET, SOCK_DGRAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, ATTACH_REJECT, }, { SOCK_ADDR_TEST_RECVMSG, "recvmsg6: recvfrom (dgram)", recvmsg6_prog_load, recvmsg6_prog_destroy, BPF_CGROUP_UDP6_RECVMSG, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SUCCESS, }, { SOCK_ADDR_TEST_RECVMSG, "recvmsg6: attach prog with wrong attach type", recvmsg6_prog_load_raw, recvmsg6_prog_destroy_raw, BPF_CGROUP_UDP4_RECVMSG, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, ATTACH_REJECT, }, { SOCK_ADDR_TEST_RECVMSG, "recvmsg_unix: recvfrom (dgram)", recvmsg_unix_prog_load, recvmsg_unix_prog_destroy, BPF_CGROUP_UNIX_RECVMSG, &user_ops, AF_UNIX, SOCK_DGRAM, SERVUN_REWRITE_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, SERVUN_ADDRESS, SUCCESS, }, { SOCK_ADDR_TEST_RECVMSG, "recvmsg_unix: recvfrom (stream)", recvmsg_unix_prog_load, recvmsg_unix_prog_destroy, BPF_CGROUP_UNIX_RECVMSG, &user_ops, AF_UNIX, SOCK_STREAM, SERVUN_REWRITE_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, SERVUN_ADDRESS, SUCCESS, }, { SOCK_ADDR_TEST_RECVMSG, "recvmsg_unix: attach prog with wrong attach type", recvmsg_unix_prog_load_raw, recvmsg_unix_prog_destroy_raw, BPF_CGROUP_UDP4_RECVMSG, &user_ops, AF_INET6, SOCK_STREAM, SERVUN_REWRITE_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, SERVUN_ADDRESS, ATTACH_REJECT, }, /* getsockname - system calls */ { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname4: getsockname (stream)", getsockname_v4_prog_load, getsockname_v4_prog_destroy, BPF_CGROUP_INET4_GETSOCKNAME, &user_ops, AF_INET, SOCK_STREAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname4: getsockname (dgram)", getsockname_v4_prog_load, getsockname_v4_prog_destroy, BPF_CGROUP_INET4_GETSOCKNAME, &user_ops, AF_INET, SOCK_DGRAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname4: attach prog with wrong attach type", getsockname_v4_prog_load_raw, getsockname_v4_prog_destroy_raw, BPF_CGROUP_INET6_GETSOCKNAME, &user_ops, AF_INET, SOCK_DGRAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname6: getsockname (stream)", getsockname_v6_prog_load, getsockname_v6_prog_destroy, BPF_CGROUP_INET6_GETSOCKNAME, &user_ops, AF_INET6, SOCK_STREAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname6: getsockname (dgram)", getsockname_v6_prog_load, getsockname_v6_prog_destroy, BPF_CGROUP_INET6_GETSOCKNAME, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname6: attach prog with wrong attach type", getsockname_v6_prog_load_raw, getsockname_v6_prog_destroy_raw, BPF_CGROUP_INET4_GETSOCKNAME, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname_unix: getsockname", getsockname_unix_prog_load, getsockname_unix_prog_destroy, BPF_CGROUP_UNIX_GETSOCKNAME, &user_ops, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname_unix: attach prog with wrong attach type", getsockname_unix_prog_load_raw, getsockname_unix_prog_destroy_raw, BPF_CGROUP_INET4_GETSOCKNAME, &user_ops, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, ATTACH_REJECT, }, /* getsockname - kernel calls */ { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname4: kernel_getsockname (stream)", getsockname_v4_prog_load, getsockname_v4_prog_destroy, BPF_CGROUP_INET4_GETSOCKNAME, &kern_ops_kernel_sendmsg, AF_INET, SOCK_STREAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname4: kernel_getsockname (dgram)", getsockname_v4_prog_load, getsockname_v4_prog_destroy, BPF_CGROUP_INET4_GETSOCKNAME, &kern_ops_kernel_sendmsg, AF_INET, SOCK_DGRAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname6: kernel_getsockname (stream)", getsockname_v6_prog_load, getsockname_v6_prog_destroy, BPF_CGROUP_INET6_GETSOCKNAME, &kern_ops_kernel_sendmsg, AF_INET6, SOCK_STREAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname6: kernel_getsockname (dgram)", getsockname_v6_prog_load, getsockname_v6_prog_destroy, BPF_CGROUP_INET6_GETSOCKNAME, &kern_ops_kernel_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETSOCKNAME, "getsockname_unix: kernel_getsockname", getsockname_unix_prog_load, getsockname_unix_prog_destroy, BPF_CGROUP_UNIX_GETSOCKNAME, &kern_ops_kernel_sendmsg, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, /* getpeername - system calls */ { SOCK_ADDR_TEST_GETPEERNAME, "getpeername4: getpeername (stream)", getpeername_v4_prog_load, getpeername_v4_prog_destroy, BPF_CGROUP_INET4_GETPEERNAME, &user_ops, AF_INET, SOCK_STREAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername4: getpeername (dgram)", getpeername_v4_prog_load, getpeername_v4_prog_destroy, BPF_CGROUP_INET4_GETPEERNAME, &user_ops, AF_INET, SOCK_DGRAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername4: attach prog with wrong attach type", getpeername_v4_prog_load_raw, getpeername_v4_prog_destroy_raw, BPF_CGROUP_INET6_GETSOCKNAME, &user_ops, AF_UNIX, SOCK_DGRAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername6: getpeername (stream)", getpeername_v6_prog_load, getpeername_v6_prog_destroy, BPF_CGROUP_INET6_GETPEERNAME, &user_ops, AF_INET6, SOCK_STREAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername6: getpeername (dgram)", getpeername_v6_prog_load, getpeername_v6_prog_destroy, BPF_CGROUP_INET6_GETPEERNAME, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername6: attach prog with wrong attach type", getpeername_v6_prog_load_raw, getpeername_v6_prog_destroy_raw, BPF_CGROUP_INET4_GETSOCKNAME, &user_ops, AF_INET6, SOCK_DGRAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, ATTACH_REJECT, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername_unix: getpeername", getpeername_unix_prog_load, getpeername_unix_prog_destroy, BPF_CGROUP_UNIX_GETPEERNAME, &user_ops, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername_unix: attach prog with wrong attach type", getpeername_unix_prog_load_raw, getpeername_unix_prog_destroy_raw, BPF_CGROUP_INET4_GETSOCKNAME, &user_ops, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, ATTACH_REJECT, }, /* getpeername - kernel calls */ { SOCK_ADDR_TEST_GETPEERNAME, "getpeername4: kernel_getpeername (stream)", getpeername_v4_prog_load, getpeername_v4_prog_destroy, BPF_CGROUP_INET4_GETPEERNAME, &kern_ops_kernel_sendmsg, AF_INET, SOCK_STREAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername4: kernel_getpeername (dgram)", getpeername_v4_prog_load, getpeername_v4_prog_destroy, BPF_CGROUP_INET4_GETPEERNAME, &kern_ops_kernel_sendmsg, AF_INET, SOCK_DGRAM, SERV4_REWRITE_IP, SERV4_REWRITE_PORT, SERV4_IP, SERV4_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername6: kernel_getpeername (stream)", getpeername_v6_prog_load, getpeername_v6_prog_destroy, BPF_CGROUP_INET6_GETPEERNAME, &kern_ops_kernel_sendmsg, AF_INET6, SOCK_STREAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername6: kernel_getpeername (dgram)", getpeername_v6_prog_load, getpeername_v6_prog_destroy, BPF_CGROUP_INET6_GETPEERNAME, &kern_ops_kernel_sendmsg, AF_INET6, SOCK_DGRAM, SERV6_REWRITE_IP, SERV6_REWRITE_PORT, SERV6_IP, SERV6_PORT, NULL, SUCCESS, }, { SOCK_ADDR_TEST_GETPEERNAME, "getpeername_unix: kernel_getpeername", getpeername_unix_prog_load, getpeername_unix_prog_destroy, BPF_CGROUP_UNIX_GETPEERNAME, &kern_ops_kernel_sendmsg, AF_UNIX, SOCK_STREAM, SERVUN_ADDRESS, 0, SERVUN_REWRITE_ADDRESS, 0, NULL, SUCCESS, }, }; typedef int (*info_fn)(int, struct sockaddr *, socklen_t *); static int cmp_addr(const struct sockaddr_storage *addr1, socklen_t addr1_len, const struct sockaddr_storage *addr2, socklen_t addr2_len, bool cmp_port) { const struct sockaddr_in *four1, *four2; const struct sockaddr_in6 *six1, *six2; const struct sockaddr_un *un1, *un2; if (addr1->ss_family != addr2->ss_family) return -1; if (addr1_len != addr2_len) return -1; if (addr1->ss_family == AF_INET) { four1 = (const struct sockaddr_in *)addr1; four2 = (const struct sockaddr_in *)addr2; return !((four1->sin_port == four2->sin_port || !cmp_port) && four1->sin_addr.s_addr == four2->sin_addr.s_addr); } else if (addr1->ss_family == AF_INET6) { six1 = (const struct sockaddr_in6 *)addr1; six2 = (const struct sockaddr_in6 *)addr2; return !((six1->sin6_port == six2->sin6_port || !cmp_port) && !memcmp(&six1->sin6_addr, &six2->sin6_addr, sizeof(struct in6_addr))); } else if (addr1->ss_family == AF_UNIX) { un1 = (const struct sockaddr_un *)addr1; un2 = (const struct sockaddr_un *)addr2; return memcmp(un1, un2, addr1_len); } return -1; } static int cmp_sock_addr(info_fn fn, int sock1, const struct sockaddr_storage *addr2, socklen_t addr2_len, bool cmp_port) { struct sockaddr_storage addr1; socklen_t len1 = sizeof(addr1); memset(&addr1, 0, len1); if (fn(sock1, (struct sockaddr *)&addr1, (socklen_t *)&len1) != 0) return -1; return cmp_addr(&addr1, len1, addr2, addr2_len, cmp_port); } static int load_sock_addr_kern(void) { int err; skel = sock_addr_kern__open_and_load(); if (!ASSERT_OK_PTR(skel, "skel")) goto err; err = 0; goto out; err: err = -1; out: return err; } static void unload_sock_addr_kern(void) { sock_addr_kern__destroy(skel); } static int test_bind(struct sock_addr_test *test) { struct sockaddr_storage expected_addr; socklen_t expected_addr_len = sizeof(struct sockaddr_storage); int serv = -1, client = -1, err; serv = test->ops->start_server(test->socket_family, test->socket_type, test->requested_addr, test->requested_port, 0); if (serv < 0) { err = errno; goto err; } err = make_sockaddr(test->socket_family, test->expected_addr, test->expected_port, &expected_addr, &expected_addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; err = cmp_sock_addr(test->ops->getsockname, serv, &expected_addr, expected_addr_len, true); if (!ASSERT_EQ(err, 0, "cmp_local_addr")) goto cleanup; /* Try to connect to server just in case */ client = connect_to_addr(test->socket_type, &expected_addr, expected_addr_len, NULL); if (!ASSERT_GE(client, 0, "connect_to_addr")) goto cleanup; cleanup: err = 0; err: if (client != -1) close(client); if (serv != -1) test->ops->close(serv); return err; } static int test_connect(struct sock_addr_test *test) { struct sockaddr_storage addr, expected_addr, expected_src_addr; socklen_t addr_len = sizeof(struct sockaddr_storage), expected_addr_len = sizeof(struct sockaddr_storage), expected_src_addr_len = sizeof(struct sockaddr_storage); int serv = -1, client = -1, err; serv = start_server(test->socket_family, test->socket_type, test->expected_addr, test->expected_port, 0); if (!ASSERT_GE(serv, 0, "start_server")) goto cleanup; err = make_sockaddr(test->socket_family, test->requested_addr, test->requested_port, &addr, &addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; client = test->ops->connect_to_addr(test->socket_type, &addr, addr_len, NULL); if (client < 0) { err = errno; goto err; } err = make_sockaddr(test->socket_family, test->expected_addr, test->expected_port, &expected_addr, &expected_addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; if (test->expected_src_addr) { err = make_sockaddr(test->socket_family, test->expected_src_addr, 0, &expected_src_addr, &expected_src_addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; } err = cmp_sock_addr(test->ops->getpeername, client, &expected_addr, expected_addr_len, true); if (!ASSERT_EQ(err, 0, "cmp_peer_addr")) goto cleanup; if (test->expected_src_addr) { err = cmp_sock_addr(test->ops->getsockname, client, &expected_src_addr, expected_src_addr_len, false); if (!ASSERT_EQ(err, 0, "cmp_local_addr")) goto cleanup; } cleanup: err = 0; err: if (client != -1) test->ops->close(client); if (serv != -1) close(serv); return err; } static int test_xmsg(struct sock_addr_test *test) { struct sockaddr_storage addr, src_addr; socklen_t addr_len = sizeof(struct sockaddr_storage), src_addr_len = sizeof(struct sockaddr_storage); char data = 'a'; int serv = -1, client = -1, err; /* Unlike the other tests, here we test that we can rewrite the src addr * with a recvmsg() hook. */ serv = start_server(test->socket_family, test->socket_type, test->expected_addr, test->expected_port, 0); if (!ASSERT_GE(serv, 0, "start_server")) goto cleanup; client = test->ops->socket(test->socket_family, test->socket_type, 0); if (!ASSERT_GE(client, 0, "socket")) goto cleanup; /* AF_UNIX sockets have to be bound to something to trigger the recvmsg bpf program. */ if (test->socket_family == AF_UNIX) { err = make_sockaddr(AF_UNIX, SRCUN_ADDRESS, 0, &src_addr, &src_addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; err = test->ops->bind(client, (struct sockaddr *)&src_addr, src_addr_len); if (!ASSERT_OK(err, "bind")) goto cleanup; } err = make_sockaddr(test->socket_family, test->requested_addr, test->requested_port, &addr, &addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; if (test->socket_type == SOCK_DGRAM) { err = test->ops->sendmsg(client, (struct sockaddr *)&addr, addr_len, &data, sizeof(data)); if (err < 0) { err = errno; goto err; } if (!ASSERT_EQ(err, sizeof(data), "sendmsg")) goto cleanup; } else { /* Testing with connection-oriented sockets is only valid for * recvmsg() tests. */ if (!ASSERT_EQ(test->type, SOCK_ADDR_TEST_RECVMSG, "recvmsg")) goto cleanup; err = connect(client, (const struct sockaddr *)&addr, addr_len); if (!ASSERT_OK(err, "connect")) goto cleanup; err = send(client, &data, sizeof(data), 0); if (!ASSERT_EQ(err, sizeof(data), "send")) goto cleanup; err = listen(serv, 0); if (!ASSERT_OK(err, "listen")) goto cleanup; err = accept(serv, NULL, NULL); if (!ASSERT_GE(err, 0, "accept")) goto cleanup; close(serv); serv = err; } addr_len = src_addr_len = sizeof(struct sockaddr_storage); err = recvfrom(serv, &data, sizeof(data), 0, (struct sockaddr *) &src_addr, &src_addr_len); if (!ASSERT_EQ(err, sizeof(data), "recvfrom")) goto cleanup; ASSERT_EQ(data, 'a', "data mismatch"); if (test->expected_src_addr) { err = make_sockaddr(test->socket_family, test->expected_src_addr, 0, &addr, &addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; err = cmp_addr(&src_addr, src_addr_len, &addr, addr_len, false); if (!ASSERT_EQ(err, 0, "cmp_addr")) goto cleanup; } cleanup: err = 0; err: if (client != -1) test->ops->close(client); if (serv != -1) close(serv); return err; } static int test_getsockname(struct sock_addr_test *test) { struct sockaddr_storage expected_addr; socklen_t expected_addr_len = sizeof(struct sockaddr_storage); int serv = -1, err; serv = test->ops->start_server(test->socket_family, test->socket_type, test->requested_addr, test->requested_port, 0); if (!ASSERT_GE(serv, 0, "start_server")) goto cleanup; err = make_sockaddr(test->socket_family, test->expected_addr, test->expected_port, &expected_addr, &expected_addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; err = cmp_sock_addr(test->ops->getsockname, serv, &expected_addr, expected_addr_len, true); if (!ASSERT_EQ(err, 0, "cmp_local_addr")) goto cleanup; cleanup: if (serv != -1) test->ops->close(serv); return 0; } static int test_getpeername(struct sock_addr_test *test) { struct sockaddr_storage addr, expected_addr; socklen_t addr_len = sizeof(struct sockaddr_storage), expected_addr_len = sizeof(struct sockaddr_storage); int serv = -1, client = -1, err; serv = start_server(test->socket_family, test->socket_type, test->requested_addr, test->requested_port, 0); if (!ASSERT_GE(serv, 0, "start_server")) goto cleanup; err = make_sockaddr(test->socket_family, test->requested_addr, test->requested_port, &addr, &addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; client = test->ops->connect_to_addr(test->socket_type, &addr, addr_len, NULL); if (!ASSERT_GE(client, 0, "connect_to_addr")) goto cleanup; err = make_sockaddr(test->socket_family, test->expected_addr, test->expected_port, &expected_addr, &expected_addr_len); if (!ASSERT_EQ(err, 0, "make_sockaddr")) goto cleanup; err = cmp_sock_addr(test->ops->getpeername, client, &expected_addr, expected_addr_len, true); if (!ASSERT_EQ(err, 0, "cmp_peer_addr")) goto cleanup; cleanup: if (client != -1) test->ops->close(client); if (serv != -1) close(serv); return 0; } static int setup_test_env(struct nstoken **tok) { int err; SYS_NOFAIL("ip netns delete %s", TEST_NS); SYS(fail, "ip netns add %s", TEST_NS); *tok = open_netns(TEST_NS); if (!ASSERT_OK_PTR(*tok, "netns token")) goto fail; SYS(fail, "ip link add dev %s1 type veth peer name %s2", TEST_IF_PREFIX, TEST_IF_PREFIX); SYS(fail, "ip link set lo up"); SYS(fail, "ip link set %s1 up", TEST_IF_PREFIX); SYS(fail, "ip link set %s2 up", TEST_IF_PREFIX); SYS(fail, "ip -4 addr add %s/8 dev %s1", TEST_IPV4, TEST_IF_PREFIX); SYS(fail, "ip -6 addr add %s/128 nodad dev %s1", TEST_IPV6, TEST_IF_PREFIX); err = 0; goto out; fail: err = -1; close_netns(*tok); *tok = NULL; SYS_NOFAIL("ip netns delete %s", TEST_NS); out: return err; } static void cleanup_test_env(struct nstoken *tok) { close_netns(tok); SYS_NOFAIL("ip netns delete %s", TEST_NS); } void test_sock_addr(void) { struct nstoken *tok = NULL; int cgroup_fd = -1; void *skel; cgroup_fd = test__join_cgroup("/sock_addr"); if (!ASSERT_GE(cgroup_fd, 0, "join_cgroup")) goto cleanup; if (!ASSERT_OK(setup_test_env(&tok), "setup_test_env")) goto cleanup; if (!ASSERT_OK(load_sock_addr_kern(), "load_sock_addr_kern")) goto cleanup; for (size_t i = 0; i < ARRAY_SIZE(tests); ++i) { struct sock_addr_test *test = &tests[i]; int err; if (!test__start_subtest(test->name)) continue; skel = test->loadfn(cgroup_fd, test->attach_type, test->expected_result == LOAD_REJECT || test->expected_result == ATTACH_REJECT); if (!skel) continue; switch (test->type) { /* Not exercised yet but we leave this code here for when the * INET and INET6 sockaddr tests are migrated to this file in * the future. */ case SOCK_ADDR_TEST_BIND: err = test_bind(test); break; case SOCK_ADDR_TEST_CONNECT: err = test_connect(test); break; case SOCK_ADDR_TEST_SENDMSG: case SOCK_ADDR_TEST_RECVMSG: err = test_xmsg(test); break; case SOCK_ADDR_TEST_GETSOCKNAME: err = test_getsockname(test); break; case SOCK_ADDR_TEST_GETPEERNAME: err = test_getpeername(test); break; default: ASSERT_TRUE(false, "Unknown sock addr test type"); break; } if (test->expected_result == SYSCALL_EPERM) ASSERT_EQ(err, EPERM, "socket operation returns EPERM"); else if (test->expected_result == SYSCALL_ENOTSUPP) ASSERT_EQ(err, ENOTSUPP, "socket operation returns ENOTSUPP"); else if (test->expected_result == SUCCESS) ASSERT_OK(err, "socket operation succeeds"); test->destroyfn(skel); } cleanup: unload_sock_addr_kern(); cleanup_test_env(tok); if (cgroup_fd >= 0) close(cgroup_fd); }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1