bind函数

2820阅读　0评论2013-12-12　liubangbo
分类：LINUX

内核版本：2.6.21.5
相信接触linux网络编程工程师对这个函数也很熟悉，还是让我们从源代码的角度看看这个函数到底做了什么，函数注释是这么说的：
Bind a name to a socket. Nothing much to do here since it's the protocol's responsibility to handle the local address.  在看这个函数之前，先看一下怎么使用这个api:
struct _in servaddr;

sockfd = (, , 0); /* create a  */

/* init servaddr */ (&servaddr, sizeof(servaddr));
servaddr.sin_family = ;
servaddr.s.s_addr = ();  //通常我们用

下面来具体看一下这个函数吧
1.

点击(此处)折叠或打开

  1. /*
  2.  *    Bind a name to a socket. Nothing much to do here since it's
  3.  *    the protocol's responsibility to handle the local address.
  4.  *
  5.  *    We move the socket address to kernel space before we call
  6.  *    the protocol layer (having also checked the address is ok).
  7.  */

  9. asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
  10. {
  11.     struct socket *sock;
  12.     char address[MAX_SOCK_ADDR];
  13.     int err, fput_needed;

  15.     sock = sockfd_lookup_light(fd, &err, &fput_needed);    //不具体看这个函数了，但我们知道通过fd，我们得到了这个socket结构
  16.     if(sock) {
  17.         err = move_addr_to_kernel(umyaddr, addrlen, address);  //这个函数是怎么实现的，还是以后再说
  18.         if (err >= 0) {
  19.             err = security_socket_bind(sock,
  20.                          (struct sockaddr *)address,
  21.                          addrlen);
  22.             if (!err)
  23.                 err = sock->ops->bind(sock,        //还记得在创建socket的时候，挂入的回调函数吧：inet_bind
  24.                          (struct sockaddr *)
  25.                          address, addrlen);
  26.         }
  27.         fput_light(sock->file, fput_needed);
  28.     }
  29.     return err;
  30. }
从上面的代码可以看到，进入bind系统调用后，根据fd得到socket，直接调用bind的回调函数，直接看inet_bind：
2.

