ss-libev 源码解析local篇(1): ss_local的启动，客户端连入

学习研究ss-libev的一点记录（基于版本3.0.6）

ss_local主要代码在local.c中，如果作为一个库编译，可通过start_ss_local_server启动local server。所以先从这个函数入手，看local的启动过程。

STEP0: int start_ss_local_server(profile_t profile)

• profile_t profile 是ss-libev的配置

typedef struct {
    /*  Required  */
    char *remote_host;    // hostname or ip of remote server
    char *local_addr;     // local ip to bind
    char *method;         // encryption method
    char *password;       // password of remote server
    int remote_port;      // port number of remote server
    int local_port;       // port number of local server
    int timeout;          // connection timeout

    /*  Optional, set NULL if not valid   */
    char *acl;            // file path to acl
    char *log;            // file path to log
    int fast_open;        // enable tcp fast open
    int mode;             // enable udp relay
    int mtu;              // MTU of interface
    int mptcp;            // enable multipath TCP
    int verbose;          // verbose mode
} profile_t;

local启动时核心是创建一个listen_ctx_t对象，这个结构定义如下：

typedef struct listen_ctx {
    ev_io io;
    char *iface;
    int remote_num;
    int timeout;
    int fd;
    int mptcp;
    struct sockaddr **remote_addr;
} listen_ctx_t;

其中，最重要的是io这个成员了，这是一个libev中的ev_io对象，用来监听某个套接字上的事件，后面会具体说。

fd是local服务器的监听套接字描述符：

struct sockaddr *remote_addr_tmp[MAX_REMOTE_NUM];
    listen_ctx_t listen_ctx;
    listen_ctx.remote_num     = 1;
    listen_ctx.remote_addr    = remote_addr_tmp;
    listen_ctx.remote_addr[0] = (struct sockaddr *)(&storage);
    listen_ctx.timeout        = timeout;
    listen_ctx.iface          = NULL;
    listen_ctx.mptcp          = mptcp;

    if (mode != UDP_ONLY) {
        // Setup socket
        int listenfd;
        listenfd = create_and_bind(local_addr, local_port_str);
        if (listenfd == -1) {
            ERROR("bind()");
            return -1;
        }
        if (listen(listenfd, SOMAXCONN) == -1) {
            ERROR("listen()");
            return -1;
        }
        setnonblocking(listenfd);

        listen_ctx.fd = listenfd;

        ev_io_init(&listen_ctx.io, accept_cb, listenfd, EV_READ);
        ev_io_start(loop, &listen_ctx.io);
    }

local服务器的socket创建并绑定端口(create_and_bind)后监听(listen)，设置为非阻塞，然后设置一个libev的ev_io对象并启动EV_READ事件的监听，当该套建字上有可以读入的数据时执行回调 accept_cb，也就是说有客户端连接上来了需要去accept。在看accept_cb之前，继续看一下剩下的代码。

// Setup UDP
    if (mode != TCP_ONLY) {
        LOGI("udprelay enabled");
        struct sockaddr *addr = (struct sockaddr *)(&storage);
        udp_fd = init_udprelay(local_addr, local_port_str, addr,
                      get_sockaddr_len(addr), mtu, crypto, timeout, NULL);
    }

这是初始化udp转发，暂时不讨论了，注意这儿返回的udp_fd是local udp server的端口对应的描述符，ss-local作为独立应用使用的时候，一般tcp和udp使用同一个端口号，所以tcp的listenfd和udp_fd转换为端口号是相同的（通过getsockname获取的地址里面的端口号），但是如果ss-local作为一个库使用，往往需要将local port设置为0，让系统选择空闲端口，这些这两个描述符对应的端口就可能不一样了。3.0.6之前就没区分，我发了个issue作者才给改的。继续：

// Init connections
    cork_dllist_init(&connections);

    // Enter the loop
    ev_run(loop, 0);

    if (verbose) {
        LOGI("closed gracefully");
    }

    // Clean up
    if (mode != UDP_ONLY) {
        ev_io_stop(loop, &listen_ctx.io);
        free_connections(loop);
        close(listen_ctx.fd);
    }

    if (mode != TCP_ONLY) {
        free_udprelay();
    }

    return 0;

