linux下深入理解TCP/IP协议的实现（基于linux1.2.13）

发表于 | 分类于 ，

bind实现

按照socket网络编程的顺序，我们这一篇来分析bind函数。我们通过socket函数拿到了一个socket结构体。bind函数的逻辑其实比较简单，他就是给socket结构体绑定一个地址，简单来说，就是给他的某些字段赋值。talk is cheap。show me the code。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static int sock_bind(int fd, struct sockaddr *umyaddr, int addrlen)
{
    struct socket *sock;
    int i;
    char address[MAX_SOCK_ADDR];
    int err;

    // 通过文件描述符找到对应的socket   
    if (!(sock = sockfd_lookup(fd, NULL))) 
        return(-ENOTSOCK);

    if((err=move_addr_to_kernel(umyaddr,addrlen,address))<0)
        return err;

    if ((i = sock->ops->bind(sock, (struct sockaddr *)address, addrlen)) < 0) 
    {
        return(i);
    }
    return(0);
}

主要是两个函数，我们一个个来。

1、sockfd_lookup

通过之前一些文章的分析，我们应该数socket和文件的内存布局比较熟悉了。下面的代码不难理解。就是根据文件描述符从pcb中找到inode节点。因为inode节点里保存了socket结构体，所以最后返回fd对应的socke结构体就行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 通过fd找到file结构体，从而找到inode节点，最后找到socket结构体
static inline struct socket *sockfd_lookup(int fd, struct file **pfile)
{
    struct file *file;
    struct inode *inode;

    if (fd < 0 || fd >= NR_OPEN || !(file = current->files->fd[fd])) 
        return NULL;

    inode = file->f_inode;
    if (!inode || !inode->i_sock)
        return NULL;

    if (pfile) 
        *pfile = file;

    return socki_lookup(inode);
}

// inode和socket互相引用
inline struct socket *socki_lookup(struct inode *inode)
{
    return &inode->u.socket_i;
}

2、sock->ops->bind

我们回顾socket那篇文章可以知道socket结构体里保存了一些列的操作函数，假设是协议簇是ipv4，那么bind函数就是inet_bind函数（省略了部分代码）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
// 给socket绑定一个地址
static int inet_bind(struct socket *sock, struct sockaddr *uaddr,
           int addr_len)
{
    struct sockaddr_in *addr=(struct sockaddr_in *)uaddr;
    // 拿到底层的sock结构体
    struct sock *sk=(struct sock *)sock->data, *sk2;
    unsigned short snum = 0 /* Stoopid compiler.. this IS ok */;
    int chk_addr_ret;

    // raw协议的这些数据由用户填充  
    if(sock->type != SOCK_RAW)
    {   // 已经绑定了端口
        if (sk->num != 0) 
            return(-EINVAL);

        snum = ntohs(addr->sin_port);

        // 端口无效则随机获取一个非root才能使用的端口
        if (snum == 0) 
        {
            snum = get_new_socknum(sk->prot, 0);
        }
        // 小于1024的端口需要超级用户权限
        if (snum < PROT_SOCK && !suser()) 
            return(-EACCES);
    }
    // 判断ip
    chk_addr_ret = ip_chk_addr(addr->sin_addr.s_addr);
    // 非法地址
    if (addr->sin_addr.s_addr != 0 && chk_addr_ret != IS_MYADDR && chk_addr_ret != IS_MULTICAST)
        return(-EADDRNOTAVAIL); /* Source address MUST be ours! */
     // 记录ip    
    if (chk_addr_ret || addr->sin_addr.s_addr == 0)
        sk->saddr = addr->sin_addr.s_addr;
    if(sock->type != SOCK_RAW)
    {
        /* Make sure we are allowed to bind here. */
        cli();
        // 遍历哈希表，哈希表冲突解决法是链地址法，校验绑定的端口的合法性
        for(sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
                    sk2 != NULL; sk2 = sk2->next) 
        {
            // 端口还没有绑定过，直接校验下一个
            if (sk2->num != snum) 
                continue;
            // 端口已经被使用，没有设置可重用标记，比如断开连接后在2msl内是否可以重用，通过setsockopt函数设置
            if (!sk->reuse)
            {
                sti();
                return(-EADDRINUSE);
            }
            // 端口一样，但是ip不一样，ok，下一个
            if (sk2->saddr != sk->saddr) 
                continue;   /* socket per slot ! -FB */
            // 端口和ip都一样。被监听的端口不能同时被使用
            if (!sk2->reuse || sk2->state==TCP_LISTEN) 
            {
                sti();
                return(-EADDRINUSE);
            }
        }
        sti();
        // 保证该sk不在sock_array队列里
        remove_sock(sk);
        // 挂载到sock_array里
        put_sock(snum, sk);
        // tcp头中的源端口
        sk->dummy_th.source = ntohs(sk->num);
        sk->daddr = 0;
        sk->dummy_th.dest = 0;
    }
    return(0);
}

