SO_REUSEADDR

最新推荐文章于 2022-11-25 16:20:39 发布
最新推荐文章于 2022-11-25 16:20:39 发布
阅读量216 收藏
点赞数
分类专栏： 理论沉淀 文章标签： SO_REUSEADDR UDP 端口复用 套接字 网络编程
原文链接：https://tennysonsky.blog.csdn.net/article/details/44062173
版权

SO_REUSEADDR

一个网络应用程序只能绑定一个端口( 一个套接字只能绑定一个端口 )。

实际上，默认的情况下，如果一个网络应用程序的一个套接字 绑定了一个端口( 占用了 8000 )，这时候，别的套接字就无法使用这个端口( 8000 ), 验证例子如下：

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

int main(int argc, char* argv[])
{
    int sockfd_one;
    int err_log;
    sockfd_one = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字one
    if (sockfd_one < 0) {
        perror("sockfd_one");
        exit(-1);
    }

    // 设置本地网络信息
    struct sockaddr_in my_addr;
    bzero(&my_addr, sizeof(my_addr));
    my_addr.sin_family = AF_INET;
    my_addr.sin_port = htons(8000); // 端口为8000
    my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 绑定，端口为8000
    err_log = bind(sockfd_one, (struct sockaddr*)&my_addr, sizeof(my_addr));
    if (err_log != 0) {
        perror("bind sockfd_one");
        close(sockfd_one);
        exit(-1);
    }

    int sockfd_two;
    sockfd_two = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字two
    if (sockfd_two < 0) {
        perror("sockfd_two");
        exit(-1);
    }

    // 新套接字sockfd_two，继续绑定8000端口，绑定失败
    // 因为8000端口已被占用，默认情况下，端口没有释放，无法绑定
    err_log = bind(sockfd_two, (struct sockaddr*)&my_addr, sizeof(my_addr));
    if (err_log != 0) {
        perror("bind sockfd_two");
        close(sockfd_two);
        exit(-1);
    }

    close(sockfd_one);
    close(sockfd_two);

    return 0;
}

m@ubuntu:~/test$ gcc 1.c
m@ubuntu:~/test$ ./a.out 
bind sockfd_two: Address already in use

那如何让sockfd_one, sockfd_two两个套接字都能成功绑定8000端口呢？这时候就需要要到端口复用了。端口复用允许在一个应用程序可以把 n 个套接字绑在一个端口上而不出错。

设置socket的SO_REUSEADDR选项，即可实现端口复用：

int opt = 1;
// sockfd为需要端口复用的套接字
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt));

SO_REUSEADDR可以用在以下四种情况下。 (摘自《Unix网络编程》卷一，即UNPv1)

1、当有一个有相同本地地址和端口的socket1处于TIME_WAIT状态时，而你启动的程序的socket2要占用该地址和端口，你的程序就要用到该选项。

2、SO_REUSEADDR允许同一port上启动同一服务器的多个实例(多个进程)。但每个实例绑定的IP地址是不能相同的。在有多块网卡或用IP Alias技术的机器可以测试这种情况。

3、SO_REUSEADDR允许单个进程绑定相同的端口到多个socket上，但每个socket绑定的ip地址不同。这和2很相似，区别请看UNPv1。

4、SO_REUSEADDR允许完全相同的地址和端口的重复绑定。但这只用于UDP的多播，不用于TCP。

需要注意的是，设置端口复用函数要在绑定之前调用，而且只要绑定到同一个端口的所有套接字都得设置复用：

// sockfd_one, sockfd_two都要设置端口复用
// 在sockfd_one绑定bind之前，设置其端口复用
int opt = 1;
setsockopt( sockfd_one, SOL_SOCKET,SO_REUSEADDR, (const void *)&opt, sizeof(opt) );
err_log = bind(sockfd_one, (struct sockaddr*)&my_addr, sizeof(my_addr));
 
// 在sockfd_two绑定bind之前，设置其端口复用
opt = 1;
setsockopt( sockfd_two, SOL_SOCKET,SO_REUSEADDR,(const void *)&opt, sizeof(opt) );
err_log = bind(sockfd_two, (struct sockaddr*)&my_addr, sizeof(my_addr));

