ss-libev 源码解析udp篇 (3)

本篇分析server_recv_cb，这个是udp转发中最重要的函数。

server_recv_cb: 当ss-local或ss-server接收到来自前端的udp数据包时调用。这个函数代码比较多，除了local和remote(即ss-server)，还有redir, tunnel,android的代码。我们只关注local和remote。

• 首先，这个函数是注册给server_ctx_t的io的，处理serverfd上的读事件
  ev_io_init(&ctx->io, server_recv_cb, fd, EV_READ);
  根据libev的用法，当fd变可读时，调用该函数。也就是说当前端数据发送到server上时，回调函数。因此该函数需要recv来自前端的数据。下面是精简后的读取数据到buf的代码，并加了注释。

static void server_recv_cb(EV_P_ ev_io *w, int revents){      //w是ev_io*，他恰好是server_ctx_t的第一个成员，因此可以获取到sever_ctx指针      server_ctx_t *server_ctx = (server_ctx_t *)w;      //src_addr用于存放前端的地址      struct sockaddr_storage src_addr;      memset(&src_addr, 0, sizeof(struct sockaddr_storage));      //创建一个buf用于读取数据      buffer_t *buf = ss_malloc(sizeof(buffer_t));      balloc(buf, buf_size);      //前端地址结构的长度，先预先设置为sockaddr_storage的长度      socklen_t src_addr_len = sizeof(struct sockaddr_storage);      //读取数据的offset          unsigned int offset    = 0;      //使用recvfrom从server_ctx->fd读取数据到buf, 返回实际读取的数据长度r，并得到发送udp包过来的前端的地址，以及地址结构的长度      //这儿使用sockaddr_storage是要兼容ipv4,ipv6地址       ssize_t r;       r = recvfrom(server_ctx->fd, buf->data, buf_size,                 0, (struct sockaddr *)&src_addr, &src_addr_len);      //buf的实际数据长度设置为r       buf->len = r;       //后续代码}

• 如果是ss-server(即MODULE_REMOTE），由于ss-local发送过来的包是加密的，所以还要先解密：

#ifdef MODULE_REMOTE    tx += buf->len; //统计接收到的数据量    //解密整个buf    int err = server_ctx->crypto->decrypt_all(buf, server_ctx->crypto->cipher, buf_size);    if (err) {        // drop the packet silently        goto CLEAN_UP;    }#endif

• 下面是local的处理，获取frag值，这个是socks5头里面的，参考上面的socks5包结构图。ss-libev只支持frag==0的情况，所以后面会看到如果frag不是0就会丢弃。然后对于local, offset偏移3，就指向了ATYP，即socks5头里面的地址类型字段。socks5包里面从ATYP开始到DATA之前的这个结构被ss-libev直接使用来传递地址信息了。这个结构称为addr header。

    uint8_t frag = *(uint8_t *)(buf->data + 2);    offset += 3;

• 继续向下是local和remote公用的代码，用于解析目的地址。在看这段代码之前，先看一下local和remote接收到的数据包是什么结构。对于local就是socks5 udp包格式，对于remote是去除掉RSV,FRAG之后的数据（已解密）。而这儿分析目的地址，使用的parse_udprealy_header方法，接受的参数都是从ATYP开始的指针，对于local，需要偏移3个字节，正如上面看的offset+=3，对于remote就不需要了，offset默认是0就好。

char host[257] = { 0 };    char port[64]  = { 0 };    struct sockaddr_storage dst_addr;//存放目的地址    memset(&dst_addr, 0, sizeof(struct sockaddr_storage));    int addr_header_len = parse_udprealy_header(buf->data + offset, buf->len - offset,                                                host, port, &dst_addr);    if (addr_header_len == 0) {        // error in parse header        goto CLEAN_UP;    }    char *addr_header = buf->data + offset;

看一下parse_udprealy_header，输入buf指针和长度，输出host, port以及一个sockaddr_storage，函数返回值是addr header的长度，（addr header即 ATYP | DST.ADDR | DST.PORT 这个结构，其中ATYP可能是ipv4,v6或域名，如果是域名ADDR是名字长度+名字），根据地址类型的不同这个长度是不一样的，并且对于域名长度本就是可变的。
static int parse_udprealy_header(const char *buf, const size_t buf_len, char *host, char *port, struct sockaddr_storage *storage)
如果addr header中是ipv4或v6地址，storage就会被设置上，如果是域名且域名内容是ip地址，那么ip地址同样会被用于设置storage; 如果是域名且域名不是ip地址，那么storage就没有被设置，也就是是全0的值。另外host和ip会被设置上，其中对于ipv4v6,host就是通过inet_ntop转换来的ip地址表示。下面回到sever_recv_cb函数中，如果parse_udprealy_header返回为0则解析失败，CLEAN_UP只是将buf释放，然后退出函数：

CLEAN_UP:    bfree(buf);    ss_free(buf);

那么对于一个不正常的udp包，ss会默默的丢弃，效果和丢包一样。
然后char *addr_header = buf->data + offset;这句解析出addr header的指针，后面会使用。
- 下面仍然是local和remote公用的代码。在init_udprelay中，会给server_ctx_t创建一个cache，此处就会用到这个cache。

#ifdef MODULE_LOCAL    char *key = hash_key(server_ctx->remote_addr->sa_family, &src_addr);#else    char *key = hash_key(dst_addr.ss_family, &src_addr);#endif    struct cache *conn_cache = server_ctx->conn_cache;    remote_ctx_t *remote_ctx = NULL;    cache_lookup(conn_cache, key, HASH_KEY_LEN, (void *)&remote_ctx);    if (remote_ctx != NULL) {        if (sockaddr_cmp(&src_addr, &remote_ctx->src_addr, sizeof(src_addr))) {            remote_ctx = NULL;        }    }// reset the timer    if (remote_ctx != NULL) {        ev_timer_again(EV_A_ & remote_ctx->watcher);    }

首先是计算key，对于local，使用它对应的remote地址的sa_family和前端地址结构创建key；对于remote，使用目的地址的ss_family和前端地址结构创建key。也就是说，cache是通过后端的sa_family值和前端的地址对象来索引的。而key的长度是1个int的长度加上sockaddr_storage结构的长度。至于为啥用这两个值的组合作为key，因为cache中存放的是remote_ctx_t结构的指针。看一下remote_ctx_t的定义：

typedef struct remote_ctx {    ev_io io;    ev_timer watcher;    int af;    int fd;    int addr_header_len;    char addr_header[384];    struct sockaddr_storage src_addr;#ifdef MODULE_REMOTE    struct sockaddr_storage dst_addr;#endif    struct server_ctx *server_ctx;} remote_ctx_t;

使用key调用cache_lookup去查询cache中是否有该key对应的remote_ctx。如果cache中有key对应的remote_ctx则取出。取出remote_ctx后，还要检查下remote_ctx中保存的src_addr和当前数据包的src_addr是否一致，如果不一致则remote_ctx置空不再使用。如果remote_ctx可用，则重置他的timeout timer，因为要复用他了。很快会看到，remote_ctx是向后端发送udp包的上下文。
- 接收数据，解析目的地址，cache查询之后就要做转发了。代码按local和remote分开了，先讨论local的代码，精简了一下，去掉无关内容以及一些错误处理。

#ifdef MODULE_LOCAL    //上面提到，根据socks5包头中的frag是否为0决定是否丢弃包    if (frag) {        LOGE("[udp] drop a message since frag is not 0, but %d", frag);        goto CLEAN_UP;    }    //取出server_ctx中存放的remote地址    const struct sockaddr *remote_addr = server_ctx->remote_addr;    const int remote_addr_len          = server_ctx->remote_addr_len;    //如果没有从cache中找到可以复用的remote_ctx，则需要创建新的套接字    if (remote_ctx == NULL) {        // Bind to any port        int remotefd = create_remote_socket(remote_addr->sa_family == AF_INET6);        setnonblocking(remotefd);//设置为非阻塞        //创建一个全新的remote_ctx对象        // Init remote_ctx        remote_ctx                  = new_remote(remotefd, server_ctx);        remote_ctx->src_addr        = src_addr;//保存src_addr        remote_ctx->af              = remote_addr->sa_family;//保存af        remote_ctx->addr_header_len = addr_header_len;        memcpy(remote_ctx->addr_header, addr_header, addr_header_len);//保存addr header        // Add to conn cache        cache_insert(conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);//加入cache中        // Start remote io        ev_io_start(EV_A_ & remote_ctx->io);//开始监听remote fd上的读事件，详见new_remote中的事件设置        ev_timer_start(EV_A_ & remote_ctx->watcher);    }    //对于local, offset==3,这儿从buf中去掉前面3个字节，即剩下addr header和数据    if (offset > 0) {        buf->len -= offset;        memmove(buf->data, buf->data + offset, buf->len);    }    //加密去除前3个字节之后的buf    int err = server_ctx->crypto->encrypt_all(buf, server_ctx->crypto->cipher, buf_size);    //通过remote fd，将buf发送到后端    int s = sendto(remote_ctx->fd, buf->data, buf->len, 0, remote_addr, remote_addr_len);

其中,new_remote如下：

remote_ctx_t *new_remote(int fd, server_ctx_t *server_ctx){    remote_ctx_t *ctx = ss_malloc(sizeof(remote_ctx_t));    memset(ctx, 0, sizeof(remote_ctx_t));    ctx->fd         = fd;    ctx->server_ctx = server_ctx;    ev_io_init(&ctx->io, remote_recv_cb, fd, EV_READ);//remote fd上有数据可读时调用remote_recv_cb，接收来自后端返回的数据    ev_timer_init(&ctx->watcher, remote_timeout_cb, server_ctx->timeout,                  server_ctx->timeout);//设置超时，超时后会从cache中移除该remote_ctx    return ctx;}

总之，ss-local对于接收到的udp包解析出地址，去除buf的前3个字节，从cache中取remote_ctx或者创建新的socket和remote_ctx，加密buf并发送到remote，从而完成了转发udp包的工作。同时，启用了remote fd上读事件的监听，当remote有数据包返回到local时，调用remote_recv_cb。
- 再来看ss-server(即remote）的处理分支，同样，此时remote已经从local接受到udp包，解密后解析了addr header，查询了cache。具体分析下面的内容。

int cache_hit  = 0;    int need_query = 0;    if (remote_ctx != NULL) {       //如果从cache中查询成功        cache_hit = 1;        // detect destination mismatch        if (remote_ctx->addr_header_len != addr_header_len            || memcmp(addr_header, remote_ctx->addr_header, addr_header_len) != 0) {            //cache命中的remote_ctx保存的addr header和分析出来的不一致            if (dst_addr.ss_family != AF_INET && dst_addr.ss_family != AF_INET6) {                need_query = 1;//fa不是ip的情况则是域名，因为域名时没有设置为0，设置need_query            }        } else {            memcpy(&dst_addr, &remote_ctx->dst_addr, sizeof(struct sockaddr_storage));        }    } else {        if (dst_addr.ss_family == AF_INET || dst_addr.ss_family == AF_INET6) {            //没有remote_ctx，且dest addr是ip地址,则创建新的socket和remote_ctx            int remotefd = create_remote_socket(dst_addr.ss_family == AF_INET6);            if (remotefd != -1) {                setnonblocking(remotefd);                remote_ctx                  = new_remote(remotefd, server_ctx);                remote_ctx->src_addr        = src_addr;                remote_ctx->server_ctx      = server_ctx;                remote_ctx->addr_header_len = addr_header_len;                memcpy(remote_ctx->addr_header, addr_header, addr_header_len);                memcpy(&remote_ctx->dst_addr, &dst_addr, sizeof(struct sockaddr_storage));//dst_addr是remote才有的            } else {                ERROR("[udp] bind() error");                goto CLEAN_UP;            }        }    }    if (remote_ctx != NULL && !need_query) {       //不需要query，则直接send数据了，数据为addr header之后的实际数据，因此这儿要偏移addr_header_len        size_t addr_len = get_sockaddr_len((struct sockaddr *)&dst_addr);        int s           = sendto(remote_ctx->fd, buf->data + addr_header_len,                                 buf->len - addr_header_len, 0,                                 (struct sockaddr *)&dst_addr, addr_len);        if (s == -1) {            ERROR("[udp] sendto_remote");            if (!cache_hit) {                close_and_free_remote(EV_A_ remote_ctx);            }        } else {            //发送成功且cache_hit，则保存remote_ctx到cache            if (!cache_hit) {                // Add to conn cache                remote_ctx->af = dst_addr.ss_family;                char *key = hash_key(remote_ctx->af, &remote_ctx->src_addr);                cache_insert(server_ctx->conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);                ev_io_start(EV_A_ & remote_ctx->io);//启动remote fd上的读事件监听，准备从目标地址接收udp                ev_timer_start(EV_A_ & remote_ctx->watcher);            }        }    } else {        //域名的情况，需要解析        struct addrinfo hints;        memset(&hints, 0, sizeof(struct addrinfo));        hints.ai_family   = AF_UNSPEC;        hints.ai_socktype = SOCK_DGRAM;        hints.ai_protocol = IPPROTO_UDP;        struct query_ctx *query_ctx = new_query_ctx(buf->data + addr_header_len,                                                    buf->len - addr_header_len);        query_ctx->server_ctx      = server_ctx;        query_ctx->addr_header_len = addr_header_len;        query_ctx->src_addr        = src_addr;        memcpy(query_ctx->addr_header, addr_header, addr_header_len);        if (need_query) {            query_ctx->remote_ctx = remote_ctx;        }        struct ResolvQuery *query = resolv_query(host, query_resolve_cb,                                                 NULL, query_ctx, htons(atoi(port)));        if (query == NULL) {            ERROR("[udp] unable to create DNS query");            close_and_free_query(EV_A_ query_ctx);            goto CLEAN_UP;        }        query_ctx->query = query;    }

query_resolve_cb就不展开了，解析成功后会做类似的操作，并且会把解析出来的addr存入remote_ctx->dst_addr，这样下次就不用再解析了。