Libevent book 笔记(1) A tiny introduction to asynchronous IO

最新推荐文章于 2024-03-07 18:49:29 发布
原创 最新推荐文章于 2024-03-07 18:49:29 发布 · 286 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文通过两个示例，深入解析了使用Libevent进行网络编程的方法。首个示例展示了如何手动管理socket读写事件，而第二个示例则引入了bufferevent和evbuffer，简化了事件处理过程。文章详细介绍了bufferevent的优势，包括数据处理和事件触发机制。

闲话不多说，略过一些无关内容，直接入正题。

文章目录

第一个例子

/* 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)
{
    /* 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;

    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;
    state->read_event = event_new(base, fd, EV_READ|EV_PERSIST, do_read, state);
    if (!state->read_event) {
        free(state);
        return NULL;
    }
    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;

    assert(state->write_event);
    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) {
        assert(state->write_event);
        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') {
                assert(state->write_event);
                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) // XXXX use evutil macro
            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) // XXX use evutil macro
                return;
            free_fd_state(state);
            return;
        }
        assert(result != 0);

        state->n_written += result;
    }

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

    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) { // XXXX eagain??
        perror("accept");
    } else if (fd > FD_SETSIZE) {
        close(fd); // XXX replace all closes with EVUTIL_CLOSESOCKET */
    } else {
        struct fd_state *state;
        evutil_make_socket_nonblocking(fd);
        state = alloc_fd_state(base, fd);
        assert(state); /*XXX err*/
        assert(state->write_event);
        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; /*XXXerr*/

    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_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
    /*XXX check it */
    event_add(listener_event, NULL);

    event_base_dispatch(base);
}

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

    run();
    return 0;
}

这里的流程是这样的

  1. 创建一个用于监听的socket
  2. 为这个socket注册连接事件及连接回调函数
  3. 在连接回调函数中，注册读事件和读回调函数
  4. 在读回调函数中，读取数据，处理数据
  5. 如果需要返回数据，则注册写事件和写回调函数，需要注意的是，写事件只能在这里注册，而不能在连接回调函数中，如果不在这里注册写事件，那么写回调函数将不会在正确的时机调用，这涉及到Libevent对读事件的处理机制，将来会有详细说明。
  6. 写回调函数最后需要移除写事件，这也是基于libevent机制所必须的，其原因也有待将来解释，虽然对于这个实例程序而言，这里的原因并不怎么明显。

对于上面5、6两步的了解和理解是很重要的。

第二个例子

/* 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)
{
    /* 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
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);

    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) {
        /* Too long; just process what there is and go on so that the buffer
         * doesn't grow infinitely long. */
        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) {
        /* connection has been closed, do any clean up here */
        /* ... */
    } else if (error & BEV_EVENT_ERROR) {
        /* check errno to see what error occurred */
        /* ... */
    } else if (error & BEV_EVENT_TIMEOUT) {
        /* must be a timeout event handle, handle it */
        /* ... */
    }
    bufferevent_free(bev);
}

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_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; /*XXXerr*/

    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_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
    /*XXX check it */
    event_add(listener_event, NULL);

    event_base_dispatch(base);
}

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

    run();
    return 0;
}

这个例子与前一个例子的主要不同在于使用了bufferevent和evbuffer。从概念上说，bufferevent强调的是buffer及event，而evbuffer强调的是buffer。具体的定义当然要看具体的文档，这里只是简单的说以方便记忆。

两个例子的区别在于

  • 第二个例子没有实现do_read和do_write两个函数，只实现了一个readcb。
  • 第二个例子没有定义fd_state及相关的操作，已知fd_state包括了event和buffer，或者说bufferevent本身就是类似于fd_state的一个数据结构，此外bufferevent还封装了底层的fd。
  • 第二个例子接收完数据就直接把数据写回到bufferevent的输出缓冲中，等待合适的机会由事件循环自己把数据返回客户端，而不是注册do_write回调。对于libevent来说，这两者本质是一样的，如前面说过的，这里涉及到libevent可写事件的触发及处理机制，姑且将来再详细讨论。
  • 另外，就是evbuffer_readln这个函数，是以'\n'作为一行结束的标志的，所以如果用Telnet测试，这个程序没有问题，如果是手写客户端，发送测试字符串的时候要记得行末加上'\n'
