/*
* Automated Testing Framework (atf)
*
* Copyright (c) 2007 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/types.h>
#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/defs.h"
#include "atf-c/error.h"

#include "process.h"
#include "sanity.h"

/* This prototype is not in the header file because this is a private
* function; however, we need to access it during testing. */
atf_error_t atf_process_status_init(atf_process_status_t *, int);

/* ---------------------------------------------------------------------
* The "stream_prepare" auxiliary type.
* --------------------------------------------------------------------- */

struct stream_prepare {
   const atf_process_stream_t *m_sb;

   bool m_pipefds_ok;
   int m_pipefds[2];
};
typedef struct stream_prepare stream_prepare_t;

static
atf_error_t
stream_prepare_init(stream_prepare_t *sp, const atf_process_stream_t *sb)
{
   atf_error_t err;

   const int type = atf_process_stream_type(sb);

   sp->m_sb = sb;
   sp->m_pipefds_ok = false;

   if (type == atf_process_stream_type_capture) {
       if (pipe(sp->m_pipefds) == -1)
           err = atf_libc_error(errno, "Failed to create pipe");
       else {
           err = atf_no_error();
           sp->m_pipefds_ok = true;
       }
   } else
       err = atf_no_error();

   return err;
}

static
void
stream_prepare_fini(stream_prepare_t *sp)
{
   if (sp->m_pipefds_ok) {
       close(sp->m_pipefds[0]);
       close(sp->m_pipefds[1]);
   }
}

/* ---------------------------------------------------------------------
* The "atf_process_stream" type.
* --------------------------------------------------------------------- */

const int atf_process_stream_type_capture = 1;
const int atf_process_stream_type_connect = 2;
const int atf_process_stream_type_inherit = 3;
const int atf_process_stream_type_redirect_fd = 4;
const int atf_process_stream_type_redirect_path = 5;

static
bool
stream_is_valid(const atf_process_stream_t *sb)
{
   return (sb->m_type == atf_process_stream_type_capture) ||
          (sb->m_type == atf_process_stream_type_connect) ||
          (sb->m_type == atf_process_stream_type_inherit) ||
          (sb->m_type == atf_process_stream_type_redirect_fd) ||
          (sb->m_type == atf_process_stream_type_redirect_path);
}

atf_error_t
atf_process_stream_init_capture(atf_process_stream_t *sb)
{
   sb->m_type = atf_process_stream_type_capture;

   POST(stream_is_valid(sb));
   return atf_no_error();
}

atf_error_t
atf_process_stream_init_connect(atf_process_stream_t *sb,
                               const int src_fd, const int tgt_fd)
{
   PRE(src_fd >= 0);
   PRE(tgt_fd >= 0);
   PRE(src_fd != tgt_fd);

   sb->m_type = atf_process_stream_type_connect;
   sb->m_src_fd = src_fd;
   sb->m_tgt_fd = tgt_fd;

   POST(stream_is_valid(sb));
   return atf_no_error();
}

atf_error_t
atf_process_stream_init_inherit(atf_process_stream_t *sb)
{
   sb->m_type = atf_process_stream_type_inherit;

   POST(stream_is_valid(sb));
   return atf_no_error();
}

atf_error_t
atf_process_stream_init_redirect_fd(atf_process_stream_t *sb,
                                   const int fd)
{
   sb->m_type = atf_process_stream_type_redirect_fd;
   sb->m_fd = fd;

   POST(stream_is_valid(sb));
   return atf_no_error();
}

atf_error_t
atf_process_stream_init_redirect_path(atf_process_stream_t *sb,
                                     const atf_fs_path_t *path)
{
   sb->m_type = atf_process_stream_type_redirect_path;
   sb->m_path = path;

   POST(stream_is_valid(sb));
   return atf_no_error();
}

void
atf_process_stream_fini(atf_process_stream_t *sb)
{
   PRE(stream_is_valid(sb));
}

int
atf_process_stream_type(const atf_process_stream_t *sb)
{
   PRE(stream_is_valid(sb));

   return sb->m_type;
}

/* ---------------------------------------------------------------------
* The "atf_process_status" type.
* --------------------------------------------------------------------- */

