tools/testing/selftests/bpf/prog_tests/tcp_hdr_options.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2020 Facebook */
   3
   4 #define _GNU_SOURCE
   5 #include <sched.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <sys/socket.h>
   9 #include <linux/compiler.h>
  10
  11 #include "test_progs.h"
  12 #include "cgroup_helpers.h"
  13 #include "network_helpers.h"
  14 #include "test_tcp_hdr_options.h"
  15 #include "test_tcp_hdr_options.skel.h"
  16 #include "test_misc_tcp_hdr_options.skel.h"
  17
  18 #define LO_ADDR6 "::1"
  19 #define CG_NAME "/tcpbpf-hdr-opt-test"
  20
  21 static struct bpf_test_option exp_passive_estab_in;
  22 static struct bpf_test_option exp_active_estab_in;
  23 static struct bpf_test_option exp_passive_fin_in;
  24 static struct bpf_test_option exp_active_fin_in;
  25 static struct hdr_stg exp_passive_hdr_stg;
  26 static struct hdr_stg exp_active_hdr_stg = { .active = true, };
  27
  28 static struct test_misc_tcp_hdr_options *misc_skel;
  29 static struct test_tcp_hdr_options *skel;
  30 static int lport_linum_map_fd;
  31 static int hdr_stg_map_fd;
  32 static __u32 duration;
  33 static int cg_fd;
  34
  35 struct sk_fds {
  36         int srv_fd;
  37         int passive_fd;
  38         int active_fd;
  39         int passive_lport;
  40         int active_lport;
  41 };
  42
  43 static int create_netns(void)
  44 {
  45         if (CHECK(unshare(CLONE_NEWNET), "create netns",
  46                   "unshare(CLONE_NEWNET): %s (%d)",
  47                   strerror(errno), errno))
  48                 return -1;
  49
  50         if (CHECK(system("ip link set dev lo up"), "run ip cmd",
  51                   "failed to bring lo link up\n"))
  52                 return -1;
  53
  54         return 0;
  55 }
  56
  57 static int write_sysctl(const char *sysctl, const char *value)
  58 {
  59         int fd, err, len;
  60
  61         fd = open(sysctl, O_WRONLY);
  62         if (CHECK(fd == -1, "open sysctl", "open(%s): %s (%d)\n",
  63                   sysctl, strerror(errno), errno))
  64                 return -1;
  65
  66         len = strlen(value);
  67         err = write(fd, value, len);
  68         close(fd);
  69         if (CHECK(err != len, "write sysctl",
  70                   "write(%s, %s): err:%d %s (%d)\n",
  71                   sysctl, value, err, strerror(errno), errno))
  72                 return -1;
  73
  74         return 0;
  75 }
  76
  77 static void print_hdr_stg(const struct hdr_stg *hdr_stg, const char *prefix)
  78 {
  79         fprintf(stderr, "%s{active:%u, resend_syn:%u, syncookie:%u, fastopen:%u}\n",
  80                 prefix ? : "", hdr_stg->active, hdr_stg->resend_syn,
  81                 hdr_stg->syncookie, hdr_stg->fastopen);
  82 }
  83
  84 static void print_option(const struct bpf_test_option *opt, const char *prefix)
  85 {
  86         fprintf(stderr, "%s{flags:0x%x, max_delack_ms:%u, rand:0x%x}\n",
  87                 prefix ? : "", opt->flags, opt->max_delack_ms, opt->rand);
  88 }
  89
  90 static void sk_fds_close(struct sk_fds *sk_fds)
  91 {
  92         close(sk_fds->srv_fd);
  93         close(sk_fds->passive_fd);
  94         close(sk_fds->active_fd);
  95 }
  96
  97 static int sk_fds_shutdown(struct sk_fds *sk_fds)
  98 {
  99         int ret, abyte;
 100
 101         shutdown(sk_fds->active_fd, SHUT_WR);
 102         ret = read(sk_fds->passive_fd, &abyte, sizeof(abyte));
 103         if (CHECK(ret != 0, "read-after-shutdown(passive_fd):",
 104                   "ret:%d %s (%d)\n",
 105                   ret, strerror(errno), errno))
 106                 return -1;
 107
 108         shutdown(sk_fds->passive_fd, SHUT_WR);
 109         ret = read(sk_fds->active_fd, &abyte, sizeof(abyte));
 110         if (CHECK(ret != 0, "read-after-shutdown(active_fd):",
 111                   "ret:%d %s (%d)\n",
 112                   ret, strerror(errno), errno))
 113                 return -1;
 114
 115         return 0;
 116 }
 117
 118 static int sk_fds_connect(struct sk_fds *sk_fds, bool fast_open)
 119 {
 120         const char fast[] = "FAST!!!";
 121         struct sockaddr_in6 addr6;
 122         socklen_t len;
 123
 124         sk_fds->srv_fd = start_server(AF_INET6, SOCK_STREAM, LO_ADDR6, 0, 0);
 125         if (CHECK(sk_fds->srv_fd == -1, "start_server", "%s (%d)\n",
 126                   strerror(errno), errno))
 127                 goto error;
 128
 129         if (fast_open)
 130                 sk_fds->active_fd = fastopen_connect(sk_fds->srv_fd, fast,
 131                                                      sizeof(fast), 0);
 132         else
 133                 sk_fds->active_fd = connect_to_fd(sk_fds->srv_fd, 0);
 134
 135         if (CHECK_FAIL(sk_fds->active_fd == -1)) {
 136                 close(sk_fds->srv_fd);
 137                 goto error;
 138         }
 139
 140         len = sizeof(addr6);
 141         if (CHECK(getsockname(sk_fds->srv_fd, (struct sockaddr *)&addr6,
 142                               &len), "getsockname(srv_fd)", "%s (%d)\n",
 143                   strerror(errno), errno))
 144                 goto error_close;
 145         sk_fds->passive_lport = ntohs(addr6.sin6_port);
 146
 147         len = sizeof(addr6);
 148         if (CHECK(getsockname(sk_fds->active_fd, (struct sockaddr *)&addr6,
 149                               &len), "getsockname(active_fd)", "%s (%d)\n",
 150                   strerror(errno), errno))
 151                 goto error_close;
 152         sk_fds->active_lport = ntohs(addr6.sin6_port);
 153
 154         sk_fds->passive_fd = accept(sk_fds->srv_fd, NULL, 0);
 155         if (CHECK(sk_fds->passive_fd == -1, "accept(srv_fd)", "%s (%d)\n",
 156                   strerror(errno), errno))
 157                 goto error_close;
 158
 159         if (fast_open) {
 160                 char bytes_in[sizeof(fast)];
 161                 int ret;
 162
 163                 ret = read(sk_fds->passive_fd, bytes_in, sizeof(bytes_in));
 164                 if (CHECK(ret != sizeof(fast), "read fastopen syn data",
 165                           "expected=%lu actual=%d\n", sizeof(fast), ret)) {
 166                         close(sk_fds->passive_fd);
 167                         goto error_close;
 168                 }
 169         }
 170
 171         return 0;
 172
 173 error_close:
 174         close(sk_fds->active_fd);
 175         close(sk_fds->srv_fd);
 176
 177 error:
 178         memset(sk_fds, -1, sizeof(*sk_fds));
 179         return -1;
 180 }
 181
 182 static int check_hdr_opt(const struct bpf_test_option *exp,
 183                          const struct bpf_test_option *act,
 184                          const char *hdr_desc)
 185 {
 186         if (CHECK(memcmp(exp, act, sizeof(*exp)),
 187                   "expected-vs-actual", "unexpected %s\n", hdr_desc)) {
 188                 print_option(exp, "expected: ");
 189                 print_option(act, "  actual: ");
 190                 return -1;
 191         }
 192
 193         return 0;
 194 }
 195
 196 static int check_hdr_stg(const struct hdr_stg *exp, int fd,
 197                          const char *stg_desc)
 198 {
 199         struct hdr_stg act;
 200
 201         if (CHECK(bpf_map_lookup_elem(hdr_stg_map_fd, &fd, &act),
 202                   "map_lookup(hdr_stg_map_fd)", "%s %s (%d)\n",
 203                   stg_desc, strerror(errno), errno))
 204                 return -1;
 205
 206         if (CHECK(memcmp(exp, &act, sizeof(*exp)),
 207                   "expected-vs-actual", "unexpected %s\n", stg_desc)) {
 208                 print_hdr_stg(exp, "expected: ");
 209                 print_hdr_stg(&act, "  actual: ");
 210                 return -1;
 211         }
 212
 213         return 0;
 214 }
 215
 216 static int check_error_linum(const struct sk_fds *sk_fds)
 217 {
 218         unsigned int nr_errors = 0;
 219         struct linum_err linum_err;
 220         int lport;
 221
 222         lport = sk_fds->passive_lport;
 223         if (!bpf_map_lookup_elem(lport_linum_map_fd, &lport, &linum_err)) {
 224                 fprintf(stderr,
 225                         "bpf prog error out at lport:passive(%d), linum:%u err:%d\n",
 226                         lport, linum_err.linum, linum_err.err);
 227                 nr_errors++;
 228         }
 229
 230         lport = sk_fds->active_lport;
 231         if (!bpf_map_lookup_elem(lport_linum_map_fd, &lport, &linum_err)) {
 232                 fprintf(stderr,
 233                         "bpf prog error out at lport:active(%d), linum:%u err:%d\n",
 234                         lport, linum_err.linum, linum_err.err);
 235                 nr_errors++;
 236         }
 237
 238         return nr_errors;
 239 }
 240
 241 static void check_hdr_and_close_fds(struct sk_fds *sk_fds)
 242 {
 243         const __u32 expected_inherit_cb_flags =
 244                 BPF_SOCK_OPS_PARSE_UNKNOWN_HDR_OPT_CB_FLAG |
 245                 BPF_SOCK_OPS_WRITE_HDR_OPT_CB_FLAG |
 246                 BPF_SOCK_OPS_STATE_CB_FLAG;
 247
 248         if (sk_fds_shutdown(sk_fds))
 249                 goto check_linum;
 250
 251         if (CHECK(expected_inherit_cb_flags != skel->bss->inherit_cb_flags,
 252                   "Unexpected inherit_cb_flags", "0x%x != 0x%x\n",
 253                   skel->bss->inherit_cb_flags, expected_inherit_cb_flags))
 254                 goto check_linum;
 255
 256         if (check_hdr_stg(&exp_passive_hdr_stg, sk_fds->passive_fd,
 257                           "passive_hdr_stg"))
 258                 goto check_linum;
 259
 260         if (check_hdr_stg(&exp_active_hdr_stg, sk_fds->active_fd,
 261                           "active_hdr_stg"))
 262                 goto check_linum;
 263
 264         if (check_hdr_opt(&exp_passive_estab_in, &skel->bss->passive_estab_in,
 265                           "passive_estab_in"))
 266                 goto check_linum;
 267
 268         if (check_hdr_opt(&exp_active_estab_in, &skel->bss->active_estab_in,
 269                           "active_estab_in"))
 270                 goto check_linum;
 271
 272         if (check_hdr_opt(&exp_passive_fin_in, &skel->bss->passive_fin_in,
 273                           "passive_fin_in"))
 274                 goto check_linum;
 275
 276         check_hdr_opt(&exp_active_fin_in, &skel->bss->active_fin_in,
 277                       "active_fin_in");
 278
 279 check_linum:
 280         CHECK_FAIL(check_error_linum(sk_fds));
 281         sk_fds_close(sk_fds);
 282 }
 283
 284 static void prepare_out(void)
 285 {
 286         skel->bss->active_syn_out = exp_passive_estab_in;
 287         skel->bss->passive_synack_out = exp_active_estab_in;
 288
 289         skel->bss->active_fin_out = exp_passive_fin_in;
 290         skel->bss->passive_fin_out = exp_active_fin_in;
 291 }
 292
 293 static void reset_test(void)
 294 {
 295         size_t optsize = sizeof(struct bpf_test_option);
 296         int lport, err;
 297
 298         memset(&skel->bss->passive_synack_out, 0, optsize);
 299         memset(&skel->bss->passive_fin_out, 0, optsize);
 300
 301         memset(&skel->bss->passive_estab_in, 0, optsize);
 302         memset(&skel->bss->passive_fin_in, 0, optsize);
 303
 304         memset(&skel->bss->active_syn_out, 0, optsize);
 305         memset(&skel->bss->active_fin_out, 0, optsize);
 306
 307         memset(&skel->bss->active_estab_in, 0, optsize);
 308         memset(&skel->bss->active_fin_in, 0, optsize);
 309
 310         skel->bss->inherit_cb_flags = 0;
 311
 312         skel->data->test_kind = TCPOPT_EXP;
 313         skel->data->test_magic = 0xeB9F;
 314
 315         memset(&exp_passive_estab_in, 0, optsize);
 316         memset(&exp_active_estab_in, 0, optsize);
 317         memset(&exp_passive_fin_in, 0, optsize);
 318         memset(&exp_active_fin_in, 0, optsize);
 319
 320         memset(&exp_passive_hdr_stg, 0, sizeof(exp_passive_hdr_stg));
 321         memset(&exp_active_hdr_stg, 0, sizeof(exp_active_hdr_stg));
 322         exp_active_hdr_stg.active = true;
 323
 324         err = bpf_map_get_next_key(lport_linum_map_fd, NULL, &lport);
 325         while (!err) {
 326                 bpf_map_delete_elem(lport_linum_map_fd, &lport);
 327                 err = bpf_map_get_next_key(lport_linum_map_fd, &lport, &lport);
 328         }
 329 }
 330
 331 static void fastopen_estab(void)
 332 {
 333         struct bpf_link *link;
 334         struct sk_fds sk_fds;
 335
 336         hdr_stg_map_fd = bpf_map__fd(skel->maps.hdr_stg_map);
 337         lport_linum_map_fd = bpf_map__fd(skel->maps.lport_linum_map);
 338
 339         exp_passive_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS;
 340         exp_passive_estab_in.rand = 0xfa;
 341         exp_passive_estab_in.max_delack_ms = 11;
 342
 343         exp_active_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS;
 344         exp_active_estab_in.rand = 0xce;
 345         exp_active_estab_in.max_delack_ms = 22;
 346
 347         exp_passive_hdr_stg.fastopen = true;
 348
 349         prepare_out();
 350
 351         /* Allow fastopen without fastopen cookie */
 352         if (write_sysctl("/proc/sys/net/ipv4/tcp_fastopen", "1543"))
 353                 return;
 354
 355         link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
 356         if (CHECK(IS_ERR(link), "attach_cgroup(estab)", "err: %ld\n",
 357                   PTR_ERR(link)))
 358                 return;
 359
 360         if (sk_fds_connect(&sk_fds, true)) {
 361                 bpf_link__destroy(link);
 362                 return;
 363         }
 364
 365         check_hdr_and_close_fds(&sk_fds);
 366         bpf_link__destroy(link);
 367 }
 368
 369 static void syncookie_estab(void)
 370 {
 371         struct bpf_link *link;
 372         struct sk_fds sk_fds;
 373
 374         hdr_stg_map_fd = bpf_map__fd(skel->maps.hdr_stg_map);
 375         lport_linum_map_fd = bpf_map__fd(skel->maps.lport_linum_map);
 376
 377         exp_passive_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS;
 378         exp_passive_estab_in.rand = 0xfa;
 379         exp_passive_estab_in.max_delack_ms = 11;
 380
 381         exp_active_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS |
 382                                         OPTION_F_RESEND;
 383         exp_active_estab_in.rand = 0xce;
 384         exp_active_estab_in.max_delack_ms = 22;
 385
 386         exp_passive_hdr_stg.syncookie = true;
 387         exp_active_hdr_stg.resend_syn = true,
 388
 389         prepare_out();
 390
 391         /* Clear the RESEND to ensure the bpf prog can learn
 392          * want_cookie and set the RESEND by itself.
 393          */
 394         skel->bss->passive_synack_out.flags &= ~OPTION_F_RESEND;
 395
 396         /* Enforce syncookie mode */
 397         if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "2"))
 398                 return;
 399
 400         link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
 401         if (CHECK(IS_ERR(link), "attach_cgroup(estab)", "err: %ld\n",
 402                   PTR_ERR(link)))
 403                 return;
 404
 405         if (sk_fds_connect(&sk_fds, false)) {
 406                 bpf_link__destroy(link);
 407                 return;
 408         }
 409
 410         check_hdr_and_close_fds(&sk_fds);
 411         bpf_link__destroy(link);
 412 }
 413
 414 static void fin(void)
 415 {
 416         struct bpf_link *link;
 417         struct sk_fds sk_fds;
 418
 419         hdr_stg_map_fd = bpf_map__fd(skel->maps.hdr_stg_map);
 420         lport_linum_map_fd = bpf_map__fd(skel->maps.lport_linum_map);
 421
 422         exp_passive_fin_in.flags = OPTION_F_RAND;
 423         exp_passive_fin_in.rand = 0xfa;
 424
 425         exp_active_fin_in.flags = OPTION_F_RAND;
 426         exp_active_fin_in.rand = 0xce;
 427
 428         prepare_out();
 429
 430         if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "1"))
 431                 return;
 432
 433         link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
 434         if (CHECK(IS_ERR(link), "attach_cgroup(estab)", "err: %ld\n",
 435                   PTR_ERR(link)))
 436                 return;
 437
 438         if (sk_fds_connect(&sk_fds, false)) {
 439                 bpf_link__destroy(link);
 440                 return;
 441         }
 442
 443         check_hdr_and_close_fds(&sk_fds);
 444         bpf_link__destroy(link);
 445 }
 446
 447 static void __simple_estab(bool exprm)
 448 {
 449         struct bpf_link *link;
 450         struct sk_fds sk_fds;
 451
 452         hdr_stg_map_fd = bpf_map__fd(skel->maps.hdr_stg_map);
 453         lport_linum_map_fd = bpf_map__fd(skel->maps.lport_linum_map);
 454
 455         exp_passive_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS;
 456         exp_passive_estab_in.rand = 0xfa;
 457         exp_passive_estab_in.max_delack_ms = 11;
 458
 459         exp_active_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS;
 460         exp_active_estab_in.rand = 0xce;
 461         exp_active_estab_in.max_delack_ms = 22;
 462
 463         prepare_out();
 464
 465         if (!exprm) {
 466                 skel->data->test_kind = 0xB9;
 467                 skel->data->test_magic = 0;
 468         }
 469
 470         if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "1"))
 471                 return;
 472
 473         link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
 474         if (CHECK(IS_ERR(link), "attach_cgroup(estab)", "err: %ld\n",
 475                   PTR_ERR(link)))
 476                 return;
 477
 478         if (sk_fds_connect(&sk_fds, false)) {
 479                 bpf_link__destroy(link);
 480                 return;
 481         }
 482
 483         check_hdr_and_close_fds(&sk_fds);
 484         bpf_link__destroy(link);
 485 }
 486
 487 static void no_exprm_estab(void)
 488 {
 489         __simple_estab(false);
 490 }
 491
 492 static void simple_estab(void)
 493 {
 494         __simple_estab(true);
 495 }
 496
 497 static void misc(void)
 498 {
 499         const char send_msg[] = "MISC!!!";
 500         char recv_msg[sizeof(send_msg)];
 501         const unsigned int nr_data = 2;
 502         struct bpf_link *link;
 503         struct sk_fds sk_fds;
 504         int i, ret;
 505
 506         lport_linum_map_fd = bpf_map__fd(misc_skel->maps.lport_linum_map);
 507
 508         if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "1"))
 509                 return;
 510
 511         link = bpf_program__attach_cgroup(misc_skel->progs.misc_estab, cg_fd);
 512         if (CHECK(IS_ERR(link), "attach_cgroup(misc_estab)", "err: %ld\n",
 513                   PTR_ERR(link)))
 514                 return;
 515
 516         if (sk_fds_connect(&sk_fds, false)) {
 517                 bpf_link__destroy(link);
 518                 return;
 519         }
 520
 521         for (i = 0; i < nr_data; i++) {
 522                 /* MSG_EOR to ensure skb will not be combined */
 523                 ret = send(sk_fds.active_fd, send_msg, sizeof(send_msg),
 524                            MSG_EOR);
 525                 if (CHECK(ret != sizeof(send_msg), "send(msg)", "ret:%d\n",
 526                           ret))
 527                         goto check_linum;
 528
 529                 ret = read(sk_fds.passive_fd, recv_msg, sizeof(recv_msg));
 530                 if (CHECK(ret != sizeof(send_msg), "read(msg)", "ret:%d\n",
 531                           ret))
 532                         goto check_linum;
 533         }
 534
 535         if (sk_fds_shutdown(&sk_fds))
 536                 goto check_linum;
 537
 538         CHECK(misc_skel->bss->nr_syn != 1, "unexpected nr_syn",
 539               "expected (1) != actual (%u)\n",
 540                 misc_skel->bss->nr_syn);
 541
 542         CHECK(misc_skel->bss->nr_data != nr_data, "unexpected nr_data",
 543               "expected (%u) != actual (%u)\n",
 544               nr_data, misc_skel->bss->nr_data);
 545
 546         /* The last ACK may have been delayed, so it is either 1 or 2. */
 547         CHECK(misc_skel->bss->nr_pure_ack != 1 &&
 548               misc_skel->bss->nr_pure_ack != 2,
 549               "unexpected nr_pure_ack",
 550               "expected (1 or 2) != actual (%u)\n",
 551                 misc_skel->bss->nr_pure_ack);
 552
 553         CHECK(misc_skel->bss->nr_fin != 1, "unexpected nr_fin",
 554               "expected (1) != actual (%u)\n",
 555               misc_skel->bss->nr_fin);
 556
 557 check_linum:
 558         CHECK_FAIL(check_error_linum(&sk_fds));
 559         sk_fds_close(&sk_fds);
 560         bpf_link__destroy(link);
 561 }
 562
 563 struct test {
 564         const char *desc;
 565         void (*run)(void);
 566 };
 567
 568 #define DEF_TEST(name) { #name, name }
 569 static struct test tests[] = {
 570         DEF_TEST(simple_estab),
 571         DEF_TEST(no_exprm_estab),
 572         DEF_TEST(syncookie_estab),
 573         DEF_TEST(fastopen_estab),
 574         DEF_TEST(fin),
 575         DEF_TEST(misc),
 576 };
 577
 578 void test_tcp_hdr_options(void)
 579 {
 580         int i;
 581
 582         skel = test_tcp_hdr_options__open_and_load();
 583         if (CHECK(!skel, "open and load skel", "failed"))
 584                 return;
 585
 586         misc_skel = test_misc_tcp_hdr_options__open_and_load();
 587         if (CHECK(!misc_skel, "open and load misc test skel", "failed"))
 588                 goto skel_destroy;
 589
 590         cg_fd = test__join_cgroup(CG_NAME);
 591         if (CHECK_FAIL(cg_fd < 0))
 592                 goto skel_destroy;
 593
 594         for (i = 0; i < ARRAY_SIZE(tests); i++) {
 595                 if (!test__start_subtest(tests[i].desc))
 596                         continue;
 597
 598                 if (create_netns())
 599                         break;
 600
 601                 tests[i].run();
 602
 603                 reset_test();
 604         }
 605
 606         close(cg_fd);
 607 skel_destroy:
 608         test_misc_tcp_hdr_options__destroy(misc_skel);
 609         test_tcp_hdr_options__destroy(skel);
 610 }