bind函数主要是对待绑定的ip和端口做一个校验，合法的时就记录在sock结构体中。并且把sock结构体挂载到一个全局的哈希表里。


listen 实现

listen函数的逻辑比bind还简单。bind主要是校验和绑定ip、端口。listen则是修改socket的状态，并记录一些设置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
static int sock_listen(int fd, int backlog)
{
    struct socket *sock;

    if (fd < 0 || fd >= NR_OPEN || current->files->fd[fd] == NULL)
        return(-EBADF);
    if (!(sock = sockfd_lookup(fd, NULL))) 
        return(-ENOTSOCK);

    if (sock->state != SS_UNCONNECTED) 
    {
        return(-EINVAL);
    }

    if (sock->ops && sock->ops->listen)
        sock->ops->listen(sock, backlog);
    // 设置socket的监听属性，accept函数时用到    
    sock->flags |= SO_ACCEPTCON;
    return(0);
}

static int inet_listen(struct socket *sock, int backlog)
{
    struct sock *sk = (struct sock *) sock->data;
    // 如果没有绑定端口则绑定一个，并把sock加到sock_array中
    if(inet_autobind(sk)!=0)
        return -EAGAIN;

    if ((unsigned) backlog > 128)
        backlog = 128;
    // tcp接收队列的长度上限，不同系统实现不一样，具体参考tcp.c的使用
    sk->max_ack_backlog = backlog;
    // 修改socket状态，防止多次调用listen
    if (sk->state != TCP_LISTEN)
    {   
        sk->ack_backlog = 0;
        sk->state = TCP_LISTEN;
    }
    return(0);
}

// 绑定一个随机的端口，更新sk的源端口字段，并把sk挂载到端口对应的队列中，见bind函数的分析
static int inet_autobind(struct sock *sk)
{
    /* We may need to bind the socket. */
    if (sk->num == 0) 
    {
        sk->num = get_new_socknum(sk->prot, 0);
        if (sk->num == 0) 
            return(-EAGAIN);
        put_sock(sk->num, sk);
        sk->dummy_th.source = ntohs(sk->num);
    }
    return 0;
}

accept 实现

