1 // SPDX-License-Identifier: GPL-2.0 2 #include <sys/un.h> 3 4 #include "test_progs.h" 5 6 #include "sock_addr_kern.skel.h" 7 #include "bind4_prog.skel.h" 8 #include "bind6_prog.skel.h" 9 #include "connect_unix_prog.skel.h" 10 #include "connect4_prog.skel.h" 11 #include "connect6_prog.skel.h" 12 #include "sendmsg4_prog.skel.h" 13 #include "sendmsg6_prog.skel.h" 14 #include "recvmsg4_prog.skel.h" 15 #include "recvmsg6_prog.skel.h" 16 #include "sendmsg_unix_prog.skel.h" 17 #include "recvmsg_unix_prog.skel.h" 18 #include "getsockname4_prog.skel.h" 19 #include "getsockname6_prog.skel.h" 20 #include "getsockname_unix_prog.skel.h" 21 #include "getpeername4_prog.skel.h" 22 #include "getpeername6_prog.skel.h" 23 #include "getpeername_unix_prog.skel.h" 24 #include "network_helpers.h" 25 26 #ifndef ENOTSUPP 27 # define ENOTSUPP 524 28 #endif 29 30 #define TEST_NS "sock_addr" 31 #define TEST_IF_PREFIX "test_sock_addr" 32 #define TEST_IPV4 "127.0.0.4" 33 #define TEST_IPV6 "::6" 34 35 #define SERV4_IP "192.168.1.254" 36 #define SERV4_REWRITE_IP "127.0.0.1" 37 #define SRC4_IP "172.16.0.1" 38 #define SRC4_REWRITE_IP TEST_IPV4 39 #define SERV4_PORT 4040 40 #define SERV4_REWRITE_PORT 4444 41 42 #define SERV6_IP "face:b00c:1234:5678::abcd" 43 #define SERV6_REWRITE_IP "::1" 44 #define SERV6_V4MAPPED_IP "::ffff:192.168.0.4" 45 #define SRC6_IP "::1" 46 #define SRC6_REWRITE_IP TEST_IPV6 47 #define WILDCARD6_IP "::" 48 #define SERV6_PORT 6060 49 #define SERV6_REWRITE_PORT 6666 50 51 #define SERVUN_ADDRESS "bpf_cgroup_unix_test" 52 #define SERVUN_REWRITE_ADDRESS "bpf_cgroup_unix_test_rewrite" 53 #define SRCUN_ADDRESS "bpf_cgroup_unix_test_src" 54 55 #define save_errno_do(op) ({ int __save = errno; op; errno = __save; }) 56 57 enum sock_addr_test_type { 58 SOCK_ADDR_TEST_BIND, 59 SOCK_ADDR_TEST_CONNECT, 60 SOCK_ADDR_TEST_SENDMSG, 61 SOCK_ADDR_TEST_RECVMSG, 62 SOCK_ADDR_TEST_GETSOCKNAME, 63 SOCK_ADDR_TEST_GETPEERNAME, 64 }; 65 66 typedef void *(*load_fn)(int cgroup_fd, 67 enum bpf_attach_type attach_type, 68 bool expect_reject); 69 typedef void (*destroy_fn)(void *skel); 70 71 static int cmp_addr(const struct sockaddr_storage *addr1, socklen_t addr1_len, 72 const struct sockaddr_storage *addr2, socklen_t addr2_len, 73 bool cmp_port); 74 75 struct init_sock_args { 76 int af; 77 int type; 78 }; 79 80 struct addr_args { 81 char addr[sizeof(struct sockaddr_storage)]; 82 int addrlen; 83 }; 84 85 struct sendmsg_args { 86 struct addr_args addr; 87 char msg[10]; 88 int msglen; 89 }; 90 91 static struct sock_addr_kern *skel; 92 93 static int run_bpf_prog(const char *prog_name, void *ctx, int ctx_size) 94 { 95 LIBBPF_OPTS(bpf_test_run_opts, topts); 96 struct bpf_program *prog; 97 int prog_fd, err; 98 99 topts.ctx_in = ctx; 100 topts.ctx_size_in = ctx_size; 101 102 prog = bpf_object__find_program_by_name(skel->obj, prog_name); 103 if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name")) 104 goto err; 105 106 prog_fd = bpf_program__fd(prog); 107 err = bpf_prog_test_run_opts(prog_fd, &topts); 108 if (!ASSERT_OK(err, prog_name)) 109 goto err; 110 111 err = topts.retval; 112 errno = -topts.retval; 113 goto out; 114 err: 115 err = -1; 116 out: 117 return err; 118 } 119 120 static int kernel_init_sock(int af, int type, int protocol) 121 { 122 struct init_sock_args args = { 123 .af = af, 124 .type = type, 125 }; 126 127 return run_bpf_prog("init_sock", &args, sizeof(args)); 128 } 129 130 static int kernel_close_sock(int fd) 131 { 132 return run_bpf_prog("close_sock", NULL, 0); 133 } 134 135 static int sock_addr_op(const char *name, struct sockaddr *addr, 136 socklen_t *addrlen, bool expect_change) 137 { 138 struct addr_args args; 139 int err; 140 141 if (addrlen) 142 args.addrlen = *addrlen; 143 144 if (addr) 145 memcpy(&args.addr, addr, *addrlen); 146 147 err = run_bpf_prog(name, &args, sizeof(args)); 148 149 if (!expect_change && addr) 150 if (!ASSERT_EQ(cmp_addr((struct sockaddr_storage *)addr, 151 *addrlen, 152 (struct sockaddr_storage *)&args.addr, 153 args.addrlen, 1), 154 0, "address_param_modified")) 155 return -1; 156 157 if (addrlen) 158 *addrlen = args.addrlen; 159 160 if (addr) 161 memcpy(addr, &args.addr, *addrlen); 162 163 return err; 164 } 165 166 static int send_msg_op(const char *name, struct sockaddr *addr, 167 socklen_t addrlen, const char *msg, int msglen) 168 { 169 struct sendmsg_args args; 170 int err; 171 172 memset(&args, 0, sizeof(args)); 173 memcpy(&args.addr.addr, addr, addrlen); 174 args.addr.addrlen = addrlen; 175 memcpy(args.msg, msg, msglen); 176 args.msglen = msglen; 177 178 err = run_bpf_prog(name, &args, sizeof(args)); 179 180 if (!ASSERT_EQ(cmp_addr((struct sockaddr_storage *)addr, 181 addrlen, 182 (struct sockaddr_storage *)&args.addr.addr, 183 args.addr.addrlen, 1), 184 0, "address_param_modified")) 185 return -1; 186 187 return err; 188 } 189 190 static int kernel_connect(struct sockaddr *addr, socklen_t addrlen) 191 { 192 return sock_addr_op("kernel_connect", addr, &addrlen, false); 193 } 194 195 static int kernel_bind(int fd, struct sockaddr *addr, socklen_t addrlen) 196 { 197 return sock_addr_op("kernel_bind", addr, &addrlen, false); 198 } 199 200 static int kernel_listen(void) 201 { 202 return sock_addr_op("kernel_listen", NULL, NULL, false); 203 } 204 205 static int kernel_sendmsg(int fd, struct sockaddr *addr, socklen_t addrlen, 206 char *msg, int msglen) 207 { 208 return send_msg_op("kernel_sendmsg", addr, addrlen, msg, msglen); 209 } 210 211 static int sock_sendmsg(int fd, struct sockaddr *addr, socklen_t addrlen, 212 char *msg, int msglen) 213 { 214 return send_msg_op("sock_sendmsg", addr, addrlen, msg, msglen); 215 } 216 217 static int kernel_getsockname(int fd, struct sockaddr *addr, socklen_t *addrlen) 218 { 219 return sock_addr_op("kernel_getsockname", addr, addrlen, true); 220 } 221 222 static int kernel_getpeername(int fd, struct sockaddr *addr, socklen_t *addrlen) 223 { 224 return sock_addr_op("kernel_getpeername", addr, addrlen, true); 225 } 226 227 int kernel_connect_to_addr(int type, const struct sockaddr_storage *addr, socklen_t addrlen, 228 const struct network_helper_opts *opts) 229 { 230 int err; 231 232 if (!ASSERT_OK(kernel_init_sock(addr->ss_family, type, 0), 233 "kernel_init_sock")) 234 goto err; 235 236 if (kernel_connect((struct sockaddr *)addr, addrlen) < 0) 237 goto err; 238 239 /* Test code expects a "file descriptor" on success. */ 240 err = 1; 241 goto out; 242 err: 243 err = -1; 244 save_errno_do(ASSERT_OK(kernel_close_sock(0), "kernel_close_sock")); 245 out: 246 return err; 247 } 248 249 int kernel_start_server(int family, int type, const char *addr_str, __u16 port, 250 int timeout_ms) 251 { 252 struct sockaddr_storage addr; 253 socklen_t addrlen; 254 int err; 255 256 if (!ASSERT_OK(kernel_init_sock(family, type, 0), "kernel_init_sock")) 257 goto err; 258 259 if (make_sockaddr(family, addr_str, port, &addr, &addrlen)) 260 goto err; 261 262 if (kernel_bind(0, (struct sockaddr *)&addr, addrlen) < 0) 263 goto err; 264 265 if (type == SOCK_STREAM) { 266 if (!ASSERT_OK(kernel_listen(), "kernel_listen")) 267 goto err; 268 } 269 270 /* Test code expects a "file descriptor" on success. */ 271 err = 1; 272 goto out; 273 err: 274 err = -1; 275 save_errno_do(ASSERT_OK(kernel_close_sock(0), "kernel_close_sock")); 276 out: 277 return err; 278 } 279 280 struct sock_ops { 281 int (*connect_to_addr)(int type, const struct sockaddr_storage *addr, 282 socklen_t addrlen, 283 const struct network_helper_opts *opts); 284 int (*start_server)(int family, int type, const char *addr_str, 285 __u16 port, int timeout_ms); 286 int (*socket)(int famil, int type, int protocol); 287 int (*bind)(int fd, struct sockaddr *addr, socklen_t addrlen); 288 int (*getsockname)(int fd, struct sockaddr *addr, socklen_t *addrlen); 289 int (*getpeername)(int fd, struct sockaddr *addr, socklen_t *addrlen); 290 int (*sendmsg)(int fd, struct sockaddr *addr, socklen_t addrlen, 291 char *msg, int msglen); 292 int (*close)(int fd); 293 }; 294 295 static int user_sendmsg(int fd, struct sockaddr *addr, socklen_t addrlen, 296 char *msg, int msglen) 297 { 298 struct msghdr hdr; 299 struct iovec iov; 300 301 memset(&iov, 0, sizeof(iov)); 302 iov.iov_base = msg; 303 iov.iov_len = msglen; 304 305 memset(&hdr, 0, sizeof(hdr)); 306 hdr.msg_name = (void *)addr; 307 hdr.msg_namelen = addrlen; 308 hdr.msg_iov = &iov; 309 hdr.msg_iovlen = 1; 310 311 return sendmsg(fd, &hdr, 0); 312 } 313 314 static int user_bind(int fd, struct sockaddr *addr, socklen_t addrlen) 315 { 316 return bind(fd, (const struct sockaddr *)addr, addrlen); 317 } 318 319 struct sock_ops user_ops = { 320 .connect_to_addr = connect_to_addr, 321 .start_server = start_server, 322 .socket = socket, 323 .bind = user_bind, 324 .getsockname = getsockname, 325 .getpeername = getpeername, 326 .sendmsg = user_sendmsg, 327 .close = close, 328 }; 329 330 struct sock_ops kern_ops_sock_sendmsg = { 331 .connect_to_addr = kernel_connect_to_addr, 332 .start_server = kernel_start_server, 333 .socket = kernel_init_sock, 334 .bind = kernel_bind, 335 .getsockname = kernel_getsockname, 336 .getpeername = kernel_getpeername, 337 .sendmsg = sock_sendmsg, 338 .close = kernel_close_sock, 339 }; 340 341 struct sock_ops kern_ops_kernel_sendmsg = { 342 .connect_to_addr = kernel_connect_to_addr, 343 .start_server = kernel_start_server, 344 .socket = kernel_init_sock, 345 .bind = kernel_bind, 346 .getsockname = kernel_getsockname, 347 .getpeername = kernel_getpeername, 348 .sendmsg = kernel_sendmsg, 349 .close = kernel_close_sock, 350 }; 351 352 struct sock_addr_test { 353 enum sock_addr_test_type type; 354 const char *name; 355 /* BPF prog properties */ 356 load_fn loadfn; 357 destroy_fn destroyfn; 358 enum bpf_attach_type attach_type; 359 /* Socket operations */ 360 struct sock_ops *ops; 361 /* Socket properties */ 362 int socket_family; 363 int socket_type; 364 /* IP:port pairs for BPF prog to override */ 365 const char *requested_addr; 366 unsigned short requested_port; 367 const char *expected_addr; 368 unsigned short expected_port; 369 const char *expected_src_addr; 370 /* Expected test result */ 371 enum { 372 LOAD_REJECT, 373 ATTACH_REJECT, 374 SYSCALL_EPERM, 375 SYSCALL_ENOTSUPP, 376 SUCCESS, 377 } expected_result; 378 }; 379 380 #define BPF_SKEL_FUNCS_RAW(skel_name, prog_name) \ 381 static void *prog_name##_load_raw(int cgroup_fd, \ 382 enum bpf_attach_type attach_type, \ 383 bool expect_reject) \ 384 { \ 385 struct skel_name *skel = skel_name##__open(); \ 386 int prog_fd = -1; \ 387 if (!ASSERT_OK_PTR(skel, "skel_open")) \ 388 goto cleanup; \ 389 if (!ASSERT_OK(skel_name##__load(skel), "load")) \ 390 goto cleanup; \ 391 prog_fd = bpf_program__fd(skel->progs.prog_name); \ 392 if (!ASSERT_GT(prog_fd, 0, "prog_fd")) \ 393 goto cleanup; \ 394 if (bpf_prog_attach(prog_fd, cgroup_fd, attach_type, \ 395 BPF_F_ALLOW_OVERRIDE), "bpf_prog_attach") { \ 396 ASSERT_TRUE(expect_reject, "unexpected rejection"); \ 397 goto cleanup; \ 398 } \ 399 if (!ASSERT_FALSE(expect_reject, "expected rejection")) \ 400 goto cleanup; \ 401 cleanup: \ 402 if (prog_fd > 0) \ 403 bpf_prog_detach(cgroup_fd, attach_type); \ 404 skel_name##__destroy(skel); \ 405 return NULL; \ 406 } \ 407 static void prog_name##_destroy_raw(void *progfd) \ 408 { \ 409 /* No-op. *_load_raw does all cleanup. */ \ 410 } \ 411 412 #define BPF_SKEL_FUNCS(skel_name, prog_name) \ 413 static void *prog_name##_load(int cgroup_fd, \ 414 enum bpf_attach_type attach_type, \ 415 bool expect_reject) \ 416 { \ 417 struct skel_name *skel = skel_name##__open(); \ 418 if (!ASSERT_OK_PTR(skel, "skel_open")) \ 419 goto cleanup; \ 420 if (!ASSERT_OK(bpf_program__set_expected_attach_type(skel->progs.prog_name, \ 421 attach_type), \ 422 "set_expected_attach_type")) \ 423 goto cleanup; \ 424 if (skel_name##__load(skel)) { \ 425 ASSERT_TRUE(expect_reject, "unexpected rejection"); \ 426 goto cleanup; \ 427 } \ 428 if (!ASSERT_FALSE(expect_reject, "expected rejection")) \ 429 goto cleanup; \ 430 skel->links.prog_name = bpf_program__attach_cgroup( \ 431 skel->progs.prog_name, cgroup_fd); \ 432 if (!ASSERT_OK_PTR(skel->links.prog_name, "prog_attach")) \ 433 goto cleanup; \ 434 return skel; \ 435 cleanup: \ 436 skel_name##__destroy(skel); \ 437 return NULL; \ 438 } \ 439 static void prog_name##_destroy(void *skel) \ 440 { \ 441 skel_name##__destroy(skel); \ 442 } 443 444 BPF_SKEL_FUNCS(bind4_prog, bind_v4_prog); 445 BPF_SKEL_FUNCS_RAW(bind4_prog, bind_v4_prog); 446 BPF_SKEL_FUNCS(bind4_prog, bind_v4_deny_prog); 447 BPF_SKEL_FUNCS(bind6_prog, bind_v6_prog); 448 BPF_SKEL_FUNCS_RAW(bind6_prog, bind_v6_prog); 449 BPF_SKEL_FUNCS(bind6_prog, bind_v6_deny_prog); 450 BPF_SKEL_FUNCS(connect4_prog, connect_v4_prog); 451 BPF_SKEL_FUNCS_RAW(connect4_prog, connect_v4_prog); 452 BPF_SKEL_FUNCS(connect4_prog, connect_v4_deny_prog); 453 BPF_SKEL_FUNCS(connect6_prog, connect_v6_prog); 454 BPF_SKEL_FUNCS_RAW(connect6_prog, connect_v6_prog); 455 BPF_SKEL_FUNCS(connect6_prog, connect_v6_deny_prog); 456 BPF_SKEL_FUNCS(connect_unix_prog, connect_unix_prog); 457 BPF_SKEL_FUNCS_RAW(connect_unix_prog, connect_unix_prog); 458 BPF_SKEL_FUNCS(connect_unix_prog, connect_unix_deny_prog); 459 BPF_SKEL_FUNCS(sendmsg4_prog, sendmsg_v4_prog); 460 BPF_SKEL_FUNCS_RAW(sendmsg4_prog, sendmsg_v4_prog); 461 BPF_SKEL_FUNCS(sendmsg4_prog, sendmsg_v4_deny_prog); 462 BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_prog); 463 BPF_SKEL_FUNCS_RAW(sendmsg6_prog, sendmsg_v6_prog); 464 BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_deny_prog); 465 BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_preserve_dst_prog); 466 BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_v4mapped_prog); 467 BPF_SKEL_FUNCS(sendmsg6_prog, sendmsg_v6_wildcard_prog); 468 BPF_SKEL_FUNCS(sendmsg_unix_prog, sendmsg_unix_prog); 469 BPF_SKEL_FUNCS_RAW(sendmsg_unix_prog, sendmsg_unix_prog); 470 BPF_SKEL_FUNCS(sendmsg_unix_prog, sendmsg_unix_deny_prog); 471 BPF_SKEL_FUNCS(recvmsg4_prog, recvmsg4_prog); 472 BPF_SKEL_FUNCS_RAW(recvmsg4_prog, recvmsg4_prog); 473 BPF_SKEL_FUNCS(recvmsg6_prog, recvmsg6_prog); 474 BPF_SKEL_FUNCS_RAW(recvmsg6_prog, recvmsg6_prog); 475 BPF_SKEL_FUNCS(recvmsg_unix_prog, recvmsg_unix_prog); 476 BPF_SKEL_FUNCS_RAW(recvmsg_unix_prog, recvmsg_unix_prog); 477 BPF_SKEL_FUNCS(getsockname_unix_prog, getsockname_unix_prog); 478 BPF_SKEL_FUNCS_RAW(getsockname_unix_prog, getsockname_unix_prog); 479 BPF_SKEL_FUNCS(getsockname4_prog, getsockname_v4_prog); 480 BPF_SKEL_FUNCS_RAW(getsockname4_prog, getsockname_v4_prog); 481 BPF_SKEL_FUNCS(getsockname6_prog, getsockname_v6_prog); 482 BPF_SKEL_FUNCS_RAW(getsockname6_prog, getsockname_v6_prog); 483 BPF_SKEL_FUNCS(getpeername_unix_prog, getpeername_unix_prog); 484 BPF_SKEL_FUNCS_RAW(getpeername_unix_prog, getpeername_unix_prog); 485 BPF_SKEL_FUNCS(getpeername4_prog, getpeername_v4_prog); 486 BPF_SKEL_FUNCS_RAW(getpeername4_prog, getpeername_v4_prog); 487 BPF_SKEL_FUNCS(getpeername6_prog, getpeername_v6_prog); 488 BPF_SKEL_FUNCS_RAW(getpeername6_prog, getpeername_v6_prog); 489 490 static struct sock_addr_test tests[] = { 491 /* bind - system calls */ 492 { 493 SOCK_ADDR_TEST_BIND, 494 "bind4: bind (stream)", 495 bind_v4_prog_load, 496 bind_v4_prog_destroy, 497 BPF_CGROUP_INET4_BIND, 498 &user_ops, 499 AF_INET, 500 SOCK_STREAM, 501 SERV4_IP, 502 SERV4_PORT, 503 SERV4_REWRITE_IP, 504 SERV4_REWRITE_PORT, 505 NULL, 506 SUCCESS, 507 }, 508 { 509 SOCK_ADDR_TEST_BIND, 510 "bind4: bind deny (stream)", 511 bind_v4_deny_prog_load, 512 bind_v4_deny_prog_destroy, 513 BPF_CGROUP_INET4_BIND, 514 &user_ops, 515 AF_INET, 516 SOCK_STREAM, 517 SERV4_IP, 518 SERV4_PORT, 519 SERV4_REWRITE_IP, 520 SERV4_REWRITE_PORT, 521 NULL, 522 SYSCALL_EPERM, 523 }, 524 { 525 SOCK_ADDR_TEST_BIND, 526 "bind4: bind (dgram)", 527 bind_v4_prog_load, 528 bind_v4_prog_destroy, 529 BPF_CGROUP_INET4_BIND, 530 &user_ops, 531 AF_INET, 532 SOCK_DGRAM, 533 SERV4_IP, 534 SERV4_PORT, 535 SERV4_REWRITE_IP, 536 SERV4_REWRITE_PORT, 537 NULL, 538 SUCCESS, 539 }, 540 { 541 SOCK_ADDR_TEST_BIND, 542 "bind4: bind deny (dgram)", 543 bind_v4_deny_prog_load, 544 bind_v4_deny_prog_destroy, 545 BPF_CGROUP_INET4_BIND, 546 &user_ops, 547 AF_INET, 548 SOCK_DGRAM, 549 SERV4_IP, 550 SERV4_PORT, 551 SERV4_REWRITE_IP, 552 SERV4_REWRITE_PORT, 553 NULL, 554 SYSCALL_EPERM, 555 }, 556 { 557 SOCK_ADDR_TEST_BIND, 558 "bind4: load prog with wrong expected attach type", 559 bind_v4_prog_load, 560 bind_v4_prog_destroy, 561 BPF_CGROUP_INET6_BIND, 562 &user_ops, 563 AF_INET, 564 SOCK_STREAM, 565 NULL, 566 0, 567 NULL, 568 0, 569 NULL, 570 LOAD_REJECT, 571 }, 572 { 573 SOCK_ADDR_TEST_BIND, 574 "bind4: attach prog with wrong attach type", 575 bind_v4_prog_load_raw, 576 bind_v4_prog_destroy_raw, 577 BPF_CGROUP_INET6_BIND, 578 &user_ops, 579 AF_INET, 580 SOCK_STREAM, 581 NULL, 582 0, 583 NULL, 584 0, 585 NULL, 586 ATTACH_REJECT, 587 }, 588 { 589 SOCK_ADDR_TEST_BIND, 590 "bind6: bind (stream)", 591 bind_v6_prog_load, 592 bind_v6_prog_destroy, 593 BPF_CGROUP_INET6_BIND, 594 &user_ops, 595 AF_INET6, 596 SOCK_STREAM, 597 SERV6_IP, 598 SERV6_PORT, 599 SERV6_REWRITE_IP, 600 SERV6_REWRITE_PORT, 601 NULL, 602 SUCCESS, 603 }, 604 { 605 SOCK_ADDR_TEST_BIND, 606 "bind6: bind deny (stream)", 607 bind_v6_deny_prog_load, 608 bind_v6_deny_prog_destroy, 609 BPF_CGROUP_INET6_BIND, 610 &user_ops, 611 AF_INET6, 612 SOCK_STREAM, 613 SERV6_IP, 614 SERV6_PORT, 615 SERV6_REWRITE_IP, 616 SERV6_REWRITE_PORT, 617 NULL, 618 SYSCALL_EPERM, 619 }, 620 { 621 SOCK_ADDR_TEST_BIND, 622 "bind6: bind (dgram)", 623 bind_v6_prog_load, 624 bind_v6_prog_destroy, 625 BPF_CGROUP_INET6_BIND, 626 &user_ops, 627 AF_INET6, 628 SOCK_DGRAM, 629 SERV6_IP, 630 SERV6_PORT, 631 SERV6_REWRITE_IP, 632 SERV6_REWRITE_PORT, 633 NULL, 634 SUCCESS, 635 }, 636 { 637 SOCK_ADDR_TEST_BIND, 638 "bind6: bind deny (dgram)", 639 bind_v6_deny_prog_load, 640 bind_v6_deny_prog_destroy, 641 BPF_CGROUP_INET6_BIND, 642 &user_ops, 643 AF_INET6, 644 SOCK_DGRAM, 645 SERV6_IP, 646 SERV6_PORT, 647 SERV6_REWRITE_IP, 648 SERV6_REWRITE_PORT, 649 NULL, 650 SYSCALL_EPERM, 651 }, 652 { 653 SOCK_ADDR_TEST_BIND, 654 "bind6: load prog with wrong expected attach type", 655 bind_v6_prog_load, 656 bind_v6_prog_destroy, 657 BPF_CGROUP_INET4_BIND, 658 &user_ops, 659 AF_INET6, 660 SOCK_STREAM, 661 NULL, 662 0, 663 NULL, 664 0, 665 NULL, 666 LOAD_REJECT, 667 }, 668 { 669 SOCK_ADDR_TEST_BIND, 670 "bind6: attach prog with wrong attach type", 671 bind_v6_prog_load_raw, 672 bind_v6_prog_destroy_raw, 673 BPF_CGROUP_INET4_BIND, 674 &user_ops, 675 AF_INET, 676 SOCK_STREAM, 677 NULL, 678 0, 679 NULL, 680 0, 681 NULL, 682 ATTACH_REJECT, 683 }, 684 685 /* bind - kernel calls */ 686 { 687 SOCK_ADDR_TEST_BIND, 688 "bind4: kernel_bind (stream)", 689 bind_v4_prog_load, 690 bind_v4_prog_destroy, 691 BPF_CGROUP_INET4_BIND, 692 &kern_ops_sock_sendmsg, 693 AF_INET, 694 SOCK_STREAM, 695 SERV4_IP, 696 SERV4_PORT, 697 SERV4_REWRITE_IP, 698 SERV4_REWRITE_PORT, 699 NULL, 700 SUCCESS, 701 }, 702 { 703 SOCK_ADDR_TEST_BIND, 704 "bind4: kernel_bind deny (stream)", 705 bind_v4_deny_prog_load, 706 bind_v4_deny_prog_destroy, 707 BPF_CGROUP_INET4_BIND, 708 &kern_ops_sock_sendmsg, 709 AF_INET, 710 SOCK_STREAM, 711 SERV4_IP, 712 SERV4_PORT, 713 SERV4_REWRITE_IP, 714 SERV4_REWRITE_PORT, 715 NULL, 716 SYSCALL_EPERM, 717 }, 718 { 719 SOCK_ADDR_TEST_BIND, 720 "bind4: kernel_bind (dgram)", 721 bind_v4_prog_load, 722 bind_v4_prog_destroy, 723 BPF_CGROUP_INET4_BIND, 724 &kern_ops_sock_sendmsg, 725 AF_INET, 726 SOCK_DGRAM, 727 SERV4_IP, 728 SERV4_PORT, 729 SERV4_REWRITE_IP, 730 SERV4_REWRITE_PORT, 731 NULL, 732 SUCCESS, 733 }, 734 { 735 SOCK_ADDR_TEST_BIND, 736 "bind4: kernel_bind deny (dgram)", 737 bind_v4_deny_prog_load, 738 bind_v4_deny_prog_destroy, 739 BPF_CGROUP_INET4_BIND, 740 &kern_ops_sock_sendmsg, 741 AF_INET, 742 SOCK_DGRAM, 743 SERV4_IP, 744 SERV4_PORT, 745 SERV4_REWRITE_IP, 746 SERV4_REWRITE_PORT, 747 NULL, 748 SYSCALL_EPERM, 749 }, 750 { 751 SOCK_ADDR_TEST_BIND, 752 "bind6: kernel_bind (stream)", 753 bind_v6_prog_load, 754 bind_v6_prog_destroy, 755 BPF_CGROUP_INET6_BIND, 756 &kern_ops_sock_sendmsg, 757 AF_INET6, 758 SOCK_STREAM, 759 SERV6_IP, 760 SERV6_PORT, 761 SERV6_REWRITE_IP, 762 SERV6_REWRITE_PORT, 763 NULL, 764 SUCCESS, 765 }, 766 { 767 SOCK_ADDR_TEST_BIND, 768 "bind6: kernel_bind deny (stream)", 769 bind_v6_deny_prog_load, 770 bind_v6_deny_prog_destroy, 771 BPF_CGROUP_INET6_BIND, 772 &kern_ops_sock_sendmsg, 773 AF_INET6, 774 SOCK_STREAM, 775 SERV6_IP, 776 SERV6_PORT, 777 SERV6_REWRITE_IP, 778 SERV6_REWRITE_PORT, 779 NULL, 780 SYSCALL_EPERM, 781 }, 782 { 783 SOCK_ADDR_TEST_BIND, 784 "bind6: kernel_bind (dgram)", 785 bind_v6_prog_load, 786 bind_v6_prog_destroy, 787 BPF_CGROUP_INET6_BIND, 788 &kern_ops_sock_sendmsg, 789 AF_INET6, 790 SOCK_DGRAM, 791 SERV6_IP, 792 SERV6_PORT, 793 SERV6_REWRITE_IP, 794 SERV6_REWRITE_PORT, 795 NULL, 796 SUCCESS, 797 }, 798 { 799 SOCK_ADDR_TEST_BIND, 800 "bind6: kernel_bind deny (dgram)", 801 bind_v6_deny_prog_load, 802 bind_v6_deny_prog_destroy, 803 BPF_CGROUP_INET6_BIND, 804 &kern_ops_sock_sendmsg, 805 AF_INET6, 806 SOCK_DGRAM, 807 SERV6_IP, 808 SERV6_PORT, 809 SERV6_REWRITE_IP, 810 SERV6_REWRITE_PORT, 811 NULL, 812 SYSCALL_EPERM, 813 }, 814 815 /* connect - system calls */ 816 { 817 SOCK_ADDR_TEST_CONNECT, 818 "connect4: connect (stream)", 819 connect_v4_prog_load, 820 connect_v4_prog_destroy, 821 BPF_CGROUP_INET4_CONNECT, 822 &user_ops, 823 AF_INET, 824 SOCK_STREAM, 825 SERV4_IP, 826 SERV4_PORT, 827 SERV4_REWRITE_IP, 828 SERV4_REWRITE_PORT, 829 SRC4_REWRITE_IP, 830 SUCCESS, 831 }, 832 { 833 SOCK_ADDR_TEST_CONNECT, 834 "connect4: connect deny (stream)", 835 connect_v4_deny_prog_load, 836 connect_v4_deny_prog_destroy, 837 BPF_CGROUP_INET4_CONNECT, 838 &user_ops, 839 AF_INET, 840 SOCK_STREAM, 841 SERV4_IP, 842 SERV4_PORT, 843 SERV4_REWRITE_IP, 844 SERV4_REWRITE_PORT, 845 SRC4_REWRITE_IP, 846 SYSCALL_EPERM, 847 }, 848 { 849 SOCK_ADDR_TEST_CONNECT, 850 "connect4: connect (dgram)", 851 connect_v4_prog_load, 852 connect_v4_prog_destroy, 853 BPF_CGROUP_INET4_CONNECT, 854 &user_ops, 855 AF_INET, 856 SOCK_DGRAM, 857 SERV4_IP, 858 SERV4_PORT, 859 SERV4_REWRITE_IP, 860 SERV4_REWRITE_PORT, 861 SRC4_REWRITE_IP, 862 SUCCESS, 863 }, 864 { 865 SOCK_ADDR_TEST_CONNECT, 866 "connect4: connect deny (dgram)", 867 connect_v4_deny_prog_load, 868 connect_v4_deny_prog_destroy, 869 BPF_CGROUP_INET4_CONNECT, 870 &user_ops, 871 AF_INET, 872 SOCK_DGRAM, 873 SERV4_IP, 874 SERV4_PORT, 875 SERV4_REWRITE_IP, 876 SERV4_REWRITE_PORT, 877 SRC4_REWRITE_IP, 878 SYSCALL_EPERM, 879 }, 880 { 881 SOCK_ADDR_TEST_CONNECT, 882 "connect4: load prog with wrong expected attach type", 883 connect_v4_prog_load, 884 connect_v4_prog_destroy, 885 BPF_CGROUP_INET6_CONNECT, 886 &user_ops, 887 AF_INET, 888 SOCK_STREAM, 889 NULL, 890 0, 891 NULL, 892 0, 893 NULL, 894 LOAD_REJECT, 895 }, 896 { 897 SOCK_ADDR_TEST_CONNECT, 898 "connect4: attach prog with wrong attach type", 899 connect_v4_prog_load_raw, 900 connect_v4_prog_destroy_raw, 901 BPF_CGROUP_INET6_CONNECT, 902 &user_ops, 903 AF_INET, 904 SOCK_STREAM, 905 NULL, 906 0, 907 NULL, 908 0, 909 NULL, 910 ATTACH_REJECT, 911 }, 912 { 913 SOCK_ADDR_TEST_CONNECT, 914 "connect6: connect (stream)", 915 connect_v6_prog_load, 916 connect_v6_prog_destroy, 917 BPF_CGROUP_INET6_CONNECT, 918 &user_ops, 919 AF_INET6, 920 SOCK_STREAM, 921 SERV6_IP, 922 SERV6_PORT, 923 SERV6_REWRITE_IP, 924 SERV6_REWRITE_PORT, 925 SRC6_REWRITE_IP, 926 SUCCESS, 927 }, 928 { 929 SOCK_ADDR_TEST_CONNECT, 930 "connect6: connect deny (stream)", 931 connect_v6_deny_prog_load, 932 connect_v6_deny_prog_destroy, 933 BPF_CGROUP_INET6_CONNECT, 934 &user_ops, 935 AF_INET6, 936 SOCK_STREAM, 937 SERV6_IP, 938 SERV6_PORT, 939 SERV6_REWRITE_IP, 940 SERV6_REWRITE_PORT, 941 SRC6_REWRITE_IP, 942 SYSCALL_EPERM, 943 }, 944 { 945 SOCK_ADDR_TEST_CONNECT, 946 "connect6: connect (dgram)", 947 connect_v6_prog_load, 948 connect_v6_prog_destroy, 949 BPF_CGROUP_INET6_CONNECT, 950 &user_ops, 951 AF_INET6, 952 SOCK_DGRAM, 953 SERV6_IP, 954 SERV6_PORT, 955 SERV6_REWRITE_IP, 956 SERV6_REWRITE_PORT, 957 SRC6_REWRITE_IP, 958 SUCCESS, 959 }, 960 { 961 SOCK_ADDR_TEST_CONNECT, 962 "connect6: connect deny (dgram)", 963 connect_v6_deny_prog_load, 964 connect_v6_deny_prog_destroy, 965 BPF_CGROUP_INET6_CONNECT, 966 &user_ops, 967 AF_INET6, 968 SOCK_DGRAM, 969 SERV6_IP, 970 SERV6_PORT, 971 SERV6_REWRITE_IP, 972 SERV6_REWRITE_PORT, 973 SRC6_REWRITE_IP, 974 SYSCALL_EPERM, 975 }, 976 { 977 SOCK_ADDR_TEST_CONNECT, 978 "connect6: load prog with wrong expected attach type", 979 connect_v6_prog_load, 980 connect_v6_prog_destroy, 981 BPF_CGROUP_INET4_CONNECT, 982 &user_ops, 983 AF_INET6, 984 SOCK_STREAM, 985 NULL, 986 0, 987 NULL, 988 0, 989 NULL, 990 LOAD_REJECT, 991 }, 992 { 993 SOCK_ADDR_TEST_CONNECT, 994 "connect6: attach prog with wrong attach type", 995 connect_v6_prog_load_raw, 996 connect_v6_prog_destroy_raw, 997 BPF_CGROUP_INET4_CONNECT, 998 &user_ops, 999 AF_INET, 1000 SOCK_STREAM, 1001 NULL, 1002 0, 1003 NULL, 1004 0, 1005 NULL, 1006 ATTACH_REJECT, 1007 }, 1008 { 1009 SOCK_ADDR_TEST_CONNECT, 1010 "connect_unix: connect (stream)", 1011 connect_unix_prog_load, 1012 connect_unix_prog_destroy, 1013 BPF_CGROUP_UNIX_CONNECT, 1014 &user_ops, 1015 AF_UNIX, 1016 SOCK_STREAM, 1017 SERVUN_ADDRESS, 1018 0, 1019 SERVUN_REWRITE_ADDRESS, 1020 0, 1021 NULL, 1022 SUCCESS, 1023 }, 1024 { 1025 SOCK_ADDR_TEST_CONNECT, 1026 "connect_unix: connect deny (stream)", 1027 connect_unix_deny_prog_load, 1028 connect_unix_deny_prog_destroy, 1029 BPF_CGROUP_UNIX_CONNECT, 1030 &user_ops, 1031 AF_UNIX, 1032 SOCK_STREAM, 1033 SERVUN_ADDRESS, 1034 0, 1035 SERVUN_REWRITE_ADDRESS, 1036 0, 1037 NULL, 1038 SYSCALL_EPERM, 1039 }, 1040 { 1041 SOCK_ADDR_TEST_CONNECT, 1042 "connect_unix: attach prog with wrong attach type", 1043 connect_unix_prog_load_raw, 1044 connect_unix_prog_destroy_raw, 1045 BPF_CGROUP_INET4_CONNECT, 1046 &user_ops, 1047 AF_UNIX, 1048 SOCK_STREAM, 1049 SERVUN_ADDRESS, 1050 0, 1051 SERVUN_REWRITE_ADDRESS, 1052 0, 1053 NULL, 1054 ATTACH_REJECT, 1055 }, 1056 1057 /* connect - kernel calls */ 1058 { 1059 SOCK_ADDR_TEST_CONNECT, 1060 "connect4: kernel_connect (stream)", 1061 connect_v4_prog_load, 1062 connect_v4_prog_destroy, 1063 BPF_CGROUP_INET4_CONNECT, 1064 &kern_ops_sock_sendmsg, 1065 AF_INET, 1066 SOCK_STREAM, 1067 SERV4_IP, 1068 SERV4_PORT, 1069 SERV4_REWRITE_IP, 1070 SERV4_REWRITE_PORT, 1071 SRC4_REWRITE_IP, 1072 SUCCESS, 1073 }, 1074 { 1075 SOCK_ADDR_TEST_CONNECT, 1076 "connect4: kernel_connect deny (stream)", 1077 connect_v4_deny_prog_load, 1078 connect_v4_deny_prog_destroy, 1079 BPF_CGROUP_INET4_CONNECT, 1080 &kern_ops_sock_sendmsg, 1081 AF_INET, 1082 SOCK_STREAM, 1083 SERV4_IP, 1084 SERV4_PORT, 1085 SERV4_REWRITE_IP, 1086 SERV4_REWRITE_PORT, 1087 SRC4_REWRITE_IP, 1088 SYSCALL_EPERM, 1089 }, 1090 { 1091 SOCK_ADDR_TEST_CONNECT, 1092 "connect4: kernel_connect (dgram)", 1093 connect_v4_prog_load, 1094 connect_v4_prog_destroy, 1095 BPF_CGROUP_INET4_CONNECT, 1096 &kern_ops_sock_sendmsg, 1097 AF_INET, 1098 SOCK_DGRAM, 1099 SERV4_IP, 1100 SERV4_PORT, 1101 SERV4_REWRITE_IP, 1102 SERV4_REWRITE_PORT, 1103 SRC4_REWRITE_IP, 1104 SUCCESS, 1105 }, 1106 { 1107 SOCK_ADDR_TEST_CONNECT, 1108 "connect4: kernel_connect deny (dgram)", 1109 connect_v4_deny_prog_load, 1110 connect_v4_deny_prog_destroy, 1111 BPF_CGROUP_INET4_CONNECT, 1112 &kern_ops_sock_sendmsg, 1113 AF_INET, 1114 SOCK_DGRAM, 1115 SERV4_IP, 1116 SERV4_PORT, 1117 SERV4_REWRITE_IP, 1118 SERV4_REWRITE_PORT, 1119 SRC4_REWRITE_IP, 1120 SYSCALL_EPERM, 1121 }, 1122 { 1123 SOCK_ADDR_TEST_CONNECT, 1124 "connect6: kernel_connect (stream)", 1125 connect_v6_prog_load, 1126 connect_v6_prog_destroy, 1127 BPF_CGROUP_INET6_CONNECT, 1128 &kern_ops_sock_sendmsg, 1129 AF_INET6, 1130 SOCK_STREAM, 1131 SERV6_IP, 1132 SERV6_PORT, 1133 SERV6_REWRITE_IP, 1134 SERV6_REWRITE_PORT, 1135 SRC6_REWRITE_IP, 1136 SUCCESS, 1137 }, 1138 { 1139 SOCK_ADDR_TEST_CONNECT, 1140 "connect6: kernel_connect deny (stream)", 1141 connect_v6_deny_prog_load, 1142 connect_v6_deny_prog_destroy, 1143 BPF_CGROUP_INET6_CONNECT, 1144 &kern_ops_sock_sendmsg, 1145 AF_INET6, 1146 SOCK_STREAM, 1147 SERV6_IP, 1148 SERV6_PORT, 1149 SERV6_REWRITE_IP, 1150 SERV6_REWRITE_PORT, 1151 SRC6_REWRITE_IP, 1152 SYSCALL_EPERM, 1153 }, 1154 { 1155 SOCK_ADDR_TEST_CONNECT, 1156 "connect6: kernel_connect (dgram)", 1157 connect_v6_prog_load, 1158 connect_v6_prog_destroy, 1159 BPF_CGROUP_INET6_CONNECT, 1160 &kern_ops_sock_sendmsg, 1161 AF_INET6, 1162 SOCK_DGRAM, 1163 SERV6_IP, 1164 SERV6_PORT, 1165 SERV6_REWRITE_IP, 1166 SERV6_REWRITE_PORT, 1167 SRC6_REWRITE_IP, 1168 SUCCESS, 1169 }, 1170 { 1171 SOCK_ADDR_TEST_CONNECT, 1172 "connect6: kernel_connect deny (dgram)", 1173 connect_v6_deny_prog_load, 1174 connect_v6_deny_prog_destroy, 1175 BPF_CGROUP_INET6_CONNECT, 1176 &kern_ops_sock_sendmsg, 1177 AF_INET6, 1178 SOCK_DGRAM, 1179 SERV6_IP, 1180 SERV6_PORT, 1181 SERV6_REWRITE_IP, 1182 SERV6_REWRITE_PORT, 1183 SRC6_REWRITE_IP, 1184 SYSCALL_EPERM, 1185 }, 1186 { 1187 SOCK_ADDR_TEST_CONNECT, 1188 "connect_unix: kernel_connect (dgram)", 1189 connect_unix_prog_load, 1190 connect_unix_prog_destroy, 1191 BPF_CGROUP_UNIX_CONNECT, 1192 &kern_ops_sock_sendmsg, 1193 AF_UNIX, 1194 SOCK_STREAM, 1195 SERVUN_ADDRESS, 1196 0, 1197 SERVUN_REWRITE_ADDRESS, 1198 0, 1199 NULL, 1200 SUCCESS, 1201 }, 1202 { 1203 SOCK_ADDR_TEST_CONNECT, 1204 "connect_unix: kernel_connect deny (dgram)", 1205 connect_unix_deny_prog_load, 1206 connect_unix_deny_prog_destroy, 1207 BPF_CGROUP_UNIX_CONNECT, 1208 &kern_ops_sock_sendmsg, 1209 AF_UNIX, 1210 SOCK_STREAM, 1211 SERVUN_ADDRESS, 1212 0, 1213 SERVUN_REWRITE_ADDRESS, 1214 0, 1215 NULL, 1216 SYSCALL_EPERM, 1217 }, 1218 1219 /* sendmsg - system calls */ 1220 { 1221 SOCK_ADDR_TEST_SENDMSG, 1222 "sendmsg4: sendmsg (dgram)", 1223 sendmsg_v4_prog_load, 1224 sendmsg_v4_prog_destroy, 1225 BPF_CGROUP_UDP4_SENDMSG, 1226 &user_ops, 1227 AF_INET, 1228 SOCK_DGRAM, 1229 SERV4_IP, 1230 SERV4_PORT, 1231 SERV4_REWRITE_IP, 1232 SERV4_REWRITE_PORT, 1233 SRC4_REWRITE_IP, 1234 SUCCESS, 1235 }, 1236 { 1237 SOCK_ADDR_TEST_SENDMSG, 1238 "sendmsg4: sendmsg deny (dgram)", 1239 sendmsg_v4_deny_prog_load, 1240 sendmsg_v4_deny_prog_destroy, 1241 BPF_CGROUP_UDP4_SENDMSG, 1242 &user_ops, 1243 AF_INET, 1244 SOCK_DGRAM, 1245 SERV4_IP, 1246 SERV4_PORT, 1247 SERV4_REWRITE_IP, 1248 SERV4_REWRITE_PORT, 1249 SRC4_REWRITE_IP, 1250 SYSCALL_EPERM, 1251 }, 1252 { 1253 SOCK_ADDR_TEST_SENDMSG, 1254 "sendmsg4: load prog with wrong expected attach type", 1255 sendmsg_v4_prog_load, 1256 sendmsg_v4_prog_destroy, 1257 BPF_CGROUP_UDP6_SENDMSG, 1258 &user_ops, 1259 AF_INET, 1260 SOCK_DGRAM, 1261 NULL, 1262 0, 1263 NULL, 1264 0, 1265 NULL, 1266 LOAD_REJECT, 1267 }, 1268 { 1269 SOCK_ADDR_TEST_SENDMSG, 1270 "sendmsg4: attach prog with wrong attach type", 1271 sendmsg_v4_prog_load_raw, 1272 sendmsg_v4_prog_destroy_raw, 1273 BPF_CGROUP_UDP6_SENDMSG, 1274 &user_ops, 1275 AF_INET, 1276 SOCK_DGRAM, 1277 NULL, 1278 0, 1279 NULL, 1280 0, 1281 NULL, 1282 ATTACH_REJECT, 1283 }, 1284 { 1285 SOCK_ADDR_TEST_SENDMSG, 1286 "sendmsg6: sendmsg (dgram)", 1287 sendmsg_v6_prog_load, 1288 sendmsg_v6_prog_destroy, 1289 BPF_CGROUP_UDP6_SENDMSG, 1290 &user_ops, 1291 AF_INET6, 1292 SOCK_DGRAM, 1293 SERV6_IP, 1294 SERV6_PORT, 1295 SERV6_REWRITE_IP, 1296 SERV6_REWRITE_PORT, 1297 SRC6_REWRITE_IP, 1298 SUCCESS, 1299 }, 1300 { 1301 SOCK_ADDR_TEST_SENDMSG, 1302 "sendmsg6: sendmsg [::] (BSD'ism) (dgram)", 1303 sendmsg_v6_preserve_dst_prog_load, 1304 sendmsg_v6_preserve_dst_prog_destroy, 1305 BPF_CGROUP_UDP6_SENDMSG, 1306 &user_ops, 1307 AF_INET6, 1308 SOCK_DGRAM, 1309 WILDCARD6_IP, 1310 SERV6_PORT, 1311 SERV6_REWRITE_IP, 1312 SERV6_PORT, 1313 SRC6_IP, 1314 SUCCESS, 1315 }, 1316 { 1317 SOCK_ADDR_TEST_SENDMSG, 1318 "sendmsg6: sendmsg deny (dgram)", 1319 sendmsg_v6_deny_prog_load, 1320 sendmsg_v6_deny_prog_destroy, 1321 BPF_CGROUP_UDP6_SENDMSG, 1322 &user_ops, 1323 AF_INET6, 1324 SOCK_DGRAM, 1325 SERV6_IP, 1326 SERV6_PORT, 1327 SERV6_REWRITE_IP, 1328 SERV6_REWRITE_PORT, 1329 SRC6_REWRITE_IP, 1330 SYSCALL_EPERM, 1331 }, 1332 { 1333 SOCK_ADDR_TEST_SENDMSG, 1334 "sendmsg6: sendmsg IPv4-mapped IPv6 (dgram)", 1335 sendmsg_v6_v4mapped_prog_load, 1336 sendmsg_v6_v4mapped_prog_destroy, 1337 BPF_CGROUP_UDP6_SENDMSG, 1338 &user_ops, 1339 AF_INET6, 1340 SOCK_DGRAM, 1341 SERV6_IP, 1342 SERV6_PORT, 1343 SERV6_REWRITE_IP, 1344 SERV6_REWRITE_PORT, 1345 SRC6_REWRITE_IP, 1346 SYSCALL_ENOTSUPP, 1347 }, 1348 { 1349 SOCK_ADDR_TEST_SENDMSG, 1350 "sendmsg6: sendmsg dst IP = [::] (BSD'ism) (dgram)", 1351 sendmsg_v6_wildcard_prog_load, 1352 sendmsg_v6_wildcard_prog_destroy, 1353 BPF_CGROUP_UDP6_SENDMSG, 1354 &user_ops, 1355 AF_INET6, 1356 SOCK_DGRAM, 1357 SERV6_IP, 1358 SERV6_PORT, 1359 SERV6_REWRITE_IP, 1360 SERV6_REWRITE_PORT, 1361 SRC6_REWRITE_IP, 1362 SUCCESS, 1363 }, 1364 { 1365 SOCK_ADDR_TEST_SENDMSG, 1366 "sendmsg6: load prog with wrong expected attach type", 1367 sendmsg_v6_prog_load, 1368 sendmsg_v6_prog_destroy, 1369 BPF_CGROUP_UDP4_SENDMSG, 1370 &user_ops, 1371 AF_INET6, 1372 SOCK_DGRAM, 1373 NULL, 1374 0, 1375 NULL, 1376 0, 1377 NULL, 1378 LOAD_REJECT, 1379 }, 1380 { 1381 SOCK_ADDR_TEST_SENDMSG, 1382 "sendmsg6: attach prog with wrong attach type", 1383 sendmsg_v6_prog_load_raw, 1384 sendmsg_v6_prog_destroy_raw, 1385 BPF_CGROUP_UDP4_SENDMSG, 1386 &user_ops, 1387 AF_INET6, 1388 SOCK_DGRAM, 1389 NULL, 1390 0, 1391 NULL, 1392 0, 1393 NULL, 1394 ATTACH_REJECT, 1395 }, 1396 { 1397 SOCK_ADDR_TEST_SENDMSG, 1398 "sendmsg_unix: sendmsg (dgram)", 1399 sendmsg_unix_prog_load, 1400 sendmsg_unix_prog_destroy, 1401 BPF_CGROUP_UNIX_SENDMSG, 1402 &user_ops, 1403 AF_UNIX, 1404 SOCK_DGRAM, 1405 SERVUN_ADDRESS, 1406 0, 1407 SERVUN_REWRITE_ADDRESS, 1408 0, 1409 NULL, 1410 SUCCESS, 1411 }, 1412 { 1413 SOCK_ADDR_TEST_SENDMSG, 1414 "sendmsg_unix: sendmsg deny (dgram)", 1415 sendmsg_unix_deny_prog_load, 1416 sendmsg_unix_deny_prog_destroy, 1417 BPF_CGROUP_UNIX_SENDMSG, 1418 &user_ops, 1419 AF_UNIX, 1420 SOCK_DGRAM, 1421 SERVUN_ADDRESS, 1422 0, 1423 SERVUN_REWRITE_ADDRESS, 1424 0, 1425 NULL, 1426 SYSCALL_EPERM, 1427 }, 1428 { 1429 SOCK_ADDR_TEST_SENDMSG, 1430 "sendmsg_unix: attach prog with wrong attach type", 1431 sendmsg_unix_prog_load_raw, 1432 sendmsg_unix_prog_destroy_raw, 1433 BPF_CGROUP_UDP4_SENDMSG, 1434 &user_ops, 1435 AF_UNIX, 1436 SOCK_DGRAM, 1437 SERVUN_ADDRESS, 1438 0, 1439 SERVUN_REWRITE_ADDRESS, 1440 0, 1441 NULL, 1442 ATTACH_REJECT, 1443 }, 1444 1445 /* sendmsg - kernel calls (sock_sendmsg) */ 1446 { 1447 SOCK_ADDR_TEST_SENDMSG, 1448 "sendmsg4: sock_sendmsg (dgram)", 1449 sendmsg_v4_prog_load, 1450 sendmsg_v4_prog_destroy, 1451 BPF_CGROUP_UDP4_SENDMSG, 1452 &kern_ops_sock_sendmsg, 1453 AF_INET, 1454 SOCK_DGRAM, 1455 SERV4_IP, 1456 SERV4_PORT, 1457 SERV4_REWRITE_IP, 1458 SERV4_REWRITE_PORT, 1459 SRC4_REWRITE_IP, 1460 SUCCESS, 1461 }, 1462 { 1463 SOCK_ADDR_TEST_SENDMSG, 1464 "sendmsg4: sock_sendmsg deny (dgram)", 1465 sendmsg_v4_deny_prog_load, 1466 sendmsg_v4_deny_prog_destroy, 1467 BPF_CGROUP_UDP4_SENDMSG, 1468 &kern_ops_sock_sendmsg, 1469 AF_INET, 1470 SOCK_DGRAM, 1471 SERV4_IP, 1472 SERV4_PORT, 1473 SERV4_REWRITE_IP, 1474 SERV4_REWRITE_PORT, 1475 SRC4_REWRITE_IP, 1476 SYSCALL_EPERM, 1477 }, 1478 { 1479 SOCK_ADDR_TEST_SENDMSG, 1480 "sendmsg6: sock_sendmsg (dgram)", 1481 sendmsg_v6_prog_load, 1482 sendmsg_v6_prog_destroy, 1483 BPF_CGROUP_UDP6_SENDMSG, 1484 &kern_ops_sock_sendmsg, 1485 AF_INET6, 1486 SOCK_DGRAM, 1487 SERV6_IP, 1488 SERV6_PORT, 1489 SERV6_REWRITE_IP, 1490 SERV6_REWRITE_PORT, 1491 SRC6_REWRITE_IP, 1492 SUCCESS, 1493 }, 1494 { 1495 SOCK_ADDR_TEST_SENDMSG, 1496 "sendmsg6: sock_sendmsg [::] (BSD'ism) (dgram)", 1497 sendmsg_v6_preserve_dst_prog_load, 1498 sendmsg_v6_preserve_dst_prog_destroy, 1499 BPF_CGROUP_UDP6_SENDMSG, 1500 &kern_ops_sock_sendmsg, 1501 AF_INET6, 1502 SOCK_DGRAM, 1503 WILDCARD6_IP, 1504 SERV6_PORT, 1505 SERV6_REWRITE_IP, 1506 SERV6_PORT, 1507 SRC6_IP, 1508 SUCCESS, 1509 }, 1510 { 1511 SOCK_ADDR_TEST_SENDMSG, 1512 "sendmsg6: sock_sendmsg deny (dgram)", 1513 sendmsg_v6_deny_prog_load, 1514 sendmsg_v6_deny_prog_destroy, 1515 BPF_CGROUP_UDP6_SENDMSG, 1516 &kern_ops_sock_sendmsg, 1517 AF_INET6, 1518 SOCK_DGRAM, 1519 SERV6_IP, 1520 SERV6_PORT, 1521 SERV6_REWRITE_IP, 1522 SERV6_REWRITE_PORT, 1523 SRC6_REWRITE_IP, 1524 SYSCALL_EPERM, 1525 }, 1526 { 1527 SOCK_ADDR_TEST_SENDMSG, 1528 "sendmsg_unix: sock_sendmsg (dgram)", 1529 sendmsg_unix_prog_load, 1530 sendmsg_unix_prog_destroy, 1531 BPF_CGROUP_UNIX_SENDMSG, 1532 &kern_ops_sock_sendmsg, 1533 AF_UNIX, 1534 SOCK_DGRAM, 1535 SERVUN_ADDRESS, 1536 0, 1537 SERVUN_REWRITE_ADDRESS, 1538 0, 1539 NULL, 1540 SUCCESS, 1541 }, 1542 { 1543 SOCK_ADDR_TEST_SENDMSG, 1544 "sendmsg_unix: sock_sendmsg deny (dgram)", 1545 sendmsg_unix_deny_prog_load, 1546 sendmsg_unix_deny_prog_destroy, 1547 BPF_CGROUP_UNIX_SENDMSG, 1548 &kern_ops_sock_sendmsg, 1549 AF_UNIX, 1550 SOCK_DGRAM, 1551 SERVUN_ADDRESS, 1552 0, 1553 SERVUN_REWRITE_ADDRESS, 1554 0, 1555 NULL, 1556 SYSCALL_EPERM, 1557 }, 1558 1559 /* sendmsg - kernel calls (kernel_sendmsg) */ 1560 { 1561 SOCK_ADDR_TEST_SENDMSG, 1562 "sendmsg4: kernel_sendmsg (dgram)", 1563 sendmsg_v4_prog_load, 1564 sendmsg_v4_prog_destroy, 1565 BPF_CGROUP_UDP4_SENDMSG, 1566 &kern_ops_kernel_sendmsg, 1567 AF_INET, 1568 SOCK_DGRAM, 1569 SERV4_IP, 1570 SERV4_PORT, 1571 SERV4_REWRITE_IP, 1572 SERV4_REWRITE_PORT, 1573 SRC4_REWRITE_IP, 1574 SUCCESS, 1575 }, 1576 { 1577 SOCK_ADDR_TEST_SENDMSG, 1578 "sendmsg4: kernel_sendmsg deny (dgram)", 1579 sendmsg_v4_deny_prog_load, 1580 sendmsg_v4_deny_prog_destroy, 1581 BPF_CGROUP_UDP4_SENDMSG, 1582 &kern_ops_kernel_sendmsg, 1583 AF_INET, 1584 SOCK_DGRAM, 1585 SERV4_IP, 1586 SERV4_PORT, 1587 SERV4_REWRITE_IP, 1588 SERV4_REWRITE_PORT, 1589 SRC4_REWRITE_IP, 1590 SYSCALL_EPERM, 1591 }, 1592 { 1593 SOCK_ADDR_TEST_SENDMSG, 1594 "sendmsg6: kernel_sendmsg (dgram)", 1595 sendmsg_v6_prog_load, 1596 sendmsg_v6_prog_destroy, 1597 BPF_CGROUP_UDP6_SENDMSG, 1598 &kern_ops_kernel_sendmsg, 1599 AF_INET6, 1600 SOCK_DGRAM, 1601 SERV6_IP, 1602 SERV6_PORT, 1603 SERV6_REWRITE_IP, 1604 SERV6_REWRITE_PORT, 1605 SRC6_REWRITE_IP, 1606 SUCCESS, 1607 }, 1608 { 1609 SOCK_ADDR_TEST_SENDMSG, 1610 "sendmsg6: kernel_sendmsg [::] (BSD'ism) (dgram)", 1611 sendmsg_v6_preserve_dst_prog_load, 1612 sendmsg_v6_preserve_dst_prog_destroy, 1613 BPF_CGROUP_UDP6_SENDMSG, 1614 &kern_ops_kernel_sendmsg, 1615 AF_INET6, 1616 SOCK_DGRAM, 1617 WILDCARD6_IP, 1618 SERV6_PORT, 1619 SERV6_REWRITE_IP, 1620 SERV6_PORT, 1621 SRC6_IP, 1622 SUCCESS, 1623 }, 1624 { 1625 SOCK_ADDR_TEST_SENDMSG, 1626 "sendmsg6: kernel_sendmsg deny (dgram)", 1627 sendmsg_v6_deny_prog_load, 1628 sendmsg_v6_deny_prog_destroy, 1629 BPF_CGROUP_UDP6_SENDMSG, 1630 &kern_ops_kernel_sendmsg, 1631 AF_INET6, 1632 SOCK_DGRAM, 1633 SERV6_IP, 1634 SERV6_PORT, 1635 SERV6_REWRITE_IP, 1636 SERV6_REWRITE_PORT, 1637 SRC6_REWRITE_IP, 1638 SYSCALL_EPERM, 1639 }, 1640 { 1641 SOCK_ADDR_TEST_SENDMSG, 1642 "sendmsg_unix: sock_sendmsg (dgram)", 1643 sendmsg_unix_prog_load, 1644 sendmsg_unix_prog_destroy, 1645 BPF_CGROUP_UNIX_SENDMSG, 1646 &kern_ops_kernel_sendmsg, 1647 AF_UNIX, 1648 SOCK_DGRAM, 1649 SERVUN_ADDRESS, 1650 0, 1651 SERVUN_REWRITE_ADDRESS, 1652 0, 1653 NULL, 1654 SUCCESS, 1655 }, 1656 { 1657 SOCK_ADDR_TEST_SENDMSG, 1658 "sendmsg_unix: kernel_sendmsg deny (dgram)", 1659 sendmsg_unix_deny_prog_load, 1660 sendmsg_unix_deny_prog_destroy, 1661 BPF_CGROUP_UNIX_SENDMSG, 1662 &kern_ops_kernel_sendmsg, 1663 AF_UNIX, 1664 SOCK_DGRAM, 1665 SERVUN_ADDRESS, 1666 0, 1667 SERVUN_REWRITE_ADDRESS, 1668 0, 1669 NULL, 1670 SYSCALL_EPERM, 1671 }, 1672 1673 /* recvmsg - system calls */ 1674 { 1675 SOCK_ADDR_TEST_RECVMSG, 1676 "recvmsg4: recvfrom (dgram)", 1677 recvmsg4_prog_load, 1678 recvmsg4_prog_destroy, 1679 BPF_CGROUP_UDP4_RECVMSG, 1680 &user_ops, 1681 AF_INET, 1682 SOCK_DGRAM, 1683 SERV4_REWRITE_IP, 1684 SERV4_REWRITE_PORT, 1685 SERV4_REWRITE_IP, 1686 SERV4_REWRITE_PORT, 1687 SERV4_IP, 1688 SUCCESS, 1689 }, 1690 { 1691 SOCK_ADDR_TEST_RECVMSG, 1692 "recvmsg4: attach prog with wrong attach type", 1693 recvmsg4_prog_load_raw, 1694 recvmsg4_prog_destroy_raw, 1695 BPF_CGROUP_UDP6_RECVMSG, 1696 &user_ops, 1697 AF_INET, 1698 SOCK_DGRAM, 1699 SERV4_REWRITE_IP, 1700 SERV4_REWRITE_PORT, 1701 SERV4_REWRITE_IP, 1702 SERV4_REWRITE_PORT, 1703 SERV4_IP, 1704 ATTACH_REJECT, 1705 }, 1706 { 1707 SOCK_ADDR_TEST_RECVMSG, 1708 "recvmsg6: recvfrom (dgram)", 1709 recvmsg6_prog_load, 1710 recvmsg6_prog_destroy, 1711 BPF_CGROUP_UDP6_RECVMSG, 1712 &user_ops, 1713 AF_INET6, 1714 SOCK_DGRAM, 1715 SERV6_REWRITE_IP, 1716 SERV6_REWRITE_PORT, 1717 SERV6_REWRITE_IP, 1718 SERV6_REWRITE_PORT, 1719 SERV6_IP, 1720 SUCCESS, 1721 }, 1722 { 1723 SOCK_ADDR_TEST_RECVMSG, 1724 "recvmsg6: attach prog with wrong attach type", 1725 recvmsg6_prog_load_raw, 1726 recvmsg6_prog_destroy_raw, 1727 BPF_CGROUP_UDP4_RECVMSG, 1728 &user_ops, 1729 AF_INET6, 1730 SOCK_DGRAM, 1731 SERV6_REWRITE_IP, 1732 SERV6_REWRITE_PORT, 1733 SERV6_REWRITE_IP, 1734 SERV6_REWRITE_PORT, 1735 SERV6_IP, 1736 ATTACH_REJECT, 1737 }, 1738 { 1739 SOCK_ADDR_TEST_RECVMSG, 1740 "recvmsg_unix: recvfrom (dgram)", 1741 recvmsg_unix_prog_load, 1742 recvmsg_unix_prog_destroy, 1743 BPF_CGROUP_UNIX_RECVMSG, 1744 &user_ops, 1745 AF_UNIX, 1746 SOCK_DGRAM, 1747 SERVUN_REWRITE_ADDRESS, 1748 0, 1749 SERVUN_REWRITE_ADDRESS, 1750 0, 1751 SERVUN_ADDRESS, 1752 SUCCESS, 1753 }, 1754 { 1755 SOCK_ADDR_TEST_RECVMSG, 1756 "recvmsg_unix: recvfrom (stream)", 1757 recvmsg_unix_prog_load, 1758 recvmsg_unix_prog_destroy, 1759 BPF_CGROUP_UNIX_RECVMSG, 1760 &user_ops, 1761 AF_UNIX, 1762 SOCK_STREAM, 1763 SERVUN_REWRITE_ADDRESS, 1764 0, 1765 SERVUN_REWRITE_ADDRESS, 1766 0, 1767 SERVUN_ADDRESS, 1768 SUCCESS, 1769 }, 1770 { 1771 SOCK_ADDR_TEST_RECVMSG, 1772 "recvmsg_unix: attach prog with wrong attach type", 1773 recvmsg_unix_prog_load_raw, 1774 recvmsg_unix_prog_destroy_raw, 1775 BPF_CGROUP_UDP4_RECVMSG, 1776 &user_ops, 1777 AF_INET6, 1778 SOCK_STREAM, 1779 SERVUN_REWRITE_ADDRESS, 1780 0, 1781 SERVUN_REWRITE_ADDRESS, 1782 0, 1783 SERVUN_ADDRESS, 1784 ATTACH_REJECT, 1785 }, 1786 1787 /* getsockname - system calls */ 1788 { 1789 SOCK_ADDR_TEST_GETSOCKNAME, 1790 "getsockname4: getsockname (stream)", 1791 getsockname_v4_prog_load, 1792 getsockname_v4_prog_destroy, 1793 BPF_CGROUP_INET4_GETSOCKNAME, 1794 &user_ops, 1795 AF_INET, 1796 SOCK_STREAM, 1797 SERV4_REWRITE_IP, 1798 SERV4_REWRITE_PORT, 1799 SERV4_IP, 1800 SERV4_PORT, 1801 NULL, 1802 SUCCESS, 1803 }, 1804 { 1805 SOCK_ADDR_TEST_GETSOCKNAME, 1806 "getsockname4: getsockname (dgram)", 1807 getsockname_v4_prog_load, 1808 getsockname_v4_prog_destroy, 1809 BPF_CGROUP_INET4_GETSOCKNAME, 1810 &user_ops, 1811 AF_INET, 1812 SOCK_DGRAM, 1813 SERV4_REWRITE_IP, 1814 SERV4_REWRITE_PORT, 1815 SERV4_IP, 1816 SERV4_PORT, 1817 NULL, 1818 SUCCESS, 1819 }, 1820 { 1821 SOCK_ADDR_TEST_GETSOCKNAME, 1822 "getsockname4: attach prog with wrong attach type", 1823 getsockname_v4_prog_load_raw, 1824 getsockname_v4_prog_destroy_raw, 1825 BPF_CGROUP_INET6_GETSOCKNAME, 1826 &user_ops, 1827 AF_INET, 1828 SOCK_DGRAM, 1829 SERV4_REWRITE_IP, 1830 SERV4_REWRITE_PORT, 1831 SERV4_IP, 1832 SERV4_PORT, 1833 NULL, 1834 ATTACH_REJECT, 1835 }, 1836 { 1837 SOCK_ADDR_TEST_GETSOCKNAME, 1838 "getsockname6: getsockname (stream)", 1839 getsockname_v6_prog_load, 1840 getsockname_v6_prog_destroy, 1841 BPF_CGROUP_INET6_GETSOCKNAME, 1842 &user_ops, 1843 AF_INET6, 1844 SOCK_STREAM, 1845 SERV6_REWRITE_IP, 1846 SERV6_REWRITE_PORT, 1847 SERV6_IP, 1848 SERV6_PORT, 1849 NULL, 1850 SUCCESS, 1851 }, 1852 { 1853 SOCK_ADDR_TEST_GETSOCKNAME, 1854 "getsockname6: getsockname (dgram)", 1855 getsockname_v6_prog_load, 1856 getsockname_v6_prog_destroy, 1857 BPF_CGROUP_INET6_GETSOCKNAME, 1858 &user_ops, 1859 AF_INET6, 1860 SOCK_DGRAM, 1861 SERV6_REWRITE_IP, 1862 SERV6_REWRITE_PORT, 1863 SERV6_IP, 1864 SERV6_PORT, 1865 NULL, 1866 SUCCESS, 1867 }, 1868 { 1869 SOCK_ADDR_TEST_GETSOCKNAME, 1870 "getsockname6: attach prog with wrong attach type", 1871 getsockname_v6_prog_load_raw, 1872 getsockname_v6_prog_destroy_raw, 1873 BPF_CGROUP_INET4_GETSOCKNAME, 1874 &user_ops, 1875 AF_INET6, 1876 SOCK_DGRAM, 1877 SERV6_REWRITE_IP, 1878 SERV6_REWRITE_PORT, 1879 SERV6_IP, 1880 SERV6_PORT, 1881 NULL, 1882 ATTACH_REJECT, 1883 }, 1884 { 1885 SOCK_ADDR_TEST_GETSOCKNAME, 1886 "getsockname_unix: getsockname", 1887 getsockname_unix_prog_load, 1888 getsockname_unix_prog_destroy, 1889 BPF_CGROUP_UNIX_GETSOCKNAME, 1890 &user_ops, 1891 AF_UNIX, 1892 SOCK_STREAM, 1893 SERVUN_ADDRESS, 1894 0, 1895 SERVUN_REWRITE_ADDRESS, 1896 0, 1897 NULL, 1898 SUCCESS, 1899 }, 1900 { 1901 SOCK_ADDR_TEST_GETSOCKNAME, 1902 "getsockname_unix: attach prog with wrong attach type", 1903 getsockname_unix_prog_load_raw, 1904 getsockname_unix_prog_destroy_raw, 1905 BPF_CGROUP_INET4_GETSOCKNAME, 1906 &user_ops, 1907 AF_UNIX, 1908 SOCK_STREAM, 1909 SERVUN_ADDRESS, 1910 0, 1911 SERVUN_REWRITE_ADDRESS, 1912 0, 1913 NULL, 1914 ATTACH_REJECT, 1915 }, 1916 1917 /* getsockname - kernel calls */ 1918 { 1919 SOCK_ADDR_TEST_GETSOCKNAME, 1920 "getsockname4: kernel_getsockname (stream)", 1921 getsockname_v4_prog_load, 1922 getsockname_v4_prog_destroy, 1923 BPF_CGROUP_INET4_GETSOCKNAME, 1924 &kern_ops_kernel_sendmsg, 1925 AF_INET, 1926 SOCK_STREAM, 1927 SERV4_REWRITE_IP, 1928 SERV4_REWRITE_PORT, 1929 SERV4_IP, 1930 SERV4_PORT, 1931 NULL, 1932 SUCCESS, 1933 }, 1934 { 1935 SOCK_ADDR_TEST_GETSOCKNAME, 1936 "getsockname4: kernel_getsockname (dgram)", 1937 getsockname_v4_prog_load, 1938 getsockname_v4_prog_destroy, 1939 BPF_CGROUP_INET4_GETSOCKNAME, 1940 &kern_ops_kernel_sendmsg, 1941 AF_INET, 1942 SOCK_DGRAM, 1943 SERV4_REWRITE_IP, 1944 SERV4_REWRITE_PORT, 1945 SERV4_IP, 1946 SERV4_PORT, 1947 NULL, 1948 SUCCESS, 1949 }, 1950 { 1951 SOCK_ADDR_TEST_GETSOCKNAME, 1952 "getsockname6: kernel_getsockname (stream)", 1953 getsockname_v6_prog_load, 1954 getsockname_v6_prog_destroy, 1955 BPF_CGROUP_INET6_GETSOCKNAME, 1956 &kern_ops_kernel_sendmsg, 1957 AF_INET6, 1958 SOCK_STREAM, 1959 SERV6_REWRITE_IP, 1960 SERV6_REWRITE_PORT, 1961 SERV6_IP, 1962 SERV6_PORT, 1963 NULL, 1964 SUCCESS, 1965 }, 1966 { 1967 SOCK_ADDR_TEST_GETSOCKNAME, 1968 "getsockname6: kernel_getsockname (dgram)", 1969 getsockname_v6_prog_load, 1970 getsockname_v6_prog_destroy, 1971 BPF_CGROUP_INET6_GETSOCKNAME, 1972 &kern_ops_kernel_sendmsg, 1973 AF_INET6, 1974 SOCK_DGRAM, 1975 SERV6_REWRITE_IP, 1976 SERV6_REWRITE_PORT, 1977 SERV6_IP, 1978 SERV6_PORT, 1979 NULL, 1980 SUCCESS, 1981 }, 1982 { 1983 SOCK_ADDR_TEST_GETSOCKNAME, 1984 "getsockname_unix: kernel_getsockname", 1985 getsockname_unix_prog_load, 1986 getsockname_unix_prog_destroy, 1987 BPF_CGROUP_UNIX_GETSOCKNAME, 1988 &kern_ops_kernel_sendmsg, 1989 AF_UNIX, 1990 SOCK_STREAM, 1991 SERVUN_ADDRESS, 1992 0, 1993 SERVUN_REWRITE_ADDRESS, 1994 0, 1995 NULL, 1996 SUCCESS, 1997 }, 1998 1999 /* getpeername - system calls */ 2000 { 2001 SOCK_ADDR_TEST_GETPEERNAME, 2002 "getpeername4: getpeername (stream)", 2003 getpeername_v4_prog_load, 2004 getpeername_v4_prog_destroy, 2005 BPF_CGROUP_INET4_GETPEERNAME, 2006 &user_ops, 2007 AF_INET, 2008 SOCK_STREAM, 2009 SERV4_REWRITE_IP, 2010 SERV4_REWRITE_PORT, 2011 SERV4_IP, 2012 SERV4_PORT, 2013 NULL, 2014 SUCCESS, 2015 }, 2016 { 2017 SOCK_ADDR_TEST_GETPEERNAME, 2018 "getpeername4: getpeername (dgram)", 2019 getpeername_v4_prog_load, 2020 getpeername_v4_prog_destroy, 2021 BPF_CGROUP_INET4_GETPEERNAME, 2022 &user_ops, 2023 AF_INET, 2024 SOCK_DGRAM, 2025 SERV4_REWRITE_IP, 2026 SERV4_REWRITE_PORT, 2027 SERV4_IP, 2028 SERV4_PORT, 2029 NULL, 2030 SUCCESS, 2031 }, 2032 { 2033 SOCK_ADDR_TEST_GETPEERNAME, 2034 "getpeername4: attach prog with wrong attach type", 2035 getpeername_v4_prog_load_raw, 2036 getpeername_v4_prog_destroy_raw, 2037 BPF_CGROUP_INET6_GETSOCKNAME, 2038 &user_ops, 2039 AF_UNIX, 2040 SOCK_DGRAM, 2041 SERV4_REWRITE_IP, 2042 SERV4_REWRITE_PORT, 2043 SERV4_IP, 2044 SERV4_PORT, 2045 NULL, 2046 ATTACH_REJECT, 2047 }, 2048 { 2049 SOCK_ADDR_TEST_GETPEERNAME, 2050 "getpeername6: getpeername (stream)", 2051 getpeername_v6_prog_load, 2052 getpeername_v6_prog_destroy, 2053 BPF_CGROUP_INET6_GETPEERNAME, 2054 &user_ops, 2055 AF_INET6, 2056 SOCK_STREAM, 2057 SERV6_REWRITE_IP, 2058 SERV6_REWRITE_PORT, 2059 SERV6_IP, 2060 SERV6_PORT, 2061 NULL, 2062 SUCCESS, 2063 }, 2064 { 2065 SOCK_ADDR_TEST_GETPEERNAME, 2066 "getpeername6: getpeername (dgram)", 2067 getpeername_v6_prog_load, 2068 getpeername_v6_prog_destroy, 2069 BPF_CGROUP_INET6_GETPEERNAME, 2070 &user_ops, 2071 AF_INET6, 2072 SOCK_DGRAM, 2073 SERV6_REWRITE_IP, 2074 SERV6_REWRITE_PORT, 2075 SERV6_IP, 2076 SERV6_PORT, 2077 NULL, 2078 SUCCESS, 2079 }, 2080 { 2081 SOCK_ADDR_TEST_GETPEERNAME, 2082 "getpeername6: attach prog with wrong attach type", 2083 getpeername_v6_prog_load_raw, 2084 getpeername_v6_prog_destroy_raw, 2085 BPF_CGROUP_INET4_GETSOCKNAME, 2086 &user_ops, 2087 AF_INET6, 2088 SOCK_DGRAM, 2089 SERV6_REWRITE_IP, 2090 SERV6_REWRITE_PORT, 2091 SERV6_IP, 2092 SERV6_PORT, 2093 NULL, 2094 ATTACH_REJECT, 2095 }, 2096 { 2097 SOCK_ADDR_TEST_GETPEERNAME, 2098 "getpeername_unix: getpeername", 2099 getpeername_unix_prog_load, 2100 getpeername_unix_prog_destroy, 2101 BPF_CGROUP_UNIX_GETPEERNAME, 2102 &user_ops, 2103 AF_UNIX, 2104 SOCK_STREAM, 2105 SERVUN_ADDRESS, 2106 0, 2107 SERVUN_REWRITE_ADDRESS, 2108 0, 2109 NULL, 2110 SUCCESS, 2111 }, 2112 { 2113 SOCK_ADDR_TEST_GETPEERNAME, 2114 "getpeername_unix: attach prog with wrong attach type", 2115 getpeername_unix_prog_load_raw, 2116 getpeername_unix_prog_destroy_raw, 2117 BPF_CGROUP_INET4_GETSOCKNAME, 2118 &user_ops, 2119 AF_UNIX, 2120 SOCK_STREAM, 2121 SERVUN_ADDRESS, 2122 0, 2123 SERVUN_REWRITE_ADDRESS, 2124 0, 2125 NULL, 2126 ATTACH_REJECT, 2127 }, 2128 2129 /* getpeername - kernel calls */ 2130 { 2131 SOCK_ADDR_TEST_GETPEERNAME, 2132 "getpeername4: kernel_getpeername (stream)", 2133 getpeername_v4_prog_load, 2134 getpeername_v4_prog_destroy, 2135 BPF_CGROUP_INET4_GETPEERNAME, 2136 &kern_ops_kernel_sendmsg, 2137 AF_INET, 2138 SOCK_STREAM, 2139 SERV4_REWRITE_IP, 2140 SERV4_REWRITE_PORT, 2141 SERV4_IP, 2142 SERV4_PORT, 2143 NULL, 2144 SUCCESS, 2145 }, 2146 { 2147 SOCK_ADDR_TEST_GETPEERNAME, 2148 "getpeername4: kernel_getpeername (dgram)", 2149 getpeername_v4_prog_load, 2150 getpeername_v4_prog_destroy, 2151 BPF_CGROUP_INET4_GETPEERNAME, 2152 &kern_ops_kernel_sendmsg, 2153 AF_INET, 2154 SOCK_DGRAM, 2155 SERV4_REWRITE_IP, 2156 SERV4_REWRITE_PORT, 2157 SERV4_IP, 2158 SERV4_PORT, 2159 NULL, 2160 SUCCESS, 2161 }, 2162 { 2163 SOCK_ADDR_TEST_GETPEERNAME, 2164 "getpeername6: kernel_getpeername (stream)", 2165 getpeername_v6_prog_load, 2166 getpeername_v6_prog_destroy, 2167 BPF_CGROUP_INET6_GETPEERNAME, 2168 &kern_ops_kernel_sendmsg, 2169 AF_INET6, 2170 SOCK_STREAM, 2171 SERV6_REWRITE_IP, 2172 SERV6_REWRITE_PORT, 2173 SERV6_IP, 2174 SERV6_PORT, 2175 NULL, 2176 SUCCESS, 2177 }, 2178 { 2179 SOCK_ADDR_TEST_GETPEERNAME, 2180 "getpeername6: kernel_getpeername (dgram)", 2181 getpeername_v6_prog_load, 2182 getpeername_v6_prog_destroy, 2183 BPF_CGROUP_INET6_GETPEERNAME, 2184 &kern_ops_kernel_sendmsg, 2185 AF_INET6, 2186 SOCK_DGRAM, 2187 SERV6_REWRITE_IP, 2188 SERV6_REWRITE_PORT, 2189 SERV6_IP, 2190 SERV6_PORT, 2191 NULL, 2192 SUCCESS, 2193 }, 2194 { 2195 SOCK_ADDR_TEST_GETPEERNAME, 2196 "getpeername_unix: kernel_getpeername", 2197 getpeername_unix_prog_load, 2198 getpeername_unix_prog_destroy, 2199 BPF_CGROUP_UNIX_GETPEERNAME, 2200 &kern_ops_kernel_sendmsg, 2201 AF_UNIX, 2202 SOCK_STREAM, 2203 SERVUN_ADDRESS, 2204 0, 2205 SERVUN_REWRITE_ADDRESS, 2206 0, 2207 NULL, 2208 SUCCESS, 2209 }, 2210 }; 2211 2212 typedef int (*info_fn)(int, struct sockaddr *, socklen_t *); 2213 2214 static int cmp_addr(const struct sockaddr_storage *addr1, socklen_t addr1_len, 2215 const struct sockaddr_storage *addr2, socklen_t addr2_len, 2216 bool cmp_port) 2217 { 2218 const struct sockaddr_in *four1, *four2; 2219 const struct sockaddr_in6 *six1, *six2; 2220 const struct sockaddr_un *un1, *un2; 2221 2222 if (addr1->ss_family != addr2->ss_family) 2223 return -1; 2224 2225 if (addr1_len != addr2_len) 2226 return -1; 2227 2228 if (addr1->ss_family == AF_INET) { 2229 four1 = (const struct sockaddr_in *)addr1; 2230 four2 = (const struct sockaddr_in *)addr2; 2231 return !((four1->sin_port == four2->sin_port || !cmp_port) && 2232 four1->sin_addr.s_addr == four2->sin_addr.s_addr); 2233 } else if (addr1->ss_family == AF_INET6) { 2234 six1 = (const struct sockaddr_in6 *)addr1; 2235 six2 = (const struct sockaddr_in6 *)addr2; 2236 return !((six1->sin6_port == six2->sin6_port || !cmp_port) && 2237 !memcmp(&six1->sin6_addr, &six2->sin6_addr, 2238 sizeof(struct in6_addr))); 2239 } else if (addr1->ss_family == AF_UNIX) { 2240 un1 = (const struct sockaddr_un *)addr1; 2241 un2 = (const struct sockaddr_un *)addr2; 2242 return memcmp(un1, un2, addr1_len); 2243 } 2244 2245 return -1; 2246 } 2247 2248 static int cmp_sock_addr(info_fn fn, int sock1, 2249 const struct sockaddr_storage *addr2, 2250 socklen_t addr2_len, bool cmp_port) 2251 { 2252 struct sockaddr_storage addr1; 2253 socklen_t len1 = sizeof(addr1); 2254 2255 memset(&addr1, 0, len1); 2256 if (fn(sock1, (struct sockaddr *)&addr1, (socklen_t *)&len1) != 0) 2257 return -1; 2258 2259 return cmp_addr(&addr1, len1, addr2, addr2_len, cmp_port); 2260 } 2261 2262 static int load_sock_addr_kern(void) 2263 { 2264 int err; 2265 2266 skel = sock_addr_kern__open_and_load(); 2267 if (!ASSERT_OK_PTR(skel, "skel")) 2268 goto err; 2269 2270 err = 0; 2271 goto out; 2272 err: 2273 err = -1; 2274 out: 2275 return err; 2276 } 2277 2278 static void unload_sock_addr_kern(void) 2279 { 2280 sock_addr_kern__destroy(skel); 2281 } 2282 2283 static int test_bind(struct sock_addr_test *test) 2284 { 2285 struct sockaddr_storage expected_addr; 2286 socklen_t expected_addr_len = sizeof(struct sockaddr_storage); 2287 int serv = -1, client = -1, err; 2288 2289 serv = test->ops->start_server(test->socket_family, test->socket_type, 2290 test->requested_addr, 2291 test->requested_port, 0); 2292 if (serv < 0) { 2293 err = errno; 2294 goto err; 2295 } 2296 2297 err = make_sockaddr(test->socket_family, 2298 test->expected_addr, test->expected_port, 2299 &expected_addr, &expected_addr_len); 2300 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2301 goto cleanup; 2302 2303 err = cmp_sock_addr(test->ops->getsockname, serv, &expected_addr, 2304 expected_addr_len, true); 2305 if (!ASSERT_EQ(err, 0, "cmp_local_addr")) 2306 goto cleanup; 2307 2308 /* Try to connect to server just in case */ 2309 client = connect_to_addr(test->socket_type, &expected_addr, expected_addr_len, NULL); 2310 if (!ASSERT_GE(client, 0, "connect_to_addr")) 2311 goto cleanup; 2312 2313 cleanup: 2314 err = 0; 2315 err: 2316 if (client != -1) 2317 close(client); 2318 if (serv != -1) 2319 test->ops->close(serv); 2320 2321 return err; 2322 } 2323 2324 static int test_connect(struct sock_addr_test *test) 2325 { 2326 struct sockaddr_storage addr, expected_addr, expected_src_addr; 2327 socklen_t addr_len = sizeof(struct sockaddr_storage), 2328 expected_addr_len = sizeof(struct sockaddr_storage), 2329 expected_src_addr_len = sizeof(struct sockaddr_storage); 2330 int serv = -1, client = -1, err; 2331 2332 serv = start_server(test->socket_family, test->socket_type, 2333 test->expected_addr, test->expected_port, 0); 2334 if (!ASSERT_GE(serv, 0, "start_server")) 2335 goto cleanup; 2336 2337 err = make_sockaddr(test->socket_family, test->requested_addr, test->requested_port, 2338 &addr, &addr_len); 2339 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2340 goto cleanup; 2341 2342 client = test->ops->connect_to_addr(test->socket_type, &addr, addr_len, 2343 NULL); 2344 if (client < 0) { 2345 err = errno; 2346 goto err; 2347 } 2348 2349 err = make_sockaddr(test->socket_family, test->expected_addr, test->expected_port, 2350 &expected_addr, &expected_addr_len); 2351 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2352 goto cleanup; 2353 2354 if (test->expected_src_addr) { 2355 err = make_sockaddr(test->socket_family, test->expected_src_addr, 0, 2356 &expected_src_addr, &expected_src_addr_len); 2357 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2358 goto cleanup; 2359 } 2360 2361 err = cmp_sock_addr(test->ops->getpeername, client, &expected_addr, 2362 expected_addr_len, true); 2363 if (!ASSERT_EQ(err, 0, "cmp_peer_addr")) 2364 goto cleanup; 2365 2366 if (test->expected_src_addr) { 2367 err = cmp_sock_addr(test->ops->getsockname, client, 2368 &expected_src_addr, expected_src_addr_len, 2369 false); 2370 if (!ASSERT_EQ(err, 0, "cmp_local_addr")) 2371 goto cleanup; 2372 } 2373 cleanup: 2374 err = 0; 2375 err: 2376 if (client != -1) 2377 test->ops->close(client); 2378 if (serv != -1) 2379 close(serv); 2380 2381 return err; 2382 } 2383 2384 static int test_xmsg(struct sock_addr_test *test) 2385 { 2386 struct sockaddr_storage addr, src_addr; 2387 socklen_t addr_len = sizeof(struct sockaddr_storage), 2388 src_addr_len = sizeof(struct sockaddr_storage); 2389 char data = 'a'; 2390 int serv = -1, client = -1, err; 2391 2392 /* Unlike the other tests, here we test that we can rewrite the src addr 2393 * with a recvmsg() hook. 2394 */ 2395 2396 serv = start_server(test->socket_family, test->socket_type, 2397 test->expected_addr, test->expected_port, 0); 2398 if (!ASSERT_GE(serv, 0, "start_server")) 2399 goto cleanup; 2400 2401 client = test->ops->socket(test->socket_family, test->socket_type, 0); 2402 if (!ASSERT_GE(client, 0, "socket")) 2403 goto cleanup; 2404 2405 /* AF_UNIX sockets have to be bound to something to trigger the recvmsg bpf program. */ 2406 if (test->socket_family == AF_UNIX) { 2407 err = make_sockaddr(AF_UNIX, SRCUN_ADDRESS, 0, &src_addr, &src_addr_len); 2408 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2409 goto cleanup; 2410 2411 err = test->ops->bind(client, (struct sockaddr *)&src_addr, 2412 src_addr_len); 2413 if (!ASSERT_OK(err, "bind")) 2414 goto cleanup; 2415 } 2416 2417 err = make_sockaddr(test->socket_family, test->requested_addr, test->requested_port, 2418 &addr, &addr_len); 2419 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2420 goto cleanup; 2421 2422 if (test->socket_type == SOCK_DGRAM) { 2423 err = test->ops->sendmsg(client, (struct sockaddr *)&addr, 2424 addr_len, &data, sizeof(data)); 2425 if (err < 0) { 2426 err = errno; 2427 goto err; 2428 } 2429 2430 if (!ASSERT_EQ(err, sizeof(data), "sendmsg")) 2431 goto cleanup; 2432 } else { 2433 /* Testing with connection-oriented sockets is only valid for 2434 * recvmsg() tests. 2435 */ 2436 if (!ASSERT_EQ(test->type, SOCK_ADDR_TEST_RECVMSG, "recvmsg")) 2437 goto cleanup; 2438 2439 err = connect(client, (const struct sockaddr *)&addr, addr_len); 2440 if (!ASSERT_OK(err, "connect")) 2441 goto cleanup; 2442 2443 err = send(client, &data, sizeof(data), 0); 2444 if (!ASSERT_EQ(err, sizeof(data), "send")) 2445 goto cleanup; 2446 2447 err = listen(serv, 0); 2448 if (!ASSERT_OK(err, "listen")) 2449 goto cleanup; 2450 2451 err = accept(serv, NULL, NULL); 2452 if (!ASSERT_GE(err, 0, "accept")) 2453 goto cleanup; 2454 2455 close(serv); 2456 serv = err; 2457 } 2458 2459 addr_len = src_addr_len = sizeof(struct sockaddr_storage); 2460 2461 err = recvfrom(serv, &data, sizeof(data), 0, (struct sockaddr *) &src_addr, &src_addr_len); 2462 if (!ASSERT_EQ(err, sizeof(data), "recvfrom")) 2463 goto cleanup; 2464 2465 ASSERT_EQ(data, 'a', "data mismatch"); 2466 2467 if (test->expected_src_addr) { 2468 err = make_sockaddr(test->socket_family, test->expected_src_addr, 0, 2469 &addr, &addr_len); 2470 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2471 goto cleanup; 2472 2473 err = cmp_addr(&src_addr, src_addr_len, &addr, addr_len, false); 2474 if (!ASSERT_EQ(err, 0, "cmp_addr")) 2475 goto cleanup; 2476 } 2477 2478 cleanup: 2479 err = 0; 2480 err: 2481 if (client != -1) 2482 test->ops->close(client); 2483 if (serv != -1) 2484 close(serv); 2485 2486 return err; 2487 } 2488 2489 static int test_getsockname(struct sock_addr_test *test) 2490 { 2491 struct sockaddr_storage expected_addr; 2492 socklen_t expected_addr_len = sizeof(struct sockaddr_storage); 2493 int serv = -1, err; 2494 2495 serv = test->ops->start_server(test->socket_family, test->socket_type, 2496 test->requested_addr, test->requested_port, 0); 2497 if (!ASSERT_GE(serv, 0, "start_server")) 2498 goto cleanup; 2499 2500 err = make_sockaddr(test->socket_family, 2501 test->expected_addr, test->expected_port, 2502 &expected_addr, &expected_addr_len); 2503 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2504 goto cleanup; 2505 2506 err = cmp_sock_addr(test->ops->getsockname, serv, &expected_addr, expected_addr_len, true); 2507 if (!ASSERT_EQ(err, 0, "cmp_local_addr")) 2508 goto cleanup; 2509 2510 cleanup: 2511 if (serv != -1) 2512 test->ops->close(serv); 2513 2514 return 0; 2515 } 2516 2517 static int test_getpeername(struct sock_addr_test *test) 2518 { 2519 struct sockaddr_storage addr, expected_addr; 2520 socklen_t addr_len = sizeof(struct sockaddr_storage), 2521 expected_addr_len = sizeof(struct sockaddr_storage); 2522 int serv = -1, client = -1, err; 2523 2524 serv = start_server(test->socket_family, test->socket_type, 2525 test->requested_addr, test->requested_port, 0); 2526 if (!ASSERT_GE(serv, 0, "start_server")) 2527 goto cleanup; 2528 2529 err = make_sockaddr(test->socket_family, test->requested_addr, test->requested_port, 2530 &addr, &addr_len); 2531 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2532 goto cleanup; 2533 2534 client = test->ops->connect_to_addr(test->socket_type, &addr, addr_len, 2535 NULL); 2536 if (!ASSERT_GE(client, 0, "connect_to_addr")) 2537 goto cleanup; 2538 2539 err = make_sockaddr(test->socket_family, test->expected_addr, test->expected_port, 2540 &expected_addr, &expected_addr_len); 2541 if (!ASSERT_EQ(err, 0, "make_sockaddr")) 2542 goto cleanup; 2543 2544 err = cmp_sock_addr(test->ops->getpeername, client, &expected_addr, 2545 expected_addr_len, true); 2546 if (!ASSERT_EQ(err, 0, "cmp_peer_addr")) 2547 goto cleanup; 2548 2549 cleanup: 2550 if (client != -1) 2551 test->ops->close(client); 2552 if (serv != -1) 2553 close(serv); 2554 2555 return 0; 2556 } 2557 2558 static int setup_test_env(struct nstoken **tok) 2559 { 2560 int err; 2561 2562 SYS_NOFAIL("ip netns delete %s", TEST_NS); 2563 SYS(fail, "ip netns add %s", TEST_NS); 2564 *tok = open_netns(TEST_NS); 2565 if (!ASSERT_OK_PTR(*tok, "netns token")) 2566 goto fail; 2567 2568 SYS(fail, "ip link add dev %s1 type veth peer name %s2", TEST_IF_PREFIX, 2569 TEST_IF_PREFIX); 2570 SYS(fail, "ip link set lo up"); 2571 SYS(fail, "ip link set %s1 up", TEST_IF_PREFIX); 2572 SYS(fail, "ip link set %s2 up", TEST_IF_PREFIX); 2573 SYS(fail, "ip -4 addr add %s/8 dev %s1", TEST_IPV4, TEST_IF_PREFIX); 2574 SYS(fail, "ip -6 addr add %s/128 nodad dev %s1", TEST_IPV6, TEST_IF_PREFIX); 2575 2576 err = 0; 2577 goto out; 2578 fail: 2579 err = -1; 2580 close_netns(*tok); 2581 *tok = NULL; 2582 SYS_NOFAIL("ip netns delete %s", TEST_NS); 2583 out: 2584 return err; 2585 } 2586 2587 static void cleanup_test_env(struct nstoken *tok) 2588 { 2589 close_netns(tok); 2590 SYS_NOFAIL("ip netns delete %s", TEST_NS); 2591 } 2592 2593 void test_sock_addr(void) 2594 { 2595 struct nstoken *tok = NULL; 2596 int cgroup_fd = -1; 2597 void *skel; 2598 2599 cgroup_fd = test__join_cgroup("/sock_addr"); 2600 if (!ASSERT_GE(cgroup_fd, 0, "join_cgroup")) 2601 goto cleanup; 2602 2603 if (!ASSERT_OK(setup_test_env(&tok), "setup_test_env")) 2604 goto cleanup; 2605 2606 if (!ASSERT_OK(load_sock_addr_kern(), "load_sock_addr_kern")) 2607 goto cleanup; 2608 2609 for (size_t i = 0; i < ARRAY_SIZE(tests); ++i) { 2610 struct sock_addr_test *test = &tests[i]; 2611 int err; 2612 2613 if (!test__start_subtest(test->name)) 2614 continue; 2615 2616 skel = test->loadfn(cgroup_fd, test->attach_type, 2617 test->expected_result == LOAD_REJECT || 2618 test->expected_result == ATTACH_REJECT); 2619 if (!skel) 2620 continue; 2621 2622 switch (test->type) { 2623 /* Not exercised yet but we leave this code here for when the 2624 * INET and INET6 sockaddr tests are migrated to this file in 2625 * the future. 2626 */ 2627 case SOCK_ADDR_TEST_BIND: 2628 err = test_bind(test); 2629 break; 2630 case SOCK_ADDR_TEST_CONNECT: 2631 err = test_connect(test); 2632 break; 2633 case SOCK_ADDR_TEST_SENDMSG: 2634 case SOCK_ADDR_TEST_RECVMSG: 2635 err = test_xmsg(test); 2636 break; 2637 case SOCK_ADDR_TEST_GETSOCKNAME: 2638 err = test_getsockname(test); 2639 break; 2640 case SOCK_ADDR_TEST_GETPEERNAME: 2641 err = test_getpeername(test); 2642 break; 2643 default: 2644 ASSERT_TRUE(false, "Unknown sock addr test type"); 2645 break; 2646 } 2647 2648 if (test->expected_result == SYSCALL_EPERM) 2649 ASSERT_EQ(err, EPERM, "socket operation returns EPERM"); 2650 else if (test->expected_result == SYSCALL_ENOTSUPP) 2651 ASSERT_EQ(err, ENOTSUPP, "socket operation returns ENOTSUPP"); 2652 else if (test->expected_result == SUCCESS) 2653 ASSERT_OK(err, "socket operation succeeds"); 2654 2655 test->destroyfn(skel); 2656 } 2657 2658 cleanup: 2659 unload_sock_addr_kern(); 2660 cleanup_test_env(tok); 2661 if (cgroup_fd >= 0) 2662 close(cgroup_fd); 2663 } 2664