可以利用Libevent库做命令行解析及命令执行结果反馈

可以利用Libevent库做定时器使用

在sslsplit中使用了此库作为事件处理，如连接建立，内容读取转换等。

一、Libevent简介


    libevent是一个基于事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。官网：http://libevent.org/

特点：

  • 事件驱动，高性能;

  • 轻量级，专注于网络，不如ACE那么臃肿庞大，只提供了简单的网络API的封装，线程池，内存池，递归锁等均需要自己实现；

  • 开放源码，代码相当精炼、易读；

  • 跨平台，支持Windows、Linux、BSD和Mac OS；

  • 支持多种I/O多路复用技术（epoll、poll、dev/poll、select和kqueue等），在不同的操作系统下，做了多路复用模型的抽象，可以选择使用不同的模型，通过事件函数提供服务；

  • 支持I/O，定时器和信号等事件；

  • 采用Reactor模式；



二、源码组织结构


    Libevent 的源代码虽然都在一层文件夹下面，但是其代码分类还是相当清晰的，主要可分为头文件、内部使用的头文件、辅助功能函数、日志、libevent框架、对系 统I/O多路复用机制的封装、信号管理、定时事件管理、缓冲区管理、基本数据结构和基于libevent的两个实用库等几个部分，有些部分可能就是一个源文件。

1）头文件

主要就是event.h：事件宏定义、接口函数声明，主要结构体event的声明；

2）内部头文件

xxx-internal.h：内部数据结构和函数，对外不可见，以达到信息隐藏的目的；

3）libevent框架

event.c：event整体框架的代码实现；

4）对系统I/O多路复用机制的封装

epoll.c：对epoll的封装；

select.c：对select的封装；

devpoll.c：对dev/poll的封装;

kqueue.c：对kqueue的封装；

5）定时事件管理

min-heap.h：其实就是一个以时间作为key的小根堆结构；

6）信号管理

signal.c：对信号事件的处理；

7）辅助功能函数

evutil.h 和evutil.c：一些辅助功能函数，包括创建socket pair和一些时间操作函数：加、减和比较等。

8）日志

log.h和log.c：log日志函数

9）缓冲区管理

evbuffer.c和buffer.c：libevent对缓冲区的封装；

10）基本数据结构

compat/sys下的两个源文件：queue.h是libevent基本数据结构的实现，包括链表，双向链表，队列等；_libevent_time.h：一些用于时间操作的结构体定义、函数和宏定义；

11）实用网络库

http和evdns：是基于libevent实现的http服务器和异步dns查询库；




三、示例

1、获取版本

  1. // gcc getVersion.c -o getVersion -levent

  3. #include <event.h>
  4. #include <stdio.h>

  6. int main()
  7. {
  8.     const char *version = event_get_version();
  9.     printf("%s\n",version);
  10.     return 0;
  11. }

2、timer程序

  1. // gcc timer.c -o timer -levent
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <time.h>
  6. #include <event2/event.h>
  7. #include <event2/event_struct.h>

  9. #define N 300
  10. #define BUFLEN 256

  12. struct timeval lasttime;
  13. struct ST_EventWithDescription
  14. {
  15.     struct event *p_event;
  16.     int time_interval;
  17.     char lable[BUFLEN];
  18. };

  20. static void timeout_cb(evutil_socket_t fd, short event, void *arg)
  21. {
  22.     struct timeval newtime, difference;
  23.     struct ST_EventWithDescription *pSTEvent = arg;
  24.     struct event *timeout = pSTEvent->p_event;
  25.     double elapsed;

  27.     evutil_gettimeofday(&newtime, NULL);
  28.     evutil_timersub(&newtime, &lasttime, &difference);
  29.     elapsed = difference.tv_sec + (difference.tv_usec / 1.0e6);

  31.     printf("%s called at %d: %.3f seconds since my last work.\n",
  32.           (char*)pSTEvent->lable,(int)newtime.tv_sec, elapsed);
  33.     lasttime = newtime;

  35.     struct timeval tv;
  36.     evutil_timerclear(&tv);
  37.     tv.tv_sec = pSTEvent->time_interval;
  38.     event_add(timeout, &tv);
  39. }

  41. void setParam(struct ST_EventWithDescription *stEventDescription,
  42.               struct event *m_event,int time_interval,char* m_lable)
  43. {
  44.     stEventDescription->p_event = m_event;
  45.     stEventDescription->time_interval = time_interval;
  46.     memset(stEventDescription->lable,0,sizeof(stEventDescription->lable));
  47.     memcpy(stEventDescription->lable,m_lable,strlen(m_lable)+1);
  48. }

  50. void setTimeIntervalArr(int *arr,int n)
  51. {
  52.     int i;
  53.     srand(time(NULL));
  54.     for(i=0; i<n; ++i)
  55.     {
  56.         *(arr+i) = rand()%n + 1;
  57.         //*(arr+i) = i+1;
  58.     }
  59. }

  61. int main(int argc, char **argv)
  62. {
  63.     struct event timeout[N];
  64.     struct ST_EventWithDescription stEvent[N];
  65.     int time_interval[N];
  66.     int i=0;

  68.     struct timeval tv;
  69.     struct event_base *base;
  70.     int flags = 0;

  72.     setTimeIntervalArr(time_interval,N);

  74.     base = event_base_new();
  75.     evutil_timerclear(&tv);

  77.     for(i=0; i<N; ++i)
  78.     {
  79.         char buf[BUFLEN]= {0};
  80.         sprintf(buf,"task%d",i+1);
  81.         setParam(stEvent+i,timeout+i,time_interval[i],buf);
  82.         event_assign(timeout+i, base, -1, flags, timeout_cb, (void*)(stEvent+i));
  83.         event_add(timeout+i, &tv);
  84.     }
  85.     
  86.     evutil_gettimeofday(&lasttime, NULL);
  87.     event_base_dispatch(base);

  89.     return (0);
  90. }

