This source file includes following definitions.
- FIXTURE
- FIXTURE_SETUP
- FIXTURE_TEARDOWN
- TEST_F
- FIXTURE
- FIXTURE_SETUP
- FIXTURE_TEARDOWN
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- test_mutliproc
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST
- TEST
- TEST
1
2
3 #define _GNU_SOURCE
4
5 #include <arpa/inet.h>
6 #include <errno.h>
7 #include <error.h>
8 #include <fcntl.h>
9 #include <poll.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <unistd.h>
13
14 #include <linux/tls.h>
15 #include <linux/tcp.h>
16 #include <linux/socket.h>
17
18 #include <sys/types.h>
19 #include <sys/sendfile.h>
20 #include <sys/socket.h>
21 #include <sys/stat.h>
22
23 #include "../kselftest_harness.h"
24
25 #define TLS_PAYLOAD_MAX_LEN 16384
26 #define SOL_TLS 282
27
28 FIXTURE(tls_basic)
29 {
30 int fd, cfd;
31 bool notls;
32 };
33
34 FIXTURE_SETUP(tls_basic)
35 {
36 struct sockaddr_in addr;
37 socklen_t len;
38 int sfd, ret;
39
40 self->notls = false;
41 len = sizeof(addr);
42
43 addr.sin_family = AF_INET;
44 addr.sin_addr.s_addr = htonl(INADDR_ANY);
45 addr.sin_port = 0;
46
47 self->fd = socket(AF_INET, SOCK_STREAM, 0);
48 sfd = socket(AF_INET, SOCK_STREAM, 0);
49
50 ret = bind(sfd, &addr, sizeof(addr));
51 ASSERT_EQ(ret, 0);
52 ret = listen(sfd, 10);
53 ASSERT_EQ(ret, 0);
54
55 ret = getsockname(sfd, &addr, &len);
56 ASSERT_EQ(ret, 0);
57
58 ret = connect(self->fd, &addr, sizeof(addr));
59 ASSERT_EQ(ret, 0);
60
61 self->cfd = accept(sfd, &addr, &len);
62 ASSERT_GE(self->cfd, 0);
63
64 close(sfd);
65
66 ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
67 if (ret != 0) {
68 ASSERT_EQ(errno, ENOENT);
69 self->notls = true;
70 printf("Failure setting TCP_ULP, testing without tls\n");
71 return;
72 }
73
74 ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
75 ASSERT_EQ(ret, 0);
76 }
77
78 FIXTURE_TEARDOWN(tls_basic)
79 {
80 close(self->fd);
81 close(self->cfd);
82 }
83
84
85 TEST_F(tls_basic, base_base)
86 {
87 char const *test_str = "test_read";
88 int send_len = 10;
89 char buf[10];
90
91 ASSERT_EQ(strlen(test_str) + 1, send_len);
92
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);
96 };
97
98 FIXTURE(tls)
99 {
100 int fd, cfd;
101 bool notls;
102 };
103
104 FIXTURE_SETUP(tls)
105 {
106 struct tls12_crypto_info_aes_gcm_128 tls12;
107 struct sockaddr_in addr;
108 socklen_t len;
109 int sfd, ret;
110
111 self->notls = false;
112 len = sizeof(addr);
113
114 memset(&tls12, 0, sizeof(tls12));
115 tls12.info.version = TLS_1_3_VERSION;
116 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
117
118 addr.sin_family = AF_INET;
119 addr.sin_addr.s_addr = htonl(INADDR_ANY);
120 addr.sin_port = 0;
121
122 self->fd = socket(AF_INET, SOCK_STREAM, 0);
123 sfd = socket(AF_INET, SOCK_STREAM, 0);
124
125 ret = bind(sfd, &addr, sizeof(addr));
126 ASSERT_EQ(ret, 0);
127 ret = listen(sfd, 10);
128 ASSERT_EQ(ret, 0);
129
130 ret = getsockname(sfd, &addr, &len);
131 ASSERT_EQ(ret, 0);
132
133 ret = connect(self->fd, &addr, sizeof(addr));
134 ASSERT_EQ(ret, 0);
135
136 ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
137 if (ret != 0) {
138 self->notls = true;
139 printf("Failure setting TCP_ULP, testing without tls\n");
140 }
141
142 if (!self->notls) {
143 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12,
144 sizeof(tls12));
145 ASSERT_EQ(ret, 0);
146 }
147
148 self->cfd = accept(sfd, &addr, &len);
149 ASSERT_GE(self->cfd, 0);
150
151 if (!self->notls) {
152 ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls",
153 sizeof("tls"));
154 ASSERT_EQ(ret, 0);
155
156 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12,
157 sizeof(tls12));
158 ASSERT_EQ(ret, 0);
159 }
160
161 close(sfd);
162 }
163
164 FIXTURE_TEARDOWN(tls)
165 {
166 close(self->fd);
167 close(self->cfd);
168 }
169
170 TEST_F(tls, sendfile)
171 {
172 int filefd = open("/proc/self/exe", O_RDONLY);
173 struct stat st;
174
175 EXPECT_GE(filefd, 0);
176 fstat(filefd, &st);
177 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
178 }
179
180 TEST_F(tls, send_then_sendfile)
181 {
182 int filefd = open("/proc/self/exe", O_RDONLY);
183 char const *test_str = "test_send";
184 int to_send = strlen(test_str) + 1;
185 char recv_buf[10];
186 struct stat st;
187 char *buf;
188
189 EXPECT_GE(filefd, 0);
190 fstat(filefd, &st);
191 buf = (char *)malloc(st.st_size);
192
193 EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send);
194 EXPECT_EQ(recv(self->cfd, recv_buf, to_send, MSG_WAITALL), to_send);
195 EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);
196
197 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
198 EXPECT_EQ(recv(self->cfd, buf, st.st_size, MSG_WAITALL), st.st_size);
199 }
200
201 TEST_F(tls, recv_max)
202 {
203 unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
204 char recv_mem[TLS_PAYLOAD_MAX_LEN];
205 char buf[TLS_PAYLOAD_MAX_LEN];
206
207 EXPECT_GE(send(self->fd, buf, send_len, 0), 0);
208 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
209 EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0);
210 }
211
212 TEST_F(tls, recv_small)
213 {
214 char const *test_str = "test_read";
215 int send_len = 10;
216 char buf[10];
217
218 send_len = strlen(test_str) + 1;
219 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
220 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
221 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
222 }
223
224 TEST_F(tls, msg_more)
225 {
226 char const *test_str = "test_read";
227 int send_len = 10;
228 char buf[10 * 2];
229
230 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
231 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
232 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
233 EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_WAITALL),
234 send_len * 2);
235 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
236 }
237
238 TEST_F(tls, msg_more_unsent)
239 {
240 char const *test_str = "test_read";
241 int send_len = 10;
242 char buf[10];
243
244 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
245 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
246 }
247
248 TEST_F(tls, sendmsg_single)
249 {
250 struct msghdr msg;
251
252 char const *test_str = "test_sendmsg";
253 size_t send_len = 13;
254 struct iovec vec;
255 char buf[13];
256
257 vec.iov_base = (char *)test_str;
258 vec.iov_len = send_len;
259 memset(&msg, 0, sizeof(struct msghdr));
260 msg.msg_iov = &vec;
261 msg.msg_iovlen = 1;
262 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
263 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
264 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
265 }
266
267 #define MAX_FRAGS 64
268 #define SEND_LEN 13
269 TEST_F(tls, sendmsg_fragmented)
270 {
271 char const *test_str = "test_sendmsg";
272 char buf[SEND_LEN * MAX_FRAGS];
273 struct iovec vec[MAX_FRAGS];
274 struct msghdr msg;
275 int i, frags;
276
277 for (frags = 1; frags <= MAX_FRAGS; frags++) {
278 for (i = 0; i < frags; i++) {
279 vec[i].iov_base = (char *)test_str;
280 vec[i].iov_len = SEND_LEN;
281 }
282
283 memset(&msg, 0, sizeof(struct msghdr));
284 msg.msg_iov = vec;
285 msg.msg_iovlen = frags;
286
287 EXPECT_EQ(sendmsg(self->fd, &msg, 0), SEND_LEN * frags);
288 EXPECT_EQ(recv(self->cfd, buf, SEND_LEN * frags, MSG_WAITALL),
289 SEND_LEN * frags);
290
291 for (i = 0; i < frags; i++)
292 EXPECT_EQ(memcmp(buf + SEND_LEN * i,
293 test_str, SEND_LEN), 0);
294 }
295 }
296 #undef MAX_FRAGS
297 #undef SEND_LEN
298
299 TEST_F(tls, sendmsg_large)
300 {
301 void *mem = malloc(16384);
302 size_t send_len = 16384;
303 size_t sends = 128;
304 struct msghdr msg;
305 size_t recvs = 0;
306 size_t sent = 0;
307
308 memset(&msg, 0, sizeof(struct msghdr));
309 while (sent++ < sends) {
310 struct iovec vec = { (void *)mem, send_len };
311
312 msg.msg_iov = &vec;
313 msg.msg_iovlen = 1;
314 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), send_len);
315 }
316
317 while (recvs++ < sends)
318 EXPECT_NE(recv(self->fd, mem, send_len, 0), -1);
319
320 free(mem);
321 }
322
323 TEST_F(tls, sendmsg_multiple)
324 {
325 char const *test_str = "test_sendmsg_multiple";
326 struct iovec vec[5];
327 char *test_strs[5];
328 struct msghdr msg;
329 int total_len = 0;
330 int len_cmp = 0;
331 int iov_len = 5;
332 char *buf;
333 int i;
334
335 memset(&msg, 0, sizeof(struct msghdr));
336 for (i = 0; i < iov_len; i++) {
337 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
338 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
339 vec[i].iov_base = (void *)test_strs[i];
340 vec[i].iov_len = strlen(test_strs[i]) + 1;
341 total_len += vec[i].iov_len;
342 }
343 msg.msg_iov = vec;
344 msg.msg_iovlen = iov_len;
345
346 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), total_len);
347 buf = malloc(total_len);
348 EXPECT_NE(recv(self->fd, buf, total_len, 0), -1);
349 for (i = 0; i < iov_len; i++) {
350 EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
351 strlen(test_strs[i])),
352 0);
353 len_cmp += strlen(buf + len_cmp) + 1;
354 }
355 for (i = 0; i < iov_len; i++)
356 free(test_strs[i]);
357 free(buf);
358 }
359
360 TEST_F(tls, sendmsg_multiple_stress)
361 {
362 char const *test_str = "abcdefghijklmno";
363 struct iovec vec[1024];
364 char *test_strs[1024];
365 int iov_len = 1024;
366 int total_len = 0;
367 char buf[1 << 14];
368 struct msghdr msg;
369 int len_cmp = 0;
370 int i;
371
372 memset(&msg, 0, sizeof(struct msghdr));
373 for (i = 0; i < iov_len; i++) {
374 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
375 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
376 vec[i].iov_base = (void *)test_strs[i];
377 vec[i].iov_len = strlen(test_strs[i]) + 1;
378 total_len += vec[i].iov_len;
379 }
380 msg.msg_iov = vec;
381 msg.msg_iovlen = iov_len;
382
383 EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
384 EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
385
386 for (i = 0; i < iov_len; i++)
387 len_cmp += strlen(buf + len_cmp) + 1;
388
389 for (i = 0; i < iov_len; i++)
390 free(test_strs[i]);
391 }
392
393 TEST_F(tls, splice_from_pipe)
394 {
395 int send_len = TLS_PAYLOAD_MAX_LEN;
396 char mem_send[TLS_PAYLOAD_MAX_LEN];
397 char mem_recv[TLS_PAYLOAD_MAX_LEN];
398 int p[2];
399
400 ASSERT_GE(pipe(p), 0);
401 EXPECT_GE(write(p[1], mem_send, send_len), 0);
402 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
403 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
404 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
405 }
406
407 TEST_F(tls, splice_from_pipe2)
408 {
409 int send_len = 16000;
410 char mem_send[16000];
411 char mem_recv[16000];
412 int p2[2];
413 int p[2];
414
415 ASSERT_GE(pipe(p), 0);
416 ASSERT_GE(pipe(p2), 0);
417 EXPECT_GE(write(p[1], mem_send, 8000), 0);
418 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
419 EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
420 EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
421 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
422 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
423 }
424
425 TEST_F(tls, send_and_splice)
426 {
427 int send_len = TLS_PAYLOAD_MAX_LEN;
428 char mem_send[TLS_PAYLOAD_MAX_LEN];
429 char mem_recv[TLS_PAYLOAD_MAX_LEN];
430 char const *test_str = "test_read";
431 int send_len2 = 10;
432 char buf[10];
433 int p[2];
434
435 ASSERT_GE(pipe(p), 0);
436 EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
437 EXPECT_EQ(recv(self->cfd, buf, send_len2, MSG_WAITALL), send_len2);
438 EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);
439
440 EXPECT_GE(write(p[1], mem_send, send_len), send_len);
441 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);
442
443 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
444 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
445 }
446
447 TEST_F(tls, splice_to_pipe)
448 {
449 int send_len = TLS_PAYLOAD_MAX_LEN;
450 char mem_send[TLS_PAYLOAD_MAX_LEN];
451 char mem_recv[TLS_PAYLOAD_MAX_LEN];
452 int p[2];
453
454 ASSERT_GE(pipe(p), 0);
455 EXPECT_GE(send(self->fd, mem_send, send_len, 0), 0);
456 EXPECT_GE(splice(self->cfd, NULL, p[1], NULL, send_len, 0), 0);
457 EXPECT_GE(read(p[0], mem_recv, send_len), 0);
458 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
459 }
460
461 TEST_F(tls, recvmsg_single)
462 {
463 char const *test_str = "test_recvmsg_single";
464 int send_len = strlen(test_str) + 1;
465 char buf[20];
466 struct msghdr hdr;
467 struct iovec vec;
468
469 memset(&hdr, 0, sizeof(hdr));
470 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
471 vec.iov_base = (char *)buf;
472 vec.iov_len = send_len;
473 hdr.msg_iovlen = 1;
474 hdr.msg_iov = &vec;
475 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
476 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
477 }
478
479 TEST_F(tls, recvmsg_single_max)
480 {
481 int send_len = TLS_PAYLOAD_MAX_LEN;
482 char send_mem[TLS_PAYLOAD_MAX_LEN];
483 char recv_mem[TLS_PAYLOAD_MAX_LEN];
484 struct iovec vec;
485 struct msghdr hdr;
486
487 EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
488 vec.iov_base = (char *)recv_mem;
489 vec.iov_len = TLS_PAYLOAD_MAX_LEN;
490
491 hdr.msg_iovlen = 1;
492 hdr.msg_iov = &vec;
493 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
494 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
495 }
496
497 TEST_F(tls, recvmsg_multiple)
498 {
499 unsigned int msg_iovlen = 1024;
500 unsigned int len_compared = 0;
501 struct iovec vec[1024];
502 char *iov_base[1024];
503 unsigned int iov_len = 16;
504 int send_len = 1 << 14;
505 char buf[1 << 14];
506 struct msghdr hdr;
507 int i;
508
509 EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
510 for (i = 0; i < msg_iovlen; i++) {
511 iov_base[i] = (char *)malloc(iov_len);
512 vec[i].iov_base = iov_base[i];
513 vec[i].iov_len = iov_len;
514 }
515
516 hdr.msg_iovlen = msg_iovlen;
517 hdr.msg_iov = vec;
518 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
519 for (i = 0; i < msg_iovlen; i++)
520 len_compared += iov_len;
521
522 for (i = 0; i < msg_iovlen; i++)
523 free(iov_base[i]);
524 }
525
526 TEST_F(tls, single_send_multiple_recv)
527 {
528 unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
529 unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
530 char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
531 char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];
532
533 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
534 memset(recv_mem, 0, total_len);
535
536 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
537 EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
538 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
539 }
540
541 TEST_F(tls, multiple_send_single_recv)
542 {
543 unsigned int total_len = 2 * 10;
544 unsigned int send_len = 10;
545 char recv_mem[2 * 10];
546 char send_mem[10];
547
548 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
549 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
550 memset(recv_mem, 0, total_len);
551 EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len);
552
553 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
554 EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
555 }
556
557 TEST_F(tls, single_send_multiple_recv_non_align)
558 {
559 const unsigned int total_len = 15;
560 const unsigned int recv_len = 10;
561 char recv_mem[recv_len * 2];
562 char send_mem[total_len];
563
564 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
565 memset(recv_mem, 0, total_len);
566
567 EXPECT_EQ(recv(self->cfd, recv_mem, recv_len, 0), recv_len);
568 EXPECT_EQ(recv(self->cfd, recv_mem + recv_len, recv_len, 0), 5);
569 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
570 }
571
572 TEST_F(tls, recv_partial)
573 {
574 char const *test_str = "test_read_partial";
575 char const *test_str_first = "test_read";
576 char const *test_str_second = "_partial";
577 int send_len = strlen(test_str) + 1;
578 char recv_mem[18];
579
580 memset(recv_mem, 0, sizeof(recv_mem));
581 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
582 EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first),
583 MSG_WAITALL), -1);
584 EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
585 memset(recv_mem, 0, sizeof(recv_mem));
586 EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second),
587 MSG_WAITALL), -1);
588 EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
589 0);
590 }
591
592 TEST_F(tls, recv_nonblock)
593 {
594 char buf[4096];
595 bool err;
596
597 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
598 err = (errno == EAGAIN || errno == EWOULDBLOCK);
599 EXPECT_EQ(err, true);
600 }
601
602 TEST_F(tls, recv_peek)
603 {
604 char const *test_str = "test_read_peek";
605 int send_len = strlen(test_str) + 1;
606 char buf[15];
607
608 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
609 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
610 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
611 memset(buf, 0, sizeof(buf));
612 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
613 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
614 }
615
616 TEST_F(tls, recv_peek_multiple)
617 {
618 char const *test_str = "test_read_peek";
619 int send_len = strlen(test_str) + 1;
620 unsigned int num_peeks = 100;
621 char buf[15];
622 int i;
623
624 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
625 for (i = 0; i < num_peeks; i++) {
626 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
627 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
628 memset(buf, 0, sizeof(buf));
629 }
630 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
631 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
632 }
633
634 TEST_F(tls, recv_peek_multiple_records)
635 {
636 char const *test_str = "test_read_peek_mult_recs";
637 char const *test_str_first = "test_read_peek";
638 char const *test_str_second = "_mult_recs";
639 int len;
640 char buf[64];
641
642 len = strlen(test_str_first);
643 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
644
645 len = strlen(test_str_second) + 1;
646 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
647
648 len = strlen(test_str_first);
649 memset(buf, 0, len);
650 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
651
652
653 len = strlen(test_str_first);
654 EXPECT_EQ(memcmp(test_str_first, buf, len), 0);
655
656 len = strlen(test_str) + 1;
657 memset(buf, 0, len);
658 EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len);
659
660
661
662
663 len = strlen(test_str) + 1;
664 EXPECT_EQ(memcmp(test_str, buf, len), 0);
665
666
667
668
669 len = strlen(test_str_first);
670 EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len);
671
672 len = strlen(test_str_second) + 1;
673 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
674
675 len = strlen(test_str) + 1;
676 memset(buf, 0, len);
677 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
678
679 len = strlen(test_str) + 1;
680 EXPECT_EQ(memcmp(test_str, buf, len), 0);
681 }
682
683 TEST_F(tls, recv_peek_large_buf_mult_recs)
684 {
685 char const *test_str = "test_read_peek_mult_recs";
686 char const *test_str_first = "test_read_peek";
687 char const *test_str_second = "_mult_recs";
688 int len;
689 char buf[64];
690
691 len = strlen(test_str_first);
692 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
693
694 len = strlen(test_str_second) + 1;
695 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
696
697 len = strlen(test_str) + 1;
698 memset(buf, 0, len);
699 EXPECT_NE((len = recv(self->cfd, buf, len,
700 MSG_PEEK | MSG_WAITALL)), -1);
701 len = strlen(test_str) + 1;
702 EXPECT_EQ(memcmp(test_str, buf, len), 0);
703 }
704
705 TEST_F(tls, recv_lowat)
706 {
707 char send_mem[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
708 char recv_mem[20];
709 int lowat = 8;
710
711 EXPECT_EQ(send(self->fd, send_mem, 10, 0), 10);
712 EXPECT_EQ(send(self->fd, send_mem, 5, 0), 5);
713
714 memset(recv_mem, 0, 20);
715 EXPECT_EQ(setsockopt(self->cfd, SOL_SOCKET, SO_RCVLOWAT,
716 &lowat, sizeof(lowat)), 0);
717 EXPECT_EQ(recv(self->cfd, recv_mem, 1, MSG_WAITALL), 1);
718 EXPECT_EQ(recv(self->cfd, recv_mem + 1, 6, MSG_WAITALL), 6);
719 EXPECT_EQ(recv(self->cfd, recv_mem + 7, 10, 0), 8);
720
721 EXPECT_EQ(memcmp(send_mem, recv_mem, 10), 0);
722 EXPECT_EQ(memcmp(send_mem, recv_mem + 10, 5), 0);
723 }
724
725 TEST_F(tls, bidir)
726 {
727 char const *test_str = "test_read";
728 int send_len = 10;
729 char buf[10];
730 int ret;
731
732 if (!self->notls) {
733 struct tls12_crypto_info_aes_gcm_128 tls12;
734
735 memset(&tls12, 0, sizeof(tls12));
736 tls12.info.version = TLS_1_3_VERSION;
737 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
738
739 ret = setsockopt(self->fd, SOL_TLS, TLS_RX, &tls12,
740 sizeof(tls12));
741 ASSERT_EQ(ret, 0);
742
743 ret = setsockopt(self->cfd, SOL_TLS, TLS_TX, &tls12,
744 sizeof(tls12));
745 ASSERT_EQ(ret, 0);
746 }
747
748 ASSERT_EQ(strlen(test_str) + 1, send_len);
749
750 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
751 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
752 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
753
754 memset(buf, 0, sizeof(buf));
755
756 EXPECT_EQ(send(self->cfd, test_str, send_len, 0), send_len);
757 EXPECT_NE(recv(self->fd, buf, send_len, 0), -1);
758 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
759 };
760
761 TEST_F(tls, pollin)
762 {
763 char const *test_str = "test_poll";
764 struct pollfd fd = { 0, 0, 0 };
765 char buf[10];
766 int send_len = 10;
767
768 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
769 fd.fd = self->cfd;
770 fd.events = POLLIN;
771
772 EXPECT_EQ(poll(&fd, 1, 20), 1);
773 EXPECT_EQ(fd.revents & POLLIN, 1);
774 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
775
776 EXPECT_EQ(poll(&fd, 1, 20), 0);
777 }
778
779 TEST_F(tls, poll_wait)
780 {
781 char const *test_str = "test_poll_wait";
782 int send_len = strlen(test_str) + 1;
783 struct pollfd fd = { 0, 0, 0 };
784 char recv_mem[15];
785
786 fd.fd = self->cfd;
787 fd.events = POLLIN;
788 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
789
790 EXPECT_EQ(poll(&fd, 1, -1), 1);
791 EXPECT_EQ(fd.revents & POLLIN, 1);
792 EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len);
793 }
794
795 TEST_F(tls, poll_wait_split)
796 {
797 struct pollfd fd = { 0, 0, 0 };
798 char send_mem[20] = {};
799 char recv_mem[15];
800
801 fd.fd = self->cfd;
802 fd.events = POLLIN;
803
804 EXPECT_EQ(send(self->fd, send_mem, sizeof(send_mem), 0),
805 sizeof(send_mem));
806
807 EXPECT_EQ(poll(&fd, 1, -1), 1);
808 EXPECT_EQ(fd.revents & POLLIN, 1);
809 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), MSG_WAITALL),
810 sizeof(recv_mem));
811
812
813 fd.fd = self->cfd;
814 fd.events = POLLIN;
815 EXPECT_EQ(poll(&fd, 1, -1), 1);
816 EXPECT_EQ(fd.revents & POLLIN, 1);
817 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), 0),
818 sizeof(send_mem) - sizeof(recv_mem));
819 }
820
821 TEST_F(tls, blocking)
822 {
823 size_t data = 100000;
824 int res = fork();
825
826 EXPECT_NE(res, -1);
827
828 if (res) {
829
830 size_t left = data;
831 char buf[16384];
832 int status;
833 int pid2;
834
835 while (left) {
836 int res = send(self->fd, buf,
837 left > 16384 ? 16384 : left, 0);
838
839 EXPECT_GE(res, 0);
840 left -= res;
841 }
842
843 pid2 = wait(&status);
844 EXPECT_EQ(status, 0);
845 EXPECT_EQ(res, pid2);
846 } else {
847
848 size_t left = data;
849 char buf[16384];
850
851 while (left) {
852 int res = recv(self->cfd, buf,
853 left > 16384 ? 16384 : left, 0);
854
855 EXPECT_GE(res, 0);
856 left -= res;
857 }
858 }
859 }
860
861 TEST_F(tls, nonblocking)
862 {
863 size_t data = 100000;
864 int sendbuf = 100;
865 int flags;
866 int res;
867
868 flags = fcntl(self->fd, F_GETFL, 0);
869 fcntl(self->fd, F_SETFL, flags | O_NONBLOCK);
870 fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK);
871
872
873
874
875 EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
876 &sendbuf, sizeof(sendbuf)), 0);
877
878 res = fork();
879 EXPECT_NE(res, -1);
880
881 if (res) {
882
883 bool eagain = false;
884 size_t left = data;
885 char buf[16384];
886 int status;
887 int pid2;
888
889 while (left) {
890 int res = send(self->fd, buf,
891 left > 16384 ? 16384 : left, 0);
892
893 if (res == -1 && errno == EAGAIN) {
894 eagain = true;
895 usleep(10000);
896 continue;
897 }
898 EXPECT_GE(res, 0);
899 left -= res;
900 }
901
902 EXPECT_TRUE(eagain);
903 pid2 = wait(&status);
904
905 EXPECT_EQ(status, 0);
906 EXPECT_EQ(res, pid2);
907 } else {
908
909 bool eagain = false;
910 size_t left = data;
911 char buf[16384];
912
913 while (left) {
914 int res = recv(self->cfd, buf,
915 left > 16384 ? 16384 : left, 0);
916
917 if (res == -1 && errno == EAGAIN) {
918 eagain = true;
919 usleep(10000);
920 continue;
921 }
922 EXPECT_GE(res, 0);
923 left -= res;
924 }
925 EXPECT_TRUE(eagain);
926 }
927 }
928
929 static void
930 test_mutliproc(struct __test_metadata *_metadata, struct _test_data_tls *self,
931 bool sendpg, unsigned int n_readers, unsigned int n_writers)
932 {
933 const unsigned int n_children = n_readers + n_writers;
934 const size_t data = 6 * 1000 * 1000;
935 const size_t file_sz = data / 100;
936 size_t read_bias, write_bias;
937 int i, fd, child_id;
938 char buf[file_sz];
939 pid_t pid;
940
941
942 ASSERT_EQ(!(n_readers % n_writers) || !(n_writers % n_readers), true);
943 read_bias = n_writers / n_readers ?: 1;
944 write_bias = n_readers / n_writers ?: 1;
945
946
947 fd = open("/tmp/", O_TMPFILE | O_RDWR, 0600);
948 ASSERT_GE(fd, 0);
949
950 memset(buf, 0xac, file_sz);
951 ASSERT_EQ(write(fd, buf, file_sz), file_sz);
952
953
954 for (child_id = 0; child_id < n_children; child_id++) {
955 pid = fork();
956 ASSERT_NE(pid, -1);
957 if (!pid)
958 break;
959 }
960
961
962 if (pid) {
963 for (i = 0; i < n_children; i++) {
964 int status;
965
966 wait(&status);
967 EXPECT_EQ(status, 0);
968 }
969
970 return;
971 }
972
973
974 if (child_id < n_readers) {
975 size_t left = data * read_bias;
976 char rb[8001];
977
978 while (left) {
979 int res;
980
981 res = recv(self->cfd, rb,
982 left > sizeof(rb) ? sizeof(rb) : left, 0);
983
984 EXPECT_GE(res, 0);
985 left -= res;
986 }
987 } else {
988 size_t left = data * write_bias;
989
990 while (left) {
991 int res;
992
993 ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0);
994 if (sendpg)
995 res = sendfile(self->fd, fd, NULL,
996 left > file_sz ? file_sz : left);
997 else
998 res = send(self->fd, buf,
999 left > file_sz ? file_sz : left, 0);
1000
1001 EXPECT_GE(res, 0);
1002 left -= res;
1003 }
1004 }
1005 }
1006
1007 TEST_F(tls, mutliproc_even)
1008 {
1009 test_mutliproc(_metadata, self, false, 6, 6);
1010 }
1011
1012 TEST_F(tls, mutliproc_readers)
1013 {
1014 test_mutliproc(_metadata, self, false, 4, 12);
1015 }
1016
1017 TEST_F(tls, mutliproc_writers)
1018 {
1019 test_mutliproc(_metadata, self, false, 10, 2);
1020 }
1021
1022 TEST_F(tls, mutliproc_sendpage_even)
1023 {
1024 test_mutliproc(_metadata, self, true, 6, 6);
1025 }
1026
1027 TEST_F(tls, mutliproc_sendpage_readers)
1028 {
1029 test_mutliproc(_metadata, self, true, 4, 12);
1030 }
1031
1032 TEST_F(tls, mutliproc_sendpage_writers)
1033 {
1034 test_mutliproc(_metadata, self, true, 10, 2);
1035 }
1036
1037 TEST_F(tls, control_msg)
1038 {
1039 if (self->notls)
1040 return;
1041
1042 char cbuf[CMSG_SPACE(sizeof(char))];
1043 char const *test_str = "test_read";
1044 int cmsg_len = sizeof(char);
1045 char record_type = 100;
1046 struct cmsghdr *cmsg;
1047 struct msghdr msg;
1048 int send_len = 10;
1049 struct iovec vec;
1050 char buf[10];
1051
1052 vec.iov_base = (char *)test_str;
1053 vec.iov_len = 10;
1054 memset(&msg, 0, sizeof(struct msghdr));
1055 msg.msg_iov = &vec;
1056 msg.msg_iovlen = 1;
1057 msg.msg_control = cbuf;
1058 msg.msg_controllen = sizeof(cbuf);
1059 cmsg = CMSG_FIRSTHDR(&msg);
1060 cmsg->cmsg_level = SOL_TLS;
1061
1062 cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
1063 cmsg->cmsg_len = CMSG_LEN(cmsg_len);
1064 *CMSG_DATA(cmsg) = record_type;
1065 msg.msg_controllen = cmsg->cmsg_len;
1066
1067 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
1068
1069 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
1070
1071 vec.iov_base = buf;
1072 EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL | MSG_PEEK), send_len);
1073
1074 cmsg = CMSG_FIRSTHDR(&msg);
1075 EXPECT_NE(cmsg, NULL);
1076 EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
1077 EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
1078 record_type = *((unsigned char *)CMSG_DATA(cmsg));
1079 EXPECT_EQ(record_type, 100);
1080 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1081
1082
1083 record_type = 0;
1084 memset(buf, 0, sizeof(buf));
1085
1086 EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL), send_len);
1087 cmsg = CMSG_FIRSTHDR(&msg);
1088 EXPECT_NE(cmsg, NULL);
1089 EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
1090 EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
1091 record_type = *((unsigned char *)CMSG_DATA(cmsg));
1092 EXPECT_EQ(record_type, 100);
1093 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1094 }
1095
1096 TEST_F(tls, shutdown)
1097 {
1098 char const *test_str = "test_read";
1099 int send_len = 10;
1100 char buf[10];
1101
1102 ASSERT_EQ(strlen(test_str) + 1, send_len);
1103
1104 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1105 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
1106 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1107
1108 shutdown(self->fd, SHUT_RDWR);
1109 shutdown(self->cfd, SHUT_RDWR);
1110 }
1111
1112 TEST_F(tls, shutdown_unsent)
1113 {
1114 char const *test_str = "test_read";
1115 int send_len = 10;
1116
1117 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
1118
1119 shutdown(self->fd, SHUT_RDWR);
1120 shutdown(self->cfd, SHUT_RDWR);
1121 }
1122
1123 TEST_F(tls, shutdown_reuse)
1124 {
1125 struct sockaddr_in addr;
1126 int ret;
1127
1128 shutdown(self->fd, SHUT_RDWR);
1129 shutdown(self->cfd, SHUT_RDWR);
1130 close(self->cfd);
1131
1132 addr.sin_family = AF_INET;
1133 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1134 addr.sin_port = 0;
1135
1136 ret = bind(self->fd, &addr, sizeof(addr));
1137 EXPECT_EQ(ret, 0);
1138 ret = listen(self->fd, 10);
1139 EXPECT_EQ(ret, -1);
1140 EXPECT_EQ(errno, EINVAL);
1141
1142 ret = connect(self->fd, &addr, sizeof(addr));
1143 EXPECT_EQ(ret, -1);
1144 EXPECT_EQ(errno, EISCONN);
1145 }
1146
1147 TEST(non_established) {
1148 struct tls12_crypto_info_aes_gcm_256 tls12;
1149 struct sockaddr_in addr;
1150 int sfd, ret, fd;
1151 socklen_t len;
1152
1153 len = sizeof(addr);
1154
1155 memset(&tls12, 0, sizeof(tls12));
1156 tls12.info.version = TLS_1_2_VERSION;
1157 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1158
1159 addr.sin_family = AF_INET;
1160 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1161 addr.sin_port = 0;
1162
1163 fd = socket(AF_INET, SOCK_STREAM, 0);
1164 sfd = socket(AF_INET, SOCK_STREAM, 0);
1165
1166 ret = bind(sfd, &addr, sizeof(addr));
1167 ASSERT_EQ(ret, 0);
1168 ret = listen(sfd, 10);
1169 ASSERT_EQ(ret, 0);
1170
1171 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1172 EXPECT_EQ(ret, -1);
1173
1174 if (errno == ENOENT)
1175 return;
1176 EXPECT_EQ(errno, ENOTCONN);
1177
1178 ret = setsockopt(sfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1179 EXPECT_EQ(ret, -1);
1180 EXPECT_EQ(errno, ENOTCONN);
1181
1182 ret = getsockname(sfd, &addr, &len);
1183 ASSERT_EQ(ret, 0);
1184
1185 ret = connect(fd, &addr, sizeof(addr));
1186 ASSERT_EQ(ret, 0);
1187
1188 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1189 ASSERT_EQ(ret, 0);
1190
1191 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1192 EXPECT_EQ(ret, -1);
1193 EXPECT_EQ(errno, EEXIST);
1194
1195 close(fd);
1196 close(sfd);
1197 }
1198
1199 TEST(keysizes) {
1200 struct tls12_crypto_info_aes_gcm_256 tls12;
1201 struct sockaddr_in addr;
1202 int sfd, ret, fd, cfd;
1203 socklen_t len;
1204 bool notls;
1205
1206 notls = false;
1207 len = sizeof(addr);
1208
1209 memset(&tls12, 0, sizeof(tls12));
1210 tls12.info.version = TLS_1_2_VERSION;
1211 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1212
1213 addr.sin_family = AF_INET;
1214 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1215 addr.sin_port = 0;
1216
1217 fd = socket(AF_INET, SOCK_STREAM, 0);
1218 sfd = socket(AF_INET, SOCK_STREAM, 0);
1219
1220 ret = bind(sfd, &addr, sizeof(addr));
1221 ASSERT_EQ(ret, 0);
1222 ret = listen(sfd, 10);
1223 ASSERT_EQ(ret, 0);
1224
1225 ret = getsockname(sfd, &addr, &len);
1226 ASSERT_EQ(ret, 0);
1227
1228 ret = connect(fd, &addr, sizeof(addr));
1229 ASSERT_EQ(ret, 0);
1230
1231 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1232 if (ret != 0) {
1233 notls = true;
1234 printf("Failure setting TCP_ULP, testing without tls\n");
1235 }
1236
1237 if (!notls) {
1238 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12,
1239 sizeof(tls12));
1240 EXPECT_EQ(ret, 0);
1241 }
1242
1243 cfd = accept(sfd, &addr, &len);
1244 ASSERT_GE(cfd, 0);
1245
1246 if (!notls) {
1247 ret = setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls",
1248 sizeof("tls"));
1249 EXPECT_EQ(ret, 0);
1250
1251 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12,
1252 sizeof(tls12));
1253 EXPECT_EQ(ret, 0);
1254 }
1255
1256 close(sfd);
1257 close(fd);
1258 close(cfd);
1259 }
1260
1261 TEST(tls12) {
1262 int fd, cfd;
1263 bool notls;
1264
1265 struct tls12_crypto_info_aes_gcm_128 tls12;
1266 struct sockaddr_in addr;
1267 socklen_t len;
1268 int sfd, ret;
1269
1270 notls = false;
1271 len = sizeof(addr);
1272
1273 memset(&tls12, 0, sizeof(tls12));
1274 tls12.info.version = TLS_1_2_VERSION;
1275 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
1276
1277 addr.sin_family = AF_INET;
1278 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1279 addr.sin_port = 0;
1280
1281 fd = socket(AF_INET, SOCK_STREAM, 0);
1282 sfd = socket(AF_INET, SOCK_STREAM, 0);
1283
1284 ret = bind(sfd, &addr, sizeof(addr));
1285 ASSERT_EQ(ret, 0);
1286 ret = listen(sfd, 10);
1287 ASSERT_EQ(ret, 0);
1288
1289 ret = getsockname(sfd, &addr, &len);
1290 ASSERT_EQ(ret, 0);
1291
1292 ret = connect(fd, &addr, sizeof(addr));
1293 ASSERT_EQ(ret, 0);
1294
1295 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1296 if (ret != 0) {
1297 notls = true;
1298 printf("Failure setting TCP_ULP, testing without tls\n");
1299 }
1300
1301 if (!notls) {
1302 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12,
1303 sizeof(tls12));
1304 ASSERT_EQ(ret, 0);
1305 }
1306
1307 cfd = accept(sfd, &addr, &len);
1308 ASSERT_GE(cfd, 0);
1309
1310 if (!notls) {
1311 ret = setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls",
1312 sizeof("tls"));
1313 ASSERT_EQ(ret, 0);
1314
1315 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12,
1316 sizeof(tls12));
1317 ASSERT_EQ(ret, 0);
1318 }
1319
1320 close(sfd);
1321
1322 char const *test_str = "test_read";
1323 int send_len = 10;
1324 char buf[10];
1325
1326 send_len = strlen(test_str) + 1;
1327 EXPECT_EQ(send(fd, test_str, send_len, 0), send_len);
1328 EXPECT_NE(recv(cfd, buf, send_len, 0), -1);
1329 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1330
1331 close(fd);
1332 close(cfd);
1333 }
1334
1335 TEST_HARNESS_MAIN