点击(此处)折叠或打开

  1. int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  2. {
  3.     struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;  //这个是我们调用bind api 传入的
  4.                                                             
  5.     struct sock *sk = sock->sk;   //通过struct socket结构，直接得到struct sock和struct inet_sock结构
  6.     struct inet_sock *inet = inet_sk(sk);
  7.     unsigned short snum;
  8.     int chk_addr_ret;
  9.     int err;

  11.     /* If the socket has its own bind function then use it. (RAW) */
  12.     if (sk->sk_prot->bind) {                                 //如果创建的是RAW类型的socket
  13.         err = sk->sk_prot->bind(sk, uaddr, addr_len);
  14.         goto out;
  15.     }
  16.     err = -EINVAL;
  17.     if (addr_len < sizeof(struct sockaddr_in))
  18.         goto out;

  20.     chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr); //通过这个函数能得到传入IP地址的类型，是单播地址，广播地址，多播地址等，有好多类型呢

  22.     /* Not specified by any standard per-se, however it breaks too
  23.      * many applications when removed. It is unfortunate since
  24.      * allowing applications to make a non-local bind solves
  25.      * several problems with systems using dynamic addressing.
  26.      * (ie. your servers still start up even if your ISDN link
  27.      * is temporarily down)
  28.      */
  29.     err = -EADDRNOTAVAIL;
  30.     if (!sysctl_ip_nonlocal_bind &&            //这个从注释上看，没明白，但从代码上看，我们设置一下sysctl_ip_nonlocal_bind等参数在这里bind就失败了
  31.      !inet->freebind &&
  32.      addr->sin_addr.s_addr != INADDR_ANY &&
  33.      chk_addr_ret != RTN_LOCAL &&
  34.      chk_addr_ret != RTN_MULTICAST &&
  35.      chk_addr_ret != RTN_BROADCAST)
  36.         goto out;

  38.     snum = ntohs(addr->sin_port); //取得端口号
  39.     err = -EACCES;
  40.     if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE)) //在这里我们看到，端口号是不能随便填的，得给知名端口号让路...
  41.         goto out;

  43.     /* We keep a pair of addresses. rcv_saddr is the one
  44.      * used by hash lookups, and saddr is used for transmit.
  45.      *
  46.      * In the BSD API these are the same except where it
  47.      * would be illegal to use them (multicast/broadcast) in
  48.      * which case the sending device address is used.
  49.      */
  50.     lock_sock(sk);

  52.     /* Check these errors (active socket, double bind). */
  53.     err = -EINVAL;
  54.     if (sk->sk_state != TCP_CLOSE || inet->num) //这里检查连接的状态，对TCP来说在timewait状态时就不能绑定了，所以
  55.                                                 //在2MSL时间后才可以绑定，这就是在server端你close socket后，过一段时间才可以绑定的原因
  56.                                                 //inet->num 这个是检查是否重复绑定，现在内核TCP/IP协议栈好像已支持端口重复绑定了，以后再分析,bind失败，大部分都是在这里引起的
  57.         goto out_release_sock;

  59.     inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;  //在这里一般是0，也就是调用bind api的时候我们用了servaddr.s.s_addr = (); 
  60.                                                             //从注释上看rcv_saddr is the one used by hash lookups, and saddr is used for transmit.
  61.                                                             //当我们填上本机IP地址的时候，这2个地址就用到了，用的时候再分析
  62.     if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
  63.         inet->saddr = 0; /* Use device */

  65.     /* Make sure we are allowed to bind here. */
  66.     if (sk->sk_prot->get_port(sk, snum)) {   //bind这个函数的作用体现在这里，这个函数一调用，我们就能通过端口号找到这个socket了，稍后我们分析这个回调函数是怎么个情况
  67.         inet->saddr = inet->rcv_saddr = 0;
  68.         err = -EADDRINUSE;
  69.         goto out_release_sock;
  70.     }

  72.     if (inet->rcv_saddr)
  73.         sk->sk_userlocks |= SOCK_BINDADDR_LOCK; 
  74.     if (snum)
  75.         sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
  76.     inet->sport = htons(inet->num); //这个是服务端的端口号，你绑定的
  77.     inet->daddr = 0; //这个是要从对端发来的数据包中提取的IP地址
  78.     inet->dport = 0; //这个是要从对端发来的数据包中提取的端口号
  79.     sk_dst_reset(sk);
  80.     err = 0;
  81. out_release_sock:
  82.     release_sock(sk);
  83. out:
  84.     return err;
  85. }
从上面的代码中，我们看到sk->sk_prot->get_port(sk, snum) 这里是关键，看看这个回调函数udp_v4_get_port：
3.
static inline int udp_v4_get_port(struct sock *sk, unsigned short snum)
{
    return udp_get_port(sk, snum, ipv4_rcv_saddr_equal);
}

__inline__ int udp_get_port(struct sock *sk, unsigned short snum,
            int (*scmp)(const struct sock *, const struct sock *))
{
    return  __udp_lib_get_port(sk, snum, udp_hash, &udp_port_rover, scmp);
}
还是直接分析__udp_lib_get_port函数，但我们要注意第3个参数udp_hash，先看看这个东东：
#define UDP_HTABLE_SIZE        128
struct hlist_head udp_hash[UDP_HTABLE_SIZE];  //是个哈希数组
DEFINE_RWLOCK(udp_hash_lock);


