1 /*- 2 * Copyright (c) 2018 Enji Cooper. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/mman.h> 32 #include <sys/socket.h> 33 #include <sys/stat.h> 34 #include <sys/sysctl.h> 35 #include <sys/uio.h> 36 #include <err.h> 37 #include <errno.h> 38 #include <fcntl.h> 39 #include <netdb.h> 40 #include <paths.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <unistd.h> 45 46 #include <atf-c.h> 47 48 const char DETERMINISTIC_PATTERN[] = 49 "The past is already gone, the future is not yet here. There's only one moment for you to live.\n"; 50 51 #define SOURCE_FILE "source" 52 #define DESTINATION_FILE "dest" 53 54 #define PORTRANGE_FIRST "net.inet.ip.portrange.first" 55 #define PORTRANGE_LAST "net.inet.ip.portrange.last" 56 57 static int portrange_first, portrange_last; 58 59 static int 60 get_int_via_sysctlbyname(const char *oidname) 61 { 62 size_t oldlen; 63 int int_value; 64 65 oldlen = sizeof(int_value); 66 67 ATF_REQUIRE_EQ_MSG(sysctlbyname(oidname, &int_value, &oldlen, NULL, 0), 68 0, "sysctlbyname(%s, ...) failed: %s", oidname, strerror(errno)); 69 ATF_REQUIRE_EQ_MSG(sizeof(int_value), oldlen, "sanity check failed"); 70 71 return (int_value); 72 } 73 74 static int 75 generate_random_port(int seed) 76 { 77 int random_port; 78 79 printf("Generating a random port with seed=%d\n", seed); 80 if (portrange_first == 0) { 81 portrange_first = get_int_via_sysctlbyname(PORTRANGE_FIRST); 82 printf("Port range lower bound: %d\n", portrange_first); 83 } 84 85 if (portrange_last == 0) { 86 portrange_last = get_int_via_sysctlbyname(PORTRANGE_LAST); 87 printf("Port range upper bound: %d\n", portrange_last); 88 } 89 90 srand((unsigned)seed); 91 92 random_port = rand() % (portrange_last - portrange_first) + 93 portrange_first; 94 95 printf("Random port generated: %d\n", random_port); 96 return (random_port); 97 } 98 99 static void 100 resolve_localhost(struct addrinfo **res, int domain, int type, int port) 101 { 102 const char *host; 103 char *serv; 104 struct addrinfo hints; 105 int error; 106 107 switch (domain) { 108 case AF_INET: 109 host = "127.0.0.1"; 110 break; 111 case AF_INET6: 112 host = "::1"; 113 break; 114 default: 115 atf_tc_fail("unhandled domain: %d", domain); 116 } 117 118 ATF_REQUIRE_MSG(asprintf(&serv, "%d", port) >= 0, 119 "asprintf failed: %s", strerror(errno)); 120 121 memset(&hints, 0, sizeof(hints)); 122 hints.ai_family = domain; 123 hints.ai_flags = AI_ADDRCONFIG|AI_NUMERICSERV|AI_NUMERICHOST; 124 hints.ai_socktype = type; 125 126 error = getaddrinfo(host, serv, &hints, res); 127 ATF_REQUIRE_EQ_MSG(error, 0, 128 "getaddrinfo failed: %s", gai_strerror(error)); 129 free(serv); 130 } 131 132 static int 133 make_socket(int domain, int type, int protocol) 134 { 135 int sock; 136 137 sock = socket(domain, type, protocol); 138 ATF_REQUIRE_MSG(sock != -1, "socket(%d, %d, 0) failed: %s", 139 domain, type, strerror(errno)); 140 141 return (sock); 142 } 143 144 static int 145 setup_client(int domain, int type, int port) 146 { 147 struct addrinfo *res; 148 char host[NI_MAXHOST+1]; 149 int error, sock; 150 151 resolve_localhost(&res, domain, type, port); 152 error = getnameinfo( 153 (const struct sockaddr*)res->ai_addr, res->ai_addrlen, 154 host, nitems(host) - 1, NULL, 0, NI_NUMERICHOST); 155 ATF_REQUIRE_EQ_MSG(error, 0, 156 "getnameinfo failed: %s", gai_strerror(error)); 157 printf( 158 "Will try to connect to host='%s', address_family=%d, " 159 "socket_type=%d\n", 160 host, res->ai_family, res->ai_socktype); 161 /* Avoid a double print when forked by flushing. */ 162 fflush(stdout); 163 sock = make_socket(res->ai_family, res->ai_socktype, res->ai_protocol); 164 error = connect(sock, (struct sockaddr*)res->ai_addr, res->ai_addrlen); 165 freeaddrinfo(res); 166 ATF_REQUIRE_EQ_MSG(error, 0, "connect failed: %s", strerror(errno)); 167 return (sock); 168 } 169 170 /* 171 * XXX: use linear probing to find a free port and eliminate `port` argument as 172 * a [const] int (it will need to be a pointer so it can be passed back out of 173 * the function and can influence which port `setup_client(..)` connects on. 174 */ 175 static int 176 setup_server(int domain, int type, int port) 177 { 178 struct addrinfo *res; 179 char host[NI_MAXHOST+1]; 180 int error, sock; 181 182 resolve_localhost(&res, domain, type, port); 183 sock = make_socket(res->ai_family, res->ai_socktype, res->ai_protocol); 184 185 error = getnameinfo( 186 (const struct sockaddr*)res->ai_addr, res->ai_addrlen, 187 host, nitems(host) - 1, NULL, 0, NI_NUMERICHOST); 188 ATF_REQUIRE_EQ_MSG(error, 0, 189 "getnameinfo failed: %s", gai_strerror(error)); 190 printf( 191 "Will try to bind socket to host='%s', address_family=%d, " 192 "socket_type=%d\n", 193 host, res->ai_family, res->ai_socktype); 194 /* Avoid a double print when forked by flushing. */ 195 fflush(stdout); 196 error = bind(sock, res->ai_addr, res->ai_addrlen); 197 freeaddrinfo(res); 198 ATF_REQUIRE_EQ_MSG(error, 0, "bind failed: %s", strerror(errno)); 199 error = listen(sock, 1); 200 ATF_REQUIRE_EQ_MSG(error, 0, "listen failed: %s", strerror(errno)); 201 202 return (sock); 203 } 204 205 /* 206 * This function is a helper routine for taking data being sent by `sendfile` via 207 * `server_sock`, and pushing the received stream out to a file, denoted by 208 * `dest_filename`. 209 */ 210 static void 211 server_cat(const char *dest_filename, int server_sock, size_t len) 212 { 213 char *buffer, *buf_window_ptr; 214 int recv_sock; 215 size_t buffer_size; 216 ssize_t received_bytes, recv_ret; 217 218 /* 219 * Ensure that there isn't excess data sent across the wire by 220 * capturing 10 extra bytes (plus 1 for nul). 221 */ 222 buffer_size = len + 10 + 1; 223 buffer = calloc(buffer_size, sizeof(char)); 224 if (buffer == NULL) 225 err(1, "malloc failed"); 226 227 recv_sock = accept(server_sock, NULL, 0); 228 if (recv_sock == -1) 229 err(1, "accept failed"); 230 231 buf_window_ptr = buffer; 232 received_bytes = 0; 233 do { 234 recv_ret = recv(recv_sock, buf_window_ptr, 235 buffer_size - received_bytes, 0); 236 if (recv_ret <= 0) 237 break; 238 buf_window_ptr += recv_ret; 239 received_bytes += recv_ret; 240 } while (received_bytes < buffer_size); 241 242 atf_utils_create_file(dest_filename, "%s", buffer); 243 244 (void)close(recv_sock); 245 (void)close(server_sock); 246 free(buffer); 247 248 if (received_bytes != len) 249 errx(1, "received unexpected data: %zd != %zd", received_bytes, 250 len); 251 } 252 253 static int 254 setup_tcp_server(int domain, int port) 255 { 256 257 return (setup_server(domain, SOCK_STREAM, port)); 258 } 259 260 static int 261 setup_tcp_client(int domain, int port) 262 { 263 264 return (setup_client(domain, SOCK_STREAM, port)); 265 } 266 267 static off_t 268 file_size_from_fd(int fd) 269 { 270 struct stat st; 271 272 ATF_REQUIRE_EQ_MSG(0, fstat(fd, &st), 273 "fstat failed: %s", strerror(errno)); 274 275 return (st.st_size); 276 } 277 278 /* 279 * NB: `nbytes` == 0 has special connotations given the sendfile(2) API 280 * contract. In short, "send the whole file" (paraphrased). 281 */ 282 static void 283 verify_source_and_dest(const char* dest_filename, int src_fd, off_t offset, 284 size_t nbytes) 285 { 286 char *dest_pointer, *src_pointer; 287 off_t dest_file_size, src_file_size; 288 size_t length; 289 int dest_fd; 290 291 atf_utils_cat_file(dest_filename, "dest_file: "); 292 293 dest_fd = open(dest_filename, O_RDONLY); 294 ATF_REQUIRE_MSG(dest_fd != -1, "open failed"); 295 296 dest_file_size = file_size_from_fd(dest_fd); 297 src_file_size = file_size_from_fd(src_fd); 298 299 /* 300 * Per sendfile(2), "send the whole file" (paraphrased). This means 301 * that we need to grab the file size, as passing in length = 0 with 302 * mmap(2) will result in a failure with EINVAL (length = 0 is invalid). 303 */ 304 length = (nbytes == 0) ? (size_t)(src_file_size - offset) : nbytes; 305 306 ATF_REQUIRE_EQ_MSG(dest_file_size, length, 307 "number of bytes written out to %s (%ju) doesn't match the " 308 "expected number of bytes (%zu)", dest_filename, dest_file_size, 309 length); 310 311 ATF_REQUIRE_EQ_MSG(0, lseek(src_fd, offset, SEEK_SET), 312 "lseek failed: %s", strerror(errno)); 313 314 dest_pointer = mmap(NULL, length, PROT_READ, MAP_PRIVATE, dest_fd, 0); 315 ATF_REQUIRE_MSG(dest_pointer != MAP_FAILED, "mmap failed: %s", 316 strerror(errno)); 317 318 printf("Will mmap in the source file from offset=%jd to length=%zu\n", 319 offset, length); 320 321 src_pointer = mmap(NULL, length, PROT_READ, MAP_PRIVATE, src_fd, offset); 322 ATF_REQUIRE_MSG(src_pointer != MAP_FAILED, "mmap failed: %s", 323 strerror(errno)); 324 325 ATF_REQUIRE_EQ_MSG(0, memcmp(src_pointer, dest_pointer, length), 326 "Contents of source and destination do not match. '%s' != '%s'", 327 src_pointer, dest_pointer); 328 329 (void)munmap(src_pointer, length); 330 (void)munmap(dest_pointer, length); 331 (void)close(dest_fd); 332 } 333 334 static void 335 fd_positive_file_test(int domain) 336 { 337 off_t offset; 338 size_t nbytes, pattern_size; 339 int client_sock, error, fd, port, server_sock; 340 pid_t server_pid; 341 342 pattern_size = strlen(DETERMINISTIC_PATTERN); 343 344 atf_utils_create_file(SOURCE_FILE, "%s", DETERMINISTIC_PATTERN); 345 fd = open(SOURCE_FILE, O_RDONLY); 346 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 347 348 port = generate_random_port(__LINE__ + domain); 349 server_sock = setup_tcp_server(domain, port); 350 client_sock = setup_tcp_client(domain, port); 351 352 server_pid = atf_utils_fork(); 353 if (server_pid == 0) { 354 (void)close(client_sock); 355 server_cat(DESTINATION_FILE, server_sock, pattern_size); 356 _exit(0); 357 } else 358 (void)close(server_sock); 359 360 nbytes = 0; 361 offset = 0; 362 error = sendfile(fd, client_sock, offset, nbytes, NULL, NULL, 363 SF_FLAGS(0, 0)); 364 ATF_REQUIRE_EQ_MSG(0, error, "sendfile failed: %s", strerror(errno)); 365 (void)close(client_sock); 366 367 atf_utils_wait(server_pid, 0, "", ""); 368 verify_source_and_dest(DESTINATION_FILE, fd, offset, nbytes); 369 370 (void)close(fd); 371 } 372 373 ATF_TC(fd_positive_file_v4); 374 ATF_TC_HEAD(fd_positive_file_v4, tc) 375 { 376 377 atf_tc_set_md_var(tc, "descr", 378 "Verify regular file as file descriptor support (IPv4)"); 379 } 380 ATF_TC_BODY(fd_positive_file_v4, tc) 381 { 382 383 fd_positive_file_test(AF_INET); 384 } 385 386 ATF_TC(fd_positive_file_v6); 387 ATF_TC_HEAD(fd_positive_file_v6, tc) 388 { 389 390 atf_tc_set_md_var(tc, "descr", 391 "Verify regular file as file descriptor support (IPv6)"); 392 } 393 ATF_TC_BODY(fd_positive_file_v6, tc) 394 { 395 396 fd_positive_file_test(AF_INET6); 397 } 398 399 static void 400 fd_positive_shm_test(int domain) 401 { 402 char *shm_pointer; 403 off_t offset; 404 size_t nbytes, pattern_size; 405 pid_t server_pid; 406 int client_sock, error, fd, port, server_sock; 407 408 pattern_size = strlen(DETERMINISTIC_PATTERN); 409 410 printf("pattern size: %zu\n", pattern_size); 411 412 fd = shm_open(SHM_ANON, O_RDWR|O_CREAT, 0600); 413 ATF_REQUIRE_MSG(fd != -1, "shm_open failed: %s", strerror(errno)); 414 ATF_REQUIRE_EQ_MSG(0, ftruncate(fd, pattern_size), 415 "ftruncate failed: %s", strerror(errno)); 416 shm_pointer = mmap(NULL, pattern_size, PROT_READ|PROT_WRITE, 417 MAP_SHARED, fd, 0); 418 ATF_REQUIRE_MSG(shm_pointer != MAP_FAILED, 419 "mmap failed: %s", strerror(errno)); 420 memcpy(shm_pointer, DETERMINISTIC_PATTERN, pattern_size); 421 ATF_REQUIRE_EQ_MSG(0, 422 memcmp(shm_pointer, DETERMINISTIC_PATTERN, pattern_size), 423 "memcmp showed data mismatch: '%s' != '%s'", 424 DETERMINISTIC_PATTERN, shm_pointer); 425 426 port = generate_random_port(__LINE__ + domain); 427 server_sock = setup_tcp_server(domain, port); 428 client_sock = setup_tcp_client(domain, port); 429 430 server_pid = atf_utils_fork(); 431 if (server_pid == 0) { 432 (void)close(client_sock); 433 server_cat(DESTINATION_FILE, server_sock, pattern_size); 434 _exit(0); 435 } else 436 (void)close(server_sock); 437 438 nbytes = 0; 439 offset = 0; 440 error = sendfile(fd, client_sock, offset, nbytes, NULL, NULL, 441 SF_FLAGS(0, 0)); 442 ATF_REQUIRE_EQ_MSG(0, error, "sendfile failed: %s", strerror(errno)); 443 (void)close(client_sock); 444 445 atf_utils_wait(server_pid, 0, "", ""); 446 verify_source_and_dest(DESTINATION_FILE, fd, offset, nbytes); 447 448 (void)munmap(shm_pointer, sizeof(DETERMINISTIC_PATTERN)); 449 (void)close(fd); 450 } 451 452 ATF_TC(fd_positive_shm_v4); 453 ATF_TC_HEAD(fd_positive_shm_v4, tc) 454 { 455 456 atf_tc_set_md_var(tc, "descr", 457 "Verify shared memory as file descriptor support (IPv4)"); 458 } 459 ATF_TC_BODY(fd_positive_shm_v4, tc) 460 { 461 462 fd_positive_shm_test(AF_INET); 463 } 464 465 ATF_TC(fd_positive_shm_v6); 466 ATF_TC_HEAD(fd_positive_shm_v6, tc) 467 { 468 469 atf_tc_set_md_var(tc, "descr", 470 "Verify shared memory as file descriptor support (IPv6))"); 471 } 472 ATF_TC_BODY(fd_positive_shm_v6, tc) 473 { 474 475 fd_positive_shm_test(AF_INET6); 476 } 477 478 static void 479 fd_negative_bad_fd_test(int domain) 480 { 481 int client_sock, error, fd, port, server_sock; 482 483 port = generate_random_port(__LINE__ + domain); 484 server_sock = setup_tcp_server(domain, port); 485 client_sock = setup_tcp_client(domain, port); 486 487 fd = -1; 488 489 error = sendfile(fd, client_sock, 0, 0, NULL, NULL, SF_FLAGS(0, 0)); 490 ATF_REQUIRE_ERRNO(EBADF, error == -1); 491 492 (void)close(client_sock); 493 (void)close(server_sock); 494 } 495 496 ATF_TC(fd_negative_bad_fd_v4); 497 ATF_TC_HEAD(fd_negative_bad_fd_v4, tc) 498 { 499 500 atf_tc_set_md_var(tc, "descr", 501 "Verify bad file descriptor returns EBADF (IPv4)"); 502 } 503 ATF_TC_BODY(fd_negative_bad_fd_v4, tc) 504 { 505 506 fd_negative_bad_fd_test(AF_INET); 507 } 508 509 ATF_TC(fd_negative_bad_fd_v6); 510 ATF_TC_HEAD(fd_negative_bad_fd_v6, tc) 511 { 512 513 atf_tc_set_md_var(tc, "descr", 514 "Verify bad file descriptor returns EBADF (IPv6)"); 515 } 516 ATF_TC_BODY(fd_negative_bad_fd_v6, tc) 517 { 518 519 fd_negative_bad_fd_test(AF_INET6); 520 } 521 522 static void 523 flags_test(int domain) 524 { 525 off_t offset; 526 size_t nbytes, pattern_size; 527 int client_sock, error, fd, i, port, server_sock; 528 pid_t server_pid; 529 int16_t number_pages = 10; 530 531 pattern_size = strlen(DETERMINISTIC_PATTERN); 532 533 struct testcase { 534 int16_t readahead_pages, flags; 535 } testcases[] = { 536 /* This is covered in `:fd_positive_file` */ 537 #if 0 538 { 539 .readahead_pages = 0, 540 .flags = 0 541 }, 542 #endif 543 { 544 .readahead_pages = 0, 545 .flags = SF_NOCACHE 546 }, 547 #ifdef SF_USER_READAHEAD 548 { 549 .readahead_pages = 0, 550 .flags = SF_NOCACHE|SF_USER_READAHEAD 551 }, 552 { 553 .readahead_pages = 0, 554 .flags = SF_USER_READAHEAD 555 }, 556 #endif 557 { 558 .readahead_pages = number_pages, 559 .flags = 0 560 }, 561 { 562 .readahead_pages = number_pages, 563 .flags = SF_NOCACHE 564 }, 565 #ifdef SF_USER_READAHEAD 566 { 567 .readahead_pages = number_pages, 568 .flags = SF_NOCACHE|SF_USER_READAHEAD 569 }, 570 #endif 571 { 572 .readahead_pages = number_pages, 573 .flags = SF_NOCACHE 574 }, 575 { 576 .readahead_pages = number_pages, 577 .flags = SF_NODISKIO 578 } 579 }; 580 581 atf_utils_create_file(SOURCE_FILE, "%s", DETERMINISTIC_PATTERN); 582 for (i = 0; i < nitems(testcases); i++) { 583 fd = open(SOURCE_FILE, O_RDONLY); 584 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 585 586 port = generate_random_port(i * __LINE__ + domain); 587 server_sock = setup_tcp_server(domain, port); 588 client_sock = setup_tcp_client(domain, port); 589 590 server_pid = atf_utils_fork(); 591 if (server_pid == 0) { 592 (void)close(client_sock); 593 server_cat(DESTINATION_FILE, server_sock, pattern_size); 594 _exit(0); 595 } else 596 (void)close(server_sock); 597 598 nbytes = 0; 599 offset = 0; 600 error = sendfile(fd, client_sock, offset, nbytes, NULL, NULL, 601 SF_FLAGS(testcases[i].readahead_pages, testcases[i].flags)); 602 ATF_CHECK_EQ_MSG(error, 0, "sendfile testcase #%d failed: %s", 603 i, strerror(errno)); 604 (void)close(client_sock); 605 606 atf_utils_wait(server_pid, 0, "", ""); 607 verify_source_and_dest(DESTINATION_FILE, fd, offset, nbytes); 608 609 (void)close(fd); 610 } 611 } 612 613 ATF_TC(flags_v4); 614 ATF_TC_HEAD(flags_v4, tc) 615 { 616 617 atf_tc_set_md_var(tc, "descr", "Verify flags functionality (IPv4)"); 618 } 619 ATF_TC_BODY(flags_v4, tc) 620 { 621 622 flags_test(AF_INET); 623 } 624 625 ATF_TC(flags_v6); 626 ATF_TC_HEAD(flags_v6, tc) 627 { 628 629 atf_tc_set_md_var(tc, "descr", "Verify flags functionality (IPv6)"); 630 } 631 ATF_TC_BODY(flags_v6, tc) 632 { 633 634 flags_test(AF_INET6); 635 } 636 637 static void 638 hdtr_positive_test(int domain) 639 { 640 struct iovec headers[1], trailers[1]; 641 struct testcase { 642 bool include_headers, include_trailers; 643 } testcases[] = { 644 /* This is covered in `:fd_positive_file` */ 645 #if 0 646 { 647 .include_headers = false, 648 .include_trailers = false 649 }, 650 #endif 651 { 652 .include_headers = true, 653 .include_trailers = false 654 }, 655 { 656 .include_headers = false, 657 .include_trailers = true 658 }, 659 { 660 .include_headers = true, 661 .include_trailers = true 662 } 663 }; 664 off_t offset; 665 size_t nbytes; 666 int client_sock, error, fd, fd2, i, port, rc, server_sock; 667 pid_t server_pid; 668 669 headers[0].iov_base = "This is a header"; 670 headers[0].iov_len = strlen(headers[0].iov_base); 671 trailers[0].iov_base = "This is a trailer"; 672 trailers[0].iov_len = strlen(trailers[0].iov_base); 673 offset = 0; 674 nbytes = 0; 675 676 for (i = 0; i < nitems(testcases); i++) { 677 struct sf_hdtr hdtr; 678 char *pattern; 679 680 if (testcases[i].include_headers) { 681 hdtr.headers = headers; 682 hdtr.hdr_cnt = nitems(headers); 683 } else { 684 hdtr.headers = NULL; 685 hdtr.hdr_cnt = 0; 686 } 687 688 if (testcases[i].include_trailers) { 689 hdtr.trailers = trailers; 690 hdtr.trl_cnt = nitems(trailers); 691 } else { 692 hdtr.trailers = NULL; 693 hdtr.trl_cnt = 0; 694 } 695 696 port = generate_random_port(i * __LINE__ + domain); 697 server_sock = setup_tcp_server(domain, port); 698 client_sock = setup_tcp_client(domain, port); 699 700 rc = asprintf(&pattern, "%s%s%s", 701 testcases[i].include_headers ? (char *)headers[0].iov_base : "", 702 DETERMINISTIC_PATTERN, 703 testcases[i].include_trailers ? (char *)trailers[0].iov_base : ""); 704 ATF_REQUIRE_MSG(rc != -1, "asprintf failed: %s", strerror(errno)); 705 706 atf_utils_create_file(SOURCE_FILE ".full", "%s", pattern); 707 atf_utils_create_file(SOURCE_FILE, "%s", DETERMINISTIC_PATTERN); 708 709 fd = open(SOURCE_FILE, O_RDONLY); 710 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 711 712 fd2 = open(SOURCE_FILE ".full", O_RDONLY); 713 ATF_REQUIRE_MSG(fd2 != -1, "open failed: %s", strerror(errno)); 714 715 server_pid = atf_utils_fork(); 716 if (server_pid == 0) { 717 (void)close(client_sock); 718 server_cat(DESTINATION_FILE, server_sock, 719 strlen(pattern)); 720 _exit(0); 721 } else 722 (void)close(server_sock); 723 724 error = sendfile(fd, client_sock, offset, nbytes, &hdtr, 725 NULL, SF_FLAGS(0, 0)); 726 ATF_CHECK_EQ_MSG(error, 0, "sendfile testcase #%d failed: %s", 727 i, strerror(errno)); 728 (void)close(client_sock); 729 730 atf_utils_wait(server_pid, 0, "", ""); 731 verify_source_and_dest(DESTINATION_FILE, fd2, offset, nbytes); 732 733 (void)close(fd); 734 (void)close(fd2); 735 free(pattern); 736 pattern = NULL; 737 } 738 } 739 740 ATF_TC(hdtr_positive_v4); 741 ATF_TC_HEAD(hdtr_positive_v4, tc) 742 { 743 744 atf_tc_set_md_var(tc, "descr", 745 "Verify positive hdtr functionality (IPv4)"); 746 } 747 ATF_TC_BODY(hdtr_positive_v4, tc) 748 { 749 750 hdtr_positive_test(AF_INET); 751 } 752 753 ATF_TC(hdtr_positive_v6); 754 ATF_TC_HEAD(hdtr_positive_v6, tc) 755 { 756 757 atf_tc_set_md_var(tc, "descr", 758 "Verify positive hdtr functionality (IPv6)"); 759 } 760 ATF_TC_BODY(hdtr_positive_v6, tc) 761 { 762 763 hdtr_positive_test(AF_INET); 764 } 765 766 static void 767 hdtr_negative_bad_pointers_test(int domain) 768 { 769 int client_sock, error, fd, port, server_sock; 770 struct sf_hdtr *hdtr1, hdtr2, hdtr3; 771 772 port = generate_random_port(__LINE__ + domain); 773 774 hdtr1 = (struct sf_hdtr*)-1; 775 776 memset(&hdtr2, 0, sizeof(hdtr2)); 777 hdtr2.hdr_cnt = 1; 778 hdtr2.headers = (struct iovec*)-1; 779 780 memset(&hdtr3, 0, sizeof(hdtr3)); 781 hdtr3.trl_cnt = 1; 782 hdtr3.trailers = (struct iovec*)-1; 783 784 fd = open(SOURCE_FILE, O_CREAT|O_RDWR); 785 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 786 787 server_sock = setup_tcp_server(domain, port); 788 client_sock = setup_tcp_client(domain, port); 789 790 error = sendfile(fd, client_sock, 0, 0, hdtr1, NULL, SF_FLAGS(0, 0)); 791 ATF_CHECK_ERRNO(EFAULT, error == -1); 792 793 error = sendfile(fd, client_sock, 0, 0, &hdtr2, NULL, SF_FLAGS(0, 0)); 794 ATF_CHECK_ERRNO(EFAULT, error == -1); 795 796 error = sendfile(fd, client_sock, 0, 0, &hdtr3, NULL, SF_FLAGS(0, 0)); 797 ATF_CHECK_ERRNO(EFAULT, error == -1); 798 799 (void)close(fd); 800 (void)close(client_sock); 801 (void)close(server_sock); 802 } 803 804 ATF_TC(hdtr_negative_bad_pointers_v4); 805 ATF_TC_HEAD(hdtr_negative_bad_pointers_v4, tc) 806 { 807 808 atf_tc_set_md_var(tc, "descr", 809 "Verify that bad pointers for hdtr storage result in EFAULT (IPv4)"); 810 } 811 ATF_TC_BODY(hdtr_negative_bad_pointers_v4, tc) 812 { 813 814 hdtr_negative_bad_pointers_test(AF_INET); 815 } 816 817 ATF_TC(hdtr_negative_bad_pointers_v6); 818 ATF_TC_HEAD(hdtr_negative_bad_pointers_v6, tc) 819 { 820 821 atf_tc_set_md_var(tc, "descr", 822 "Verify that bad pointers for hdtr storage result in EFAULT (IPv6)"); 823 } 824 ATF_TC_BODY(hdtr_negative_bad_pointers_v6, tc) 825 { 826 827 hdtr_negative_bad_pointers_test(AF_INET6); 828 } 829 830 static void 831 offset_negative_value_less_than_zero_test(int domain) 832 { 833 int client_sock, error, fd, port, server_sock; 834 835 port = generate_random_port(__LINE__ + domain); 836 server_sock = setup_tcp_server(domain, port); 837 client_sock = setup_tcp_client(domain, port); 838 839 fd = open(SOURCE_FILE, O_CREAT|O_RDWR); 840 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 841 842 error = sendfile(fd, client_sock, -1, 0, NULL, NULL, SF_FLAGS(0, 0)); 843 ATF_REQUIRE_ERRNO(EINVAL, error == -1); 844 845 (void)close(fd); 846 (void)close(client_sock); 847 (void)close(server_sock); 848 } 849 850 ATF_TC(offset_negative_value_less_than_zero_v4); 851 ATF_TC_HEAD(offset_negative_value_less_than_zero_v4, tc) 852 { 853 854 atf_tc_set_md_var(tc, "descr", 855 "Verify that a negative offset results in EINVAL (IPv4)"); 856 } 857 ATF_TC_BODY(offset_negative_value_less_than_zero_v4, tc) 858 { 859 860 offset_negative_value_less_than_zero_test(AF_INET); 861 } 862 863 ATF_TC(offset_negative_value_less_than_zero_v6); 864 ATF_TC_HEAD(offset_negative_value_less_than_zero_v6, tc) 865 { 866 867 atf_tc_set_md_var(tc, "descr", 868 "Verify that a negative offset results in EINVAL (IPv6)"); 869 } 870 ATF_TC_BODY(offset_negative_value_less_than_zero_v6, tc) 871 { 872 873 offset_negative_value_less_than_zero_test(AF_INET6); 874 } 875 876 static void 877 sbytes_positive_test(int domain) 878 { 879 size_t pattern_size = strlen(DETERMINISTIC_PATTERN); 880 off_t sbytes; 881 int client_sock, error, fd, port, server_sock; 882 883 port = generate_random_port(__LINE__ + domain); 884 server_sock = setup_tcp_server(domain, port); 885 client_sock = setup_tcp_client(domain, port); 886 887 atf_utils_create_file(SOURCE_FILE, "%s", DETERMINISTIC_PATTERN); 888 fd = open(SOURCE_FILE, O_RDONLY); 889 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 890 891 error = sendfile(fd, client_sock, 0, 0, NULL, &sbytes, SF_FLAGS(0, 0)); 892 ATF_CHECK_EQ_MSG(error, 0, "sendfile failed: %s", strerror(errno)); 893 894 (void)close(fd); 895 (void)close(client_sock); 896 (void)close(server_sock); 897 898 ATF_CHECK_EQ_MSG(pattern_size, sbytes, 899 "the value returned by sbytes does not match the expected pattern " 900 "size"); 901 } 902 903 ATF_TC(sbytes_positive_v4); 904 ATF_TC_HEAD(sbytes_positive_v4, tc) 905 { 906 907 atf_tc_set_md_var(tc, "descr", 908 "Verify positive `sbytes` functionality (IPv4)"); 909 } 910 ATF_TC_BODY(sbytes_positive_v4, tc) 911 { 912 913 sbytes_positive_test(AF_INET); 914 } 915 916 ATF_TC(sbytes_positive_v6); 917 ATF_TC_HEAD(sbytes_positive_v6, tc) 918 { 919 920 atf_tc_set_md_var(tc, "descr", 921 "Verify positive `sbytes` functionality (IPv6)"); 922 } 923 ATF_TC_BODY(sbytes_positive_v6, tc) 924 { 925 926 sbytes_positive_test(AF_INET6); 927 } 928 929 static void 930 sbytes_negative_test(int domain) 931 { 932 off_t *sbytes_p = (off_t*)-1; 933 int client_sock, error, fd, port, server_sock; 934 935 port = generate_random_port(__LINE__ + domain); 936 server_sock = setup_tcp_server(domain, port); 937 client_sock = setup_tcp_client(domain, port); 938 939 atf_utils_create_file(SOURCE_FILE, "%s", DETERMINISTIC_PATTERN); 940 fd = open(SOURCE_FILE, O_RDONLY); 941 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 942 943 atf_tc_expect_fail( 944 "bug 232210: EFAULT assert fails because copyout(9) call is not checked"); 945 946 error = sendfile(fd, client_sock, 0, 0, NULL, sbytes_p, SF_FLAGS(0, 0)); 947 ATF_REQUIRE_ERRNO(EFAULT, error == -1); 948 949 (void)close(fd); 950 (void)close(client_sock); 951 (void)close(server_sock); 952 } 953 954 ATF_TC(sbytes_negative_v4); 955 ATF_TC_HEAD(sbytes_negative_v4, tc) 956 { 957 958 atf_tc_set_md_var(tc, "descr", 959 "Verify negative `sbytes` functionality (IPv4)"); 960 } 961 ATF_TC_BODY(sbytes_negative_v4, tc) 962 { 963 964 sbytes_negative_test(AF_INET); 965 } 966 967 ATF_TC(sbytes_negative_v6); 968 ATF_TC_HEAD(sbytes_negative_v6, tc) 969 { 970 971 atf_tc_set_md_var(tc, "descr", 972 "Verify negative `sbytes` functionality (IPv6)"); 973 } 974 ATF_TC_BODY(sbytes_negative_v6, tc) 975 { 976 977 sbytes_negative_test(AF_INET6); 978 } 979 980 static void 981 s_negative_not_connected_socket_test(int domain) 982 { 983 int client_sock, error, fd, port; 984 985 port = generate_random_port(__LINE__ + domain); 986 client_sock = setup_tcp_server(domain, port); 987 988 fd = open(SOURCE_FILE, O_CREAT|O_RDWR); 989 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 990 991 error = sendfile(fd, client_sock, 0, 0, NULL, NULL, SF_FLAGS(0, 0)); 992 ATF_REQUIRE_ERRNO(ENOTCONN, error == -1); 993 994 (void)close(fd); 995 (void)close(client_sock); 996 } 997 998 ATF_TC(s_negative_not_connected_socket_v4); 999 ATF_TC_HEAD(s_negative_not_connected_socket_v4, tc) 1000 { 1001 1002 atf_tc_set_md_var(tc, "descr", 1003 "Verify that a non-connected SOCK_STREAM socket results in ENOTCONN (IPv4)"); 1004 } 1005 1006 ATF_TC_BODY(s_negative_not_connected_socket_v4, tc) 1007 { 1008 1009 s_negative_not_connected_socket_test(AF_INET); 1010 } 1011 1012 ATF_TC(s_negative_not_connected_socket_v6); 1013 ATF_TC_HEAD(s_negative_not_connected_socket_v6, tc) 1014 { 1015 1016 atf_tc_set_md_var(tc, "descr", 1017 "Verify that a non-connected SOCK_STREAM socket results in ENOTCONN (IPv6)"); 1018 } 1019 1020 ATF_TC_BODY(s_negative_not_connected_socket_v6, tc) 1021 { 1022 1023 s_negative_not_connected_socket_test(AF_INET6); 1024 } 1025 1026 ATF_TC(s_negative_not_descriptor); 1027 ATF_TC_HEAD(s_negative_not_descriptor, tc) 1028 { 1029 1030 atf_tc_set_md_var(tc, "descr", 1031 "Verify that an invalid file descriptor, e.g., -1, fails with EBADF"); 1032 } 1033 1034 ATF_TC_BODY(s_negative_not_descriptor, tc) 1035 { 1036 int client_sock, error, fd; 1037 1038 client_sock = -1; 1039 1040 fd = open(SOURCE_FILE, O_CREAT|O_RDWR); 1041 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 1042 1043 error = sendfile(fd, client_sock, 0, 0, NULL, NULL, SF_FLAGS(0, 0)); 1044 ATF_REQUIRE_ERRNO(EBADF, error == -1); 1045 1046 (void)close(fd); 1047 } 1048 1049 ATF_TC(s_negative_not_socket_file_descriptor); 1050 ATF_TC_HEAD(s_negative_not_socket_file_descriptor, tc) 1051 { 1052 1053 atf_tc_set_md_var(tc, "descr", 1054 "Verify that a non-socket file descriptor fails with ENOTSOCK"); 1055 } 1056 1057 ATF_TC_BODY(s_negative_not_socket_file_descriptor, tc) 1058 { 1059 int client_sock, error, fd; 1060 1061 fd = open(SOURCE_FILE, O_CREAT|O_RDWR); 1062 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 1063 1064 client_sock = open(_PATH_DEVNULL, O_WRONLY); 1065 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 1066 1067 error = sendfile(fd, client_sock, 0, 0, NULL, NULL, SF_FLAGS(0, 0)); 1068 ATF_REQUIRE_ERRNO(ENOTSOCK, error == -1); 1069 1070 (void)close(fd); 1071 (void)close(client_sock); 1072 } 1073 1074 static void 1075 s_negative_udp_socket_test(int domain) 1076 { 1077 int client_sock, error, fd, port; 1078 1079 port = generate_random_port(__LINE__ + domain); 1080 client_sock = setup_client(domain, SOCK_DGRAM, port); 1081 1082 fd = open(SOURCE_FILE, O_CREAT|O_RDWR); 1083 ATF_REQUIRE_MSG(fd != -1, "open failed: %s", strerror(errno)); 1084 1085 error = sendfile(fd, client_sock, 0, 0, NULL, NULL, SF_FLAGS(0, 0)); 1086 ATF_REQUIRE_ERRNO(EINVAL, error == -1); 1087 1088 (void)close(fd); 1089 (void)close(client_sock); 1090 } 1091 1092 ATF_TC(s_negative_udp_socket_v4); 1093 ATF_TC_HEAD(s_negative_udp_socket_v4, tc) 1094 { 1095 1096 atf_tc_set_md_var(tc, "descr", 1097 "Verify that a non-SOCK_STREAM type socket results in EINVAL (IPv4)"); 1098 } 1099 ATF_TC_BODY(s_negative_udp_socket_v4, tc) 1100 { 1101 1102 s_negative_udp_socket_test(AF_INET); 1103 } 1104 1105 ATF_TC(s_negative_udp_socket_v6); 1106 ATF_TC_HEAD(s_negative_udp_socket_v6, tc) 1107 { 1108 1109 atf_tc_set_md_var(tc, "descr", 1110 "Verify that a non-SOCK_STREAM type socket results in EINVAL (IPv6)"); 1111 } 1112 ATF_TC_BODY(s_negative_udp_socket_v6, tc) 1113 { 1114 1115 s_negative_udp_socket_test(AF_INET6); 1116 } 1117 1118 ATF_TP_ADD_TCS(tp) 1119 { 1120 1121 ATF_TP_ADD_TC(tp, fd_positive_file_v4); 1122 ATF_TP_ADD_TC(tp, fd_positive_file_v6); 1123 ATF_TP_ADD_TC(tp, fd_positive_shm_v4); 1124 ATF_TP_ADD_TC(tp, fd_positive_shm_v6); 1125 ATF_TP_ADD_TC(tp, fd_negative_bad_fd_v4); 1126 ATF_TP_ADD_TC(tp, fd_negative_bad_fd_v6); 1127 ATF_TP_ADD_TC(tp, flags_v4); 1128 ATF_TP_ADD_TC(tp, flags_v6); 1129 /* 1130 * TODO: the negative case for SF_NODISKIO (returns EBUSY if file in 1131 * use) is not covered yet. 1132 * 1133 * Need to lock a file in a subprocess in write mode, then try and 1134 * send the data in read mode with sendfile. 1135 * 1136 * This should work with FFS/UFS, but there are no guarantees about 1137 * other filesystem implementations of sendfile(2), e.g., ZFS. 1138 */ 1139 ATF_TP_ADD_TC(tp, hdtr_positive_v4); 1140 ATF_TP_ADD_TC(tp, hdtr_positive_v6); 1141 ATF_TP_ADD_TC(tp, hdtr_negative_bad_pointers_v4); 1142 ATF_TP_ADD_TC(tp, hdtr_negative_bad_pointers_v6); 1143 ATF_TP_ADD_TC(tp, offset_negative_value_less_than_zero_v4); 1144 ATF_TP_ADD_TC(tp, offset_negative_value_less_than_zero_v6); 1145 ATF_TP_ADD_TC(tp, sbytes_positive_v4); 1146 ATF_TP_ADD_TC(tp, sbytes_positive_v6); 1147 ATF_TP_ADD_TC(tp, sbytes_negative_v4); 1148 ATF_TP_ADD_TC(tp, sbytes_negative_v6); 1149 ATF_TP_ADD_TC(tp, s_negative_not_connected_socket_v4); 1150 ATF_TP_ADD_TC(tp, s_negative_not_connected_socket_v6); 1151 ATF_TP_ADD_TC(tp, s_negative_not_descriptor); 1152 ATF_TP_ADD_TC(tp, s_negative_not_socket_file_descriptor); 1153 ATF_TP_ADD_TC(tp, s_negative_udp_socket_v4); 1154 ATF_TP_ADD_TC(tp, s_negative_udp_socket_v6); 1155 1156 return (atf_no_error()); 1157 } 1158