atf_error_t
atf_process_status_init(atf_process_status_t *s, int status)
{
   s->m_status = status;

   return atf_no_error();
}

void
atf_process_status_fini(atf_process_status_t *s ATF_DEFS_ATTRIBUTE_UNUSED)
{
}

bool
atf_process_status_exited(const atf_process_status_t *s)
{
   int mutable_status = s->m_status;
   return WIFEXITED(mutable_status);
}

int
atf_process_status_exitstatus(const atf_process_status_t *s)
{
   PRE(atf_process_status_exited(s));
   int mutable_status = s->m_status;
   return WEXITSTATUS(mutable_status);
}

bool
atf_process_status_signaled(const atf_process_status_t *s)
{
   int mutable_status = s->m_status;
   return WIFSIGNALED(mutable_status);
}

int
atf_process_status_termsig(const atf_process_status_t *s)
{
   PRE(atf_process_status_signaled(s));
   int mutable_status = s->m_status;
   return WTERMSIG(mutable_status);
}

bool
atf_process_status_coredump(const atf_process_status_t *s)
{
   PRE(atf_process_status_signaled(s));
#if defined(WCOREDUMP)
   int mutable_status = s->m_status;
   return WCOREDUMP(mutable_status);
#else
   return false;
#endif
}

/* ---------------------------------------------------------------------
* The "atf_process_child" type.
* --------------------------------------------------------------------- */

static
atf_error_t
atf_process_child_init(atf_process_child_t *c)
{
   c->m_pid = 0;
   c->m_stdout = -1;
   c->m_stderr = -1;

   return atf_no_error();
}

static
void
atf_process_child_fini(atf_process_child_t *c)
{
   if (c->m_stdout != -1)
       close(c->m_stdout);
   if (c->m_stderr != -1)
       close(c->m_stderr);
}

atf_error_t
atf_process_child_wait(atf_process_child_t *c, atf_process_status_t *s)
{
   atf_error_t err;
   int status;

   if (waitpid(c->m_pid, &status, 0) == -1)
       err = atf_libc_error(errno, "Failed waiting for process %d",
                            c->m_pid);
   else {
       atf_process_child_fini(c);
       err = atf_process_status_init(s, status);
   }

   return err;
}

pid_t
atf_process_child_pid(const atf_process_child_t *c)
{
   return c->m_pid;
}

int
atf_process_child_stdout(atf_process_child_t *c)
{
   PRE(c->m_stdout != -1);
   return c->m_stdout;
}

int
atf_process_child_stderr(atf_process_child_t *c)
{
   PRE(c->m_stderr != -1);
   return c->m_stderr;
}

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

static
atf_error_t
safe_dup(const int oldfd, const int newfd)
{
   atf_error_t err;

   if (oldfd != newfd) {
       if (dup2(oldfd, newfd) == -1) {
           err = atf_libc_error(errno, "Could not allocate file descriptor");
       } else {
           close(oldfd);
           err = atf_no_error();
       }
   } else
       err = atf_no_error();

   return err;
}

static
atf_error_t
child_connect(const stream_prepare_t *sp, int procfd)
{
   atf_error_t err;
   const int type = atf_process_stream_type(sp->m_sb);

   if (type == atf_process_stream_type_capture) {
       close(sp->m_pipefds[0]);
       err = safe_dup(sp->m_pipefds[1], procfd);
   } else if (type == atf_process_stream_type_connect) {
       if (dup2(sp->m_sb->m_tgt_fd, sp->m_sb->m_src_fd) == -1)
           err = atf_libc_error(errno, "Cannot connect descriptor %d to %d",
                                sp->m_sb->m_tgt_fd, sp->m_sb->m_src_fd);
       else
           err = atf_no_error();
   } else if (type == atf_process_stream_type_inherit) {
       err = atf_no_error();
   } else if (type == atf_process_stream_type_redirect_fd) {
       err = safe_dup(sp->m_sb->m_fd, procfd);
   } else if (type == atf_process_stream_type_redirect_path) {
       int aux = open(atf_fs_path_cstring(sp->m_sb->m_path),
                      O_WRONLY | O_CREAT | O_TRUNC, 0644);
       if (aux == -1)
           err = atf_libc_error(errno, "Could not create %s",
                                atf_fs_path_cstring(sp->m_sb->m_path));
       else {
           err = safe_dup(aux, procfd);
           if (atf_is_error(err))
               close(aux);
       }
   } else {
       UNREACHABLE;
       err = atf_no_error();
   }

   return err;
}

