Linux内核网络协议栈4－socket地址绑定

http://blog.chinaunix.net/uid-22359610-id-461265.html

一、socket绑定入口

1、示例代码

1. struct sockaddr_in server_address;  
2. server_address.sin_family = AF_INET;  
3. server_address.sin_addr.s_addr = inet_addr("0.0.0.0");  
4. server_address.sin_port = htons(9734);  
5. server_len = sizeof(server_address);  
6. bind(server_sockfd, (struct sockaddr *)&server_address, server_len);  

2、绑定入口
前面介绍了socket从库函数到内核的过程，其最终都是通过102号中断进入内核，所不同的是子中断号不同；对于绑定，其子中断号是2；

和创建socket一样，绑定socket的处理函数都是：

1. asmlinkage long sys_socketcall(int call, unsigned long __user *args)  
2. {  
3.     unsigned long a[6];  
4.     unsigned long a0, a1;  
5.     int err;  
6.     if (copy_from_user(a, args, nargs[call]))  
7.             return -EFAULT;  
8.     a0 = a[0];  
9.     a1 = a[1];  
10.   
11.     switch (call) {  
12.             …...  
13.     case SYS_BIND:  
14.             err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);  
15.             …...  
16. }  

根据子中断号，内核会执行sys_bind()函数来完成地址的绑定；

二、绑定的具体过程

sys_bind()函数如下，一起来分析一下它的主要过程：

1. asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)  
2. {  
3.     struct socket *sock;  
4.     char address[MAX_SOCK_ADDR];  
5.     int err, fput_needed;  
6.     // 1, 根据fd查找相应的socket结构  
7.     sock = sockfd_lookup_light(fd, &err, &fput_needed);  
8.     if (sock) {  
9.             // 2, 将用户空间的地址结构拷贝到内核空间  
10.             err = move_addr_to_kernel(umyaddr, addrlen, address);  
11.             if (err >= 0) {  
12.                     err = security_socket_bind(sock,  
13.                                           (struct sockaddr *)address,  
14.                                           addrlen);  
15.                     if (!err)  
16.                             // 3, 根据协议域及socket类型，调用相应的bind函数  
17.                             err = sock->ops->bind(sock,  
18.                                              (struct sockaddr *)  
19.                                              address, addrlen);  
20.             }  
21.             fput_light(sock->file, fput_needed);  
22.     }  
23.     return err;  
24. }  

上面的过程中：
1、根据fd找到相应的socket结构
在创建socket的最后，会将socket结构与文件系统关联，并返回给应用程序与socket相关的文件描述符；这里是根据应用程序传递过来的文件描述符取得关联的socket结构；
下面看看从fd取得socket结构的代码：

1. static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)  
2. {  
3.     struct file *file;  
4.     struct socket *sock;  
5.   
6.     *err = -EBADF;  
7.     file = fget_light(fd, fput_needed);  
8.     if (file) {  
9.             sock = sock_from_file(file, err);  
10.             if (sock)  
11.                     return sock;  
12.             fput_light(file, *fput_needed);  
13.     }  
14.     return NULL;  
15. }  

再到fget_lignt()去看看：

1. struct file *fget_light(unsigned int fd, int *fput_needed)  
2. {  
3.     struct file *file;  
4.     struct files_struct *files = current->files;  
5.     …...  
6.     file = fcheck_files(files, fd);  
7.     …...  
8.     return file;  
9. }  

这里current宏返回当前运行的进程的描述符，current->files返回当前进程的打开文件表；函数fcheck_files(files, fd)根据fd从打开文件表里取出相应的file结构变量；
在创建socket中提到，file与socket关联，是通过file->private=socket完成的，因为获取到file结构变量后，也可以通过同样的方式取得socket结构变量；sock_from_file()函数就是用来完成此工作的；

2、将地址从用户空间拷贝到内核空间
1) 用户空间和内核空间的概念：
Linux内核管理模型中，简化了分段机制，使得虚拟地址与线性地址总是一致的；因此，针对32位的机器，Linux的虚拟地址空间也为0~4G。