cork_dllist_init(&connections);初始化了一个链表，这个方法来自于libcork库。后面会说到server_t对象会存放到connections链表中，然后在free_connections的时候从链表中取出server_t对象关闭和释放。这儿有意思的是这种c语言的链表中并不是直接存放一个server_t类型的指针，而是存放了一个cork_dllist_item类型的变量，且server_t结构中会包含这个cork_dllist_item类型的变量。核心是通过cork_container_of方法可以根据cork_dllist_item的指针获取server_t对象的指针。这就相当于实现了一个侵入式的万能链表，不经常使用c语言的同学比如我还是觉得挺有趣的，c语言没有泛型是不是也挺好的。

/* Return a pointer to a @c struct, given a pointer to one of its
 * fields. */
#define cork_container_of(field, struct_type, field_name) \
    ((struct_type *) (- offsetof(struct_type, field_name) + \
                      (void *) (field)))

回到启动函数里面，ev_run(loop, 0);这句启动了一个libev的循环，且线程就阻塞在这儿了。直到服务器退出后才继续执行后面的clean up代码。所以说listen_ctx虽然是在栈上定义的，但会在ss local运行期间一直存在。下面会看到这个对象会通过指针转换在accept_cb中取得并把他存放于server_t对象中。

STEP1: void accept_cb(EV_P_ ev_io *w, int revents)

这个函数短就直接贴了：

void
accept_cb(EV_P_ ev_io *w, int revents)
{
    listen_ctx_t *listener = (listen_ctx_t *)w;
    int serverfd           = accept(listener->fd, NULL, NULL);
    if (serverfd == -1) {
        ERROR("accept");
        return;
    }
    setnonblocking(serverfd);
    int opt = 1;
    setsockopt(serverfd, SOL_TCP, TCP_NODELAY, &opt, sizeof(opt));
#ifdef SO_NOSIGPIPE
    setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
#endif

    server_t *server = new_server(serverfd);
    server->listener = listener;

    ev_io_start(EV_A_ & server->recv_ctx->io);
}

首先回顾一下上面start_ss_local_server里的两句代码：

ev_io_init(&listen_ctx.io, accept_cb, listenfd, EV_READ);
ev_io_start(loop, &listen_ctx.io);

这是libev的基本用法，简单说就是创建并初始化一个ev_io对象，即listen_ctx.io，他将监听listenfd所描述的套接字上的读事件，当有数据可读入时，调用回到函数accept_cb。ev_io_init只是初始化，只有调用了ev_io_start后才真正开始监听，这点很重要，因为代码里面经常会先init，然后在合适的时候再start，所以为了不看错代码流程一定要分清start才是真正开始监听。

回到accept_cb中，参数ev_io *w会传入监听的ev_io对象，由于io正好是listen_ctx_t结构体的第一个成员，因此可以通过指针转换得到listener的指针，进而获取到fd。由于fd是一个监听套接字，也就是说socket-bind-listen之后的套接字，这是tcp服务器的通常流程，当这个套接字上有可读数据时，说明是有客户端连入了，因此要执行accept函数，这个和在线程里面阻塞住等待accept的做法很不一样，通过libev可以异步的知道有数据可读，然后主动调用accept，这样避免开很多线程解决高并发的问题。在整个ss-local运行期间，客户端每次连入都会回调到accept_cb，进而调用accept产生一个serverfd，这个serverfd用来描述来自客户端的一条连接，ss-libev通过一个server_t结构体来管理来自客户端的一条连接。

typedef struct server {
    int fd;
    int stage;

    cipher_ctx_t *e_ctx;
    cipher_ctx_t *d_ctx;
    struct server_ctx *recv_ctx;
    struct server_ctx *send_ctx;
    struct listen_ctx *listener;
    struct remote *remote;

    buffer_t *buf;
    buffer_t *abuf;

    ev_timer delayed_connect_watcher;

    struct cork_dllist_item entries;
} server_t;

