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