skynet源码分析（8）--skynet的网络

作者:[e-mail]，转载请注明作者
网络部分是一个服务器最基础最核心的部分，这个技术也已经是非常成熟了，现在已经很少有人自己实现一个网络相关的库了。skynet的网络库是自己实现的。

网络底层的技术在windows上是完成端口（IOCP），在linux上是EPOLL，在mac/freebsd上是kqueue。这些技术都是能够承载高负载高并发网络请求的。IOCP和EPOLL都是异步IO，kqueue我不熟悉，就不敢评论了。

实际上云风只实现了epoll和kqueue，windows上的变种请自行搜索吧。

epoll和kqueue的实现分别在skynet_epoll.h和epoll_kqueue.h当中。epoll的函数其实就是epoll_create/epoll_ctl/epoll_del/epoll_wait这几个，要注意的是skynet中的epoll_create的参数是1024。所以连接数上不去的话很可能就是这里限制了。

skynet在skynet_poll.h中根据平台的不同包含了不同的头文件，屏蔽了平台相关性。然后在socket_server.c中实现了网络服务的逻辑。

然后skynet在skynet_socket.c中对socket_server.c中的逻辑再次做了一个封装，还添加了socket客户端相关的函数，就是connect/send/close之类的函数。

为了方便lua层使用socket，在lua-socket.c中再将对skynet_socket.c进行了一次封装。这个封装就是c语言层和lua语言层的相互转换。目前只支持tcp和udp，基于tcp上的http/websocket之类统统是不支持的。

前面讲到socket有一个单独的线程，这个线程的代码如下：

