event_loop_epoll.c

#define _GNU_SOURCE
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/timerfd.h>

#if defined(__linux__)
#include <sys/epoll.h>
#endif
#include <poll.h>

static int set_nonblock(int fd)
{
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0) return -1;
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) return -1;
    return 0;
}

static int make_timerfd(void)
{
#if defined(__linux__)
    int fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
    if (fd < 0) return -1;
    struct itimerspec its;
    its.it_interval.tv_sec = 1;
    its.it_interval.tv_nsec = 0;
    its.it_value.tv_sec = 1;
    its.it_value.tv_nsec = 0;
    if (timerfd_settime(fd, 0, &its, NULL) < 0) {
        close(fd);
        return -1;
    }
    return fd;
#else
    return -1;
#endif
}

int main(void)
{
    int fd_in = STDIN_FILENO;
    if (set_nonblock(fd_in) < 0) {
        perror("set_nonblock");
    }
#if defined(__linux__)
    int tfd = make_timerfd();
    int ep = epoll_create1(EPOLL_CLOEXEC);
    if (ep < 0) {
        perror("epoll_create1");
        return 1;
    }
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.u32 = 1;
    if (epoll_ctl(ep, EPOLL_CTL_ADD, fd_in, &ev) < 0) {
        perror("epoll_ctl stdin");
        return 1;
    }
    if (tfd >= 0) {
        ev.events = EPOLLIN;
        ev.data.u32 = 2;
        if (epoll_ctl(ep, EPOLL_CTL_ADD, tfd, &ev) < 0) {
            perror("epoll_ctl timer");
            return 1;
        }
    }
    printf("type lines; timer fires once per second; ctrl-d to exit\n");
    for (;;) {
        struct epoll_event evs[4];
        int n = epoll_wait(ep, evs, 4, -1);
        if (n < 0) {
            if (errno == EINTR) continue;
            perror("epoll_wait");
            break;
        }
        for (int i = 0; i < n; i++) {
            if (evs[i].data.u32 == 1) {
                char buf[256];
                ssize_t r = read(fd_in, buf, sizeof buf - 1);
                if (r == 0) {
                    printf("eof\n");
                    close(ep);
                    if (tfd >= 0) close(tfd);
                    return 0;
                } else if (r > 0) {
                    buf[r] = 0;
                    printf("in: %s", buf);
                }
            } else if (evs[i].data.u32 == 2) {
                uint64_t exp;
                ssize_t r = read(tfd, &exp, sizeof exp);
                if (r > 0) {
                    printf("timer tick\n");
                }
            }
        }
    }
    close(ep);
    if (tfd >= 0) close(tfd);
    return 0;
#else
    printf("using poll fallback; type lines; ctrl-d to exit\n");
    for (;;) {
        struct pollfd pfds[1];
        pfds[0].fd = fd_in;
        pfds[0].events = POLLIN;
        int r = poll(pfds, 1, 1000);
        if (r < 0) {
            if (errno == EINTR) continue;
            perror("poll");
            break;
        } else if (r == 0) {
            printf("poll timeout\n");
            continue;
        }
        if (pfds[0].revents & POLLIN) {
            char buf[256];
            ssize_t n = read(fd_in, buf, sizeof buf - 1);
            if (n == 0) {
                printf("eof\n");
                break;
            } else if (n > 0) {
                buf[n] = 0;
                printf("in: %s", buf);
            }
        }
    }
    return 0;
#endif
}