/*      $OpenBSD: select_iocond.c,v 1.3 2021/12/27 16:38:06 visa Exp $  */

/*
 * Copyright (c) 2021 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.
 */

/*
 * Test select(2) with various I/O conditions.
 */

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>

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

#if defined(__OpenBSD__)
/* for pty */
#include <termios.h>
#include <util.h>
#endif

#if !defined(__linux__)
#define HAVE_SOCKADDR_LEN 1
#endif

#define MIN(a, b) ((a) <= (b) ? (a) : (b))

#define TEST_FIFO_NAME "iocond_fifo"

enum filetype {
        FTYPE_NONE,
        FTYPE_FIFO,
        FTYPE_PIPE,
        FTYPE_PTY,
        FTYPE_SOCKET_TCP,
        FTYPE_SOCKET_UDP,
        FTYPE_SOCKET_UNIX,
};

static struct {
        const char              *name;
        enum filetype            type;
} filetypes[] = {
        { "fifo",               FTYPE_FIFO },
        { "pipe",               FTYPE_PIPE },
#if defined(__OpenBSD__)
        { "pty",                FTYPE_PTY },
#endif
        { "socket-tcp",         FTYPE_SOCKET_TCP },
        { "socket-udp",         FTYPE_SOCKET_UDP },
        { "socket-unix",        FTYPE_SOCKET_UNIX },
};

static enum filetype filetype = FTYPE_NONE;

static void cleanup(void);
static void proc_barrier(int);
static void proc_child(int, int);
static void proc_parent(int, int);

