同一个socket是否可以bind多个端口？

版权所有，转载请注明出处。
Author: Tony

今天一个可爱的同事问我同一个socket能否bind多个port？说实话，真没这么玩过。本着严谨的态度，决定研究一下这样是否可以。
说明本内容针对的内核版本是SLES 11 SP2 3.0.13-0.27

首先分析系统调用函数bind，内核层实现在net/socket.c中：

点击(此处)折叠或打开

1. SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
   
2. {
   
3.     struct socket *sock;
   
4.     struct sockaddr_storage address;
   
5.     int err, fput_needed;
   
6. 
   
7.     sock = sockfd_lookup_light(fd, &err, &fput_needed);
   
8.     if (sock) {
   
9.         err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address);
   
10.         if (err >= 0) {
    
11.             err = security_socket_bind(sock,
    
12.                          (struct sockaddr *)&address,
    
13.                          addrlen);
    
14.             if (!err)
    
15.             /*这里调用对应proto_ops的bind，这里以tcp为例说明
16.               proto_ops实现了从协议无关的套接口层到协议相关的传输层的转接
    
17.             */
    
18.                 err = sock->ops->bind(sock,
    
19.                          (struct sockaddr *)
    
20.                          &address, addrlen);
    
21.         }
    
22.         fput_light(sock->file, fput_needed);
    
23.     }
    
24.     return err;
    
25. }

在net/ipv4/af_inet.c中，inet_protosw定义了tcp传输层的proto_ops

点击(此处)折叠或打开

1. static struct inet_protosw inetsw_array[] =
   
2. {
   
3.     {
   
4.         .type = SOCK_STREAM,
   
5.         .protocol = IPPROTO_TCP,
   
6.         .prot = &tcp_prot,
   
7.         /*这里指定了tcp传输层协议的proto_ops*/
   
8.         .ops = &inet_stream_ops,
   
9.         .no_check = 0,
   
10.         .flags = INET_PROTOSW_PERMANENT |
    
11.              INET_PROTOSW_ICSK,
    
12.     },
    
13. 
    
14.     {
    
15.         .type = SOCK_DGRAM,
    
16.         .protocol = IPPROTO_UDP,
    
17.         .prot = &udp_prot,
    
18.         .ops = &inet_dgram_ops,
    
19.         .no_check = UDP_CSUM_DEFAULT,
    
20.         .flags = INET_PROTOSW_PERMANENT,
    
21.        },
    
22. 
    
23.        {
    
24.         .type = SOCK_DGRAM,
    
25.         .protocol = IPPROTO_ICMP,
    
26.         .prot = &ping_prot,
    
27.         .ops = &inet_dgram_ops,
    
28.         .no_check = UDP_CSUM_DEFAULT,
    
29.         .flags = INET_PROTOSW_REUSE,
    
30.        },
    
31. 
    
32.        {
    
33.      .type = SOCK_RAW,
    
34.      .protocol = IPPROTO_IP,    /* wild card */
    
35.      .prot = &raw_prot,
    
36.      .ops = &inet_sockraw_ops,
    
37.      .no_check = UDP_CSUM_DEFAULT,
    
38.      .flags = INET_PROTOSW_REUSE,
    
39.        }
    
40. };

inet_stream_ops的定义也在net/ipv4/af_inet.c中

点击(此处)折叠或打开

