1 /* @generated by `generate-fortify-tests.lua "unistd"` */ 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 #define JAIL_HOSTNAME "host.example.com" 167 #define JAIL_DOMAINNAME "example.com" 168 static void 169 dhost_jail(void) 170 { 171 struct iovec iov[4]; 172 int jid; 173 174 iov[0].iov_base = __DECONST(char *, "host.hostname"); 175 iov[0].iov_len = sizeof("host.hostname"); 176 iov[1].iov_base = __DECONST(char *, JAIL_HOSTNAME); 177 iov[1].iov_len = sizeof(JAIL_HOSTNAME); 178 iov[2].iov_base = __DECONST(char *, "host.domainname"); 179 iov[2].iov_len = sizeof("host.domainname"); 180 iov[3].iov_base = __DECONST(char *, JAIL_DOMAINNAME); 181 iov[3].iov_len = sizeof(JAIL_DOMAINNAME); 182 183 jid = jail_set(iov, nitems(iov), JAIL_CREATE | JAIL_ATTACH); 184 ATF_REQUIRE_MSG(jid > 0, "Jail creation failed: %s", strerror(errno)); 185 } 186 187 ATF_TC(getcwd_before_end); 188 ATF_TC_HEAD(getcwd_before_end, tc) 189 { 190 } 191 ATF_TC_BODY(getcwd_before_end, tc) 192 { 193 #define BUF &__stack.__buf 194 struct { 195 uint8_t padding_l; 196 unsigned char __buf[8]; 197 uint8_t padding_r; 198 } __stack; 199 const size_t __bufsz __unused = sizeof(__stack.__buf); 200 const size_t __len = 8 - 1; 201 const size_t __idx __unused = __len - 1; 202 203 getcwd(__stack.__buf, __len); 204 #undef BUF 205 206 } 207 208 ATF_TC(getcwd_end); 209 ATF_TC_HEAD(getcwd_end, tc) 210 { 211 } 212 ATF_TC_BODY(getcwd_end, tc) 213 { 214 #define BUF &__stack.__buf 215 struct { 216 uint8_t padding_l; 217 unsigned char __buf[8]; 218 uint8_t padding_r; 219 } __stack; 220 const size_t __bufsz __unused = sizeof(__stack.__buf); 221 const size_t __len = 8; 222 const size_t __idx __unused = __len - 1; 223 224 getcwd(__stack.__buf, __len); 225 #undef BUF 226 227 } 228 229 ATF_TC(getcwd_heap_before_end); 230 ATF_TC_HEAD(getcwd_heap_before_end, tc) 231 { 232 } 233 ATF_TC_BODY(getcwd_heap_before_end, tc) 234 { 235 #define BUF __stack.__buf 236 struct { 237 uint8_t padding_l; 238 unsigned char * __buf; 239 uint8_t padding_r; 240 } __stack; 241 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (8); 242 const size_t __len = 8 - 1; 243 const size_t __idx __unused = __len - 1; 244 245 __stack.__buf = malloc(__bufsz); 246 247 getcwd(__stack.__buf, __len); 248 #undef BUF 249 250 } 251 252 ATF_TC(getcwd_heap_end); 253 ATF_TC_HEAD(getcwd_heap_end, tc) 254 { 255 } 256 ATF_TC_BODY(getcwd_heap_end, tc) 257 { 258 #define BUF __stack.__buf 259 struct { 260 uint8_t padding_l; 261 unsigned char * __buf; 262 uint8_t padding_r; 263 } __stack; 264 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (8); 265 const size_t __len = 8; 266 const size_t __idx __unused = __len - 1; 267 268 __stack.__buf = malloc(__bufsz); 269 270 getcwd(__stack.__buf, __len); 271 #undef BUF 272 273 } 274 275 ATF_TC(getcwd_heap_after_end); 276 ATF_TC_HEAD(getcwd_heap_after_end, tc) 277 { 278 } 279 ATF_TC_BODY(getcwd_heap_after_end, tc) 280 { 281 #define BUF __stack.__buf 282 struct { 283 uint8_t padding_l; 284 unsigned char * __buf; 285 uint8_t padding_r; 286 } __stack; 287 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (8); 288 const size_t __len = 8 + 1; 289 const size_t __idx __unused = __len - 1; 290 pid_t __child; 291 int __status; 292 293 __child = fork(); 294 ATF_REQUIRE(__child >= 0); 295 if (__child > 0) 296 goto monitor; 297 298 /* Child */ 299 disable_coredumps(); 300 __stack.__buf = malloc(__bufsz); 301 302 getcwd(__stack.__buf, __len); 303 _exit(EX_SOFTWARE); /* Should have aborted. */ 304 305 monitor: 306 while (waitpid(__child, &__status, 0) != __child) { 307 ATF_REQUIRE_EQ(EINTR, errno); 308 } 309 310 if (!WIFSIGNALED(__status)) { 311 switch (WEXITSTATUS(__status)) { 312 case EX_SOFTWARE: 313 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 314 break; 315 case EX_OSERR: 316 atf_tc_fail("setrlimit(2) failed"); 317 break; 318 default: 319 atf_tc_fail("child exited with status %d", 320 WEXITSTATUS(__status)); 321 } 322 } else { 323 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 324 } 325 #undef BUF 326 327 } 328 329 ATF_TC(getgrouplist_before_end); 330 ATF_TC_HEAD(getgrouplist_before_end, tc) 331 { 332 } 333 ATF_TC_BODY(getgrouplist_before_end, tc) 334 { 335 #define BUF &__stack.__buf 336 struct { 337 uint8_t padding_l; 338 gid_t __buf[4]; 339 uint8_t padding_r; 340 } __stack; 341 const size_t __bufsz __unused = sizeof(__stack.__buf); 342 const size_t __len = 4 - 1; 343 const size_t __idx __unused = __len - 1; 344 int intlen = (int)__len; 345 346 getgrouplist("root", 0, __stack.__buf, &intlen); 347 #undef BUF 348 349 } 350 351 ATF_TC(getgrouplist_end); 352 ATF_TC_HEAD(getgrouplist_end, tc) 353 { 354 } 355 ATF_TC_BODY(getgrouplist_end, tc) 356 { 357 #define BUF &__stack.__buf 358 struct { 359 uint8_t padding_l; 360 gid_t __buf[4]; 361 uint8_t padding_r; 362 } __stack; 363 const size_t __bufsz __unused = sizeof(__stack.__buf); 364 const size_t __len = 4; 365 const size_t __idx __unused = __len - 1; 366 int intlen = (int)__len; 367 368 getgrouplist("root", 0, __stack.__buf, &intlen); 369 #undef BUF 370 371 } 372 373 ATF_TC(getgrouplist_heap_before_end); 374 ATF_TC_HEAD(getgrouplist_heap_before_end, tc) 375 { 376 } 377 ATF_TC_BODY(getgrouplist_heap_before_end, tc) 378 { 379 #define BUF __stack.__buf 380 struct { 381 uint8_t padding_l; 382 gid_t * __buf; 383 uint8_t padding_r; 384 } __stack; 385 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); 386 const size_t __len = 4 - 1; 387 const size_t __idx __unused = __len - 1; 388 int intlen = (int)__len; 389 390 __stack.__buf = malloc(__bufsz); 391 392 getgrouplist("root", 0, __stack.__buf, &intlen); 393 #undef BUF 394 395 } 396 397 ATF_TC(getgrouplist_heap_end); 398 ATF_TC_HEAD(getgrouplist_heap_end, tc) 399 { 400 } 401 ATF_TC_BODY(getgrouplist_heap_end, tc) 402 { 403 #define BUF __stack.__buf 404 struct { 405 uint8_t padding_l; 406 gid_t * __buf; 407 uint8_t padding_r; 408 } __stack; 409 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); 410 const size_t __len = 4; 411 const size_t __idx __unused = __len - 1; 412 int intlen = (int)__len; 413 414 __stack.__buf = malloc(__bufsz); 415 416 getgrouplist("root", 0, __stack.__buf, &intlen); 417 #undef BUF 418 419 } 420 421 ATF_TC(getgrouplist_heap_after_end); 422 ATF_TC_HEAD(getgrouplist_heap_after_end, tc) 423 { 424 } 425 ATF_TC_BODY(getgrouplist_heap_after_end, tc) 426 { 427 #define BUF __stack.__buf 428 struct { 429 uint8_t padding_l; 430 gid_t * __buf; 431 uint8_t padding_r; 432 } __stack; 433 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); 434 const size_t __len = 4 + 1; 435 const size_t __idx __unused = __len - 1; 436 pid_t __child; 437 int __status; 438 int intlen = (int)__len; 439 440 __child = fork(); 441 ATF_REQUIRE(__child >= 0); 442 if (__child > 0) 443 goto monitor; 444 445 /* Child */ 446 disable_coredumps(); 447 __stack.__buf = malloc(__bufsz); 448 449 getgrouplist("root", 0, __stack.__buf, &intlen); 450 _exit(EX_SOFTWARE); /* Should have aborted. */ 451 452 monitor: 453 while (waitpid(__child, &__status, 0) != __child) { 454 ATF_REQUIRE_EQ(EINTR, errno); 455 } 456 457 if (!WIFSIGNALED(__status)) { 458 switch (WEXITSTATUS(__status)) { 459 case EX_SOFTWARE: 460 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 461 break; 462 case EX_OSERR: 463 atf_tc_fail("setrlimit(2) failed"); 464 break; 465 default: 466 atf_tc_fail("child exited with status %d", 467 WEXITSTATUS(__status)); 468 } 469 } else { 470 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 471 } 472 #undef BUF 473 474 } 475 476 ATF_TC(getgroups_before_end); 477 ATF_TC_HEAD(getgroups_before_end, tc) 478 { 479 } 480 ATF_TC_BODY(getgroups_before_end, tc) 481 { 482 #define BUF &__stack.__buf 483 struct { 484 uint8_t padding_l; 485 gid_t __buf[4]; 486 uint8_t padding_r; 487 } __stack; 488 const size_t __bufsz __unused = sizeof(__stack.__buf); 489 const size_t __len = 4 - 1; 490 const size_t __idx __unused = __len - 1; 491 492 getgroups(__len, __stack.__buf); 493 #undef BUF 494 495 } 496 497 ATF_TC(getgroups_end); 498 ATF_TC_HEAD(getgroups_end, tc) 499 { 500 } 501 ATF_TC_BODY(getgroups_end, tc) 502 { 503 #define BUF &__stack.__buf 504 struct { 505 uint8_t padding_l; 506 gid_t __buf[4]; 507 uint8_t padding_r; 508 } __stack; 509 const size_t __bufsz __unused = sizeof(__stack.__buf); 510 const size_t __len = 4; 511 const size_t __idx __unused = __len - 1; 512 513 getgroups(__len, __stack.__buf); 514 #undef BUF 515 516 } 517 518 ATF_TC(getgroups_heap_before_end); 519 ATF_TC_HEAD(getgroups_heap_before_end, tc) 520 { 521 } 522 ATF_TC_BODY(getgroups_heap_before_end, tc) 523 { 524 #define BUF __stack.__buf 525 struct { 526 uint8_t padding_l; 527 gid_t * __buf; 528 uint8_t padding_r; 529 } __stack; 530 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); 531 const size_t __len = 4 - 1; 532 const size_t __idx __unused = __len - 1; 533 534 __stack.__buf = malloc(__bufsz); 535 536 getgroups(__len, __stack.__buf); 537 #undef BUF 538 539 } 540 541 ATF_TC(getgroups_heap_end); 542 ATF_TC_HEAD(getgroups_heap_end, tc) 543 { 544 } 545 ATF_TC_BODY(getgroups_heap_end, tc) 546 { 547 #define BUF __stack.__buf 548 struct { 549 uint8_t padding_l; 550 gid_t * __buf; 551 uint8_t padding_r; 552 } __stack; 553 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); 554 const size_t __len = 4; 555 const size_t __idx __unused = __len - 1; 556 557 __stack.__buf = malloc(__bufsz); 558 559 getgroups(__len, __stack.__buf); 560 #undef BUF 561 562 } 563 564 ATF_TC(getgroups_heap_after_end); 565 ATF_TC_HEAD(getgroups_heap_after_end, tc) 566 { 567 } 568 ATF_TC_BODY(getgroups_heap_after_end, tc) 569 { 570 #define BUF __stack.__buf 571 struct { 572 uint8_t padding_l; 573 gid_t * __buf; 574 uint8_t padding_r; 575 } __stack; 576 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); 577 const size_t __len = 4 + 1; 578 const size_t __idx __unused = __len - 1; 579 pid_t __child; 580 int __status; 581 582 __child = fork(); 583 ATF_REQUIRE(__child >= 0); 584 if (__child > 0) 585 goto monitor; 586 587 /* Child */ 588 disable_coredumps(); 589 __stack.__buf = malloc(__bufsz); 590 591 getgroups(__len, __stack.__buf); 592 _exit(EX_SOFTWARE); /* Should have aborted. */ 593 594 monitor: 595 while (waitpid(__child, &__status, 0) != __child) { 596 ATF_REQUIRE_EQ(EINTR, errno); 597 } 598 599 if (!WIFSIGNALED(__status)) { 600 switch (WEXITSTATUS(__status)) { 601 case EX_SOFTWARE: 602 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 603 break; 604 case EX_OSERR: 605 atf_tc_fail("setrlimit(2) failed"); 606 break; 607 default: 608 atf_tc_fail("child exited with status %d", 609 WEXITSTATUS(__status)); 610 } 611 } else { 612 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 613 } 614 #undef BUF 615 616 } 617 618 ATF_TC(getloginclass_before_end); 619 ATF_TC_HEAD(getloginclass_before_end, tc) 620 { 621 } 622 ATF_TC_BODY(getloginclass_before_end, tc) 623 { 624 #define BUF &__stack.__buf 625 struct { 626 uint8_t padding_l; 627 unsigned char __buf[42]; 628 uint8_t padding_r; 629 } __stack; 630 const size_t __bufsz __unused = sizeof(__stack.__buf); 631 const size_t __len = 42 - 1; 632 const size_t __idx __unused = __len - 1; 633 634 getloginclass(__stack.__buf, __len); 635 #undef BUF 636 637 } 638 639 ATF_TC(getloginclass_end); 640 ATF_TC_HEAD(getloginclass_end, tc) 641 { 642 } 643 ATF_TC_BODY(getloginclass_end, tc) 644 { 645 #define BUF &__stack.__buf 646 struct { 647 uint8_t padding_l; 648 unsigned char __buf[42]; 649 uint8_t padding_r; 650 } __stack; 651 const size_t __bufsz __unused = sizeof(__stack.__buf); 652 const size_t __len = 42; 653 const size_t __idx __unused = __len - 1; 654 655 getloginclass(__stack.__buf, __len); 656 #undef BUF 657 658 } 659 660 ATF_TC(getloginclass_heap_before_end); 661 ATF_TC_HEAD(getloginclass_heap_before_end, tc) 662 { 663 } 664 ATF_TC_BODY(getloginclass_heap_before_end, tc) 665 { 666 #define BUF __stack.__buf 667 struct { 668 uint8_t padding_l; 669 unsigned char * __buf; 670 uint8_t padding_r; 671 } __stack; 672 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 673 const size_t __len = 42 - 1; 674 const size_t __idx __unused = __len - 1; 675 676 __stack.__buf = malloc(__bufsz); 677 678 getloginclass(__stack.__buf, __len); 679 #undef BUF 680 681 } 682 683 ATF_TC(getloginclass_heap_end); 684 ATF_TC_HEAD(getloginclass_heap_end, tc) 685 { 686 } 687 ATF_TC_BODY(getloginclass_heap_end, tc) 688 { 689 #define BUF __stack.__buf 690 struct { 691 uint8_t padding_l; 692 unsigned char * __buf; 693 uint8_t padding_r; 694 } __stack; 695 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 696 const size_t __len = 42; 697 const size_t __idx __unused = __len - 1; 698 699 __stack.__buf = malloc(__bufsz); 700 701 getloginclass(__stack.__buf, __len); 702 #undef BUF 703 704 } 705 706 ATF_TC(getloginclass_heap_after_end); 707 ATF_TC_HEAD(getloginclass_heap_after_end, tc) 708 { 709 } 710 ATF_TC_BODY(getloginclass_heap_after_end, tc) 711 { 712 #define BUF __stack.__buf 713 struct { 714 uint8_t padding_l; 715 unsigned char * __buf; 716 uint8_t padding_r; 717 } __stack; 718 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 719 const size_t __len = 42 + 1; 720 const size_t __idx __unused = __len - 1; 721 pid_t __child; 722 int __status; 723 724 __child = fork(); 725 ATF_REQUIRE(__child >= 0); 726 if (__child > 0) 727 goto monitor; 728 729 /* Child */ 730 disable_coredumps(); 731 __stack.__buf = malloc(__bufsz); 732 733 getloginclass(__stack.__buf, __len); 734 _exit(EX_SOFTWARE); /* Should have aborted. */ 735 736 monitor: 737 while (waitpid(__child, &__status, 0) != __child) { 738 ATF_REQUIRE_EQ(EINTR, errno); 739 } 740 741 if (!WIFSIGNALED(__status)) { 742 switch (WEXITSTATUS(__status)) { 743 case EX_SOFTWARE: 744 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 745 break; 746 case EX_OSERR: 747 atf_tc_fail("setrlimit(2) failed"); 748 break; 749 default: 750 atf_tc_fail("child exited with status %d", 751 WEXITSTATUS(__status)); 752 } 753 } else { 754 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 755 } 756 #undef BUF 757 758 } 759 760 ATF_TC(pread_before_end); 761 ATF_TC_HEAD(pread_before_end, tc) 762 { 763 } 764 ATF_TC_BODY(pread_before_end, tc) 765 { 766 #define BUF &__stack.__buf 767 struct { 768 uint8_t padding_l; 769 unsigned char __buf[41]; 770 uint8_t padding_r; 771 } __stack; 772 const size_t __bufsz __unused = sizeof(__stack.__buf); 773 const size_t __len = 41 - 1; 774 const size_t __idx __unused = __len - 1; 775 int fd; 776 777 fd = new_tmpfile(); /* Cannot fail */ 778 779 pread(fd, __stack.__buf, __len, 0); 780 #undef BUF 781 782 } 783 784 ATF_TC(pread_end); 785 ATF_TC_HEAD(pread_end, tc) 786 { 787 } 788 ATF_TC_BODY(pread_end, tc) 789 { 790 #define BUF &__stack.__buf 791 struct { 792 uint8_t padding_l; 793 unsigned char __buf[41]; 794 uint8_t padding_r; 795 } __stack; 796 const size_t __bufsz __unused = sizeof(__stack.__buf); 797 const size_t __len = 41; 798 const size_t __idx __unused = __len - 1; 799 int fd; 800 801 fd = new_tmpfile(); /* Cannot fail */ 802 803 pread(fd, __stack.__buf, __len, 0); 804 #undef BUF 805 806 } 807 808 ATF_TC(pread_heap_before_end); 809 ATF_TC_HEAD(pread_heap_before_end, tc) 810 { 811 } 812 ATF_TC_BODY(pread_heap_before_end, tc) 813 { 814 #define BUF __stack.__buf 815 struct { 816 uint8_t padding_l; 817 unsigned char * __buf; 818 uint8_t padding_r; 819 } __stack; 820 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41); 821 const size_t __len = 41 - 1; 822 const size_t __idx __unused = __len - 1; 823 int fd; 824 825 __stack.__buf = malloc(__bufsz); 826 fd = new_tmpfile(); /* Cannot fail */ 827 828 pread(fd, __stack.__buf, __len, 0); 829 #undef BUF 830 831 } 832 833 ATF_TC(pread_heap_end); 834 ATF_TC_HEAD(pread_heap_end, tc) 835 { 836 } 837 ATF_TC_BODY(pread_heap_end, tc) 838 { 839 #define BUF __stack.__buf 840 struct { 841 uint8_t padding_l; 842 unsigned char * __buf; 843 uint8_t padding_r; 844 } __stack; 845 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41); 846 const size_t __len = 41; 847 const size_t __idx __unused = __len - 1; 848 int fd; 849 850 __stack.__buf = malloc(__bufsz); 851 fd = new_tmpfile(); /* Cannot fail */ 852 853 pread(fd, __stack.__buf, __len, 0); 854 #undef BUF 855 856 } 857 858 ATF_TC(pread_heap_after_end); 859 ATF_TC_HEAD(pread_heap_after_end, tc) 860 { 861 } 862 ATF_TC_BODY(pread_heap_after_end, tc) 863 { 864 #define BUF __stack.__buf 865 struct { 866 uint8_t padding_l; 867 unsigned char * __buf; 868 uint8_t padding_r; 869 } __stack; 870 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41); 871 const size_t __len = 41 + 1; 872 const size_t __idx __unused = __len - 1; 873 pid_t __child; 874 int __status; 875 int fd; 876 877 __child = fork(); 878 ATF_REQUIRE(__child >= 0); 879 if (__child > 0) 880 goto monitor; 881 882 /* Child */ 883 disable_coredumps(); 884 __stack.__buf = malloc(__bufsz); 885 fd = new_tmpfile(); /* Cannot fail */ 886 887 pread(fd, __stack.__buf, __len, 0); 888 _exit(EX_SOFTWARE); /* Should have aborted. */ 889 890 monitor: 891 while (waitpid(__child, &__status, 0) != __child) { 892 ATF_REQUIRE_EQ(EINTR, errno); 893 } 894 895 if (!WIFSIGNALED(__status)) { 896 switch (WEXITSTATUS(__status)) { 897 case EX_SOFTWARE: 898 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 899 break; 900 case EX_OSERR: 901 atf_tc_fail("setrlimit(2) failed"); 902 break; 903 default: 904 atf_tc_fail("child exited with status %d", 905 WEXITSTATUS(__status)); 906 } 907 } else { 908 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 909 } 910 #undef BUF 911 912 } 913 914 ATF_TC(read_before_end); 915 ATF_TC_HEAD(read_before_end, tc) 916 { 917 } 918 ATF_TC_BODY(read_before_end, tc) 919 { 920 #define BUF &__stack.__buf 921 struct { 922 uint8_t padding_l; 923 unsigned char __buf[41]; 924 uint8_t padding_r; 925 } __stack; 926 const size_t __bufsz __unused = sizeof(__stack.__buf); 927 const size_t __len = 41 - 1; 928 const size_t __idx __unused = __len - 1; 929 int fd; 930 931 fd = new_tmpfile(); /* Cannot fail */ 932 933 read(fd, __stack.__buf, __len); 934 #undef BUF 935 936 } 937 938 ATF_TC(read_end); 939 ATF_TC_HEAD(read_end, tc) 940 { 941 } 942 ATF_TC_BODY(read_end, tc) 943 { 944 #define BUF &__stack.__buf 945 struct { 946 uint8_t padding_l; 947 unsigned char __buf[41]; 948 uint8_t padding_r; 949 } __stack; 950 const size_t __bufsz __unused = sizeof(__stack.__buf); 951 const size_t __len = 41; 952 const size_t __idx __unused = __len - 1; 953 int fd; 954 955 fd = new_tmpfile(); /* Cannot fail */ 956 957 read(fd, __stack.__buf, __len); 958 #undef BUF 959 960 } 961 962 ATF_TC(read_heap_before_end); 963 ATF_TC_HEAD(read_heap_before_end, tc) 964 { 965 } 966 ATF_TC_BODY(read_heap_before_end, tc) 967 { 968 #define BUF __stack.__buf 969 struct { 970 uint8_t padding_l; 971 unsigned char * __buf; 972 uint8_t padding_r; 973 } __stack; 974 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41); 975 const size_t __len = 41 - 1; 976 const size_t __idx __unused = __len - 1; 977 int fd; 978 979 __stack.__buf = malloc(__bufsz); 980 fd = new_tmpfile(); /* Cannot fail */ 981 982 read(fd, __stack.__buf, __len); 983 #undef BUF 984 985 } 986 987 ATF_TC(read_heap_end); 988 ATF_TC_HEAD(read_heap_end, tc) 989 { 990 } 991 ATF_TC_BODY(read_heap_end, tc) 992 { 993 #define BUF __stack.__buf 994 struct { 995 uint8_t padding_l; 996 unsigned char * __buf; 997 uint8_t padding_r; 998 } __stack; 999 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41); 1000 const size_t __len = 41; 1001 const size_t __idx __unused = __len - 1; 1002 int fd; 1003 1004 __stack.__buf = malloc(__bufsz); 1005 fd = new_tmpfile(); /* Cannot fail */ 1006 1007 read(fd, __stack.__buf, __len); 1008 #undef BUF 1009 1010 } 1011 1012 ATF_TC(read_heap_after_end); 1013 ATF_TC_HEAD(read_heap_after_end, tc) 1014 { 1015 } 1016 ATF_TC_BODY(read_heap_after_end, tc) 1017 { 1018 #define BUF __stack.__buf 1019 struct { 1020 uint8_t padding_l; 1021 unsigned char * __buf; 1022 uint8_t padding_r; 1023 } __stack; 1024 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41); 1025 const size_t __len = 41 + 1; 1026 const size_t __idx __unused = __len - 1; 1027 pid_t __child; 1028 int __status; 1029 int fd; 1030 1031 __child = fork(); 1032 ATF_REQUIRE(__child >= 0); 1033 if (__child > 0) 1034 goto monitor; 1035 1036 /* Child */ 1037 disable_coredumps(); 1038 __stack.__buf = malloc(__bufsz); 1039 fd = new_tmpfile(); /* Cannot fail */ 1040 1041 read(fd, __stack.__buf, __len); 1042 _exit(EX_SOFTWARE); /* Should have aborted. */ 1043 1044 monitor: 1045 while (waitpid(__child, &__status, 0) != __child) { 1046 ATF_REQUIRE_EQ(EINTR, errno); 1047 } 1048 1049 if (!WIFSIGNALED(__status)) { 1050 switch (WEXITSTATUS(__status)) { 1051 case EX_SOFTWARE: 1052 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1053 break; 1054 case EX_OSERR: 1055 atf_tc_fail("setrlimit(2) failed"); 1056 break; 1057 default: 1058 atf_tc_fail("child exited with status %d", 1059 WEXITSTATUS(__status)); 1060 } 1061 } else { 1062 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1063 } 1064 #undef BUF 1065 1066 } 1067 1068 ATF_TC(readlink_before_end); 1069 ATF_TC_HEAD(readlink_before_end, tc) 1070 { 1071 } 1072 ATF_TC_BODY(readlink_before_end, tc) 1073 { 1074 #define BUF &__stack.__buf 1075 struct { 1076 uint8_t padding_l; 1077 unsigned char __buf[42]; 1078 uint8_t padding_r; 1079 } __stack; 1080 const size_t __bufsz __unused = sizeof(__stack.__buf); 1081 const size_t __len = 42 - 1; 1082 const size_t __idx __unused = __len - 1; 1083 const char *path; 1084 1085 path = new_symlink(__len); /* Cannot fail */ 1086 1087 readlink(path, __stack.__buf, __len); 1088 #undef BUF 1089 1090 } 1091 1092 ATF_TC(readlink_end); 1093 ATF_TC_HEAD(readlink_end, tc) 1094 { 1095 } 1096 ATF_TC_BODY(readlink_end, tc) 1097 { 1098 #define BUF &__stack.__buf 1099 struct { 1100 uint8_t padding_l; 1101 unsigned char __buf[42]; 1102 uint8_t padding_r; 1103 } __stack; 1104 const size_t __bufsz __unused = sizeof(__stack.__buf); 1105 const size_t __len = 42; 1106 const size_t __idx __unused = __len - 1; 1107 const char *path; 1108 1109 path = new_symlink(__len); /* Cannot fail */ 1110 1111 readlink(path, __stack.__buf, __len); 1112 #undef BUF 1113 1114 } 1115 1116 ATF_TC(readlink_heap_before_end); 1117 ATF_TC_HEAD(readlink_heap_before_end, tc) 1118 { 1119 } 1120 ATF_TC_BODY(readlink_heap_before_end, tc) 1121 { 1122 #define BUF __stack.__buf 1123 struct { 1124 uint8_t padding_l; 1125 unsigned char * __buf; 1126 uint8_t padding_r; 1127 } __stack; 1128 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1129 const size_t __len = 42 - 1; 1130 const size_t __idx __unused = __len - 1; 1131 const char *path; 1132 1133 __stack.__buf = malloc(__bufsz); 1134 path = new_symlink(__len); /* Cannot fail */ 1135 1136 readlink(path, __stack.__buf, __len); 1137 #undef BUF 1138 1139 } 1140 1141 ATF_TC(readlink_heap_end); 1142 ATF_TC_HEAD(readlink_heap_end, tc) 1143 { 1144 } 1145 ATF_TC_BODY(readlink_heap_end, tc) 1146 { 1147 #define BUF __stack.__buf 1148 struct { 1149 uint8_t padding_l; 1150 unsigned char * __buf; 1151 uint8_t padding_r; 1152 } __stack; 1153 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1154 const size_t __len = 42; 1155 const size_t __idx __unused = __len - 1; 1156 const char *path; 1157 1158 __stack.__buf = malloc(__bufsz); 1159 path = new_symlink(__len); /* Cannot fail */ 1160 1161 readlink(path, __stack.__buf, __len); 1162 #undef BUF 1163 1164 } 1165 1166 ATF_TC(readlink_heap_after_end); 1167 ATF_TC_HEAD(readlink_heap_after_end, tc) 1168 { 1169 } 1170 ATF_TC_BODY(readlink_heap_after_end, tc) 1171 { 1172 #define BUF __stack.__buf 1173 struct { 1174 uint8_t padding_l; 1175 unsigned char * __buf; 1176 uint8_t padding_r; 1177 } __stack; 1178 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1179 const size_t __len = 42 + 1; 1180 const size_t __idx __unused = __len - 1; 1181 pid_t __child; 1182 int __status; 1183 const char *path; 1184 1185 __child = fork(); 1186 ATF_REQUIRE(__child >= 0); 1187 if (__child > 0) 1188 goto monitor; 1189 1190 /* Child */ 1191 disable_coredumps(); 1192 __stack.__buf = malloc(__bufsz); 1193 path = new_symlink(__len); /* Cannot fail */ 1194 1195 readlink(path, __stack.__buf, __len); 1196 _exit(EX_SOFTWARE); /* Should have aborted. */ 1197 1198 monitor: 1199 while (waitpid(__child, &__status, 0) != __child) { 1200 ATF_REQUIRE_EQ(EINTR, errno); 1201 } 1202 1203 if (!WIFSIGNALED(__status)) { 1204 switch (WEXITSTATUS(__status)) { 1205 case EX_SOFTWARE: 1206 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1207 break; 1208 case EX_OSERR: 1209 atf_tc_fail("setrlimit(2) failed"); 1210 break; 1211 default: 1212 atf_tc_fail("child exited with status %d", 1213 WEXITSTATUS(__status)); 1214 } 1215 } else { 1216 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1217 } 1218 #undef BUF 1219 1220 } 1221 1222 ATF_TC(readlinkat_before_end); 1223 ATF_TC_HEAD(readlinkat_before_end, tc) 1224 { 1225 } 1226 ATF_TC_BODY(readlinkat_before_end, tc) 1227 { 1228 #define BUF &__stack.__buf 1229 struct { 1230 uint8_t padding_l; 1231 unsigned char __buf[42]; 1232 uint8_t padding_r; 1233 } __stack; 1234 const size_t __bufsz __unused = sizeof(__stack.__buf); 1235 const size_t __len = 42 - 1; 1236 const size_t __idx __unused = __len - 1; 1237 const char *path; 1238 1239 path = new_symlink(__len); /* Cannot fail */ 1240 1241 readlinkat(AT_FDCWD, path, __stack.__buf, __len); 1242 #undef BUF 1243 1244 } 1245 1246 ATF_TC(readlinkat_end); 1247 ATF_TC_HEAD(readlinkat_end, tc) 1248 { 1249 } 1250 ATF_TC_BODY(readlinkat_end, tc) 1251 { 1252 #define BUF &__stack.__buf 1253 struct { 1254 uint8_t padding_l; 1255 unsigned char __buf[42]; 1256 uint8_t padding_r; 1257 } __stack; 1258 const size_t __bufsz __unused = sizeof(__stack.__buf); 1259 const size_t __len = 42; 1260 const size_t __idx __unused = __len - 1; 1261 const char *path; 1262 1263 path = new_symlink(__len); /* Cannot fail */ 1264 1265 readlinkat(AT_FDCWD, path, __stack.__buf, __len); 1266 #undef BUF 1267 1268 } 1269 1270 ATF_TC(readlinkat_heap_before_end); 1271 ATF_TC_HEAD(readlinkat_heap_before_end, tc) 1272 { 1273 } 1274 ATF_TC_BODY(readlinkat_heap_before_end, tc) 1275 { 1276 #define BUF __stack.__buf 1277 struct { 1278 uint8_t padding_l; 1279 unsigned char * __buf; 1280 uint8_t padding_r; 1281 } __stack; 1282 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1283 const size_t __len = 42 - 1; 1284 const size_t __idx __unused = __len - 1; 1285 const char *path; 1286 1287 __stack.__buf = malloc(__bufsz); 1288 path = new_symlink(__len); /* Cannot fail */ 1289 1290 readlinkat(AT_FDCWD, path, __stack.__buf, __len); 1291 #undef BUF 1292 1293 } 1294 1295 ATF_TC(readlinkat_heap_end); 1296 ATF_TC_HEAD(readlinkat_heap_end, tc) 1297 { 1298 } 1299 ATF_TC_BODY(readlinkat_heap_end, tc) 1300 { 1301 #define BUF __stack.__buf 1302 struct { 1303 uint8_t padding_l; 1304 unsigned char * __buf; 1305 uint8_t padding_r; 1306 } __stack; 1307 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1308 const size_t __len = 42; 1309 const size_t __idx __unused = __len - 1; 1310 const char *path; 1311 1312 __stack.__buf = malloc(__bufsz); 1313 path = new_symlink(__len); /* Cannot fail */ 1314 1315 readlinkat(AT_FDCWD, path, __stack.__buf, __len); 1316 #undef BUF 1317 1318 } 1319 1320 ATF_TC(readlinkat_heap_after_end); 1321 ATF_TC_HEAD(readlinkat_heap_after_end, tc) 1322 { 1323 } 1324 ATF_TC_BODY(readlinkat_heap_after_end, tc) 1325 { 1326 #define BUF __stack.__buf 1327 struct { 1328 uint8_t padding_l; 1329 unsigned char * __buf; 1330 uint8_t padding_r; 1331 } __stack; 1332 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1333 const size_t __len = 42 + 1; 1334 const size_t __idx __unused = __len - 1; 1335 pid_t __child; 1336 int __status; 1337 const char *path; 1338 1339 __child = fork(); 1340 ATF_REQUIRE(__child >= 0); 1341 if (__child > 0) 1342 goto monitor; 1343 1344 /* Child */ 1345 disable_coredumps(); 1346 __stack.__buf = malloc(__bufsz); 1347 path = new_symlink(__len); /* Cannot fail */ 1348 1349 readlinkat(AT_FDCWD, path, __stack.__buf, __len); 1350 _exit(EX_SOFTWARE); /* Should have aborted. */ 1351 1352 monitor: 1353 while (waitpid(__child, &__status, 0) != __child) { 1354 ATF_REQUIRE_EQ(EINTR, errno); 1355 } 1356 1357 if (!WIFSIGNALED(__status)) { 1358 switch (WEXITSTATUS(__status)) { 1359 case EX_SOFTWARE: 1360 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1361 break; 1362 case EX_OSERR: 1363 atf_tc_fail("setrlimit(2) failed"); 1364 break; 1365 default: 1366 atf_tc_fail("child exited with status %d", 1367 WEXITSTATUS(__status)); 1368 } 1369 } else { 1370 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1371 } 1372 #undef BUF 1373 1374 } 1375 1376 ATF_TC(getdomainname_before_end); 1377 ATF_TC_HEAD(getdomainname_before_end, tc) 1378 { 1379 atf_tc_set_md_var(tc, "require.user", "root"); 1380 } 1381 ATF_TC_BODY(getdomainname_before_end, tc) 1382 { 1383 #define BUF &__stack.__buf 1384 struct { 1385 uint8_t padding_l; 1386 unsigned char __buf[12]; 1387 uint8_t padding_r; 1388 } __stack; 1389 const size_t __bufsz __unused = sizeof(__stack.__buf); 1390 const size_t __len = 12 - 1; 1391 const size_t __idx __unused = __len - 1; 1392 1393 dhost_jail(); 1394 getdomainname(__stack.__buf, __len); 1395 #undef BUF 1396 1397 } 1398 1399 ATF_TC(getdomainname_end); 1400 ATF_TC_HEAD(getdomainname_end, tc) 1401 { 1402 atf_tc_set_md_var(tc, "require.user", "root"); 1403 } 1404 ATF_TC_BODY(getdomainname_end, tc) 1405 { 1406 #define BUF &__stack.__buf 1407 struct { 1408 uint8_t padding_l; 1409 unsigned char __buf[12]; 1410 uint8_t padding_r; 1411 } __stack; 1412 const size_t __bufsz __unused = sizeof(__stack.__buf); 1413 const size_t __len = 12; 1414 const size_t __idx __unused = __len - 1; 1415 1416 dhost_jail(); 1417 getdomainname(__stack.__buf, __len); 1418 #undef BUF 1419 1420 } 1421 1422 ATF_TC(getdomainname_heap_before_end); 1423 ATF_TC_HEAD(getdomainname_heap_before_end, tc) 1424 { 1425 atf_tc_set_md_var(tc, "require.user", "root"); 1426 } 1427 ATF_TC_BODY(getdomainname_heap_before_end, tc) 1428 { 1429 #define BUF __stack.__buf 1430 struct { 1431 uint8_t padding_l; 1432 unsigned char * __buf; 1433 uint8_t padding_r; 1434 } __stack; 1435 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12); 1436 const size_t __len = 12 - 1; 1437 const size_t __idx __unused = __len - 1; 1438 1439 dhost_jail(); 1440 __stack.__buf = malloc(__bufsz); 1441 1442 getdomainname(__stack.__buf, __len); 1443 #undef BUF 1444 1445 } 1446 1447 ATF_TC(getdomainname_heap_end); 1448 ATF_TC_HEAD(getdomainname_heap_end, tc) 1449 { 1450 atf_tc_set_md_var(tc, "require.user", "root"); 1451 } 1452 ATF_TC_BODY(getdomainname_heap_end, tc) 1453 { 1454 #define BUF __stack.__buf 1455 struct { 1456 uint8_t padding_l; 1457 unsigned char * __buf; 1458 uint8_t padding_r; 1459 } __stack; 1460 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12); 1461 const size_t __len = 12; 1462 const size_t __idx __unused = __len - 1; 1463 1464 dhost_jail(); 1465 __stack.__buf = malloc(__bufsz); 1466 1467 getdomainname(__stack.__buf, __len); 1468 #undef BUF 1469 1470 } 1471 1472 ATF_TC(getdomainname_heap_after_end); 1473 ATF_TC_HEAD(getdomainname_heap_after_end, tc) 1474 { 1475 atf_tc_set_md_var(tc, "require.user", "root"); 1476 } 1477 ATF_TC_BODY(getdomainname_heap_after_end, tc) 1478 { 1479 #define BUF __stack.__buf 1480 struct { 1481 uint8_t padding_l; 1482 unsigned char * __buf; 1483 uint8_t padding_r; 1484 } __stack; 1485 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12); 1486 const size_t __len = 12 + 1; 1487 const size_t __idx __unused = __len - 1; 1488 pid_t __child; 1489 int __status; 1490 1491 dhost_jail(); 1492 __child = fork(); 1493 ATF_REQUIRE(__child >= 0); 1494 if (__child > 0) 1495 goto monitor; 1496 1497 /* Child */ 1498 disable_coredumps(); 1499 __stack.__buf = malloc(__bufsz); 1500 1501 getdomainname(__stack.__buf, __len); 1502 _exit(EX_SOFTWARE); /* Should have aborted. */ 1503 1504 monitor: 1505 while (waitpid(__child, &__status, 0) != __child) { 1506 ATF_REQUIRE_EQ(EINTR, errno); 1507 } 1508 1509 if (!WIFSIGNALED(__status)) { 1510 switch (WEXITSTATUS(__status)) { 1511 case EX_SOFTWARE: 1512 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1513 break; 1514 case EX_OSERR: 1515 atf_tc_fail("setrlimit(2) failed"); 1516 break; 1517 default: 1518 atf_tc_fail("child exited with status %d", 1519 WEXITSTATUS(__status)); 1520 } 1521 } else { 1522 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1523 } 1524 #undef BUF 1525 1526 } 1527 1528 ATF_TC(getentropy_before_end); 1529 ATF_TC_HEAD(getentropy_before_end, tc) 1530 { 1531 } 1532 ATF_TC_BODY(getentropy_before_end, tc) 1533 { 1534 #define BUF &__stack.__buf 1535 struct { 1536 uint8_t padding_l; 1537 unsigned char __buf[42]; 1538 uint8_t padding_r; 1539 } __stack; 1540 const size_t __bufsz __unused = sizeof(__stack.__buf); 1541 const size_t __len = 42 - 1; 1542 const size_t __idx __unused = __len - 1; 1543 1544 getentropy(__stack.__buf, __len); 1545 #undef BUF 1546 1547 } 1548 1549 ATF_TC(getentropy_end); 1550 ATF_TC_HEAD(getentropy_end, tc) 1551 { 1552 } 1553 ATF_TC_BODY(getentropy_end, tc) 1554 { 1555 #define BUF &__stack.__buf 1556 struct { 1557 uint8_t padding_l; 1558 unsigned char __buf[42]; 1559 uint8_t padding_r; 1560 } __stack; 1561 const size_t __bufsz __unused = sizeof(__stack.__buf); 1562 const size_t __len = 42; 1563 const size_t __idx __unused = __len - 1; 1564 1565 getentropy(__stack.__buf, __len); 1566 #undef BUF 1567 1568 } 1569 1570 ATF_TC(getentropy_heap_before_end); 1571 ATF_TC_HEAD(getentropy_heap_before_end, tc) 1572 { 1573 } 1574 ATF_TC_BODY(getentropy_heap_before_end, tc) 1575 { 1576 #define BUF __stack.__buf 1577 struct { 1578 uint8_t padding_l; 1579 unsigned char * __buf; 1580 uint8_t padding_r; 1581 } __stack; 1582 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1583 const size_t __len = 42 - 1; 1584 const size_t __idx __unused = __len - 1; 1585 1586 __stack.__buf = malloc(__bufsz); 1587 1588 getentropy(__stack.__buf, __len); 1589 #undef BUF 1590 1591 } 1592 1593 ATF_TC(getentropy_heap_end); 1594 ATF_TC_HEAD(getentropy_heap_end, tc) 1595 { 1596 } 1597 ATF_TC_BODY(getentropy_heap_end, tc) 1598 { 1599 #define BUF __stack.__buf 1600 struct { 1601 uint8_t padding_l; 1602 unsigned char * __buf; 1603 uint8_t padding_r; 1604 } __stack; 1605 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1606 const size_t __len = 42; 1607 const size_t __idx __unused = __len - 1; 1608 1609 __stack.__buf = malloc(__bufsz); 1610 1611 getentropy(__stack.__buf, __len); 1612 #undef BUF 1613 1614 } 1615 1616 ATF_TC(getentropy_heap_after_end); 1617 ATF_TC_HEAD(getentropy_heap_after_end, tc) 1618 { 1619 } 1620 ATF_TC_BODY(getentropy_heap_after_end, tc) 1621 { 1622 #define BUF __stack.__buf 1623 struct { 1624 uint8_t padding_l; 1625 unsigned char * __buf; 1626 uint8_t padding_r; 1627 } __stack; 1628 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1629 const size_t __len = 42 + 1; 1630 const size_t __idx __unused = __len - 1; 1631 pid_t __child; 1632 int __status; 1633 1634 __child = fork(); 1635 ATF_REQUIRE(__child >= 0); 1636 if (__child > 0) 1637 goto monitor; 1638 1639 /* Child */ 1640 disable_coredumps(); 1641 __stack.__buf = malloc(__bufsz); 1642 1643 getentropy(__stack.__buf, __len); 1644 _exit(EX_SOFTWARE); /* Should have aborted. */ 1645 1646 monitor: 1647 while (waitpid(__child, &__status, 0) != __child) { 1648 ATF_REQUIRE_EQ(EINTR, errno); 1649 } 1650 1651 if (!WIFSIGNALED(__status)) { 1652 switch (WEXITSTATUS(__status)) { 1653 case EX_SOFTWARE: 1654 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1655 break; 1656 case EX_OSERR: 1657 atf_tc_fail("setrlimit(2) failed"); 1658 break; 1659 default: 1660 atf_tc_fail("child exited with status %d", 1661 WEXITSTATUS(__status)); 1662 } 1663 } else { 1664 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1665 } 1666 #undef BUF 1667 1668 } 1669 1670 ATF_TC(gethostname_before_end); 1671 ATF_TC_HEAD(gethostname_before_end, tc) 1672 { 1673 atf_tc_set_md_var(tc, "require.user", "root"); 1674 } 1675 ATF_TC_BODY(gethostname_before_end, tc) 1676 { 1677 #define BUF &__stack.__buf 1678 struct { 1679 uint8_t padding_l; 1680 unsigned char __buf[17]; 1681 uint8_t padding_r; 1682 } __stack; 1683 const size_t __bufsz __unused = sizeof(__stack.__buf); 1684 const size_t __len = 17 - 1; 1685 const size_t __idx __unused = __len - 1; 1686 1687 dhost_jail(); 1688 gethostname(__stack.__buf, __len); 1689 #undef BUF 1690 1691 } 1692 1693 ATF_TC(gethostname_end); 1694 ATF_TC_HEAD(gethostname_end, tc) 1695 { 1696 atf_tc_set_md_var(tc, "require.user", "root"); 1697 } 1698 ATF_TC_BODY(gethostname_end, tc) 1699 { 1700 #define BUF &__stack.__buf 1701 struct { 1702 uint8_t padding_l; 1703 unsigned char __buf[17]; 1704 uint8_t padding_r; 1705 } __stack; 1706 const size_t __bufsz __unused = sizeof(__stack.__buf); 1707 const size_t __len = 17; 1708 const size_t __idx __unused = __len - 1; 1709 1710 dhost_jail(); 1711 gethostname(__stack.__buf, __len); 1712 #undef BUF 1713 1714 } 1715 1716 ATF_TC(gethostname_heap_before_end); 1717 ATF_TC_HEAD(gethostname_heap_before_end, tc) 1718 { 1719 atf_tc_set_md_var(tc, "require.user", "root"); 1720 } 1721 ATF_TC_BODY(gethostname_heap_before_end, tc) 1722 { 1723 #define BUF __stack.__buf 1724 struct { 1725 uint8_t padding_l; 1726 unsigned char * __buf; 1727 uint8_t padding_r; 1728 } __stack; 1729 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17); 1730 const size_t __len = 17 - 1; 1731 const size_t __idx __unused = __len - 1; 1732 1733 dhost_jail(); 1734 __stack.__buf = malloc(__bufsz); 1735 1736 gethostname(__stack.__buf, __len); 1737 #undef BUF 1738 1739 } 1740 1741 ATF_TC(gethostname_heap_end); 1742 ATF_TC_HEAD(gethostname_heap_end, tc) 1743 { 1744 atf_tc_set_md_var(tc, "require.user", "root"); 1745 } 1746 ATF_TC_BODY(gethostname_heap_end, tc) 1747 { 1748 #define BUF __stack.__buf 1749 struct { 1750 uint8_t padding_l; 1751 unsigned char * __buf; 1752 uint8_t padding_r; 1753 } __stack; 1754 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17); 1755 const size_t __len = 17; 1756 const size_t __idx __unused = __len - 1; 1757 1758 dhost_jail(); 1759 __stack.__buf = malloc(__bufsz); 1760 1761 gethostname(__stack.__buf, __len); 1762 #undef BUF 1763 1764 } 1765 1766 ATF_TC(gethostname_heap_after_end); 1767 ATF_TC_HEAD(gethostname_heap_after_end, tc) 1768 { 1769 atf_tc_set_md_var(tc, "require.user", "root"); 1770 } 1771 ATF_TC_BODY(gethostname_heap_after_end, tc) 1772 { 1773 #define BUF __stack.__buf 1774 struct { 1775 uint8_t padding_l; 1776 unsigned char * __buf; 1777 uint8_t padding_r; 1778 } __stack; 1779 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17); 1780 const size_t __len = 17 + 1; 1781 const size_t __idx __unused = __len - 1; 1782 pid_t __child; 1783 int __status; 1784 1785 dhost_jail(); 1786 __child = fork(); 1787 ATF_REQUIRE(__child >= 0); 1788 if (__child > 0) 1789 goto monitor; 1790 1791 /* Child */ 1792 disable_coredumps(); 1793 __stack.__buf = malloc(__bufsz); 1794 1795 gethostname(__stack.__buf, __len); 1796 _exit(EX_SOFTWARE); /* Should have aborted. */ 1797 1798 monitor: 1799 while (waitpid(__child, &__status, 0) != __child) { 1800 ATF_REQUIRE_EQ(EINTR, errno); 1801 } 1802 1803 if (!WIFSIGNALED(__status)) { 1804 switch (WEXITSTATUS(__status)) { 1805 case EX_SOFTWARE: 1806 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1807 break; 1808 case EX_OSERR: 1809 atf_tc_fail("setrlimit(2) failed"); 1810 break; 1811 default: 1812 atf_tc_fail("child exited with status %d", 1813 WEXITSTATUS(__status)); 1814 } 1815 } else { 1816 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1817 } 1818 #undef BUF 1819 1820 } 1821 1822 ATF_TC(getlogin_r_before_end); 1823 ATF_TC_HEAD(getlogin_r_before_end, tc) 1824 { 1825 } 1826 ATF_TC_BODY(getlogin_r_before_end, tc) 1827 { 1828 #define BUF &__stack.__buf 1829 struct { 1830 uint8_t padding_l; 1831 unsigned char __buf[MAXLOGNAME + 1]; 1832 uint8_t padding_r; 1833 } __stack; 1834 const size_t __bufsz __unused = sizeof(__stack.__buf); 1835 const size_t __len = MAXLOGNAME + 1 - 1; 1836 const size_t __idx __unused = __len - 1; 1837 1838 getlogin_r(__stack.__buf, __len); 1839 #undef BUF 1840 1841 } 1842 1843 ATF_TC(getlogin_r_end); 1844 ATF_TC_HEAD(getlogin_r_end, tc) 1845 { 1846 } 1847 ATF_TC_BODY(getlogin_r_end, tc) 1848 { 1849 #define BUF &__stack.__buf 1850 struct { 1851 uint8_t padding_l; 1852 unsigned char __buf[MAXLOGNAME + 1]; 1853 uint8_t padding_r; 1854 } __stack; 1855 const size_t __bufsz __unused = sizeof(__stack.__buf); 1856 const size_t __len = MAXLOGNAME + 1; 1857 const size_t __idx __unused = __len - 1; 1858 1859 getlogin_r(__stack.__buf, __len); 1860 #undef BUF 1861 1862 } 1863 1864 ATF_TC(getlogin_r_heap_before_end); 1865 ATF_TC_HEAD(getlogin_r_heap_before_end, tc) 1866 { 1867 } 1868 ATF_TC_BODY(getlogin_r_heap_before_end, tc) 1869 { 1870 #define BUF __stack.__buf 1871 struct { 1872 uint8_t padding_l; 1873 unsigned char * __buf; 1874 uint8_t padding_r; 1875 } __stack; 1876 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (MAXLOGNAME + 1); 1877 const size_t __len = MAXLOGNAME + 1 - 1; 1878 const size_t __idx __unused = __len - 1; 1879 1880 __stack.__buf = malloc(__bufsz); 1881 1882 getlogin_r(__stack.__buf, __len); 1883 #undef BUF 1884 1885 } 1886 1887 ATF_TC(getlogin_r_heap_end); 1888 ATF_TC_HEAD(getlogin_r_heap_end, tc) 1889 { 1890 } 1891 ATF_TC_BODY(getlogin_r_heap_end, tc) 1892 { 1893 #define BUF __stack.__buf 1894 struct { 1895 uint8_t padding_l; 1896 unsigned char * __buf; 1897 uint8_t padding_r; 1898 } __stack; 1899 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (MAXLOGNAME + 1); 1900 const size_t __len = MAXLOGNAME + 1; 1901 const size_t __idx __unused = __len - 1; 1902 1903 __stack.__buf = malloc(__bufsz); 1904 1905 getlogin_r(__stack.__buf, __len); 1906 #undef BUF 1907 1908 } 1909 1910 ATF_TC(getlogin_r_heap_after_end); 1911 ATF_TC_HEAD(getlogin_r_heap_after_end, tc) 1912 { 1913 } 1914 ATF_TC_BODY(getlogin_r_heap_after_end, tc) 1915 { 1916 #define BUF __stack.__buf 1917 struct { 1918 uint8_t padding_l; 1919 unsigned char * __buf; 1920 uint8_t padding_r; 1921 } __stack; 1922 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (MAXLOGNAME + 1); 1923 const size_t __len = MAXLOGNAME + 1 + 1; 1924 const size_t __idx __unused = __len - 1; 1925 pid_t __child; 1926 int __status; 1927 1928 __child = fork(); 1929 ATF_REQUIRE(__child >= 0); 1930 if (__child > 0) 1931 goto monitor; 1932 1933 /* Child */ 1934 disable_coredumps(); 1935 __stack.__buf = malloc(__bufsz); 1936 1937 getlogin_r(__stack.__buf, __len); 1938 _exit(EX_SOFTWARE); /* Should have aborted. */ 1939 1940 monitor: 1941 while (waitpid(__child, &__status, 0) != __child) { 1942 ATF_REQUIRE_EQ(EINTR, errno); 1943 } 1944 1945 if (!WIFSIGNALED(__status)) { 1946 switch (WEXITSTATUS(__status)) { 1947 case EX_SOFTWARE: 1948 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1949 break; 1950 case EX_OSERR: 1951 atf_tc_fail("setrlimit(2) failed"); 1952 break; 1953 default: 1954 atf_tc_fail("child exited with status %d", 1955 WEXITSTATUS(__status)); 1956 } 1957 } else { 1958 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1959 } 1960 #undef BUF 1961 1962 } 1963 1964 ATF_TC(ttyname_r_before_end); 1965 ATF_TC_HEAD(ttyname_r_before_end, tc) 1966 { 1967 } 1968 ATF_TC_BODY(ttyname_r_before_end, tc) 1969 { 1970 #define BUF &__stack.__buf 1971 struct { 1972 uint8_t padding_l; 1973 unsigned char __buf[42]; 1974 uint8_t padding_r; 1975 } __stack; 1976 const size_t __bufsz __unused = sizeof(__stack.__buf); 1977 const size_t __len = 42 - 1; 1978 const size_t __idx __unused = __len - 1; 1979 int fd; 1980 1981 fd = STDIN_FILENO; 1982 if (!isatty(fd)) 1983 atf_tc_skip("stdin is not an fd"); 1984 1985 ttyname_r(fd, __stack.__buf, __len); 1986 #undef BUF 1987 1988 } 1989 1990 ATF_TC(ttyname_r_end); 1991 ATF_TC_HEAD(ttyname_r_end, tc) 1992 { 1993 } 1994 ATF_TC_BODY(ttyname_r_end, tc) 1995 { 1996 #define BUF &__stack.__buf 1997 struct { 1998 uint8_t padding_l; 1999 unsigned char __buf[42]; 2000 uint8_t padding_r; 2001 } __stack; 2002 const size_t __bufsz __unused = sizeof(__stack.__buf); 2003 const size_t __len = 42; 2004 const size_t __idx __unused = __len - 1; 2005 int fd; 2006 2007 fd = STDIN_FILENO; 2008 if (!isatty(fd)) 2009 atf_tc_skip("stdin is not an fd"); 2010 2011 ttyname_r(fd, __stack.__buf, __len); 2012 #undef BUF 2013 2014 } 2015 2016 ATF_TC(ttyname_r_heap_before_end); 2017 ATF_TC_HEAD(ttyname_r_heap_before_end, tc) 2018 { 2019 } 2020 ATF_TC_BODY(ttyname_r_heap_before_end, tc) 2021 { 2022 #define BUF __stack.__buf 2023 struct { 2024 uint8_t padding_l; 2025 unsigned char * __buf; 2026 uint8_t padding_r; 2027 } __stack; 2028 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 2029 const size_t __len = 42 - 1; 2030 const size_t __idx __unused = __len - 1; 2031 int fd; 2032 2033 fd = STDIN_FILENO; 2034 if (!isatty(fd)) 2035 atf_tc_skip("stdin is not an fd"); 2036 2037 __stack.__buf = malloc(__bufsz); 2038 2039 ttyname_r(fd, __stack.__buf, __len); 2040 #undef BUF 2041 2042 } 2043 2044 ATF_TC(ttyname_r_heap_end); 2045 ATF_TC_HEAD(ttyname_r_heap_end, tc) 2046 { 2047 } 2048 ATF_TC_BODY(ttyname_r_heap_end, tc) 2049 { 2050 #define BUF __stack.__buf 2051 struct { 2052 uint8_t padding_l; 2053 unsigned char * __buf; 2054 uint8_t padding_r; 2055 } __stack; 2056 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 2057 const size_t __len = 42; 2058 const size_t __idx __unused = __len - 1; 2059 int fd; 2060 2061 fd = STDIN_FILENO; 2062 if (!isatty(fd)) 2063 atf_tc_skip("stdin is not an fd"); 2064 2065 __stack.__buf = malloc(__bufsz); 2066 2067 ttyname_r(fd, __stack.__buf, __len); 2068 #undef BUF 2069 2070 } 2071 2072 ATF_TC(ttyname_r_heap_after_end); 2073 ATF_TC_HEAD(ttyname_r_heap_after_end, tc) 2074 { 2075 } 2076 ATF_TC_BODY(ttyname_r_heap_after_end, tc) 2077 { 2078 #define BUF __stack.__buf 2079 struct { 2080 uint8_t padding_l; 2081 unsigned char * __buf; 2082 uint8_t padding_r; 2083 } __stack; 2084 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 2085 const size_t __len = 42 + 1; 2086 const size_t __idx __unused = __len - 1; 2087 pid_t __child; 2088 int __status; 2089 int fd; 2090 2091 fd = STDIN_FILENO; 2092 if (!isatty(fd)) 2093 atf_tc_skip("stdin is not an fd"); 2094 2095 __child = fork(); 2096 ATF_REQUIRE(__child >= 0); 2097 if (__child > 0) 2098 goto monitor; 2099 2100 /* Child */ 2101 disable_coredumps(); 2102 __stack.__buf = malloc(__bufsz); 2103 2104 ttyname_r(fd, __stack.__buf, __len); 2105 _exit(EX_SOFTWARE); /* Should have aborted. */ 2106 2107 monitor: 2108 while (waitpid(__child, &__status, 0) != __child) { 2109 ATF_REQUIRE_EQ(EINTR, errno); 2110 } 2111 2112 if (!WIFSIGNALED(__status)) { 2113 switch (WEXITSTATUS(__status)) { 2114 case EX_SOFTWARE: 2115 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 2116 break; 2117 case EX_OSERR: 2118 atf_tc_fail("setrlimit(2) failed"); 2119 break; 2120 default: 2121 atf_tc_fail("child exited with status %d", 2122 WEXITSTATUS(__status)); 2123 } 2124 } else { 2125 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 2126 } 2127 #undef BUF 2128 2129 } 2130 2131 ATF_TP_ADD_TCS(tp) 2132 { 2133 ATF_TP_ADD_TC(tp, getcwd_before_end); 2134 ATF_TP_ADD_TC(tp, getcwd_end); 2135 ATF_TP_ADD_TC(tp, getcwd_heap_before_end); 2136 ATF_TP_ADD_TC(tp, getcwd_heap_end); 2137 ATF_TP_ADD_TC(tp, getcwd_heap_after_end); 2138 ATF_TP_ADD_TC(tp, getgrouplist_before_end); 2139 ATF_TP_ADD_TC(tp, getgrouplist_end); 2140 ATF_TP_ADD_TC(tp, getgrouplist_heap_before_end); 2141 ATF_TP_ADD_TC(tp, getgrouplist_heap_end); 2142 ATF_TP_ADD_TC(tp, getgrouplist_heap_after_end); 2143 ATF_TP_ADD_TC(tp, getgroups_before_end); 2144 ATF_TP_ADD_TC(tp, getgroups_end); 2145 ATF_TP_ADD_TC(tp, getgroups_heap_before_end); 2146 ATF_TP_ADD_TC(tp, getgroups_heap_end); 2147 ATF_TP_ADD_TC(tp, getgroups_heap_after_end); 2148 ATF_TP_ADD_TC(tp, getloginclass_before_end); 2149 ATF_TP_ADD_TC(tp, getloginclass_end); 2150 ATF_TP_ADD_TC(tp, getloginclass_heap_before_end); 2151 ATF_TP_ADD_TC(tp, getloginclass_heap_end); 2152 ATF_TP_ADD_TC(tp, getloginclass_heap_after_end); 2153 ATF_TP_ADD_TC(tp, pread_before_end); 2154 ATF_TP_ADD_TC(tp, pread_end); 2155 ATF_TP_ADD_TC(tp, pread_heap_before_end); 2156 ATF_TP_ADD_TC(tp, pread_heap_end); 2157 ATF_TP_ADD_TC(tp, pread_heap_after_end); 2158 ATF_TP_ADD_TC(tp, read_before_end); 2159 ATF_TP_ADD_TC(tp, read_end); 2160 ATF_TP_ADD_TC(tp, read_heap_before_end); 2161 ATF_TP_ADD_TC(tp, read_heap_end); 2162 ATF_TP_ADD_TC(tp, read_heap_after_end); 2163 ATF_TP_ADD_TC(tp, readlink_before_end); 2164 ATF_TP_ADD_TC(tp, readlink_end); 2165 ATF_TP_ADD_TC(tp, readlink_heap_before_end); 2166 ATF_TP_ADD_TC(tp, readlink_heap_end); 2167 ATF_TP_ADD_TC(tp, readlink_heap_after_end); 2168 ATF_TP_ADD_TC(tp, readlinkat_before_end); 2169 ATF_TP_ADD_TC(tp, readlinkat_end); 2170 ATF_TP_ADD_TC(tp, readlinkat_heap_before_end); 2171 ATF_TP_ADD_TC(tp, readlinkat_heap_end); 2172 ATF_TP_ADD_TC(tp, readlinkat_heap_after_end); 2173 ATF_TP_ADD_TC(tp, getdomainname_before_end); 2174 ATF_TP_ADD_TC(tp, getdomainname_end); 2175 ATF_TP_ADD_TC(tp, getdomainname_heap_before_end); 2176 ATF_TP_ADD_TC(tp, getdomainname_heap_end); 2177 ATF_TP_ADD_TC(tp, getdomainname_heap_after_end); 2178 ATF_TP_ADD_TC(tp, getentropy_before_end); 2179 ATF_TP_ADD_TC(tp, getentropy_end); 2180 ATF_TP_ADD_TC(tp, getentropy_heap_before_end); 2181 ATF_TP_ADD_TC(tp, getentropy_heap_end); 2182 ATF_TP_ADD_TC(tp, getentropy_heap_after_end); 2183 ATF_TP_ADD_TC(tp, gethostname_before_end); 2184 ATF_TP_ADD_TC(tp, gethostname_end); 2185 ATF_TP_ADD_TC(tp, gethostname_heap_before_end); 2186 ATF_TP_ADD_TC(tp, gethostname_heap_end); 2187 ATF_TP_ADD_TC(tp, gethostname_heap_after_end); 2188 ATF_TP_ADD_TC(tp, getlogin_r_before_end); 2189 ATF_TP_ADD_TC(tp, getlogin_r_end); 2190 ATF_TP_ADD_TC(tp, getlogin_r_heap_before_end); 2191 ATF_TP_ADD_TC(tp, getlogin_r_heap_end); 2192 ATF_TP_ADD_TC(tp, getlogin_r_heap_after_end); 2193 ATF_TP_ADD_TC(tp, ttyname_r_before_end); 2194 ATF_TP_ADD_TC(tp, ttyname_r_end); 2195 ATF_TP_ADD_TC(tp, ttyname_r_heap_before_end); 2196 ATF_TP_ADD_TC(tp, ttyname_r_heap_end); 2197 ATF_TP_ADD_TC(tp, ttyname_r_heap_after_end); 2198 return (atf_no_error()); 2199 } 2200