Libevent

// 一个简单的阻塞HTTP客户端
/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For gethostbyname */
#include <netdb.h>

#include <unistd.h>
#include <string.h>
#include <stdio.h>

int main(int c, char **v)
{
    const char query[] =
        "GET / HTTP/1.0\r\n"
        "Host: www.google.com\r\n"
        "\r\n";
    const char hostname[] = "www.google.com";
    struct sockaddr_in sin;
    struct hostent *h;
    const char *cp;
    int fd;
    ssize_t n_written, remaining;
    char buf[1024];

    /* Look up the IP address for the hostname.   Watch out; this isn't
       threadsafe on most platforms. */
    h = gethostbyname(hostname);
    if (!h) {
        fprintf(stderr, "Couldn't lookup %s: %s", hostname, hstrerror(h_errno));
        return 1;
    }
    if (h->h_addrtype != AF_INET) {
        fprintf(stderr, "No ipv6 support, sorry.");
        return 1;
    }

    /* Allocate a new socket */
    fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        perror("socket");
        return 1;
    }

    /* Connect to the remote host. */
    sin.sin_family = AF_INET;
    sin.sin_port = htons(80);
    sin.sin_addr = *(struct in_addr*)h->h_addr;
    if (connect(fd, (struct sockaddr*) &sin, sizeof(sin))) {
        perror("connect");
        close(fd);
        return 1;
    }

    /* Write the query. */
    /* XXX Can send succeed partially? */
    cp = query;
    remaining = strlen(query);
    while (remaining) {
      n_written = send(fd, cp, remaining, 0);
      if (n_written <= 0) {
        perror("send");
        return 1;
      }
      remaining -= n_written;
      cp += n_written;
    }

    /* Get an answer back. */
    while (1) {
        ssize_t result = recv(fd, buf, sizeof(buf), 0);
        if (result == 0) {
            break;
        } else if (result < 0) {
            perror("recv");
            close(fd);
            return 1;
        }
        fwrite(buf, 1, result, stdout);
    }

    close(fd);
    return 0;
}

// 坏例子
/* This won't work. */
char buf[1024];
int i, n;
while (i_still_want_to_read()) {
    for (i=0; i<n_sockets; ++i) {
        n = recv(fd[i], buf, sizeof(buf), 0);
        if (n==0)
            handle_close(fd[i]);
        else if (n<0)
            handle_error(fd[i], errno);
        else
            handle_input(fd[i], buf, n);
    }
}

// 伪造ROT13服务器
/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>

#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#define MAX_LINE 16384

char
rot13_char(char c)
{
    /* We don't want to use isalpha here; setting the locale would change
     * which characters are considered alphabetical. */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

void
child(int fd)
{
    char outbuf[MAX_LINE+1];
    size_t outbuf_used = 0;
    ssize_t result;

    while (1) {
        char ch;
        result = recv(fd, &ch, 1, 0);
        if (result == 0) {
            break;
        } else if (result == -1) {
            perror("read");
            break;
        }

        /* We do this test to keep the user from overflowing the buffer. */
        if (outbuf_used < sizeof(outbuf)) {
            outbuf[outbuf_used++] = rot13_char(ch);
        }

        if (ch == '\n') {
            send(fd, outbuf, outbuf_used, 0);
            outbuf_used = 0;
            continue;
        }
    }
}

void
run(void)
{
    int listener;
    struct sockaddr_in sin;

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    listener = socket(AF_INET, SOCK_STREAM, 0);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }



    while (1) {
        struct sockaddr_storage ss;
        socklen_t slen = sizeof(ss);
        int fd = accept(listener, (struct sockaddr*)&ss, &slen);
        if (fd < 0) {
            perror("accept");
        } else {
            if (fork() == 0) {
                child(fd);
                exit(0);
            }
        }
    }
}

int
main(int c, char **v)
{
    run();
    return 0;
}

fcntl(fd, F_SETFL, O_NONBLOCK);

// 不好的例子 忙着轮询所有插座
/* This will work, but the performance will be unforgivably bad. */
int i, n;
char buf[1024];
for (i=0; i < n_sockets; ++i)
    fcntl(fd[i], F_SETFL, O_NONBLOCK);

while (i_still_want_to_read()) {
    for (i=0; i < n_sockets; ++i) {
        n = recv(fd[i], buf, sizeof(buf), 0);
        if (n == 0) {
            handle_close(fd[i]);
        } else if (n < 0) {
            if (errno == EAGAIN)
                 ; /* The kernel didn't have any data for us to read. */
            else
                 handle_error(fd[i], errno);
         } else {
            handle_input(fd[i], buf, n);
         }
    }
}

// 示例:使用select
/* If you only have a couple dozen fds, this version won't be awful */
fd_set readset;
int i, n;
char buf[1024];

