/*-
 * Copyright (c) 2025 Klara, Inc.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <sys/poll.h>
#include <sys/wait.h>

#include <fcntl.h>
#include <signal.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

#include <atf-c.h>

#define MAILX   "mailx"
#define BODY    "hello\n"
#define BODYLEN (sizeof(BODY) - 1)

/*
 * When interactive, mailx(1) should print a message on receipt of SIGINT,
 * then exit cleanly on receipt of a second.
 *
 * When not interactive, mailx(1) should terminate on receipt of SIGINT.
 *
 * In either case, mailx(1) should terminate on receipt of SIGHUP.
 */
static void
mailx_signal_test(int signo, bool interactive)
{
        char obuf[1024] = "";
        char ebuf[1024] = "";
        struct pollfd fds[2];
        int ipd[2], opd[2], epd[2], spd[2];
        time_t start, now;
        size_t olen = 0, elen = 0;
        ssize_t rlen;
        pid_t pid;
        int kc, status;

        /* input, output, error, sync pipes */
        if (pipe(ipd) != 0 || pipe(opd) != 0 || pipe(epd) != 0 ||
            pipe(spd) != 0 || fcntl(spd[1], F_SETFD, FD_CLOEXEC) != 0)
                atf_tc_fail("failed to pipe");
        /* fork child */
        if ((pid = fork()) < 0)
                atf_tc_fail("failed to fork");
        if (pid == 0) {
                /* child */
                sigset_t set;

                /*
                 * Ensure mailx(1) will handle SIGINT; i.e., that it's not
                 * ignored or blocked.
                 */
                (void)signal(signo, SIG_DFL);
                sigemptyset(&set);
                sigaddset(&set, signo);
                ATF_REQUIRE_INTEQ(0, sigprocmask(SIG_UNBLOCK, &set, NULL));

                dup2(ipd[0], STDIN_FILENO);
                close(ipd[0]);
                close(ipd[1]);
                dup2(opd[1], STDOUT_FILENO);
                close(opd[0]);
                close(opd[1]);
                dup2(epd[1], STDERR_FILENO);
                close(epd[0]);
                close(epd[1]);
                close(spd[0]);
                /* force dead.letter to go to cwd */
                setenv("HOME", ".", 1);
                /* exec mailx */
                execlp(MAILX,
                    MAILX,
                    interactive ? "-Is" : "-s",
                    "test",
                    "test@example.com",
                    NULL);
                _exit(2);
        }
        /* parent */
        close(ipd[0]);
        close(opd[1]);
        close(epd[1]);
        close(spd[1]);
        /* block until child execs or exits */
        (void)read(spd[0], &spd[1], sizeof(spd[1]));
        /* send one line of input */
        ATF_REQUIRE_INTEQ(BODYLEN, write(ipd[1], BODY, BODYLEN));
        /* give it a chance to process */
        poll(NULL, 0, 2000);
        /* send first signal */
        ATF_CHECK_INTEQ(0, kill(pid, signo));
        kc = 1;
        /* receive output until child terminates */
        fds[0].fd = opd[0];
        fds[0].events = POLLIN;
        fds[1].fd = epd[0];
        fds[1].events = POLLIN;
        time(&start);
        for (;;) {
                ATF_REQUIRE(poll(fds, 2, 1000) >= 0);
                if (fds[0].revents == POLLIN && olen < sizeof(obuf)) {
                        rlen = read(opd[0], obuf + olen, sizeof(obuf) - olen - 1);
                        ATF_REQUIRE(rlen >= 0);
                        olen += rlen;
                }
                if (fds[1].revents == POLLIN && elen < sizeof(ebuf)) {
                        rlen = read(epd[0], ebuf + elen, sizeof(ebuf) - elen - 1);
                        ATF_REQUIRE(rlen >= 0);
                        elen += rlen;
                }
                time(&now);
                if (now - start > 1 && elen > 0 && kc == 1) {
                        ATF_CHECK_INTEQ(0, kill(pid, signo));
                        kc++;
                }
                if (now - start > 15 && kc > 0) {
                        (void)kill(pid, SIGKILL);
                        kc = -1;
                }
                if (waitpid(pid, &status, WNOHANG) == pid)
                        break;
        }
        close(ipd[1]);
        close(opd[0]);
        close(epd[0]);
        close(spd[0]);
        /*
         * In interactive mode, SIGINT results in a prompt, and a second
         * SIGINT results in exit(1).  In all other cases, we should see
         * the signal terminate the process.
         */
        if (interactive && signo == SIGINT) {
                ATF_CHECK(WIFEXITED(status));
                if (WIFEXITED(status))
                        ATF_CHECK_INTEQ(1, WEXITSTATUS(status));
                ATF_CHECK_INTEQ(2, kc);
                ATF_CHECK_STREQ("", obuf);
                ATF_CHECK_MATCH("Interrupt -- one more to kill letter", ebuf);
        } else {
                ATF_CHECK(WIFSIGNALED(status));
                if (WIFSIGNALED(status))
                        ATF_CHECK_INTEQ(signo, WTERMSIG(status));
                ATF_CHECK_INTEQ(1, kc);
                ATF_CHECK_STREQ("", obuf);
                ATF_CHECK_STREQ("", ebuf);
        }
        /*
         * In interactive mode, and only in interactive mode, mailx should
         * save whatever was typed before termination in ~/dead.letter.
         * This is why we set HOME to "." in the child.
         */
        if (interactive) {
                atf_utils_compare_file("dead.letter", BODY);
        } else {
                ATF_CHECK_INTEQ(-1, access("dead.letter", F_OK));
        }
}

ATF_TC_WITHOUT_HEAD(mailx_sighup_interactive);
ATF_TC_BODY(mailx_sighup_interactive, tc)
{
        mailx_signal_test(SIGHUP, true);
}

ATF_TC_WITHOUT_HEAD(mailx_sighup_noninteractive);
ATF_TC_BODY(mailx_sighup_noninteractive, tc)
{
        mailx_signal_test(SIGHUP, false);
}

ATF_TC_WITHOUT_HEAD(mailx_sigint_interactive);
ATF_TC_BODY(mailx_sigint_interactive, tc)
{
        mailx_signal_test(SIGINT, true);
}

ATF_TC_WITHOUT_HEAD(mailx_sigint_noninteractive);
ATF_TC_BODY(mailx_sigint_noninteractive, tc)
{
        mailx_signal_test(SIGINT, false);
}

ATF_TP_ADD_TCS(tp)
{
        ATF_TP_ADD_TC(tp, mailx_sighup_interactive);
        ATF_TP_ADD_TC(tp, mailx_sighup_noninteractive);
        ATF_TP_ADD_TC(tp, mailx_sigint_interactive);
        ATF_TP_ADD_TC(tp, mailx_sigint_noninteractive);
        return (atf_no_error());
}