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, 0), 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, 0), 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_DONTWAIT), 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, 0), 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_GE(recv(self->cfd, mem_recv, send_len, 0), 0); 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_GE(recv(self->cfd, mem_recv, send_len, 0), 0); 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_NE(recv(self->cfd, buf, send_len2, 0), -1); 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_GE(recv(self->cfd, mem_recv, send_len, 0), 0); 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, 0), 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, pollin) 506 { 507 char const *test_str = "test_poll"; 508 struct pollfd fd = { 0, 0, 0 }; 509 char buf[10]; 510 int send_len = 10; 511 512 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 513 fd.fd = self->cfd; 514 fd.events = POLLIN; 515 516 EXPECT_EQ(poll(&fd, 1, 20), 1); 517 EXPECT_EQ(fd.revents & POLLIN, 1); 518 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len); 519 /* Test timing out */ 520 EXPECT_EQ(poll(&fd, 1, 20), 0); 521 } 522 523 TEST_F(tls, poll_wait) 524 { 525 char const *test_str = "test_poll_wait"; 526 int send_len = strlen(test_str) + 1; 527 struct pollfd fd = { 0, 0, 0 }; 528 char recv_mem[15]; 529 530 fd.fd = self->cfd; 531 fd.events = POLLIN; 532 EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len); 533 /* Set timeout to inf. secs */ 534 EXPECT_EQ(poll(&fd, 1, -1), 1); 535 EXPECT_EQ(fd.revents & POLLIN, 1); 536 EXPECT_EQ(recv(self->cfd, recv_mem, send_len, 0), send_len); 537 } 538 539 TEST_F(tls, blocking) 540 { 541 size_t data = 100000; 542 int res = fork(); 543 544 EXPECT_NE(res, -1); 545 546 if (res) { 547 /* parent */ 548 size_t left = data; 549 char buf[16384]; 550 int status; 551 int pid2; 552 553 while (left) { 554 int res = send(self->fd, buf, 555 left > 16384 ? 16384 : left, 0); 556 557 EXPECT_GE(res, 0); 558 left -= res; 559 } 560 561 pid2 = wait(&status); 562 EXPECT_EQ(status, 0); 563 EXPECT_EQ(res, pid2); 564 } else { 565 /* child */ 566 size_t left = data; 567 char buf[16384]; 568 569 while (left) { 570 int res = recv(self->cfd, buf, 571 left > 16384 ? 16384 : left, 0); 572 573 EXPECT_GE(res, 0); 574 left -= res; 575 } 576 } 577 } 578 579 TEST_F(tls, nonblocking) 580 { 581 size_t data = 100000; 582 int sendbuf = 100; 583 int flags; 584 int res; 585 586 flags = fcntl(self->fd, F_GETFL, 0); 587 fcntl(self->fd, F_SETFL, flags | O_NONBLOCK); 588 fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK); 589 590 /* Ensure nonblocking behavior by imposing a small send 591 * buffer. 592 */ 593 EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF, 594 &sendbuf, sizeof(sendbuf)), 0); 595 596 res = fork(); 597 EXPECT_NE(res, -1); 598 599 if (res) { 600 /* parent */ 601 bool eagain = false; 602 size_t left = data; 603 char buf[16384]; 604 int status; 605 int pid2; 606 607 while (left) { 608 int res = send(self->fd, buf, 609 left > 16384 ? 16384 : left, 0); 610 611 if (res == -1 && errno == EAGAIN) { 612 eagain = true; 613 usleep(10000); 614 continue; 615 } 616 EXPECT_GE(res, 0); 617 left -= res; 618 } 619 620 EXPECT_TRUE(eagain); 621 pid2 = wait(&status); 622 623 EXPECT_EQ(status, 0); 624 EXPECT_EQ(res, pid2); 625 } else { 626 /* child */ 627 bool eagain = false; 628 size_t left = data; 629 char buf[16384]; 630 631 while (left) { 632 int res = recv(self->cfd, buf, 633 left > 16384 ? 16384 : left, 0); 634 635 if (res == -1 && errno == EAGAIN) { 636 eagain = true; 637 usleep(10000); 638 continue; 639 } 640 EXPECT_GE(res, 0); 641 left -= res; 642 } 643 EXPECT_TRUE(eagain); 644 } 645 } 646 647 TEST_F(tls, control_msg) 648 { 649 if (self->notls) 650 return; 651 652 char cbuf[CMSG_SPACE(sizeof(char))]; 653 char const *test_str = "test_read"; 654 int cmsg_len = sizeof(char); 655 char record_type = 100; 656 struct cmsghdr *cmsg; 657 struct msghdr msg; 658 int send_len = 10; 659 struct iovec vec; 660 char buf[10]; 661 662 vec.iov_base = (char *)test_str; 663 vec.iov_len = 10; 664 memset(&msg, 0, sizeof(struct msghdr)); 665 msg.msg_iov = &vec; 666 msg.msg_iovlen = 1; 667 msg.msg_control = cbuf; 668 msg.msg_controllen = sizeof(cbuf); 669 cmsg = CMSG_FIRSTHDR(&msg); 670 cmsg->cmsg_level = SOL_TLS; 671 /* test sending non-record types. */ 672 cmsg->cmsg_type = TLS_SET_RECORD_TYPE; 673 cmsg->cmsg_len = CMSG_LEN(cmsg_len); 674 *CMSG_DATA(cmsg) = record_type; 675 msg.msg_controllen = cmsg->cmsg_len; 676 677 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len); 678 /* Should fail because we didn't provide a control message */ 679 EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1); 680 681 vec.iov_base = buf; 682 EXPECT_EQ(recvmsg(self->cfd, &msg, 0), send_len); 683 cmsg = CMSG_FIRSTHDR(&msg); 684 EXPECT_NE(cmsg, NULL); 685 EXPECT_EQ(cmsg->cmsg_level, SOL_TLS); 686 EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE); 687 record_type = *((unsigned char *)CMSG_DATA(cmsg)); 688 EXPECT_EQ(record_type, 100); 689 EXPECT_EQ(memcmp(buf, test_str, send_len), 0); 690 } 691 692 TEST_HARNESS_MAIN 693