端口复用的完整代码如下

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

int main(int argc, char* argv[])
{
    int sockfd_one;
    int err_log;
    sockfd_one = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字one
    if (sockfd_one < 0) {
        perror("sockfd_one");
        exit(-1);
    }

    // 设置本地网络信息
    struct sockaddr_in my_addr;
    bzero(&my_addr, sizeof(my_addr));
    my_addr.sin_family = AF_INET;
    my_addr.sin_port = htons(8000); // 端口为8000
    my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 在sockfd_one绑定bind之前，设置其端口复用
    int opt = 1;
    setsockopt(sockfd_one, SOL_SOCKET, SO_REUSEADDR,
        (const void*)&opt, sizeof(opt));

    // 绑定，端口为8000
    err_log = bind(sockfd_one, (struct sockaddr*)&my_addr, sizeof(my_addr));
    if (err_log != 0) {
        perror("bind sockfd_one");
        close(sockfd_one);
        exit(-1);
    }

    int sockfd_two;
    sockfd_two = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字two
    if (sockfd_two < 0) {
        perror("sockfd_two");
        exit(-1);
    }

    // 在sockfd_two绑定bind之前，设置其端口复用
    opt = 1;
    setsockopt(sockfd_two, SOL_SOCKET, SO_REUSEADDR,
        (const void*)&opt, sizeof(opt));

    // 新套接字sockfd_two，继续绑定8000端口，成功
    err_log = bind(sockfd_two, (struct sockaddr*)&my_addr, sizeof(my_addr));
    if (err_log != 0) {
        perror("bind sockfd_two");
        close(sockfd_two);
        exit(-1);
    }

    close(sockfd_one);
    close(sockfd_two);

    return 0;
}

端口复用允许在一个应用程序可以把 n 个套接字绑在一个端口上而不出错。同时，这 n 个套接字发送信息都正常，没有问题。但是，这些套接字并不是所有都能读取信息，只有最后一个套接字会正常接收数据。其实相当于把接管了。

下面，我们在之前的代码上，添加两个线程，分别负责接收sockfd_one，sockfd_two的信息：

#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

// 线程1的回调函数
void* recv_one(void* arg)
{
    printf("===========recv_one==============\n");
    int sockfd = (int)arg;
    while (1) {
        int recv_len;
        char recv_buf[512] = "";
        struct sockaddr_in client_addr;
        char cli_ip[INET_ADDRSTRLEN] = ""; //INET_ADDRSTRLEN=16
        socklen_t cliaddr_len = sizeof(client_addr);

        recv_len = recvfrom(sockfd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&client_addr, &cliaddr_len);
        inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN);
        printf("\nip:%s ,port:%d\n", cli_ip, ntohs(client_addr.sin_port));
        printf("sockfd_one =========== data(%d):%s\n", recv_len, recv_buf);
    }

    return NULL;
}

// 线程2的回调函数
void* recv_two(void* arg)
{
    printf("+++++++++recv_two++++++++++++++\n");
    int sockfd = (int)arg;
    while (1) {
        int recv_len;
        char recv_buf[512] = "";
        struct sockaddr_in client_addr;
        char cli_ip[INET_ADDRSTRLEN] = ""; //INET_ADDRSTRLEN=16
        socklen_t cliaddr_len = sizeof(client_addr);

        recv_len = recvfrom(sockfd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&client_addr, &cliaddr_len);
        inet_ntop(AF_INET, &client_addr.sin_addr, cli_ip, INET_ADDRSTRLEN);
        printf("\nip:%s ,port:%d\n", cli_ip, ntohs(client_addr.sin_port));
        printf("sockfd_two @@@@@@@@@@@@@@@ data(%d):%s\n", recv_len, recv_buf);
    }

    return NULL;
}

