Socket层实现系列 — bind()的实现（二）

最新推荐文章于 2023-08-08 15:41:29 发布
最新推荐文章于 2023-08-08 15:41:29 发布
阅读量6.8k 收藏 5
点赞数 5
分类专栏： Socket Socket源码分析 文章标签： socket TCPIP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangskd/article/details/14170013
版权

本文主要内容：bind()的TCP层实现、端口的冲突处理，以及不同内核版本的实现差异。

内核版本：3.6

Author：zhangskd @ csdn blog

 

TCP层实现


SOCK_STREAM套接口的TCP层操作函数集实例为tcp_prot，其中端口绑定函数为inet_csk_get_port()。

struct proto tcp_prot = {
    .name = "TCP",
    .owner = THIS_MODULE,
    ...
    .get_port = inet_csk_get_port, /* TCP层bind()相关操作 */
    ...
};

 

和较早的内核版本不同，现在系统自动选择端口时，也可以复用端口了。

/* Obtain a reference to a local port for the given sock,
 * if snum is zero it means select any available local port.
 */

int inet_csk_get_port(struct sock *sk, unsigned short snum)
{
    struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo; /* 指向tcp_hashinfo */
    struct inet_bind_hashbucket *head;
    struct hlist_node *node;
    struct inet_bind_bucket *tb;
    int ret, attempts = 5;
    struct net *net = sock_net(sk);
    int smallest_size = -1, smallest_rover;
 
    local_bh_disable(); /* 禁止下半部，防止和进程冲突 */
 
    /* 如果snum为0，系统自动为sock选择一个端口号 */
    if (! snum) { 
        int remaining, rover, low, high;
        
again:
        inet_get_local_port_range(&low, &high); /* 获取端口号的取值范围 */
        remaining = (high - low) + 1; /* 取值范围内端口号的个数 */
        smallest_rover = rover = net_random() % remaining + low; /* 随机选取范围内的一个端口 */
    
        smallest_size = -1;

        do {
            if (inet_is_reserved_local_port(rover)) /* 查看端口是否属于保留的 */
                goto next_nolock; /* rover加1，继续 */

            /* 根据端口号，确定所在的哈希桶 */
            head = &hashinfo->bhash[inet_bhashfn(net, rover, hashinfo->bhash_size)]; 
            spin_lock( &head->lock); /* 锁住哈希桶 */

            inet_bind_bucket_for_each(tb, node, &head->chain) /* 从头遍历哈希桶 */
                /* 如果端口被使用了 */
                if (eq(ib_net(tb), net) && tb->port == rover) { 

                    if (tb->fastreuse > 0 && sk->sk_reuse && sk->sk_state != TCP_LISTEN &&
                        tb->num_owners < smallest_size || smallest_size == -1)) {
                        smallest_size = tb->num_owners; /* 记下这个端口使用者的个数 */
                        smallest_rover = rover; /* 记下这个端口 */

                        /* 如果系统绑定的端口已经很多了，那么就判断端口是否有绑定冲突*/
                        if (atomic_read(&hashinfo->bsockets) > (high - low) + 1 &&
                            ! inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
                            snum = smallest_rover; /* 没有冲突，使用此端口 */
                            goto tb_found;
                        }
                    }
 
                    /* 检查是否有端口绑定冲突，该端口是否能重用 */
                    if (! inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {
                        snum = rover;
                        goto tb_found;
                    }

                    goto next; /* 此端口不可重用，看下一个 */
                }

            break; /* 找到了没被用的端口，退出 */
next:            
            spin_unlock(&head->lock);
next_nolock:
            if (++rover > high)
                rover = low;
        } while(--remaining > 0);
 

        /* Exhausted local port range during search? It is not possible for us to be holding
         * one of the bind hash locks if this test triggers, because if 'remaining' drops to zero,
         * we broke out of the do/while loop at the top level, not from the 'break' statement.
         */
        ret = 1;
        if (remaining <= 0) { /* 完全遍历 */
            if (smallest_size != -1) {
                snum = smallest_rover;
                goto have_snum;
            }
            goto fail;
        }

        /* OK, here is the one we will use. 
         * HEAD is non-NULL and we hold it's mutex.
         */
        snum = rover; /* 自动选择的可用端口 */

    } else { /* 如果有指定要绑定的端口 */

have_snum:
        head = &hashinfo->bhash[inet_bhashfn(net, snum, hashinfo->bhash_size)];
        spin_lock(&head->lock);
        inet_bind_bucket_for_each(tb, node, &head->chain)
            if (net_eq(ib_net(tb), net) && tb->port == snum)
                goto tb_found; /* 发现端口在用 */
    }
    tb = NULL;
    goto tb_not_found;

tb_found:
    /* 端口上有绑定sock时 */
    if (! hlist_empty(&tb->owners)) {
        /* 这是强制的绑定啊，不管端口是否会绑定冲突！*/
        if (sk->sk_reuse == SK_FORCE_REUSE)
            goto success;

        if (tb->fastreuse > 0 && sk->sk_reuse && sk->sk_state != TCP_LISTEN &&
            smallest_size == -1) { /* 指定端口的情况 */
            goto success;

        } else {
            ret = 1;
            if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) { /* 端口绑定冲突 */
                /* 自动分配的端口绑定冲突了，再次尝试，最多重试5次。 
                 * 我觉得以下if不必要，因为自动选择时goto tb_found之前都有检测过了。
                 */
                if (sk->sk_reuse && sk->sk_state != TCP_LISTEN && smallest_size != -1
                    && --attempts >= 0) {
                    spin_unlock(&head->lock);
                    goto again;
                }
                goto fail_unlock; /* 失败 */
            }
        }
    }