Linux内核将这4G字节的空间分为两部分：将最高的1G字节（从虚拟地址0xC0000000到0xFFFFFFFF），供内核使用，称为“内核空间”；而将较低的3G字节（从虚拟地址0x00000000到0xBFFFFFFF），供各个进程使用，称为“用户空间”。因为每个进程可以通过系统调用进入内核，因此，Linux内核由系统内的所有进程共享。但是从具体进程的角度来看，每个进程可以拥有4G字节的虚拟空间。

2) 用户态和内核态
当进程在执行用户自己的代码时，则称其处于用户运行态（用户态）；即此时处理器在特权级最低的（3级）用户代码中运行；在用户态，进程使用进程的用户栈；
当进程执行系统调用而陷入内核代码中执行时，称该进程处于内核运行态（或简称为内核态），此时处理器处于特权级最高的（0级）内核代码中执行；当进程处于内核态时，执行的内核代码会使用当前进程的内核栈；每个进程都有自己的内核堆栈。

当正在执行用户程序而突然被中断程序中断时，此时用户程序也可以象征性地称为处于内核态，因为中断处理程序将使用当前进程的内核栈，这与处于内核态的进程的状态有些类似。

3) 用户栈和内核栈
前面提到，每个进程有2个栈，即用户栈和内核栈；用户栈的空间指向用户地址空间，内核栈的空间指向内核地址空间。当进程在用户态运行时，CPU堆栈指针寄存器esp指向用户栈地址，使用用户栈；当进程运行在内核态时，CPU堆栈指针寄存器esp指向的是内核栈空间地址，使用的是内核栈；

内核在创建一个新的进程时，在创建进程控制块的同时，即创建了内核栈；而当进程调用execve的时候，才会创建用户栈；

4) 为什么要拷贝？
如果内核直接访问用户空间的地址，或是使用memcpy来拷贝，可能会出现缺页，但是缺页后的中断处理程序需要特定的结构辅助才能正常返回到缺页中断发生的地方，因此需要使用copy_from_user来完成；

结合上面提到的用户态、内核态、用户空间和地址空间后，就不难理解为什么系统调用中，都要将一些参数从用户空间拷贝到内核空间了；

3、地址结构
示例代码中创建的是类型为struct sockaddr_in的结构体变量，在调用bind()库函数时，将地址变量强制转化为struct sockaddr结构；

大家看到这里可能会有下面的疑问：

a)这两个结构体到底是什么关系？

b)为什么要强制转化为struct sockaddr结构？

c)bind()库函数最后一个参数，为什么要把结构体长度传进去呢？

首先看看struct sockaddr_in和struct sockaddr结构体吧：

1. struct sockaddr_in {  
2.   sa_family_t           sin_family; /* Address family           */  
3.   __be16            sin_port;       /* Port number                  */  
4.   struct in_addr   sin_addr;    /* Internet address             */  
5.    
6.   /* Pad to size of `struct sockaddr'. */  
7.   unsigned char         __pad[__SOCK_SIZE__ - sizeof(short int) -  
8.                     sizeof(unsigned short int) - sizeof(struct in_addr)];  
9. };  
10.    
11. struct sockaddr {  
12.     sa_family_t  sa_family; /* address family, AF_xxx       */  
13.     char            sa_data[14]; /* 14 bytes of protocol address    */  
14. };  

这里struct sockaddr_in代表AF_INET域的地址，还有一个结构体struct sockaddr_un代表AF_UNIX域的地址；而struct sockaddr表示内核系统调用时使用的地址类型，内核根据不同的协议域，在处理具体地址时再转化为相应的结构体；

在struct sockaddr_in结构体中，__pad成员用于结构体的对齐，使struct sockaddr_in和struct sockaddr的大小一致；

三、根据不同的协议来完成绑定

上面代码中的第3步是根据应用程序在创建socket时传递到内核的协议域及socket类型来决定调用采用哪个方法，具体可以参考创建socket一文，这里不再赘述；下面以AF_IENT及SOCK_STREAM为例来说明绑定的过程；
1、调用链：
net/Socket.c:sys_bind()->net/ipv4/Af_inet.c:inet_bind()；
2、inet_bind()逻辑：
1) 地址类型检查

1. chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);  
2. if (!sysctl_ip_nonlocal_bind &&  
3.     !inet->freebind &&  
4.     addr->sin_addr.s_addr != htonl(INADDR_ANY) &&  
5.     chk_addr_ret != RTN_LOCAL &&  
6.     chk_addr_ret != RTN_MULTICAST &&  
7.     chk_addr_ret != RTN_BROADCAST)  
8.     goto out;  

inet_addr_type()函数根据设置的ip地址检查其类型：

1. static inline unsigned __inet_dev_addr_type(struct net *net,  
2.                                     const struct net_device *dev,  
3.                                     __be32 addr)  
4. {  
5.     ……  
6.    
7.     if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))  
8.             return RTN_BROADCAST;  
9.     if (ipv4_is_multicast(addr))  
10.             return RTN_MULTICAST;  
11.     ……  
12.    
13.     local_table = fib_get_table(net, RT_TABLE_LOCAL);  
14.     if (local_table) {  
15.             ret = RTN_UNICAST;  
16.             if (!local_table->tb_lookup(local_table, &fl, &res)) {  
17.                     if (!dev || dev == res.fi->fib_dev)  
18.                             ret = res.type;  
19.                     fib_res_put(&res);  
20.             }  
21.     }  
22.     return ret;  
23. }  

其中：

a.ipv4_is_zeronet()用于检查地址的高8位是否为0，即地址是否为0.x.x.x，这类地址称为零网地址，零网地址也属于广播地址；

b.ipv4_is_lbcast()用于检查地址是否是广播地址（广播地址有两种，一种是有限广播，即255.255.255.255，它不会被路由但是会发送到物理网段上的所有主机；另一种是直接广播，该类地址的主机字段为255，如192.168.1.255，该广播会路由到192.168.1网段的所有主机上）；这里只是检查是否是有限广播地址；

c.ipv4_is_multicast()用于检查地址是否是多播地址，即224.x.x.x的D类地址；

当ip地址既不是多播，也不是广播时，需要通过查找路由表来确定地址的类型（关于路由表，后面再叙述）；

拿到地址类型后，inet_bind()函数会检查地址是否是单播、多播或广播地址；否则就直接出错并返回；

2) 端口范围检查

1. snum = ntohs(addr->sin_port);  
2. if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))  
3. goto out;  
4.   
5. /* Sockets 0-1023 can't be bound to unless you are superuser */  
6. #define PROT_SOCK   1024  

这里检查如果端口小于1024，且具有超级用户权限，否则直接出错并返回；

3) 设置源地址和接收地址

1. if (sk->sk_state != TCP_CLOSE || inet->num)  
2.     goto out_release_sock;  
3.    
4. inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;  
5. if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)  
6.     inet->saddr = 0;  /* Use device */  

这里先检查sock的状态，如果不是TCP_CLOSE或端口为0，则出错返回（这里也映射到创建socket时要将sock结构体变量的状态设置为TCP_CLOSE上了）；
如果地址类型是多播或广播，则源地址设置为0，而接收地址为设置的ip地址；

4) 检查端口是否被占用

1. if (sk->sk_prot->get_port(sk, snum)) {  
2.     inet->saddr = inet->rcv_saddr = 0;  
3.     err = -EADDRINUSE;  
4.     goto out_release_sock;  
5. }  

这里根据创建socket协议族初始化时设置的sk_prot来判断端口是否被占用，如果被占用则直接出错返回；关于端口是否被占用，后面会有专门的一章来描述；

5) 初始化目标地址和端口

1. inet->sport = htons(inet->num);  
2. inet->daddr = 0;  
3. inet->dport = 0;  

至此，地址绑定就完成了。

总结：

1、 根据文件描述符从进程描述符中取出相应的文件，再得到socket结构；

2、 检查ip地址的类型是否是单播、多播或广播；

3、 检查端口是否被占用；