深入理解TCP/IP协议的实现之三次握手（基于linux1.2.13）

theanarkh

发布于 2020-03-12 00:23:33

5750

发布于 2020-03-12 00:23:33

上篇我们分析了accept函数，他是消费者，这篇我们看看生产者是怎么实现的。我们从tcp_rcv函数开始，这个函数是一个分发器。当接收到一个tcp包的时候，底层就会调这个函数交给tcp层处理。

// daddr,saddr是ip头的字段，len为tcp头+数据长度 
int tcp_rcv(
    struct sk_buff *skb, 
    struct device *dev, 
    struct options *opt, 
    unsigned long daddr, 
    unsigned short len, 
    unsigned long saddr, 
    int redo, 
    struct inet_protocol * protocol
){

    // tcp报文头
    th = skb->h.th;
    // 从tcp的socket哈希链表中找到对应的socket结构
    sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
    // 读缓冲区已满，丢弃数据包
    if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
    {
        kfree_skb(skb, FREE_READ);
        release_sock(sk);
        return(0);
    }
    // 这个就是上篇我们说的skb中关联的sock结构体。
    skb->sk=sk;
    // 增加读缓冲区已使用的内存的大小
    sk->rmem_alloc += skb->mem_len;
    // 连接还没有建立，不是通信数据包
    if(sk->state!=TCP_ESTABLISHED)      
    {

        // 是监听socket则可能是一个syn包  
        if(sk->state==TCP_LISTEN)
        {   
            // 不存在这种可能的各种情况，直接丢包               
            if(th->rst || !th->syn || th->ack || ip_chk_addr(daddr)!=IS_MYADDR)
            {
                kfree_skb(skb, FREE_READ);
                release_sock(sk);
                return 0;
            }

            // 是个syn包，建立连接
            tcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());

            release_sock(sk);
            return 0;
        }
    }
}

上面的函数主要的逻辑两个 1 get_sock是根据源ip、端口和目的ip、端口从tcp的sock_array哈希表里找到对应的sock结构体。

/*
    num 目的端口
    raddr 源ip
    rnum 源端口
    laddr 目的ip
*/
struct sock *get_sock(struct proto *prot, unsigned short num,
                unsigned long raddr,
                unsigned short rnum, unsigned long laddr)
{
    struct sock *s;
    struct sock *result = NULL;
    int badness = -1;
    unsigned short hnum;

    hnum = ntohs(num);

    for(s = prot->sock_array[hnum & (SOCK_ARRAY_SIZE - 1)];
            s != NULL; s = s->next) 
    {
        int score = 0;
        // 绑定的端口是否等于报文中的目的端口
        if (s->num != hnum) 
            continue;
        // 该sock已经不用了，下一个
        if(s->dead && (s->state == TCP_CLOSE))
            continue;
        /* local address matches? */
        // 绑定的ip，bind的时候赋值
        if (s->saddr) {
            // 报文中的目的ip是不是等于该socket绑定的ip
            if (s->saddr != laddr)
                continue;
            score++;
        }
        /* remote address matches? */
        // 目的ip
        if (s->daddr) {
            if (s->daddr != raddr)
                continue;
            score++;
        }
        /* remote port matches? */
        // 目的端口
        if (s->dummy_th.dest) {
            if (s->dummy_th.dest != rnum)
                continue;
            score++;
        }
        /* perfect match? */
        // 全匹配，直接返回
        if (score == 3)
            return s;
        /* no, check if this is the best so far.. */
        if (score <= badness)
            continue;
        // 记录最好的匹配项
        result = s;
        badness = score;
      }
      return result;
}

对于监听型的socket，我们在bind的时候写入了绑定的ip和端口。对于监听型的socket，是没有目的ip和目的端口的。通信型的socket才有。所以上面的函数根据服务端绑定的ip和端口。判断是否等于tcp报文中的目的ip和端口。最后拿到监听型的sock结构体。 2 tcp_conn_request处理sync包，tcp_conn_request里完成了tcp的第一次和第二次握手。

// 收到一个syn包时的处理 
static void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
         unsigned long daddr, unsigned long saddr,
         struct options *opt, struct device *dev, unsigned long seq)
{
    struct sk_buff *buff;
    struct tcphdr *t1;
    unsigned char *ptr;
    struct sock *newsk;
    struct tcphdr *th;
    struct device *ndev=NULL;
    int tmp;
    struct rtable *rt;

    th = skb->h.th;

    // 过载则丢包，防止ddos，max_ack_backlog即listen的参数
    if (sk->ack_backlog >= sk->max_ack_backlog) 
    {
        tcp_statistics.TcpAttemptFails++;
        kfree_skb(skb, FREE_READ);
        return;
    }

