1/* 2 * Automated Testing Framework (atf) 3 * 4 * Copyright (c) 2008, 2009, 2010 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30#include <sys/types.h> 31#include <sys/resource.h> 32#include <sys/time.h> 33#include <sys/wait.h> 34 35#include <errno.h> 36#include <fcntl.h> 37#include <signal.h> 38#include <stdio.h> 39#include <stdlib.h> 40#include <string.h> 41#include <unistd.h> 42 43#include <atf-c.h> 44 45#include "atf-c/defs.h" 46 47#include "process.h" 48#include "sanity.h" 49#include "test_helpers.h" 50 51atf_error_t atf_process_status_init(atf_process_status_t *, int); 52 53/* --------------------------------------------------------------------- 54 * Auxiliary functions for testing of 'atf_process_fork'. 55 * --------------------------------------------------------------------- */ 56 57/* 58 * Testing of atf_process_fork is quite messy. We want to be able to test 59 * all the possible combinations of stdout and stderr behavior to ensure 60 * that the streams are manipulated correctly. 61 * 62 * To do this, the do_fork function is a wrapper for atf_process_fork that 63 * issues stream-specific hooks before fork, while the child is running and 64 * after the child terminates. We then provide test cases that just call 65 * do_fork with different hooks. 66 * 67 * The hooks are described by base_stream, and we then have one *_stream 68 * type for ever possible stream behavior. 69 */ 70 71enum out_type { stdout_type, stderr_type }; 72 73struct base_stream { 74 void (*init)(void *); 75 void (*process)(void *, atf_process_child_t *); 76 void (*fini)(void *); 77 78 /* m_sb is initialized by subclasses that need it, but all consumers 79 * must use m_sb_ptr, which may or may not point to m_sb. This allows 80 * us to test the interface with a NULL value, which triggers a 81 * default behavior. */ 82 atf_process_stream_t m_sb; 83 atf_process_stream_t *m_sb_ptr; 84 enum out_type m_type; 85}; 86#define BASE_STREAM(ihook, phook, fhook, type) \ 87 { .init = ihook, \ 88 .process = phook, \ 89 .fini = fhook, \ 90 .m_type = type } 91 92static 93void 94check_file(const enum out_type type) 95{ 96 switch (type) { 97 case stdout_type: 98 ATF_CHECK(grep_file("stdout", "stdout: msg")); 99 ATF_CHECK(!grep_file("stdout", "stderr: msg")); 100 break; 101 case stderr_type: 102 ATF_CHECK(grep_file("stderr", "stderr: msg")); 103 ATF_CHECK(!grep_file("stderr", "stdout: msg")); 104 break; 105 default: 106 UNREACHABLE; 107 } 108} 109 110struct capture_stream { 111 struct base_stream m_base; 112 113 atf_dynstr_t m_msg; 114}; 115#define CAPTURE_STREAM(type) \ 116 { .m_base = BASE_STREAM(capture_stream_init, \ 117 capture_stream_process, \ 118 capture_stream_fini, \ 119 type) } 120 121static 122void 123capture_stream_init(void *v) 124{ 125 struct capture_stream *s = v; 126 127 s->m_base.m_sb_ptr = &s->m_base.m_sb; 128 RE(atf_process_stream_init_capture(&s->m_base.m_sb)); 129 RE(atf_dynstr_init(&s->m_msg)); 130} 131 132static 133void 134capture_stream_process(void *v, atf_process_child_t *c) 135{ 136 struct capture_stream *s = v; 137 138 switch (s->m_base.m_type) { 139 case stdout_type: 140 (void) read_line(atf_process_child_stdout(c), &s->m_msg); 141 break; 142 case stderr_type: 143 (void) read_line(atf_process_child_stderr(c), &s->m_msg); 144 break; 145 default: 146 UNREACHABLE; 147 } 148} 149 150static 151void 152capture_stream_fini(void *v) 153{ 154 struct capture_stream *s = v; 155 156 switch (s->m_base.m_type) { 157 case stdout_type: 158 ATF_CHECK(grep_string(&s->m_msg, "stdout: msg")); 159 ATF_CHECK(!grep_string(&s->m_msg, "stderr: msg")); 160 break; 161 case stderr_type: 162 ATF_CHECK(!grep_string(&s->m_msg, "stdout: msg")); 163 ATF_CHECK(grep_string(&s->m_msg, "stderr: msg")); 164 break; 165 default: 166 UNREACHABLE; 167 } 168 169 atf_dynstr_fini(&s->m_msg); 170 atf_process_stream_fini(&s->m_base.m_sb); 171} 172 173struct connect_stream { 174 struct base_stream m_base; 175 176 int m_fd; 177}; 178#define CONNECT_STREAM(type) \ 179 { .m_base = BASE_STREAM(connect_stream_init, \ 180 NULL, \ 181 connect_stream_fini, \ 182 type) } 183 184static 185void 186connect_stream_init(void *v) 187{ 188 struct connect_stream *s = v; 189 int src_fd; 190 191 switch (s->m_base.m_type) { 192 case stdout_type: 193 src_fd = STDOUT_FILENO; 194 s->m_fd = open("stdout", O_WRONLY | O_CREAT | O_TRUNC, 0644); 195 break; 196 case stderr_type: 197 src_fd = STDERR_FILENO; 198 s->m_fd = open("stderr", O_WRONLY | O_CREAT | O_TRUNC, 0644); 199 break; 200 default: 201 UNREACHABLE; 202 src_fd = -1; 203 } 204 ATF_REQUIRE(s->m_fd != -1); 205 206 s->m_base.m_sb_ptr = &s->m_base.m_sb; 207 RE(atf_process_stream_init_connect(&s->m_base.m_sb, src_fd, s->m_fd)); 208} 209 210static 211void 212connect_stream_fini(void *v) 213{ 214 struct connect_stream *s = v; 215 216 ATF_REQUIRE(close(s->m_fd) != -1); 217 218 atf_process_stream_fini(&s->m_base.m_sb); 219 220 check_file(s->m_base.m_type); 221} 222 223struct inherit_stream { 224 struct base_stream m_base; 225 int m_fd; 226 227 int m_old_fd; 228}; 229#define INHERIT_STREAM(type) \ 230 { .m_base = BASE_STREAM(inherit_stream_init, \ 231 NULL, \ 232 inherit_stream_fini, \ 233 type) } 234 235static 236void 237inherit_stream_init(void *v) 238{ 239 struct inherit_stream *s = v; 240 const char *name; 241 242 s->m_base.m_sb_ptr = &s->m_base.m_sb; 243 RE(atf_process_stream_init_inherit(&s->m_base.m_sb)); 244 245 switch (s->m_base.m_type) { 246 case stdout_type: 247 s->m_fd = STDOUT_FILENO; 248 name = "stdout"; 249 break; 250 case stderr_type: 251 s->m_fd = STDERR_FILENO; 252 name = "stderr"; 253 break; 254 default: 255 UNREACHABLE; 256 name = NULL; 257 } 258 259 s->m_old_fd = dup(s->m_fd); 260 ATF_REQUIRE(s->m_old_fd != -1); 261 ATF_REQUIRE(close(s->m_fd) != -1); 262 ATF_REQUIRE_EQ(open(name, O_WRONLY | O_CREAT | O_TRUNC, 0644), 263 s->m_fd); 264} 265 266static 267void 268inherit_stream_fini(void *v) 269{ 270 struct inherit_stream *s = v; 271 272 ATF_REQUIRE(dup2(s->m_old_fd, s->m_fd) != -1); 273 ATF_REQUIRE(close(s->m_old_fd) != -1); 274 275 atf_process_stream_fini(&s->m_base.m_sb); 276 277 check_file(s->m_base.m_type); 278} 279 280#define default_stream inherit_stream 281#define DEFAULT_STREAM(type) \ 282 { .m_base = BASE_STREAM(default_stream_init, \ 283 NULL, \ 284 default_stream_fini, \ 285 type) } 286 287static 288void 289default_stream_init(void *v) 290{ 291 struct inherit_stream *s = v; 292 293 inherit_stream_init(v); 294 s->m_base.m_sb_ptr = NULL; 295} 296 297static 298void 299default_stream_fini(void *v) 300{ 301 inherit_stream_fini(v); 302} 303 304struct redirect_fd_stream { 305 struct base_stream m_base; 306 307 int m_fd; 308}; 309#define REDIRECT_FD_STREAM(type) \ 310 { .m_base = BASE_STREAM(redirect_fd_stream_init, \ 311 NULL, \ 312 redirect_fd_stream_fini, \ 313 type) } 314 315static 316void 317redirect_fd_stream_init(void *v) 318{ 319 struct redirect_fd_stream *s = v; 320 321 switch (s->m_base.m_type) { 322 case stdout_type: 323 s->m_fd = open("stdout", O_WRONLY | O_CREAT | O_TRUNC, 0644); 324 break; 325 case stderr_type: 326 s->m_fd = open("stderr", O_WRONLY | O_CREAT | O_TRUNC, 0644); 327 break; 328 default: 329 UNREACHABLE; 330 } 331 ATF_REQUIRE(s->m_fd != -1); 332 333 s->m_base.m_sb_ptr = &s->m_base.m_sb; 334 RE(atf_process_stream_init_redirect_fd(&s->m_base.m_sb, s->m_fd)); 335} 336 337static 338void 339redirect_fd_stream_fini(void *v) 340{ 341 struct redirect_fd_stream *s = v; 342 343 ATF_REQUIRE(close(s->m_fd) != -1); 344 345 atf_process_stream_fini(&s->m_base.m_sb); 346 347 check_file(s->m_base.m_type); 348} 349 350struct redirect_path_stream { 351 struct base_stream m_base; 352 353 atf_fs_path_t m_path; 354}; 355#define REDIRECT_PATH_STREAM(type) \ 356 { .m_base = BASE_STREAM(redirect_path_stream_init, \ 357 NULL, \ 358 redirect_path_stream_fini, \ 359 type) } 360 361static 362void 363redirect_path_stream_init(void *v) 364{ 365 struct redirect_path_stream *s = v; 366 367 switch (s->m_base.m_type) { 368 case stdout_type: 369 RE(atf_fs_path_init_fmt(&s->m_path, "stdout")); 370 break; 371 case stderr_type: 372 RE(atf_fs_path_init_fmt(&s->m_path, "stderr")); 373 break; 374 default: 375 UNREACHABLE; 376 } 377 378 s->m_base.m_sb_ptr = &s->m_base.m_sb; 379 RE(atf_process_stream_init_redirect_path(&s->m_base.m_sb, &s->m_path)); 380} 381 382static 383void 384redirect_path_stream_fini(void *v) 385{ 386 struct redirect_path_stream *s = v; 387 388 atf_process_stream_fini(&s->m_base.m_sb); 389 390 atf_fs_path_fini(&s->m_path); 391 392 check_file(s->m_base.m_type); 393} 394 395static void child_print(void *) ATF_DEFS_ATTRIBUTE_NORETURN; 396 397struct child_print_data { 398 const char *m_msg; 399}; 400 401static 402void 403child_print(void *v) 404{ 405 struct child_print_data *cpd = v; 406 407 fprintf(stdout, "stdout: %s\n", cpd->m_msg); 408 fprintf(stderr, "stderr: %s\n", cpd->m_msg); 409 410 exit(EXIT_SUCCESS); 411} 412 413static 414void 415do_fork(const struct base_stream *outfs, void *out, 416 const struct base_stream *errfs, void *err) 417{ 418 atf_process_child_t child; 419 atf_process_status_t status; 420 struct child_print_data cpd = { "msg" }; 421 422 outfs->init(out); 423 errfs->init(err); 424 425 RE(atf_process_fork(&child, child_print, outfs->m_sb_ptr, 426 errfs->m_sb_ptr, &cpd)); 427 if (outfs->process != NULL) 428 outfs->process(out, &child); 429 if (errfs->process != NULL) 430 errfs->process(err, &child); 431 RE(atf_process_child_wait(&child, &status)); 432 433 outfs->fini(out); 434 errfs->fini(err); 435 436 atf_process_status_fini(&status); 437} 438 439/* --------------------------------------------------------------------- 440 * Test cases for the "stream" type. 441 * --------------------------------------------------------------------- */ 442 443ATF_TC(stream_init_capture); 444ATF_TC_HEAD(stream_init_capture, tc) 445{ 446 atf_tc_set_md_var(tc, "descr", "Tests the " 447 "atf_process_stream_init_capture function"); 448} 449ATF_TC_BODY(stream_init_capture, tc) 450{ 451 atf_process_stream_t sb; 452 453 RE(atf_process_stream_init_capture(&sb)); 454 455 ATF_CHECK_EQ(atf_process_stream_type(&sb), 456 atf_process_stream_type_capture); 457 458 atf_process_stream_fini(&sb); 459} 460 461ATF_TC(stream_init_connect); 462ATF_TC_HEAD(stream_init_connect, tc) 463{ 464 atf_tc_set_md_var(tc, "descr", "Tests the " 465 "atf_process_stream_init_connect function"); 466} 467ATF_TC_BODY(stream_init_connect, tc) 468{ 469 atf_process_stream_t sb; 470 471 RE(atf_process_stream_init_connect(&sb, 1, 2)); 472 473 ATF_CHECK_EQ(atf_process_stream_type(&sb), 474 atf_process_stream_type_connect); 475 476 atf_process_stream_fini(&sb); 477} 478 479ATF_TC(stream_init_inherit); 480ATF_TC_HEAD(stream_init_inherit, tc) 481{ 482 atf_tc_set_md_var(tc, "descr", "Tests the " 483 "atf_process_stream_init_inherit function"); 484} 485ATF_TC_BODY(stream_init_inherit, tc) 486{ 487 atf_process_stream_t sb; 488 489 RE(atf_process_stream_init_inherit(&sb)); 490 491 ATF_CHECK_EQ(atf_process_stream_type(&sb), 492 atf_process_stream_type_inherit); 493 494 atf_process_stream_fini(&sb); 495} 496 497ATF_TC(stream_init_redirect_fd); 498ATF_TC_HEAD(stream_init_redirect_fd, tc) 499{ 500 atf_tc_set_md_var(tc, "descr", "Tests the " 501 "atf_process_stream_init_redirect_fd function"); 502} 503ATF_TC_BODY(stream_init_redirect_fd, tc) 504{ 505 atf_process_stream_t sb; 506 507 RE(atf_process_stream_init_redirect_fd(&sb, 1)); 508 509 ATF_CHECK_EQ(atf_process_stream_type(&sb), 510 atf_process_stream_type_redirect_fd); 511 512 atf_process_stream_fini(&sb); 513} 514 515ATF_TC(stream_init_redirect_path); 516ATF_TC_HEAD(stream_init_redirect_path, tc) 517{ 518 atf_tc_set_md_var(tc, "descr", "Tests the " 519 "atf_process_stream_init_redirect_path function"); 520} 521ATF_TC_BODY(stream_init_redirect_path, tc) 522{ 523 atf_process_stream_t sb; 524 atf_fs_path_t path; 525 526 RE(atf_fs_path_init_fmt(&path, "foo")); 527 RE(atf_process_stream_init_redirect_path(&sb, &path)); 528 529 ATF_CHECK_EQ(atf_process_stream_type(&sb), 530 atf_process_stream_type_redirect_path); 531 532 atf_process_stream_fini(&sb); 533 atf_fs_path_fini(&path); 534} 535 536/* --------------------------------------------------------------------- 537 * Test cases for the "status" type. 538 * --------------------------------------------------------------------- */ 539 540static void child_exit_success(void) ATF_DEFS_ATTRIBUTE_NORETURN; 541static void child_exit_failure(void) ATF_DEFS_ATTRIBUTE_NORETURN; 542static void child_sigkill(void) ATF_DEFS_ATTRIBUTE_NORETURN; 543static void child_sigquit(void) ATF_DEFS_ATTRIBUTE_NORETURN; 544static void child_sigterm(void) ATF_DEFS_ATTRIBUTE_NORETURN; 545 546void 547child_exit_success(void) 548{ 549 exit(EXIT_SUCCESS); 550} 551 552void 553child_exit_failure(void) 554{ 555 exit(EXIT_FAILURE); 556} 557 558void 559child_sigkill(void) 560{ 561 kill(getpid(), SIGKILL); 562 abort(); 563} 564 565void 566child_sigquit(void) 567{ 568 kill(getpid(), SIGQUIT); 569 abort(); 570} 571 572void 573child_sigterm(void) 574{ 575 kill(getpid(), SIGTERM); 576 abort(); 577} 578 579static 580int 581fork_and_wait_child(void (*child_func)(void)) 582{ 583 pid_t pid; 584 int status; 585 586 pid = fork(); 587 ATF_REQUIRE(pid != -1); 588 if (pid == 0) { 589 status = 0; /* Silence compiler warnings */ 590 child_func(); 591 UNREACHABLE; 592 } else { 593 ATF_REQUIRE(waitpid(pid, &status, 0) != 0); 594 } 595 596 return status; 597} 598 599ATF_TC(status_exited); 600ATF_TC_HEAD(status_exited, tc) 601{ 602 atf_tc_set_md_var(tc, "descr", "Tests the status type for processes " 603 "that exit cleanly"); 604} 605ATF_TC_BODY(status_exited, tc) 606{ 607 { 608 const int rawstatus = fork_and_wait_child(child_exit_success); 609 atf_process_status_t s; 610 RE(atf_process_status_init(&s, rawstatus)); 611 ATF_CHECK(atf_process_status_exited(&s)); 612 ATF_CHECK_EQ(atf_process_status_exitstatus(&s), EXIT_SUCCESS); 613 ATF_CHECK(!atf_process_status_signaled(&s)); 614 atf_process_status_fini(&s); 615 } 616 617 { 618 const int rawstatus = fork_and_wait_child(child_exit_failure); 619 atf_process_status_t s; 620 RE(atf_process_status_init(&s, rawstatus)); 621 ATF_CHECK(atf_process_status_exited(&s)); 622 ATF_CHECK_EQ(atf_process_status_exitstatus(&s), EXIT_FAILURE); 623 ATF_CHECK(!atf_process_status_signaled(&s)); 624 atf_process_status_fini(&s); 625 } 626} 627 628ATF_TC(status_signaled); 629ATF_TC_HEAD(status_signaled, tc) 630{ 631 atf_tc_set_md_var(tc, "descr", "Tests the status type for processes " 632 "that end due to a signal"); 633} 634ATF_TC_BODY(status_signaled, tc) 635{ 636 { 637 const int rawstatus = fork_and_wait_child(child_sigkill); 638 atf_process_status_t s; 639 RE(atf_process_status_init(&s, rawstatus)); 640 ATF_CHECK(!atf_process_status_exited(&s)); 641 ATF_CHECK(atf_process_status_signaled(&s)); 642 ATF_CHECK_EQ(atf_process_status_termsig(&s), SIGKILL); 643 ATF_CHECK(!atf_process_status_coredump(&s)); 644 atf_process_status_fini(&s); 645 } 646 647 { 648 const int rawstatus = fork_and_wait_child(child_sigterm); 649 atf_process_status_t s; 650 RE(atf_process_status_init(&s, rawstatus)); 651 ATF_CHECK(!atf_process_status_exited(&s)); 652 ATF_CHECK(atf_process_status_signaled(&s)); 653 ATF_CHECK_EQ(atf_process_status_termsig(&s), SIGTERM); 654 ATF_CHECK(!atf_process_status_coredump(&s)); 655 atf_process_status_fini(&s); 656 } 657} 658 659ATF_TC(status_coredump); 660ATF_TC_HEAD(status_coredump, tc) 661{ 662 atf_tc_set_md_var(tc, "descr", "Tests the status type for processes " 663 "that crash"); 664} 665ATF_TC_BODY(status_coredump, tc) 666{ 667 struct rlimit rl; 668 rl.rlim_cur = RLIM_INFINITY; 669 rl.rlim_max = RLIM_INFINITY; 670 if (setrlimit(RLIMIT_CORE, &rl) == -1) 671 atf_tc_skip("Cannot unlimit the core file size; check limits " 672 "manually"); 673 674 const int rawstatus = fork_and_wait_child(child_sigquit); 675 atf_process_status_t s; 676 RE(atf_process_status_init(&s, rawstatus)); 677 ATF_CHECK(!atf_process_status_exited(&s)); 678 ATF_CHECK(atf_process_status_signaled(&s)); 679 ATF_CHECK_EQ(atf_process_status_termsig(&s), SIGQUIT); 680 ATF_CHECK(atf_process_status_coredump(&s)); 681 atf_process_status_fini(&s); 682} 683 684/* --------------------------------------------------------------------- 685 * Test cases for the "child" type. 686 * --------------------------------------------------------------------- */ 687 688static void child_report_pid(void *) ATF_DEFS_ATTRIBUTE_NORETURN; 689 690static 691void 692child_report_pid(void *v) 693{ 694 const pid_t pid = getpid(); 695 if (write(STDOUT_FILENO, &pid, sizeof(pid)) != sizeof(pid)) 696 abort(); 697 fprintf(stderr, "Reporting %d to parent\n", (int)getpid()); 698 exit(EXIT_SUCCESS); 699} 700 701ATF_TC(child_pid); 702ATF_TC_HEAD(child_pid, tc) 703{ 704 atf_tc_set_md_var(tc, "descr", "Tests the correctness of the pid " 705 "stored in the child type"); 706} 707ATF_TC_BODY(child_pid, tc) 708{ 709 atf_process_stream_t outsb, errsb; 710 atf_process_child_t child; 711 atf_process_status_t status; 712 pid_t pid; 713 714 RE(atf_process_stream_init_capture(&outsb)); 715 RE(atf_process_stream_init_inherit(&errsb)); 716 717 RE(atf_process_fork(&child, child_report_pid, &outsb, &errsb, NULL)); 718 ATF_CHECK_EQ(read(atf_process_child_stdout(&child), &pid, sizeof(pid)), 719 sizeof(pid)); 720 printf("Expected PID: %d\n", (int)atf_process_child_pid(&child)); 721 printf("Actual PID: %d\n", (int)pid); 722 ATF_CHECK_EQ(atf_process_child_pid(&child), pid); 723 724 RE(atf_process_child_wait(&child, &status)); 725 atf_process_status_fini(&status); 726 727 atf_process_stream_fini(&outsb); 728 atf_process_stream_fini(&errsb); 729} 730 731static 732void 733child_loop(void *v) 734{ 735 for (;;) 736 sleep(1); 737} 738 739static 740void 741nop_signal(int sig) 742{ 743} 744 745static 746void 747child_spawn_loop_and_wait_eintr(void *v) 748{ 749 atf_process_child_t child; 750 atf_process_status_t status; 751 struct sigaction sighup, old_sighup; 752 753#define RE_ABORT(expr) \ 754 do { \ 755 atf_error_t _aux_err = expr; \ 756 if (atf_is_error(_aux_err)) { \ 757 atf_error_free(_aux_err); \ 758 abort(); \ 759 } \ 760 } while (0) 761 762 { 763 atf_process_stream_t outsb, errsb; 764 765 RE_ABORT(atf_process_stream_init_capture(&outsb)); 766 RE_ABORT(atf_process_stream_init_inherit(&errsb)); 767 RE_ABORT(atf_process_fork(&child, child_loop, &outsb, &errsb, NULL)); 768 atf_process_stream_fini(&outsb); 769 atf_process_stream_fini(&errsb); 770 } 771 772 sighup.sa_handler = nop_signal; 773 sigemptyset(&sighup.sa_mask); 774 sighup.sa_flags = 0; 775 if (sigaction(SIGHUP, &sighup, &old_sighup) == -1) 776 abort(); 777 778 printf("waiting\n"); 779 fflush(stdout); 780 781 fprintf(stderr, "Child entering wait(2)\n"); 782 atf_error_t err = atf_process_child_wait(&child, &status); 783 fprintf(stderr, "Child's wait(2) terminated\n"); 784 if (!atf_is_error(err)) { 785 fprintf(stderr, "wait completed successfully (not interrupted)\n"); 786 abort(); 787 } 788 if (!atf_error_is(err, "libc")) { 789 fprintf(stderr, "wait did not raise libc_error\n"); 790 abort(); 791 } 792 if (atf_libc_error_code(err) != EINTR) { 793 fprintf(stderr, "libc_error is not EINTR\n"); 794 abort(); 795 } 796 atf_error_free(err); 797 798 sigaction(SIGHUP, &old_sighup, NULL); 799 800 fprintf(stderr, "Child is killing subchild\n"); 801 kill(atf_process_child_pid(&child), SIGTERM); 802 803 RE_ABORT(atf_process_child_wait(&child, &status)); 804 atf_process_status_fini(&status); 805 806#undef RE_ABORT 807 808 exit(EXIT_SUCCESS); 809} 810 811ATF_TC(child_wait_eintr); 812ATF_TC_HEAD(child_wait_eintr, tc) 813{ 814 atf_tc_set_md_var(tc, "descr", "Tests the interruption of the wait " 815 "method by an external signal, and the return of " 816 "an EINTR error"); 817 atf_tc_set_md_var(tc, "timeout", "30"); 818} 819ATF_TC_BODY(child_wait_eintr, tc) 820{ 821 atf_process_child_t child; 822 atf_process_status_t status; 823 824 { 825 atf_process_stream_t outsb, errsb; 826 827 RE(atf_process_stream_init_capture(&outsb)); 828 RE(atf_process_stream_init_inherit(&errsb)); 829 RE(atf_process_fork(&child, child_spawn_loop_and_wait_eintr, 830 &outsb, &errsb, NULL)); 831 atf_process_stream_fini(&outsb); 832 atf_process_stream_fini(&errsb); 833 } 834 835 { 836 /* Wait until the child process performs the wait call. This is 837 * racy, because the message we get from it is sent *before* 838 * doing the real system call... but I can't figure any other way 839 * to do this. */ 840 char buf[16]; 841 printf("Waiting for child to issue wait(2)\n"); 842 ATF_REQUIRE(read(atf_process_child_stdout(&child), buf, 843 sizeof(buf)) > 0); 844 sleep(1); 845 } 846 847 printf("Interrupting child's wait(2) call\n"); 848 kill(atf_process_child_pid(&child), SIGHUP); 849 850 printf("Waiting for child's completion\n"); 851 RE(atf_process_child_wait(&child, &status)); 852 ATF_REQUIRE(atf_process_status_exited(&status)); 853 ATF_REQUIRE_EQ(atf_process_status_exitstatus(&status), EXIT_SUCCESS); 854 atf_process_status_fini(&status); 855} 856 857/* --------------------------------------------------------------------- 858 * Tests cases for the free functions. 859 * --------------------------------------------------------------------- */ 860 861static 862void 863do_exec(const atf_tc_t *tc, const char *helper_name, atf_process_status_t *s) 864{ 865 atf_fs_path_t process_helpers; 866 const char *argv[3]; 867 868 get_process_helpers_path(tc, true, &process_helpers); 869 870 argv[0] = atf_fs_path_cstring(&process_helpers); 871 argv[1] = helper_name; 872 argv[2] = NULL; 873 printf("Executing %s %s\n", argv[0], argv[1]); 874 875 RE(atf_process_exec_array(s, &process_helpers, argv, NULL, NULL)); 876 atf_fs_path_fini(&process_helpers); 877} 878 879static 880void 881check_line(int fd, const char *exp) 882{ 883 atf_dynstr_t line; 884 bool eof; 885 886 atf_dynstr_init(&line); 887 eof = read_line(fd, &line); 888 ATF_CHECK(!eof); 889 ATF_CHECK_MSG(atf_equal_dynstr_cstring(&line, exp), 890 "read: '%s', expected: '%s'", 891 atf_dynstr_cstring(&line), exp); 892 atf_dynstr_fini(&line); 893} 894 895ATF_TC(exec_failure); 896ATF_TC_HEAD(exec_failure, tc) 897{ 898 atf_tc_set_md_var(tc, "descr", "Tests execing a command"); 899} 900ATF_TC_BODY(exec_failure, tc) 901{ 902 atf_process_status_t status; 903 904 do_exec(tc, "exit-failure", &status); 905 ATF_CHECK(atf_process_status_exited(&status)); 906 ATF_CHECK_EQ(atf_process_status_exitstatus(&status), EXIT_FAILURE); 907 atf_process_status_fini(&status); 908} 909 910ATF_TC(exec_list); 911ATF_TC_HEAD(exec_list, tc) 912{ 913 atf_tc_set_md_var(tc, "descr", "Tests execing a command"); 914} 915ATF_TC_BODY(exec_list, tc) 916{ 917 atf_fs_path_t process_helpers; 918 atf_list_t argv; 919 atf_process_status_t status; 920 921 RE(atf_list_init(&argv)); 922 923 get_process_helpers_path(tc, true, &process_helpers); 924 atf_list_append(&argv, strdup(atf_fs_path_cstring(&process_helpers)), true); 925 atf_list_append(&argv, strdup("echo"), true); 926 atf_list_append(&argv, strdup("test-message"), true); 927 { 928 atf_fs_path_t outpath; 929 atf_process_stream_t outsb; 930 931 RE(atf_fs_path_init_fmt(&outpath, "stdout")); 932 RE(atf_process_stream_init_redirect_path(&outsb, &outpath)); 933 RE(atf_process_exec_list(&status, &process_helpers, &argv, &outsb, 934 NULL)); 935 atf_process_stream_fini(&outsb); 936 atf_fs_path_fini(&outpath); 937 } 938 atf_list_fini(&argv); 939 940 ATF_CHECK(atf_process_status_exited(&status)); 941 ATF_CHECK_EQ(atf_process_status_exitstatus(&status), EXIT_SUCCESS); 942 943 { 944 int fd = open("stdout", O_RDONLY); 945 ATF_CHECK(fd != -1); 946 check_line(fd, "test-message"); 947 close(fd); 948 } 949 950 atf_process_status_fini(&status); 951 atf_fs_path_fini(&process_helpers); 952} 953 954ATF_TC(exec_success); 955ATF_TC_HEAD(exec_success, tc) 956{ 957 atf_tc_set_md_var(tc, "descr", "Tests execing a command"); 958} 959ATF_TC_BODY(exec_success, tc) 960{ 961 atf_process_status_t status; 962 963 do_exec(tc, "exit-success", &status); 964 ATF_CHECK(atf_process_status_exited(&status)); 965 ATF_CHECK_EQ(atf_process_status_exitstatus(&status), EXIT_SUCCESS); 966 atf_process_status_fini(&status); 967} 968 969static const int exit_v_null = 1; 970static const int exit_v_notnull = 2; 971 972static 973void 974child_cookie(void *v) 975{ 976 if (v == NULL) 977 exit(exit_v_null); 978 else 979 exit(exit_v_notnull); 980 981 UNREACHABLE; 982} 983 984ATF_TC(fork_cookie); 985ATF_TC_HEAD(fork_cookie, tc) 986{ 987 atf_tc_set_md_var(tc, "descr", "Tests forking a child, with " 988 "a null and non-null data cookie"); 989} 990ATF_TC_BODY(fork_cookie, tc) 991{ 992 atf_process_stream_t outsb, errsb; 993 994 RE(atf_process_stream_init_inherit(&outsb)); 995 RE(atf_process_stream_init_inherit(&errsb)); 996 997 { 998 atf_process_child_t child; 999 atf_process_status_t status; 1000 1001 RE(atf_process_fork(&child, child_cookie, &outsb, &errsb, NULL)); 1002 RE(atf_process_child_wait(&child, &status)); 1003 1004 ATF_CHECK(atf_process_status_exited(&status)); 1005 ATF_CHECK_EQ(atf_process_status_exitstatus(&status), exit_v_null); 1006 1007 atf_process_status_fini(&status); 1008 } 1009 1010 { 1011 atf_process_child_t child; 1012 atf_process_status_t status; 1013 int dummy_int; 1014 1015 RE(atf_process_fork(&child, child_cookie, &outsb, &errsb, &dummy_int)); 1016 RE(atf_process_child_wait(&child, &status)); 1017 1018 ATF_CHECK(atf_process_status_exited(&status)); 1019 ATF_CHECK_EQ(atf_process_status_exitstatus(&status), exit_v_notnull); 1020 1021 atf_process_status_fini(&status); 1022 } 1023 1024 atf_process_stream_fini(&errsb); 1025 atf_process_stream_fini(&outsb); 1026} 1027 1028#define TC_FORK_STREAMS(outlc, outuc, errlc, erruc) \ 1029 ATF_TC(fork_out_ ## outlc ## _err_ ## errlc); \ 1030 ATF_TC_HEAD(fork_out_ ## outlc ## _err_ ## errlc, tc) \ 1031 { \ 1032 atf_tc_set_md_var(tc, "descr", "Tests forking a child, with " \ 1033 "stdout " #outlc " and stderr " #errlc); \ 1034 } \ 1035 ATF_TC_BODY(fork_out_ ## outlc ## _err_ ## errlc, tc) \ 1036 { \ 1037 struct outlc ## _stream out = outuc ## _STREAM(stdout_type); \ 1038 struct errlc ## _stream err = erruc ## _STREAM(stderr_type); \ 1039 do_fork(&out.m_base, &out, &err.m_base, &err); \ 1040 } 1041 1042TC_FORK_STREAMS(capture, CAPTURE, capture, CAPTURE); 1043TC_FORK_STREAMS(capture, CAPTURE, connect, CONNECT); 1044TC_FORK_STREAMS(capture, CAPTURE, default, DEFAULT); 1045TC_FORK_STREAMS(capture, CAPTURE, inherit, INHERIT); 1046TC_FORK_STREAMS(capture, CAPTURE, redirect_fd, REDIRECT_FD); 1047TC_FORK_STREAMS(capture, CAPTURE, redirect_path, REDIRECT_PATH); 1048TC_FORK_STREAMS(connect, CONNECT, capture, CAPTURE); 1049TC_FORK_STREAMS(connect, CONNECT, connect, CONNECT); 1050TC_FORK_STREAMS(connect, CONNECT, default, DEFAULT); 1051TC_FORK_STREAMS(connect, CONNECT, inherit, INHERIT); 1052TC_FORK_STREAMS(connect, CONNECT, redirect_fd, REDIRECT_FD); 1053TC_FORK_STREAMS(connect, CONNECT, redirect_path, REDIRECT_PATH); 1054TC_FORK_STREAMS(default, DEFAULT, capture, CAPTURE); 1055TC_FORK_STREAMS(default, DEFAULT, connect, CONNECT); 1056TC_FORK_STREAMS(default, DEFAULT, default, DEFAULT); 1057TC_FORK_STREAMS(default, DEFAULT, inherit, INHERIT); 1058TC_FORK_STREAMS(default, DEFAULT, redirect_fd, REDIRECT_FD); 1059TC_FORK_STREAMS(default, DEFAULT, redirect_path, REDIRECT_PATH); 1060TC_FORK_STREAMS(inherit, INHERIT, capture, CAPTURE); 1061TC_FORK_STREAMS(inherit, INHERIT, connect, CONNECT); 1062TC_FORK_STREAMS(inherit, INHERIT, default, DEFAULT); 1063TC_FORK_STREAMS(inherit, INHERIT, inherit, INHERIT); 1064TC_FORK_STREAMS(inherit, INHERIT, redirect_fd, REDIRECT_FD); 1065TC_FORK_STREAMS(inherit, INHERIT, redirect_path, REDIRECT_PATH); 1066TC_FORK_STREAMS(redirect_fd, REDIRECT_FD, capture, CAPTURE); 1067TC_FORK_STREAMS(redirect_fd, REDIRECT_FD, connect, CONNECT); 1068TC_FORK_STREAMS(redirect_fd, REDIRECT_FD, default, DEFAULT); 1069TC_FORK_STREAMS(redirect_fd, REDIRECT_FD, inherit, INHERIT); 1070TC_FORK_STREAMS(redirect_fd, REDIRECT_FD, redirect_fd, REDIRECT_FD); 1071TC_FORK_STREAMS(redirect_fd, REDIRECT_FD, redirect_path, REDIRECT_PATH); 1072TC_FORK_STREAMS(redirect_path, REDIRECT_PATH, capture, CAPTURE); 1073TC_FORK_STREAMS(redirect_path, REDIRECT_PATH, connect, CONNECT); 1074TC_FORK_STREAMS(redirect_path, REDIRECT_PATH, default, DEFAULT); 1075TC_FORK_STREAMS(redirect_path, REDIRECT_PATH, inherit, INHERIT); 1076TC_FORK_STREAMS(redirect_path, REDIRECT_PATH, redirect_fd, REDIRECT_FD); 1077TC_FORK_STREAMS(redirect_path, REDIRECT_PATH, redirect_path, REDIRECT_PATH); 1078 1079#undef TC_FORK_STREAMS 1080 1081/* --------------------------------------------------------------------- 1082 * Main. 1083 * --------------------------------------------------------------------- */ 1084 1085ATF_TP_ADD_TCS(tp) 1086{ 1087 /* Add the tests for the "stream" type. */ 1088 ATF_TP_ADD_TC(tp, stream_init_capture); 1089 ATF_TP_ADD_TC(tp, stream_init_connect); 1090 ATF_TP_ADD_TC(tp, stream_init_inherit); 1091 ATF_TP_ADD_TC(tp, stream_init_redirect_fd); 1092 ATF_TP_ADD_TC(tp, stream_init_redirect_path); 1093 1094 /* Add the tests for the "status" type. */ 1095 ATF_TP_ADD_TC(tp, status_exited); 1096 ATF_TP_ADD_TC(tp, status_signaled); 1097 ATF_TP_ADD_TC(tp, status_coredump); 1098 1099 /* Add the tests for the "child" type. */ 1100 ATF_TP_ADD_TC(tp, child_pid); 1101 ATF_TP_ADD_TC(tp, child_wait_eintr); 1102 1103 /* Add the tests for the free functions. */ 1104 ATF_TP_ADD_TC(tp, exec_failure); 1105 ATF_TP_ADD_TC(tp, exec_list); 1106 ATF_TP_ADD_TC(tp, exec_success); 1107 ATF_TP_ADD_TC(tp, fork_cookie); 1108 ATF_TP_ADD_TC(tp, fork_out_capture_err_capture); 1109 ATF_TP_ADD_TC(tp, fork_out_capture_err_connect); 1110 ATF_TP_ADD_TC(tp, fork_out_capture_err_default); 1111 ATF_TP_ADD_TC(tp, fork_out_capture_err_inherit); 1112 ATF_TP_ADD_TC(tp, fork_out_capture_err_redirect_fd); 1113 ATF_TP_ADD_TC(tp, fork_out_capture_err_redirect_path); 1114 ATF_TP_ADD_TC(tp, fork_out_connect_err_capture); 1115 ATF_TP_ADD_TC(tp, fork_out_connect_err_connect); 1116 ATF_TP_ADD_TC(tp, fork_out_connect_err_default); 1117 ATF_TP_ADD_TC(tp, fork_out_connect_err_inherit); 1118 ATF_TP_ADD_TC(tp, fork_out_connect_err_redirect_fd); 1119 ATF_TP_ADD_TC(tp, fork_out_connect_err_redirect_path); 1120 ATF_TP_ADD_TC(tp, fork_out_default_err_capture); 1121 ATF_TP_ADD_TC(tp, fork_out_default_err_connect); 1122 ATF_TP_ADD_TC(tp, fork_out_default_err_default); 1123 ATF_TP_ADD_TC(tp, fork_out_default_err_inherit); 1124 ATF_TP_ADD_TC(tp, fork_out_default_err_redirect_fd); 1125 ATF_TP_ADD_TC(tp, fork_out_default_err_redirect_path); 1126 ATF_TP_ADD_TC(tp, fork_out_inherit_err_capture); 1127 ATF_TP_ADD_TC(tp, fork_out_inherit_err_connect); 1128 ATF_TP_ADD_TC(tp, fork_out_inherit_err_default); 1129 ATF_TP_ADD_TC(tp, fork_out_inherit_err_inherit); 1130 ATF_TP_ADD_TC(tp, fork_out_inherit_err_redirect_fd); 1131 ATF_TP_ADD_TC(tp, fork_out_inherit_err_redirect_path); 1132 ATF_TP_ADD_TC(tp, fork_out_redirect_fd_err_capture); 1133 ATF_TP_ADD_TC(tp, fork_out_redirect_fd_err_connect); 1134 ATF_TP_ADD_TC(tp, fork_out_redirect_fd_err_default); 1135 ATF_TP_ADD_TC(tp, fork_out_redirect_fd_err_inherit); 1136 ATF_TP_ADD_TC(tp, fork_out_redirect_fd_err_redirect_fd); 1137 ATF_TP_ADD_TC(tp, fork_out_redirect_fd_err_redirect_path); 1138 ATF_TP_ADD_TC(tp, fork_out_redirect_path_err_capture); 1139 ATF_TP_ADD_TC(tp, fork_out_redirect_path_err_connect); 1140 ATF_TP_ADD_TC(tp, fork_out_redirect_path_err_default); 1141 ATF_TP_ADD_TC(tp, fork_out_redirect_path_err_inherit); 1142 ATF_TP_ADD_TC(tp, fork_out_redirect_path_err_redirect_fd); 1143 ATF_TP_ADD_TC(tp, fork_out_redirect_path_err_redirect_path); 1144 1145 return atf_no_error(); 1146} 1147