while (i_still_want_to_read()) {
    int maxfd = -1;
    FD_ZERO(&readset);

    /* Add all of the interesting fds to readset */
    for (i=0; i < n_sockets; ++i) {
         if (fd[i]>maxfd) maxfd = fd[i];
         FD_SET(fd[i], &readset);
    }

    /* Wait until one or more fds are ready to read */
    select(maxfd+1, &readset, NULL, NULL, NULL);

    /* Process all of the fds that are still set in readset */
    for (i=0; i < n_sockets; ++i) {
        if (FD_ISSET(fd[i], &readset)) {
            n = recv(fd[i], buf, sizeof(buf), 0);
            if (n == 0) {
                handle_close(fd[i]);
            } else if (n < 0) {
                if (errno == EAGAIN)
                     ; /* The kernel didn't have any data for us to read. */
                else
                     handle_error(fd[i], errno);
             } else {
                handle_input(fd[i], buf, n);
             }
        }
    }
}

// 示例:基于select()的ROT13服务器
/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>
/* for select */
#include <sys/select.h>

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

#define MAX_LINE 16384

char
rot13_char(char c)
{
    /* We don't want to use isalpha here; setting the locale would change
     * which characters are considered alphabetical. */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

struct fd_state {
    char buffer[MAX_LINE];
    size_t buffer_used;

    int writing;
    size_t n_written;
    size_t write_upto;
};

struct fd_state *
alloc_fd_state(void)
{
    struct fd_state *state = malloc(sizeof(struct fd_state));
    if (!state)
        return NULL;
    state->buffer_used = state->n_written = state->writing =
        state->write_upto = 0;
    return state;
}

void
free_fd_state(struct fd_state *state)
{
    free(state);
}

void
make_nonblocking(int fd)
{
    fcntl(fd, F_SETFL, O_NONBLOCK);
}

int
do_read(int fd, struct fd_state *state)
{
    char buf[1024];
    int i;
    ssize_t result;
    while (1) {
        result = recv(fd, buf, sizeof(buf), 0);
        if (result <= 0)
            break;

        for (i=0; i < result; ++i)  {
            if (state->buffer_used < sizeof(state->buffer))
                state->buffer[state->buffer_used++] = rot13_char(buf[i]);
            if (buf[i] == '\n') {
                state->writing = 1;
                state->write_upto = state->buffer_used;
            }
        }
    }

    if (result == 0) {
        return 1;
    } else if (result < 0) {
        if (errno == EAGAIN)
            return 0;
        return -1;
    }

    return 0;
}

int
do_write(int fd, struct fd_state *state)
{
    while (state->n_written < state->write_upto) {
        ssize_t result = send(fd, state->buffer + state->n_written,
                              state->write_upto - state->n_written, 0);
        if (result < 0) {
            if (errno == EAGAIN)
                return 0;
            return -1;
        }
        assert(result != 0);

        state->n_written += result;
    }

    if (state->n_written == state->buffer_used)
        state->n_written = state->write_upto = state->buffer_used = 0;

    state->writing = 0;

    return 0;
}

void
run(void)
{
    int listener;
    struct fd_state *state[FD_SETSIZE];
    struct sockaddr_in sin;
    int i, maxfd;
    fd_set readset, writeset, exset;

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    for (i = 0; i < FD_SETSIZE; ++i)
        state[i] = NULL;

    listener = socket(AF_INET, SOCK_STREAM, 0);
    make_nonblocking(listener);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }

    FD_ZERO(&readset);
    FD_ZERO(&writeset);
    FD_ZERO(&exset);

    while (1) {
        maxfd = listener;

        FD_ZERO(&readset);
        FD_ZERO(&writeset);
        FD_ZERO(&exset);

        FD_SET(listener, &readset);

        for (i=0; i < FD_SETSIZE; ++i) {
            if (state[i]) {
                if (i > maxfd)
                    maxfd = i;
                FD_SET(i, &readset);
                if (state[i]->writing) {
                    FD_SET(i, &writeset);
                }
            }
        }

        if (select(maxfd+1, &readset, &writeset, &exset, NULL) < 0) {
            perror("select");
            return;
        }

        if (FD_ISSET(listener, &readset)) {
            struct sockaddr_storage ss;
            socklen_t slen = sizeof(ss);
            int fd = accept(listener, (struct sockaddr*)&ss, &slen);
            if (fd < 0) {
                perror("accept");
            } else if (fd > FD_SETSIZE) {
                close(fd);
            } else {
                make_nonblocking(fd);
                state[fd] = alloc_fd_state();
                assert(state[fd]);/*XXX*/
            }
        }

        for (i=0; i < maxfd+1; ++i) {
            int r = 0;
            if (i == listener)
                continue;

            if (FD_ISSET(i, &readset)) {
                r = do_read(i, state[i]);
            }
            if (r == 0 && FD_ISSET(i, &writeset)) {
                r = do_write(i, state[i]);
            }
            if (r) {
                free_fd_state(state[i]);
                state[i] = NULL;
                close(i);
            }
        }
    }
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

// 示例：带有Libevent的低级ROT13服务器
/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>

#include <event2/event.h>

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

#define MAX_LINE 16384

void do_read(evutil_socket_t fd, short events, void *arg);
void do_write(evutil_socket_t fd, short events, void *arg);

char
rot13_char(char c)
{
    /* ROT13字符转换 */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

struct fd_state {
    char buffer[MAX_LINE]; // 缓冲区
    size_t buffer_used;    // 缓冲区已使用大小

    size_t n_written;      // 已写入数据大小
    size_t write_upto;     // 写入目标大小

    struct event *read_event;  // 读事件
    struct event *write_event; // 写事件
};

struct fd_state *
alloc_fd_state(struct event_base *base, evutil_socket_t fd)
{
    struct fd_state *state = malloc(sizeof(struct fd_state));
    if (!state)
        return NULL;

    // 创建读事件，绑定到fd，回调函数为do_read
    state->read_event = event_new(base, fd, EV_READ|EV_PERSIST, do_read, state);
    if (!state->read_event) {
        free(state);
        return NULL;
    }

    // 创建写事件，绑定到fd，回调函数为do_write
    state->write_event =
        event_new(base, fd, EV_WRITE|EV_PERSIST, do_write, state);

    if (!state->write_event) {
        event_free(state->read_event);
        free(state);
        return NULL;
    }

    state->buffer_used = state->n_written = state->write_upto = 0;

    return state;
}

void
free_fd_state(struct fd_state *state)
{
    // 释放事件和状态
    event_free(state->read_event);
    event_free(state->write_event);
    free(state);
}

void
do_read(evutil_socket_t fd, short events, void *arg)
{
    struct fd_state *state = arg;
    char buf[1024];
    int i;
    ssize_t result;

    while (1) {
        result = recv(fd, buf, sizeof(buf), 0);
        if (result <= 0)
            break;

        for (i = 0; i < result; ++i) {
            if (state->buffer_used < sizeof(state->buffer))
                state->buffer[state->buffer_used++] = rot13_char(buf[i]);
            if (buf[i] == '\n') {
                // 数据行结束，添加写事件
                event_add(state->write_event, NULL);
                state->write_upto = state->buffer_used;
            }
        }
    }

    if (result == 0) {
        free_fd_state(state); // 连接关闭
    } else if (result < 0) {
        if (errno == EAGAIN)
            return;
        perror("recv");
        free_fd_state(state);
    }
}

void
do_write(evutil_socket_t fd, short events, void *arg)
{
    struct fd_state *state = arg;

    while (state->n_written < state->write_upto) {
        ssize_t result = send(fd, state->buffer + state->n_written,
                              state->write_upto - state->n_written, 0);
        if (result < 0) {
            if (errno == EAGAIN)
                return;
            free_fd_state(state);
            return;
        }

        state->n_written += result;
    }

    if (state->n_written == state->buffer_used)
        state->n_written = state->write_upto = state->buffer_used = 0;

    // 写完成后移除写事件
    event_del(state->write_event);
}

void
do_accept(evutil_socket_t listener, short event, void *arg)
{
    struct event_base *base = arg;
    struct sockaddr_storage ss;
    socklen_t slen = sizeof(ss);
    int fd = accept(listener, (struct sockaddr*)&ss, &slen);
    if (fd < 0) {
        perror("accept");
    } else if (fd > FD_SETSIZE) {
        close(fd);
    } else {
        struct fd_state *state;
        evutil_make_socket_nonblocking(fd); // 设置非阻塞
        state = alloc_fd_state(base, fd);
        event_add(state->read_event, NULL); // 添加读事件
    }
}

void
run(void)
{
    evutil_socket_t listener;
    struct sockaddr_in sin;
    struct event_base *base;
    struct event *listener_event;

    base = event_base_new(); // 创建事件循环
    if (!base)
        return;

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    listener = socket(AF_INET, SOCK_STREAM, 0);
    evutil_make_socket_nonblocking(listener); // 设置监听套接字为非阻塞

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16) < 0) {
        perror("listen");
        return;
    }

    // 创建监听事件，绑定到listener，回调函数为do_accept
    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
    event_add(listener_event, NULL); // 添加监听事件

    event_base_dispatch(base); // 开始事件循环
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

// 示例:带有Libevent的更简单的ROT13服务器
/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>

#include <event2/event.h>
#include <event2/buffer.h>
#include <event2/bufferevent.h>

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

#define MAX_LINE 16384

void do_read(evutil_socket_t fd, short events, void *arg);
void do_write(evutil_socket_t fd, short events, void *arg);

char
rot13_char(char c)
{
    /* ROT13字符转换 */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

void
readcb(struct bufferevent *bev, void *ctx)
{
    struct evbuffer *input, *output;
    char *line;
    size_t n;
    int i;

    // 获取输入缓冲区和输出缓冲区
    input = bufferevent_get_input(bev);
    output = bufferevent_get_output(bev);

    // 从输入缓冲区读取一行数据并进行ROT13转换
    while ((line = evbuffer_readln(input, &n, EVBUFFER_EOL_LF))) {
        for (i = 0; i < n; ++i)
            line[i] = rot13_char(line[i]);
        evbuffer_add(output, line, n); // 将转换后的数据添加到输出缓冲区
        evbuffer_add(output, "\n", 1); // 添加换行符
        free(line); // 释放读取的行
    }

    // 如果输入缓冲区长度超过最大值，处理剩余数据
    if (evbuffer_get_length(input) >= MAX_LINE) {
        char buf[1024];
        while (evbuffer_get_length(input)) {
            int n = evbuffer_remove(input, buf, sizeof(buf));
            for (i = 0; i < n; ++i)
                buf[i] = rot13_char(buf[i]);
            evbuffer_add(output, buf, n);
        }
        evbuffer_add(output, "\n", 1);
    }
}

void
errorcb(struct bufferevent *bev, short error, void *ctx)
{
    if (error & BEV_EVENT_EOF) {
        /* 连接已关闭，进行清理操作 */
    } else if (error & BEV_EVENT_ERROR) {
        /* 检查errno以确定发生的错误 */
    } else if (error & BEV_EVENT_TIMEOUT) {
        /* 处理超时事件 */
    }
    bufferevent_free(bev); // 释放bufferevent
}

void
do_accept(evutil_socket_t listener, short event, void *arg)
{
    struct event_base *base = arg;
    struct sockaddr_storage ss;
    socklen_t slen = sizeof(ss);
    int fd = accept(listener, (struct sockaddr*)&ss, &slen);
    if (fd < 0) {
        perror("accept");
    } else if (fd > FD_SETSIZE) {
        close(fd);
    } else {
        struct bufferevent *bev;
        evutil_make_socket_nonblocking(fd); // 设置套接字为非阻塞
        bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE); // 创建bufferevent
        bufferevent_setcb(bev, readcb, NULL, errorcb, NULL); // 设置回调函数
        bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE); // 设置读取水位线
        bufferevent_enable(bev, EV_READ|EV_WRITE); // 启用读写事件
    }
}

