投稿
  1. 高性能架构探索首页
  2. C/C++

socket 问题: 连续bind/listen 同一个socket fd

admin • • C/C++ • 阅读 132

找一个进程可用端口号

如果我们想尝试哪个端口号可用，然后监听该端口，该如何处理？比如FTP协议里面有这样一个需求，PASV模式下，Server需要监听本地数据端口，通常是找一个随机端口号进行监听。而且每收到一个客户PASV命令后，就需要提供一个不同的数据端口，这也就是说，不能两个连接同时使用同一个数据端口。那么，我们如何确定一个可用的本地端口号呢？

我们知道，正常的监听本地端口流程是：socket(), bind(), listen()。如果从socket到listen，监听一个端口号，都调用成功，说明该端口号可用。因此，我们可以用这种方法创建一个可用的socket fd。

#include <unistd.h>
#include <errno.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <stdio.h>
#include <arpa/inet.h>
using namespace std;

typedef sockaddr SA;
int socket_create(const char* ip, const int port)
{
    if (ip == NULL || port < 0) {
        return -1;
    }

    /* create socket */
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket error");
        return -1;
    }

    /* set sock option SO_REUSEADDR for re-bind when calling socket failed */
    int op = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &op, sizeof(op));

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(static_cast<uint16_t>(port));
    local.sin_addr.s_addr = inet_addr(ip);

    if (bind(sock, reinterpret_cast<SA*>(&local), sizeof(local)) < 0) {
        perror("bind error");
        return -1;
    }

    if (listen(sock, 10) < 0) {
        perror("listen error");
        return -1;
    }

    return sock;
}

但如果失败了，怎么办？
我们不用关心是哪一步失败，而是直接跳过该端口，尝试监听下一个端口，直到成功为止。
注意：知名端口号范围0 ~ 1023；应用程序能用的动态端口号范围1024 ~ 65535。如果非专用应用程序，通常只能用动态端口号，而且在Linux下使用知名端口号，需要root权限。

/**
 * 打开数据连接，尝试在指定端口范围[start_port, end_port]中，找一个可用端口号并监听之
 */
int ftp_create_datasocket(const char *ip, int start_port, int end_port)
{
    int listenfd = -1;
    int i;
    if (start_port < 1024) start_port = 1024;
    if (end_port >= 65535) end_port = 65535;
    if (start_port > end_port) return -1;

    for (i = start_port; i <= end_port; ++i) {
        if ((listenfd = socket_create(ip, i)) != -1) /* success */
            break;
    }
    return listenfd;
}

端口已被同一进程占用

到这里，我们最开始的问题解决了。但由此让人不得不思考另外几个问题：如果本地端口已经被同一个进程占用，到底是哪一步会失败？或者说，我们有一个sockfd，如果连续多次bind、listen，到底是哪一步会失败？
下面用几组实验来验证。

首先，是对通过一个socket fd调用bind 2次，看是否报错，以及报错信息。

int test_bindTwoTimes(const char* ip, const int port)
{
    if (ip == NULL || port < 0) {
        return -1;
    }

    /* create socket */
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket error");
        return -1;
    }

    /* set sock option SO_REUSEADDR for re-bind when calling socket failed */
    int op = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &op, sizeof(op));

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(static_cast<uint16_t>(port));
    local.sin_addr.s_addr = inet_addr(ip);

    if (bind(sock, reinterpret_cast<SA*>(&local), sizeof(local)) < 0) { /* first time */
        perror("bind1 error");
        return -1;
    }

    if (bind(sock, reinterpret_cast<SA*>(&local), sizeof(local)) < 0) { /* second time */
        perror("bind2 error");
        return -1;
    }

    if (listen(sock, 10) < 0) {
        perror("bind error");
        return -1;
    }

    return sock;
}

接着，对同一个socket fd调用listen 2次，看是否报错及报错信息。

int test_listenTwoTimes(const char* ip, const int port)
{
    if (ip == NULL || port < 0) {
        return -1;
    }

    /* create socket */
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket error");
        return -1;
    }

    /* set sock option SO_REUSEADDR for re-bind when calling socket failed */
    int op = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &op, sizeof(op));

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(static_cast<uint16_t>(port));
    local.sin_addr.s_addr = inet_addr(ip);

    if (bind(sock, reinterpret_cast<SA*>(&local), sizeof(local)) < 0) {
        perror("bind error");
        return -1;
    }

    if (listen(sock, 10) < 0) {
        perror("listen1 error");
        return -1;
    }

    if (listen(sock, 10) < 0) {
        perror("listen2 error");
        return -1;
    }

    return sock;
}