点击(此处)折叠或打开

  1. /**
  2.  * __udp_lib_get_port - UDP/-Lite port lookup for IPv4 and IPv6
  3.  *
  4.  * @sk: socket struct in question
  5.  * @snum: port number to look up
  6.  * @udptable: hash list table, must be of UDP_HTABLE_SIZE
  7.  * @port_rover: pointer to record of last unallocated port
  8.  * @saddr_comp: AF-dependent comparison of bound local IP addresses
  9.  */
  10. int __udp_lib_get_port(struct sock *sk, unsigned short snum,
  11.          struct hlist_head udptable[], int *port_rover,
  12.          int (*saddr_comp)(const struct sock *sk1,
  13.                      const struct sock *sk2 ) )
  14. {
  15.     struct hlist_node *node;
  16.     struct hlist_head *head;
  17.     struct sock *sk2;
  18.     int error = 1;

  20.     write_lock_bh(&udp_hash_lock);
  21.     if (snum == 0) {     //先不看这里
  22.         int best_size_so_far, best, result, i;

  24.         if (*port_rover > sysctl_local_port_range[1] ||
  25.          *port_rover < sysctl_local_port_range[0])
  26.             *port_rover = sysctl_local_port_range[0];
  27.         best_size_so_far = 32767;
  28.         best = result = *port_rover;
  29.         for (i = 0; i < UDP_HTABLE_SIZE; i++, result++) {
  30.             int size;

  32.             head = &udptable[result & (UDP_HTABLE_SIZE - 1)];
  33.             if (hlist_empty(head)) {
  34.                 if (result > sysctl_local_port_range[1])
  35.                     result = sysctl_local_port_range[0] +
  36.                         ((result - sysctl_local_port_range[0]) &
  37.                          (UDP_HTABLE_SIZE - 1));
  38.                 goto gotit;
  39.             }
  40.             size = 0;
  41.             sk_for_each(sk2, node, head) {
  42.                 if (++size >= best_size_so_far)
  43.                     goto next;
  44.             }
  45.             best_size_so_far = size;
  46.             best = result;
  47.         next:
  48.             ;
  49.         }
  50.         result = best;
  51.         for(i = 0; i < (1 << 16) / UDP_HTABLE_SIZE; i++, result += UDP_HTABLE_SIZE) {
  52.             if (result > sysctl_local_port_range[1])
  53.                 result = sysctl_local_port_range[0]
  54.                     + ((result - sysctl_local_port_range[0]) &
  55.                      (UDP_HTABLE_SIZE - 1));
  56.             if (! __udp_lib_lport_inuse(result, udptable))
  57.                 break;
  58.         }
  59.         if (i >= (1 << 16) / UDP_HTABLE_SIZE)
  60.             goto fail;
  61. gotit:
  62.         *port_rover = snum = result;
  63.     } else {  
  64.         head = &udptable[snum & (UDP_HTABLE_SIZE - 1)]; //以端口号为key找到head

  66.         sk_for_each(sk2, node, head)
  67.             if (sk2->sk_hash == snum &&     //在这里哈希冲突了(当我们用创建的不同socket去bind相同的端口号就出现了此情况)，就判断这个端口号是否已经绑定了等其他条件，如还冲突就goto fail;
  68.              sk2 != sk &&       //这个比较就看这2个socket是否是同一个socket
  69.              (!sk2->sk_reuse || !sk->sk_reuse) &&  //这个比较就是对应的SO_REUSEADDR 端口复用属性，如果不设置这个属性，2个有相同端口号的socket第二个bind会失败
  70.              (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if
  71.              || sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
  72.              (*saddr_comp)(sk, sk2) )
  73.                 goto fail;
  74.     }
  75.     inet_sk(sk)->num = snum; //在这里把端口号赋值给inet_sk->num字段，也就是我们说的bind端口号了
  76.     sk->sk_hash = snum;      //赋值给哈希key
  77.     if (sk_unhashed(sk)) {
  78.         head = &udptable[snum & (UDP_HTABLE_SIZE - 1)];
  79.         sk_add_node(sk, head);       //在这里把挂入sock节点，也就是通过端口号把socket关联起来了，在前面文章的分析中我们知道通过接收到的skb中的目的端口号我们就可以找到处理这个skb的socket
  80.                                      //然后就把这个skb挂入到这个socket接收队列中，在应用层我们就可以recv_from了。
  81.         sock_prot_inc_use(sk->sk_prot);
  82.     }
  83.     error = 0;
  84. fail:
  85.     write_unlock_bh(&udp_hash_lock);
  86.     return error;
  87. }
还是来张图吧：



over......


上一篇：socket创建过程
下一篇：recvfrom函数