【libevent】libevent简介
1、Libevent
1.1 简介
Libevent 是一个用C语言编写的、轻量级的开源高性能事件驱动网络库。
基本的socket编程是阻塞/同步的，每个操作除非已经完成或者出错才会返回，这样对于每一个请求，要使用一个线程或者单独的进程去处理，系统资源没法支撑大量的请求，于是各系统分别提出了基于异步/callback的系统调用，例如Linux的epoll，BSD的kqueue，Windows的IOCP。由于在内核层面做了支持，所以可以用O(1)的效率查找到active的fd。
libevent就是对这些高效IO的封装，提供统一的API，简化开发。
1.2 特点
libevent是一个用于开发可扩展性网络服务器的基于事件驱动(event-driven)模型的网络库。Libevent有几个显著的特点：
（1）事件驱动（event-driven），高性能；
（2）轻量级，专注于网络，不如 ACE 那么臃肿庞大；
（3）跨平台，支持 Windows、Linux、*BSD和 Mac Os；
（4）支持多种I/O多路复用技术，epoll、poll、dev/poll、select和kqueue等；
（5）支持I/O，定时器和信号等事件；
（6）采用Reactor模式；
libevent实现高并发的关键在于其基于事件驱动的异步模型。主要实现方式包括：
- 事件驱动: libevent使用事件循环机制，通过监听和响应事件来实现非阻塞IO操作。当有事件发生时，libevent会调用相应的回调函数进行处理，从而避免了传统同步阻塞IO模型中的线程阻塞和资源浪费。
- 多路复用: libevent利用操作系统提供的多路复用机制（如epoll、kqueue、select等），将多个IO操作事件集中管理，实现在单线程或少量线程上处理大量并发连接的能力。这样可以避免每个连接都需要一个线程的资源消耗，从而提高了系统的并发性能。
- 缓冲区管理: libevent的bufferevent模块提供了高效的缓冲区管理，可以在网络IO中缓冲数据，以减少系统调用次数和数据拷贝，从而提升性能。
- 非阻塞IO: libevent使用非阻塞IO操作，通过设置套接字为非阻塞模式，使得IO操作不会阻塞整个进程或线程，提高了处理并发连接的效率。
1.3 下载安装
这里下载的是libevent-2.1.11-stable.tar.gz
tar -zxvf libevent-2.1.11-stable.tar.gz
cd libevent-2.1.11-stable/
./configure --prefix=`pwd`/install #检查安装环境，指定安装路径，生成makefile
make
make install
1.4 测试
在sample文件下有libevent提供的测试程序
#服务器端
cd libevent-2.1.11-stable/sample
./hello-world
#客户端（另开一个窗口）
netcat 127.0.0.1 9995 #收到hello world
2、事件驱动
2.1 简介
事件驱动（Event-Driven）是一种编程范式，系统中的各种操作是通过事件的发生来驱动的。事件驱动编程模型通过事件监听器（Listener）和事件处理器（Handler）来响应和处理各种事件。
事件驱动模型的核心是通过事件（Event）来触发操作。事件可以是用户的操作（如鼠标点击、键盘输入），也可以是系统内部的状态变化（如定时器事件、网络数据到达）。事件驱动编程通过事件循环（Event Loop）不断地等待和处理事件，从而实现系统的响应和交互。
2.2 组成部分
- 事件：事件是系统中的一种信号，表示某种操作或状态的发生。事件可以携带额外的信息，如鼠标位置、键盘按键值、网络数据等。
- 事件源（Event Source）：事件源是事件的产生者，可以是用户输入设备、网络连接、定时器等。
- 事件监听器（Event Listener）：事件监听器是一个回调函数或方法，用于监听和捕获特定类型的事件。当事件发生时，事件监听器会被触发并调用相应的事件处理器。
- 事件处理器（Event Handler）：事件处理器是实际处理事件的逻辑，包含具体的业务操作。
- 事件循环（Event Loop）：事件循环是事件驱动模型的核心，负责不断地等待和分发事件。事件循环通常是一个无限循环，通过检查事件队列或事件多路复用器来获取事件，并调用相应的事件处理器。
2.3 工作流程
- 事件注册：应用程序将事件和对应的事件监听器注册到事件源。
- 事件产生：当事件源产生事件时，事件被放入事件队列中等待处理
- 事件分发：事件循环不断地从事件队列中取出事件，将事件分发给相应的事件监听器。
- 事件处理：事件监听器调用事件处理器，执行相应的业务逻辑。
- 事件循环继续：事件处理完成后，事件循环继续等待和处理下一个事件。
3、Reactor模式
3.1 简介
Reactor模式是一种高效的事件驱动设计模式，广泛应用于高性能服务器和网络应用中。它通过将事件的检测和分发与实际的事件处理逻辑分离，提供了一种高效的多任务并发处理方法。
3.2 事件处理机制
普通函数调用的机制：
- 函数调用：调用一个函数，传递必要的参数。
- 执行函数：程序执行进入函数体，按顺序执行函数内的代码。
- 返回结果：函数执行完毕后返回结果，程序继续执行调用处之后的代码。
- 阻塞执行：在函数执行期间，调用线程会被阻塞，直到函数返回结果。
而事件驱动机制不同，程序不是主动的调用某个API完成处理，恰恰相反，Reactor逆置了事件处理流程，应用程序需要提供相应的接口并注册到Reactor上，如果相应的事件发生，Reactor将主动调用应用程序注册的接口，这些接口又称为“回调函数”
3.3 组成部分
描述符（handle）：由操作系统提供，用于识别每一个事件，如Socket描述符、文件描述符等。在Linux中，它用一个整数来表示。事件可以来自外部，如来自客户端的连接请求、数据等。事件也可以来自内部，如定时器事件。
事件多路复用器（Event Demultiplexer）：使用操作系统提供的多路复用机制（如select、poll、epoll、kqueue）来监听多个事件源。程序首先将其关心的句柄（事件源）及其事件注册到event demultiplexer上； 当有事件到达时，event demultiplexer会通知程序处理事件。
反应器 Reactor：事件管理的接口，内部使用event demultiplexer注册、注销事件，并运行事件循环，当有事件进入“就绪”状态时，调用注册事件的回调函数处理事件。（libevent中的event_base结构体）
事件处理器（Event Handler）：提供了一组接口（回调函数），每个接口对应了一种类型的事件，供Reactor在相应的事件发生时调用，执行相应的事件处理。
3.4 工作流程
4、基本使用
4.1 事件处理流程
- 应用程序准备并初始化event，设置事件类型和回调函数
- 向libevent添加事件event。对于定时事件，libevent使用一个小根堆管理，key为超时时间；对于Signal和I/O事件，libevent将其放入到等待链表（wait list）中，这是一个双向链表
- 程序调用event_base_dispatch()系列函数进入无限循环，等待事件
5、源码分析
5.1 event_base
libevent默认情况下是单线程的（可以配置成多线程），每个线程有且只有一个event_base，对应一个struct event_base结构体（以及附于其上的事件管理器），用来托管给它的一系列event，可以和操作系统的进程管理类比，当一个事件发生后，event_base会在合适的时间（不一定是立即）去调用绑定在这个事件上的函数，直到这个函数执行完，再返回其他事件。
event_base结构体就是Reactor框架中的反应器Reactor。
结构体声明位于event-internal.h文件中。
//创建一个event_base
struct event_base *base = event_base_new();
assert(base != NULL);
event_base内部有一个循环，循环阻塞在epoll/kqueue等系统调用上，直到有事件发生，然后去处理这些事件。
启动event_base的循环，这样才能开始处理发生的事件。循环的启动使用event_base_dispatch，循环将一直持续，直到不再有需要关注的事件，或者是遇到event_loopbreak()/event_loopexit()函数。
//启动事件循环
event_base_dispatch(base);
使用完 event_base 之后,使用 event_base_free()进行释放。
void event_base_free(struct event_base *base);
5.2 事件event
event是整个libevent的核心。event就是Reactor框架中的事件处理程序组件。它提供了函数接口，供Reactor在事件发生时调用，以执行相应的事件处理。
5.2.1. 事件类型
libevent 支持以下几种主要的事件类型：
- I/O 事件：用于监视文件描述符（如套接字）的可读、可写状态。
- 定时事件：在指定的时间间隔之后触发。
- 信号事件：用于处理 UNIX 信号。
调用 libevent 函数设置事件并且关联到 event_base 之后，事件进入“已初始化(initialized)”状态。此时可以将事件添加到 event_base 中，这使之进入“未决(pending)”状态。
在未决状态下，如果触发事件的条件发生，则事件进入“激活(active)”状态，事件回调函数将被执行。如果配置为“持久的(persistent)”，事件将保持为未决状态。否则，执行完回调后，事件不再是未决的。删除操作可以让未决事件成为非未决(已初始化)的 ; 添加操作可以让非未决事件再次成为未决的。
5.2.2 创建event
每个事件对应一个struct event，struct event使用event_new来创建和绑定，使用event_add来启用：
//创建并绑定一个event
struct event *event;
//参数：event_base, 监听的fd，事件类型及属性，绑定的回调函数，给回调函数的参数
event = event_new(base, listener, EV_READ|EV_PERSIST, callback_func, (void*)base);
//参数：event，超时时间(struct timeval *类型的，NULL表示无超时设置)
event_add(event, NULL);
libevent支持的事件及属性包括(使用bitfield实现，所以要用 | 来让它们合体)
(1) EV_TIMEOUT: 超时
(2) EV_READ: 只要网络缓冲中还有数据，回调函数就会被触发
(3) EV_WRITE: 只要塞给网络缓冲的数据被写完，回调函数就会被触发
(4) EV_SIGNAL: POSIX信号量
(5) EV_PERSIST: 不指定这个属性的话，回调函数被触发后事件会被删除
(6) EV_ET: Edge-Trigger边缘触发，参考EPOLL_ET
5.2.3 管理event
每次当有事件event转变为就绪状态时，libevent就会把它移入到active event list[priority]中，其中priority是event的优先级。
libevent会根据自己的调度策略选择就绪事件，调用其callback()函数执行事件处理；并根据就绪的句柄和事件类型填充callback函数的参数
5.2.4 检查事件状态
/*确定给定的事件是否是未决的或者激活的。如果是,而且 what 参 数设置了 EV_READ、EV_WRITE、EV_SIGNAL 或者 EV_TIMEOUT 等标志,则函数会返回事件当前为之未决或者激活的所有标志 。如果提供了 tv_out 参数,并且 what 参数中设置了 EV_TIMEOUT 标志,而事件当前正因超时事件而未决或者激活,则 tv_out 会返回事件的超时值。*/
int event_pending(const struct event *ev, short what, struct timeval *tv_out);
//事件配置的文件描述符
evutil_socket_t event_get_fd(const struct event *ev);
//事件配置的 event_base
struct event_base *event_get_base(const struct event *ev);
//返回事件的标志(EV_READ、EV_WRITE 等)
short event_get_events(const struct event *ev);
//返回事件的回调函数及其参数指针
event_callback_fn event_get_callback(const struct event *ev);
void *event_get_callback_arg(const struct event *ev);
5.2.5 一次触发事件
如果不需要多次添加一个事件,或者要在添加后立即删除事件,而事件又不需要是持久的 , 则可以使用 event_base_once()。
int event_base_once(struct event_base *, evutil_socket_t, short, void (*)(evutil_socket_t, short, void *), void *, const struct timeval *);
- 除了不支持 EV_SIGNAL 或者 EV_PERSIST 之外，这个函数的接口与 event_new()相同。
- 安排的事件将以默认的优先级加入到 event_base并执行。回调被执行后,libevent内部将 会释放 event 结构。
- 不能删除或者手动激活使用 event_base_once ()插入的事件，如果要取消事件, 应该使用 event_new()或者 event_assign()。
5.2.6 事件状态的转换
5.3 事件主循环
在libevent中，事件主循环的作用就是执行一个循环，在循环中监听事件以及超时的事件并且将这些激活的事件进行处理。libevent提供了对用户开放了两种执行事件主循环的函数：
int event_base_dispatch(struct event_base *);
int event_base_loop(struct event_base *, int);
在event_base_dispatch函数中，实际上调用的是event_base_loop(event_base, 0)。
event_base_loop()函数的定义：
int event_base_loop(struct event_base *base, int flags){
const struct eventop *evsel = base->evsel;
void *evbase = base->evbase;
struct timeval tv;
struct timeval *tv_p;
int res, done;
// 清空时间缓存
base->tv_cache.tv_sec = 0;
// evsignal_base是全局变量，在处理signal时，用于指名signal所属的event_base实例
if (base->sig.ev_signal_added)
evsignal_base = base;
done = 0;
while (!done) { // 事件主循环
// 查看是否需要跳出循环，程序可以调用event_loopexit_cb()设置event_gotterm标记
// 调用event_base_loopbreak()设置event_break标记
if (base->event_gotterm) {
base->event_gotterm = 0;
break;
}
if (base->event_break) {
base->event_break = 0;
break;
}
// 校正系统时间，如果系统使用的是非MONOTONIC时间，用户可能会向后调整了系统时间
// 在timeout_correct函数里，比较last wait time和当前时间，如果当前时间< last wait time
// 表明时间有问题，这是需要更新timer_heap中所有定时事件的超时时间。
timeout_correct(base, &tv);
// 根据timer heap中事件的最小超时时间，计算系统I/O demultiplexer的最大等待时间
tv_p = &tv;
if (!base->event_count_active && !(flags & EVLOOP_NONBLOCK)) {
timeout_next(base, &tv_p);
} else {
// 依然有未处理的就绪时间，就让I/O demultiplexer立即返回，不必等待
// 下面会提到，在libevent中，低优先级的就绪事件可能不能立即被处理
evutil_timerclear(&tv);
}
// 如果当前没有注册事件，就退出
if (!event_haveevents(base)) {
event_debug(("%s: no events registered.", __func__));
return (1);
}
// 更新last wait time，并清空time cache
gettime(base, &base->event_tv);
base->tv_cache.tv_sec = 0;
// 调用系统I/O demultiplexer等待就绪I/O events，可能是epoll_wait，或者select等；
// 在evsel->dispatch()中，会把就绪signal event、I/O event插入到激活链表中
res = evsel->dispatch(base, evbase, tv_p);
if (res == -1)
return (-1);
// 将time cache赋值为当前系统时间
gettime(base, &base->tv_cache);
// 检查heap中的timer events，将就绪的timer event从heap上删除，并插入到激活链表中
timeout_process(base);
// 调用event_process_active()处理激活链表中的就绪event，调用其回调函数执行事件处理
// 该函数会寻找最高优先级（priority值越小优先级越高）的激活事件链表，
// 然后处理链表中的所有就绪事件；
// 因此低优先级的就绪事件可能得不到及时处理；
if (base->event_count_active) {
event_process_active(base);
if (!base->event_count_active && (flags & EVLOOP_ONCE))
done = 1;
} else if (flags & EVLOOP_NONBLOCK)
done = 1;
}
// 循环结束，清空时间缓存
base->tv_cache.tv_sec = 0;
event_debug(("%s: asked to terminate loop.", __func__));
return (0);
}
5.4 bufferevent
5.4.1 简介
bufferevent专门为封装成带有缓冲区的socket套接字。一个bufferevent包含了一个底层传输的fd（通常为socket），一个输入buffer和一个输出buffer。每个 bufferevent 有两个与数据相关的回调：读取回调函数和写入回调函数。 bufferevent中回调函数触发的条件与普通的event回调函数触发的条件不同（ 普通的事件在底层传输端口已经就绪，可读或可写时就会执行回调函数，而 bufferevent 是在读取或写入了一定量的数据后才会调用回调函数）。
struct bufferevent结构体定义：
//bufferevent_struct.h文件
struct bufferevent {
struct event_base *ev_base; //执行ev_base,最后需要将socket fd添加进ev_base。
//操作结构体，成员有一些函数指针。类似struct eventop结构体
const struct bufferevent_ops *be_ops;
struct event ev_read;//读事件event
struct event ev_write;//写事件event
struct evbuffer *input;//读缓冲区
struct evbuffer *output; //写缓冲区
struct event_watermark wm_read;//读水位
struct event_watermark wm_write;//写水位
bufferevent_data_cb readcb;//可读时的回调函数指针
bufferevent_data_cb writecb;//可写时的回调函数指针
bufferevent_event_cb errorcb;//错误发生时的回调函数指针
void *cbarg;//回调函数的参数
struct timeval timeout_read;//读事件event的超时值
struct timeval timeout_write;//写事件event的超时值
/** Events that are currently enabled: currently EV_READ and EV_WRITE
are supported. */
short enabled;
};
5.4.2 水位线
我们刚刚说bufferevent两个数据相关的回调：一个读取回调和一个写入回调，bufferevent 是在读取或写入了一定量的数据后才会调用回调函数。通过调整bufferevent的读取和写入“水位（watermarks）”可以覆盖这些函数的默认行为。
每个bufferevent有四个水位：
读取低水位：读取操作使得输入缓冲区的数据量在此级别或者更高时，读取回调将被调用。默认值为0，所以每个读取操作都会导致读取回调被调用。
读取高水位：输入缓冲区中的数据量达到此级别后，bufferevent将停止读取，直到输入缓冲区中足够量的数据被抽取，使得数据量低于此级别。默认值是无限，所以永远不会因为输入缓冲区的大小而停止读取。
写入低水位：写入操作使得输出缓冲区的数据量达到或者低于此级别时，写入回调将被调用。默认值是0，所以只有输出缓冲区空的时候才会调用写入回调。
写入高水位：bufferevent没有直接使用这个水位。它在bufferevent用作另外一个bufferevent的底层传输端口时有特殊意义。
5.4.3 evbuffer
bufferevent采用evbuffer作为输入输出缓存。evbuffer像是一个字节队列，在队列的末尾写入数据，在队列的头部读取数据。evbuffer具体实现则是一个链表，链表中的每个节点都是一块连续的内存块，往evbuffer写数据时（调用evbuffer_add/evbuffer_add_printf等函数），evbuffer内部动态创建链表节点，并紧凑的写入数据（一个节点写满后，再写另外一个节点）；从evbuffer中删除数据时（调用evbuffer_remove/evbuffer_drain），从链表头部节点开始读取，当一个节点的数据被全部读取后删除该节点，如果未读取完，则用标示记录数据已读取（删除）的位置。对于这种头部有数据被标示为读取（删除）的节点，再次写入数据时，可能会进行调整，即将数据部分整体往前拷贝移动，然后再继续写入数据。
关于evbuffer和bufferevent的详细介绍可以参考：http://t.csdnimg.cn/rit2P
5.4.4 bufferevent 选项标志
- BEV_OPT_CLOSE_ON_FREE :释放 bufferevent 时关闭底层传输端口。这将关闭底层套接字,释放底层 bufferevent 等。
- BEV_OPT_THREADSAFE :自动为 bufferevent 分配锁,这样就可以安全地在多个线程中使用 bufferevent。
- BEV_OPT_DEFER_CALLBACKS :设置这个标志时, bufferevent 延迟所有回调,如上所述。
- BEV_OPT_UNLOCK_CALLBACKS :默认情况下,如果设置 bufferevent 为线程安全 的,则 bufferevent 会在调用用户提供的回调时进行锁定。设置这个选项会让 libevent 在执行回调的时候不进行锁定。
5.4.5 使用
5.4.5.4 创建bufferevent
struct bufferevent *bufferevent_socket_new(
struct event_base *base,
evutil_socket_t fd,
enum bufferevent_options options);
5.4.5.5 连接
int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *address, int addrlen);
address 和 addrlen 参数跟标准调用 connect()的参数相同。如果还没有为 bufferevent 设置套接字,调用函数将为其分配一个新的流套接字,并且设置为非阻塞的。
如果已经为 bufferevent 设置套接字,调用bufferevent_socket_connect() 将告知 libevent 套接字还未连接,直到连接成功之前不应该对其进行读取或者写入操作。
6、evbuffer
6.1 简介
Libevent提供了evbuffer用于处理缓冲网络IO的缓冲部分，为后续bufferevent的工作做准备。
缓冲区由evbuffer和evbuffer_chain组成，其中evbuffer_chain是真正存储数据的一块内存，通过链表将一个一个的evbuffer_chain连接在一起，组成内存池,可以存放很多的缓冲数据。。而通过evbuffer结构体就可以管理这个内存池链表了。
struct evbuffer结构体定义如下：
//evbuffer-internal.h文件
struct evbuffer_chain;
struct evbuffer {
struct evbuffer_chain *first;
struct evbuffer_chain *last;
//这是一个二级指针。使用*last_with_datap时，指向的是链表中最后一个有数据的evbuffer_chain。
//所以last_with_datap存储的是倒数第二个evbuffer_chain的next成员地址。
//一开始buffer->last_with_datap = &buffer->first;此时first为NULL。所以当链表没有节点时
//*last_with_datap为NULL。当只有一个节点时*last_with_datap就是first。
struct evbuffer_chain **last_with_datap;
size_t total_len;//链表中所有chain的总字节数
...
};
struct evbuffer_chain {
struct evbuffer_chain *next;
size_t buffer_len;//buffer的大小
//错开不使用的空间。该成员的值一般等于0
ev_off_t misalign;
//evbuffer_chain已存数据的字节数
//所以要从buffer + misalign + off的位置开始写入数据
size_t off;
...
unsigned char *buffer;
};
6.2 使用
6.2.1 创建和释放evbuffer
struct evbuffer *evbuffer_new(void);
void evbuffer_free(struct evbuffer *buf);
6.2.2 线程安全
int evbuffer_enable_locking(struct evbuffer *buf, void *lock);
void evbuffer_lock(struct evbuffer *buf);
void evbuffer_unlock(struct evbuffer *buf);
在多个线程中同时访问 evbuffer 是不安全的。如果需要这样的访问,可以调 用 evbuffer_enable_locking() 。如果 lock 参数为 NULL , libevent 会使用evthread_set_lock_creation_callback 提供的锁创建函数创建一个锁 。否则,libevent 将 lock 参数用作锁。
evbuffer_lock()和 evbuffer_unlock()函数分别请求和释放 evbuffer 上的锁。可以使用这两个 函数让一系列操作是原子的。
6.2.3 添加数据
//添加 data 处的 datalen 字节到 buf 的末尾,成功时返回0,失败时返回-1。
int evbuffer_add(struct evbuffer *buf, const void *data, size_t datlen);
//添加格式化的数据到 buf 末尾。
//格式参数和其他参数的处理分别与 C 库函数 printf 和 vprintf 相同。函数返回添加的字节数。
int evbuffer_add_printf(struct evbuffer *buf, const char *fmt, ...)
int evbuffer_add_vprintf(struct evbuffer *buf, const char *fmt, va_list ap);
7、 示例代码
7.1 客户端
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>
#include <fcntl.h>
#include <signal.h>
#include <event2/event.h>
#include <event2/bufferevent.h>
#include <event2/util.h>
#include <arpa/inet.h>
#define IP "127.0.0.1"
#define PORT 8888
void event_cb(struct bufferevent *bev, short events, void *arg)
{
if( events & BEV_EVENT_EOF )
{
printf("Connection closed\n");
}
else if( events & BEV_EVENT_ERROR )
{
printf("Connection error:%s\n", strerror(errno));
}
}
void send_data(evutil_socket_t fd, short events, void *arg)
{
struct bufferevent *bev = (struct bufferevent *)arg;
char buf[32] = "Hello, world!";
printf("%s\n", buf);
bufferevent_write(bev, buf, strlen(buf));
}
int main (int argc, char **argv)
{
struct sockaddr_in addr;
int len = sizeof(addr);
struct event_base *base = NULL;
struct bufferevent *bev = NULL;
struct timeval tv;
struct event *ev = NULL;
base = event_base_new();
if( !base )
{
printf("event_base_new() failure\n");
return -1;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
inet_aton(IP, &addr.sin_addr);
bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
if( !bev )
{
printf("Could not create bufferevent\n");
event_base_free(base);
return -2;
}
bufferevent_setcb(bev, NULL, NULL, event_callback, NULL);
bufferevent_enable(bev, EV_READ | EV_WRITE);
bufferevent_socket_connect(bev, (struct sockaddr *)&addr, len);
tv.tv_sec = 3;
tv.tv_usec = 0;
ev = event_new(base, -1, EV_PERSIST, send_data, bev);
event_add(ev, &tv);
event_base_dispatch(base);
event_free(ev);
bufferevent_free(bev);
event_base_free(base);
return 0;
}
7.2服务器端
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>
#include <fcntl.h>
#include <signal.h>
#include <event2/event.h>
#include <event2/bufferevent.h>
#include <event2/util.h>
#include <event2/listener.h>
#include <arpa/inet.h>
#define PORT 8888
void read_cb(struct bufferevent *bev, void *arg)
{
char buf[32];
int len;
while( (len = bufferevent_read(bev, buf, sizeof(buf))) > 0 )
{
buf[len] = '\0';
printf("%s\n", buf);
}
}
void event_cb(struct bufferevent *bev, short events, void *arg)
{
if( events & BEV_EVENT_EOF )
{
printf("Connection closed\n");
}
else if( events & BEV_EVENT_ERROR )
{
printf("Connection error:%s\n", strerror(errno));
}
}
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *addr, int len, void *arg)
{
struct event_base *base = (struct event_base *)arg;
struct bufferevent *bev = NULL;
bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
if( !bev )
{
printf("bufferevent_socket_new() failure:%s\n", strerror(errno));
close(fd);
return ;
}
bufferevent_setcb(bev, read_cb, NULL, event_callback, NULL);
bufferevent_enable(bev, EV_READ | EV_WRITE);
}
int main (int argc, char **argv)
{
struct sockaddr_in addr;
struct event_base *base = NULL;
struct evconnlistener *listener = NULL;
base = event_base_new();
if( !base )
{
printf("event_base_new() failure\n");
return -1;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
listener = evconnlistener_new_bind(base, listener_cb, base, LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE, -1, (struct sockaddr *)&addr, sizeof(addr));
if( !listener )
{
printf("Can't create a listener\n");
return -2;
}
event_base_dispatch(base);
evconnlistener_free(listener);
event_base_free(base);
return 0;
}