static
void
parent_connect(const stream_prepare_t *sp, int *fd)
{
   const int type = atf_process_stream_type(sp->m_sb);

   if (type == atf_process_stream_type_capture) {
       close(sp->m_pipefds[1]);
       *fd = sp->m_pipefds[0];
   } else if (type == atf_process_stream_type_connect) {
       /* Do nothing. */
   } else if (type == atf_process_stream_type_inherit) {
       /* Do nothing. */
   } else if (type == atf_process_stream_type_redirect_fd) {
       /* Do nothing. */
   } else if (type == atf_process_stream_type_redirect_path) {
       /* Do nothing. */
   } else {
       UNREACHABLE;
   }
}

static
atf_error_t
do_parent(atf_process_child_t *c,
         const pid_t pid,
         const stream_prepare_t *outsp,
         const stream_prepare_t *errsp)
{
   atf_error_t err;

   err = atf_process_child_init(c);
   if (atf_is_error(err))
       goto out;

   c->m_pid = pid;

   parent_connect(outsp, &c->m_stdout);
   parent_connect(errsp, &c->m_stderr);

out:
   return err;
}

static
void
do_child(void (*)(void *),
        void *,
        const stream_prepare_t *,
        const stream_prepare_t *) ATF_DEFS_ATTRIBUTE_NORETURN;

static
void
do_child(void (*start)(void *),
        void *v,
        const stream_prepare_t *outsp,
        const stream_prepare_t *errsp)
{
   atf_error_t err;

   err = child_connect(outsp, STDOUT_FILENO);
   if (atf_is_error(err))
       goto out;

   err = child_connect(errsp, STDERR_FILENO);
   if (atf_is_error(err))
       goto out;

   start(v);
   UNREACHABLE;

out:
   if (atf_is_error(err)) {
       char buf[1024];

       atf_error_format(err, buf, sizeof(buf));
       fprintf(stderr, "Unhandled error: %s\n", buf);
       atf_error_free(err);

       exit(EXIT_FAILURE);
   } else
       exit(EXIT_SUCCESS);
}

static
atf_error_t
fork_with_streams(atf_process_child_t *c,
                 void (*start)(void *),
                 const atf_process_stream_t *outsb,
                 const atf_process_stream_t *errsb,
                 void *v)
{
   atf_error_t err;
   stream_prepare_t outsp;
   stream_prepare_t errsp;
   pid_t pid;

   err = stream_prepare_init(&outsp, outsb);
   if (atf_is_error(err))
       goto out;

   err = stream_prepare_init(&errsp, errsb);
   if (atf_is_error(err))
       goto err_outpipe;

   pid = fork();
   if (pid == -1) {
       err = atf_libc_error(errno, "Failed to fork");
       goto err_errpipe;
   }

   if (pid == 0) {
       do_child(start, v, &outsp, &errsp);
       UNREACHABLE;
       abort();
       err = atf_no_error();
   } else {
       err = do_parent(c, pid, &outsp, &errsp);
       if (atf_is_error(err))
           goto err_errpipe;
   }

   goto out;

err_errpipe:
   stream_prepare_fini(&errsp);
err_outpipe:
   stream_prepare_fini(&outsp);

out:
   return err;
}

static
atf_error_t
init_stream_w_default(const atf_process_stream_t *usersb,
                     atf_process_stream_t *inheritsb,
                     const atf_process_stream_t **realsb)
{
   atf_error_t err;

   if (usersb == NULL) {
       err = atf_process_stream_init_inherit(inheritsb);
       if (!atf_is_error(err))
           *realsb = inheritsb;
   } else {
       err = atf_no_error();
       *realsb = usersb;
   }

   return err;
}