最重要的是两个server_ctx成员，recv_ctx和send_ctx，这是用来收发数据的上下文对象。server_t相当于在socks5客户端和ss-local 的socks5服务端之间交互的对象，而recv_ctx用来处理来自于socks5客户端的数据，send_ctx用来处理向socks5客户端转发来自远程服务器的数据。remote就是处理远程服务器交互的对象。其他内容先忽略，看一下server_ctx:

typedef struct server_ctx {
    ev_io io;
    int connected;
    struct server *server;
} server_ctx_t;

其中的ev_io对象io就是用来监听客户端和ss-local socks5 sever之间的数据读写的。

回到accept_cb中，server_t *server = new_server(serverfd);创建了server对象并进行设置：

static server_t *
new_server(int fd)
{
    server_t *server;
    server = ss_malloc(sizeof(server_t));

    memset(server, 0, sizeof(server_t));

    server->recv_ctx = ss_malloc(sizeof(server_ctx_t));
    server->send_ctx = ss_malloc(sizeof(server_ctx_t));
    server->buf      = ss_malloc(sizeof(buffer_t));
    server->abuf     = ss_malloc(sizeof(buffer_t));
    balloc(server->buf, BUF_SIZE);
    balloc(server->abuf, BUF_SIZE);
    memset(server->recv_ctx, 0, sizeof(server_ctx_t));
    memset(server->send_ctx, 0, sizeof(server_ctx_t));
    server->stage               = STAGE_INIT;
    server->recv_ctx->connected = 0;
    server->send_ctx->connected = 0;
    server->fd                  = fd;
    server->recv_ctx->server    = server;
    server->send_ctx->server    = server;

    server->e_ctx = ss_align(sizeof(cipher_ctx_t));
    server->d_ctx = ss_align(sizeof(cipher_ctx_t));
    crypto->ctx_init(crypto->cipher, server->e_ctx, 1);
    crypto->ctx_init(crypto->cipher, server->d_ctx, 0);

    ev_io_init(&server->recv_ctx->io, server_recv_cb, fd, EV_READ);
    ev_io_init(&server->send_ctx->io, server_send_cb, fd, EV_WRITE);

    ev_timer_init(&server->delayed_connect_watcher,
            delayed_connect_cb, 0.05, 0);

    cork_dllist_add(&connections, &server->entries);

    return server;
}

主要工作就是分配内存给recv_ctx，send_ctx以及buf和abuf这两个buffer。设置stage为STAGE_INIT，设置上fd，设置加密解密的上下文对象e_ctx和d_ctx。然后设置了两个ev_io监听，分别是对于recv_ctx->io设置READ监听，对于send_ctx->io设置WRITE监听，并且还启动了一个timer，这个timer 0.05秒之后会调用delayed_connect_cb回调。最后会通过cork_dllist_add方法，把server加入到connections链表中（上面说过）。

返回accept_cb中，执行ev_io_start(EV_A_ & server->recv_ctx->io);启动了recv_ctx->io上的事件监听，即serverfd上的读事件。下次会具体分析这个读事件的回调server_recv_cb，local的主要逻辑在这里面。

小结

• listen_ctx_t对象用于处理ss-local的监听，保存了用于处理READ事件的io和监听套接字fd，并且保存了远端ss-server服务器的地址。这个对象在ss-local运行期间一直存在。
• 当有客户端连接上ss-local后，accept_cb会被调用，其中在listen_ctx_t保存的监听fd上执行accept操作，获取serverfd，并保存在一个server_t结构中。server_t用于处理客户端和ss-lcoal之间的一条连接，客户端每次连接都会调用一次accept_cb并创建一个server_t。
• server_t对象创建后会设置recv_ctx和send_ctx，其中都包含io对象用于处理读或写事件。先启动读事件，等待客户端发送SOCKS5握手请求。
• 下文会分析server_recv_cb，从SOCKS5握手开始。