skynet源码分析之网络层——网关服务器

在上一篇文章里介绍Lua层通过lualib/skynet/socket.lua这个库与网络底层交互（http://www.cnblogs.com/RainRill/p/8707328.html）。除此之外，skynet还提供一个通用模板lualib/snax/gateserver来启动一个网关服务器，通过TCP连接和客户端交换数据，这个库不能与socket.lua共用，因为这个库接管了底层传来的socket类消息，具体用法参考官方wiki https://github.com/cloudwu/skynet/wiki/GateServer。

1. 概述

gateserver注册接收网络底层传过来的socket消息，通过netpack.filter解析消息包（第6行），稍后会着重分析如何解析，解析完返回的type有6中类型，每种类型指定特定的回调函数。注：当一个包不完整时，type为nil，这种情况不需要处理。

"open"：新连接建立；"close"：关闭连接；"warning"：当fd上待发送的数据累积超过1M时，会收到这个消息；’"error"：发生错误，关闭fd；“data”：表示收到一个完整的tcp包，回调函数把这个包传给逻辑层去处理；

 -- lualib/snax/gateserver.lua
 skynet.register_protocol {
     name = "socket",
     id = skynet.PTYPE_SOCKET,       -- PTYPE_SOCKET = 6
     unpack = function ( msg, sz )
         return netpack.filter( queue, msg, sz)
     end,
     dispatch = function (_, _, q, type, ...)
         queue = q
         if type then
              MSG[type](...)
         end
     end
 }

“more”：表示收到的数据不止一个tcp包，netpack.filter会把包依次放到队列里，然后回调函数一个个从队列中pop出来（第11行）

-- lualib/snax/gateserver.lua
local function dispatch_queue()
    local fd, msg, sz = netpack.pop(queue)
    if fd then
    -- may dispatch even the handler.message blocked
    -- If the handler.message never block, the queue should be --
    -- empty, so only fork once and then exit.
        skynet.fork(dispatch_queue)
            dispatch_msg(fd, msg, sz)

            for fd, msg, sz in netpack.pop, queue do
                 dispatch_msg(fd, msg, sz)
            end
        end
    end

    MSG.more = dispatch_queue

2. 如何解析TCP数据包

为了说明如何解析TCP数据包，先了解下网络底层是采用什么策略接收数据的。单个socket每次从内核尝试读取的数据字节数为sz（第6行），这个值保存在s->p.size中，初始是MIN_READ_BUFFER(64b)，当实际读到的数据等于sz时，sz扩大一倍(8-9行)；如果小于sz的一半，则设置sz为原来的一半(10-11行)。

比如，客户端发了一个1kb的数据，socket线程会从内核里依次读取64b，128b，256b，512b，64b数据，总共需读取5次，即会向gateserver服务发5条消息，一个TCP包被切割成5个数据块。第5次尝试读取1024b数据，所以可能会读到其他TCP包的数据(只要客户端有发送其他数据)。接下来，客户端再发一个1kb的数据，socket线程只需从内核读取一次即可。

// skynet-src/socket_server.c
static int
forward_message_tcp(struct socket_server *ss, struct socket *s, struct socket_lock *l, struct socket_message * result) {
    int sz = s->p.size;
    char * buffer = MALLOC(sz);
    int n = (int)read(s->fd, buffer, sz);
    ...
    if (n == sz) {
        s->p.size *= 2;
    } else if (sz > MIN_READ_BUFFER && n*2 < sz) {
        s->p.size /= 2;
    }
}

netpack做的工作就是把这些数据块组装成一个完整的TCP包，再交给gateserver去处理。注：netpack约定，tcp包头两字节（大端方式）表示数据包长度。如果采用sproto打包方式，需附加4字节(32位)的session值。所以客户端传过来1kb数据，实际数据只有1024-2-4=1018字节。

数据结构：

16-19行，用数组实现的队列。当客户端连续发了几个小的tcp包，gateserver收到的一条消息包可能包含多个tcp包，存放到这个队列里

第20行，存放不完整的tcp包的指针数组，每一项是指向一个链表，fd hash值相同的组成一个链表。

 // lualib-src/lua-netpack.c
 struct netpack {
     int id; //socket id
     int size; //数据块长度
     void * buffer; //数据块
 };
 
 struct uncomplete { //不完整tcp包结构
     struct netpack pack; //数据块信息
     struct uncomplete * next; //链表，指向下一个
     int read; //已读的字节数
     int header; //第一个字节(代表数据长度的高8位)
 };
 
 struct queue {
     int cap;
     int head;
     int tail;
     struct netpack queue[QUEUESIZE]; //一次从内核读取多个tcp包时放入该队列里
     struct uncomplete * hash[HASHSIZE]; //指针数组，数组里每个位置指向一个不完整的tcp包链表，fd hash值相同的组成一个链表
 }; 

解析流程：

最终会调用filter_data_这个接口解析，下面着重介绍：

参数：fd socket； buffer从内核中读到的数据块；size数据块大小

先看后半段46-82行，当queue里并没有该socket剩余的数据块，执行46行分支。

