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
53static
54atf_error_t
55create_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));
71out:
72    return err;
73}
74
75static
76void
77cleanup_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
106static
107int
108const_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
115static
116atf_error_t
117init_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
129static
130atf_error_t
131init_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
146out:
147    return err;
148}
149
150struct exec_data {
151    const char *const *m_argv;
152};
153
154static void exec_child(void *) ATF_DEFS_ATTRIBUTE_NORETURN;
155
156static
157void
158exec_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
167static
168atf_error_t
169fork_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
187out_sbs:
188    atf_process_stream_fini(&errsb);
189    atf_process_stream_fini(&outsb);
190out:
191    return err;
192}
193
194static
195void
196update_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
223static
224atf_error_t
225array_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
247out:
248    return err;
249}
250
251static void
252print_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
262static
263atf_error_t
264check_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));
279out:
280    return err;
281}
282
283/* ---------------------------------------------------------------------
284 * The "atf_check_result" type.
285 * --------------------------------------------------------------------- */
286
287struct 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
295static
296atf_error_t
297atf_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
327err_stdout:
328    atf_fs_path_fini(&r->pimpl->m_stdout);
329err_dir:
330    atf_fs_path_fini(&r->pimpl->m_dir);
331err_argv:
332    atf_list_fini(&r->pimpl->m_argv);
333out:
334    return err;
335}
336
337void
338atf_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
353const char *
354atf_check_result_stdout(const atf_check_result_t *r)
355{
356    return atf_fs_path_cstring(&r->pimpl->m_stdout);
357}
358
359const char *
360atf_check_result_stderr(const atf_check_result_t *r)
361{
362    return atf_fs_path_cstring(&r->pimpl->m_stderr);
363}
364
365bool
366atf_check_result_exited(const atf_check_result_t *r)
367{
368    return atf_process_status_exited(&r->pimpl->m_status);
369}
370
371int
372atf_check_result_exitcode(const atf_check_result_t *r)
373{
374    return atf_process_status_exitstatus(&r->pimpl->m_status);
375}
376
377bool
378atf_check_result_signaled(const atf_check_result_t *r)
379{
380    return atf_process_status_signaled(&r->pimpl->m_status);
381}
382
383int
384atf_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). */
396atf_error_t
397atf_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);
412out:
413    return err;
414}
415
416atf_error_t
417atf_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);
432out:
433    return err;
434}
435
436atf_error_t
437atf_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);
452out:
453    return err;
454}
455
456atf_error_t
457atf_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);
483out:
484    return err;
485}
486