projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
selftests: tls: test splicing decrypted records
[linux-block.git] / tools / testing / selftests / net / tls.c
CommitLineData
7f657d5b
DW		 1// SPDX-License-Identifier: GPL-2.0
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
291c53e4
JK		 28struct tls_crypto_info_keys {
29 union {
30 struct tls12_crypto_info_aes_gcm_128 aes128;
31 struct tls12_crypto_info_chacha20_poly1305 chacha20;
e506342a
TZ		 32 struct tls12_crypto_info_sm4_gcm sm4gcm;
33 struct tls12_crypto_info_sm4_ccm sm4ccm;
291c53e4
JK		 34 };
35 size_t len;
36};
37
38static void tls_crypto_info_init(uint16_t tls_version, uint16_t cipher_type,
39 struct tls_crypto_info_keys *tls12)
40{
41 memset(tls12, 0, sizeof(*tls12));
42
43 switch (cipher_type) {
44 case TLS_CIPHER_CHACHA20_POLY1305:
45 tls12->len = sizeof(struct tls12_crypto_info_chacha20_poly1305);
46 tls12->chacha20.info.version = tls_version;
47 tls12->chacha20.info.cipher_type = cipher_type;
48 break;
49 case TLS_CIPHER_AES_GCM_128:
50 tls12->len = sizeof(struct tls12_crypto_info_aes_gcm_128);
51 tls12->aes128.info.version = tls_version;
52 tls12->aes128.info.cipher_type = cipher_type;
53 break;
e506342a
TZ		 54 case TLS_CIPHER_SM4_GCM:
55 tls12->len = sizeof(struct tls12_crypto_info_sm4_gcm);
56 tls12->sm4gcm.info.version = tls_version;
57 tls12->sm4gcm.info.cipher_type = cipher_type;
58 break;
59 case TLS_CIPHER_SM4_CCM:
60 tls12->len = sizeof(struct tls12_crypto_info_sm4_ccm);
61 tls12->sm4ccm.info.version = tls_version;
62 tls12->sm4ccm.info.cipher_type = cipher_type;
63 break;
291c53e4
JK		 64 default:
65 break;
66 }
67}
68
baa00119
JK		 69static void memrnd(void *s, size_t n)
70{
71 int *dword = s;
72 char *byte;
73
74 for (; n >= 4; n -= 4)
75 *dword++ = rand();
76 byte = (void *)dword;
77 while (n--)
78 *byte++ = rand();
79}
80
a125f91f
JK		 81static void ulp_sock_pair(struct __test_metadata *_metadata,
82 int *fd, int *cfd, bool *notls)
cf32526c
JK		 83{
84 struct sockaddr_in addr;
85 socklen_t len;
86 int sfd, ret;
87
a125f91f 88 *notls = false;
cf32526c
JK		 89 len = sizeof(addr);
90
91 addr.sin_family = AF_INET;
92 addr.sin_addr.s_addr = htonl(INADDR_ANY);
93 addr.sin_port = 0;
94
a125f91f 95 *fd = socket(AF_INET, SOCK_STREAM, 0);
cf32526c
JK		 96 sfd = socket(AF_INET, SOCK_STREAM, 0);
97
98 ret = bind(sfd, &addr, sizeof(addr));
99 ASSERT_EQ(ret, 0);
100 ret = listen(sfd, 10);
101 ASSERT_EQ(ret, 0);
102
103 ret = getsockname(sfd, &addr, &len);
104 ASSERT_EQ(ret, 0);
105
a125f91f 106 ret = connect(*fd, &addr, sizeof(addr));
cf32526c
JK		 107 ASSERT_EQ(ret, 0);
108
a125f91f
JK		 109 *cfd = accept(sfd, &addr, &len);
110 ASSERT_GE(*cfd, 0);
cf32526c
JK		 111
112 close(sfd);
113
a125f91f 114 ret = setsockopt(*fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
cf32526c 115 if (ret != 0) {
e29903c4 116 ASSERT_EQ(errno, ENOENT);
a125f91f 117 *notls = true;
cf32526c
JK		 118 printf("Failure setting TCP_ULP, testing without tls\n");
119 return;
120 }
121
a125f91f 122 ret = setsockopt(*cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
cf32526c
JK		 123 ASSERT_EQ(ret, 0);
124}
125
31180adb
JK		 126/* Produce a basic cmsg */
127static int tls_send_cmsg(int fd, unsigned char record_type,
128 void *data, size_t len, int flags)
129{
130 char cbuf[CMSG_SPACE(sizeof(char))];
131 int cmsg_len = sizeof(char);
132 struct cmsghdr *cmsg;
133 struct msghdr msg;
134 struct iovec vec;
135
136 vec.iov_base = data;
137 vec.iov_len = len;
138 memset(&msg, 0, sizeof(struct msghdr));
139 msg.msg_iov = &vec;
140 msg.msg_iovlen = 1;
141 msg.msg_control = cbuf;
142 msg.msg_controllen = sizeof(cbuf);
143 cmsg = CMSG_FIRSTHDR(&msg);
144 cmsg->cmsg_level = SOL_TLS;
145 /* test sending non-record types. */
146 cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
147 cmsg->cmsg_len = CMSG_LEN(cmsg_len);
148 *CMSG_DATA(cmsg) = record_type;
149 msg.msg_controllen = cmsg->cmsg_len;
150
151 return sendmsg(fd, &msg, flags);
152}
153
154static int tls_recv_cmsg(struct __test_metadata *_metadata,
155 int fd, unsigned char record_type,
156 void *data, size_t len, int flags)
157{
158 char cbuf[CMSG_SPACE(sizeof(char))];
159 struct cmsghdr *cmsg;
160 unsigned char ctype;
161 struct msghdr msg;
162 struct iovec vec;
163 int n;
164
165 vec.iov_base = data;
166 vec.iov_len = len;
167 memset(&msg, 0, sizeof(struct msghdr));
168 msg.msg_iov = &vec;
169 msg.msg_iovlen = 1;
170 msg.msg_control = cbuf;
171 msg.msg_controllen = sizeof(cbuf);
172
173 n = recvmsg(fd, &msg, flags);
174
175 cmsg = CMSG_FIRSTHDR(&msg);
176 EXPECT_NE(cmsg, NULL);
177 EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
178 EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
179 ctype = *((unsigned char *)CMSG_DATA(cmsg));
180 EXPECT_EQ(ctype, record_type);
181
182 return n;
183}
184
a125f91f
JK		 185FIXTURE(tls_basic)
186{
187 int fd, cfd;
188 bool notls;
189};
190
191FIXTURE_SETUP(tls_basic)
192{
193 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls);
194}
195
cf32526c
JK		 196FIXTURE_TEARDOWN(tls_basic)
197{
198 close(self->fd);
199 close(self->cfd);
200}
201
202/* Send some data through with ULP but no keys */
203TEST_F(tls_basic, base_base)
204{
205 char const *test_str = "test_read";
206 int send_len = 10;
207 char buf[10];
208
209 ASSERT_EQ(strlen(test_str) + 1, send_len);
210
211 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
212 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
213 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
214};
215
7f657d5b
DW		 216FIXTURE(tls)
217{
218 int fd, cfd;
219 bool notls;
220};
221
0feba221
JK		 222FIXTURE_VARIANT(tls)
223{
3502bd9b
VF		 224 uint16_t tls_version;
225 uint16_t cipher_type;
0feba221
JK		 226};
227
e506342a 228FIXTURE_VARIANT_ADD(tls, 12_aes_gcm)
0feba221
JK		 229{
230 .tls_version = TLS_1_2_VERSION,
4f336e88 231 .cipher_type = TLS_CIPHER_AES_GCM_128,
0feba221
JK		 232};
233
e506342a 234FIXTURE_VARIANT_ADD(tls, 13_aes_gcm)
0feba221
JK		 235{
236 .tls_version = TLS_1_3_VERSION,
4f336e88
VF		 237 .cipher_type = TLS_CIPHER_AES_GCM_128,
238};
239
240FIXTURE_VARIANT_ADD(tls, 12_chacha)
241{
242 .tls_version = TLS_1_2_VERSION,
243 .cipher_type = TLS_CIPHER_CHACHA20_POLY1305,
244};
245
246FIXTURE_VARIANT_ADD(tls, 13_chacha)
247{
248 .tls_version = TLS_1_3_VERSION,
249 .cipher_type = TLS_CIPHER_CHACHA20_POLY1305,
0feba221
JK		 250};
251
e506342a
TZ		 252FIXTURE_VARIANT_ADD(tls, 13_sm4_gcm)
253{
254 .tls_version = TLS_1_3_VERSION,
255 .cipher_type = TLS_CIPHER_SM4_GCM,
256};
257
258FIXTURE_VARIANT_ADD(tls, 13_sm4_ccm)
259{
260 .tls_version = TLS_1_3_VERSION,
261 .cipher_type = TLS_CIPHER_SM4_CCM,
262};
263
7f657d5b
DW		 264FIXTURE_SETUP(tls)
265{
291c53e4 266 struct tls_crypto_info_keys tls12;
a125f91f 267 int ret;
7f657d5b 268
291c53e4
JK		 269 tls_crypto_info_init(variant->tls_version, variant->cipher_type,
270 &tls12);
7f657d5b 271
a125f91f 272 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls);
7f657d5b 273
a125f91f
JK		 274 if (self->notls)
275 return;
7f657d5b 276
a125f91f 277 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len);
7f657d5b
DW		 278 ASSERT_EQ(ret, 0);
279
a125f91f 280 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len);
7f657d5b 281 ASSERT_EQ(ret, 0);
7f657d5b
DW		 282}
283
284FIXTURE_TEARDOWN(tls)
285{
286 close(self->fd);
287 close(self->cfd);
288}
289
290TEST_F(tls, sendfile)
291{
292 int filefd = open("/proc/self/exe", O_RDONLY);
293 struct stat st;
294
295 EXPECT_GE(filefd, 0);
296 fstat(filefd, &st);
297 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
298}
299
300TEST_F(tls, send_then_sendfile)
301{
302 int filefd = open("/proc/self/exe", O_RDONLY);
303 char const *test_str = "test_send";
304 int to_send = strlen(test_str) + 1;
305 char recv_buf[10];
306 struct stat st;
307 char *buf;
308
309 EXPECT_GE(filefd, 0);
310 fstat(filefd, &st);
311 buf = (char *)malloc(st.st_size);
312
313 EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send);
0185e2e6 314 EXPECT_EQ(recv(self->cfd, recv_buf, to_send, MSG_WAITALL), to_send);
7f657d5b
DW		 315 EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);
316
317 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
0185e2e6 318 EXPECT_EQ(recv(self->cfd, buf, st.st_size, MSG_WAITALL), st.st_size);
7f657d5b
DW		 319}
320
0e6fbe39
PT		 321static void chunked_sendfile(struct __test_metadata *_metadata,
322 struct _test_data_tls *self,
323 uint16_t chunk_size,
324 uint16_t extra_payload_size)
325{
326 char buf[TLS_PAYLOAD_MAX_LEN];
327 uint16_t test_payload_size;
328 int size = 0;
329 int ret;
330 char filename[] = "/tmp/mytemp.XXXXXX";
331 int fd = mkstemp(filename);
332 off_t offset = 0;
333
334 unlink(filename);
335 ASSERT_GE(fd, 0);
336 EXPECT_GE(chunk_size, 1);
337 test_payload_size = chunk_size + extra_payload_size;
338 ASSERT_GE(TLS_PAYLOAD_MAX_LEN, test_payload_size);
339 memset(buf, 1, test_payload_size);
340 size = write(fd, buf, test_payload_size);
341 EXPECT_EQ(size, test_payload_size);
342 fsync(fd);
343
344 while (size > 0) {
345 ret = sendfile(self->fd, fd, &offset, chunk_size);
346 EXPECT_GE(ret, 0);
347 size -= ret;
348 }
349
350 EXPECT_EQ(recv(self->cfd, buf, test_payload_size, MSG_WAITALL),
351 test_payload_size);
352
353 close(fd);
354}
355
356TEST_F(tls, multi_chunk_sendfile)
357{
358 chunked_sendfile(_metadata, self, 4096, 4096);
359 chunked_sendfile(_metadata, self, 4096, 0);
360 chunked_sendfile(_metadata, self, 4096, 1);
361 chunked_sendfile(_metadata, self, 4096, 2048);
362 chunked_sendfile(_metadata, self, 8192, 2048);
363 chunked_sendfile(_metadata, self, 4096, 8192);
364 chunked_sendfile(_metadata, self, 8192, 4096);
365 chunked_sendfile(_metadata, self, 12288, 1024);
366 chunked_sendfile(_metadata, self, 12288, 2000);
367 chunked_sendfile(_metadata, self, 15360, 100);
368 chunked_sendfile(_metadata, self, 15360, 300);
369 chunked_sendfile(_metadata, self, 1, 4096);
370 chunked_sendfile(_metadata, self, 2048, 4096);
371 chunked_sendfile(_metadata, self, 2048, 8192);
372 chunked_sendfile(_metadata, self, 4096, 8192);
373 chunked_sendfile(_metadata, self, 1024, 12288);
374 chunked_sendfile(_metadata, self, 2000, 12288);
375 chunked_sendfile(_metadata, self, 100, 15360);
376 chunked_sendfile(_metadata, self, 300, 15360);
377}
378
7f657d5b
DW		 379TEST_F(tls, recv_max)
380{
381 unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
382 char recv_mem[TLS_PAYLOAD_MAX_LEN];
383 char buf[TLS_PAYLOAD_MAX_LEN];
384
baa00119
JK		 385 memrnd(buf, sizeof(buf));
386
7f657d5b
DW		 387 EXPECT_GE(send(self->fd, buf, send_len, 0), 0);
388 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
389 EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0);
390}
391
392TEST_F(tls, recv_small)
393{
394 char const *test_str = "test_read";
395 int send_len = 10;
396 char buf[10];
397
398 send_len = strlen(test_str) + 1;
399 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
400 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
401 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
402}
403
404TEST_F(tls, msg_more)
405{
406 char const *test_str = "test_read";
407 int send_len = 10;
408 char buf[10 * 2];
409
410 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
411 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
412 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
0185e2e6 413 EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_WAITALL),
7f657d5b
DW		 414 send_len * 2);
415 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
416}
417
8051bb7f
JK		 418TEST_F(tls, msg_more_unsent)
419{
420 char const *test_str = "test_read";
421 int send_len = 10;
422 char buf[10];
423
424 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
425 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
426}
427
7f657d5b
DW		 428TEST_F(tls, sendmsg_single)
429{
430 struct msghdr msg;
431
432 char const *test_str = "test_sendmsg";
433 size_t send_len = 13;
434 struct iovec vec;
435 char buf[13];
436
437 vec.iov_base = (char *)test_str;
438 vec.iov_len = send_len;
439 memset(&msg, 0, sizeof(struct msghdr));
440 msg.msg_iov = &vec;
441 msg.msg_iovlen = 1;
442 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
0185e2e6 443 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
7f657d5b
DW		 444 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
445}
446
65190f77
JK		 447#define MAX_FRAGS 64
448#define SEND_LEN 13
449TEST_F(tls, sendmsg_fragmented)
450{
451 char const *test_str = "test_sendmsg";
452 char buf[SEND_LEN * MAX_FRAGS];
453 struct iovec vec[MAX_FRAGS];
454 struct msghdr msg;
455 int i, frags;
456
457 for (frags = 1; frags <= MAX_FRAGS; frags++) {
458 for (i = 0; i < frags; i++) {
459 vec[i].iov_base = (char *)test_str;
460 vec[i].iov_len = SEND_LEN;
461 }
462
463 memset(&msg, 0, sizeof(struct msghdr));
464 msg.msg_iov = vec;
465 msg.msg_iovlen = frags;
466
467 EXPECT_EQ(sendmsg(self->fd, &msg, 0), SEND_LEN * frags);
468 EXPECT_EQ(recv(self->cfd, buf, SEND_LEN * frags, MSG_WAITALL),
469 SEND_LEN * frags);
470
471 for (i = 0; i < frags; i++)
472 EXPECT_EQ(memcmp(buf + SEND_LEN * i,
473 test_str, SEND_LEN), 0);
474 }
475}
476#undef MAX_FRAGS
477#undef SEND_LEN
478
7f657d5b
DW		 479TEST_F(tls, sendmsg_large)
480{
481 void *mem = malloc(16384);
482 size_t send_len = 16384;
483 size_t sends = 128;
484 struct msghdr msg;
485 size_t recvs = 0;
486 size_t sent = 0;
487
488 memset(&msg, 0, sizeof(struct msghdr));
489 while (sent++ < sends) {
490 struct iovec vec = { (void *)mem, send_len };
491
492 msg.msg_iov = &vec;
493 msg.msg_iovlen = 1;
494 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), send_len);
495 }
496
f50688b4 497 while (recvs++ < sends) {
7f657d5b 498 EXPECT_NE(recv(self->fd, mem, send_len, 0), -1);
f50688b4 499 }
7f657d5b
DW		 500
501 free(mem);
502}
503
504TEST_F(tls, sendmsg_multiple)
505{
506 char const *test_str = "test_sendmsg_multiple";
507 struct iovec vec[5];
508 char *test_strs[5];
509 struct msghdr msg;
510 int total_len = 0;
511 int len_cmp = 0;
512 int iov_len = 5;
513 char *buf;
514 int i;
515
516 memset(&msg, 0, sizeof(struct msghdr));
517 for (i = 0; i < iov_len; i++) {
518 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
519 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
520 vec[i].iov_base = (void *)test_strs[i];
521 vec[i].iov_len = strlen(test_strs[i]) + 1;
522 total_len += vec[i].iov_len;
523 }
524 msg.msg_iov = vec;
525 msg.msg_iovlen = iov_len;
526
527 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), total_len);
528 buf = malloc(total_len);
529 EXPECT_NE(recv(self->fd, buf, total_len, 0), -1);
530 for (i = 0; i < iov_len; i++) {
531 EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
532 strlen(test_strs[i])),
533 0);
534 len_cmp += strlen(buf + len_cmp) + 1;
535 }
536 for (i = 0; i < iov_len; i++)
537 free(test_strs[i]);
538 free(buf);
539}
540
541TEST_F(tls, sendmsg_multiple_stress)
542{
543 char const *test_str = "abcdefghijklmno";
544 struct iovec vec[1024];
545 char *test_strs[1024];
546 int iov_len = 1024;
547 int total_len = 0;
548 char buf[1 << 14];
549 struct msghdr msg;
550 int len_cmp = 0;
551 int i;
552
553 memset(&msg, 0, sizeof(struct msghdr));
554 for (i = 0; i < iov_len; i++) {
555 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
556 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
557 vec[i].iov_base = (void *)test_strs[i];
558 vec[i].iov_len = strlen(test_strs[i]) + 1;
559 total_len += vec[i].iov_len;
560 }
561 msg.msg_iov = vec;
562 msg.msg_iovlen = iov_len;
563
564 EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
565 EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
566
567 for (i = 0; i < iov_len; i++)
568 len_cmp += strlen(buf + len_cmp) + 1;
569
570 for (i = 0; i < iov_len; i++)
571 free(test_strs[i]);
572}
573
574TEST_F(tls, splice_from_pipe)
575{
576 int send_len = TLS_PAYLOAD_MAX_LEN;
577 char mem_send[TLS_PAYLOAD_MAX_LEN];
578 char mem_recv[TLS_PAYLOAD_MAX_LEN];
579 int p[2];
580
581 ASSERT_GE(pipe(p), 0);
582 EXPECT_GE(write(p[1], mem_send, send_len), 0);
583 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
0ed3015c 584 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
7f657d5b
DW		 585 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
586}
587
588TEST_F(tls, splice_from_pipe2)
589{
590 int send_len = 16000;
591 char mem_send[16000];
592 char mem_recv[16000];
593 int p2[2];
594 int p[2];
595
596 ASSERT_GE(pipe(p), 0);
597 ASSERT_GE(pipe(p2), 0);
598 EXPECT_GE(write(p[1], mem_send, 8000), 0);
599 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
600 EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
601 EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
0185e2e6 602 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
7f657d5b
DW		 603 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
604}
605
606TEST_F(tls, send_and_splice)
607{
608 int send_len = TLS_PAYLOAD_MAX_LEN;
609 char mem_send[TLS_PAYLOAD_MAX_LEN];
610 char mem_recv[TLS_PAYLOAD_MAX_LEN];
611 char const *test_str = "test_read";
612 int send_len2 = 10;
613 char buf[10];
614 int p[2];
615
616 ASSERT_GE(pipe(p), 0);
617 EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
0ed3015c 618 EXPECT_EQ(recv(self->cfd, buf, send_len2, MSG_WAITALL), send_len2);
7f657d5b
DW		 619 EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);
620
621 EXPECT_GE(write(p[1], mem_send, send_len), send_len);
622 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);
623
0ed3015c 624 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
7f657d5b
DW		 625 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
626}
627
628TEST_F(tls, splice_to_pipe)
629{
630 int send_len = TLS_PAYLOAD_MAX_LEN;
631 char mem_send[TLS_PAYLOAD_MAX_LEN];
632 char mem_recv[TLS_PAYLOAD_MAX_LEN];
633 int p[2];
634
635 ASSERT_GE(pipe(p), 0);
636 EXPECT_GE(send(self->fd, mem_send, send_len, 0), 0);
637 EXPECT_GE(splice(self->cfd, NULL, p[1], NULL, send_len, 0), 0);
638 EXPECT_GE(read(p[0], mem_recv, send_len), 0);
639 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
640}
641
d87d67fd
JK		 642TEST_F(tls, splice_cmsg_to_pipe)
643{
644 char *test_str = "test_read";
645 char record_type = 100;
646 int send_len = 10;
647 char buf[10];
648 int p[2];
649
650 ASSERT_GE(pipe(p), 0);
651 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10);
652 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), -1);
653 EXPECT_EQ(errno, EINVAL);
654 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
655 EXPECT_EQ(errno, EIO);
656 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type,
657 buf, sizeof(buf), MSG_WAITALL),
658 send_len);
659 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
660}
661
662TEST_F(tls, splice_dec_cmsg_to_pipe)
663{
664 char *test_str = "test_read";
665 char record_type = 100;
666 int send_len = 10;
667 char buf[10];
668 int p[2];
669
670 ASSERT_GE(pipe(p), 0);
671 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10);
672 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
673 EXPECT_EQ(errno, EIO);
674 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), -1);
675 EXPECT_EQ(errno, EINVAL);
676 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type,
677 buf, sizeof(buf), MSG_WAITALL),
678 send_len);
679 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
680}
681
274af0f9
JK		 682TEST_F(tls, recv_and_splice)
683{
684 int send_len = TLS_PAYLOAD_MAX_LEN;
685 char mem_send[TLS_PAYLOAD_MAX_LEN];
686 char mem_recv[TLS_PAYLOAD_MAX_LEN];
687 int half = send_len / 2;
688 int p[2];
689
690 ASSERT_GE(pipe(p), 0);
691 EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len);
692 /* Recv hald of the record, splice the other half */
693 EXPECT_EQ(recv(self->cfd, mem_recv, half, MSG_WAITALL), half);
694 EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, half, SPLICE_F_NONBLOCK),
695 half);
696 EXPECT_EQ(read(p[0], &mem_recv[half], half), half);
697 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
698}
699
700TEST_F(tls, peek_and_splice)
701{
702 int send_len = TLS_PAYLOAD_MAX_LEN;
703 char mem_send[TLS_PAYLOAD_MAX_LEN];
704 char mem_recv[TLS_PAYLOAD_MAX_LEN];
705 int chunk = TLS_PAYLOAD_MAX_LEN / 4;
706 int n, i, p[2];
707
708 memrnd(mem_send, sizeof(mem_send));
709
710 ASSERT_GE(pipe(p), 0);
711 for (i = 0; i < 4; i++)
712 EXPECT_EQ(send(self->fd, &mem_send[chunk * i], chunk, 0),
713 chunk);
714
715 EXPECT_EQ(recv(self->cfd, mem_recv, chunk * 5 / 2,
716 MSG_WAITALL | MSG_PEEK),
717 chunk * 5 / 2);
718 EXPECT_EQ(memcmp(mem_send, mem_recv, chunk * 5 / 2), 0);
719
720 n = 0;
721 while (n < send_len) {
722 i = splice(self->cfd, NULL, p[1], NULL, send_len - n, 0);
723 EXPECT_GT(i, 0);
724 n += i;
725 }
726 EXPECT_EQ(n, send_len);
727 EXPECT_EQ(read(p[0], mem_recv, send_len), send_len);
728 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
729}
730
7f657d5b
DW		 731TEST_F(tls, recvmsg_single)
732{
733 char const *test_str = "test_recvmsg_single";
734 int send_len = strlen(test_str) + 1;
735 char buf[20];
736 struct msghdr hdr;
737 struct iovec vec;
738
739 memset(&hdr, 0, sizeof(hdr));
740 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
741 vec.iov_base = (char *)buf;
742 vec.iov_len = send_len;
743 hdr.msg_iovlen = 1;
744 hdr.msg_iov = &vec;
745 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
746 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
747}
748
749TEST_F(tls, recvmsg_single_max)
750{
751 int send_len = TLS_PAYLOAD_MAX_LEN;
752 char send_mem[TLS_PAYLOAD_MAX_LEN];
753 char recv_mem[TLS_PAYLOAD_MAX_LEN];
754 struct iovec vec;
755 struct msghdr hdr;
756
baa00119
JK		 757 memrnd(send_mem, sizeof(send_mem));
758
7f657d5b
DW		 759 EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
760 vec.iov_base = (char *)recv_mem;
761 vec.iov_len = TLS_PAYLOAD_MAX_LEN;
762
763 hdr.msg_iovlen = 1;
764 hdr.msg_iov = &vec;
765 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
766 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
767}
768
769TEST_F(tls, recvmsg_multiple)
770{
771 unsigned int msg_iovlen = 1024;
7f657d5b
DW		 772 struct iovec vec[1024];
773 char *iov_base[1024];
774 unsigned int iov_len = 16;
775 int send_len = 1 << 14;
776 char buf[1 << 14];
777 struct msghdr hdr;
778 int i;
779
baa00119
JK		 780 memrnd(buf, sizeof(buf));
781
7f657d5b
DW		 782 EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
783 for (i = 0; i < msg_iovlen; i++) {
784 iov_base[i] = (char *)malloc(iov_len);
785 vec[i].iov_base = iov_base[i];
786 vec[i].iov_len = iov_len;
787 }
788
789 hdr.msg_iovlen = msg_iovlen;
790 hdr.msg_iov = vec;
791 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
7f657d5b
DW		 792
793 for (i = 0; i < msg_iovlen; i++)
794 free(iov_base[i]);
795}
796
797TEST_F(tls, single_send_multiple_recv)
798{
799 unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
800 unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
801 char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
802 char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];
803
baa00119
JK		 804 memrnd(send_mem, sizeof(send_mem));
805
7f657d5b
DW		 806 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
807 memset(recv_mem, 0, total_len);
808
809 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
810 EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
811 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
812}
813
814TEST_F(tls, multiple_send_single_recv)
815{
816 unsigned int total_len = 2 * 10;
817 unsigned int send_len = 10;
818 char recv_mem[2 * 10];
819 char send_mem[10];
820
821 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
822 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
823 memset(recv_mem, 0, total_len);
0185e2e6 824 EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len);
7f657d5b
DW		 825
826 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
827 EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
828}
829
043556d0
JK		 830TEST_F(tls, single_send_multiple_recv_non_align)
831{
832 const unsigned int total_len = 15;
833 const unsigned int recv_len = 10;
834 char recv_mem[recv_len * 2];
835 char send_mem[total_len];
836
837 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
838 memset(recv_mem, 0, total_len);
839
840 EXPECT_EQ(recv(self->cfd, recv_mem, recv_len, 0), recv_len);
841 EXPECT_EQ(recv(self->cfd, recv_mem + recv_len, recv_len, 0), 5);
842 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
843}
844
7f657d5b
DW		 845TEST_F(tls, recv_partial)
846{
847 char const *test_str = "test_read_partial";
848 char const *test_str_first = "test_read";
849 char const *test_str_second = "_partial";
850 int send_len = strlen(test_str) + 1;
851 char recv_mem[18];
852
853 memset(recv_mem, 0, sizeof(recv_mem));
854 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
cea3bfb3
VG		 855 EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first),
856 MSG_WAITALL), -1);
7f657d5b
DW		 857 EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
858 memset(recv_mem, 0, sizeof(recv_mem));
cea3bfb3
VG		 859 EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second),
860 MSG_WAITALL), -1);
7f657d5b
DW		 861 EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
862 0);
863}
864
865TEST_F(tls, recv_nonblock)
866{
867 char buf[4096];
868 bool err;
869
870 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
871 err = (errno == EAGAIN || errno == EWOULDBLOCK);
872 EXPECT_EQ(err, true);
873}
874
875TEST_F(tls, recv_peek)
876{
877 char const *test_str = "test_read_peek";
878 int send_len = strlen(test_str) + 1;
879 char buf[15];
880
881 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
882 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
883 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
884 memset(buf, 0, sizeof(buf));
885 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
886 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
887}
888
889TEST_F(tls, recv_peek_multiple)
890{
891 char const *test_str = "test_read_peek";
892 int send_len = strlen(test_str) + 1;
893 unsigned int num_peeks = 100;
894 char buf[15];
895 int i;
896
897 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
898 for (i = 0; i < num_peeks; i++) {
899 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
900 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
901 memset(buf, 0, sizeof(buf));
902 }
903 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
904 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
905}
906
50c6b58a
DB		 907TEST_F(tls, recv_peek_multiple_records)
908{
909 char const *test_str = "test_read_peek_mult_recs";
910 char const *test_str_first = "test_read_peek";
911 char const *test_str_second = "_mult_recs";
912 int len;
913 char buf[64];
914
915 len = strlen(test_str_first);
916 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
917
918 len = strlen(test_str_second) + 1;
919 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
920
0ed3015c 921 len = strlen(test_str_first);
50c6b58a 922 memset(buf, 0, len);
0ed3015c 923 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
50c6b58a
DB		 924
925 /* MSG_PEEK can only peek into the current record. */
0ed3015c 926 len = strlen(test_str_first);
50c6b58a
DB		 927 EXPECT_EQ(memcmp(test_str_first, buf, len), 0);
928
0ed3015c 929 len = strlen(test_str) + 1;
50c6b58a 930 memset(buf, 0, len);
0ed3015c 931 EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len);
50c6b58a
DB		 932
933 /* Non-MSG_PEEK will advance strparser (and therefore record)
934 * however.
935 */
936 len = strlen(test_str) + 1;
937 EXPECT_EQ(memcmp(test_str, buf, len), 0);
938
939 /* MSG_MORE will hold current record open, so later MSG_PEEK
940 * will see everything.
941 */
942 len = strlen(test_str_first);
943 EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len);
944
945 len = strlen(test_str_second) + 1;
946 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
947
0ed3015c 948 len = strlen(test_str) + 1;
50c6b58a 949 memset(buf, 0, len);
0ed3015c 950 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
50c6b58a
DB		 951
952 len = strlen(test_str) + 1;
953 EXPECT_EQ(memcmp(test_str, buf, len), 0);
954}
955
c2ad647c
VG		 956TEST_F(tls, recv_peek_large_buf_mult_recs)
957{
958 char const *test_str = "test_read_peek_mult_recs";
959 char const *test_str_first = "test_read_peek";
960 char const *test_str_second = "_mult_recs";
961 int len;
962 char buf[64];
963
964 len = strlen(test_str_first);
965 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
966
967 len = strlen(test_str_second) + 1;
968 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
969
cea3bfb3 970 len = strlen(test_str) + 1;
c2ad647c 971 memset(buf, 0, len);
cea3bfb3
VG		 972 EXPECT_NE((len = recv(self->cfd, buf, len,
973 MSG_PEEK | MSG_WAITALL)), -1);
c2ad647c
VG		 974 len = strlen(test_str) + 1;
975 EXPECT_EQ(memcmp(test_str, buf, len), 0);
976}
977
7718a855
JK		 978TEST_F(tls, recv_lowat)
979{
980 char send_mem[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
981 char recv_mem[20];
982 int lowat = 8;
983
984 EXPECT_EQ(send(self->fd, send_mem, 10, 0), 10);
985 EXPECT_EQ(send(self->fd, send_mem, 5, 0), 5);
986
987 memset(recv_mem, 0, 20);
988 EXPECT_EQ(setsockopt(self->cfd, SOL_SOCKET, SO_RCVLOWAT,
989 &lowat, sizeof(lowat)), 0);
990 EXPECT_EQ(recv(self->cfd, recv_mem, 1, MSG_WAITALL), 1);
991 EXPECT_EQ(recv(self->cfd, recv_mem + 1, 6, MSG_WAITALL), 6);
992 EXPECT_EQ(recv(self->cfd, recv_mem + 7, 10, 0), 8);
993
994 EXPECT_EQ(memcmp(send_mem, recv_mem, 10), 0);
995 EXPECT_EQ(memcmp(send_mem, recv_mem + 10, 5), 0);
996}
e366fa43 997
65d41fb3
JK		 998TEST_F(tls, bidir)
999{
65d41fb3
JK		 1000 char const *test_str = "test_read";
1001 int send_len = 10;
1002 char buf[10];
1003 int ret;
1004
e29903c4 1005 if (!self->notls) {
291c53e4 1006 struct tls_crypto_info_keys tls12;
65d41fb3 1007
291c53e4
JK		 1008 tls_crypto_info_init(variant->tls_version, variant->cipher_type,
1009 &tls12);
65d41fb3 1010
e29903c4 1011 ret = setsockopt(self->fd, SOL_TLS, TLS_RX, &tls12,
291c53e4 1012 tls12.len);
e29903c4
JK		 1013 ASSERT_EQ(ret, 0);
1014
1015 ret = setsockopt(self->cfd, SOL_TLS, TLS_TX, &tls12,
291c53e4 1016 tls12.len);
e29903c4
JK		 1017 ASSERT_EQ(ret, 0);
1018 }
65d41fb3
JK		 1019
1020 ASSERT_EQ(strlen(test_str) + 1, send_len);
1021
1022 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1023 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
1024 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1025
1026 memset(buf, 0, sizeof(buf));
1027
1028 EXPECT_EQ(send(self->cfd, test_str, send_len, 0), send_len);
1029 EXPECT_NE(recv(self->fd, buf, send_len, 0), -1);
1030 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1031};
1032
7f657d5b
DW		 1033TEST_F(tls, pollin)
1034{
1035 char const *test_str = "test_poll";
1036 struct pollfd fd = { 0, 0, 0 };
1037 char buf[10];
1038 int send_len = 10;
1039
1040 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1041 fd.fd = self->cfd;
1042 fd.events = POLLIN;
1043
1044 EXPECT_EQ(poll(&fd, 1, 20), 1);
1045 EXPECT_EQ(fd.revents & POLLIN, 1);
0185e2e6 1046 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
7f657d5b
DW		 1047 /* Test timing out */
1048 EXPECT_EQ(poll(&fd, 1, 20), 0);
1049}
1050
1051TEST_F(tls, poll_wait)
1052{
1053 char const *test_str = "test_poll_wait";
1054 int send_len = strlen(test_str) + 1;
1055 struct pollfd fd = { 0, 0, 0 };
1056 char recv_mem[15];
1057
1058 fd.fd = self->cfd;
1059 fd.events = POLLIN;
1060 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1061 /* Set timeout to inf. secs */
1062 EXPECT_EQ(poll(&fd, 1, -1), 1);
1063 EXPECT_EQ(fd.revents & POLLIN, 1);
0185e2e6 1064 EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len);
7f657d5b
DW		 1065}
1066
81a89ef6
JK		 1067TEST_F(tls, poll_wait_split)
1068{
1069 struct pollfd fd = { 0, 0, 0 };
1070 char send_mem[20] = {};
1071 char recv_mem[15];
1072
1073 fd.fd = self->cfd;
1074 fd.events = POLLIN;
1075 /* Send 20 bytes */
1076 EXPECT_EQ(send(self->fd, send_mem, sizeof(send_mem), 0),
1077 sizeof(send_mem));
1078 /* Poll with inf. timeout */
1079 EXPECT_EQ(poll(&fd, 1, -1), 1);
1080 EXPECT_EQ(fd.revents & POLLIN, 1);
1081 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), MSG_WAITALL),
1082 sizeof(recv_mem));
1083
1084 /* Now the remaining 5 bytes of record data are in TLS ULP */
1085 fd.fd = self->cfd;
1086 fd.events = POLLIN;
1087 EXPECT_EQ(poll(&fd, 1, -1), 1);
1088 EXPECT_EQ(fd.revents & POLLIN, 1);
1089 EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), 0),
1090 sizeof(send_mem) - sizeof(recv_mem));
1091}
1092
7f657d5b
DW		 1093TEST_F(tls, blocking)
1094{
1095 size_t data = 100000;
1096 int res = fork();
1097
1098 EXPECT_NE(res, -1);
1099
1100 if (res) {
1101 /* parent */
1102 size_t left = data;
1103 char buf[16384];
1104 int status;
1105 int pid2;
1106
1107 while (left) {
1108 int res = send(self->fd, buf,
1109 left > 16384 ? 16384 : left, 0);
1110
1111 EXPECT_GE(res, 0);
1112 left -= res;
1113 }
1114
1115 pid2 = wait(&status);
1116 EXPECT_EQ(status, 0);
1117 EXPECT_EQ(res, pid2);
1118 } else {
1119 /* child */
1120 size_t left = data;
1121 char buf[16384];
1122
1123 while (left) {
1124 int res = recv(self->cfd, buf,
1125 left > 16384 ? 16384 : left, 0);
1126
1127 EXPECT_GE(res, 0);
1128 left -= res;
1129 }
1130 }
1131}
1132
1133TEST_F(tls, nonblocking)
1134{
1135 size_t data = 100000;
1136 int sendbuf = 100;
1137 int flags;
1138 int res;
1139
1140 flags = fcntl(self->fd, F_GETFL, 0);
1141 fcntl(self->fd, F_SETFL, flags | O_NONBLOCK);
1142 fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK);
1143
1144 /* Ensure nonblocking behavior by imposing a small send
1145 * buffer.
1146 */
1147 EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
1148 &sendbuf, sizeof(sendbuf)), 0);
1149
1150 res = fork();
1151 EXPECT_NE(res, -1);
1152
1153 if (res) {
1154 /* parent */
1155 bool eagain = false;
1156 size_t left = data;
1157 char buf[16384];
1158 int status;
1159 int pid2;
1160
1161 while (left) {
1162 int res = send(self->fd, buf,
1163 left > 16384 ? 16384 : left, 0);
1164
1165 if (res == -1 && errno == EAGAIN) {
1166 eagain = true;
1167 usleep(10000);
1168 continue;
1169 }
1170 EXPECT_GE(res, 0);
1171 left -= res;
1172 }
1173
1174 EXPECT_TRUE(eagain);
1175 pid2 = wait(&status);
1176
1177 EXPECT_EQ(status, 0);
1178 EXPECT_EQ(res, pid2);
1179 } else {
1180 /* child */
1181 bool eagain = false;
1182 size_t left = data;
1183 char buf[16384];
1184
1185 while (left) {
1186 int res = recv(self->cfd, buf,
1187 left > 16384 ? 16384 : left, 0);
1188
1189 if (res == -1 && errno == EAGAIN) {
1190 eagain = true;
1191 usleep(10000);
1192 continue;
1193 }
1194 EXPECT_GE(res, 0);
1195 left -= res;
1196 }
1197 EXPECT_TRUE(eagain);
1198 }
1199}
1200
41098af5
JK		 1201static void
1202test_mutliproc(struct __test_metadata *_metadata, struct _test_data_tls *self,
1203 bool sendpg, unsigned int n_readers, unsigned int n_writers)
1204{
1205 const unsigned int n_children = n_readers + n_writers;
1206 const size_t data = 6 * 1000 * 1000;
1207 const size_t file_sz = data / 100;
1208 size_t read_bias, write_bias;
1209 int i, fd, child_id;
1210 char buf[file_sz];
1211 pid_t pid;
1212
1213 /* Only allow multiples for simplicity */
1214 ASSERT_EQ(!(n_readers % n_writers) || !(n_writers % n_readers), true);
1215 read_bias = n_writers / n_readers ?: 1;
1216 write_bias = n_readers / n_writers ?: 1;
1217
1218 /* prep a file to send */
1219 fd = open("/tmp/", O_TMPFILE | O_RDWR, 0600);
1220 ASSERT_GE(fd, 0);
1221
1222 memset(buf, 0xac, file_sz);
1223 ASSERT_EQ(write(fd, buf, file_sz), file_sz);
1224
1225 /* spawn children */
1226 for (child_id = 0; child_id < n_children; child_id++) {
1227 pid = fork();
1228 ASSERT_NE(pid, -1);
1229 if (!pid)
1230 break;
1231 }
1232
1233 /* parent waits for all children */
1234 if (pid) {
1235 for (i = 0; i < n_children; i++) {
1236 int status;
1237
1238 wait(&status);
1239 EXPECT_EQ(status, 0);
1240 }
1241
1242 return;
1243 }
1244
1245 /* Split threads for reading and writing */
1246 if (child_id < n_readers) {
1247 size_t left = data * read_bias;
1248 char rb[8001];
1249
1250 while (left) {
1251 int res;
1252
1253 res = recv(self->cfd, rb,
1254 left > sizeof(rb) ? sizeof(rb) : left, 0);
1255
1256 EXPECT_GE(res, 0);
1257 left -= res;
1258 }
1259 } else {
1260 size_t left = data * write_bias;
1261
1262 while (left) {
1263 int res;
1264
1265 ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0);
1266 if (sendpg)
1267 res = sendfile(self->fd, fd, NULL,
1268 left > file_sz ? file_sz : left);
1269 else
1270 res = send(self->fd, buf,
1271 left > file_sz ? file_sz : left, 0);
1272
1273 EXPECT_GE(res, 0);
1274 left -= res;
1275 }
1276 }
1277}
1278
1279TEST_F(tls, mutliproc_even)
1280{
1281 test_mutliproc(_metadata, self, false, 6, 6);
1282}
1283
1284TEST_F(tls, mutliproc_readers)
1285{
1286 test_mutliproc(_metadata, self, false, 4, 12);
1287}
1288
1289TEST_F(tls, mutliproc_writers)
1290{
1291 test_mutliproc(_metadata, self, false, 10, 2);
1292}
1293
1294TEST_F(tls, mutliproc_sendpage_even)
1295{
1296 test_mutliproc(_metadata, self, true, 6, 6);
1297}
1298
1299TEST_F(tls, mutliproc_sendpage_readers)
1300{
1301 test_mutliproc(_metadata, self, true, 4, 12);
1302}
1303
1304TEST_F(tls, mutliproc_sendpage_writers)
1305{
1306 test_mutliproc(_metadata, self, true, 10, 2);
1307}
1308
7f657d5b
DW		 1309TEST_F(tls, control_msg)
1310{
31180adb 1311 char *test_str = "test_read";
7f657d5b 1312 char record_type = 100;
7f657d5b 1313 int send_len = 10;
7f657d5b
DW		 1314 char buf[10];
1315
31180adb
JK		 1316 if (self->notls)
1317 SKIP(return, "no TLS support");
7f657d5b 1318
31180adb
JK		 1319 EXPECT_EQ(tls_send_cmsg(self->fd, record_type, test_str, send_len, 0),
1320 send_len);
7f657d5b
DW		 1321 /* Should fail because we didn't provide a control message */
1322 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
1323
31180adb
JK		 1324 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type,
1325 buf, sizeof(buf), MSG_WAITALL | MSG_PEEK),
1326 send_len);
203ef5f1
VG		 1327 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1328
1329 /* Recv the message again without MSG_PEEK */
203ef5f1
VG		 1330 memset(buf, 0, sizeof(buf));
1331
31180adb
JK		 1332 EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type,
1333 buf, sizeof(buf), MSG_WAITALL),
1334 send_len);
7f657d5b
DW		 1335 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1336}
1337
d4d34185
JK		 1338TEST_F(tls, shutdown)
1339{
1340 char const *test_str = "test_read";
1341 int send_len = 10;
1342 char buf[10];
1343
1344 ASSERT_EQ(strlen(test_str) + 1, send_len);
1345
1346 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1347 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
1348 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1349
1350 shutdown(self->fd, SHUT_RDWR);
1351 shutdown(self->cfd, SHUT_RDWR);
1352}
1353
1354TEST_F(tls, shutdown_unsent)
1355{
1356 char const *test_str = "test_read";
1357 int send_len = 10;
1358
1359 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
1360
1361 shutdown(self->fd, SHUT_RDWR);
1362 shutdown(self->cfd, SHUT_RDWR);
1363}
1364
cd114d2e
JK		 1365TEST_F(tls, shutdown_reuse)
1366{
1367 struct sockaddr_in addr;
1368 int ret;
1369
1370 shutdown(self->fd, SHUT_RDWR);
1371 shutdown(self->cfd, SHUT_RDWR);
1372 close(self->cfd);
1373
1374 addr.sin_family = AF_INET;
1375 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1376 addr.sin_port = 0;
1377
1378 ret = bind(self->fd, &addr, sizeof(addr));
1379 EXPECT_EQ(ret, 0);
1380 ret = listen(self->fd, 10);
1381 EXPECT_EQ(ret, -1);
1382 EXPECT_EQ(errno, EINVAL);
1383
1384 ret = connect(self->fd, &addr, sizeof(addr));
1385 EXPECT_EQ(ret, -1);
1386 EXPECT_EQ(errno, EISCONN);
1387}
1388
ef0fc0b3
JK		 1389FIXTURE(tls_err)
1390{
1391 int fd, cfd;
1392 int fd2, cfd2;
1393 bool notls;
1394};
1395
1396FIXTURE_VARIANT(tls_err)
1397{
1398 uint16_t tls_version;
1399};
1400
1401FIXTURE_VARIANT_ADD(tls_err, 12_aes_gcm)
1402{
1403 .tls_version = TLS_1_2_VERSION,
1404};
1405
1406FIXTURE_VARIANT_ADD(tls_err, 13_aes_gcm)
1407{
1408 .tls_version = TLS_1_3_VERSION,
1409};
1410
1411FIXTURE_SETUP(tls_err)
1412{
1413 struct tls_crypto_info_keys tls12;
1414 int ret;
1415
1416 tls_crypto_info_init(variant->tls_version, TLS_CIPHER_AES_GCM_128,
1417 &tls12);
1418
1419 ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls);
1420 ulp_sock_pair(_metadata, &self->fd2, &self->cfd2, &self->notls);
1421 if (self->notls)
1422 return;
1423
1424 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len);
1425 ASSERT_EQ(ret, 0);
1426
1427 ret = setsockopt(self->cfd2, SOL_TLS, TLS_RX, &tls12, tls12.len);
1428 ASSERT_EQ(ret, 0);
1429}
1430
1431FIXTURE_TEARDOWN(tls_err)
1432{
1433 close(self->fd);
1434 close(self->cfd);
1435 close(self->fd2);
1436 close(self->cfd2);
1437}
1438
1439TEST_F(tls_err, bad_rec)
1440{
1441 char buf[64];
1442
1443 if (self->notls)
1444 SKIP(return, "no TLS support");
1445
1446 memset(buf, 0x55, sizeof(buf));
1447 EXPECT_EQ(send(self->fd2, buf, sizeof(buf), 0), sizeof(buf));
1448 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1449 EXPECT_EQ(errno, EMSGSIZE);
1450 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), MSG_DONTWAIT), -1);
1451 EXPECT_EQ(errno, EAGAIN);
1452}
1453
1454TEST_F(tls_err, bad_auth)
1455{
1456 char buf[128];
1457 int n;
1458
1459 if (self->notls)
1460 SKIP(return, "no TLS support");
1461
1462 memrnd(buf, sizeof(buf) / 2);
1463 EXPECT_EQ(send(self->fd, buf, sizeof(buf) / 2, 0), sizeof(buf) / 2);
1464 n = recv(self->cfd, buf, sizeof(buf), 0);
1465 EXPECT_GT(n, sizeof(buf) / 2);
1466
1467 buf[n - 1]++;
1468
1469 EXPECT_EQ(send(self->fd2, buf, n, 0), n);
1470 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1471 EXPECT_EQ(errno, EBADMSG);
1472 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1473 EXPECT_EQ(errno, EBADMSG);
1474}
1475
1476TEST_F(tls_err, bad_in_large_read)
1477{
1478 char txt[3][64];
1479 char cip[3][128];
1480 char buf[3 * 128];
1481 int i, n;
1482
1483 if (self->notls)
1484 SKIP(return, "no TLS support");
1485
1486 /* Put 3 records in the sockets */
1487 for (i = 0; i < 3; i++) {
1488 memrnd(txt[i], sizeof(txt[i]));
1489 EXPECT_EQ(send(self->fd, txt[i], sizeof(txt[i]), 0),
1490 sizeof(txt[i]));
1491 n = recv(self->cfd, cip[i], sizeof(cip[i]), 0);
1492 EXPECT_GT(n, sizeof(txt[i]));
1493 /* Break the third message */
1494 if (i == 2)
1495 cip[2][n - 1]++;
1496 EXPECT_EQ(send(self->fd2, cip[i], n, 0), n);
1497 }
1498
1499 /* We should be able to receive the first two messages */
1500 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), sizeof(txt[0]) * 2);
1501 EXPECT_EQ(memcmp(buf, txt[0], sizeof(txt[0])), 0);
1502 EXPECT_EQ(memcmp(buf + sizeof(txt[0]), txt[1], sizeof(txt[1])), 0);
1503 /* Third mesasge is bad */
1504 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1505 EXPECT_EQ(errno, EBADMSG);
1506 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1507 EXPECT_EQ(errno, EBADMSG);
1508}
1509
1510TEST_F(tls_err, bad_cmsg)
1511{
1512 char *test_str = "test_read";
1513 int send_len = 10;
1514 char cip[128];
1515 char buf[128];
1516 char txt[64];
1517 int n;
1518
1519 if (self->notls)
1520 SKIP(return, "no TLS support");
1521
1522 /* Queue up one data record */
1523 memrnd(txt, sizeof(txt));
1524 EXPECT_EQ(send(self->fd, txt, sizeof(txt), 0), sizeof(txt));
1525 n = recv(self->cfd, cip, sizeof(cip), 0);
1526 EXPECT_GT(n, sizeof(txt));
1527 EXPECT_EQ(send(self->fd2, cip, n, 0), n);
1528
1529 EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10);
1530 n = recv(self->cfd, cip, sizeof(cip), 0);
1531 cip[n - 1]++; /* Break it */
1532 EXPECT_GT(n, send_len);
1533 EXPECT_EQ(send(self->fd2, cip, n, 0), n);
1534
1535 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), sizeof(txt));
1536 EXPECT_EQ(memcmp(buf, txt, sizeof(txt)), 0);
1537 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1538 EXPECT_EQ(errno, EBADMSG);
1539 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1540 EXPECT_EQ(errno, EBADMSG);
1541}
1542
78b5dc3d
JK		 1543TEST(non_established) {
1544 struct tls12_crypto_info_aes_gcm_256 tls12;
1545 struct sockaddr_in addr;
1546 int sfd, ret, fd;
1547 socklen_t len;
1548
1549 len = sizeof(addr);
1550
1551 memset(&tls12, 0, sizeof(tls12));
1552 tls12.info.version = TLS_1_2_VERSION;
1553 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1554
1555 addr.sin_family = AF_INET;
1556 addr.sin_addr.s_addr = htonl(INADDR_ANY);
1557 addr.sin_port = 0;
1558
1559 fd = socket(AF_INET, SOCK_STREAM, 0);
1560 sfd = socket(AF_INET, SOCK_STREAM, 0);
1561
1562 ret = bind(sfd, &addr, sizeof(addr));
1563 ASSERT_EQ(ret, 0);
1564 ret = listen(sfd, 10);
1565 ASSERT_EQ(ret, 0);
1566
1567 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1568 EXPECT_EQ(ret, -1);
1569 /* TLS ULP not supported */
1570 if (errno == ENOENT)
1571 return;
4a5cdc60 1572 EXPECT_EQ(errno, ENOTCONN);
78b5dc3d
JK		 1573
1574 ret = setsockopt(sfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1575 EXPECT_EQ(ret, -1);
4a5cdc60 1576 EXPECT_EQ(errno, ENOTCONN);
78b5dc3d
JK		 1577
1578 ret = getsockname(sfd, &addr, &len);
1579 ASSERT_EQ(ret, 0);
1580
1581 ret = connect(fd, &addr, sizeof(addr));
1582 ASSERT_EQ(ret, 0);
1583
1584 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1585 ASSERT_EQ(ret, 0);
1586
1587 ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1588 EXPECT_EQ(ret, -1);
1589 EXPECT_EQ(errno, EEXIST);
1590
1591 close(fd);
1592 close(sfd);
1593}
1594
fb99bce7
DW		 1595TEST(keysizes) {
1596 struct tls12_crypto_info_aes_gcm_256 tls12;
a125f91f 1597 int ret, fd, cfd;
fb99bce7
DW		 1598 bool notls;
1599
fb99bce7
DW		 1600 memset(&tls12, 0, sizeof(tls12));
1601 tls12.info.version = TLS_1_2_VERSION;
1602 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1603
a125f91f 1604 ulp_sock_pair(_metadata, &fd, &cfd, &notls);
fb99bce7
DW		 1605
1606 if (!notls) {
1607 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12,
1608 sizeof(tls12));
1609 EXPECT_EQ(ret, 0);
fb99bce7
DW		 1610
1611 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12,
1612 sizeof(tls12));
1613 EXPECT_EQ(ret, 0);
1614 }
1615
fb99bce7
DW		 1616 close(fd);
1617 close(cfd);
1618}
1619
7f657d5b 1620TEST_HARNESS_MAIN
Linux 6.x block layer and io_uring tree(s)