46-51行，是一个不完整的tcp包，只有一个字节数据，说明表示长度的头部两字节数据都还差一个字节，构造一个uncomplete结构(简称uc)，然后存在queue->hash里。uc->read设置为-1，uc->header存放这一个字节。返回给Lua层的type是nil，Lua层不需要处理。

52-54行，通过头部两字节计算tcp包的长度read_size，接下来比较收到的数据size与真正需要的数据pack_size。

56-63行，size<pack_size，说明tcp包还有未读到的数据，将已读到的数据构造一个uc结构，保存在queue->hash里，返回给Lua层的type是nil，Lua层不需要处理。uc->read已读到字节，uc->pack.size目标字节数

64-73行，size=pack_size，说明是一个完整的tcp包，大部分是这种情况，把tcp包返回给Lua层即可，此时返回的type是“data”（第66行）。

74-82行，size>pack_size，说明不止一个tcp包的数据，则先通过push_data保存第一个完整的tcp包（76行），接着通过push_more处理余下的数据（79行）。返回的type是"more"。

　　　　push_data做的工作是将tcp包保存在队列里，供Lua层pop出使用。

　　　　push_more是一个递归操作，流程跟上面一样，对比读到的数据和需要的数据做对应的处理。

接着看6-44行，之前收到了tcp包的部分数据块。

8-18行，说明之前只读到一个字节，加上该数据块的第一个字节，组成两个字节计算出整个包的长度（12行）

第19行，目标字节-已读字节=需要的字节need。

20-27行，如果size<need，说明仍然还差数据块没收到，此时将数据附加到之前的uc->pack.buffer里。

28-44行，其他两种情况跟上面处理流程一样。

// lualib-src/lua-netpack.c
static int
filter_data_(lua_State *L, int fd, uint8_t * buffer, int size) {
    struct queue *q = lua_touserdata(L,1);
    struct uncomplete * uc = find_uncomplete(q, fd);
    if (uc) { //之前收到该包的部分数据块，
        // fill uncomplete
        if (uc->read < 0) {//之前只收到一个字节,加上该数据块的第一个字节，表示整个包的长度
            // read size
            assert(uc->read == -1);
            int pack_size = *buffer;
            pack_size |= uc->header << 8 ;
            ++buffer;
            --size;
            uc->pack.size = pack_size;
            uc->pack.buffer = skynet_malloc(pack_size);
            uc->read = 0;
        }
        int need = uc->pack.size - uc->read;//包还差多少字节
        if (size < need) {
            memcpy(uc->pack.buffer + uc->read, buffer, size);
            uc->read += size;
            int h = hash_fd(fd);
            uc->next = q->hash[h];
            q->hash[h] = uc;
            return 1;
        }
        memcpy(uc->pack.buffer + uc->read, buffer, need);
        buffer += need;
        size -= need;
        if (size == 0) {
            lua_pushvalue(L, lua_upvalueindex(TYPE_DATA));
            lua_pushinteger(L, fd);
            lua_pushlightuserdata(L, uc->pack.buffer);
            lua_pushinteger(L, uc->pack.size);
            skynet_free(uc);
            return 5;
        }
        // more data
        push_data(L, fd, uc->pack.buffer, uc->pack.size, 0);
        skynet_free(uc);
        push_more(L, fd, buffer, size);
        lua_pushvalue(L, lua_upvalueindex(TYPE_MORE));
        return 2;
    } else {
        if (size == 1) {
            struct uncomplete * uc = save_uncomplete(L, fd);
            uc->read = -1;
            uc->header = *buffer;
            return 1;
        }
        int pack_size = read_size(buffer); //需要数据包的字节数
        buffer+=2;
        size-=2;

        if (size < pack_size) { //说明还有未获得的数据包
            struct uncomplete * uc = save_uncomplete(L, fd); //保存这个数据包
            uc->read = size;
            uc->pack.size = pack_size;
            uc->pack.buffer = skynet_malloc(pack_size);
            memcpy(uc->pack.buffer, buffer, size);
            return 1;
        }
        if (size == pack_size) { //说明是一个完整包，把包返回给Lua层即可
            // just one package
            lua_pushvalue(L, lua_upvalueindex(TYPE_DATA));
            lua_pushinteger(L, fd);
            void * result = skynet_malloc(pack_size);
            memcpy(result, buffer, size);
            lua_pushlightuserdata(L, result);
            lua_pushinteger(L, size);
            return 5;
        }
        // more data
        // 说明不止同一个数据包,还有额外的
        push_data(L, fd, buffer, pack_size, 1); //保存第一个包到q->queue中
        buffer += pack_size;
        size -= pack_size;
        push_more(L, fd, buffer, size); //处理余下的包
        lua_pushvalue(L, lua_upvalueindex(TYPE_MORE));
        return 2;
    }
}

举例，客户端发了一个1kb的数据，socket线程会从内核里依次读取64b，128b，256b，512b，64b数据。gateserver会执行5次filter_data_，分支依次是56行，20行，20行，20行，31行。