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