我家自动化

这个屌丝很懒，什么也没留下！

热门标签

Linux网络编程10——libevent库

作者：我家自动化 | 2024-04-20 17:28:06

踩

libevent

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

四、带缓冲区的事件 bufferevent

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

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 框架相关函数的介绍


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <event2/event.h>
 
int main(int argc, char *argv[])
{
    struct event_base *base = event_base_new();
    
    const char **buf;
 
    buf = event_get_supported_methods();
    for (int i = 0; i < 5; i++) {
        printf("buf[%d] = %s\n", i, buf[i]);
    }
    
    return 0;
}

三、常规事件 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


#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <string.h>  
#include <fcntl.h>  
#include <event2/event.h>  
 
// 对操作处理函数  
void read_cb(evutil_socket_t fd, short what, void *arg)  
{  
    // 读管道  
    char buf[1024] = {0};  
      
    int len = read(fd, buf, sizeof(buf));  
          
    printf("read event: %s \n", what & EV_READ ? "Yes" : "No");  
    printf("data len = %d, buf = %s\n", len, buf);  
          
    sleep(1);  
}  
 
 
// 读管道  
int main(int argc, const char* argv[])  
{  
    unlink("myfifo");  
  
    //创建有名管道  
    mkfifo("myfifo", 0664);  
 
    // open file  
    //int fd = open("myfifo", O_RDONLY | O_NONBLOCK);  
    int fd = open("myfifo", O_RDONLY);  
    if(fd == -1)  
    {  
        perror("open error");  
        exit(1);  
    }  
     
    // 创建个event_base  
    struct event_base* base = NULL;  
    base = event_base_new();  
 
    // 创建事件  
    struct event* ev = NULL;  
    ev = event_new(base, fd, EV_READ | EV_PERSIST, read_cb, NULL);  
 
    // 添加事件  
    event_add(ev, NULL);  
 
    // 事件循环  
    event_base_dispatch(base);  // while（1） { epoll();}  
 
    // 释放资源  
    event_free(ev);  
    event_base_free(base);  
    close(fd);  
  
    return 0;  
}

write


#include <stdio.h>    
#include <unistd.h>    
#include <stdlib.h>    
#include <sys/types.h>    
#include <sys/stat.h>    
#include <string.h>    
#include <fcntl.h>    
#include <event2/event.h>    
    
//  对操作处理函数    
void  write_cb(evutil_socket_t  fd,  short  what,  void  *arg)    
{    
    //  write管道    
    char buf[1024]  =  {0};    
            
    static int num = 0;    
    sprintf(buf, "hello,world-%d\n", num++);    
    write(fd, buf, strlen(buf)+1);    
          
    sleep(1);    
}        
   
//  写管道    
int main(int argc, const char* argv[])    
{    
    // open file    
    //int fd = open("myfifo", O_WRONLY | O_NONBLOCK);    
    int fd = open("myfifo", O_WRONLY);    
    if(fd  ==  -1)    
    {    
        perror("open error");    
        exit(1);    
    }    
    
    //  写管道    
    struct event_base* base = NULL;    
    base = event_base_new();    
   
    //  创建事件    
    struct  event*  ev  =  NULL;    
    // 检测的写缓冲区是否有空间写    
    // ev = event_new(base, fd, EV_WRITE, write_cb, NULL);    
    ev  =  event_new(base,  fd,  EV_WRITE  |  EV_PERSIST,  write_cb,  NULL);    
   
    // 添加事件    
     event_add(ev,  NULL);    
 
    // 事件循环    
    event_base_dispatch(base);    
 
    // 释放资源    
    event_free(ev);    
    event_base_free(base);    
    close(fd);    
         
    return  0;    
}

如果没设置持续写

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 代码实现


#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <string.h>  
#include <event2/event.h>  
#include <event2/listener.h>  
#include <event2/bufferevent.h>  
  
// 读缓冲区回调  
void read_cb(struct bufferevent *bev, void *arg)  
{  
    char buf[1024] = {0};     
    bufferevent_read(bev, buf, sizeof(buf));  
    printf("client say: %s\n", buf);  
  
    char *p = "我是服务器, 已经成功收到你发送的数据!";  
    // 发数据给客户端  
    bufferevent_write(bev, p, strlen(p)+1);  
    sleep(1);  
}  
  
// 写缓冲区回调  
void write_cb(struct bufferevent *bev, void *arg)  
{  
    printf("I'm服务器, 成功写数据给客户端,写缓冲区回调函数被回调...\n");   
}  
  
// 事件  
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("some other error\n");  
    }  
      
    bufferevent_free(bev);      
    printf("buffevent 资源已经被释放...\n");   
}  
  
  
void cb_listener(  
    struct evconnlistener *listener,   
    evutil_socket_t fd,   
    struct sockaddr *addr,   
    int len, void *ptr)  
{  
   printf("connect new client\n");  
  
   struct event_base* base = (struct event_base*)ptr;  
   // 通信操作  
   // 添加新事件  
   struct bufferevent *bev;  
   bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);  
  
   // 给bufferevent缓冲区设置回调  
   bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);  
   bufferevent_enable(bev, EV_READ);  
}  
  
  
int main(int argc, const char* argv[])  
{  
  
    // init server   
    struct sockaddr_in serv;  
  
    memset(&serv, 0, sizeof(serv));  
    serv.sin_family = AF_INET;  
    serv.sin_port = htons(9876);  
    serv.sin_addr.s_addr = htonl(INADDR_ANY);  
  
    struct event_base* base;  
    base = event_base_new();  
    // 创建套接字  
    // 绑定  
    // 接收连接请求  
    struct evconnlistener* listener;  
    listener = evconnlistener_new_bind(base, cb_listener, base,   
                                  LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,   
                                  36, (struct sockaddr*)&serv, sizeof(serv));  
  
    event_base_dispatch(base);  
  
    evconnlistener_free(listener);  
    event_base_free(base);  
  
    return 0;  
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/458478