tb_not_found:
    ret = 1;
    /* 申请和初始化一个inet_bind_bucket结构 */
    if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep, net, 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:
    /* 赋值icsk中的inet_bind_bucket */
    if (! inet_csk(sk)->icsk_bind_hash)
        inet_bind_hash(sk, tb, snum);
    WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);
    ret = 0;

fail_unlock:
    spin_unlock(&head->lock);

fail:
    local_bh_enable();
    return ret;
}

 

端口区间

 

我们可以指定系统自动分配端口号时，端口的区间：

/proc/sys/net/ipv4/ip_local_port_range，默认为：32768 61000

也可以指定要保留的端口区间：

/proc/sys/net/ipv4/ip_local_reserved_ports，默认为空

 

typedef struct {
    unsigned sequence;
    spinlock_t lock;
}seqlock_t;

struct local_ports {
    seqlock_t lock; /* 顺序锁，读多写少，写优先 */
    int range[2];
};

/* This struct holds the first and last local port number.
 * 用于系统自动分配的端口区间。
 */
struct local_ports sysctl_local_ports __read_mostly = {
    .lock = __SEQLOCK_UNLOCKED(sysctl_local_ports.lock),
    .range = {32768, 61000},
};

 

当snum为0时，由系统自动分配端口号时，获取端口号的取值范围。

void inet_get_local_port_range(int *low, int *high)
{
    unsigned int seq;

    do {
        seq = read_seqbegin(&sysctl_local_ports.lock);

        *low = sysctl_local_ports.range[0];
        *high = sysctl_local_ports.range[1];

    } while(read_seqretry(&sysctl_local_ports.lock, seq)); /* 用顺序锁来读 */
}

 

端口绑定冲突

 

面向连接的、传输层的协议族相关的操作函数集：

/*
 * Pointers to address related TCP functions
 * (i.e. things that depend on the address family)
 */
struct inet_connection_sock_af_ops {
    ...
    int (*bind_conflict) (const struct sock *sk, const struct inet_bind_bucket *tb, bool relax);
    ...
};
const struct inet_connection_sock_af_ops ipv4_specific = {
    ...
    .bind_conflict = inet_csk_bind_conflict, /* 用于判断绑定端口是否冲突 */
    ...
};

 

如果不冲突，则可以绑定该端口，返回0；如果冲突，则不可绑定该端口，返回1。