int main(int argc, char* argv[])
{
    int err_log;

    int sockfd_one;
    sockfd_one = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字one
    if (sockfd_one < 0) {
        perror("sockfd_one");
        exit(-1);
    }

    // 设置本地网络信息
    struct sockaddr_in my_addr;
    bzero(&my_addr, sizeof(my_addr));
    my_addr.sin_family = AF_INET;
    my_addr.sin_port = htons(8000); // 端口为8000
    my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 在sockfd_one绑定bind之前，设置其端口复用
    int opt = 1;
    setsockopt(sockfd_one, SOL_SOCKET, SO_REUSEADDR,
        (const void*)&opt, sizeof(opt));

    // 绑定，端口为8000
    err_log = bind(sockfd_one, (struct sockaddr*)&my_addr, sizeof(my_addr));
    if (err_log != 0) {
        perror("bind sockfd_one");
        close(sockfd_one);
        exit(-1);
    }

    //接收信息线程1
    pthread_t tid_one;
    pthread_create(&tid_one, NULL, recv_one, (void*)sockfd_one);

    int sockfd_two;
    sockfd_two = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字two
    if (sockfd_two < 0) {
        perror("sockfd_two");
        exit(-1);
    }

    // 在sockfd_two绑定bind之前，设置其端口复用
    opt = 1;
    setsockopt(sockfd_two, SOL_SOCKET, SO_REUSEADDR,
        (const void*)&opt, sizeof(opt));

    // 新套接字sockfd_two，继续绑定8000端口，成功
    err_log = bind(sockfd_two, (struct sockaddr*)&my_addr, sizeof(my_addr));
    if (err_log != 0) {
        perror("bind sockfd_two");
        close(sockfd_two);
        exit(-1);
    }
    //接收信息线程2
    pthread_t tid_two;
    pthread_create(&tid_two, NULL, recv_two, (void*)sockfd_two);

    while (1) { // 让程序阻塞在这，不结束
        NULL;
    }

    close(sockfd_one);
    close(sockfd_two);

    return 0;
}

接着，通过客户端给这个服务器发送数据，结果显示，只有最后一个套接字sockfd_two会正常接收数据：

m@ubuntu:~/test$ gcc 1.c -lpthread                                              ^
m@ubuntu:~/test$ ./a.out 
===========recv_one==============
+++++++++recv_two++++++++++++++

ip:127.0.0.1 ,port:36348
sockfd_two @@@@@@@@@@@@@@@ data(4):222


ip:127.0.0.1 ,port:47277
sockfd_two @@@@@@@@@@@@@@@ data(11):3333333333

另一个终端编译并运行如下程序

/*
 * mx
 */
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
const int SERV_PORT=8000;
const int MAXLINE=2048;

void dg_cli(FILE* fp,int sockfd,const struct sockaddr* pservaddr,socklen_t servlen)
{
    int n;
    char sendline[MAXLINE],recvline[MAXLINE+1];
    while(fgets(sendline,MAXLINE,fp)!=NULL)
    {
        if(sendto(sockfd,sendline,strlen(sendline),0,pservaddr,servlen)<0)
        {
            perror("sendto error");
            exit(1);
        }
        if((n=recvfrom(sockfd,recvline,MAXLINE,0,NULL,NULL))<0)
        {
            perror("recvfrom error");
            exit(1);
        }
        recvline[n]='\0';
        fputs(recvline,stdout);
    }
}

