基于libevent和unix domain socket的本地server

https://www.pacificsimplicity.ca/blog/libevent-echo-server-tutorial

根据这一篇写一个最简单的demo。然后开始写client。

client调优

client最初的代码如下：

#include <sys/socket.h>
#include <sys/un.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <errno.h>

int main(int argc, char *argv[]) {
    struct sockaddr_un addr;
    int fd,rc;

    if ( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
        perror("socket error");
        exit(-1);
    }

    const char *socket_path = "/tmp/mysocket";
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strcpy(addr.sun_path, socket_path);

    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("connect error");
        exit(-1);
    }

    char sendbuf[8145] = {0};
    rc = 8145;
    
    {
        if (write(fd, sendbuf, rc) != rc) {
            if (rc > 0) fprintf(stderr,"partial write");
            else {
                perror("write error");
                exit(-1);
            }
        }        
    }
    

    char buf[1024] = {0};

    while ((rc = read(fd, buf, 1024)) > 0) {
        buf[rc] = '\0';
                printf("%s\n", buf);
    }

    close(fd);

    return 0;
}            

代码很简单，会发现有个问题，read这里会阻塞住不退出。

因为这是阻塞IO，读不到数据时会阻塞。有没办法可以知道服务端已经写完了呢？如果用非阻塞的是不是有不一样的返回码呢。又试了下非阻塞版。

int val = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, val|O_NONBLOCK);// 设置为非阻塞

//...

char buf[1024] = {0};
while (true) {
        rc = read(fd, buf, 1024);
        if (rc > 0) {
            buf[rc] = '\0';
            printf("recv:%s\n", buf);
        } else if (rc == 0) {
            break;
        } else if (rc < 0 && (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)) {
            //printf("errno %d\n", errno);
            continue;
        } else {
            break;
        }
    }

这时就会出现一直跑到第15行这里，errno一直是EWOULDBLOCK/EAGAIN。

非阻塞模式下返回值 <0时并且 (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)的情况下认为连接是正常的， 继续发送。

https://blog.csdn.net/qq_14821541/article/details/52028924

好吧，问题同样没有解决。实际上网络通信server端可能会出现很多情况，写得慢、网络慢或者server挂了等，为了鲁棒性，一个比较通用的策略就是超时。如果超了时间就直接退出。

struct timeval tv;
tv.tv_sec = 3;
tv.tv_usec = 0;
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));

用阻塞+超时，这样就可以正常退出了。不过还是没解决正常情况下的退出。

一个简单的思路就是服务端写完了数据，在数据的最终加上一个mark，标识已经写完了，client读到这个mark，就直接退出。

#include <sys/socket.h>
#include <sys/un.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <errno.h>

int main(int argc, char *argv[]) {
    struct sockaddr_un addr;
    int fd,rc;

    if ( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
        perror("socket error");
        exit(-1);
    }

    struct timeval tv;
    tv.tv_sec = 3;
    tv.tv_usec = 0;
    setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));

    const char *socket_path = "/tmp/mysocket";
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strcpy(addr.sun_path, socket_path);

    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("connect error");
        exit(-1);
    }

    const char *end_mark = "$@%^&~";
    int end_mark_len = strlen(end_mark);

    char sendbuf[8145] = {0};
    rc = 8145;
    memcpy(sendbuf + rc - end_mark_len, end_mark, end_mark_len);
    
    printf("%s %d\n", sendbuf, rc);

    {
        if (write(fd, sendbuf, rc) != rc) {
            if (rc > 0) fprintf(stderr,"partial write");
            else {
                perror("write error");
                exit(-1);
            }
        }    
    }
    

    char buf[1024] = {0};    
    while ((rc = read(fd, buf, 1024)) > 0) {
        buf[rc] = '\0';
        if (rc < end_mark_len) break;
        if (strncmp(buf + rc - end_mark_len, end_mark, end_mark_len) == 0) {
            printf("%s\n", buf);
            break;
        }
    }

    close(fd);

    return 0;
}

server调优

https://www.pacificsimplicity.ca/blog/libevent-echo-server-tutorial

前面我们用bufferevent_setcb来设置回调函数，libevent的回调触发时机是这样的：