int inet_csk_bind_conflict(const struct sock *sk, const struct inet_bind_bucket *tb, bool relax)
{
    struct sock *sk2;
    struct hlist_node *node;
    int reuse = sk->sk_reuse; /* SO_REUSEADDR，表示处于TIME_WAIT状态的端口允许重用 */

    /* Unlike other sk lookup places we do not check for sk_net here, since all the socks
     * listed in tb->owners list belong to the same net - the one this bucket belongs to.
     * 遍历此端口上的sock。
     */
    sk_for_each_bound(sk2, node, &tb->owners) {
        /* 冲突的条件1：不是同一socket、绑定在相同的设备上 */
        if (sk != sk2 && ! inet_v6_ipv6only(sk2) && (! sk->sk_bound_dev_if || ! sk2->sk_bound_dev_if
            || sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {

            /* 冲突的条件2：绑定在相同的IP上
             * 冲突的条件3（符合一个即满足）：
             * 3.1 本socket不允许重用
             * 3.2 链表中的socket不允许重用
             * 3.3 链表中的socket处于监听状态
             */
            if (! reuse || ! sk2->sk_reuse || sk2->sk_state == TCP_LISTEN) {
                const __u32 sk2_rcv_saddr = sk_rcv_saddr(sk2); /* sk2的绑定IP */
                if (! sk2_rcv_saddr || ! sk_rcv_saddr(sk) || sk2_rcv_saddr == sk_rcv_saddr(sk))
                    break; /* 冲突了 */
             }

             /* 觉得这段代码有好多冗余，可以精简下：）
              * 3.4 relax为false
              */
             if (! relax && reuse && sk2->sk_reuse && sk2->sk_state != TCP_LISTEN) {
                 const __be32 sk2_rcv_saddr = sk_rcv_saddr(sk2);
                 if (! sk2_rcv_saddr || ! sk_rcv_saddr(sk) || sk2_rcv_saddr == sk_rcv_saddr(sk))
                     break;
             }
        }            
    }
    return node != NULL;
}

 

Q: 什么情况下会出现冲突呢？

A: 同时符合以下条件才会冲突：

1. 绑定的设备相同（不允许自动选择设备）

2. 绑定的IP地址相同（不允许自动选择IP）

3 以下条件有一个成立：

    3.1 要绑定的socket不允许重用

    3.2 已绑定的socket不允许重用

    3.3 已绑定的socket处于监听状态   

    3.4 relax参数为false

 

这样看来能够重用端口号的情况包括：

1. 绑定的设备不同

2. 绑定的IP地址不同

3. 要绑定的socket允许重用，且已绑定的socket允许重用，且已绑定的socket不处于监听状态，relex参数为true。

    在这种情况下，有可能两个socket的(addr, port)、绑定的设备完全一样，所以增加了relax参数，可用于禁止。

    我们看到系统自动选择端口时，relax为false，是不允许这种情况的。

 

inet_bind_bucket

 

inet_bind_bucket用来保存使用中的端口，以及绑定在该端口上的sock链表。

 

（1）创建

/*
 * Allocate and initialize a new local port bind bucket.
 * The bindhash mutex for snum's hash chain must be held here.
 */
struct inet_bind_bucket *inet_bind_bucket_create(struct kmem_cache *cachep, struct net *net,
                             struct inet_bind_hashbucket *head, const unsigned short snum)
{
    struct inet_bind_bucket *tb = kmem_cache_alloc(cachep, GFP_ATOMIC);

    if (tb != NULL) {
        write_pnet(&tb->ib_net, hold_net(net)); /* 指定网络命名空间 */
        tb->port = snum; /* 指定绑定端口 */
        tb->fastreuse = 0;
        tb->num_owners = 0;
        INIT_HLIST_HEAD(&tb->owners); /* 初始化owners哈希链表 */
        hlist_add_head(&tb->node, &head->chain); /* 把此inet_bind_bucket实例添加到哈希桶中 */
    }
    return tb;
}

 

（2）销毁

void inet_bind_bucket_destroy(struct kmem_cache *cachep, struct inet_bind_bucket *tb)
{
    if (hlist_empty(&tb->owners)) {
        __hlist_del(&tb->node);
        release_net(ib_net(tb));
        kmem_cache_free(cachep, tb);
    }
}

 

（3）赋值

更新赋值icsk的inet_bind_bucket类型成员icsk_bind_hash。

void inet_bind_hash(struct sock *sk, struct inet_bind_bucket *tb, const unsigned short snum)
{
    struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo; /* 指向tcp_hashinfo */
    atomic_inc(&hashinfo->bsockets); /* 增加总的绑定次数 */
    inet_sk(sk)->inet_num = snum; /* 保存绑定的端口 */
    sk_add_bind_node(sk, &tb->owners); /* 把此sock链入tb->owners哈希链表中 */
    tb->num_owners++; /* 增加端口绑定次数 */
    inet_csk(sk)->icsk_bind_hash = tb; /* 把此tb作为icsk成员icsk_bind_hash */
}

 

（4）查找

根据端口号，确定所在的哈希桶索引。

static inline int inet_bhashfn(struct net *net, const __16 lport, const int bhash_size)
{
    return (lport + net_hash_mix(net)) & (bhash_size - 1);
}

 

问题

 

笔者看的是3.6的版本，一开始对系统自动选择端口的逻辑感到不解。

 

2.6.18版本

 

2.6.18版本的系统自动选择端口：随机选取一个未使用端口，不允许端口复用。

由于snum为0时不进行端口复用，所以实现起来很简单。

 

3.2版本

 

查了下3.2版本，系统自动选择端口的思路是这样的：

1. 随机选取一个端口。

2. 检查其是否被使用了。 

    2.1 没有被使用，那么就是这个端口了，退出：）

    2.2 被使用了，就检查它是否能够重用。

           2.2.1 如果可以重用，则记下它的使用者个数small_size和端口号small_rover。

                     下次如果发现使用者更少的可重用端口，则更small_size和small_rover。

           2.2.2 检查此时已绑定的端口总数，是不是超过了自动绑定区间的端口数。

                     2.2.2.1 超过了，说明端口基本上都被使用了，不再继续寻找没被使用过的，直接重用此时的small_rover。

                                  退出：）

                     2.2.2.2 没超过，那就继续寻找没被使用过的端口。如果又发现可重用的端口时，顺便更新下small_size

                                  和small_rover。

3. 端口++，重复1和2。

 

简而言之，系统自动选择端口时：尽量选择没被使用过的端口。如果实在没有，就选择使用者个数最少的可重用端口。

 

3.6版本

 

在3.3版本中加入了commit 2b05ad33。

增加了几行代码：

if (! inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) {

    snum = rover;

    goto tb_found;

}

作者的描述如下：

tcp: bind() fix autoselection to share ports

The current code checks for conflicts when the application requests a specific port.

If there is no conflict, then the request is granted.

On the other hand, the port autoselection done by the kernel fails when all ports are bound

even when there is a port whith no conflict available.

The fix changes port autoselection to check if there is a conflict and use it if not.

 

作者的意思是，在系统自动选择端口时，判断可重用端口的主要条件为：

tb->fastreuse > 0 && sk->sk_reuse && sk->sk_state != TCP_LISTEN

而其实不符合此条件、但通过bind_conflict()检查的端口也是可以重用的，所以作者的出发点是正确的。

 

但是，简单的把上面那几行代码就这样加进去，系统自动选择端口的思路就变为：

1. 随机选取一个端口。

2. 检查其是否被使用了。

    2.1 没有被使用，那么就是这个端口了，退出：）

    2.2 被使用了，检查重用是否有冲突。

          2.2.1 没有冲突，就重用这个端口，退出！

          2.2.2 有冲突，继续遍历。

3. 端口++，重复1和2。

 

也就是说，系统自动选择端口时：不优先选择没被使用过的端口。只要没有冲突，直接重用端口。

这样一来，上面small_size和small_rover的代码就成了空摆设了，跟原意不一样了。我认为这个改动并不合适，

不知道当时是怎么通过的：）

 

 

zhangskd
关注
专栏目录
【并发编程七】C++进程通信——套接字（socket)_80行代码实现一个聊天软件
junxuezheng的博客
12-17 1561
c++,80行代码实现一个聊天软件。刚写完《【操作系统二】图解TCP/IP模型+实战》、和《【操作系统三】图解网络IO（bio\nio\slect\epoll）》，和网络通信相关的基本都介绍清楚了，所以原本这篇socket通信不想再写了，但是考虑到【并发编程】系列不完整，所以才写了下了这篇。所以本篇文章所以本篇文章侧重Windows系统下socket的代码实战（写了一个简单的聊天软件），如果对什么是socket还没有清晰的印象，建议先读上面的两篇文章，然后再看本篇。
网络编程（基于winsocket）-- 常用函数介绍（一）
老院长的博客
06-28 2684
本文主要记录网络编程中经常用到的函数，作为学习的笔记
Windows: client socket bind to n…
zxg519的专栏
01-15 592
Windows's not supporting binding address  -------------------------------------------------------------------- Windows doesn't support client socket's binding to certain network adapter.  http://
windows下Socket编程入门---bind()的使用
qq_42673507的博客
02-14 3177
bind() 用来绑定套接字 函数原型 int bind( _In_ SOCKET s, //需要绑定的套接字 _In_ const struct sockaddr *name,//要分配给绑定套接字的本地地址的sockaddr的指针 _In_ int namelen //参数指向值的长度 ); 绑定失败返回S...
winsocket入门学习
晚晴小筑
09-13 161
参考资料：http://c.biancheng.net/cpp/socket/ http://www.winsocketdotnetworkprogramming.com/ socket 是“套接字”意思，是计算机之间进行通信的一种约定。 通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。 学习 socket，也就是学习计算机之间如何通信，并...
DTU如何通过socket实现网络通信.pdf
11-03
- 绑定（Bind）Socket到指定的IP地址和端口号。 - 监听（Listen）连接请求。 - 接受（Accept）来自客户端的连接请求。 - 开始数据传输（Send/Receive）。 - 关闭Socket。 2. **客户端**： - 创建Socket。 - ...
利用rawsocket实现本机网络报文监控解析
11-06
3. **绑定Raw Socket**：使用`bind()`函数将Raw Socket与本地接口地址关联，这样可以监听特定接口的所有进出报文。 4. **接收数据**：调用`recvfrom()`或`recvmsg()`函数接收原始数据包，并对其进行解析。 5. **...
STM32F767驱动GM196模组，实现TCP网络通信【支持STM32F7系列单片机】.zip
06-02
在TCP连接建立后，可以使用套接字（socket）编程模型来实现数据交换。创建TCP套接字，通过bind绑定本地端口，listen监听连接请求，accept接受客户端连接，最后用send和recv函数发送和接收数据。在STM32上，这些操作...
STM32F429驱动GM510模组，实现UDP网络通信【支持STM32F4系列单片机】.zip
06-02
开发者需要熟悉lwIP的API，如socket()、bind()、connect()、sendto()、recvfrom()等，以构建UDP通信链路。 5. 硬件接口：STM32与GM510之间的通信通常通过UART接口进行，因此需要配置STM32的UART外设，包括波特率、...
WinSock网络编程学习笔记（八）：测试bind程序
Less Is More
03-01 2181
Winsock网络编程学习笔记。新手可以看看！欢迎交流！
socket套接字 通信原理
jamin_liu_90的博客
09-09 942
文章参考链接： https://www.cnblogs.com/wangcq/p/3520400.html https://www.cnblogs.com/lixiaoliuer/p/6543968.html 在学习网络编程之前还有许多的知识需要普及。socket就是很重要的一环。今天来看一看套接字。 1.服务器端与客户端 BS架构 （腾讯通软件：server+client） CS架构...
socket网络编程学习笔记(socket、bind)
最新发布
qq_45911139的博客
08-08 225
创建一个套接字。
inet_csk_get_port(...)
chenliang0224的专栏
07-01 1250
1. tcp协议内部绑定tcp_hashinfostruct proto tcp_prot = { .name = "TCP", .owner = THIS_MODULE, .close = tcp_close, .connect = tcp_v4_connect, .disconnect = tcp_disconnect, .accept = inet_csk_a...
linux操作系统：socket内核数据结构
OceanStar的博客
11-30 1102
解析socket函数 socket系统调用的定义如下： SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol) { int retval; struct socket *sock; int flags; ...... if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) flags = (flags & ~SOCK_NONBLOC
TCP之系统调用bind()
九天小哥的专栏
12-15 6099
这篇笔记记录了TCP协议对bind()系统调用的实现。 1. 概述 应用程序可以通过bind()系统调用将套接字和本地地址绑定，这里的地址包括L3的IP地址和L4的端口，应用程序可以只指定其中一个，另外一个由内核自动选择。 这里我们不关注IP地址的绑定过程，因为这没什么好看的，就是校验地址合法性，然后保存到内核相关数据结构中即可；这里重点看L4端口的绑定过程。 2. 端口信息的管理 一般来讲，一个...
TCP/IP驱动十一 ——内核2.6.26中inet_csk和inet_sk两个函数推导
hxchuan000的专栏
06-20 2051
原址： http://fpcfjf.blog.163.com/blog/static/55469793201372033430691/ 在内核的sys_bind（sys_bind()---inet_bind()---inet_csk_get_port()）过程中，在函数int inet_csk_get_port(struct sock *sk, unsigned short snum)
(十三) 深入浅出TCPIP之setsockopt参数详解
网易搬砖选手
11-29 1609
在socket编程中我们会经常用到setsockopt这个函数，那么本节我们将对这个函数的参数和使用做说明：首先看下函数原型：int setsockopt( int socket, in...
Linux下端口复用(SO_REUSEADDR与SO_REUSEPORT)
weixin_34294649的博客
09-03 637
freebsd与linux下bind系统调用小结： 只考虑AF_INET的情况（同一端口指ip地址与端口号都相同）freebsd支持SO_REUSEPORT和SO_REUSEADDR选项,而linux只支持SO_REUSEADDR选项。freebsd下,使用SO_REUSEPORT选项，两个tcp的socket可以绑定同一个端口；同样，使用SO_REUSEPORT选项，两个udp的so...
基于Socket实现客户端与服务端的简易通讯
常见的套接字API函数包括socket()、bind()、listen()、accept()、connect()、send()、recv()等。 3. TCP套接字编程模型：TCP套接字编程模型涉及客户端和服务端两个部分。服务端需要先创建套接字、绑定地址和端口、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值