/*      $OpenBSD: util.c,v 1.1 2020/09/16 14:02:23 mpi Exp $    */

/*
 * Copyright (c) 2018 Visa Hankala
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/socket.h>
#include <sys/wait.h>
#include <assert.h>
#include <errno.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "common.h"

static void
signal_handler(int signum)
{
}

void
expect_signal_impl(int signum, const char *signame, const char *file, int line)
{
        sigset_t sigmask;
        struct timespec tmo;
        int ret;

        tmo.tv_sec = 5;
        tmo.tv_nsec = 0;
        sigprocmask(0, NULL, &sigmask);
        sigdelset(&sigmask, signum);
        ret = ppoll(NULL, 0, &tmo, &sigmask);
        if (ret == 0) {
                fprintf(stderr, "%s:%d: signal %s timeout\n",
                    file, line, signame);
                _exit(1);
        }
        if (ret != -1) {
                fprintf(stderr, "%s: poll: unexpected return value: %d\n",
                    __func__, ret);
                _exit(1);
        }
}

void
reject_signal_impl(int signum, const char *signame, const char *file, int line)
{
        sigset_t sigmask;

        if (sigpending(&sigmask) != 0) {
                fprintf(stderr, "%s: sigpending: %s\n", __func__,
                    strerror(errno));
                _exit(1);
        }
        if (sigismember(&sigmask, signum)) {
                fprintf(stderr, "%s:%d: signal %s not expected\n", file, line,
                    signame);
                _exit(1);
        }
}

void
test_init(void)
{
        sigset_t mask;

        sigemptyset(&mask);
        sigaddset(&mask, SIGCHLD);
        sigaddset(&mask, SIGIO);
        sigaddset(&mask, SIGURG);
        sigprocmask(SIG_BLOCK, &mask, NULL);
        signal(SIGCHLD, signal_handler);
        signal(SIGIO, signal_handler);
        signal(SIGURG, signal_handler);

        alarm(10);
}

void
test_barrier(int sfd)
{
        char b = 0;

        assert(write(sfd, &b, 1) == 1);
        assert(read(sfd, &b, 1) == 1);
}

int
test_fork(pid_t *ppid, int *psfd)
{
        pid_t pid;
        int fds[2];

        assert(socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == 0);

        pid = fork();
        assert(pid != -1);
        *ppid = pid;
        if (pid == 0) {
                close(fds[0]);
                *psfd = fds[1];
                return CHILD;
        } else {
                close(fds[1]);
                *psfd = fds[0];
                return PARENT;
        }
}

int
test_wait(pid_t pid, int sfd)
{
        int status;

        close(sfd);
        if (pid == 0)
                _exit(0);
        assert(waitpid(pid, &status, 0) == pid);
        return 0;
}