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