TOA 的由来

咱们晓得 LVS 之前有三种负载平衡模式：DR、NAT 和 Tunnel，但都有各自的缺点，比方 DR 和 NAT 要求 virtual server 与 real server 在同一子网下，而 Tunnel 运维起来比较复杂。因而，为了灵便部署，开发了第四种模式，即 FULLNAT。

FULLNAT 模式是 NAT 模式的一种扩大，不仅会替换目标 IP，也会替换源 IP。带来的益处是，使得 virtual server 和 real server 解脱后端网络的解放，不再要求它们位于同一子网下。

然而，这种模式也带来了一个问题，real server 无奈获取实在的客户端 IP 地址，而在很多业务场景下，咱们在对外提供服务时，须要查看服务申请方的 IP 地址，来针对IP地址做一些业务解决，最常见的一个例子就是：做白名单校验，只有在白名单列表中的 IP 地址，咱们才容许它拜访咱们的服务；还有一种利用场景，那就是基于客户端的申请 IP 来进行调度，譬如 CDN 服务，那么就须要依据客户端的申请 IP，来调度最近最适宜的资源提供服务。

为了解决上述问题，TOA 应运而生，它理论是一个 TCP option filed，应用了 8 字节（kind = 0xfe，Length = 0x08，Value = 4B client's IP + 2B port），源码如下，

/* MUST be 4 bytes alignment */struct toa_data {    __u8 opcode;    __u8 opsize;    __u16 port;    __u32 ip;};

服务端机器打上 patch 后，在 lvs FULLNAT 模式下可能通过零碎调用 getsockopt 拿到实在的 client IP 地址。

TOA 的应用

为了反对 TOA，FULLNAT 间接批改了内核代码，如果要从新编译内核，那应用起来就很麻烦了，咱们能够以 .ko 文件的模式加载到内核，通过以下命令查看以后机器是否加载了 toa 模块，

lsmod | grep toa

toa 模块的编译能够参考文档 TOA插件配置。

TOA 的实现原理

TOA 次要通过 hook 零碎函数，进而从 tcp option 解析出 toa data。

留神：以下阐明中用到的 linux 源码版本为 3.2.101。

toa_init 函数是 toa 模块的初始化函数，

/* module init */static int __inittoa_init(void){    ...    /* hook funcs for parse and get toa */    hook_toa_functions();    ...}

以上省略了一些解决细节，重点代码是 hook 的处理函数 hook_toa_functions，以 ipv4 协定为例进行阐明。

/* replace the functions with our functions */static inline inthook_toa_functions(void){    /* hook inet_getname for ipv4 */    struct proto_ops *inet_stream_ops_p =            (struct proto_ops *)&inet_stream_ops;        /* hook tcp_v4_syn_recv_sock for ipv4 */    struct inet_connection_sock_af_ops *ipv4_specific_p =            (struct inet_connection_sock_af_ops *)&ipv4_specific;    ...    inet_stream_ops_p->getname = inet_getname_toa;    ...    ipv4_specific_p->syn_recv_sock = tcp_v4_syn_recv_sock_toa;    return 0;}

在linux 源码中 ipv4 协定各处理函数有如下定义，

/* net/ipv4/tcp_ipv4.c */const struct inet_connection_sock_af_ops ipv4_specific = {    ..    .send_check       = tcp_v4_send_check,    .conn_request       = tcp_v4_conn_request,    .syn_recv_sock       = tcp_v4_syn_recv_sock,    .get_peer       = tcp_v4_get_peer,};EXPORT_SYMBOL(ipv4_specific);

stream 类型 socket 各处理函数有如下定义，

/* net/ipv4/af_inet.c */const struct proto_ops inet_stream_ops = {    .family           = PF_INET,    .bind           = inet_bind,    .connect       = inet_stream_connect,    .accept           = inet_accept,    .getname       = inet_getname,    .listen           = inet_listen,    .shutdown       = inet_shutdown,    ...};EXPORT_SYMBOL(inet_stream_ops);

联合 linux 源码和 toa 代码，发现了两个要害 hook：

  • syn_recv_sock 函数指针 tcp_v4_syn_recv_sock -> tcp_v4_syn_recv_sock_toa；
  • getname 函数指针 inet_getname -> inet_getname_toa。

