基于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, )) == -) {
         perror("socket error");
         exit(-);
     }

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

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

     char sendbuf[] = {};
     rc = ;

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

     char buf[] = {};

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

     close(fd);

     return ;
 }            

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

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

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

 //...

 char buf[] = {};
 while (true) {
         rc = read(fd, buf, );
         if (rc > ) {
             buf[rc] = '\0';
             printf("recv:%s\n", buf);
         } else if (rc == ) {
             break;
         } else if (rc <  && (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 = ;
 tv.tv_usec = ;
 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, )) == -) {
         perror("socket error");
         exit(-);
     }

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

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

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

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

     char sendbuf[] = {};
     rc = ;
     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 > ) fprintf(stderr,"partial write");
             else {
                 perror("write error");
                 exit(-);
             }
         }
     }

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

     close(fd);

     return ;
 }

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 = ;

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

     int end_mark_len = strlen(end_mark);
     for (unsigned i = n - ; i >= ; --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) == ;
         } else {
             if (strncmp((char*)(v[i].iov_base), end_mark + (end_mark_len - len), len) != ) {
                 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 = {, }, write_tv = {, };
     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事件，同样是会关掉服务端的连接。