Linux C編程之十九（2） libevent

一、事件處理框架（event_base）

1.  event_base

     使用 libevent 函數之前需要分配一個或者多個 event_base 結構體。每個event_base 結構體持有一個事件集合,可以檢測以確定哪個事件是激活的。

• 相當於epoll紅黑樹的樹根

• 抽象層, 完成對event_base的封裝
• 每個 event_base 都有一種用於檢測哪種事件已經就緒的 ”方法“,或者說后端。

2.  相關函數

（1）創建event_base

struct event_base* event_base_new(void);
失敗返回NULL

（2）釋放event_base

event_base_free(struct event_base* base);

（3）循環監聽base對應的事件, 等待條件滿足

event_base_dispatch();

（4）查看event_base封裝的后端

const char **event_get_supported_methods(void);
char* str[];
const char * event_base_get_method(
    const struct event_base *base
);

注意：event_base和fork

• 子進程創建成功之后, 父進程可以繼續使用event_base
• 子進程中需要繼續使用event_base需要重新進程初始化

int event_reinit(struct event_base* base);

二、事件循環（event_loop） 

1. 事件處理方式

    一旦有了一個已經注冊了某些事件的 event_base, 就需要讓 libevent 等待事件並且通知事件的發生。

#define EVLOOP_ONCE                  0x01
    事件只會被觸發一次
    事件沒有被觸發, 阻塞等
#define EVLOOP_NONBLOCK              0x02
    非阻塞 等方式去做事件檢測
    不關心事件是否被觸發了
#define EVLOOP_NO_EXIT_ON_EMPTY      0x04
    沒有事件的時候, 也不退出輪詢檢測

2. 相關函數

 （1）int event_base_loop(struct event_base *base, int flags);
          正常退出返回0, 失敗返回-1
 （2）int event_base_dispatch(struct event_base* base);

• 等同於沒有設置標志的 event_base_loop ( )
• 將一直運行，直到沒有已經注冊的事件了,或者調用 了event_base_loopbreak()或者 event_base_loopexit()為止。

3. 循環停止

（1）如果 event_base 當前正在執行激活事件的回調 ,它將在執行完當前正在處理的事件后立即退出

int event_base_loopexit(
    struct event_base *base,
    const struct timeval *tv
);

（2）讓event_base 立即退出循環

int event_base_loopbreak(struct event_base *base);

返回值: 成功 0, 失敗 -1

    其中：

struct timeval {
    long tv_sec; 
    long tv_usec; 
};

三、事件創建 （event） 

1. 創建新事件

#define  EV_TIMEOUT              0x01    // 廢棄
#define  EV_READ                 0x02
#define  EV_WRITE                0x04
#define  EV_SIGNAL               0x08
#define  EV_PERSIST              0x10    // 持續觸發
#define  EV_ET                   0x20    // 邊沿模式

typedef void (*event_callback_fn)(evutil_socket_t, short, void *); 
struct event *event_new(
    struct event_base *base, 
    evutil_socket_t fd, // 文件描述符 - int
    short what, 
    event_callback_fn cb, // 事件的處理動作
    void *arg
); 

 注意：調用event_new()函數之后，新事件處於已初始化和非未決狀態 。 

2. 釋放事件

void event_free(struct event *event);

3. 設置未決事件

     構造事件之后,在將其添加到 event_base 之前實際上是不能對其做任何操作的。使用event_add()將事件添加到event_base, 非未決事件 -> 未決事件。

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

參數：

     ev：創建的事件

 tv: 
   NULL: 事件被觸發, 對應的回調被調用
   tv = {0, 100}, 如果設置的時間，在改時間段內檢測的事件沒被觸發, 時間到達之后, 回調函數還是會被調用

返回值：

    函數調用成功返回 0，失敗返回 -1 。

 4. 設置非未決

int event_del(struct event *ev); 

對已經初始化的事件調用 event_del() 將使其成為非未決和非激活的。如果事件不是未決的或者激活的，調用將沒有效果。

返回值：

           成功時函數返回 0,失敗時返回-1。

5. 事件的狀態轉換

 6. 示例

    通過 libevent 實現進程間通過管道來通信：

#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);
}


// 寫管道
int main(int argc, const char* argv[])
{
    // open file
    int fd = open("myfifo", O_WRONLY | O_NONBLOCK);
    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 | EV_PERSIST, write_cb, NULL);

    // 添加事件
    event_add(ev, NULL);

    // 事件循環
    event_base_dispatch(base);

    // 釋放資源
    event_free(ev);
    event_base_free(base);
    close(fd);
    
    return 0;
}

#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("data len = %d, buf = %s\n", len, buf);
    printf("read event: %s", what & EV_READ ? "Yes" : "No");
}


// 讀管道
int main(int argc, const char* argv[])
{
    unlink("myfifo");
    //創建有名管道
    mkfifo("myfifo", 0664);

    // open file
    int fd = open("myfifo", O_RDONLY | O_NONBLOCK);
    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_READ | EV_PERSIST, read_cb, NULL);

    // 添加事件
    event_add(ev, NULL);

    // 事件循環
    event_base_dispatch(base);

    // 釋放資源
    event_free(ev);
    event_base_free(base);
    close(fd);
    
    return 0;
}

