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 56 static 57 atf_error_t 58 create_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)); 74 out: 75 return err; 76 } 77 78 static 79 void 80 cleanup_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 109 static 110 int 111 const_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 118 static 119 atf_error_t 120 init_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 132 static 133 atf_error_t 134 init_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 149 out: 150 return err; 151 } 152 153 struct exec_data { 154 const char *const *m_argv; 155 }; 156 157 static void exec_child(void *) ATF_DEFS_ATTRIBUTE_NORETURN; 158 159 static 160 void 161 exec_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 170 static 171 atf_error_t 172 fork_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 190 out_sbs: 191 atf_process_stream_fini(&errsb); 192 atf_process_stream_fini(&outsb); 193 out: 194 return err; 195 } 196 197 static 198 void 199 update_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 226 static 227 atf_error_t 228 array_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 250 out: 251 return err; 252 } 253 254 static void 255 print_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 265 static 266 atf_error_t 267 check_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)); 282 out: 283 return err; 284 } 285 286 /* --------------------------------------------------------------------- 287 * The "atf_check_result" type. 288 * --------------------------------------------------------------------- */ 289 290 struct 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 298 static 299 atf_error_t 300 atf_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 330 err_stdout: 331 atf_fs_path_fini(&r->pimpl->m_stdout); 332 err_dir: 333 atf_fs_path_fini(&r->pimpl->m_dir); 334 err_argv: 335 atf_list_fini(&r->pimpl->m_argv); 336 out: 337 return err; 338 } 339 340 void 341 atf_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 356 const char * 357 atf_check_result_stdout(const atf_check_result_t *r) 358 { 359 return atf_fs_path_cstring(&r->pimpl->m_stdout); 360 } 361 362 const char * 363 atf_check_result_stderr(const atf_check_result_t *r) 364 { 365 return atf_fs_path_cstring(&r->pimpl->m_stderr); 366 } 367 368 bool 369 atf_check_result_exited(const atf_check_result_t *r) 370 { 371 return atf_process_status_exited(&r->pimpl->m_status); 372 } 373 374 int 375 atf_check_result_exitcode(const atf_check_result_t *r) 376 { 377 return atf_process_status_exitstatus(&r->pimpl->m_status); 378 } 379 380 bool 381 atf_check_result_signaled(const atf_check_result_t *r) 382 { 383 return atf_process_status_signaled(&r->pimpl->m_status); 384 } 385 386 int 387 atf_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). */ 399 atf_error_t 400 atf_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); 415 out: 416 return err; 417 } 418 419 atf_error_t 420 atf_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); 435 out: 436 return err; 437 } 438 439 atf_error_t 440 atf_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); 455 out: 456 return err; 457 } 458 459 atf_error_t 460 atf_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); 486 out: 487 return err; 488 } 489
Indexes created Sun Sep 27 00:26:35 UTC 2026