void
run(void)
{
    evutil_socket_t listener;
    struct sockaddr_in sin;
    struct event_base *base;
    struct event *listener_event;

    base = event_base_new(); // 创建事件循环
    if (!base)
        return;

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    listener = socket(AF_INET, SOCK_STREAM, 0);
    evutil_make_socket_nonblocking(listener); // 设置监听套接字为非阻塞

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); // 设置SO_REUSEADDR选项
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }

    // 创建监听事件，绑定到listener，回调函数为do_accept
    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
    event_add(listener_event, NULL); // 添加监听事件

    event_base_dispatch(base); // 开始事件循环
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

#define EVENT_LOG_DEBUG 0
#define EVENT_LOG_MSG   1
#define EVENT_LOG_WARN  2
#define EVENT_LOG_ERR   3

/* Deprecated; see note at the end of this section */
#define _EVENT_LOG_DEBUG EVENT_LOG_DEBUG
#define _EVENT_LOG_MSG   EVENT_LOG_MSG
#define _EVENT_LOG_WARN  EVENT_LOG_WARN
#define _EVENT_LOG_ERR   EVENT_LOG_ERR

typedef void (*event_log_cb)(int severity, const char *msg);

void event_set_log_callback(event_log_cb cb);

#include <event2/event.h>
#include <stdio.h>

