1/* 2 * Automated Testing Framework (atf) 3 * 4 * Copyright (c) 2008 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/wait.h> 31 32#include <errno.h> 33#include <fcntl.h> 34#include <stdio.h> 35#include <stdlib.h> 36#include <string.h> 37#include <unistd.h> 38 39#include "atf-c/build.h" 40#include "atf-c/check.h" 41#include "atf-c/config.h" 42#include "atf-c/defs.h" 43#include "atf-c/error.h" 44#include "atf-c/utils.h" 45 46#include "detail/dynstr.h" 47#include "detail/fs.h" 48#include "detail/list.h" 49#include "detail/process.h" 50#include "detail/sanity.h" 51 52/* --------------------------------------------------------------------- 53 * Auxiliary functions. 54 * --------------------------------------------------------------------- */ 55 56static 57atf_error_t 58create_tmpdir(atf_fs_path_t *dir) 59{ 60 atf_error_t err; 61 62 err = atf_fs_path_init_fmt(dir, "%s/check.XXXXXX", 63 atf_config_get("atf_workdir")); 64 if (atf_is_error(err)) 65 goto out; 66 67 err = atf_fs_mkdtemp(dir); 68 if (atf_is_error(err)) { 69 atf_fs_path_fini(dir); 70 goto out; 71 } 72 73 INV(!atf_is_error(err)); 74out: 75 return err; 76} 77 78static 79void 80cleanup_tmpdir(const atf_fs_path_t *dir, const atf_fs_path_t *outfile, 81 const atf_fs_path_t *errfile) 82{ 83 { 84 atf_error_t err = atf_fs_unlink(outfile); 85 if (atf_is_error(err)) { 86 INV(atf_error_is(err, "libc") && 87 atf_libc_error_code(err) == ENOENT); 88 atf_error_free(err); 89 } else 90 INV(!atf_is_error(err)); 91 } 92 93 { 94 atf_error_t err = atf_fs_unlink(errfile); 95 if (atf_is_error(err)) { 96 INV(atf_error_is(err, "libc") && 97 atf_libc_error_code(err) == ENOENT); 98 atf_error_free(err); 99 } else 100 INV(!atf_is_error(err)); 101 } 102 103 { 104 atf_error_t err = atf_fs_rmdir(dir); 105 INV(!atf_is_error(err)); 106 } 107} 108 109static 110int 111const_execvp(const char *file, const char *const *argv) 112{ 113#define UNCONST(a) ((void *)(unsigned long)(const void *)(a)) 114 return execvp(file, UNCONST(argv)); 115#undef UNCONST 116} 117 118static 119atf_error_t 120init_sb(const atf_fs_path_t *path, atf_process_stream_t *sb) 121{ 122 atf_error_t err; 123 124 if (path == NULL) 125 err = atf_process_stream_init_inherit(sb); 126 else 127 err = atf_process_stream_init_redirect_path(sb, path); 128 129 return err; 130} 131 132static 133atf_error_t 134init_sbs(const atf_fs_path_t *outfile, atf_process_stream_t *outsb, 135 const atf_fs_path_t *errfile, atf_process_stream_t *errsb) 136{ 137 atf_error_t err; 138 139 err = init_sb(outfile, outsb); 140 if (atf_is_error(err)) 141 goto out; 142 143 err = init_sb(errfile, errsb); 144 if (atf_is_error(err)) { 145 atf_process_stream_fini(outsb); 146 goto out; 147 } 148 149out: 150 return err; 151} 152 153struct exec_data { 154 const char *const *m_argv; 155}; 156 157static void exec_child(void *) ATF_DEFS_ATTRIBUTE_NORETURN; 158 159static 160void 161exec_child(void *v) 162{ 163 struct exec_data *ea = v; 164 165 const_execvp(ea->m_argv[0], ea->m_argv); 166 fprintf(stderr, "execvp(%s) failed: %s\n", ea->m_argv[0], strerror(errno)); 167 exit(127); 168} 169 170static 171atf_error_t 172fork_and_wait(const char *const *argv, const atf_fs_path_t *outfile, 173 const atf_fs_path_t *errfile, atf_process_status_t *status) 174{ 175 atf_error_t err; 176 atf_process_child_t child; 177 atf_process_stream_t outsb, errsb; 178 struct exec_data ea = { argv }; 179 180 err = init_sbs(outfile, &outsb, errfile, &errsb); 181 if (atf_is_error(err)) 182 goto out; 183 184 err = atf_process_fork(&child, exec_child, &outsb, &errsb, &ea); 185 if (atf_is_error(err)) 186 goto out_sbs; 187 188 err = atf_process_child_wait(&child, status); 189 190out_sbs: 191 atf_process_stream_fini(&errsb); 192 atf_process_stream_fini(&outsb); 193out: 194 return err; 195} 196 197static 198void 199update_success_from_status(const char *progname, 200 const atf_process_status_t *status, bool *success) 201{ 202 bool s = atf_process_status_exited(status) && 203 atf_process_status_exitstatus(status) == EXIT_SUCCESS; 204 205 if (atf_process_status_exited(status)) { 206 if (atf_process_status_exitstatus(status) == EXIT_SUCCESS) 207 INV(s); 208 else { 209 INV(!s); 210 fprintf(stderr, "%s failed with exit code %d\n", progname, 211 atf_process_status_exitstatus(status)); 212 } 213 } else if (atf_process_status_signaled(status)) { 214 INV(!s); 215 fprintf(stderr, "%s failed due to signal %d%s\n", progname, 216 atf_process_status_termsig(status), 217 atf_process_status_coredump(status) ? " (core dumped)" : ""); 218 } else { 219 INV(!s); 220 fprintf(stderr, "%s failed due to unknown reason\n", progname); 221 } 222 223 *success = s; 224} 225 226static 227atf_error_t 228array_to_list(const char *const *a, atf_list_t *l) 229{ 230 atf_error_t err; 231 232 err = atf_list_init(l); 233 if (atf_is_error(err)) 234 goto out; 235 236 while (*a != NULL) { 237 char *item = strdup(*a); 238 if (item == NULL) { 239 err = atf_no_memory_error(); 240 goto out; 241 } 242 243 err = atf_list_append(l, item, true); 244 if (atf_is_error(err)) 245 goto out; 246 247 a++; 248 } 249 250out: 251 return err; 252} 253 254static void 255print_array(const char *const *array, const char *pfx) 256{ 257 const char *const *ptr; 258 259 printf("%s", pfx); 260 for (ptr = array; *ptr != NULL; ptr++) 261 printf(" %s", *ptr); 262 printf("\n"); 263} 264 265static 266atf_error_t 267check_build_run(const char *const *argv, bool *success) 268{ 269 atf_error_t err; 270 atf_process_status_t status; 271 272 print_array(argv, ">"); 273 274 err = fork_and_wait(argv, NULL, NULL, &status); 275 if (atf_is_error(err)) 276 goto out; 277 278 update_success_from_status(argv[0], &status, success); 279 atf_process_status_fini(&status); 280 281 INV(!atf_is_error(err)); 282out: 283 return err; 284} 285 286/* --------------------------------------------------------------------- 287 * The "atf_check_result" type. 288 * --------------------------------------------------------------------- */ 289 290struct atf_check_result_impl { 291 atf_list_t m_argv; 292 atf_fs_path_t m_dir; 293 atf_fs_path_t m_stdout; 294 atf_fs_path_t m_stderr; 295 atf_process_status_t m_status; 296}; 297 298static 299atf_error_t 300atf_check_result_init(atf_check_result_t *r, const char *const *argv, 301 const atf_fs_path_t *dir) 302{ 303 atf_error_t err; 304 305 r->pimpl = malloc(sizeof(struct atf_check_result_impl)); 306 if (r->pimpl == NULL) 307 return atf_no_memory_error(); 308 309 err = array_to_list(argv, &r->pimpl->m_argv); 310 if (atf_is_error(err)) 311 goto out; 312 313 err = atf_fs_path_copy(&r->pimpl->m_dir, dir); 314 if (atf_is_error(err)) 315 goto err_argv; 316 317 err = atf_fs_path_init_fmt(&r->pimpl->m_stdout, "%s/stdout", 318 atf_fs_path_cstring(dir)); 319 if (atf_is_error(err)) 320 goto err_dir; 321 322 err = atf_fs_path_init_fmt(&r->pimpl->m_stderr, "%s/stderr", 323 atf_fs_path_cstring(dir)); 324 if (atf_is_error(err)) 325 goto err_stdout; 326 327 INV(!atf_is_error(err)); 328 goto out; 329 330err_stdout: 331 atf_fs_path_fini(&r->pimpl->m_stdout); 332err_dir: 333 atf_fs_path_fini(&r->pimpl->m_dir); 334err_argv: 335 atf_list_fini(&r->pimpl->m_argv); 336out: 337 return err; 338} 339 340void 341atf_check_result_fini(atf_check_result_t *r) 342{ 343 atf_process_status_fini(&r->pimpl->m_status); 344 345 cleanup_tmpdir(&r->pimpl->m_dir, &r->pimpl->m_stdout, 346 &r->pimpl->m_stderr); 347 atf_fs_path_fini(&r->pimpl->m_stdout); 348 atf_fs_path_fini(&r->pimpl->m_stderr); 349 atf_fs_path_fini(&r->pimpl->m_dir); 350 351 atf_list_fini(&r->pimpl->m_argv); 352 353 free(r->pimpl); 354} 355 356const char * 357atf_check_result_stdout(const atf_check_result_t *r) 358{ 359 return atf_fs_path_cstring(&r->pimpl->m_stdout); 360} 361 362const char * 363atf_check_result_stderr(const atf_check_result_t *r) 364{ 365 return atf_fs_path_cstring(&r->pimpl->m_stderr); 366} 367 368bool 369atf_check_result_exited(const atf_check_result_t *r) 370{ 371 return atf_process_status_exited(&r->pimpl->m_status); 372} 373 374int 375atf_check_result_exitcode(const atf_check_result_t *r) 376{ 377 return atf_process_status_exitstatus(&r->pimpl->m_status); 378} 379 380bool 381atf_check_result_signaled(const atf_check_result_t *r) 382{ 383 return atf_process_status_signaled(&r->pimpl->m_status); 384} 385 386int 387atf_check_result_termsig(const atf_check_result_t *r) 388{ 389 return atf_process_status_termsig(&r->pimpl->m_status); 390} 391 392/* --------------------------------------------------------------------- 393 * Free functions. 394 * --------------------------------------------------------------------- */ 395 396/* XXX: This function shouldn't be in this module. It messes with stdout 397 * and stderr, and it provides a very high-end interface. This belongs, 398 * probably, somewhere related to test cases (such as in the tc module). */ 399atf_error_t 400atf_check_build_c_o(const char *sfile, 401 const char *ofile, 402 const char *const optargs[], 403 bool *success) 404{ 405 atf_error_t err; 406 char **argv; 407 408 err = atf_build_c_o(sfile, ofile, optargs, &argv); 409 if (atf_is_error(err)) 410 goto out; 411 412 err = check_build_run((const char *const *)argv, success); 413 414 atf_utils_free_charpp(argv); 415out: 416 return err; 417} 418 419atf_error_t 420atf_check_build_cpp(const char *sfile, 421 const char *ofile, 422 const char *const optargs[], 423 bool *success) 424{ 425 atf_error_t err; 426 char **argv; 427 428 err = atf_build_cpp(sfile, ofile, optargs, &argv); 429 if (atf_is_error(err)) 430 goto out; 431 432 err = check_build_run((const char *const *)argv, success); 433 434 atf_utils_free_charpp(argv); 435out: 436 return err; 437} 438 439atf_error_t 440atf_check_build_cxx_o(const char *sfile, 441 const char *ofile, 442 const char *const optargs[], 443 bool *success) 444{ 445 atf_error_t err; 446 char **argv; 447 448 err = atf_build_cxx_o(sfile, ofile, optargs, &argv); 449 if (atf_is_error(err)) 450 goto out; 451 452 err = check_build_run((const char *const *)argv, success); 453 454 atf_utils_free_charpp(argv); 455out: 456 return err; 457} 458 459atf_error_t 460atf_check_exec_array(const char *const *argv, atf_check_result_t *r) 461{ 462 atf_error_t err; 463 atf_fs_path_t dir; 464 465 err = create_tmpdir(&dir); 466 if (atf_is_error(err)) 467 goto out; 468 469 err = atf_check_result_init(r, argv, &dir); 470 if (atf_is_error(err)) { 471 atf_error_t err2 = atf_fs_rmdir(&dir); 472 INV(!atf_is_error(err2)); 473 goto out; 474 } 475 476 err = fork_and_wait(argv, &r->pimpl->m_stdout, &r->pimpl->m_stderr, 477 &r->pimpl->m_status); 478 if (atf_is_error(err)) { 479 atf_check_result_fini(r); 480 goto out; 481 } 482 483 INV(!atf_is_error(err)); 484 485 atf_fs_path_fini(&dir); 486out: 487 return err; 488} 489