学习研究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握手开始。
网友评论