/*
* Automated Testing Framework (atf)
*
* Copyright (c) 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/wait.h>

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "atf-c/build.h"
#include "atf-c/check.h"
#include "atf-c/config.h"
#include "atf-c/defs.h"
#include "atf-c/error.h"
#include "atf-c/utils.h"

#include "detail/dynstr.h"
#include "detail/fs.h"
#include "detail/list.h"
#include "detail/process.h"
#include "detail/sanity.h"

/* ---------------------------------------------------------------------
* Auxiliary functions.
* --------------------------------------------------------------------- */

static
atf_error_t
create_tmpdir(atf_fs_path_t *dir)
{
   atf_error_t err;

   err = atf_fs_path_init_fmt(dir, "%s/check.XXXXXX",
                              atf_config_get("atf_workdir"));
   if (atf_is_error(err))
       goto out;

   err = atf_fs_mkdtemp(dir);
   if (atf_is_error(err)) {
       atf_fs_path_fini(dir);
       goto out;
   }

   INV(!atf_is_error(err));
out:
   return err;
}

static
void
cleanup_tmpdir(const atf_fs_path_t *dir, const atf_fs_path_t *outfile,
              const atf_fs_path_t *errfile)
{
   {
       atf_error_t err = atf_fs_unlink(outfile);
       if (atf_is_error(err)) {
           INV(atf_error_is(err, "libc") &&
               atf_libc_error_code(err) == ENOENT);
           atf_error_free(err);
       } else
           INV(!atf_is_error(err));
   }

   {
       atf_error_t err = atf_fs_unlink(errfile);
       if (atf_is_error(err)) {
           INV(atf_error_is(err, "libc") &&
               atf_libc_error_code(err) == ENOENT);
           atf_error_free(err);
       } else
           INV(!atf_is_error(err));
   }

   {
       atf_error_t err = atf_fs_rmdir(dir);
       INV(!atf_is_error(err));
   }
}

static
int
const_execvp(const char *file, const char *const *argv)
{
#define UNCONST(a) ((void *)(unsigned long)(const void *)(a))
   return execvp(file, UNCONST(argv));
#undef UNCONST
}

static
atf_error_t
init_sb(const atf_fs_path_t *path, atf_process_stream_t *sb)
{
   atf_error_t err;

   if (path == NULL)
       err = atf_process_stream_init_inherit(sb);
   else
       err = atf_process_stream_init_redirect_path(sb, path);

   return err;
}

static
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)
{
   atf_error_t err;

   err = init_sb(outfile, outsb);
   if (atf_is_error(err))
       goto out;

   err = init_sb(errfile, errsb);
   if (atf_is_error(err)) {
       atf_process_stream_fini(outsb);
       goto out;
   }

out:
   return err;
}

struct exec_data {
   const char *const *m_argv;
};

static void exec_child(void *) ATF_DEFS_ATTRIBUTE_NORETURN;

static
void
exec_child(void *v)
{
   struct exec_data *ea = v;

   const_execvp(ea->m_argv[0], ea->m_argv);
   fprintf(stderr, "execvp(%s) failed: %s\n", ea->m_argv[0], strerror(errno));
   exit(127);
}

static
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)
{
   atf_error_t err;
   atf_process_child_t child;
   atf_process_stream_t outsb, errsb;
   struct exec_data ea = { argv };

   err = init_sbs(outfile, &outsb, errfile, &errsb);
   if (atf_is_error(err))
       goto out;

   err = atf_process_fork(&child, exec_child, &outsb, &errsb, &ea);
   if (atf_is_error(err))
       goto out_sbs;

   err = atf_process_child_wait(&child, status);

out_sbs:
   atf_process_stream_fini(&errsb);
   atf_process_stream_fini(&outsb);
out:
   return err;
}

static
void
update_success_from_status(const char *progname,
                          const atf_process_status_t *status, bool *success)
{
   bool s = atf_process_status_exited(status) &&
            atf_process_status_exitstatus(status) == EXIT_SUCCESS;

   if (atf_process_status_exited(status)) {
       if (atf_process_status_exitstatus(status) == EXIT_SUCCESS)
           INV(s);
       else {
           INV(!s);
           fprintf(stderr, "%s failed with exit code %d\n", progname,
                   atf_process_status_exitstatus(status));
       }
   } else if (atf_process_status_signaled(status)) {
       INV(!s);
       fprintf(stderr, "%s failed due to signal %d%s\n", progname,
               atf_process_status_termsig(status),
               atf_process_status_coredump(status) ? " (core dumped)" : "");
   } else {
       INV(!s);
       fprintf(stderr, "%s failed due to unknown reason\n", progname);
   }

   *success = s;
}

static
atf_error_t
array_to_list(const char *const *a, atf_list_t *l)
{
   atf_error_t err;

   err = atf_list_init(l);
   if (atf_is_error(err))
       goto out;

   while (*a != NULL) {
       char *item = strdup(*a);
       if (item == NULL) {
           err = atf_no_memory_error();
           goto out;
       }

       err = atf_list_append(l, item, true);
       if (atf_is_error(err))
           goto out;

       a++;
   }

out:
   return err;
}

static void
print_array(const char *const *array, const char *pfx)
{
   const char *const *ptr;

   printf("%s", pfx);
   for (ptr = array; *ptr != NULL; ptr++)
       printf(" %s", *ptr);
   printf("\n");
}

static
atf_error_t
check_build_run(const char *const *argv, bool *success)
{
   atf_error_t err;
   atf_process_status_t status;

   print_array(argv, ">");

   err = fork_and_wait(argv, NULL, NULL, &status);
   if (atf_is_error(err))
       goto out;

   update_success_from_status(argv[0], &status, success);
   atf_process_status_fini(&status);

   INV(!atf_is_error(err));
out:
   return err;
}