    // 分配一个新的sock结构用于通信。accept的时候返回的就是这个sock结构体
    newsk = (struct sock *) kmalloc(sizeof(struct sock), GFP_ATOMIC);
    // 从listen套接字复制内容，再覆盖某些字段
    memcpy(newsk, sk, sizeof(*newsk));
    skb_queue_head_init(&newsk->write_queue);
    skb_queue_head_init(&newsk->receive_queue);
    newsk->send_head = NULL;
    newsk->send_tail = NULL;
    skb_queue_head_init(&newsk->back_log);
    newsk->rtt = 0;     /*TCP_CONNECT_TIME<<3*/
    newsk->rto = TCP_TIMEOUT_INIT;
    newsk->mdev = 0;
    newsk->max_window = 0;
    newsk->cong_window = 1;
    newsk->cong_count = 0;
    newsk->ssthresh = 0;
    newsk->backoff = 0;
    newsk->blog = 0;
    newsk->intr = 0;
    newsk->proc = 0;
    newsk->done = 0;
    newsk->partial = NULL;
    newsk->pair = NULL;
    newsk->wmem_alloc = 0;
    newsk->rmem_alloc = 0;
    newsk->localroute = sk->localroute;
    newsk->max_unacked = MAX_WINDOW - TCP_WINDOW_DIFF;
    newsk->err = 0;
    newsk->shutdown = 0;
    newsk->ack_backlog = 0;
    // 期待收到的对端下一个字节的序列号
    newsk->acked_seq = skb->h.th->seq+1;
    // 进程可以读但是还没有读取的字节序列号
    newsk->copied_seq = skb->h.th->seq+1;
    // 当收到对端fin包的时候，回复的ack包中的序列号    
    newsk->fin_seq = skb->h.th->seq;
    // 进入syn_recv状态
    newsk->state = TCP_SYN_RECV;
    newsk->timeout = 0;
    newsk->ip_xmit_timeout = 0;
    // 下一个发送的字节的序列号
    newsk->write_seq = seq; 
    // 可发送的字节序列号最大值
    newsk->window_seq = newsk->write_seq;
    // 序列号小于rcv_ack_seq的数据包都已经收到
    newsk->rcv_ack_seq = newsk->write_seq;
    newsk->urg_data = 0;
    newsk->retransmits = 0;
    // 关闭套接字的时候不需要等待一段时间才能关闭
    newsk->linger=0;
    newsk->destroy = 0;
    init_timer(&newsk->timer);
    newsk->timer.data = (unsigned long)newsk;
    newsk->timer.function = &net_timer;
    init_timer(&newsk->retransmit_timer);
    newsk->retransmit_timer.data = (unsigned long)newsk;
    newsk->retransmit_timer.function=&retransmit_timer;
    // 记录端口，发送ack和get_sock的时候用
    newsk->dummy_th.source = skb->h.th->dest;
    newsk->dummy_th.dest = skb->h.th->source;
    // 记录ip，发送ack和get_sock的时候用
    newsk->daddr = saddr;
    newsk->saddr = daddr;
    // 放到tcp的sock哈希表
    put_sock(newsk->num,newsk);
    // tcp头
    newsk->dummy_th.res1 = 0;
    newsk->dummy_th.doff = 6;
    newsk->dummy_th.fin = 0;
    newsk->dummy_th.syn = 0;
    newsk->dummy_th.rst = 0;    
    newsk->dummy_th.psh = 0;
    newsk->dummy_th.ack = 0;
    newsk->dummy_th.urg = 0;
    newsk->dummy_th.res2 = 0;
    newsk->acked_seq = skb->h.th->seq + 1;
    newsk->copied_seq = skb->h.th->seq + 1;
    newsk->socket = NULL;
    newsk->ip_ttl=sk->ip_ttl;
    newsk->ip_tos=skb->ip_hdr->tos;
    rt=ip_rt_route(saddr, NULL,NULL);

    if(rt!=NULL && (rt->rt_flags&RTF_WINDOW))
        newsk->window_clamp = rt->rt_window;
    else
        newsk->window_clamp = 0;

    if (sk->user_mss)
        newsk->mtu = sk->user_mss;
    else if(rt!=NULL && (rt->rt_flags&RTF_MSS))
        newsk->mtu = rt->rt_mss - HEADER_SIZE;
    else 
    {
#ifdef CONFIG_INET_SNARL    /* Sub Nets Are Local */
        if ((saddr ^ daddr) & default_mask(saddr))
#else
        if ((saddr ^ daddr) & dev->pa_mask)
#endif
            newsk->mtu = 576 - HEADER_SIZE;
        else
            newsk->mtu = MAX_WINDOW;
    }

    // mtu等于设备的mtu减去ip头和tcp头的大小
    newsk->mtu = min(newsk->mtu, dev->mtu - HEADER_SIZE);

    // 解析tcp选项
    tcp_options(newsk,skb->h.th);
    // 分配一个skb
    buff = newsk->prot->wmalloc(newsk, MAX_SYN_SIZE, 1, GFP_ATOMIC);
    // skb和sock关联，4个字节是用于tcp mss选项，告诉对端自己的mss
    buff->len = sizeof(struct tcphdr)+4;
    buff->sk = newsk;
    buff->localroute = newsk->localroute;