atf_error_t
atf_process_fork(atf_process_child_t *c,
                void (*start)(void *),
                const atf_process_stream_t *outsb,
                const atf_process_stream_t *errsb,
                void *v)
{
   atf_error_t err;
   atf_process_stream_t inherit_outsb, inherit_errsb;
   const atf_process_stream_t *real_outsb, *real_errsb;

   real_outsb = NULL;  /* Shut up GCC warning. */
   err = init_stream_w_default(outsb, &inherit_outsb, &real_outsb);
   if (atf_is_error(err))
       goto out;

   real_errsb = NULL;  /* Shut up GCC warning. */
   err = init_stream_w_default(errsb, &inherit_errsb, &real_errsb);
   if (atf_is_error(err))
       goto out_out;

   err = fork_with_streams(c, start, real_outsb, real_errsb, v);

   if (errsb == NULL)
       atf_process_stream_fini(&inherit_errsb);
out_out:
   if (outsb == NULL)
       atf_process_stream_fini(&inherit_outsb);
out:
   return 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
list_to_array(const atf_list_t *l, const char ***ap)
{
   atf_error_t err;
   const char **a;

   a = (const char **)malloc((atf_list_size(l) + 1) * sizeof(const char *));
   if (a == NULL)
       err = atf_no_memory_error();
   else {
       const char **aiter;
       atf_list_citer_t liter;

       aiter = a;
       atf_list_for_each_c(liter, l) {
           *aiter = (const char *)atf_list_citer_data(liter);
           aiter++;
       }
       *aiter = NULL;

       err = atf_no_error();
       *ap = a;
   }

   return err;
}

struct exec_args {
   const atf_fs_path_t *m_prog;
   const char *const *m_argv;
   void (*m_prehook)(void);
};

static
void
do_exec(void *v)
{
   struct exec_args *ea = v;

   if (ea->m_prehook != NULL)
       ea->m_prehook();

   const int ret = const_execvp(atf_fs_path_cstring(ea->m_prog), ea->m_argv);
   const int errnocopy = errno;
   INV(ret == -1);
   fprintf(stderr, "exec(%s) failed: %s\n",
           atf_fs_path_cstring(ea->m_prog), strerror(errnocopy));
   exit(EXIT_FAILURE);
}

atf_error_t
atf_process_exec_array(atf_process_status_t *s,
                      const atf_fs_path_t *prog,
                      const char *const *argv,
                      const atf_process_stream_t *outsb,
                      const atf_process_stream_t *errsb,
                      void (*prehook)(void))
{
   atf_error_t err;
   atf_process_child_t c;
   struct exec_args ea = { prog, argv, prehook };

   PRE(outsb == NULL ||
       atf_process_stream_type(outsb) != atf_process_stream_type_capture);
   PRE(errsb == NULL ||
       atf_process_stream_type(errsb) != atf_process_stream_type_capture);

   err = atf_process_fork(&c, do_exec, outsb, errsb, &ea);
   if (atf_is_error(err))
       goto out;

again:
   err = atf_process_child_wait(&c, s);
   if (atf_is_error(err)) {
       INV(atf_error_is(err, "libc") && atf_libc_error_code(err) == EINTR);
       atf_error_free(err);
       goto again;
   }

out:
   return err;
}

atf_error_t
atf_process_exec_list(atf_process_status_t *s,
                     const atf_fs_path_t *prog,
                     const atf_list_t *argv,
                     const atf_process_stream_t *outsb,
                     const atf_process_stream_t *errsb,
                     void (*prehook)(void))
{
   atf_error_t err;
   const char **argv2;

   PRE(outsb == NULL ||
       atf_process_stream_type(outsb) != atf_process_stream_type_capture);
   PRE(errsb == NULL ||
       atf_process_stream_type(errsb) != atf_process_stream_type_capture);

   argv2 = NULL; /* Silence GCC warning. */
   err = list_to_array(argv, &argv2);
   if (atf_is_error(err))
       goto out;

   err = atf_process_exec_array(s, prog, argv2, outsb, errsb, prehook);

   free(argv2);
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.