static void *thread_socket(void *p) {    struct monitor * m = p;    skynet_initthread(THREAD_SOCKET);    for (;;) {        int r = skynet_socket_poll(); //看这里        if (r==0)            break;        if (r<0) {            CHECK_ABORT            continue;        }        wakeup(m,0);    }    return NULL;}

socket线程一直调用skynet_socket_poll，这和普通网络服务器写法是一样的。普通网络服务器也是创建socket，绑定socket，添加到epoll，然后epoll_wait等待事件的发生。

skynet中的的连接会有一个状态流转的过程，可以理解为状态机。

#define SOCKET_TYPE_LISTEN 3  //监听#define SOCKET_TYPE_CONNECTING 4 //连接中#define SOCKET_TYPE_CONNECTED 5 //已连接#define SOCKET_TYPE_HALFCLOSE 6 //半双工，半连接#define SOCKET_TYPE_PACCEPT 7 //有连接进来#define SOCKET_TYPE_BIND 8 //绑定

再来重点看一下socket_server.c这个文件，它做了很多事情，代码量也比较大，有1800多行。这个文件要详细的讲呢，一是篇幅会特别大，二是大部分是网络操作，也和skynet本身没太大关联性。所以就不会细讲了，只会挑一些我认为比较重要的东西去讲。这一篇主要讲一下对网络的控制命令。

下面列出来的都是消息类型，用一个字符来表示，很不直接，很不好记/*    The first byte is TYPE    S Start socket    B Bind socket    L Listen socket    K Close socket    O Connect to (Open)    X Exit    D Send package (high)    P Send package (low)    A Send UDP package    T Set opt    U Create UDP socket    C set udp address *///请求消息头，上面的操作都是通过发送消息来实现的struct request_package {    uint8_t header[8];  // 6 bytes dummy    union {        char buffer[256];        struct request_open open;        struct request_send send;        struct request_send_udp send_udp;        struct request_close close;        struct request_listen listen;        struct request_bind bind;        struct request_start start;        struct request_setopt setopt;        struct request_udp udp;        struct request_setudp set_udp;    } u;    uint8_t dummy[256];};

这里就是处理请求的地方// return typestatic intctrl_cmd(struct socket_server *ss, struct socket_message *result) {    int fd = ss->recvctrl_fd;    // the length of message is one byte, so 256+8 buffer size is enough.    uint8_t buffer[256];    uint8_t header[2];    block_readpipe(fd, header, sizeof(header));    int type = header[0];    int len = header[1];    block_readpipe(fd, buffer, len);    // ctrl command only exist in local fd, so don't worry about endian.    switch (type) {    case 'S':        return start_socket(ss,(struct request_start *)buffer, result);    case 'B':        return bind_socket(ss,(struct request_bind *)buffer, result);    case 'L':        return listen_socket(ss,(struct request_listen *)buffer, result);    case 'K':        return close_socket(ss,(struct request_close *)buffer, result);    case 'O':        return open_socket(ss, (struct request_open *)buffer, result);  //在这里面调用connect    case 'X':        result->opaque = 0;        result->id = 0;        result->ud = 0;        result->data = NULL;        return SOCKET_EXIT;    case 'D':        return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_HIGH, NULL);    case 'P':        return send_socket(ss, (struct request_send *)buffer, result, PRIORITY_LOW, NULL);    case 'A': {        struct request_send_udp * rsu = (struct request_send_udp *)buffer;        return send_socket(ss, &rsu->send, result, PRIORITY_HIGH, rsu->address);    }    case 'C':        return set_udp_address(ss, (struct request_setudp *)buffer, result);    case 'T':        setopt_socket(ss, (struct request_setopt *)buffer);        return -1;    case 'U':        add_udp_socket(ss, (struct request_udp *)buffer);        return -1;    default:        fprintf(stderr, "socket-server: Unknown ctrl %c.\n",type);        return -1;    };    return -1;}

以‘O’为例分析一下这个流程，skynet是基于消息的，这个是它的设计理念。所以对socket的操作，也都是基于消息的。它是怎么做的呢，首先创建一个recvctrl_fd，把消息发到recvctrl_fd。然后每次socket_server_poll被调用的时候，会select这个recvctrl_fd，看有没消息。如果有就调用上面的crl_cmd函数。

过程大致都讲清楚了，现在来看’O’这个命令，也就是打开一个连接是怎么一个过程。
1.lua层的connect函数对应的是lconnect函数，

static intlconnect(lua_State *L) {    size_t sz = 0;    const char * addr = luaL_checklstring(L,1,&sz);    char tmp[sz];    int port = 0;    const char * host = address_port(L, tmp, addr, 2, &port);    if (port == 0) {        return luaL_error(L, "Invalid port");    }    struct skynet_context * ctx = lua_touserdata(L, lua_upvalueindex(1));    int id = skynet_socket_connect(ctx, host, port);  //将Lua数据转为c数据以后调c函数    lua_pushinteger(L, id);    return 1;}

2.lconnect函数调用了skynet_socket_connect函数。

int skynet_socket_connect(struct skynet_context *ctx, const char *host, int port) {    uint32_t source = skynet_context_handle(ctx);    return socket_server_connect(SOCKET_SERVER, source, host, port);}

3.skynet_socket_connect函数又调了socket_server_connect

int socket_server_connect(struct socket_server *ss, uintptr_t opaque, const char * addr, int port) {    struct request_package request;    int len = open_request(ss, &request, opaque, addr, port);    if (len < 0)        return -1;    send_request(ss, &request, 'O', sizeof(request.u.open) + len); //注意'O’    return request.u.open.id;}

4.socket_server_connect调用了一个叫send_request的函数

static voidsend_request(struct socket_server *ss, struct request_package *request, char type, int len) {    request->header[6] = (uint8_t)type;    request->header[7] = (uint8_t)len;    for (;;) {//注意write和ss->send_ctrl_fd        ssize_t n = write(ss->sendctrl_fd, &request->header[6], len+2);        if (n<0) {            if (errno != EINTR) {                fprintf(stderr, "socket-server : send ctrl command error %s.\n", strerror(errno));            }            continue;        }        assert(n == len+2);        return;    }}

到这个函数以后，比较清楚地看到，数据被发送到sendctrl_fd这个描述符上了。
5.从send_request来看，数据明明是发到了sendctrl_fd上面，而上面讲的取数据是从recvctrl_fd上取的，明显对不上。这到底是怎么回事？是的，确实是这样，还有一段代码没有看的话，这个确实是解释不通的。

    int fd[2];    poll_fd efd = sp_create();    if (sp_invalid(efd)) {        fprintf(stderr, "socket-server: create event pool failed.\n");        return NULL;    }    if (pipe(fd)) { //管道操作，fd[0]为读取端，fd[1]为写入端        sp_release(efd);        fprintf(stderr, "socket-server: create socket pair failed.\n");        return NULL;    }    if (sp_add(efd, fd[0], NULL)) {        // add recvctrl_fd to event poll        fprintf(stderr, "socket-server: can't add server fd to event pool.\n");        close(fd[0]);        close(fd[1]);        sp_release(efd);        return NULL;    }    struct socket_server *ss = MALLOC(sizeof(*ss));    ss->event_fd = efd;    ss->recvctrl_fd = fd[0];  //其它这个是管道的读取端    ss->sendctrl_fd = fd[1]; //这个是管道的写入端    ss->checkctrl = 1;

6.上面的几行代码说明了sendctrl_fd是管道的写入端，recvctrl_fd是管道的读取端，这就解释了上面5的疑问。因为管道写入端的数据都会到读取端。所以从sendctrl_fd写进去，会到recvctrl_fd里。

7.socket_server_poll中select函数检查recvctrl_fd，如果有消息，进入case控制语句，然后到’O‘，调用open_socket，在这个函数里，会调用大家熟悉的connect函数。打开一个连接到目标ip和端口的连接。

为什么操作一个网络要费这么大的劲呢，绕来绕去非常的不直观。因为skynet是基于消息的，而且每个服务都有一个monitor,每个消息处理的时候要尽可能的短，这样才不会阻塞服务里其它的请求。而connect这种明显是阻塞的，当然也可以写成非阻塞的，但是非阻塞的话，你需要不断地挂起，因为非阻塞实际上是基于select技术来实现的。而不断地挂起，这个就很麻烦，写起来很痛苦而且很容易出错。因此云风把这些都放到网络线程中来做，这样就不会影响工作线程。但是这样做也有它的缺点，那就是网络线程可能会被阻塞，网络线程被阻塞就会导致服务无响应。或者导致大量的数据包积累，引起波峰。