libevent API 介绍

基本应用场景也是使用 libevnet 的基本流程，下面来考虑一个最简单的场景，使用
livevent 设置定时器，应用程序只需要执行下面几个简单的步骤即可。

1）首先初始化 libevent 库，并保存返回的指针
struct event_base * base = event_init();
实际上这一步相当于初始化一个 Reactor 实例；在初始化 libevent 后，就可以注册事件了。

2）初始化事件 event，设置回调函数和关注的事件
evtimer_set(&ev, timer_cb, NULL);
事实上这等价于调用 event_set(&ev, -1, 0, timer_cb, NULL);
event_set 的函数原型是：
void event_set(struct event *ev, int fd, short event, void (*cb)(int,
short, void *), void *arg)
ev：执行要初始化的 event 对象；
fd：该 event 绑定的“句柄”，对于信号事件，它就是关注的信号；
event：在该 fd 上关注的事件类型，它可以是 EV_READ, EV_WRITE, EV_SIGNAL；
cb：这是一个函数指针，当 fd 上的事件 event 发生时，调用该函数执行处理，它有三个参数，
调用时由 event_base 负责传入，按顺序，实际上就是 event_set 时的 fd, event 和 arg；
arg：传递给 cb 函数指针的参数；
由于定时事件不需要 fd，并且定时事件是根据添加时（event_add）的超时值设定的，因此
这里 event 也不需要设置。
这一步相当于初始化一个 event handler，在 libevent 中事件类型保存在 event 结构体中。
注意：libevent 并不会管理 event 事件集合，这需要应用程序自行管理；

3）设置 event 从属的 event_base
event_base_set(base, &ev);
这一步相当于指明 event 要注册到哪个 event_base 实例上；

4）是正式的添加事件的时候了
event_add(&ev, timeout);
基本信息都已设置完成，只要简单的调用 event_add()函数即可完成，其中 timeout 是定时值；

 

这一步相当于调用 Reactor::register_handler()函数注册事件。

5）程序进入无限循环，等待就绪事件并执行事件处理
event_base_dispatch(base);

 

 NOTE：在你使用任何有意思的Libevent函数之前,你需要分配一个或多个event_base结构.每一个event_base结构含有一组events，并且可以告知你哪一些events是就绪的.

就是一个event_base可以有一个或一组event

 

下面的例子中 base就有多个event

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>

#include <event.h>


#define PORT        25341
#define BACKLOG     5
#define MEM_SIZE    1024

struct event_base* base;
struct sock_ev {
    struct event* read_ev;
    struct event* write_ev;
    char* buffer;
};

void release_sock_event(struct sock_ev* ev)
{
    event_del(ev->read_ev);
    free(ev->read_ev);
    free(ev->write_ev);
    free(ev->buffer);
    free(ev);
}

void on_write(int sock, short event, void* arg)
{
    char* buffer = (char*)arg;
    send(sock, buffer, strlen(buffer), 0);

    free(buffer);
}

void on_read(int sock, short event, void* arg)
{
    struct event* write_ev;
    int size;
    struct sock_ev* ev = (struct sock_ev*)arg;
    ev->buffer = (char*)malloc(MEM_SIZE);
    bzero(ev->buffer, MEM_SIZE);
    size = recv(sock, ev->buffer, MEM_SIZE, 0);
    printf("receive data:%s, size:%d\n", ev->buffer, size);
    if (size == 0) {
        release_sock_event(ev);
        close(sock);
        return;
    }
    event_set(ev->write_ev, sock, EV_WRITE, on_write, ev->buffer);
    event_base_set(base, ev->write_ev);
    event_add(ev->write_ev, NULL);
}

void on_accept(int sock, short event, void* arg)
{
    struct sockaddr_in cli_addr;
    int newfd, sin_size;
    struct sock_ev* ev = (struct sock_ev*)malloc(sizeof(struct sock_ev));
    ev->read_ev = (struct event*)malloc(sizeof(struct event));
    ev->write_ev = (struct event*)malloc(sizeof(struct event));
    sin_size = sizeof(struct sockaddr_in);
    newfd = accept(sock, (struct sockaddr*)&cli_addr, &sin_size);
    event_set(ev->read_ev, newfd, EV_READ|EV_PERSIST, on_read, ev);
    event_base_set(base, ev->read_ev);
    event_add(ev->read_ev, NULL);
}

int main(int argc, char* argv[])
{
    struct sockaddr_in my_addr;
    int sock;

    sock = socket(AF_INET, SOCK_STREAM, 0);
    int yes = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
    memset(&my_addr, 0, sizeof(my_addr));
    my_addr.sin_family = AF_INET;
    my_addr.sin_port = htons(PORT);
    my_addr.sin_addr.s_addr = INADDR_ANY;
    bind(sock, (struct sockaddr*)&my_addr, sizeof(struct sockaddr));
    listen(sock, BACKLOG);

    struct event listen_ev;
    base = event_base_new();
    event_set(&listen_ev, sock, EV_READ|EV_PERSIST, on_accept, NULL);
    event_base_set(base, &listen_ev);
    event_add(&listen_ev, NULL);
    event_base_dispatch(base);

    return 0;