/*
* libevent echo server example.
*/
#include
#include
#include
/* For inet_ntoa. */
#include
/* Required by event.h. */
#include
#include
#include
#include
#include
#include
#include
#include
/* Libevent. */
#include
/* Port to listen on. */
#define SERVER_PORT 5555
/**
* 这个结构是指定的客户端数据，这个例子中只指定了读事件对象。
*/
struct client {
struct event ev_read;
};
/**
* 将一个socket设置成非阻塞模式
*/
int
setnonblock(int fd)
{
int flags;
flags = fcntl(fd, F_GETFL);
if (flags < 0)
return flags;
flags |= O_NONBLOCK;
if (fcntl(fd, F_SETFL, flags) < 0)
return -1;
return 0;
}
/**
* 这个函数当客户端的socket可读时由libevent调用
*/
void
on_read(int fd, short ev, void *arg)
{
struct client *client = (struct client *)arg;
u_char buf[8196];
int len, wlen;
len = read(fd, buf, sizeof(buf));
if (len == 0) {
/* 客户端断开连接，在这里移除读事件并且释放客户数据结构 */
printf("Client disconnected.\n");
close(fd);
event_del(&client->ev_read);
free(client);
return;
}
else if (len < 0) {
/* 出现了其它的错误，在这里关闭socket，移除事件并且释放客户数据结构 */
printf("Socket failure, disconnecting client: %s",
strerror(errno));
close(fd);
event_del(&client->ev_read);
free(client);
return;
}
/* 为了简便，我们直接将数据写回到客户端。通常我们不能在非阻塞的应用程序中这么做，
* 我们应该将数据放到队列中，等待可写事件的时候再写回客户端。 */
wlen = write(fd, buf, len);
if (wlen < len) {
/* 我们没有把所有数据都写回。如果我们有适当的队列/缓存机制，
* 我们能够在再次的可写事件中再次写入剩余的数据。因为这是一个简单的例子，
* 我们仅仅舍去了没有写入的数据。 */
printf("Short write, not all data echoed back to client.\n");
}
}
/**
* 当有一个连接请求准备被接受时，这个函数将被libevent调用。 */
void
on_accept(int fd, short ev, void *arg)
{
int client_fd;
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
struct client *client;
/* 接受新的连接 */
client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
if (client_fd == -1) {
warn("accept failed");
return;
}
/* 设置客户端socket为非阻塞模式。 */
if (setnonblock(client_fd) < 0)
warn("failed to set client socket non-blocking");
/* 我们接受了一个新的客户，分配一个新的客户数据结构对象来保存这个客户的状态。 */
client = calloc(1, sizeof(*client));
if (client == NULL)
err(1, "malloc failed");
/* 设置读事件，libevent将在客户端socket可读时调用on_read函数。
* 我们也会我们也会不断的响应读事件，所以我们不用在每次读取时再次添加读事件。 */
event_set(&client->ev_read, client_fd, EV_READ|EV_PERSIST, on_read,
client);
/* 设置的事件并没有激活，使用添加事件让其激活。 */
event_add(&client->ev_read, NULL);
printf("Accepted connection from %s\n",
inet_ntoa(client_addr.sin_addr));
}
int
main(int argc, char **argv)
{
int listen_fd;
struct sockaddr_in listen_addr;
int reuseaddr_on = 1;
/* 接受连接请求的事件对象。 */
struct event ev_accept;
/* 初始化 libevent. */
event_init();
/* 创建我们监听的socket。 */
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0)
err(1, "listen failed");
if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on,
sizeof(reuseaddr_on)) == -1)
err(1, "setsockopt failed");
memset(&listen_addr, 0, sizeof(listen_addr));
listen_addr.sin_family = AF_INET;
listen_addr.sin_addr.s_addr = INADDR_ANY;
listen_addr.sin_port = htons(SERVER_PORT);
if (bind(listen_fd, (struct sockaddr *)&listen_addr,
sizeof(listen_addr)) < 0)
err(1, "bind failed");
if (listen(listen_fd, 5) < 0)
err(1, "listen failed");
/* 设置socket为非阻塞模式，使用libevent编程这是必不可少的。 */
if (setnonblock(listen_fd) < 0)
err(1, "failed to set server socket to non-blocking");
/* 我们现在有了一个监听的socket，我们创建一个读事件，当有客户连接时，接收通知。 */
event_set(&ev_accept, listen_fd, EV_READ|EV_PERSIST, on_accept, NULL);
event_add(&ev_accept, NULL);
/* 开始 libevent 的事件循环。 */
event_dispatch();
return 0;
}
第二个例子：
/*
* libevent echo server example.
*/
#include
#include
#include
/* For inet_ntoa. */
#include
/* Required by event.h. */
#include
#include
#include
#include
#include
#include
#include
#include
/* Easy sensible linked lists. */
#include "queue.h"
/* Libevent. */
#include
/* Port to listen on. */
#define SERVER_PORT 5555
/* Length of each buffer in the buffer queue. Also becomes the amount
* of data we try to read per call to read(2). */
#define BUFLEN 1024
/**
* 在以事件为基础的编程时，我们需要一个队列来存储要写入的数据，
* 直到libevent通知我们可以写入，才能够真正的写入数据。这个简单的buffer队列用
* queue.h中的TAILQ来写入。
*/
struct bufferq {
/* The buffer. */
u_char *buf;
/* The length of buf. */
int len;
/* 本次写buffer的开始位置偏移。 */
int offset;
/* 链表结构。 */
TAILQ_ENTRY(bufferq) entries;
};
/**
* 指定的客户数据结构，也包含一个存储一列用户的指针。
*
* 在基于事件的程序中，通常需要为每个客户保存一些状态信息的对象。
*/
struct client {
/* 事件对象。我们需要两个事件对象，一个用于读事件一个用于写事件通知。 */
struct event ev_read;
struct event ev_write;
/* 这是数据队列，它将被写入这个客户端。我们只能等到libevent告诉我们这个socket准备好写入时，
* 才能真正写入。 */
TAILQ_HEAD(, bufferq) writeq;
};
/**
* 设置socket为非阻塞模式。
*/
int
setnonblock(int fd)
{
int flags;
flags = fcntl(fd, F_GETFL);
if (flags < 0)
return flags;
flags |= O_NONBLOCK;
if (fcntl(fd, F_SETFL, flags) < 0)
return -1;
return 0;
}
/**
* 当客户端socket可读时，libevent调用这个函数。
*/
void
on_read(int fd, short ev, void *arg)
{
struct client *client = (struct client *)arg;
struct bufferq *bufferq;
u_char *buf;
int len;
/* 因为我们需要在可写事接收到通知，所以我们需要分配读取缓冲区，
* 并且将它放到客户数据对象的写入队列。 */
buf = malloc(BUFLEN);
if (buf == NULL)
err(1, "malloc failed");
len = read(fd, buf, BUFLEN);
if (len == 0) {
/* 客户端断开连接，在这里移除读事件并释放客户数据结构。 */
printf("Client disconnected.\n");
close(fd);
event_del(&client->ev_read);
free(client);
return;
}
else if (len < 0) {
/* 一些其它的错误发生，在这里关闭socket、事件对象并释放客户数据结构。 */
printf("Socket failure, disconnecting client: %s",
strerror(errno));
close(fd);
event_del(&client->ev_read);
free(client);
return;
}
/* 我们不能仅仅将buffer写回，因为我们需要在可以写入时响应libevent的可写事件，
* 将缓冲区放到客户数据结构中的写队列，并安排一个可写事件。 */
bufferq = calloc(1, sizeof(*bufferq));
if (bufferq == NULL)
err(1, "malloc faild");
bufferq->buf = buf;
bufferq->len = len;
bufferq->offset = 0;
TAILQ_INSERT_TAIL(&client->writeq, bufferq, entries);
/* 由于现在我们拥有需要写回到客户端的数据，所以添加一个可写事件通知。 */
event_add(&client->ev_write, NULL);
}
/**
* 当客户端socket准备好写入时，libevent调用这个函数。
*/
void
on_write(int fd, short ev, void *arg)
{
struct client *client = (struct client *)arg;
struct bufferq *bufferq;
int len;
/* 将第一个元素移出写队列。我们可能不用再探测写队列是否是空，但是应该确认返回值不是NULL。 */
bufferq = TAILQ_FIRST(&client->writeq);
if (bufferq == NULL)
return;
/* 写buffer里的数据。buffer中的一部分可能已经在前面写入了，所以只写剩下的字节。 */
len = bufferq->len - bufferq->offset;
len = write(fd, bufferq->buf bufferq->offset,
bufferq->len - bufferq->offset);
if (len == -1) {
if (errno == EINTR || errno == EAGAIN) {
/* 写操作被一个信号打断，或者我们不能写入数据，调整一下并返回。 */
event_add(&client->ev_write, NULL);
return;
}
else {
/* 一些其它的socket错误发生，退出吧。 */
err(1, "write");
}
}
else if ((bufferq->offset len) < bufferq->len) {
/* 不是所有的数据都被写入了，更新写入的偏移并调整写入事件。 */
bufferq->offset = len;
event_add(&client->ev_write, NULL);
return;
}
/* 数据已经完整的写入了，从写队列中移除这个buffer。 */
TAILQ_REMOVE(&client->writeq, bufferq, entries);
free(bufferq->buf);
free(bufferq);
}
/**
* 当有一个连接请求准备被接受时，libevent将调用这个函数。
*/
void
on_accept(int fd, short ev, void *arg)
{
int client_fd;
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
struct client *client;
/* 接受这个新的连接请求。 */
client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
if (client_fd == -1) {
warn("accept failed");
return;
}
/* 设置客户端socket为非阻塞模式。 */
if (setnonblock(client_fd) < 0)
warn("failed to set client socket non-blocking");
/* 我们已经接受了一个新的客户，分配一个客户数据结构对象来保存这个客户的状态。 */
client = calloc(1, sizeof(*client));
if (client == NULL)
err(1, "malloc failed");
/* 设置读事件，当客户端socket可读时，libevent将调用on_read()函数。
* 我们也不断的构造可读事件，所以不用再每次读取时从新加入读事件了。 */
event_set(&client->ev_read, client_fd, EV_READ|EV_PERSIST, on_read,
client);
/* 设置的事件没有激活，添加事件以便激活它。 */
event_add(&client->ev_read, NULL);
/* 创建写事件，但是在我们有数据可写之前，不要添加它。 */
event_set(&client->ev_write, client_fd, EV_WRITE, on_write, client);
/* 初始化客户端写队列。 */
TAILQ_INIT(&client->writeq);
printf("Accepted connection from %s\n",
inet_ntoa(client_addr.sin_addr));
}
int
main(int argc, char **argv)
{
int listen_fd;
struct sockaddr_in listen_addr;
int reuseaddr_on = 1;
/* socket的接受事件对象。 */
struct event ev_accept;
/* 初始化 libevent. */
event_init();
/* 创建我们的监听socket。 This is largely boiler plate
* code that I'll abstract away in the future. */
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0)
err(1, "listen failed");
if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on,
sizeof(reuseaddr_on)) == -1)
err(1, "setsockopt failed");
memset(&listen_addr, 0, sizeof(listen_addr));
listen_addr.sin_family = AF_INET;
listen_addr.sin_addr.s_addr = INADDR_ANY;
listen_addr.sin_port = htons(SERVER_PORT);
if (bind(listen_fd, (struct sockaddr *)&listen_addr,
sizeof(listen_addr)) < 0)
err(1, "bind failed");
if (listen(listen_fd, 5) < 0)
err(1, "listen failed");
/* 设置socket为非阻塞模式，这个在使用libevent编程中时必须的。 */
if (setnonblock(listen_fd) < 0)
err(1, "failed to set server socket to non-blocking");
/* 我们现在有了一个监听的socket，我们创建一个读事件，以便有客户连接请求时能够接收到通知。 */
event_set(&ev_accept, listen_fd, EV_READ|EV_PERSIST, on_accept, NULL);
event_add(&ev_accept, NULL);
/* 启动 libevent 时间循环. */
event_dispatch();
return 0;
}
第三个例子：
/*
* libevent echo server example using buffered events.
*/
#include
#include
#include
#include
/* Required by event.h. */
#include
#include
#include
#include
#include
#include
#include
#include
/* Libevent. */
#include
/* Port to listen on. */
#define SERVER_PORT 5555
/**
* 指定用户数据的结构，也包含一列用户的指针。
*/
struct client {
/* 客户端socket */
int fd;
/* 这个客户的 bufferedevent 对象。 */
struct bufferevent *buf_ev;
};
/**
* 设置一个socket为非阻塞模式。
*/
int
setnonblock(int fd)
{
int flags;
flags = fcntl(fd, F_GETFL);
if (flags < 0)
return flags;
flags |= O_NONBLOCK;
if (fcntl(fd, F_SETFL, flags) < 0)
return -1;
return 0;
}
/**
* 当有数据可读时，libevent调用这个函数
*/
void
buffered_on_read(struct bufferevent *bev, void *arg)
{
/* 写回读缓冲区。注意 bufferevent_write_buffer 将逐渐发送完输入的数据
* 所以我们调用它时，它就开始生效了。 */
bufferevent_write_buffer(bev, bev->input);
}
/**
* 当写缓冲为0时，libevent调用这个函数。我们写出这个函数只是因为libevent需要，但是我们没有使用它。
*/
void
buffered_on_write(struct bufferevent *bev, void *arg)
{
}
/**
* 当基础的socket描述符发生错误时，libevent将调用这个函数。
*/
void
buffered_on_error(struct bufferevent *bev, short what, void *arg)
{
struct client *client = (struct client *)arg;
if (what & EVBUFFER_EOF) {
/* 客户端断开连接，在这里移除读事件并释放客户数据结构。 */
printf("Client disconnected.\n");
}
else {
warn("Client socket error, disconnecting.\n");
}
bufferevent_free(client->buf_ev);
close(client->fd);
free(client);
}
/**
* 当有一个连接请求准备被接受时，这个函数将被libevent调用。
*/
void
on_accept(int fd, short ev, void *arg)
{
int client_fd;
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
struct client *client;
client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
if (client_fd < 0) {
warn("accept failed");
return;
}
/* 设置客户端socket为非阻塞模式。 */
if (setnonblock(client_fd) < 0)
warn("failed to set client socket non-blocking");
/* 我们接受一个新的客户，创建一个客户数据结构对象。 */
client = calloc(1, sizeof(*client));
if (client == NULL)
err(1, "malloc failed");
client->fd = client_fd;
/* 创建 buffered 事件。
*
* 第一个参数是引起事件的文件描述符，这里是客户端socket。
*
* 第二个参数是一个回调函数，当数据已经被socket读取并且对程序有效时，它被调用。
*
* 第三个参数是一个回调函数，当写缓冲区到达最小值时，它被调用。
* 这通常意味着，当写入缓冲区长度为0时，这个回调函数将被调用。
* 它必须被定义，但是实际上你可以在这个回调函数中不做任何处理。
*
* 第四个参数是一个回调函数，当有socket错误发生时，它被调用。
* 在这里你可以探测客户端断开连接，或者其它的错误。
*
* 第五个参数用来存储一个将会传递给各个回调函数的参数。我们在这里存储客户数据对象。
*/
client->buf_ev = bufferevent_new(client_fd, buffered_on_read,
buffered_on_write, buffered_on_error, client);
/* 我们必须在回调函数被调用前，使它有效。 */
bufferevent_enable(client->buf_ev, EV_READ);
printf("Accepted connection from %s\n",
inet_ntoa(client_addr.sin_addr));
}
int
main(int argc, char **argv)
{
int listen_fd;
struct sockaddr_in listen_addr;
struct event ev_accept;
int reuseaddr_on;
/* 初始化 libevent. */
event_init();
/* 创建我们的监听socket。 */
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0)
err(1, "listen failed");
memset(&listen_addr, 0, sizeof(listen_addr));
listen_addr.sin_family = AF_INET;
listen_addr.sin_addr.s_addr = INADDR_ANY;
listen_addr.sin_port = htons(SERVER_PORT);
if (bind(listen_fd, (struct sockaddr *)&listen_addr,
sizeof(listen_addr)) < 0)
err(1, "bind failed");
if (listen(listen_fd, 5) < 0)
err(1, "listen failed");
reuseaddr_on = 1;
setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on,
sizeof(reuseaddr_on));
/* 设置socket为非阻塞模式，这种与libevent编程时是必须的。 */
if (setnonblock(listen_fd) < 0)
err(1, "failed to set server socket to non-blocking");
/* 我们现在有了一个监听socket，我们创建一个读事件，以便在有客户连接请求时能够接收到通知。 */
event_set(&ev_accept, listen_fd, EV_READ|EV_PERSIST, on_accept, NULL);
event_add(&ev_accept, NULL);
/* 开始事件循环。 */
event_dispatch();
return 0;
}
联系客服
