#include <sys/poll.h>
#include <sys/socket.h>
#include <sys/stat.h>

#include <err.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define FIFONAME        "fifo.tmp"
#define FT_END          3
#define FT_FIFO         2
#define FT_PIPE         0
#define FT_SOCKETPAIR   1

static int filetype;

static const char *
decode_events(int events)
{
        char *ncresult;
        const char *result;

        switch (events) {
        case POLLIN:
                result = "POLLIN";
                break;
        case POLLHUP:
                result = "POLLHUP";
                break;
        case POLLIN | POLLHUP:
                result = "POLLIN | POLLHUP";
                break;
        default:
                asprintf(&ncresult, "%#x", events);
                result = ncresult;
                break;
        }
        return (result);
}

static void
report_state(const char *state)
{

        printf(" %s state %s: ",
            filetype == FT_PIPE ? "Pipe" :
            filetype == FT_SOCKETPAIR ? "Sock" : "FIFO",
            state);
}

static void
report(int num, const char *state, int expected, int got, int res,
    int res_expected)
{

        if (res != res_expected) {
                printf("not ok %-2d", num);
                report_state(state);
                printf("poll result %d expected %d. ",
                    res, res_expected);
        } else {
                if (expected == got)
                        printf("ok %-2d    ", num);
                else
                        printf("not ok %-2d", num);
                report_state(state);
        }
        printf("expected %s; got %s\n", decode_events(expected),
            decode_events(got));
        fflush(stdout);
}

static pid_t cpid;
static pid_t ppid;
static volatile sig_atomic_t state;

static void
catch(int sig __unused)
{

        state++;
}

static void
child(int fd, int num)
{
        struct pollfd pfd;
        int fd2, res;
        char buf[256];

        if (filetype == FT_FIFO) {
                fd = open(FIFONAME, O_RDONLY | O_NONBLOCK);
                if (fd < 0)
                        err(1, "open for read");
        }
        pfd.fd = fd;
        pfd.events = POLLIN;

        if (filetype == FT_FIFO) {
                if ((res = poll(&pfd, 1, 0)) < 0)
                        err(1, "poll");
                report(num++, "0", 0, pfd.revents, res, 0);
        }
        kill(ppid, SIGUSR1);

        usleep(1);
        while (state != 1)
                ;
        if (filetype != FT_FIFO) {
                /*
                 * The connection cannot be reestablished.  Use the code that
                 * delays the read until after the writer disconnects since
                 * that case is more interesting.
                 */
                state = 4;
                goto state4;
        }
        if ((res = poll(&pfd, 1, 0)) < 0)
                err(1, "poll");
        report(num++, "1", 0, pfd.revents, res, 0);
        kill(ppid, SIGUSR1);

        usleep(1);
        while (state != 2)
                ;
        if ((res = poll(&pfd, 1, 0)) < 0)
                err(1, "poll");
        report(num++, "2", POLLIN, pfd.revents, res, 1);
        if (read(fd, buf, sizeof buf) != 1)
                err(1, "read");
        if ((res = poll(&pfd, 1, 0)) < 0)
                err(1, "poll");
        report(num++, "2a", 0, pfd.revents, res, 0);
        kill(ppid, SIGUSR1);

        usleep(1);
        while (state != 3)
                ;
        if ((res = poll(&pfd, 1, 0)) < 0)
                err(1, "poll");
        report(num++, "3", POLLHUP, pfd.revents, res, 1);
        kill(ppid, SIGUSR1);

        /*
         * Now we expect a new writer, and a new connection too since
         * we read all the data.  The only new point is that we didn't
         * start quite from scratch since the read fd is not new.  Check
         * startup state as above, but don't do the read as above.
         */
        usleep(1);
        while (state != 4)
                ;
state4:
        if ((res = poll(&pfd, 1, 0)) < 0)
                err(1, "poll");
        report(num++, "4", 0, pfd.revents, res, 0);
        kill(ppid, SIGUSR1);

        usleep(1);
        while (state != 5)
                ;
        if ((res = poll(&pfd, 1, 0)) < 0)
                err(1, "poll");
        report(num++, "5", POLLIN, pfd.revents, res, 1);
        kill(ppid, SIGUSR1);

        usleep(1);
        while (state != 6)
                ;
        /*
         * Now we have no writer, but should still have data from the old
         * writer.  Check that we have both a data-readable condition and a
         * hangup condition, and that the data can be read in the usual way.
         * Since Linux does this, programs must not quit reading when they
         * see POLLHUP; they must see POLLHUP without POLLIN (or another
         * input condition) before they decide that there is EOF.  gdb-6.1.1
         * is an example of a broken program that quits on POLLHUP only --
         * see its event-loop.c.
         */
        if ((res = poll(&pfd, 1, 0)) < 0)
                err(1, "poll");
        report(num++, "6", POLLIN | POLLHUP, pfd.revents, res, 1);
        if (read(fd, buf, sizeof buf) != 1)
                err(1, "read");
        if ((res = poll(&pfd, 1, 0)) < 0)
                err(1, "poll");
        report(num++, "6a", POLLHUP, pfd.revents, res, 1);
        if (filetype == FT_FIFO) {
                /*
                 * Check that POLLHUP is sticky for a new reader and for
                 * the old reader.
                 */
                fd2 = open(FIFONAME, O_RDONLY | O_NONBLOCK);
                if (fd2 < 0)
                        err(1, "open for read");
                pfd.fd = fd2;
                if ((res = poll(&pfd, 1, 0)) < 0)
                        err(1, "poll");
                report(num++, "6b", POLLHUP, pfd.revents, res, 1);
                pfd.fd = fd;
                if ((res = poll(&pfd, 1, 0)) < 0)
                        err(1, "poll");
                report(num++, "6c", POLLHUP, pfd.revents, res, 1);
                close(fd2);
                if ((res = poll(&pfd, 1, 0)) < 0)
                        err(1, "poll");
                report(num++, "6d", POLLHUP, pfd.revents, res, 1);
        }
        close(fd);
        kill(ppid, SIGUSR1);

        exit(0);
}