我们继续分析tcp/ip协议的实现，这一篇讲一下accept，accept就是从已完成三次握手的连接队列里，摘下一个节点。我们可以了解到三次握手的实现和过程。很多同学都了解三次握手是什么，但是可能很少同学会深入思考或者看他的实现，众所周知，一个服务器启动的时候，会监听一个端口。其实就是新建了一个socket。那么如果有一个连接到来的时候，我们通过accept就能拿到这个新连接对应的socket。那么这个socket和监听的socket是不是同一个呢？其实socket分为监听型和通信型的。表面上，服务器用一个端口实现了多个连接，但是这个端口是用于监听的，底层用于和客户端通信的其实是另一个socket。所以每一个连接过来，负责监听的socket发现是一个建立连接的包（syn包），他就会生成一个新的socket与之通信（accept的时候返回的那个）。我们将会从代码中看到这个实现。
我们从accept函数开始，详细分析这个过程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
static int sock_accept(int fd, struct sockaddr *upeer_sockaddr, int *upeer_addrlen)
{
    struct file *file;
    struct socket *sock, *newsock;
    int i;
    char address[MAX_SOCK_ADDR];
    int len;

    if (fd < 0 || fd >= NR_OPEN || ((file = current->files->fd[fd]) == NULL))
        return(-EBADF);
    // 根据文件描述符找到对应的file结构体和socket结构
      if (!(sock = sockfd_lookup(fd, &file))) 
        return(-ENOTSOCK);
    if (sock->state != SS_UNCONNECTED) 
    {
        return(-EINVAL);
    }
    // socket没有调用过listen，报错，该标记位在listen中设置
    if (!(sock->flags & SO_ACCEPTCON)) 
    {
        return(-EINVAL);
    }
    // 分配一个新的socket结构体
    if (!(newsock = sock_alloc())) 
    {
        printk("NET: sock_accept: no more sockets\n");
        return(-ENOSR); /* Was: EAGAIN, but we are out of system
                   resources! */
    }
    newsock->type = sock->type;
    newsock->ops = sock->ops;
    // 创建一个底层的sock结构体和新的socket结构体互相关联
    if ((i = sock->ops->dup(newsock, sock)) < 0) 
    {
        sock_release(newsock);
        return(i);
    }
    // accept返回一个新的sock和socket关联
    i = newsock->ops->accept(sock, newsock, file->f_flags);
    if ( i < 0) 
    {
        sock_release(newsock);
        return(i);
    }
    // 返回一个新的文件描述符
    if ((fd = get_fd(SOCK_INODE(newsock))) < 0) 
    {
        sock_release(newsock);
        return(-EINVAL);
    }
    // 是否需要获取socket对应的地址
    if (upeer_sockaddr)
    {
        newsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
        move_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
    }
    return(fd);
}

我们一步步来分析这个函数。
1 通过fd找到对应的socket结构体，然后申请一个新的socket结构体和sock结构体，并且把他们两互相关联。这个在前面的文章分析过。
2 然后把监听的socket和准备用于通信的结构体作为参数，调用accept函数。
3 最后返回通信socket对应的文件描述符。

下面我们开始分析accept函数的真正实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static int inet_accept(struct socket *sock, struct socket *newsock, int flags)
{
    struct sock *sk1, *sk2;
    int err;
    sk1 = (struct sock *) sock->data;
    // 返回一个新的sock结构体
    sk2 = sk1->prot->accept(sk1,flags);
    // 互相关联
    newsock->data = (void *)sk2;
    sk2->socket = newsock;
    newsock->conn = NULL;
    // 设置sock为已经建立连接状态
    newsock->state = SS_CONNECTED;
    return(0);
}

这个函数主要是调底层的accept函数，底层accept函数会返回一个新的sock结构体，socket和sock结构体的区别和背景在之前的文章里已经分析过。总的来说，accept函数就是申请一个新的通信socket，这个socket关联了一个新的sock结构体。下面我们看看tcp层的accept函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
static struct sock *tcp_accept(struct sock *sk, int flags)
{
    struct sock *newsk;
    struct sk_buff *skb;

    // 是一个listen的套接字
    if (sk->state != TCP_LISTEN) 
    {
        sk->err = EINVAL;
        return(NULL); 
    }

    cli();
    // 从sock的receive_queue队列摘取已建立连接的节点，
    while((skb = tcp_dequeue_established(sk)) == NULL) 
    {   
        // 没有已经建立连接的节点，但是设置了非阻塞模式，直接返回
        if (flags & O_NONBLOCK) 
        {
            sti();
            release_sock(sk);
            sk->err = EAGAIN;
            return(NULL);
        }
        release_sock(sk);
        //阻塞进程，如果后续建立了连接，则进程被唤醒的时候，就会跳出while循环
        interruptible_sleep_on(sk->sleep);
      }
    sti();

    // 拿到一个新的sock结构，由建立连接的时候创建的
    newsk = skb->sk;

    // 返回新的sock结构体
    return(newsk);
}

这个函数主要的逻辑是从监听型socket的已完成三次握手的队列里摘下一个节点。这个节点是一个sk_buff结构体，sk_buff是一个表示网络数据包的数据结构。

img

accept函数就分析完了。下一篇我们分析三次握手。看看accept函数摘下的这个节点是如果生成的。


connect 实现

分析完了服务器端，我们继续分析客户端，在socket编程中，客户端的流程是比较简单的，申请一个socket，然后调connect去发起连接就行。我们先看一下connect函数的定义。

