• Linux网络编程10——libevent库

    学习视频链接​​​​​​​02-web大练习的概述_bilibili_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1iJ411S7UA?p=132&vd_source=0471cde1c644648fafd07b54e303c905

    目录

    一、介绍、下载、解压和安装

    1.1 libevent 库简介

    1.2 下载

    1.3 解压 

    1.4 源码包安装

    二、libevent 框架

    2.1 流程

    2.2 分析 hello-world.c

    2.3 框架相关函数的介绍

    三、常规事件 event

    3.1 事件函数

    3.2 和管道配合编程

    3.3 事件的未决和非未决

    四、带缓冲区的事件 bufferevent

    4.1 简介

    4.2 函数

    五、客户端与服务端

    5.1 用到的函数

    5.2 流程

    5.3 代码实现

    一、介绍、下载、解压和安装

    1.1 libevent 库简介

    开源。精简。跨平台(Windows、 Linux、 maxos、unix)。专注于网络诵信

    特性：基于 "事件" 异步通信模型。依赖回调机制，和 QT 里面信号与槽差不多

    1.2 下载

    1.3 解压 

    1.4 源码包安装

    参考 READIE、readme

    . /configure     检查安装环境生成 makefile

    make    生成 .o 和可执行文件

    sudo make install    将必要的资源 cp 置系统指定目录

    安装过程

    缺少 make 工具，安装一下

     

     

    验证是否安装成功

    进入 sample 目录，运行 demo

    编译错误，说明我们缺少库，添加 libevent 库

    运行的时候报错，error while loading shared libraries: libevent-2.1.so.6

    是用映射把安装目录映射到 hello 能访问到的目录，重新运行就运行了起来

    测试通信成功

    视频中的库所在目录

    二、libevent 框架

    2.1 流程

    1、创建 event_base

            struct event_base *base = event_base_new();

    2、创建 事件 event

            常规事件 event --> event_new();

            bufferevent --> bufferevent_socket_new();

    3、将事件 添加到 base 上

            int event_add(struct event *ev, const struct timeval *tv);

    4、循环监听事件满足

            int event_base_dispath(struct event_base *base);  // 启动循环的函数

                    event_base_dispatch(base);

    5、释放 event_base

            event_base_free(base);

    2.2 分析 hello-world.c

    类似于 QT 的信号与槽，当发生事件的时候，执行下面对应的回调函数

    下面的回调函数主要用来处理：按 ctrl + C 退出程序等 2 s

    2.3 框架相关函数的介绍

     

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11.     struct event_base *base = event_base_new();
    12.     
    13.     const char **buf;
    14.  
    15.     buf = event_get_supported_methods();
    16.     for (int i = 0; i < 5; i++) {
    17.         printf("buf[%d] = %s\n", i, buf[i]);
    18.     }
    19.     
    20.     return 0;
    21. }

    三、常规事件 event

    3.1 事件函数

    1、创建事件

    struct event *event_new(struct event_base *base, evutil_socket_t fd, short what, event_callback_fn cb, void *arg);

            base：event_base_new() 返回值

            fd：绑定到 event 上的文件描述符

            what：对应的事件 (r、w、e)

                    EV_READ        一次 读事件（读一次数据就从循环结束）

                    EV_WRTIE        一次 写事件

                    EV_PERSIST        持续触发。结合 event_base_dispatch 函数使用，生效

            cb：一旦事件满足监听条件，回调的函数

                    typedef void(*event_callback_fn)(evutil_socket_t fd, short, void*);

            arg：回调的函数的参数

            返回值：成功创建的 event

    2、添加事件到 event_base

    int event_add(struct event *ev, const struct timeval *tv);

            ev：event_new() 的返回值

            tv：NULL

    3、从 event_base 上摘除事件

    int event_del();

            ev：event_new() 的返回值

    4、销毁事件

    int event_free(struct event *ev);

            ev：event_new() 的返回值

    3.2 和管道配合编程

    read

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5. #include   
    6. #include   
    7. #include   
    8. #include   
    9.  
    10. // 对操作处理函数  
    11. void read_cb(evutil_socket_t fd, short what, void *arg)  
    12. {  
    13.     // 读管道  
    14.     char buf[1024] = {0};  
    15.       
    16.     int len = read(fd, buf, sizeof(buf));  
    17.           
    18.     printf("read event: %s \n", what & EV_READ ? "Yes" : "No");  
    19.     printf("data len = %d, buf = %s\n", len, buf);  
    20.           
    21.     sleep(1);  
    22. }  
    23.  
    24.  
    25. // 读管道  
    26. int main(int argc, const char* argv[])  
    27. {  
    28.     unlink("myfifo");  
    29.   
    30.     //创建有名管道  
    31.     mkfifo("myfifo", 0664);  
    32.  
    33.     // open file  
    34.     //int fd = open("myfifo", O_RDONLY | O_NONBLOCK);  
    35.     int fd = open("myfifo", O_RDONLY);  
    36.     if(fd == -1)  
    37.     {  
    38.         perror("open error");  
    39.         exit(1);  
    40.     }  
    41.      
    42.     // 创建个event_base  
    43.     struct event_base* base = NULL;  
    44.     base = event_base_new();  
    45.  
    46.     // 创建事件  
    47.     struct event* ev = NULL;  
    48.     ev = event_new(base, fd, EV_READ | EV_PERSIST, read_cb, NULL);  
    49.  
    50.     // 添加事件  
    51.     event_add(ev, NULL);  
    52.  
    53.     // 事件循环  
    54.     event_base_dispatch(base);  // while（1） { epoll();}  
    55.  
    56.     // 释放资源  
    57.     event_free(ev);  
    58.     event_base_free(base);  
    59.     close(fd);  
    60.   
    61.     return 0;  
    62. }

    write

    1. #include     
    2. #include     
    3. #include     
    4. #include     
    5. #include     
    6. #include     
    7. #include     
    8. #include     
    9.     
    10. //  对操作处理函数    
    11. void  write_cb(evutil_socket_t  fd,  short  what,  void  *arg)    
    12. {    
    13.     //  write管道    
    14.     char buf[1024]  =  {0};    
    15.             
    16.     static int num = 0;    
    17.     sprintf(buf, "hello,world-%d\n", num++);    
    18.     write(fd, buf, strlen(buf)+1);    
    19.           
    20.     sleep(1);    
    21. }        
    22.    
    23. //  写管道    
    24. int main(int argc, const char* argv[])    
    25. {    
    26.     // open file    
    27.     //int fd = open("myfifo", O_WRONLY | O_NONBLOCK);    
    28.     int fd = open("myfifo", O_WRONLY);    
    29.     if(fd  ==  -1)    
    30.     {    
    31.         perror("open error");    
    32.         exit(1);    
    33.     }    
    34.     
    35.     //  写管道    
    36.     struct event_base* base = NULL;    
    37.     base = event_base_new();    
    38.    
    39.     //  创建事件    
    40.     struct  event*  ev  =  NULL;    
    41.     // 检测的写缓冲区是否有空间写    
    42.     // ev = event_new(base, fd, EV_WRITE, write_cb, NULL);    
    43.     ev  =  event_new(base,  fd,  EV_WRITE  |  EV_PERSIST,  write_cb,  NULL);    
    44.    
    45.     // 添加事件    
    46.      event_add(ev,  NULL);    
    47.  
    48.     // 事件循环    
    49.     event_base_dispatch(base);    
    50.  
    51.     // 释放资源    
    52.     event_free(ev);    
    53.     event_base_free(base);    
    54.     close(fd);    
    55.          
    56.     return  0;    
    57. }

    如果没设置持续写

    3.3 事件的未决和非未决

    未决：有资格被处理，但还没有被处理

    非未决：没有资格被处理

    四、带缓冲区的事件 bufferevent

    4.1 简介

    原理：bufferevent 有两个缓冲区；队列实现，read 中写入的数据只能读一次，数据先进先出

    读：有数据 -> 读回调函数被调用 -> 使用 bufferevent read() -> 读数据

    写：使用 bufferevent_write() -> 向写缓冲中写数据 -> 该缓冲区有数据自动写出 -> 写完，回调函数被调用（鸡肋）

    4.2 函数

    1、创建 bufferevent

    struct bufferevent *ev;

    struct bufferevent *bufferevent_socket_new(struct event_base *base, evutil_socket_t fd, enum bufferevent_options options);

            base：event_base

            fd：封装到 bufferevent 内的 fd

            options：BEV_OPT_CLOSE_ON_FREE

    返回：成功创建的 bufferevent 事件对象

    2、销毁 bufferevent

    void bufferevent_socket_free(struct bufferevent *ev);

    3、给 bufferevent 设置回调

    对比 event

    event_new(fd, callback);                event_add() -- 挂到 event_base 上

    bufferevent_socket_new(fd)                bufferevent_setcb(callback)

    void bufferevent_setcb(struct bufferevent *bufev, bufferevent_data_cb readcb, bufferevent_data_cb writecb, bufferevent_event_cb eventcb, void *cbarg);

    bufev：bufferevent_socket_new() 返回值

    readcb：设置 bufferevent 读缓冲，对应回调 read_cb { bufferevent_read() 读数据 }

    writecb：设置 bufferevent 写缓冲，对应回调 write_cb { } -- 给调用者，发送写成功通知。可以 NULL

    eventcb：设置 事件回调。也可传 NULL

            typedef void (*bufferevent_event_cb)(struct bufferevent *bev, short events, void *ctx);

            void event_cb(struct bufferevent *bev, short events, void *ctx)  {
                    ......
            }

            events：BEV_EVENT_CONNECTED

    cbarg：上述回调函数使用的 参数

    read 回调函数类型：

            typedef void(*bufferevent_data_cb) (struct bufferevent *bev, void *ctx);

            void read_cb (struct bufferevent *bev, void *cbarg) {
                    ......
                    bufferevent_read() ;
            }

    bufferevent_read() 函数的原型：

            size_t bufferevent_read(struct bufferevent *bev, void *buf, size_t bufsize);

    write 回调函数类型：

    int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size);

    4、禁用、启用缓冲区

    五、客户端与服务端

    5.1 用到的函数

    客户端

    socket();  connect();

    int bufferevent_socket_connect(struct bufferevent *bev, struct sockaddr *address, int addrlen);

    bev：bufferevent 事件对象 (封装了 fd)

    address、len：等同于 connect()

    服务器

    socket();  bind();  listen();  accept();

    struct evconnlistener * listner

    struct evconnlistener *evconlistener_new_bind (
            struct event_base *base,
            evconnlistener_cb cb,
            void *ptr,
            unsigned flags,
            int backlog,
            const struct sockaddr *sa,
            int socklen) ;

            base：event_base

            cb：回调函数。一旦被回调，说明在其内部应该与客户端完成，数据读写操作，进行通信

            ptr：回调函数的参数

            flags：LEV_OPT_CLOSE_ON_ FREE | LEV_0PT_REUSEABLE

            backlog：listen()     -1 表最大值

            sa：服务器自己的地址结构体

            socklen：服务器自己的地址结构体大小

            返回值：成功创建的监听器

    释放监听服务器：

            void evconnlistener_free(struct evconnlistener *lev);

    5.2 流程

    5.3 代码实现

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5. #include   
    6. #include   
    7. #include   
    8. #include   
    9. #include   
    10.   
    11. // 读缓冲区回调  
    12. void read_cb(struct bufferevent *bev, void *arg)  
    13. {  
    14.     char buf[1024] = {0};     
    15.     bufferevent_read(bev, buf, sizeof(buf));  
    16.     printf("client say: %s\n", buf);  
    17.   
    18.     char *p = "我是服务器, 已经成功收到你发送的数据!";  
    19.     // 发数据给客户端  
    20.     bufferevent_write(bev, p, strlen(p)+1);  
    21.     sleep(1);  
    22. }  
    23.   
    24. // 写缓冲区回调  
    25. void write_cb(struct bufferevent *bev, void *arg)  
    26. {  
    27.     printf("I'm服务器, 成功写数据给客户端,写缓冲区回调函数被回调...\n");   
    28. }  
    29.   
    30. // 事件  
    31. void event_cb(struct bufferevent *bev, short events, void *arg)  
    32. {  
    33.     if (events & BEV_EVENT_EOF)  
    34.     {  
    35.         printf("connection closed\n");    
    36.     }  
    37.     else if(events & BEV_EVENT_ERROR)     
    38.     {  
    39.         printf("some other error\n");  
    40.     }  
    41.       
    42.     bufferevent_free(bev);      
    43.     printf("buffevent 资源已经被释放...\n");   
    44. }  
    45.   
    46.   
    47. void cb_listener(  
    48.     struct evconnlistener *listener,   
    49.     evutil_socket_t fd,   
    50.     struct sockaddr *addr,   
    51.     int len, void *ptr)  
    52. {  
    53.    printf("connect new client\n");  
    54.   
    55.    struct event_base* base = (struct event_base*)ptr;  
    56.    // 通信操作  
    57.    // 添加新事件  
    58.    struct bufferevent *bev;  
    59.    bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);  
    60.   
    61.    // 给bufferevent缓冲区设置回调  
    62.    bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);  
    63.    bufferevent_enable(bev, EV_READ);  
    64. }  
    65.   
    66.   
    67. int main(int argc, const char* argv[])  
    68. {  
    69.   
    70.     // init server   
    71.     struct sockaddr_in serv;  
    72.   
    73.     memset(&serv, 0, sizeof(serv));  
    74.     serv.sin_family = AF_INET;  
    75.     serv.sin_port = htons(9876);  
    76.     serv.sin_addr.s_addr = htonl(INADDR_ANY);  
    77.   
    78.     struct event_base* base;  
    79.     base = event_base_new();  
    80.     // 创建套接字  
    81.     // 绑定  
    82.     // 接收连接请求  
    83.     struct evconnlistener* listener;  
    84.     listener = evconnlistener_new_bind(base, cb_listener, base,   
    85.                                   LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,   
    86.                                   36, (struct sockaddr*)&serv, sizeof(serv));  
    87.   
    88.     event_base_dispatch(base);  
    89.   
    90.     evconnlistener_free(listener);  
    91.     event_base_free(base);  
    92.   
    93.     return 0;  
    94. }

  • 相关阅读:
    《从菜鸟到大师之路 正则表达式 篇》
    【Adobe Illustrator 教程】4. 认识渐变工具
    动态规划算法（2）最长回文子串详解
    【牛客刷题】——Python入门 06 条件语句
    JAVA德纳影城售票管理计算机毕业设计Mybatis+系统+数据库+调试部署
    MySQL 数据处理之增删改
    Python - Flask 实现自动登录
    北京化工大学数据结构2022/10/20作业 题解
    Docker | 入门：原理探究
    vue3动态绑定class
  • 原文地址：https://blog.csdn.net/HuanBianCheng27/article/details/127757939