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，这样下次就不用再解析了。