1
2
3
4
5
/*
    socket 通过socket函数申请的结构体
    address 需要连接的目的地地址信息
*/
int connect(int socket, const struct sockaddr *address,socklen_t address_len);

我们通过层层调用揭开connect的迷雾。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static int sock_connect(int fd, struct sockaddr *uservaddr, int addrlen)
{
    struct socket *sock;
    struct file *file;
    int i;
    char address[MAX_SOCK_ADDR];
    int err;

    if (fd < 0 || fd >= NR_OPEN || (file=current->files->fd[fd]) == NULL)
        return(-EBADF);
    if (!(sock = sockfd_lookup(fd, &file)))
        return(-ENOTSOCK);

    i = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, file->f_flags);
    if (i < 0) 
    {
        return(i);
    }
    return(0);
}

没有太多逻辑，通过fd找到关联的socket结构体。然后调底层函数。底层的函数是inet_connect，这个函数逻辑比较多，我们分开分析。

1
2
3
4
5
6
7
8
9
if (sock->state == SS_CONNECTING && sk->protocol == IPPROTO_TCP && (flags & O_NONBLOCK)) {
    if (sk->err != 0)
    {
        err=sk->err;
        sk->err=0;
        return -err;
    }
    return -EALREADY;   /* Connecting is currently in progress */
}

正在连接，并且是非阻塞的，直接返回。

1
2
3
4
5
6
7
8
9
10
11
12
if (sock->state != SS_CONNECTING) 
    {
        // 如果绑过就不需要绑了
        if(inet_autobind(sk)!=0)
            return(-EAGAIN);
        // 调用底层的连接函数，发一个syn包
        err = sk->prot->connect(sk, (struct sockaddr_in *)uaddr, addr_len);
        if (err < 0) 
            return(err);
        // 发送成功设置状态为连接中
          sock->state = SS_CONNECTING;
    }

继续调用底层的函数，这里是tcp，所以是发送一个sync包（一会分析）。然后把socket状态修改为连接中。

1
2
if (sk->state != TCP_ESTABLISHED &&(flags & O_NONBLOCK)) 
    return(-EINPROGRESS);

还没建立连接成功并且是非阻塞的方式，直接返回。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 连接建立中，阻塞当前进程
while(sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV) 
{   
    // 可中断式睡眠，即可被信号唤醒
    interruptible_sleep_on(sk->sleep);
    // 被唤醒后，判断是因为被信号唤醒的还是因为建立建立了。
    if (current->signal & ~current->blocked) 
    {
        sti();
        return(-ERESTARTSYS);
    }
    // 连接失败
    if(sk->err && sk->protocol == IPPROTO_TCP)
    {
        sti();
        sock->state = SS_UNCONNECTED;
        err = -sk->err;
        sk->err=0;
        return err; /* set by tcp_err() */
    }
}

connect的时候如果没有设置阻塞标记，则进程会被挂起。tcp层建立连接后会唤醒进程。

1
2
3
4
5
6
7
8
9
10
// 连接建立
    sock->state = SS_CONNECTED;

    if (sk->state != TCP_ESTABLISHED && sk->err) 
    {
        sock->state = SS_UNCONNECTED;
        err=sk->err;
        sk->err=0;
        return(-err);
    }

最后被连接建立唤醒后，设置socket的状态。connect就完成了。