static void discard_cb(int severity, const char *msg)
{
    /* This callback does nothing. */
}

static FILE *logfile = NULL;
static void write_to_file_cb(int severity, const char *msg)
{
    const char *s;
    if (!logfile)
        return;
    switch (severity) {
        case _EVENT_LOG_DEBUG: s = "debug"; break;
        case _EVENT_LOG_MSG:   s = "msg";   break;
        case _EVENT_LOG_WARN:  s = "warn";  break;
        case _EVENT_LOG_ERR:   s = "error"; break;
        default:               s = "?";     break; /* never reached */
    }
    fprintf(logfile, "[%s] %s\n", s, msg);
}

/* Turn off all logging from Libevent. */
void suppress_logging(void)
{
    event_set_log_callback(discard_cb);
}

/* Redirect all Libevent log messages to the C stdio file 'f'. */
void set_logfile(FILE *f)
{
    logfile = f;
    event_set_log_callback(write_to_file_cb);
}

#define EVENT_DBG_NONE 0
#define EVENT_DBG_ALL 0xffffffffu

void event_enable_debug_logging(ev_uint32_t which);

typedef void (*event_fatal_cb)(int err);
void event_set_fatal_callback(event_fatal_cb cb);

void event_set_mem_functions(void *(*malloc_fn)(size_t sz),
                             void *(*realloc_fn)(void *ptr, size_t sz),
                             void (*free_fn)(void *ptr));

#include <event2/event.h>
#include <sys/types.h>
#include <stdlib.h>

/* 该联合的目的是确保其大小与包含的所有类型中最大的类型一致。 */
union alignment {
    size_t sz;   // 用于存储大小的类型
    void *ptr;   // 用于存储指针的类型
    double dbl;  // 用于存储双精度浮点数的类型
};
/* 我们需要确保返回的所有内存都具有正确的对齐方式，
   以便能够存储任何类型的数据，包括双精度浮点数。 */
#define ALIGNMENT sizeof(union alignment)

/* 我们需要对指针进行强制转换为 char* 类型，以便调整它们；
   对 void* 类型进行算术运算在标准中是不被支持的。 */
#define OUTPTR(ptr) (((char*)ptr)+ALIGNMENT) // 调整指针以跳过对齐信息
#define INPTR(ptr) (((char*)ptr)-ALIGNMENT) // 调整指针以返回对齐信息的位置

/* 记录总分配的内存大小 */
static size_t total_allocated = 0;