syn_recv_sock 调用

syn_recv_sock 函数在 server 收到第三次握手的 ack 包后触发调用逻辑，调用门路为 tcp_v4_do_rcv -> tcp_v4_hnd_req -> tcp_check_req -> syn_recv_sock。

/* net/ipv4/tcp_minisocks.c */struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,               struct request_sock *req,               struct request_sock **prev){    ...    child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);    if (child == NULL)        goto listen_overflow;    ...}

另外，在浏览这部分 linux 源码时发现，server socket 在收到第三次握手时状态仍为 TCP_LISTEN。

int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb){    ...    if (sk->sk_state == TCP_LISTEN) {        struct sock *nsk = tcp_v4_hnd_req(sk, skb);        if (!nsk)            goto discard;         /* 在第三次握手时产生了一个新的 socket，进入该逻辑 */        if (nsk != sk) {            sock_rps_save_rxhash(nsk, skb);            if (tcp_child_process(sk, nsk, skb)) {                rsk = nsk;                goto reset;            }            return 0;        }    }    ...}

第三次握手会产生一个新 socket，初始状态为 TCP_SYN_RECV，随后转换成 TCP_ESTABLISHED。

上面来看一下代替函数 tcp_v4_syn_recv_sock_toa 代码逻辑，

static struct sock *tcp_v4_syn_recv_sock_toa(struct sock *sk, struct sk_buff *skb,            struct request_sock *req, struct dst_entry *dst){    struct sock *newsock = NULL;    /* 先走原有的逻辑 */    newsock = tcp_v4_syn_recv_sock(sk, skb, req, dst);    /* 解析 toa data 放到 newsock->sk_user_data */    if (NULL != newsock && NULL == newsock->sk_user_data) {        newsock->sk_user_data = get_toa_data(skb);        ..    }    return newsock;}

解析 toa data 的函数为 get_toa_data，代码要害是找到 tcp option 的相应字段并解析到一个 toa_data 类型的变量 sk_user_data 里，这里不开展剖析。

inet_getname 调用

当咱们须要从 socket 里拿 client ip 时，就会调用到 inet_getname 函数。

一种应用形式是通过 accept 零碎调用。

#include <sys/socket.h>int accept(int sockfd, struct sockaddr *restrict addr,           socklen_t *restrict addrlen);

如果传入 sockaddr 类型变量，就会触发 inet_getname 函数调用逻辑，

/* net/socket.c */SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,        int __user *, upeer_addrlen, int, flags){    ...    if (upeer_sockaddr) {        if (newsock->ops->getname(newsock, (struct sockaddr *)&address,                      &len, 2) < 0) {            err = -ECONNABORTED;            goto out_fd;        }        ...    }    ...}

另外，也能够通过 getpeername、getsockopt 等零碎调用触发。

那么，上面来看一下代替函数 inet_getname_toa 的实现逻辑。

static intinet_getname_toa(struct socket *sock, struct sockaddr *uaddr,        int *uaddr_len, int peer){    int retval = 0;    struct sock *sk = sock->sk;    struct sockaddr_in *sin = (struct sockaddr_in *) uaddr;    struct toa_data tdata;    /* 调用原来的逻辑 */    retval = inet_getname(sock, uaddr, uaddr_len, peer);        /* sk_user_data 有数据会进行数据拷贝 */    if (retval == 0 && NULL != sk->sk_user_data && peer) {        if (sk_data_ready_addr == (unsigned long) sk->sk_data_ready) {            memcpy(&tdata, &sk->sk_user_data, sizeof(tdata));            if (TCPOPT_TOA == tdata.opcode &&                TCPOLEN_TOA == tdata.opsize) {                sin->sin_port = tdata.port;                sin->sin_addr.s_addr = tdata.ip;            }            ...        }        ...    }     return retval;}

当 sk_user_data 变量里有数据时，且未 toa 数据时，会替换相应的 ip 和 port，这样就能拿到失常的 client ip 和 port 了。

通过以上剖析能够看到，toa 模块的工作模式是，在第三次握手时，将 toa data 解析到 sk_user_data 变量里，而后，每次在须要的时候进行相应的替换。