测试用例：
分为参照组，实验组：连续bind 2次、连续listen 2次。
为每个实验组设置2个测试用例，是为了观察不同端口号是否有影响。

int main()
{
    printf("Test on different socket fd\n");
    {// 参照组
        printf("Test Case: background\n");
        const char* ip = "0.0.0.0";
        int port = 1025; /* 使用well-known端口号(0~1023)需要root权限*/
        int sockfd = socket_create(ip, port);
        if (sockfd >= 0) {
            printf("Success to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        else {
            printf("Fail to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }

        close(sockfd);
    }

    {// 连续bind 2次
        printf("Test Case1: bind two times on same sockfd\n");
        const char* ip = "0.0.0.0";
        int port = 1025;
        int sockfd = test_bindTwoTimes(ip, port);
        if (sockfd >= 0) {
            printf("Success to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        else {
            printf("Fail to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        close(sockfd);
    }

    {// 连续bind 2次
        printf("Test Case2: bind two times on same sockfd\n");
        const char* ip = "0.0.0.0";
        int port = 65536;
        int sockfd = test_bindTwoTimes(ip, port);
        if (sockfd >= 0) {
            printf("Success to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        else {
            printf("Fail to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        close(sockfd);
    }

    {// 连续listen 2次
        printf("Test Case1: listen two times on same sockfd\n");
        const char* ip = "0.0.0.0";
        int port = 1025;
        int sockfd = test_listenTwoTimes(ip, port);
        if (sockfd >= 0) {
            printf("Success to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        else {
            printf("Fail to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        close(sockfd);
    }

    {// 连续listen 2次
        printf("Test Case2: listen two times on same sockfd\n");
        const char* ip = "0.0.0.0";
        int port = 65536;
        int sockfd = test_listenTwoTimes(ip, port);
        if (sockfd >= 0) {
            printf("Success to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        else {
            printf("Fail to create sockfd %d on %s:%d\n", sockfd, ip, port);
        }
        close(sockfd);
    }
    return 0;
}

实验结果：

Test on different socket fd
Test Case: background
Success to create sockfd 3 on 0.0.0.0:1025
Test Case1: bind two times on same sockfd
bind2 error: Invalid argument
Fail to create sockfd -1 on 0.0.0.0:1025
Test Case2: bind two times on same sockfd
bind2 error: Invalid argument
Fail to create sockfd -1 on 0.0.0.0:65536
Test Case1: listen two times on same sockfd
Success to create sockfd 5 on 0.0.0.0:1025
Test Case2: listen two times on same sockfd
Success to create sockfd 5 on 0.0.0.0:65536

从实验结果，我们可以看到，连续bind同一个端口号，失败的是第二次bind；而listen不受此影响，两次都成功。

同一进程下，不同sockfd能多次监听同一地址+端口号吗？

前面提到的是，同一进程下，同一个sockfd只能监听一次同一地址+端口号。那如果是不同sockfd呢，能多次监听同一地址+端口号吗？比如一种常见情形，是多线程环境下，不同业务线程同时收到建立数据连接请求时，需要监听本地ip+端口。
我第一反应应该跟上面一样，都是不行。但实际情况是这样吗？还是利用前面的socket_create()根据指定IP+port，创建一个sockfd并监听port，做实验验证一下。

// 生成2个不同sockfd，都绑定到同一个ip地址 + 端口port
void bind_same_port_in_two_sockfd(const char* ip, int port)
{
    int ret;
    fprintf(stdout, "case1:\n");
    ret = socket_create(ip, port);
    if (ret < 0) {
        fprintf(stdout, "fail to create socket listen on %s:%d\n", ip, port);
    }
    else {
        fprintf(stdout, "success to create socket listen on %s:%d\n", ip, port);
    }

    fprintf(stdout, "case2:\n");
    ret = socket_create(ip, port);
    if (ret < 0) {
        fprintf(stdout, "fail to create socket listen on %s:%d\n", ip, port);
    }
    else {
        fprintf(stdout, "success to create socket listen on %s:%d\n", ip, port);
    }
}

/**
 * 同一个进程, 用2个fd bind同一个port， 观察会发生什么
 */
int main()
{
    const char* ip = "192.168.1.100"; // 根据自己主机ip地址设置，也可以偷懒设为通配ip地址"0.0.0.0"
    int port = 2000;
    bind_same_port_in_two_sockfd(ip, port);
    return 0;
}

运行结果：

case1:
success to create socket listen on 192.168.1.100:2000
case2:
success to create socket listen on 192.168.1.100:2000

可以发现，两次创建的sockfd，均能绑定到同一个ip地址+port，这与前面的直觉并不相同。这也就是说，如果创建了不同sockfd，我们不能依赖于bind/listen返回值，来判断同一个进程下，是否能监听同一ip+port，进而决定该port是否可用。

让内核分配随机端口号

显然，前面的做法：同一进程下，创建不同sockfd，绑定同一ip+port，是有问题的。比如收到对端连接请求，内核是将连接请求交给哪个sockfd呢？

如果想要分配不同的端口号，该怎么办？
可用为bind指定端口号0，作为通配，让内核决定使用哪个随机端口号，这样内核能保证每次分配不同的端口。

我们如何知道内核分配的哪个端口号，绑定到sockfd呢？可用调用getsockname()，根据sockfd来获取本地绑定的ip、port。

void bind_same_port_in_two_sockfd(const char* ip, int port)
{
    int sockfd;
    fprintf(stdout, "case1:\n");
    sockfd = socket_create(ip, port);
    if (sockfd < 0) {
        fprintf(stdout, "fail to create socket listen on %s:%d\n", ip, port);
    }
    else {
        char buf[INET_ADDRSTRLEN];
        sockaddr_in localAddr = getLocalAddr(sockfd);

        const char* str = inet_ntop(AF_INET, static_cast<void*>(&localAddr.sin_addr), buf, sizeof(buf));
        int localPort = static_cast<int>(ntohs(localAddr.sin_port));
        if (str == NULL) {
            perror("inet_ntop error");
        }
        fprintf(stdout, "success to create socket listen on %s:%d\n", buf, localPort);
    }

    fprintf(stdout, "case2:\n");
    sockfd = socket_create(ip, port);
    if (sockfd < 0) {
        fprintf(stdout, "fail to create socket listen on %s:%d\n", ip, port);
    }
    else {
        char buf[INET_ADDRSTRLEN];
        sockaddr_in localAddr = getLocalAddr(sockfd);

        const char* str = inet_ntop(AF_INET, static_cast<void*>(&localAddr.sin_addr), buf, sizeof(buf));
        int localPort = static_cast<int>(ntohs(localAddr.sin_port));
        if (str == NULL) {
            perror("inet_ntop error");
        }
        fprintf(stdout, "success to create socket listen on %s:%d\n", buf, localPort);
    }
}

/**
 * 同一个进程,
 * 1) 用2个sockfd, bind同一个port， 观察会发生什么
 * 2) 用2个sockfd, 让内核决定绑定哪个端口号, 观察会发生什么
 */
int main()
{
    const char* ip = "192.168.1.100";

    { // 第一组
        int port = 2000; // 由应用程序知道端口号
        bind_same_port_in_two_sockfd(ip, port);
    }

    { // 第二组
        int port = 0; // 通配端口, 让内核决定具体使用哪个端口号
        bind_same_port_in_two_sockfd(ip, port);
    }
    return 0;
}

// 获取本地sockfd绑定的ip、port地址信息
struct sockaddr_in getLocalAddr(int sockfd)
{
    struct sockaddr_in localaddr;
    memset(&localaddr, 0, sizeof(localaddr));
    socklen_t addrlen = static_cast<socklen_t>(sizeof(localaddr));
    // get local ip addr info bound to sockfd
    if (::getsockname(sockfd, reinterpret_cast<sockaddr*>(&localaddr), &addrlen) < 0)
    {
        perror("getsockname error");
    }
    return localaddr;
}

运行结果：

case1:
success to create socket listen on 192.168.1.100:2000
case2:
success to create socket listen on 192.168.1.100:2000
case1:
success to create socket listen on 192.168.1.100:2838
case2:
success to create socket listen on 192.168.1.100:2839

可以看到，在第二组实验结果中，内核为不同sockfd分配了不同port。

原文链接: https://www.cnblogs.com/fortunely/p/16367542.html

欢迎关注

微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍;

也有高质量的技术群，里面有嵌入式、搜广推等BAT大佬

    socket 问题: 连续bind/listen 同一个socket fd

原创文章受到原创版权保护。转载请注明出处：https://www.ccppcoding.com/archives/402537

非原创文章文中已经注明原地址，如有侵权，联系删除

关注公众号【高性能架构探索】，第一时间获取最新文章

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
adminadmin
0 0
上一篇 2023年4月21日 上午11:06
下一篇 2023年4月21日 上午11:06

相关推荐