/* 自定义 malloc 函数，用于分配内存并记录分配的大小 */
static void *replacement_malloc(size_t sz)
{
    // 分配内存，额外分配 ALIGNMENT 字节用于存储对齐信息
    void *chunk = malloc(sz + ALIGNMENT);
    if (!chunk) return chunk; // 如果分配失败，返回 NULL
    total_allocated += sz;    // 更新总分配的内存大小
    *(size_t*)chunk = sz;     // 在内存的起始位置存储分配的大小
    return OUTPTR(chunk);     // 返回调整后的指针
}

/* 自定义 realloc 函数，用于重新分配内存并更新记录 */
static void *replacement_realloc(void *ptr, size_t sz)
{
    size_t old_size = 0;
    if (ptr) {
        ptr = INPTR(ptr);          // 获取原始指针
        old_size = *(size_t*)ptr; // 获取原始分配的大小
    }
    ptr = realloc(ptr, sz + ALIGNMENT); // 重新分配内存
    if (!ptr)
        return NULL; // 如果重新分配失败，返回 NULL
    *(size_t*)ptr = sz; // 更新新的分配大小
    total_allocated = total_allocated - old_size + sz; // 更新总分配的内存大小
    return OUTPTR(ptr); // 返回调整后的指针
}

/* 自定义 free 函数，用于释放内存并更新记录 */
static void replacement_free(void *ptr)
{
    ptr = INPTR(ptr);               // 获取原始指针
    total_allocated -= *(size_t*)ptr; // 减去释放的内存大小
    free(ptr);                      // 释放内存
}

/* 启动自定义内存管理函数，用于统计分配的内存大小 */
void start_counting_bytes(void)
{
    event_set_mem_functions(replacement_malloc,  // 设置自定义 malloc 函数
                            replacement_realloc, // 设置自定义 realloc 函数
                            replacement_free);   // 设置自定义 free 函数
}

#ifdef WIN32
int evthread_use_windows_threads(void);
#define EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED
#endif
#ifdef _EVENT_HAVE_PTHREADS
int evthread_use_pthreads(void);
#define EVTHREAD_USE_PTHREADS_IMPLEMENTED
#endif

// 线程锁操作模式
#define EVTHREAD_WRITE  0x04   // 写操作
#define EVTHREAD_READ   0x08   // 读操作
#define EVTHREAD_TRY    0x10   // 尝试获取锁（非阻塞）

// 锁类型
#define EVTHREAD_LOCKTYPE_RECURSIVE 1   // 递归锁
#define EVTHREAD_LOCKTYPE_READWRITE 2   // 读写锁

// 锁API版本号
#define EVTHREAD_LOCK_API_VERSION 1

// 线程锁回调结构体
struct evthread_lock_callbacks {
    int lock_api_version;           // API版本号
    unsigned supported_locktypes;   // 支持的锁类型
    void *(*alloc)(unsigned locktype); // 分配锁
    void (*free)(void *lock, unsigned locktype); // 释放锁
    int (*lock)(unsigned mode, void *lock);      // 加锁
    int (*unlock)(unsigned mode, void *lock);    // 解锁
};

// 设置线程锁回调
int evthread_set_lock_callbacks(const struct evthread_lock_callbacks *);

// 设置线程ID回调
void evthread_set_id_callback(unsigned long (*id_fn)(void));

// 条件变量回调结构体
struct evthread_condition_callbacks {
     int condition_api_version; // API版本号
     void *(*alloc_condition)(unsigned condtype); // 分配条件变量
     void (*free_condition)(void *cond);          // 释放条件变量
     int (*signal_condition)(void *cond, int broadcast); // 发送信号（broadcast为1时广播）
     int (*wait_condition)(void *cond, void *lock,
         const struct timeval *timeout); // 等待条件变量，带超时
};

// 设置条件变量回调
int evthread_set_condition_callbacks(
     const struct evthread_condition_callbacks *);

For an example of how to use these functions, see evthread_pthread.c and
evthread_win32.c in the Libevent source distribution.

void evthread_enable_lock_debugging(void);
#define evthread_enable_lock_debuging() evthread_enable_lock_debugging()

void event_enable_debug_mode(void);

void event_debug_unassign(struct event *ev);

#include <event2/event.h>
#include <event2/event_struct.h>
#include <stdlib.h>

// 回调函数，当事件触发时被调用
void cb(evutil_socket_t fd, short what, void *ptr)
{
    // 对于堆上分配的事件，回调参数为 NULL
    // 对于栈上分配的事件，回调参数为事件本身
    struct event *ev = ptr;

    // 如果 ev 不为 NULL，则调用 event_debug_unassign
    // 通知 Libevent 该事件不再被视为已分配（仅在调试模式下有效）
    if (ev)
        event_debug_unassign(ev);
}

/*
 * 一个简单的主循环，等待 fd1 和 fd2 都准备好读取
 * fd1 和 fd2 是两个文件描述符
 * debug_mode 为 1 时启用事件调试模式
 */
