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