tcp选项TCP_DEFER_ACCEPT

    之前在项目测试的时候，如果第三次握手发完裸ack（没有数据）之后不发送数据的时候，连接状态一直为SYN_RCV，而且服务端重传synack，当时很不解，后来看了下源码，才发现些端倪。当时测试的内核是2.6.18-194（centos5.5）。

    第三次握手会调用函数tcp_v4_hnd_req：

static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
{
    ......
    struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
                         iph->saddr, iph->daddr);//查找半连接队列，返回req
    if (req)
        return tcp_check_req(sk, skb, req, prev);//ack的处理
    ......
}

    我们看函数tcp_check_req

struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
             struct request_sock *req,
             struct request_sock **prev)
{
       ......
        /* If TCP_DEFER_ACCEPT is set, drop bare ACK. */
        if (inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&
         TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {//如果选项设置了，并且是裸
                                                                   ack，丢弃该ack；选项值得默
                                                                   认为1
            inet_rsk(req)->acked = 1;
            return NULL;
        }
        child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb,
                                 req, NULL);//如果非裸ack或没设置选项则建立连接（req从半连接
                                              队列到连接队列及tcp状态变为ESTABLISHED）
        ......
}

我们在用户层写socket程序时，可以通过setsockopt来设置TCP_DEFER_ACCEPT选项：

val = 5;
setsockopt(srv_socket->fd, SOL_TCP, TCP_DEFER_ACCEPT, &val, sizeof(val)) ;
里面 val 的单位是秒，注意如果打开这个功能，kernel 在 val 秒之内还没有收到数据，不会继续唤醒进程，而是直接丢弃连接。

在内核空间会调用：

static int do_tcp_setsockopt(struct sock *sk, int level,
        int optname, char __user *optval, int optlen)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);
    int val;    ......
    ......
    case TCP_DEFER_ACCEPT:
        icsk->icsk_accept_queue.rskq_defer_accept = 0;
        if (val > 0) {//如果setsockopt中设置val为0，则不开始TCP_DEFER_ACCEPT选项
            /* Translate value in seconds to number of
             * retransmits */
            while (icsk->icsk_accept_queue.rskq_defer_accept < 32 &&
             val > ((TCP_TIMEOUT_INIT / HZ) <<
                 icsk->icsk_accept_queue.rskq_defer_accept))//根据设置的val决定重传次数，譬
                                                如val=10，重传次数为3；后面我们可以看到，只有
                                                /proc/sys/net/ipv4/tcp_synack_retries的
                                                值小于等于通过val算出的重传次数时，这个val才
                                                起作用
                icsk->icsk_accept_queue.rskq_defer_accept++;
            icsk->icsk_accept_queue.rskq_defer_accept++;
        }
        break;
    ......
}

内核是通过函数inet_csk_reqsk_queue_prune进行重传synack：

void inet_csk_reqsk_queue_prune(struct sock *parent,
                const unsigned long interval,
                const unsigned long timeout,
                const unsigned long max_rto)
{
    struct inet_connection_sock *icsk = inet_csk(parent);
    struct request_sock_queue *queue = &icsk->icsk_accept_queue;
    struct listen_sock *lopt = queue->listen_opt;
    int max_retries = icsk->icsk_syn_retries ? : sysctl_tcp_synack_retries;//默认synack
                                                                             重传次数为5
    int thresh = max_retries;
    unsigned long now = jiffies;
    struct request_sock **reqp, *req;
    int i, budget;
    ......
    if (queue->rskq_defer_accept)
        max_retries = queue->rskq_defer_accept;//设定支持选项时候的重传次数

    budget = 2 * (lopt->nr_table_entries / (timeout / interval));
    i = lopt->clock_hand;

    do {
        reqp=&lopt->syn_table[i];
        while ((req = *reqp) != NULL) {
            if (time_after_eq(now, req->expires)) {
                if ((req->retrans < thresh ||
                 (inet_rsk(req)->acked && req->retrans < max_retries))
                 && !req->rsk_ops->rtx_syn_ack(parent, req, NULL)) {//如果重传次数小于设定
                 的重传次数，就重传synack；这里可以看出两个并列的判断条件：req->retrans < thres
                 h和(inet_rsk(req)->acked && req->retrans < max_retries)，第一个是当前req
                 的重传次数小于设定的最大重传次数，这里是5；第二个则是TCP_DEFER_ACCEPT；inet_rs
                 k(req)->acked则是在函数tcp_check_req中设定的，上面讨论过了，而max_retries则
                 为通过val计算的值，默认为1。这个重传次数决定了synack包的重传次数及最长超时时间，
                 显然两者中较大者起到决定性的作用。譬如，默认重传为2，通过val计算出的max_retries
                 值为3，则将发送3次重传的synack及超时时间为12秒后，关闭连接
                    unsigned long timeo;

                    if (req->retrans++ == 0)
                        lopt->qlen_young--;
                    timeo = min((timeout << req->retrans), max_rto);
                    req->expires = now + timeo;//每重传一次，超时值就按初始值
                                                 timeout（TCP_TIMEOUT_INIT）比值为2的等比
                                                 数列增加，如3 6 12 24 48 96
                    reqp = &req->dl_next;
                    continue;//继续循环
                }

                /* Drop this request */
                如果超时，如超过例子中的96秒，就将req从半连接队列里删除，丢弃连接
                inet_csk_reqsk_queue_unlink(parent, req, reqp);
                reqsk_queue_removed(queue, req);
                reqsk_free(req);
                continue;
            }
            reqp = &req->dl_next;
        }

        i = (i + 1) & (lopt->nr_table_entries - 1);

    } while (--budget > 0);

    lopt->clock_hand = i;

    if (lopt->qlen)
        inet_csk_reset_keepalive_timer(parent, interval);
}

那么TCP_DEFER_ACCEPT选项有什么好处呢，我们知道服务端处于监听时，客户端connect；服务端会收到syn包，并发送synack；当客户端收到synack并发送裸ack时，服务端accept创建一个新的句柄，这是不支持TCP_DEFER_ACCEPT选项下的流程。如果支持TCP_DEFER_ACCEPT，收到裸ack时，不会建立连接，操作系统不会Accept，也不会创建IO句柄。操作系统应该在若干秒后，会释放相关的链接；但没有同时关闭相应的端口，所以客户端会一直以为处于链接状态，如果Connect后面马上有后续的发送数据，那么服务器会调用Accept接收这个连接。

函数inet_csk_reqsk_queue_prune是通过tcp_synack_timer，是它在定时器中起作用的

static void tcp_synack_timer(struct sock *sk)
{
    inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL,
                 TCP_TIMEOUT_INIT, TCP_RTO_MAX);
}

关于定时器，在后续的分析中。