void mainloop(evutil_socket_t fd1, evutil_socket_t fd2, int debug_mode)
{
    struct event_base *base;              // 事件处理主循环对象
    struct event event_on_stack, *event_on_heap; // 分别用于栈上和堆上分配的事件

    // 如果启用调试模式，则调用 event_enable_debug_mode
    // 必须在创建 event_base 之前调用
    if (debug_mode)
       event_enable_debug_mode();

    // 创建事件主循环对象
    base = event_base_new();

    // 在堆上创建一个新的事件，监听 fd1 的可读事件，回调函数为 cb，参数为 NULL
    event_on_heap = event_new(base, fd1, EV_READ, cb, NULL);

    // 在栈上分配一个事件，监听 fd2 的可读事件，回调函数为 cb，参数为事件本身
    event_assign(&event_on_stack, base, fd2, EV_READ, cb, &event_on_stack);

    // 将两个事件添加到事件主循环中
    event_add(event_on_heap, NULL);
    event_add(&event_on_stack, NULL);

    // 启动事件主循环，等待事件发生
    event_base_dispatch(base);

    // 释放堆上分配的事件
    event_free(event_on_heap);
    // 释放事件主循环对象
    event_base_free(base);
}

#define LIBEVENT_VERSION_NUMBER 0x02000300
#define LIBEVENT_VERSION "2.0.3-alpha"
const char *event_get_version(void);
ev_uint32_t event_get_version_number(void);

#include <event2/event.h>

#if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000100
#error "This version of Libevent is not supported; Get 2.0.1-alpha or later."
#endif

int
make_sandwich(void)
{
        /* Let's suppose that Libevent 6.0.5 introduces a make-me-a
           sandwich function. */
#if LIBEVENT_VERSION_NUMBER >= 0x06000500
        evutil_make_me_a_sandwich();
        return 0;
#else
        return -1;
#endif
}

#include <event2/event.h>
#include <string.h>

int
check_for_old_version(void)
{
    const char *v = event_get_version();
    /* This is a dumb way to do it, but it is the only thing that works
       before Libevent 2.0. */
    if (!strncmp(v, "0.", 2) ||
        !strncmp(v, "1.1", 3) ||
        !strncmp(v, "1.2", 3) ||
        !strncmp(v, "1.3", 3)) {

        printf("Your version of Libevent is very old.  If you run into bugs,"
               " consider upgrading.\n");
        return -1;
    } else {
        printf("Running with Libevent version %s\n", v);
        return 0;
    }
}

int
check_version_match(void)
{
    ev_uint32_t v_compile, v_run;
    v_compile = LIBEVENT_VERSION_NUMBER;
    v_run = event_get_version_number();
    if ((v_compile & 0xffff0000) != (v_run & 0xffff0000)) {
        printf("Running with a Libevent version (%s) very different from the "
               "one we were built with (%s).\n", event_get_version(),
               LIBEVENT_VERSION);
        return -1;
    }
    return 0;
}

void libevent_global_shutdown(void);

struct event_base *event_base_new(void);

struct event_config *event_config_new(void);
struct event_base *event_base_new_with_config(const struct event_config *cfg);
void event_config_free(struct event_config *cfg);

// 禁用指定的后端方法（如 "select"、"epoll" 等）
// cfg: event_config 配置对象
// method: 要禁用的方法名称
// 返回值：成功返回0，失败返回-1
int event_config_avoid_method(struct event_config *cfg, const char *method);

// 事件方法特性枚举
enum event_method_feature {
    EV_FEATURE_ET = 0x01,    // 支持边缘触发（Edge Triggered）
    EV_FEATURE_O1 = 0x02,    // 要求后端方法在添加、删除单个事件或单个事件变为激活时，操作复杂度为 O(1)。
    EV_FEATURE_FDS = 0x04,   // 要求后端方法支持任意类型的文件描述符，而不仅仅是套接字。
};

// 要求 event_base 必须支持指定的特性
// cfg: event_config 配置对象
// feature: 所需的特性（可以按位或组合）
// 返回值：成功返回0，失败返回-1
int event_config_require_features(struct event_config *cfg,
                                  enum event_method_feature feature);

// event_base 配置标志枚举
enum event_base_config_flag {
    // 不为 event_base 分配锁。设置此选项可以节省一些加锁和解锁的时间，但会导致 event_base 在多线程环境下不安全且不可用。
    EVENT_BASE_FLAG_NOLOCK = 0x01,
    // 在选择后端方法时不检查 EVENT_* 环境变量。使用此标志前请谨慎考虑：它可能会让用户更难调试你的程序与 Libevent 之间的交互。
    EVENT_BASE_FLAG_IGNORE_ENV = 0x02,
    // 仅适用于 Windows。该标志让 Libevent 在启动时启用所有必要的 IOCP 分发逻辑，而不是按需启用。
    EVENT_BASE_FLAG_STARTUP_IOCP = 0x04,
    // 每次事件循环准备运行超时回调时都检查当前时间，而不是每次超时回调后再检查。这可能会比你预期的消耗更多 CPU，请注意！
    EVENT_BASE_FLAG_NO_CACHE_TIME = 0x08,
    // 告诉 Libevent，如果决定使用 epoll 后端，可以安全地使用更快的 "changelist" 优化。epoll-changelist 后端可以避免在同一个 fd 状态在两次分发函数调用之间被多次修改时产生不必要的系统调用，但如果你给 Libevent 传递了通过 dup() 或其变体克隆的 fd，可能会触发内核 bug 并导致错误结果。如果你使用的不是 epoll 后端，此标志无效。你也可以通过设置环境变量 `EVENT_EPOLL_USE_CHANGELIST` 启用该选项。
    EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST = 0x10,
    // 默认情况下，Libevent 会尝试使用操作系统提供的最快的定时机制。如果有一种更慢但更精确的定时机制，此标志会让 Libevent 使用该机制。如果操作系统没有这种机制，则此标志无效。启用高精度定时器
    EVENT_BASE_FLAG_PRECISE_TIMER = 0x20
};

