1 // SPDX-License-Identifier: GPL-2.0
14 #include <linux/tls.h>
15 #include <linux/tcp.h>
16 #include <linux/socket.h>
18 #include <sys/types.h>
19 #include <sys/sendfile.h>
20 #include <sys/socket.h>
23 #include "../kselftest_harness.h"
25 #define TLS_PAYLOAD_MAX_LEN 16384
34 FIXTURE_SETUP(tls_basic)
36 struct sockaddr_in addr;
43 addr.sin_family = AF_INET;
44 addr.sin_addr.s_addr = htonl(INADDR_ANY);
47 self->fd = socket(AF_INET, SOCK_STREAM, 0);
48 sfd = socket(AF_INET, SOCK_STREAM, 0);
50 ret = bind(sfd, &addr, sizeof(addr));
52 ret = listen(sfd, 10);
55 ret = getsockname(sfd, &addr, &len);
58 ret = connect(self->fd, &addr, sizeof(addr));
61 self->cfd = accept(sfd, &addr, &len);
62 ASSERT_GE(self->cfd, 0);
66 ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
68 ASSERT_EQ(errno, ENOENT);
70 printf("Failure setting TCP_ULP, testing without tls\n");
74 ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
78 FIXTURE_TEARDOWN(tls_basic)
84 /* Send some data through with ULP but no keys */
85 TEST_F(tls_basic, base_base)
87 char const *test_str = "test_read";
91 ASSERT_EQ(strlen(test_str) + 1, send_len);
93 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
94 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
95 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
106 unsigned int tls_version;
109 FIXTURE_VARIANT_ADD(tls, 12)
111 .tls_version = TLS_1_2_VERSION,
114 FIXTURE_VARIANT_ADD(tls, 13)
116 .tls_version = TLS_1_3_VERSION,
121 struct tls12_crypto_info_aes_gcm_128 tls12;
122 struct sockaddr_in addr;
129 memset(&tls12, 0, sizeof(tls12));
130 tls12.info.version = variant->tls_version;
131 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
133 addr.sin_family = AF_INET;
134 addr.sin_addr.s_addr = htonl(INADDR_ANY);
137 self->fd = socket(AF_INET, SOCK_STREAM, 0);
138 sfd = socket(AF_INET, SOCK_STREAM, 0);
140 ret = bind(sfd, &addr, sizeof(addr));
142 ret = listen(sfd, 10);
145 ret = getsockname(sfd, &addr, &len);
148 ret = connect(self->fd, &addr, sizeof(addr));
151 ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
154 printf("Failure setting TCP_ULP, testing without tls\n");
158 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12,
163 self->cfd = accept(sfd, &addr, &len);
164 ASSERT_GE(self->cfd, 0);
167 ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls",
171 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12,
179 FIXTURE_TEARDOWN(tls)
185 TEST_F(tls, sendfile)
187 int filefd = open("/proc/self/exe", O_RDONLY);
190 EXPECT_GE(filefd, 0);
192 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
195 TEST_F(tls, send_then_sendfile)
197 int filefd = open("/proc/self/exe", O_RDONLY);
198 char const *test_str = "test_send";
199 int to_send = strlen(test_str) + 1;
204 EXPECT_GE(filefd, 0);
206 buf = (char *)malloc(st.st_size);
208 EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send);
209 EXPECT_EQ(recv(self->cfd, recv_buf, to_send, MSG_WAITALL), to_send);
210 EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);
212 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
213 EXPECT_EQ(recv(self->cfd, buf, st.st_size, MSG_WAITALL), st.st_size);
216 static void chunked_sendfile(struct __test_metadata *_metadata,
217 struct _test_data_tls *self,
219 uint16_t extra_payload_size)
221 char buf[TLS_PAYLOAD_MAX_LEN];
222 uint16_t test_payload_size;
225 char filename[] = "/tmp/mytemp.XXXXXX";
226 int fd = mkstemp(filename);
231 EXPECT_GE(chunk_size, 1);
232 test_payload_size = chunk_size + extra_payload_size;
233 ASSERT_GE(TLS_PAYLOAD_MAX_LEN, test_payload_size);
234 memset(buf, 1, test_payload_size);
235 size = write(fd, buf, test_payload_size);
236 EXPECT_EQ(size, test_payload_size);
240 ret = sendfile(self->fd, fd, &offset, chunk_size);
245 EXPECT_EQ(recv(self->cfd, buf, test_payload_size, MSG_WAITALL),
251 TEST_F(tls, multi_chunk_sendfile)
253 chunked_sendfile(_metadata, self, 4096, 4096);
254 chunked_sendfile(_metadata, self, 4096, 0);
255 chunked_sendfile(_metadata, self, 4096, 1);
256 chunked_sendfile(_metadata, self, 4096, 2048);
257 chunked_sendfile(_metadata, self, 8192, 2048);
258 chunked_sendfile(_metadata, self, 4096, 8192);
259 chunked_sendfile(_metadata, self, 8192, 4096);
260 chunked_sendfile(_metadata, self, 12288, 1024);
261 chunked_sendfile(_metadata, self, 12288, 2000);
262 chunked_sendfile(_metadata, self, 15360, 100);
263 chunked_sendfile(_metadata, self, 15360, 300);
264 chunked_sendfile(_metadata, self, 1, 4096);
265 chunked_sendfile(_metadata, self, 2048, 4096);
266 chunked_sendfile(_metadata, self, 2048, 8192);
267 chunked_sendfile(_metadata, self, 4096, 8192);
268 chunked_sendfile(_metadata, self, 1024, 12288);
269 chunked_sendfile(_metadata, self, 2000, 12288);
270 chunked_sendfile(_metadata, self, 100, 15360);
271 chunked_sendfile(_metadata, self, 300, 15360);
274 TEST_F(tls, recv_max)
276 unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
277 char recv_mem[TLS_PAYLOAD_MAX_LEN];
278 char buf[TLS_PAYLOAD_MAX_LEN];
280 EXPECT_GE(send(self->fd, buf, send_len, 0), 0);
281 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
282 EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0);
285 TEST_F(tls, recv_small)
287 char const *test_str = "test_read";
291 send_len = strlen(test_str) + 1;
292 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
293 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
294 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
297 TEST_F(tls, msg_more)
299 char const *test_str = "test_read";
303 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
304 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
305 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
306 EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_WAITALL),
308 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
311 TEST_F(tls, msg_more_unsent)
313 char const *test_str = "test_read";
317 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
318 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
321 TEST_F(tls, sendmsg_single)
325 char const *test_str = "test_sendmsg";
326 size_t send_len = 13;
330 vec.iov_base = (char *)test_str;
331 vec.iov_len = send_len;
332 memset(&msg, 0, sizeof(struct msghdr));
335 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
336 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
337 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
342 TEST_F(tls, sendmsg_fragmented)
344 char const *test_str = "test_sendmsg";
345 char buf[SEND_LEN * MAX_FRAGS];
346 struct iovec vec[MAX_FRAGS];
350 for (frags = 1; frags <= MAX_FRAGS; frags++) {
351 for (i = 0; i < frags; i++) {
352 vec[i].iov_base = (char *)test_str;
353 vec[i].iov_len = SEND_LEN;
356 memset(&msg, 0, sizeof(struct msghdr));
358 msg.msg_iovlen = frags;
360 EXPECT_EQ(sendmsg(self->fd, &msg, 0), SEND_LEN * frags);
361 EXPECT_EQ(recv(self->cfd, buf, SEND_LEN * frags, MSG_WAITALL),
364 for (i = 0; i < frags; i++)
365 EXPECT_EQ(memcmp(buf + SEND_LEN * i,
366 test_str, SEND_LEN), 0);
372 TEST_F(tls, sendmsg_large)
374 void *mem = malloc(16384);
375 size_t send_len = 16384;
381 memset(&msg, 0, sizeof(struct msghdr));
382 while (sent++ < sends) {
383 struct iovec vec = { (void *)mem, send_len };
387 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), send_len);
390 while (recvs++ < sends)
391 EXPECT_NE(recv(self->fd, mem, send_len, 0), -1);
396 TEST_F(tls, sendmsg_multiple)
398 char const *test_str = "test_sendmsg_multiple";
408 memset(&msg, 0, sizeof(struct msghdr));
409 for (i = 0; i < iov_len; i++) {
410 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
411 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
412 vec[i].iov_base = (void *)test_strs[i];
413 vec[i].iov_len = strlen(test_strs[i]) + 1;
414 total_len += vec[i].iov_len;
417 msg.msg_iovlen = iov_len;
419 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), total_len);
420 buf = malloc(total_len);
421 EXPECT_NE(recv(self->fd, buf, total_len, 0), -1);
422 for (i = 0; i < iov_len; i++) {
423 EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
424 strlen(test_strs[i])),
426 len_cmp += strlen(buf + len_cmp) + 1;
428 for (i = 0; i < iov_len; i++)
433 TEST_F(tls, sendmsg_multiple_stress)
435 char const *test_str = "abcdefghijklmno";
436 struct iovec vec[1024];
437 char *test_strs[1024];
445 memset(&msg, 0, sizeof(struct msghdr));
446 for (i = 0; i < iov_len; i++) {
447 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
448 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
449 vec[i].iov_base = (void *)test_strs[i];
450 vec[i].iov_len = strlen(test_strs[i]) + 1;
451 total_len += vec[i].iov_len;
454 msg.msg_iovlen = iov_len;
456 EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
457 EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
459 for (i = 0; i < iov_len; i++)
460 len_cmp += strlen(buf + len_cmp) + 1;
462 for (i = 0; i < iov_len; i++)
466 TEST_F(tls, splice_from_pipe)
468 int send_len = TLS_PAYLOAD_MAX_LEN;
469 char mem_send[TLS_PAYLOAD_MAX_LEN];
470 char mem_recv[TLS_PAYLOAD_MAX_LEN];
473 ASSERT_GE(pipe(p), 0);
474 EXPECT_GE(write(p[1], mem_send, send_len), 0);
475 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
476 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
477 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
480 TEST_F(tls, splice_from_pipe2)
482 int send_len = 16000;
483 char mem_send[16000];
484 char mem_recv[16000];
488 ASSERT_GE(pipe(p), 0);
489 ASSERT_GE(pipe(p2), 0);
490 EXPECT_GE(write(p[1], mem_send, 8000), 0);
491 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
492 EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
493 EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
494 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
495 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
498 TEST_F(tls, send_and_splice)
500 int send_len = TLS_PAYLOAD_MAX_LEN;
501 char mem_send[TLS_PAYLOAD_MAX_LEN];
502 char mem_recv[TLS_PAYLOAD_MAX_LEN];
503 char const *test_str = "test_read";
508 ASSERT_GE(pipe(p), 0);
509 EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
510 EXPECT_EQ(recv(self->cfd, buf, send_len2, MSG_WAITALL), send_len2);
511 EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);
513 EXPECT_GE(write(p[1], mem_send, send_len), send_len);
514 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);
516 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
517 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
520 TEST_F(tls, splice_to_pipe)
522 int send_len = TLS_PAYLOAD_MAX_LEN;
523 char mem_send[TLS_PAYLOAD_MAX_LEN];
524 char mem_recv[TLS_PAYLOAD_MAX_LEN];
527 ASSERT_GE(pipe(p), 0);
528 EXPECT_GE(send(self->fd, mem_send, send_len, 0), 0);
529 EXPECT_GE(splice(self->cfd, NULL, p[1], NULL, send_len, 0), 0);
530 EXPECT_GE(read(p[0], mem_recv, send_len), 0);
531 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
534 TEST_F(tls, recvmsg_single)
536 char const *test_str = "test_recvmsg_single";
537 int send_len = strlen(test_str) + 1;
542 memset(&hdr, 0, sizeof(hdr));
543 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
544 vec.iov_base = (char *)buf;
545 vec.iov_len = send_len;
548 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
549 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
552 TEST_F(tls, recvmsg_single_max)
554 int send_len = TLS_PAYLOAD_MAX_LEN;
555 char send_mem[TLS_PAYLOAD_MAX_LEN];
556 char recv_mem[TLS_PAYLOAD_MAX_LEN];
560 EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
561 vec.iov_base = (char *)recv_mem;
562 vec.iov_len = TLS_PAYLOAD_MAX_LEN;
566 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
567 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
570 TEST_F(tls, recvmsg_multiple)
572 unsigned int msg_iovlen = 1024;
573 unsigned int len_compared = 0;
574 struct iovec vec[1024];
575 char *iov_base[1024];
576 unsigned int iov_len = 16;
577 int send_len = 1 << 14;
582 EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
583 for (i = 0; i < msg_iovlen; i++) {
584 iov_base[i] = (char *)malloc(iov_len);
585 vec[i].iov_base = iov_base[i];
586 vec[i].iov_len = iov_len;
589 hdr.msg_iovlen = msg_iovlen;
591 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
592 for (i = 0; i < msg_iovlen; i++)
593 len_compared += iov_len;
595 for (i = 0; i < msg_iovlen; i++)
599 TEST_F(tls, single_send_multiple_recv)
601 unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
602 unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
603 char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
604 char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];
606 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
607 memset(recv_mem, 0, total_len);
609 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
610 EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
611 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
614 TEST_F(tls, multiple_send_single_recv)
616 unsigned int total_len = 2 * 10;
617 unsigned int send_len = 10;
618 char recv_mem[2 * 10];
621 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
622 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
623 memset(recv_mem, 0, total_len);
624 EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len);
626 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
627 EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
630 TEST_F(tls, single_send_multiple_recv_non_align)
632 const unsigned int total_len = 15;
633 const unsigned int recv_len = 10;
634 char recv_mem[recv_len * 2];
635 char send_mem[total_len];
637 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
638 memset(recv_mem, 0, total_len);
640 EXPECT_EQ(recv(self->cfd, recv_mem, recv_len, 0), recv_len);
641 EXPECT_EQ(recv(self->cfd, recv_mem + recv_len, recv_len, 0), 5);
642 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
645 TEST_F(tls, recv_partial)
647 char const *test_str = "test_read_partial";
648 char const *test_str_first = "test_read";
649 char const *test_str_second = "_partial";
650 int send_len = strlen(test_str) + 1;
653 memset(recv_mem, 0, sizeof(recv_mem));
654 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
655 EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first),
657 EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
658 memset(recv_mem, 0, sizeof(recv_mem));
659 EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second),
661 EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
665 TEST_F(tls, recv_nonblock)
670 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
671 err = (errno == EAGAIN || errno == EWOULDBLOCK);
672 EXPECT_EQ(err, true);
675 TEST_F(tls, recv_peek)
677 char const *test_str = "test_read_peek";
678 int send_len = strlen(test_str) + 1;
681 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
682 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
683 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
684 memset(buf, 0, sizeof(buf));
685 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
686 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
689 TEST_F(tls, recv_peek_multiple)
691 char const *test_str = "test_read_peek";
692 int send_len = strlen(test_str) + 1;
693 unsigned int num_peeks = 100;
697 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
698 for (i = 0; i < num_peeks; i++) {
699 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
700 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
701 memset(buf, 0, sizeof(buf));
703 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
704 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
707 TEST_F(tls, recv_peek_multiple_records)
709 char const *test_str = "test_read_peek_mult_recs";
710 char const *test_str_first = "test_read_peek";
711 char const *test_str_second = "_mult_recs";
715 len = strlen(test_str_first);
716 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
718 len = strlen(test_str_second) + 1;
719 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
721 len = strlen(test_str_first);
723 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
725 /* MSG_PEEK can only peek into the current record. */
726 len = strlen(test_str_first);
727 EXPECT_EQ(memcmp(test_str_first, buf, len), 0);
729 len = strlen(test_str) + 1;
731 EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len);
733 /* Non-MSG_PEEK will advance strparser (and therefore record)
736 len = strlen(test_str) + 1;
737 EXPECT_EQ(memcmp(test_str, buf, len), 0);
739 /* MSG_MORE will hold current record open, so later MSG_PEEK
740 * will see everything.
742 len = strlen(test_str_first);
743 EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len);
745 len = strlen(test_str_second) + 1;
746 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
748 len = strlen(test_str) + 1;
750 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
752 len = strlen(test_str) + 1;
753 EXPECT_EQ(memcmp(test_str, buf, len), 0);
756 TEST_F(tls, recv_peek_large_buf_mult_recs)
758 char const *test_str = "test_read_peek_mult_recs";
759 char const *test_str_first = "test_read_peek";
760 char const *test_str_second = "_mult_recs";
764 len = strlen(test_str_first);
765 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
767 len = strlen(test_str_second) + 1;
768 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
770 len = strlen(test_str) + 1;
772 EXPECT_NE((len = recv(self->cfd, buf, len,
773 MSG_PEEK | MSG_WAITALL)), -1);
774 len = strlen(test_str) + 1;
775 EXPECT_EQ(memcmp(test_str, buf, len), 0);
778 TEST_F(tls, recv_lowat)
780 char send_mem[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
784 EXPECT_EQ(send(self->fd, send_mem, 10, 0), 10);
785 EXPECT_EQ(send(self->fd, send_mem, 5, 0), 5);
787 memset(recv_mem, 0, 20);
788 EXPECT_EQ(setsockopt(self->cfd, SOL_SOCKET, SO_RCVLOWAT,
789 &lowat, sizeof(lowat)), 0);
790 EXPECT_EQ(recv(self->cfd, recv_mem, 1, MSG_WAITALL), 1);
791 EXPECT_EQ(recv(self->cfd, recv_mem + 1, 6, MSG_WAITALL), 6);
792 EXPECT_EQ(recv(self->cfd, recv_mem + 7, 10, 0), 8);
794 EXPECT_EQ(memcmp(send_mem, recv_mem, 10), 0);
795 EXPECT_EQ(memcmp(send_mem, recv_mem + 10, 5), 0);
800 char const *test_str = "test_read";
806 struct tls12_crypto_info_aes_gcm_128 tls12;
808 memset(&tls12, 0, sizeof(tls12));
809 tls12.info.version = variant->tls_version;
810 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
812 ret = setsockopt(self->fd, SOL_TLS, TLS_RX, &tls12,
816 ret = setsockopt(self->cfd, SOL_TLS, TLS_TX, &tls12,
821 ASSERT_EQ(strlen(test_str) + 1, send_len);
823 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
824 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
825 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
827 memset(buf, 0, sizeof(buf));
829 EXPECT_EQ(send(self->cfd, test_str, send_len, 0), send_len);
830 EXPECT_NE(recv(self->fd, buf, send_len, 0), -1);
831 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
836 char const *test_str = "test_poll";
837 struct pollfd fd = { 0, 0, 0 };
841 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
845 EXPECT_EQ(poll(&fd, 1, 20), 1);
846 EXPECT_EQ(fd.revents & POLLIN, 1);
847 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
848 /* Test timing out */
849 EXPECT_EQ(poll(&fd, 1, 20), 0);
852 TEST_F(tls, poll_wait)
854 char const *test_str = "test_poll_wait";
855 int send_len = strlen(test_str) + 1;
856 struct pollfd fd = { 0, 0, 0 };
861 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
862 /* Set timeout to inf. secs */
863 EXPECT_EQ(poll(&fd, 1, -1), 1);
864 EXPECT_EQ(fd.revents & POLLIN, 1);
865 EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len);
868 TEST_F(tls, poll_wait_split)
870 struct pollfd fd = { 0, 0, 0 };
871 char send_mem[20] = {};
877 EXPECT_EQ(send(self->fd, send_mem, sizeof(send_mem), 0),
879 /* Poll with inf. timeout */
880 EXPECT_EQ(poll(&fd, 1, -1), 1);
881 EXPECT_EQ(fd.revents & POLLIN, 1);
882 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), MSG_WAITALL),
885 /* Now the remaining 5 bytes of record data are in TLS ULP */
888 EXPECT_EQ(poll(&fd, 1, -1), 1);
889 EXPECT_EQ(fd.revents & POLLIN, 1);
890 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), 0),
891 sizeof(send_mem) - sizeof(recv_mem));
894 TEST_F(tls, blocking)
896 size_t data = 100000;
909 int res = send(self->fd, buf,
910 left > 16384 ? 16384 : left, 0);
916 pid2 = wait(&status);
917 EXPECT_EQ(status, 0);
918 EXPECT_EQ(res, pid2);
925 int res = recv(self->cfd, buf,
926 left > 16384 ? 16384 : left, 0);
934 TEST_F(tls, nonblocking)
936 size_t data = 100000;
941 flags = fcntl(self->fd, F_GETFL, 0);
942 fcntl(self->fd, F_SETFL, flags | O_NONBLOCK);
943 fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK);
945 /* Ensure nonblocking behavior by imposing a small send
948 EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
949 &sendbuf, sizeof(sendbuf)), 0);
963 int res = send(self->fd, buf,
964 left > 16384 ? 16384 : left, 0);
966 if (res == -1 && errno == EAGAIN) {
976 pid2 = wait(&status);
978 EXPECT_EQ(status, 0);
979 EXPECT_EQ(res, pid2);
987 int res = recv(self->cfd, buf,
988 left > 16384 ? 16384 : left, 0);
990 if (res == -1 && errno == EAGAIN) {
1003 test_mutliproc(struct __test_metadata *_metadata, struct _test_data_tls *self,
1004 bool sendpg, unsigned int n_readers, unsigned int n_writers)
1006 const unsigned int n_children = n_readers + n_writers;
1007 const size_t data = 6 * 1000 * 1000;
1008 const size_t file_sz = data / 100;
1009 size_t read_bias, write_bias;
1010 int i, fd, child_id;
1014 /* Only allow multiples for simplicity */
1015 ASSERT_EQ(!(n_readers % n_writers) || !(n_writers % n_readers), true);
1016 read_bias = n_writers / n_readers ?: 1;
1017 write_bias = n_readers / n_writers ?: 1;
1019 /* prep a file to send */
1020 fd = open("/tmp/", O_TMPFILE | O_RDWR, 0600);
1023 memset(buf, 0xac, file_sz);
1024 ASSERT_EQ(write(fd, buf, file_sz), file_sz);
1026 /* spawn children */
1027 for (child_id = 0; child_id < n_children; child_id++) {
1034 /* parent waits for all children */
1036 for (i = 0; i < n_children; i++) {
1040 EXPECT_EQ(status, 0);
1046 /* Split threads for reading and writing */
1047 if (child_id < n_readers) {
1048 size_t left = data * read_bias;
1054 res = recv(self->cfd, rb,
1055 left > sizeof(rb) ? sizeof(rb) : left, 0);
1061 size_t left = data * write_bias;
1066 ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0);
1068 res = sendfile(self->fd, fd, NULL,
1069 left > file_sz ? file_sz : left);
1071 res = send(self->fd, buf,
1072 left > file_sz ? file_sz : left, 0);
1080 TEST_F(tls, mutliproc_even)
1082 test_mutliproc(_metadata, self, false, 6, 6);
1085 TEST_F(tls, mutliproc_readers)
1087 test_mutliproc(_metadata, self, false, 4, 12);
1090 TEST_F(tls, mutliproc_writers)
1092 test_mutliproc(_metadata, self, false, 10, 2);
1095 TEST_F(tls, mutliproc_sendpage_even)
1097 test_mutliproc(_metadata, self, true, 6, 6);
1100 TEST_F(tls, mutliproc_sendpage_readers)
1102 test_mutliproc(_metadata, self, true, 4, 12);
1105 TEST_F(tls, mutliproc_sendpage_writers)
1107 test_mutliproc(_metadata, self, true, 10, 2);
1110 TEST_F(tls, control_msg)
1115 char cbuf[CMSG_SPACE(sizeof(char))];
1116 char const *test_str = "test_read";
1117 int cmsg_len = sizeof(char);
1118 char record_type = 100;
1119 struct cmsghdr *cmsg;
1125 vec.iov_base = (char *)test_str;
1127 memset(&msg, 0, sizeof(struct msghdr));
1130 msg.msg_control = cbuf;
1131 msg.msg_controllen = sizeof(cbuf);
1132 cmsg = CMSG_FIRSTHDR(&msg);
1133 cmsg->cmsg_level = SOL_TLS;
1134 /* test sending non-record types. */
1135 cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
1136 cmsg->cmsg_len = CMSG_LEN(cmsg_len);
1137 *CMSG_DATA(cmsg) = record_type;
1138 msg.msg_controllen = cmsg->cmsg_len;
1140 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
1141 /* Should fail because we didn't provide a control message */
1142 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
1145 EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL | MSG_PEEK), send_len);
1147 cmsg = CMSG_FIRSTHDR(&msg);
1148 EXPECT_NE(cmsg, NULL);
1149 EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
1150 EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
1151 record_type = *((unsigned char *)CMSG_DATA(cmsg));
1152 EXPECT_EQ(record_type, 100);
1153 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1155 /* Recv the message again without MSG_PEEK */
1157 memset(buf, 0, sizeof(buf));
1159 EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL), send_len);
1160 cmsg = CMSG_FIRSTHDR(&msg);
1161 EXPECT_NE(cmsg, NULL);
1162 EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
1163 EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
1164 record_type = *((unsigned char *)CMSG_DATA(cmsg));
1165 EXPECT_EQ(record_type, 100);
1166 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1169 TEST_F(tls, shutdown)
1171 char const *test_str = "test_read";
1175 ASSERT_EQ(strlen(test_str) + 1, send_len);
1177 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1178 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
1179 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1181 shutdown(self->fd, SHUT_RDWR);
1182 shutdown(self->cfd, SHUT_RDWR);
1185 TEST_F(tls, shutdown_unsent)
1187 char const *test_str = "test_read";
1190 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
1192 shutdown(self->fd, SHUT_RDWR);
1193 shutdown(self->cfd, SHUT_RDWR);
1196 TEST_F(tls, shutdown_reuse)
1198 struct sockaddr_in addr;
1201 shutdown(self->fd, SHUT_RDWR);
1202 shutdown(self->cfd, SHUT_RDWR);
1205 addr.sin_family = AF_INET;
1206 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1209 ret = bind(self->fd, &addr, sizeof(addr));
1211 ret = listen(self->fd, 10);
1213 EXPECT_EQ(errno, EINVAL);
1215 ret = connect(self->fd, &addr, sizeof(addr));
1217 EXPECT_EQ(errno, EISCONN);
1220 TEST(non_established) {
1221 struct tls12_crypto_info_aes_gcm_256 tls12;
1222 struct sockaddr_in addr;
1228 memset(&tls12, 0, sizeof(tls12));
1229 tls12.info.version = TLS_1_2_VERSION;
1230 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1232 addr.sin_family = AF_INET;
1233 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1236 fd = socket(AF_INET, SOCK_STREAM, 0);
1237 sfd = socket(AF_INET, SOCK_STREAM, 0);
1239 ret = bind(sfd, &addr, sizeof(addr));
1241 ret = listen(sfd, 10);
1244 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1246 /* TLS ULP not supported */
1247 if (errno == ENOENT)
1249 EXPECT_EQ(errno, ENOTCONN);
1251 ret = setsockopt(sfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1253 EXPECT_EQ(errno, ENOTCONN);
1255 ret = getsockname(sfd, &addr, &len);
1258 ret = connect(fd, &addr, sizeof(addr));
1261 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1264 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1266 EXPECT_EQ(errno, EEXIST);
1273 struct tls12_crypto_info_aes_gcm_256 tls12;
1274 struct sockaddr_in addr;
1275 int sfd, ret, fd, cfd;
1282 memset(&tls12, 0, sizeof(tls12));
1283 tls12.info.version = TLS_1_2_VERSION;
1284 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1286 addr.sin_family = AF_INET;
1287 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1290 fd = socket(AF_INET, SOCK_STREAM, 0);
1291 sfd = socket(AF_INET, SOCK_STREAM, 0);
1293 ret = bind(sfd, &addr, sizeof(addr));
1295 ret = listen(sfd, 10);
1298 ret = getsockname(sfd, &addr, &len);
1301 ret = connect(fd, &addr, sizeof(addr));
1304 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1307 printf("Failure setting TCP_ULP, testing without tls\n");
1311 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12,
1316 cfd = accept(sfd, &addr, &len);
1320 ret = setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls",
1324 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12,