int
main(int argc, char *argv[])
{
        const char *ftname;
        int bfd[2], fds[2];
        int child_fd = -1;
        int parent_fd = -1;
        int sock = -1;
        unsigned int i;
        pid_t pid;

        /* Enforce test timeout. */
        alarm(10);

        if (argc != 2) {
                fprintf(stderr, "usage: %s filetype\n", argv[0]);
                return 1;
        }
        ftname = argv[1];

        for (i = 0; i < sizeof(filetypes) / sizeof(filetypes[0]); i++) {
                if (strcmp(ftname, filetypes[i].name) == 0) {
                        filetype = filetypes[i].type;
                        break;
                }
        }
        if (filetype == FTYPE_NONE)
                errx(1, "unknown filetype");

        /* Open barrier sockets. */
        if (socketpair(AF_UNIX, SOCK_STREAM, 0, bfd) == -1)
                err(1, "socketpair");

        atexit(cleanup);

        switch (filetype) {
        case FTYPE_FIFO:
                (void)unlink(TEST_FIFO_NAME);
                if (mkfifo(TEST_FIFO_NAME, 0644) == -1)
                        err(1, "mkfifo");
                break;
        case FTYPE_PIPE:
                if (pipe(fds) == -1)
                        err(1, "pipe");
                parent_fd = fds[0];
                child_fd = fds[1];
                break;
#if defined(__OpenBSD__)
        case FTYPE_PTY:
                if (openpty(&parent_fd, &child_fd, NULL, NULL, NULL) == -1)
                        err(1, "openpty");
                break;
#endif
        case FTYPE_SOCKET_TCP: {
                struct sockaddr_in inaddr;

                sock = socket(AF_INET, SOCK_STREAM, 0);

                memset(&inaddr, 0, sizeof(inaddr));
#ifdef HAVE_SOCKADDR_LEN
                inaddr.sin_len = sizeof(inaddr);
#endif
                inaddr.sin_family = AF_INET;
                inaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
                if (bind(sock, (struct sockaddr *)&inaddr,
                    sizeof(inaddr)) == -1)
                        err(1, "bind");
                if (listen(sock, 1) == -1)
                        err(1, "listen");
                break;
            }
        case FTYPE_SOCKET_UDP: {
                struct sockaddr_in inaddr;

                sock = socket(AF_INET, SOCK_DGRAM, 0);

                memset(&inaddr, 0, sizeof(inaddr));
#ifdef HAVE_SOCKADDR_LEN
                inaddr.sin_len = sizeof(inaddr);
#endif
                inaddr.sin_family = AF_INET;
                inaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
                if (bind(sock, (struct sockaddr *)&inaddr,
                    sizeof(inaddr)) == -1)
                        err(1, "bind");
                break;
            }
        case FTYPE_SOCKET_UNIX:
                if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1)
                        err(1, "socketpair");
                parent_fd = fds[0];
                child_fd = fds[1];
                break;
        default:
                errx(1, "unhandled filetype");
        }

        pid = fork();
        switch (pid) {
        case -1:
                err(1, "fork");
        case 0:
                switch (filetype) {
                case FTYPE_FIFO:
                        child_fd = open(TEST_FIFO_NAME, O_WRONLY);
                        if (child_fd == -1)
                                err(1, "child: open");
                        break;
                case FTYPE_SOCKET_TCP: {
                        struct sockaddr_in inaddr;
                        socklen_t inaddrlen;
                        int on = 1;

                        /* Get the bound address. */
                        inaddrlen = sizeof(inaddr);
                        if (getsockname(sock, (struct sockaddr *)&inaddr,
                            &inaddrlen) == -1)
                                err(1, "child: getsockname");

                        child_fd = socket(AF_INET, SOCK_STREAM, 0);
                        if (child_fd == -1)
                                err(1, "child: socket");
                        if (connect(child_fd, (struct sockaddr *)&inaddr,
                            sizeof(inaddr)) == -1)
                                err(1, "child: connect");
                        if (setsockopt(child_fd, IPPROTO_TCP, TCP_NODELAY,
                            &on, sizeof(on)) == -1)
                                err(1, "child: setsockopt(TCP_NODELAY)");
                        break;
                    }
                case FTYPE_SOCKET_UDP: {
                        struct sockaddr_in inaddr;
                        socklen_t inaddrlen;

                        /* Get the bound address. */
                        inaddrlen = sizeof(inaddr);
                        if (getsockname(sock, (struct sockaddr *)&inaddr,
                            &inaddrlen) == -1)
                                err(1, "child: getsockname");

                        child_fd = socket(AF_INET, SOCK_DGRAM, 0);
                        if (child_fd == -1)
                                err(1, "child: socket");
                        if (connect(child_fd, (struct sockaddr *)&inaddr,
                            sizeof(inaddr)) == -1)
                                err(1, "child: connect");
                        break;
                    }
                default:
                        break;
                }
                if (parent_fd != -1) {
                        close(parent_fd);
                        parent_fd = -1;
                }
                if (sock != -1) {
                        close(sock);
                        sock = -1;
                }
                proc_child(child_fd, bfd[1]);
                _exit(0);
        default:
                switch (filetype) {
                case FTYPE_FIFO:
                        parent_fd = open(TEST_FIFO_NAME, O_RDONLY);
                        if (parent_fd == -1)
                                err(1, "parent: open");
                        break;
                case FTYPE_SOCKET_TCP: {
                        int on = 1;

                        parent_fd = accept(sock, NULL, NULL);
                        if (parent_fd == -1)
                                err(1, "parent: accept");
                        if (setsockopt(parent_fd, IPPROTO_TCP, TCP_NODELAY,
                            &on, sizeof(on)) == -1)
                                err(1, "parent: setsockopt(TCP_NODELAY)");
                        break;
                    }
                case FTYPE_SOCKET_UDP:
                        parent_fd = sock;
                        sock = -1;
                        break;
                default:
                        break;
                }
                if (child_fd != -1) {
                        close(child_fd);
                        child_fd = -1;
                }
                if (sock != -1) {
                        close(sock);
                        sock = -1;
                }
                proc_parent(parent_fd, bfd[0]);
                break;
        }

        if (waitpid(pid, NULL, 0) == -1)
                err(1, "waitpid");

        return 0;
}

static void
cleanup(void)
{
        if (filetype == FTYPE_FIFO)
                (void)unlink(TEST_FIFO_NAME);
}