1. const struct proto_ops inet_stream_ops = {
   
2.     .family         = PF_INET,
   
3.     .owner         = THIS_MODULE,
   
4.     .release     = inet_release,
   
5.     /*这里指定了tcp协议proto_ops的bind函数为inet_bind*/
   
6.     .bind         = inet_bind,
   
7.     .connect     = inet_stream_connect,
   
8.     .socketpair     = sock_no_socketpair,
   
9.     .accept         = inet_accept,
   
10.     .getname     = inet_getname,
    
11.     .poll         = tcp_poll,
    
12.     .ioctl         = inet_ioctl,
    
13.     .listen         = inet_listen,
    
14.     .shutdown     = inet_shutdown,
    
15.     .setsockopt     = sock_common_setsockopt,
    
16.     .getsockopt     = sock_common_getsockopt,
    
17.     .sendmsg     = inet_sendmsg,
    
18.     .recvmsg     = inet_recvmsg,
    
19.     .mmap         = sock_no_mmap,
    
20.     .sendpage     = inet_sendpage,
    
21.     .splice_read     = tcp_splice_read,
    
22. #ifdef CONFIG_COMPAT
    
23.     .compat_setsockopt = compat_sock_common_setsockopt,
    
24.     .compat_getsockopt = compat_sock_common_getsockopt,
    
25.     .compat_ioctl     = inet_compat_ioctl,
    
26. #endif
    
27. };

inet_bind的实现也在文件net/ipv4/af_inet.c中

点击(此处)折叠或打开

1. int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
   
2. {
   
3.     struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
   
4.     struct sock *sk = sock->sk;
   
5.     struct inet_sock *inet = inet_sk(sk);
   
6.     unsigned short snum;
   
7.     int chk_addr_ret;
   
8.     int err;
   
9. 
   
10.     /* If the socket has its own bind function then use it. (RAW) */
    
11.     if (sk->sk_prot->bind) {
    
12.         err = sk->sk_prot->bind(sk, uaddr, addr_len);
    
13.         goto out;
    
14.     }
    
15.     err = -EINVAL;
    
16.     if (addr_len < sizeof(struct sockaddr_in))
    
17.         goto out;
    
18. 
    
19.     if (addr->sin_family != AF_INET) {
    
20.         /* Compatibility games : accept AF_UNSPEC (mapped to AF_INET)
    
21.          * only if s_addr is INADDR_ANY.
    
22.          */
    
23.         err = -EAFNOSUPPORT;
    
24.         if (addr->sin_family != AF_UNSPEC ||
    
25.          addr->sin_addr.s_addr != htonl(INADDR_ANY))
    
26.             goto out;
    
27.     }
    
28. 
    
29.     chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);
    
30. 
    
31.     /* Not specified by any standard per-se, however it breaks too
    
32.      * many applications when removed. It is unfortunate since
    
33.      * allowing applications to make a non-local bind solves
    
34.      * several problems with systems using dynamic addressing.
    
35.      * (ie. your servers still start up even if your ISDN link
    
36.      * is temporarily down)
    
37.      */
    
38.     err = -EADDRNOTAVAIL;
    
39.     if (!sysctl_ip_nonlocal_bind &&
    
40.      !(inet->freebind || inet->transparent) &&
    
41.      addr->sin_addr.s_addr != htonl(INADDR_ANY) &&
    
42.      chk_addr_ret != RTN_LOCAL &&
    
43.      chk_addr_ret != RTN_MULTICAST &&
    
44.      chk_addr_ret != RTN_BROADCAST)
    
45.         goto out;
    
46. 
    
47.     snum = ntohs(addr->sin_port);
    
48.     err = -EACCES;
    
49.     if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
    
50.         goto out;
    
51. 
    
52.     /* We keep a pair of addresses. rcv_saddr is the one
    
53.      * used by hash lookups, and saddr is used for transmit.
    
54.      *
    
55.      * In the BSD API these are the same except where it
    
56.      * would be illegal to use them (multicast/broadcast) in
    
57.      * which case the sending device address is used.
    
58.      */
    
59.     lock_sock(sk);
    
60. 
    
61.     /* Check these errors (active socket, double bind). */
    
62.     err = -EINVAL;
    
63.     /*这里会校验要bind的sock是不是在TCP_CLOSE状态（未使用），以及当前
64.       sock是否已经bind相应的端口。
65.       当该sock第一次bind的时候，inet->inet_num肯定是0，当bind一次后，
66.       这个inet_num就变为了非零，从而一个socket最多bind一个端口，如果
    
67.       尝试bind多个端口将会返回错误22（EINVAL)
    
68.       下面我们看一下，inet_num是在什么时候被复制的？
    
69.     */
70.     if (sk->sk_state != TCP_CLOSE || inet->inet_num)
    