下面我们看一下tcp层的connect的实现，其实就是从客户端视角看三次握手的过程。代码比较多，只看一下核心的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
static int tcp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
{
    struct sk_buff *buff;
    struct device *dev=NULL;
    unsigned char *ptr;
    int tmp;
    int atype;
    struct tcphdr *t1;
    struct rtable *rt;

    if (usin->sin_family && usin->sin_family != AF_INET) 
        return(-EAFNOSUPPORT);

      // 不传ip则取本机ip
      if(usin->sin_addr.s_addr==INADDR_ANY)
        usin->sin_addr.s_addr=ip_my_addr();
    // 禁止广播和多播
    if ((atype=ip_chk_addr(usin->sin_addr.s_addr)) == IS_BROADCAST || atype==IS_MULTICAST) 
        return -ENETUNREACH;

    sk->inuse = 1;
    // 连接的远端地址
    sk->daddr = usin->sin_addr.s_addr;
    // 第一个字节的序列号
    sk->write_seq = tcp_init_seq();
    sk->window_seq = sk->write_seq;
    sk->rcv_ack_seq = sk->write_seq -1;
    sk->err = 0;
    // 远端端口
    sk->dummy_th.dest = usin->sin_port;
    release_sock(sk);
    // 分配一个skb
    buff = sk->prot->wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL);
    sk->inuse = 1;
    // tcp头和选项，告诉对方自己的接收窗口大小1
    buff->len = 24;
    buff->sk = sk;
    buff->free = 0;
    buff->localroute = sk->localroute;
    t1 = (struct tcphdr *) buff->data;
    // 查找路由
    rt=ip_rt_route(sk->daddr, NULL, NULL);
    // 构建ip和mac头
    tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
                    IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
    buff->len += tmp;
    t1 = (struct tcphdr *)((char *)t1 +tmp);
    memcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
    // 序列号为初始化的序列号
    t1->seq = ntohl(sk->write_seq++);
    // 下一个数据包中第一个字节的序列号 
    sk->sent_seq = sk->write_seq;
    buff->h.seq = sk->write_seq;
    t1->ack = 0;
    t1->window = 2;
    t1->res1=0;
    t1->res2=0;
    t1->rst = 0;
    t1->urg = 0;
    t1->psh = 0;
    // 是一个syn包
    t1->syn = 1;
    t1->urg_ptr = 0;
    // TCP头包括24个字节，因为还有4个字节的选项
    t1->doff = 6;

    // 执行tcp头后面的第一个字节
    ptr = (unsigned char *)(t1+1);
    // 选项的类型是2，通知对方TCP报文中数据部分的最大值
    ptr[0] = 2;
    // 选项内容长度是4个字节
    ptr[1] = 4;
    // 组成MSS
    ptr[2] = (sk->mtu) >> 8;
    ptr[3] = (sk->mtu) & 0xff;
    // tcp头的校验和
    tcp_send_check(t1, sk->saddr, sk->daddr,sizeof(struct tcphdr) + 4, sk);

    // 设置套接字为syn_send状态
    tcp_set_state(sk,TCP_SYN_SENT);
    // 设置数据包往返时间需要的时间
    sk->rto = TCP_TIMEOUT_INIT;
    // 设置超时回调
    sk->retransmit_timer.function=&retransmit_timer;
    sk->retransmit_timer.data = (unsigned long)sk;
    // 设置超时时间
    reset_xmit_timer(sk, TIME_WRITE, sk->rto);  
    // 设置syn包的重试次数
    sk->retransmits = TCP_SYN_RETRIES;
    // 发送
    sk->prot->queue_xmit(sk, dev, buff, 0);  
    reset_xmit_timer(sk, TIME_WRITE, sk->rto);
    release_sock(sk);
    return(0);
}

代码很长，主要是构建一个sync包发出去。在这个代码里我们大概能看到tcp协议的相关实现。上面的代码完成了第一次握手。下面再看一下第二次握手的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 发送了syn包
if(sk->state==TCP_SYN_SENT)
{
    // 发送了syn包，收到ack包说明可能是建立连接的ack包
    if(th->ack)
    {
        // 尝试连接但是对端回复了重置包
        if(th->rst)
            return tcp_std_reset(sk,skb);
        // 建立连接的回包 
        syn_ok=1;   
        // 期待收到对端下一个的序列号
        sk->acked_seq=th->seq+1;
        sk->fin_seq=th->seq;
        // 发送第三次握手的ack包，进入连接建立状态
        tcp_send_ack(sk->sent_seq,sk->acked_seq,sk,th,sk->daddr);
        tcp_set_state(sk, TCP_ESTABLISHED);
        // 解析tcp选项
        tcp_options(sk,th);
        // 记录对端地址
        sk->dummy_th.dest=th->source;
        // 可以读取但是还没读取的序列号
        sk->copied_seq = sk->acked_seq;
        // 唤醒阻塞在connect函数的进程
        if(!sk->dead)
        {
            sk->state_change(sk);
            sock_wake_async(sk->socket, 0);
        }

    }
}

上面代码完成了第二次握手。tcp_send_ack完成第三次握手。这里不打算深入分析tcp层的代码，后续再深入分析。