/* ---------------------------------------------------------------------
* The "atf_check_result" type.
* --------------------------------------------------------------------- */

struct atf_check_result_impl {
   atf_list_t m_argv;
   atf_fs_path_t m_dir;
   atf_fs_path_t m_stdout;
   atf_fs_path_t m_stderr;
   atf_process_status_t m_status;
};

static
atf_error_t
atf_check_result_init(atf_check_result_t *r, const char *const *argv,
                     const atf_fs_path_t *dir)
{
   atf_error_t err;

   r->pimpl = malloc(sizeof(struct atf_check_result_impl));
   if (r->pimpl == NULL)
       return atf_no_memory_error();

   err = array_to_list(argv, &r->pimpl->m_argv);
   if (atf_is_error(err))
       goto out;

   err = atf_fs_path_copy(&r->pimpl->m_dir, dir);
   if (atf_is_error(err))
       goto err_argv;

   err = atf_fs_path_init_fmt(&r->pimpl->m_stdout, "%s/stdout",
                              atf_fs_path_cstring(dir));
   if (atf_is_error(err))
       goto err_dir;

   err = atf_fs_path_init_fmt(&r->pimpl->m_stderr, "%s/stderr",
                              atf_fs_path_cstring(dir));
   if (atf_is_error(err))
       goto err_stdout;

   INV(!atf_is_error(err));
   goto out;

err_stdout:
   atf_fs_path_fini(&r->pimpl->m_stdout);
err_dir:
   atf_fs_path_fini(&r->pimpl->m_dir);
err_argv:
   atf_list_fini(&r->pimpl->m_argv);
out:
   return err;
}

void
atf_check_result_fini(atf_check_result_t *r)
{
   atf_process_status_fini(&r->pimpl->m_status);

   cleanup_tmpdir(&r->pimpl->m_dir, &r->pimpl->m_stdout,
                  &r->pimpl->m_stderr);
   atf_fs_path_fini(&r->pimpl->m_stdout);
   atf_fs_path_fini(&r->pimpl->m_stderr);
   atf_fs_path_fini(&r->pimpl->m_dir);

   atf_list_fini(&r->pimpl->m_argv);

   free(r->pimpl);
}

const char *
atf_check_result_stdout(const atf_check_result_t *r)
{
   return atf_fs_path_cstring(&r->pimpl->m_stdout);
}

const char *
atf_check_result_stderr(const atf_check_result_t *r)
{
   return atf_fs_path_cstring(&r->pimpl->m_stderr);
}

bool
atf_check_result_exited(const atf_check_result_t *r)
{
   return atf_process_status_exited(&r->pimpl->m_status);
}

int
atf_check_result_exitcode(const atf_check_result_t *r)
{
   return atf_process_status_exitstatus(&r->pimpl->m_status);
}

bool
atf_check_result_signaled(const atf_check_result_t *r)
{
   return atf_process_status_signaled(&r->pimpl->m_status);
}

int
atf_check_result_termsig(const atf_check_result_t *r)
{
   return atf_process_status_termsig(&r->pimpl->m_status);
}

/* ---------------------------------------------------------------------
* Free functions.
* --------------------------------------------------------------------- */

/* XXX: This function shouldn't be in this module.  It messes with stdout
* and stderr, and it provides a very high-end interface.  This belongs,
* probably, somewhere related to test cases (such as in the tc module). */
atf_error_t
atf_check_build_c_o(const char *sfile,
                   const char *ofile,
                   const char *const optargs[],
                   bool *success)
{
   atf_error_t err;
   char **argv;

   err = atf_build_c_o(sfile, ofile, optargs, &argv);
   if (atf_is_error(err))
       goto out;

   err = check_build_run((const char *const *)argv, success);

   atf_utils_free_charpp(argv);
out:
   return err;
}

atf_error_t
atf_check_build_cpp(const char *sfile,
                   const char *ofile,
                   const char *const optargs[],
                   bool *success)
{
   atf_error_t err;
   char **argv;

   err = atf_build_cpp(sfile, ofile, optargs, &argv);
   if (atf_is_error(err))
       goto out;

   err = check_build_run((const char *const *)argv, success);

   atf_utils_free_charpp(argv);
out:
   return err;
}

atf_error_t
atf_check_build_cxx_o(const char *sfile,
                     const char *ofile,
                     const char *const optargs[],
                     bool *success)
{
   atf_error_t err;
   char **argv;

   err = atf_build_cxx_o(sfile, ofile, optargs, &argv);
   if (atf_is_error(err))
       goto out;

   err = check_build_run((const char *const *)argv, success);

   atf_utils_free_charpp(argv);
out:
   return err;
}

atf_error_t
atf_check_exec_array(const char *const *argv, atf_check_result_t *r)
{
   atf_error_t err;
   atf_fs_path_t dir;

   err = create_tmpdir(&dir);
   if (atf_is_error(err))
       goto out;

   err = atf_check_result_init(r, argv, &dir);
   if (atf_is_error(err)) {
       atf_error_t err2 = atf_fs_rmdir(&dir);
       INV(!atf_is_error(err2));
       goto out;
   }

   err = fork_and_wait(argv, &r->pimpl->m_stdout, &r->pimpl->m_stderr,
                       &r->pimpl->m_status);
   if (atf_is_error(err)) {
       atf_check_result_fini(r);
       goto out;
   }

   INV(!atf_is_error(err));

   atf_fs_path_fini(&dir);
out:
   return err;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.