libevent book
01-09
libevent book 必备参考资料，方便学习libevent网络库
LibeventBook
01-17
Libenvent 开发手册，原始英文版本。自己编译生成 PDF版本。英文好的可以参考
A tiny introduction to asynchronous IO
weixin_30362083的博客
10-01 99
http://www.wangafu.net/~nickm/libevent-book/01_intro.html These documents are Copyright (c) 2009-2010 by Nick Mathewson, and are made available under the Creative Commons Attribution-Noncom...
Libevent : LibeventBook
Huntinux
06-28 1940
http://www.wangafu.net/~nickm/libevent-book/ 前言 以下内容是对《LibeventBook》的翻译 Chapter6 : Creating a event_base Before you can use any interesting Libevent function, you need to allocate one ...
libevent英文book
06-25
http://www.wangafu.net/~nickm/libevent-book/ 英文文档
libeventBook（Programming with Libevent.）
11-30
《编程与Libevent》这本书是关于使用Libevent库进行网络编程的重要参考资料。Libevent是一个开源的事件通知库，它提供了一种高效的方式来处理大量的并发I/O操作，特别适合于网络服务器的开发。以下是对该书内容及...
20121021_libevent笔记1
08-04
Libevent笔记 Libevent是一个基于事件触发的网络库，适用于Windows、Linux、BSD等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。下面是对Libevent的详细介绍和解释： 1. 事件驱动，高性能：...
LibeventBook.pdf
06-09
Libevent是一个高性能的事件通知库，支持多种类型的I/O事件，包括网络事件、定时器事件和信号事件。它被广泛应用于需要快速、可扩展和非阻塞I/O操作的应用程序中。Libevent的API设计使得它在Unix和Windows平台上都能...
Libevent book 笔记(9) Bufferevents advanced topics
MYTCHITOS的博客
05-26 654
文章目录Paired buffereventsbufferevent_pair_newbufferevent_pair_get_partnerFiltering buffereventsbufferevent_filter_newLimiting maximum single read/write sizebufferevent_set_max_single_readbufferevent_set_max_single_writebufferevent_get_max_single_readbufferev
关于libevent-book-examples_01----ROT13 server by using select() 一处bug分析及修正
jeremy的博客
09-11 243
刚刚学习libevent这个开源网络库时,在研究libevent-book examples_01 目录下有一例子，使用select（）实现rto13 server. 这个select（）的基本框架在并发连接非常少时可以用来做一个简易服务器，可以在此基础上进行相应修改即可。 此server的功能基本上就是一个 echo server. 我比较关注的是select...
Libevent参考手册（初步）
Clement
07-20 806
1. 从一万英尺外看 Libevent Libevent 是用于编写高速可移植非阻塞 IO 应用的库，其设计目标是： 可移植性：使用 libevent 编写的程序应该可以在 libevent 支持的所有平台上工作。即使 没有好的方式进行非阻塞 IO，libevent 也应该支持一般的方式，让程序可以在受限的环 境中运行。 速度：libevent 尝试使用每个平台上最高速的非阻塞 IO 实现，并且不引入太多的额外 开销。 可扩展性：libevent 被设计为程序即使需要上万个活动套接字的时候也可以良好工作。
libevent入门(转)
diewang5896的博客
11-17 436
花了两天的时间在libevent上，想总结下，就以写简单tutorial的方式吧，貌似没有一篇简单的说明，让人马上就能上手用的。 首先给出官方文档吧： http://libevent.org ，首页有个Programming with Libevent，里面是一节一节的介绍libevent，但是感觉信息量太大了，而且还是英文的-。-（当然，如果想好好用libevent，看看还是很有必要...
libevent的使用
know yourself
04-17 771
一般而言，我们有时候也需要写一些网络通信的功能，但是，用原生的TCP/UDP又让人感觉麻烦。所以，我们还是希望用某些lib。libevent就是一个很好的选择。只要花费一两个小时看了官方的文档[2]，还是很容易开始使用这个lib的。   对于客户端程序，大多数情况下只有一个连接，甚至是一问一答这样的模式。是非常简单的模式。在服务端，我们一般使用Linux，相信现在使用BSD的也少了，更不用说Wi
【亲测免费】 Libevent Book: 原生事件通知库的终极指南
最新发布
gitblog_00001的博客
03-07 422
Libevent Book: 原生事件通知库的终极指南 Libevent 是一个强大的、轻量级的、高性能的事件通知库，它提供了一种高效的方法来处理大量的并发连接和网络 I/O 操作。如果您正在寻找一个易于使用的事件驱动框架来构建高效的网络应用程序，那么 Libevent 可能是您的最佳选择。 在本文中，我们将向您介绍 Libevent Book，这是一个由官方团队编写的权威文档，旨在帮助开发者充分...
Linux c 开发 - libevent
自娱自乐的代码人
12-15 1万+
Libevent介绍 libevent是一个事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。著名分布式缓存软件memcached也是libevent based，而且libevent在使用上可以做到跨平台，而且根据libevent官方网站上公布的数据统计，似乎也有着非凡的性能。
LibEvent中文帮助文档--第1、2、3、4章
zhouyongku的专栏
09-07 1万+
LibEvent中文帮助文档:http://blog.youkuaiyun.com/zhouyongku LibEvent快速可移植非阻塞式网络编程
LibEvent中文帮助文档
热门推荐
zhouyongku的专栏
07-27 2万+
LibEvent中文帮助文档:http://blog.youkuaiyun.com/zhouyongku LibEvent快速可移植非阻塞式网络编程
Libevent学习笔记（一）：基本使用
耗纸的博客
05-03 2737
转载于 http://www.tuicool.com/articles/VZBRBbF 这篇还比较全面。前言其实，现在高性能网络服务器基本都是异步I/O模式构建的，而Libevent就是对select、poll、epoll等各类异步模式接口的封装，通过设置回调函数的方式，在监听文件描述符和套接字读写事件的同时，还兼任定时器和信号接收的管理工作。所以这货对高性能服务器后台开发、跨平台开发、网络开发都
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值