3、socket程序

  1. /*
    编译
    # gcc -o test test.c -levent


    测试
    # ./test
    在另一终端启动
    # telnet 127.0.0.1 8990


    add by jiayanhui 20140623
    */




    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <netinet/in.h>
    #include <netinet/tcp.h>
    #include <event.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <errno.h>
    #include <fcntl.h>






    static short ListenPort = 8990;
    static long ListenAddr = INADDR_ANY;//任意地址的值就是0
    static int MaxConnections = 1024;
    static int ServerSocket;
    static struct event ServerEvent;//创建event
    static struct event ServerEvent1;//创建event




    //不论在什么平台编写网络程序，都应该使用NONBLOCK将一个socket设置成非阻塞模式。这样可以保证你的程序至少不会在recv/send/accept/connect这些操作上发生block从而将整个网络服务都停下来
    int SetNonblock(int fd)
    {
        int flags;
        
        if ((flags = fcntl(fd, F_GETFL)) == -1) { //用来操作文件描述符的一些特性
            return -1;
        }


        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
            return -1;
        }


        return 0;
    }


    //这个函数当客户端的socket可读时由libevent调用
    void ServerRead(int fd, short ev, void *arg)
    {
        struct client *client = (struct client *)arg;
        u_char buf[8196];
        int len, wlen;


        //会把参数fd 所指的文件传送count个字节到buf指针所指的内存中
        len = read(fd, buf, sizeof(buf));
        if (len == 0) {
            /* 客户端断开连接，在这里移除读事件并且释放客户数据结构 */
            printf("disconnected\n");
            close(fd);
            event_del(&ServerEvent);
            free(client);
            return;
        } else if (len < 0) {
            /* 出现了其它的错误，在这里关闭socket，移除事件并且释放客户数据结构 */
            printf("socket fail %s\n", strerror(errno));
            close(fd);
            event_del(&ServerEvent);
            free(client);
            return;
        }
        /* 
         为了简便，我们直接将数据写回到客户端。通常我们不能在非阻塞的应用程序中这么做，
           我们应该将数据放到队列中，等待可写事件的时候再写回客户端。 
         如果使用多个终端进行socket连接会出现错误socket fail Bad file descriptor
         */
        wlen = write(fd, buf, len);
        if (wlen < len) {
            printf("not all data write back to client\n");
        }


        return;
    }


    /*
       当有一个连接请求准备被接受时，这个函数将被libevent调用并传递给三个变量: 
       int fd:触发事件的文件描述符. 
       short event:触发事件的类型EV_TIMEOUT,EV_SIGNAL, EV_READ, or EV_WRITE. 
       void* :由arg参数指定的变量. 
    */
    void ServerAccept(int fd, short ev, void *arg)
    {
        int cfd;
        struct sockaddr_in addr;
        socklen_t addrlen = sizeof(addr);
        int yes = 1;
        int retval;


        //将从连接请求队列中获得连接信息，创建新的套接字，并返回该套接字的文件描述符。
        //新创建的套接字用于服务器与客户机的通信，而原来的套接字仍然处于监听状态。
        //该函数的第一个参数指定处于监听状态的流套接字
        cfd = accept(fd, (struct sockaddr *)&addr, &addrlen);
        if (cfd == -1) {
            printf("accept(): can not accept client connection");
            return;
        }
        if (SetNonblock(cfd) == -1) {
            close(cfd);
            return;
        }


        //设置与某个套接字关联的选项
        //参数二 IPPROTO_TCP:TCP选项
        //参数三 TCP_NODELAY 不使用Nagle算法 选择立即发送数据而不是等待产生更多的数据然后再一次发送
        // 更多参数TCP_NODELAY 和 TCP_CORK
        //参数四 新选项TCP_NODELAY的值
        if (setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {
            printf("setsockopt(): TCP_NODELAY %s\n", strerror(errno));
            close(cfd);
            return;
        }


        event_set(&ServerEvent, cfd, EV_READ | EV_PERSIST, ServerRead, NULL);
        event_add(&ServerEvent, NULL);
        
        printf("Accepted connection from %x\n", addr.sin_addr.s_addr);
    }


    int NewSocket(void)
    {
        struct sockaddr_in sa;


        //socket函数来创建一个能够进行网络通信的套接字。
        //第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置AF_INET;
        //第二个参数指定要创建的套接字类型
        //流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM、原始套接字SOCK_RAW
        //第三个参数指定应用程序所使用的通信协议。
        ServerSocket = socket(AF_INET, SOCK_STREAM, 0);
        if (ServerSocket == -1) {
            printf("socket(): can not create server socket\n");
            return -1;
        }


        if (SetNonblock(ServerSocket) == -1) {
            return -1;
        }


        //清空内存数据
        memset(&sa, 0, sizeof(sa));
        sa.sin_family = AF_INET;
        //htons将一个无符号短整型数值转换为网络字节序
        sa.sin_port = htons(ListenPort);
        //htonl将主机的无符号长整形数转换成网络字节顺序
        sa.sin_addr.s_addr = htonl(ListenAddr);


        //(struct sockaddr*)&sa将sa强制转换为sockaddr类型的指针
        /*struct sockaddr 
            数据结构用做bind、connect、recvfrom、sendto等函数的参数，指明地址信息。
            但一般编程中并不直接针对此数据结构操作，而是使用另一个与sockaddr等价的数据结构 struct sockaddr_in
            sockaddr_in和sockaddr是并列的结构，指向sockaddr_in的结构体的指针也可以指向
            sockadd的结构体，并代替它。也就是说，你可以使用sockaddr_in建立你所需要的信息,
            在最后用进行类型转换就可以了
        */
        //bind函数用于将套接字绑定到一个已知的地址上
        if (bind(ServerSocket, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
            close(ServerSocket);
            printf("bind(): can not bind server socket");
            return -1;
        }
        
        //执行listen 之后套接字进入被动模式
        //MaxConnections 连接请求队列的最大长度,队列满了以后，将拒绝新的连接请求
        if (listen(ServerSocket, MaxConnections) == -1) {
            printf("listen(): can not listen server socket");
            close(ServerSocket);
            return -1;
        }


        /*
         event_set的参数：
         + 参数1: 为要创建的event
         + 参数2: file descriptor，创建纯计时器可以设置其为-1，即宏evtimer_set定义的那样
         + 参数3: 设置event种类，常用的EV_READ, EV_WRITE, EV_PERSIST, EV_SIGNAL, EV_TIMEOUT，纯计时器设置该参数为0
         + 参数4: event被激活之后触发的callback函数
         + 参数5: 传递给callback函数的参数
         备注：
                如果初始化event的时候设置其为persistent的(设置了EV_PERSIST)，
                则使用event_add将其添加到侦听事件集合后(pending状态)，
                该event会持续保持pending状态，即该event可以无限次参加libevent的事件侦听。
                每当其被激活触发callback函数执行之后，该event自动从active转回为pending状态，
                继续参加libevent的侦听(当激活条件满足，又可以继续执行其callback)。
                除非在代码中使用event_del()函数将该event从libevent的侦听事件集合中删除。
                如果不通过设置EV_PERSIST使得event是persistent的，需要在event的callback中再次调用event_add
                (即在每次pending变为active之后，在callback中再将其设置为pending)
         */
        event_set(&ServerEvent1, ServerSocket, EV_READ | EV_PERSIST, ServerAccept, NULL);
        //将event添加到libevent侦听的事件集中
        if (event_add(&ServerEvent1, 0) == -1) {
            printf("event_add(): can not add accept event into libevent");
            close(ServerSocket);
            return -1;
        }
        return 0;
    }


    int main(int argc, char *argv[])
    {
        int retval;
        
        event_init(); //初始化event base使用默认的全局current_base
        
        retval = NewSocket();
        if (retval == -1) {
            exit(-1);
        }
        
        event_dispatch(); //启动事件队列系统，开始监听（并接受）请求
        
        return 0;
    }


GitHub 加速计划 / li / linux-dash
10.39 K
1.2 K
下载
A beautiful web dashboard for Linux
最近提交(Master分支：2 个月前 )
186a802e added ecosystem file for PM2 4 年前
5def40a3 Add host customization support for the NodeJS version 4 年前
Logo
GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的

avatar GitCode 开源社区

centOS 8 使用dnf安装Docker

DNF是什么？CentOS 8使用YUM软件包管理器版本v4.0.4。现在，该版本使用DNF(已删除YUM)。DNF是软件包管理器。它会在Linux发行版上安装，执行更新并删除软件包。使用DNF安装Docker跳过具有损坏依赖性的程序包一个有效的解决方案是使您的CentOS 8系统使用以下--nobest命令安装最符合条件的版本：sudo dnf install docker...

avatar GitCode 开源社区

定时同步数据库表(mysql+linux+crontab)

sync.sh里面的参数需要改变，ip/username/password/database/tablesync.sh#!/bin/sh# Please change the IP and password of the data source db.# Then change the table name.filename=/home/nington/db/$(date +%Y-%m

avatar GitCode 开源社区