static void
proc_barrier(int fd)
{
        int ret;
        char b = 0;

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

static void
fdset_init(fd_set *rfd, fd_set *wfd, fd_set *efd, int fd)
{
        FD_ZERO(rfd);
        FD_ZERO(wfd);
        FD_ZERO(efd);
        FD_SET(fd, rfd);
        FD_SET(fd, wfd);
        FD_SET(fd, efd);
}

static void
proc_child(int fd, int bfd)
{
        char buf[1024];
        fd_set efd, rfd, wfd;
        struct timeval tv = { 0, 1 };
        struct timeval zerotv = { 0, 0 };
        size_t nbytes;
        int ret;
        char b = 0;

        proc_barrier(bfd);

        fdset_init(&rfd, &wfd, &efd, fd);
        ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
        assert(ret == 1);
        assert(FD_ISSET(fd, &rfd) == 0);
        assert(FD_ISSET(fd, &wfd) != 0);
        assert(FD_ISSET(fd, &efd) == 0);

        proc_barrier(bfd);

        ret = write(fd, &b, 1);
        assert(ret == 1);

        proc_barrier(bfd);

        fdset_init(&rfd, &wfd, &efd, fd);
        ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
        assert(ret == 1);
        assert(FD_ISSET(fd, &rfd) == 0);
        assert(FD_ISSET(fd, &wfd) != 0);
        assert(FD_ISSET(fd, &efd) == 0);

        proc_barrier(bfd);

        /* parent: read */

        proc_barrier(bfd);

        if (filetype != FTYPE_SOCKET_UDP) {
                /* write until full */
                memset(buf, 0, sizeof(buf));
                nbytes = 0;
                for (;;) {
                        FD_ZERO(&wfd);
                        FD_SET(fd, &wfd);
                        ret = select(fd + 1, NULL, &wfd, NULL, &zerotv);
                        if (ret == 0)
                                break;
                        assert(ret == 1);
                        assert(FD_ISSET(fd, &wfd) != 0);
                        ret = write(fd, buf, sizeof(buf));
                        assert(ret > 0);
                        nbytes += ret;
                }
                ret = write(bfd, &nbytes, sizeof(nbytes));
                assert(ret == sizeof(nbytes));

                proc_barrier(bfd);

                /* parent: read until empty */
        }

        proc_barrier(bfd);

        /* Test out-of-band data. */
        switch (filetype) {
#if defined(__OpenBSD__)
        case FTYPE_PTY: {
                /* parent: enable user ioctl command mode */

                proc_barrier(bfd);

                ret = write(fd, &b, 1);
                assert(ret == 1);

                if (ioctl(fd, UIOCCMD(42), NULL) == -1)
                        err(1, "child: ioctl(UIOCCMD)");

                ret = write(fd, &b, 1);
                assert(ret == 1);

                proc_barrier(bfd);

                /* parent: read, and disable user ioctl command mode */

                proc_barrier(bfd);
                break;
            }
#endif /* __OpenBSD__ */

        case FTYPE_SOCKET_TCP:
                ret = send(fd, &b, 1, 0);
                assert(ret == 1);

                ret = send(fd, &b, 1, MSG_OOB);
                assert(ret == 1);

                ret = send(fd, &b, 1, 0);
                assert(ret == 1);

                proc_barrier(bfd);

                /* parent: read */

                proc_barrier(bfd);
                break;

        default:
                break;
        }

        /* Test socket shutdown. */
        switch (filetype) {
        case FTYPE_SOCKET_TCP:
        case FTYPE_SOCKET_UNIX:
                ret = write(fd, &b, 1);
                assert(ret == 1);

                ret = shutdown(fd, SHUT_WR);
                assert(ret == 0);

                proc_barrier(bfd);

                /* parent: read and shutdown */

                proc_barrier(bfd);

                /* Let inet sockets take their time. */
                if (filetype == FTYPE_SOCKET_TCP)
                        usleep(10000);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 2);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;

        case FTYPE_FIFO:
        case FTYPE_PIPE:
        case FTYPE_PTY:
        case FTYPE_SOCKET_UDP:
        default:
                break;
        }

        proc_barrier(bfd);

        close(fd);

        proc_barrier(bfd);

        fdset_init(&rfd, &wfd, &efd, fd);
        ret = select(fd + 1, &rfd, &wfd, &efd, NULL);
        assert(ret == -1);
        assert(errno == EBADF);
}

