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