71.         goto out_release_sock;
    
72. 
    
73.     inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;
    
74.     if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
    
75.         inet->inet_saddr = 0; /* Use device */
    
76. 
    
77.     /* Make sure we are allowed to bind here. */
    
78.     /* 这个函数会根据传入的参数，选择一个可用的端口进行bind,
79.        sk->sk_prot就是网络控制块sock的操作函数，struct proto
    
80.        实现了传输层到网络层的转换。
    
81.        tcp sock的get_port函数是inet_csk_get_port函数
    
82.        tcp_prot(struct proto)在net/ipv4/tcp_ipv4.c中定义
    
83.     */
    
84.     if (sk->sk_prot->get_port(sk, snum)) {
    
85.         inet->inet_saddr = inet->inet_rcv_saddr = 0;
    
86.         err = -EADDRINUSE;
    
87.         goto out_release_sock;
    
88.     }
    
89. 
    
90.     if (inet->inet_rcv_saddr)
    
91.         sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
    
92.     if (snum)
    
93.         sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
    
94.     inet->inet_sport = htons(inet->inet_num);
    
95.     inet->inet_daddr = 0;
    
96.     inet->inet_dport = 0;
    
97.     sk_dst_reset(sk);
    
98.     err = 0;
    
99. out_release_sock:
    
100.     release_sock(sk);
     
101. out:
     
102.     return err;
     
103. }

inet_csk_get_port的实现在net/ipv4/inet_connection_sock.c中

点击(此处)折叠或打开

1. /* Obtain a reference to a local port for the given sock,
   
2.  * if snum is zero it means select any available local port.
   
3.  */
   
4. int inet_csk_get_port(struct sock *sk, unsigned short snum)
   
