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
FIXTURE(tls)28 FIXTURE(tls)
29 {
30 int fd, cfd;
31 bool notls;
32 };
33
FIXTURE_SETUP(tls)34 FIXTURE_SETUP(tls)
35 {
36 struct tls12_crypto_info_aes_gcm_128 tls12;
37 struct sockaddr_in addr;
38 socklen_t len;
39 int sfd, ret;
40
41 self->notls = false;
42 len = sizeof(addr);
43
44 memset(&tls12, 0, sizeof(tls12));
45 tls12.info.version = TLS_1_2_VERSION;
46 tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
47
48 addr.sin_family = AF_INET;
49 addr.sin_addr.s_addr = htonl(INADDR_ANY);
50 addr.sin_port = 0;
51
52 self->fd = socket(AF_INET, SOCK_STREAM, 0);
53 sfd = socket(AF_INET, SOCK_STREAM, 0);
54
55 ret = bind(sfd, &addr, sizeof(addr));
56 ASSERT_EQ(ret, 0);
57 ret = listen(sfd, 10);
58 ASSERT_EQ(ret, 0);
59
60 ret = getsockname(sfd, &addr, &len);
61 ASSERT_EQ(ret, 0);
62
63 ret = connect(self->fd, &addr, sizeof(addr));
64 ASSERT_EQ(ret, 0);
65
66 ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
67 if (ret != 0) {
68 self->notls = true;
69 printf("Failure setting TCP_ULP, testing without tls\n");
70 }
71
72 if (!self->notls) {
73 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12,
74 sizeof(tls12));
75 ASSERT_EQ(ret, 0);
76 }
77
78 self->cfd = accept(sfd, &addr, &len);
79 ASSERT_GE(self->cfd, 0);
80
81 if (!self->notls) {
82 ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls",
83 sizeof("tls"));
84 ASSERT_EQ(ret, 0);
85
86 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12,
87 sizeof(tls12));
88 ASSERT_EQ(ret, 0);
89 }
90
91 close(sfd);
92 }
93
FIXTURE_TEARDOWN(tls)94 FIXTURE_TEARDOWN(tls)
95 {
96 close(self->fd);
97 close(self->cfd);
98 }
99
TEST_F(tls,sendfile)100 TEST_F(tls, sendfile)
101 {
102 int filefd = open("/proc/self/exe", O_RDONLY);
103 struct stat st;
104
105 EXPECT_GE(filefd, 0);
106 fstat(filefd, &st);
107 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
108 }
109
TEST_F(tls,send_then_sendfile)110 TEST_F(tls, send_then_sendfile)
111 {
112 int filefd = open("/proc/self/exe", O_RDONLY);
113 char const *test_str = "test_send";
114 int to_send = strlen(test_str) + 1;
115 char recv_buf[10];
116 struct stat st;
117 char *buf;
118
119 EXPECT_GE(filefd, 0);
120 fstat(filefd, &st);
121 buf = (char *)malloc(st.st_size);
122
123 EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send);
124 EXPECT_EQ(recv(self->cfd, recv_buf, to_send, MSG_WAITALL), to_send);
125 EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);
126
127 EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
128 EXPECT_EQ(recv(self->cfd, buf, st.st_size, MSG_WAITALL), st.st_size);
129 }
130
TEST_F(tls,recv_max)131 TEST_F(tls, recv_max)
132 {
133 unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
134 char recv_mem[TLS_PAYLOAD_MAX_LEN];
135 char buf[TLS_PAYLOAD_MAX_LEN];
136
137 EXPECT_GE(send(self->fd, buf, send_len, 0), 0);
138 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
139 EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0);
140 }
141
TEST_F(tls,recv_small)142 TEST_F(tls, recv_small)
143 {
144 char const *test_str = "test_read";
145 int send_len = 10;
146 char buf[10];
147
148 send_len = strlen(test_str) + 1;
149 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
150 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
151 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
152 }
153
TEST_F(tls,msg_more)154 TEST_F(tls, msg_more)
155 {
156 char const *test_str = "test_read";
157 int send_len = 10;
158 char buf[10 * 2];
159
160 EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
161 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
162 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
163 EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_WAITALL),
164 send_len * 2);
165 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
166 }
167
TEST_F(tls,sendmsg_single)168 TEST_F(tls, sendmsg_single)
169 {
170 struct msghdr msg;
171
172 char const *test_str = "test_sendmsg";
173 size_t send_len = 13;
174 struct iovec vec;
175 char buf[13];
176
177 vec.iov_base = (char *)test_str;
178 vec.iov_len = send_len;
179 memset(&msg, 0, sizeof(struct msghdr));
180 msg.msg_iov = &vec;
181 msg.msg_iovlen = 1;
182 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
183 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
184 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
185 }
186
TEST_F(tls,sendmsg_large)187 TEST_F(tls, sendmsg_large)
188 {
189 void *mem = malloc(16384);
190 size_t send_len = 16384;
191 size_t sends = 128;
192 struct msghdr msg;
193 size_t recvs = 0;
194 size_t sent = 0;
195
196 memset(&msg, 0, sizeof(struct msghdr));
197 while (sent++ < sends) {
198 struct iovec vec = { (void *)mem, send_len };
199
200 msg.msg_iov = &vec;
201 msg.msg_iovlen = 1;
202 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), send_len);
203 }
204
205 while (recvs++ < sends)
206 EXPECT_NE(recv(self->fd, mem, send_len, 0), -1);
207
208 free(mem);
209 }
210
TEST_F(tls,sendmsg_multiple)211 TEST_F(tls, sendmsg_multiple)
212 {
213 char const *test_str = "test_sendmsg_multiple";
214 struct iovec vec[5];
215 char *test_strs[5];
216 struct msghdr msg;
217 int total_len = 0;
218 int len_cmp = 0;
219 int iov_len = 5;
220 char *buf;
221 int i;
222
223 memset(&msg, 0, sizeof(struct msghdr));
224 for (i = 0; i < iov_len; i++) {
225 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
226 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
227 vec[i].iov_base = (void *)test_strs[i];
228 vec[i].iov_len = strlen(test_strs[i]) + 1;
229 total_len += vec[i].iov_len;
230 }
231 msg.msg_iov = vec;
232 msg.msg_iovlen = iov_len;
233
234 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), total_len);
235 buf = malloc(total_len);
236 EXPECT_NE(recv(self->fd, buf, total_len, 0), -1);
237 for (i = 0; i < iov_len; i++) {
238 EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
239 strlen(test_strs[i])),
240 0);
241 len_cmp += strlen(buf + len_cmp) + 1;
242 }
243 for (i = 0; i < iov_len; i++)
244 free(test_strs[i]);
245 free(buf);
246 }
247
TEST_F(tls,sendmsg_multiple_stress)248 TEST_F(tls, sendmsg_multiple_stress)
249 {
250 char const *test_str = "abcdefghijklmno";
251 struct iovec vec[1024];
252 char *test_strs[1024];
253 int iov_len = 1024;
254 int total_len = 0;
255 char buf[1 << 14];
256 struct msghdr msg;
257 int len_cmp = 0;
258 int i;
259
260 memset(&msg, 0, sizeof(struct msghdr));
261 for (i = 0; i < iov_len; i++) {
262 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
263 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
264 vec[i].iov_base = (void *)test_strs[i];
265 vec[i].iov_len = strlen(test_strs[i]) + 1;
266 total_len += vec[i].iov_len;
267 }
268 msg.msg_iov = vec;
269 msg.msg_iovlen = iov_len;
270
271 EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
272 EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
273
274 for (i = 0; i < iov_len; i++)
275 len_cmp += strlen(buf + len_cmp) + 1;
276
277 for (i = 0; i < iov_len; i++)
278 free(test_strs[i]);
279 }
280
TEST_F(tls,splice_from_pipe)281 TEST_F(tls, splice_from_pipe)
282 {
283 int send_len = TLS_PAYLOAD_MAX_LEN;
284 char mem_send[TLS_PAYLOAD_MAX_LEN];
285 char mem_recv[TLS_PAYLOAD_MAX_LEN];
286 int p[2];
287
288 ASSERT_GE(pipe(p), 0);
289 EXPECT_GE(write(p[1], mem_send, send_len), 0);
290 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
291 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
292 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
293 }
294
TEST_F(tls,splice_from_pipe2)295 TEST_F(tls, splice_from_pipe2)
296 {
297 int send_len = 16000;
298 char mem_send[16000];
299 char mem_recv[16000];
300 int p2[2];
301 int p[2];
302
303 ASSERT_GE(pipe(p), 0);
304 ASSERT_GE(pipe(p2), 0);
305 EXPECT_GE(write(p[1], mem_send, 8000), 0);
306 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
307 EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
308 EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
309 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
310 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
311 }
312
TEST_F(tls,send_and_splice)313 TEST_F(tls, send_and_splice)
314 {
315 int send_len = TLS_PAYLOAD_MAX_LEN;
316 char mem_send[TLS_PAYLOAD_MAX_LEN];
317 char mem_recv[TLS_PAYLOAD_MAX_LEN];
318 char const *test_str = "test_read";
319 int send_len2 = 10;
320 char buf[10];
321 int p[2];
322
323 ASSERT_GE(pipe(p), 0);
324 EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
325 EXPECT_EQ(recv(self->cfd, buf, send_len2, MSG_WAITALL), send_len2);
326 EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);
327
328 EXPECT_GE(write(p[1], mem_send, send_len), send_len);
329 EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);
330
331 EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
332 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
333 }
334
TEST_F(tls,splice_to_pipe)335 TEST_F(tls, splice_to_pipe)
336 {
337 int send_len = TLS_PAYLOAD_MAX_LEN;
338 char mem_send[TLS_PAYLOAD_MAX_LEN];
339 char mem_recv[TLS_PAYLOAD_MAX_LEN];
340 int p[2];
341
342 ASSERT_GE(pipe(p), 0);
343 EXPECT_GE(send(self->fd, mem_send, send_len, 0), 0);
344 EXPECT_GE(splice(self->cfd, NULL, p[1], NULL, send_len, 0), 0);
345 EXPECT_GE(read(p[0], mem_recv, send_len), 0);
346 EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
347 }
348
TEST_F(tls,recvmsg_single)349 TEST_F(tls, recvmsg_single)
350 {
351 char const *test_str = "test_recvmsg_single";
352 int send_len = strlen(test_str) + 1;
353 char buf[20];
354 struct msghdr hdr;
355 struct iovec vec;
356
357 memset(&hdr, 0, sizeof(hdr));
358 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
359 vec.iov_base = (char *)buf;
360 vec.iov_len = send_len;
361 hdr.msg_iovlen = 1;
362 hdr.msg_iov = &vec;
363 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
364 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
365 }
366
TEST_F(tls,recvmsg_single_max)367 TEST_F(tls, recvmsg_single_max)
368 {
369 int send_len = TLS_PAYLOAD_MAX_LEN;
370 char send_mem[TLS_PAYLOAD_MAX_LEN];
371 char recv_mem[TLS_PAYLOAD_MAX_LEN];
372 struct iovec vec;
373 struct msghdr hdr;
374
375 EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
376 vec.iov_base = (char *)recv_mem;
377 vec.iov_len = TLS_PAYLOAD_MAX_LEN;
378
379 hdr.msg_iovlen = 1;
380 hdr.msg_iov = &vec;
381 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
382 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
383 }
384
TEST_F(tls,recvmsg_multiple)385 TEST_F(tls, recvmsg_multiple)
386 {
387 unsigned int msg_iovlen = 1024;
388 unsigned int len_compared = 0;
389 struct iovec vec[1024];
390 char *iov_base[1024];
391 unsigned int iov_len = 16;
392 int send_len = 1 << 14;
393 char buf[1 << 14];
394 struct msghdr hdr;
395 int i;
396
397 EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
398 for (i = 0; i < msg_iovlen; i++) {
399 iov_base[i] = (char *)malloc(iov_len);
400 vec[i].iov_base = iov_base[i];
401 vec[i].iov_len = iov_len;
402 }
403
404 hdr.msg_iovlen = msg_iovlen;
405 hdr.msg_iov = vec;
406 EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
407 for (i = 0; i < msg_iovlen; i++)
408 len_compared += iov_len;
409
410 for (i = 0; i < msg_iovlen; i++)
411 free(iov_base[i]);
412 }
413
TEST_F(tls,single_send_multiple_recv)414 TEST_F(tls, single_send_multiple_recv)
415 {
416 unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
417 unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
418 char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
419 char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];
420
421 EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
422 memset(recv_mem, 0, total_len);
423
424 EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
425 EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
426 EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
427 }
428
TEST_F(tls,multiple_send_single_recv)429 TEST_F(tls, multiple_send_single_recv)
430 {
431 unsigned int total_len = 2 * 10;
432 unsigned int send_len = 10;
433 char recv_mem[2 * 10];
434 char send_mem[10];
435
436 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
437 EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
438 memset(recv_mem, 0, total_len);
439 EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len);
440
441 EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
442 EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
443 }
444
TEST_F(tls,recv_partial)445 TEST_F(tls, recv_partial)
446 {
447 char const *test_str = "test_read_partial";
448 char const *test_str_first = "test_read";
449 char const *test_str_second = "_partial";
450 int send_len = strlen(test_str) + 1;
451 char recv_mem[18];
452
453 memset(recv_mem, 0, sizeof(recv_mem));
454 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
455 EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first), 0), -1);
456 EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
457 memset(recv_mem, 0, sizeof(recv_mem));
458 EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second), 0), -1);
459 EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
460 0);
461 }
462
TEST_F(tls,recv_nonblock)463 TEST_F(tls, recv_nonblock)
464 {
465 char buf[4096];
466 bool err;
467
468 EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
469 err = (errno == EAGAIN || errno == EWOULDBLOCK);
470 EXPECT_EQ(err, true);
471 }
472
TEST_F(tls,recv_peek)473 TEST_F(tls, recv_peek)
474 {
475 char const *test_str = "test_read_peek";
476 int send_len = strlen(test_str) + 1;
477 char buf[15];
478
479 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
480 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
481 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
482 memset(buf, 0, sizeof(buf));
483 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
484 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
485 }
486
TEST_F(tls,recv_peek_multiple)487 TEST_F(tls, recv_peek_multiple)
488 {
489 char const *test_str = "test_read_peek";
490 int send_len = strlen(test_str) + 1;
491 unsigned int num_peeks = 100;
492 char buf[15];
493 int i;
494
495 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
496 for (i = 0; i < num_peeks; i++) {
497 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
498 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
499 memset(buf, 0, sizeof(buf));
500 }
501 EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
502 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
503 }
504
TEST_F(tls,recv_peek_multiple_records)505 TEST_F(tls, recv_peek_multiple_records)
506 {
507 char const *test_str = "test_read_peek_mult_recs";
508 char const *test_str_first = "test_read_peek";
509 char const *test_str_second = "_mult_recs";
510 int len;
511 char buf[64];
512
513 len = strlen(test_str_first);
514 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
515
516 len = strlen(test_str_second) + 1;
517 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
518
519 len = strlen(test_str_first);
520 memset(buf, 0, len);
521 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
522
523 /* MSG_PEEK can only peek into the current record. */
524 len = strlen(test_str_first);
525 EXPECT_EQ(memcmp(test_str_first, buf, len), 0);
526
527 len = strlen(test_str) + 1;
528 memset(buf, 0, len);
529 EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len);
530
531 /* Non-MSG_PEEK will advance strparser (and therefore record)
532 * however.
533 */
534 len = strlen(test_str) + 1;
535 EXPECT_EQ(memcmp(test_str, buf, len), 0);
536
537 /* MSG_MORE will hold current record open, so later MSG_PEEK
538 * will see everything.
539 */
540 len = strlen(test_str_first);
541 EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len);
542
543 len = strlen(test_str_second) + 1;
544 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
545
546 len = strlen(test_str) + 1;
547 memset(buf, 0, len);
548 EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
549
550 len = strlen(test_str) + 1;
551 EXPECT_EQ(memcmp(test_str, buf, len), 0);
552 }
553
TEST_F(tls,recv_peek_large_buf_mult_recs)554 TEST_F(tls, recv_peek_large_buf_mult_recs)
555 {
556 char const *test_str = "test_read_peek_mult_recs";
557 char const *test_str_first = "test_read_peek";
558 char const *test_str_second = "_mult_recs";
559 int len;
560 char buf[64];
561
562 len = strlen(test_str_first);
563 EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
564
565 len = strlen(test_str_second) + 1;
566 EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
567
568 len = sizeof(buf);
569 memset(buf, 0, len);
570 EXPECT_NE(recv(self->cfd, buf, len, MSG_PEEK), -1);
571
572 len = strlen(test_str) + 1;
573 EXPECT_EQ(memcmp(test_str, buf, len), 0);
574 }
575
576
TEST_F(tls,pollin)577 TEST_F(tls, pollin)
578 {
579 char const *test_str = "test_poll";
580 struct pollfd fd = { 0, 0, 0 };
581 char buf[10];
582 int send_len = 10;
583
584 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
585 fd.fd = self->cfd;
586 fd.events = POLLIN;
587
588 EXPECT_EQ(poll(&fd, 1, 20), 1);
589 EXPECT_EQ(fd.revents & POLLIN, 1);
590 EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
591 /* Test timing out */
592 EXPECT_EQ(poll(&fd, 1, 20), 0);
593 }
594
TEST_F(tls,poll_wait)595 TEST_F(tls, poll_wait)
596 {
597 char const *test_str = "test_poll_wait";
598 int send_len = strlen(test_str) + 1;
599 struct pollfd fd = { 0, 0, 0 };
600 char recv_mem[15];
601
602 fd.fd = self->cfd;
603 fd.events = POLLIN;
604 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
605 /* Set timeout to inf. secs */
606 EXPECT_EQ(poll(&fd, 1, -1), 1);
607 EXPECT_EQ(fd.revents & POLLIN, 1);
608 EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len);
609 }
610
TEST_F(tls,blocking)611 TEST_F(tls, blocking)
612 {
613 size_t data = 100000;
614 int res = fork();
615
616 EXPECT_NE(res, -1);
617
618 if (res) {
619 /* parent */
620 size_t left = data;
621 char buf[16384];
622 int status;
623 int pid2;
624
625 while (left) {
626 int res = send(self->fd, buf,
627 left > 16384 ? 16384 : left, 0);
628
629 EXPECT_GE(res, 0);
630 left -= res;
631 }
632
633 pid2 = wait(&status);
634 EXPECT_EQ(status, 0);
635 EXPECT_EQ(res, pid2);
636 } else {
637 /* child */
638 size_t left = data;
639 char buf[16384];
640
641 while (left) {
642 int res = recv(self->cfd, buf,
643 left > 16384 ? 16384 : left, 0);
644
645 EXPECT_GE(res, 0);
646 left -= res;
647 }
648 }
649 }
650
TEST_F(tls,nonblocking)651 TEST_F(tls, nonblocking)
652 {
653 size_t data = 100000;
654 int sendbuf = 100;
655 int flags;
656 int res;
657
658 flags = fcntl(self->fd, F_GETFL, 0);
659 fcntl(self->fd, F_SETFL, flags | O_NONBLOCK);
660 fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK);
661
662 /* Ensure nonblocking behavior by imposing a small send
663 * buffer.
664 */
665 EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
666 &sendbuf, sizeof(sendbuf)), 0);
667
668 res = fork();
669 EXPECT_NE(res, -1);
670
671 if (res) {
672 /* parent */
673 bool eagain = false;
674 size_t left = data;
675 char buf[16384];
676 int status;
677 int pid2;
678
679 while (left) {
680 int res = send(self->fd, buf,
681 left > 16384 ? 16384 : left, 0);
682
683 if (res == -1 && errno == EAGAIN) {
684 eagain = true;
685 usleep(10000);
686 continue;
687 }
688 EXPECT_GE(res, 0);
689 left -= res;
690 }
691
692 EXPECT_TRUE(eagain);
693 pid2 = wait(&status);
694
695 EXPECT_EQ(status, 0);
696 EXPECT_EQ(res, pid2);
697 } else {
698 /* child */
699 bool eagain = false;
700 size_t left = data;
701 char buf[16384];
702
703 while (left) {
704 int res = recv(self->cfd, buf,
705 left > 16384 ? 16384 : left, 0);
706
707 if (res == -1 && errno == EAGAIN) {
708 eagain = true;
709 usleep(10000);
710 continue;
711 }
712 EXPECT_GE(res, 0);
713 left -= res;
714 }
715 EXPECT_TRUE(eagain);
716 }
717 }
718
TEST_F(tls,control_msg)719 TEST_F(tls, control_msg)
720 {
721 if (self->notls)
722 return;
723
724 char cbuf[CMSG_SPACE(sizeof(char))];
725 char const *test_str = "test_read";
726 int cmsg_len = sizeof(char);
727 char record_type = 100;
728 struct cmsghdr *cmsg;
729 struct msghdr msg;
730 int send_len = 10;
731 struct iovec vec;
732 char buf[10];
733
734 vec.iov_base = (char *)test_str;
735 vec.iov_len = 10;
736 memset(&msg, 0, sizeof(struct msghdr));
737 msg.msg_iov = &vec;
738 msg.msg_iovlen = 1;
739 msg.msg_control = cbuf;
740 msg.msg_controllen = sizeof(cbuf);
741 cmsg = CMSG_FIRSTHDR(&msg);
742 cmsg->cmsg_level = SOL_TLS;
743 /* test sending non-record types. */
744 cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
745 cmsg->cmsg_len = CMSG_LEN(cmsg_len);
746 *CMSG_DATA(cmsg) = record_type;
747 msg.msg_controllen = cmsg->cmsg_len;
748
749 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
750 /* Should fail because we didn't provide a control message */
751 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
752
753 vec.iov_base = buf;
754 EXPECT_EQ(recvmsg(self->cfd, &msg, MSG_WAITALL), send_len);
755 cmsg = CMSG_FIRSTHDR(&msg);
756 EXPECT_NE(cmsg, NULL);
757 EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
758 EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
759 record_type = *((unsigned char *)CMSG_DATA(cmsg));
760 EXPECT_EQ(record_type, 100);
761 EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
762 }
763
764 TEST_HARNESS_MAIN
765