    t1 =(struct tcphdr *) buff->data;

    // 构造ip和mac头
    tmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev,
                   IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);

    buff->len += tmp;
    // tcp头
    t1 =(struct tcphdr *)((char *)t1 +tmp);

    memcpy(t1, skb->h.th, sizeof(*t1));
    buff->h.seq = newsk->write_seq;
    t1->dest = skb->h.th->source;
    t1->source = newsk->dummy_th.source;
    t1->seq = ntohl(newsk->write_seq++);
    // 是个ack包，即第二次握手
    t1->ack = 1;
    newsk->window = tcp_select_window(newsk);
    newsk->sent_seq = newsk->write_seq;
    t1->window = ntohs(newsk->window);
    t1->res1 = 0;
    t1->res2 = 0;
    t1->rst = 0;
    t1->urg = 0;
    t1->psh = 0;
    t1->syn = 1;
    t1->ack_seq = ntohl(skb->h.th->seq+1);
    t1->doff = sizeof(*t1)/4+1;
    ptr =(unsigned char *)(t1+1);
    ptr[0] = 2;
    ptr[1] = 4;
    ptr[2] = ((newsk->mtu) >> 8) & 0xff;
    ptr[3] =(newsk->mtu) & 0xff;

    tcp_send_check(t1, daddr, saddr, sizeof(*t1)+4, newsk);
    // 发送ack，即第二次握手
    newsk->prot->queue_xmit(newsk, ndev, buff, 0);
    reset_xmit_timer(newsk, TIME_WRITE , TCP_TIMEOUT_INIT);
    // skb关联的socket为newsk，accept的时候摘取skb时即拿到该socket返回给应用层
    skb->sk = newsk;
    // 把skb中数据的大小算在newsk中 
    sk->rmem_alloc -= skb->mem_len;
    newsk->rmem_alloc += skb->mem_len;
    // 插入监听型socket的接收队列，accept的时候摘取
    skb_queue_tail(&sk->receive_queue,skb);
    // 连接队列节点个数加1
    sk->ack_backlog++;
    release_sock(newsk);
    tcp_statistics.TcpOutSegs++;
}

这个函数主要是生成一个sock结构体，挂载到skb中，然后把skb插入队列中。最后发送ack完成第二次握手。

我们继续来看第三次握手。前面说过tcp_rcv是处理tcp数据包的。所以我们还是回到这个函数。

// daddr,saddr是ip头的字段，len为tcp头+数据长度 
int tcp_rcv(
    struct sk_buff *skb, 
    struct device *dev, 
    struct options *opt, 
    unsigned long daddr, 
    unsigned short len, 
    unsigned long saddr, 
    int redo, 
    struct inet_protocol * protocol
){
    // 从tcp的socket哈希链表中找到对应的socket结构
    sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
    // 省略大量代码
    if(sk->state==TCP_SYN_RECV)
    {
        tcp_set_state(sk, TCP_ESTABLISHED);
    }
}

这里的逻辑很简单，就是设置sock结构体的状态为建立。但是我们发现，get_sock的时候，拿到的不再是listen型的那个sock结构体了，而是tcp_conn_request中生成的那个。因为tcp_conn_request生成的sock里设置了源ip、端口、目的ip、端口。get_sock匹配的时候会全匹配到这个新的sock。三次握手的过程中，第一次握手的时候，在监听型的sock结构体的接收队列里插入了一个sock节点。在第三次握手的时候，修改这个sock状态为已连接。我们看看accept函数是怎么摘取这个队列中的节点的。

// 返回一个完成的连接
static struct sk_buff *tcp_dequeue_established(struct sock *s)
{
    struct sk_buff *skb;
    unsigned long flags;
    save_flags(flags);
    cli(); 
    skb=tcp_find_established(s);
    if(skb!=NULL)
        skb_unlink(skb);    /* Take it off the queue */
    restore_flags(flags);
    return skb;
}

// 找出已经完成三次握手的socket
static struct sk_buff *tcp_find_established(struct sock *s)
{
    struct sk_buff *p=skb_peek(&s->receive_queue);
    if(p==NULL)
        return NULL;
    do
    {
        if(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
            return p;
        p=p->next;
    }
    while(p!=(struct sk_buff *)&s->receive_queue);
    return NULL;
}

就是找到状态为TCP_ESTABLISHED的节点返回。另外监听型socket和通信型socket他的接收队列意义是不一样的，前者是已完成连接或者正在建立连接的队列，后者是数据包队列。这一版的linux把正在连接和已经完成连接的sock都放到一个队列里维护，现在的版本据说已经分为两个队列了。

本文参与腾讯云自媒体分享计划，分享自微信公众号。

原始发表：2020-03-07，如有侵权请联系 cloudcommunity@tencent.com 删除

tcp/ip