static void
parent(int fd)
{
        usleep(1);
        while (state != 1)
                ;
        if (filetype == FT_FIFO) {
                fd = open(FIFONAME, O_WRONLY | O_NONBLOCK);
                if (fd < 0)
                        err(1, "open for write");
        }
        kill(cpid, SIGUSR1);

        usleep(1);
        while (state != 2)
                ;
        if (write(fd, "", 1) != 1)
                err(1, "write");
        kill(cpid, SIGUSR1);

        usleep(1);
        while (state != 3)
                ;
        if (close(fd) != 0)
                err(1, "close for write");
        kill(cpid, SIGUSR1);

        usleep(1);
        while (state != 4)
                ;
        if (filetype != FT_FIFO)
                return;
        fd = open(FIFONAME, O_WRONLY | O_NONBLOCK);
        if (fd < 0)
                err(1, "open for write");
        kill(cpid, SIGUSR1);

        usleep(1);
        while (state != 5)
                ;
        if (write(fd, "", 1) != 1)
                err(1, "write");
        kill(cpid, SIGUSR1);

        usleep(1);
        while (state != 6)
                ;
        if (close(fd) != 0)
                err(1, "close for write");
        kill(cpid, SIGUSR1);

        usleep(1);
        while (state != 7)
                ;
}

int
main(void)
{
        int fd[2], num;

        num = 1;
        printf("1..20\n");
        fflush(stdout);
        signal(SIGUSR1, catch);
        ppid = getpid();
        for (filetype = 0; filetype < FT_END; filetype++) {
                switch (filetype) {
                case FT_FIFO:
                        if (mkfifo(FIFONAME, 0666) != 0)
                                err(1, "mkfifo");
                        fd[0] = -1;
                        fd[1] = -1;
                        break;
                case FT_SOCKETPAIR:
                        if (socketpair(AF_UNIX, SOCK_STREAM, AF_UNSPEC,
                            fd) != 0)
                                err(1, "socketpair");
                        break;
                case FT_PIPE:
                        if (pipe(fd) != 0)
                                err(1, "pipe");
                        break;
                }
                state = 0;
                switch (cpid = fork()) {
                case -1:
                        err(1, "fork");
                case 0:
                        (void)close(fd[1]);
                        child(fd[0], num);
                        break;
                default:
                        (void)close(fd[0]);
                        parent(fd[1]);
                        break;
                }
                num += filetype == FT_FIFO ? 12 : 4;
        }
        (void)unlink(FIFONAME);
        return (0);
}