static void
proc_parent(int fd, int bfd)
{
        char buf[1024];
        fd_set efd, rfd, wfd;
        struct timeval tv = { 0, 1 };
        struct timeval zerotv = { 0, 0 };
        size_t nbytes;
        int ret, retries;
        char b = 0;

        proc_barrier(bfd);

        fdset_init(&rfd, &wfd, &efd, fd);
        if (filetype == FTYPE_FIFO || filetype == FTYPE_PIPE)
                FD_CLR(fd, &wfd);
        ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
        switch (filetype) {
        case FTYPE_FIFO:
        case FTYPE_PIPE:
                assert(ret == 0);
                assert(FD_ISSET(fd, &rfd) == 0);
                assert(FD_ISSET(fd, &wfd) == 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;
        default:
                assert(ret == 1);
                assert(FD_ISSET(fd, &rfd) == 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;
        }

        proc_barrier(bfd);

        /* child: write */

        proc_barrier(bfd);

        /* Let inet sockets take their time. */
        if (filetype == FTYPE_SOCKET_TCP ||
            filetype == FTYPE_SOCKET_UDP)
                usleep(10000);

        fdset_init(&rfd, &wfd, &efd, fd);
        if (filetype == FTYPE_FIFO || filetype == FTYPE_PIPE)
                FD_CLR(fd, &wfd);
        ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
        switch (filetype) {
        case FTYPE_FIFO:
        case FTYPE_PIPE:
                assert(ret == 1);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) == 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;
        case FTYPE_PTY:
        case FTYPE_SOCKET_TCP:
        case FTYPE_SOCKET_UDP:
        case FTYPE_SOCKET_UNIX:
                assert(ret == 2);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;
        default:
                assert(0);
        }

        proc_barrier(bfd);

        ret = read(fd, &b, 1);
        assert(ret == 1);

        fdset_init(&rfd, &wfd, &efd, fd);
        ret = select(fd + 1, &rfd, NULL, NULL, &tv);
        assert(ret == 0);

        proc_barrier(bfd);

        if (filetype != FTYPE_SOCKET_UDP) {
                /* child: write until full */
                nbytes = 0;
                ret = read(bfd, &nbytes, sizeof(nbytes));
                assert(ret == sizeof(nbytes));

                proc_barrier(bfd);

                /* read until empty */
                retries = 5;
                while (retries > 0) {
                        FD_ZERO(&rfd);
                        FD_SET(fd, &rfd);
                        ret = select(fd + 1, &rfd, NULL, NULL, &zerotv);
                        if (ret == 0) {
                                retries--;
                                /* Let inet sockets take their time. */
                                if (nbytes > 0 && retries > 0)
                                        usleep(10000);
                                continue;
                        }
                        assert(ret == 1);
                        assert(FD_ISSET(fd, &rfd) != 0);
                        assert(nbytes > 0);
                        ret = read(fd, buf, MIN(sizeof(buf), nbytes));
                        assert(ret > 0);
                        nbytes -= ret;
                }
                assert(nbytes == 0);
        }

        proc_barrier(bfd);

        /* Test out-of-band data. */
        switch (filetype) {
#if defined(__OpenBSD__)
        case FTYPE_PTY: {
                int off = 0;
                int on = 1;

                if (ioctl(fd, TIOCUCNTL, &on) == -1)
                        err(1, "parent: ioctl(TIOCUCNTL, 1)");

                proc_barrier(bfd);

                /* child: write */

                proc_barrier(bfd);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 3);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) != 0);

                /* Read out-of-band data. */
                ret = read(fd, buf, sizeof(buf));
                assert(ret == 1);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 2);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);

                /* Read normal data. */
                ret = read(fd, buf, sizeof(buf));
                assert(ret == 3);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 1);
                assert(FD_ISSET(fd, &rfd) == 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);

                if (ioctl(fd, TIOCUCNTL, &off) == -1)
                        err(1, "parent: ioctl(TIOCUCNTL, 0)");

                proc_barrier(bfd);
                break;
            }