注意：在執行上述代碼時可能會出現下面錯誤

[root@centos1 event]# ./read
./read: error while loading shared libraries: libevent-2.1.so.6: cannot open shared object file: No such file or directory

    查找 libevent-2.1.so.6 該動態庫文件：

[root@centos1 event]# locate libevent-2.1.so.6
/home/linuxC/libevent/libevent-2.1.8-stable/.libs/libevent-2.1.so.6
/home/linuxC/libevent/libevent-2.1.8-stable/.libs/libevent-2.1.so.6.0.2
/usr/local/lib/libevent-2.1.so.6
/usr/local/lib/libevent-2.1.so.6.0.2

    將紅色動態庫路徑添加到 /etc/ld.so.conf文件中，然后執行 ldconfig -v 即可：

include ld.so.conf.d/*.conf
/home/xuejiale/src/calc/lib/
/usr/local/lib/

四、數據緩沖區（Bufferevent）

1. bufferevent 理解

• 是libevent為IO緩沖區操作提供的一種通用機制
• bufferevent 由一個底層的傳輸端口(如套接字 )，一個讀取緩沖區和一個寫入緩沖區組成。
• 與通常的事件在底層傳輸端口已經就緒,可以讀取或者寫入的時候執行回調不同的是，bufferevent 在讀取或者寫入了足夠量的數據之后調用用戶提供的回調。

2. 回調 - 緩沖區對應的操作

（1）每個 bufferevent 有兩個數據相關的回調

• 一個讀取回調

          從底層傳輸端口讀取了任意量的數據之后會調用讀取回調(默認)

• 一個寫入回調

         輸出緩沖區中足夠量的數據被清空到底層傳輸端口后寫入回調會被調用(默認)

（2）緩沖區數據存儲方式      

      緩沖去內部數據存儲 - 隊列

（3）event 和 bufferevent 

      event --> 沒有緩沖區

      bufferevent --> 有緩沖區

 3. 使用 bufferevent

 （1）創建基於套接字的bufferevent

    可以使用 bufferevent_socket_new()創建基於套接字的 bufferevent

struct bufferevent *bufferevent_socket_new(
    struct event_base *base,
    evutil_socket_t fd,
    enum bufferevent_options options
);
參數：
    options: BEV_OPT_CLOSE_ON_FREE 
    釋放 bufferevent 時關閉底層傳輸端口。這將關閉底層套接字,釋放底層 bufferevent 等
    libevent中文參考手冊page53 - bufferevent的選項標志
    struct bufferevent也是一個 event
    成功時函數返回一個 bufferevent,失敗則返回 NULL。

（2）在bufferevent上啟動鏈接

int bufferevent_socket_connect(
    struct bufferevent *bev,
    struct sockaddr *address, //server ip和port 
    int addrlen
); 
1）address 和 addrlen 參數跟標准調用connect()的參數相同。如果還沒有為bufferevent 設置套接字，調用函數將為其分配一個新的流套接字，並且設置為非阻塞的
2）如果已經為 bufferevent 設置套接字,調用bufferevent_socket_connect() 將告知libevent 套接字還未連接,直到連接成功之前不應該對其進行讀取或者寫入操作。
3）連接完成之前可以向輸出緩沖區添加數據。

（3）釋放bufferevent操作

void bufferevent_free(struct bufferevent *bev); 
這個函數釋放 bufferevent

（4）bufferevent讀寫緩沖區回調操作

typedef void (*bufferevent_data_cb)(
    struct bufferevent *bev, 
    void *ctx
);
typedef void (*bufferevent_event_cb)(
    struct bufferevent *bev,
    short events, 
    void *ctx
);
events參數:
    EV_EVENT_READING：讀取操作時發生某事件，具體是哪種事件請看其他標志。
    BEV_EVENT_WRITING：寫入操作時發生某事件，具體是哪種事件請看其他標志。
    BEV_EVENT_ERROR：操作時發生錯誤。關於錯誤的更多信息，請調 用
                            EVUTIL_SOCKET_ERROR()。
    BEV_EVENT_TIMEOUT：發生超時。
    BEV_EVENT_EOF：遇到文件結束指示。
    BEV_EVENT_CONNECTED：請求的連接過程已經完成（實現客戶端的時候可以判斷）

void bufferevent_setcb(
    struct bufferevent *bufev,
    bufferevent_data_cb readcb, //在讀回調中讀數據，bufferevent_read()
    bufferevent_data_cb writecb, //可以是NULL
    bufferevent_event_cb eventcb, //可以是NULL
    void *cbarg
);

（5）禁用、啟用緩沖區

禁用之后, 對應的回調就不會被調用了
void bufferevent_enable(
    struct bufferevent *bufev, 
    short events
); 
void bufferevent_disable(
    struct bufferevent *bufev, 
    short events
); 
short bufferevent_get_enabled(
    struct bufferevent *bufev
); 
可以啟用或者禁用 bufferevent 上的 EV_READ、EV_WRITE 或者 EV_READ | EV_WRITE 事件。沒有啟用讀取或者寫入事件時, bufferevent 將不會試圖進行數據讀取或者寫入。

（6）操作bufferevent中的數據

    1）向bufferevent的輸出緩沖區添加數據

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

    2）從bufferevent的輸入緩沖區移除數據

size_t bufferevent_read(
    struct bufferevent *bufev, 
    void *data, 
    size_t size
);

4. 鏈接監聽器（evconnlistener）

 （1）創建和釋放監聽器

   1）創建監聽器

typedef void (*evconnlistener_cb)(
    struct evconnlistener *listener,   
    evutil_socket_t sock,  //用於通信的文件描述符
    struct sockaddr *addr, //客戶端的IP和端口信息
    int len, 
    void *ptr              //外部傳進來的數據
); 

struct evconnlistener * evconnlistener_new(
    struct event_base *base,
    evconnlistener_cb cb, 
    void *ptr, 
    unsigned flags, 
    int backlog,
    evutil_socket_t fd
);
參數flags：
    參考手冊 - page99-100 [可識別的標志]
    LEV_OPT_CLOSE_ON_FREE
    LEV_OPT_REUSEABLE
    
struct evconnlistener *evconnlistener_new_bind(
    struct event_base *base,
    evconnlistener_cb cb,   // 接受連接之后, 用戶要做的操作
    void *ptr,              // 給回調傳參
    unsigned flags, 
    int backlog,           //-1: 使用默認的最大值
    const struct sockaddr *sa, //服務器的IP和端口信息
    int socklen
);

    兩個 evconnlistener_new*()函數都分配和返回一個新的連接監聽器對象。連接監聽器使 用 event_base 來得知什么時候在給定的監聽套接字上有新的 TCP 連接。新連接到達時,監聽 器調用你給出的回調函數。

    evconnlistener_new_bind 函數內部完成的是下面5步：

    a. socket - server
    b. 創建監聽socket
    c. 綁定
    d. 監聽
    f. 等待並接收連接

    2）釋放監聽器

void evconnlistener_free(struct evconnlistener *lev); 

（2）啟用和禁用 evconnlistener

int evconnlistener_disable(struct evconnlistener *lev);
int evconnlistener_enable(struct evconnlistener *lev);

這兩個函數暫時禁止或者重新允許監聽新連接。

 （3）調整 evconnlistener 的回調函數

void evconnlistener_set_cb(
    struct evconnlistener *lev,
    evconnlistener_cb cb, 
    void *arg
); 

函數調整 evconnlistener 的回調函數和其參數。

 5. 示例

    實現服務器和客戶端：

#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));
    char* p = "我已經收到了你發送的數據!";
    printf("client say: %s\n", p);

    // 發數據給客戶端
    bufferevent_write(bev, p, strlen(p)+1);
    printf("====== send buf: %s\n", p);
}

// 寫緩沖區回調
void write_cb(struct bufferevent *bev, void *arg)
{
    printf("我是寫緩沖區的回調函數...\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);  //默認寫enable，讀disenable
}


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;
    //第二個base傳給了cb_listener的ptr(base --> ptr)
    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;
}

#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/bufferevent.h>


void read_cb(struct bufferevent *bev, void *arg)
{
    char buf[1024] = {0}; 
    bufferevent_read(bev, buf, sizeof(buf));
    printf("Server say: %s\n", buf);
}

void write_cb(struct bufferevent *bev, void *arg)
{
    printf("I am Write_cb function....\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");
    }
    else if(events & BEV_EVENT_CONNECTED)
    {
        printf("成功連接到服務器, O(∩_∩)O哈哈~\n");
        return;
    }
    
    bufferevent_free(bev);
    printf("free bufferevent...\n");
}

void send_cb(evutil_socket_t fd, short what, void *arg)
{
    char buf[1024] = {0}; 
    struct bufferevent* bev = (struct bufferevent*)arg;
    printf("請輸入要發送的數據: \n");
    //注意這塊的fd --> STDIN_FILENO，讀終端輸入中的數據到buf
    read(fd, buf, sizeof(buf));
    bufferevent_write(bev, buf, strlen(buf)+1);
}


int main(int argc, const char* argv[])
{
    struct event_base* base;
    base = event_base_new();


    struct bufferevent* bev;
    bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);

    // 連接服務器
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_port = htons(9876);
    evutil_inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);
    bufferevent_socket_connect(bev, (struct sockaddr*)&serv, sizeof(serv));

    // 設置回調
    bufferevent_setcb(bev, read_cb, write_cb, event_cb, NULL);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);

    // 創建一個事件
    struct event* ev = event_new(base, STDIN_FILENO, 
                                 EV_READ | EV_PERSIST, 
                                 send_cb, bev);
    event_add(ev, NULL);
    
    event_base_dispatch(base);

    event_base_free(base);

    return 0;
}