5. {
   
6.     struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
   
7.     struct inet_bind_hashbucket *head;
   
8.     struct hlist_node *node;
   
9.     struct inet_bind_bucket *tb;
   
10.     int ret, attempts = 5;
    
11.     struct net *net = sock_net(sk);
    
12.     int smallest_size = -1, smallest_rover;
    
13. 
    
14.     local_bh_disable();
    
15.     /*从这里可用看的，如果传入的端口为0，那么内核会自动选择一个可用的端口*/
    
16.     if (!snum) {
    
17.         int remaining, rover, low, high;
    
18. 
    
19. again:
    
20.         inet_get_local_port_range(&low, &high);
    
21.         remaining = (high - low) + 1;
    
22.         smallest_rover = rover = net_random() % remaining + low;
    
23. 
    
24.         smallest_size = -1;
    
25.         do {
    
26.             if (inet_is_reserved_local_port(rover))
    
27.                 goto next_nolock;
    
28.             head = &hashinfo->bhash[inet_bhashfn(net, rover,
    
29.                     hashinfo->bhash_size)];
    
30.             spin_lock(&head->lock);
    
31.             inet_bind_bucket_for_each(tb, node, &head->chain)
    
32.                 if (net_eq(ib_net(tb), net) && tb->port == rover) {
    
33.                     if (tb->fastreuse > 0 &&
    
34.                      sk->sk_reuse &&
    
35.                      sk->sk_state != TCP_LISTEN &&
    
36.                      (tb->num_owners < smallest_size || smallest_size == -1)) {
    
37.                         smallest_size = tb->num_owners;
    
38.                         smallest_rover = rover;
    
39.                         if (atomic_read(&hashinfo->bsockets) > (high - low) + 1) {
    
40.                             spin_unlock(&head->lock);
    
41.                             snum = smallest_rover;
    
42.                             goto have_snum;
    
43.                         }
    
44.                     }
    
45.                     goto next;
    
46.                 }
    
47.             break;
    
48.         next:
    
49.             spin_unlock(&head->lock);
    
50.         next_nolock:
    
51.             if (++rover > high)
    
52.                 rover = low;
    
53.         } while (--remaining > 0);
    
54. 
    
55.         /* Exhausted local port range during search? It is not
    
56.          * possible for us to be holding one of the bind hash
    
57.          * locks if this test triggers, because if 'remaining'
    
58.          * drops to zero, we broke out of the do/while loop at
    
59.          * the top level, not from the 'break;' statement.
    
60.          */
    
61.         ret = 1;
    
62.         if (remaining <= 0) {
    
63.             if (smallest_size != -1) {
    
64.                 snum = smallest_rover;
    
65.                 goto have_snum;
    
66.             }
    
67.             goto fail;
    
68.         }
    
69.         /* OK, here is the one we will use. HEAD is
    
70.          * non-NULL and we hold it's mutex.
    
71.          */
    
72.         snum = rover;
    
73.     } else {
    
74. have_snum:
    
75.         head = &hashinfo->bhash[inet_bhashfn(net, snum,
    
76.                 hashinfo->bhash_size)];
    
77.         spin_lock(&head->lock);
    
78.         inet_bind_bucket_for_each(tb, node, &head->chain)
    
79.             if (net_eq(ib_net(tb), net) && tb->port == snum)
    
80.                 goto tb_found;
    
81.     }
    
82.     tb = NULL;
    
83.     goto tb_not_found;
    
84. tb_found:
    
85.     if (!hlist_empty(&tb->owners)) {
    
86.         if (tb->fastreuse > 0 &&
    
87.          sk->sk_reuse && sk->sk_state != TCP_LISTEN &&
    
88.          smallest_size == -1) {
    
89.             goto success;
    
90.         } else {
    
91.             ret = 1;
    
92.             if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb)) {
    
93.                 if (sk->sk_reuse && sk->sk_state != TCP_LISTEN &&
    
94.                  smallest_size != -1 && --attempts >= 0) {
    
95.                     spin_unlock(&head->lock);
    
96.                     goto again;
    
97.                 }
    
98.                 goto fail_unlock;
    
99.             }
    
100.         }
     
101.     }
     
102. tb_not_found:
     
103.     ret = 1;
     
104.     if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
     
105.                     net, head, snum)) == NULL)
     
106.         goto fail_unlock;
     
107.     if (hlist_empty(&tb->owners)) {
     
108.         if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
     
109.             tb->fastreuse = 1;
     
110.         else
     
111.             tb->fastreuse = 0;
     
112.     } else if (tb->fastreuse &&
     
113.          (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
     
114.         tb->fastreuse = 0;
     
115. success:
     
116.     if (!inet_csk(sk)->icsk_bind_hash)
     
117.         /*到这里说明端口是可用的了,需要将该sk挂接到该端口的owners链表中
118.           我们看一下这个函数的实现。
     
119.         */
     
120.         inet_bind_hash(sk, tb, snum);
     
121.     WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);
     
122.     ret = 0;
     
123. 
     
124. fail_unlock:
     
125.     spin_unlock(&head->lock);
     
126. fail:
     
127.     local_bh_enable();
     
128.     return ret;
     
129. }

inet_bind_hash函数在net/ipv4/inet_hashtables.c中实现

点击(此处)折叠或打开

1. void inet_bind_hash(struct sock *sk, struct inet_bind_bucket *tb,
   
2.          const unsigned short snum)
   
3. {
   
4.     struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
   
5. 
   
6.     atomic_inc(&hashinfo->bsockets);
   
7.     /*
8.         在这里将sock的inet_num置为选中的端口。
   
9.     */
   
10.     inet_sk(sk)->inet_num = snum;
    
11.     sk_add_bind_node(sk, &tb->owners);
    
12.     tb->num_owners++;
    
13.     inet_csk(sk)->icsk_bind_hash = tb;
    
14. }

综上的分析，可用看出同一个socket只可以bind最多一个端口，如果bind超过1个端口，会返回错误22（EINVAL）。