#endif /* __OpenBSD__ */

        case FTYPE_SOCKET_TCP: {
                int atmark;
                int on = 1;

                /* child: write */

                if (setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &on,
                    sizeof(on)) == -1)
                        err(1, "parent: setsockopt(SO_OOBINLINE)");

                proc_barrier(bfd);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 3);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) != 0);

                /* Read normal data. */
                atmark = 0;
                if (ioctl(fd, SIOCATMARK, &atmark) == -1)
                        err(1, "parent: ioctl(SIOCATMARK)");
                assert(atmark == 0);
                ret = recv(fd, buf, sizeof(buf), 0);
                assert(ret == 1);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 3);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) != 0);

                /* Read out-of-band data. */
                atmark = 0;
                if (ioctl(fd, SIOCATMARK, &atmark) == -1)
                        err(1, "parent: ioctl(SIOCATMARK)");
                assert(atmark != 0);
                ret = recv(fd, &b, 1, 0);
                assert(ret == 1);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 2);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);

                /* Read normal data. */
                atmark = 0;
                if (ioctl(fd, SIOCATMARK, &atmark) == -1)
                        err(1, "parent: ioctl(SIOCATMARK)");
                assert(atmark == 0);
                ret = recv(fd, buf, sizeof(buf), 0);
                assert(ret == 1);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 1);
                assert(FD_ISSET(fd, &rfd) == 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);

                proc_barrier(bfd);
                break;
            }

        default:
                break;
        }

        /* Test socket shutdown. */
        switch (filetype) {
        case FTYPE_SOCKET_TCP:
        case FTYPE_SOCKET_UNIX:
                /* child: write and shutdown */

                proc_barrier(bfd);

                /* Let inet sockets take their time. */
                if (filetype == FTYPE_SOCKET_TCP)
                        usleep(10000);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, NULL, NULL, &tv);
                assert(ret == 1);
                assert(FD_ISSET(fd, &rfd) != 0);

                ret = read(fd, &b, 1);
                assert(ret == 1);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, NULL, NULL, &tv);
                assert(ret == 1);
                assert(FD_ISSET(fd, &rfd) != 0);

                ret = read(fd, &b, 1);
                assert(ret == 0);

                ret = shutdown(fd, SHUT_WR);
                assert(ret == 0);

                proc_barrier(bfd);

                fdset_init(&rfd, &wfd, &efd, fd);
                ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
                assert(ret == 2);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;

        case FTYPE_FIFO:
        case FTYPE_PIPE:
        case FTYPE_PTY:
        case FTYPE_SOCKET_UDP:
        default:
                break;
        }

        proc_barrier(bfd);

        /* child: close */

        proc_barrier(bfd);

        fdset_init(&rfd, &wfd, &efd, fd);
        if (filetype == FTYPE_FIFO || filetype == FTYPE_PIPE)
                FD_CLR(fd, &wfd);
        ret = select(fd + 1, &rfd, &wfd, &efd, &tv);
        switch (filetype) {
        case FTYPE_FIFO:
        case FTYPE_PIPE:
                assert(ret == 1);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) == 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;
        case FTYPE_PTY:
        case FTYPE_SOCKET_TCP:
        case FTYPE_SOCKET_UNIX:
                assert(ret == 2);
                assert(FD_ISSET(fd, &rfd) != 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;
        case FTYPE_SOCKET_UDP:
                assert(ret == 1);
                assert(FD_ISSET(fd, &rfd) == 0);
                assert(FD_ISSET(fd, &wfd) != 0);
                assert(FD_ISSET(fd, &efd) == 0);
                break;
        default:
                assert(0);
        }

        close(fd);
}