1、bind()
当创建了一个 Socket 套接字后，对于服务器来说，接下来的工作，就是调用 bind(2)为服务器指明本地址、协议端口号，常常可以看到这样的代码：
strut sockaddr_in sin;sin.sin_family = AF_INET;
sin.sin_addr.s_addr = xxx;
sin.sin_port = xxx;
bind(sock, (struct sockaddr *)&sin, sizeof(sin));
从这个系统调用中，可以知道当进行 SYS_BIND 操作的时候，：
1、对于 AF_INET 协议簇来讲，其地址格式是 strut sockaddr_in，而对于 socket 来讲，strut sockaddr 结构表示的地址格式实现了更高层次 的抽像，因为每种协议长簇的地址不一定是相同的，所以，系统调用的第三个参数得指明该协议簇的地址格式的长度。
2、进行 bind(2)系统调用时，除了地址长度外，还得向内核提供：sock 描述符、协议簇名称、本地地址、端口这些参数；
2、sys_bind()
操作 SYS_BIND 是由 sys_bind()实现的：asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
{
struct socket *sock;
char address[MAX_SOCK_ADDR];
int err;
if((sock = sockfd_lookup(fd,&err))!=NULL)
{
if((err=move_addr_to_kernel(umyaddr,addrlen,address))>=0) {
err = security_socket_bind(sock, (struct sockaddr *)address, addrlen);
if (err) {
sockfd_put(sock);
return err;
}
err = sock->ops->bind(sock, (struct sockaddr *)address, addrlen);
}
sockfd_put(sock);
}
return err;
}
在 socket 的创建中，已经反复分析了 socket 与文件系统的关系，现在已知 socket的描述符号，要找出与之相关的 socket 结构，应该是件容易的事情：
struct socket *sockfd_lookup(int fd, int *err)
{
struct file *file;
struct inode *inode;
struct socket *sock;
if (!(file = fget(fd)))
{
*err = -EBADF;
return NULL;
}
inode = file->f_dentry->d_inode;
if (!S_ISSOCK(inode->i_mode)) {
*err = -ENOTSOCK;
fput(file);
return NULL;
}
sock = SOCKET_I(inode);
if (sock->file != file) {
printk(KERN_ERR "socki_lookup: socket file changed!\n");
sock->file = file;
}
return sock;
}
fget 从当前进程的 files 指针中，根据 sock 对应的描述符号，找到已打开的文件 file，再根据文件的目录项中的 inode，利用inode 与 sock 被封装在同一个结构中的事实，调用宏 SOCKET_I找到待查的 sock 结构。最后做一个小小的判断，因为正常情况下，sock 的 file 指针是 回指与之相关的 file。
接下来的工作是把用户态的地址拷贝至内核中来：
int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr)
{
if(ulen<0||ulen>MAX_SOCK_ADDR)
return -EINVAL;
if(ulen==0)
return 0;
if(copy_from_user(kaddr,uaddr,ulen))
return -EFAULT;
return 0;
}
bind(2)第三个参数必须存在的原因之一，copy_from_user 必须知道拷贝的字节长度。
因为 sock 的 ops 函数指针集，在创建之初，就指向了对应的协议类型，例如如果类型是SOCK_STREAM，那么它就指向 inetsw_array[0].ops。也就是 inet_stream_ops：
struct proto_ops inet_stream_ops = {
.family = PF_INET,
…… .bind = inet_bind,
……
};
sys_bind()在做完了一个通用的 socket bind 应该做的事情，包括查找对应 sock 结构，拷贝地址。就
调用对应协议族的对应协议类型的 bind 函数，也就是 inet_bind。
3、inet_bind
说 bind()的最重要的作用，就是为套接字绑定地址和端口，那么要分析 inet_bind()之前，要搞清楚的一件事情就是，这个绑定，是绑定到哪儿？或者说，是绑定到内核的哪个数据结构的哪个成员变量上面？？
有三个地方是可以考虑的：socket 结构，包括 sock 和 sk，inet结构，以及 protoname_sock 结构。绑定在 socket 结构上是可行 的，这样可以实现最高层面上的抽像，但是因为每一类协议簇 socket 的地址及端口表现形式差异很大，这样就得引入专门的转换处理功能。绑定在 protoname_sock 也是可行的，但是却是最笨拙的，因为例如 tcp 和 udp，它们的地址及端口表现形式是一样的，这样就浪费了空间，加大了代码 处理量。所以，inet 做为一个协议类型的抽像，是最理想的地方了，再来回顾一下它的定义：
struct inet_sock {
……
/* Socket demultiplex comparisons on incoming packets. */
__u32 daddr; /* Foreign IPv4 addr */
__u32 rcv_saddr; /* Bound local IPv4 addr */
__u16 dport; /* Destination port */
__u16 num; /* Local port */
__u32 saddr; /* Sending source */
……
};
去掉了其它成员，保留了与地址及端口相关的成员变量，从注释中，可以清楚地了解它们的作用。所以，我们说的 bind(2)之绑定，主要就是对这几个成员变量赋值的过程了。
int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
{
/* 获取地址参数 */
struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
/* 获取 sock 对应的 sk */
struct sock *sk = sock->sk;
/* 获取 sk 对应的inet */
struct inet_sock *inet = inet_sk(sk);
/* 这个临时变量用来保存用户态传递下来的端口参数 */
unsigned short snum;
int chk_addr_ret;
int err;
/* 如果协议簇对应的协议自身还有 bind 函数，调用之，例如 SOCK_RAW 就还有一个raw_bind */
if (sk->sk_prot->bind) {
err = sk->sk_prot->bind(sk, uaddr, addr_len);
goto out;
}
/* 校验地址长度 */
err = -EINVAL;
if (addr_len < sizeof(struct sockaddr_in))
goto out;
/* 判断地址类型：广播？多播？单播？ */
chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr);
/* ipv4 有一个 ip_nonlocal_bind标志，表示是否绑定非本地址 IP地址，可以通过
* cat /proc/sys/net/ipv4/ip_nonlocal_bind 查看到。它用来解决某些服务绑定
* 动态 IP地址的情况。作者在注释中已有详细说明：
* Not specified by any standard per-se, however it breaks too
* many applications when removed. It is unfortunate since
* allowing applications to make a non-local bind solves
* several problems with systems using dynamic addressing.
* (ie. your servers still start up even if your ISDN link
* is temporarily down)
* 这里判断，用来确认如果没有开启“绑定非本地址 IP”，地址值及类型是正确的
*/
err = -EADDRNOTAVAIL;
if (!sysctl_ip_nonlocal_bind &&
!inet->freebind &&
addr->sin_addr.s_addr != INADDR_ANY &&
chk_addr_ret != RTN_LOCAL &&
chk_addr_ret != RTN_MULTICAST &&
chk_addr_ret != RTN_BROADCAST)
goto out;
/* 获取协议端口号 */
snum = ntohs(addr->sin_port);
err = -EACCES;
/* 校验当前进程有没有使用低于 1024 端口的能力 */
if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
goto out;
/* We keep a pair of addresses. rcv_saddr is the one
* used by hash lookups, and saddr is used for transmit. *
* In the BSD API these are the same except where it
* would be illegal to use them (multicast/broadcast) in
* which case the sending device address is used.
*/
lock_sock(sk);
/* 检查 socket 是否已经被绑定过了：用了两个检查项，一个是 sk 状态，另一个是是否已经绑定过端口了 当然地址本来就可以为 0，所以，不能做为检查项 */
err = -EINVAL;
if (sk->sk_state != TCP_CLOSE || inet->num)
goto out_release_sock;
/* 绑定 inet 的接收地址(地址服务绑定地址)和来源地址为用户态指定地址 */
inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;
/* 若地址类型为广播或多播，则将地址置 0，表示直接使用网络设备 */
if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
inet->saddr = 0; /* Use device */
/*
* 调用协议的 get_port 函数，确认是否可绑定端口，若可以，则绑定在 inet->num 之上，注意，这里虽然没有
* 把inet 传过去，但是第一个参数 sk，它本身和 inet是可以互相转化的
*/
if (sk->sk_prot->get_port(sk, snum)) {
inet->saddr = inet->rcv_saddr = 0;
err = -EADDRINUSE;
goto out_release_sock;
}
/* 如果端口和地址可以绑定，置标志位 */
if (inet->rcv_saddr)
sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
if (snum)
sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
/* inet的 sport(来源端口)成员也置为绑定端口 */
inet->sport = htons(inet->num);
inet->daddr = 0;
inet->dport = 0;
sk_dst_reset(sk);
err = 0;
out_release_sock:
release_sock(sk); out:
return err;
}
上述分析中，忽略的第一个细节是 capable()函数调用，它是 Linux 安全模块(LSM)的一部份，简单地讲其用来对权限做出检查， 检查是否有权对指定的资源进行操作。这里它的参数是 CAP_NET_BIND_SERVICE，表示的含义是：
/* Allows binding to TCP/UDP sockets below 1024 */
/* Allows binding to ATM VCIs below 32 */
#define CAP_NET_BIND_SERVICE 10
另一个就是协议的端口绑定，调用了协议的 get_port 函数，如果是 SOCK_STREAM的 TCP 协议，那么它就是 tcp_v4_get_port()函数。
4、协议端口的绑定
要分配这个函数，还是得先绕一些基本的东东。这里涉及到内核中提供 hash 链表的操作的 API。可以参考其它相关资料。
http://www.ibm.com/developerworks/cn/linux/kernel/l-chain/index.html
这里讲了链表的实现，顺道提了一个 hash 链表，觉得写得还不错，收藏一下。
对于 TCP已注册的端口，是采用一个 hash 表来维护的。hash 桶用 struct tcp_bind_hashbucket 结构来表示：
struct tcp_bind_hashbucket {
spinlock_t lock;
struct hlist_head chain;
};
hash 表中的每一个 hash节点，用 struct tcp_bind_hashbucket 结构来表示：
struct tcp_bind_bucket {
unsigned short port; /* 节点中绑定的端口 */
signed short fastreuse;
struct hlist_node node;
struct hlist_head owners;
};
tcp_hashinfo 的 hash 表信息，都集中封装在结构 tcp_hashinfo 当中，而维护已注册端口，只是它其中一部份：
extern struct tcp_hashinfo {
……
/* Ok, let's try this, I give up, we do need a local binding
* TCP hash as well as the others for fast bind/connect. */
struct tcp_bind_hashbucket *__tcp_bhash;
int __tcp_bhash_size;
……
} tcp_hashinfo;
#define tcp_bhash (tcp_hashinfo.__tcp_bhash)
#define tcp_bhash_size (tcp_hashinfo.__tcp_bhash_size)
其使用的 hash 函数是 tcp_bhashfn：
/* These are AF independent. */
static __inline__ int tcp_bhashfn(__u16 lport)
{
return (lport & (tcp_bhash_size - 1));
}
这样，如果要取得某个端口对应的 hash 链的首部hash 桶节点的话，可以使用：
struct tcp_bind_hashbucket *head;
head = &tcp_bhash[tcp_bhashfn(snum)];
如果要新绑定一个端口，就是先创建一个 struct tcp_bind_hashbucket 结构的 hash 节点，然后把它插入到对应的 hash 链中去：
struct tcp_bind_bucket *tb;
tb = tcp_bucket_create(head, snum);struct tcp_bind_bucket *tcp_bucket_create(struct tcp_bind_hashbucket *head,
unsigned short snum)
{
struct tcp_bind_bucket *tb = kmem_cache_alloc(tcp_bucket_cachep,
SLAB_ATOMIC);
if (tb) {
tb->port = snum;
tb->fastreuse = 0;
INIT_HLIST_HEAD(&tb->owners);
hlist_add_head(&tb->node, &head->chain);
}
return tb;
}
另外，sk 中，还级护了一个类似的 hash 链表，同时需要调用 tcp_bind_hash()函数把 hash 节点插入进去：
struct sock {
struct sock_common __sk_common;#define sk_bind_node __sk_common.skc_bind_node
……
}
/* @skc_bind_node: bind hash linkage for various protocol lookup tables */
struct sock_common {
struct hlist_node skc_bind_node;
……
}
if (!tcp_sk(sk)->bind_hash)
tcp_bind_hash(sk, tb, snum);
void tcp_bind_hash(struct sock *sk, struct tcp_bind_bucket *tb,
unsigned short snum)
{
inet_sk(sk)->num = snum;
sk_add_bind_node(sk, &tb->owners);
tcp_sk(sk)->bind_hash = tb;
}
这里，就顺道绑定了 inet 的 num成员变量，并置协议的 bind_hash 指针为当前分配的 hash 节点。而sk_add_bind_node 函数， 就是一个插入 hash 表节点的过程：
static __inline__ void sk_add_bind_node(struct sock *sk,
struct hlist_head *list)
{
hlist_add_head(&sk->sk_bind_node, list);
}
如果要遍历 hash 表的话，例如在插入之前，先判断端口是否已经在 hash表当中了。就可以调用：
#define tb_for_each(tb, node, head) hlist_for_each_entry(tb, node, head, node)
struct tcp_bind_hashbucket *head;
struct tcp_bind_bucket *tb;
head = &tcp_bhash[tcp_bhashfn(snum)];
spin_lock(&head->lock);
tb_for_each(tb, node, &head->chain)
if (tb->port == snum) found,do_something;
有了这些基础知识，再来看 tcp_v4_get_port()的实现，就要容易得多了：
static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
{
struct tcp_bind_hashbucket *head;
struct hlist_node *node;
struct tcp_bind_bucket *tb;
int ret;
local_bh_disable();
/* 如果端口值为 0，意味着让系统从本地可用端口用选择一个，并置 snum为分配的值 */
if (!snum) {
int low = sysctl_local_port_range[0];
int high = sysctl_local_port_range[1];
int remaining = (high - low) + 1;
int rover;
spin_lock(&tcp_portalloc_lock);
if (tcp_port_rover < low)
rover = low;
else
rover = tcp_port_rover;
do {
rover++;
if (rover > high)
rover = low;
head = &tcp_bhash[tcp_bhashfn(rover)];
spin_lock(&head->lock);
tb_for_each(tb, node, &head->chain)
if (tb->port == rover)
goto next;
break;
next:
spin_unlock(&head->lock);
} while (--remaining > 0);
tcp_port_rover = rover;
spin_unlock(&tcp_portalloc_lock);
/* Exhausted local port range during search? */
ret = 1;
if (remaining <= 0)
goto fail;
/* OK, here is the one we will use. HEAD is
* non-NULL and we hold it's mutex.
*/
snum = rover;
} else {
/* 否则，就在 hash 表中，查找端口是否已经存在 */
head = &tcp_bhash[tcp_bhashfn(snum)];
spin_lock(&head->lock);
tb_for_each(tb, node, &head->chain)
if (tb->port == snum)
goto tb_found;
}
tb = NULL;
goto tb_not_found;
tb_found:
/* 稍后有对应的代码：第一次分配 tb 后，会调用 tcp_bind_hash加入至相应的 sk，这里先做一个判断，来确定这一步工作是否进行过*/
if (!hlist_empty(&tb->owners)) {
/* socket的 SO_REUSEADDR 选项，用来确定是否允许本地地址重用，例如同时启动多个服务器、多个套接字绑定至同一端口等等， sk_reuse 成员对应其值，因为如果一个绑定的 hash节点已经存在，而且不允许重用的话，那么则表示因冲突导致出错，调用 tcp_bind_conflict 来处理之 */
if (sk->sk_reuse > 1)
goto success;
if (tb->fastreuse > 0 &&
sk->sk_reuse && sk->sk_state != TCP_LISTEN) {
goto success;
} else {
ret = 1;
if (tcp_bind_conflict(sk, tb))
goto fail_unlock;
}
}
tb_not_found:
/* 如果不存在，则分配 hash节点，绑定端口 */
ret = 1;
if (!tb && (tb = tcp_bucket_create(head, snum)) == NULL)
goto fail_unlock;
if (hlist_empty(&tb->owners)) {
if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
tb->fastreuse = 1;
else
tb->fastreuse = 0;
} else if (tb->fastreuse && (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
tb->fastreuse = 0;
success:
if (!tcp_sk(sk)->bind_hash)
tcp_bind_hash(sk, tb, snum);
BUG_TRAP(tcp_sk(sk)->bind_hash == tb);
ret = 0;
fail_unlock:
spin_unlock(&head->lock);
fail:
local_bh_enable();
return ret;
}
到这里，可以为这部份下一个小结了，所谓绑定，就是：
1、设置内核中 inet 相关变量成员的值，以待后用；
2、协议中，如 TCP协议，记录绑定的协议端口的信息，采用 hash 链表存储，sk 中也同时维护了这么一个链表。两者的区别应该是 前者给协议用。后者给 socket 用。