1 /* @generated by `generate-fortify-tests.lua "select"` */ 2 3 #define _FORTIFY_SOURCE 2 4 #define TMPFILE_SIZE (1024 * 32) 5 6 #include <sys/param.h> 7 #include <sys/jail.h> 8 #include <sys/random.h> 9 #include <sys/resource.h> 10 #include <sys/select.h> 11 #include <sys/socket.h> 12 #include <sys/time.h> 13 #include <sys/uio.h> 14 #include <sys/wait.h> 15 #include <dirent.h> 16 #include <errno.h> 17 #include <fcntl.h> 18 #include <limits.h> 19 #include <poll.h> 20 #include <signal.h> 21 #include <stdio.h> 22 #include <stdlib.h> 23 #include <string.h> 24 #include <strings.h> 25 #include <sysexits.h> 26 #include <unistd.h> 27 #include <wchar.h> 28 #include <atf-c.h> 29 30 static FILE * __unused 31 new_fp(size_t __len) 32 { 33 static char fpbuf[LINE_MAX]; 34 FILE *fp; 35 36 ATF_REQUIRE(__len <= sizeof(fpbuf)); 37 38 memset(fpbuf, 'A', sizeof(fpbuf) - 1); 39 fpbuf[sizeof(fpbuf) - 1] = '\0'; 40 41 fp = fmemopen(fpbuf, sizeof(fpbuf), "rb"); 42 ATF_REQUIRE(fp != NULL); 43 44 return (fp); 45 } 46 47 /* 48 * Create a new symlink to use for readlink(2) style tests, we'll just use a 49 * random target name to have something interesting to look at. 50 */ 51 static const char * __unused 52 new_symlink(size_t __len) 53 { 54 static const char linkname[] = "link"; 55 char target[MAXNAMLEN]; 56 int error; 57 58 ATF_REQUIRE(__len <= sizeof(target)); 59 60 arc4random_buf(target, sizeof(target)); 61 62 error = unlink(linkname); 63 ATF_REQUIRE(error == 0 || errno == ENOENT); 64 65 error = symlink(target, linkname); 66 ATF_REQUIRE(error == 0); 67 68 return (linkname); 69 } 70 71 /* 72 * For our purposes, first descriptor will be the reader; we'll send both 73 * raw data and a control message over it so that the result can be used for 74 * any of our recv*() tests. 75 */ 76 static void __unused 77 new_socket(int sock[2]) 78 { 79 unsigned char ctrl[CMSG_SPACE(sizeof(int))] = { 0 }; 80 static char sockbuf[256]; 81 ssize_t rv; 82 size_t total = 0; 83 struct msghdr hdr = { 0 }; 84 struct cmsghdr *cmsg; 85 int error, fd; 86 87 error = socketpair(AF_UNIX, SOCK_STREAM, 0, sock); 88 ATF_REQUIRE(error == 0); 89 90 while (total != sizeof(sockbuf)) { 91 rv = send(sock[1], &sockbuf[total], sizeof(sockbuf) - total, 0); 92 93 ATF_REQUIRE_MSG(rv > 0, 94 "expected bytes sent, got %zd with %zu left (size %zu, total %zu)", 95 rv, sizeof(sockbuf) - total, sizeof(sockbuf), total); 96 ATF_REQUIRE_MSG(total + (size_t)rv <= sizeof(sockbuf), 97 "%zd exceeds total %zu", rv, sizeof(sockbuf)); 98 total += rv; 99 } 100 101 hdr.msg_control = ctrl; 102 hdr.msg_controllen = sizeof(ctrl); 103 104 cmsg = CMSG_FIRSTHDR(&hdr); 105 cmsg->cmsg_level = SOL_SOCKET; 106 cmsg->cmsg_type = SCM_RIGHTS; 107 cmsg->cmsg_len = CMSG_LEN(sizeof(fd)); 108 fd = STDIN_FILENO; 109 memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd)); 110 111 error = sendmsg(sock[1], &hdr, 0); 112 ATF_REQUIRE(error != -1); 113 } 114 115 /* 116 * Constructs a tmpfile that we can use for testing read(2) and friends. 117 */ 118 static int __unused 119 new_tmpfile(void) 120 { 121 char buf[1024]; 122 ssize_t rv; 123 size_t written; 124 int fd; 125 126 fd = open("tmpfile", O_RDWR | O_CREAT | O_TRUNC, 0644); 127 ATF_REQUIRE(fd >= 0); 128 129 written = 0; 130 while (written < TMPFILE_SIZE) { 131 rv = write(fd, buf, sizeof(buf)); 132 ATF_REQUIRE(rv > 0); 133 134 written += rv; 135 } 136 137 ATF_REQUIRE_EQ(0, lseek(fd, 0, SEEK_SET)); 138 return (fd); 139 } 140 141 static void 142 disable_coredumps(void) 143 { 144 struct rlimit rl = { 0 }; 145 146 if (setrlimit(RLIMIT_CORE, &rl) == -1) 147 _exit(EX_OSERR); 148 } 149 150 /* 151 * Replaces stdin with a file that we can actually read from, for tests where 152 * we want a FILE * or fd that we can get data from. 153 */ 154 static void __unused 155 replace_stdin(void) 156 { 157 int fd; 158 159 fd = new_tmpfile(); 160 161 (void)dup2(fd, STDIN_FILENO); 162 if (fd != STDIN_FILENO) 163 close(fd); 164 } 165 166 ATF_TC(FD_SET_before_end); 167 ATF_TC_HEAD(FD_SET_before_end, tc) 168 { 169 } 170 ATF_TC_BODY(FD_SET_before_end, tc) 171 { 172 #define BUF &__stack.__buf 173 struct { 174 uint8_t padding_l; 175 fd_set __buf; 176 uint8_t padding_r; 177 } __stack; 178 const size_t __bufsz __unused = sizeof(__stack.__buf); 179 const size_t __len = FD_SETSIZE - 1; 180 const size_t __idx __unused = __len - 1; 181 182 FD_SET(__idx, &__stack.__buf); 183 #undef BUF 184 185 } 186 187 ATF_TC(FD_SET_end); 188 ATF_TC_HEAD(FD_SET_end, tc) 189 { 190 } 191 ATF_TC_BODY(FD_SET_end, tc) 192 { 193 #define BUF &__stack.__buf 194 struct { 195 uint8_t padding_l; 196 fd_set __buf; 197 uint8_t padding_r; 198 } __stack; 199 const size_t __bufsz __unused = sizeof(__stack.__buf); 200 const size_t __len = FD_SETSIZE; 201 const size_t __idx __unused = __len - 1; 202 203 FD_SET(__idx, &__stack.__buf); 204 #undef BUF 205 206 } 207 208 ATF_TC(FD_SET_after_end); 209 ATF_TC_HEAD(FD_SET_after_end, tc) 210 { 211 } 212 ATF_TC_BODY(FD_SET_after_end, tc) 213 { 214 #define BUF &__stack.__buf 215 struct { 216 uint8_t padding_l; 217 fd_set __buf; 218 uint8_t padding_r; 219 } __stack; 220 const size_t __bufsz __unused = sizeof(__stack.__buf); 221 const size_t __len = FD_SETSIZE + 1; 222 const size_t __idx __unused = __len - 1; 223 pid_t __child; 224 int __status; 225 226 __child = fork(); 227 ATF_REQUIRE(__child >= 0); 228 if (__child > 0) 229 goto monitor; 230 231 /* Child */ 232 disable_coredumps(); 233 FD_SET(__idx, &__stack.__buf); 234 _exit(EX_SOFTWARE); /* Should have aborted. */ 235 236 monitor: 237 while (waitpid(__child, &__status, 0) != __child) { 238 ATF_REQUIRE_EQ(EINTR, errno); 239 } 240 241 if (!WIFSIGNALED(__status)) { 242 switch (WEXITSTATUS(__status)) { 243 case EX_SOFTWARE: 244 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 245 break; 246 case EX_OSERR: 247 atf_tc_fail("setrlimit(2) failed"); 248 break; 249 default: 250 atf_tc_fail("child exited with status %d", 251 WEXITSTATUS(__status)); 252 } 253 } else { 254 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 255 } 256 #undef BUF 257 258 } 259 260 ATF_TC(FD_SET_heap_before_end); 261 ATF_TC_HEAD(FD_SET_heap_before_end, tc) 262 { 263 } 264 ATF_TC_BODY(FD_SET_heap_before_end, tc) 265 { 266 #define BUF __stack.__buf 267 struct { 268 uint8_t padding_l; 269 fd_set * __buf; 270 uint8_t padding_r; 271 } __stack; 272 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 273 const size_t __len = FD_SETSIZE - 1; 274 const size_t __idx __unused = __len - 1; 275 276 __stack.__buf = malloc(__bufsz); 277 278 FD_SET(__idx, __stack.__buf); 279 #undef BUF 280 281 } 282 283 ATF_TC(FD_SET_heap_end); 284 ATF_TC_HEAD(FD_SET_heap_end, tc) 285 { 286 } 287 ATF_TC_BODY(FD_SET_heap_end, tc) 288 { 289 #define BUF __stack.__buf 290 struct { 291 uint8_t padding_l; 292 fd_set * __buf; 293 uint8_t padding_r; 294 } __stack; 295 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 296 const size_t __len = FD_SETSIZE; 297 const size_t __idx __unused = __len - 1; 298 299 __stack.__buf = malloc(__bufsz); 300 301 FD_SET(__idx, __stack.__buf); 302 #undef BUF 303 304 } 305 306 ATF_TC(FD_SET_heap_after_end); 307 ATF_TC_HEAD(FD_SET_heap_after_end, tc) 308 { 309 } 310 ATF_TC_BODY(FD_SET_heap_after_end, tc) 311 { 312 #define BUF __stack.__buf 313 struct { 314 uint8_t padding_l; 315 fd_set * __buf; 316 uint8_t padding_r; 317 } __stack; 318 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 319 const size_t __len = FD_SETSIZE + 1; 320 const size_t __idx __unused = __len - 1; 321 pid_t __child; 322 int __status; 323 324 __child = fork(); 325 ATF_REQUIRE(__child >= 0); 326 if (__child > 0) 327 goto monitor; 328 329 /* Child */ 330 disable_coredumps(); 331 __stack.__buf = malloc(__bufsz); 332 333 FD_SET(__idx, __stack.__buf); 334 _exit(EX_SOFTWARE); /* Should have aborted. */ 335 336 monitor: 337 while (waitpid(__child, &__status, 0) != __child) { 338 ATF_REQUIRE_EQ(EINTR, errno); 339 } 340 341 if (!WIFSIGNALED(__status)) { 342 switch (WEXITSTATUS(__status)) { 343 case EX_SOFTWARE: 344 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 345 break; 346 case EX_OSERR: 347 atf_tc_fail("setrlimit(2) failed"); 348 break; 349 default: 350 atf_tc_fail("child exited with status %d", 351 WEXITSTATUS(__status)); 352 } 353 } else { 354 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 355 } 356 #undef BUF 357 358 } 359 360 ATF_TC(FD_CLR_before_end); 361 ATF_TC_HEAD(FD_CLR_before_end, tc) 362 { 363 } 364 ATF_TC_BODY(FD_CLR_before_end, tc) 365 { 366 #define BUF &__stack.__buf 367 struct { 368 uint8_t padding_l; 369 fd_set __buf; 370 uint8_t padding_r; 371 } __stack; 372 const size_t __bufsz __unused = sizeof(__stack.__buf); 373 const size_t __len = FD_SETSIZE - 1; 374 const size_t __idx __unused = __len - 1; 375 376 FD_CLR(__idx, &__stack.__buf); 377 #undef BUF 378 379 } 380 381 ATF_TC(FD_CLR_end); 382 ATF_TC_HEAD(FD_CLR_end, tc) 383 { 384 } 385 ATF_TC_BODY(FD_CLR_end, tc) 386 { 387 #define BUF &__stack.__buf 388 struct { 389 uint8_t padding_l; 390 fd_set __buf; 391 uint8_t padding_r; 392 } __stack; 393 const size_t __bufsz __unused = sizeof(__stack.__buf); 394 const size_t __len = FD_SETSIZE; 395 const size_t __idx __unused = __len - 1; 396 397 FD_CLR(__idx, &__stack.__buf); 398 #undef BUF 399 400 } 401 402 ATF_TC(FD_CLR_after_end); 403 ATF_TC_HEAD(FD_CLR_after_end, tc) 404 { 405 } 406 ATF_TC_BODY(FD_CLR_after_end, tc) 407 { 408 #define BUF &__stack.__buf 409 struct { 410 uint8_t padding_l; 411 fd_set __buf; 412 uint8_t padding_r; 413 } __stack; 414 const size_t __bufsz __unused = sizeof(__stack.__buf); 415 const size_t __len = FD_SETSIZE + 1; 416 const size_t __idx __unused = __len - 1; 417 pid_t __child; 418 int __status; 419 420 __child = fork(); 421 ATF_REQUIRE(__child >= 0); 422 if (__child > 0) 423 goto monitor; 424 425 /* Child */ 426 disable_coredumps(); 427 FD_CLR(__idx, &__stack.__buf); 428 _exit(EX_SOFTWARE); /* Should have aborted. */ 429 430 monitor: 431 while (waitpid(__child, &__status, 0) != __child) { 432 ATF_REQUIRE_EQ(EINTR, errno); 433 } 434 435 if (!WIFSIGNALED(__status)) { 436 switch (WEXITSTATUS(__status)) { 437 case EX_SOFTWARE: 438 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 439 break; 440 case EX_OSERR: 441 atf_tc_fail("setrlimit(2) failed"); 442 break; 443 default: 444 atf_tc_fail("child exited with status %d", 445 WEXITSTATUS(__status)); 446 } 447 } else { 448 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 449 } 450 #undef BUF 451 452 } 453 454 ATF_TC(FD_CLR_heap_before_end); 455 ATF_TC_HEAD(FD_CLR_heap_before_end, tc) 456 { 457 } 458 ATF_TC_BODY(FD_CLR_heap_before_end, tc) 459 { 460 #define BUF __stack.__buf 461 struct { 462 uint8_t padding_l; 463 fd_set * __buf; 464 uint8_t padding_r; 465 } __stack; 466 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 467 const size_t __len = FD_SETSIZE - 1; 468 const size_t __idx __unused = __len - 1; 469 470 __stack.__buf = malloc(__bufsz); 471 472 FD_CLR(__idx, __stack.__buf); 473 #undef BUF 474 475 } 476 477 ATF_TC(FD_CLR_heap_end); 478 ATF_TC_HEAD(FD_CLR_heap_end, tc) 479 { 480 } 481 ATF_TC_BODY(FD_CLR_heap_end, tc) 482 { 483 #define BUF __stack.__buf 484 struct { 485 uint8_t padding_l; 486 fd_set * __buf; 487 uint8_t padding_r; 488 } __stack; 489 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 490 const size_t __len = FD_SETSIZE; 491 const size_t __idx __unused = __len - 1; 492 493 __stack.__buf = malloc(__bufsz); 494 495 FD_CLR(__idx, __stack.__buf); 496 #undef BUF 497 498 } 499 500 ATF_TC(FD_CLR_heap_after_end); 501 ATF_TC_HEAD(FD_CLR_heap_after_end, tc) 502 { 503 } 504 ATF_TC_BODY(FD_CLR_heap_after_end, tc) 505 { 506 #define BUF __stack.__buf 507 struct { 508 uint8_t padding_l; 509 fd_set * __buf; 510 uint8_t padding_r; 511 } __stack; 512 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 513 const size_t __len = FD_SETSIZE + 1; 514 const size_t __idx __unused = __len - 1; 515 pid_t __child; 516 int __status; 517 518 __child = fork(); 519 ATF_REQUIRE(__child >= 0); 520 if (__child > 0) 521 goto monitor; 522 523 /* Child */ 524 disable_coredumps(); 525 __stack.__buf = malloc(__bufsz); 526 527 FD_CLR(__idx, __stack.__buf); 528 _exit(EX_SOFTWARE); /* Should have aborted. */ 529 530 monitor: 531 while (waitpid(__child, &__status, 0) != __child) { 532 ATF_REQUIRE_EQ(EINTR, errno); 533 } 534 535 if (!WIFSIGNALED(__status)) { 536 switch (WEXITSTATUS(__status)) { 537 case EX_SOFTWARE: 538 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 539 break; 540 case EX_OSERR: 541 atf_tc_fail("setrlimit(2) failed"); 542 break; 543 default: 544 atf_tc_fail("child exited with status %d", 545 WEXITSTATUS(__status)); 546 } 547 } else { 548 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 549 } 550 #undef BUF 551 552 } 553 554 ATF_TC(FD_ISSET_before_end); 555 ATF_TC_HEAD(FD_ISSET_before_end, tc) 556 { 557 } 558 ATF_TC_BODY(FD_ISSET_before_end, tc) 559 { 560 #define BUF &__stack.__buf 561 struct { 562 uint8_t padding_l; 563 fd_set __buf; 564 uint8_t padding_r; 565 } __stack; 566 const size_t __bufsz __unused = sizeof(__stack.__buf); 567 const size_t __len = FD_SETSIZE - 1; 568 const size_t __idx __unused = __len - 1; 569 570 FD_ISSET(__idx, &__stack.__buf); 571 #undef BUF 572 573 } 574 575 ATF_TC(FD_ISSET_end); 576 ATF_TC_HEAD(FD_ISSET_end, tc) 577 { 578 } 579 ATF_TC_BODY(FD_ISSET_end, tc) 580 { 581 #define BUF &__stack.__buf 582 struct { 583 uint8_t padding_l; 584 fd_set __buf; 585 uint8_t padding_r; 586 } __stack; 587 const size_t __bufsz __unused = sizeof(__stack.__buf); 588 const size_t __len = FD_SETSIZE; 589 const size_t __idx __unused = __len - 1; 590 591 FD_ISSET(__idx, &__stack.__buf); 592 #undef BUF 593 594 } 595 596 ATF_TC(FD_ISSET_after_end); 597 ATF_TC_HEAD(FD_ISSET_after_end, tc) 598 { 599 } 600 ATF_TC_BODY(FD_ISSET_after_end, tc) 601 { 602 #define BUF &__stack.__buf 603 struct { 604 uint8_t padding_l; 605 fd_set __buf; 606 uint8_t padding_r; 607 } __stack; 608 const size_t __bufsz __unused = sizeof(__stack.__buf); 609 const size_t __len = FD_SETSIZE + 1; 610 const size_t __idx __unused = __len - 1; 611 pid_t __child; 612 int __status; 613 614 __child = fork(); 615 ATF_REQUIRE(__child >= 0); 616 if (__child > 0) 617 goto monitor; 618 619 /* Child */ 620 disable_coredumps(); 621 FD_ISSET(__idx, &__stack.__buf); 622 _exit(EX_SOFTWARE); /* Should have aborted. */ 623 624 monitor: 625 while (waitpid(__child, &__status, 0) != __child) { 626 ATF_REQUIRE_EQ(EINTR, errno); 627 } 628 629 if (!WIFSIGNALED(__status)) { 630 switch (WEXITSTATUS(__status)) { 631 case EX_SOFTWARE: 632 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 633 break; 634 case EX_OSERR: 635 atf_tc_fail("setrlimit(2) failed"); 636 break; 637 default: 638 atf_tc_fail("child exited with status %d", 639 WEXITSTATUS(__status)); 640 } 641 } else { 642 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 643 } 644 #undef BUF 645 646 } 647 648 ATF_TC(FD_ISSET_heap_before_end); 649 ATF_TC_HEAD(FD_ISSET_heap_before_end, tc) 650 { 651 } 652 ATF_TC_BODY(FD_ISSET_heap_before_end, tc) 653 { 654 #define BUF __stack.__buf 655 struct { 656 uint8_t padding_l; 657 fd_set * __buf; 658 uint8_t padding_r; 659 } __stack; 660 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 661 const size_t __len = FD_SETSIZE - 1; 662 const size_t __idx __unused = __len - 1; 663 664 __stack.__buf = malloc(__bufsz); 665 666 FD_ISSET(__idx, __stack.__buf); 667 #undef BUF 668 669 } 670 671 ATF_TC(FD_ISSET_heap_end); 672 ATF_TC_HEAD(FD_ISSET_heap_end, tc) 673 { 674 } 675 ATF_TC_BODY(FD_ISSET_heap_end, tc) 676 { 677 #define BUF __stack.__buf 678 struct { 679 uint8_t padding_l; 680 fd_set * __buf; 681 uint8_t padding_r; 682 } __stack; 683 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 684 const size_t __len = FD_SETSIZE; 685 const size_t __idx __unused = __len - 1; 686 687 __stack.__buf = malloc(__bufsz); 688 689 FD_ISSET(__idx, __stack.__buf); 690 #undef BUF 691 692 } 693 694 ATF_TC(FD_ISSET_heap_after_end); 695 ATF_TC_HEAD(FD_ISSET_heap_after_end, tc) 696 { 697 } 698 ATF_TC_BODY(FD_ISSET_heap_after_end, tc) 699 { 700 #define BUF __stack.__buf 701 struct { 702 uint8_t padding_l; 703 fd_set * __buf; 704 uint8_t padding_r; 705 } __stack; 706 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (1); 707 const size_t __len = FD_SETSIZE + 1; 708 const size_t __idx __unused = __len - 1; 709 pid_t __child; 710 int __status; 711 712 __child = fork(); 713 ATF_REQUIRE(__child >= 0); 714 if (__child > 0) 715 goto monitor; 716 717 /* Child */ 718 disable_coredumps(); 719 __stack.__buf = malloc(__bufsz); 720 721 FD_ISSET(__idx, __stack.__buf); 722 _exit(EX_SOFTWARE); /* Should have aborted. */ 723 724 monitor: 725 while (waitpid(__child, &__status, 0) != __child) { 726 ATF_REQUIRE_EQ(EINTR, errno); 727 } 728 729 if (!WIFSIGNALED(__status)) { 730 switch (WEXITSTATUS(__status)) { 731 case EX_SOFTWARE: 732 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 733 break; 734 case EX_OSERR: 735 atf_tc_fail("setrlimit(2) failed"); 736 break; 737 default: 738 atf_tc_fail("child exited with status %d", 739 WEXITSTATUS(__status)); 740 } 741 } else { 742 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 743 } 744 #undef BUF 745 746 } 747 748 ATF_TP_ADD_TCS(tp) 749 { 750 ATF_TP_ADD_TC(tp, FD_SET_before_end); 751 ATF_TP_ADD_TC(tp, FD_SET_end); 752 ATF_TP_ADD_TC(tp, FD_SET_after_end); 753 ATF_TP_ADD_TC(tp, FD_SET_heap_before_end); 754 ATF_TP_ADD_TC(tp, FD_SET_heap_end); 755 ATF_TP_ADD_TC(tp, FD_SET_heap_after_end); 756 ATF_TP_ADD_TC(tp, FD_CLR_before_end); 757 ATF_TP_ADD_TC(tp, FD_CLR_end); 758 ATF_TP_ADD_TC(tp, FD_CLR_after_end); 759 ATF_TP_ADD_TC(tp, FD_CLR_heap_before_end); 760 ATF_TP_ADD_TC(tp, FD_CLR_heap_end); 761 ATF_TP_ADD_TC(tp, FD_CLR_heap_after_end); 762 ATF_TP_ADD_TC(tp, FD_ISSET_before_end); 763 ATF_TP_ADD_TC(tp, FD_ISSET_end); 764 ATF_TP_ADD_TC(tp, FD_ISSET_after_end); 765 ATF_TP_ADD_TC(tp, FD_ISSET_heap_before_end); 766 ATF_TP_ADD_TC(tp, FD_ISSET_heap_end); 767 ATF_TP_ADD_TC(tp, FD_ISSET_heap_after_end); 768 return (atf_no_error()); 769 } 770