xref: /linux/tools/testing/selftests/bpf/prog_tests/tcp_hdr_options.c (revision 58d416351e6df1a41d415958ccdd8eb9c2173fed) 
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 (!ASSERT_OK_PTR(link, "attach_cgroup(estab)"))
357 		return;
358 
359 	if (sk_fds_connect(&sk_fds, true)) {
360 		bpf_link__destroy(link);
361 		return;
362 	}
363 
364 	check_hdr_and_close_fds(&sk_fds);
365 	bpf_link__destroy(link);
366 }
367 
368 static void syncookie_estab(void)
369 {
370 	struct bpf_link *link;
371 	struct sk_fds sk_fds;
372 
373 	hdr_stg_map_fd = bpf_map__fd(skel->maps.hdr_stg_map);
374 	lport_linum_map_fd = bpf_map__fd(skel->maps.lport_linum_map);
375 
376 	exp_passive_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS;
377 	exp_passive_estab_in.rand = 0xfa;
378 	exp_passive_estab_in.max_delack_ms = 11;
379 
380 	exp_active_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS |
381 					OPTION_F_RESEND;
382 	exp_active_estab_in.rand = 0xce;
383 	exp_active_estab_in.max_delack_ms = 22;
384 
385 	exp_passive_hdr_stg.syncookie = true;
386 	exp_active_hdr_stg.resend_syn = true,
387 
388 	prepare_out();
389 
390 	/* Clear the RESEND to ensure the bpf prog can learn
391 	 * want_cookie and set the RESEND by itself.
392 	 */
393 	skel->bss->passive_synack_out.flags &= ~OPTION_F_RESEND;
394 
395 	/* Enforce syncookie mode */
396 	if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "2"))
397 		return;
398 
399 	link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
400 	if (!ASSERT_OK_PTR(link, "attach_cgroup(estab)"))
401 		return;
402 
403 	if (sk_fds_connect(&sk_fds, false)) {
404 		bpf_link__destroy(link);
405 		return;
406 	}
407 
408 	check_hdr_and_close_fds(&sk_fds);
409 	bpf_link__destroy(link);
410 }
411 
412 static void fin(void)
413 {
414 	struct bpf_link *link;
415 	struct sk_fds sk_fds;
416 
417 	hdr_stg_map_fd = bpf_map__fd(skel->maps.hdr_stg_map);
418 	lport_linum_map_fd = bpf_map__fd(skel->maps.lport_linum_map);
419 
420 	exp_passive_fin_in.flags = OPTION_F_RAND;
421 	exp_passive_fin_in.rand = 0xfa;
422 
423 	exp_active_fin_in.flags = OPTION_F_RAND;
424 	exp_active_fin_in.rand = 0xce;
425 
426 	prepare_out();
427 
428 	if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "1"))
429 		return;
430 
431 	link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
432 	if (!ASSERT_OK_PTR(link, "attach_cgroup(estab)"))
433 		return;
434 
435 	if (sk_fds_connect(&sk_fds, false)) {
436 		bpf_link__destroy(link);
437 		return;
438 	}
439 
440 	check_hdr_and_close_fds(&sk_fds);
441 	bpf_link__destroy(link);
442 }
443 
444 static void __simple_estab(bool exprm)
445 {
446 	struct bpf_link *link;
447 	struct sk_fds sk_fds;
448 
449 	hdr_stg_map_fd = bpf_map__fd(skel->maps.hdr_stg_map);
450 	lport_linum_map_fd = bpf_map__fd(skel->maps.lport_linum_map);
451 
452 	exp_passive_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS;
453 	exp_passive_estab_in.rand = 0xfa;
454 	exp_passive_estab_in.max_delack_ms = 11;
455 
456 	exp_active_estab_in.flags = OPTION_F_RAND | OPTION_F_MAX_DELACK_MS;
457 	exp_active_estab_in.rand = 0xce;
458 	exp_active_estab_in.max_delack_ms = 22;
459 
460 	prepare_out();
461 
462 	if (!exprm) {
463 		skel->data->test_kind = 0xB9;
464 		skel->data->test_magic = 0;
465 	}
466 
467 	if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "1"))
468 		return;
469 
470 	link = bpf_program__attach_cgroup(skel->progs.estab, cg_fd);
471 	if (!ASSERT_OK_PTR(link, "attach_cgroup(estab)"))
472 		return;
473 
474 	if (sk_fds_connect(&sk_fds, false)) {
475 		bpf_link__destroy(link);
476 		return;
477 	}
478 
479 	check_hdr_and_close_fds(&sk_fds);
480 	bpf_link__destroy(link);
481 }
482 
483 static void no_exprm_estab(void)
484 {
485 	__simple_estab(false);
486 }
487 
488 static void simple_estab(void)
489 {
490 	__simple_estab(true);
491 }
492 
493 static void misc(void)
494 {
495 	const char send_msg[] = "MISC!!!";
496 	char recv_msg[sizeof(send_msg)];
497 	const unsigned int nr_data = 2;
498 	struct bpf_link *link;
499 	struct sk_fds sk_fds;
500 	int i, ret;
501 
502 	lport_linum_map_fd = bpf_map__fd(misc_skel->maps.lport_linum_map);
503 
504 	if (write_sysctl("/proc/sys/net/ipv4/tcp_syncookies", "1"))
505 		return;
506 
507 	link = bpf_program__attach_cgroup(misc_skel->progs.misc_estab, cg_fd);
508 	if (!ASSERT_OK_PTR(link, "attach_cgroup(misc_estab)"))
509 		return;
510 
511 	if (sk_fds_connect(&sk_fds, false)) {
512 		bpf_link__destroy(link);
513 		return;
514 	}
515 
516 	for (i = 0; i < nr_data; i++) {
517 		/* MSG_EOR to ensure skb will not be combined */
518 		ret = send(sk_fds.active_fd, send_msg, sizeof(send_msg),
519 			   MSG_EOR);
520 		if (CHECK(ret != sizeof(send_msg), "send(msg)", "ret:%d\n",
521 			  ret))
522 			goto check_linum;
523 
524 		ret = read(sk_fds.passive_fd, recv_msg, sizeof(recv_msg));
525 		if (CHECK(ret != sizeof(send_msg), "read(msg)", "ret:%d\n",
526 			  ret))
527 			goto check_linum;
528 	}
529 
530 	if (sk_fds_shutdown(&sk_fds))
531 		goto check_linum;
532 
533 	CHECK(misc_skel->bss->nr_syn != 1, "unexpected nr_syn",
534 	      "expected (1) != actual (%u)\n",
535 		misc_skel->bss->nr_syn);
536 
537 	CHECK(misc_skel->bss->nr_data != nr_data, "unexpected nr_data",
538 	      "expected (%u) != actual (%u)\n",
539 	      nr_data, misc_skel->bss->nr_data);
540 
541 	/* The last ACK may have been delayed, so it is either 1 or 2. */
542 	CHECK(misc_skel->bss->nr_pure_ack != 1 &&
543 	      misc_skel->bss->nr_pure_ack != 2,
544 	      "unexpected nr_pure_ack",
545 	      "expected (1 or 2) != actual (%u)\n",
546 		misc_skel->bss->nr_pure_ack);
547 
548 	CHECK(misc_skel->bss->nr_fin != 1, "unexpected nr_fin",
549 	      "expected (1) != actual (%u)\n",
550 	      misc_skel->bss->nr_fin);
551 
552 check_linum:
553 	CHECK_FAIL(check_error_linum(&sk_fds));
554 	sk_fds_close(&sk_fds);
555 	bpf_link__destroy(link);
556 }
557 
558 struct test {
559 	const char *desc;
560 	void (*run)(void);
561 };
562 
563 #define DEF_TEST(name) { #name, name }
564 static struct test tests[] = {
565 	DEF_TEST(simple_estab),
566 	DEF_TEST(no_exprm_estab),
567 	DEF_TEST(syncookie_estab),
568 	DEF_TEST(fastopen_estab),
569 	DEF_TEST(fin),
570 	DEF_TEST(misc),
571 };
572 
573 void test_tcp_hdr_options(void)
574 {
575 	int i;
576 
577 	skel = test_tcp_hdr_options__open_and_load();
578 	if (CHECK(!skel, "open and load skel", "failed"))
579 		return;
580 
581 	misc_skel = test_misc_tcp_hdr_options__open_and_load();
582 	if (CHECK(!misc_skel, "open and load misc test skel", "failed"))
583 		goto skel_destroy;
584 
585 	cg_fd = test__join_cgroup(CG_NAME);
586 	if (CHECK_FAIL(cg_fd < 0))
587 		goto skel_destroy;
588 
589 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
590 		if (!test__start_subtest(tests[i].desc))
591 			continue;
592 
593 		if (create_netns())
594 			break;
595 
596 		tests[i].run();
597 
598 		reset_test();
599 	}
600 
601 	close(cg_fd);
602 skel_destroy:
603 	test_misc_tcp_hdr_options__destroy(misc_skel);
604 	test_tcp_hdr_options__destroy(skel);
605 }
606