1. 当输入缓冲区的数据大于或等于输入低水位时，读取回调就会被调用。默认情况下，输入低水位的值是 0，也就是说，只要 socket 变得可读，就会调用读取回调。
2. 当输出缓冲区的数据小于或等于输出低水位时，写入回调就会被调用。默认情况下，输出低水位的值是 0，也就是说，只有当输出缓冲区的数据都发送完了，才会调用写入回调。因此，默认情况下的写入回调也可以理解成为 write complete callback。
3. 当连接建立、连接关闭、连接超时或者连接发生错误时，则会调用事件回调。

参考：http://senlinzhan.github.io/2017/08/20/libevent-buffer/

http://www.wangafu.net/~nickm/libevent-book/Ref6_bufferevent.html

这里提到的demo，会有几个问题：

1. client提前退出时，server端继续写数据会收到sigpipe信号，然后直接退出。
2. echo_read_cb读回调，如果读的数据比较大，可能会触发多次，然而我们需要在数据结束时再同时处理，这里同样需要判断一下数据是否已经读取结束；
3. 如果client提前退出，即使忽略了sigpipe信号 ，但是链接依旧不会关闭；

第一个问题，是因为连接建立，若某一端关闭连接，而另一端仍然向它写数据，第一次写数据后会收到RST响应，此后再写数据，内核将向进程发出SIGPIPE信号，通知进程此连接已经断开。而SIGPIPE信号的默认处理是终止程序。解决方案就是直接忽略SIGPIPE信号。

signal(SIGPIPE, SIG_IGN);

第二个问题，同样用一个mark来标记读取结束。这里用到evbuffer_peek来获取整个buffer内存而不是copy出来再查。

http://www.wangafu.net/~nickm/libevent-book/Ref7_evbuffer.html

bool CheckReadFinished(struct evbuffer *input) {
    const int limit_vec = 10;

    struct evbuffer_iovec v[limit_vec];
    int n = evbuffer_peek(input, -1, NULL, v, limit_vec);
    if (n <= 0) {
        return false;
    }

    int end_mark_len = strlen(end_mark);
    for (unsigned i = n - 1; i >= 0; --i) {
        size_t len = v[i].iov_len;
        if (len >= end_mark_len) {
            return strncmp((char*)(v[i].iov_base) + (len - end_mark_len), end_mark, end_mark_len) == 0;
        } else {
            if (strncmp((char*)(v[i].iov_base), end_mark + (end_mark_len - len), len) != 0) {
                return false;
            }
            end_mark_len -= len;
        }
    }
    return false;
}

这里直接用了limit_vec来限制大小，如果超出buff大小就认为是错误的。

static void echo_read_cb(struct bufferevent *bev, void *ctx) {
    struct evbuffer *input = bufferevent_get_input(bev);
    struct evbuffer *output = bufferevent_get_output(bev);
    
    if (CheckReadFinished(input)) {
        size_t len = evbuffer_get_length(input);
        printf("we got some data: %d\n", len);
        evbuffer_add_printf(output, end_mark);
    }
}

第三个问题，client异常退出是避免不了的，所以要有容错机制，同样是采用超时来容错。

static void
accept_conn_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *ctx) {
    evutil_make_socket_nonblocking(fd);

    struct event_base *base = evconnlistener_get_base(listener);
    struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    bufferevent_setcb(bev, echo_read_cb, echo_write_cb, echo_event_cb, NULL);

    // 设置超时，然后断开链接
    struct timeval read_tv = {2, 0}, write_tv = {3, 0};
    bufferevent_set_timeouts(bev, &read_tv, &write_tv);

    bufferevent_enable(bev, EV_READ | EV_WRITE);
}

然后在BEV_EVENT_TIMEOUT事件触发时free掉evbuff。因为我们指定了BEV_OPT_CLOSE_ON_FREE，所以这时候就会断掉连接。

static void echo_event_cb(struct bufferevent *bev, short events, void *ctx) {
    if (events & BEV_EVENT_ERROR)
        perror("Error from bufferevent");
    if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR | BEV_EVENT_TIMEOUT)) {
        printf("free event\n");
        bufferevent_free(bev);
    }
}

这里我们也可以看到，正常情况下，当client读取结束之后会close(fd)，这时就会触发BEV_EVENT_EOF事件，同样是会关掉服务端的连接。