作者:shihuaping0918@163.com，转载请注明作者
网络部分是一个服务器最基础最核心的部分，这个技术也已经是非常成熟了，现在已经很少有人自己实现一个网络相关的库了。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 type
static int
ctrl_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 int
lconnect(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 void
send_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技术来实现的。而不断地挂起，这个就很麻烦，写起来很痛苦而且很容易出错。因此云风把这些都放到网络线程中来做，这样就不会影响工作线程。但是这样做也有它的缺点，那就是网络线程可能会被阻塞，网络线程被阻塞就会导致服务无响应。或者导致大量的数据包积累，引起波峰。