int main(int argc,char** argv)
{
    int sockfd,t;
    struct sockaddr_in servaddr;
    if(argc!=2)
    {
        perror("usage: udpcli<IPaddress>");
        exit(1);
    }
    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family=AF_INET;
    servaddr.sin_port=htons(SERV_PORT);
    if((t=inet_pton(AF_INET,argv[1],&servaddr.sin_addr))<=0)
    {
        perror("inet_pton error");
        exit(1);
    }
    if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
    {
        perror("socket error");
        exit(1);
    }
    dg_cli(stdin,sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
    exit(0);
}

m@ubuntu:~/test$ gcc 2.c
m@ubuntu:~/test$ ./a.out 127.0.0.1
222
^C
m@ubuntu:~/test$ ./a.out 127.0.0.1
3333333333

我们上面的用法，实际上没有太大的意义。端口复用最常用的用途应该是防止服务器重启时之前绑定的端口还未释放或者程序突然退出而系统没有释放端口。这种情况下如果设定了端口复用，则新启动的服务器进程可以直接绑定端口。如果没有设定端口复用，绑定会失败，提示ADDR已经在使用中——那只好等等再重试了，麻烦！

infralan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
setsockopt 函数功能及参数详解
Jaylen.sun的嵌入式之旅
03-13 7585
setsockopt() 函数用于任意类型、任意状态套接口的设置选项值
SO_REUSEADDR配置 & TCP_NODELAY1
08-08
SO_REUSEADDR配置 & TCP_NODELAY SO_REUSEADDR配置和TCP_NODELAY是两种重要的网络协议配置选项，分别用于解决TCP连接中的端口重用和数据传输效率问题。 SO_REUSEADDR配置 在TCP连接中，主机A断开连接时，会发送...
setsockopt 的 SO_REUSEADDR标识使用说明
小饼仙子的专栏
03-24 905
1、当有一个有相同本地地址和端口的socket1处于TIME_WAIT状态时，而你启 动的程序的socket2要占用该地址和端口，你的程序就要用到该选项。  2、SO_REUSEADDR允许同一port上启动同一服务器的多个实例(多个进程)。但 每个实例绑定的IP地址是不能相同的。在有多块网卡或用IP Alias技术的机器可 以测试这种情况。  3、SO_REUSEADDR允许单个进程绑
setsockopt中参数SO_REUSEADDR的四个作功用
Kingbaiyulong的专栏
05-19 1382
一：SO_REUSEADDR是让端口释放后立即就可以被再次使用，即使以前建立的绑定该端口的连接仍然存在。 我们知道，tcp连接中主动执行关闭的那一端将处于TIME_WAIT状态，该端留在这个状态的持续时间叫做最长分节生命期(maximum segment lifetime,MSL)的两倍，一般MSL=30秒，即要等待一分钟之后该端口才能被重新使用。 所有TCP服务器都应该指定本套接字选项，以允
网络编程中的SO_REUSEADDR和SO_REUSEPORT参数详解
赶路人儿
06-19 4896
在BSD中，SO_REUSEADDR选项有两个用户：setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,(const void *)&reuse , sizeof(int));目的：当服务端出现timewait状态的链接时，确保server能够重启成功。注意：SO_REUSEADDR只有针对time-wait链接(linux系统time-wait连接持续时间为1min)，确保server重启成功的这一个作用。举个time_wait的连接通过so_reuseaddr选项
详谈套接字中SO_REUSEPORT和SO_REUSEADDR的区别
09-20
下面小编就为大家分享一篇详谈套接字中SO_REUSEPORT和SO_REUSEADDR的区别，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
关于在socket编程中设置套接字选项so_reuseaddr
11-07
"关于在socket编程中设置套接字选项so_reuseaddr" 在 Socket 编程中，设置套接字选项 so_reuseaddr 是设计稳定的网络通讯程序的基础。那么，为什么需要设置这个选项呢？我们可以从 czas_wait 的概念开始理解。 ...
linger-tools:用于测试 SO_LINGER 的工具
06-09
关于 linger-tools： 此处编写的工具是为执行 SO_LINGER 套接字选项的跨平台测试而编写的。 您可以在以下博客文章中找到我们的测试结果： 我们发布代码的主要动机是让其他人可以复制我们执行的测试或针对新平台进行...
通讯架构实战——5-03 TCP状态转换，TIME_WAIT，SO_REUSEADDR
Xiao2018428的博客
03-28 233
一：TCP状态转换 同一个IP（INADDR_ANY），同一个端口SERV_PORT，只能被成功的bind()一次，若再次bind()就会失败，并且显示：Address already in use 就好像一个班级里不能有两个人叫张三； 结论：相同IP地址的相同端口，只能被bind一次；第二次bind会失败； 介绍命令netstat：显示网络相关信息 ...
C++ SOCKET端口复用
08-27
复用端口的原理是用在服务器安装一个中间程序,在客户端发送数据给端口前劫获这个数据,判断这个是不是HACKER发来的数据,如果是把它发给后门程序,如果不是则转发给端口程序,返回信息再发给客户端.所以中间程序即是一个服务端程序(监听连接)也是一个客户端程序(发送给端口程序).要复用端口,必须使中间程序的监听SOCKET用setsockopt()函数设置.
Socket中SO_REUSEADDR详解
Lce的专栏
09-04 1701
如果我们终止一个已经建立连接的服务器程序，并试图立即重新启动这个服务器程序，服务器程序将不能把它的这个周知端口赋值给它的端点，因为那个端口是处于 2MSL 连接的一部分。（1）如果服务器最后发送的ACK因为某种原因丢失了，那么客户一定会重新发送FIN，这样因为有TIME_WAIT的存在，服务器会重新发送ACK给客户，如果没有TIME_WAIT，那么无论客户有没有收到ACK，服务器都已经关掉连接了，此时客户重新发送FIN，服务器将不会发送ACK，而是RST，从而使客户端报错。所以，这样是安全的。
端口号 & 一个端口号是否可以被多个进程绑定？& 一个进程是否可以bind多个端口号？
dangzhangjing97的博客
07-08 1万+
1.端口号的作用 端口号可以用来标识同一个主机上通信的不同应用程序，端口号+IP地址就可以组成一个套接字，用来标识一个进程 2.端口号的应用场景 在TCP/IP协议中，用“源IP地址”，“目的IP地址”，“源端口号”，“目的端口号”,协议号（IP协议的协议号为4，TCP的协议号为6）这样的一个五元组来标识一个通信，通信的双方在发送消息时，消息的头部会带着这样的五元组 3.端...
socket 网络编程——端口复用技术（setsockopt（））（linux下多个进程监听同一个端口）
热门推荐
JMW1407的博客
07-14 2万+
端口复用技术端口复用1、背景2、定义3、setsockopt4、实验案例参考 端口复用 1、背景 操作系统如何区分一个socket的呢？ socket = 《A进程的IP地址：端口号，B进程的IP地址：端口号》 也就是说，只要五元素不完全一致，操作系统就能区分socket。 场景分析： 在A机上进行客户端网络编程，假如它所使用的本地端口号是1234，如果没有开启端口复用的话，它用本地端口1234去连接B机再用本地端口连接C机时就不可以，若开启端口复用的话在用本地端口1234访问B机的情况下还可以用本地端口
setsockopt函数
最新发布
weixin_47783699的博客
11-25 4569
初学者必学的四种设置setsockopt函数方式。第一种用于广播设置、第二种用于多播设置、第三种增加地址复用功能、第四种增加端口复用功能。
关于SO_REUSEADDR的使用说明
Beyond.cn
08-26 1003
参考WINDOWS   网络编程技术      1.   可以对一个端口进行多次绑定，一般这个是不支持使用的；      2.   对于监听套接字，比较特殊。如果你定义了SO_REUSEADDR，并且让两个套接字在同一个端口上进行接听，那么对于由谁来ACCEPT，就会出现歧义。如果你定义个SO_REUSEADDR，只定义一个套接字在一个端口上进行监听，如果服务器出现意外而导致没有将这个端口释放
SO_REUSEADDR 套接字选项应用实例
null
07-08 3183
网络上关于SO_REUSEADDR套接字选项用来解决地址重用问题的资料不少，但只停留在文字表达上，并没有实例，很容易误导初学者，并产生疑惑，此处不再赘述。下面通过一个简短的例子来展示如何在项目中合理的使用该选项，以及需要注意的问题。 关于TCP断开连接四次握手，如图所示 应用场景： 之前项目中遇到一个问题，聊天服务器的开启，关闭和重启，例如将服务器
socket服务器开发中的SO_REUSEADDR选项与让人心烦的TIME_WAIT
weixin_30938149的博客
04-21 197
本文有更新，请移步我的个人博客：https://blog.andyqiao.top/article/15/ 1 发现问题　　 　　我在开发一个socket服务器程序并反复调试的时候，发现了一个让人无比心烦的情况：每次kill掉该服务器进程并重新启动的时候，都会出现bind错误：error:98，Address already in use。然而再kill掉该进程，再次重新启动的时候，就bind...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值