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 28 FIXTURE(tls) 29 { 30 int fd, cfd; 31 bool notls; 32 }; 33 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 94 FIXTURE_TEARDOWN(tls) 95 { 96 close(self->fd); 97 close(self->cfd); 98 } 99 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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