// 设置 event_base 的配置标志
// cfg: event_config 配置对象
// flag: 配置标志（可以按位或组合）
// 返回值：成功返回0，失败返回-1
int event_config_set_flag(struct event_config *cfg,
    enum event_base_config_flag flag);

int event_config_set_num_cpus_hint(struct event_config *cfg, int cpus)

int event_config_set_max_dispatch_interval(struct event_config *cfg,
    const struct timeval *max_interval, int max_callbacks,
    int min_priority);

struct event_config *cfg;
struct event_base *base;
int i;

/* My program wants to use edge-triggered events if at all possible.  So
   I'll try to get a base twice: Once insisting on edge-triggered IO, and
   once not. */
for (i=0; i<2; ++i) {
    cfg = event_config_new();

    /* I don't like select. */
    event_config_avoid_method(cfg, "select");

    if (i == 0)
        event_config_require_features(cfg, EV_FEATURE_ET);

    base = event_base_new_with_config(cfg);
    event_config_free(cfg);
    if (base)
        break;

    /* If we get here, event_base_new_with_config() returned NULL.  If
       this is the first time around the loop, we'll try again without
       setting EV_FEATURE_ET.  If this is the second time around the
       loop, we'll give up. */
}

struct event_config *cfg;
struct event_base *base;

cfg = event_config_new();
if (!cfg)
   /* 处理错误 */;

/* 我要运行两个优先级的事件。我预计某些优先级为1的事件回调会比较慢，
   所以我不希望在检查优先级为0的事件之前，超过100毫秒或执行超过5个回调。 */
struct timeval msec_100 = { 0, 100*1000 };
event_config_set_max_dispatch_interval(cfg, &msec_100, 5, 1);

base = event_base_new_with_config(cfg);
if (!base)
   /* 处理错误 */;

// 设置这个事件循环支持 2个优先级：0 和 1。
event_base_priority_init(base, 2);  // 初始化两个优先级的事件

const char **event_get_supported_methods(void);

int i;
const char **methods = event_get_supported_methods();
printf("Starting Libevent %s.  Available methods are:\n",
    event_get_version());
for (i=0; methods[i] != NULL; ++i) {
    printf("    %s\n", methods[i]);
}

const char *event_base_get_method(const struct event_base *base);
enum event_method_feature event_base_get_features(const struct event_base *base);

struct event_base *base;
enum event_method_feature f;

base = event_base_new();
if (!base) {
    puts("Couldn't get an event_base!");
} else {
    printf("Using Libevent with backend method %s.",
        event_base_get_method(base));
    f = event_base_get_features(base);
    if ((f & EV_FEATURE_ET))
        printf("  Edge-triggered events are supported.");
    if ((f & EV_FEATURE_O1))
        printf("  O(1) event notification is supported.");
    if ((f & EV_FEATURE_FDS))
        printf("  All FD types are supported.");
    puts("");
}

void event_base_free(struct event_base *base);

int event_base_priority_init(struct event_base *base, int n_priorities);

int event_base_get_npriorities(struct event_base *base);
// 返回值等于当前配置的优先级数量，例如返回3，就说明当前可用的优先级是0、1、2

n_priorities / 2

int event_reinit(struct event_base *base);

struct event_base *base = event_base_new();

/* ... 向 event_base 添加一些事件 ... */

if (fork()) {
    // 父进程中
    continue_running_parent(base);  // 父进程继续运行
} else {
    // 子进程中
    event_reinit(base);             // 重新初始化 event_base
    continue_running_child(base);   // 子进程继续运行
}

struct event_base *event_init(void);

int event_base_loop(struct event_base *base, int flags);

while (有事件注册，或者设置了 EVLOOP_NO_EXIT_ON_EMPTY) {
    如果设置了 EVLOOP_NONBLOCK 或已经有事件 active：
        检查是否有事件触发，如果有则标记为 active；
    否则：
        阻塞等待至少一个事件触发，并标记为 active。

    for (按优先级从高到低遍历) {
        如果当前优先级的事件被激活：
            执行这些事件的回调函数；
            break; // 不执行更低优先级的事件
    }

    如果设置了 EVLOOP_ONCE 或 EVLOOP_NONBLOCK：
        跳出循环；
}

int event_base_dispatch(struct event_base *base);

int event_base_loopexit(struct event_base *base, const struct timeval *tv);
int event_base_loopbreak(struct event_base *base);
// 返回值
// 0 成功 -1 调用失败

void cb(int sock, short what, void *arg) {
    struct event_base *base = arg;
    event_base_loopbreak(base);
}

void main_loop(struct event_base *base, evutil_socket_t watchdog_fd) {
    struct event *watchdog_event;

    watchdog_event = event_new(base, watchdog_fd, EV_READ, cb, base);
    event_add(watchdog_event, NULL);

    event_base_dispatch(base);
}

void run_base_with_ticks(struct event_base *base) {
    struct timeval ten_sec = {10, 0};

    while (1) {
        event_base_loopexit(base, &ten_sec);
        event_base_dispatch(base);
        puts("Tick");
    }
}

int event_base_got_exit(struct event_base *base);
int event_base_got_break(struct event_base *base);

int event_base_loopcontinue(struct event_base *base);
// 返回值
// 0 成功 -1 失败

#include <stdio.h>
#include <stdlib.h>
#include <event2/event.h>

// 用于演示的第二个事件
void second_event_cb(evutil_socket_t fd, short what, void *arg) {
    printf("Second event triggered!\n");
}

// 第一个事件，在它的回调中调用 event_base_loopcontinue()
void first_event_cb(evutil_socket_t fd, short what, void *arg) {
    struct event_base *base = (struct event_base *)arg;

    printf("First event triggered!\n");

    // 创建并添加第二个事件（短延迟）
    struct timeval delay = {0, 10 * 1000}; // 10ms
    struct event *second_event = evtimer_new(base, second_event_cb, NULL);
    evtimer_add(second_event, &delay);

    // 通知事件循环：当前回调执行完后，立即重新检查事件
    if (event_base_loopcontinue(base) == 0) {
        printf("Requested immediate re-check for events.\n");
    } else {
        fprintf(stderr, "Failed to request loopcontinue.\n");
    }
}

int main() {
    struct event_base *base = event_base_new();
    if (!base) {
        fprintf(stderr, "Failed to create event_base\n");
        return 1;
    }

    // 添加第一个定时器事件
    struct timeval start_delay = {0, 100 * 1000}; // 100ms
    struct event *first_event = evtimer_new(base, first_event_cb, base);
    evtimer_add(first_event, &start_delay);

    // 启动事件循环
    event_base_dispatch(base);

    event_free(first_event);
    event_base_free(base);
    return 0;
}
// First event triggered!
// Requested immediate re-check for events.
// Second event triggered!

int event_base_gettimeofday_cached(struct event_base *base,
                                   struct timeval *tv_out);

int event_base_update_cache_time(struct event_base *base);

#include <stdio.h>
#include <stdlib.h>
#include <event2/event.h>
#include <sys/time.h>

void timer_cb(evutil_socket_t fd, short what, void *arg) {
    struct event_base *base = (struct event_base *)arg;
    struct timeval cached_time;

    // 获取 Libevent 缓存的时间
    if (event_base_gettimeofday_cached(base, &cached_time) == 0) {
        printf("Cached time (before update): %ld.%06ld\n",
               (long)cached_time.tv_sec, (long)cached_time.tv_usec);
    } else {
        fprintf(stderr, "Failed to get cached time.\n");
    }

    // 模拟一些耗时操作
    struct timeval delay = {1, 0}; // 睡 1 秒
    select(0, NULL, NULL, NULL, &delay);

    // 手动更新缓存时间
    event_base_update_cache_time(base);

    // 再次获取缓存时间
    if (event_base_gettimeofday_cached(base, &cached_time) == 0) {
        printf("Cached time (after update): %ld.%06ld\n",
               (long)cached_time.tv_sec, (long)cached_time.tv_usec);
    }
}

int main() {
    struct event_base *base;
    struct event *timer_event;
    struct timeval delay = {0, 100 * 1000}; // 100 毫秒

    base = event_base_new();
    if (!base) {
        fprintf(stderr, "Could not initialize libevent!\n");
        return 1;
    }

    // 创建一个一次性的定时器事件
    timer_event = evtimer_new(base, timer_cb, base);
    evtimer_add(timer_event, &delay);

    // 启动事件循环
    event_base_dispatch(base);

    // 清理资源
    event_free(timer_event);
    event_base_free(base);
    return 0;
}

void event_base_dump_events(struct event_base *base, FILE *f);

#include <stdio.h>
#include <stdlib.h>
#include <event2/event.h>

// 简单的事件回调函数
void demo_cb(evutil_socket_t fd, short what, void *arg) {
    printf("Demo event triggered.\n");
}

int main() {
    struct event_base *base = event_base_new();
    if (!base) {
        fprintf(stderr, "Failed to create event base\n");
        return 1;
    }

    // 创建一个定时器事件，5秒后触发
    struct timeval delay = {5, 0};
    struct event *demo_event = evtimer_new(base, demo_cb, NULL);
    evtimer_add(demo_event, &delay);

    // 🧾 打印当前事件状态到 stdout
    printf("=== 当前 event_base 中的事件状态 ===\n");
    event_base_dump_events(base, stdout);

    // 启动事件循环
    event_base_dispatch(base);

    // 释放资源
    event_free(demo_event);
    event_base_free(base);
    return 0;
}